c语言实现BMP序列转YUV文件

一、实验目的

1．理解图像文件的基本组成。
2．掌握结构体作为复杂数据对象的用法。进一步熟悉由问题到程序的解决方案，并掌握
编程细节：如内存分配、倒序读写、字节序、文件读写过程等。

二、主要设备

安装 Visual Studio 软件的个人计算机

三、实验内容

1、BMP 文件的组成结构

典型的 BMP 图像文件由四部分组成：
（1）位图头文件数据结构，它包含 BMP 图像文件的类型、显示内容等信息；
（2）位图信息数据结构，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信
息；
（3）调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24
位的 BMP）就不需要调色板；
（4）位图数据，这部分的内容根据 BMP 位图使用的位数不同而不同，在 24 位图中直接
使用 RGB，而其他的小于 24 位的使用调色板中颜色索引值。
位图文件头主要包括：
typedef struct tagBITMAPFILEHEADER {
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 文件各个部分的数据存储格式。

四、实验步骤

1、实验素材

5个不同的场景画面的BMP文件，含有班级、学号后四位和本人姓名（缩写或昵称均可）的logo。

2、实验思路

（1）编写将第一步所生成的多个BMP文件转化为YUV文件，要求可在命令行中设置每个画面出现的帧数。最后形成的YUV文件应至少包含200帧。重点掌握函数定义、缓冲区分配、倒序读写、结构体的操作。
（2）对整个程序进行调试，并将生成的YUV文件用播放软件观看，验证是否正确。

五、c语言实现

1、rgb2yuv.h

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

void InitLookupTable();

2、main.cpp

#include <stdio.h>
#include <stdlib.h>
#include "rgb2yuv.h" 
#include <Windows.h>
void ReadRGB(FILE *pbmp, unsigned char *rgbbuf, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h);
#define u_int8_t	unsigned __int8
#define u_int		unsigned __int32
#define u_int32_t	unsigned __int32
int main(int argc, char** argv)
{
	u_int frameWidth;				/* --width=<uint> */
	u_int frameHeight;
	bool flip = FALSE;				/* --flip */
	unsigned int i;					/* internal variables */
	char* bmpFileName[5];
	char* yuvFileName = NULL;
	FILE* bmpFile =NULL;
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;
	bmpFileName[0] = argv[1];
    bmpFileName[1] = argv[2];
    bmpFileName[2] = argv[3];
    bmpFileName[3] = argv[4];
    bmpFileName[4] = argv[5];
    yuvFileName = argv[6];
    
	/* open the RAW 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);
	}
	
	/* open the BMP file */
	for (int m = 0; m < 5; m++)
	{
		bmpFile = fopen(bmpFileName[m], "rb");
		if (bmpFile == NULL)
		{
			printf("cannot find bmp file\n");
			exit(1);
		}
		else
		{
			printf("The input bmp file is %s\n", bmpFileName[m]);
		}
		BITMAPINFOHEADER info_header;
		BITMAPFILEHEADER file_header;

		//	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

		if (info_header.biWidth*info_header.biBitCount % 32 == 0)
		{
			frameWidth = info_header.biWidth;
		}
		else
		{
			frameWidth = (info_header.biWidth*info_header.biBitCount +31) / 32 * (32 / info_header.biBitCount);
		}
		//规定每一扫描行的字节数必须是 4 的整倍数（32位的整数倍），也就是DWORD 对齐的
		//一行总的数据量（按位来说），是宽度*位深
		//（x/32）得整数，再加上32就是比x大的最近的32的倍数，除以8就是像素的字节数

		if (info_header.biHeight % 2 == 0)
		{
			frameHeight = info_header.biHeight;
		}
		else
		{
			frameHeight = info_header.biHeight + 1;
		}
		/* get an input buffer for a frame */
		rgbBuf = (u_int8_t*)malloc(frameWidth*frameHeight*3);
		/* get the output buffers for a frame */
		yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
		uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
		vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
		if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
		{
			printf("no enought memory\n");
			exit(1);
		}
			ReadRGB(bmpFile,rgbBuf,file_header,info_header);
			if (RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
			{
				printf("error");
				return 0;
			}
			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;
			}
			for (i = 0; i < 40; i++)
			{
				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%u %ux%u video frames written\n",
		videoFramesWritten, frameWidth, frameHeight);
	/* cleanup */
	fclose(bmpFile);
	fclose(yuvFile);
	free(rgbBuf);
	free(yBuf);
	free(uBuf);
	free(vBuf);
	getchar();
	return(0);
}

3、read.cpp

#include "stdlib.h"
#include "rgb2yuv.h"
#include <stdio.h>
#include <malloc.h>
#include <math.h>
#include <windows.h>

//判断是否有调色板
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(2.0, info_h.biBitCount))
	{
		fseek(pFile, sizeof(BITMAPFILEHEADER) + info_h.biSize, 0);
		fread(pRGB_out, sizeof(RGBQUAD), (unsigned int)pow(2.0, info_h.biBitCount), pFile);
		return true;
	}
	else
		return false;
}

//读取RGB文件
void ReadRGB(FILE *pbmp, unsigned char *rgbbuf, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h)
{
	unsigned long h, w, pix_h, pix_w;
	if (info_h.biWidth *info_h.biBitCount% 32 == 0)
	{
		pix_w = info_h.biWidth;
	}
	else
	{
		pix_w = (info_h.biWidth*info_h.biBitCount+31 ) / 32 * (32 / info_h.biBitCount);
	}
	//规定每一扫描行的字节数必须是 4 的整倍数（32位的整数倍），也就是DWORD 对齐的
	//一行总的数据量（按位来说），是宽度*位深
	//（x/32）得整数，再加上32就是比x大的最近的32的倍数，除以8就是像素的字节数

	if (info_h.biHeight % 2 == 0)
	{
		pix_h = info_h.biHeight;
	}
	else
	{
		pix_h = info_h.biHeight + 1;
	}
	//宽（按字节）必须是4的的整数倍，高（按字节）必须是2的整数倍
	//24位.宽*高*3,16位.宽*高*2，8位.宽*高，4位.宽*高/2，2位.宽*高/4，1位.宽*高/8
	//要保证一行四字节扫描，所以宽为4字节的整数倍
	//要保证1位的时候数据为字节的整数倍
	w = pix_w * info_h.biBitCount/8;
	h = pix_h;//为了方便定义的宽高
	unsigned char *data,*be_data;
	//be_data = (unsigned char*)malloc(h*w);//buffer大小应该与bmp中有效数据大小相同
	data=(unsigned char*)malloc(w*h);//开辟一个缓冲区，把bmp的图像数据存在缓冲区里面
	fseek(pbmp,file_h.bfOffBits,0);//指针指向图像的数据处
	fread(data,w*h,1,pbmp);//把图像数据存在缓冲区里面
	RGBQUAD *pRGB = (RGBQUAD *)malloc(sizeof(RGBQUAD)*(unsigned int)pow(2.0, info_h.biBitCount));

	if (info_h.biBitCount == 24)
	{
		//24位的话就把数据copy到rgbbuf里面
		memcpy(rgbbuf, data, w*h);
	}
	else if (info_h.biBitCount == 16)
	{
           if (file_h.bfOffBits == 70)
		{
			for (unsigned long Loop = 0; Loop < h * w; Loop += 2)
			{
				*rgbbuf = (data[Loop] & 0x1F) << 3;
				//B：用0001 1111取出低字节的右五位，再放到目标字节的高5位（通过右移3位），得到五位的B 
				*(rgbbuf + 1) = ((data[Loop] & 0xE0) >> 3) + ((data[Loop + 1] & 0x07) << 5);
				// G：11100000取出低字节的左三位，00000011取出高字节的右三位，合并后，放到再放到目标字节的高5位，得到6位的G
				*(rgbbuf + 2) = (data[Loop + 1] & 0xF8);
				///R：1111 1000取出高字节的中间五位，再放到目标字节的高5位，得到5位的R  
				rgbbuf += 3;
			}
		}
		else
		{
			for (unsigned long Loop = 0; Loop < h * w; Loop += 2)
			{
				*rgbbuf = (data[Loop] & 0x1F) << 3;
				*(rgbbuf + 1) = ((data[Loop] & 0xE0) >> 2) + ((data[Loop + 1] & 0x03) << 6);
				*(rgbbuf + 2) = (data[Loop + 1] & 0x7C) << 1;
				rgbbuf += 3;
			}
		}
	}
	//判断若为其他位深数，要通过调色板来解决

	else
	{
		if (!MakePalette(pbmp, file_h, info_h, pRGB))
			printf("Nopalette!");
		unsigned char mask = 0;
		for (unsigned long Loop = 0; Loop < w*h; Loop++)
		{
			switch (info_h.biBitCount)
			{
			case 1: mask = 0x80; break;
			case 2: mask = 0xC0; break;
			case 4: mask = 0xF0; break;
			case 8: mask = 0xFF; break;
			default:printf("biBitCount error!"); break;
			}
			int shiftCnt = 1;
			while (mask)//一个字节里面的解析
			{
				unsigned char index = mask == 0xFF ? data[Loop] : ((data[Loop] & mask) >> (8 - shiftCnt * info_h.biBitCount));
				*rgbbuf = pRGB[index].rgbBlue;
				*(rgbbuf + 1) = pRGB[index].rgbGreen;
				*(rgbbuf + 2) = pRGB[index].rgbRed;
				
				if (info_h.biBitCount == 8)	mask = 0;
				else 	mask >>= info_h.biBitCount;
				rgbbuf += 3;
				shiftCnt++;
			}
		}
	}

	if (data)
		free(data);
	if (pRGB)
		free(pRGB);
}

4、rgb2yuv.cpp

#include "stdlib.h"
#include "rgb2yuv.h"

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



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;
	unsigned char *y, *u, *v;
	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;

	// allocate memory
	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(size * sizeof(unsigned char));
	v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
	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;

	// convert RGB to YUV
	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 ++;
		}
	}

	// subsample UV
	for (j = 0; j < y_dim/2; j ++)
	{
		psu = sub_u_buf + j * x_dim / 2;
		psv = sub_v_buf + j * x_dim / 2;
		pu1 = u_buffer + 2 * j * x_dim;
		pu2 = u_buffer + (2 * j + 1) * x_dim;
		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;
}

（参考rgb2yuv程序）

六、运行结果

1、

2、在虚拟机中查看yuv视频