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
28 /* 1.0 second at 24Mbit/s */
29 #define MAX_SCAN_PACKETS 32000
31 /* maximum size in which we look for synchronisation if
32 synchronisation is lost */
33 #define MAX_RESYNC_SIZE 4096
35 typedef struct PESContext PESContext
;
37 static PESContext
* add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
, int stream_type
);
38 static AVStream
* new_pes_av_stream(PESContext
*pes
, uint32_t code
);
39 extern void av_set_program_name(AVProgram
*program
, char *provider_name
, char *name
);
40 extern void av_program_add_stream_index(AVFormatContext
*ac
, int progid
, unsigned int idx
);
42 enum MpegTSFilterType
{
47 typedef struct MpegTSFilter MpegTSFilter
;
49 typedef void PESCallback(MpegTSFilter
*f
, const uint8_t *buf
, int len
, int is_start
);
51 typedef struct MpegTSPESFilter
{
56 typedef void SectionCallback(MpegTSFilter
*f
, const uint8_t *buf
, int len
);
58 typedef void SetServiceCallback(void *opaque
, int ret
);
60 typedef struct MpegTSSectionFilter
{
65 int end_of_section_reached
:1;
66 SectionCallback
*section_cb
;
68 } MpegTSSectionFilter
;
72 int last_cc
; /* last cc code (-1 if first packet) */
73 enum MpegTSFilterType type
;
75 MpegTSPESFilter pes_filter
;
76 MpegTSSectionFilter section_filter
;
80 #define MAX_PIDS_PER_PROGRAM 64
82 unsigned int id
; //program id/service id
84 unsigned int pids
[MAX_PIDS_PER_PROGRAM
];
87 struct MpegTSContext
{
89 AVFormatContext
*stream
;
90 /** raw packet size, including FEC if present */
92 /** if true, all pids are analyzed to find streams */
95 /** compute exact PCR for each transport stream packet */
96 int mpeg2ts_compute_pcr
;
98 int64_t cur_pcr
; /**< used to estimate the exact PCR */
99 int pcr_incr
; /**< used to estimate the exact PCR */
101 /* data needed to handle file based ts */
102 /** stop parsing loop */
104 /** packet containing Audio/Video data */
107 /******************************************/
108 /* private mpegts data */
110 /** structure to keep track of Program->pids mapping */
115 /** filters for various streams specified by PMT + for the PAT and PMT */
116 MpegTSFilter
*pids
[NB_PID_MAX
];
119 /* TS stream handling */
123 MPEGTS_PESHEADER_FILL
,
128 /* enough for PES header + length */
129 #define PES_START_SIZE 9
130 #define MAX_PES_HEADER_SIZE (9 + 255)
134 int pcr_pid
; /**< if -1 then all packets containing PCR are considered */
137 AVFormatContext
*stream
;
139 enum MpegTSState state
;
140 /* used to get the format */
145 uint8_t header
[MAX_PES_HEADER_SIZE
];
148 extern AVInputFormat mpegts_demuxer
;
150 static void clear_program(MpegTSContext
*ts
, unsigned int programid
)
154 for(i
=0; i
<ts
->nb_prg
; i
++)
155 if(ts
->prg
[i
].id
== programid
)
156 ts
->prg
[i
].nb_pids
= 0;
159 static void clear_programs(MpegTSContext
*ts
)
165 static void add_pat_entry(MpegTSContext
*ts
, unsigned int programid
)
168 void *tmp
= av_realloc(ts
->prg
, (ts
->nb_prg
+1)*sizeof(Program_t
));
172 p
= &ts
->prg
[ts
->nb_prg
];
178 static void add_pid_to_pmt(MpegTSContext
*ts
, unsigned int programid
, unsigned int pid
)
182 for(i
=0; i
<ts
->nb_prg
; i
++) {
183 if(ts
->prg
[i
].id
== programid
) {
191 if(p
->nb_pids
>= MAX_PIDS_PER_PROGRAM
)
193 p
->pids
[p
->nb_pids
++] = pid
;
197 * \brief discard_pid() decides if the pid is to be discarded according
198 * to caller's programs selection
199 * \param ts : - TS context
201 * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
204 static int discard_pid(MpegTSContext
*ts
, unsigned int pid
)
207 int used
= 0, discarded
= 0;
209 for(i
=0; i
<ts
->nb_prg
; i
++) {
211 for(j
=0; j
<p
->nb_pids
; j
++) {
212 if(p
->pids
[j
] != pid
)
214 //is program with id p->id set to be discarded?
215 for(k
=0; k
<ts
->stream
->nb_programs
; k
++) {
216 if(ts
->stream
->programs
[k
]->id
== p
->id
) {
217 if(ts
->stream
->programs
[k
]->discard
== AVDISCARD_ALL
)
226 return (!used
&& discarded
);
230 * Assembles PES packets out of TS packets, and then calls the "section_cb"
231 * function when they are complete.
233 static void write_section_data(AVFormatContext
*s
, MpegTSFilter
*tss1
,
234 const uint8_t *buf
, int buf_size
, int is_start
)
236 MpegTSSectionFilter
*tss
= &tss1
->u
.section_filter
;
240 memcpy(tss
->section_buf
, buf
, buf_size
);
241 tss
->section_index
= buf_size
;
242 tss
->section_h_size
= -1;
243 tss
->end_of_section_reached
= 0;
245 if (tss
->end_of_section_reached
)
247 len
= 4096 - tss
->section_index
;
250 memcpy(tss
->section_buf
+ tss
->section_index
, buf
, len
);
251 tss
->section_index
+= len
;
254 /* compute section length if possible */
255 if (tss
->section_h_size
== -1 && tss
->section_index
>= 3) {
256 len
= (AV_RB16(tss
->section_buf
+ 1) & 0xfff) + 3;
259 tss
->section_h_size
= len
;
262 if (tss
->section_h_size
!= -1 && tss
->section_index
>= tss
->section_h_size
) {
263 tss
->end_of_section_reached
= 1;
264 if (!tss
->check_crc
||
265 av_crc(av_crc04C11DB7
, -1, tss
->section_buf
, tss
->section_h_size
) == 0)
266 tss
->section_cb(tss1
, tss
->section_buf
, tss
->section_h_size
);
270 static MpegTSFilter
*mpegts_open_section_filter(MpegTSContext
*ts
, unsigned int pid
,
271 SectionCallback
*section_cb
, void *opaque
,
275 MpegTSFilter
*filter
;
276 MpegTSSectionFilter
*sec
;
279 av_log(ts
->stream
, AV_LOG_DEBUG
, "Filter: pid=0x%x\n", pid
);
281 if (pid
>= NB_PID_MAX
|| ts
->pids
[pid
])
283 filter
= av_mallocz(sizeof(MpegTSFilter
));
286 ts
->pids
[pid
] = filter
;
287 filter
->type
= MPEGTS_SECTION
;
289 filter
->last_cc
= -1;
290 sec
= &filter
->u
.section_filter
;
291 sec
->section_cb
= section_cb
;
292 sec
->opaque
= opaque
;
293 sec
->section_buf
= av_malloc(MAX_SECTION_SIZE
);
294 sec
->check_crc
= check_crc
;
295 if (!sec
->section_buf
) {
302 static MpegTSFilter
*mpegts_open_pes_filter(MpegTSContext
*ts
, unsigned int pid
,
306 MpegTSFilter
*filter
;
307 MpegTSPESFilter
*pes
;
309 if (pid
>= NB_PID_MAX
|| ts
->pids
[pid
])
311 filter
= av_mallocz(sizeof(MpegTSFilter
));
314 ts
->pids
[pid
] = filter
;
315 filter
->type
= MPEGTS_PES
;
317 filter
->last_cc
= -1;
318 pes
= &filter
->u
.pes_filter
;
319 pes
->pes_cb
= pes_cb
;
320 pes
->opaque
= opaque
;
324 static void mpegts_close_filter(MpegTSContext
*ts
, MpegTSFilter
*filter
)
329 if (filter
->type
== MPEGTS_SECTION
)
330 av_freep(&filter
->u
.section_filter
.section_buf
);
331 else if (filter
->type
== MPEGTS_PES
)
332 av_freep(&filter
->u
.pes_filter
.opaque
);
335 ts
->pids
[pid
] = NULL
;
338 static int analyze(const uint8_t *buf
, int size
, int packet_size
, int *index
){
339 int stat
[packet_size
];
344 memset(stat
, 0, packet_size
*sizeof(int));
346 for(x
=i
=0; i
<size
; i
++){
349 if(stat
[x
] > best_score
){
356 if(x
== packet_size
) x
= 0;
362 /* autodetect fec presence. Must have at least 1024 bytes */
363 static int get_packet_size(const uint8_t *buf
, int size
)
365 int score
, fec_score
, dvhs_score
;
367 if (size
< (TS_FEC_PACKET_SIZE
* 5 + 1))
370 score
= analyze(buf
, size
, TS_PACKET_SIZE
, NULL
);
371 dvhs_score
= analyze(buf
, size
, TS_DVHS_PACKET_SIZE
, NULL
);
372 fec_score
= analyze(buf
, size
, TS_FEC_PACKET_SIZE
, NULL
);
373 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
375 if (score
> fec_score
&& score
> dvhs_score
) return TS_PACKET_SIZE
;
376 else if(dvhs_score
> score
&& dvhs_score
> fec_score
) return TS_DVHS_PACKET_SIZE
;
377 else if(score
< fec_score
&& dvhs_score
< fec_score
) return TS_FEC_PACKET_SIZE
;
381 typedef struct SectionHeader
{
386 uint8_t last_sec_num
;
389 static inline int get8(const uint8_t **pp
, const uint8_t *p_end
)
402 static inline int get16(const uint8_t **pp
, const uint8_t *p_end
)
408 if ((p
+ 1) >= p_end
)
416 /* read and allocate a DVB string preceeded by its length */
417 static char *getstr8(const uint8_t **pp
, const uint8_t *p_end
)
424 len
= get8(&p
, p_end
);
427 if ((p
+ len
) > p_end
)
429 str
= av_malloc(len
+ 1);
439 static int parse_section_header(SectionHeader
*h
,
440 const uint8_t **pp
, const uint8_t *p_end
)
444 val
= get8(pp
, p_end
);
449 val
= get16(pp
, p_end
);
453 val
= get8(pp
, p_end
);
456 h
->version
= (val
>> 1) & 0x1f;
457 val
= get8(pp
, p_end
);
461 val
= get8(pp
, p_end
);
464 h
->last_sec_num
= val
;
469 static void pmt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
471 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
472 SectionHeader h1
, *h
= &h1
;
475 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
476 int program_info_length
, pcr_pid
, pid
, stream_type
;
477 int desc_list_len
, desc_len
, desc_tag
;
478 int comp_page
= 0, anc_page
= 0; /* initialize to kill warnings */
479 char language
[4] = {0}; /* initialize to kill warnings */
482 av_log(ts
->stream
, AV_LOG_DEBUG
, "PMT: len %i\n", section_len
);
483 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
485 p_end
= section
+ section_len
- 4;
487 if (parse_section_header(h
, &p
, p_end
) < 0)
490 av_log(ts
->stream
, AV_LOG_DEBUG
, "sid=0x%x sec_num=%d/%d\n",
491 h
->id
, h
->sec_num
, h
->last_sec_num
);
493 if (h
->tid
!= PMT_TID
)
496 clear_program(ts
, h
->id
);
497 pcr_pid
= get16(&p
, p_end
) & 0x1fff;
500 add_pid_to_pmt(ts
, h
->id
, pcr_pid
);
502 av_log(ts
->stream
, AV_LOG_DEBUG
, "pcr_pid=0x%x\n", pcr_pid
);
504 program_info_length
= get16(&p
, p_end
) & 0xfff;
505 if (program_info_length
< 0)
507 p
+= program_info_length
;
513 stream_type
= get8(&p
, p_end
);
516 pid
= get16(&p
, p_end
) & 0x1fff;
519 desc_list_len
= get16(&p
, p_end
) & 0xfff;
520 if (desc_list_len
< 0)
522 desc_list_end
= p
+ desc_list_len
;
523 if (desc_list_end
> p_end
)
526 desc_tag
= get8(&p
, desc_list_end
);
529 if (stream_type
== STREAM_TYPE_PRIVATE_DATA
) {
530 if((desc_tag
== 0x6A) || (desc_tag
== 0x7A)) {
531 /*assume DVB AC-3 Audio*/
532 stream_type
= STREAM_TYPE_AUDIO_AC3
;
533 } else if(desc_tag
== 0x7B) {
535 stream_type
= STREAM_TYPE_AUDIO_DTS
;
538 desc_len
= get8(&p
, desc_list_end
);
539 desc_end
= p
+ desc_len
;
540 if (desc_end
> desc_list_end
)
543 av_log(ts
->stream
, AV_LOG_DEBUG
, "tag: 0x%02x len=%d\n",
547 case DVB_SUBT_DESCID
:
548 if (stream_type
== STREAM_TYPE_PRIVATE_DATA
)
549 stream_type
= STREAM_TYPE_SUBTITLE_DVB
;
551 language
[0] = get8(&p
, desc_end
);
552 language
[1] = get8(&p
, desc_end
);
553 language
[2] = get8(&p
, desc_end
);
556 comp_page
= get16(&p
, desc_end
);
557 anc_page
= get16(&p
, desc_end
);
560 case 0x0a: /* ISO 639 language descriptor */
561 language
[0] = get8(&p
, desc_end
);
562 language
[1] = get8(&p
, desc_end
);
563 language
[2] = get8(&p
, desc_end
);
574 av_log(ts
->stream
, AV_LOG_DEBUG
, "stream_type=%d pid=0x%x\n",
578 /* now create ffmpeg stream */
579 switch(stream_type
) {
580 case STREAM_TYPE_AUDIO_MPEG1
:
581 case STREAM_TYPE_AUDIO_MPEG2
:
582 case STREAM_TYPE_VIDEO_MPEG1
:
583 case STREAM_TYPE_VIDEO_MPEG2
:
584 case STREAM_TYPE_VIDEO_MPEG4
:
585 case STREAM_TYPE_VIDEO_H264
:
586 case STREAM_TYPE_VIDEO_VC1
:
587 case STREAM_TYPE_AUDIO_AAC
:
588 case STREAM_TYPE_AUDIO_AC3
:
589 case STREAM_TYPE_AUDIO_DTS
:
590 case STREAM_TYPE_SUBTITLE_DVB
:
591 if(ts
->pids
[pid
] && ts
->pids
[pid
]->type
== MPEGTS_PES
){
592 pes
= ts
->pids
[pid
]->u
.pes_filter
.opaque
;
595 if (ts
->pids
[pid
]) mpegts_close_filter(ts
, ts
->pids
[pid
]); //wrongly added sdt filter probably
596 pes
= add_pes_stream(ts
, pid
, pcr_pid
, stream_type
);
598 st
= new_pes_av_stream(pes
, 0);
600 add_pid_to_pmt(ts
, h
->id
, pid
);
602 av_program_add_stream_index(ts
->stream
, h
->id
, st
->index
);
605 /* we ignore the other streams */
610 if (language
[0] != 0) {
611 memcpy(st
->language
, language
, 4);
614 if (stream_type
== STREAM_TYPE_SUBTITLE_DVB
) {
615 st
->codec
->sub_id
= (anc_page
<< 16) | comp_page
;
619 /* all parameters are there */
621 mpegts_close_filter(ts
, filter
);
624 static void pat_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
626 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
627 SectionHeader h1
, *h
= &h1
;
628 const uint8_t *p
, *p_end
;
632 av_log(ts
->stream
, AV_LOG_DEBUG
, "PAT:\n");
633 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
635 p_end
= section
+ section_len
- 4;
637 if (parse_section_header(h
, &p
, p_end
) < 0)
639 if (h
->tid
!= PAT_TID
)
644 sid
= get16(&p
, p_end
);
647 pmt_pid
= get16(&p
, p_end
) & 0x1fff;
651 av_log(ts
->stream
, AV_LOG_DEBUG
, "sid=0x%x pid=0x%x\n", sid
, pmt_pid
);
656 av_new_program(ts
->stream
, sid
);
658 mpegts_open_section_filter(ts
, pmt_pid
, pmt_cb
, ts
, 1);
659 add_pat_entry(ts
, sid
);
660 add_pid_to_pmt(ts
, sid
, 0); //add pat pid to program
661 add_pid_to_pmt(ts
, sid
, pmt_pid
);
667 mpegts_close_filter(ts
, filter
);
670 static void mpegts_set_service(MpegTSContext
*ts
)
672 mpegts_open_section_filter(ts
, PAT_PID
,
676 static void sdt_cb(MpegTSFilter
*filter
, const uint8_t *section
, int section_len
)
678 MpegTSContext
*ts
= filter
->u
.section_filter
.opaque
;
679 SectionHeader h1
, *h
= &h1
;
680 const uint8_t *p
, *p_end
, *desc_list_end
, *desc_end
;
681 int onid
, val
, sid
, desc_list_len
, desc_tag
, desc_len
, service_type
;
682 char *name
, *provider_name
;
685 av_log(ts
->stream
, AV_LOG_DEBUG
, "SDT:\n");
686 av_hex_dump_log(ts
->stream
, AV_LOG_DEBUG
, (uint8_t *)section
, section_len
);
689 p_end
= section
+ section_len
- 4;
691 if (parse_section_header(h
, &p
, p_end
) < 0)
693 if (h
->tid
!= SDT_TID
)
695 onid
= get16(&p
, p_end
);
698 val
= get8(&p
, p_end
);
702 sid
= get16(&p
, p_end
);
705 val
= get8(&p
, p_end
);
708 desc_list_len
= get16(&p
, p_end
) & 0xfff;
709 if (desc_list_len
< 0)
711 desc_list_end
= p
+ desc_list_len
;
712 if (desc_list_end
> p_end
)
715 desc_tag
= get8(&p
, desc_list_end
);
718 desc_len
= get8(&p
, desc_list_end
);
719 desc_end
= p
+ desc_len
;
720 if (desc_end
> desc_list_end
)
723 av_log(ts
->stream
, AV_LOG_DEBUG
, "tag: 0x%02x len=%d\n",
728 service_type
= get8(&p
, p_end
);
729 if (service_type
< 0)
731 provider_name
= getstr8(&p
, p_end
);
734 name
= getstr8(&p
, p_end
);
736 AVProgram
*program
= av_new_program(ts
->stream
, sid
);
738 av_set_program_name(program
, provider_name
, name
);
750 /* scan services in a transport stream by looking at the SDT */
751 static void mpegts_scan_sdt(MpegTSContext
*ts
)
753 mpegts_open_section_filter(ts
, SDT_PID
,
757 static int64_t get_pts(const uint8_t *p
)
759 int64_t pts
= (int64_t)((p
[0] >> 1) & 0x07) << 30;
760 pts
|= (AV_RB16(p
+ 1) >> 1) << 15;
761 pts
|= AV_RB16(p
+ 3) >> 1;
765 /* return non zero if a packet could be constructed */
766 static void mpegts_push_data(MpegTSFilter
*filter
,
767 const uint8_t *buf
, int buf_size
, int is_start
)
769 PESContext
*pes
= filter
->u
.pes_filter
.opaque
;
770 MpegTSContext
*ts
= pes
->ts
;
778 pes
->state
= MPEGTS_HEADER
;
782 while (buf_size
> 0) {
785 len
= PES_START_SIZE
- pes
->data_index
;
788 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
789 pes
->data_index
+= len
;
792 if (pes
->data_index
== PES_START_SIZE
) {
793 /* we got all the PES or section header. We can now
796 av_hex_dump_log(pes
->stream
, AV_LOG_DEBUG
, pes
->header
, pes
->data_index
);
798 if (pes
->header
[0] == 0x00 && pes
->header
[1] == 0x00 &&
799 pes
->header
[2] == 0x01) {
800 /* it must be an mpeg2 PES stream */
801 code
= pes
->header
[3] | 0x100;
802 if (!((code
>= 0x1c0 && code
<= 0x1df) ||
803 (code
>= 0x1e0 && code
<= 0x1ef) ||
804 (code
== 0x1bd) || (code
== 0x1fd)))
807 /* allocate stream */
808 new_pes_av_stream(pes
, code
);
810 pes
->state
= MPEGTS_PESHEADER_FILL
;
811 pes
->total_size
= AV_RB16(pes
->header
+ 4);
812 /* NOTE: a zero total size means the PES size is
815 pes
->total_size
+= 6;
816 pes
->pes_header_size
= pes
->header
[8] + 9;
818 /* otherwise, it should be a table */
821 pes
->state
= MPEGTS_SKIP
;
826 /**********************************************/
827 /* PES packing parsing */
828 case MPEGTS_PESHEADER_FILL
:
829 len
= pes
->pes_header_size
- pes
->data_index
;
832 memcpy(pes
->header
+ pes
->data_index
, p
, len
);
833 pes
->data_index
+= len
;
836 if (pes
->data_index
== pes
->pes_header_size
) {
840 flags
= pes
->header
[7];
842 pes
->pts
= AV_NOPTS_VALUE
;
843 pes
->dts
= AV_NOPTS_VALUE
;
844 if ((flags
& 0xc0) == 0x80) {
845 pes
->pts
= get_pts(r
);
847 } else if ((flags
& 0xc0) == 0xc0) {
848 pes
->pts
= get_pts(r
);
850 pes
->dts
= get_pts(r
);
853 /* we got the full header. We parse it and get the payload */
854 pes
->state
= MPEGTS_PAYLOAD
;
858 if (pes
->total_size
) {
859 len
= pes
->total_size
- pes
->data_index
;
866 AVPacket
*pkt
= ts
->pkt
;
867 if (pes
->st
&& av_new_packet(pkt
, len
) == 0) {
868 memcpy(pkt
->data
, p
, len
);
869 pkt
->stream_index
= pes
->st
->index
;
872 /* reset pts values */
873 pes
->pts
= AV_NOPTS_VALUE
;
874 pes
->dts
= AV_NOPTS_VALUE
;
888 static AVStream
* new_pes_av_stream(PESContext
*pes
, uint32_t code
)
891 int codec_type
, codec_id
;
893 switch(pes
->stream_type
){
894 case STREAM_TYPE_AUDIO_MPEG1
:
895 case STREAM_TYPE_AUDIO_MPEG2
:
896 codec_type
= CODEC_TYPE_AUDIO
;
897 codec_id
= CODEC_ID_MP3
;
899 case STREAM_TYPE_VIDEO_MPEG1
:
900 case STREAM_TYPE_VIDEO_MPEG2
:
901 codec_type
= CODEC_TYPE_VIDEO
;
902 codec_id
= CODEC_ID_MPEG2VIDEO
;
904 case STREAM_TYPE_VIDEO_MPEG4
:
905 codec_type
= CODEC_TYPE_VIDEO
;
906 codec_id
= CODEC_ID_MPEG4
;
908 case STREAM_TYPE_VIDEO_H264
:
909 codec_type
= CODEC_TYPE_VIDEO
;
910 codec_id
= CODEC_ID_H264
;
912 case STREAM_TYPE_VIDEO_VC1
:
913 codec_type
= CODEC_TYPE_VIDEO
;
914 codec_id
= CODEC_ID_VC1
;
916 case STREAM_TYPE_AUDIO_AAC
:
917 codec_type
= CODEC_TYPE_AUDIO
;
918 codec_id
= CODEC_ID_AAC
;
920 case STREAM_TYPE_AUDIO_AC3
:
921 codec_type
= CODEC_TYPE_AUDIO
;
922 codec_id
= CODEC_ID_AC3
;
924 case STREAM_TYPE_AUDIO_DTS
:
925 codec_type
= CODEC_TYPE_AUDIO
;
926 codec_id
= CODEC_ID_DTS
;
928 case STREAM_TYPE_SUBTITLE_DVB
:
929 codec_type
= CODEC_TYPE_SUBTITLE
;
930 codec_id
= CODEC_ID_DVB_SUBTITLE
;
933 if (code
>= 0x1c0 && code
<= 0x1df) {
934 codec_type
= CODEC_TYPE_AUDIO
;
935 codec_id
= CODEC_ID_MP2
;
936 } else if (code
== 0x1bd) {
937 codec_type
= CODEC_TYPE_AUDIO
;
938 codec_id
= CODEC_ID_AC3
;
940 codec_type
= CODEC_TYPE_VIDEO
;
941 codec_id
= CODEC_ID_MPEG1VIDEO
;
945 st
= av_new_stream(pes
->stream
, pes
->pid
);
947 av_set_pts_info(st
, 33, 1, 90000);
949 st
->codec
->codec_type
= codec_type
;
950 st
->codec
->codec_id
= codec_id
;
951 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
958 static PESContext
*add_pes_stream(MpegTSContext
*ts
, int pid
, int pcr_pid
, int stream_type
)
963 /* if no pid found, then add a pid context */
964 pes
= av_mallocz(sizeof(PESContext
));
968 pes
->stream
= ts
->stream
;
970 pes
->pcr_pid
= pcr_pid
;
971 pes
->stream_type
= stream_type
;
972 tss
= mpegts_open_pes_filter(ts
, pid
, mpegts_push_data
, pes
);
980 /* handle one TS packet */
981 static void handle_packet(MpegTSContext
*ts
, const uint8_t *packet
)
983 AVFormatContext
*s
= ts
->stream
;
985 int len
, pid
, cc
, cc_ok
, afc
, is_start
;
986 const uint8_t *p
, *p_end
;
988 pid
= AV_RB16(packet
+ 1) & 0x1fff;
989 if(pid
&& discard_pid(ts
, pid
))
991 is_start
= packet
[1] & 0x40;
993 if (ts
->auto_guess
&& tss
== NULL
&& is_start
) {
994 add_pes_stream(ts
, pid
, -1, 0);
1000 /* continuity check (currently not used) */
1001 cc
= (packet
[3] & 0xf);
1002 cc_ok
= (tss
->last_cc
< 0) || ((((tss
->last_cc
+ 1) & 0x0f) == cc
));
1005 /* skip adaptation field */
1006 afc
= (packet
[3] >> 4) & 3;
1008 if (afc
== 0) /* reserved value */
1010 if (afc
== 2) /* adaptation field only */
1013 /* skip adapation field */
1016 /* if past the end of packet, ignore */
1017 p_end
= packet
+ TS_PACKET_SIZE
;
1021 if (tss
->type
== MPEGTS_SECTION
) {
1023 /* pointer field present */
1025 if (p
+ len
> p_end
)
1028 /* write remaining section bytes */
1029 write_section_data(s
, tss
,
1031 /* check whether filter has been closed */
1037 write_section_data(s
, tss
,
1042 write_section_data(s
, tss
,
1047 tss
->u
.pes_filter
.pes_cb(tss
,
1048 p
, p_end
- p
, is_start
);
1052 /* XXX: try to find a better synchro over several packets (use
1053 get_packet_size() ?) */
1054 static int mpegts_resync(ByteIOContext
*pb
)
1058 for(i
= 0;i
< MAX_RESYNC_SIZE
; i
++) {
1063 url_fseek(pb
, -1, SEEK_CUR
);
1071 /* return -1 if error or EOF. Return 0 if OK. */
1072 static int read_packet(ByteIOContext
*pb
, uint8_t *buf
, int raw_packet_size
)
1077 len
= get_buffer(pb
, buf
, TS_PACKET_SIZE
);
1078 if (len
!= TS_PACKET_SIZE
)
1079 return AVERROR(EIO
);
1080 /* check paquet sync byte */
1081 if (buf
[0] != 0x47) {
1082 /* find a new packet start */
1083 url_fseek(pb
, -TS_PACKET_SIZE
, SEEK_CUR
);
1084 if (mpegts_resync(pb
) < 0)
1085 return AVERROR_INVALIDDATA
;
1089 skip
= raw_packet_size
- TS_PACKET_SIZE
;
1091 url_fskip(pb
, skip
);
1098 static int handle_packets(MpegTSContext
*ts
, int nb_packets
)
1100 AVFormatContext
*s
= ts
->stream
;
1101 ByteIOContext
*pb
= &s
->pb
;
1102 uint8_t packet
[TS_PACKET_SIZE
];
1103 int packet_num
, ret
;
1108 if (ts
->stop_parse
>0)
1111 if (nb_packets
!= 0 && packet_num
>= nb_packets
)
1113 ret
= read_packet(pb
, packet
, ts
->raw_packet_size
);
1116 handle_packet(ts
, packet
);
1121 static int mpegts_probe(AVProbeData
*p
)
1124 const int size
= p
->buf_size
;
1125 int score
, fec_score
, dvhs_score
;
1126 #define CHECK_COUNT 10
1128 if (size
< (TS_FEC_PACKET_SIZE
* CHECK_COUNT
))
1131 score
= analyze(p
->buf
, TS_PACKET_SIZE
*CHECK_COUNT
, TS_PACKET_SIZE
, NULL
);
1132 dvhs_score
= analyze(p
->buf
, TS_DVHS_PACKET_SIZE
*CHECK_COUNT
, TS_DVHS_PACKET_SIZE
, NULL
);
1133 fec_score
= analyze(p
->buf
, TS_FEC_PACKET_SIZE
*CHECK_COUNT
, TS_FEC_PACKET_SIZE
, NULL
);
1134 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score);
1136 // we need a clear definition for the returned score otherwise things will become messy sooner or later
1137 if (score
> fec_score
&& score
> dvhs_score
&& score
> 6) return AVPROBE_SCORE_MAX
+ score
- CHECK_COUNT
;
1138 else if(dvhs_score
> score
&& dvhs_score
> fec_score
&& dvhs_score
> 6) return AVPROBE_SCORE_MAX
+ dvhs_score
- CHECK_COUNT
;
1139 else if( fec_score
> 6) return AVPROBE_SCORE_MAX
+ fec_score
- CHECK_COUNT
;
1142 /* only use the extension for safer guess */
1143 if (match_ext(p
->filename
, "ts"))
1144 return AVPROBE_SCORE_MAX
;
1150 /* return the 90 kHz PCR and the extension for the 27 MHz PCR. return
1151 (-1) if not available */
1152 static int parse_pcr(int64_t *ppcr_high
, int *ppcr_low
,
1153 const uint8_t *packet
)
1155 int afc
, len
, flags
;
1159 afc
= (packet
[3] >> 4) & 3;
1169 if (!(flags
& 0x10))
1174 *ppcr_high
= ((int64_t)v
<< 1) | (p
[4] >> 7);
1175 *ppcr_low
= ((p
[4] & 1) << 8) | p
[5];
1179 static int mpegts_read_header(AVFormatContext
*s
,
1180 AVFormatParameters
*ap
)
1182 MpegTSContext
*ts
= s
->priv_data
;
1183 ByteIOContext
*pb
= &s
->pb
;
1189 ts
->mpeg2ts_compute_pcr
= ap
->mpeg2ts_compute_pcr
;
1190 if(ap
->mpeg2ts_raw
){
1191 av_log(s
, AV_LOG_ERROR
, "use mpegtsraw_demuxer!\n");
1196 /* read the first 1024 bytes to get packet size */
1197 pos
= url_ftell(pb
);
1198 len
= get_buffer(pb
, buf
, sizeof(buf
));
1199 if (len
!= sizeof(buf
))
1201 ts
->raw_packet_size
= get_packet_size(buf
, sizeof(buf
));
1202 if (ts
->raw_packet_size
<= 0)
1207 if (s
->iformat
== &mpegts_demuxer
) {
1210 /* first do a scaning to get all the services */
1211 url_fseek(pb
, pos
, SEEK_SET
);
1212 mpegts_scan_sdt(ts
);
1214 mpegts_set_service(ts
);
1216 handle_packets(ts
, s
->probesize
);
1217 /* if could not find service, enable auto_guess */
1222 av_log(ts
->stream
, AV_LOG_DEBUG
, "tuning done\n");
1224 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
1227 int pcr_pid
, pid
, nb_packets
, nb_pcrs
, ret
, pcr_l
;
1228 int64_t pcrs
[2], pcr_h
;
1229 int packet_count
[2];
1230 uint8_t packet
[TS_PACKET_SIZE
];
1232 /* only read packets */
1234 st
= av_new_stream(s
, 0);
1237 av_set_pts_info(st
, 60, 1, 27000000);
1238 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
1239 st
->codec
->codec_id
= CODEC_ID_MPEG2TS
;
1241 /* we iterate until we find two PCRs to estimate the bitrate */
1246 ret
= read_packet(&s
->pb
, packet
, ts
->raw_packet_size
);
1249 pid
= AV_RB16(packet
+ 1) & 0x1fff;
1250 if ((pcr_pid
== -1 || pcr_pid
== pid
) &&
1251 parse_pcr(&pcr_h
, &pcr_l
, packet
) == 0) {
1253 packet_count
[nb_pcrs
] = nb_packets
;
1254 pcrs
[nb_pcrs
] = pcr_h
* 300 + pcr_l
;
1262 /* NOTE1: the bitrate is computed without the FEC */
1263 /* NOTE2: it is only the bitrate of the start of the stream */
1264 ts
->pcr_incr
= (pcrs
[1] - pcrs
[0]) / (packet_count
[1] - packet_count
[0]);
1265 ts
->cur_pcr
= pcrs
[0] - ts
->pcr_incr
* packet_count
[0];
1266 s
->bit_rate
= (TS_PACKET_SIZE
* 8) * 27e6
/ ts
->pcr_incr
;
1267 st
->codec
->bit_rate
= s
->bit_rate
;
1268 st
->start_time
= ts
->cur_pcr
;
1270 av_log(ts
->stream
, AV_LOG_DEBUG
, "start=%0.3f pcr=%0.3f incr=%d\n",
1271 st
->start_time
/ 1000000.0, pcrs
[0] / 27e6
, ts
->pcr_incr
);
1275 url_fseek(pb
, pos
, SEEK_SET
);
1281 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1283 static int mpegts_raw_read_packet(AVFormatContext
*s
,
1286 MpegTSContext
*ts
= s
->priv_data
;
1288 int64_t pcr_h
, next_pcr_h
, pos
;
1289 int pcr_l
, next_pcr_l
;
1290 uint8_t pcr_buf
[12];
1292 if (av_new_packet(pkt
, TS_PACKET_SIZE
) < 0)
1293 return AVERROR(ENOMEM
);
1294 pkt
->pos
= url_ftell(&s
->pb
);
1295 ret
= read_packet(&s
->pb
, pkt
->data
, ts
->raw_packet_size
);
1297 av_free_packet(pkt
);
1300 if (ts
->mpeg2ts_compute_pcr
) {
1301 /* compute exact PCR for each packet */
1302 if (parse_pcr(&pcr_h
, &pcr_l
, pkt
->data
) == 0) {
1303 /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1304 pos
= url_ftell(&s
->pb
);
1305 for(i
= 0; i
< MAX_PACKET_READAHEAD
; i
++) {
1306 url_fseek(&s
->pb
, pos
+ i
* ts
->raw_packet_size
, SEEK_SET
);
1307 get_buffer(&s
->pb
, pcr_buf
, 12);
1308 if (parse_pcr(&next_pcr_h
, &next_pcr_l
, pcr_buf
) == 0) {
1309 /* XXX: not precise enough */
1310 ts
->pcr_incr
= ((next_pcr_h
- pcr_h
) * 300 + (next_pcr_l
- pcr_l
)) /
1315 url_fseek(&s
->pb
, pos
, SEEK_SET
);
1316 /* no next PCR found: we use previous increment */
1317 ts
->cur_pcr
= pcr_h
* 300 + pcr_l
;
1319 pkt
->pts
= ts
->cur_pcr
;
1320 pkt
->duration
= ts
->pcr_incr
;
1321 ts
->cur_pcr
+= ts
->pcr_incr
;
1323 pkt
->stream_index
= 0;
1327 static int mpegts_read_packet(AVFormatContext
*s
,
1330 MpegTSContext
*ts
= s
->priv_data
;
1333 return handle_packets(ts
, 0);
1336 static int mpegts_read_close(AVFormatContext
*s
)
1338 MpegTSContext
*ts
= s
->priv_data
;
1340 for(i
=0;i
<NB_PID_MAX
;i
++)
1341 if (ts
->pids
[i
]) mpegts_close_filter(ts
, ts
->pids
[i
]);
1346 static int64_t mpegts_get_pcr(AVFormatContext
*s
, int stream_index
,
1347 int64_t *ppos
, int64_t pos_limit
)
1349 MpegTSContext
*ts
= s
->priv_data
;
1350 int64_t pos
, timestamp
;
1351 uint8_t buf
[TS_PACKET_SIZE
];
1352 int pcr_l
, pcr_pid
= ((PESContext
*)s
->streams
[stream_index
]->priv_data
)->pcr_pid
;
1353 const int find_next
= 1;
1354 pos
= ((*ppos
+ ts
->raw_packet_size
- 1) / ts
->raw_packet_size
) * ts
->raw_packet_size
;
1357 url_fseek(&s
->pb
, pos
, SEEK_SET
);
1358 if (get_buffer(&s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1359 return AV_NOPTS_VALUE
;
1360 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1361 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1364 pos
+= ts
->raw_packet_size
;
1368 pos
-= ts
->raw_packet_size
;
1370 return AV_NOPTS_VALUE
;
1371 url_fseek(&s
->pb
, pos
, SEEK_SET
);
1372 if (get_buffer(&s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1373 return AV_NOPTS_VALUE
;
1374 if ((pcr_pid
< 0 || (AV_RB16(buf
+ 1) & 0x1fff) == pcr_pid
) &&
1375 parse_pcr(×tamp
, &pcr_l
, buf
) == 0) {
1385 static int read_seek(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int flags
){
1386 MpegTSContext
*ts
= s
->priv_data
;
1387 uint8_t buf
[TS_PACKET_SIZE
];
1390 if(av_seek_frame_binary(s
, stream_index
, target_ts
, flags
) < 0)
1393 pos
= url_ftell(&s
->pb
);
1396 url_fseek(&s
->pb
, pos
, SEEK_SET
);
1397 if (get_buffer(&s
->pb
, buf
, TS_PACKET_SIZE
) != TS_PACKET_SIZE
)
1399 // pid = AV_RB16(buf + 1) & 0x1fff;
1400 if(buf
[1] & 0x40) break;
1401 pos
+= ts
->raw_packet_size
;
1403 url_fseek(&s
->pb
, pos
, SEEK_SET
);
1408 /**************************************************************/
1409 /* parsing functions - called from other demuxers such as RTP */
1411 MpegTSContext
*mpegts_parse_open(AVFormatContext
*s
)
1415 ts
= av_mallocz(sizeof(MpegTSContext
));
1418 /* no stream case, currently used by RTP */
1419 ts
->raw_packet_size
= TS_PACKET_SIZE
;
1425 /* return the consumed length if a packet was output, or -1 if no
1427 int mpegts_parse_packet(MpegTSContext
*ts
, AVPacket
*pkt
,
1428 const uint8_t *buf
, int len
)
1436 if (ts
->stop_parse
>0)
1438 if (len
< TS_PACKET_SIZE
)
1440 if (buf
[0] != 0x47) {
1444 handle_packet(ts
, buf
);
1445 buf
+= TS_PACKET_SIZE
;
1446 len
-= TS_PACKET_SIZE
;
1452 void mpegts_parse_close(MpegTSContext
*ts
)
1456 for(i
=0;i
<NB_PID_MAX
;i
++)
1457 av_free(ts
->pids
[i
]);
1461 AVInputFormat mpegts_demuxer
= {
1463 "MPEG2 transport stream format",
1464 sizeof(MpegTSContext
),
1471 .flags
= AVFMT_SHOW_IDS
,
1474 AVInputFormat mpegtsraw_demuxer
= {
1476 "MPEG2 raw transport stream format",
1477 sizeof(MpegTSContext
),
1480 mpegts_raw_read_packet
,
1484 .flags
= AVFMT_SHOW_IDS
,