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 */
533 static void mpegts_find_stream_type(AVStream
*st
,
534 uint32_t stream_type
, const StreamType
*types
)
536 for (; types
->stream_type
; types
++) {
537 if (stream_type
== types
->stream_type
) {
538 st
->codec
->codec_type
= types
->codec_type
;
539 st
->codec
->codec_id
= types
->codec_id
;
545 static AVStream
*new_pes_av_stream(PESContext
*pes
, uint32_t prog_reg_desc
, uint32_t code
)
547 AVStream
*st
= av_new_stream(pes
->stream
, pes
->pid
);
552 av_set_pts_info(st
, 33, 1, 90000);
554 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
555 st
->codec
->codec_id
= CODEC_ID_PROBE
;
556 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
559 dprintf(pes
->stream
, "stream_type=%x pid=%x prog_reg_desc=%.4s\n",
560 pes
->stream_type
, pes
->pid
, (char*)&prog_reg_desc
);
562 st
->codec
->codec_tag
= pes
->stream_type
;
564 mpegts_find_stream_type(st
, pes
->stream_type
, ISO_types
);
565 if (prog_reg_desc
== AV_RL32("HDMV") &&
566 st
->codec
->codec_id
== CODEC_ID_PROBE
)
567 mpegts_find_stream_type(st
, pes
->stream_type
, HDMV_types
);
568 if (st
->codec
->codec_id
== CODEC_ID_PROBE
)
569 mpegts_find_stream_type(st
, pes
->stream_type
, MISC_types
);
571 /* stream was not present in PMT, guess based on PES start code */
572 if (st
->codec
->codec_id
== CODEC_ID_PROBE
) {
573 if (code
>= 0x1c0 && code
<= 0x1df) {
574 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
575 st
->codec
->codec_id
= CODEC_ID_MP2
;
576 } else if (code
== 0x1bd) {
577 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
578 st
->codec
->codec_id
= CODEC_ID_AC3
;
585 static void pmt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
587 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
588 SectionHeader h1
, *h
= &h1
;
591 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
592 int program_info_length
, pcr_pid
, pid
, stream_type
;
593 int desc_list_len
, desc_len
, desc_tag
;
594 int comp_page
, anc_page
;
596 uint32_t prog_reg_desc
= 0; /* registration descriptor */
599 dprintf(ts
->stream
, "PMT: len %i\n", section_len
);
600 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
603 p_end
= section
+ section_len
- 4;
605 if (parse_section_header(h
, &p
, p_end
) < 0)
608 dprintf(ts
->stream
, "sid=0x%x sec_num=%d/%d\n",
609 h
->id
, h
->sec_num
, h
->last_sec_num
);
611 if (h
->tid
!= PMT_TID
)
614 clear_program(ts
, h
->id
);
615 pcr_pid
= get16(&p
, p_end
) & 0x1fff;
618 add_pid_to_pmt(ts
, h
->id
, pcr_pid
);
620 dprintf(ts
->stream
, "pcr_pid=0x%x\n", pcr_pid
);
622 program_info_length
= get16(&p
, p_end
) & 0xfff;
623 if (program_info_length
< 0)
625 while(program_info_length
>= 2) {
627 tag
= get8(&p
, p_end
);
628 len
= get8(&p
, p_end
);
629 if(len
> program_info_length
- 2)
630 //something else is broken, exit the program_descriptors_loop
632 program_info_length
-= len
+ 2;
633 if(tag
== 0x05 && len
>= 4) { // registration descriptor
634 prog_reg_desc
= bytestream_get_le32(&p
);
639 p
+= program_info_length
;
644 stream_type
= get8(&p
, p_end
);
647 pid
= get16(&p
, p_end
) & 0x1fff;
651 /* now create ffmpeg stream */
652 if (ts
->pids
[pid
] && ts
->pids
[pid
]->type
== MPEGTS_PES
) {
653 pes
= ts
->pids
[pid
]->u
.pes_filter
.opaque
;
656 if (ts
->pids
[pid
]) mpegts_close_filter(ts
, ts
->pids
[pid
]); //wrongly added sdt filter probably
657 pes
= add_pes_stream(ts
, pid
, pcr_pid
, stream_type
);
659 st
= new_pes_av_stream(pes
, prog_reg_desc
, 0);
665 add_pid_to_pmt(ts
, h
->id
, pid
);
667 av_program_add_stream_index(ts
->stream
, h
->id
, st
->index
);
669 desc_list_len
= get16(&p
, p_end
) & 0xfff;
670 if (desc_list_len
< 0)
672 desc_list_end
= p
+ desc_list_len
;
673 if (desc_list_end
> p_end
)
676 desc_tag
= get8(&p
, desc_list_end
);
679 desc_len
= get8(&p
, desc_list_end
);
682 desc_end
= p
+ desc_len
;
683 if (desc_end
> desc_list_end
)
686 dprintf(ts
->stream
, "tag: 0x%02x len=%d\n",
689 if (st
->codec
->codec_id
== CODEC_ID_PROBE
&&
690 stream_type
== STREAM_TYPE_PRIVATE_DATA
)
691 mpegts_find_stream_type(st
, desc_tag
, DESC_types
);
694 case 0x59: /* subtitling descriptor */
695 language
[0] = get8(&p
, desc_end
);
696 language
[1] = get8(&p
, desc_end
);
697 language
[2] = get8(&p
, desc_end
);
700 comp_page
= get16(&p
, desc_end
);
701 anc_page
= get16(&p
, desc_end
);
702 st
->codec
->sub_id
= (anc_page
<< 16) | comp_page
;
703 av_metadata_set(&st
->metadata
, "language", language
);
705 case 0x0a: /* ISO 639 language descriptor */
706 language
[0] = get8(&p
, desc_end
);
707 language
[1] = get8(&p
, desc_end
);
708 language
[2] = get8(&p
, desc_end
);
710 av_metadata_set(&st
->metadata
, "language", language
);
712 case 0x05: /* registration descriptor */
713 st
->codec
->codec_tag
= bytestream_get_le32(&p
);
714 dprintf(ts
->stream
, "reg_desc=%.4s\n", (char*)&st
->codec
->codec_tag
);
715 if (st
->codec
->codec_id
== CODEC_ID_PROBE
&&
716 stream_type
== STREAM_TYPE_PRIVATE_DATA
)
717 mpegts_find_stream_type(st
, st
->codec
->codec_tag
, REGD_types
);
726 /* all parameters are there */
728 mpegts_close_filter(ts
, filter
);
731 static void pat_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
733 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
734 SectionHeader h1
, *h
= &h1
;
735 const uint8_t *p
, *p_end
;
739 dprintf(ts
->stream
, "PAT:\n");
740 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
742 p_end
= section
+ section_len
- 4;
744 if (parse_section_header(h
, &p
, p_end
) < 0)
746 if (h
->tid
!= PAT_TID
)
751 sid
= get16(&p
, p_end
);
754 pmt_pid
= get16(&p
, p_end
) & 0x1fff;
758 dprintf(ts
->stream
, "sid=0x%x pid=0x%x\n", sid
, pmt_pid
);
763 av_new_program(ts
->stream
, sid
);
765 mpegts_open_section_filter(ts
, pmt_pid
, pmt_cb
, ts
, 1);
766 add_pat_entry(ts
, sid
);
767 add_pid_to_pmt(ts
, sid
, 0); //add pat pid to program
768 add_pid_to_pmt(ts
, sid
, pmt_pid
);
774 mpegts_close_filter(ts
, filter
);
777 static void sdt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
779 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
780 SectionHeader h1
, *h
= &h1
;
781 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
782 int onid
, val
, sid
, desc_list_len
, desc_tag
, desc_len
, service_type
;
783 char *name
, *provider_name
;
786 dprintf(ts
->stream
, "SDT:\n");
787 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
790 p_end
= section
+ section_len
- 4;
792 if (parse_section_header(h
, &p
, p_end
) < 0)
794 if (h
->tid
!= SDT_TID
)
796 onid
= get16(&p
, p_end
);
799 val
= get8(&p
, p_end
);
803 sid
= get16(&p
, p_end
);
806 val
= get8(&p
, p_end
);
809 desc_list_len
= get16(&p
, p_end
) & 0xfff;
810 if (desc_list_len
< 0)
812 desc_list_end
= p
+ desc_list_len
;
813 if (desc_list_end
> p_end
)
816 desc_tag
= get8(&p
, desc_list_end
);
819 desc_len
= get8(&p
, desc_list_end
);
820 desc_end
= p
+ desc_len
;
821 if (desc_end
> desc_list_end
)
824 dprintf(ts
->stream
, "tag: 0x%02x len=%d\n",
829 service_type
= get8(&p
, p_end
);
830 if (service_type
< 0)
832 provider_name
= getstr8(&p
, p_end
);
835 name
= getstr8(&p
, p_end
);
837 AVProgram
*program
= av_new_program(ts
->stream
, sid
);
839 av_metadata_set(&program
->metadata
, "name", name
);
840 av_metadata_set(&program
->metadata
, "provider_name", provider_name
);
844 av_free(provider_name
);
855 static int64_t get_pts(const uint8_t *p
)
857 int64_t pts
= (int64_t)((p
[0] >> 1) & 0x07) << 30;
858 pts
|= (AV_RB16(p
+ 1) >> 1) << 15;
859 pts
|= AV_RB16(p
+ 3) >> 1;
863 static void new_pes_packet(PESContext
*pes
, AVPacket
*pkt
)
867 pkt
->destruct
= av_destruct_packet
;
868 pkt
->data
= pes
->buffer
;
869 pkt
->size
= pes
->data_index
;
870 memset(pkt
->data
+pkt
->size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
872 pkt
->stream_index
= pes
->st
->index
;
875 /* store position of first TS packet of this PES packet */
876 pkt
->pos
= pes
->ts_packet_pos
;
878 /* reset pts values */
879 pes
->pts
= AV_NOPTS_VALUE
;
880 pes
->dts
= AV_NOPTS_VALUE
;
885 /* return non zero if a packet could be constructed */
886 static int mpegts_push_data(MpegTSFilter
*filter
,
887 const uint8_t *buf
, int buf_size
, int is_start
,
890 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
891 MpegTSContext
*ts
= pes
->ts
;
899 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
900 new_pes_packet(pes
, ts
->pkt
);
903 pes
->state
= MPEGTS_HEADER
;
905 pes
->ts_packet_pos
= pos
;
908 while (buf_size
> 0) {
911 len
= PES_START_SIZE
- pes
->data_index
;
914 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
915 pes
->data_index
+= len
;
918 if (pes
->data_index
== PES_START_SIZE
) {
919 /* we got all the PES or section header. We can now
922 av_hex_dump_log(pes
->stream
, AV_LOG_DEBUG
, pes
->header
, pes
->data_index
);
924 if (pes
->header
[0] == 0x00 && pes
->header
[1] == 0x00 &&
925 pes
->header
[2] == 0x01) {
926 /* it must be an mpeg2 PES stream */
927 code
= pes
->header
[3] | 0x100;
928 dprintf(pes
->stream
, "pid=%x pes_code=%#x\n", pes
->pid
, code
);
930 if ((!pes
->st
&& pes
->stream
->nb_streams
== MAX_STREAMS
) ||
931 (pes
->st
&& pes
->st
->discard
== AVDISCARD_ALL
) ||
932 code
== 0x1be) /* padding_stream */
935 /* stream not present in PMT */
937 pes
->st
= new_pes_av_stream(pes
, 0, code
);
939 return AVERROR(ENOMEM
);
941 pes
->total_size
= AV_RB16(pes
->header
+ 4);
942 /* NOTE: a zero total size means the PES size is
944 if (!pes
->total_size
)
945 pes
->total_size
= MAX_PES_PAYLOAD
;
947 /* allocate pes buffer */
948 pes
->buffer
= av_malloc(pes
->total_size
+FF_INPUT_BUFFER_PADDING_SIZE
);
950 return AVERROR(ENOMEM
);
952 if (code
!= 0x1bc && code
!= 0x1bf && /* program_stream_map, private_stream_2 */
953 code
!= 0x1f0 && code
!= 0x1f1 && /* ECM, EMM */
954 code
!= 0x1ff && code
!= 0x1f2 && /* program_stream_directory, DSMCC_stream */
955 code
!= 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
956 pes
->state
= MPEGTS_PESHEADER
;
958 pes
->state
= MPEGTS_PAYLOAD
;
962 /* otherwise, it should be a table */
965 pes
->state
= MPEGTS_SKIP
;
970 /**********************************************/
971 /* PES packing parsing */
972 case MPEGTS_PESHEADER
:
973 len
= PES_HEADER_SIZE
- pes
->data_index
;
978 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
979 pes
->data_index
+= len
;
982 if (pes
->data_index
== PES_HEADER_SIZE
) {
983 pes
->pes_header_size
= pes
->header
[8] + 9;
984 pes
->state
= MPEGTS_PESHEADER_FILL
;
987 case MPEGTS_PESHEADER_FILL
:
988 len
= pes
->pes_header_size
- pes
->data_index
;
993 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
994 pes
->data_index
+= len
;
997 if (pes
->data_index
== pes
->pes_header_size
) {
1001 flags
= pes
->header
[7];
1002 r
= pes
->header
+ 9;
1003 pes
->pts
= AV_NOPTS_VALUE
;
1004 pes
->dts
= AV_NOPTS_VALUE
;
1005 if ((flags
& 0xc0) == 0x80) {
1006 pes
->dts
= pes
->pts
= get_pts(r
);
1008 } else if ((flags
& 0xc0) == 0xc0) {
1009 pes
->pts
= get_pts(r
);
1011 pes
->dts
= get_pts(r
);
1015 /* we got the full header. We parse it and get the payload */
1016 pes
->state
= MPEGTS_PAYLOAD
;
1017 pes
->data_index
= 0;
1020 case MPEGTS_PAYLOAD
:
1022 if (pes
->data_index
+buf_size
> pes
->total_size
) {
1023 new_pes_packet(pes
, ts
->pkt
);
1024 pes
->total_size
= MAX_PES_PAYLOAD
;
1025 pes
->buffer
= av_malloc(pes
->total_size
+FF_INPUT_BUFFER_PADDING_SIZE
);
1027 return AVERROR(ENOMEM
);
1030 memcpy(pes
->buffer
+pes
->data_index
, p
, buf_size
);
1031 pes
->data_index
+= buf_size
;
1044 static PESContext
*add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
, int stream_type
)
1049 /* if no pid found, then add a pid context */
1050 pes
= av_mallocz(sizeof(PESContext
));
1054 pes
->stream
= ts
->stream
;
1056 pes
->pcr_pid
= pcr_pid
;
1057 pes
->stream_type
= stream_type
;
1058 pes
->state
= MPEGTS_SKIP
;
1059 tss
= mpegts_open_pes_filter(ts
, pid
, mpegts_push_data
, pes
);
1067 /* handle one TS packet */
1068 static int handle_packet(MpegTSContext
*ts
, const uint8_t *packet
)
1070 AVFormatContext
*s
= ts
->stream
;
1072 int len
, pid
, cc
, cc_ok
, afc
, is_start
;
1073 const uint8_t *p
, *p_end
;
1076 pid
= AV_RB16(packet
+ 1) & 0x1fff;
1077 if(pid
&& discard_pid(ts
, pid
))
1079 is_start
= packet
[1] & 0x40;
1080 tss
= ts
->pids
[pid
];
1081 if (ts
->auto_guess
&& tss
== NULL
&& is_start
) {
1082 add_pes_stream(ts
, pid
, -1, 0);
1083 tss
= ts
->pids
[pid
];
1088 /* continuity check (currently not used) */
1089 cc
= (packet
[3] & 0xf);
1090 cc_ok
= (tss
->last_cc
< 0) || ((((tss
->last_cc
+ 1) & 0x0f) == cc
));
1093 /* skip adaptation field */
1094 afc
= (packet
[3] >> 4) & 3;
1096 if (afc
== 0) /* reserved value */
1098 if (afc
== 2) /* adaptation field only */
1101 /* skip adapation field */
1104 /* if past the end of packet, ignore */
1105 p_end
= packet
+ TS_PACKET_SIZE
;
1109 pos
= url_ftell(ts
->stream
->pb
);
1110 ts
->pos47
= pos
% ts
->raw_packet_size
;
1112 if (tss
->type
== MPEGTS_SECTION
) {
1114 /* pointer field present */
1116 if (p
+ len
> p_end
)
1119 /* write remaining section bytes */
1120 write_section_data(s
, tss
,
1122 /* check whether filter has been closed */
1128 write_section_data(s
, tss
,
1133 write_section_data(s
, tss
,
1139 // Note: The position here points actually behind the current packet.
1140 if ((ret
= tss
->u
.pes_filter
.pes_cb(tss
, p
, p_end
- p
, is_start
,
1141 pos
- ts
->raw_packet_size
)) < 0)
1148 /* XXX: try to find a better synchro over several packets (use
1149 get_packet_size() ?) */
1150 static int mpegts_resync(ByteIOContext
*pb
)
1154 for(i
= 0;i
< MAX_RESYNC_SIZE
; i
++) {
1159 url_fseek(pb
, -1, SEEK_CUR
);
1167 /* return -1 if error or EOF. Return 0 if OK. */
1168 static int read_packet(ByteIOContext
*pb
, uint8_t *buf
, int raw_packet_size
)
1173 len
= get_buffer(pb
, buf
, TS_PACKET_SIZE
);
1174 if (len
!= TS_PACKET_SIZE
)
1175 return AVERROR(EIO
);
1176 /* check paquet sync byte */
1177 if (buf
[0] != 0x47) {
1178 /* find a new packet start */
1179 url_fseek(pb
, -TS_PACKET_SIZE
, SEEK_CUR
);
1180 if (mpegts_resync(pb
) < 0)
1181 return AVERROR_INVALIDDATA
;
1185 skip
= raw_packet_size
- TS_PACKET_SIZE
;
1187 url_fskip(pb
, skip
);
1194 static int handle_packets(MpegTSContext
*ts
, int nb_packets
)
1196 AVFormatContext
*s
= ts
->stream
;
1197 ByteIOContext
*pb
= s
->pb
;
1198 uint8_t packet
[TS_PACKET_SIZE
];
1199 int packet_num
, ret
;
1204 if (ts
->stop_parse
>0)
1207 if (nb_packets
!= 0 && packet_num
>= nb_packets
)
1209 ret
= read_packet(pb
, packet
, ts
->raw_packet_size
);
1212 ret
= handle_packet(ts
, packet
);
1219 static int mpegts_probe(AVProbeData
*p
)
1222 const int size
= p
->buf_size
;
1223 int score
, fec_score
, dvhs_score
;
1224 int check_count
= size
/ TS_FEC_PACKET_SIZE
;
1225 #define CHECK_COUNT 10
1227 if (check_count
< CHECK_COUNT
)
1230 score
= analyze(p
->buf
, TS_PACKET_SIZE
*check_count
, TS_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1231 dvhs_score
= analyze(p
->buf
, TS_DVHS_PACKET_SIZE
*check_count
, TS_DVHS_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1232 fec_score
= analyze(p
->buf
, TS_FEC_PACKET_SIZE
*check_count
, TS_FEC_PACKET_SIZE
, NULL
)*CHECK_COUNT
/check_count
;
1233 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1235 // we need a clear definition for the returned score otherwise things will become messy sooner or later
1236 if (score
> fec_score
&& score
> dvhs_score
&& score
> 6) return AVPROBE_SCORE_MAX
+ score
- CHECK_COUNT
;
1237 else if(dvhs_score
> score
&& dvhs_score
> fec_score
&& dvhs_score
> 6) return AVPROBE_SCORE_MAX
+ dvhs_score
- CHECK_COUNT
;
1238 else if( fec_score
> 6) return AVPROBE_SCORE_MAX
+ fec_score
- CHECK_COUNT
;
1241 /* only use the extension for safer guess */
1242 if (match_ext(p
->filename
, "ts"))
1243 return AVPROBE_SCORE_MAX
;
1249 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
1250 (-1) if not available */
1251 static int parse_pcr(int64_t *ppcr_high
, int *ppcr_low
,
1252 const uint8_t *packet
)
1254 int afc
, len
, flags
;
1258 afc
= (packet
[3] >> 4) & 3;
1268 if (!(flags
& 0x10))
1273 *ppcr_high
= ((int64_t)v
<< 1) | (p
[4] >> 7);
1274 *ppcr_low
= ((p
[4] & 1) << 8) | p
[5];
1278 static int mpegts_read_header(AVFormatContext
*s
,
1279 AVFormatParameters
*ap
)
1281 MpegTSContext
*ts
= s
->priv_data
;
1282 ByteIOContext
*pb
= s
->pb
;
1283 uint8_t buf
[5*1024];
1288 ts
->mpeg2ts_compute_pcr
= ap
->mpeg2ts_compute_pcr
;
1289 if(ap
->mpeg2ts_raw
){
1290 av_log(s
, AV_LOG_ERROR
, "use mpegtsraw_demuxer!\n");
1295 /* read the first 1024 bytes to get packet size */
1296 pos
= url_ftell(pb
);
1297 len
= get_buffer(pb
, buf
, sizeof(buf
));
1298 if (len
!= sizeof(buf
))
1300 ts
->raw_packet_size
= get_packet_size(buf
, sizeof(buf
));
1301 if (ts
->raw_packet_size
<= 0)
1306 if (s
->iformat
== &mpegts_demuxer
) {
1309 /* first do a scaning to get all the services */
1310 url_fseek(pb
, pos
, SEEK_SET
);
1312 mpegts_open_section_filter(ts
, SDT_PID
, sdt_cb
, ts
, 1);
1314 mpegts_open_section_filter(ts
, PAT_PID
, pat_cb
, ts
, 1);
1316 handle_packets(ts
, s
->probesize
);
1317 /* if could not find service, enable auto_guess */
1321 dprintf(ts
->stream
, "tuning done\n");
1323 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
1326 int pcr_pid
, pid
, nb_packets
, nb_pcrs
, ret
, pcr_l
;
1327 int64_t pcrs
[2], pcr_h
;
1328 int packet_count
[2];
1329 uint8_t packet
[TS_PACKET_SIZE
];
1331 /* only read packets */
1333 st
= av_new_stream(s
, 0);
1336 av_set_pts_info(st
, 60, 1, 27000000);
1337 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
1338 st
->codec
->codec_id
= CODEC_ID_MPEG2TS
;
1340 /* we iterate until we find two PCRs to estimate the bitrate */
1345 ret
= read_packet(s
->pb
, packet
, ts
->raw_packet_size
);
1348 pid
= AV_RB16(packet
+ 1) & 0x1fff;
1349 if ((pcr_pid
== -1 || pcr_pid
== pid
) &&
1350 parse_pcr(&pcr_h
, &pcr_l
, packet
) == 0) {
1352 packet_count
[nb_pcrs
] = nb_packets
;
1353 pcrs
[nb_pcrs
] = pcr_h
* 300 + pcr_l
;
1361 /* NOTE1: the bitrate is computed without the FEC */
1362 /* NOTE2: it is only the bitrate of the start of the stream */
1363 ts
->pcr_incr
= (pcrs
[1] - pcrs
[0]) / (packet_count
[1] - packet_count
[0]);
1364 ts
->cur_pcr
= pcrs
[0] - ts
->pcr_incr
* packet_count
[0];
1365 s
->bit_rate
= (TS_PACKET_SIZE
* 8) * 27e6
/ ts
->pcr_incr
;
1366 st
->codec
->bit_rate
= s
->bit_rate
;
1367 st
->start_time
= ts
->cur_pcr
;
1369 av_log(ts
->stream
, AV_LOG_DEBUG
, "start=%0.3f pcr=%0.3f incr=%d\n",
1370 st
->start_time
/ 1000000.0, pcrs
[0] / 27e6
, ts
->pcr_incr
);
1374 url_fseek(pb
, pos
, SEEK_SET
);
1380 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1382 static int mpegts_raw_read_packet(AVFormatContext
*s
,
1385 MpegTSContext
*ts
= s
->priv_data
;
1387 int64_t pcr_h
, next_pcr_h
, pos
;
1388 int pcr_l
, next_pcr_l
;
1389 uint8_t pcr_buf
[12];
1391 if (av_new_packet(pkt
, TS_PACKET_SIZE
) < 0)
1392 return AVERROR(ENOMEM
);
1393 pkt
->pos
= url_ftell(s
->pb
);
1394 ret
= read_packet(s
->pb
, pkt
->data
, ts
->raw_packet_size
);
1396 av_free_packet(pkt
);
1399 if (ts
->mpeg2ts_compute_pcr
) {
1400 /* compute exact PCR for each packet */
1401 if (parse_pcr(&pcr_h
, &pcr_l
, pkt
->data
) == 0) {
1402 /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1403 pos
= url_ftell(s
->pb
);
1404 for(i
= 0; i
< MAX_PACKET_READAHEAD
; i
++) {
1405 url_fseek(s
->pb
, pos
+ i
* ts
->raw_packet_size
, SEEK_SET
);
1406 get_buffer(s
->pb
, pcr_buf
, 12);
1407 if (parse_pcr(&next_pcr_h
, &next_pcr_l
, pcr_buf
) == 0) {
1408 /* XXX: not precise enough */
1409 ts
->pcr_incr
= ((next_pcr_h
- pcr_h
) * 300 + (next_pcr_l
- pcr_l
)) /
1414 url_fseek(s
->pb
, pos
, SEEK_SET
);
1415 /* no next PCR found: we use previous increment */
1416 ts
->cur_pcr
= pcr_h
* 300 + pcr_l
;
1418 pkt
->pts
= ts
->cur_pcr
;
1419 pkt
->duration
= ts
->pcr_incr
;
1420 ts
->cur_pcr
+= ts
->pcr_incr
;
1422 pkt
->stream_index
= 0;
1426 static int mpegts_read_packet(AVFormatContext
*s
,
1429 MpegTSContext
*ts
= s
->priv_data
;
1432 if (url_ftell(s
->pb
) != ts
->last_pos
) {
1433 /* seek detected, flush pes buffer */
1434 for (i
= 0; i
< NB_PID_MAX
; i
++) {
1435 if (ts
->pids
[i
] && ts
->pids
[i
]->type
== MPEGTS_PES
) {
1436 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
1437 av_freep(&pes
->buffer
);
1438 pes
->data_index
= 0;
1439 pes
->state
= MPEGTS_SKIP
; /* skip until pes header */
1445 ret
= handle_packets(ts
, 0);
1447 /* flush pes data left */
1448 for (i
= 0; i
< NB_PID_MAX
; i
++) {
1449 if (ts
->pids
[i
] && ts
->pids
[i
]->type
== MPEGTS_PES
) {
1450 PESContext
*pes
= ts
->pids
[i
]->u
.pes_filter
.opaque
;
1451 if (pes
->state
== MPEGTS_PAYLOAD
&& pes
->data_index
> 0) {
1452 new_pes_packet(pes
, pkt
);
1460 ts
->last_pos
= url_ftell(s
->pb
);
1465 static int mpegts_read_close(AVFormatContext
*s
)
1467 MpegTSContext
*ts
= s
->priv_data
;
1472 for(i
=0;i
<NB_PID_MAX
;i
++)
1473 if (ts
->pids
[i
]) mpegts_close_filter(ts
, ts
->pids
[i
]);
1478 static int64_t mpegts_get_pcr(AVFormatContext
*s
, int stream_index
,
1479 int64_t *ppos
, int64_t pos_limit
)
1481 MpegTSContext
*ts
= s
->priv_data
;
1482 int64_t pos
, timestamp
;
1483 uint8_t buf
[TS_PACKET_SIZE
];
1484 int pcr_l
, pcr_pid
= ((PESContext
*)s
->streams
[stream_index
]->priv_data
)->pcr_pid
;
1485 const int find_next
= 1;
1486 pos
= ((*ppos
+ ts
->raw_packet_size
- 1 - ts
->pos47
) / ts
->raw_packet_size
) * ts
->raw_packet_size
+ ts
->pos47
;
1489 url_fseek(s
->pb
, pos
, SEEK_SET
);
1490 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1491 return AV_NOPTS_VALUE
;
1492 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1493 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1496 pos
+= ts
->raw_packet_size
;
1500 pos
-= ts
->raw_packet_size
;
1502 return AV_NOPTS_VALUE
;
1503 url_fseek(s
->pb
, pos
, SEEK_SET
);
1504 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1505 return AV_NOPTS_VALUE
;
1506 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1507 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1517 static int read_seek(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int flags
){
1518 MpegTSContext
*ts
= s
->priv_data
;
1519 uint8_t buf
[TS_PACKET_SIZE
];
1522 if(av_seek_frame_binary(s
, stream_index
, target_ts
, flags
) < 0)
1525 pos
= url_ftell(s
->pb
);
1528 url_fseek(s
->pb
, pos
, SEEK_SET
);
1529 if (get_buffer(s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1531 // pid = AV_RB16(buf + 1) & 0x1fff;
1532 if(buf
[1] & 0x40) break;
1533 pos
+= ts
->raw_packet_size
;
1535 url_fseek(s
->pb
, pos
, SEEK_SET
);
1540 /**************************************************************/
1541 /* parsing functions - called from other demuxers such as RTP */
1543 MpegTSContext
*mpegts_parse_open(AVFormatContext
*s
)
1547 ts
= av_mallocz(sizeof(MpegTSContext
));
1550 /* no stream case, currently used by RTP */
1551 ts
->raw_packet_size
= TS_PACKET_SIZE
;
1557 /* return the consumed length if a packet was output, or -1 if no
1559 int mpegts_parse_packet(MpegTSContext
*ts
, AVPacket
*pkt
,
1560 const uint8_t *buf
, int len
)
1568 if (ts
->stop_parse
>0)
1570 if (len
< TS_PACKET_SIZE
)
1572 if (buf
[0] != 0x47) {
1576 handle_packet(ts
, buf
);
1577 buf
+= TS_PACKET_SIZE
;
1578 len
-= TS_PACKET_SIZE
;
1584 void mpegts_parse_close(MpegTSContext
*ts
)
1588 for(i
=0;i
<NB_PID_MAX
;i
++)
1589 av_free(ts
->pids
[i
]);
1593 AVInputFormat mpegts_demuxer
= {
1595 NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
1596 sizeof(MpegTSContext
),
1603 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,
1606 AVInputFormat mpegtsraw_demuxer
= {
1608 NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
1609 sizeof(MpegTSContext
),
1612 mpegts_raw_read_packet
,
1616 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,