数据压缩实验2|图像文件的读写和转换（设计性实验）

实验二：图像文件的读写和转换（设计性实验）

一、实验目的

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

二、主要设备

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

三、实验内容

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

主函数

#include<windows.h>
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include"bmp2yuv.h"

int main(char argc,char *argv[])
{
	int height,width;
	BITMAPFILEHEADER File_header;
	BITMAPINFOHEADER Info_header;
	char* bmpfile_name[10];
	char* yuvfile_name=NULL;
	FILE* bmp;
	FILE* yuv;
	unsigned char *rgb_buffer,*y_buffer,*u_buffer,*v_buffer;
	bool flip=true;

	yuvfile_name=argv[11];
	yuv=fopen(yuvfile_name,"wb");
		if(yuv==NULL)
		{
			printf("cannot find yuv file!\n");
			exit(1);
		}
		else
		{
			printf("The input yuv file is %s\n",yuvfile_name);
		}

	/*一共10张bmp图片*/
	/*argv[1]到argv[10]用来表示这10张bmp图片*/
	for(int num=0;num<10;num++)
	{
		bmpfile_name[num]=argv[num+1];
	}
	
	height=atoi(argv[12]);
	width=atoi(argv[13]);

	for(int i=0;i<10;i++)
	{
		bmp=fopen(bmpfile_name[i],"rb");
	
		if(bmp==NULL)
		{
			printf("cannot find bmp file!\n");
			exit(1);
		}
		else
		{
			printf("The input bmp file is %s\n",bmpfile_name[i]);
		}
	
		

		if((fread(&File_header,sizeof(BITMAPFILEHEADER),1,bmp))!=1)
		{
			printf("Read File header error!");
			exit(0);
		}

		/*判断是否为bmp文件*/
		if(File_header.bfType!=0x4D42)
		{
			printf("Not bmp file!");
			exit(0);
		}
		else
		{
			printf("This is bmp file!\n");
		}

		if((fread(&Info_header,sizeof(BITMAPINFOHEADER),1,bmp))!=1)
		{
			printf("Read Info header error!");
			exit(0);
		}

		/*判断行数是否为4的倍数*/
		if(Info_header.biWidth%4==0)
		{
			width=Info_header.biWidth;
		}
		else
		{
			width=(Info_header.biWidth*Info_header.biBitCount+31)/32*(32/8); 
			//每行的像素数*每个像素的位数=每行像素的总位数，必须为32bit的整数倍（4字节）
			//做法：（x+31）/32*(32/8)	
		}
	
		/*判断列数是否为偶数*/
		if(Info_header.biHeight%2==0)
		{
			height=Info_header.biHeight;
		}
		else
		{
			height=Info_header.biHeight+1;
		}

		int size=width*height;
		rgb_buffer=(unsigned char*)malloc(size*3);
		y_buffer=(unsigned char*)malloc(size);
		u_buffer=(unsigned char*)malloc(size/4);
		v_buffer=(unsigned char*)malloc(size/4);

		/*从bmp得到rgb数据*/
		read_bmp_2_get_rgb(bmp,rgb_buffer,File_header,Info_header);
		
		
		/*rgb转yuv*/
		if(RGB2YUV (width, height, rgb_buffer, y_buffer, u_buffer, v_buffer, flip))
		{
			printf("rgb2yuv failed!\n");
		}
		else
		{
			printf("rgb2yuv successfully!\n");
		}

		int j=0;
		for(j=0;j<size;j++)
		{
			if(y_buffer[j]<16) y_buffer[j]=16;
			if(y_buffer[j]>235) y_buffer[j]=235;
		}

		for(j=0;j<size/4;j++)
		{
			if(u_buffer[j]<16) y_buffer[j]=16;
			if(u_buffer[j]>240) y_buffer[j]=240;
		}

		for(j=0;j<size/4;j++)
		{
			if(v_buffer[j]<16) v_buffer[j]=16;
			if(v_buffer[j]>240) v_buffer[j]=240;
		}
		/*每张bmp图片播放30帧*/
		for(int k=0;k<30;k++)
		{
			fwrite(y_buffer,1,size,yuv);
			fwrite(u_buffer,1,size/4,yuv);
			fwrite(v_buffer,1,size/4,yuv);
		}
		free(rgb_buffer);
		free(y_buffer);
		free(u_buffer);
		free(v_buffer);	
	}
	
		fclose(yuv);
	return 0;
}

RGB2YUV

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

read_bmp_2_get_rgb

#include"stdlib.h"
#include"stdio.h"
#include"windows.h"
#include"malloc.h"

void read_bmp_2_get_rgb(FILE* bmp,unsigned char* rgb_out,BITMAPFILEHEADER &file_header,BITMAPINFOHEADER &info_header)
{
	int width,height,w,h;
	unsigned char *inverse_buffer,*buffer;
	int x=0,y=0;

	//行数为4的倍数
	if(info_header.biWidth%4==0)
	{
		w=info_header.biWidth;
	}
	else
	{
		w=(info_header.biWidth*info_header.biBitCount+31)/32*(32/8);
	}

	//列数为偶数
	if(info_header.biHeight%2==0)
	{
		h=info_header.biHeight;
	}
	else
	{
		h=info_header.biHeight+1;
	}

	width=w/8*info_header.biBitCount;
	height=h;

	inverse_buffer=(unsigned char*)malloc(height*width);
	buffer=(unsigned char*)malloc(height*width);

	//将bmp指针定位到有效数据的起始处
	fseek(bmp,file_header.bfOffBits,0);
	//int fseek(FILE *stream, long offset, int fromwhere);
	//函数设置文件指针stream的位置。
	//如果执行成功，stream将指向以fromwhere为基准，偏移offset（指针偏移量）个字节的位置，函数返回0。
	fread(inverse_buffer,height*width,1,bmp);

	for(y=0;y<height;y++)
	{
		for(x=0;x<width;x++)
		{
		buffer[y*width+x]=inverse_buffer[width*(height-y-1)+x];
		}
	}

	if(info_header.biBitCount==24)
	{
		memcpy(rgb_out,buffer,height*width);
		free(inverse_buffer);
		free(buffer);
	}
}

五、实验结果

通过代码得到一个300帧的小视频，这里采用动图形式进行播放比较方便。
一共十张图，每张30帧，重点是函数定义、缓冲区分配、倒序读写、结构体的操作。