ffmpeg的对象架构简析——解复用器

看这篇文章你需要对ffmpeg已经有一定的使用经验，知道如何read帧，解帧，或者write等。
ffmpeg内部使用跑结构体表函数指针的方式，实现了类似C++的多态性，，我们来简析一下。

【注册表】
我们使用ffmpeg，首先要执行av_register_all，这个玩意儿把全局的解码器、编码器等结构体注册到一些全局的对象表里，以便后面跑表调用。
注册的类型有：解复用器、重复用器、解码器、编码器、包解析器、BitStreamFilter（位流处理器）。

【解封装（解复用器）】
解复用的工作主要有：
1、判断流格式是否支持（正确）。
2、提取流的头信息，比如视频的长宽、音频的声道样本数等。
3、读取压缩的数据流，用于被解码器解码。

这3个步骤，就是我们使用的抽象化的3个函数：
avformat_open_input->av_find_stream_info->av_read_frame。

我们来看一下ffmpeg中解复用器的核心结构（以FLAC音频为例）：

[cpp]  view plain  copy

 

1. AVInputFormat ff_flac_demuxer = {  
2.     .name           = "flac",  
3.     .long_name      = NULL_IF_CONFIG_SMALL("raw FLAC"),  
4.     .read_probe     = flac_probe,  
5.     .read_header    = flac_read_header,  
6.     .read_packet    = ff_raw_read_partial_packet,  
7.     .flags          = AVFMT_GENERIC_INDEX,  
8.     .extensions     = "flac",  
9.     .raw_codec_id   = AV_CODEC_ID_FLAC,  
10. };  

在我们执行av_register_all后，这个flac的AVInputFormat结构体指针会被注册到一个全局对象表里。
而avformat_open_input的工作很简单，其通过avio从来源读取字节流头，然后跑这个全局对象表，一个个去执行read_probe函数，如果哪个read_probe认了就行了。

我们看flac的read_probe实现：

[cpp]  view plain  copy

 

1. static int flac_probe(AVProbeData *p)  
2. {  
3.     if (p->buf_size < 4 || memcmp(p->buf, "fLaC", 4))  
4.         return 0;  
5.     return AVPROBE_SCORE_EXTENSION;  
6. }  

这个probe仅仅只是判断了头是不是fLaC这个字符，是就是ok了，我认了，不是，让avformat_open_input继续匹配文件扩展名（如果有的话）。
如果全部的probe函数都不认，则open失败。
如果有一个probe认了，本来按照理论上来说，read_header应该是在av_find_stream_info执行的，但是ffmpeg还是将其放在了avformat_open_input，其实效果也一样，我们来看看flac的read_header：

[cpp]  view plain  copy

 

1. static int flac_read_header(AVFormatContext *s)  
2. {  
3.     int ret, metadata_last=0, metadata_type, metadata_size, found_streaminfo=0;  
4.     uint8_t header[4];  
5.     uint8_t *buffer=NULL;  
6.     AVStream *st = avformat_new_stream(s, NULL);  
7.     if (!st)  
8.         return AVERROR(ENOMEM);  
9.     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;  
10.     st->codec->codec_id = AV_CODEC_ID_FLAC;  
11.     st->need_parsing = AVSTREAM_PARSE_FULL_RAW;  
12.     /* the parameters will be extracted from the compressed bitstream */  
13.   
14.     /* if fLaC marker is not found, assume there is no header */  
15.     if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {  
16.         avio_seek(s->pb, -4, SEEK_CUR);  
17.         return 0;  
18.     }  
19.   
20.     /* process metadata blocks */  
21.     while (!url_feof(s->pb) && !metadata_last) {  
22.         avio_read(s->pb, header, 4);  
23.         avpriv_flac_parse_block_header(header, &metadata_last, &metadata_type,  
24.                                    &metadata_size);  
25.         switch (metadata_type) {  
26.         /* allocate and read metadata block for supported types */  
27.         case FLAC_METADATA_TYPE_STREAMINFO:  
28.         case FLAC_METADATA_TYPE_CUESHEET:  
29.         case FLAC_METADATA_TYPE_PICTURE:  
30.         case FLAC_METADATA_TYPE_VORBIS_COMMENT:  
31.             buffer = av_mallocz(metadata_size + FF_INPUT_BUFFER_PADDING_SIZE);  
32.             if (!buffer) {  
33.                 return AVERROR(ENOMEM);  
34.             }  
35.             if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {  
36.                 RETURN_ERROR(AVERROR(EIO));  
37.             }  
38.             break;  
39.         /* skip metadata block for unsupported types */  
40.         default:  
41.             ret = avio_skip(s->pb, metadata_size);  
42.             if (ret < 0)  
43.                 return ret;  
44.         }  
45.   
46.         if (metadata_type == FLAC_METADATA_TYPE_STREAMINFO) {  
47.             FLACStreaminfo si;  
48.             /* STREAMINFO can only occur once */  
49.             if (found_streaminfo) {  
50.                 RETURN_ERROR(AVERROR_INVALIDDATA);  
51.             }  
52.             if (metadata_size != FLAC_STREAMINFO_SIZE) {  
53.                 RETURN_ERROR(AVERROR_INVALIDDATA);  
54.             }  
55.             found_streaminfo = 1;  
56.             st->codec->extradata      = buffer;  
57.             st->codec->extradata_size = metadata_size;  
58.             buffer = NULL;  
59.   
60.             /* get codec params from STREAMINFO header */  
61.             avpriv_flac_parse_streaminfo(st->codec, &si, st->codec->extradata);  
62.   
63.             /* set time base and duration */  
64.             if (si.samplerate > 0) {  
65.                 avpriv_set_pts_info(st, 64, 1, si.samplerate);  
66.                 if (si.samples > 0)  
67.                     st->duration = si.samples;  
68.             }  
69.         } else if (metadata_type == FLAC_METADATA_TYPE_CUESHEET) {  
70.             uint8_t isrc[13];  
71.             uint64_t start;  
72.             const uint8_t *offset;  
73.             int i, chapters, track, ti;  
74.             if (metadata_size < 431)  
75.                 RETURN_ERROR(AVERROR_INVALIDDATA);  
76.             offset = buffer + 395;  
77.             chapters = bytestream_get_byte(&offset) - 1;  
78.             if (chapters <= 0)  
79.                 RETURN_ERROR(AVERROR_INVALIDDATA);  
80.             for (i = 0; i < chapters; i++) {  
81.                 if (offset + 36 - buffer > metadata_size)  
82.                     RETURN_ERROR(AVERROR_INVALIDDATA);  
83.                 start = bytestream_get_be64(&offset);  
84.                 track = bytestream_get_byte(&offset);  
85.                 bytestream_get_buffer(&offset, isrc, 12);  
86.                 isrc[12] = 0;  
87.                 offset += 14;  
88.                 ti = bytestream_get_byte(&offset);  
89.                 if (ti <= 0) RETURN_ERROR(AVERROR_INVALIDDATA);  
90.                 offset += ti * 12;  
91.                 avpriv_new_chapter(s, track, st->time_base, start, AV_NOPTS_VALUE, isrc);  
92.             }  
93.             av_freep(&buffer);  
94.         } else if (metadata_type == FLAC_METADATA_TYPE_PICTURE) {  
95.             ret = ff_flac_parse_picture(s, buffer, metadata_size);  
96.             av_freep(&buffer);  
97.             if (ret < 0) {  
98.                 av_log(s, AV_LOG_ERROR, "Error parsing attached picture.\n");  
99.                 return ret;  
100.             }  
101.         } else {  
102.             /* STREAMINFO must be the first block */  
103.             if (!found_streaminfo) {  
104.                 RETURN_ERROR(AVERROR_INVALIDDATA);  
105.             }  
106.             /* process supported blocks other than STREAMINFO */  
107.             if (metadata_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {  
108.                 if (ff_vorbis_comment(s, &s->metadata, buffer, metadata_size)) {  
109.                     av_log(s, AV_LOG_WARNING, "error parsing VorbisComment metadata\n");  
110.                 }  
111.             }  
112.             av_freep(&buffer);  
113.         }  
114.     }  
115.   
116.     return 0;  
117.   
118. fail:  
119.     av_free(buffer);  
120.     return ret;  
121. }  

首先，我们看到它avformat_new_stream了一个流，因为flac音频只有一个流。
然后我们可以看到，它设置了codec的type和id，就像在DShow里面我们设置MajorType和SubType一样。
我们看到下面有行代码：st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
这个是指示parser（包解析器）的flag，后面说。
再来就进入遍历flac的metadata块过程。

因为我们不是分析flac格式，我这里也不会说flac的metadata块是如何如何，我们只说，当read_header后，AVFormatContext这个结构体，变成啥样了。
flac文件的流信息存储在FLAC_METADATA_TYPE_STREAMINFO块里面，我们看到，在跑FLAC_METADATA_TYPE_STREAMINFO块的时候：

[cpp]  view plain  copy

 

1. if (metadata_type == FLAC_METADATA_TYPE_STREAMINFO) {  
2.     FLACStreaminfo si;  
3.     /* STREAMINFO can only occur once */  
4.     if (found_streaminfo) {  
5.         RETURN_ERROR(AVERROR_INVALIDDATA);  
6.     }  
7.     if (metadata_size != FLAC_STREAMINFO_SIZE) {  
8.         RETURN_ERROR(AVERROR_INVALIDDATA);  
9.     }  
10.     found_streaminfo = 1;  
11.     st->codec->extradata      = buffer;  
12.     st->codec->extradata_size = metadata_size;  
13.     buffer = NULL;  
14.   
15.     /* get codec params from STREAMINFO header */  
16.     avpriv_flac_parse_streaminfo(st->codec, &si, st->codec->extradata);  
17.   
18.     /* set time base and duration */  
19.     if (si.samplerate > 0) {  
20.         avpriv_set_pts_info(st, 64, 1, si.samplerate);  
21.         if (si.samples > 0)  
22.             st->duration = si.samples;  
23.     }  

首先，codec->extradata有数据了（就像H264解码器需要SPS\PPS\NAL头一样）。
然后代码里，我们可以看到，流的总长度有了，流的采样率有了，我们再看看avpriv_flac_parse_streaminfo函数：

[cpp]  view plain  copy

 

1. void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,  
2.                               const uint8_t *buffer)  
3. {  
4.     GetBitContext gb;  
5.     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);  
6.   
7.     skip_bits(&gb, 16); /* skip min blocksize */  
8.     s->max_blocksize = get_bits(&gb, 16);  
9.     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {  
10.         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",  
11.                s->max_blocksize);  
12.         s->max_blocksize = 16;  
13.     }  
14.   
15.     skip_bits(&gb, 24); /* skip min frame size */  
16.     s->max_framesize = get_bits_long(&gb, 24);  
17.   
18.     s->samplerate = get_bits_long(&gb, 20);  
19.     s->channels = get_bits(&gb, 3) + 1;  
20.     s->bps = get_bits(&gb, 5) + 1;  
21.   
22.     avctx->channels = s->channels;  
23.     avctx->sample_rate = s->samplerate;  
24.     avctx->bits_per_raw_sample = s->bps;  
25.     ff_flac_set_channel_layout(avctx);  
26.   
27.     s->samples = get_bits64(&gb, 36);  
28.   
29.     skip_bits_long(&gb, 64); /* md5 sum */  
30.     skip_bits_long(&gb, 64); /* md5 sum */  
31. }  

可以看到，解码一个音频需要的东西都有了，声道、采样率、速率、声道布局、样本总数都已经保存起来了。
而这些信息全部设置在AVCodecContext里，由此，我们可以得出结论，read_header就是一个提取解码器需要的私有信息的函数。

read_header完成，基本上avformat_open_input就要返回了，此时AVCodecContext虽然有一些信息了，但是AVFormatContext还是挺空虚的（此时它已经有流的总数），我们需要填充它，就应该到调用av_find_stream_info的时候了。

av_find_stream_info主要做的工作有几个：
1、填充AVFormatContext信息，比如总长度，timebase、pts、dts和一些内部信息。
2、初始化解码器需要的一些信息。
3、如果需要，则初始化包解析器（parser）。
4、如果需要，尝试解码一些数据，来获取媒体信息。

这里我们忽略前面二点，因为他们跟解封装的关系不大，而第三点，则是跟解封装有莫大关联的。

我们先假设，我们av_find_stream_info成功了。此时我们可以av_read_frame了。
我们知道，av_read_frame读出来的AVFrame，如果是视频，则是视频的一帧(IPB中)，如果是音频，则是几帧。
但是av_read_frame不会有断帧的情况，就是不会有0.5帧这种情况，这个到底是如何做的呢，我们来看。

首先我们回到上面的：

[cpp]  view plain  copy

 

1. AVInputFormat ff_flac_demuxer = {  
2.     .name           = "flac",  
3.     .long_name      = NULL_IF_CONFIG_SMALL("raw FLAC"),  
4.     .read_probe     = flac_probe,  
5.     .read_header    = flac_read_header,  
6.     .read_packet    = ff_raw_read_partial_packet,  
7.     .flags          = AVFMT_GENERIC_INDEX,  
8.     .extensions     = "flac",  
9.     .raw_codec_id   = AV_CODEC_ID_FLAC,  
10. };  

我们看了read_probe用于判断，read_header用于解析头，那还有一个关键的东西没看，就是那个read_packet。
我们可以看到，flac这里的read_packet指向了一个公用函数ff_raw_read_partial_packet，我们来看看这个函数：

[cpp]  view plain  copy

 

1. #define RAW_PACKET_SIZE 1024  
2.   
3. int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)  
4. {  
5.     int ret, size;  
6.   
7.     size = RAW_PACKET_SIZE;  
8.   
9.     if (av_new_packet(pkt, size) < 0)  
10.         return AVERROR(ENOMEM);  
11.   
12.     pkt->pos= avio_tell(s->pb);  
13.     pkt->stream_index = 0;  
14.     ret = ffio_read_partial(s->pb, pkt->data, size);  
15.     if (ret < 0) {  
16.         av_free_packet(pkt);  
17.         return ret;  
18.     }  
19.     av_shrink_packet(pkt, ret);  
20.     return ret;  
21. }  

这个函数那真是十分简单，其注意做的工作就是：
1、新建一个1024字节的AVPacket。
2、从IO读1024字节的数据（如果当前指针到文件尾没有1024字节，即读差值）。
3、把实际读取到的数据写回包size（av_shrink_packet）。

我们可以看到，这玩意儿每次就读个1024字节，可就算是音频文件，也不可能说所有帧在文件里面的偏移都对齐到1024个字节，也不可能说一个帧大小必定是1024字节，而且对视频文件，读到的1024字节的数据还会穿插着视频\音频帧，所以这个AVPacket肯定不会是我们调用av_read_frame出来的那么漂亮的AVPakcet，必然是经过“修整”的，那这个修整模块在哪里呢？即为parser。

我们来看flac的parser结构：

[cpp]  view plain  copy

 

1. AVCodecParser ff_flac_parser = {  
2.     .codec_ids      = { AV_CODEC_ID_FLAC },  
3.     .priv_data_size = sizeof(FLACParseContext),  
4.     .parser_init    = flac_parse_init,  
5.     .parser_parse   = flac_parse,  
6.     .parser_close   = flac_parse_close,  
7. };  

我们可以看到，demuxer和parser都关联了同一个codec的id，即AV_CODEC_ID_FLAC，表明他们是连接在一起的。
parser结构由av_find_stream_info初始化，av_find_stream_info会执行av_parser_init通过codec_id给一个个流初始化parser。
av_parser_init的查找方式也是跟查找demuxer一样，parser已经注册在了全局的表里面，跑表匹配即可。

关于包解析器，下次细说。