数据压缩 实验二 图像文件的读写和转换

实验原理

1．BMP文件的组成结构
BMP（全称 Bitmap）是 Windows 操作系统中的标准图像文件格式，可以分成两类：设备
相关位图（DDB）和设备无关位图（DIB），使用非常广。它采用位映射存储格式，除了图像
深度可选以外，在绝大多数应用中不采用其他任何压缩，因此，BMP 文件所占用的空间很大。
BMP 文件的图像深度可选 lbit、4bit、8bit、16bit 及 24bit。BMP 文件存储数据时，图像的扫
描方式是按从左到右、从下到上的顺序。由于 BMP 文件格式是 Windows 环境中交换与图有
关的数据的一种标准，因此在 Windows 环境中运行的图形图像软件都支持 BMP 图像格式。
典型的 BMP 图像文件由四部分组成：
（1）位图头文件数据结构，它包含 BMP 图像文件的类型、显示内容等信息；
（2）位图信息数据结构，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信
息；
（3）调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的 BMP）就不需要调色板；
（4）位图数据，这部分的内容根据 BMP 位图使用的位数不同而不同，在 24 位图中直接使用 RGB，而其他的小于 24 位的使用调色板中颜色索引值。
相应的数据结构可表示如下:
位图文件头主要包括：

typedef struct tagBITMAPFILEHEADER { 
 2
WORD bfType; /* 说明文件的类型 */ 
DWORD bfSize; /* 说明文件的大小，用字节为单位 */ 
WORD bfReserved1; /* 保留，设置为 0 */ 
WORD bfReserved2; /* 保留，设置为 0 */ 
DWORD bfOffBits; /* 说明从 BITMAPFILEHEADER 结构开始到实际的图像数 据之间的字节偏移量 */ 
} BITMAPFILEHEADER; 

(2) 位图信息头主要包括：

typedef struct tagBITMAPINFOHEADER { 
DWORD biSize; /* 说明结构体所需字节数 */ 
LONG biWidth; /* 以像素为单位说明图像的宽度 */ 
LONG biHeight; /* 以像素为单位说明图像的高速 */ 
WORD biPlanes; /* 说明位面数，必须为 1 */ 
WORD biBitCount; /* 说明位数/像素，1、2、4、8、24 */ 
DWORD biCompression; /* 说明图像是否压缩及压缩类型 BI_RGB，BI_RLE8，BI_RLE4， BI_BITFIELDS */ 
DWORD biSizeImage; /* 以字节为单位说明图像大小，必须是 4 的整数倍*/ 
LONG biXPelsPerMeter; /*目标设备的水平分辨率，像素/米 */ LONG biYPelsPerMeter; /*目标设备的垂直分辨率，像素/米 */ DWORD biClrUsed; /* 说明图像实际用到的颜色数，如果为 0，则颜色数为 2 的 biBitCount 次方 */ 
DWORD biClrImportant; /*说明对图像显示有重要影响的颜色索引的数目，如果是 0，表 示都重要。*/ 
} BITMAPINFOHEADER; 

(3) 调色板实际上是一个数组，它所包含的元素与位图所具有的颜色数相同，决定于biClrUsed 和 biBitCount 字段。数组中每个元素的类型是一个 RGBQUAD 结构。真彩色无调色板部分。

typedef struct tagRGBQUAD { 
BYTE rgbBlue; /*指定蓝色分量*/ 
BYTE rgbGreen; /*指定绿色分量*/ 
BYTE rgbRed; /*指定红色分量*/ 
BYTE rgbReserved; /*保留，指定为 0*/ 
} RGBQUAD; 

(4) 紧跟在调色板之后的是图像数据字节阵列。对于用到调色板的位图，图像数据就是该像素颜色在调色板中的索引值（逻辑色）。对于真彩色图，图像数据就是实际的 R、G、B值。图像的每一扫描行由表示图像像素的连续的字节组成，每一行的字节数取决于图像的颜色数目和用像素表示的图像宽度。规定每一扫描行的字节数必须是 4 的整倍数，也就是DWORD 对齐的。扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的像素，而最后一个字节表示位图右上角的像素。
2．字节序
不同的计算机系统采用不同的字节序存储数据，同样一个 4 字节的 32 位整数，在内存中存储的方式不同。字节序分为小尾字节序(Little Endian)和大尾字节序(Big Endian)。Intel 处理
器大多数使用小尾字节序，Motorola 处理器大多数使用大尾(Big Endian)字节序。
小尾就是低位字节排放在内存的低端，高位字节排放在内存的高端，即所谓的“低位在前，高位在后”。大尾就是高位字节排放在内存的低端，低位字节排放在内存的高端，即所谓的“高位在前，低位在后”。 TCP/IP 各层协议将字节序定义为大尾，因此 TCP/IP 协议中使用的字节序通常称之为网络字节序。
在实现 BMP 文件头信息的写入时，需要注意整数保存时的字节序。例如：文件大小是以Intel 序保存的。在编程前先用二进制打开方式观察 BMP 文件各个部分的数据存储格式。

实验流程

读取BMP文件信息，获得R、G、B值，将R、G、B值顺序调整，转换为Y、U、V值，将Y、U、V值写入新文件。

代码分析

参数：pic1.bmp 80 pic2.bmp 70 pic3.bmp 60 out.yuv
main.cpp代码

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <Windows.h>
#include <math.h>
#include "bmp2yuv.h"
#define u_int8_t    unsigned __int8
#define u_int       unsigned __int32
#define u_int32_t   unsigned __int32

BITMAPFILEHEADER File_header;
BITMAPINFOHEADER Info_header;

int main(int argc, char** argv)
{   
    bool flip = FALSE;                                      //BMP文件倒序存的所以要做倒序
    char* bmpFileName = NULL;                               //文件名
    char* yuvFileName = NULL;
    FILE* bmpFile = NULL;                                   //文件指针
    FILE* yuvFile = NULL;
    u_int8_t* rgbBuf = NULL;                                //buffer
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int32_t videoFramesWritten = 0;
    u_int frameWidth, frameHeight;                          //图像宽高
    int i=0,j=0;

   /***********打开YUV文件***********/
    yuvFileName = argv[argc-1];                             //取YUV文件名
    yuvFile = fopen(yuvFileName, "ab");                     //打开已有或新建YUV文件
    if (yuvFile == NULL)
    {
        printf("cannot find yuv file\n");
        exit(1);
    }
    else
    {
        printf("The output yuv file is %s\n", yuvFileName);
    }
    /***********循环读BMP文件并写入YUV文件***********/
    for (i = 0; i < argc/2-1; i++)                          //循环(argc/2-1)次
    {
        videoFramesWritten = 0;
        /***********打开BMP文件***********/
        bmpFileName = argv[2*i+1];                          //取BMP文件名
        bmpFile = fopen(bmpFileName, "rb");                 //读取BMP文件
        if (bmpFile == NULL)
        {
            printf("cannot find bmp file\n");
            exit(1);
        }
        else
        {
            printf("The input bmp file is %s\n", bmpFileName);
        }

        /***********read BMP fileheader & infoheader***********/
        if (fread(&File_header, sizeof(BITMAPFILEHEADER), 1, bmpFile) != 1)
        {
            printf("read file header error!");
            exit(0);
        }
        if (File_header.bfType != 0x4D42)
        {
            printf("Not bmp file!");
            exit(0);
        }
        else
        {
            printf("this is a bmp file.\n", File_header.bfType);
        }
        if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpFile) != 1)
        {
            printf("read info header error!");
            exit(0);
        }
        /***********end read header***********/

        frameWidth = Info_header.biWidth;               //宽
        frameHeight = Info_header.biHeight;             //高
        printf("width=%d  height=%d\n", frameWidth, frameHeight);

        /***********开BUFFER***********/
        rgbBuf = (unsigned char *)malloc(sizeof(unsigned char)*frameHeight*frameWidth * 3);
        yBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth);
        uBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth/4);
        vBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth/4);
        if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)     //判断buffer是否建好
        {
            printf("no enought memory\n");
            exit(1);
        }

        ReadRGB(rgbBuf, bmpFile, File_header,Info_header);

        if (RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
        {
            printf("error");
            return 0;
        }

        /**********带上这一段有bug*********
        for (i = 0; i < frameWidth*frameHeight; i++)
        {
            if (yBuf[i] < 16) yBuf[i] = 16;
            if (yBuf[i] > 235) yBuf[i] = 235;
        }

        for (i = 0; i < frameWidth*frameHeight/4; i++)
        {
            if (uBuf[i] < 16) uBuf[i] = 16;
            if (uBuf[i] > 240) uBuf[i] = 240;

            if (vBuf[i] < 16) vBuf[i] = 16;
            if (vBuf[i] > 240) vBuf[i] = 240;
        }
        ***********************************/

        /**********按参数写YUV文件**********/
        for (j = 0; j <atoi(argv[2*i+2]);j++)
        {
            fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);
            fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
            fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
            printf("\r...%d", ++videoFramesWritten);
        }
        printf("\n%ux%u video frames written\n", frameWidth, frameHeight);

        printf("\n\n");
        if (rgbBuf != NULL) 
            free(rgbBuf);
        if (yBuf != NULL) 
            free(yBuf);
        if (uBuf != NULL) 
            free(uBuf);
        if (vBuf != NULL) 
            free(vBuf);
        if (bmpFile != NULL) 
            fclose(bmpFile);
    }
    if (yuvFile != NULL) 
        fclose(yuvFile);

    system("pause");
    return 0;
}

bmp2yuv.cpp代码

#include<Windows.h>
#include<stdio.h>
#include<math.h>
#include"bmp2yuv.h"

static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static float RGBYUV01684[256], RGBYUV03316[256];
static float RGBYUV04187[256], RGBYUV00813[256];

/***********调色板***********/
bool MakePalette(FILE * pFile, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h, RGBQUAD *pRGB_out)
{
    if ((file_h.bfOffBits - sizeof(BITMAPFILEHEADER) - info_h.biSize) == sizeof(RGBQUAD)*pow((float)2, info_h.biBitCount))
    {
        fseek(pFile, sizeof(BITMAPFILEHEADER) + info_h.biSize, 0);
        fread(pRGB_out, sizeof(RGBQUAD), (unsigned int)pow((float)2, info_h.biBitCount), pFile);
        return true;
    }
    else
        return false;
}

/***********读取BMP图像数据***********/
void ReadRGB(unsigned char * rgbbuf, FILE *bmpfile, BITMAPFILEHEADER &file_h ,BITMAPINFOHEADER & info_h )
{
    u_int Width=0, Height=0;
    int k=0;
    unsigned char *bmpBuf=NULL;
    unsigned char *rgb=NULL;
    unsigned char mask=0;
    int difference = 0;
    rgb = rgbbuf;

/*每一扫描行的字节数必须是4的整数倍，与DWORD对齐
  若扫描行字节数不为4的整数倍，要补零为4的整数倍
  difference用来计算实际字节数和用于图像信息存储的字节数之差*/

    if (((info_h.biWidth*info_h.biBitCount/8)%4) == 0)
        Width = info_h.biWidth*info_h.biBitCount/8;
    else
        Width = (info_h.biWidth*info_h.biBitCount+31)/32*4;

    if ((info_h.biHeight % 2) == 0)
        Height= info_h.biHeight;
    else
        Height = info_h.biHeight + 1;

    difference = Width-info_h.biWidth*info_h.biBitCount/8 ;

    bmpBuf = (unsigned char *)malloc(sizeof(unsigned char)*Height*Width);

    RGBQUAD *pRGB = (RGBQUAD *)malloc(sizeof(RGBQUAD)*(unsigned int)pow((float)2, info_h.biBitCount));

    if (!MakePalette(bmpfile, file_h, info_h, pRGB))
    {
        printf("No palette!\n");                    //没有调色板
    }

    fread(bmpBuf, 1, Height*Width, bmpfile);

    if (info_h.biBitCount == 24)
    {
        for (k=0; k<Height*Width; k++)
        {
        /***********补零***********/
            if (difference != 0)
            {
                if (difference == 1)
                {
                    if ((k+1)%Width == 0)
                        continue;
                }
                else if (difference == 2)
                {
                    if ((k+1)%Width == 0 || (k+2)%Width == 0)
                        continue;
                }
                else
                {
                    if ((k+1)%Width == 0 || (k+2)%Width == 0 || (k+3)%Width == 0)
                        continue;
                }
            }
            *rgb = *(bmpBuf+k);
            rgb++;
        }
    }
    if(pRGB!=NULL) 
        free(pRGB);
    if(bmpBuf != NULL)
        free(bmpBuf);
}

/***********把所读取的BMP数据的RGB信息转换为YUV数据***********/
int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip)
{
    static int init_done = 0;

    long i, j, size;
    unsigned char *r, *g, *b;                               //建rgb指针
    unsigned char *y, *u, *v;                               //建yuv指针
    unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;
    unsigned char *y_buffer, *u_buffer, *v_buffer;
    unsigned char *sub_u_buf, *sub_v_buf;

    if (init_done == 0)
    {
        InitLookupTable();
        init_done = 1;
    }

    // check to see if x_dim and y_dim are divisible by 2
    if ((x_dim % 2) || (y_dim % 2)) return 1;               //检查图像宽高是否是偶数
    size = x_dim * y_dim;                                   //尺寸=宽×高

    y_buffer  = (unsigned char *)y_out;
    sub_u_buf = (unsigned char *)u_out;
    sub_v_buf = (unsigned char *)v_out;
    u_buffer  = (unsigned char *)malloc(x_dim * y_dim);
    v_buffer  = (unsigned char *)malloc(x_dim * y_dim);

    if (!(u_buffer && v_buffer))
    {
        if (u_buffer) free(u_buffer);
        if (v_buffer) free(v_buffer);
        return 2;
    }

    b = (unsigned char *)bmp;
    y = y_buffer;
    u = u_buffer;
    v = v_buffer;

    if (!flip)                                              //倒序
    {
        for (j = 0; j < y_dim; j ++)
        {
            y = y_buffer + (y_dim - j - 1) * x_dim;
            u = u_buffer + (y_dim - j - 1) * x_dim;
            v = v_buffer + (y_dim - j - 1) * x_dim;
            for (i = 0; i < x_dim; i ++) {
                g = b + 1;
                r = b + 2;
                *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
                *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
                *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
                b += 3;
                y ++;
                u ++;
                v ++;
            }
        }
    }
    else                                                    //正序
    {                                   
        for (i = 0; i < size; i++)
        {
            g = b + 1;
            r = b + 2;
            *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
            *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
            *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
            b += 3;
            y ++;
            u ++;
            v ++;
        }
    }

    for (j = 0; j < y_dim/2; j ++)
    {
        psu = sub_u_buf + j * x_dim / 2;
        pu1 = u_buffer + 2 * j * x_dim;
        pu2 = u_buffer + (2 * j + 1) * x_dim;

        psv = sub_v_buf + j * x_dim / 2;
        pv1 = v_buffer + 2 * j * x_dim;
        pv2 = v_buffer + (2 * j + 1) * x_dim;

        for (i = 0; i < x_dim/2; i ++)
        {
            *psu = (*pu1 + *(pu1+1) + *pu2 + *(pu2+1)) / 4;
            *psv = (*pv1 + *(pv1+1) + *pv2 + *(pv2+1)) / 4;
            psu ++;
            psv ++;
            pu1 += 2;
            pu2 += 2;
            pv1 += 2;
            pv2 += 2;
        }
    }

    free(u_buffer);
    free(v_buffer);

    return 0;
}

void InitLookupTable()                  //提前计算所有可能的值
{
    int i;

    for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
    for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
    for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
    for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
    for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
    for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
    for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
}

bmp2yuv.h代码

#ifndef BMP2YUV_H_
#define BMP2YUV_H_

void ReadRGB(unsigned char * rgbbuf, FILE *bmpfile, BITMAPFILEHEADER &file_h ,BITMAPINFOHEADER & info_h );

int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip);

void InitLookupTable();

#endif

实验结果与总结

运行结果如图：

bitCount	BMP	YUV
24bit
8bit
4bit
1bit

实验总结

本次实验中应重点掌握的是文件格式的概念、字节序、缓冲区分配、结构体操作、倒序读写文件、函数定义等操作。