2 * MPEG2 transport stream (aka DVB) demuxer
3 * Copyright (c) 2002-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/buffer.h"
23 #include "libavutil/crc.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/log.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/avassert.h"
30 #include "libavcodec/bytestream.h"
31 #include "libavcodec/get_bits.h"
32 #include "libavcodec/opus.h"
36 #include "avio_internal.h"
41 /* maximum size in which we look for synchronisation if
42 * synchronisation is lost */
43 #define MAX_RESYNC_SIZE 65536
45 #define MAX_PES_PAYLOAD 200 * 1024
47 #define MAX_MP4_DESCR_COUNT 16
49 #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \
51 if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \
52 (modulus) = (dividend) % (divisor); \
53 (prev_dividend) = (dividend); \
56 enum MpegTSFilterType
{
62 typedef struct MpegTSFilter MpegTSFilter
;
64 typedef int PESCallback (MpegTSFilter
*f
, const uint8_t *buf
, int len
,
65 int is_start
, int64_t pos
);
67 typedef struct MpegTSPESFilter
{
72 typedef void SectionCallback (MpegTSFilter
*f
, const uint8_t *buf
, int len
);
74 typedef void SetServiceCallback (void *opaque
, int ret
);
76 typedef struct MpegTSSectionFilter
{
80 unsigned int check_crc
: 1;
81 unsigned int end_of_section_reached
: 1;
82 SectionCallback
*section_cb
;
84 } MpegTSSectionFilter
;
89 int last_cc
; /* last cc code (-1 if first packet) */
91 enum MpegTSFilterType type
;
93 MpegTSPESFilter pes_filter
;
94 MpegTSSectionFilter section_filter
;
98 #define MAX_PIDS_PER_PROGRAM 64
100 unsigned int id
; // program id/service id
101 unsigned int nb_pids
;
102 unsigned int pids
[MAX_PIDS_PER_PROGRAM
];
104 /** have we found pmt for this program */
108 struct MpegTSContext
{
109 const AVClass
*class;
111 AVFormatContext
*stream
;
112 /** raw packet size, including FEC if present */
117 #define SIZE_STAT_THRESHOLD 10
121 /** if true, all pids are analyzed to find streams */
124 /** compute exact PCR for each transport stream packet */
125 int mpeg2ts_compute_pcr
;
127 /** fix dvb teletext pts */
128 int fix_teletext_pts
;
130 int64_t cur_pcr
; /**< used to estimate the exact PCR */
131 int pcr_incr
; /**< used to estimate the exact PCR */
133 /* data needed to handle file based ts */
134 /** stop parsing loop */
136 /** packet containing Audio/Video data */
138 /** to detect seek */
148 /******************************************/
149 /* private mpegts data */
151 /** structure to keep track of Program->pids mapping */
155 int8_t crc_validity
[NB_PID_MAX
];
156 /** filters for various streams specified by PMT + for the PAT and PMT */
157 MpegTSFilter
*pids
[NB_PID_MAX
];
161 #define MPEGTS_OPTIONS \
162 { "resync_size", "Size limit for looking up a new synchronization.", offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM }
164 static const AVOption options
[] = {
166 {"fix_teletext_pts", "Try to fix pts values of dvb teletext streams.", offsetof(MpegTSContext
, fix_teletext_pts
), AV_OPT_TYPE_INT
,
167 {.i64
= 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM
},
168 {"ts_packetsize", "Output option carrying the raw packet size.", offsetof(MpegTSContext
, raw_packet_size
), AV_OPT_TYPE_INT
,
169 {.i64
= 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_EXPORT
| AV_OPT_FLAG_READONLY
},
170 {"scan_all_pmts", "Scan and combine all PMTs", offsetof(MpegTSContext
, scan_all_pmts
), AV_OPT_TYPE_INT
,
171 { .i64
= -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM
},
172 {"skip_changes", "Skip changing / adding streams / programs.", offsetof(MpegTSContext
, skip_changes
), AV_OPT_TYPE_INT
,
173 {.i64
= 0}, 0, 1, 0 },
174 {"skip_clear", "Skip clearing programs.", offsetof(MpegTSContext
, skip_clear
), AV_OPT_TYPE_INT
,
175 {.i64
= 0}, 0, 1, 0 },
179 static const AVClass mpegts_class
= {
180 .class_name
= "mpegts demuxer",
181 .item_name
= av_default_item_name
,
183 .version
= LIBAVUTIL_VERSION_INT
,
186 static const AVOption raw_options
[] = {
188 { "compute_pcr", "Compute exact PCR for each transport stream packet.",
189 offsetof(MpegTSContext
, mpeg2ts_compute_pcr
), AV_OPT_TYPE_INT
,
190 { .i64
= 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM
},
191 { "ts_packetsize", "Output option carrying the raw packet size.",
192 offsetof(MpegTSContext
, raw_packet_size
), AV_OPT_TYPE_INT
,
194 AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_EXPORT
| AV_OPT_FLAG_READONLY
},
198 static const AVClass mpegtsraw_class
= {
199 .class_name
= "mpegtsraw demuxer",
200 .item_name
= av_default_item_name
,
201 .option
= raw_options
,
202 .version
= LIBAVUTIL_VERSION_INT
,
205 /* TS stream handling */
210 MPEGTS_PESHEADER_FILL
,
215 /* enough for PES header + length */
216 #define PES_START_SIZE 6
217 #define PES_HEADER_SIZE 9
218 #define MAX_PES_HEADER_SIZE (9 + 255)
220 typedef struct PESContext
{
222 int pcr_pid
; /**< if -1 then all packets containing PCR are considered */
225 AVFormatContext
*stream
;
227 AVStream
*sub_st
; /**< stream for the embedded AC3 stream in HDMV TrueHD */
228 enum MpegTSState state
;
229 /* used to get the format */
231 int flags
; /**< copied to the AVPacket flags */
234 int extended_stream_id
;
236 int64_t ts_packet_pos
; /**< position of first TS packet of this PES packet */
237 uint8_t header
[MAX_PES_HEADER_SIZE
];
242 extern AVInputFormat ff_mpegts_demuxer
;
244 static struct Program
* get_program(MpegTSContext
*ts
, unsigned int programid
)
247 for (i
= 0; i
< ts
->nb_prg
; i
++) {
248 if (ts
->prg
[i
].id
== programid
) {
255 static void clear_avprogram(MpegTSContext
*ts
, unsigned int programid
)
257 AVProgram
*prg
= NULL
;
260 for (i
= 0; i
< ts
->stream
->nb_programs
; i
++)
261 if (ts
->stream
->programs
[i
]->id
== programid
) {
262 prg
= ts
->stream
->programs
[i
];
267 prg
->nb_stream_indexes
= 0;
270 static void clear_program(MpegTSContext
*ts
, unsigned int programid
)
274 clear_avprogram(ts
, programid
);
275 for (i
= 0; i
< ts
->nb_prg
; i
++)
276 if (ts
->prg
[i
].id
== programid
) {
277 ts
->prg
[i
].nb_pids
= 0;
278 ts
->prg
[i
].pmt_found
= 0;
282 static void clear_programs(MpegTSContext
*ts
)
288 static void add_pat_entry(MpegTSContext
*ts
, unsigned int programid
)
291 if (av_reallocp_array(&ts
->prg
, ts
->nb_prg
+ 1, sizeof(*ts
->prg
)) < 0) {
295 p
= &ts
->prg
[ts
->nb_prg
];
302 static void add_pid_to_pmt(MpegTSContext
*ts
, unsigned int programid
,
305 struct Program
*p
= get_program(ts
, programid
);
310 if (p
->nb_pids
>= MAX_PIDS_PER_PROGRAM
)
313 for (i
= 0; i
< p
->nb_pids
; i
++)
314 if (p
->pids
[i
] == pid
)
317 p
->pids
[p
->nb_pids
++] = pid
;
320 static void set_pmt_found(MpegTSContext
*ts
, unsigned int programid
)
322 struct Program
*p
= get_program(ts
, programid
);
329 static void set_pcr_pid(AVFormatContext
*s
, unsigned int programid
, unsigned int pid
)
332 for (i
= 0; i
< s
->nb_programs
; i
++) {
333 if (s
->programs
[i
]->id
== programid
) {
334 s
->programs
[i
]->pcr_pid
= pid
;
341 * @brief discard_pid() decides if the pid is to be discarded according
342 * to caller's programs selection
343 * @param ts : - TS context
345 * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
348 static int discard_pid(MpegTSContext
*ts
, unsigned int pid
)
351 int used
= 0, discarded
= 0;
354 /* If none of the programs have .discard=AVDISCARD_ALL then there's
355 * no way we have to discard this packet */
356 for (k
= 0; k
< ts
->stream
->nb_programs
; k
++)
357 if (ts
->stream
->programs
[k
]->discard
== AVDISCARD_ALL
)
359 if (k
== ts
->stream
->nb_programs
)
362 for (i
= 0; i
< ts
->nb_prg
; i
++) {
364 for (j
= 0; j
< p
->nb_pids
; j
++) {
365 if (p
->pids
[j
] != pid
)
367 // is program with id p->id set to be discarded?
368 for (k
= 0; k
< ts
->stream
->nb_programs
; k
++) {
369 if (ts
->stream
->programs
[k
]->id
== p
->id
) {
370 if (ts
->stream
->programs
[k
]->discard
== AVDISCARD_ALL
)
379 return !used
&& discarded
;
383 * Assemble PES packets out of TS packets, and then call the "section_cb"
384 * function when they are complete.
386 static void write_section_data(MpegTSContext
*ts
, MpegTSFilter
*tss1
,
387 const uint8_t *buf
, int buf_size
, int is_start
)
389 MpegTSSectionFilter
*tss
= &tss1
->u
.section_filter
;
393 memcpy(tss
->section_buf
, buf
, buf_size
);
394 tss
->section_index
= buf_size
;
395 tss
->section_h_size
= -1;
396 tss
->end_of_section_reached
= 0;
398 if (tss
->end_of_section_reached
)
400 len
= 4096 - tss
->section_index
;
403 memcpy(tss
->section_buf
+ tss
->section_index
, buf
, len
);
404 tss
->section_index
+= len
;
407 /* compute section length if possible */
408 if (tss
->section_h_size
== -1 && tss
->section_index
>= 3) {
409 len
= (AV_RB16(tss
->section_buf
+ 1) & 0xfff) + 3;
412 tss
->section_h_size
= len
;
415 if (tss
->section_h_size
!= -1 &&
416 tss
->section_index
>= tss
->section_h_size
) {
418 tss
->end_of_section_reached
= 1;
420 if (tss
->check_crc
) {
421 crc_valid
= !av_crc(av_crc_get_table(AV_CRC_32_IEEE
), -1, tss
->section_buf
, tss
->section_h_size
);
423 ts
->crc_validity
[ tss1
->pid
] = 100;
424 }else if (ts
->crc_validity
[ tss1
->pid
] > -10) {
425 ts
->crc_validity
[ tss1
->pid
]--;
430 tss
->section_cb(tss1
, tss
->section_buf
, tss
->section_h_size
);
434 static MpegTSFilter
*mpegts_open_filter(MpegTSContext
*ts
, unsigned int pid
,
435 enum MpegTSFilterType type
)
437 MpegTSFilter
*filter
;
439 av_dlog(ts
->stream
, "Filter: pid=0x%x\n", pid
);
441 if (pid
>= NB_PID_MAX
|| ts
->pids
[pid
])
443 filter
= av_mallocz(sizeof(MpegTSFilter
));
446 ts
->pids
[pid
] = filter
;
451 filter
->last_cc
= -1;
452 filter
->last_pcr
= -1;
457 static MpegTSFilter
*mpegts_open_section_filter(MpegTSContext
*ts
,
459 SectionCallback
*section_cb
,
463 MpegTSFilter
*filter
;
464 MpegTSSectionFilter
*sec
;
466 if (!(filter
= mpegts_open_filter(ts
, pid
, MPEGTS_SECTION
)))
468 sec
= &filter
->u
.section_filter
;
469 sec
->section_cb
= section_cb
;
470 sec
->opaque
= opaque
;
471 sec
->section_buf
= av_malloc(MAX_SECTION_SIZE
);
472 sec
->check_crc
= check_crc
;
473 if (!sec
->section_buf
) {
480 static MpegTSFilter
*mpegts_open_pes_filter(MpegTSContext
*ts
, unsigned int pid
,
484 MpegTSFilter
*filter
;
485 MpegTSPESFilter
*pes
;
487 if (!(filter
= mpegts_open_filter(ts
, pid
, MPEGTS_PES
)))
490 pes
= &filter
->u
.pes_filter
;
491 pes
->pes_cb
= pes_cb
;
492 pes
->opaque
= opaque
;
496 static MpegTSFilter
*mpegts_open_pcr_filter(MpegTSContext
*ts
, unsigned int pid
)
498 return mpegts_open_filter(ts
, pid
, MPEGTS_PCR
);
501 static void mpegts_close_filter(MpegTSContext
*ts
, MpegTSFilter
*filter
)
506 if (filter
->type
== MPEGTS_SECTION
)
507 av_freep(&filter
->u
.section_filter
.section_buf
);
508 else if (filter
->type
== MPEGTS_PES
) {
509 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
510 av_buffer_unref(&pes
->buffer
);
511 /* referenced private data will be freed later in
512 * avformat_close_input */
513 if (!((PESContext
*)filter
->u
.pes_filter
.opaque
)->st
) {
514 av_freep(&filter
->u
.pes_filter
.opaque
);
519 ts
->pids
[pid
] = NULL
;
522 static int analyze(const uint8_t *buf
, int size
, int packet_size
, int *index
)
524 int stat
[TS_MAX_PACKET_SIZE
];
529 memset(stat
, 0, packet_size
* sizeof(*stat
));
531 for (i
= 0; i
< size
- 3; i
++) {
532 if (buf
[i
] == 0x47 && !(buf
[i
+ 1] & 0x80) && buf
[i
+ 3] != 0x47) {
533 int x
= i
% packet_size
;
536 if (stat
[x
] > best_score
) {
537 best_score
= stat
[x
];
544 return best_score
- FFMAX(stat_all
- 10*best_score
, 0)/10;
547 /* autodetect fec presence. Must have at least 1024 bytes */
548 static int get_packet_size(const uint8_t *buf
, int size
)
550 int score
, fec_score
, dvhs_score
;
552 if (size
< (TS_FEC_PACKET_SIZE
* 5 + 1))
553 return AVERROR_INVALIDDATA
;
555 score
= analyze(buf
, size
, TS_PACKET_SIZE
, NULL
);
556 dvhs_score
= analyze(buf
, size
, TS_DVHS_PACKET_SIZE
, NULL
);
557 fec_score
= analyze(buf
, size
, TS_FEC_PACKET_SIZE
, NULL
);
558 av_dlog(NULL
, "score: %d, dvhs_score: %d, fec_score: %d \n",
559 score
, dvhs_score
, fec_score
);
561 if (score
> fec_score
&& score
> dvhs_score
)
562 return TS_PACKET_SIZE
;
563 else if (dvhs_score
> score
&& dvhs_score
> fec_score
)
564 return TS_DVHS_PACKET_SIZE
;
565 else if (score
< fec_score
&& dvhs_score
< fec_score
)
566 return TS_FEC_PACKET_SIZE
;
568 return AVERROR_INVALIDDATA
;
571 typedef struct SectionHeader
{
576 uint8_t last_sec_num
;
579 static inline int get8(const uint8_t **pp
, const uint8_t *p_end
)
586 return AVERROR_INVALIDDATA
;
592 static inline int get16(const uint8_t **pp
, const uint8_t *p_end
)
598 if ((p
+ 1) >= p_end
)
599 return AVERROR_INVALIDDATA
;
606 /* read and allocate a DVB string preceded by its length */
607 static char *getstr8(const uint8_t **pp
, const uint8_t *p_end
)
614 len
= get8(&p
, p_end
);
617 if ((p
+ len
) > p_end
)
619 str
= av_malloc(len
+ 1);
629 static int parse_section_header(SectionHeader
*h
,
630 const uint8_t **pp
, const uint8_t *p_end
)
634 val
= get8(pp
, p_end
);
639 val
= get16(pp
, p_end
);
643 val
= get8(pp
, p_end
);
646 h
->version
= (val
>> 1) & 0x1f;
647 val
= get8(pp
, p_end
);
651 val
= get8(pp
, p_end
);
654 h
->last_sec_num
= val
;
659 uint32_t stream_type
;
660 enum AVMediaType codec_type
;
661 enum AVCodecID codec_id
;
664 static const StreamType ISO_types
[] = {
665 { 0x01, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_MPEG2VIDEO
},
666 { 0x02, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_MPEG2VIDEO
},
667 { 0x03, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_MP3
},
668 { 0x04, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_MP3
},
669 { 0x0f, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AAC
},
670 { 0x10, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_MPEG4
},
671 /* Makito encoder sets stream type 0x11 for AAC,
672 * so auto-detect LOAS/LATM instead of hardcoding it. */
673 #if !CONFIG_LOAS_DEMUXER
674 { 0x11, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AAC_LATM
}, /* LATM syntax */
676 { 0x1b, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_H264
},
677 { 0x24, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_HEVC
},
678 { 0x42, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_CAVS
},
679 { 0xd1, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_DIRAC
},
680 { 0xea, AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_VC1
},
684 static const StreamType HDMV_types
[] = {
685 { 0x80, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_PCM_BLURAY
},
686 { 0x81, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AC3
},
687 { 0x82, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
688 { 0x83, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_TRUEHD
},
689 { 0x84, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_EAC3
},
690 { 0x85, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
}, /* DTS HD */
691 { 0x86, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
}, /* DTS HD MASTER*/
692 { 0xa1, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_EAC3
}, /* E-AC3 Secondary Audio */
693 { 0xa2, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
}, /* DTS Express Secondary Audio */
694 { 0x90, AVMEDIA_TYPE_SUBTITLE
, AV_CODEC_ID_HDMV_PGS_SUBTITLE
},
699 static const StreamType MISC_types
[] = {
700 { 0x81, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AC3
},
701 { 0x8a, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
705 static const StreamType REGD_types
[] = {
706 { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_DIRAC
},
707 { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AC3
},
708 { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_S302M
},
709 { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
710 { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
711 { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
712 { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_HEVC
},
713 { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA
, AV_CODEC_ID_SMPTE_KLV
},
714 { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO
, AV_CODEC_ID_VC1
},
715 { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_OPUS
},
719 static const StreamType METADATA_types
[] = {
720 { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA
, AV_CODEC_ID_SMPTE_KLV
},
721 { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA
, AV_CODEC_ID_TIMED_ID3
},
725 /* descriptor present */
726 static const StreamType DESC_types
[] = {
727 { 0x6a, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_AC3
}, /* AC-3 descriptor */
728 { 0x7a, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_EAC3
}, /* E-AC-3 descriptor */
729 { 0x7b, AVMEDIA_TYPE_AUDIO
, AV_CODEC_ID_DTS
},
730 { 0x56, AVMEDIA_TYPE_SUBTITLE
, AV_CODEC_ID_DVB_TELETEXT
},
731 { 0x59, AVMEDIA_TYPE_SUBTITLE
, AV_CODEC_ID_DVB_SUBTITLE
}, /* subtitling descriptor */
735 static void mpegts_find_stream_type(AVStream
*st
,
736 uint32_t stream_type
,
737 const StreamType
*types
)
739 if (avcodec_is_open(st
->codec
)) {
740 av_log(NULL
, AV_LOG_DEBUG
, "cannot set stream info, codec is open\n");
744 for (; types
->stream_type
; types
++)
745 if (stream_type
== types
->stream_type
) {
746 st
->codec
->codec_type
= types
->codec_type
;
747 st
->codec
->codec_id
= types
->codec_id
;
748 st
->request_probe
= 0;
753 static int mpegts_set_stream_info(AVStream
*st
, PESContext
*pes
,
754 uint32_t stream_type
, uint32_t prog_reg_desc
)
756 int old_codec_type
= st
->codec
->codec_type
;
757 int old_codec_id
= st
->codec
->codec_id
;
759 if (avcodec_is_open(st
->codec
)) {
760 av_log(pes
->stream
, AV_LOG_DEBUG
, "cannot set stream info, codec is open\n");
764 avpriv_set_pts_info(st
, 33, 1, 90000);
766 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
767 st
->codec
->codec_id
= AV_CODEC_ID_NONE
;
768 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
770 pes
->stream_type
= stream_type
;
772 av_log(pes
->stream
, AV_LOG_DEBUG
,
773 "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
774 st
->index
, pes
->stream_type
, pes
->pid
, (char *)&prog_reg_desc
);
776 st
->codec
->codec_tag
= pes
->stream_type
;
778 mpegts_find_stream_type(st
, pes
->stream_type
, ISO_types
);
779 if ((prog_reg_desc
== AV_RL32("HDMV") ||
780 prog_reg_desc
== AV_RL32("HDPR")) &&
781 st
->codec
->codec_id
== AV_CODEC_ID_NONE
) {
782 mpegts_find_stream_type(st
, pes
->stream_type
, HDMV_types
);
783 if (pes
->stream_type
== 0x83) {
784 // HDMV TrueHD streams also contain an AC3 coded version of the
785 // audio track - add a second stream for this
787 // priv_data cannot be shared between streams
788 PESContext
*sub_pes
= av_malloc(sizeof(*sub_pes
));
790 return AVERROR(ENOMEM
);
791 memcpy(sub_pes
, pes
, sizeof(*sub_pes
));
793 sub_st
= avformat_new_stream(pes
->stream
, NULL
);
796 return AVERROR(ENOMEM
);
799 sub_st
->id
= pes
->pid
;
800 avpriv_set_pts_info(sub_st
, 33, 1, 90000);
801 sub_st
->priv_data
= sub_pes
;
802 sub_st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
803 sub_st
->codec
->codec_id
= AV_CODEC_ID_AC3
;
804 sub_st
->need_parsing
= AVSTREAM_PARSE_FULL
;
805 sub_pes
->sub_st
= pes
->sub_st
= sub_st
;
808 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
)
809 mpegts_find_stream_type(st
, pes
->stream_type
, MISC_types
);
810 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
) {
811 st
->codec
->codec_id
= old_codec_id
;
812 st
->codec
->codec_type
= old_codec_type
;
818 static void reset_pes_packet_state(PESContext
*pes
)
820 pes
->pts
= AV_NOPTS_VALUE
;
821 pes
->dts
= AV_NOPTS_VALUE
;
824 av_buffer_unref(&pes
->buffer
);
827 static void new_pes_packet(PESContext
*pes
, AVPacket
*pkt
)
831 pkt
->buf
= pes
->buffer
;
832 pkt
->data
= pes
->buffer
->data
;
833 pkt
->size
= pes
->data_index
;
835 if (pes
->total_size
!= MAX_PES_PAYLOAD
&&
836 pes
->pes_header_size
+ pes
->data_index
!= pes
->total_size
+
838 av_log(pes
->stream
, AV_LOG_WARNING
, "PES packet size mismatch\n");
839 pes
->flags
|= AV_PKT_FLAG_CORRUPT
;
841 memset(pkt
->data
+ pkt
->size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
843 // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
844 if (pes
->sub_st
&& pes
->stream_type
== 0x83 && pes
->extended_stream_id
== 0x76)
845 pkt
->stream_index
= pes
->sub_st
->index
;
847 pkt
->stream_index
= pes
->st
->index
;
850 /* store position of first TS packet of this PES packet */
851 pkt
->pos
= pes
->ts_packet_pos
;
852 pkt
->flags
= pes
->flags
;
855 reset_pes_packet_state(pes
);
858 static uint64_t get_ts64(GetBitContext
*gb
, int bits
)
860 if (get_bits_left(gb
) < bits
)
861 return AV_NOPTS_VALUE
;
862 return get_bits64(gb
, bits
);
865 static int read_sl_header(PESContext
*pes
, SLConfigDescr
*sl
,
866 const uint8_t *buf
, int buf_size
)
869 int au_start_flag
= 0, au_end_flag
= 0, ocr_flag
= 0, idle_flag
= 0;
870 int padding_flag
= 0, padding_bits
= 0, inst_bitrate_flag
= 0;
871 int dts_flag
= -1, cts_flag
= -1;
872 int64_t dts
= AV_NOPTS_VALUE
, cts
= AV_NOPTS_VALUE
;
873 uint8_t buf_padded
[128 + FF_INPUT_BUFFER_PADDING_SIZE
];
874 int buf_padded_size
= FFMIN(buf_size
, sizeof(buf_padded
) - FF_INPUT_BUFFER_PADDING_SIZE
);
876 memcpy(buf_padded
, buf
, buf_padded_size
);
878 init_get_bits(&gb
, buf_padded
, buf_padded_size
* 8);
880 if (sl
->use_au_start
)
881 au_start_flag
= get_bits1(&gb
);
883 au_end_flag
= get_bits1(&gb
);
884 if (!sl
->use_au_start
&& !sl
->use_au_end
)
885 au_start_flag
= au_end_flag
= 1;
887 ocr_flag
= get_bits1(&gb
);
889 idle_flag
= get_bits1(&gb
);
891 padding_flag
= get_bits1(&gb
);
893 padding_bits
= get_bits(&gb
, 3);
895 if (!idle_flag
&& (!padding_flag
|| padding_bits
!= 0)) {
896 if (sl
->packet_seq_num_len
)
897 skip_bits_long(&gb
, sl
->packet_seq_num_len
);
898 if (sl
->degr_prior_len
)
900 skip_bits(&gb
, sl
->degr_prior_len
);
902 skip_bits_long(&gb
, sl
->ocr_len
);
904 if (sl
->use_rand_acc_pt
)
906 if (sl
->au_seq_num_len
> 0)
907 skip_bits_long(&gb
, sl
->au_seq_num_len
);
908 if (sl
->use_timestamps
) {
909 dts_flag
= get_bits1(&gb
);
910 cts_flag
= get_bits1(&gb
);
913 if (sl
->inst_bitrate_len
)
914 inst_bitrate_flag
= get_bits1(&gb
);
916 dts
= get_ts64(&gb
, sl
->timestamp_len
);
918 cts
= get_ts64(&gb
, sl
->timestamp_len
);
920 skip_bits_long(&gb
, sl
->au_len
);
921 if (inst_bitrate_flag
)
922 skip_bits_long(&gb
, sl
->inst_bitrate_len
);
925 if (dts
!= AV_NOPTS_VALUE
)
927 if (cts
!= AV_NOPTS_VALUE
)
930 if (sl
->timestamp_len
&& sl
->timestamp_res
)
931 avpriv_set_pts_info(pes
->st
, sl
->timestamp_len
, 1, sl
->timestamp_res
);
933 return (get_bits_count(&gb
) + 7) >> 3;
936 /* return non zero if a packet could be constructed */
937 static int mpegts_push_data(MpegTSFilter
*filter
,
938 const uint8_t *buf
, int buf_size
, int is_start
,
941 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
942 MpegTSContext
*ts
= pes
->ts
;
950 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
951 new_pes_packet(pes
, ts
->pkt
);
954 reset_pes_packet_state(pes
);
956 pes
->state
= MPEGTS_HEADER
;
957 pes
->ts_packet_pos
= pos
;
960 while (buf_size
> 0) {
961 switch (pes
->state
) {
963 len
= PES_START_SIZE
- pes
->data_index
;
966 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
967 pes
->data_index
+= len
;
970 if (pes
->data_index
== PES_START_SIZE
) {
971 /* we got all the PES or section header. We can now
973 if (pes
->header
[0] == 0x00 && pes
->header
[1] == 0x00 &&
974 pes
->header
[2] == 0x01) {
975 /* it must be an mpeg2 PES stream */
976 code
= pes
->header
[3] | 0x100;
977 av_dlog(pes
->stream
, "pid=%x pes_code=%#x\n", pes
->pid
,
980 if ((pes
->st
&& pes
->st
->discard
== AVDISCARD_ALL
&&
982 pes
->sub_st
->discard
== AVDISCARD_ALL
)) ||
983 code
== 0x1be) /* padding_stream */
986 /* stream not present in PMT */
988 if (ts
->skip_changes
)
991 pes
->st
= avformat_new_stream(ts
->stream
, NULL
);
993 return AVERROR(ENOMEM
);
994 pes
->st
->id
= pes
->pid
;
995 mpegts_set_stream_info(pes
->st
, pes
, 0, 0);
998 pes
->total_size
= AV_RB16(pes
->header
+ 4);
999 /* NOTE: a zero total size means the PES size is
1001 if (!pes
->total_size
)
1002 pes
->total_size
= MAX_PES_PAYLOAD
;
1004 /* allocate pes buffer */
1005 pes
->buffer
= av_buffer_alloc(pes
->total_size
+
1006 FF_INPUT_BUFFER_PADDING_SIZE
);
1008 return AVERROR(ENOMEM
);
1010 if (code
!= 0x1bc && code
!= 0x1bf && /* program_stream_map, private_stream_2 */
1011 code
!= 0x1f0 && code
!= 0x1f1 && /* ECM, EMM */
1012 code
!= 0x1ff && code
!= 0x1f2 && /* program_stream_directory, DSMCC_stream */
1013 code
!= 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
1014 pes
->state
= MPEGTS_PESHEADER
;
1015 if (pes
->st
->codec
->codec_id
== AV_CODEC_ID_NONE
&& !pes
->st
->request_probe
) {
1016 av_dlog(pes
->stream
,
1017 "pid=%x stream_type=%x probing\n",
1020 pes
->st
->request_probe
= 1;
1023 pes
->state
= MPEGTS_PAYLOAD
;
1024 pes
->data_index
= 0;
1027 /* otherwise, it should be a table */
1030 pes
->state
= MPEGTS_SKIP
;
1035 /**********************************************/
1036 /* PES packing parsing */
1037 case MPEGTS_PESHEADER
:
1038 len
= PES_HEADER_SIZE
- pes
->data_index
;
1040 return AVERROR_INVALIDDATA
;
1043 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
1044 pes
->data_index
+= len
;
1047 if (pes
->data_index
== PES_HEADER_SIZE
) {
1048 pes
->pes_header_size
= pes
->header
[8] + 9;
1049 pes
->state
= MPEGTS_PESHEADER_FILL
;
1052 case MPEGTS_PESHEADER_FILL
:
1053 len
= pes
->pes_header_size
- pes
->data_index
;
1055 return AVERROR_INVALIDDATA
;
1058 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
1059 pes
->data_index
+= len
;
1062 if (pes
->data_index
== pes
->pes_header_size
) {
1064 unsigned int flags
, pes_ext
, skip
;
1066 flags
= pes
->header
[7];
1067 r
= pes
->header
+ 9;
1068 pes
->pts
= AV_NOPTS_VALUE
;
1069 pes
->dts
= AV_NOPTS_VALUE
;
1070 if ((flags
& 0xc0) == 0x80) {
1071 pes
->dts
= pes
->pts
= ff_parse_pes_pts(r
);
1073 } else if ((flags
& 0xc0) == 0xc0) {
1074 pes
->pts
= ff_parse_pes_pts(r
);
1076 pes
->dts
= ff_parse_pes_pts(r
);
1079 pes
->extended_stream_id
= -1;
1080 if (flags
& 0x01) { /* PES extension */
1082 /* Skip PES private data, program packet sequence counter and P-STD buffer */
1083 skip
= (pes_ext
>> 4) & 0xb;
1086 if ((pes_ext
& 0x41) == 0x01 &&
1087 (r
+ 2) <= (pes
->header
+ pes
->pes_header_size
)) {
1088 /* PES extension 2 */
1089 if ((r
[0] & 0x7f) > 0 && (r
[1] & 0x80) == 0)
1090 pes
->extended_stream_id
= r
[1];
1094 /* we got the full header. We parse it and get the payload */
1095 pes
->state
= MPEGTS_PAYLOAD
;
1096 pes
->data_index
= 0;
1097 if (pes
->stream_type
== 0x12 && buf_size
> 0) {
1098 int sl_header_bytes
= read_sl_header(pes
, &pes
->sl
, p
,
1100 pes
->pes_header_size
+= sl_header_bytes
;
1101 p
+= sl_header_bytes
;
1102 buf_size
-= sl_header_bytes
;
1104 if (pes
->stream_type
== 0x15 && buf_size
>= 5) {
1105 /* skip metadata access unit header */
1106 pes
->pes_header_size
+= 5;
1110 if (pes
->ts
->fix_teletext_pts
&& pes
->st
->codec
->codec_id
== AV_CODEC_ID_DVB_TELETEXT
) {
1111 AVProgram
*p
= NULL
;
1112 while ((p
= av_find_program_from_stream(pes
->stream
, p
, pes
->st
->index
))) {
1113 if (p
->pcr_pid
!= -1 && p
->discard
!= AVDISCARD_ALL
) {
1114 MpegTSFilter
*f
= pes
->ts
->pids
[p
->pcr_pid
];
1116 AVStream
*st
= NULL
;
1117 if (f
->type
== MPEGTS_PES
) {
1118 PESContext
*pcrpes
= f
->u
.pes_filter
.opaque
;
1121 } else if (f
->type
== MPEGTS_PCR
) {
1123 for (i
= 0; i
< p
->nb_stream_indexes
; i
++) {
1124 AVStream
*pst
= pes
->stream
->streams
[p
->stream_index
[i
]];
1125 if (pst
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
)
1129 if (f
->last_pcr
!= -1 && st
&& st
->discard
!= AVDISCARD_ALL
) {
1130 // teletext packets do not always have correct timestamps,
1131 // the standard says they should be handled after 40.6 ms at most,
1132 // and the pcr error to this packet should be no more than 100 ms.
1133 // TODO: we should interpolate the PCR, not just use the last one
1134 int64_t pcr
= f
->last_pcr
/ 300;
1135 pes
->st
->pts_wrap_reference
= st
->pts_wrap_reference
;
1136 pes
->st
->pts_wrap_behavior
= st
->pts_wrap_behavior
;
1137 if (pes
->dts
== AV_NOPTS_VALUE
|| pes
->dts
< pcr
) {
1138 pes
->pts
= pes
->dts
= pcr
;
1139 } else if (pes
->dts
> pcr
+ 3654 + 9000) {
1140 pes
->pts
= pes
->dts
= pcr
+ 3654 + 9000;
1150 case MPEGTS_PAYLOAD
:
1152 if (pes
->data_index
> 0 &&
1153 pes
->data_index
+ buf_size
> pes
->total_size
) {
1154 new_pes_packet(pes
, ts
->pkt
);
1155 pes
->total_size
= MAX_PES_PAYLOAD
;
1156 pes
->buffer
= av_buffer_alloc(pes
->total_size
+
1157 FF_INPUT_BUFFER_PADDING_SIZE
);
1159 return AVERROR(ENOMEM
);
1161 } else if (pes
->data_index
== 0 &&
1162 buf_size
> pes
->total_size
) {
1163 // pes packet size is < ts size packet and pes data is padded with 0xff
1164 // not sure if this is legal in ts but see issue #2392
1165 buf_size
= pes
->total_size
;
1167 memcpy(pes
->buffer
->data
+ pes
->data_index
, p
, buf_size
);
1168 pes
->data_index
+= buf_size
;
1169 /* emit complete packets with known packet size
1170 * decreases demuxer delay for infrequent packets like subtitles from
1171 * a couple of seconds to milliseconds for properly muxed files.
1172 * total_size is the number of bytes following pes_packet_length
1173 * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
1174 if (!ts
->stop_parse
&& pes
->total_size
< MAX_PES_PAYLOAD
&&
1175 pes
->pes_header_size
+ pes
->data_index
== pes
->total_size
+ PES_START_SIZE
) {
1177 new_pes_packet(pes
, ts
->pkt
);
1191 static PESContext
*add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
)
1196 /* if no pid found, then add a pid context */
1197 pes
= av_mallocz(sizeof(PESContext
));
1201 pes
->stream
= ts
->stream
;
1203 pes
->pcr_pid
= pcr_pid
;
1204 pes
->state
= MPEGTS_SKIP
;
1205 pes
->pts
= AV_NOPTS_VALUE
;
1206 pes
->dts
= AV_NOPTS_VALUE
;
1207 tss
= mpegts_open_pes_filter(ts
, pid
, mpegts_push_data
, pes
);
1220 Mp4Descr
*active_descr
;
1222 int max_descr_count
;
1224 int predefined_SLConfigDescriptor_seen
;
1225 } MP4DescrParseContext
;
1227 static int init_MP4DescrParseContext(MP4DescrParseContext
*d
, AVFormatContext
*s
,
1228 const uint8_t *buf
, unsigned size
,
1229 Mp4Descr
*descr
, int max_descr_count
)
1232 if (size
> (1 << 30))
1233 return AVERROR_INVALIDDATA
;
1235 if ((ret
= ffio_init_context(&d
->pb
, (unsigned char *)buf
, size
, 0,
1236 NULL
, NULL
, NULL
, NULL
)) < 0)
1243 d
->active_descr
= NULL
;
1244 d
->max_descr_count
= max_descr_count
;
1249 static void update_offsets(AVIOContext
*pb
, int64_t *off
, int *len
)
1251 int64_t new_off
= avio_tell(pb
);
1252 (*len
) -= new_off
- *off
;
1256 static int parse_mp4_descr(MP4DescrParseContext
*d
, int64_t off
, int len
,
1259 static int parse_mp4_descr_arr(MP4DescrParseContext
*d
, int64_t off
, int len
)
1262 int ret
= parse_mp4_descr(d
, off
, len
, 0);
1265 update_offsets(&d
->pb
, &off
, &len
);
1270 static int parse_MP4IODescrTag(MP4DescrParseContext
*d
, int64_t off
, int len
)
1272 avio_rb16(&d
->pb
); // ID
1278 update_offsets(&d
->pb
, &off
, &len
);
1279 return parse_mp4_descr_arr(d
, off
, len
);
1282 static int parse_MP4ODescrTag(MP4DescrParseContext
*d
, int64_t off
, int len
)
1287 id_flags
= avio_rb16(&d
->pb
);
1288 if (!(id_flags
& 0x0020)) { // URL_Flag
1289 update_offsets(&d
->pb
, &off
, &len
);
1290 return parse_mp4_descr_arr(d
, off
, len
); // ES_Descriptor[]
1296 static int parse_MP4ESDescrTag(MP4DescrParseContext
*d
, int64_t off
, int len
)
1299 if (d
->descr_count
>= d
->max_descr_count
)
1300 return AVERROR_INVALIDDATA
;
1301 ff_mp4_parse_es_descr(&d
->pb
, &es_id
);
1302 d
->active_descr
= d
->descr
+ (d
->descr_count
++);
1304 d
->active_descr
->es_id
= es_id
;
1305 update_offsets(&d
->pb
, &off
, &len
);
1306 parse_mp4_descr(d
, off
, len
, MP4DecConfigDescrTag
);
1307 update_offsets(&d
->pb
, &off
, &len
);
1309 parse_mp4_descr(d
, off
, len
, MP4SLDescrTag
);
1310 d
->active_descr
= NULL
;
1314 static int parse_MP4DecConfigDescrTag(MP4DescrParseContext
*d
, int64_t off
,
1317 Mp4Descr
*descr
= d
->active_descr
;
1319 return AVERROR_INVALIDDATA
;
1320 d
->active_descr
->dec_config_descr
= av_malloc(len
);
1321 if (!descr
->dec_config_descr
)
1322 return AVERROR(ENOMEM
);
1323 descr
->dec_config_descr_len
= len
;
1324 avio_read(&d
->pb
, descr
->dec_config_descr
, len
);
1328 static int parse_MP4SLDescrTag(MP4DescrParseContext
*d
, int64_t off
, int len
)
1330 Mp4Descr
*descr
= d
->active_descr
;
1333 return AVERROR_INVALIDDATA
;
1335 predefined
= avio_r8(&d
->pb
);
1338 int flags
= avio_r8(&d
->pb
);
1339 descr
->sl
.use_au_start
= !!(flags
& 0x80);
1340 descr
->sl
.use_au_end
= !!(flags
& 0x40);
1341 descr
->sl
.use_rand_acc_pt
= !!(flags
& 0x20);
1342 descr
->sl
.use_padding
= !!(flags
& 0x08);
1343 descr
->sl
.use_timestamps
= !!(flags
& 0x04);
1344 descr
->sl
.use_idle
= !!(flags
& 0x02);
1345 descr
->sl
.timestamp_res
= avio_rb32(&d
->pb
);
1347 descr
->sl
.timestamp_len
= avio_r8(&d
->pb
);
1348 if (descr
->sl
.timestamp_len
> 64) {
1349 avpriv_request_sample(NULL
, "timestamp_len > 64");
1350 descr
->sl
.timestamp_len
= 64;
1351 return AVERROR_PATCHWELCOME
;
1353 descr
->sl
.ocr_len
= avio_r8(&d
->pb
);
1354 descr
->sl
.au_len
= avio_r8(&d
->pb
);
1355 descr
->sl
.inst_bitrate_len
= avio_r8(&d
->pb
);
1356 lengths
= avio_rb16(&d
->pb
);
1357 descr
->sl
.degr_prior_len
= lengths
>> 12;
1358 descr
->sl
.au_seq_num_len
= (lengths
>> 7) & 0x1f;
1359 descr
->sl
.packet_seq_num_len
= (lengths
>> 2) & 0x1f;
1360 } else if (!d
->predefined_SLConfigDescriptor_seen
){
1361 avpriv_report_missing_feature(d
->s
, "Predefined SLConfigDescriptor");
1362 d
->predefined_SLConfigDescriptor_seen
= 1;
1367 static int parse_mp4_descr(MP4DescrParseContext
*d
, int64_t off
, int len
,
1371 int len1
= ff_mp4_read_descr(d
->s
, &d
->pb
, &tag
);
1372 update_offsets(&d
->pb
, &off
, &len
);
1373 if (len
< 0 || len1
> len
|| len1
<= 0) {
1374 av_log(d
->s
, AV_LOG_ERROR
,
1375 "Tag %x length violation new length %d bytes remaining %d\n",
1377 return AVERROR_INVALIDDATA
;
1380 if (d
->level
++ >= MAX_LEVEL
) {
1381 av_log(d
->s
, AV_LOG_ERROR
, "Maximum MP4 descriptor level exceeded\n");
1385 if (target_tag
&& tag
!= target_tag
) {
1386 av_log(d
->s
, AV_LOG_ERROR
, "Found tag %x expected %x\n", tag
,
1393 parse_MP4IODescrTag(d
, off
, len1
);
1396 parse_MP4ODescrTag(d
, off
, len1
);
1399 parse_MP4ESDescrTag(d
, off
, len1
);
1401 case MP4DecConfigDescrTag
:
1402 parse_MP4DecConfigDescrTag(d
, off
, len1
);
1405 parse_MP4SLDescrTag(d
, off
, len1
);
1412 avio_seek(&d
->pb
, off
+ len1
, SEEK_SET
);
1416 static int mp4_read_iods(AVFormatContext
*s
, const uint8_t *buf
, unsigned size
,
1417 Mp4Descr
*descr
, int *descr_count
, int max_descr_count
)
1419 MP4DescrParseContext d
;
1422 ret
= init_MP4DescrParseContext(&d
, s
, buf
, size
, descr
, max_descr_count
);
1426 ret
= parse_mp4_descr(&d
, avio_tell(&d
.pb
), size
, MP4IODescrTag
);
1428 *descr_count
= d
.descr_count
;
1432 static int mp4_read_od(AVFormatContext
*s
, const uint8_t *buf
, unsigned size
,
1433 Mp4Descr
*descr
, int *descr_count
, int max_descr_count
)
1435 MP4DescrParseContext d
;
1438 ret
= init_MP4DescrParseContext(&d
, s
, buf
, size
, descr
, max_descr_count
);
1442 ret
= parse_mp4_descr_arr(&d
, avio_tell(&d
.pb
), size
);
1444 *descr_count
= d
.descr_count
;
1448 static void m4sl_cb(MpegTSFilter
*filter
, const uint8_t *section
,
1451 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
1453 const uint8_t *p
, *p_end
;
1455 int mp4_descr_count
= 0;
1456 Mp4Descr mp4_descr
[MAX_MP4_DESCR_COUNT
] = { { 0 } };
1458 AVFormatContext
*s
= ts
->stream
;
1460 p_end
= section
+ section_len
- 4;
1462 if (parse_section_header(&h
, &p
, p_end
) < 0)
1464 if (h
.tid
!= M4OD_TID
)
1467 mp4_read_od(s
, p
, (unsigned) (p_end
- p
), mp4_descr
, &mp4_descr_count
,
1468 MAX_MP4_DESCR_COUNT
);
1470 for (pid
= 0; pid
< NB_PID_MAX
; pid
++) {
1473 for (i
= 0; i
< mp4_descr_count
; i
++) {
1476 if (ts
->pids
[pid
]->es_id
!= mp4_descr
[i
].es_id
)
1478 if (ts
->pids
[pid
]->type
!= MPEGTS_PES
) {
1479 av_log(s
, AV_LOG_ERROR
, "pid %x is not PES\n", pid
);
1482 pes
= ts
->pids
[pid
]->u
.pes_filter
.opaque
;
1487 pes
->sl
= mp4_descr
[i
].sl
;
1489 ffio_init_context(&pb
, mp4_descr
[i
].dec_config_descr
,
1490 mp4_descr
[i
].dec_config_descr_len
, 0,
1491 NULL
, NULL
, NULL
, NULL
);
1492 ff_mp4_read_dec_config_descr(s
, st
, &pb
);
1493 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&&
1494 st
->codec
->extradata_size
> 0)
1495 st
->need_parsing
= 0;
1496 if (st
->codec
->codec_id
== AV_CODEC_ID_H264
&&
1497 st
->codec
->extradata_size
> 0)
1498 st
->need_parsing
= 0;
1500 if (st
->codec
->codec_id
<= AV_CODEC_ID_NONE
) {
1502 } else if (st
->codec
->codec_id
< AV_CODEC_ID_FIRST_AUDIO
)
1503 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
1504 else if (st
->codec
->codec_id
< AV_CODEC_ID_FIRST_SUBTITLE
)
1505 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
1506 else if (st
->codec
->codec_id
< AV_CODEC_ID_FIRST_UNKNOWN
)
1507 st
->codec
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
1510 for (i
= 0; i
< mp4_descr_count
; i
++)
1511 av_free(mp4_descr
[i
].dec_config_descr
);
1514 static const uint8_t opus_coupled_stream_cnt
[9] = {
1515 1, 0, 1, 1, 2, 2, 2, 3, 3
1518 static const uint8_t opus_channel_map
[8][8] = {
1526 { 0,6,1,2,3,4,5,7 },
1529 int ff_parse_mpeg2_descriptor(AVFormatContext
*fc
, AVStream
*st
, int stream_type
,
1530 const uint8_t **pp
, const uint8_t *desc_list_end
,
1531 Mp4Descr
*mp4_descr
, int mp4_descr_count
, int pid
,
1534 const uint8_t *desc_end
;
1535 int desc_len
, desc_tag
, desc_es_id
, ext_desc_tag
, channels
, channel_config_code
;
1539 desc_tag
= get8(pp
, desc_list_end
);
1541 return AVERROR_INVALIDDATA
;
1542 desc_len
= get8(pp
, desc_list_end
);
1544 return AVERROR_INVALIDDATA
;
1545 desc_end
= *pp
+ desc_len
;
1546 if (desc_end
> desc_list_end
)
1547 return AVERROR_INVALIDDATA
;
1549 av_dlog(fc
, "tag: 0x%02x len=%d\n", desc_tag
, desc_len
);
1551 if ((st
->codec
->codec_id
== AV_CODEC_ID_NONE
|| st
->request_probe
> 0) &&
1552 stream_type
== STREAM_TYPE_PRIVATE_DATA
)
1553 mpegts_find_stream_type(st
, desc_tag
, DESC_types
);
1556 case 0x1E: /* SL descriptor */
1557 desc_es_id
= get16(pp
, desc_end
);
1558 if (ts
&& ts
->pids
[pid
])
1559 ts
->pids
[pid
]->es_id
= desc_es_id
;
1560 for (i
= 0; i
< mp4_descr_count
; i
++)
1561 if (mp4_descr
[i
].dec_config_descr_len
&&
1562 mp4_descr
[i
].es_id
== desc_es_id
) {
1564 ffio_init_context(&pb
, mp4_descr
[i
].dec_config_descr
,
1565 mp4_descr
[i
].dec_config_descr_len
, 0,
1566 NULL
, NULL
, NULL
, NULL
);
1567 ff_mp4_read_dec_config_descr(fc
, st
, &pb
);
1568 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&&
1569 st
->codec
->extradata_size
> 0)
1570 st
->need_parsing
= 0;
1571 if (st
->codec
->codec_id
== AV_CODEC_ID_MPEG4SYSTEMS
)
1572 mpegts_open_section_filter(ts
, pid
, m4sl_cb
, ts
, 1);
1575 case 0x1F: /* FMC descriptor */
1576 get16(pp
, desc_end
);
1577 if (mp4_descr_count
> 0 &&
1578 (st
->codec
->codec_id
== AV_CODEC_ID_AAC_LATM
|| st
->request_probe
> 0) &&
1579 mp4_descr
->dec_config_descr_len
&& mp4_descr
->es_id
== pid
) {
1581 ffio_init_context(&pb
, mp4_descr
->dec_config_descr
,
1582 mp4_descr
->dec_config_descr_len
, 0,
1583 NULL
, NULL
, NULL
, NULL
);
1584 ff_mp4_read_dec_config_descr(fc
, st
, &pb
);
1585 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&&
1586 st
->codec
->extradata_size
> 0) {
1587 st
->request_probe
= st
->need_parsing
= 0;
1588 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
1592 case 0x56: /* DVB teletext descriptor */
1594 uint8_t *extradata
= NULL
;
1595 int language_count
= desc_len
/ 5;
1597 if (desc_len
> 0 && desc_len
% 5 != 0)
1598 return AVERROR_INVALIDDATA
;
1600 if (language_count
> 0) {
1601 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1602 if (language_count
> sizeof(language
) / 4) {
1603 language_count
= sizeof(language
) / 4;
1606 if (st
->codec
->extradata
== NULL
) {
1607 if (ff_alloc_extradata(st
->codec
, language_count
* 2)) {
1608 return AVERROR(ENOMEM
);
1612 if (st
->codec
->extradata_size
< language_count
* 2)
1613 return AVERROR_INVALIDDATA
;
1615 extradata
= st
->codec
->extradata
;
1617 for (i
= 0; i
< language_count
; i
++) {
1618 language
[i
* 4 + 0] = get8(pp
, desc_end
);
1619 language
[i
* 4 + 1] = get8(pp
, desc_end
);
1620 language
[i
* 4 + 2] = get8(pp
, desc_end
);
1621 language
[i
* 4 + 3] = ',';
1623 memcpy(extradata
, *pp
, 2);
1629 language
[i
* 4 - 1] = 0;
1630 av_dict_set(&st
->metadata
, "language", language
, 0);
1634 case 0x59: /* subtitling descriptor */
1636 /* 8 bytes per DVB subtitle substream data:
1637 * ISO_639_language_code (3 bytes),
1638 * subtitling_type (1 byte),
1639 * composition_page_id (2 bytes),
1640 * ancillary_page_id (2 bytes) */
1641 int language_count
= desc_len
/ 8;
1643 if (desc_len
> 0 && desc_len
% 8 != 0)
1644 return AVERROR_INVALIDDATA
;
1646 if (language_count
> 1) {
1647 avpriv_request_sample(fc
, "DVB subtitles with multiple languages");
1650 if (language_count
> 0) {
1653 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1654 if (language_count
> sizeof(language
) / 4) {
1655 language_count
= sizeof(language
) / 4;
1658 if (st
->codec
->extradata
== NULL
) {
1659 if (ff_alloc_extradata(st
->codec
, language_count
* 5)) {
1660 return AVERROR(ENOMEM
);
1664 if (st
->codec
->extradata_size
< language_count
* 5)
1665 return AVERROR_INVALIDDATA
;
1667 extradata
= st
->codec
->extradata
;
1669 for (i
= 0; i
< language_count
; i
++) {
1670 language
[i
* 4 + 0] = get8(pp
, desc_end
);
1671 language
[i
* 4 + 1] = get8(pp
, desc_end
);
1672 language
[i
* 4 + 2] = get8(pp
, desc_end
);
1673 language
[i
* 4 + 3] = ',';
1675 /* hearing impaired subtitles detection using subtitling_type */
1677 case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1678 case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1679 case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1680 case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1681 case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1682 case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1683 st
->disposition
|= AV_DISPOSITION_HEARING_IMPAIRED
;
1687 extradata
[4] = get8(pp
, desc_end
); /* subtitling_type */
1688 memcpy(extradata
, *pp
, 4); /* composition_page_id and ancillary_page_id */
1694 language
[i
* 4 - 1] = 0;
1695 av_dict_set(&st
->metadata
, "language", language
, 0);
1699 case 0x0a: /* ISO 639 language descriptor */
1700 for (i
= 0; i
+ 4 <= desc_len
; i
+= 4) {
1701 language
[i
+ 0] = get8(pp
, desc_end
);
1702 language
[i
+ 1] = get8(pp
, desc_end
);
1703 language
[i
+ 2] = get8(pp
, desc_end
);
1704 language
[i
+ 3] = ',';
1705 switch (get8(pp
, desc_end
)) {
1707 st
->disposition
|= AV_DISPOSITION_CLEAN_EFFECTS
;
1710 st
->disposition
|= AV_DISPOSITION_HEARING_IMPAIRED
;
1713 st
->disposition
|= AV_DISPOSITION_VISUAL_IMPAIRED
;
1717 if (i
&& language
[0]) {
1718 language
[i
- 1] = 0;
1719 av_dict_set(&st
->metadata
, "language", language
, 0);
1722 case 0x05: /* registration descriptor */
1723 st
->codec
->codec_tag
= bytestream_get_le32(pp
);
1724 av_dlog(fc
, "reg_desc=%.4s\n", (char *)&st
->codec
->codec_tag
);
1725 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
)
1726 mpegts_find_stream_type(st
, st
->codec
->codec_tag
, REGD_types
);
1728 case 0x52: /* stream identifier descriptor */
1729 st
->stream_identifier
= 1 + get8(pp
, desc_end
);
1731 case 0x26: /* metadata descriptor */
1732 if (get16(pp
, desc_end
) == 0xFFFF)
1734 if (get8(pp
, desc_end
) == 0xFF) {
1735 st
->codec
->codec_tag
= bytestream_get_le32(pp
);
1736 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
)
1737 mpegts_find_stream_type(st
, st
->codec
->codec_tag
, METADATA_types
);
1740 case 0x7f: /* DVB extension descriptor */
1741 ext_desc_tag
= get8(pp
, desc_end
);
1742 if (ext_desc_tag
< 0)
1743 return AVERROR_INVALIDDATA
;
1744 if (st
->codec
->codec_id
== AV_CODEC_ID_OPUS
&&
1745 ext_desc_tag
== 0x80) { /* User defined (provisional Opus) */
1746 if (!st
->codec
->extradata
) {
1747 st
->codec
->extradata
= av_mallocz(sizeof(opus_default_extradata
) +
1748 FF_INPUT_BUFFER_PADDING_SIZE
);
1749 if (!st
->codec
->extradata
)
1750 return AVERROR(ENOMEM
);
1752 st
->codec
->extradata_size
= sizeof(opus_default_extradata
);
1753 memcpy(st
->codec
->extradata
, opus_default_extradata
, sizeof(opus_default_extradata
));
1755 channel_config_code
= get8(pp
, desc_end
);
1756 if (channel_config_code
< 0)
1757 return AVERROR_INVALIDDATA
;
1758 if (channel_config_code
<= 0x8) {
1759 st
->codec
->extradata
[9] = channels
= channel_config_code
? channel_config_code
: 2;
1760 st
->codec
->extradata
[18] = channels
> 2;
1761 st
->codec
->extradata
[19] = channel_config_code
;
1762 if (channel_config_code
== 0) { /* Dual Mono */
1763 st
->codec
->extradata
[18] = 255; /* Mapping */
1764 st
->codec
->extradata
[19] = 2; /* Stream Count */
1766 st
->codec
->extradata
[20] = opus_coupled_stream_cnt
[channel_config_code
];
1767 memcpy(&st
->codec
->extradata
[21], opus_channel_map
[channels
- 1], channels
);
1769 avpriv_request_sample(fc
, "Opus in MPEG-TS - channel_config_code > 0x8");
1771 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
1782 static void pmt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
1784 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
1785 SectionHeader h1
, *h
= &h1
;
1788 const uint8_t *p
, *p_end
, *desc_list_end
;
1789 int program_info_length
, pcr_pid
, pid
, stream_type
;
1791 uint32_t prog_reg_desc
= 0; /* registration descriptor */
1793 int mp4_descr_count
= 0;
1794 Mp4Descr mp4_descr
[MAX_MP4_DESCR_COUNT
] = { { 0 } };
1797 av_dlog(ts
->stream
, "PMT: len %i\n", section_len
);
1798 hex_dump_debug(ts
->stream
, section
, section_len
);
1800 p_end
= section
+ section_len
- 4;
1802 if (parse_section_header(h
, &p
, p_end
) < 0)
1805 av_dlog(ts
->stream
, "sid=0x%x sec_num=%d/%d version=%d\n",
1806 h
->id
, h
->sec_num
, h
->last_sec_num
, h
->version
);
1808 if (h
->tid
!= PMT_TID
)
1810 if (!ts
->scan_all_pmts
&& ts
->skip_changes
)
1813 if (!ts
->skip_clear
)
1814 clear_program(ts
, h
->id
);
1816 pcr_pid
= get16(&p
, p_end
);
1820 add_pid_to_pmt(ts
, h
->id
, pcr_pid
);
1821 set_pcr_pid(ts
->stream
, h
->id
, pcr_pid
);
1823 av_dlog(ts
->stream
, "pcr_pid=0x%x\n", pcr_pid
);
1825 program_info_length
= get16(&p
, p_end
);
1826 if (program_info_length
< 0)
1828 program_info_length
&= 0xfff;
1829 while (program_info_length
>= 2) {
1831 tag
= get8(&p
, p_end
);
1832 len
= get8(&p
, p_end
);
1834 av_dlog(ts
->stream
, "program tag: 0x%02x len=%d\n", tag
, len
);
1836 if (len
> program_info_length
- 2)
1837 // something else is broken, exit the program_descriptors_loop
1839 program_info_length
-= len
+ 2;
1840 if (tag
== 0x1d) { // IOD descriptor
1841 get8(&p
, p_end
); // scope
1842 get8(&p
, p_end
); // label
1844 mp4_read_iods(ts
->stream
, p
, len
, mp4_descr
+ mp4_descr_count
,
1845 &mp4_descr_count
, MAX_MP4_DESCR_COUNT
);
1846 } else if (tag
== 0x05 && len
>= 4) { // registration descriptor
1847 prog_reg_desc
= bytestream_get_le32(&p
);
1852 p
+= program_info_length
;
1856 // stop parsing after pmt, we found header
1857 if (!ts
->stream
->nb_streams
)
1860 set_pmt_found(ts
, h
->id
);
1866 stream_type
= get8(&p
, p_end
);
1867 if (stream_type
< 0)
1869 pid
= get16(&p
, p_end
);
1873 if (pid
== ts
->current_pid
)
1876 /* now create stream */
1877 if (ts
->pids
[pid
] && ts
->pids
[pid
]->type
== MPEGTS_PES
) {
1878 pes
= ts
->pids
[pid
]->u
.pes_filter
.opaque
;
1880 pes
->st
= avformat_new_stream(pes
->stream
, NULL
);
1883 pes
->st
->id
= pes
->pid
;
1886 } else if (stream_type
!= 0x13) {
1888 mpegts_close_filter(ts
, ts
->pids
[pid
]); // wrongly added sdt filter probably
1889 pes
= add_pes_stream(ts
, pid
, pcr_pid
);
1891 st
= avformat_new_stream(pes
->stream
, NULL
);
1897 int idx
= ff_find_stream_index(ts
->stream
, pid
);
1899 st
= ts
->stream
->streams
[idx
];
1901 st
= avformat_new_stream(ts
->stream
, NULL
);
1905 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
1912 if (pes
&& !pes
->stream_type
)
1913 mpegts_set_stream_info(st
, pes
, stream_type
, prog_reg_desc
);
1915 add_pid_to_pmt(ts
, h
->id
, pid
);
1917 ff_program_add_stream_index(ts
->stream
, h
->id
, st
->index
);
1919 desc_list_len
= get16(&p
, p_end
);
1920 if (desc_list_len
< 0)
1922 desc_list_len
&= 0xfff;
1923 desc_list_end
= p
+ desc_list_len
;
1924 if (desc_list_end
> p_end
)
1927 if (ff_parse_mpeg2_descriptor(ts
->stream
, st
, stream_type
, &p
,
1928 desc_list_end
, mp4_descr
,
1929 mp4_descr_count
, pid
, ts
) < 0)
1932 if (pes
&& prog_reg_desc
== AV_RL32("HDMV") &&
1933 stream_type
== 0x83 && pes
->sub_st
) {
1934 ff_program_add_stream_index(ts
->stream
, h
->id
,
1935 pes
->sub_st
->index
);
1936 pes
->sub_st
->codec
->codec_tag
= st
->codec
->codec_tag
;
1942 if (!ts
->pids
[pcr_pid
])
1943 mpegts_open_pcr_filter(ts
, pcr_pid
);
1946 for (i
= 0; i
< mp4_descr_count
; i
++)
1947 av_free(mp4_descr
[i
].dec_config_descr
);
1950 static void pat_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
1952 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
1953 SectionHeader h1
, *h
= &h1
;
1954 const uint8_t *p
, *p_end
;
1958 av_dlog(ts
->stream
, "PAT:\n");
1959 hex_dump_debug(ts
->stream
, section
, section_len
);
1961 p_end
= section
+ section_len
- 4;
1963 if (parse_section_header(h
, &p
, p_end
) < 0)
1965 if (h
->tid
!= PAT_TID
)
1967 if (ts
->skip_changes
)
1970 ts
->stream
->ts_id
= h
->id
;
1974 sid
= get16(&p
, p_end
);
1977 pmt_pid
= get16(&p
, p_end
);
1982 if (pmt_pid
== ts
->current_pid
)
1985 av_dlog(ts
->stream
, "sid=0x%x pid=0x%x\n", sid
, pmt_pid
);
1987 if (sid
== 0x0000) {
1990 MpegTSFilter
*fil
= ts
->pids
[pmt_pid
];
1991 program
= av_new_program(ts
->stream
, sid
);
1993 program
->program_num
= sid
;
1994 program
->pmt_pid
= pmt_pid
;
1997 if ( fil
->type
!= MPEGTS_SECTION
1998 || fil
->pid
!= pmt_pid
1999 || fil
->u
.section_filter
.section_cb
!= pmt_cb
)
2000 mpegts_close_filter(ts
, ts
->pids
[pmt_pid
]);
2002 if (!ts
->pids
[pmt_pid
])
2003 mpegts_open_section_filter(ts
, pmt_pid
, pmt_cb
, ts
, 1);
2004 add_pat_entry(ts
, sid
);
2005 add_pid_to_pmt(ts
, sid
, 0); // add pat pid to program
2006 add_pid_to_pmt(ts
, sid
, pmt_pid
);
2012 for (j
=0; j
<ts
->stream
->nb_programs
; j
++) {
2013 for (i
= 0; i
< ts
->nb_prg
; i
++)
2014 if (ts
->prg
[i
].id
== ts
->stream
->programs
[j
]->id
)
2016 if (i
==ts
->nb_prg
&& !ts
->skip_clear
)
2017 clear_avprogram(ts
, ts
->stream
->programs
[j
]->id
);
2022 static void sdt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
2024 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
2025 SectionHeader h1
, *h
= &h1
;
2026 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
2027 int onid
, val
, sid
, desc_list_len
, desc_tag
, desc_len
, service_type
;
2028 char *name
, *provider_name
;
2030 av_dlog(ts
->stream
, "SDT:\n");
2031 hex_dump_debug(ts
->stream
, section
, section_len
);
2033 p_end
= section
+ section_len
- 4;
2035 if (parse_section_header(h
, &p
, p_end
) < 0)
2037 if (h
->tid
!= SDT_TID
)
2039 if (ts
->skip_changes
)
2041 onid
= get16(&p
, p_end
);
2044 val
= get8(&p
, p_end
);
2048 sid
= get16(&p
, p_end
);
2051 val
= get8(&p
, p_end
);
2054 desc_list_len
= get16(&p
, p_end
);
2055 if (desc_list_len
< 0)
2057 desc_list_len
&= 0xfff;
2058 desc_list_end
= p
+ desc_list_len
;
2059 if (desc_list_end
> p_end
)
2062 desc_tag
= get8(&p
, desc_list_end
);
2065 desc_len
= get8(&p
, desc_list_end
);
2066 desc_end
= p
+ desc_len
;
2067 if (desc_len
< 0 || desc_end
> desc_list_end
)
2070 av_dlog(ts
->stream
, "tag: 0x%02x len=%d\n",
2071 desc_tag
, desc_len
);
2075 service_type
= get8(&p
, p_end
);
2076 if (service_type
< 0)
2078 provider_name
= getstr8(&p
, p_end
);
2081 name
= getstr8(&p
, p_end
);
2083 AVProgram
*program
= av_new_program(ts
->stream
, sid
);
2085 av_dict_set(&program
->metadata
, "service_name", name
, 0);
2086 av_dict_set(&program
->metadata
, "service_provider",
2091 av_free(provider_name
);
2102 static int parse_pcr(int64_t *ppcr_high
, int *ppcr_low
,
2103 const uint8_t *packet
);
2105 /* handle one TS packet */
2106 static int handle_packet(MpegTSContext
*ts
, const uint8_t *packet
)
2109 int len
, pid
, cc
, expected_cc
, cc_ok
, afc
, is_start
, is_discontinuity
,
2110 has_adaptation
, has_payload
;
2111 const uint8_t *p
, *p_end
;
2114 pid
= AV_RB16(packet
+ 1) & 0x1fff;
2115 if (pid
&& discard_pid(ts
, pid
))
2117 is_start
= packet
[1] & 0x40;
2118 tss
= ts
->pids
[pid
];
2119 if (ts
->auto_guess
&& !tss
&& is_start
) {
2120 add_pes_stream(ts
, pid
, -1);
2121 tss
= ts
->pids
[pid
];
2125 ts
->current_pid
= pid
;
2127 afc
= (packet
[3] >> 4) & 3;
2128 if (afc
== 0) /* reserved value */
2130 has_adaptation
= afc
& 2;
2131 has_payload
= afc
& 1;
2132 is_discontinuity
= has_adaptation
&&
2133 packet
[4] != 0 && /* with length > 0 */
2134 (packet
[5] & 0x80); /* and discontinuity indicated */
2136 /* continuity check (currently not used) */
2137 cc
= (packet
[3] & 0xf);
2138 expected_cc
= has_payload
? (tss
->last_cc
+ 1) & 0x0f : tss
->last_cc
;
2139 cc_ok
= pid
== 0x1FFF || // null packet PID
2146 av_log(ts
->stream
, AV_LOG_DEBUG
,
2147 "Continuity check failed for pid %d expected %d got %d\n",
2148 pid
, expected_cc
, cc
);
2149 if (tss
->type
== MPEGTS_PES
) {
2150 PESContext
*pc
= tss
->u
.pes_filter
.opaque
;
2151 pc
->flags
|= AV_PKT_FLAG_CORRUPT
;
2156 if (has_adaptation
) {
2159 if (parse_pcr(&pcr_h
, &pcr_l
, packet
) == 0)
2160 tss
->last_pcr
= pcr_h
* 300 + pcr_l
;
2161 /* skip adaptation field */
2164 /* if past the end of packet, ignore */
2165 p_end
= packet
+ TS_PACKET_SIZE
;
2166 if (p
>= p_end
|| !has_payload
)
2169 pos
= avio_tell(ts
->stream
->pb
);
2171 av_assert0(pos
>= TS_PACKET_SIZE
);
2172 ts
->pos47_full
= pos
- TS_PACKET_SIZE
;
2175 if (tss
->type
== MPEGTS_SECTION
) {
2177 /* pointer field present */
2179 if (p
+ len
> p_end
)
2182 /* write remaining section bytes */
2183 write_section_data(ts
, tss
,
2185 /* check whether filter has been closed */
2191 write_section_data(ts
, tss
,
2196 write_section_data(ts
, tss
,
2201 // stop find_stream_info from waiting for more streams
2202 // when all programs have received a PMT
2203 if (ts
->stream
->ctx_flags
& AVFMTCTX_NOHEADER
&& ts
->scan_all_pmts
<= 0) {
2205 for (i
= 0; i
< ts
->nb_prg
; i
++) {
2206 if (!ts
->prg
[i
].pmt_found
)
2209 if (i
== ts
->nb_prg
&& ts
->nb_prg
> 0) {
2211 for (i
= 0; i
< ts
->stream
->nb_streams
; i
++) {
2212 AVStream
*st
= ts
->stream
->streams
[i
];
2213 types
|= 1<<st
->codec
->codec_type
;
2215 if ((types
& (1<<AVMEDIA_TYPE_AUDIO
) && types
& (1<<AVMEDIA_TYPE_VIDEO
)) || pos
> 100000) {
2216 av_log(ts
->stream
, AV_LOG_DEBUG
, "All programs have pmt, headers found\n");
2217 ts
->stream
->ctx_flags
&= ~AVFMTCTX_NOHEADER
;
2224 // Note: The position here points actually behind the current packet.
2225 if (tss
->type
== MPEGTS_PES
) {
2226 if ((ret
= tss
->u
.pes_filter
.pes_cb(tss
, p
, p_end
- p
, is_start
,
2227 pos
- ts
->raw_packet_size
)) < 0)
2235 static void reanalyze(MpegTSContext
*ts
) {
2236 AVIOContext
*pb
= ts
->stream
->pb
;
2237 int64_t pos
= avio_tell(pb
);
2240 pos
-= ts
->pos47_full
;
2241 if (pos
== TS_PACKET_SIZE
) {
2242 ts
->size_stat
[0] ++;
2243 } else if (pos
== TS_DVHS_PACKET_SIZE
) {
2244 ts
->size_stat
[1] ++;
2245 } else if (pos
== TS_FEC_PACKET_SIZE
) {
2246 ts
->size_stat
[2] ++;
2249 ts
->size_stat_count
++;
2250 if (ts
->size_stat_count
> SIZE_STAT_THRESHOLD
) {
2252 if (ts
->size_stat
[0] > SIZE_STAT_THRESHOLD
) {
2253 newsize
= TS_PACKET_SIZE
;
2254 } else if (ts
->size_stat
[1] > SIZE_STAT_THRESHOLD
) {
2255 newsize
= TS_DVHS_PACKET_SIZE
;
2256 } else if (ts
->size_stat
[2] > SIZE_STAT_THRESHOLD
) {
2257 newsize
= TS_FEC_PACKET_SIZE
;
2259 if (newsize
&& newsize
!= ts
->raw_packet_size
) {
2260 av_log(ts
->stream
, AV_LOG_WARNING
, "changing packet size to %d\n", newsize
);
2261 ts
->raw_packet_size
= newsize
;
2263 ts
->size_stat_count
= 0;
2264 memset(ts
->size_stat
, 0, sizeof(ts
->size_stat
));
2268 /* XXX: try to find a better synchro over several packets (use
2269 * get_packet_size() ?) */
2270 static int mpegts_resync(AVFormatContext
*s
)
2272 MpegTSContext
*ts
= s
->priv_data
;
2273 AVIOContext
*pb
= s
->pb
;
2276 for (i
= 0; i
< ts
->resync_size
; i
++) {
2281 avio_seek(pb
, -1, SEEK_CUR
);
2282 reanalyze(s
->priv_data
);
2286 av_log(s
, AV_LOG_ERROR
,
2287 "max resync size reached, could not find sync byte\n");
2289 return AVERROR_INVALIDDATA
;
2292 /* return AVERROR_something if error or EOF. Return 0 if OK. */
2293 static int read_packet(AVFormatContext
*s
, uint8_t *buf
, int raw_packet_size
,
2294 const uint8_t **data
)
2296 AVIOContext
*pb
= s
->pb
;
2300 len
= ffio_read_indirect(pb
, buf
, TS_PACKET_SIZE
, data
);
2301 if (len
!= TS_PACKET_SIZE
)
2302 return len
< 0 ? len
: AVERROR_EOF
;
2303 /* check packet sync byte */
2304 if ((*data
)[0] != 0x47) {
2305 /* find a new packet start */
2306 uint64_t pos
= avio_tell(pb
);
2307 avio_seek(pb
, -FFMIN(raw_packet_size
, pos
), SEEK_CUR
);
2309 if (mpegts_resync(s
) < 0)
2310 return AVERROR(EAGAIN
);
2320 static void finished_reading_packet(AVFormatContext
*s
, int raw_packet_size
)
2322 AVIOContext
*pb
= s
->pb
;
2323 int skip
= raw_packet_size
- TS_PACKET_SIZE
;
2325 avio_skip(pb
, skip
);
2328 static int handle_packets(MpegTSContext
*ts
, int64_t nb_packets
)
2330 AVFormatContext
*s
= ts
->stream
;
2331 uint8_t packet
[TS_PACKET_SIZE
+ FF_INPUT_BUFFER_PADDING_SIZE
];
2332 const uint8_t *data
;
2336 if (avio_tell(s
->pb
) != ts
->last_pos
) {
2338 av_dlog(ts
->stream
, "Skipping after seek\n");
2339 /* seek detected, flush pes buffer */
2340 for (i
= 0; i
< NB_PID_MAX
; i
++) {
2342 if (ts
->pids
[i
]->type
== MPEGTS_PES
) {
2343 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
2344 av_buffer_unref(&pes
->buffer
);
2345 pes
->data_index
= 0;
2346 pes
->state
= MPEGTS_SKIP
; /* skip until pes header */
2348 ts
->pids
[i
]->last_cc
= -1;
2349 ts
->pids
[i
]->last_pcr
= -1;
2356 memset(packet
+ TS_PACKET_SIZE
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
2359 if (nb_packets
!= 0 && packet_num
>= nb_packets
||
2360 ts
->stop_parse
> 1) {
2361 ret
= AVERROR(EAGAIN
);
2364 if (ts
->stop_parse
> 0)
2367 ret
= read_packet(s
, packet
, ts
->raw_packet_size
, &data
);
2370 ret
= handle_packet(ts
, data
);
2371 finished_reading_packet(s
, ts
->raw_packet_size
);
2375 ts
->last_pos
= avio_tell(s
->pb
);
2379 static int mpegts_probe(AVProbeData
*p
)
2381 const int size
= p
->buf_size
;
2385 int check_count
= size
/ TS_FEC_PACKET_SIZE
;
2386 #define CHECK_COUNT 10
2387 #define CHECK_BLOCK 100
2389 if (check_count
< CHECK_COUNT
)
2390 return AVERROR_INVALIDDATA
;
2392 for (i
= 0; i
<check_count
; i
+=CHECK_BLOCK
) {
2393 int left
= FFMIN(check_count
- i
, CHECK_BLOCK
);
2394 int score
= analyze(p
->buf
+ TS_PACKET_SIZE
*i
, TS_PACKET_SIZE
*left
, TS_PACKET_SIZE
, NULL
);
2395 int dvhs_score
= analyze(p
->buf
+ TS_DVHS_PACKET_SIZE
*i
, TS_DVHS_PACKET_SIZE
*left
, TS_DVHS_PACKET_SIZE
, NULL
);
2396 int fec_score
= analyze(p
->buf
+ TS_FEC_PACKET_SIZE
*i
, TS_FEC_PACKET_SIZE
*left
, TS_FEC_PACKET_SIZE
, NULL
);
2397 score
= FFMAX3(score
, dvhs_score
, fec_score
);
2399 maxscore
= FFMAX(maxscore
, score
);
2402 sumscore
= sumscore
* CHECK_COUNT
/ check_count
;
2403 maxscore
= maxscore
* CHECK_COUNT
/ CHECK_BLOCK
;
2405 av_dlog(0, "TS score: %d %d\n", sumscore
, maxscore
);
2407 if (sumscore
> 6) return AVPROBE_SCORE_MAX
+ sumscore
- CHECK_COUNT
;
2408 else if (maxscore
> 6) return AVPROBE_SCORE_MAX
/2 + sumscore
- CHECK_COUNT
;
2410 return AVERROR_INVALIDDATA
;
2413 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
2414 * (-1) if not available */
2415 static int parse_pcr(int64_t *ppcr_high
, int *ppcr_low
, const uint8_t *packet
)
2417 int afc
, len
, flags
;
2421 afc
= (packet
[3] >> 4) & 3;
2423 return AVERROR_INVALIDDATA
;
2428 return AVERROR_INVALIDDATA
;
2431 if (!(flags
& 0x10))
2432 return AVERROR_INVALIDDATA
;
2434 return AVERROR_INVALIDDATA
;
2436 *ppcr_high
= ((int64_t) v
<< 1) | (p
[4] >> 7);
2437 *ppcr_low
= ((p
[4] & 1) << 8) | p
[5];
2441 static void seek_back(AVFormatContext
*s
, AVIOContext
*pb
, int64_t pos
) {
2443 /* NOTE: We attempt to seek on non-seekable files as well, as the
2444 * probe buffer usually is big enough. Only warn if the seek failed
2445 * on files where the seek should work. */
2446 if (avio_seek(pb
, pos
, SEEK_SET
) < 0)
2447 av_log(s
, pb
->seekable
? AV_LOG_ERROR
: AV_LOG_INFO
, "Unable to seek back to the start\n");
2450 static int mpegts_read_header(AVFormatContext
*s
)
2452 MpegTSContext
*ts
= s
->priv_data
;
2453 AVIOContext
*pb
= s
->pb
;
2454 uint8_t buf
[8 * 1024] = {0};
2456 int64_t pos
, probesize
= s
->probesize
? s
->probesize
: s
->probesize2
;
2458 ffio_ensure_seekback(pb
, probesize
);
2460 /* read the first 8192 bytes to get packet size */
2461 pos
= avio_tell(pb
);
2462 len
= avio_read(pb
, buf
, sizeof(buf
));
2463 ts
->raw_packet_size
= get_packet_size(buf
, len
);
2464 if (ts
->raw_packet_size
<= 0) {
2465 av_log(s
, AV_LOG_WARNING
, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
2466 ts
->raw_packet_size
= TS_PACKET_SIZE
;
2471 if (s
->iformat
== &ff_mpegts_demuxer
) {
2474 /* first do a scan to get all the services */
2475 seek_back(s
, pb
, pos
);
2477 mpegts_open_section_filter(ts
, SDT_PID
, sdt_cb
, ts
, 1);
2479 mpegts_open_section_filter(ts
, PAT_PID
, pat_cb
, ts
, 1);
2481 handle_packets(ts
, probesize
/ ts
->raw_packet_size
);
2482 /* if could not find service, enable auto_guess */
2486 av_dlog(ts
->stream
, "tuning done\n");
2488 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
2491 int pcr_pid
, pid
, nb_packets
, nb_pcrs
, ret
, pcr_l
;
2492 int64_t pcrs
[2], pcr_h
;
2493 int packet_count
[2];
2494 uint8_t packet
[TS_PACKET_SIZE
];
2495 const uint8_t *data
;
2497 /* only read packets */
2499 st
= avformat_new_stream(s
, NULL
);
2501 return AVERROR(ENOMEM
);
2502 avpriv_set_pts_info(st
, 60, 1, 27000000);
2503 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
2504 st
->codec
->codec_id
= AV_CODEC_ID_MPEG2TS
;
2506 /* we iterate until we find two PCRs to estimate the bitrate */
2511 ret
= read_packet(s
, packet
, ts
->raw_packet_size
, &data
);
2514 pid
= AV_RB16(data
+ 1) & 0x1fff;
2515 if ((pcr_pid
== -1 || pcr_pid
== pid
) &&
2516 parse_pcr(&pcr_h
, &pcr_l
, data
) == 0) {
2517 finished_reading_packet(s
, ts
->raw_packet_size
);
2519 packet_count
[nb_pcrs
] = nb_packets
;
2520 pcrs
[nb_pcrs
] = pcr_h
* 300 + pcr_l
;
2525 finished_reading_packet(s
, ts
->raw_packet_size
);
2530 /* NOTE1: the bitrate is computed without the FEC */
2531 /* NOTE2: it is only the bitrate of the start of the stream */
2532 ts
->pcr_incr
= (pcrs
[1] - pcrs
[0]) / (packet_count
[1] - packet_count
[0]);
2533 ts
->cur_pcr
= pcrs
[0] - ts
->pcr_incr
* packet_count
[0];
2534 s
->bit_rate
= TS_PACKET_SIZE
* 8 * 27e6
/ ts
->pcr_incr
;
2535 st
->codec
->bit_rate
= s
->bit_rate
;
2536 st
->start_time
= ts
->cur_pcr
;
2537 av_dlog(ts
->stream
, "start=%0.3f pcr=%0.3f incr=%d\n",
2538 st
->start_time
/ 1000000.0, pcrs
[0] / 27e6
, ts
->pcr_incr
);
2541 seek_back(s
, pb
, pos
);
2545 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
2547 static int mpegts_raw_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
2549 MpegTSContext
*ts
= s
->priv_data
;
2551 int64_t pcr_h
, next_pcr_h
, pos
;
2552 int pcr_l
, next_pcr_l
;
2553 uint8_t pcr_buf
[12];
2554 const uint8_t *data
;
2556 if (av_new_packet(pkt
, TS_PACKET_SIZE
) < 0)
2557 return AVERROR(ENOMEM
);
2558 ret
= read_packet(s
, pkt
->data
, ts
->raw_packet_size
, &data
);
2559 pkt
->pos
= avio_tell(s
->pb
);
2561 av_free_packet(pkt
);
2564 if (data
!= pkt
->data
)
2565 memcpy(pkt
->data
, data
, ts
->raw_packet_size
);
2566 finished_reading_packet(s
, ts
->raw_packet_size
);
2567 if (ts
->mpeg2ts_compute_pcr
) {
2568 /* compute exact PCR for each packet */
2569 if (parse_pcr(&pcr_h
, &pcr_l
, pkt
->data
) == 0) {
2570 /* we read the next PCR (XXX: optimize it by using a bigger buffer */
2571 pos
= avio_tell(s
->pb
);
2572 for (i
= 0; i
< MAX_PACKET_READAHEAD
; i
++) {
2573 avio_seek(s
->pb
, pos
+ i
* ts
->raw_packet_size
, SEEK_SET
);
2574 avio_read(s
->pb
, pcr_buf
, 12);
2575 if (parse_pcr(&next_pcr_h
, &next_pcr_l
, pcr_buf
) == 0) {
2576 /* XXX: not precise enough */
2578 ((next_pcr_h
- pcr_h
) * 300 + (next_pcr_l
- pcr_l
)) /
2583 avio_seek(s
->pb
, pos
, SEEK_SET
);
2584 /* no next PCR found: we use previous increment */
2585 ts
->cur_pcr
= pcr_h
* 300 + pcr_l
;
2587 pkt
->pts
= ts
->cur_pcr
;
2588 pkt
->duration
= ts
->pcr_incr
;
2589 ts
->cur_pcr
+= ts
->pcr_incr
;
2591 pkt
->stream_index
= 0;
2595 static int mpegts_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
2597 MpegTSContext
*ts
= s
->priv_data
;
2602 ret
= handle_packets(ts
, 0);
2604 av_free_packet(ts
->pkt
);
2605 /* flush pes data left */
2606 for (i
= 0; i
< NB_PID_MAX
; i
++)
2607 if (ts
->pids
[i
] && ts
->pids
[i
]->type
== MPEGTS_PES
) {
2608 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
2609 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
2610 new_pes_packet(pes
, pkt
);
2611 pes
->state
= MPEGTS_SKIP
;
2618 if (!ret
&& pkt
->size
< 0)
2619 ret
= AVERROR(EINTR
);
2623 static void mpegts_free(MpegTSContext
*ts
)
2629 for (i
= 0; i
< NB_PID_MAX
; i
++)
2631 mpegts_close_filter(ts
, ts
->pids
[i
]);
2634 static int mpegts_read_close(AVFormatContext
*s
)
2636 MpegTSContext
*ts
= s
->priv_data
;
2641 static av_unused
int64_t mpegts_get_pcr(AVFormatContext
*s
, int stream_index
,
2642 int64_t *ppos
, int64_t pos_limit
)
2644 MpegTSContext
*ts
= s
->priv_data
;
2645 int64_t pos
, timestamp
;
2646 uint8_t buf
[TS_PACKET_SIZE
];
2647 int pcr_l
, pcr_pid
=
2648 ((PESContext
*)s
->streams
[stream_index
]->priv_data
)->pcr_pid
;
2649 int pos47
= ts
->pos47_full
% ts
->raw_packet_size
;
2651 ((*ppos
+ ts
->raw_packet_size
- 1 - pos47
) / ts
->raw_packet_size
) *
2652 ts
->raw_packet_size
+ pos47
;
2653 while(pos
< pos_limit
) {
2654 if (avio_seek(s
->pb
, pos
, SEEK_SET
) < 0)
2655 return AV_NOPTS_VALUE
;
2656 if (avio_read(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
2657 return AV_NOPTS_VALUE
;
2658 if (buf
[0] != 0x47) {
2659 avio_seek(s
->pb
, -TS_PACKET_SIZE
, SEEK_CUR
);
2660 if (mpegts_resync(s
) < 0)
2661 return AV_NOPTS_VALUE
;
2662 pos
= avio_tell(s
->pb
);
2665 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
2666 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
2670 pos
+= ts
->raw_packet_size
;
2673 return AV_NOPTS_VALUE
;
2676 static int64_t mpegts_get_dts(AVFormatContext
*s
, int stream_index
,
2677 int64_t *ppos
, int64_t pos_limit
)
2679 MpegTSContext
*ts
= s
->priv_data
;
2681 int pos47
= ts
->pos47_full
% ts
->raw_packet_size
;
2682 pos
= ((*ppos
+ ts
->raw_packet_size
- 1 - pos47
) / ts
->raw_packet_size
) * ts
->raw_packet_size
+ pos47
;
2683 ff_read_frame_flush(s
);
2684 if (avio_seek(s
->pb
, pos
, SEEK_SET
) < 0)
2685 return AV_NOPTS_VALUE
;
2686 while(pos
< pos_limit
) {
2689 av_init_packet(&pkt
);
2690 ret
= av_read_frame(s
, &pkt
);
2692 return AV_NOPTS_VALUE
;
2693 av_free_packet(&pkt
);
2694 if (pkt
.dts
!= AV_NOPTS_VALUE
&& pkt
.pos
>= 0) {
2695 ff_reduce_index(s
, pkt
.stream_index
);
2696 av_add_index_entry(s
->streams
[pkt
.stream_index
], pkt
.pos
, pkt
.dts
, 0, 0, AVINDEX_KEYFRAME
/* FIXME keyframe? */);
2697 if (pkt
.stream_index
== stream_index
&& pkt
.pos
>= *ppos
) {
2705 return AV_NOPTS_VALUE
;
2708 /**************************************************************/
2709 /* parsing functions - called from other demuxers such as RTP */
2711 MpegTSContext
*avpriv_mpegts_parse_open(AVFormatContext
*s
)
2715 ts
= av_mallocz(sizeof(MpegTSContext
));
2718 /* no stream case, currently used by RTP */
2719 ts
->raw_packet_size
= TS_PACKET_SIZE
;
2722 mpegts_open_section_filter(ts
, SDT_PID
, sdt_cb
, ts
, 1);
2723 mpegts_open_section_filter(ts
, PAT_PID
, pat_cb
, ts
, 1);
2728 /* return the consumed length if a packet was output, or -1 if no
2729 * packet is output */
2730 int avpriv_mpegts_parse_packet(MpegTSContext
*ts
, AVPacket
*pkt
,
2731 const uint8_t *buf
, int len
)
2739 if (len
< TS_PACKET_SIZE
)
2740 return AVERROR_INVALIDDATA
;
2741 if (buf
[0] != 0x47) {
2745 handle_packet(ts
, buf
);
2746 buf
+= TS_PACKET_SIZE
;
2747 len
-= TS_PACKET_SIZE
;
2748 if (ts
->stop_parse
== 1)
2755 void avpriv_mpegts_parse_close(MpegTSContext
*ts
)
2761 AVInputFormat ff_mpegts_demuxer
= {
2763 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
2764 .priv_data_size
= sizeof(MpegTSContext
),
2765 .read_probe
= mpegts_probe
,
2766 .read_header
= mpegts_read_header
,
2767 .read_packet
= mpegts_read_packet
,
2768 .read_close
= mpegts_read_close
,
2769 .read_timestamp
= mpegts_get_dts
,
2770 .flags
= AVFMT_SHOW_IDS
| AVFMT_TS_DISCONT
,
2771 .priv_class
= &mpegts_class
,
2774 AVInputFormat ff_mpegtsraw_demuxer
= {
2775 .name
= "mpegtsraw",
2776 .long_name
= NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
2777 .priv_data_size
= sizeof(MpegTSContext
),
2778 .read_header
= mpegts_read_header
,
2779 .read_packet
= mpegts_raw_read_packet
,
2780 .read_close
= mpegts_read_close
,
2781 .read_timestamp
= mpegts_get_dts
,
2782 .flags
= AVFMT_SHOW_IDS
| AVFMT_TS_DISCONT
,
2783 .priv_class
= &mpegtsraw_class
,