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
25 #include "libavutil/crc.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavcodec/bytestream.h"
32 /* 1.0 second at 24Mbit/s */
33 #define MAX_SCAN_PACKETS 32000
35 /* maximum size in which we look for synchronisation if
36 synchronisation is lost */
37 #define MAX_RESYNC_SIZE 4096
39 #define MAX_PES_PAYLOAD 200*1024
41 typedef struct PESContext PESContext
;
43 static PESContext
* add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
, int stream_type
);
45 enum MpegTSFilterType
{
50 typedef struct MpegTSFilter MpegTSFilter
;
52 typedef int PESCallback(MpegTSFilter
*f
, const uint8_t *buf
, int len
, int is_start
, int64_t pos
);
54 typedef struct MpegTSPESFilter
{
59 typedef void SectionCallback(MpegTSFilter
*f
, const uint8_t *buf
, int len
);
61 typedef void SetServiceCallback(void *opaque
, int ret
);
63 typedef struct MpegTSSectionFilter
{
67 unsigned int check_crc
:1;
68 unsigned int end_of_section_reached
:1;
69 SectionCallback
*section_cb
;
71 } MpegTSSectionFilter
;
75 int last_cc
; /* last cc code (-1 if first packet) */
76 enum MpegTSFilterType type
;
78 MpegTSPESFilter pes_filter
;
79 MpegTSSectionFilter section_filter
;
83 #define MAX_PIDS_PER_PROGRAM 64
85 unsigned int id
; //program id/service id
87 unsigned int pids
[MAX_PIDS_PER_PROGRAM
];
90 struct MpegTSContext
{
92 AVFormatContext
*stream
;
93 /** raw packet size, including FEC if present */
98 /** if true, all pids are analyzed to find streams */
101 /** compute exact PCR for each transport stream packet */
102 int mpeg2ts_compute_pcr
;
104 int64_t cur_pcr
; /**< used to estimate the exact PCR */
105 int pcr_incr
; /**< used to estimate the exact PCR */
107 /* data needed to handle file based ts */
108 /** stop parsing loop */
110 /** packet containing Audio/Video data */
112 /** to detect seek */
115 /******************************************/
116 /* private mpegts data */
118 /** structure to keep track of Program->pids mapping */
123 /** filters for various streams specified by PMT + for the PAT and PMT */
124 MpegTSFilter
*pids
[NB_PID_MAX
];
127 /* TS stream handling */
132 MPEGTS_PESHEADER_FILL
,
137 /* enough for PES header + length */
138 #define PES_START_SIZE 6
139 #define PES_HEADER_SIZE 9
140 #define MAX_PES_HEADER_SIZE (9 + 255)
144 int pcr_pid
; /**< if -1 then all packets containing PCR are considered */
147 AVFormatContext
*stream
;
149 enum MpegTSState state
;
150 /* used to get the format */
155 int64_t ts_packet_pos
; /**< position of first TS packet of this PES packet */
156 uint8_t header
[MAX_PES_HEADER_SIZE
];
160 extern AVInputFormat mpegts_demuxer
;
162 static void clear_program(MpegTSContext
*ts
, unsigned int programid
)
166 for(i
=0; i
<ts
->nb_prg
; i
++)
167 if(ts
->prg
[i
].id
== programid
)
168 ts
->prg
[i
].nb_pids
= 0;
171 static void clear_programs(MpegTSContext
*ts
)
177 static void add_pat_entry(MpegTSContext
*ts
, unsigned int programid
)
180 void *tmp
= av_realloc(ts
->prg
, (ts
->nb_prg
+1)*sizeof(struct Program
));
184 p
= &ts
->prg
[ts
->nb_prg
];
190 static void add_pid_to_pmt(MpegTSContext
*ts
, unsigned int programid
, unsigned int pid
)
193 struct Program
*p
= NULL
;
194 for(i
=0; i
<ts
->nb_prg
; i
++) {
195 if(ts
->prg
[i
].id
== programid
) {
203 if(p
->nb_pids
>= MAX_PIDS_PER_PROGRAM
)
205 p
->pids
[p
->nb_pids
++] = pid
;
209 * \brief discard_pid() decides if the pid is to be discarded according
210 * to caller's programs selection
211 * \param ts : - TS context
213 * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
216 static int discard_pid(MpegTSContext
*ts
, unsigned int pid
)
219 int used
= 0, discarded
= 0;
221 for(i
=0; i
<ts
->nb_prg
; i
++) {
223 for(j
=0; j
<p
->nb_pids
; j
++) {
224 if(p
->pids
[j
] != pid
)
226 //is program with id p->id set to be discarded?
227 for(k
=0; k
<ts
->stream
->nb_programs
; k
++) {
228 if(ts
->stream
->programs
[k
]->id
== p
->id
) {
229 if(ts
->stream
->programs
[k
]->discard
== AVDISCARD_ALL
)
238 return !used
&& discarded
;
242 * Assembles PES packets out of TS packets, and then calls the "section_cb"
243 * function when they are complete.
245 static void write_section_data(AVFormatContext
*s
, MpegTSFilter
*tss1
,
246 const uint8_t *buf
, int buf_size
, int is_start
)
248 MpegTSSectionFilter
*tss
= &tss1
->u
.section_filter
;
252 memcpy(tss
->section_buf
, buf
, buf_size
);
253 tss
->section_index
= buf_size
;
254 tss
->section_h_size
= -1;
255 tss
->end_of_section_reached
= 0;
257 if (tss
->end_of_section_reached
)
259 len
= 4096 - tss
->section_index
;
262 memcpy(tss
->section_buf
+ tss
->section_index
, buf
, len
);
263 tss
->section_index
+= len
;
266 /* compute section length if possible */
267 if (tss
->section_h_size
== -1 && tss
->section_index
>= 3) {
268 len
= (AV_RB16(tss
->section_buf
+ 1) & 0xfff) + 3;
271 tss
->section_h_size
= len
;
274 if (tss
->section_h_size
!= -1 && tss
->section_index
>= tss
->section_h_size
) {
275 tss
->end_of_section_reached
= 1;
276 if (!tss
->check_crc
||
277 av_crc(av_crc_get_table(AV_CRC_32_IEEE
), -1,
278 tss
->section_buf
, tss
->section_h_size
) == 0)
279 tss
->section_cb(tss1
, tss
->section_buf
, tss
->section_h_size
);
283 static MpegTSFilter
*mpegts_open_section_filter(MpegTSContext
*ts
, unsigned int pid
,
284 SectionCallback
*section_cb
, void *opaque
,
288 MpegTSFilter
*filter
;
289 MpegTSSectionFilter
*sec
;
291 dprintf(ts
->stream
, "Filter: pid=0x%x\n", pid
);
293 if (pid
>= NB_PID_MAX
|| ts
->pids
[pid
])
295 filter
= av_mallocz(sizeof(MpegTSFilter
));
298 ts
->pids
[pid
] = filter
;
299 filter
->type
= MPEGTS_SECTION
;
301 filter
->last_cc
= -1;
302 sec
= &filter
->u
.section_filter
;
303 sec
->section_cb
= section_cb
;
304 sec
->opaque
= opaque
;
305 sec
->section_buf
= av_malloc(MAX_SECTION_SIZE
);
306 sec
->check_crc
= check_crc
;
307 if (!sec
->section_buf
) {
314 static MpegTSFilter
*mpegts_open_pes_filter(MpegTSContext
*ts
, unsigned int pid
,
318 MpegTSFilter
*filter
;
319 MpegTSPESFilter
*pes
;
321 if (pid
>= NB_PID_MAX
|| ts
->pids
[pid
])
323 filter
= av_mallocz(sizeof(MpegTSFilter
));
326 ts
->pids
[pid
] = filter
;
327 filter
->type
= MPEGTS_PES
;
329 filter
->last_cc
= -1;
330 pes
= &filter
->u
.pes_filter
;
331 pes
->pes_cb
= pes_cb
;
332 pes
->opaque
= opaque
;
336 static void mpegts_close_filter(MpegTSContext
*ts
, MpegTSFilter
*filter
)
341 if (filter
->type
== MPEGTS_SECTION
)
342 av_freep(&filter
->u
.section_filter
.section_buf
);
343 else if (filter
->type
== MPEGTS_PES
) {
344 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
345 av_freep(&pes
->buffer
);
346 /* referenced private data will be freed later in
347 * av_close_input_stream */
348 if (!((PESContext
*)filter
->u
.pes_filter
.opaque
)->st
) {
349 av_freep(&filter
->u
.pes_filter
.opaque
);
354 ts
->pids
[pid
] = NULL
;
357 static int analyze(const uint8_t *buf
, int size
, int packet_size
, int *index
){
358 int stat
[packet_size
];
363 memset(stat
, 0, packet_size
*sizeof(int));
365 for(x
=i
=0; i
<size
-3; i
++){
366 if(buf
[i
] == 0x47 && !(buf
[i
+1] & 0x80) && (buf
[i
+3] & 0x30)){
368 if(stat
[x
] > best_score
){
375 if(x
== packet_size
) x
= 0;
381 /* autodetect fec presence. Must have at least 1024 bytes */
382 static int get_packet_size(const uint8_t *buf
, int size
)
384 int score
, fec_score
, dvhs_score
;
386 if (size
< (TS_FEC_PACKET_SIZE
* 5 + 1))
389 score
= analyze(buf
, size
, TS_PACKET_SIZE
, NULL
);
390 dvhs_score
= analyze(buf
, size
, TS_DVHS_PACKET_SIZE
, NULL
);
391 fec_score
= analyze(buf
, size
, TS_FEC_PACKET_SIZE
, NULL
);
392 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
394 if (score
> fec_score
&& score
> dvhs_score
) return TS_PACKET_SIZE
;
395 else if(dvhs_score
> score
&& dvhs_score
> fec_score
) return TS_DVHS_PACKET_SIZE
;
396 else if(score
< fec_score
&& dvhs_score
< fec_score
) return TS_FEC_PACKET_SIZE
;
400 typedef struct SectionHeader
{
405 uint8_t last_sec_num
;
408 static inline int get8(const uint8_t **pp
, const uint8_t *p_end
)
421 static inline int get16(const uint8_t **pp
, const uint8_t *p_end
)
427 if ((p
+ 1) >= p_end
)
435 /* read and allocate a DVB string preceeded by its length */
436 static char *getstr8(const uint8_t **pp
, const uint8_t *p_end
)
443 len
= get8(&p
, p_end
);
446 if ((p
+ len
) > p_end
)
448 str
= av_malloc(len
+ 1);
458 static int parse_section_header(SectionHeader
*h
,
459 const uint8_t **pp
, const uint8_t *p_end
)
463 val
= get8(pp
, p_end
);
468 val
= get16(pp
, p_end
);
472 val
= get8(pp
, p_end
);
475 h
->version
= (val
>> 1) & 0x1f;
476 val
= get8(pp
, p_end
);
480 val
= get8(pp
, p_end
);
483 h
->last_sec_num
= val
;
488 uint32_t stream_type
;
489 enum CodecType codec_type
;
490 enum CodecID codec_id
;
493 static const StreamType ISO_types
[] = {
494 { 0x01, CODEC_TYPE_VIDEO
, CODEC_ID_MPEG2VIDEO
},
495 { 0x02, CODEC_TYPE_VIDEO
, CODEC_ID_MPEG2VIDEO
},
496 { 0x03, CODEC_TYPE_AUDIO
, CODEC_ID_MP3
},
497 { 0x04, CODEC_TYPE_AUDIO
, CODEC_ID_MP3
},
498 { 0x0f, CODEC_TYPE_AUDIO
, CODEC_ID_AAC
},
499 { 0x10, CODEC_TYPE_VIDEO
, CODEC_ID_MPEG4
},
500 { 0x1b, CODEC_TYPE_VIDEO
, CODEC_ID_H264
},
501 { 0xd1, CODEC_TYPE_VIDEO
, CODEC_ID_DIRAC
},
502 { 0xea, CODEC_TYPE_VIDEO
, CODEC_ID_VC1
},
506 static const StreamType HDMV_types
[] = {
507 { 0x81, CODEC_TYPE_AUDIO
, CODEC_ID_AC3
},
508 { 0x82, CODEC_TYPE_AUDIO
, CODEC_ID_DTS
},
513 static const StreamType MISC_types
[] = {
514 { 0x81, CODEC_TYPE_AUDIO
, CODEC_ID_AC3
},
515 { 0x8a, CODEC_TYPE_AUDIO
, CODEC_ID_DTS
},
519 static const StreamType REGD_types
[] = {
520 { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO
, CODEC_ID_DIRAC
},
521 { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO
, CODEC_ID_AC3
},
525 /* descriptor present */
526 static const StreamType DESC_types
[] = {
527 { 0x6a, CODEC_TYPE_AUDIO
, CODEC_ID_AC3
}, /* AC-3 descriptor */
528 { 0x7a, CODEC_TYPE_AUDIO
, CODEC_ID_EAC3
}, /* E-AC-3 descriptor */
529 { 0x7b, CODEC_TYPE_AUDIO
, CODEC_ID_DTS
},
530 { 0x59, CODEC_TYPE_SUBTITLE
, CODEC_ID_DVB_SUBTITLE
}, /* subtitling descriptor */
534 static void mpegts_find_stream_type(AVStream
*st
,
535 uint32_t stream_type
, const StreamType
*types
)
537 for (; types
->stream_type
; types
++) {
538 if (stream_type
== types
->stream_type
) {
539 st
->codec
->codec_type
= types
->codec_type
;
540 st
->codec
->codec_id
= types
->codec_id
;
546 static AVStream
*new_pes_av_stream(PESContext
*pes
, uint32_t prog_reg_desc
, uint32_t code
)
548 AVStream
*st
= av_new_stream(pes
->stream
, pes
->pid
);
553 av_set_pts_info(st
, 33, 1, 90000);
555 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
556 st
->codec
->codec_id
= CODEC_ID_PROBE
;
557 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
560 dprintf(pes
->stream
, "stream_type=%x pid=%x prog_reg_desc=%.4s\n",
561 pes
->stream_type
, pes
->pid
, (char*)&prog_reg_desc
);
563 st
->codec
->codec_tag
= pes
->stream_type
;
565 mpegts_find_stream_type(st
, pes
->stream_type
, ISO_types
);
566 if (prog_reg_desc
== AV_RL32("HDMV") &&
567 st
->codec
->codec_id
== CODEC_ID_PROBE
)
568 mpegts_find_stream_type(st
, pes
->stream_type
, HDMV_types
);
569 if (st
->codec
->codec_id
== CODEC_ID_PROBE
)
570 mpegts_find_stream_type(st
, pes
->stream_type
, MISC_types
);
572 /* stream was not present in PMT, guess based on PES start code */
573 if (st
->codec
->codec_id
== CODEC_ID_PROBE
) {
574 if (code
>= 0x1c0 && code
<= 0x1df) {
575 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
576 st
->codec
->codec_id
= CODEC_ID_MP2
;
577 } else if (code
== 0x1bd) {
578 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
579 st
->codec
->codec_id
= CODEC_ID_AC3
;
586 static void pmt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
588 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
589 SectionHeader h1
, *h
= &h1
;
592 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
593 int program_info_length
, pcr_pid
, pid
, stream_type
;
594 int desc_list_len
, desc_len
, desc_tag
;
595 int comp_page
, anc_page
;
597 uint32_t prog_reg_desc
= 0; /* registration descriptor */
600 dprintf(ts
->stream
, "PMT: len %i\n", section_len
);
601 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
604 p_end
= section
+ section_len
- 4;
606 if (parse_section_header(h
, &p
, p_end
) < 0)
609 dprintf(ts
->stream
, "sid=0x%x sec_num=%d/%d\n",
610 h
->id
, h
->sec_num
, h
->last_sec_num
);
612 if (h
->tid
!= PMT_TID
)
615 clear_program(ts
, h
->id
);
616 pcr_pid
= get16(&p
, p_end
) & 0x1fff;
619 add_pid_to_pmt(ts
, h
->id
, pcr_pid
);
621 dprintf(ts
->stream
, "pcr_pid=0x%x\n", pcr_pid
);
623 program_info_length
= get16(&p
, p_end
) & 0xfff;
624 if (program_info_length
< 0)
626 while(program_info_length
>= 2) {
628 tag
= get8(&p
, p_end
);
629 len
= get8(&p
, p_end
);
630 if(len
> program_info_length
- 2)
631 //something else is broken, exit the program_descriptors_loop
633 program_info_length
-= len
+ 2;
634 if(tag
== 0x05 && len
>= 4) { // registration descriptor
635 prog_reg_desc
= bytestream_get_le32(&p
);
640 p
+= program_info_length
;
645 stream_type
= get8(&p
, p_end
);
648 pid
= get16(&p
, p_end
) & 0x1fff;
652 /* now create ffmpeg stream */
653 if (ts
->pids
[pid
] && ts
->pids
[pid
]->type
== MPEGTS_PES
) {
654 pes
= ts
->pids
[pid
]->u
.pes_filter
.opaque
;
657 if (ts
->pids
[pid
]) mpegts_close_filter(ts
, ts
->pids
[pid
]); //wrongly added sdt filter probably
658 pes
= add_pes_stream(ts
, pid
, pcr_pid
, stream_type
);
660 st
= new_pes_av_stream(pes
, prog_reg_desc
, 0);
666 add_pid_to_pmt(ts
, h
->id
, pid
);
668 av_program_add_stream_index(ts
->stream
, h
->id
, st
->index
);
670 desc_list_len
= get16(&p
, p_end
) & 0xfff;
671 if (desc_list_len
< 0)
673 desc_list_end
= p
+ desc_list_len
;
674 if (desc_list_end
> p_end
)
677 desc_tag
= get8(&p
, desc_list_end
);
680 desc_len
= get8(&p
, desc_list_end
);
683 desc_end
= p
+ desc_len
;
684 if (desc_end
> desc_list_end
)
687 dprintf(ts
->stream
, "tag: 0x%02x len=%d\n",
690 if (st
->codec
->codec_id
== CODEC_ID_PROBE
&&
691 stream_type
== STREAM_TYPE_PRIVATE_DATA
)
692 mpegts_find_stream_type(st
, desc_tag
, DESC_types
);
695 case 0x59: /* subtitling descriptor */
696 language
[0] = get8(&p
, desc_end
);
697 language
[1] = get8(&p
, desc_end
);
698 language
[2] = get8(&p
, desc_end
);
701 comp_page
= get16(&p
, desc_end
);
702 anc_page
= get16(&p
, desc_end
);
703 st
->codec
->sub_id
= (anc_page
<< 16) | comp_page
;
704 av_metadata_set(&st
->metadata
, "language", language
);
706 case 0x0a: /* ISO 639 language descriptor */
707 language
[0] = get8(&p
, desc_end
);
708 language
[1] = get8(&p
, desc_end
);
709 language
[2] = get8(&p
, desc_end
);
711 av_metadata_set(&st
->metadata
, "language", language
);
713 case 0x05: /* registration descriptor */
714 st
->codec
->codec_tag
= bytestream_get_le32(&p
);
715 dprintf(ts
->stream
, "reg_desc=%.4s\n", (char*)&st
->codec
->codec_tag
);
716 if (st
->codec
->codec_id
== CODEC_ID_PROBE
&&
717 stream_type
== STREAM_TYPE_PRIVATE_DATA
)
718 mpegts_find_stream_type(st
, st
->codec
->codec_tag
, REGD_types
);
727 /* all parameters are there */
729 mpegts_close_filter(ts
, filter
);
732 static void pat_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
734 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
735 SectionHeader h1
, *h
= &h1
;
736 const uint8_t *p
, *p_end
;
740 dprintf(ts
->stream
, "PAT:\n");
741 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
743 p_end
= section
+ section_len
- 4;
745 if (parse_section_header(h
, &p
, p_end
) < 0)
747 if (h
->tid
!= PAT_TID
)
752 sid
= get16(&p
, p_end
);
755 pmt_pid
= get16(&p
, p_end
) & 0x1fff;
759 dprintf(ts
->stream
, "sid=0x%x pid=0x%x\n", sid
, pmt_pid
);
764 av_new_program(ts
->stream
, sid
);
766 mpegts_open_section_filter(ts
, pmt_pid
, pmt_cb
, ts
, 1);
767 add_pat_entry(ts
, sid
);
768 add_pid_to_pmt(ts
, sid
, 0); //add pat pid to program
769 add_pid_to_pmt(ts
, sid
, pmt_pid
);
775 mpegts_close_filter(ts
, filter
);
778 static void sdt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
780 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
781 SectionHeader h1
, *h
= &h1
;
782 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
783 int onid
, val
, sid
, desc_list_len
, desc_tag
, desc_len
, service_type
;
784 char *name
, *provider_name
;
787 dprintf(ts
->stream
, "SDT:\n");
788 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
791 p_end
= section
+ section_len
- 4;
793 if (parse_section_header(h
, &p
, p_end
) < 0)
795 if (h
->tid
!= SDT_TID
)
797 onid
= get16(&p
, p_end
);
800 val
= get8(&p
, p_end
);
804 sid
= get16(&p
, p_end
);
807 val
= get8(&p
, p_end
);
810 desc_list_len
= get16(&p
, p_end
) & 0xfff;
811 if (desc_list_len
< 0)
813 desc_list_end
= p
+ desc_list_len
;
814 if (desc_list_end
> p_end
)
817 desc_tag
= get8(&p
, desc_list_end
);
820 desc_len
= get8(&p
, desc_list_end
);
821 desc_end
= p
+ desc_len
;
822 if (desc_end
> desc_list_end
)
825 dprintf(ts
->stream
, "tag: 0x%02x len=%d\n",
830 service_type
= get8(&p
, p_end
);
831 if (service_type
< 0)
833 provider_name
= getstr8(&p
, p_end
);
836 name
= getstr8(&p
, p_end
);
838 AVProgram
*program
= av_new_program(ts
->stream
, sid
);
840 av_metadata_set(&program
->metadata
, "name", name
);
841 av_metadata_set(&program
->metadata
, "provider_name", provider_name
);
845 av_free(provider_name
);
856 static int64_t get_pts(const uint8_t *p
)
858 int64_t pts
= (int64_t)((p
[0] >> 1) & 0x07) << 30;
859 pts
|= (AV_RB16(p
+ 1) >> 1) << 15;
860 pts
|= AV_RB16(p
+ 3) >> 1;
864 static void new_pes_packet(PESContext
*pes
, AVPacket
*pkt
)
868 pkt
->destruct
= av_destruct_packet
;
869 pkt
->data
= pes
->buffer
;
870 pkt
->size
= pes
->data_index
;
871 memset(pkt
->data
+pkt
->size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
873 pkt
->stream_index
= pes
->st
->index
;
876 /* store position of first TS packet of this PES packet */
877 pkt
->pos
= pes
->ts_packet_pos
;
879 /* reset pts values */
880 pes
->pts
= AV_NOPTS_VALUE
;
881 pes
->dts
= AV_NOPTS_VALUE
;
886 /* return non zero if a packet could be constructed */
887 static int mpegts_push_data(MpegTSFilter
*filter
,
888 const uint8_t *buf
, int buf_size
, int is_start
,
891 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
892 MpegTSContext
*ts
= pes
->ts
;
900 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
901 new_pes_packet(pes
, ts
->pkt
);
904 pes
->state
= MPEGTS_HEADER
;
906 pes
->ts_packet_pos
= pos
;
909 while (buf_size
> 0) {
912 len
= PES_START_SIZE
- pes
->data_index
;
915 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
916 pes
->data_index
+= len
;
919 if (pes
->data_index
== PES_START_SIZE
) {
920 /* we got all the PES or section header. We can now
923 av_hex_dump_log(pes
->stream
, AV_LOG_DEBUG
, pes
->header
, pes
->data_index
);
925 if (pes
->header
[0] == 0x00 && pes
->header
[1] == 0x00 &&
926 pes
->header
[2] == 0x01) {
927 /* it must be an mpeg2 PES stream */
928 code
= pes
->header
[3] | 0x100;
929 dprintf(pes
->stream
, "pid=%x pes_code=%#x\n", pes
->pid
, code
);
931 if ((!pes
->st
&& pes
->stream
->nb_streams
== MAX_STREAMS
) ||
932 (pes
->st
&& pes
->st
->discard
== AVDISCARD_ALL
) ||
933 code
== 0x1be) /* padding_stream */
936 /* stream not present in PMT */
938 pes
->st
= new_pes_av_stream(pes
, 0, code
);
940 return AVERROR(ENOMEM
);
942 pes
->total_size
= AV_RB16(pes
->header
+ 4);
943 /* NOTE: a zero total size means the PES size is
945 if (!pes
->total_size
)
946 pes
->total_size
= MAX_PES_PAYLOAD
;
948 /* allocate pes buffer */
949 pes
->buffer
= av_malloc(pes
->total_size
+FF_INPUT_BUFFER_PADDING_SIZE
);
951 return AVERROR(ENOMEM
);
953 if (code
!= 0x1bc && code
!= 0x1bf && /* program_stream_map, private_stream_2 */
954 code
!= 0x1f0 && code
!= 0x1f1 && /* ECM, EMM */
955 code
!= 0x1ff && code
!= 0x1f2 && /* program_stream_directory, DSMCC_stream */
956 code
!= 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
957 pes
->state
= MPEGTS_PESHEADER
;
959 pes
->state
= MPEGTS_PAYLOAD
;
963 /* otherwise, it should be a table */
966 pes
->state
= MPEGTS_SKIP
;
971 /**********************************************/
972 /* PES packing parsing */
973 case MPEGTS_PESHEADER
:
974 len
= PES_HEADER_SIZE
- pes
->data_index
;
979 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
980 pes
->data_index
+= len
;
983 if (pes
->data_index
== PES_HEADER_SIZE
) {
984 pes
->pes_header_size
= pes
->header
[8] + 9;
985 pes
->state
= MPEGTS_PESHEADER_FILL
;
988 case MPEGTS_PESHEADER_FILL
:
989 len
= pes
->pes_header_size
- pes
->data_index
;
994 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
995 pes
->data_index
+= len
;
998 if (pes
->data_index
== pes
->pes_header_size
) {
1002 flags
= pes
->header
[7];
1003 r
= pes
->header
+ 9;
1004 pes
->pts
= AV_NOPTS_VALUE
;
1005 pes
->dts
= AV_NOPTS_VALUE
;
1006 if ((flags
& 0xc0) == 0x80) {
1007 pes
->dts
= pes
->pts
= get_pts(r
);
1009 } else if ((flags
& 0xc0) == 0xc0) {
1010 pes
->pts
= get_pts(r
);
1012 pes
->dts
= get_pts(r
);
1016 /* we got the full header. We parse it and get the payload */
1017 pes
->state
= MPEGTS_PAYLOAD
;
1018 pes
->data_index
= 0;
1021 case MPEGTS_PAYLOAD
:
1023 if (pes
->data_index
+buf_size
> pes
->total_size
) {
1024 new_pes_packet(pes
, ts
->pkt
);
1025 pes
->total_size
= MAX_PES_PAYLOAD
;
1026 pes
->buffer
= av_malloc(pes
->total_size
+FF_INPUT_BUFFER_PADDING_SIZE
);
1028 return AVERROR(ENOMEM
);
1031 memcpy(pes
->buffer
+pes
->data_index
, p
, buf_size
);
1032 pes
->data_index
+= buf_size
;
1045 static PESContext
*add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
, int stream_type
)
1050 /* if no pid found, then add a pid context */
1051 pes
= av_mallocz(sizeof(PESContext
));
1055 pes
->stream
= ts
->stream
;
1057 pes
->pcr_pid
= pcr_pid
;
1058 pes
->stream_type
= stream_type
;
1059 pes
->state
= MPEGTS_SKIP
;
1060 tss
= mpegts_open_pes_filter(ts
, pid
, mpegts_push_data
, pes
);
1068 /* handle one TS packet */
1069 static int handle_packet(MpegTSContext
*ts
, const uint8_t *packet
)
1071 AVFormatContext
*s
= ts
->stream
;
1073 int len
, pid
, cc
, cc_ok
, afc
, is_start
;
1074 const uint8_t *p
, *p_end
;
1077 pid
= AV_RB16(packet
+ 1) & 0x1fff;
1078 if(pid
&& discard_pid(ts
, pid
))
1080 is_start
= packet
[1] & 0x40;
1081 tss
= ts
->pids
[pid
];
1082 if (ts
->auto_guess
&& tss
== NULL
&& is_start
) {
1083 add_pes_stream(ts
, pid
, -1, 0);
1084 tss
= ts
->pids
[pid
];
1089 /* continuity check (currently not used) */
1090 cc
= (packet
[3] & 0xf);
1091 cc_ok
= (tss
->last_cc
< 0) || ((((tss
->last_cc
+ 1) & 0x0f) == cc
));
1094 /* skip adaptation field */
1095 afc
= (packet
[3] >> 4) & 3;
1097 if (afc
== 0) /* reserved value */
1099 if (afc
== 2) /* adaptation field only */
1102 /* skip adapation field */
1105 /* if past the end of packet, ignore */
1106 p_end
= packet
+ TS_PACKET_SIZE
;
1110 pos
= url_ftell(ts
->stream
->pb
);
1111 ts
->pos47
= pos
% ts
->raw_packet_size
;
1113 if (tss
->type
== MPEGTS_SECTION
) {
1115 /* pointer field present */
1117 if (p
+ len
> p_end
)
1120 /* write remaining section bytes */
1121 write_section_data(s
, tss
,
1123 /* check whether filter has been closed */
1129 write_section_data(s
, tss
,
1134 write_section_data(s
, tss
,
1140 // Note: The position here points actually behind the current packet.
1141 if ((ret
= tss
->u
.pes_filter
.pes_cb(tss
, p
, p_end
- p
, is_start
,
1142 pos
- ts
->raw_packet_size
)) < 0)
1149 /* XXX: try to find a better synchro over several packets (use
1150 get_packet_size() ?) */
1151 static int mpegts_resync(ByteIOContext
*pb
)
1155 for(i
= 0;i
< MAX_RESYNC_SIZE
; i
++) {
1160 url_fseek(pb
, -1, SEEK_CUR
);
1168 /* return -1 if error or EOF. Return 0 if OK. */
1169 static int read_packet(ByteIOContext
*pb
, uint8_t *buf
, int raw_packet_size
)
1174 len
= get_buffer(pb
, buf
, TS_PACKET_SIZE
);
1175 if (len
!= TS_PACKET_SIZE
)
1176 return AVERROR(EIO
);
1177 /* check paquet sync byte */
1178 if (buf
[0] != 0x47) {
1179 /* find a new packet start */
1180 url_fseek(pb
, -TS_PACKET_SIZE
, SEEK_CUR
);
1181 if (mpegts_resync(pb
) < 0)
1182 return AVERROR_INVALIDDATA
;
1186 skip
= raw_packet_size
- TS_PACKET_SIZE
;
1188 url_fskip(pb
, skip
);
1195 static int handle_packets(MpegTSContext
*ts
, int nb_packets
)
1197 AVFormatContext
*s
= ts
->stream
;
1198 ByteIOContext
*pb
= s
->pb
;
1199 uint8_t packet
[TS_PACKET_SIZE
];
1200 int packet_num
, ret
;
1205 if (ts
->stop_parse
>0)
1208 if (nb_packets
!= 0 && packet_num
>= nb_packets
)
1210 ret
= read_packet(pb
, packet
, ts
->raw_packet_size
);
1213 ret
= handle_packet(ts
, packet
);
1220 static int mpegts_probe(AVProbeData
*p
)
1223 const int size
= p
->buf_size
;
1224 int score
, fec_score
, dvhs_score
;
1225 int check_count
= size
/ TS_FEC_PACKET_SIZE
;
1226 #define CHECK_COUNT 10
1228 if (check_count
< CHECK_COUNT
)
1231 score
= analyze(p
->buf
, TS_PACKET_SIZE
*check_count
, TS_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1232 dvhs_score
= analyze(p
->buf
, TS_DVHS_PACKET_SIZE
*check_count
, TS_DVHS_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1233 fec_score
= analyze(p
->buf
, TS_FEC_PACKET_SIZE
*check_count
, TS_FEC_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1234 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1236 // we need a clear definition for the returned score otherwise things will become messy sooner or later
1237 if (score
> fec_score
&& score
> dvhs_score
&& score
> 6) return AVPROBE_SCORE_MAX
+ score
- CHECK_COUNT
;
1238 else if(dvhs_score
> score
&& dvhs_score
> fec_score
&& dvhs_score
> 6) return AVPROBE_SCORE_MAX
+ dvhs_score
- CHECK_COUNT
;
1239 else if( fec_score
> 6) return AVPROBE_SCORE_MAX
+ fec_score
- CHECK_COUNT
;
1242 /* only use the extension for safer guess */
1243 if (match_ext(p
->filename
, "ts"))
1244 return AVPROBE_SCORE_MAX
;
1250 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
1251 (-1) if not available */
1252 static int parse_pcr(int64_t *ppcr_high
, int *ppcr_low
,
1253 const uint8_t *packet
)
1255 int afc
, len
, flags
;
1259 afc
= (packet
[3] >> 4) & 3;
1269 if (!(flags
& 0x10))
1274 *ppcr_high
= ((int64_t)v
<< 1) | (p
[4] >> 7);
1275 *ppcr_low
= ((p
[4] & 1) << 8) | p
[5];
1279 static int mpegts_read_header(AVFormatContext
*s
,
1280 AVFormatParameters
*ap
)
1282 MpegTSContext
*ts
= s
->priv_data
;
1283 ByteIOContext
*pb
= s
->pb
;
1284 uint8_t buf
[5*1024];
1289 ts
->mpeg2ts_compute_pcr
= ap
->mpeg2ts_compute_pcr
;
1290 if(ap
->mpeg2ts_raw
){
1291 av_log(s
, AV_LOG_ERROR
, "use mpegtsraw_demuxer!\n");
1296 /* read the first 1024 bytes to get packet size */
1297 pos
= url_ftell(pb
);
1298 len
= get_buffer(pb
, buf
, sizeof(buf
));
1299 if (len
!= sizeof(buf
))
1301 ts
->raw_packet_size
= get_packet_size(buf
, sizeof(buf
));
1302 if (ts
->raw_packet_size
<= 0)
1307 if (s
->iformat
== &mpegts_demuxer
) {
1310 /* first do a scaning to get all the services */
1311 url_fseek(pb
, pos
, SEEK_SET
);
1313 mpegts_open_section_filter(ts
, SDT_PID
, sdt_cb
, ts
, 1);
1315 mpegts_open_section_filter(ts
, PAT_PID
, pat_cb
, ts
, 1);
1317 handle_packets(ts
, s
->probesize
);
1318 /* if could not find service, enable auto_guess */
1322 dprintf(ts
->stream
, "tuning done\n");
1324 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
1327 int pcr_pid
, pid
, nb_packets
, nb_pcrs
, ret
, pcr_l
;
1328 int64_t pcrs
[2], pcr_h
;
1329 int packet_count
[2];
1330 uint8_t packet
[TS_PACKET_SIZE
];
1332 /* only read packets */
1334 st
= av_new_stream(s
, 0);
1337 av_set_pts_info(st
, 60, 1, 27000000);
1338 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
1339 st
->codec
->codec_id
= CODEC_ID_MPEG2TS
;
1341 /* we iterate until we find two PCRs to estimate the bitrate */
1346 ret
= read_packet(s
->pb
, packet
, ts
->raw_packet_size
);
1349 pid
= AV_RB16(packet
+ 1) & 0x1fff;
1350 if ((pcr_pid
== -1 || pcr_pid
== pid
) &&
1351 parse_pcr(&pcr_h
, &pcr_l
, packet
) == 0) {
1353 packet_count
[nb_pcrs
] = nb_packets
;
1354 pcrs
[nb_pcrs
] = pcr_h
* 300 + pcr_l
;
1362 /* NOTE1: the bitrate is computed without the FEC */
1363 /* NOTE2: it is only the bitrate of the start of the stream */
1364 ts
->pcr_incr
= (pcrs
[1] - pcrs
[0]) / (packet_count
[1] - packet_count
[0]);
1365 ts
->cur_pcr
= pcrs
[0] - ts
->pcr_incr
* packet_count
[0];
1366 s
->bit_rate
= (TS_PACKET_SIZE
* 8) * 27e6
/ ts
->pcr_incr
;
1367 st
->codec
->bit_rate
= s
->bit_rate
;
1368 st
->start_time
= ts
->cur_pcr
;
1370 av_log(ts
->stream
, AV_LOG_DEBUG
, "start=%0.3f pcr=%0.3f incr=%d\n",
1371 st
->start_time
/ 1000000.0, pcrs
[0] / 27e6
, ts
->pcr_incr
);
1375 url_fseek(pb
, pos
, SEEK_SET
);
1381 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1383 static int mpegts_raw_read_packet(AVFormatContext
*s
,
1386 MpegTSContext
*ts
= s
->priv_data
;
1388 int64_t pcr_h
, next_pcr_h
, pos
;
1389 int pcr_l
, next_pcr_l
;
1390 uint8_t pcr_buf
[12];
1392 if (av_new_packet(pkt
, TS_PACKET_SIZE
) < 0)
1393 return AVERROR(ENOMEM
);
1394 pkt
->pos
= url_ftell(s
->pb
);
1395 ret
= read_packet(s
->pb
, pkt
->data
, ts
->raw_packet_size
);
1397 av_free_packet(pkt
);
1400 if (ts
->mpeg2ts_compute_pcr
) {
1401 /* compute exact PCR for each packet */
1402 if (parse_pcr(&pcr_h
, &pcr_l
, pkt
->data
) == 0) {
1403 /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1404 pos
= url_ftell(s
->pb
);
1405 for(i
= 0; i
< MAX_PACKET_READAHEAD
; i
++) {
1406 url_fseek(s
->pb
, pos
+ i
* ts
->raw_packet_size
, SEEK_SET
);
1407 get_buffer(s
->pb
, pcr_buf
, 12);
1408 if (parse_pcr(&next_pcr_h
, &next_pcr_l
, pcr_buf
) == 0) {
1409 /* XXX: not precise enough */
1410 ts
->pcr_incr
= ((next_pcr_h
- pcr_h
) * 300 + (next_pcr_l
- pcr_l
)) /
1415 url_fseek(s
->pb
, pos
, SEEK_SET
);
1416 /* no next PCR found: we use previous increment */
1417 ts
->cur_pcr
= pcr_h
* 300 + pcr_l
;
1419 pkt
->pts
= ts
->cur_pcr
;
1420 pkt
->duration
= ts
->pcr_incr
;
1421 ts
->cur_pcr
+= ts
->pcr_incr
;
1423 pkt
->stream_index
= 0;
1427 static int mpegts_read_packet(AVFormatContext
*s
,
1430 MpegTSContext
*ts
= s
->priv_data
;
1433 if (url_ftell(s
->pb
) != ts
->last_pos
) {
1434 /* seek detected, flush pes buffer */
1435 for (i
= 0; i
< NB_PID_MAX
; i
++) {
1436 if (ts
->pids
[i
] && ts
->pids
[i
]->type
== MPEGTS_PES
) {
1437 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
1438 av_freep(&pes
->buffer
);
1439 pes
->data_index
= 0;
1440 pes
->state
= MPEGTS_SKIP
; /* skip until pes header */
1446 ret
= handle_packets(ts
, 0);
1448 /* flush pes data left */
1449 for (i
= 0; i
< NB_PID_MAX
; i
++) {
1450 if (ts
->pids
[i
] && ts
->pids
[i
]->type
== MPEGTS_PES
) {
1451 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
1452 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
1453 new_pes_packet(pes
, pkt
);
1461 ts
->last_pos
= url_ftell(s
->pb
);
1466 static int mpegts_read_close(AVFormatContext
*s
)
1468 MpegTSContext
*ts
= s
->priv_data
;
1473 for(i
=0;i
<NB_PID_MAX
;i
++)
1474 if (ts
->pids
[i
]) mpegts_close_filter(ts
, ts
->pids
[i
]);
1479 static int64_t mpegts_get_pcr(AVFormatContext
*s
, int stream_index
,
1480 int64_t *ppos
, int64_t pos_limit
)
1482 MpegTSContext
*ts
= s
->priv_data
;
1483 int64_t pos
, timestamp
;
1484 uint8_t buf
[TS_PACKET_SIZE
];
1485 int pcr_l
, pcr_pid
= ((PESContext
*)s
->streams
[stream_index
]->priv_data
)->pcr_pid
;
1486 const int find_next
= 1;
1487 pos
= ((*ppos
+ ts
->raw_packet_size
- 1 - ts
->pos47
) / ts
->raw_packet_size
) * ts
->raw_packet_size
+ ts
->pos47
;
1490 url_fseek(s
->pb
, pos
, SEEK_SET
);
1491 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1492 return AV_NOPTS_VALUE
;
1493 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1494 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1497 pos
+= ts
->raw_packet_size
;
1501 pos
-= ts
->raw_packet_size
;
1503 return AV_NOPTS_VALUE
;
1504 url_fseek(s
->pb
, pos
, SEEK_SET
);
1505 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1506 return AV_NOPTS_VALUE
;
1507 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1508 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1518 static int read_seek(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int flags
){
1519 MpegTSContext
*ts
= s
->priv_data
;
1520 uint8_t buf
[TS_PACKET_SIZE
];
1523 if(av_seek_frame_binary(s
, stream_index
, target_ts
, flags
) < 0)
1526 pos
= url_ftell(s
->pb
);
1529 url_fseek(s
->pb
, pos
, SEEK_SET
);
1530 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1532 // pid = AV_RB16(buf + 1) & 0x1fff;
1533 if(buf
[1] & 0x40) break;
1534 pos
+= ts
->raw_packet_size
;
1536 url_fseek(s
->pb
, pos
, SEEK_SET
);
1541 /**************************************************************/
1542 /* parsing functions - called from other demuxers such as RTP */
1544 MpegTSContext
*mpegts_parse_open(AVFormatContext
*s
)
1548 ts
= av_mallocz(sizeof(MpegTSContext
));
1551 /* no stream case, currently used by RTP */
1552 ts
->raw_packet_size
= TS_PACKET_SIZE
;
1558 /* return the consumed length if a packet was output, or -1 if no
1560 int mpegts_parse_packet(MpegTSContext
*ts
, AVPacket
*pkt
,
1561 const uint8_t *buf
, int len
)
1569 if (ts
->stop_parse
>0)
1571 if (len
< TS_PACKET_SIZE
)
1573 if (buf
[0] != 0x47) {
1577 handle_packet(ts
, buf
);
1578 buf
+= TS_PACKET_SIZE
;
1579 len
-= TS_PACKET_SIZE
;
1585 void mpegts_parse_close(MpegTSContext
*ts
)
1589 for(i
=0;i
<NB_PID_MAX
;i
++)
1590 av_free(ts
->pids
[i
]);
1594 AVInputFormat mpegts_demuxer
= {
1596 NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1597 sizeof(MpegTSContext
),
1604 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,
1607 AVInputFormat mpegtsraw_demuxer
= {
1609 NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1610 sizeof(MpegTSContext
),
1613 mpegts_raw_read_packet
,
1617 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,