ffmpeg TS DTS PTS AV_TIME_BASE

比眉伴天荒 2022-05-21 00:17 160阅读 0赞

# 视频的显示和存放原理 #

对于一个电影，帧是这样来显示的：I B B P。现在我们需要在显示B帧之前知道P帧中的信息。因此，帧可能会按照这样的方式来存储：IPBB。这就是为什么我们会有一个解码时间戳和一个显示时间戳的原因。解码时间戳告诉我们什么时候需要解码，显示时间戳告诉我们什么时候需要显示。所以，在这种情况下，我们的流可以是这样的：

PTS: 1 4 2 3
    DTS: 1 2 3 4
    Stream: I P B B

通常PTS和DTS只有在流中有B帧的时候会不同。

## DTS和PTS ##

音频和视频流都有一些关于以多快速度和什么时间来播放它们的信息在里面。音频流有采样，视频流有每秒的帧率。然而，如果我们只是简单的通过数帧和乘以帧率的方式来同步视频，那么就很有可能会失去同步。于是作为一种补充，在流中的包有种叫做DTS（解码时间戳）和PTS（显示时间戳）的机制。为了这两个参数，你需要了解电影存放的方式。像MPEG等格式，使用被叫做B帧（B表示双向bidrectional）的方式。另外两种帧被叫做I帧和P帧（I表示关键帧，P表示预测帧）。I帧包含了某个特定的完整图像。P帧依赖于前面的I帧和P帧并且使用比较或者差分的方式来编码。B帧与P帧有点类似，但是它是依赖于前面和后面的帧的信息的。这也就解释了为什么我们可能在调用avcodec\_decode\_video以后会得不到一帧图像。

# ffmpeg中的时间单位 #

## AV\_TIME\_BASE ##

ffmpeg中的内部计时单位（时间基），ffmepg中的所有时间都是于它为一个单位，比如AVStream中的duration即以为着这个流的长度为duration个AV\_TIME\_BASE。AV\_TIME\_BASE定义为：

#define         AV_TIME_BASE   1000000

## AV\_TIME\_BASE\_Q ##

ffmpeg内部时间基的分数表示，实际上它是AV\_TIME\_BASE的倒数。从它的定义能很清楚的看到这点：

#define         AV_TIME_BASE_Q   (AVRational){1, AV_TIME_BASE}

AVRatioal的定义如下：

typedef struct AVRational{
    int num; //numerator
    int den; //denominator
    } AVRational;

ffmpeg提供了一个把AVRatioal结构转换成double的函数：

![复制代码][copycode.gif]

static inline double av_q2d(AVRational a)｛
    /**
    * Convert rational to double.
    * @param a rational to convert
    **/
        return a.num / (double) a.den;
    }

![复制代码][copycode.gif]

现在可以根据pts来计算一桢在整个视频中的时间位置：

timestamp(秒) = pts * av_q2d(st->time_base)

计算视频长度的方法：

time(秒) = st->duration * av_q2d(st->time_base)

这里的st是一个AVStream对象指针。

## 时间基转换公式 ##

*  timestamp(ffmpeg内部时间戳) = AV\_TIME\_BASE \* time(秒)
 *  time(秒) = AV\_TIME\_BASE\_Q \* timestamp(ffmpeg内部时间戳)

所以当需要把视频跳转到N秒的时候可以使用下面的方法：

int64_t timestamp = N * AV_TIME_BASE; 
    2
    av_seek_frame(fmtctx, index_of_video, timestamp, AVSEEK_FLAG_BACKWARD);

ffmpeg同样为我们提供了不同时间基之间的转换函数：

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

这个函数的作用是计算a \* bq / cq，来把时间戳从一个时基调整到另外一个时基。在进行时基转换的时候，我们应该首选这个函数，因为它可以避免溢出的情况发生。

**-------------------------------------------------------------------------------------------------------------------------**

**介绍:**

MPEG的系统层编码为不同的应用场景设计了两种格式:

TS(Transport Stream) 和PS(Program Stream),

它们两者之间不具有层级关系，

在逻辑上，它们两者都是由PES(Packetized Elementary Stream)包组成的，

所以可以很方便地实现相互转换.

TS(Transport Stream):

是将具有一个或多个独立时间基的一个或多个节目(包括音频和视频)组成一个流,

组成同一个节目的基本流(如一个视频流，多个音频流)的PES包有一个共用的时间基。

TS的包长标准为188bytes.

从上面的定义可以分成三层来看TS/PS。

ES层 : 由单独的音频(如mp3)，视频流(如h.264)组成基本的ES(Elementary Stream)。

PES层 : 将基本的ES按一定的规则(如H.264以AU)进行封装，并打上时间戳，组成PES。

TS/PS层: 将PES包进行切分后再封装成188bytes大小的TS包，

同时还将一些节目信息也封装成TS包(称为section), 两者共同组成TS层。

从上面的总结，TS/PS总体上来说，是一种封装格式，用来承载数据。

所以FFmpeg

将TS/PS的解析文件定义在libavformat/mpegts.c文件中

将音频，视频的解码定义在libavcodec/mpeg12.c文件中

下面来看FFmpeg是如何进行TS的demuxer的。

**1. MPEG2-TS的demuxer函数**

1.  AVInputFormat ff\_mpegts\_demuxer = \{
2.  "mpegts",
3.  NULL\_IF\_CONFIG\_SMALL("MPEG-2 transport stream format"),
4.  sizeof(MpegTSContext),
5.  mpegts\_probe,
6.  mpegts\_read\_header,
7.  mpegts\_read\_packet,
8.  mpegts\_read\_close,
9.  read\_seek,
10. mpegts\_get\_pcr,
11. .flags = AVFMT\_SHOW\_IDS|AVFMT\_TS\_DISCONT,
12. \#ifdef USE\_SYNCPOINT\_SEARCH
13. .read\_seek2 = read\_seek2,
14. \#endif
15. \};

**2. 解析流中的TS格式**

1.  /\*
2.   \* 出现3种格式，主要原因是：
3.   \* TS标准是 188Bytes;
4.   \* 日本标准是192Bytes的DVH-S格式;
5.   \* 第三种的 204Bytes则是在188Bytes的基础上，加上16Bytes的FEC(前向纠错).
6.   \*/
7.  \#define TS\_PACKET\_SIZE 188
8.  \#define TS\_DVHS\_PACKET\_SIZE 192
9.  \#define TS\_FEC\_PACKET\_SIZE 204
10. 
11. \#define TS\_MAX\_PACKET\_SIZE 204
12. 
13. //< maximum score, half of that is used for file-extension-based detection
14. \#define AVPROBE\_SCORE\_MAX 100

1.  /\*
2.   \* 函数功能:
3.   \* 分析流中是三种TS格式的哪一种
4.   \*/
5.  static int mpegts\_probe(AVProbeData \*p)
6.  \{
7.  \#define CHECK\_COUNT 10
8.  
9.  const int size= p->buf\_size;
10. int score, fec\_score, dvhs\_score;
11. int check\_count= size / TS\_FEC\_PACKET\_SIZE;
12. 
13. if (check\_count < CHECK\_COUNT)
14. return -1;
15. 
16. score = analyze(p->buf, TS\_PACKET\_SIZE \*check\_count, TS\_PACKET\_SIZE , NULL)
17. \* CHECK\_COUNT / check\_count;
18. dvhs\_score= analyze(p->buf, TS\_DVHS\_PACKET\_SIZE\*check\_count, TS\_DVHS\_PACKET\_SIZE, NULL)
19. \* CHECK\_COUNT / check\_count;
20. fec\_score = analyze(p->buf, TS\_FEC\_PACKET\_SIZE \*check\_count, TS\_FEC\_PACKET\_SIZE , NULL)
21. \* CHECK\_COUNT / check\_count;
22. 
23. /\*
24. \* we need a clear definition for the returned score ,
25. \* otherwise things will become messy sooner or later
26. \*/
27. if (score > fec\_score && score > dvhs\_score && score > 6)
28. return AVPROBE\_SCORE\_MAX + score - CHECK\_COUNT;
29. else if(dvhs\_score > score && dvhs\_score > fec\_score && dvhs\_score > 6)
30. return AVPROBE\_SCORE\_MAX + dvhs\_score - CHECK\_COUNT;
31. else if(fec\_score > 6)
32. return AVPROBE\_SCORE\_MAX + fec\_score - CHECK\_COUNT;
33. else
34. return -1;
35. \}

1.  /\*
2.   \* 函数功能:
3.   \* 在size大小的buf中，寻找满足特定格式，长度为packet\_size的
4.   \* packet的个数;
5.   \* 显然，返回的值越大越可能是相应的格式(188/192/204)
6.   \*/
7.  static int analyze(const uint8\_t \*buf, int size, int packet\_size, int \*index)\{
8.  int stat\[TS\_MAX\_PACKET\_SIZE\];
9.  int i;
10. int x=0;
11. int best\_score=0;
12. 
13. memset(stat, 0, packet\_size\*sizeof(int));
14. 
15. for (x=i=0; i < size-3; i++)
16. \{
17. if ((buf\[i\] == 0x47) && !(buf\[i+1\] & 0x80) && (buf\[i+3\] & 0x30))
18. \{
19. stat\[x\]++;
20. 
21. if (stat\[x\] > best\_score)
22. \{
23. best\_score= stat\[x\];
24. if (index)
25. \*index= x;
26. \}
27. \}
28. 
29. x++;
30. if (x == packet\_size)
31. x= 0;
32. \}
33. 
34. return best\_score;
35. \}

buf\[i\] == 0x47

其中的sync\_byte固定为0x47,即上面的.

!(buf\[i+1\] & 0x80)

由于transport\_error\_indicator为1的TS Packet实际有错误,

表示携带的数据无意义, 这样的Packet显然没什么意义.

buf\[i+3\] & 0x30

对于adaptation\_field\_control, 如果取值为0x00,则表示为未来保留，现在不用.

这就是MPEG TS的侦测过程.

**3. MPEG2-TS头解析**

1.  \#define NB\_PID\_MAX 8192
2.  \#define MAX\_SECTION\_SIZE 4096
3.  
4.  /\* pids \*/
5.  \#define PAT\_PID 0x0000
6.  \#define SDT\_PID 0x0011
7.  
8.  /\* table ids \*/
9.  \#define PAT\_TID 0x00
10. \#define PMT\_TID 0x02
11. \#define SDT\_TID 0x42

1.  /\*
2.  \* 函数功能:
3.  \*
4.  \*/
5.  int mpegts\_read\_header(AVFormatContext \*s, AVFormatParameters \*ap)
6.  \{
7.   /\*
8.   \* MpegTSContext , 是为了解码不同容器格式所使用的私有数据，
9.   \* 只有在相应的诸如mpegts.c文件才可以使用的.
10.  \* 这样，增加了这个库的模块化.
11.  \*/
12. MpegTSContext \*ts = s->priv\_data;
13. AVIOContext \*pb = s->pb;
14. uint8\_t buf\[8\*1024\];
15. int len;
16. int64\_t pos;
17. 
18. /\* read the first 8\*1024 bytes to get packet size \*/
19. pos = avio\_tell(pb); // 获取buf的当前位置
20. len = avio\_read(pb, buf, sizeof(buf)); // 从pb->opaque中读取sizeof(buf)个字节到buf
21. if (len != sizeof(buf))
22. goto fail;
23. 
24.  /\* 
25.  \* 获得TS包的实际长度
26.  \*/
27. ts->raw\_packet\_size = get\_packet\_size(buf, sizeof(buf));
28. if (ts->raw\_packet\_size <= 0)
29. \{
30. av\_log(s, AV\_LOG\_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\\n");
31. ts->raw\_packet\_size = TS\_PACKET\_SIZE;
32. \}
33. 
34. ts->stream = s;
35. ts->auto\_guess = 0;
36. 
37. if (s->iformat == &ff\_mpegts\_demuxer)
38. \{
39. /\* normal demux \*/
40. /\* first do a scaning to get all the services \*/
41. if (avio\_seek(pb, pos, SEEK\_SET) < 0)
42. \{
43. av\_log(s, AV\_LOG\_ERROR, "Unable to seek back to the start\\n");
44. \}
45. 
46.  /\*
47.  \* 挂载了两个Section类型的过滤器,
48.  \* 其实在TS的两种负载中，section是PES的元数据，
49.  \* 只有先解析了section,才能进一步解析PES数据，因此先挂上section的过滤器。
50.  \*/
51. mpegts\_open\_section\_filter(ts, SDT\_PID, sdt\_cb, ts, 1);
52. mpegts\_open\_section\_filter(ts, PAT\_PID, pat\_cb, ts, 1);
53. 
54. /\*
55. \*/
56. handle\_packets(ts, s->probesize / ts->raw\_packet\_size);
57. 
58. /\* if could not find service, enable auto\_guess \*/
59. ts->auto\_guess = 1;
60. av\_dlog(ts->stream, "tuning done\\n");
61. s->ctx\_flags |= AVFMTCTX\_NOHEADER;
62. \}
63. else
64. \{
65. ...
66. \}
67. 
68. avio\_seek(pb, pos, SEEK\_SET);
69. return 0;
70. 
71. fail:
72. return -1;
73. \}

1.  MpegTSFilter \*mpegts\_open\_section\_filter(MpegTSContext\* ts,
2.  unsigned int pid,
3.  SectionCallback\* section\_cb,
4.  void\* opaque,
5.  int check\_crc)
6.  \{
7.  MpegTSFilter \*filter;
8.  MpegTSSectionFilter \*sec;
9.  
10. av\_dlog(ts->stream, "Filter: pid=0x%x\\n", pid);
11. 
12. if (pid >= NB\_PID\_MAX || ts->pids\[pid\])
13. return NULL;
14. 
15. filter = av\_mallocz(sizeof(MpegTSFilter));
16. if (!filter)
17. return NULL;
18. 
19. ts->pids\[pid\] = filter;
20. filter->type = MPEGTS\_SECTION;
21. filter->pid = pid;
22. filter->last\_cc = -1;
23. sec = &filter->u.section\_filter;
24. sec->section\_cb = section\_cb;
25. sec->opaque = opaque;
26. sec->section\_buf= av\_malloc(MAX\_SECTION\_SIZE);
27. sec->check\_crc = check\_crc;
28. 
29. if (!sec->section\_buf)
30. \{
31. av\_free(filter);
32. return NULL;
33. \}
34. 
35. return filter;
36. \}

对于这部分代码，需要分析数据结构的定义：

依次为：

struct MpegTSContext;

struct MpegTSFilter;

\+--------------+---------------+

| |

V V

MpegTSPESFilter MpegTSSectionFilter

就是struct MpegTSContext；中有NB\_PID\_MAX(8192)个TS的Filter，

而每个struct MpegTSFilter

可能是 PES 的Filter

或者是 Section的Filter。

为什么NB\_PID\_MAX 是 8192,

需要看TS的语法结构(ISO/IEC 138138-1 page 19):

1.  Syntax No. of bits Mnemonic
2.  transport\_packet()\{
3.  sync\_byte 8 bslbf
4.  transport\_error\_indicator 1 bslbf
5.  payload\_unit\_start\_indicator 1 bslbf
6.  transport\_priority 1 bslbf
7.  PID 13 uimsbf
8.  transport\_scrambling\_control 2 bslbf
9.  adaptation\_field\_control 2 bslbf
10. continuity\_counter 4 uimsbf
11. if (adaptation\_field\_control=='10' ||
12. adaptation\_field\_control=='11' )
13. \{
14. adaptation\_field()
15. \}
16. 
17. if (adaptation\_field\_control=='01' ||
18. adaptation\_field\_control=='11' )
19. \{
20. for (i=0;i<N;i++)
21. \{
22. data\_byte 8 bslbf
23. \}
24. \}
25. \}

而8192,是2^13=8192(PID)的最大数目，

为什么会有PES和Section的区分，更详细的可以参考ISO/IEC-13818-1.

挂载上了两种section过滤器，如下：

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

PID |Section Name |Callback

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

SDT\_PID(0x0011) |ServiceDescriptionTable|sdt\_cb

| |

PAT\_PID(0x0000) |ProgramAssociationTable|pat\_cb

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

设计成回调函数，是为了在后面使用。

**4. MPEG2-TS的包处理**

1.  int handle\_packets(MpegTSContext \*ts, int nb\_packets)
2.  \{
3.  AVFormatContext \*s = ts->stream;
4.  uint8\_t packet\[TS\_PACKET\_SIZE\];
5.  int packet\_num, ret;
6.  
7.  ts->stop\_parse = 0;
8.  packet\_num = 0;
9.  
10. for ( ; ; )
11. \{
12. packet\_num++;
13. 
14. if (nb\_packets != 0 && packet\_num >= nb\_packets ||
15. ts->stop\_parse > 1)
16. \{
17. ret = AVERROR(EAGAIN);
18. break;
19. \}
20. 
21. if (ts->stop\_parse > 0)
22. break;
23. 
24. ret = read\_packet(s, packet, ts->raw\_packet\_size);
25. if (ret != 0)
26. return ret;
27. 
28. ret = handle\_packet(ts, packet);
29. if (ret != 0)
30. return ret;
31. \}
32. 
33. return 0;
34. \}

它的代码结构很简单:

handle\_packets()

\+->read\_packet()

\+->handle\_packet()

\+->write\_section\_data()

read\_packet(), 很简单, 就是去找sync\_byte(0x47),

handle\_packet(),是真正处理数据的地方.它的代码如下:

1.  /\* 
2.   \* 功能: handle one TS packet 
3.   \*/
4.  int handle\_packet(MpegTSContext \*ts, const uint8\_t \*packet)
5.  \{
6.  AVFormatContext \*s = ts->stream;
7.  MpegTSFilter \*tss;
8.  int len, pid, cc, expected\_cc, cc\_ok, afc, is\_start;
9.  const uint8\_t \*p, \*p\_end;
10. int64\_t pos;
11. 
12.  /\* 获取该包的PID \*/
13. pid = AV\_RB16(packet + 1) & 0x1fff;
14. if (pid && discard\_pid(ts, pid))
15. return 0;
16. 
17.  /\* 
18.  \* 是否是PES或者Section的开头
19.  \* 即syntax element: payload\_unit\_start\_indicator 
20.  \*/
21. is\_start = packet\[1\] & 0x40;
22. tss = ts->pids\[pid\];
23. 
24.  /\* 
25.  \* ts->auto\_guess此时为0，因此不考虑下面的代码
26.  \*/
27. if (ts->auto\_guess && tss == NULL && is\_start)
28. \{
29. add\_pes\_stream(ts, pid, -1);
30. tss = ts->pids\[pid\];
31. \}
32. if (!tss)
33. return 0;
34. 
35.  /\* 
36.  \* continuity check (currently not used) 
37.  \* 虽然检查，但不利用检查的结果
38.  \*/
39. cc = (packet\[3\] & 0xf);
40. expected\_cc = (packet\[3\] & 0x10) ? (tss->last\_cc + 1) & 0x0f : tss->last\_cc;
41. cc\_ok = (tss->last\_cc < 0) || (expected\_cc == cc);
42. tss->last\_cc = cc;
43. 
44.  /\* 
45.  \* 解析 adaptation\_field\_control 语法元素
46.  \* =======================================================
47.  \* 00 | Reserved for future use by ISO/IEC
48.  \* 01 | No adaptation\_field, payload only
49.  \* 10 | Adaptation\_field only, no payload
50.  \* 11 | Adaptation\_field follwed by payload
51.  \* =======================================================
52.  \*/
53. afc = (packet\[3\] >> 4) & 3;
54. p = packet + 4;
55. if (afc == 0) /\* reserved value \*/
56. return 0;
57. if (afc == 2) /\* adaptation field only \*/
58. return 0;
59. if (afc == 3)
60. \{
61.  /\* 
62.  \* 跳过 adapation field 
63.  \* p\[0\]对应的语法元素为: adaptation\_field\_length
64.  \*/
65. p += p\[0\] + 1;
66. \}
67. 
68.  /\* 
69.  \* if past the end of packet, ignore 
70.  \* p已近到达TS包中的有效负载的地方
71.  \*/
72. p\_end = packet + TS\_PACKET\_SIZE;
73. if (p >= p\_end)
74. return 0;
75. 
76. pos = avio\_tell(ts->stream->pb);
77. ts->pos47= pos % ts->raw\_packet\_size;
78. 
79. if (tss->type == MPEGTS\_SECTION)
80. \{
81.  /\*
82.  \* 针对Section, 第一个字节对应的语法元素为:pointer\_field(见2.4.4.1),
83.  \* 它表示在当前TS包中，从pointer\_field开始到第一个section的第一个字节间的字节数。
84.  \* 当TS包中有至少一个section的起始时,
85.  \* payload\_unit\_start\_indicator = 1 且 TS负载的第一个字节为pointer\_field;
86.  \* pointer\_field = 0x00时，表示section的起始就在这个字节之后;
87.  \* 当TS包中没有section的起始时, 
88.  \* payload\_unit\_start\_indicator = 0 且 TS负载中没有pointer\_field;
89.  \*/
90. if (is\_start)
91. \{
92. /\* pointer field present \*/
93. len = \*p++;
94. if (p + len > p\_end)
95. return 0;
96. 
97. if (len && cc\_ok)
98. \{
99.  /\* 
100.  \* write remaining section bytes 
101.  \* TS包的负载部分由Section A的End部分和Section B的Start组成，
102.  \* 先把Section A的End部分写入
103.  \*/
104. write\_section\_data(s, tss, p, len, 0);
105. 
106. /\* check whether filter has been closed \*/
107. if (!ts->pids\[pid\])
108. return 0;
109. \}
110. p += len;
111. 
112. if (p < p\_end)
113. \{
114.  /\*
115.  \* 再将Section B的Start部分写入
116.  \*/
117. write\_section\_data(s, tss, p, p\_end - p, 1);
118. \}
119. \}
120. else
121. \{
122.  /\* TS包负载仅是一个Section的中间部分部分，将其写入\*/
123. if (cc\_ok)
124. \{
125. write\_section\_data(s, tss, p, p\_end - p, 0);
126. \}
127. \}
128. \}
129. else
130. \{
131. int ret;
132. 
133.  /\* 
134.  \* 如果是PES类型，直接调用其Callback，
135.  \* 但显然，只有Section部分解析完成后才可能解析PES
136.  \*/
137. // Note: The position here points actually behind the current packet.
138. if ((ret = tss->u.pes\_filter.pes\_cb(tss, p, p\_end - p, is\_start,
139. pos - ts->raw\_packet\_size)) < 0)
140. return ret;
141. \}
142. 
143. return 0;
144. \}

write\_section\_data()函数:

反复收集buffer中的数据，指导完成相关Section的重组过程,

然后调用之前注册的两个section\_cb.

**5. 节目指定信息的解析**

1.  /\*
2.   \* PAT(Program Association Table) 节目相关表
3.   \* 提供了节目号与PID值的对应关系
4.   \* 见ISO/IEC 13818-1 2.4.4.3 Table 2-30
5.   \*/
6.  void pat\_cb(MpegTSFilter \*filter, const uint8\_t \*section, int section\_len);
7.  
8.  /\*
9.   \* PMT(Program Map Table) 节目映射表
10.  \* 提供了节目号与组成节目的元素之间的映射关系--或者称为"节目定义"
11.  \* 见ISO/IEC 13818-1 2.4.4.8 Table 2-33
12.  \*/
13. void pmt\_cb(MpegTSFilter \*filter, const uint8\_t \*section, int section\_len);
14. 
15. 
16. /\*
17.  \* SDT(Transport Stream Description Table) TS描述表
18.  \* 用于定义TS描述子的表
19.  \* 见ISO/IEC 13818-1 2.4.4.12 Table 2-36
20.  \*/
21. void sdt\_cb(MpegTSFilter \*filter, const uint8\_t \*section, int section\_len)

**6. 解析PES包**

1.  /\* 
2.   \* 见ISO/IEC 13818-1 2.4.3.6 Table 2-21
3.   \*/
4.  int mpegts\_push\_data(MpegTSFilter\* filter,
5.  const uint8\_t\* buf,
6.  int buf\_size,
7.  int is\_start,
8.  int64\_t pos);

至此，整个TS层的解析基本完成。

[copycode.gif]: /images/20220521/5493fdb657c34e0fadf067e3c1a91633.png