实验二YUV

BMP序列转YUV文件

实验目的

1．理解图像文件的基本组成。

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

实验要求

（1）在图像处理软件中自行生成多个BMP文件，至少含5个不同的场景画面，要求带含有班级、学号后四位和本人姓名（缩写或昵称均可）的logo。（基本要求为24bit的BMP，进阶要求为支持小于24bit的BMP。）

（2）编写将第一步所生成的多个BMP文件转化为YUV文件，要求可在命令行中设置每个画面出现的帧数。最后形成的YUV文件应至少包含200帧。重点掌握函数定义、缓冲区分配、倒序读写、结构体的操作。

（3）对整个程序进行调试，并将生成的YUV文件用播放软件观看，验证是否正确。

BMP图像文件格式

位图文件(Bitmap-File，BMP)格式是Windows采用的图像文件存储格式，在Windows环境下运行的所有图像处理软件都支持这种格式。BMP位图文件默认的文件扩展名是bmp或者dib。BMP图像文件格式BMP文件大体上分为四个部分：

位图文件头BITMAPFILEHEADER

位图信息头BITMAPINFOHEADER

调色板Palette

实际的位图数据ImageData

位图文件头
包含BMP图像文件的类型、显示内容等信息，共14字节

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

位图信息头
信息数据结构，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信息，共40字节。

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;

调色板实际上是一个数组，它所包含的元素与位图所具有的颜色数相同，决定于biClrUsed和biBitCount字段。数组中每个元素的类型是一个RGBQUAD结构。有些位图（比如真彩色图 24位的 BMP）不需要调色板。

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

紧跟在调色板之后的是图像数据字节阵列。对于用到调色板的位图，图象数据就是该象素颜色在调色板中的索引值（逻辑色）。对于真彩色图，图象数据就是实际的R、G、B值。

图像的每一扫描行由表示图像像素的连续的字节组成，每一行的字节数取决于图像的颜色数目和用像素表示的图像宽度。规定每一扫描行的字节数必需是4的整倍数，也就是DWORD对齐的。

扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的像素，而最后一个字节表示位图右上角的像素。（只针对于倒向DIB，如果是正向DIB，则扫描行是由顶向下存储）

实验过程

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

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

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

4.写YUV文件

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

 

 实验代码

main.cpp

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<Windows.h>
#include<wingdi.h>
#include"bmp2yuv.h";

using namespace std;

int main(int argc, char** argv)
{
	//定义变量
	BITMAPFILEHEADER File_header;
	BITMAPINFOHEADER Info_header;
	FILE* bmpFile = NULL;
	FILE* yuvFile = NULL;
	int frameWidth;
	int frameHeight;
	const int imageNum = 5;
	const char* bmpFileName[imageNum] = { "1.bmp","2.bmp","3.bmp","4.bmp","5.bmp" };
	const char* yuvFileName = "out.yuv";
	unsigned char* rgbBuf;
	unsigned char* yBuf;
	unsigned char* uBuf;
	unsigned char* vBuf;
	bool flip = TRUE;
	
	//打开输出文件
	yuvFile = fopen(yuvFileName, "wb");
	
	//逐个图片转换
	for (int i = 0; i < imageNum; i++)
	{
		bmpFile = fopen(bmpFileName[i], "rb");
		//读文件头、信息头
		if (fread(&File_header, sizeof(BITMAPFILEHEADER), 1, bmpFile) != 1)
		{
			cout << "read file header error!" << endl;
			exit(0);
		}
		if (File_header.bfType != 0x4D42)
		{
			cout << "Not bmp file!" << endl;
			exit(0);
		}
		else
		{
			cout << "this is a bmp file!" << endl;
		}
		if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpFile) != 1)
		{
			cout << "read info header error!" << endl;
			exit(0);
		}
		
		//赋值
		frameWidth = Info_header.biWidth;
		frameHeight = Info_header.biHeight;

		//分配空间
		rgbBuf = (unsigned char*)malloc(frameWidth * frameHeight * 3);
		yBuf = (unsigned char*)malloc(frameWidth * frameHeight);
		uBuf = (unsigned char*)malloc(frameWidth * frameHeight / 4);
		vBuf = (unsigned char*)malloc(frameWidth * frameHeight / 4);

		//调色板判断
		RGBQUAD* pRGB = (RGBQUAD*)malloc(sizeof(RGBQUAD) * (unsigned int)pow(2, Info_header.biBitCount));
		if (!MakePalette(bmpFile, File_header, Info_header, pRGB))
			cout << "No palettel" << endl;

		//读取BMP文件中的RGB数据
		READRGB(frameWidth, frameHeight, bmpFile, rgbBuf);

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

		for (int i = 0; i < frameWidth * frameHeight; i++)
		{
			if (yBuf[i] < 16) yBuf[i] = 16;
			if (yBuf[i] > 235) yBuf[i] = 235;
		}

		for (int 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 (int 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);
		}
		
		//释放空间，关闭文件
		free(rgbBuf);
		free(yBuf);
		free(uBuf);
		free(vBuf);
		fclose(bmpFile);
	}
	fclose(yuvFile);

	return 0;
}

bmp2yuv.h

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<Windows.h>
#include<wingdi.h>

int RGB2YUV(int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip);
bool MakePalette(FILE* pFile, BITMAPFILEHEADER& file_h, BITMAPINFOHEADER& info_h, RGBQUAD* pRGB_out);
int READRGB(int width, int height, FILE* bmpFile, unsigned char* rgb);


void InitLookupTable();

bmp2yuv.cpp 

#define _CRT_SECURE_NO_DEPRECATE
#include "stdlib.h"
#include "bmp2yuv.h"
#include<stdio.h>
#include<iostream>
#include<Windows.h>
#include<wingdi.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)    //RGB转YUV函数
{
	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;
}

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, info_h.biBitCount))
	{
		fseek(pFile, sizeof(BITMAPFILEHEADER) + info_h.biSize, 0);
		fread(pRGB_out, sizeof(RGBQUAD), (unsigned int)pow(2, info_h.biBitCount), pFile);
		return true;
	}
	else
	{
		return false;
	}
}

int READRGB(int width, int height, FILE* bmpFile, unsigned char* rgb)
{
	unsigned char* bmp = (unsigned char*)malloc(sizeof(unsigned char) * width * height * 3);
	unsigned char* tmp_rgb = (unsigned char*)malloc(sizeof(unsigned char) * width * height * 3);

	fread(bmp, width * height * 3, 1, bmpFile);

	for (int i = 0; i < width * height * 3; i++)
	{
		*(tmp_rgb + i) = *bmp;
		bmp++;
	}

	//倒序转正序
	for (int i = 0; i < height; i++)
	{
		for (int j = 0; j < width * 3; j++)
		{
			*(rgb + (height - 1 - i) * width * 3 + j) = *tmp_rgb;
			tmp_rgb++;
		}
	}

	return 0;
}
//这里需要注意：由于BMP文件中数据部分是由下到上，由左到右存储，故读取RGB数据后需要进行翻转才能得到正序图像。

实验结果