数据压缩实验实验2—图像文件的读写和转换（bmp转yuv）

一、实验分析

BMP 文件的图像深度可选 lbit、4bit、8bit、16bit 及 24bit。BMP 文件存储数据时，图像的扫描方式是按从左到右、从下到上的顺序。典型的 BMP 图像文件由四部分组成：

1、位图头文件数据结构，它包含 BMP 图像文件的类型、显示内容等信息；
2、位图信息数据结构，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信息；
3、调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的 BMP）就不需要调色板；
4、位图数据，这部分的内容根据 BMP 位图使用的位数不同而不同，在 24 位图中直接使用 RGB，而其他的小于 24 位的使用调色板中颜色索引值。

相应的数据结构可表示如下:

1、位图文件头主要包括：
typedef struct tag BITMAPFILEHEADER {

WORD bf Type; /*  说明文件的类型*/
DWORD bf Size; /*  说明文件的大小，用字节为单位*/
WORD bf Reserved1; /*  保留，设置为 0 */
WORD bf Reserved2; /*  保留，设置为 0 */
DWORD bf Off Bits; /*  说明从 BITMAPFILEHEADER 结构开始到实际的图像数据之间的字节偏移量 */
} BITMAPFILEHEADER;
2、位图信息头主要包括：
typedef struct tag BITMAPINFOHEADER {
DWORD bi Size; /*  说明结构体所需字节数 */
LONG bi Width; /*  以像素为单位说明图像的宽度  */
LONG bi Height; /*  以像素为单位说明图像的高速 */
WORD bi Planes; /*  说明位面数，必须为 1 */
WORD bi Bit Count; /*  说明位数/像素，1、2、4、8、24 */
DWORD bi Compression; /*  说明图像是否压缩及压缩类型 BI_RGB，BI_RLE8，BI_RLE4，BI_BITFIELDS */
DWORD bi Size Image; /*  以字节为单位说明图像大小，必须是 4 的整数倍*/
LONG bi XPels Per Meter; /*目标设备的水平分辨率，像素/米*/
LONG bi YPels Per Meter; /*目标设备的垂直分辨率，像素/米  */
DWORD bi Clr Used; /*  说明图像实际用到的颜色数，如果为 0，则颜色数为 2 的 bi Bit Count次方 */
DWORD  bi Clr Important;  /*说明对图像显示有重要影响的颜色索引的数目，如果是 0，表示都重要。*/
} BITMAPINFOHEADER;
3、调色板实际上是一个数组，它所包含的元素与位图所具有的颜色数相同，决定于bi Clr Used 和 bi Bit Count 字段。数组中每个元素的类型是一个 RGBQUAD 结构。真彩色无调色板部分。
typedef struct tag RGBQUAD {
BYTE rgb Blue; /*指定蓝色分量*/
BYTE rgb Green; /*指定绿色分量*/
BYTE rgb Red; /*指定红色分量*/
BYTE rgb Reserved; /*保留，指定为 0*/
} RGBQUAD;
4、紧跟在调色板之后的是图像数据字节阵列。对于用到调色板的位图，图像数据就是该像素颜色在调色板中的索引值（逻辑色）。对于真彩色图，图像数据就是实际的 R、G、B值。图像的每一扫描行由表示图像像素的连续的字节组成，每一行的字节数取决于图像的颜色数目和用像素表示的图像宽度。规定每一扫描行的字节数必须是 4 的整倍数，也就是DWORD 对齐的。扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的像素，而最后一个字节表示位图右上角的像素。

不同的计算机系统采用不同的字节序存储数据，同样一个 4 字节的32位整数，在内存中存储的方式不同。字节序分为小尾字节序
(Little Endian)和大尾字节序(Big Endian)。Intel 处理器大多数使用小尾字节序，Motorola 处理器大多数使用大尾(Big Endian)字节序。小尾就是低位字节排放在内存的低端，高位字节排放在内存的高端，即所谓的“低位在前，高位在后”。大尾就是高位字节排放在内存的低端，低位字节排放在内存的高端，即所谓的“高位在前，低位在后”。

在编程前先用二进制打开方式观察 BMP 文件各个部分的数据存储格式。

BMP2YUV文件转换流程分析

1.程序初始化（打开两个文件、定义变量和缓冲区等）

2.读取BMP文件，抽取或生成RGB数据写入缓冲区

3.调用RGB2YUV的函数实现RGB到YUV数据的转换

4.写YUV文件

5.程序收尾工作（关闭文件，释放缓冲区）

其中重点在第2步，进一步分析有：

24bit时：实际就是RGB转YUV。

16bit时：

for(Loop = 0;Loop < height *width;Loop +=2)

{

       *rgbDataOut =(Data[Loop]&0x1F)<<3;//B:用00011111取出低字节的低5位，通过左移3位将其放到目标字节的高5位

       *(rgbDataOut + 1)= ((Data[Loop]&0xE0)>>2) +  ((Data[Loop+1]&0x03)<<6);//G:用11100000取出低字节的高3位，用00000011取出高字节的低两位，相加后，放到目标字节的高5位

       *(rgbDataOut + 2)= (Data[Loop+1]&0x7C)<<1;//R:01111100取出高字节的中间5位,放到目标字节的高5位，得到R

       rgbDataOut +=3;

}

1~8bit时：

intshiftCnt = 1;

while(mask)

{

unsignedchar index = mask == 0xFF ? Data[Loop] : ((Data[Loop] & mask)>>(8 -shiftCnt *info_h.biBitCount));

//通过判断mask与0xFF是否相等，确定index的值是 Data[Loop]还是 ((Data[Loop] & mask)>>(8 - shiftCnt *info_h.biBitCount))

*rgbDataOut =pRGB[index].rgbBlue;

*(rgbDataOut+1) =pRGB[index].rgbGreen;

*(rgbDataOut+2) =pRGB[index].rgbRed;

//查找调色板，将BGR的值存入rgbDataOut中

if(info_h.biBitCount ==8) mask = 0;//如果是8位的bmp，一次取完一个字节的颜色数据后直接跳出循环

else  mask >>=info_h.biBitCount;//否则：如果是4位的bmp，则1字节取2次数据；如果是2位的bmp，则1字节可以被取4次数据；

如果是1位的bmp，则1字节可以被取8次数据； 

rgbDataOut+=3;

shiftCnt ++;

}

二、程序实现

bmp2yuv.h

void ReadRGB(FILE * pFile,BITMAPFILEHEADER & file_h,BITMAPINFOHEADER & info_h,unsigned char * rgbDataOut);
void RGB2YUV(unsigned long w,unsigned long h,unsigned char * rgbData,unsigned char * y,unsigned char * u,unsigned char *v);
bool WriteYUV(unsigned char *Y,unsigned char *U,unsigned char *V,unsigned long size,FILE *outFile); //写YUV文件函数

#ifndef BMP2YUV_H_
#define BMP2YUV_H_
#endif

#ifndef stdlib_H_
#define stdlib_H_
#endif

main.c

#include <stdio.h>
#include <windows.h>
#include "bmp2yuv.h"
void main(int argc,char *argv[])
{
	
	FILE *bmpFile = NULL,*yuvFile = NULL;
	BITMAPFILEHEADER File_header;
	BITMAPINFOHEADER Info_header;

	char* bmpFileName = NULL;
	char* yuvFileName = NULL;
	unsigned char * rgbData = NULL;
	unsigned char * yBuff = NULL;
	unsigned char * uBuff = NULL;
	unsigned char * vBuff = NULL;
        int videoFramesWritten = 0;
	unsigned int time;
	unsigned long width,height;

        yuvFileName = argv[6];
	time=atoi(argv[7]);	
        //open yuv file
	yuvFile = fopen(yuvFileName, "wb");
	if (yuvFile == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The output yuv file is %s\n", yuvFileName);
	}
	//end open yuv file
	for(int j=0;j<5;j++)//循环5次，打开5个bmp文件
	{
	bmpFileName=argv[1+j];
	 //open bmp file
	bmpFile = fopen(bmpFileName, "rb");
	if (bmpFile == NULL)
	{
		printf("cannot find bmp file\n");
		exit(1);
	}
	else
	{
		printf("The input bmp file is %s\n", bmpFileName);
	}	
       //end open bmp file
 	
       //read file & info header
	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);
	}
	if(fread(&Info_header,sizeof(BITMAPINFOHEADER),1,bmpFile) != 1)
	{
		printf("read info header error!");
		exit(0);
	}
        //end read header

	if ((Info_header.biWidth%4) == 0)
		width = Info_header.biWidth;
	else
		width = (Info_header.biWidth*Info_header.biBitCount+31)/32*4;
	/*由于规定每一扫描行的字节数必须是 4 的整倍数，所以为了保证这一点，
	就要求每一行的每一行的总位数（Info_header.biWidth*Info_header.biBitCount)是32位的整数倍
	加上最大的余数31后，除以32取整，再乘以4（32/8)，得到的就一定是4字节的整数倍
	即：width = (Info_header.biWidth*Info_header.biBitCount + 31) / 32 * (32 / 8);*/
	if ((Info_header.biHeight%2) == 0)
		height = Info_header.biHeight;
	else
		height = Info_header.biHeight + 1;//保证height是偶数

	//allocate buffer for YUV and RGBData	
	rgbData = (unsigned char *)malloc(height*width*3);
	memset(rgbData,0,height*width*3);
	yBuff = (unsigned char * )malloc(height*width);
	uBuff = (unsigned char * )malloc((height*width)/4);
	vBuff = (unsigned char * )malloc((height*width)/4);
	//end allocate

	printf("This is a %d bits image!\n",Info_header.biBitCount);
	printf("\nbmp size: \t%d X %d\n",Info_header.biWidth,Info_header.biHeight);

	ReadRGB(bmpFile,File_header,Info_header,rgbData);//将bmp文件转成rgb文件

	RGB2YUV(width,height,rgbData,yBuff,uBuff,vBuff);//将rgb文件转成yuv文件

	for( ;videoFramesWritten<time;videoFramesWritten++)//写YUV文件，并写time次
		{
		fwrite(yBuff, 1, height*width, yuvFile);
		fwrite(uBuff, 1, (height*width) / 4, yuvFile);
		fwrite(vBuff, 1, (height*width) / 4, yuvFile);
		}
	videoFramesWritten=0;
	//clean up
	free(rgbData);
	free(yBuff);
	free(uBuff);
	free(vBuff);
	fclose(bmpFile);
	}
	fclose(yuvFile);
}

bmp2yuv.cc

#include <stdio.h>
#include <windows.h>
#include <math.h>
bool MakePalette(FILE * pFile,BITMAPFILEHEADER &file_h,BITMAPINFOHEADER & info_h,RGBQUAD *pRGB_out);//定义调色板函数

void ReadRGB(FILE * pFile,BITMAPFILEHEADER & file_h,BITMAPINFOHEADER & info_h,unsigned char * rgbDataOut)
{
	unsigned long Loop,iLoop,jLoop,width,height,w,h;
	unsigned char mask,*Index_Data,* Data;

	if ((info_h.biWidth%4) == 0)
		w = info_h.biWidth;
	else
		w = (info_h.biWidth*info_h.biBitCount+31)/32*4;
	if ((info_h.biHeight%2) == 0)
		h = info_h.biHeight;
	else
		h = info_h.biHeight + 1;

	width = w/8*info_h.biBitCount;//用字节数表示width
	height = h;

	Index_Data = (unsigned char *)malloc(height*width);//用来存放BMP文件的原始倒序数据
	Data = (unsigned char *)malloc(height*width);//用来存放将BMP文件处理后的正序数据

	fseek(pFile,file_h.bfOffBits,0);//跳过bmp文件的文件头和信息头
	if(fread(Index_Data,height*width,1,pFile) != 1)//读取bmp文件
	{
		printf("read file error!");
		exit(0);
	}

	for ( iLoop = 0;iLoop < height;iLoop ++)//将bmp文件原始的倒序数据转成正序数据
		for (jLoop = 0;jLoop < width;jLoop++)
		{
			Data[iLoop*width+jLoop] = Index_Data[(height-iLoop-1)*width+jLoop];
		}

	if(info_h.biBitCount == 24)//判断是否是24位bmp
	{
		memcpy(rgbDataOut,Data,height*width);//bmp的正序数据不做处理，直接存在rgbDataOut中
		free(Index_Data);
		free(Data);
		return;
	}

	RGBQUAD *pRGB = (RGBQUAD *)malloc(sizeof(RGBQUAD)*(unsigned long long)pow((float)2,info_h.biBitCount));
	/*一个单元代表一种颜色,调色板实际上是一个数组，它所包含的元素与位图所具有的颜色数相同，决定于biClrUsed和biBitCount字段。
	数组中每个元素的类型是一个RGBQUAD结构。真彩色无调色板部分。*/
	if(!MakePalette(pFile,file_h,info_h,pRGB))//判断是否存在调色板
		printf("No palette!");

	if(info_h.biBitCount == 16)//判断是否是16位bmp
	{
		for (Loop = 0;Loop < height * width;Loop +=2)
		{
	   *rgbDataOut = (Data[Loop]&0x1F)<<3;
       *(rgbDataOut + 1) = ((Data[Loop]&0xE0)>>2) +((Data[Loop+1]&0x03)<<6);
       *(rgbDataOut + 2) = (Data[Loop+1]&0x7C)<<1;
       rgbDataOut +=3;
		}
	
		}

	for (Loop=0;Loop<height*width;Loop++)//判断是否是1~8位bmp
	{
		//根据位深设置mask
		switch(info_h.biBitCount)
		{
		case 1:
			mask = 0x80;
			break;
		case 2:
			mask = 0xC0;
			break;
		case 4:
			mask = 0xF0;
			break;
		case 8:
			mask = 0xFF;
		}

		int shiftCnt = 1;

		while (mask)
		{
			unsigned char index = mask == 0xFF ? Data[Loop] : ((Data[Loop] & mask)>>(8 - shiftCnt * info_h.biBitCount));
			
			* rgbDataOut = pRGB[index].rgbBlue;
			* (rgbDataOut+1) = pRGB[index].rgbGreen;
			* (rgbDataOut+2) = pRGB[index].rgbRed;

			if(info_h.biBitCount == 8)
				mask = 0;
			else
				mask >>= info_h.biBitCount;
			rgbDataOut+=3;
			shiftCnt ++;
			if (Loop == width*height - 1)
			{
				rgbDataOut = rgbDataOut + 3 - width*height*3;
				break;
			}
		}
	}
	free(Index_Data);
	free(Data);
	free(pRGB);

}

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);
		//把调色数据放到pRGB_out中，完成make palette工作
		return true;
	}
	else
		return false;
}

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

void initLookupTable();
void RGB2YUV(unsigned long w,unsigned long h,unsigned char * rgbData,unsigned char * y,unsigned char * u,unsigned char *v)
{
	initLookupTable();//初始化查找表
	unsigned char *ytemp = NULL;
	unsigned char *utemp = NULL;
	unsigned char *vtemp = NULL;
	utemp = (unsigned char *)malloc(w*h);
	vtemp = (unsigned char *)malloc(w*h);
	
	unsigned long i,nr,ng,nb,nSize;
	//对每个像素进行 rgb -> yuv的转换
	for (i=0,nSize=0;nSize<w*h*3;nSize+=3)
	{
		nb = rgbData[nSize];
		ng = rgbData[nSize+1];
		nr = rgbData[nSize+2];
		y[i] = (unsigned char)(RGBYUV02990[nr]+RGBYUV05870[ng]+RGBYUV01140[nb]);
		utemp[i] = (unsigned char)(-RGBYUV01684[nr]-RGBYUV03316[ng]+nb/2+128);
		vtemp[i] = (unsigned char)(nr/2-RGBYUV04187[ng]-RGBYUV00813[nb]+128);
		i++;
	}
	//对u信号及v信号进行采样
	int k = 0;
	for (i=0;i<h;i+=2)
		for(unsigned long j=0;j<w;j+=2)
		{
			u[k]=(utemp[i*w+j]+utemp[(i+1)*w+j]+utemp[i*w+j+1]+utemp[(i+1)*w+j+1])/4;
			v[k]=(vtemp[i*w+j]+vtemp[(i+1)*w+j]+vtemp[i*w+j+1]+vtemp[(i+1)*w+j+1])/4;
			k++;
		}
	//对y、u、v 信号进行限电平处理
	for (i=0;i<w*h;i++)
	{
		if(y[i]<16)
			y[i] = 16;
		if(y[i]>235)
			y[i] = 235;
	}
	for(i=0;i<h*w/4;i++)
	{
		if(u[i]<16)
			u[i] = 16;
		if(v[i]<16)
			v[i] = 16;
		if(u[i]>240)
			u[i] = 240;
		if(v[i]>240)
			v[i] = 240;
	}
	free(utemp);
	free(vtemp);
}

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

bool WriteYUV(unsigned char *Y,unsigned char *U,unsigned char *V,unsigned long size,FILE *outFile)//写YUV文件
{
	if(fwrite(Y,1,size,outFile) != size)
		return false;
	if (fwrite(U,1,size/4,outFile) != size/4)
		return false;
	if(fwrite(V,1,size/4,outFile) != size/4)
		return false;
	return true;
}

三、实验结果

设置命令行参数

bmp图片（分别为1、4、8、16、24位）

根据老师要求，最后形成的YUV文件应至少包含200帧，于是本人将以上图片每张写了40帧。

（由于无法上传YUV文件，则截取关键帧的图来表明。）

       

        

          

           

         
四、实验总结

1、理解BMP文件的各个组成部分以及清楚各个数据结构是关键。

2、理清BMP2YUV文件转换流程分析，总体来说主要是BMP转RGB，RGB转YUV两个过程。

3、不同深度的BMP转RGB时的方式不同，需要理解老师给出的代码。（如果是自己写的话，就要狗带了）

五、出现的问题

本人用300x300像素的文件做实验的时候出现的YUV文件一直是混乱的，经过多次尝试，选择宽度为8的整数倍的图片即可出现正常结果。具体原因，本人还不明白。初出茅庐，还请各位大神多加指教！