视音频数据处理入门：RGB、YUV像素数据处理

痛定思痛。 2022-05-27 09:37 173阅读 0赞

=====================================================

视音频数据处理入门系列文章：

[视音频数据处理入门：RGB、YUV像素数据处理][RGB_YUV]

[视音频数据处理入门：PCM音频采样数据处理][PCM]

[视音频数据处理入门：H.264视频码流解析][H.264]

[视音频数据处理入门：AAC音频码流解析][AAC]

[视音频数据处理入门：FLV封装格式解析][FLV]

[视音频数据处理入门：UDP-RTP协议解析][UDP-RTP]

=====================================================

有段时间没有写博客了，这两天写起博客来竟然感觉有些兴奋，仿佛找回了原来的感觉。前一阵子在梳理以前文章的时候，发现自己虽然总结了各种视音频应用程序，却还缺少一个适合无视音频背景人员学习的“最基础”的程序。因此抽时间将以前写过的代码整理成了一个小项目。这个小项目里面包含了一系列简单的函数，可以对RGB/YUV视频像素数据、PCM音频采样数据、H.264视频码流、AAC音频码流、FLV封装格式数据、UDP/RTP协议数据进行简单处理。这个项目的一大特点就是没有使用任何的第三方类库，完全借助于C语言的基本函数实现了功能。通过对这些代码的学习，可以让初学者迅速掌握视音频数据的基本格式。有关上述几种格式的介绍可以参考文章《[\[总结\]视音频编解码技术零基础学习方法][Link 1]》。

从这篇文章开始打算写6篇文章分别记录上述6种不同类型的视音频数据的处理方法。本文首先记录第一部分即RGB/YUV视频像素数据的处理方法。视频像素数据在视频播放器的解码流程中的位置如下图所示。

![20160118002918690][]

本文分别介绍如下几个RGB/YUV视频像素数据处理函数：  
 分离YUV420P像素数据中的Y、U、V分量  
 分离YUV444P像素数据中的Y、U、V分量  
 将YUV420P像素数据去掉颜色（变成灰度图）  
 将YUV420P像素数据的亮度减半  
 将YUV420P像素数据的周围加上边框  
 生成YUV420P格式的灰阶测试图  
 计算两个YUV420P像素数据的PSNR  
 分离RGB24像素数据中的R、G、B分量  
 将RGB24格式像素数据封装为BMP图像  
 将RGB24格式像素数据转换为YUV420P格式像素数据  
 生成RGB24格式的彩条测试图

本文中的RGB/YUV文件需要使用RGB/YUV播放器才能查看。YUV播放器种类比较多，例如[YUV Player Deluxe][]，或者开源播放器（参考文章《[修改了一个YUV/RGB播放器][YUV_RGB]》）等。

## 函数列表 ##

### (1) 分离YUV420P像素数据中的Y、U、V分量 ###

本程序中的函数可以将YUV420P数据中的Y、U、V三个分量分离开来并保存成三个文件。函数的代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Split Y, U, V planes in YUV420P file.
3. \* @param url Location of Input YUV file.
4. \* @param w Width of Input YUV file.
5. \* @param h Height of Input YUV file.
6. \* @param num Number of frames to process.
7. \*
8. \*/
9. int simplest\_yuv420\_split(char \*url, int w, int h,int num)\{ 
10. FILE \*fp=fopen(url,"rb+"); 
11. FILE \*fp1=fopen("output\_420\_y.y","wb+"); 
12. FILE \*fp2=fopen("output\_420\_u.y","wb+"); 
13. FILE \*fp3=fopen("output\_420\_v.y","wb+"); 
14. 
15. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3/2); 
16. 
17. for(int i=0;i<num;i++)\{ 
18. 
19. fread(pic,1,w\*h\*3/2,fp); 
20. //Y
21. fwrite(pic,1,w\*h,fp1); 
22. //U
23. fwrite(pic+w\*h,1,w\*h/4,fp2); 
24. //V
25. fwrite(pic+w\*h\*5/4,1,w\*h/4,fp3); 
26. \} 
27. 
28. free(pic); 
29. fclose(fp); 
30. fclose(fp1); 
31. fclose(fp2); 
32. fclose(fp3); 
33. 
34. return 0; 
35. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_split("lena\_256x256\_yuv420p.yuv",256,256,1);

从代码可以看出，如果视频帧的宽和高分别为w和h，那么一帧YUV420P像素数据一共占用w\*h\*3/2 Byte的数据。其中前w\*h Byte存储Y，接着的w\*h\*1/4 Byte存储U，最后w\*h\*1/4 Byte存储V。上述调用函数的代码运行后，将会把一张分辨率为256x256的名称为lena\_256x256\_yuv420p.yuv的YUV420P格式的像素数据文件分离成为三个文件：

> output\_420\_y.y：纯Y数据，分辨率为256x256。
> 
> output\_420\_u.y：纯U数据，分辨率为128x128。
> 
> output\_420\_v.y：纯V数据，分辨率为128x128。

注：本文中像素的采样位数一律为8bit。由于1Byte=8bit，所以一个像素的一个分量的采样值占用1Byte。

程序输入的原图如下所示。

![20160117232415153][]

lena\_256x256\_yuv420p.yuv

程序输出的三个文件的截图如下图所示。在这里需要注意输出的U、V分量在YUV播放器中也是当做Y分量进行播放的。

![20160117232435874][]

output\_420\_y.y

![20160117232500394][] ![20160117232505751][]

output\_420\_u.y和output\_420\_v.y

### (2)分离YUV444P像素数据中的Y、U、V分量 ###

本程序中的函数可以将YUV444P数据中的Y、U、V三个分量分离开来并保存成三个文件。函数的代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Split Y, U, V planes in YUV444P file.
3. \* @param url Location of YUV file.
4. \* @param w Width of Input YUV file.
5. \* @param h Height of Input YUV file.
6. \* @param num Number of frames to process.
7. \*
8. \*/
9. int simplest\_yuv444\_split(char \*url, int w, int h,int num)\{ 
10. FILE \*fp=fopen(url,"rb+"); 
11. FILE \*fp1=fopen("output\_444\_y.y","wb+"); 
12. FILE \*fp2=fopen("output\_444\_u.y","wb+"); 
13. FILE \*fp3=fopen("output\_444\_v.y","wb+"); 
14. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3); 
15. 
16. for(int i=0;i<num;i++)\{ 
17. fread(pic,1,w\*h\*3,fp); 
18. //Y
19. fwrite(pic,1,w\*h,fp1); 
20. //U
21. fwrite(pic+w\*h,1,w\*h,fp2); 
22. //V
23. fwrite(pic+w\*h\*2,1,w\*h,fp3); 
24. \} 
25. 
26. free(pic); 
27. fclose(fp); 
28. fclose(fp1); 
29. fclose(fp2); 
30. fclose(fp3); 
31. 
32. return 0; 
33. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv444\_split("lena\_256x256\_yuv444p.yuv",256,256,1);

从代码可以看出，如果视频帧的宽和高分别为w和h，那么一帧YUV444P像素数据一共占用w\*h\*3 Byte的数据。其中前w\*h Byte存储Y，接着的w\*h Byte存储U，最后w\*h Byte存储V。上述调用函数的代码运行后，将会把一张分辨率为256x256的名称为lena\_256x256\_yuv444p.yuv的YUV444P格式的像素数据文件分离成为三个文件：

> output\_444\_y.y：纯Y数据，分辨率为256x256。  
> output\_444\_u.y：纯U数据，分辨率为256x256。  
> output\_444\_v.y：纯V数据，分辨率为256x256。

输入的原图如下所示。

![20160117232650727][]

输出的三个文件的截图如下图所示。

![20160117232704546][]

output\_444\_y.y

![20160117232711011][]

output\_444\_u.y

![20160117232719517][]

output\_444\_v.y

### (3) 将YUV420P像素数据去掉颜色（变成灰度图） ###

本程序中的函数可以将YUV420P格式像素数据的彩色去掉，变成纯粹的灰度图。函数的代码如下。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Convert YUV420P file to gray picture
3. \* @param url Location of Input YUV file.
4. \* @param w Width of Input YUV file.
5. \* @param h Height of Input YUV file.
6. \* @param num Number of frames to process.
7. \*/
8. int simplest\_yuv420\_gray(char \*url, int w, int h,int num)\{ 
9. FILE \*fp=fopen(url,"rb+"); 
10. FILE \*fp1=fopen("output\_gray.yuv","wb+"); 
11. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3/2); 
12. 
13. for(int i=0;i<num;i++)\{ 
14. fread(pic,1,w\*h\*3/2,fp); 
15. //Gray
16. memset(pic+w\*h,128,w\*h/2); 
17. fwrite(pic,1,w\*h\*3/2,fp1); 
18. \} 
19. 
20. free(pic); 
21. fclose(fp); 
22. fclose(fp1); 
23. return 0; 
24. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_gray("lena\_256x256\_yuv420p.yuv",256,256,1);

从代码可以看出，如果想把YUV格式像素数据变成灰度图像，只需要将U、V分量设置成128即可。这是因为U、V是图像中的经过偏置处理的色度分量。色度分量在偏置处理前的取值范围是-128至127，这时候的无色对应的是“0”值。经过偏置后色度分量取值变成了0至255，因而此时的无色对应的就是128了。上述调用函数的代码运行后，将会把一张分辨率为256x256的名称为lena\_256x256\_yuv420p.yuv的YUV420P格式的像素数据文件处理成名称为output\_gray.yuv的YUV420P格式的像素数据文件。输入的原图如下所示。

![20160117232856722][]

处理后的图像如下所示。

![20160117232913602][]

### (4)将YUV420P像素数据的亮度减半 ###

本程序中的函数可以通过将YUV数据中的亮度分量Y的数值减半的方法，降低图像的亮度。函数代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Halve Y value of YUV420P file
3. \* @param url Location of Input YUV file.
4. \* @param w Width of Input YUV file.
5. \* @param h Height of Input YUV file.
6. \* @param num Number of frames to process.
7. \*/
8. int simplest\_yuv420\_halfy(char \*url, int w, int h,int num)\{ 
9. FILE \*fp=fopen(url,"rb+"); 
10. FILE \*fp1=fopen("output\_half.yuv","wb+"); 
11. 
12. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3/2); 
13. 
14. for(int i=0;i<num;i++)\{ 
15. fread(pic,1,w\*h\*3/2,fp); 
16. //Half
17. for(int j=0;j<w\*h;j++)\{ 
18. unsigned char temp=pic\[j\]/2; 
19. //printf("%d,\\n",temp);
20. pic\[j\]=temp; 
21. \} 
22. fwrite(pic,1,w\*h\*3/2,fp1); 
23. \} 
24. 
25. free(pic); 
26. fclose(fp); 
27. fclose(fp1); 
28. 
29. return 0; 
30. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_halfy("lena\_256x256\_yuv420p.yuv",256,256,1);

从代码可以看出，如果打算将图像的亮度减半，只要将图像的每个像素的Y值取出来分别进行除以2的工作就可以了。图像的每个Y值占用1 Byte，取值范围是0至255，对应C语言中的unsigned char数据类型。上述调用函数的代码运行后，将会把一张分辨率为256x256的名称为lena\_256x256\_yuv420p.yuv的YUV420P格式的像素数据文件处理成名称为output\_half.yuv的YUV420P格式的像素数据文件。输入的原图如下所示。

![20160117233038584][]

处理后的图像如下所示。

![20160117233049307][]

### (5)将YUV420P像素数据的周围加上边框 ###

本程序中的函数可以通过修改YUV数据中特定位置的亮度分量Y的数值，给图像添加一个“边框”的效果。函数代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Add border for YUV420P file
3. \* @param url Location of Input YUV file.
4. \* @param w Width of Input YUV file.
5. \* @param h Height of Input YUV file.
6. \* @param border Width of Border.
7. \* @param num Number of frames to process.
8. \*/
9. int simplest\_yuv420\_border(char \*url, int w, int h,int border,int num)\{ 
10. FILE \*fp=fopen(url,"rb+"); 
11. FILE \*fp1=fopen("output\_border.yuv","wb+"); 
12. 
13. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3/2); 
14. 
15. for(int i=0;i<num;i++)\{ 
16. fread(pic,1,w\*h\*3/2,fp); 
17. //Y
18. for(int j=0;j<h;j++)\{ 
19. for(int k=0;k<w;k++)\{ 
20. if(k<border||k>(w-border)||j<border||j>(h-border))\{ 
21. pic\[j\*w+k\]=255; 
22. //pic\[j\*w+k\]=0;
23. \} 
24. \} 
25. \} 
26. fwrite(pic,1,w\*h\*3/2,fp1); 
27. \} 
28. 
29. free(pic); 
30. fclose(fp); 
31. fclose(fp1); 
32. 
33. return 0; 
34. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_border("lena\_256x256\_yuv420p.yuv",256,256,20,1);

从代码可以看出，图像的边框的宽度为border，本程序将距离图像边缘border范围内的像素的亮度分量Y的取值设置成了亮度最大值255。上述调用函数的代码运行后，将会把一张分辨率为256x256的名称为lena\_256x256\_yuv420p.yuv的YUV420P格式的像素数据文件处理成名称为output\_border.yuv的YUV420P格式的像素数据文件。输入的原图如下所示。

![20160117233158395][]

处理后的图像如下所示。

![20160117233215510][]

### (6) 生成YUV420P格式的灰阶测试图 ###

本程序中的函数可以生成一张YUV420P格式的灰阶测试图。函数代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Generate YUV420P gray scale bar.
3. \* @param width Width of Output YUV file.
4. \* @param height Height of Output YUV file.
5. \* @param ymin Max value of Y
6. \* @param ymax Min value of Y
7. \* @param barnum Number of bars
8. \* @param url\_out Location of Output YUV file.
9. \*/
10. int simplest\_yuv420\_graybar(int width, int height,int ymin,int ymax,int barnum,char \*url\_out)\{ 
11. int barwidth; 
12. float lum\_inc; 
13. unsigned char lum\_temp; 
14. int uv\_width,uv\_height; 
15. FILE \*fp=NULL; 
16. unsigned char \*data\_y=NULL; 
17. unsigned char \*data\_u=NULL; 
18. unsigned char \*data\_v=NULL; 
19. int t=0,i=0,j=0; 
20. 
21. barwidth=width/barnum; 
22. lum\_inc=((float)(ymax-ymin))/((float)(barnum-1)); 
23. uv\_width=width/2; 
24. uv\_height=height/2; 
25. 
26. data\_y=(unsigned char \*)malloc(width\*height); 
27. data\_u=(unsigned char \*)malloc(uv\_width\*uv\_height); 
28. data\_v=(unsigned char \*)malloc(uv\_width\*uv\_height); 
29. 
30. if((fp=fopen(url\_out,"wb+"))==NULL)\{ 
31. printf("Error: Cannot create file!"); 
32. return \-1; 
33. \} 
34. 
35. //Output Info
36. printf("Y, U, V value from picture's left to right:\\n"); 
37. for(t=0;t<(width/barwidth);t++)\{ 
38. lum\_temp=ymin+(char)(t\*lum\_inc); 
39. printf("%3d, 128, 128\\n",lum\_temp); 
40. \} 
41. //Gen Data
42. for(j=0;j<height;j++)\{ 
43. for(i=0;i<width;i++)\{ 
44. t=i/barwidth; 
45. lum\_temp=ymin+(char)(t\*lum\_inc); 
46. data\_y\[j\*width+i\]=lum\_temp; 
47. \} 
48. \} 
49. for(j=0;j<uv\_height;j++)\{ 
50. for(i=0;i<uv\_width;i++)\{ 
51. data\_u\[j\*uv\_width+i\]=128; 
52. \} 
53. \} 
54. for(j=0;j<uv\_height;j++)\{ 
55. for(i=0;i<uv\_width;i++)\{ 
56. data\_v\[j\*uv\_width+i\]=128; 
57. \} 
58. \} 
59. fwrite(data\_y,width\*height,1,fp); 
60. fwrite(data\_u,uv\_width\*uv\_height,1,fp); 
61. fwrite(data\_v,uv\_width\*uv\_height,1,fp); 
62. fclose(fp); 
63. free(data\_y); 
64. free(data\_u); 
65. free(data\_v); 
66. return 0; 
67. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_graybar(640, 360,0,255,10,"graybar\_640x360.yuv");

从源代码可以看出，本程序一方面通过灰阶测试图的亮度最小值ymin，亮度最大值ymax，灰阶数量barnum确定每一个灰度条中像素的亮度分量Y的取值。另一方面还要根据图像的宽度width和图像的高度height以及灰阶数量barnum确定每一个灰度条的宽度。有了这两方面信息之后，就可以生成相应的图片了。上述调用函数的代码运行后，会生成一个取值范围从0-255，一共包含10个灰度条的YUV420P格式的测试图。测试图的内容如下所示。

![20160117233318275][]

从程序也可以得到从左到右10个灰度条的Y、U、V取值，如下所示。

### (7)计算两个YUV420P像素数据的PSNR ###

PSNR是最基本的视频质量评价方法。本程序中的函数可以对比两张YUV图片中亮度分量Y的PSNR。函数的代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Calculate PSNR between 2 YUV420P file
3. \* @param url1 Location of first Input YUV file.
4. \* @param url2 Location of another Input YUV file.
5. \* @param w Width of Input YUV file.
6. \* @param h Height of Input YUV file.
7. \* @param num Number of frames to process.
8. \*/
9. int simplest\_yuv420\_psnr(char \*url1,char \*url2,int w,int h,int num)\{ 
10. FILE \*fp1=fopen(url1,"rb+"); 
11. FILE \*fp2=fopen(url2,"rb+"); 
12. unsigned char \*pic1=(unsigned char \*)malloc(w\*h); 
13. unsigned char \*pic2=(unsigned char \*)malloc(w\*h); 
14. 
15. for(int i=0;i<num;i++)\{ 
16. fread(pic1,1,w\*h,fp1); 
17. fread(pic2,1,w\*h,fp2); 
18. 
19. double mse\_sum=0,mse=0,psnr=0; 
20. for(int j=0;j<w\*h;j++)\{ 
21. mse\_sum+=pow((double)(pic1\[j\]-pic2\[j\]),2); 
22. \} 
23. mse=mse\_sum/(w\*h); 
24. psnr=10\*log10(255.0\*255.0/mse); 
25. printf("%5.3f\\n",psnr); 
26. 
27. fseek(fp1,w\*h/2,SEEK\_CUR); 
28. fseek(fp2,w\*h/2,SEEK\_CUR); 
29. 
30. \} 
31. 
32. free(pic1); 
33. free(pic2); 
34. fclose(fp1); 
35. fclose(fp2); 
36. return 0; 
37. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_yuv420\_psnr("lena\_256x256\_yuv420p.yuv","lena\_distort\_256x256\_yuv420p.yuv",256,256,1);

对于8bit量化的像素数据来说，PSNR的计算公式如下所示。

![20160117233527240][]

上述公式中mse的计算公式如下所示。

![20160117233543104][]

其中M，N分别为图像的宽高，xij和yij分别为两张图像的每一个像素值。PSNR通常用于质量评价，就是计算受损图像与原始图像之间的差别，以此来评价受损图像的质量。本程序输入的两张图像的对比图如下图所示。其中左边的图像为原始图像，右边的图像为受损图像。

![20160117233618041][]

经过程序计算后得到的PSNR取值为26.693。PSNR取值通常情况下都在20-50的范围内，取值越高，代表两张图像越接近，反映出受损图像质量越好。

### (8) 分离RGB24像素数据中的R、G、B分量 ###

本程序中的函数可以将RGB24数据中的R、G、B三个分量分离开来并保存成三个文件。函数的代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Split R, G, B planes in RGB24 file.
3. \* @param url Location of Input RGB file.
4. \* @param w Width of Input RGB file.
5. \* @param h Height of Input RGB file.
6. \* @param num Number of frames to process.
7. \*
8. \*/
9. int simplest\_rgb24\_split(char \*url, int w, int h,int num)\{ 
10. FILE \*fp=fopen(url,"rb+"); 
11. FILE \*fp1=fopen("output\_r.y","wb+"); 
12. FILE \*fp2=fopen("output\_g.y","wb+"); 
13. FILE \*fp3=fopen("output\_b.y","wb+"); 
14. 
15. unsigned char \*pic=(unsigned char \*)malloc(w\*h\*3); 
16. 
17. for(int i=0;i<num;i++)\{ 
18. 
19. fread(pic,1,w\*h\*3,fp); 
20. 
21. for(int j=0;j<w\*h\*3;j=j+3)\{ 
22. //R
23. fwrite(pic+j,1,1,fp1); 
24. //G
25. fwrite(pic+j+1,1,1,fp2); 
26. //B
27. fwrite(pic+j+2,1,1,fp3); 
28. \} 
29. \} 
30. 
31. free(pic); 
32. fclose(fp); 
33. fclose(fp1); 
34. fclose(fp2); 
35. fclose(fp3); 
36. 
37. return 0; 
38. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_rgb24\_split("cie1931\_500x500.rgb", 500, 500,1);

从代码可以看出，与YUV420P三个分量分开存储不同，RGB24格式的每个像素的三个分量是连续存储的。一帧宽高分别为w、h的RGB24图像一共占用w\*h\*3 Byte的存储空间。RGB24格式规定首先存储第一个像素的R、G、B，然后存储第二个像素的R、G、B…以此类推。类似于YUV420P的存储方式称为Planar方式，而类似于RGB24的存储方式称为Packed方式。上述调用函数的代码运行后，将会把一张分辨率为500x500的名称为cie1931\_500x500.rgb的RGB24格式的像素数据文件分离成为三个文件：

> output\_r.y：R数据，分辨率为256x256。  
> output\_g.y：G数据，分辨率为256x256。
> 
> output\_b.y：B数据，分辨率为256x256。

输入的原图是一张标准的CIE 1931色度图。该色度图右下为红色，上方为绿色，左下为蓝色，如下所示。

![20160117233802920][]

R数据图像如下所示。

![20160117233815619][]

G数据图像如下所示。

![20160117233828210][]

B数据图像如下所示。

![20160117233838071][]

### (9)将RGB24格式像素数据封装为BMP图像 ###

BMP图像内部实际上存储的就是RGB数据。本程序实现了对RGB像素数据的封装处理。通过本程序中的函数，可以将RGB数据封装成为一张BMP图像。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Convert RGB24 file to BMP file
3. \* @param rgb24path Location of input RGB file.
4. \* @param width Width of input RGB file.
5. \* @param height Height of input RGB file.
6. \* @param url\_out Location of Output BMP file.
7. \*/
8. int simplest\_rgb24\_to\_bmp(constchar \*rgb24path,int width,int height,constchar \*bmppath)\{ 
9. typedefstruct
10. \{ 
11. long imageSize; 
12. long blank; 
13. long startPosition; 
14. \}BmpHead; 
15. 
16. typedefstruct
17. \{ 
18. long Length; 
19. long width; 
20. long height; 
21. unsigned short colorPlane; 
22. unsigned short bitColor; 
23. long zipFormat; 
24. long realSize; 
25. long xPels; 
26. long yPels; 
27. long colorUse; 
28. long colorImportant; 
29. \}InfoHead; 
30. 
31. int i=0,j=0; 
32. BmpHead m\_BMPHeader=\{0\}; 
33. InfoHead m\_BMPInfoHeader=\{0\}; 
34. char bfType\[2\]=\{ 'B','M'\}; 
35. int header\_size=sizeof(bfType)+sizeof(BmpHead)+sizeof(InfoHead); 
36. unsigned char \*rgb24\_buffer=NULL; 
37. FILE \*fp\_rgb24=NULL,\*fp\_bmp=NULL; 
38. 
39. if((fp\_rgb24=fopen(rgb24path,"rb"))==NULL)\{ 
40. printf("Error: Cannot open input RGB24 file.\\n"); 
41. return \-1; 
42. \} 
43. if((fp\_bmp=fopen(bmppath,"wb"))==NULL)\{ 
44. printf("Error: Cannot open output BMP file.\\n"); 
45. return \-1; 
46. \} 
47. 
48. rgb24\_buffer=(unsigned char \*)malloc(width\*height\*3); 
49. fread(rgb24\_buffer,1,width\*height\*3,fp\_rgb24); 
50. 
51. m\_BMPHeader.imageSize=3\*width\*height+header\_size; 
52. m\_BMPHeader.startPosition=header\_size; 
53. 
54. m\_BMPInfoHeader.Length=sizeof(InfoHead); 
55. m\_BMPInfoHeader.width=width; 
56. //BMP storage pixel data in opposite direction of Y-axis (from bottom to top).
57. m\_BMPInfoHeader.height=-height; 
58. m\_BMPInfoHeader.colorPlane=1; 
59. m\_BMPInfoHeader.bitColor=24; 
60. m\_BMPInfoHeader.realSize=3\*width\*height; 
61. 
62. fwrite(bfType,1,sizeof(bfType),fp\_bmp); 
63. fwrite(&m\_BMPHeader,1,sizeof(m\_BMPHeader),fp\_bmp); 
64. fwrite(&m\_BMPInfoHeader,1,sizeof(m\_BMPInfoHeader),fp\_bmp); 
65. 
66. //BMP save R1|G1|B1,R2|G2|B2 as B1|G1|R1,B2|G2|R2
67. //It saves pixel data in Little Endian
68. //So we change 'R' and 'B'
69. for(j =0;j<height;j++)\{ 
70. for(i=0;i<width;i++)\{ 
71. char temp=rgb24\_buffer\[(j\*width+i)\*3+2\]; 
72. rgb24\_buffer\[(j\*width+i)\*3+2\]=rgb24\_buffer\[(j\*width+i)\*3+0\]; 
73. rgb24\_buffer\[(j\*width+i)\*3+0\]=temp; 
74. \} 
75. \} 
76. fwrite(rgb24\_buffer,3\*width\*height,1,fp\_bmp); 
77. fclose(fp\_rgb24); 
78. fclose(fp\_bmp); 
79. free(rgb24\_buffer); 
80. printf("Finish generate %s!\\n",bmppath); 
81. return 0; 
82. return 0; 
83. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_rgb24\_to\_bmp("lena\_256x256\_rgb24.rgb",256,256,"output\_lena.bmp");

通过代码可以看出，改程序完成了主要完成了两个工作：  
 1)将RGB数据前面加上文件头。  
 2)将RGB数据中每个像素的“B”和“R”的位置互换。

BMP文件是由BITMAPFILEHEADER、BITMAPINFOHEADER、RGB像素数据共3个部分构成，它的结构如下图所示。

<table style="width:780px;"> 
 <tbody> 
 <tr> 
 <td>BITMAPFILEHEADER</td> 
 </tr> 
 <tr> 
 <td>BITMAPINFOHEADER</td> 
 </tr> 
 <tr> 
 <td>RGB像素数据</td> 
 </tr> 
 </tbody> 
</table>

其中前两部分的结构如下所示。在写入BMP文件头的时候给其中的每个字段赋上合适的值就可以了。

**\[cpp\]** [view plain][] [copy][view plain]

1.  typedefstruct tagBITMAPFILEHEADER 
2.  \{ 
3.  unsigned shortint bfType; //位图文件的类型，必须为BM 
4.  unsigned long bfSize; //文件大小，以字节为单位
5.  unsigned shortint bfReserverd1; //位图文件保留字，必须为0 
6.  unsigned shortint bfReserverd2; //位图文件保留字，必须为0 
7.  unsigned long bfbfOffBits; //位图文件头到数据的偏移量，以字节为单位
8.  \}BITMAPFILEHEADER; 
9.  typedefstruct tagBITMAPINFOHEADER 
10. \{ 
11. long biSize; //该结构大小，字节为单位
12. long biWidth; //图形宽度以象素为单位
13. long biHeight; //图形高度以象素为单位
14. shortint biPlanes; //目标设备的级别，必须为1 
15. shortint biBitcount; //颜色深度，每个象素所需要的位数
16. shortint biCompression; //位图的压缩类型
17. long biSizeImage; //位图的大小，以字节为单位
18. long biXPelsPermeter; //位图水平分辨率，每米像素数
19. long biYPelsPermeter; //位图垂直分辨率，每米像素数
20. long biClrUsed; //位图实际使用的颜色表中的颜色数
21. long biClrImportant; //位图显示过程中重要的颜色数
22. \}BITMAPINFOHEADER;

BMP采用的是小端（Little Endian）存储方式。这种存储方式中“RGB24”格式的像素的分量存储的先后顺序为B、G、R。由于RGB24格式存储的顺序是R、G、B，所以需要将“R”和“B”顺序作一个调换再进行存储。

下图为输入的RGB24格式的图像lena\_256x256\_rgb24.rgb。

![20160117234249036][]

下图分封装为BMP格式后的图像output\_lena.bmp。封装后的图像使用普通的看图软件就可以查看。

![20160117234306638][]

### (10)将RGB24格式像素数据转换为YUV420P格式像素数据 ###

本程序中的函数可以将RGB24格式的像素数据转换为YUV420P格式的像素数据。函数的代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. unsigned char clip\_value(unsigned char x,unsigned char min\_val,unsigned char max\_val)\{ 
2. if(x>max\_val)\{ 
3. return max\_val; 
4. \}elseif(x<min\_val)\{ 
5. return min\_val; 
6. \}else\{ 
7. return x; 
8. \} 
9. \} 
10. 
11. //RGB to YUV420
12. bool RGB24\_TO\_YUV420(unsigned char \*RgbBuf,int w,int h,unsigned char \*yuvBuf) 
13. \{ 
14. unsigned char\*ptrY, \*ptrU, \*ptrV, \*ptrRGB; 
15. memset(yuvBuf,0,w\*h\*3/2); 
16. ptrY = yuvBuf; 
17. ptrU = yuvBuf + w\*h; 
18. ptrV = ptrU + (w\*h\*1/4); 
19. unsigned char y, u, v, r, g, b; 
20. for (int j = 0; j<h;j++)\{ 
21. ptrRGB = RgbBuf + w\*j\*3 ; 
22. for (int i = 0;i<w;i++)\{ 
23. 
24. r = \*(ptrRGB++); 
25. g = \*(ptrRGB++); 
26. b = \*(ptrRGB++); 
27. y = (unsigned char)( ( 66 \* r + 129 \* g + 25 \* b + 128) >> 8) + 16 ; 
28. u = (unsigned char)( ( -38 \* r - 74 \* g + 112 \* b + 128) >> 8) + 128 ; 
29. v = (unsigned char)( ( 112 \* r - 94 \* g - 18 \* b + 128) >> 8) + 128 ; 
30. \*(ptrY++) = clip\_value(y,0,255); 
31. if (j%2==0&&i%2 ==0)\{ 
32. \*(ptrU++) =clip\_value(u,0,255); 
33. \} 
34. else\{ 
35. if (i%2==0)\{ 
36. \*(ptrV++) =clip\_value(v,0,255); 
37. \} 
38. \} 
39. \} 
40. \} 
41. returntrue; 
42. \} 
43. 
44. /\*\*
45. \* Convert RGB24 file to YUV420P file
46. \* @param url\_in Location of Input RGB file.
47. \* @param w Width of Input RGB file.
48. \* @param h Height of Input RGB file.
49. \* @param num Number of frames to process.
50. \* @param url\_out Location of Output YUV file.
51. \*/
52. int simplest\_rgb24\_to\_yuv420(char \*url\_in, int w, int h,int num,char \*url\_out)\{ 
53. FILE \*fp=fopen(url\_in,"rb+"); 
54. FILE \*fp1=fopen(url\_out,"wb+"); 
55. 
56. unsigned char \*pic\_rgb24=(unsigned char \*)malloc(w\*h\*3); 
57. unsigned char \*pic\_yuv420=(unsigned char \*)malloc(w\*h\*3/2); 
58. 
59. for(int i=0;i<num;i++)\{ 
60. fread(pic\_rgb24,1,w\*h\*3,fp); 
61. RGB24\_TO\_YUV420(pic\_rgb24,w,h,pic\_yuv420); 
62. fwrite(pic\_yuv420,1,w\*h\*3/2,fp1); 
63. \} 
64. 
65. free(pic\_rgb24); 
66. free(pic\_yuv420); 
67. fclose(fp); 
68. fclose(fp1); 
69. 
70. return 0; 
71. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_rgb24\_to\_yuv420("lena\_256x256\_rgb24.rgb",256,256,1,"output\_lena.yuv");

从源代码可以看出，本程序实现了RGB到YUV的转换公式：

Y= 0.299\*R+0.587\*G+0.114\*B

U=-0.147\*R-0.289\*G+0.463\*B

V= 0.615\*R-0.515\*G-0.100\*B

在转换的过程中有以下几点需要注意：  
 1) RGB24存储方式是Packed，YUV420P存储方式是Packed。  
 2) U，V在水平和垂直方向的取样数是Y的一半

转换前的RGB24格式像素数据lena\_256x256\_rgb24.rgb的内容如下所示。

![20160117234455936][]

转换后的YUV420P格式的像素数据output\_lena.yuv的内容如下所示。

![20160117234519667][]

### (11)生成RGB24格式的彩条测试图 ###

本程序中的函数可以生成一张RGB24格式的彩条测试图。函数代码如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1. /\*\*
2. \* Generate RGB24 colorbar.
3. \* @param width Width of Output RGB file.
4. \* @param height Height of Output RGB file.
5. \* @param url\_out Location of Output RGB file.
6. \*/
7. int simplest\_rgb24\_colorbar(int width, int height,char \*url\_out)\{ 
8. 
9. unsigned char \*data=NULL; 
10. int barwidth; 
11. char filename\[100\]=\{0\}; 
12. FILE \*fp=NULL; 
13. int i=0,j=0; 
14. 
15. data=(unsigned char \*)malloc(width\*height\*3); 
16. barwidth=width/8; 
17. 
18. if((fp=fopen(url\_out,"wb+"))==NULL)\{ 
19. printf("Error: Cannot create file!"); 
20. return \-1; 
21. \} 
22. 
23. for(j=0;j<height;j++)\{ 
24. for(i=0;i<width;i++)\{ 
25. int barnum=i/barwidth; 
26. switch(barnum)\{ 
27. case 0:\{ 
28. data\[(j\*width+i)\*3+0\]=255; 
29. data\[(j\*width+i)\*3+1\]=255; 
30. data\[(j\*width+i)\*3+2\]=255; 
31. break; 
32. \} 
33. case 1:\{ 
34. data\[(j\*width+i)\*3+0\]=255; 
35. data\[(j\*width+i)\*3+1\]=255; 
36. data\[(j\*width+i)\*3+2\]=0; 
37. break; 
38. \} 
39. case 2:\{ 
40. data\[(j\*width+i)\*3+0\]=0; 
41. data\[(j\*width+i)\*3+1\]=255; 
42. data\[(j\*width+i)\*3+2\]=255; 
43. break; 
44. \} 
45. case 3:\{ 
46. data\[(j\*width+i)\*3+0\]=0; 
47. data\[(j\*width+i)\*3+1\]=255; 
48. data\[(j\*width+i)\*3+2\]=0; 
49. break; 
50. \} 
51. case 4:\{ 
52. data\[(j\*width+i)\*3+0\]=255; 
53. data\[(j\*width+i)\*3+1\]=0; 
54. data\[(j\*width+i)\*3+2\]=255; 
55. break; 
56. \} 
57. case 5:\{ 
58. data\[(j\*width+i)\*3+0\]=255; 
59. data\[(j\*width+i)\*3+1\]=0; 
60. data\[(j\*width+i)\*3+2\]=0; 
61. break; 
62. \} 
63. case 6:\{ 
64. data\[(j\*width+i)\*3+0\]=0; 
65. data\[(j\*width+i)\*3+1\]=0; 
66. data\[(j\*width+i)\*3+2\]=255; 
67. 
68. break; 
69. \} 
70. case 7:\{ 
71. data\[(j\*width+i)\*3+0\]=0; 
72. data\[(j\*width+i)\*3+1\]=0; 
73. data\[(j\*width+i)\*3+2\]=0; 
74. break; 
75. \} 
76. \} 
77. 
78. \} 
79. \} 
80. fwrite(data,width\*height\*3,1,fp); 
81. fclose(fp); 
82. free(data); 
83. 
84. return 0; 
85. \}

调用上面函数的方法如下所示。

**\[cpp\]** [view plain][] [copy][view plain]

1.  simplest\_rgb24\_colorbar(640, 360,"colorbar\_640x360.rgb");

从源代码可以看出，本程序循环输出“白黄青绿品红蓝黑”8种颜色的彩条。这8种颜色的彩条的R、G、B取值如下所示。

生成的图像截图如下所示。

![20160117234659993][]

## 下载 ##

Simplest mediadata test

项目主页

SourceForge：[https://sourceforge.net/projects/simplest-mediadata-test/][https_sourceforge.net_projects_simplest-mediadata-test]

Github：[https://github.com/leixiaohua1020/simplest\_mediadata\_test][https_github.com_leixiaohua1020_simplest_mediadata_test]

开源中国： [http://git.oschina.net/leixiaohua1020/simplest\_mediadata\_test][http_git.oschina.net_leixiaohua1020_simplest_mediadata_test]

CSDN下载地址： [http://download.csdn.net/detail/leixiaohua1020/9422409][http_download.csdn.net_detail_leixiaohua1020_9422409]  
  
本项目包含如下几种视音频数据解析示例：  
 (1)像素数据处理程序。包含RGB和YUV像素格式处理的函数。  
 (2)音频采样数据处理程序。包含PCM音频采样格式处理的函数。  
 (3)H.264码流分析程序。可以分离并解析NALU。  
 (4)AAC码流分析程序。可以分离并解析ADTS帧。  
 (5)FLV封装格式分析程序。可以将FLV中的MP3音频码流分离出来。

(6)UDP-RTP协议分析程序。可以将分析UDP/RTP/MPEG-TS数据包

[RGB_YUV]: http://blog.csdn.net/leixiaohua1020/article/details/50534150
[PCM]: http://blog.csdn.net/leixiaohua1020/article/details/50534316
[H.264]: http://blog.csdn.net/leixiaohua1020/article/details/50534369
[AAC]: http://blog.csdn.net/leixiaohua1020/article/details/50535042
[FLV]: http://blog.csdn.net/leixiaohua1020/article/details/50535082
[UDP-RTP]: http://blog.csdn.net/leixiaohua1020/article/details/50535230
[Link 1]: http://blog.csdn.net/leixiaohua1020/article/details/18893769
[20160118002918690]: /images/20220527/157d06ed220943a690637f98d8bb12f0.png
[YUV Player Deluxe]: http://www.yuvplayer.com/
[YUV_RGB]: http://blog.csdn.net/leixiaohua1020/article/details/50466201
[view plain]: https://blog.csdn.net/leixiaohua1020/article/details/50534150#
[20160117232415153]: /images/20220527/225da517b2054f46a438c0bebb75c137.png
[20160117232435874]: /images/20220527/a570e1cacb2542fd842cf305456ad731.png
[20160117232500394]: https://img-blog.csdn.net/20160117232500394
[20160117232505751]: /images/20220527/d8bb275dd92d45809f4188834fe23a25.png
[20160117232650727]: /images/20220527/9a66532ea04f495f8d9f8f111fa5541c.png
[20160117232704546]: /images/20220527/1b76eb78c79b4434af8fc39cca16dea2.png
[20160117232711011]: /images/20220527/43fef288747844ff95ba5009b04725b8.png
[20160117232719517]: /images/20220527/eacf5a1c67f342d99c864a3ddd92b754.png
[20160117232856722]: /images/20220527/1fb0034cee7f46c6a08ba757a34cf62a.png
[20160117232913602]: /images/20220527/e092a6f73f3c4e16b4ea07f6b3d71ca7.png
[20160117233038584]: /images/20220527/712d08ab6fac4c439d42264cf08b1f22.png
[20160117233049307]: /images/20220527/ba0e9c819f444308a056eeafb3bbec03.png
[20160117233158395]: /images/20220527/40623d30ced445fa98ee083f1aa9da11.png
[20160117233215510]: /images/20220527/695c8e1f423c46f3b9277687effe9a22.png
[20160117233318275]: /images/20220527/f7d2d24ce8564d779f9dfc471805a39e.png
[20160117233527240]: /images/20220527/29ba9be3b58f4fa8a06bfd6d821bbb7b.png
[20160117233543104]: /images/20220527/1fc9efee6df1479ea10f382c96f89655.png
[20160117233618041]: /images/20220527/9c131ea9b15b45038129fadb25281ba0.png
[20160117233802920]: /images/20220527/5aaa79ec537f42d890722c0c739e0224.png
[20160117233815619]: /images/20220527/d34292f5c81a4c4eaa84e0a4d51253b5.png
[20160117233828210]: /images/20220527/15f13f66ec9b4729a7f85dd1139ece04.png
[20160117233838071]: /images/20220527/d2ce1bf27180403c8714525b1a7ab1e0.png
[20160117234249036]: /images/20220527/cfd30a98842a4bfeac1e326959a7a9e5.png
[20160117234306638]: /images/20220527/992e243ec5e541b59b3753fe68612ecc.png
[20160117234455936]: /images/20220527/e7caa2b5e7a04455a000b6777a55c277.png
[20160117234519667]: /images/20220527/7010add2c1844729878b7fc69e1c5126.png
[20160117234659993]: /images/20220527/f6b895f2b159408aaec26fcbedac36b2.png
[https_sourceforge.net_projects_simplest-mediadata-test]: https://sourceforge.net/projects/simplest-mediadata-test/
[https_github.com_leixiaohua1020_simplest_mediadata_test]: https://github.com/leixiaohua1020/simplest_mediadata_test
[http_git.oschina.net_leixiaohua1020_simplest_mediadata_test]: http://git.oschina.net/leixiaohua1020/simplest_mediadata_test
[http_download.csdn.net_detail_leixiaohua1020_9422409]: http://download.csdn.net/detail/leixiaohua1020/9422409