2 * Demultiplexer for MPEG2 Transport Streams.
4 * Written by Nico <nsabbi@libero.it>
5 * Kind feedback is appreciated; 'sucks' and alike is not.
6 * Originally based on demux_pva.c written by Matteo Giani and FFmpeg (libavformat) sources
8 * This file is part of MPlayer.
10 * MPlayer is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * MPlayer is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
33 #include "stream/stream.h"
41 #define TS_PH_PACKET_SIZE 192
42 #define TS_FEC_PACKET_SIZE 204
43 #define TS_PACKET_SIZE 188
44 #define NB_PID_MAX 8192
46 #define MAX_HEADER_SIZE 6 /* enough for PES header + length */
47 #define MAX_CHECK_SIZE 65535
48 #define NUM_CONSECUTIVE_TS_PACKETS 32
49 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348
50 #define MAX_A52_FRAME_SIZE 3840
53 #define SIZE_MAX ((size_t)-1)
62 int audio_substream_id
= -1;
67 VIDEO_MPEG1
= 0x10000001,
68 VIDEO_MPEG2
= 0x10000002,
69 VIDEO_MPEG4
= 0x10000004,
70 VIDEO_H264
= 0x10000005,
71 VIDEO_AVC
= mmioFOURCC('a', 'v', 'c', '1'),
72 VIDEO_DIRAC
= mmioFOURCC('d', 'r', 'a', 'c'),
73 VIDEO_VC1
= mmioFOURCC('W', 'V', 'C', '1'),
77 AUDIO_LPCM_BE
= 0x10001,
78 AUDIO_AAC
= mmioFOURCC('M', 'P', '4', 'A'),
79 AUDIO_TRUEHD
= mmioFOURCC('T', 'R', 'H', 'D'),
82 SPU_TELETEXT
= 0x3000002,
83 PES_PRIVATE1
= 0xBD00000,
84 SL_PES_STREAM
= 0xD000000,
85 SL_SECTION
= 0xD100000,
97 uint16_t payload_size
;
98 es_stream_type_t type
, subtype
;
102 int last_cc
; // last cc code (-1 if first packet)
104 ts_section_t section
;
106 int extradata_alloc
, extradata_len
;
108 uint8_t au_start
, au_end
, last_au_end
;
118 typedef struct MpegTSContext
{
119 int packet_size
; // raw packet size, including FEC if present e.g. 188 bytes
120 ES_stream_t
*pids
[NB_PID_MAX
];
121 sh_av_t streams
[NB_PID_MAX
];
127 demux_packet_t
*pack
;
128 int offset
, buffer_size
;
131 #define MAX_EXTRADATA_SIZE 64*1024
133 int32_t object_type
; //aka codec used
134 int32_t stream_type
; //video, audio etc.
135 uint8_t buf
[MAX_EXTRADATA_SIZE
];
138 } mp4_decoder_config_t
;
145 uint8_t random_accesspoint
;
146 uint8_t random_accesspoint_only
;
152 uint32_t ts_resolution
, ocr_resolution
;
153 uint8_t ts_len
, ocr_len
, au_len
, instant_bitrate_len
, degr_len
, au_seqnum_len
, packet_seqnum_len
;
155 uint16_t au_duration
, cts_duration
;
156 uint64_t ocr
, dts
, cts
;
162 mp4_decoder_config_t decoder
;
177 uint16_t section_length
;
179 uint8_t version_number
;
181 uint8_t section_number
;
182 uint8_t last_section_number
;
188 ts_section_t section
;
196 uint16_t section_length
;
197 uint8_t version_number
;
199 uint8_t section_number
;
200 uint8_t last_section_number
;
202 uint16_t prog_descr_length
;
203 ts_section_t section
;
207 uint32_t type
; //it's 8 bit long, but cast to the right type as FOURCC
208 uint16_t descr_length
;
209 uint8_t format_descriptor
[5];
214 mp4_es_descr_t
*mp4es
;
215 int od_cnt
, mp4es_cnt
;
228 av_fifo_t fifo
[3]; //0 for audio, 1 for video, 2 for subs
237 char packet
[TS_FEC_PACKET_SIZE
];
238 TS_stream_info vstr
, astr
;
243 es_stream_type_t type
;
244 ts_section_t section
;
248 #define IS_AUDIO(x) (((x) == AUDIO_MP2) || ((x) == AUDIO_A52) || ((x) == AUDIO_LPCM_BE) || ((x) == AUDIO_AAC) || ((x) == AUDIO_DTS) || ((x) == AUDIO_TRUEHD))
249 #define IS_VIDEO(x) (((x) == VIDEO_MPEG1) || ((x) == VIDEO_MPEG2) || ((x) == VIDEO_MPEG4) || ((x) == VIDEO_H264) || ((x) == VIDEO_AVC) || ((x) == VIDEO_DIRAC) || ((x) == VIDEO_VC1))
250 #define IS_SUB(x) (((x) == SPU_DVD) || ((x) == SPU_DVB) || ((x) == SPU_TELETEXT))
252 static int ts_parse(demuxer_t
*demuxer
, ES_stream_t
*es
, unsigned char *packet
, int probe
);
254 static uint8_t get_packet_size(const unsigned char *buf
, int size
)
258 if (size
< (TS_FEC_PACKET_SIZE
* NUM_CONSECUTIVE_TS_PACKETS
))
261 for(i
=0; i
<NUM_CONSECUTIVE_TS_PACKETS
; i
++)
263 if (buf
[i
* TS_PACKET_SIZE
] != 0x47)
265 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "GET_PACKET_SIZE, pos %d, char: %2x\n", i
, buf
[i
* TS_PACKET_SIZE
]);
269 return TS_PACKET_SIZE
;
272 for(i
=0; i
<NUM_CONSECUTIVE_TS_PACKETS
; i
++)
274 if (buf
[i
* TS_FEC_PACKET_SIZE
] != 0x47){
275 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "GET_PACKET_SIZE, pos %d, char: %2x\n", i
, buf
[i
* TS_PACKET_SIZE
]);
279 return TS_FEC_PACKET_SIZE
;
282 for(i
=0; i
<NUM_CONSECUTIVE_TS_PACKETS
; i
++)
284 if (buf
[i
* TS_PH_PACKET_SIZE
] != 0x47)
287 return TS_PH_PACKET_SIZE
;
290 static int parse_avc_sps(uint8_t *buf
, int len
, int *w
, int *h
);
291 static inline uint8_t *pid_lang_from_pmt(ts_priv_t
*priv
, int pid
);
293 static void ts_add_stream(demuxer_t
* demuxer
, ES_stream_t
*es
)
296 ts_priv_t
*priv
= (ts_priv_t
*) demuxer
->priv
;
298 if(priv
->ts
.streams
[es
->pid
].sh
)
301 if((IS_AUDIO(es
->type
) || IS_AUDIO(es
->subtype
)) && priv
->last_aid
+1 < MAX_A_STREAMS
)
303 sh_audio_t
*sh
= new_sh_audio_aid(demuxer
, priv
->last_aid
, es
->pid
);
306 const char *lang
= pid_lang_from_pmt(priv
, es
->pid
);
307 sh
->needs_parsing
= 1;
308 sh
->format
= IS_AUDIO(es
->type
) ? es
->type
: es
->subtype
;
309 sh
->ds
= demuxer
->audio
;
311 priv
->ts
.streams
[es
->pid
].id
= priv
->last_aid
;
312 priv
->ts
.streams
[es
->pid
].sh
= sh
;
313 priv
->ts
.streams
[es
->pid
].type
= TYPE_AUDIO
;
314 mp_msg(MSGT_DEMUX
, MSGL_V
, "\r\nADDED AUDIO PID %d, type: %x stream n. %d\r\n", es
->pid
, sh
->format
, priv
->last_aid
);
316 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "ID_AID_%d_LANG=%s\n", es
->pid
, lang
);
320 if(es
->extradata
&& es
->extradata_len
)
322 sh
->wf
= malloc(sizeof (WAVEFORMATEX
) + es
->extradata_len
);
323 sh
->wf
->cbSize
= es
->extradata_len
;
324 memcpy(sh
->wf
+ 1, es
->extradata
, es
->extradata_len
);
328 if((IS_VIDEO(es
->type
) || IS_VIDEO(es
->subtype
)) && priv
->last_vid
+1 < MAX_V_STREAMS
)
330 sh_video_t
*sh
= new_sh_video_vid(demuxer
, priv
->last_vid
, es
->pid
);
333 sh
->format
= IS_VIDEO(es
->type
) ? es
->type
: es
->subtype
;
334 sh
->ds
= demuxer
->video
;
336 priv
->ts
.streams
[es
->pid
].id
= priv
->last_vid
;
337 priv
->ts
.streams
[es
->pid
].sh
= sh
;
338 priv
->ts
.streams
[es
->pid
].type
= TYPE_VIDEO
;
339 mp_msg(MSGT_DEMUX
, MSGL_V
, "\r\nADDED VIDEO PID %d, type: %x stream n. %d\r\n", es
->pid
, sh
->format
, priv
->last_vid
);
343 if(sh
->format
== VIDEO_AVC
&& es
->extradata
&& es
->extradata_len
)
346 sh
->bih
= calloc(1, sizeof(BITMAPINFOHEADER
) + es
->extradata_len
);
347 sh
->bih
->biSize
= sizeof(BITMAPINFOHEADER
) + es
->extradata_len
;
348 sh
->bih
->biCompression
= sh
->format
;
349 memcpy(sh
->bih
+ 1, es
->extradata
, es
->extradata_len
);
350 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "EXTRADATA(%d BYTES): \n", es
->extradata_len
);
351 for(i
= 0;i
< es
->extradata_len
; i
++)
352 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "%02x ", (int) es
->extradata
[i
]);
353 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
,"\n");
354 if(parse_avc_sps(es
->extradata
, es
->extradata_len
, &w
, &h
))
356 sh
->bih
->biWidth
= w
;
357 sh
->bih
->biHeight
= h
;
364 static int ts_check_file(demuxer_t
* demuxer
)
366 const int buf_size
= (TS_FEC_PACKET_SIZE
* NUM_CONSECUTIVE_TS_PACKETS
);
367 unsigned char buf
[TS_FEC_PACKET_SIZE
* NUM_CONSECUTIVE_TS_PACKETS
], done
= 0, *ptr
;
368 uint32_t _read
, i
, count
= 0, is_ts
;
369 int cc
[NB_PID_MAX
], last_cc
[NB_PID_MAX
], pid
, cc_ok
, c
, good
, bad
;
374 mp_msg(MSGT_DEMUX
, MSGL_V
, "Checking for MPEG-TS...\n");
376 init_pos
= stream_tell(demuxer
->stream
);
383 while(((c
=stream_read_char(demuxer
->stream
)) != 0x47)
385 && (i
< MAX_CHECK_SIZE
)
386 && ! demuxer
->stream
->eof
392 mp_msg(MSGT_DEMUX
, MSGL_V
, "THIS DOESN'T LOOK LIKE AN MPEG-TS FILE!\n");
398 pos
= stream_tell(demuxer
->stream
) - 1;
400 _read
= stream_read(demuxer
->stream
, &buf
[1], buf_size
-1);
402 if(_read
< buf_size
-1)
404 mp_msg(MSGT_DEMUX
, MSGL_V
, "COULDN'T READ ENOUGH DATA, EXITING TS_CHECK\n");
405 stream_reset(demuxer
->stream
);
409 size
= get_packet_size(buf
, buf_size
);
416 if(pos
- init_pos
>= MAX_CHECK_SIZE
)
423 mp_msg(MSGT_DEMUX
, MSGL_V
, "TRIED UP TO POSITION %"PRIu64
", FOUND %x, packet_size= %d, SEEMS A TS? %d\n", (uint64_t) pos
, c
, size
, is_ts
);
424 stream_seek(demuxer
->stream
, pos
);
429 //LET'S CHECK continuity counters
431 for(count
= 0; count
< NB_PID_MAX
; count
++)
433 cc
[count
] = last_cc
[count
] = -1;
436 for(count
= 0; count
< NUM_CONSECUTIVE_TS_PACKETS
; count
++)
438 ptr
= &(buf
[size
* count
]);
439 pid
= ((ptr
[1] & 0x1f) << 8) | ptr
[2];
440 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "BUF: %02x %02x %02x %02x, PID %d, SIZE: %d \n",
441 ptr
[0], ptr
[1], ptr
[2], ptr
[3], pid
, size
);
443 if((pid
== 8191) || (pid
< 16))
446 cc
[pid
] = (ptr
[3] & 0xf);
447 cc_ok
= (last_cc
[pid
] < 0) || ((((last_cc
[pid
] + 1) & 0x0f) == cc
[pid
]));
448 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "PID %d, COMPARE CC %d AND LAST_CC %d\n", pid
, cc
[pid
], last_cc
[pid
]);
455 last_cc
[pid
] = cc
[pid
];
458 mp_msg(MSGT_DEMUX
, MSGL_V
, "GOOD CC: %d, BAD CC: %d\n", good
, bad
);
467 static inline int32_t progid_idx_in_pmt(ts_priv_t
*priv
, uint16_t progid
)
471 if(priv
->pmt
== NULL
)
474 for(x
= 0; x
< priv
->pmt_cnt
; x
++)
476 if(priv
->pmt
[x
].progid
== progid
)
484 static inline int32_t progid_for_pid(ts_priv_t
*priv
, int pid
, int32_t req
) //finds the first program listing a pid
490 if(priv
->pmt
== NULL
)
494 for(i
=0; i
< priv
->pmt_cnt
; i
++)
496 pmt
= &(priv
->pmt
[i
]);
501 for(j
= 0; j
< pmt
->es_cnt
; j
++)
503 if(pmt
->es
[j
].pid
== pid
)
505 if((req
== 0) || (req
== pmt
->progid
))
514 static inline int32_t prog_pcr_pid(ts_priv_t
*priv
, int progid
)
518 if(priv
->pmt
== NULL
)
520 for(i
=0; i
< priv
->pmt_cnt
; i
++)
522 if(priv
->pmt
[i
].progid
== progid
)
523 return priv
->pmt
[i
].PCR_PID
;
529 static inline int pid_match_lang(ts_priv_t
*priv
, uint16_t pid
, char *lang
)
534 if(priv
->pmt
== NULL
)
537 for(i
=0; i
< priv
->pmt_cnt
; i
++)
539 pmt
= &(priv
->pmt
[i
]);
544 for(j
= 0; j
< pmt
->es_cnt
; j
++)
546 if(pmt
->es
[j
].pid
!= pid
)
549 mp_msg(MSGT_DEMUXER
, MSGL_V
, "CMP LANG %s AND %s, pids: %d %d\n",pmt
->es
[j
].lang
, lang
, pmt
->es
[j
].pid
, pid
);
550 if(strncmp(pmt
->es
[j
].lang
, lang
, 3) == 0)
562 int32_t atype
, vtype
, stype
; //types
563 int32_t apid
, vpid
, spid
; //stream ids
564 char slang
[4], alang
[4]; //languages
569 //stripped down version of a52_syncinfo() from liba52
570 //copyright belongs to Michel Lespinasse <walken@zoy.org> and Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
571 int mp_a52_framesize(uint8_t * buf
, int *srate
)
573 int rate
[] = { 32, 40, 48, 56, 64, 80, 96, 112,
574 128, 160, 192, 224, 256, 320, 384, 448,
577 uint8_t halfrate
[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
578 int frmsizecod
, bitrate
, half
;
580 if((buf
[0] != 0x0b) || (buf
[1] != 0x77)) /* syncword */
583 if(buf
[5] >= 0x60) /* bsid >= 12 */
586 half
= halfrate
[buf
[5] >> 3];
588 frmsizecod
= buf
[4] & 63;
592 bitrate
= rate
[frmsizecod
>> 1];
594 switch(buf
[4] & 0xc0)
597 *srate
= 48000 >> half
;
599 case 0x40: /* 44.1 KHz */
600 *srate
= 44100 >> half
;
601 return 2 * (320 * bitrate
/ 147 + (frmsizecod
& 1));
602 case 0x80: /* 32 KHz */
603 *srate
= 32000 >> half
;
610 //second stage: returns the count of A52 syncwords found
611 static int a52_check(char *buf
, int len
)
613 int cnt
, frame_length
, ok
, srate
;
621 if(buf
[cnt
] == 0x0B && buf
[cnt
+1] == 0x77)
623 frame_length
= mp_a52_framesize(&buf
[cnt
], &srate
);
624 if(frame_length
>=7 && frame_length
<=3840)
636 mp_msg(MSGT_DEMUXER
, MSGL_V
, "A52_CHECK(%d input bytes), found %d frame syncwords of %d bytes length\n", len
, ok
, frame_length
);
641 static off_t
ts_detect_streams(demuxer_t
*demuxer
, tsdemux_init_t
*param
)
643 int video_found
= 0, audio_found
= 0, sub_found
= 0, i
, num_packets
= 0, req_apid
, req_vpid
, req_spid
;
644 int is_audio
, is_video
, is_sub
, has_tables
;
645 int32_t p
, chosen_pid
= 0;
646 off_t pos
=0, ret
= 0, init_pos
, end_pos
;
648 unsigned char tmp
[TS_FEC_PACKET_SIZE
];
649 ts_priv_t
*priv
= (ts_priv_t
*) demuxer
->priv
;
653 } pes_priv1
[8192], *pptr
;
656 priv
->last_pid
= 8192; //invalid pid
658 req_apid
= param
->apid
;
659 req_vpid
= param
->vpid
;
660 req_spid
= param
->spid
;
663 memset(pes_priv1
, 0, sizeof(pes_priv1
));
664 init_pos
= stream_tell(demuxer
->stream
);
665 mp_msg(MSGT_DEMUXER
, MSGL_V
, "PROBING UP TO %"PRIu64
", PROG: %d\n", (uint64_t) param
->probe
, param
->prog
);
666 end_pos
= init_pos
+ (param
->probe
? param
->probe
: TS_MAX_PROBE_SIZE
);
669 pos
= stream_tell(demuxer
->stream
);
670 if(pos
> end_pos
|| demuxer
->stream
->eof
)
673 if(ts_parse(demuxer
, &es
, tmp
, 1))
675 //Non PES-aligned A52 audio may escape detection if PMT is not present;
676 //in this case we try to find at least 3 A52 syncwords
677 if((es
.type
== PES_PRIVATE1
) && (! audio_found
) && req_apid
> -2)
679 pptr
= &pes_priv1
[es
.pid
];
680 if(pptr
->pos
< 64*1024)
682 tmpbuf
= realloc(pptr
->buf
, pptr
->pos
+ es
.size
);
686 memcpy(&(pptr
->buf
[ pptr
->pos
]), es
.start
, es
.size
);
687 pptr
->pos
+= es
.size
;
688 if(a52_check(pptr
->buf
, pptr
->pos
) > 2)
690 param
->atype
= AUDIO_A52
;
691 param
->apid
= es
.pid
;
698 is_audio
= IS_AUDIO(es
.type
) || ((es
.type
==SL_PES_STREAM
) && IS_AUDIO(es
.subtype
));
699 is_video
= IS_VIDEO(es
.type
) || ((es
.type
==SL_PES_STREAM
) && IS_VIDEO(es
.subtype
));
700 is_sub
= IS_SUB(es
.type
);
703 if((! is_audio
) && (! is_video
) && (! is_sub
))
705 if(is_audio
&& req_apid
==-2)
710 chosen_pid
= (req_vpid
== es
.pid
);
711 if((! chosen_pid
) && (req_vpid
> 0))
718 chosen_pid
= (req_apid
== es
.pid
);
722 else if(param
->alang
[0] > 0 && es
.lang
[0] > 0)
724 if(pid_match_lang(priv
, es
.pid
, param
->alang
) == -1)
728 param
->apid
= req_apid
= es
.pid
;
733 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "ID_SUBTITLE_ID=%d\n", es
.pid
);
735 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "ID_SID_%d_LANG=%s\n", es
.pid
, es
.lang
);
736 chosen_pid
= (req_spid
== es
.pid
);
737 if((! chosen_pid
) && (req_spid
> 0))
741 if(req_apid
< 0 && (param
->alang
[0] == 0) && req_vpid
< 0 && req_spid
< 0)
744 if((ret
== 0) && chosen_pid
)
746 ret
= stream_tell(demuxer
->stream
);
749 p
= progid_for_pid(priv
, es
.pid
, param
->prog
);
753 if(!param
->prog
&& chosen_pid
)
757 if((param
->prog
> 0) && (param
->prog
!= p
))
761 if(is_video
&& (req_vpid
== es
.pid
))
763 param
->vtype
= IS_VIDEO(es
.type
) ? es
.type
: es
.subtype
;
764 param
->vpid
= es
.pid
;
772 if(is_audio
&& (req_apid
== es
.pid
))
774 param
->atype
= IS_AUDIO(es
.type
) ? es
.type
: es
.subtype
;
775 param
->apid
= es
.pid
;
786 mp_msg(MSGT_DEMUXER
, MSGL_DBG2
, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es
.type
, es
.pid
, param
->prog
);
791 if((req_vpid
== -1) || (req_vpid
== es
.pid
))
793 param
->vtype
= IS_VIDEO(es
.type
) ? es
.type
: es
.subtype
;
794 param
->vpid
= es
.pid
;
800 if(((req_vpid
== -2) || (num_packets
>= NUM_CONSECUTIVE_AUDIO_PACKETS
)) && audio_found
&& !param
->probe
)
802 //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only)
809 if((req_spid
== -1) || (req_spid
== es
.pid
))
811 param
->stype
= es
.type
;
812 param
->spid
= es
.pid
;
819 if((req_apid
== -1) || (req_apid
== es
.pid
))
821 param
->atype
= IS_AUDIO(es
.type
) ? es
.type
: es
.subtype
;
822 param
->apid
= es
.pid
;
827 if(audio_found
&& (param
->apid
== es
.pid
) && (! video_found
))
830 if((has_tables
==0) && (video_found
&& audio_found
) && (pos
>= 1000000))
835 for(i
=0; i
<8192; i
++)
837 if(pes_priv1
[i
].buf
!= NULL
)
839 free(pes_priv1
[i
].buf
);
840 pes_priv1
[i
].buf
= NULL
;
841 pes_priv1
[i
].pos
= 0;
847 if(param
->vtype
== VIDEO_MPEG1
)
848 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO MPEG1(pid=%d) ", param
->vpid
);
849 else if(param
->vtype
== VIDEO_MPEG2
)
850 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO MPEG2(pid=%d) ", param
->vpid
);
851 else if(param
->vtype
== VIDEO_MPEG4
)
852 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO MPEG4(pid=%d) ", param
->vpid
);
853 else if(param
->vtype
== VIDEO_H264
)
854 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO H264(pid=%d) ", param
->vpid
);
855 else if(param
->vtype
== VIDEO_VC1
)
856 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO VC1(pid=%d) ", param
->vpid
);
857 else if(param
->vtype
== VIDEO_AVC
)
858 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "VIDEO AVC(NAL-H264, pid=%d) ", param
->vpid
);
862 param
->vtype
= UNKNOWN
;
863 //WE DIDN'T MATCH ANY VIDEO STREAM
864 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "NO VIDEO! ");
867 if(param
->atype
== AUDIO_MP2
)
868 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO MPA(pid=%d)", param
->apid
);
869 else if(param
->atype
== AUDIO_A52
)
870 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO A52(pid=%d)", param
->apid
);
871 else if(param
->atype
== AUDIO_DTS
)
872 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO DTS(pid=%d)", param
->apid
);
873 else if(param
->atype
== AUDIO_LPCM_BE
)
874 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO LPCM(pid=%d)", param
->apid
);
875 else if(param
->atype
== AUDIO_AAC
)
876 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO AAC(pid=%d)", param
->apid
);
877 else if(param
->atype
== AUDIO_TRUEHD
)
878 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "AUDIO TRUEHD(pid=%d)", param
->apid
);
882 param
->atype
= UNKNOWN
;
883 //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO
884 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "NO AUDIO! ");
887 if(IS_SUB(param
->stype
))
888 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " SUB %s(pid=%d) ", (param
->stype
==SPU_DVD
? "DVD" : param
->stype
==SPU_DVB
? "DVB" : "Teletext"), param
->spid
);
891 param
->stype
= UNKNOWN
;
892 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " NO SUBS (yet)! ");
895 if(video_found
|| audio_found
)
899 p
= progid_for_pid(priv
, video_found
? param
->vpid
: param
->apid
, 0);
904 if(demuxer
->stream
->eof
&& (ret
== 0))
906 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, " PROGRAM N. %d\n", param
->prog
);
909 mp_msg(MSGT_DEMUXER
, MSGL_INFO
, "\n");
912 for(i
=0; i
<8192; i
++)
914 if(priv
->ts
.pids
[i
] != NULL
)
916 priv
->ts
.pids
[i
]->payload_size
= 0;
917 priv
->ts
.pids
[i
]->pts
= priv
->ts
.pids
[i
]->last_pts
= 0;
918 priv
->ts
.pids
[i
]->last_cc
= -1;
919 priv
->ts
.pids
[i
]->is_synced
= 0;
926 static int parse_avc_sps(uint8_t *buf
, int len
, int *w
, int *h
)
930 mp_mpeg_header_t picture
;
936 sps_len
= (buf
[6] << 8) | buf
[7];
937 if(!sps_len
|| (sps_len
> len
- 8))
940 picture
.display_picture_width
= picture
.display_picture_height
= 0;
941 h264_parse_sps(&picture
, ptr
, len
- 8);
942 if(!picture
.display_picture_width
|| !picture
.display_picture_height
)
944 *w
= picture
.display_picture_width
;
945 *h
= picture
.display_picture_height
;
949 static demuxer_t
*demux_open_ts(demuxer_t
* demuxer
)
953 sh_video_t
*sh_video
;
954 sh_audio_t
*sh_audio
;
956 tsdemux_init_t params
;
957 ts_priv_t
* priv
= demuxer
->priv
;
959 mp_msg(MSGT_DEMUX
, MSGL_V
, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n",
960 demuxer
->audio
->id
, demuxer
->video
->id
, demuxer
->sub
->id
);
963 demuxer
->type
= DEMUXER_TYPE_MPEG_TS
;
966 stream_reset(demuxer
->stream
);
968 packet_size
= ts_check_file(demuxer
);
972 priv
= calloc(1, sizeof(ts_priv_t
));
975 mp_msg(MSGT_DEMUX
, MSGL_FATAL
, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n");
979 for(i
=0; i
< 8192; i
++)
981 priv
->ts
.pids
[i
] = NULL
;
982 priv
->ts
.streams
[i
].id
= -3;
984 priv
->pat
.progs
= NULL
;
985 priv
->pat
.progs_cnt
= 0;
986 priv
->pat
.section
.buffer
= NULL
;
987 priv
->pat
.section
.buffer_len
= 0;
992 priv
->keep_broken
= ts_keep_broken
;
993 priv
->ts
.packet_size
= packet_size
;
996 demuxer
->priv
= priv
;
997 if(demuxer
->stream
->type
!= STREAMTYPE_FILE
)
998 demuxer
->seekable
= 1;
1000 demuxer
->seekable
= 1;
1003 params
.atype
= params
.vtype
= params
.stype
= UNKNOWN
;
1004 params
.apid
= demuxer
->audio
->id
;
1005 params
.vpid
= demuxer
->video
->id
;
1006 params
.spid
= demuxer
->sub
->id
;
1007 params
.prog
= ts_prog
;
1008 params
.probe
= ts_probe
;
1010 if(demuxer
->opts
->sub_lang
!= NULL
)
1012 strncpy(params
.slang
, demuxer
->opts
->sub_lang
, 3);
1013 params
.slang
[3] = 0;
1016 memset(params
.slang
, 0, 4);
1018 if(demuxer
->opts
->audio_lang
!= NULL
)
1020 strncpy(params
.alang
, demuxer
->opts
->audio_lang
, 3);
1021 params
.alang
[3] = 0;
1024 memset(params
.alang
, 0, 4);
1026 start_pos
= ts_detect_streams(demuxer
, ¶ms
);
1028 demuxer
->sub
->id
= params
.spid
;
1029 priv
->prog
= params
.prog
;
1031 if(params
.vtype
!= UNKNOWN
)
1033 ts_add_stream(demuxer
, priv
->ts
.pids
[params
.vpid
]);
1034 sh_video
= priv
->ts
.streams
[params
.vpid
].sh
;
1035 demuxer
->video
->id
= priv
->ts
.streams
[params
.vpid
].id
;
1036 sh_video
->ds
= demuxer
->video
;
1037 sh_video
->format
= params
.vtype
;
1038 demuxer
->video
->sh
= sh_video
;
1041 if(params
.atype
!= UNKNOWN
)
1043 ES_stream_t
*es
= priv
->ts
.pids
[params
.apid
];
1045 if(!IS_AUDIO(es
->type
) && !IS_AUDIO(es
->subtype
) && IS_AUDIO(params
.atype
)) es
->subtype
= params
.atype
;
1046 ts_add_stream(demuxer
, priv
->ts
.pids
[params
.apid
]);
1047 sh_audio
= priv
->ts
.streams
[params
.apid
].sh
;
1048 demuxer
->audio
->id
= priv
->ts
.streams
[params
.apid
].id
;
1049 sh_audio
->ds
= demuxer
->audio
;
1050 sh_audio
->format
= params
.atype
;
1051 demuxer
->audio
->sh
= sh_audio
;
1055 mp_msg(MSGT_DEMUXER
,MSGL_V
, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...POS=%"PRIu64
", PROBE=%"PRIu64
"\n", params
.atype
, demuxer
->audio
->id
, params
.vtype
, demuxer
->video
->id
, (uint64_t) start_pos
, ts_probe
);
1058 start_pos
= (start_pos
<= priv
->ts
.packet_size
? 0 : start_pos
- priv
->ts
.packet_size
);
1059 demuxer
->movi_start
= start_pos
;
1060 demuxer
->reference_clock
= MP_NOPTS_VALUE
;
1061 stream_reset(demuxer
->stream
);
1062 stream_seek(demuxer
->stream
, start_pos
); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES?
1065 priv
->last_pid
= 8192; //invalid pid
1067 for(i
= 0; i
< 3; i
++)
1069 priv
->fifo
[i
].pack
= NULL
;
1070 priv
->fifo
[i
].offset
= 0;
1072 priv
->fifo
[0].ds
= demuxer
->audio
;
1073 priv
->fifo
[1].ds
= demuxer
->video
;
1074 priv
->fifo
[2].ds
= demuxer
->sub
;
1076 priv
->fifo
[0].buffer_size
= 1536;
1077 priv
->fifo
[1].buffer_size
= 32767;
1078 priv
->fifo
[2].buffer_size
= 32767;
1080 priv
->pat
.section
.buffer_len
= 0;
1081 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
1082 priv
->pmt
[i
].section
.buffer_len
= 0;
1084 demuxer
->filepos
= stream_tell(demuxer
->stream
);
1088 static void demux_close_ts(demuxer_t
* demuxer
)
1091 ts_priv_t
*priv
= (ts_priv_t
*) demuxer
->priv
;
1095 if(priv
->pat
.section
.buffer
)
1096 free(priv
->pat
.section
.buffer
);
1098 free(priv
->pat
.progs
);
1102 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
1104 if(priv
->pmt
[i
].section
.buffer
)
1105 free(priv
->pmt
[i
].section
.buffer
);
1107 free(priv
->pmt
[i
].es
);
1117 #define getbits mp_getbits
1119 static int mp4_parse_sl_packet(pmt_t
*pmt
, uint8_t *buf
, uint16_t packet_len
, int pid
, ES_stream_t
*pes_es
)
1121 int i
, n
, m
, mp4_es_id
= -1;
1123 uint32_t pl_size
= 0;
1125 mp4_es_descr_t
*es
= NULL
;
1126 mp4_sl_config_t
*sl
= NULL
;
1127 uint8_t au_start
= 0, au_end
= 0, rap_flag
= 0, ocr_flag
= 0, padding
= 0, padding_bits
= 0, idle
= 0;
1129 pes_es
->is_synced
= 0;
1130 mp_msg(MSGT_DEMUXER
,MSGL_V
, "mp4_parse_sl_packet, pid: %d, pmt: %pm, packet_len: %d\n", pid
, pmt
, packet_len
);
1131 if(! pmt
|| !packet_len
)
1134 for(i
= 0; i
< pmt
->es_cnt
; i
++)
1136 if(pmt
->es
[i
].pid
== pid
)
1137 mp4_es_id
= pmt
->es
[i
].mp4_es_id
;
1142 for(i
= 0; i
< pmt
->mp4es_cnt
; i
++)
1144 if(pmt
->mp4es
[i
].id
== mp4_es_id
)
1145 es
= &(pmt
->mp4es
[i
]);
1150 pes_es
->subtype
= es
->decoder
.object_type
;
1156 //now es is the complete es_descriptor of out mp4 ES stream
1157 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "ID: %d, FLAGS: 0x%x, subtype: %x\n", es
->id
, sl
->flags
, pes_es
->subtype
);
1161 pes_es
->sl
.au_start
= au_start
= getbits(buf
, n
++, 1);
1163 pes_es
->sl
.au_start
= (pes_es
->sl
.last_au_end
? 1 : 0);
1165 pes_es
->sl
.au_end
= au_end
= getbits(buf
, n
++, 1);
1167 if(!sl
->au_start
&& !sl
->au_end
)
1169 pes_es
->sl
.au_start
= pes_es
->sl
.au_end
= au_start
= au_end
= 1;
1171 pes_es
->sl
.last_au_end
= pes_es
->sl
.au_end
;
1175 ocr_flag
= getbits(buf
, n
++, 1);
1177 idle
= getbits(buf
, n
++, 1);
1179 padding
= getbits(buf
, n
++, 1);
1182 padding_bits
= getbits(buf
, n
, 3);
1186 if(idle
|| (padding
&& !padding_bits
))
1188 pes_es
->payload_size
= 0;
1192 //(! idle && (!padding || padding_bits != 0)) is true
1193 n
+= sl
->packet_seqnum_len
;
1195 deg_flag
= getbits(buf
, n
++, 1);
1202 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "OCR: %d bits\n", sl
->ocr_len
);
1205 if(packet_len
* 8 <= n
)
1208 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "\nAU_START: %d, AU_END: %d\n", au_start
, au_end
);
1211 int dts_flag
= 0, cts_flag
= 0, ib_flag
= 0;
1213 if(sl
->random_accesspoint
)
1214 rap_flag
= getbits(buf
, n
++, 1);
1216 //check commented because it seems it's rarely used, and we need this flag set in case of au_start
1217 //the decoder will eventually discard the payload if it can't decode it
1218 //if(rap_flag || sl->random_accesspoint_only)
1219 pes_es
->is_synced
= 1;
1221 n
+= sl
->au_seqnum_len
;
1222 if(packet_len
* 8 <= n
+8)
1226 dts_flag
= getbits(buf
, n
++, 1);
1227 cts_flag
= getbits(buf
, n
++, 1);
1229 if(sl
->instant_bitrate_len
)
1230 ib_flag
= getbits(buf
, n
++, 1);
1231 if(packet_len
* 8 <= n
+8)
1233 if(dts_flag
&& (sl
->ts_len
> 0))
1236 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "DTS: %d bits\n", sl
->ts_len
);
1238 if(packet_len
* 8 <= n
+8)
1240 if(cts_flag
&& (sl
->ts_len
> 0))
1244 while(i
< sl
->ts_len
)
1246 m
= FFMIN(8, sl
->ts_len
- i
);
1247 v
|= getbits(buf
, n
, m
);
1248 if(sl
->ts_len
- i
> 8)
1252 if(packet_len
* 8 <= n
+8)
1256 pes_es
->pts
= (double) v
/ (double) sl
->ts_resolution
;
1257 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "CTS: %d bits, value: %"PRIu64
"/%d = %.3f\n", sl
->ts_len
, v
, sl
->ts_resolution
, pes_es
->pts
);
1263 while(i
< sl
->au_len
)
1265 m
= FFMIN(8, sl
->au_len
- i
);
1266 pl_size
|= getbits(buf
, n
, m
);
1267 if(sl
->au_len
- i
> 8)
1271 if(packet_len
* 8 <= n
+8)
1274 mp_msg(MSGT_DEMUXER
,MSGL_DBG2
, "AU_LEN: %u (%d bits)\n", pl_size
, sl
->au_len
);
1276 n
+= sl
->instant_bitrate_len
;
1280 if(0 < pl_size
&& pl_size
< pes_es
->payload_size
)
1281 pes_es
->payload_size
= pl_size
;
1283 mp_msg(MSGT_DEMUXER
,MSGL_V
, "mp4_parse_sl_packet, n=%d, m=%d, size from pes hdr: %u, sl hdr size: %u, RAP FLAGS: %d/%d\n",
1284 n
, m
, pes_es
->payload_size
, pl_size
, (int) rap_flag
, (int) sl
->random_accesspoint_only
);
1289 //this function parses the extension fields in the PES header and returns the substream_id, or -1 in case of errors
1290 static int parse_pes_extension_fields(unsigned char *p
, int pkt_len
)
1293 unsigned char flags
;
1295 if(!(p
[7] & 0x1)) //no extension_field
1304 if(p
[7] & 0x20) //escr_flag
1306 if(p
[7] & 0x10) //es_rate_flag
1308 if(p
[7] & 0x08)//dsm_trick_mode is unsupported, skip
1310 skip
= 0;//don't let's parse the extension fields
1312 if(p
[7] & 0x04) //additional_copy_info
1314 if(p
[7] & 0x02) //pes_crc_flag
1316 if(skip
>= pkt_len
) //too few bytes
1320 if(flags
& 0x80) //pes_private_data_flag
1324 if(flags
& 0x40) //pack_header_field_flag
1326 unsigned char l
= p
[skip
];
1329 if(flags
& 0x20) //program_packet_sequence_counter
1331 if(flags
& 0x10) //p_std
1335 if(flags
& 0x01) //finally the long desired pes_extension2
1337 unsigned char l
= p
[skip
]; //ext2 flag+len
1339 if((l
== 0x81) && (skip
< pkt_len
))
1342 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "SUBSTREAM_ID=%d (0x%02X)\n", ssid
, ssid
);
1350 static int pes_parse2(unsigned char *buf
, uint16_t packet_len
, ES_stream_t
*es
, int32_t type_from_pmt
, pmt_t
*pmt
, int pid
)
1353 uint32_t header_len
;
1356 uint32_t pkt_len
, pes_is_aligned
;
1358 //Here we are always at the start of a PES packet
1359 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2(%p, %d): \n", buf
, (uint32_t) packet_len
);
1361 if(packet_len
== 0 || packet_len
> 184)
1363 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2, BUFFER LEN IS TOO SMALL OR TOO BIG: %d EXIT\n", packet_len
);
1368 pkt_len
= packet_len
;
1371 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: HEADER %02x %02x %02x %02x\n", p
[0], p
[1], p
[2], p
[3]);
1372 if (p
[0] || p
[1] || (p
[2] != 1))
1374 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: error HEADER %02x %02x %02x (should be 0x000001) \n", p
[0], p
[1], p
[2]);
1381 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: packet too short: %d, exit\n", packet_len
);
1385 es
->payload_size
= (p
[4] << 8 | p
[5]);
1386 pes_is_aligned
= (p
[6] & 4);
1392 { /* pts available */
1393 pts
= (int64_t)(p
[9] & 0x0E) << 29 ;
1394 pts
|= p
[10] << 22 ;
1395 pts
|= (p
[11] & 0xFE) << 14 ;
1397 pts
|= (p
[13] & 0xFE) >> 1 ;
1399 es
->pts
= pts
/ 90000.0;
1408 if (header_len
+ 9 > pkt_len
) //9 are the bytes read up to the header_length field
1410 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "demux_ts: illegal value for PES_header_data_length (0x%02x)\n", header_len
);
1416 int ssid
= parse_pes_extension_fields(p
, pkt_len
);
1417 if((audio_substream_id
!=-1) && (ssid
!= audio_substream_id
))
1419 if(ssid
== 0x72 && type_from_pmt
!= AUDIO_DTS
)
1420 es
->type
= type_from_pmt
= AUDIO_TRUEHD
;
1423 p
+= header_len
+ 9;
1424 packet_len
-= header_len
+ 3;
1426 if(es
->payload_size
)
1427 es
->payload_size
-= header_len
+ 3;
1430 es
->is_synced
= 1; //only for SL streams we have to make sure it's really true, see below
1431 if (stream_id
== 0xbd)
1433 mp_msg(MSGT_DEMUX
, MSGL_DBG3
, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n",
1434 p
[0], p
[1], p
[2], p
[3], p
[4], p
[5], p
[6], p
[7], p
[0] & 0x80);
1438 * we check the descriptor tag first because some stations
1439 * do not include any of the A52 header info in their audio tracks
1440 * these "raw" streams may begin with a byte that looks like a stream type.
1445 (type_from_pmt
== AUDIO_A52
) || /* A52 - raw */
1446 (p
[0] == 0x0B && p
[1] == 0x77) /* A52 - syncword */
1449 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "A52 RAW OR SYNCWORD\n");
1451 es
->size
= packet_len
;
1452 es
->type
= AUDIO_A52
;
1453 es
->payload_size
-= packet_len
;
1458 else if(type_from_pmt
== SPU_DVB
||
1459 ((p
[0] == 0x20) && pes_is_aligned
)) // && p[1] == 0x00))
1462 es
->size
= packet_len
;
1464 es
->payload_size
-= packet_len
;
1468 else if (pes_is_aligned
&& ((p
[0] & 0xE0) == 0x20)) //SPU_DVD
1472 es
->size
= packet_len
-1;
1474 es
->payload_size
-= packet_len
;
1478 else if (pes_is_aligned
&& (p
[0] & 0xF8) == 0x80)
1480 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "A52 WITH HEADER\n");
1482 es
->size
= packet_len
- 4;
1483 es
->type
= AUDIO_A52
;
1484 es
->payload_size
-= packet_len
;
1488 else if (pes_is_aligned
&& ((p
[0]&0xf0) == 0xa0))
1492 for (pcm_offset
=0; ++pcm_offset
< packet_len
-1 ; )
1494 if (p
[pcm_offset
] == 0x01 && p
[pcm_offset
+1] == 0x80)
1501 es
->start
= p
+ pcm_offset
;
1502 es
->size
= packet_len
- pcm_offset
;
1503 es
->type
= AUDIO_LPCM_BE
;
1504 es
->payload_size
-= packet_len
;
1510 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "PES_PRIVATE1\n");
1512 es
->size
= packet_len
;
1513 es
->type
= (type_from_pmt
== UNKNOWN
? PES_PRIVATE1
: type_from_pmt
);
1514 es
->payload_size
-= packet_len
;
1519 else if(((stream_id
>= 0xe0) && (stream_id
<= 0xef)) || (stream_id
== 0xfd && type_from_pmt
!= UNKNOWN
))
1522 es
->size
= packet_len
;
1523 if(type_from_pmt
!= UNKNOWN
)
1524 es
->type
= type_from_pmt
;
1526 es
->type
= VIDEO_MPEG2
;
1527 if(es
->payload_size
)
1528 es
->payload_size
-= packet_len
;
1530 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: M2V size %d\n", es
->size
);
1533 else if ((stream_id
== 0xfa))
1538 if(type_from_pmt
!= UNKNOWN
) //MP4 A/V or SL
1541 es
->size
= packet_len
;
1542 es
->type
= type_from_pmt
;
1544 if(type_from_pmt
== SL_PES_STREAM
)
1546 //if(pes_is_aligned)
1548 l
= mp4_parse_sl_packet(pmt
, p
, packet_len
, pid
, es
);
1549 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "L=%d, TYPE=%x\n", l
, type_from_pmt
);
1552 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: couldn't parse SL header, passing along full PES payload\n");
1561 if(es
->payload_size
)
1562 es
->payload_size
-= packet_len
;
1566 else if ((stream_id
& 0xe0) == 0xc0)
1569 es
->size
= packet_len
;
1571 if(type_from_pmt
!= UNKNOWN
)
1572 es
->type
= type_from_pmt
;
1574 es
->type
= AUDIO_MP2
;
1576 es
->payload_size
-= packet_len
;
1580 else if (type_from_pmt
!= -1) //as a last resort here we trust the PMT, if present
1583 es
->size
= packet_len
;
1584 es
->type
= type_from_pmt
;
1585 es
->payload_size
-= packet_len
;
1591 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "pes_parse2: unknown packet, id: %x\n", stream_id
);
1601 static int ts_sync(stream_t
*stream
)
1605 mp_msg(MSGT_DEMUX
, MSGL_DBG3
, "TS_SYNC \n");
1607 while(((c
=stream_read_char(stream
)) != 0x47) && ! stream
->eof
);
1616 static void ts_dump_streams(ts_priv_t
*priv
)
1620 for(i
= 0; i
< 3; i
++)
1622 if((priv
->fifo
[i
].pack
!= NULL
) && (priv
->fifo
[i
].offset
!= 0))
1624 resize_demux_packet(priv
->fifo
[i
].pack
, priv
->fifo
[i
].offset
);
1625 ds_add_packet(priv
->fifo
[i
].ds
, priv
->fifo
[i
].pack
);
1626 priv
->fifo
[i
].offset
= 0;
1627 priv
->fifo
[i
].pack
= NULL
;
1633 static inline int32_t prog_idx_in_pat(ts_priv_t
*priv
, uint16_t progid
)
1637 if(priv
->pat
.progs
== NULL
)
1640 for(x
= 0; x
< priv
->pat
.progs_cnt
; x
++)
1642 if(priv
->pat
.progs
[x
].id
== progid
)
1650 static inline int32_t prog_id_in_pat(ts_priv_t
*priv
, uint16_t pid
)
1654 if(priv
->pat
.progs
== NULL
)
1657 for(x
= 0; x
< priv
->pat
.progs_cnt
; x
++)
1659 if(priv
->pat
.progs
[x
].pmt_pid
== pid
)
1660 return priv
->pat
.progs
[x
].id
;
1666 static int collect_section(ts_section_t
*section
, int is_start
, unsigned char *buff
, int size
)
1672 mp_msg(MSGT_DEMUX
, MSGL_V
, "COLLECT_SECTION, start: %d, size: %d, collected: %d\n", is_start
, size
, section
->buffer_len
);
1673 if(! is_start
&& !section
->buffer_len
)
1678 if(! section
->buffer
)
1680 section
->buffer
= malloc(4096 + 256);
1681 if(section
->buffer
== NULL
)
1684 section
->buffer_len
= 0;
1687 if(size
+ section
->buffer_len
> 4096+256)
1689 mp_msg(MSGT_DEMUX
, MSGL_V
, "COLLECT_SECTION, excessive len: %d + %d\n", section
->buffer_len
, size
);
1693 memcpy(&(section
->buffer
[section
->buffer_len
]), buff
, size
);
1694 section
->buffer_len
+= size
;
1696 if(section
->buffer_len
< 3)
1699 skip
= section
->buffer
[0];
1700 if(skip
+ 4 > section
->buffer_len
)
1703 ptr
= &(section
->buffer
[skip
+ 1]);
1705 tlen
= ((ptr
[1] & 0x0f) << 8) | ptr
[2];
1706 mp_msg(MSGT_DEMUX
, MSGL_V
, "SKIP: %d+1, TID: %d, TLEN: %d, COLLECTED: %d\n", skip
, tid
, tlen
, section
->buffer_len
);
1707 if(section
->buffer_len
< (skip
+1+3+tlen
))
1709 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "DATA IS NOT ENOUGH, NEXT TIME\n");
1716 static int parse_pat(ts_priv_t
* priv
, int is_start
, unsigned char *buff
, int size
)
1720 unsigned char *base
;
1723 struct pat_progs_t
*tmp
;
1724 ts_section_t
*section
;
1726 section
= &(priv
->pat
.section
);
1727 skip
= collect_section(section
, is_start
, buff
, size
);
1731 ptr
= &(section
->buffer
[skip
]);
1733 priv
->pat
.table_id
= ptr
[0];
1734 if(priv
->pat
.table_id
!= 0)
1736 priv
->pat
.ssi
= (ptr
[1] >> 7) & 0x1;
1737 priv
->pat
.curr_next
= ptr
[5] & 0x01;
1738 priv
->pat
.ts_id
= (ptr
[3] << 8 ) | ptr
[4];
1739 priv
->pat
.version_number
= (ptr
[5] >> 1) & 0x1F;
1740 priv
->pat
.section_length
= ((ptr
[1] & 0x03) << 8 ) | ptr
[2];
1741 priv
->pat
.section_number
= ptr
[6];
1742 priv
->pat
.last_section_number
= ptr
[7];
1744 //check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]);
1745 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_PAT: section_len: %d, section %d/%d\n", priv
->pat
.section_length
, priv
->pat
.section_number
, priv
->pat
.last_section_number
);
1747 entries
= (int) (priv
->pat
.section_length
- 9) / 4; //entries per section
1749 for(i
=0; i
< entries
; i
++)
1752 base
= &ptr
[8 + i
*4];
1753 progid
= (base
[0] << 8) | base
[1];
1755 if((idx
= prog_idx_in_pat(priv
, progid
)) == -1)
1757 int sz
= sizeof(struct pat_progs_t
) * (priv
->pat
.progs_cnt
+1);
1758 tmp
= realloc_struct(priv
->pat
.progs
, priv
->pat
.progs_cnt
+1, sizeof(struct pat_progs_t
));
1761 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "PARSE_PAT: COULDN'T REALLOC %d bytes, NEXT\n", sz
);
1764 priv
->pat
.progs
= tmp
;
1765 idx
= priv
->pat
.progs_cnt
;
1766 priv
->pat
.progs_cnt
++;
1769 priv
->pat
.progs
[idx
].id
= progid
;
1770 priv
->pat
.progs
[idx
].pmt_pid
= ((base
[2] & 0x1F) << 8) | base
[3];
1771 mp_msg(MSGT_DEMUX
, MSGL_V
, "PROG: %d (%d-th of %d), PMT: %d\n", priv
->pat
.progs
[idx
].id
, i
+1, entries
, priv
->pat
.progs
[idx
].pmt_pid
);
1772 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "PROGRAM_ID=%d (0x%02X), PMT_PID: %d(0x%02X)\n",
1773 progid
, progid
, priv
->pat
.progs
[idx
].pmt_pid
, priv
->pat
.progs
[idx
].pmt_pid
);
1780 static inline int32_t es_pid_in_pmt(pmt_t
* pmt
, uint16_t pid
)
1790 for(i
= 0; i
< pmt
->es_cnt
; i
++)
1792 if(pmt
->es
[i
].pid
== pid
)
1800 static uint16_t get_mp4_desc_len(uint8_t *buf
, int *len
)
1802 //uint16_t i = 0, size = 0;
1803 int i
= 0, j
, size
= 0;
1805 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "PARSE_MP4_DESC_LEN(%d), bytes: ", *len
);
1809 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, " %x ", buf
[i
]);
1810 size
|= (buf
[i
] & 0x7f);
1811 if(!(buf
[i
] & 0x80))
1816 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, ", SIZE=%d\n", size
);
1823 static uint16_t parse_mp4_slconfig_descriptor(uint8_t *buf
, int len
, void *elem
)
1827 mp4_sl_config_t
*sl
;
1829 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_SLCONFIG_DESCRIPTOR(%d)\n", len
);
1830 es
= (mp4_es_descr_t
*) elem
;
1833 mp_msg(MSGT_DEMUX
, MSGL_V
, "argh! NULL elem passed, skip\n");
1838 sl
->ts_len
= sl
->ocr_len
= sl
->au_len
= sl
->instant_bitrate_len
= sl
->degr_len
= sl
->au_seqnum_len
= sl
->packet_seqnum_len
= 0;
1839 sl
->ocr
= sl
->dts
= sl
->cts
= 0;
1846 sl
->ts_resolution
= (buf
[i
] << 24) | (buf
[i
+1] << 16) | (buf
[i
+2] << 8) | buf
[i
+3];
1848 sl
->ocr_resolution
= (buf
[i
] << 24) | (buf
[i
+1] << 16) | (buf
[i
+2] << 8) | buf
[i
+3];
1850 sl
->ts_len
= buf
[i
];
1852 sl
->ocr_len
= buf
[i
];
1854 sl
->au_len
= buf
[i
];
1856 sl
->instant_bitrate_len
= buf
[i
];
1858 sl
->degr_len
= (buf
[i
] >> 4) & 0x0f;
1859 sl
->au_seqnum_len
= ((buf
[i
] & 0x0f) << 1) | ((buf
[i
+1] >> 7) & 0x01);
1861 sl
->packet_seqnum_len
= ((buf
[i
] >> 2) & 0x1f);
1865 else if(buf
[0] == 1)
1868 sl
->ts_resolution
= 1000;
1872 else if(buf
[0] == 2)
1883 sl
->au_start
= (sl
->flags
>> 7) & 0x1;
1884 sl
->au_end
= (sl
->flags
>> 6) & 0x1;
1885 sl
->random_accesspoint
= (sl
->flags
>> 5) & 0x1;
1886 sl
->random_accesspoint_only
= (sl
->flags
>> 4) & 0x1;
1887 sl
->padding
= (sl
->flags
>> 3) & 0x1;
1888 sl
->use_ts
= (sl
->flags
>> 2) & 0x1;
1889 sl
->idle
= (sl
->flags
>> 1) & 0x1;
1890 sl
->duration
= sl
->flags
& 0x1;
1894 sl
->timescale
= (buf
[i
] << 24) | (buf
[i
+1] << 16) | (buf
[i
+2] << 8) | buf
[i
+3];
1896 sl
->au_duration
= (buf
[i
] << 8) | buf
[i
+1];
1898 sl
->cts_duration
= (buf
[i
] << 8) | buf
[i
+1];
1901 else //no support for fixed durations atm
1902 sl
->timescale
= sl
->au_duration
= sl
->cts_duration
= 0;
1904 mp_msg(MSGT_DEMUX
, MSGL_V
, "MP4SLCONFIG(len=0x%x), predef: %d, flags: %x, use_ts: %d, tslen: %d, timescale: %d, dts: %"PRIu64
", cts: %"PRIu64
"\n",
1905 len
, buf
[0], sl
->flags
, sl
->use_ts
, sl
->ts_len
, sl
->timescale
, (uint64_t) sl
->dts
, (uint64_t) sl
->cts
);
1910 static int parse_mp4_descriptors(pmt_t
*pmt
, uint8_t *buf
, int len
, void *elem
);
1912 static uint16_t parse_mp4_decoder_config_descriptor(pmt_t
*pmt
, uint8_t *buf
, int len
, void *elem
)
1916 mp4_decoder_config_t
*dec
;
1918 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_DECODER_CONFIG_DESCRIPTOR(%d)\n", len
);
1919 es
= (mp4_es_descr_t
*) elem
;
1922 mp_msg(MSGT_DEMUX
, MSGL_V
, "argh! NULL elem passed, skip\n");
1925 dec
= (mp4_decoder_config_t
*) &(es
->decoder
);
1927 dec
->object_type
= buf
[i
];
1928 dec
->stream_type
= (buf
[i
+1]>>2) & 0x3f;
1930 if(dec
->object_type
== 1 && dec
->stream_type
== 1)
1932 dec
->object_type
= MP4_OD
;
1933 dec
->stream_type
= MP4_OD
;
1935 else if(dec
->stream_type
== 4)
1937 if(dec
->object_type
== 0x6a)
1938 dec
->object_type
= VIDEO_MPEG1
;
1939 if(dec
->object_type
>= 0x60 && dec
->object_type
<= 0x65)
1940 dec
->object_type
= VIDEO_MPEG2
;
1941 else if(dec
->object_type
== 0x20)
1942 dec
->object_type
= VIDEO_MPEG4
;
1943 else if(dec
->object_type
== 0x21)
1944 dec
->object_type
= VIDEO_AVC
;
1945 /*else if(dec->object_type == 0x22)
1946 fprintf(stderr, "TYPE 0x22\n");*/
1947 else dec
->object_type
= UNKNOWN
;
1949 else if(dec
->stream_type
== 5)
1951 if(dec
->object_type
== 0x40)
1952 dec
->object_type
= AUDIO_AAC
;
1953 else if(dec
->object_type
== 0x6b)
1954 dec
->object_type
= AUDIO_MP2
;
1955 else if(dec
->object_type
>= 0x66 && dec
->object_type
<= 0x69)
1956 dec
->object_type
= AUDIO_MP2
;
1958 dec
->object_type
= UNKNOWN
;
1961 dec
->object_type
= dec
->stream_type
= UNKNOWN
;
1963 if(dec
->object_type
!= UNKNOWN
)
1965 //update the type of the current stream
1966 for(j
= 0; j
< pmt
->es_cnt
; j
++)
1968 if(pmt
->es
[j
].mp4_es_id
== es
->id
)
1970 pmt
->es
[j
].type
= SL_PES_STREAM
;
1976 parse_mp4_descriptors(pmt
, &buf
[13], len
-13, dec
);
1978 mp_msg(MSGT_DEMUX
, MSGL_V
, "MP4DECODER(0x%x), object_type: 0x%x, stream_type: 0x%x\n", len
, dec
->object_type
, dec
->stream_type
);
1983 static uint16_t parse_mp4_decoder_specific_descriptor(uint8_t *buf
, int len
, void *elem
)
1986 mp4_decoder_config_t
*dec
;
1988 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_DECODER_SPECIFIC_DESCRIPTOR(%d)\n", len
);
1989 dec
= (mp4_decoder_config_t
*) elem
;
1992 mp_msg(MSGT_DEMUX
, MSGL_V
, "argh! NULL elem passed, skip\n");
1996 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "MP4 SPECIFIC INFO BYTES: \n");
1997 for(i
=0; i
<len
; i
++)
1998 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "%02x ", buf
[i
]);
1999 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "\n");
2001 if(len
> MAX_EXTRADATA_SIZE
)
2003 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "DEMUX_TS, EXTRADATA SUSPICIOUSLY BIG: %d, REFUSED\r\n", len
);
2006 memcpy(dec
->buf
, buf
, len
);
2007 dec
->buf_size
= len
;
2012 static uint16_t parse_mp4_es_descriptor(pmt_t
*pmt
, uint8_t *buf
, int len
)
2014 int i
= 0, j
= 0, k
, found
;
2016 mp4_es_descr_t es
, *target_es
= NULL
, *tmp
;
2018 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4ES: len=%d\n", len
);
2019 memset(&es
, 0, sizeof(mp4_es_descr_t
));
2022 es
.id
= (buf
[i
] << 8) | buf
[i
+1];
2023 mp_msg(MSGT_DEMUX
, MSGL_V
, "MP4ES_ID: %d\n", es
.id
);
2031 if(flag
& 0x20) //OCR, maybe we need it
2034 j
= parse_mp4_descriptors(pmt
, &buf
[i
], len
-i
, &es
);
2035 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4ES, types after parse_mp4_descriptors: 0x%x, 0x%x\n", es
.decoder
.object_type
, es
.decoder
.stream_type
);
2036 if(es
.decoder
.object_type
!= UNKNOWN
&& es
.decoder
.stream_type
!= UNKNOWN
)
2039 //search this ES_ID if we already have it
2040 for(k
=0; k
< pmt
->mp4es_cnt
; k
++)
2042 if(pmt
->mp4es
[k
].id
== es
.id
)
2044 target_es
= &(pmt
->mp4es
[k
]);
2051 tmp
= realloc_struct(pmt
->mp4es
, pmt
->mp4es_cnt
+1, sizeof(mp4_es_descr_t
));
2054 fprintf(stderr
, "CAN'T REALLOC MP4_ES_DESCR\n");
2058 target_es
= &(pmt
->mp4es
[pmt
->mp4es_cnt
]);
2061 memcpy(target_es
, &es
, sizeof(mp4_es_descr_t
));
2062 mp_msg(MSGT_DEMUX
, MSGL_V
, "MP4ES_CNT: %d, ID=%d\n", pmt
->mp4es_cnt
, target_es
->id
);
2071 static void parse_mp4_object_descriptor(pmt_t
*pmt
, uint8_t *buf
, int len
, void *elem
)
2076 id
= (buf
[0] << 2) | ((buf
[1] & 0xc0) >> 6);
2077 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_OBJECT_DESCRIPTOR: len=%d, OD_ID=%d\n", len
, id
);
2080 i
+= buf
[2] + 1; //url
2081 mp_msg(MSGT_DEMUX
, MSGL_V
, "URL\n");
2089 j
= parse_mp4_descriptors(pmt
, &(buf
[i
]), len
-i
, elem
);
2090 mp_msg(MSGT_DEMUX
, MSGL_V
, "OBJD, NOW i = %d, j=%d, LEN=%d\n", i
, j
, len
);
2097 static void parse_mp4_iod(pmt_t
*pmt
, uint8_t *buf
, int len
, void *elem
)
2100 mp4_od_t
*iod
= &(pmt
->iod
);
2102 iod
->id
= (buf
[0] << 2) | ((buf
[1] & 0xc0) >> 6);
2103 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_IOD: len=%d, IOD_ID=%d\n", len
, iod
->id
);
2107 i
+= buf
[2] + 1; //url
2108 mp_msg(MSGT_DEMUX
, MSGL_V
, "URL\n");
2115 j
= parse_mp4_descriptors(pmt
, &(buf
[i
]), len
-i
, elem
);
2116 mp_msg(MSGT_DEMUX
, MSGL_V
, "IOD, NOW i = %d, j=%d, LEN=%d\n", i
, j
, len
);
2122 static int parse_mp4_descriptors(pmt_t
*pmt
, uint8_t *buf
, int len
, void *elem
)
2124 int tag
, descr_len
, i
= 0, j
= 0;
2126 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_MP4_DESCRIPTORS, len=%d\n", len
);
2134 descr_len
= get_mp4_desc_len(&(buf
[i
+1]), &j
);
2135 mp_msg(MSGT_DEMUX
, MSGL_V
, "TAG=%d (0x%x), DESCR_len=%d, len=%d, j=%d\n", tag
, tag
, descr_len
, len
, j
);
2136 if(descr_len
> len
- j
+1)
2138 mp_msg(MSGT_DEMUX
, MSGL_V
, "descriptor is too long, exit\n");
2146 parse_mp4_object_descriptor(pmt
, &(buf
[i
]), descr_len
, elem
);
2149 parse_mp4_iod(pmt
, &(buf
[i
]), descr_len
, elem
);
2152 parse_mp4_es_descriptor(pmt
, &(buf
[i
]), descr_len
);
2155 parse_mp4_decoder_config_descriptor(pmt
, &buf
[i
], descr_len
, elem
);
2158 parse_mp4_decoder_specific_descriptor(&buf
[i
], descr_len
, elem
);
2161 parse_mp4_slconfig_descriptor(&buf
[i
], descr_len
, elem
);
2164 mp_msg(MSGT_DEMUX
, MSGL_V
, "Unsupported mp4 descriptor 0x%x\n", tag
);
2172 static ES_stream_t
*new_pid(ts_priv_t
*priv
, int pid
)
2176 tss
= malloc(sizeof(ES_stream_t
));
2179 memset(tss
, 0, sizeof(ES_stream_t
));
2182 tss
->type
= UNKNOWN
;
2183 tss
->subtype
= UNKNOWN
;
2185 tss
->extradata
= NULL
;
2186 tss
->extradata_alloc
= tss
->extradata_len
= 0;
2187 priv
->ts
.pids
[pid
] = tss
;
2193 static int parse_program_descriptors(pmt_t
*pmt
, uint8_t *buf
, uint16_t len
)
2195 uint16_t i
= 0, k
, olen
= len
;
2199 mp_msg(MSGT_DEMUX
, MSGL_V
, "PROG DESCR, TAG=%x, LEN=%d(%x)\n", buf
[i
], buf
[i
+1], buf
[i
+1]);
2200 if(buf
[i
+1] > len
-2)
2202 mp_msg(MSGT_DEMUX
, MSGL_V
, "ERROR, descriptor len is too long, skipping\n");
2208 if(buf
[i
+3] == 2) //buggy versions of vlc muxer make this non-standard mess (missing iod_scope)
2211 k
= 4; //this is standard compliant
2212 parse_mp4_descriptors(pmt
, &buf
[i
+k
], (int) buf
[i
+1]-(k
-2), NULL
);
2215 len
-= 2 + buf
[i
+1];
2221 static int parse_descriptors(struct pmt_es_t
*es
, uint8_t *ptr
)
2223 int j
, descr_len
, len
;
2226 len
= es
->descr_length
;
2229 descr_len
= ptr
[j
+1];
2230 mp_msg(MSGT_DEMUX
, MSGL_V
, "...descr id: 0x%x, len=%d\n", ptr
[j
], descr_len
);
2233 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "INVALID DESCR LEN for tag %02x: %d vs %d max, EXIT LOOP\n", ptr
[j
], descr_len
, len
);
2238 if(ptr
[j
] == 0x6a || ptr
[j
] == 0x7a) //A52 Descriptor
2242 es
->type
= AUDIO_A52
;
2243 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "DVB A52 Descriptor\n");
2246 else if(ptr
[j
] == 0x7b) //DVB DTS Descriptor
2250 es
->type
= AUDIO_DTS
;
2251 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "DVB DTS Descriptor\n");
2254 else if(ptr
[j
] == 0x56) // Teletext
2256 if(descr_len
>= 5) {
2257 memcpy(es
->lang
, ptr
+2, 3);
2260 es
->type
= SPU_TELETEXT
;
2262 else if(ptr
[j
] == 0x59) //Subtitling Descriptor
2266 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Subtitling Descriptor\n");
2269 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Descriptor length too short for DVB Subtitle Descriptor: %d, SKIPPING\n", descr_len
);
2273 memcpy(es
->lang
, &ptr
[j
+2], 3);
2277 (subtype
>= 0x10 && subtype
<= 0x13) ||
2278 (subtype
>= 0x20 && subtype
<= 0x23)
2282 //page parameters: compo page 2 bytes, ancillary page 2 bytes
2288 else if(ptr
[j
] == 0x50) //Component Descriptor
2290 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Component Descriptor\n");
2291 memcpy(es
->lang
, &ptr
[j
+5], 3);
2294 else if(ptr
[j
] == 0xa) //Language Descriptor
2296 memcpy(es
->lang
, &ptr
[j
+2], 3);
2298 mp_msg(MSGT_DEMUX
, MSGL_V
, "Language Descriptor: %s\n", es
->lang
);
2300 else if(ptr
[j
] == 0x5) //Registration Descriptor (looks like e fourCC :) )
2302 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Registration Descriptor\n");
2305 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Registration Descriptor length too short: %d, SKIPPING\n", descr_len
);
2310 memcpy(es
->format_descriptor
, &ptr
[j
+2], 4);
2311 es
->format_descriptor
[4] = 0;
2314 if(d
[0] == 'A' && d
[1] == 'C' && d
[2] == '-' && d
[3] == '3')
2316 es
->type
= AUDIO_A52
;
2318 else if(d
[0] == 'D' && d
[1] == 'T' && d
[2] == 'S' && d
[3] == '1')
2320 es
->type
= AUDIO_DTS
;
2322 else if(d
[0] == 'D' && d
[1] == 'T' && d
[2] == 'S' && d
[3] == '2')
2324 es
->type
= AUDIO_DTS
;
2326 else if(d
[0] == 'V' && d
[1] == 'C' && d
[2] == '-' && d
[3] == '1')
2328 es
->type
= VIDEO_VC1
;
2330 else if(d
[0] == 'd' && d
[1] == 'r' && d
[2] == 'a' && d
[3] == 'c')
2332 es
->type
= VIDEO_DIRAC
;
2336 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "FORMAT %s\n", es
->format_descriptor
);
2339 else if(ptr
[j
] == 0x1e)
2341 es
->mp4_es_id
= (ptr
[j
+2] << 8) | ptr
[j
+3];
2342 mp_msg(MSGT_DEMUX
, MSGL_V
, "SL Descriptor: ES_ID: %d(%x), pid: %d\n", es
->mp4_es_id
, es
->mp4_es_id
, es
->pid
);
2345 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "Unknown descriptor 0x%x, SKIPPING\n", ptr
[j
]);
2347 len
-= 2 + descr_len
;
2354 static int parse_sl_section(pmt_t
*pmt
, ts_section_t
*section
, int is_start
, unsigned char *buff
, int size
)
2358 skip
= collect_section(section
, is_start
, buff
, size
);
2362 ptr
= &(section
->buffer
[skip
]);
2364 len
= ((ptr
[1] & 0x0f) << 8) | ptr
[2];
2365 mp_msg(MSGT_DEMUX
, MSGL_V
, "TABLEID: %d (av. %d), skip=%d, LEN: %d\n", tid
, section
->buffer_len
, skip
, len
);
2366 if(len
> 4093 || section
->buffer_len
< len
|| tid
!= 5)
2368 mp_msg(MSGT_DEMUX
, MSGL_V
, "SECTION TOO LARGE or wrong section type, EXIT\n");
2375 //8 is the current position, len - 9 is the amount of data available
2376 parse_mp4_descriptors(pmt
, &ptr
[8], len
- 9, NULL
);
2381 static int parse_pmt(ts_priv_t
* priv
, uint16_t progid
, uint16_t pid
, int is_start
, unsigned char *buff
, int size
)
2383 unsigned char *base
, *es_base
;
2385 int32_t idx
, es_count
, section_bytes
;
2389 struct pmt_es_t
*tmp_es
;
2390 ts_section_t
*section
;
2393 idx
= progid_idx_in_pmt(priv
, progid
);
2397 int sz
= (priv
->pmt_cnt
+ 1) * sizeof(pmt_t
);
2398 tmp
= realloc_struct(priv
->pmt
, priv
->pmt_cnt
+ 1, sizeof(pmt_t
));
2401 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz
);
2405 idx
= priv
->pmt_cnt
;
2406 memset(&(priv
->pmt
[idx
]), 0, sizeof(pmt_t
));
2408 priv
->pmt
[idx
].progid
= progid
;
2411 pmt
= &(priv
->pmt
[idx
]);
2413 section
= &(pmt
->section
);
2414 skip
= collect_section(section
, is_start
, buff
, size
);
2418 base
= &(section
->buffer
[skip
]);
2420 mp_msg(MSGT_DEMUX
, MSGL_V
, "FILL_PMT(prog=%d), PMT_len: %d, IS_START: %d, TS_PID: %d, SIZE=%d, M=%d, ES_CNT=%d, IDX=%d, PMT_PTR=%p\n",
2421 progid
, pmt
->section
.buffer_len
, is_start
, pid
, size
, m
, pmt
->es_cnt
, idx
, pmt
);
2423 pmt
->table_id
= base
[0];
2424 if(pmt
->table_id
!= 2)
2426 pmt
->ssi
= base
[1] & 0x80;
2427 pmt
->section_length
= (((base
[1] & 0xf) << 8 ) | base
[2]);
2428 pmt
->version_number
= (base
[5] >> 1) & 0x1f;
2429 pmt
->curr_next
= (base
[5] & 1);
2430 pmt
->section_number
= base
[6];
2431 pmt
->last_section_number
= base
[7];
2432 pmt
->PCR_PID
= ((base
[8] & 0x1f) << 8 ) | base
[9];
2433 pmt
->prog_descr_length
= ((base
[10] & 0xf) << 8 ) | base
[11];
2434 if(pmt
->prog_descr_length
> pmt
->section_length
- 9)
2436 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_PMT, INVALID PROG_DESCR LENGTH (%d vs %d)\n", pmt
->prog_descr_length
, pmt
->section_length
- 9);
2440 if(pmt
->prog_descr_length
)
2441 parse_program_descriptors(pmt
, &base
[12], pmt
->prog_descr_length
);
2443 es_base
= &base
[12 + pmt
->prog_descr_length
]; //the beginning of th ES loop
2445 section_bytes
= pmt
->section_length
- 13 - pmt
->prog_descr_length
;
2448 while(section_bytes
>= 5)
2450 int es_pid
, es_type
;
2452 es_type
= es_base
[0];
2453 es_pid
= ((es_base
[1] & 0x1f) << 8) | es_base
[2];
2455 idx
= es_pid_in_pmt(pmt
, es_pid
);
2458 int sz
= sizeof(struct pmt_es_t
) * (pmt
->es_cnt
+ 1);
2459 tmp_es
= realloc_struct(pmt
->es
, pmt
->es_cnt
+ 1, sizeof(struct pmt_es_t
));
2462 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz
);
2467 memset(&(pmt
->es
[idx
]), 0, sizeof(struct pmt_es_t
));
2471 pmt
->es
[idx
].descr_length
= ((es_base
[3] & 0xf) << 8) | es_base
[4];
2474 if(pmt
->es
[idx
].descr_length
> section_bytes
- 5)
2476 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT\n",
2477 pmt
->es
[idx
].descr_length
, section_bytes
- 5);
2482 pmt
->es
[idx
].pid
= es_pid
;
2484 pmt
->es
[idx
].type
= UNKNOWN
;
2486 pmt
->es
[idx
].type
= es_type
;
2488 parse_descriptors(&pmt
->es
[idx
], &es_base
[5]);
2493 pmt
->es
[idx
].type
= VIDEO_MPEG1
;
2496 pmt
->es
[idx
].type
= VIDEO_MPEG2
;
2500 pmt
->es
[idx
].type
= AUDIO_MP2
;
2503 if(pmt
->es
[idx
].type
== 0x6) //this could have been ovrwritten by parse_descriptors
2504 pmt
->es
[idx
].type
= UNKNOWN
;
2507 pmt
->es
[idx
].type
= VIDEO_MPEG4
;
2511 pmt
->es
[idx
].type
= AUDIO_AAC
;
2514 pmt
->es
[idx
].type
= VIDEO_H264
;
2517 pmt
->es
[idx
].type
= SL_PES_STREAM
;
2520 pmt
->es
[idx
].type
= SL_SECTION
;
2523 pmt
->es
[idx
].type
= AUDIO_A52
;
2529 pmt
->es
[idx
].type
= AUDIO_DTS
;
2532 pmt
->es
[idx
].type
= VIDEO_DIRAC
;
2535 pmt
->es
[idx
].type
= VIDEO_VC1
;
2538 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "UNKNOWN ES TYPE=0x%x\n", es_type
);
2539 pmt
->es
[idx
].type
= UNKNOWN
;
2542 tss
= priv
->ts
.pids
[es_pid
]; //an ES stream
2545 tss
= new_pid(priv
, es_pid
);
2547 tss
->type
= pmt
->es
[idx
].type
;
2550 section_bytes
-= 5 + pmt
->es
[idx
].descr_length
;
2551 mp_msg(MSGT_DEMUX
, MSGL_V
, "PARSE_PMT(%d INDEX %d), STREAM: %d, FOUND pid=0x%x (%d), type=0x%x, ES_DESCR_LENGTH: %d, bytes left: %d\n",
2552 progid
, idx
, es_count
, pmt
->es
[idx
].pid
, pmt
->es
[idx
].pid
, pmt
->es
[idx
].type
, pmt
->es
[idx
].descr_length
, section_bytes
);
2555 es_base
+= 5 + pmt
->es
[idx
].descr_length
;
2560 mp_msg(MSGT_DEMUX
, MSGL_V
, "----------------------------\n");
2564 static pmt_t
* pmt_of_pid(ts_priv_t
*priv
, int pid
, mp4_decoder_config_t
**mp4_dec
)
2570 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
2572 if(priv
->pmt
[i
].es
&& priv
->pmt
[i
].es_cnt
)
2574 for(j
= 0; j
< priv
->pmt
[i
].es_cnt
; j
++)
2576 if(priv
->pmt
[i
].es
[j
].pid
== pid
)
2579 if(priv
->pmt
[i
].es
[j
].mp4_es_id
)
2581 for(k
= 0; k
< priv
->pmt
[i
].mp4es_cnt
; k
++)
2583 if(priv
->pmt
[i
].mp4es
[k
].id
== priv
->pmt
[i
].es
[j
].mp4_es_id
)
2585 *mp4_dec
= &(priv
->pmt
[i
].mp4es
[k
].decoder
);
2591 return &(priv
->pmt
[i
]);
2602 static inline int32_t pid_type_from_pmt(ts_priv_t
*priv
, int pid
)
2604 int32_t pmt_idx
, pid_idx
, i
, j
;
2606 pmt_idx
= progid_idx_in_pmt(priv
, priv
->prog
);
2610 pid_idx
= es_pid_in_pmt(&(priv
->pmt
[pmt_idx
]), pid
);
2612 return priv
->pmt
[pmt_idx
].es
[pid_idx
].type
;
2616 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
2618 pmt_t
*pmt
= &(priv
->pmt
[i
]);
2619 for(j
= 0; j
< pmt
->es_cnt
; j
++)
2620 if(pmt
->es
[j
].pid
== pid
)
2621 return pmt
->es
[j
].type
;
2629 static inline uint8_t *pid_lang_from_pmt(ts_priv_t
*priv
, int pid
)
2631 int32_t pmt_idx
, pid_idx
, i
, j
;
2633 pmt_idx
= progid_idx_in_pmt(priv
, priv
->prog
);
2637 pid_idx
= es_pid_in_pmt(&(priv
->pmt
[pmt_idx
]), pid
);
2639 return priv
->pmt
[pmt_idx
].es
[pid_idx
].lang
;
2643 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
2645 pmt_t
*pmt
= &(priv
->pmt
[i
]);
2646 for(j
= 0; j
< pmt
->es_cnt
; j
++)
2647 if(pmt
->es
[j
].pid
== pid
)
2648 return pmt
->es
[j
].lang
;
2656 static int fill_packet(demuxer_t
*demuxer
, demux_stream_t
*ds
, demux_packet_t
**dp
, int *dp_offset
, TS_stream_info
*si
)
2660 if((*dp
!= NULL
) && (*dp_offset
> 0))
2663 resize_demux_packet(*dp
, ret
); //shrinked to the right size
2664 ds_add_packet(ds
, *dp
);
2665 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "ADDED %d bytes to %s fifo, PTS=%.3f\n", ret
, (ds
== demuxer
->audio
? "audio" : (ds
== demuxer
->video
? "video" : "sub")), (*dp
)->pts
);
2668 float diff
= (*dp
)->pts
- si
->last_pts
;
2671 if(abs(diff
) > 1) //1 second, there's a discontinuity
2673 si
->duration
+= si
->last_pts
- si
->first_pts
;
2674 si
->first_pts
= si
->last_pts
= (*dp
)->pts
;
2678 si
->last_pts
= (*dp
)->pts
;
2681 dur
= si
->duration
+ (si
->last_pts
- si
->first_pts
);
2683 if(dur
> 0 && ds
== demuxer
->video
)
2685 ts_priv_t
* priv
= (ts_priv_t
*) demuxer
->priv
;
2686 if(dur
> 1) //otherwise it may be unreliable
2687 priv
->vbitrate
= (uint32_t) ((float) si
->size
/ dur
);
2698 static int fill_extradata(mp4_decoder_config_t
* mp4_dec
, ES_stream_t
*tss
)
2702 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "MP4_dec: %p, pid: %d\n", mp4_dec
, tss
->pid
);
2704 if(mp4_dec
->buf_size
> tss
->extradata_alloc
)
2706 tmp
= realloc(tss
->extradata
, mp4_dec
->buf_size
);
2709 tss
->extradata
= tmp
;
2710 tss
->extradata_alloc
= mp4_dec
->buf_size
;
2712 memcpy(tss
->extradata
, mp4_dec
->buf
, mp4_dec
->buf_size
);
2713 tss
->extradata_len
= mp4_dec
->buf_size
;
2714 mp_msg(MSGT_DEMUX
, MSGL_V
, "EXTRADATA: %p, alloc=%d, len=%d\n", tss
->extradata
, tss
->extradata_alloc
, tss
->extradata_len
);
2716 return tss
->extradata_len
;
2719 // 0 = EOF or no stream found
2720 // else = [-] number of bytes written to the packet
2721 static int ts_parse(demuxer_t
*demuxer
, ES_stream_t
*es
, unsigned char *packet
, int probe
)
2725 int buf_size
, is_start
, pid
, base
;
2726 int len
, cc
, cc_ok
, afc
, retv
= 0, is_video
, is_audio
, is_sub
;
2727 ts_priv_t
* priv
= (ts_priv_t
*) demuxer
->priv
;
2728 stream_t
*stream
= demuxer
->stream
;
2730 demux_stream_t
*ds
= NULL
;
2731 demux_packet_t
**dp
= NULL
;
2732 int *dp_offset
= 0, *buffer_size
= 0;
2733 int32_t progid
, pid_type
, bad
, ts_error
;
2734 int junk
= 0, rap_flag
= 0;
2736 mp4_decoder_config_t
*mp4_dec
;
2743 ds
= (demux_stream_t
*) NULL
;
2744 dp
= (demux_packet_t
**) NULL
;
2745 dp_offset
= buffer_size
= NULL
;
2752 junk
= priv
->ts
.packet_size
- TS_PACKET_SIZE
;
2753 buf_size
= priv
->ts
.packet_size
- junk
;
2755 if(stream_eof(stream
))
2759 ts_dump_streams(priv
);
2760 demuxer
->filepos
= stream_tell(demuxer
->stream
);
2767 if(! ts_sync(stream
))
2769 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "TS_PARSE: COULDN'T SYNC\n");
2773 len
= stream_read(stream
, &packet
[1], 3);
2778 if((packet
[1] >> 7) & 0x01) //transport error
2782 is_start
= packet
[1] & 0x40;
2783 pid
= ((packet
[1] & 0x1f) << 8) | packet
[2];
2785 tss
= priv
->ts
.pids
[pid
]; //an ES stream
2788 tss
= new_pid(priv
, pid
);
2793 cc
= (packet
[3] & 0xf);
2794 cc_ok
= (tss
->last_cc
< 0) || ((((tss
->last_cc
+ 1) & 0x0f) == cc
));
2797 bad
= ts_error
; // || (! cc_ok);
2800 if(priv
->keep_broken
== 0)
2802 stream_skip(stream
, buf_size
-1+junk
);
2806 is_start
= 0; //queued to the packet data
2812 if((!is_start
&& !tss
->is_synced
) || ((pid
> 1) && (pid
< 16)) || (pid
== 8191)) //invalid pid
2814 stream_skip(stream
, buf_size
-1+junk
);
2819 afc
= (packet
[3] >> 4) & 3;
2820 if(! (afc
% 2)) //no payload in this TS packet
2822 stream_skip(stream
, buf_size
-1+junk
);
2829 c
= stream_read_char(stream
);
2831 if(c
< 0 || c
> 183) //broken from the stream layer or invalid
2833 stream_skip(stream
, buf_size
-1+junk
);
2840 uint8_t pcrbuf
[188];
2841 int flags
= stream_read_char(stream
);
2843 rap_flag
= (flags
& 0x40) >> 6;
2844 has_pcr
= flags
& 0x10;
2848 stream_read(stream
, pcrbuf
, c
);
2852 int pcr_pid
= prog_pcr_pid(priv
, priv
->prog
);
2855 uint64_t pcr
, pcr_ext
;
2857 pcr
= (int64_t)(pcrbuf
[0]) << 25;
2858 pcr
|= pcrbuf
[1] << 17 ;
2859 pcr
|= (pcrbuf
[2]) << 9;
2860 pcr
|= pcrbuf
[3] << 1 ;
2861 pcr
|= (pcrbuf
[4] & 0x80) >> 7;
2863 pcr_ext
= (pcrbuf
[4] & 0x01) << 8;
2864 pcr_ext
|= pcrbuf
[5];
2866 pcr
= pcr
* 300 + pcr_ext
;
2868 demuxer
->reference_clock
= (double)pcr
/(double)27000000.0;
2878 //find the program that the pid belongs to; if (it's the right one or -1) && pid_type==SL_SECTION
2879 //call parse_sl_section()
2880 pmt
= pmt_of_pid(priv
, pid
, &mp4_dec
);
2883 fill_extradata(mp4_dec
, tss
);
2884 if(IS_VIDEO(mp4_dec
->object_type
) || IS_AUDIO(mp4_dec
->object_type
))
2886 tss
->type
= SL_PES_STREAM
;
2887 tss
->subtype
= mp4_dec
->object_type
;
2894 base
= priv
->ts
.packet_size
- buf_size
;
2896 priv
->last_pid
= pid
;
2898 is_video
= IS_VIDEO(tss
->type
) || (tss
->type
==SL_PES_STREAM
&& IS_VIDEO(tss
->subtype
));
2899 is_audio
= IS_AUDIO(tss
->type
) || (tss
->type
==SL_PES_STREAM
&& IS_AUDIO(tss
->subtype
)) || (tss
->type
== PES_PRIVATE1
);
2900 is_sub
= IS_SUB(tss
->type
);
2901 pid_type
= pid_type_from_pmt(priv
, pid
);
2903 // PES CONTENT STARTS HERE
2906 if((is_video
|| is_audio
) && is_start
&& !priv
->ts
.streams
[pid
].sh
)
2907 ts_add_stream(demuxer
, tss
);
2909 if((pid
== demuxer
->sub
->id
)) //or the lang is right
2914 if(is_video
&& (demuxer
->video
->id
== priv
->ts
.streams
[pid
].id
))
2916 ds
= demuxer
->video
;
2918 dp
= &priv
->fifo
[1].pack
;
2919 dp_offset
= &priv
->fifo
[1].offset
;
2920 buffer_size
= &priv
->fifo
[1].buffer_size
;
2923 else if(is_audio
&& (demuxer
->audio
->id
== priv
->ts
.streams
[pid
].id
))
2925 ds
= demuxer
->audio
;
2927 dp
= &priv
->fifo
[0].pack
;
2928 dp_offset
= &priv
->fifo
[0].offset
;
2929 buffer_size
= &priv
->fifo
[0].buffer_size
;
2933 || IS_SUB(pid_type
))
2935 //SUBS are infrequent, so the initial detection may fail
2936 // and we may need to add them at play-time
2937 if(demuxer
->sub
->id
== -1)
2940 p
= progid_for_pid(priv
, tss
->pid
, priv
->prog
);
2947 if(demuxer
->opts
->sub_lang
)
2949 if ((lang
= pid_lang_from_pmt(priv
, pid
)))
2950 asgn
= (strncmp(lang
, demuxer
->opts
->sub_lang
, 3) == 0);
2952 else //no language specified with -slang
2957 demuxer
->sub
->id
= tss
->pid
;
2958 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "CHOSEN SUBs pid 0x%x (%d) FROM PROG %d\n", tss
->pid
, tss
->pid
, priv
->prog
);
2963 if(demuxer
->sub
->id
== tss
->pid
)
2967 dp
= &priv
->fifo
[2].pack
;
2968 dp_offset
= &priv
->fifo
[2].offset
;
2969 buffer_size
= &priv
->fifo
[2].buffer_size
;
2973 stream_skip(stream
, buf_size
+junk
);
2978 //IS IT TIME TO QUEUE DATA to the dp_packet?
2979 if(is_start
&& (dp
!= NULL
))
2981 retv
= fill_packet(demuxer
, ds
, dp
, dp_offset
, si
);
2985 if(dp
&& *dp
== NULL
)
2987 if(*buffer_size
> MAX_PACK_BYTES
)
2988 *buffer_size
= MAX_PACK_BYTES
;
2989 *dp
= new_demux_packet(*buffer_size
); //es->size
2993 fprintf(stderr
, "fill_buffer, NEW_ADD_PACKET(%d)FAILED\n", *buffer_size
);
2996 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "CREATED DP(%d)\n", *buffer_size
);
3001 if(probe
|| !dp
) //dp is NULL for tables and sections
3007 if(*dp_offset
+ buf_size
> *buffer_size
)
3009 *buffer_size
= *dp_offset
+ buf_size
+ TS_FEC_PACKET_SIZE
;
3010 resize_demux_packet(*dp
, *buffer_size
);
3012 p
= &((*dp
)->buffer
[*dp_offset
]);
3015 len
= stream_read(stream
, p
, buf_size
);
3018 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "\r\nts_parse() couldn't read enough data: %d < %d\r\n", len
, buf_size
);
3021 stream_skip(stream
, junk
);
3025 parse_pat(priv
, is_start
, p
, buf_size
);
3028 else if((tss
->type
== SL_SECTION
) && pmt
)
3030 int k
, mp4_es_id
= -1;
3031 ts_section_t
*section
;
3032 for(k
= 0; k
< pmt
->mp4es_cnt
; k
++)
3034 if(pmt
->mp4es
[k
].decoder
.object_type
== MP4_OD
&& pmt
->mp4es
[k
].decoder
.stream_type
== MP4_OD
)
3035 mp4_es_id
= pmt
->mp4es
[k
].id
;
3037 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "MP4ESID: %d\n", mp4_es_id
);
3038 for(k
= 0; k
< pmt
->es_cnt
; k
++)
3040 if(pmt
->es
[k
].mp4_es_id
== mp4_es_id
)
3042 section
= &(tss
->section
);
3043 parse_sl_section(pmt
, section
, is_start
, &packet
[base
], buf_size
);
3050 progid
= prog_id_in_pat(priv
, pid
);
3053 if(pid
!= demuxer
->video
->id
&& pid
!= demuxer
->audio
->id
&& pid
!= demuxer
->sub
->id
)
3055 parse_pmt(priv
, progid
, pid
, is_start
, &packet
[base
], buf_size
);
3059 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "Argh! Data pid %d used in the PMT, Skipping PMT parsing!\n", pid
);
3068 uint8_t *lang
= NULL
;
3070 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "IS_START\n");
3072 len
= pes_parse2(p
, buf_size
, es
, pid_type
, pmt
, pid
);
3079 tss
->is_synced
|= es
->is_synced
|| rap_flag
;
3080 tss
->payload_size
= es
->payload_size
;
3082 if((is_sub
|| is_audio
) && (lang
= pid_lang_from_pmt(priv
, es
->pid
)))
3084 memcpy(es
->lang
, lang
, 3);
3092 if(es
->type
== UNKNOWN
)
3095 tss
->type
= es
->type
;
3096 tss
->subtype
= es
->subtype
;
3103 es
->pts
= tss
->pts
= tss
->last_pts
;
3105 tss
->pts
= tss
->last_pts
= es
->pts
;
3107 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%p, len=%d\n",
3108 es
->pid
, es
->payload_size
, es
->type
, es
->start
, es
->size
);
3110 demuxer
->filepos
= stream_tell(demuxer
->stream
) - es
->size
;
3112 memmove(p
, es
->start
, es
->size
);
3113 *dp_offset
+= es
->size
;
3115 (*dp
)->pos
= stream_tell(demuxer
->stream
);
3116 (*dp
)->pts
= es
->pts
;
3129 es
->type
= tss
->type
;
3130 es
->subtype
= tss
->subtype
;
3131 es
->pts
= tss
->pts
= tss
->last_pts
;
3132 es
->start
= &packet
[base
];
3135 if(tss
->payload_size
> 0)
3137 sz
= FFMIN(tss
->payload_size
, buf_size
);
3138 tss
->payload_size
-= sz
;
3145 sz
= es
->size
= buf_size
;
3158 if(*dp_offset
>= MAX_PACK_BYTES
)
3160 (*dp
)->pts
= tss
->last_pts
;
3161 retv
= fill_packet(demuxer
, ds
, dp
, dp_offset
, si
);
3169 memcpy(es
->start
, p
, sz
);
3183 void skip_audio_frame(sh_audio_t
*sh_audio
);
3185 static void reset_fifos(demuxer_t
*demuxer
, int a
, int v
, int s
)
3187 ts_priv_t
* priv
= demuxer
->priv
;
3190 if(priv
->fifo
[0].pack
!= NULL
)
3192 free_demux_packet(priv
->fifo
[0].pack
);
3193 priv
->fifo
[0].pack
= NULL
;
3195 priv
->fifo
[0].offset
= 0;
3200 if(priv
->fifo
[1].pack
!= NULL
)
3202 free_demux_packet(priv
->fifo
[1].pack
);
3203 priv
->fifo
[1].pack
= NULL
;
3205 priv
->fifo
[1].offset
= 0;
3210 if(priv
->fifo
[2].pack
!= NULL
)
3212 free_demux_packet(priv
->fifo
[2].pack
);
3213 priv
->fifo
[2].pack
= NULL
;
3215 priv
->fifo
[2].offset
= 0;
3217 demuxer
->reference_clock
= MP_NOPTS_VALUE
;
3221 static void demux_seek_ts(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
, int flags
)
3223 demux_stream_t
*d_audio
=demuxer
->audio
;
3224 demux_stream_t
*d_video
=demuxer
->video
;
3225 sh_audio_t
*sh_audio
=d_audio
->sh
;
3226 sh_video_t
*sh_video
=d_video
->sh
;
3227 ts_priv_t
* priv
= (ts_priv_t
*) demuxer
->priv
;
3231 //================= seek in MPEG-TS ==========================
3233 ts_dump_streams(demuxer
->priv
);
3234 reset_fifos(demuxer
, sh_audio
!= NULL
, sh_video
!= NULL
, demuxer
->sub
->id
> 0);
3236 demux_flush(demuxer
);
3240 video_stats
= (sh_video
!= NULL
);
3243 mp_msg(MSGT_DEMUX
, MSGL_V
, "IBPS: %d, vb: %d\r\n", sh_video
->i_bps
, priv
->vbitrate
);
3245 video_stats
= priv
->vbitrate
;
3247 video_stats
= sh_video
->i_bps
;
3250 newpos
= (flags
& SEEK_ABSOLUTE
) ? demuxer
->movi_start
: demuxer
->filepos
;
3251 if(flags
& SEEK_FACTOR
) // float seek 0..1
3252 newpos
+=(demuxer
->movi_end
-demuxer
->movi_start
)*rel_seek_secs
;
3256 if(! video_stats
) // unspecified or VBR
3257 newpos
+= 2324*75*rel_seek_secs
; // 174.3 kbyte/sec
3259 newpos
+= video_stats
*rel_seek_secs
;
3263 if(newpos
< demuxer
->movi_start
)
3264 newpos
= demuxer
->movi_start
; //begininng of stream
3266 stream_seek(demuxer
->stream
, newpos
);
3267 for(i
= 0; i
< 8192; i
++)
3268 if(priv
->ts
.pids
[i
] != NULL
)
3269 priv
->ts
.pids
[i
]->is_synced
= 0;
3271 videobuf_code_len
= 0;
3273 if(sh_video
!= NULL
)
3274 ds_fill_buffer(d_video
);
3276 if(sh_audio
!= NULL
)
3278 ds_fill_buffer(d_audio
);
3281 while(sh_video
!= NULL
)
3283 if(sh_audio
&& !d_audio
->eof
&& d_video
->pts
&& d_audio
->pts
)
3285 double a_pts
=d_audio
->pts
;
3286 a_pts
+=(ds_tell_pts(d_audio
)-sh_audio
->a_in_buffer_len
)/(double)sh_audio
->i_bps
;
3287 if(d_video
->pts
> a_pts
)
3289 skip_audio_frame(sh_audio
); // sync audio
3295 i
= sync_video_packet(d_video
);
3296 if((sh_video
->format
== VIDEO_MPEG1
) || (sh_video
->format
== VIDEO_MPEG2
))
3298 if(i
==0x1B3 || i
==0x1B8) break; // found it!
3300 else if((sh_video
->format
== VIDEO_MPEG4
) && (i
==0x1B6))
3302 else if(sh_video
->format
== VIDEO_VC1
&& (i
==0x10E || i
==0x10F))
3306 if((i
& ~0x60) == 0x105 || (i
& ~0x60) == 0x107) break;
3309 if(!i
|| !skip_video_packet(d_video
)) break; // EOF?
3314 static int demux_ts_fill_buffer(demuxer_t
* demuxer
, demux_stream_t
*ds
)
3317 ts_priv_t
*priv
= (ts_priv_t
*)demuxer
->priv
;
3319 return -ts_parse(demuxer
, &es
, priv
->packet
, 0);
3323 static int ts_check_file_dmx(demuxer_t
*demuxer
)
3325 return ts_check_file(demuxer
) ? DEMUXER_TYPE_MPEG_TS
: 0;
3328 static int is_usable_program(ts_priv_t
*priv
, pmt_t
*pmt
)
3332 for(j
= 0; j
< pmt
->es_cnt
; j
++)
3334 if(priv
->ts
.pids
[pmt
->es
[j
].pid
] == NULL
|| priv
->ts
.streams
[pmt
->es
[j
].pid
].sh
== NULL
)
3337 priv
->ts
.streams
[pmt
->es
[j
].pid
].type
== TYPE_VIDEO
||
3338 priv
->ts
.streams
[pmt
->es
[j
].pid
].type
== TYPE_AUDIO
3346 static int demux_ts_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
3348 ts_priv_t
* priv
= (ts_priv_t
*)demuxer
->priv
;
3352 case DEMUXER_CTRL_SWITCH_AUDIO
:
3353 case DEMUXER_CTRL_SWITCH_VIDEO
:
3357 int reftype
, areset
= 0, vreset
= 0;
3360 if(cmd
== DEMUXER_CTRL_SWITCH_VIDEO
)
3362 reftype
= TYPE_VIDEO
;
3363 ds
= demuxer
->video
;
3368 reftype
= TYPE_AUDIO
;
3369 ds
= demuxer
->audio
;
3375 reset_fifos(demuxer
, areset
, vreset
, 0);
3379 *((int*)arg
) = ds
->id
;
3380 return DEMUXER_CTRL_OK
;
3385 for(i
= 0; i
< 8192; i
++)
3387 if(priv
->ts
.streams
[i
].id
== ds
->id
&& priv
->ts
.streams
[i
].type
== reftype
)
3394 if(priv
->ts
.streams
[i
].type
== reftype
)
3396 if(priv
->ts
.streams
[i
].id
== ds
->id
) //we made a complete loop
3398 sh
= priv
->ts
.streams
[i
].sh
;
3402 else //audio track <n>
3404 if (n
>= 8192 || priv
->ts
.streams
[n
].type
!= reftype
) return DEMUXER_CTRL_NOTIMPL
;
3406 sh
= priv
->ts
.streams
[i
].sh
;
3411 if(ds
->id
!= priv
->ts
.streams
[i
].id
)
3412 reset_fifos(demuxer
, areset
, vreset
, 0);
3413 ds
->id
= priv
->ts
.streams
[i
].id
;
3416 mp_msg(MSGT_DEMUX
, MSGL_V
, "\r\ndemux_ts, switched to audio pid %d, id: %d, sh: %p\r\n", i
, ds
->id
, sh
);
3419 *((int*)arg
) = ds
->id
;
3420 return DEMUXER_CTRL_OK
;
3423 case DEMUXER_CTRL_IDENTIFY_PROGRAM
: //returns in prog->{aid,vid} the new ids that comprise a program
3426 int vid_done
=0, aid_done
=0;
3428 demux_program_t
*prog
= arg
;
3430 if(priv
->pmt_cnt
< 2)
3431 return DEMUXER_CTRL_NOTIMPL
;
3433 if(prog
->progid
== -1)
3435 int cur_pmt_idx
= 0;
3437 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
3438 if(priv
->pmt
[i
].progid
== priv
->prog
)
3444 i
= (cur_pmt_idx
+ 1) % priv
->pmt_cnt
;
3445 while(i
!= cur_pmt_idx
)
3447 pmt
= &priv
->pmt
[i
];
3448 cnt
= is_usable_program(priv
, pmt
);
3451 i
= (i
+ 1) % priv
->pmt_cnt
;
3456 for(i
= 0; i
< priv
->pmt_cnt
; i
++)
3457 if(priv
->pmt
[i
].progid
== prog
->progid
)
3459 pmt
= &priv
->pmt
[i
]; //required program
3460 cnt
= is_usable_program(priv
, pmt
);
3465 return DEMUXER_CTRL_NOTIMPL
;
3468 prog
->aid
= prog
->vid
= -2; //no audio and no video by default
3469 for(j
= 0; j
< pmt
->es_cnt
; j
++)
3471 if(priv
->ts
.pids
[pmt
->es
[j
].pid
] == NULL
|| priv
->ts
.streams
[pmt
->es
[j
].pid
].sh
== NULL
)
3474 if(!vid_done
&& priv
->ts
.streams
[pmt
->es
[j
].pid
].type
== TYPE_VIDEO
)
3477 prog
->vid
= pmt
->es
[j
].pid
;
3479 else if(!aid_done
&& priv
->ts
.streams
[pmt
->es
[j
].pid
].type
== TYPE_AUDIO
)
3482 prog
->aid
= pmt
->es
[j
].pid
;
3486 priv
->prog
= prog
->progid
= pmt
->progid
;
3487 return DEMUXER_CTRL_OK
;
3491 return DEMUXER_CTRL_NOTIMPL
;
3496 const demuxer_desc_t demuxer_desc_mpeg_ts
= {
3502 DEMUXER_TYPE_MPEG_TS
,
3503 0, // unsafe autodetect
3505 demux_ts_fill_buffer
,