FFmpeg简介

古城微笑少年丶 2022-07-26 11:07 215阅读 0赞

**认识FFmpeg**

FFMPEG堪称自由软件中最完备的一套多媒体支持库，它几乎实现了所有当下常见的数据封装格式、多媒体传输协议以及音视频编解码器。因此，对于从事多媒体技术开发的工程师来说，深入研究FFMPEG成为一门必不可少的工作，可以这样说，FFMPEG之于多媒体开发工程师的重要性正如kernel之于嵌入式系统工程师一般。

几个小知识：

*  FFMPEG项目是由法国人Fabrice Bellard发起的，此人也是著名的CPU模拟器项目QEMU的发起者，同时还是 [圆周率算法纪录][Link 1]的保持者。
 *  FF是Fast Forward的意思，翻译成中文是“快进”。
 *  [FFMPEG的LOGO][FFMPEG_LOGO]是一个”Z字扫描”示意图，Z字扫描用于将图像的二维频域数据一维化，同时保证了一维化的数据具备良好的统计特性，从而提高其后要进行的一维熵编码的效率。

关于耻辱柱（Hall of Shame）：FFMpeg大部分代码遵循LGPL许可证，如果使用者对FFMpeg进行了修改，要求公布修改的源代码；有少部分代码遵循GPL许可证，要求使用者同时公开使用FFMpeg的软件的源代码。实际上，除去部分大的系统软件开发商（Microsoft、Apple等）以及某些著名的音视频服务提供商（Divx、Real等）提供的自有播放器之外，绝大部分第三方开发的播放器都离不开FFMpeg的支持，像Linux桌面环境中的开源播放器VLC、MPlayer，Windows下的KMPlayer、暴风影音以及Android下几乎全部第三方播放器都是基于FFMpeg的。也有许多看似具备自主技术的播放器，其实也都不声不响地使用了FFMpeg，这种行为被称为“盗窃”，参与“盗窃”的公司的名字则被刻在[耻辱柱][Link 2]上，国产播放器暴风影音、QQ影音于2009年上榜。

示例程序

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

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1. \#include <stdio.h>  
2. \#include <string.h>  
3. \#include <stdlib.h>  
4.    
5. \#include <sys/time.h>  
6.    
7. \#include "libavutil/avstring.h"  
8. \#include "libavformat/avformat.h"  
9. \#include "libavdevice/avdevice.h"  
10. \#include "libavutil/opt.h"  
11. \#include "libswscale/swscale.h"  
12.    
13. \#define DECODED\_AUDIO\_BUFFER\_SIZE            192000  
14.    
15. **struct** options  
16. \{  
17.     **int** streamId;  
18.     **int** frames;  
19.     **int** nodec;  
20.     **int** bplay;  
21.     **int** thread\_count;  
22.     int64\_t lstart;  
23.     **char** finput\[256\];  
24.     **char** foutput1\[256\];  
25.     **char** foutput2\[256\];  
26. \};  
27.    
28. **int** parse\_options(**struct** options \*opts, **int** argc, **char**\*\* argv)  
29. \{  
30.     **int** optidx;  
31.     **char** \*optstr;  
32.    
33.     **if** (argc < 2) **return** -1;  
34.    
35.     opts->streamId = -1;  
36.     opts->lstart = -1;  
37.     opts->frames = -1;  
38.     opts->foutput1\[0\] = 0;  
39.     opts->foutput2\[0\] = 0;  
40.     opts->nodec = 0;  
41.     opts->bplay = 0;  
42.     opts->thread\_count = 0;  
43.     strcpy(opts->finput, argv\[1\]);  
44.    
45.     optidx = 2;  
46.     **while** (optidx < argc)  
47.     \{  
48.         optstr = argv\[optidx++\];  
49.         **if** (\*optstr++ != '-') **return** -1;  
50.         **switch** (\*optstr++)  
51.         \{  
52.         **case** 's':  //< stream id  
53.             opts->streamId = atoi(optstr);  
54.             **break**;  
55.         **case** 'f':  //< frames  
56.             opts->frames = atoi(optstr);  
57.             **break**;  
58.         **case** 'k':  //< skipped  
59.             opts->lstart = atoll(optstr);  
60.             **break**;  
61.         **case** 'o':  //< output  
62.             strcpy(opts->foutput1, optstr);  
63.             strcat(opts->foutput1, ".mpg");  
64.             strcpy(opts->foutput2, optstr);  
65.             strcat(opts->foutput2, ".raw");  
66.             **break**;  
67.         **case** 'n': //decoding and output options  
68.             **if** (strcmp("dec", optstr) == 0)  
69.                 opts->nodec = 1;  
70.             **break**;  
71.         **case** 'p':  
72.             opts->bplay = 1;  
73.             **break**;  
74.         **case** 't':  
75.             opts->thread\_count = atoi(optstr);  
76.             **break**;  
77.         **default**:  
78.             **return** -1;  
79.         \}  
80.     \}  
81.    
82.     **return** 0;  
83. \}  
84.    
85. **void** show\_help(**char**\* program)  
86. \{  
87.     printf("Simple FFMPEG test program\\n");  
88.     printf("Usage: %s inputfile \[-sstreamid \[-fframes\] \[-kskipped\] \[-ooutput\_filename(without extension)\] \[-ndec\] \[-p\] \[-tthread\_count\]\]\\n",  
89.            program);  
90.     **return**;  
91. \}  
92.    
93. **static** **void** log\_callback(**void**\* ptr, **int** level, **const** **char**\* fmt, **va\_list** vl)  
94. \{  
95.     vfprintf(stdout, fmt, vl);  
96. \}  
97.    
98. /\* 
99. \* audio renderer code (oss) 
100. \*/  
101. \#include <sys/ioctl.h>  
102. \#include <unistd.h>  
103. \#include <fcntl.h>  
104. \#include <sys/soundcard.h>  
105.    
106. \#define OSS\_DEVICE "/dev/dsp0"  
107.    
108. **struct** audio\_dsp  
109. \{  
110.     **int** audio\_fd;  
111.     **int** channels;  
112.     **int** format;  
113.     **int** speed;  
114. \};  
115. **int** map\_formats(**enum** AVSampleFormat format)  
116. \{  
117.     **switch**(format)  
118.     \{  
119.         **case** AV\_SAMPLE\_FMT\_U8:  
120.             **return** AFMT\_U8;  
121.         **case** AV\_SAMPLE\_FMT\_S16:  
122.             **return** AFMT\_S16\_LE;  
123.         **default**:  
124.             **return** AFMT\_U8;   
125.     \}  
126. \}  
127. **int** set\_audio(**struct** audio\_dsp\* dsp)  
128. \{  
129.     **if** (dsp->audio\_fd == -1)  
130.     \{  
131.         printf("Invalid audio dsp id!\\n");  
132.         **return** -1;  
133.     \}      
134.    
135.     **if** (-1 == ioctl(dsp->audio\_fd, SNDCTL\_DSP\_SETFMT, &dsp->format))  
136.     \{  
137.         printf("Failed to set dsp format!\\n");  
138.         **return** -1;  
139.     \}  
140.    
141.     **if** (-1 == ioctl(dsp->audio\_fd, SNDCTL\_DSP\_CHANNELS, &dsp->channels))  
142.     \{  
143.         printf("Failed to set dsp format!\\n");  
144.         **return** -1;  
145.     \}  
146.    
147.     **if** (-1 == ioctl(dsp->audio\_fd, SNDCTL\_DSP\_SPEED, &dsp->speed))  
148.     \{  
149.         printf("Failed to set dsp format!\\n");  
150.         **return** -1;  
151.     \}      
152.     **return** 0;  
153. \}  
154.    
155. **int** play\_pcm(**struct** audio\_dsp\* dsp, unsigned **char** \*buf, **int** size)  
156. \{  
157.     **if** (dsp->audio\_fd == -1)  
158.     \{  
159.         printf("Invalid audio dsp id!\\n");  
160.         **return** -1;  
161.     \}  
162.    
163.     **if** (-1 == write(dsp->audio\_fd, buf, size))  
164.     \{  
165.         printf("Failed to write audio dsp!\\n");  
166.         **return** -1;  
167.     \}  
168.    
169.     **return** 0;  
170. \}  
171. /\* audio renderer code end \*/  
172.    
173. /\* video renderer code\*/  
174. \#include <linux/fb.h>  
175. \#include <sys/mman.h>  
176.    
177. \#define FB\_DEVICE "/dev/fb0"  
178.    
179. **enum** pic\_format  
180. \{  
181.     eYUV\_420\_Planer,  
182. \};  
183. **struct** video\_fb  
184. \{  
185.     **int** video\_fd;  
186.     **struct** fb\_var\_screeninfo vinfo;  
187.     **struct** fb\_fix\_screeninfo finfo;  
188.     unsigned **char** \*fbp;  
189.     AVFrame \*frameRGB;  
190.     **struct**   
191.     \{  
192.         **int** x;  
193.         **int** y;  
194.     \} video\_pos;  
195. \};  
196.    
197. **int** open\_video(**struct** video\_fb \*fb, **int** x, **int** y)  
198. \{  
199.     **int** screensize;  
200.     fb->video\_fd = open(FB\_DEVICE, O\_WRONLY);  
201.     **if** (fb->video\_fd == -1) **return** -1;  
202.    
203.     **if** (ioctl(fb->video\_fd, FBIOGET\_FSCREENINFO, &fb->finfo)) **return** -2;  
204.     **if** (ioctl(fb->video\_fd, FBIOGET\_VSCREENINFO, &fb->vinfo)) **return** -2;  
205.    
206.    
207.     printf("video device: resolution %dx%d, %dbpp\\n", fb->vinfo.xres, fb->vinfo.yres, fb->vinfo.bits\_per\_pixel);  
208.     screensize = fb->vinfo.xres \* fb->vinfo.yres \* fb->vinfo.bits\_per\_pixel / 8;  
209.     fb->fbp = (unsigned **char** \*) mmap(0, screensize, PROT\_READ|PROT\_WRITE, MAP\_SHARED, fb->video\_fd, 0);  
210.     **if** (fb->fbp == -1) **return** -3;  
211.    
212.     **if** (x >= fb->vinfo.xres || y >= fb->vinfo.yres)  
213.     \{  
214.         **return** -4;  
215.     \}  
216.     **else**  
217.     \{  
218.         fb->video\_pos.x = x;  
219.         fb->video\_pos.y = y;  
220.     \}  
221.    
222.     fb->frameRGB = avcodec\_alloc\_frame();  
223.     **if** (!fb->frameRGB) **return** -5;  
224.    
225.     **return** 0;  
226. \}  
227.    
228. /\* only 420P supported now \*/  
229. **int** show\_picture(**struct** video\_fb \*fb, AVFrame \*frame, **int** width, **int** height, **enum** pic\_format format)  
230. \{  
231.     **struct** SwsContext \*sws;  
232.     **int** i;  
233.     unsigned **char** \*dest;  
234.     unsigned **char** \*src;  
235.    
236.     **if** (fb->video\_fd == -1) **return** -1;  
237.     **if** ((fb->video\_pos.x >= fb->vinfo.xres) || (fb->video\_pos.y >= fb->vinfo.yres)) **return** -2;  
238.    
239.     **if** (fb->video\_pos.x + width > fb->vinfo.xres)  
240.     \{  
241.         width = fb->vinfo.xres - fb->video\_pos.x;  
242.     \}  
243.     **if** (fb->video\_pos.y + height > fb->vinfo.yres)  
244.     \{  
245.         height = fb->vinfo.yres - fb->video\_pos.y;  
246.     \}  
247.    
248.     **if** (format == PIX\_FMT\_YUV420P)  
249.     \{  
250.         sws = sws\_getContext(width, height, format, width, height, PIX\_FMT\_RGB32, SWS\_FAST\_BILINEAR, NULL, NULL, NULL);  
251.         **if** (sws == 0)  
252.         \{  
253.             **return** -3;  
254.         \}  
255.         **if** (sws\_scale(sws, frame->data, frame->linesize, 0, height, fb->frameRGB->data, fb->frameRGB->linesize))  
256.         \{  
257.             **return** -3;  
258.         \}  
259.    
260.         dest = fb->fbp + (fb->video\_pos.x+fb->vinfo.xoffset) \* (fb->vinfo.bits\_per\_pixel/8) +(fb->video\_pos.y+fb->vinfo.yoffset) \* fb->finfo.line\_length;  
261.         **for** (i = 0; i < height; i++)  
262.         \{  
263.             memcpy(dest, src, width\*4);  
264.             src += fb->frameRGB->linesize\[0\];  
265.             dest += fb->finfo.line\_length;  
266.         \}  
267.     \}  
268.     **return** 0;  
269. \}  
270.    
271. **void** close\_video(**struct** video\_fb \*fb)  
272. \{  
273.     **if** (fb->video\_fd != -1)   
274.     \{  
275.         munmap(fb->fbp, fb->vinfo.xres \* fb->vinfo.yres \* fb->vinfo.bits\_per\_pixel / 8);  
276.         close(fb->video\_fd);  
277.         fb->video\_fd = -1;  
278.     \}  
279. \}  
280. /\* video renderer code end \*/  
281.    
282. **int** main(**int** argc, **char** \*\*argv)  
283. \{  
284.     AVFormatContext\* pCtx = 0;  
285.     AVCodecContext \*pCodecCtx = 0;  
286.     AVCodec \*pCodec = 0;  
287.     AVPacket packet;  
288.     AVFrame \*pFrame = 0;  
289.     **FILE** \*fpo1 = NULL;  
290.     **FILE** \*fpo2 = NULL;  
291.     **int** nframe;  
292.     **int** err;  
293.     **int** got\_picture;  
294.     **int** picwidth, picheight, linesize;  
295.     unsigned **char** \*pBuf;  
296.     **int** i;  
297.     int64\_t timestamp;  
298.     **struct** options opt;  
299.     **int** usefo = 0;  
300.     **struct** audio\_dsp dsp;  
301.     **struct** video\_fb fb;  
302.     **int** dusecs;  
303.     **float** usecs1 = 0;  
304.     **float** usecs2 = 0;  
305.     **struct** timeval elapsed1, elapsed2;  
306.     **int** decoded = 0;  
307.    
308.     av\_register\_all();  
309.    
310.     av\_log\_set\_callback(log\_callback);  
311.     av\_log\_set\_level(50);  
312.    
313.     **if** (parse\_options(&opt, argc, argv) < 0 || (strlen(opt.finput) == 0))  
314.     \{  
315.         show\_help(argv\[0\]);  
316.         **return** 0;  
317.     \}  
318.    
319.    
320.     err = avformat\_open\_input(&pCtx, opt.finput, 0, 0);  
321.     **if** (err < 0)  
322.     \{  
323.         printf("\\n->(avformat\_open\_input)\\tERROR:\\t%d\\n", err);  
324.         **goto** fail;  
325.     \}  
326.     err = avformat\_find\_stream\_info(pCtx, 0);  
327.     **if** (err < 0)  
328.     \{  
329.         printf("\\n->(avformat\_find\_stream\_info)\\tERROR:\\t%d\\n", err);  
330.         **goto** fail;  
331.     \}  
332.     **if** (opt.streamId < 0)  
333.     \{  
334.         av\_dump\_format(pCtx, 0, pCtx->filename, 0);  
335.         **goto** fail;  
336.     \}  
337.     **else**  
338.     \{  
339.         printf("\\n extra data in Stream %d (%dB):", opt.streamId, pCtx->streams\[opt.streamId\]->codec->extradata\_size);  
340.         **for** (i = 0; i < pCtx->streams\[opt.streamId\]->codec->extradata\_size; i++)  
341.         \{  
342.             **if** (i%16 == 0) printf("\\n");  
343.             printf("%2x  ", pCtx->streams\[opt.streamId\]->codec->extradata\[i\]);  
344.         \}  
345.     \}  
346.     /\* try opening output files \*/  
347.     **if** (strlen(opt.foutput1) && strlen(opt.foutput2))  
348.     \{  
349.         fpo1 = fopen(opt.foutput1, "wb");  
350.         fpo2 = fopen(opt.foutput2, "wb");  
351.         **if** (!fpo1 || !fpo2)  
352.         \{  
353.             printf("\\n->error opening output files\\n");  
354.             **goto** fail;  
355.         \}  
356.         usefo = 1;  
357.     \}  
358.     **else**  
359.     \{  
360.         usefo = 0;  
361.     \}  
362.    
363.     **if** (opt.streamId >= pCtx->nb\_streams)  
364.     \{  
365.         printf("\\n->StreamId\\tERROR\\n");  
366.         **goto** fail;  
367.     \}  
368.    
369.     **if** (opt.lstart > 0)  
370.     \{  
371.         err = av\_seek\_frame(pCtx, opt.streamId, opt.lstart, AVSEEK\_FLAG\_ANY);  
372.         **if** (err < 0)  
373.         \{  
374.             printf("\\n->(av\_seek\_frame)\\tERROR:\\t%d\\n", err);  
375.             **goto** fail;  
376.         \}  
377.     \}  
378.    
379.     /\* for decoder configuration \*/  
380.     **if** (!opt.nodec)  
381.     \{  
382.         /\* prepare codec \*/  
383.         pCodecCtx = pCtx->streams\[opt.streamId\]->codec;  
384.    
385.         **if** (opt.thread\_count <= 16 && opt.thread\_count > 0 )  
386.         \{  
387.             pCodecCtx->thread\_count = opt.thread\_count;  
388.             pCodecCtx->thread\_type = FF\_THREAD\_FRAME;  
389.         \}  
390.         pCodec = avcodec\_find\_decoder(pCodecCtx->codec\_id);  
391.         **if** (!pCodec)  
392.         \{  
393.             printf("\\n->can not find codec!\\n");  
394.             **goto** fail;  
395.         \}  
396.         err = avcodec\_open2(pCodecCtx, pCodec, 0);  
397.         **if** (err < 0)  
398.         \{  
399.             printf("\\n->(avcodec\_open)\\tERROR:\\t%d\\n", err);  
400.             **goto** fail;  
401.         \}  
402.         pFrame = avcodec\_alloc\_frame();          
403.    
404.         /\* prepare device \*/  
405.         **if** (opt.bplay)  
406.         \{  
407.             /\* audio devices \*/  
408.             dsp.audio\_fd = open(OSS\_DEVICE, O\_WRONLY);  
409.             **if** (dsp.audio\_fd == -1)  
410.             \{  
411.                 printf("\\n-> can not open audio device\\n");  
412.                 **goto** fail;  
413.             \}  
414.             dsp.channels = pCodecCtx->channels;  
415.             dsp.speed = pCodecCtx->sample\_rate;  
416.             dsp.format = map\_formats(pCodecCtx->sample\_fmt);  
417.             **if** (set\_audio(&dsp) < 0)  
418.             \{  
419.                 printf("\\n-> can not set audio device\\n");  
420.                 **goto** fail;  
421.             \}  
422.             /\* video devices \*/  
423.             **if** (open\_video(&fb, 0, 0) != 0)  
424.             \{  
425.                 printf("\\n-> can not open video device\\n");  
426.                 **goto** fail;  
427.             \}  
428.         \}  
429.     \}  
430.    
431.     nframe = 0;  
432.     **while**(nframe < opt.frames || opt.frames == -1)  
433.     \{  
434.         gettimeofday(&elapsed1, NULL);  
435.         err = av\_read\_frame(pCtx, &packet);  
436.         **if** (err < 0)  
437.         \{  
438.             printf("\\n->(av\_read\_frame)\\tERROR:\\t%d\\n", err);  
439.             **break**;  
440.         \}  
441.         gettimeofday(&elapsed2, NULL);  
442.         dusecs = (elapsed2.tv\_sec - elapsed1.tv\_sec)\*1000000 + (elapsed2.tv\_usec - elapsed1.tv\_usec);  
443.         usecs2 += dusecs;          
444.         timestamp = av\_rescale\_q(packet.dts, pCtx->streams\[packet.stream\_index\]->time\_base, (AVRational)\{1, AV\_TIME\_BASE\});  
445.         printf("\\nFrame No %5d stream\#%d\\tsize %6dB, timestamp:%6lld, dts:%6lld, pts:%6lld, ", nframe++, packet.stream\_index, packet.size,   
446.                timestamp, packet.dts, packet.pts);  
447.    
448.         **if** (packet.stream\_index == opt.streamId)  
449.         \{  
450. \#if 0   
451.             **for** (i = 0; i < 16; /\*packet.size;\*/ i++)  
452.             \{  
453.                 **if** (i%16 == 0) printf("\\n pktdata: ");  
454.                 printf("%2x  ", packet.data\[i\]);  
455.             \}  
456.             printf("\\n");  
457. \#endif              
458.             **if** (usefo)  
459.             \{  
460.                 fwrite(packet.data, packet.size, 1, fpo1);  
461.                 fflush(fpo1);  
462.             \}  
463.    
464.             **if** (pCtx->streams\[opt.streamId\]->codec->codec\_type == AVMEDIA\_TYPE\_VIDEO && !opt.nodec)  
465.             \{  
466.                 picheight = pCtx->streams\[opt.streamId\]->codec->height;  
467.                 picwidth = pCtx->streams\[opt.streamId\]->codec->width;  
468.    
469.                 gettimeofday(&elapsed1, NULL);   
470.                 avcodec\_decode\_video2(pCodecCtx, pFrame, &got\_picture, &packet);  
471.                 decoded++;  
472.                 gettimeofday(&elapsed2, NULL);  
473.                 dusecs = (elapsed2.tv\_sec - elapsed1.tv\_sec)\*1000000 + (elapsed2.tv\_usec - elapsed1.tv\_usec);  
474.                 usecs1 += dusecs;  
475.    
476.                 **if** (got\_picture)  
477.                 \{  
478.                     printf("\[Video: type %d, ref %d, pts %lld, pkt\_pts %lld, pkt\_dts %lld\]",   
479.                             pFrame->pict\_type, pFrame->reference, pFrame->pts, pFrame->pkt\_pts, pFrame->pkt\_dts);  
480.    
481.                     **if** (pCtx->streams\[opt.streamId\]->codec->pix\_fmt == PIX\_FMT\_YUV420P)  
482.                     \{  
483.                         **if** (usefo)  
484.                         \{  
485.                             linesize = pFrame->linesize\[0\];  
486.                             pBuf = pFrame->data\[0\];  
487.                             **for** (i = 0; i < picheight; i++)  
488.                             \{  
489.                                 fwrite(pBuf, picwidth, 1, fpo2);  
490.                                 pBuf += linesize;  
491.                             \}  
492.    
493.                             linesize = pFrame->linesize\[1\];  
494.                             pBuf = pFrame->data\[1\];  
495.                             **for** (i = 0; i < picheight/2; i++)  
496.                             \{  
497.                                 fwrite(pBuf, picwidth/2, 1, fpo2);  
498.                                 pBuf += linesize;  
499.                             \}             
500.    
501.                             linesize = pFrame->linesize\[2\];  
502.                             pBuf = pFrame->data\[2\];  
503.                             **for** (i = 0; i < picheight/2; i++)  
504.                             \{  
505.                                 fwrite(pBuf, picwidth/2, 1, fpo2);  
506.                                 pBuf += linesize;  
507.                             \}    
508.                             fflush(fpo2);  
509.                         \}   
510.    
511.                         **if** (opt.bplay)  
512.                         \{  
513.                             /\* show picture \*/  
514.                             show\_picture(&fb, pFrame, picheight, picwidth, PIX\_FMT\_YUV420P);  
515.                         \}  
516.                     \}  
517.                 \}  
518.                 av\_free\_packet(&packet);  
519.             \}  
520.             **else** **if** (pCtx->streams\[opt.streamId\]->codec->codec\_type == AVMEDIA\_TYPE\_AUDIO && !opt.nodec)  
521.             \{  
522.                 **int** got;  
523.    
524.                 gettimeofday(&elapsed1, NULL);  
525.                 avcodec\_decode\_audio4(pCodecCtx, pFrame, &got, &packet);  
526.                 decoded++;  
527.                 gettimeofday(&elapsed2, NULL);  
528.                 dusecs = (elapsed2.tv\_sec - elapsed1.tv\_sec)\*1000000 + (elapsed2.tv\_usec - elapsed1.tv\_usec);  
529.                 usecs1 += dusecs;  
530.    
531.                 **if** (got)  
532.                 \{  
533.                     printf("\[Audio: %5dB raw data, decoding time: %d\]", pFrame->linesize\[0\], dusecs);  
534.                     **if** (usefo)  
535.                     \{  
536.                         fwrite(pFrame->data\[0\],  pFrame->linesize\[0\], 1, fpo2);  
537.                         fflush(fpo2);  
538.                     \}  
539.                     **if** (opt.bplay)  
540.                     \{  
541.                         play\_pcm(&dsp, pFrame->data\[0\],  pFrame->linesize\[0\]);  
542.                     \}  
543.                 \}  
544.             \}  
545.         \}  
546.     \}    
547.    
548.     **if** (!opt.nodec && pCodecCtx)  
549.     \{  
550.         avcodec\_close(pCodecCtx);  
551.     \}  
552.    
553.     printf("\\n%d frames parsed, average %.2f us per frame\\n", nframe, usecs2/nframe);  
554.     printf("%d frames decoded, average %.2f us per frame\\n", decoded, usecs1/decoded);  
555.    
556. fail:  
557.     **if** (pCtx)  
558.     \{  
559.         avformat\_close\_input(&pCtx);  
560.     \}  
561.     **if** (fpo1)  
562.     \{  
563.         fclose(fpo1);  
564.     \}  
565.     **if** (fpo2)  
566.     \{  
567.         fclose(fpo2);  
568.     \}  
569.     **if** (!pFrame)  
570.     \{  
571.         av\_free(pFrame);  
572.     \}  
573.     **if** (!usefo && (dsp.audio\_fd != -1))  
574.     \{  
575.         close(dsp.audio\_fd);  
576.     \}  
577.     **if** (!usefo && (fb.video\_fd != -1))  
578.     \{  
579.         close\_video(&fb);  
580.     \}  
581.     **return** 0;  
582. \}

这一小段代码可以实现的功能包括：

*  打开一个多媒体文件并获取基本的媒体信息。
 *  获取编码器句柄。
 *  根据给定的时间标签进行一个跳转。
 *  读取数据帧。
 *  解码音频帧或者视频帧。
 *  关闭多媒体文件。

这些功能足以支持一个功能强大的多媒体播放器，因为最复杂的解复用、解码、数据分析过程已经在FFMpeg内部实现了，需要关注的仅剩同步问题。

用户接口

### 数据结构 ###

#### 基本概念 ####

编解码器、数据帧、媒体流和容器是数字媒体处理系统的四个基本概念。

首先需要统一术语：

*  容器／文件（Conainer/File）：即特定格式的多媒体文件。
 *  媒体流（Stream）：指时间轴上的一段连续数据，如一段声音数据，一段视频数据或一段字幕数据，可以是压缩的，也可以是非压缩的，压缩的数据需要关联特定的编解码器。
 *  数据帧／数据包（Frame/Packet）：通常，一个媒体流由大量的数据帧组成，对于压缩数据，帧对应着编解码器的最小处理单元。通常，分属于不同媒体流的数据帧交错复用于容器之中，参见 [交错][Link 3]。
 *  编解码器：编解码器以帧为单位实现压缩数据和原始数据之间的相互转换。

在FFMPEG中，使用AVFormatContext、AVStream、AVCodecContext、AVCodec及AVPacket等结构来抽象这些基本要素，它们的关系如下图所示：[![tech_multimedia_ffmpeg.png][]][tech_multimedia_ffmpeg.png 1]

#### AVCodecContext ####

这是一个描述编解码器上下文的数据结构，包含了众多编解码器需要的参数信息，如下列出了部分比较重要的域：

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

1. **typedef** **struct** AVCodecContext \{  
2.    
3.     ......  
4.    
5.     /\*\* 
6.      \* some codecs need / can use extradata like Huffman tables. 
7.      \* mjpeg: Huffman tables 
8.      \* rv10: additional flags 
9.      \* mpeg4: global headers (they can be in the bitstream or here) 
10.      \* The allocated memory should be FF\_INPUT\_BUFFER\_PADDING\_SIZE bytes larger 
11.      \* than extradata\_size to avoid prolems if it is read with the bitstream reader. 
12.      \* The bytewise contents of extradata must not depend on the architecture or CPU endianness. 
13.      \* - encoding: Set/allocated/freed by libavcodec. 
14.      \* - decoding: Set/allocated/freed by user. 
15.      \*/  
16.     uint8\_t \*extradata;  
17.     **int** extradata\_size;  
18.     /\*\* 
19.      \* This is the fundamental unit of time (in seconds) in terms 
20.      \* of which frame timestamps are represented. For fixed-fps content, 
21.      \* timebase should be 1/framerate and timestamp increments should be 
22.      \* identically 1. 
23.      \* - encoding: MUST be set by user. 
24.      \* - decoding: Set by libavcodec. 
25.      \*/  
26.     AVRational time\_base;  
27.    
28.     /\* video only \*/  
29.     /\*\* 
30.      \* picture width / height. 
31.      \* - encoding: MUST be set by user. 
32.      \* - decoding: Set by libavcodec. 
33.      \* Note: For compatibility it is possible to set this instead of 
34.      \* coded\_width/height before decoding. 
35.      \*/  
36.     **int** width, height;  
37.    
38.     ......  
39.    
40.     /\* audio only \*/  
41.     **int** sample\_rate; ///< samples per second  
42.     **int** channels;    ///< number of audio channels  
43.    
44.     /\*\* 
45.      \* audio sample format 
46.      \* - encoding: Set by user. 
47.      \* - decoding: Set by libavcodec. 
48.      \*/  
49.     **enum** SampleFormat sample\_fmt;  ///< sample format  
50.    
51.     /\* The following data should not be initialized. \*/  
52.     /\*\* 
53.      \* Samples per packet, initialized when calling 'init'. 
54.      \*/  
55.     **int** frame\_size;  
56.     **int** frame\_number;   ///< audio or video frame number  
57.    
58.     ......  
59.    
60.     **char** codec\_name\[32\];  
61.     **enum** AVMediaType codec\_type; /\* see AVMEDIA\_TYPE\_xxx \*/  
62.     **enum** CodecID codec\_id; /\* see CODEC\_ID\_xxx \*/  
63.    
64.     /\*\* 
65.      \* fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). 
66.      \* This is used to work around some encoder bugs. 
67.      \* A demuxer should set this to what is stored in the field used to identify the codec. 
68.      \* If there are multiple such fields in a container then the demuxer should choose the one 
69.      \* which maximizes the information about the used codec. 
70.      \* If the codec tag field in a container is larger then 32 bits then the demuxer should 
71.      \* remap the longer ID to 32 bits with a table or other structure. Alternatively a new 
72.      \* extra\_codec\_tag + size could be added but for this a clear advantage must be demonstrated 
73.      \* first. 
74.      \* - encoding: Set by user, if not then the default based on codec\_id will be used. 
75.      \* - decoding: Set by user, will be converted to uppercase by libavcodec during init. 
76.      \*/  
77.     unsigned **int** codec\_tag;              
78.    
79.     ......  
80.    
81.     /\*\* 
82.      \* Size of the frame reordering buffer in the decoder. 
83.      \* For MPEG-2 it is 1 IPB or 0 low delay IP. 
84.      \* - encoding: Set by libavcodec. 
85.      \* - decoding: Set by libavcodec. 
86.      \*/  
87.     **int** has\_b\_frames;  
88.    
89.     /\*\* 
90.      \* number of bytes per packet if constant and known or 0 
91.      \* Used by some WAV based audio codecs. 
92.      \*/  
93.     **int** block\_align;  
94.    
95.     ......  
96.    
97.     /\*\* 
98.      \* bits per sample/pixel from the demuxer (needed for huffyuv). 
99.      \* - encoding: Set by libavcodec. 
100.      \* - decoding: Set by user. 
101.      \*/  
102.      **int** bits\_per\_coded\_sample;    
103.    
104.      ......  
105.    
106. \} AVCodecContext;

如果是单纯使用libavcodec，这部分信息需要调用者进行初始化；如果是使用整个FFMPEG库，这部分信息在调用avformat\_open\_input和avformat\_find\_stream\_info的过程中根据文件的头信息及媒体流内的头部信息完成初始化。其中几个主要域的释义如下：

1.  extradata/extradata\_size：这个buffer中存放了解码器可能会用到的额外信息，在av\_read\_frame中填充。一般来说，首先，某种具体格式的demuxer在读取格式头信息的时候会填充extradata，其次，如果demuxer没有做这个事情，比如可能在头部压根儿就没有相关的编解码信息，则相应的parser会继续从已经解复用出来的媒体流中继续寻找。在没有找到任何额外信息的情况下，这个buffer指针为空。
2.  time\_base：
3.  width/height：视频的宽和高。
4.  sample\_rate/channels：音频的采样率和信道数目。
5.  sample\_fmt： 音频的原始采样格式。
6.  codec\_name/codec\_type/codec\_id/codec\_tag：编解码器的信息。

#### AVStream ####

该结构体描述一个媒体流，定义如下：

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

1. **typedef** **struct** AVStream \{  
2.     **int** index;    /\*\*< stream index in AVFormatContext \*/  
3.     **int** id;       /\*\*< format-specific stream ID \*/  
4.     AVCodecContext \*codec; /\*\*< codec context \*/  
5.     /\*\* 
6.      \* Real base framerate of the stream. 
7.      \* This is the lowest framerate with which all timestamps can be 
8.      \* represented accurately (it is the least common multiple of all 
9.      \* framerates in the stream). Note, this value is just a guess! 
10.      \* For example, if the time base is 1/90000 and all frames have either 
11.      \* approximately 3600 or 1800 timer ticks, then r\_frame\_rate will be 50/1. 
12.      \*/  
13.     AVRational r\_frame\_rate;  
14.    
15.     ......  
16.    
17.     /\*\* 
18.      \* This is the fundamental unit of time (in seconds) in terms 
19.      \* of which frame timestamps are represented. For fixed-fps content, 
20.      \* time base should be 1/framerate and timestamp increments should be 1. 
21.      \*/  
22.     AVRational time\_base;  
23.    
24.     ......  
25.    
26.     /\*\* 
27.      \* Decoding: pts of the first frame of the stream, in stream time base. 
28.      \* Only set this if you are absolutely 100% sure that the value you set 
29.      \* it to really is the pts of the first frame. 
30.      \* This may be undefined (AV\_NOPTS\_VALUE). 
31.      \* @note The ASF header does NOT contain a correct start\_time the ASF 
32.      \* demuxer must NOT set this. 
33.      \*/  
34.     int64\_t start\_time;  
35.     /\*\* 
36.      \* Decoding: duration of the stream, in stream time base. 
37.      \* If a source file does not specify a duration, but does specify 
38.      \* a bitrate, this value will be estimated from bitrate and file size. 
39.      \*/  
40.     int64\_t duration;  
41.    
42. \#if LIBAVFORMAT\_VERSION\_INT < (53<<16)  
43.     **char** language\[4\]; /\*\* ISO 639-2/B 3-letter language code (empty string if undefined) \*/  
44. \#endif  
45.    
46.     /\* av\_read\_frame() support \*/  
47.     **enum** AVStreamParseType need\_parsing;  
48.     **struct** AVCodecParserContext \*parser;  
49.    
50.     ......  
51.    
52.     /\* av\_seek\_frame() support \*/  
53.     AVIndexEntry \*index\_entries; /\*\*< Only used if the format does not 
54.                                     support seeking natively. \*/  
55.     **int** nb\_index\_entries;  
56.     unsigned **int** index\_entries\_allocated\_size;  
57.    
58.     int64\_t nb\_frames;                 ///< number of frames in this stream if known or 0  
59.    
60.     ......  
61.    
62.     /\*\* 
63.      \* Average framerate 
64.      \*/  
65.     AVRational avg\_frame\_rate;  
66.     ......  
67. \} AVStream;

主要域的释义如下，其中大部分域的值可以由avformat\_open\_input根据文件头的信息确定，缺少的信息需要通过调用avformat\_find\_stream\_info读帧及软解码进一步获取：

1.  index/id：index对应流的索引，这个数字是自动生成的，根据index可以从AVFormatContext::streams表中索引到该流；而id则是流的标识，依赖于具体的容器格式。比如对于MPEG TS格式，id就是pid。
2.  time\_base：流的时间基准，是一个实数，该流中媒体数据的pts和dts都将以这个时间基准为粒度。通常，使用av\_rescale/av\_rescale\_q可以实现不同时间基准的转换。
3.  start\_time：流的起始时间，以流的时间基准为单位，通常是该流中第一个帧的pts。
4.  duration：流的总时间，以流的时间基准为单位。
5.  need\_parsing：对该流parsing过程的控制域。
6.  nb\_frames：流内的帧数目。
7.  r\_frame\_rate/framerate/avg\_frame\_rate：帧率相关。
8.  codec：指向该流对应的AVCodecContext结构，调用avformat\_open\_input时生成。
9.  parser：指向该流对应的AVCodecParserContext结构，调用avformat\_find\_stream\_info时生成。。

#### AVFormatContext ####

这个结构体描述了一个媒体文件或媒体流的构成和基本信息，定义如下：

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

1. **typedef** **struct** AVFormatContext \{  
2.     **const** AVClass \*av\_class; /\*\*< Set by avformat\_alloc\_context. \*/  
3.     /\* Can only be iformat or oformat, not both at the same time. \*/  
4.     **struct** AVInputFormat \*iformat;  
5.     **struct** AVOutputFormat \*oformat;  
6.     **void** \*priv\_data;  
7.     ByteIOContext \*pb;  
8.     unsigned **int** nb\_streams;  
9.     AVStream \*streams\[MAX\_STREAMS\];  
10.     **char** filename\[1024\]; /\*\*< input or output filename \*/  
11.     /\* stream info \*/  
12.     int64\_t timestamp;  
13. \#if LIBAVFORMAT\_VERSION\_INT < (53<<16)  
14.     **char** title\[512\];  
15.     **char** author\[512\];  
16.     **char** copyright\[512\];  
17.     **char** comment\[512\];  
18.     **char** album\[512\];  
19.     **int** year;  /\*\*< ID3 year, 0 if none \*/  
20.     **int** track; /\*\*< track number, 0 if none \*/  
21.     **char** genre\[32\]; /\*\*< ID3 genre \*/  
22. \#endif  
23.    
24.     **int** ctx\_flags; /\*\*< Format-specific flags, see AVFMTCTX\_xx \*/  
25.     /\* private data for pts handling (do not modify directly). \*/  
26.     /\*\* This buffer is only needed when packets were already buffered but 
27.        not decoded, for example to get the codec parameters in MPEG 
28.        streams. \*/  
29.     **struct** AVPacketList \*packet\_buffer;  
30.    
31.     /\*\* Decoding: position of the first frame of the component, in 
32.        AV\_TIME\_BASE fractional seconds. NEVER set this value directly: 
33.        It is deduced from the AVStream values.  \*/  
34.     int64\_t start\_time;  
35.     /\*\* Decoding: duration of the stream, in AV\_TIME\_BASE fractional 
36.        seconds. Only set this value if you know none of the individual stream 
37.        durations and also dont set any of them. This is deduced from the 
38.        AVStream values if not set.  \*/  
39.     int64\_t duration;  
40.     /\*\* decoding: total file size, 0 if unknown \*/  
41.     int64\_t file\_size;  
42.     /\*\* Decoding: total stream bitrate in bit/s, 0 if not 
43.        available. Never set it directly if the file\_size and the 
44.        duration are known as FFmpeg can compute it automatically. \*/  
45.     **int** bit\_rate;  
46.    
47.     /\* av\_read\_frame() support \*/  
48.     AVStream \*cur\_st;  
49. \#if LIBAVFORMAT\_VERSION\_INT < (53<<16)  
50.     **const** uint8\_t \*cur\_ptr\_deprecated;  
51.     **int** cur\_len\_deprecated;  
52.     AVPacket cur\_pkt\_deprecated;  
53. \#endif  
54.    
55.     /\* av\_seek\_frame() support \*/  
56.     int64\_t data\_offset; /\*\* offset of the first packet \*/  
57.     **int** index\_built;  
58.    
59.     **int** mux\_rate;  
60.     unsigned **int** packet\_size;  
61.     **int** preload;  
62.     **int** max\_delay;  
63.    
64. \#define AVFMT\_NOOUTPUTLOOP -1  
65. \#define AVFMT\_INFINITEOUTPUTLOOP 0  
66.     /\*\* number of times to loop output in formats that support it \*/  
67.     **int** loop\_output;  
68.    
69.     **int** flags;  
70. \#define AVFMT\_FLAG\_GENPTS       0x0001 ///< Generate missing pts even if it requires parsing future frames.  
71. \#define AVFMT\_FLAG\_IGNIDX       0x0002 ///< Ignore index.  
72. \#define AVFMT\_FLAG\_NONBLOCK     0x0004 ///< Do not block when reading packets from input.  
73. \#define AVFMT\_FLAG\_IGNDTS       0x0008 ///< Ignore DTS on frames that contain both DTS & PTS  
74. \#define AVFMT\_FLAG\_NOFILLIN     0x0010 ///< Do not infer any values from other values, just return what is stored in the container  
75. \#define AVFMT\_FLAG\_NOPARSE      0x0020 ///< Do not use AVParsers, you also must set AVFMT\_FLAG\_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled  
76. \#define AVFMT\_FLAG\_RTP\_HINT     0x0040 ///< Add RTP hinting to the output file  
77.    
78.     **int** loop\_input;  
79.     /\*\* decoding: size of data to probe; encoding: unused. \*/  
80.     unsigned **int** probesize;  
81.    
82.     /\*\* 
83.      \* Maximum time (in AV\_TIME\_BASE units) during which the input should 
84.      \* be analyzed in avformat\_find\_stream\_info(). 
85.      \*/  
86.     **int** max\_analyze\_duration;  
87.    
88.     **const** uint8\_t \*key;  
89.     **int** keylen;  
90.    
91.     unsigned **int** nb\_programs;  
92.     AVProgram \*\*programs;  
93.    
94.     /\*\* 
95.      \* Forced video codec\_id. 
96.      \* Demuxing: Set by user. 
97.      \*/  
98.     **enum** CodecID video\_codec\_id;  
99.     /\*\* 
100.      \* Forced audio codec\_id. 
101.      \* Demuxing: Set by user. 
102.      \*/  
103.     **enum** CodecID audio\_codec\_id;  
104.     /\*\* 
105.      \* Forced subtitle codec\_id. 
106.      \* Demuxing: Set by user. 
107.      \*/  
108.     **enum** CodecID subtitle\_codec\_id;  
109.    
110.     /\*\* 
111.      \* Maximum amount of memory in bytes to use for the index of each stream. 
112.      \* If the index exceeds this size, entries will be discarded as 
113.      \* needed to maintain a smaller size. This can lead to slower or less 
114.      \* accurate seeking (depends on demuxer). 
115.      \* Demuxers for which a full in-memory index is mandatory will ignore 
116.      \* this. 
117.      \* muxing  : unused 
118.      \* demuxing: set by user 
119.      \*/  
120.     unsigned **int** max\_index\_size;  
121.    
122.     /\*\* 
123.      \* Maximum amount of memory in bytes to use for buffering frames 
124.      \* obtained from realtime capture devices. 
125.      \*/  
126.     unsigned **int** max\_picture\_buffer;  
127.    
128.     unsigned **int** nb\_chapters;  
129.     AVChapter \*\*chapters;  
130.    
131.     /\*\* 
132.      \* Flags to enable debugging. 
133.      \*/  
134.     **int** debug;  
135. \#define FF\_FDEBUG\_TS        0x0001  
136.    
137.     /\*\* 
138.      \* Raw packets from the demuxer, prior to parsing and decoding. 
139.      \* This buffer is used for buffering packets until the codec can 
140.      \* be identified, as parsing cannot be done without knowing the 
141.      \* codec. 
142.      \*/  
143.     **struct** AVPacketList \*raw\_packet\_buffer;  
144.     **struct** AVPacketList \*raw\_packet\_buffer\_end;  
145.    
146.     **struct** AVPacketList \*packet\_buffer\_end;  
147.    
148.     AVMetadata \*metadata;  
149.    
150.     /\*\* 
151.      \* Remaining size available for raw\_packet\_buffer, in bytes. 
152.      \* NOT PART OF PUBLIC API 
153.      \*/  
154. \#define RAW\_PACKET\_BUFFER\_SIZE 2500000  
155.     **int** raw\_packet\_buffer\_remaining\_size;  
156.    
157.     /\*\* 
158.      \* Start time of the stream in real world time, in microseconds 
159.      \* since the unix epoch (00:00 1st January 1970). That is, pts=0 
160.      \* in the stream was captured at this real world time. 
161.      \* - encoding: Set by user. 
162.      \* - decoding: Unused. 
163.      \*/  
164.     int64\_t start\_time\_realtime;  
165. \} AVFormatContext;

这是FFMpeg中最为基本的一个结构，是其他所有结构的根，是一个多媒体文件或流的根本抽象。其中:

*  nb\_streams和streams所表示的AVStream结构指针数组包含了所有内嵌媒体流的描述；
 *  iformat和oformat指向对应的demuxer和muxer指针；
 *  pb则指向一个控制底层数据读写的ByteIOContext结构。
 *  start\_time和duration是从streams数组的各个AVStream中推断出的多媒体文件的起始时间和长度，以微妙为单位。

通常，这个结构由avformat\_open\_input在内部创建并以缺省值初始化部分成员。但是，如果调用者希望自己创建该结构，则需要显式为该结构的一些成员置缺省值——如果没有缺省值的话，会导致之后的动作产生异常。以下成员需要被关注：

*  probesize
 *  mux\_rate
 *  packet\_size
 *  flags
 *  max\_analyze\_duration
 *  key
 *  max\_index\_size
 *  max\_picture\_buffer
 *  max\_delay

#### AVPacket ####

AVPacket定义在avcodec.h中，如下：

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

1. **typedef** **struct** AVPacket \{  
2.     /\*\* 
3.      \* Presentation timestamp in AVStream->time\_base units; the time at which 
4.      \* the decompressed packet will be presented to the user. 
5.      \* Can be AV\_NOPTS\_VALUE if it is not stored in the file. 
6.      \* pts MUST be larger or equal to dts as presentation cannot happen before 
7.      \* decompression, unless one wants to view hex dumps. Some formats misuse 
8.      \* the terms dts and pts/cts to mean something different. Such timestamps 
9.      \* must be converted to true pts/dts before they are stored in AVPacket. 
10.      \*/  
11.     int64\_t pts;  
12.     /\*\* 
13.      \* Decompression timestamp in AVStream->time\_base units; the time at which 
14.      \* the packet is decompressed. 
15.      \* Can be AV\_NOPTS\_VALUE if it is not stored in the file. 
16.      \*/  
17.     int64\_t dts;  
18.     uint8\_t \*data;  
19.     **int**   size;  
20.     **int**   stream\_index;  
21.     **int**   flags;  
22.     /\*\* 
23.      \* Duration of this packet in AVStream->time\_base units, 0 if unknown. 
24.      \* Equals next\_pts - this\_pts in presentation order. 
25.      \*/  
26.     **int**   duration;  
27.     **void**  (\*destruct)(**struct** AVPacket \*);  
28.     **void**  \*priv;  
29.     int64\_t pos;                            ///< byte position in stream, -1 if unknown  
30.    
31.     /\*\* 
32.      \* Time difference in AVStream->time\_base units from the pts of this 
33.      \* packet to the point at which the output from the decoder has converged 
34.      \* independent from the availability of previous frames. That is, the 
35.      \* frames are virtually identical no matter if decoding started from 
36.      \* the very first frame or from this keyframe. 
37.      \* Is AV\_NOPTS\_VALUE if unknown. 
38.      \* This field is not the display duration of the current packet. 
39.      \* 
40.      \* The purpose of this field is to allow seeking in streams that have no 
41.      \* keyframes in the conventional sense. It corresponds to the 
42.      \* recovery point SEI in H.264 and match\_time\_delta in NUT. It is also 
43.      \* essential for some types of subtitle streams to ensure that all 
44.      \* subtitles are correctly displayed after seeking. 
45.      \*/  
46.     int64\_t convergence\_duration;  
47. \} AVPacket;

FFMPEG使用AVPacket来暂存解复用之后、解码之前的媒体数据（一个音/视频帧、一个字幕包等）及附加信息（解码时间戳、显示时间戳、时长等）。其中：

*  dts表示解码时间戳，pts表示显示时间戳，它们的单位是所属媒体流的时间基准。
 *  stream\_index给出所属媒体流的索引；
 *  data为数据缓冲区指针，size为长度；
 *  duration为数据的时长，也是以所属媒体流的时间基准为单位；
 *  pos表示该数据在媒体流中的字节偏移量；
 *  destruct为用于释放数据缓冲区的函数指针；
 *  flags为标志域，其中，最低为置1表示该数据是一个关键帧。

AVPacket结构本身只是个容器，它使用data成员引用实际的数据缓冲区。这个缓冲区通常是由av\_new\_packet创建的，但也可能由FFMPEG的API创建（如av\_read\_frame）。当某个AVPacket结构的数据缓冲区不再被使用时，要需要通过调用av\_free\_packet释放。av\_free\_packet调用的是结构体本身的destruct函数，它的值有两种情况：1)av\_destruct\_packet\_nofree或0；2)av\_destruct\_packet，其中，情况1)仅仅是将data和size的值清0而已，情况2)才会真正地释放缓冲区。

FFMPEG内部使用AVPacket结构建立缓冲区装载数据，同时提供destruct函数，如果FFMPEG打算自己维护缓冲区，则将destruct设为av\_destruct\_packet\_nofree，用户调用av\_free\_packet清理缓冲区时并不能够将其释放；如果FFMPEG打算将该缓冲区彻底交给调用者，则将destruct设为av\_destruct\_packet，表示它能够被释放。安全起见，如果用户希望自由地使用一个FFMPEG内部创建的AVPacket结构，最好调用av\_dup\_packet进行缓冲区的克隆，将其转化为缓冲区能够被释放的AVPacket，以免对缓冲区的不当占用造成异常错误。av\_dup\_packet会为destruct指针为av\_destruct\_packet\_nofree的AVPacket新建一个缓冲区，然后将原缓冲区的数据拷贝至新缓冲区，置data的值为新缓冲区的地址，同时设destruct指针为av\_destruct\_packet。

#### 时间信息 ####

时间信息用于实现多媒体同步。

同步的目的在于展示多媒体信息时，能够保持媒体对象之间固有的时间关系。同步有两类，一类是流内同步，其主要任务是保证单个媒体流内的时间关系，以满足感知要求，如按照规定的帧率播放一段视频；另一类是流间同步，主要任务是保证不同媒体流之间的时间关系，如音频和视频之间的关系（lipsync）。

对于固定速率的媒体，如固定帧率的视频或固定比特率的音频，可以将时间信息（帧率或比特率）置于文件首部（header），如[AVI的hdrl List、MP4的moov box][AVI_hdrl List_MP4_moov box]，还有一种相对复杂的方案是将时间信息嵌入媒体流的内部，如MPEG TS和Real video，这种方案可以处理变速率的媒体，亦可有效避免同步过程中的时间漂移。

FFMPEG会为每一个数据包打上时间标签，以更有效地支持上层应用的同步机制。时间标签有两种，一种是DTS，称为解码时间标签，另一种是PTS，称为显示时间标签。对于声音来说 ，这两个时间标签是相同的，但对于某些视频编码格式，由于采用了双向预测技术，会造成DTS和PTS的不一致。

无双向预测帧的情况：

图像类型: I   P   P   P   P   P   P ...  I   P   P
    DTS:     0   1   2   3   4   5   6...  100 101 102
    PTS:     0   1   2   3   4   5   6...  100 101 102

有双向预测帧的情况：

图像类型: I   P   B   B   P   B   B ...  I   P   B
    DTS:     0   1   2   3   4   5   6 ...  100 101 102
    PTS:     0   3   1   2   6   4   5 ...  100 104 102

对于存在双向预测帧的情况，通常要求解码器对图像重排序，以保证输出的图像顺序为显示顺序：

解码器输入：I   P   B   B   P   B   B
     (DTS)     0   1   2   3   4   5   6  
     (PTS)     0   3   1   2   6   4   5
    解码器输出：X   I   B   B   P   B   B   P
     (PTS)     X   0   1   2   3   4   5   6

**时间信息的获取：**

通过调用avformat\_find\_stream\_info，多媒体应用可以从AVFormatContext对象中拿到媒体文件的时间信息：主要是总时间长度和开始时间，此外还有与时间信息相关的比特率和文件大小。其中时间信息的单位是AV\_TIME\_BASE：微秒。

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

1.  **typedef** **struct** AVFormatContext \{  
2.     
3.      ......  
4.     
5.      /\*\* Decoding: position of the first frame of the component, in 
6.         AV\_TIME\_BASE fractional seconds. NEVER set this value directly: 
7.         It is deduced from the AVStream values.  \*/  
8.      int64\_t start\_time;  
9.      /\*\* Decoding: duration of the stream, in AV\_TIME\_BASE fractional 
10.        seconds. Only set this value if you know none of the individual stream 
11.        durations and also dont set any of them. This is deduced from the 
12.        AVStream values if not set.  \*/  
13.     int64\_t duration;  
14.     /\*\* decoding: total file size, 0 if unknown \*/  
15.     int64\_t file\_size;  
16.     /\*\* Decoding: total stream bitrate in bit/s, 0 if not 
17.        available. Never set it directly if the file\_size and the 
18.        duration are known as FFmpeg can compute it automatically. \*/  
19.     **int** bit\_rate;  
20.    
21.     ......  
22.    
23. \} AVFormatContext;

以上4个成员变量都是只读的，基于FFMpeg的中间件需要将其封装到某个接口中，如：

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

1.  **LONG** GetDuratioin(IntfX\*);  
2.  **LONG** GetStartTime(IntfX\*);  
3.  **LONG** GetFileSize(IntfX\*);  
4.  **LONG** GetBitRate(IntfX\*);

### APIs ###

#### avformat\_open\_input ####

int avformat_open_input(AVFormatContext **ic_ptr, const char *filename, AVInputFormat *fmt, AVDictionary **options);

avformat\_open\_input完成两个任务：

1.  打开一个文件或URL，基于字节流的底层输入模块得到初始化。
2.  解析多媒体文件或多媒体流的头信息，创建AVFormatContext结构并填充其中的关键字段，依次为各个原始流建立AVStream结构。

一个多媒体文件或多媒体流与其包含的原始流的关系如下：

多媒体文件/多媒体流 (movie.mkv)
      原始流 1  (h.264 video)
      原始流 2  (aac audio for Chinese)
      原始流 3  (aac audio for english)
      原始流 4  (Chinese Subtitle)
      原始流 5  (English Subtitle)
      ...

关于输入参数：

*  ic\_ptr，这是一个指向指针的指针，用于返回avformat\_open\_input内部构造的一个AVFormatContext结构体。
 *  filename，指定文件名。
 *  fmt，用于显式指定输入文件的格式，如果设为空则自动判断其输入格式。
 *  options

这个函数通过解析多媒体文件或流的头信息及其他辅助数据，能够获取足够多的关于文件、流和编解码器的信息，但由于任何一种多媒体格式提供的信息都是有限的，而且不同的多媒体内容制作软件对头信息的设置不尽相同，此外这些软件在产生多媒体内容时难免会引入一些错误，因此这个函数并不保证能够获取所有需要的信息，在这种情况下，则需要考虑另一个函数：avformat\_find\_stream\_info。

#### avformat\_find\_stream\_info ####

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);

这个函数主要用于获取必要的编解码器参数，设置到ic→streams\[i\]→codec中。

首先必须得到各媒体流对应编解码器的类型和id，这是两个定义在avutils.h和avcodec.h中的枚举：

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

1. **enum** AVMediaType \{  
2.     AVMEDIA\_TYPE\_UNKNOWN = -1,  
3.     AVMEDIA\_TYPE\_VIDEO,  
4.     AVMEDIA\_TYPE\_AUDIO,  
5.     AVMEDIA\_TYPE\_DATA,  
6.     AVMEDIA\_TYPE\_SUBTITLE,  
7.     AVMEDIA\_TYPE\_ATTACHMENT,  
8.     AVMEDIA\_TYPE\_NB  
9. \};  
10. **enum** CodecID \{  
11.     CODEC\_ID\_NONE,  
12.   
13.     /\* video codecs \*/  
14.     CODEC\_ID\_MPEG1VIDEO,  
15.     CODEC\_ID\_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding  
16.     CODEC\_ID\_MPEG2VIDEO\_XVMC,  
17.     CODEC\_ID\_H261,  
18.     CODEC\_ID\_H263,  
19.     ...  
20. \};

通常，如果某种媒体格式具备完备而正确的头信息，调用avformat\_open\_input即可以得到这两个参数，但若是因某种原因avformat\_open\_input无法获取它们，这一任务将由avformat\_find\_stream\_info完成。

其次还要获取各媒体流对应编解码器的时间基准。

此外，对于音频编解码器，还需要得到：

1.  采样率，
2.  声道数，
3.  位宽，
4.  帧长度（对于某些编解码器是必要的），

对于视频编解码器，则是：

1.  图像大小，
2.  色彩空间及格式，

#### av\_read\_frame ####

int av_read_frame(AVFormatContext *s, AVPacket *pkt);

这个函数用于从多媒体文件或多媒体流中读取媒体数据，获取的数据由AVPacket结构pkt来存放。对于音频数据，如果是固定比特率，则pkt中装载着一个或多个音频帧；如果是可变比特率，则pkt中装载有一个音频帧。对于视频数据，pkt中装载有一个视频帧。需要注意的是：再次调用本函数之前，必须使用av\_free\_packet释放pkt所占用的资源。

通过pkt→stream\_index可以查到获取的媒体数据的类型，从而将数据送交相应的解码器进行后续处理。

#### av\_seek\_frame ####

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags);

这个函数通过改变媒体文件的读写指针来实现对媒体文件的随机访问，支持以下三种方式：

*  基于时间的随机访问：具体而言就是将媒体文件读写指针定位到某个给定的时间点上，则之后调用av\_read\_frame时能够读到时间标签等于给定时间点的媒体数据，通常用于实现媒体播放器的快进、快退等功能。
 *  基于文件偏移的随机访问：相当于普通文件的seek函数，timestamp也成为文件的偏移量。
 *  基于帧号的随机访问：timestamp为要访问的媒体数据的帧号。

关于参数：

*  s：是个AVFormatContext指针，就是avformat\_open\_input返回的那个结构。
 *  stream\_index：指定媒体流，如果是基于时间的随机访问，则第三个参数timestamp将以此媒体流的时间基准为单位；如果设为负数，则相当于不指定具体的媒体流，FFMPEG会按照特定的算法寻找缺省的媒体流，此时，timestamp的单位为AV\_TIME\_BASE（微秒）。
 *  timestamp：时间标签，单位取决于其他参数。
 *  flags：定位方式，AVSEEK\_FLAG\_BYTE表示基于字节偏移，AVSEEK\_FLAG\_FRAME表示基于帧号，其它表示基于时间。

#### av\_close\_input\_file ####

void av_close_input_file(AVFormatContext *s);

关闭一个媒体文件：释放资源，关闭物理IO。

#### avcodec\_find\_decoder ####

AVCodec *avcodec_find_decoder(enum CodecID id);
 AVCodec *avcodec_find_decoder_by_name(const char *name);

根据给定的codec id或解码器名称从系统中搜寻并返回一个AVCodec结构的指针。

#### avcodec\_open ####

int avcodec_open(AVCodecContext *avctx, AVCodec *codec);

此函数根据输入的AVCodec指针具体化AVCodecContext结构。在调用该函数之前，需要首先调用avcodec\_alloc\_context分配一个AVCodecContext结构，或调用avformat\_open\_input获取媒体文件中对应媒体流的AVCodecContext结构；此外还需要通过avcodec\_find\_decoder获取AVCodec结构。

这一函数还将初始化对应的解码器。

#### avcodec\_decode\_video2 ####

int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt);

解码一个视频帧。got\_picture\_ptr指示是否有解码数据输出。

输入数据在AVPacket结构中，输出数据在AVFrame结构中。AVFrame是定义在avcodec.h中的一个数据结构：

typedef struct AVFrame {
 FF_COMMON_FRAME
 } AVFrame;

FF\_COMMON\_FRAME定义了诸多数据域，大部分由FFMpeg内部使用，对于用户来说，比较重要的主要包括：

#define FF_COMMON_FRAME \
 ......
 uint8_t *data[4];\
 int linesize[4];\
 int key_frame;\
 int pict_type;\
 int64_t pts;\ 
 int reference;\ 
 ......

FFMpeg内部以planar的方式存储原始图像数据，即将图像像素分为多个平面（R/G/B或Y/U/V），data数组内的指针分别指向四个像素平面的起始位置，linesize数组则存放各个存贮各个平面的缓冲区的行宽：

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 +++data[0]->#################################++++++++++++
 ++++++++++++###########picture data##########++++++++++++
 ++++++++++++#################################++++++++++++
 ++++++++++++#################################++++++++++++ 
 ........................
 ++++++++++++#################################++++++++++++
 |<-------------------line_size[0]---------------------->|

此外，key\_frame标识该图像是否是关键帧；pict\_type表示该图像的编码类型：I(1)/P(2)/B(3)……；pts是以time\_base为单位的时间标签，对于部分解码器如H.261、H.263和MPEG4，可以从头信息中获取；reference表示该图像是否被用作参考。

#### avcodec\_decode\_audio4 ####

int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt);

解码一个音频帧。输入数据在AVPacket结构中，输出数据在frame中，got\_frame\_ptr表示是否有数据输出。

#### avcodec\_close ####

int avcodec_close(AVCodecContext *avctx);

关闭解码器，释放avcodec\_open中分配的资源。

##### 写系列 #####

写系列API负责将媒体数据以包的形式分发到指定的目标，这个目标可以是一个本地文件、一个RTSP或HTTP流或者其他。

avformat\_alloc\_output\_context2

int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
 const char *format_name, const char *filename);

这个函数负责分配一个用于输出目的的AVFormatContext，输出格式由oformat、format\_name和filename决定，oformat优先级最高，如果oformat为空则依据format\_name，如果format\_name为空则依据filename。

avformat\_write\_header

int avformat_write_header(AVFormatContext *s, AVDictionary **options);

此函数负责产生一个文件头并写入到输出目标中，调用之前，AVFormatContext结构中的oformat、pb必须正确设置，并且streams列表不能为空，列表中各stream的codec参数需要配置正确。

av\_write\_frame

int av_write_frame(AVFormatContext *s, AVPacket *pkt);

此函数负责输出一个媒体包。AVFormatContext参数给出输出目标及媒体流的格式设置，pkt是一个包含媒体数据的结构，其内部成员如dts/pts、stream\_index等必须被正确设置。

av\_interleaved\_write\_frame

int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);

此函数负责交错地输出一个媒体包。如果调用者无法保证来自各个媒体流的包正确交错，则最好调用此函数输出媒体包，反之，可以调用av\_write\_frame以提高性能。

av\_write\_trailer

int av_write_trailer(AVFormatContext *s);

##### 其他 #####

avformat\_new\_stream

AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c);

这个函数负责创建一个AVStream结构，并将其添加到指定的AVFormatContext中，此时，AVStream的大部分域处于非法状态。如果输入参数c不为空，AVStream的codec域根据c实现初始化。

### 核心架构和机制 ###

### 过滤链 ###

FFMPEG支持由多个过滤器结构组成的过滤链，以实现对视频帧和音频采样数据的后续处理，如图像缩放、图像增强、声音的重采样等。

#### 数据结构 ####

[![tech_multimedia_avfilter.png][]][tech_multimedia_avfilter.png 1]

FFMPEG使用了的四个主要的数据结构来构造过滤链，如上图所示。其中，AVFilter是一个过滤器的抽象，它拥有若干AVFilterPad，分别实现过滤器数据的输入和输出。而AVFilterLink表示各个过滤器之间的连接，这种连接的实现是基于AVFilterPad的，每个连接都有一个实现输入的AVFilterPad和一个实现输出的AVFilterPad以及对应的源过滤器和目的过滤器。

此外，还有两个数据结构AVFilterBuffer和AVFilterBufferRef来表示过滤器的输入输出数据，其中AVFilterBufferRef是AVFilterBuffer的引用，这种设计的目的是避免不必要的数据拷贝。通过avfilter\_get\_buffer\_ref\_from\_frame可以获得一个AVFrame结构的引用，从而实现过滤器对来自AVFrame的图像原数据或声音采样序列的处理。

#### APIs ####

avfilter\_open

avfilter\_free

avfilter\_init\_filter

avfilter\_link

avfilter\_link\_free

avfilter\_ref\_buffer

[Link 1]: http://bellard.org/pi/pi2700e9/announce.html
[FFMPEG_LOGO]: http://bits.ohloh.net/attachments/2230/ffmpeg-logo-square_med.png
[Link 2]: http://ffmpeg.org/shame.html
[view plain]: http://blog.csdn.net/zsc09_leaf/article/details/14001619#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/76214
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/76214/fork
[Link 3]: http://3xin2yi.info/wwwroot/tech/doku.php/tech:multimedia:interleave
[tech_multimedia_ffmpeg.png]: http://3xin2yi.info/wwwroot/tech/lib/exe/fetch.php/tech:multimedia:ffmpeg.png
[tech_multimedia_ffmpeg.png 1]: http://3xin2yi.info/wwwroot/tech/lib/exe/detail.php/tech:multimedia:ffmpeg.png?id=tech%3Amultimedia%3Affmpeg
[view plain 1]: http://blog.csdn.net/hustbin/article/details/7630821#
[AVI_hdrl List_MP4_moov box]: http://3xin2yi.info/wwwroot/tech/doku.php/tech:multimedia:digital_media#%E5%AE%B9%E5%99%A8
[tech_multimedia_avfilter.png]: http://3xin2yi.info/wwwroot/tech/lib/exe/fetch.php/tech:multimedia:avfilter.png
[tech_multimedia_avfilter.png 1]: http://3xin2yi.info/wwwroot/tech/lib/exe/detail.php/tech:multimedia:avfilter.png?id=tech%3Amultimedia%3Affmpeg