【数据压缩】BMP2YUV文件转换实验

一、实验原理

1、BMP文件的组成结构

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

（1）位图文件头

位图文件头主要包括：

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）调色板

这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的BMP）就不需要调色板。1、4、8色位均需要调色板，16、24、32则不需要调色板，由R、G、B三种颜色直接表示一个像素的颜色。颜色表的大小根据所使用的颜色模式而定：单色位为2色图像为8字节；4色位为16色图像为64字节；8色位为256色图像为1024字节。其中，每4字节表示一种颜色，并以B（蓝色）、G（绿色）、R（红色）、alpha（32位位图的透明度值，一般不需要）。即首先4字节表示颜色号0的颜色，接下来表示颜色号1的颜色，依此类推。

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

注：1、2、3部分结构体在#include<windows.h>头文件中已定义。

（4）图像数据

紧跟在调色板之后的是图像数据字节阵列。对于用到调色板的位图，图像数据就是该像素颜色在调色板中的索引值（逻辑色）。对于真彩色图，图像数据就是实际的R、G、B值。
位图数据记录了位图的每一个像素值，一般BMP图片记录顺序是在自左到右,自下到上。位图的一个像素值所占的字节数：
当biBitCount=1时，8个像素占1个字节；
当biBitCount=4时，2个像素占1个字节；
当biBitCount=8时，1个像素占1个字节；
当biBitCount=24时,1个像素占3个字节；
未经压缩的图像数据信息大小（字节）=（图像宽度×图像高度×像素深度）/8字节
规定每一扫描行的字节数必须是4的整倍数，也就是DWORD对齐的。扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的像素，而最后一个字节表示位图右上角的像素。

2、BMP文件分析

用Visual Studio2022以二进制编辑器形式打开一幅位深度为16bit的bmp图像。

（1）位图文件头

各字节依次表示：
0-1：文件类型，424DH= “BM”，表示这是Windows支持的位图格式。开头两个字节必须为“BM”才是Windows位图文件。
2-5 ：74F80200（小尾字节序） = 0002F874H= 194676B = 190KB，通过查询文件属性发现一致。
6-9 ：这是两个保留段，为0。
A-D：32040000（小尾字节序） = 00000432H = 1074。即从文件头到位图数据需偏移1074个字节。我们稍后将验证这个数据。

（2）位图信息头

0E-11：00000028H=40，位图信息头大小为40个字节。
12-15：000001B8H=440，位图宽度为440像素。
16-19：同理，位图高度也为440像素。
10-1A：0001H，固定值1。
1B-1C：0008H=8，每个像素的位数，1-黑白图，4-16色，8-256色，24-真彩色。
1E-21：0，压缩方式，BI_RGB（0）为不压缩。
22-25：0002F442H=193602，位图全部像素占用的字节数。194676=193602+1074，从文件头到位图数据需偏移1074个字节，与位图文件头一致。
26-29：00000B12H=2834，水平分辨率，缺省。
2A-2D：00000B12H=2834，垂直分辨率，缺省。
2E-31：000000FF，位图使用的颜色数，255。
32-35：000000FF，重要的颜色数，255。

（3）调色板

下面的数据就是调色板了。前面已经提过，调色板是一张映射表，标识颜色索引号与其代表的颜色的对应关系。它在文件中的布局就像一个二维数组palette[N][4],其中N表示总的颜色索引数，每行的四个元素分别表示该索引对应的B、G、R和Alpha的值，每个分量占一个字节。如不设透明通道时，Alpha为0。因为前面知道，本图有256个颜色索引，因此N = 256。索引号就是所在行的行号，对应的颜色就是所在行的四个元素。这里截取一些数据来说明：

索引：(蓝，绿，红，Alpha)
0号：(00，00，00，00)
1号：(FF，FF，FF，00)
2号：(88，78，DF，00)
3号：(3B，38，4C，00)
4号：(EA，D8，E8，00)等等。
一共有256种颜色，每个颜色占用4个字节，就是一共1024个字节，再加上前面的文件信息头和位图信息头的54个字节加起来一共是1078个字节。也就是说在位图数据出现之前一共有1078个字节，与我们在文件信息头得到的信息：文件头到文图数据区的偏移为1078个字节一致。

（4）位图数据

下面就是位图数据了，每个像素占一个字节，取得这个字节后，以该字节为索引查询相应的颜色，并显示到相应的显示设备上就可以了。
注意：由于位图信息头中的图像高度是正数，所以位图数据在文件中的排列顺序是从左下角到右上角，以行为主序排列的。

也即我们见到的第一个像素56是图像最左下角的数据，第二个像素32为图像最后一行第二列的数据，…一直到最后一行的最后一列数据，后面紧接的是倒数第二行的第一列的数据，依此类推。
如果图像是24位或是32位数据的位图的话，位图数据区就不是索引而是实际的像素值了。下面说明一下，此时位图数据区的每个像素的RGB颜色阵列排布：
24位RGB按照BGR的顺序来存储每个像素的各颜色通道的值，一个像素的所有颜色分量值都存完后才存下一个下一个像素，不进行交织存储。
32位数据按照BGRA的顺序存储，其余与24位位图的方式一样。
像素的排布规则与前述一致。

3、实验相关知识点

（1）RGB2YUV

①RGB转YUV的公式
Y = 0.2990R + 0.5870G + 0.1140B
U = - 0.1684R - 0.3316G + 0.5B + 128
V = 0.5R - 0.4187G - 0.0813B + 128
这里，采用部分查找表法，提高运行效率，如代码所示。

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;
	} 
}

②YUV流的采样方式
YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有四种：
YUV4:4:4：表示一个Y分量对应一组UV分量。
YUV4:2:2：表示两个Y分量共用一组UV分量。
YUV4:1:1: 是在水平方向上对色度进行4:1抽样。
YUV4:2:0：表示四个Y分量共用一组UV分量。
本实验是：YUV4:2:0 采样方式为: U分量和V分量隔行采样， 同时UV分量在其采样行也是隔行采样。

（2）字节序

字节序分为小尾字节序(Little Endian)和大尾字节序(Big Endian)。Intel处理器大多数使用小尾字节序，Motorola处理器大多数使用大尾(Big Endian)字节序。
小尾就是低位字节排放在内存的低端，高位字节排放在内存的高端，即所谓的"低位在前，高位在后”。大尾就是高位字节排放在内存的低端，低位字节排放在内存的高端，即所谓的“高位在前，低位在后”。
在实现BMP文件头信息的写入和读出时，需要注意整数保存时的字节序。例如：文件大小是以Intel序保存的。对于小尾字节序，数据0×1756在内存中存储顺序为下图所示。

（3）DWORD对齐

图像的每一扫描行由表示图像像素的连续的字节构成，每一行的字节数取决于图像的颜色数目和用像素表示的图像宽度，特别的：规定每一扫描行的字节数必须是4的倍数，即DWORD对齐方式。写入位图文件数据时，如果图像每行像素字节总数[宽 X biBiCount % 8 ！= 0 ]，系统会自动在每行最后填充若干0值使满足整数字节，接着，如果[每行像素字节数 % 4 != 0 ]，系统会自动在每行最后填充若干字节0值使满足DWORD对齐。所以我们对位图加载处理时要注意判断每行数据是否有0值填充，若有0值填充则从位图中读取数据的过程中要注意指针偏移量和即时跳转。

三、实验流程

1. 程序初始化（打开两个文件、定义变量和缓冲区等）
2. 读取BMP文件，抽取或生成RGB数据写入缓冲区
①读位图文件头（判断是否可读出以及判断是否是BMP文件）
②读位图信息头（判断是否读出）
③判断像素的实际点阵数
④开辟缓冲区，读数据，倒序存放
⑤根据每像素位数的不同，执行不同的操作
a.8bit以下：构造调色板→位与移位取像素数据、查调色板、写RGB缓冲区
b.16bit：位与移位取像素数据、转换为8bit彩色分量、写RGB缓冲区
c.24/32bit：直接取像素数据、写RGB缓冲区
3. 调用RGB2YUV的函数实现RGB到YUV数据的转换
采用部分查找表法，提高运行效率
4. 写YUV文件
5. 程序收尾工作（关闭文件，释放缓冲区）

四、实验要求

（1）在图像处理软件中自行生成多个BMP文件，至少含5个不同的场景画面，要求带含有班级、学号后四位和本人姓名（缩写或昵称均可）的logo。
（基本要求为24bit的BMP，进阶要求为支持小于24bit的BMP。）
（2）编写将第一步所生成的多个BMP文件转化为YUV文件，要求可在命令行中设置每个画面出现的帧数。最后形成的YUV文件应至少包含200帧。重点掌握函数定义、缓冲区分配、倒序读写、结构体的操作。
（3）对整个程序进行调试，并将生成的YUV文件用播放软件观看，验证是否正确。

五、实验代码

1、bmp2yuv.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <windows.h> 
#ifndef BMP2YUV_H_
#define BMP2YUV_H_

void bmp2rgb(int width, int height, BITMAPFILEHEADER& File_header, BITMAPINFOHEADER& Info_header, FILE* file, unsigned char* rgb);
bool MakePalette(FILE* bmpfile, BITMAPFILEHEADER& file_header, BITMAPINFOHEADER& info_header, RGBQUAD* rgbout);
void rgb2yuv(int file_size, unsigned char* rgbBuf, unsigned char* yBuf, unsigned char* uBuf, unsigned char* vBuf);
void DownSample_YUV(int height, int width, unsigned char* uBuf, unsigned char* vBuf, unsigned char* uBuf_tmp, unsigned char* vBuf_tmp);
#endif

2、bmp2rgb.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h> 
#include <math.h> 
#include <iostream>
using namespace std;
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;
}
void bmp2rgb(int width, int height, BITMAPFILEHEADER& File_header, BITMAPINFOHEADER& Info_header, FILE* file, unsigned char* rgb) {
	unsigned char mask, * tmp_data, * data;
	unsigned long loop;
	WORD bitcount = Info_header.biBitCount;
	DWORD offbits = File_header.bfOffBits;
	int w = width * bitcount / 8;
	int h = height;
	
	tmp_data = new unsigned char[w * h];
	data = new unsigned char[w * h];
	
	fseek(file, offbits, 0);  //file指向以0为基准，偏移offbits（指针偏移量）个字节的位置
	if (fread(tmp_data, w * h, 1, file) != 1) {
		cout << "read imgdata error!" << endl;
		exit(0);
	}

	//倒序转正序
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			data[i * w + j] = tmp_data[(h - 1 - i) * w + j];
		}
	}

	if (bitcount == 24) {
		memcpy(rgb, data, w * h);   //从data所指的地址开始将w*h大小的数据给rgb
	}

	if (bitcount == 16) {
		for (loop = 0; loop < w * h; loop += 2)
		{
			*rgb = (data[loop] & 0x1F) << 3;
			*(rgb + 1) = ((data[loop] & 0xE0) >> 2) + ((data[loop + 1] & 0x03) << 6);
			*(rgb + 2) = (data[loop + 1] & 0x7C) << 1;
			rgb += 3;
		}
	}

	RGBQUAD* prgb = (RGBQUAD*)malloc(sizeof(RGBQUAD) * (unsigned int)pow(2, (float)bitcount));
	if (!MakePalette(file, File_header, Info_header, prgb))  //判断是否有调色板数据
		cout << "No palette!" << endl;

	if (bitcount <= 8) {

		for (loop = 0; loop < w * h; loop++)
		{
			//根据位深设置掩膜
			switch (bitcount) {
			case 1:
				mask = 0x80;   //1000 0000
				break;
			case 2:
				mask = 0xC0;   //1100 0000
				break;
			case 4:
				mask = 0xF0;   //1111 0000
				break;
			case 8:
				mask = 0xFF;   //1111 1111
			}

			int shiftCnt = 1;
			while (mask) //循环mask次：1bit每字节循环8次，2bit4次，4bit2次
			{
				unsigned char index = mask == 0xFF ? data[loop] : ((data[loop] & mask) >> (8 - shiftCnt * bitcount));

				*rgb = prgb[index].rgbBlue;
				*(rgb + 1) = prgb[index].rgbGreen;
				*(rgb + 2) = prgb[index].rgbRed;

				if (bitcount == 8)
					mask = 0;
				else
					mask >>= bitcount;
				rgb += 3;
				shiftCnt++;
			}
		}
	}
	//delete[] tmp_data;
	//delete[] data;
}

3、rgb2yuv.c

#include "stdlib.h"
#include "bmp2yuv.h"

static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static float RGBYUV01684[256], RGBYUV03316[256];
static float RGBYUV04187[256], RGBYUV00813[256];
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;
}

void rgb2yuv(int file_size, unsigned char* rgbBuf, unsigned char* yBuf, unsigned char* uBuf, unsigned char* vBuf) {
	InitLookupTable();   //初始化查找表

	unsigned char* r, * g, * b;
	unsigned char* y, * u, * v;
	float y_tmp, u_tmp, v_tmp;    //临时变量，防止计算和转换过程中yuv值溢出

	y = yBuf;
	u = uBuf;
	v = vBuf;
	b = rgbBuf;  //b指向rgb文件

	for (int i = 0; i < file_size; i++) {
		g = b + 1;
		r = b + 2;

		unsigned char r_tmp, g_tmp, b_tmp;
		r_tmp = *r;
		g_tmp = *g;
		b_tmp = *b;

		y_tmp = RGBYUV02990[r_tmp] + RGBYUV05870[g_tmp] + RGBYUV01140[b_tmp];
		u_tmp = -RGBYUV01684[r_tmp] - RGBYUV03316[g_tmp] + (b_tmp) / 2 + 128;
		v_tmp = (r_tmp) / 2 - RGBYUV04187[g_tmp] - RGBYUV00813[b_tmp] + 128;     //uv分量+128，将零电平变为128码电平

		if (y_tmp < 16) y_tmp = 16;
		if (y_tmp > 235) y_tmp = 235;
		if (u_tmp < 16) u_tmp = 16;
		if (u_tmp > 240) u_tmp = 240;
		if (v_tmp < 16) v_tmp = 16;
		if (v_tmp > 240) v_tmp = 240;     //防止计算出的yuv溢出

//		printf("No.%d",i);

		*y = (unsigned char)y_tmp;
		*u = (unsigned char)u_tmp;
		*v = (unsigned char)v_tmp;

		b += 3;
		y++;
		u++;
		v++;
	}
	yBuf = y;
	uBuf = u;
	vBuf = v;
}

4、DownYUV.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h> 
#include <math.h> 
void DownSample_YUV(int height, int width, unsigned char* uBuf, unsigned char* vBuf, unsigned char* uBuf_tmp, unsigned char* vBuf_tmp) {
	//YUV文件色度格式为420，对UV分量进行采样，计算相邻4个像素的平均值作为对应的值存入UV
	int k = 0;
	unsigned char* ub = uBuf, * vb = vBuf;
	unsigned char* utmp = uBuf_tmp, * vtmp = vBuf_tmp;
	float u, v;

	for (int i = 0; i < height * width / 4; i++) {
		u = (float)(*(utmp + k) + *(utmp + k + 1) + *(utmp + k + width) + *(utmp + k + width + 1)) / 4.0;
		v = (float)(*(vtmp + k) + *(vtmp + k + 1) + *(vtmp + k + width) + *(vtmp + k + width + 1)) / 4.0;

		*ub = (unsigned char)u;
		*vb = (unsigned char)v;

		ub++;
		vb++;

		if ((i + 1) % (width / 2) == 0) {
			k += 2 + width;
		}
		else {
			k += 2;
		}
	}
	uBuf = ub;
	vBuf = vb;
}

5、main.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h> 
#include <math.h> 
#include "bmp2yuv.h"
#include <iostream>
using namespace std;

#define u_int8_t	unsigned __int8
#define u_int		unsigned __int32
#define u_int32_t	unsigned __int32

int main(int argc, char** argv)
{
	//设置命令行参数： 40 40 40 40 20 20
	const int picnum = 6;   //图片张数
	int bmpnum[picnum] = { 0 };
	for (int i = 0; i < picnum; i++) {
		bmpnum[i] = atoi(argv[i + 1]);   //存储每张图片循环次数
	}

	//定义缓冲区
	FILE* bmpfile = NULL;
	FILE* yuvfile = NULL;
	unsigned char* rgbBuf = NULL;
	unsigned char* yBuf = NULL, * uBuf = NULL, * vBuf = NULL;

	const char* bmpfilename[picnum] = {"1bit.bmp","4bit.bmp" ,"8bit.bmp" ,"16bit.bmp" ,"24bit.bmp" ,"32bit.bmp" };
	const char* yuvname = "outyuv.yuv";

	//打开yuv文件
	if ((yuvfile = fopen(yuvname, "wb")) == NULL) {
		cout << "can't open yuvfile!" << endl;
		exit(0);
	}

	for (int i = 0; i < picnum; i++) {
		//打开bmp文件
		if ((bmpfile = fopen(bmpfilename[i], "rb")) == NULL) {
			cout << "can't open bmpfile!" << endl;
			exit(0);
		}

		BITMAPFILEHEADER File_header;
		BITMAPINFOHEADER Info_header;

		//读取BMP文件头
		if (fread(&File_header, sizeof(BITMAPFILEHEADER), 1, bmpfile) != 1) {
			cout << "read fileheader error!" << endl;
			exit(0);
		}

		//判断是否是bmp
		if (File_header.bfType != 0x4D42) {
			cout << "not bmp file!" << endl;
			exit(0);
		}
		else {
			cout << "this is a bmp!" << endl;
		}

		//读取bmp文件信息头
		if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpfile) != 1) {
			cout << "read infoheader error!" << endl;
			exit(0);
		}
		//处理图像宽高
		int width, height;
		//每行字节数必须是4的整数倍
		if ((Info_header.biWidth % 4) == 0) {
			width = Info_header.biWidth;
		}
		else {
			width = (Info_header.biWidth * Info_header.biBitCount + 31) / 32 * 4;
			//加31再除以32后下取整，保证计算结果是离这个数最近的而且是比它大的32的倍数，即为4字节的整数倍。乘以4和行数，得到4字节整数倍的图像大小。 
		}
		//高是偶数
		if ((Info_header.biHeight % 2) == 0) {
			height = Info_header.biHeight;
		}
		else {
			height = Info_header.biHeight + 1;
		}
		//开辟空间
		rgbBuf = new unsigned char[width * height * 3];
		yBuf = new unsigned char[width * height];
		uBuf = new unsigned char[(width * height) / 4];
		vBuf = new unsigned char[(width * height) / 4];
		unsigned char* u_tmp = new unsigned char[width * height];
		unsigned char* v_tmp = new unsigned char[width * height];
		//BMP2RGB
		bmp2rgb(width, height, File_header, Info_header, bmpfile, rgbBuf);
		rgb2yuv(width*height, rgbBuf, yBuf, u_tmp, v_tmp);
		//下采样
		DownSample_YUV(height, width, uBuf, vBuf, u_tmp, v_tmp);

		//循环写入文件
		for (int k = 0; k < bmpnum[i]; k++) {
			fwrite(yBuf, 1, width * height, yuvfile);
			fwrite(uBuf, 1, (width * height) / 4, yuvfile);
			fwrite(vBuf, 1, (width * height) / 4, yuvfile);
		}

		delete[] rgbBuf;
		delete[] yBuf;
		delete[] uBuf;
		delete[] vBuf;
		delete[] u_tmp;
		delete[] v_tmp;

		fclose(bmpfile);
	}
	fclose(yuvfile);
}

六、实验结果与分析

1、准备工作

本实验用ps对原本位深度为24bit的图像进行处理，从而得到了6个BMP图片文件，并含有班级、学号后四位和本人姓名。图片的位深度分别为1bit、4bit、8bit、16bit、24bit、32bit。图片如下所示。
上一行从左到右分别为1bit、4bit、8bit位深度图片，下一行从左到右分别为16bit、24bit、32bit位深度图片。

之后修改命令参数为各图片帧数，位深度从小到大，分别为40、40、40、40、20、20。则可运行代码。

2、实验结果

实验结果中仅有16bit、24bit、32bit位深度显示图像，其余为空白。如下图所示。

我百思不得其解，故而此实验一直搁置，直到后来一次实验中，使用实验中提供的8bit图像试验，发现可以成功显示，如下图所示。猜测可能是ps处理图片时出现问题。但由于没有其它路径获取1bit、4bit深度图片，暂且作罢，本实验实现了8bit、16bit、24bit、32bit位深度200帧图像显示。

---

参考

BMP文件格式详解（BMP file format）
BMP图片解析
BMP2YUV