关于视频H264编解码的应用实现

　

h264编码

http://blog.csdn.net/scalerzhangjie/article/details/8273410

项目要用到视频编解码，最近半个月都在搞，说实话真是走了很多弯路，浪费了很多时间。将自己的最终成果记录于此，期望会给其他人提供些许帮助。

参考教程：

http://ffmpeg.org/trac/ffmpeg/wiki/ubuntuCompilationGuide安装ffmpeg和x264，官方权威教程（注意不要用命令行安装，会少很多库的。编译安装最保险）

http://blog.csdn.net/zgyulongfei/article/details/7526249采集与编码的教程

http://www.cnblogs.com/fojian/archive/2012/09/01/2666627.html编码的好文章

http://my.oschina.net/u/555701/blog/56616?p=2#comments-解码的好文章

整体过程流程如下：

显而易见，整个过程分为三个部分：采集、编码、解码。

1.采集视频

我是利用USB摄像头采集视频的，我的摄像头只支持YUV422格式的图像采集，因为x264编码库只能编码YUV420P(planar)格式，因此在采集到yuv422格式的图像数据后要变换成yuv420p格式。

采集视频使用官方的那个采集程序，稍加修改即可，具体点说就是修改

static void process_image (const char * p) ;函数

参数p指向一帧采集图像的yuv数据。

关于YUV格式和RGB格式，网上有很多教程。

在这儿，我讲一下自己的理解。

假设有一幅4*4分辨率的图片，如下：

1	2	3	4
5	6	7	8
9	10	11	12
13	14	15	16

每个像素是由YUV数据构成，假设如下：

Y1	U1	V1	Y2	U2	V2	Y3	U3	V3	Y4	U4	V4
Y5	U5	V5	Y6	U6	V6	Y7	U7	V7	Y8	U8	V8
Y9	U9	V9	Y10	U10	V10	Y11	U11	V11	Y12	U12	V12
Y13	U13	V13	Y14	U14	V14	Y15	U15	V15	Y16	U16	V16

YUV422图像是这样的，每个像素采集Y，UV每隔两个像素采集一次：

Packed格式的YUV420是这样的，每个像素采集Y，UV隔行采集，每行是每两个像素采集一次：

以上几种格式存储就是按照从左到右，从上到下顺序存储的。

我想要得到是planar格式的YUV420，即在一段连续的内存中，先存储所有的Y，接着是所有的U，最后是所有的V。

修改后的process_image函数如下：

[cpp]view plaincopy

1. staticvoid
2. process_image(constchar*p)
3. {
4. //fputc('.',stdout);
5. //convertyuv422toyuv420p
6. char*y=yuv420p;
7. char*u=&yuv420p[IMAGE_WIDTH*IMAGE_HEIGHT];
8. char*v=&yuv420p[IMAGE_WIDTH*IMAGE_HEIGHT+IMAGE_WIDTH*IMAGE_HEIGHT/4];
10. inti=0,j=0,l=0;
11. for(j=0;j<IMAGE_HEIGHT;j++)
12. for(i=0;i<IMAGE_WIDTH*2;i++,l++){
14. if(j%2==0){//evenlinetosampleU-Chriminance
15. if(l==1){//sampleU-Chriminance
16. *u=p[j*IMAGE_WIDTH*2+i];
17. u++;
18. }
19. elseif(l==3){//abandonV-Chroma
20. l=-1;
21. continue;
23. }
24. else{
25. *y=p[j*IMAGE_WIDTH*2+i];
26. ++y;
27. }
28. }
30. elseif(j%2==1){//oddlinestosampleV-Chroma
31. if(l==1){
32. continue;
33. }
34. elseif(l==3){
35. l=-1;
36. *v=p[j*IMAGE_WIDTH*2+i];
37. ++v;
38. }
39. else{
40. *y=p[j*IMAGE_WIDTH*2+i];
41. ++y;
42. }
44. }
46. }
48. fwrite(yuv420p,IMAGE_WIDTH*IMAGE_HEIGHT*3>>1,1,fp_yuv420p);
50. fflush(stdout);
52. }

2.编码

采用x264编码库编码yuv420p文件。

程序如下：

[cpp]view plaincopy

1. #include<stdint.h>
2. #include<x264.h>
3. #include<stdio.h>
4. #include<unistd.h>
5. #include<fcntl.h>
6. #include<stdlib.h>
7. #include<string.h>
9. #definedEBUG0
11. #defineCLEAR(x)(memset((&x),0,sizeof(x)))
12. #defineIMAGE_WIDTH320
13. #defineIMAGE_HEIGHT240
14. #defineENCODER_PRESET"veryfast"
15. #defineENCODER_TUNE"zerolatency"
16. #defineENCODER_profile"baseline"
17. #defineENCODER_colorSPACEX264_CSP_I420
19. typedefstructmy_x264_encoder{
20. x264_param_t*x264_parameter;
21. charparameter_preset[20];
22. charparameter_tune[20];
23. charparameter_profile[20];
24. x264_t*x264_encoder;
25. x264_picture_t*yuv420p_picture;
26. longcolorspace;
27. unsignedchar*yuv;
28. x264_nal_t*nal;
29. }my_x264_encoder;
31. char*read_filename="yuv420p.yuv";
32. char*write_filename="encode.h264";
34. int
35. main(intargc,char**argv){
36. intret;
37. intfd_read,fd_write;
38. my_x264_encoder*encoder=(my_x264_encoder*)malloc(sizeof(my_x264_encoder));
39. if(!encoder){
40. printf("cannotmallocmy_x264_encoder!\n");
41. exit(EXIT_FAILURE);
42. }
43. CLEAR(*encoder);
46. /****************************************************************************
47. *Advancedparameterhandlingfunctions
48. ****************************************************************************/
50. /*Thesefunctionsexposethefullpowerofx264'spreset-tune-profilesystemfor
51. *easyadjustmentoflargenumbers//free(encoder->yuv420p_picture);ofinternalparameters.
52. *
53. *Inordertoreplicatex264CLI'soptionhandling,thesefunctionsMUSTbecalled
54. *inthefollowingorder:
55. *1)x264_param_default_preset
56. *2)Customuseroptions(viaparam_parseordirectlyassignedvariables)
57. *3)x264_param_APPly_fastfirstpass
58. *4)x264_param_apply_profile
59. *
60. *Additionally,x264CLIdoesnotapplystep3ifthepresetchosenis"placebo"
61. *or--slow-firstpassisset.*/
62. strcpy(encoder->parameter_preset,ENCODER_PRESET);
63. strcpy(encoder->parameter_tune,ENCODER_TUNE);
65. encoder->x264_parameter=(x264_param_t*)malloc(sizeof(x264_param_t));
66. if(!encoder->x264_parameter){
67. printf("mallocx264_parameterERROR!\n");
68. exit(EXIT_FAILURE);
69. }
70. CLEAR(*(encoder->x264_parameter));
71. x264_param_default(encoder->x264_parameter);
73. if((ret=x264_param_default_preset(encoder->x264_parameter,encoder->parameter_preset,encoder->parameter_tune))<0){
74. printf("x264_param_default_preseterror!\n");
75. exit(EXIT_FAILURE);
76. }
78. encoder->x264_parameter->i_fps_den=1;
79. encoder->x264_parameter->i_fps_num=25;
80. encoder->x264_parameter->i_width=IMAGE_WIDTH;
81. encoder->x264_parameter->i_height=IMAGE_HEIGHT;
82. encoder->x264_parameter->i_threads=1;
83. encoder->x264_parameter->i_keyint_max=25;
84. encoder->x264_parameter->b_intra_refresh=1;
85. encoder->x264_parameter->b_annexb=1;
87. strcpy(encoder->parameter_profile,ENCODER_PROFILE);
88. if((ret=x264_param_apply_profile(encoder->x264_parameter,encoder->parameter_profile))<0){
89. printf("x264_param_apply_profileerror!\n");
90. exit(EXIT_FAILURE);
91. }
93. #ifDEBUG
94. printf("Line--------%d\n",__LINE__);
95. #endif
97. encoder->x264_encoder=x264_encoder_open(encoder->x264_parameter);
99. encoder->colorspace=ENCODER_COLORSPACE;
101. #ifDEBUG
102. printf("Line--------%d\n",__LINE__);
103. #endif
105. encoder->yuv420p_picture=(x264_picture_t*)malloc(sizeof(x264_picture_t));
106. if(!encoder->yuv420p_picture){
107. printf("mallocencoder->yuv420p_pictureerror!\n");
108. exit(EXIT_FAILURE);
109. }
110. if((ret=x264_picture_alloc(encoder->yuv420p_picture,encoder->colorspace,IMAGE_WIDTH,IMAGE_HEIGHT))<0){
111. printf("ret=%d\n",ret);
112. printf("x264_picture_allocerror!\n");
113. exit(EXIT_FAILURE);
114. }
116. encoder->yuv420p_picture->img.i_csp=encoder->colorspace;
117. encoder->yuv420p_picture->img.i_plane=3;
118. encoder->yuv420p_picture->i_type=X264_TYPE_AUTO;
122. #ifDEBUG
123. printf("Line--------%d\n",__LINE__);
124. #endif
126. encoder->yuv=(uint8_t*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*3/2);
127. if(!encoder->yuv){
128. printf("mallocyuverror!\n");
129. exit(EXIT_FAILURE);
130. }
131. CLEAR(*(encoder->yuv));
133. #ifDEBUG
134. printf("Line--------%d\n",__LINE__);
135. #endif
137. encoder->yuv420p_picture->img.plane[0]=encoder->yuv;
138. encoder->yuv420p_picture->img.plane[1]=encoder->yuv+IMAGE_WIDTH*IMAGE_HEIGHT;
139. encoder->yuv420p_picture->img.plane[2]=encoder->yuv+IMAGE_WIDTH*IMAGE_HEIGHT+IMAGE_WIDTH*IMAGE_HEIGHT/4;
141. if((fd_read=open(read_filename,O_RDONLY))<0){
142. printf("cannotopeninputfile!\n");
143. exit(EXIT_FAILURE);
144. }
146. if((fd_write=open(write_filename,O_WRONLY|O_append|O_CREAT,0777))<0){
147. printf("cannotopenoutputfile!\n");
148. exit(EXIT_FAILURE);
149. }
151. #ifDEBUG
152. printf("Line--------%d\n",__LINE__);
153. #endif
154. intn_nal;
155. x264_picture_tpic_out;
156. x264_nal_t*my_nal;
157. encoder->nal=(x264_nal_t*)malloc(sizeof(x264_nal_t));
158. if(!encoder->nal){
159. printf("mallocx264_nal_terror!\n");
160. exit(EXIT_FAILURE);
161. }
162. CLEAR(*(encoder->nal));
164. while(read(fd_read,encoder->yuv,IMAGE_WIDTH*IMAGE_HEIGHT*3/2)>0){
165. encoder->yuv420p_picture->i_pts++;
166. if((ret=x264_encoder_encode(encoder->x264_encoder,&encoder->nal,&n_nal,encoder->yuv420p_picture,&pic_out))<0){
167. printf("x264_encoder_encodeerror!\n");
168. exit(EXIT_FAILURE);
169. }
171. unsignedintlength=0;
172. for(my_nal=encoder->nal;my_nal<encoder->nal+n_nal;++my_nal){
173. write(fd_write,my_nal->p_payload,my_nal->i_payload);
174. length+=my_nal->i_payload;
175. }
176. printf("length=%d\n",length);
177. }
179. /*clean_upfunctions*/
180. //x264_picture_clean(encoder->yuv420p_picture);
181. //free(encoder->nal);//????confusedconflictwithx264_encoder_close(encoder->x264_encoder);
183. free(encoder->yuv);
184. free(encoder->yuv420p_picture);
185. free(encoder->x264_parameter);
186. x264_encoder_close(encoder->x264_encoder);
187. free(encoder);
188. close(fd_read);
189. close(fd_write);
191. return0;
192. }

3.解码

利用ffmpeg进行解码

程序如下：

[cpp]view plaincopy

1. #include<stdio.h>
2. #include<string.h>
3. #include<stdlib.h>
4. #include<fcntl.h>
5. #include<unistd.h>
6. #include<libavcodec/avcodec.h>
7. #include<libavformat/avformat.h>
8. #include<libavutil/mathematics.h>
10. #defineDECODED_OUTPUT_FORMATAV_PIX_FMT_YUV420P
11. #defineINPUT_FILE_NAME"encode.h264"
12. #defineOUTPUT_FILE_NAME"decode.yuv"
13. #defineIMAGE_WIDTH320
14. #defineIMAGE_HEIGHT240
16. void
17. error_handle(constchar*errorInfo){
18. printf("%serror!\n",errorInfo);
19. exit(EXIT_FAILURE);
20. }
23. int
24. main(intargc,char**argv){
25. intwrite_fd,ret,videoStream;
26. AVFormatcontext*formatContext=NULL;
27. AVCodec*codec;
28. AVCodecContext*codecContext;
29. AVFrame*decodedFrame;
30. AVPacketpacket;
31. uint8_t*decodedBuffer;
32. unsignedintdecodedBufferSize;
33. intfinishedFrame;
36. av_register_all();
39. write_fd=open(OUTPUT_FILE_NAME,O_RDWR|O_CREAT,0666);
40. if(write_fd<0){
41. perror("open");
42. exit(1);
43. }
45. ret=avformat_open_input(&formatContext,INPUT_FILE_NAME,NULL,NULL);
46. if(ret<0)
47. error_handle("avformat_open_inputerror");
49. ret=avformat_find_stream_info(formatContext,NULL);
50. if(ret<0)
51. error_handle("av_find_stream_info");
54. videoStream=0;
55. codecContext=formatContext->streams[videoStream]->codec;
57. codec=avcodec_find_decoder(AV_CODEC_ID_H264);
58. if(codec==NULL)
59. error_handle("avcodec_find_decodererror!\n");
61. ret=avcodec_open2(codecContext,codec,NULL);
62. if(ret<0)
63. error_handle("avcodec_open2");
65. decodedFrame=avcodec_alloc_frame();
66. if(!decodedFrame)
67. error_handle("avcodec_alloc_frame!");
69. decodedBufferSize=avpicture_get_size(DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT);
70. decodedBuffer=(uint8_t*)malloc(decodedBufferSize);
71. if(!decodedBuffer)
72. error_handle("mallocdecodedBuffererror!");
74. av_init_packet(&packet);
75. while(av_read_frame(formatContext,&packet)>=0){
76. ret=avcodec_decode_video2(codecContext,decodedFrame,&finishedFrame,&packet);
77. if(ret<0)
78. error_handle("avcodec_decode_video2error!");
79. if(finishedFrame){
80. avpicture_layout((AVPicture*)decodedFrame,DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT,decodedBuffer,decodedBufferSize);
81. ret=write(write_fd,decodedBuffer,decodedBufferSize);
82. if(ret<0)
83. error_handle("writeyuvstreamerror!");
84. }
86. av_free_packet(&packet);
87. }
89. while(1){
90. packet.data=NULL;
91. packet.size=0;
92. ret=avcodec_decode_video2(codecContext,decodedFrame,&finishedFrame,&packet);
93. if(ret<=0&&(finishedFrame<=0))
94. break;
95. if(finishedFrame){
96. avpicture_layout((AVPicture*)decodedFrame,DECODED_OUTPUT_FORMAT,IMAGE_WIDTH,IMAGE_HEIGHT,decodedBuffer,decodedBufferSize);
97. ret=write(write_fd,decodedBuffer,decodedBufferSize);
98. if(ret<0)
99. error_handle("writeyuvstreamerror!");
100. }
102. av_free_packet(&packet);
103. }
106. avformat_close_input(&formatContext);
107. free(decodedBuffer);
108. av_free(decodedFrame);
109. avcodec_close(codecContext);
111. return0;
112. }

结果：

1.利用USB摄像头采集的YUV420P，大小11.0MB，可以用pyuv播放器正常播放。

2.编码后的文件encode.h264，大小262.4kb，可用vlc播放器正常播放。

3.解码后的文件decode.yuv，大小11.0MB，可以用pyuv播放器正常播放。

相关文件在我的资源里，里面包含：

1.采集、编码、解码程序、对应的可执行程序和makefile文件；

2.Pyuv播放器（用于XP）

3. 实验文件-yuv420p.yuv 、encode.h264、 decode.yuv

4. 相关参考文档pdf版本

欢迎批评指正！

相关阅读

【人人早报】568期：多亏李世石的不懈努力，AlphaGo 的命

导读香港科技大学计算机科学硕士，中国科学技术大学科技与战略风云学会研究员，新浪围棋 6D。本文首发于“观察者”，原标题为“ 陈经：

Python 方法重载

python的方法重载有些特殊，在python中，如下的代码并不能实现方法重载： def Aa():     pass def Aa(a):     print(1) def

如何解决浏览网页出现http404错误问题

我最近发现一个问题，在浏览我经常浏览的一些网站时，浏览器总是提示http 404错误，无法找到文件。起初，以为是该网站在进行日常维护，打开

What is CRA?

What is CRA? 什么是CRA？ 众所周知，sensor的效能与sensor

x264源码分析-threads参数

sprintf( s, " threads=%d", p->i_threads );最大值128 X264_THREAD_MAX。如果没有设置threads参数，x264根据当前CPU核数以及slice