?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use MSGT_DECVIDEO in a video decoder.
[mplayer/glamo.git] / libmpdemux / demux_ts.c
blob0a79dcded5ee9e4365d1b3e87e5c06792b071291
1 /*
2 * Demultiplexer for MPEG2 Transport Streams.
3 *
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
7 *
8 * This file is part of MPlayer.
9 *
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.
14 *
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.
19 *
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.
23 */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "config.h"
30 #include "mp_msg.h"
31 #include "help_mp.h"
32
33 #include "stream/stream.h"
34 #include "demuxer.h"
35 #include "parse_es.h"
36 #include "stheader.h"
37 #include "ms_hdr.h"
38 #include "mpeg_hdr.h"
39 #include "demux_ts.h"
40
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
45
46 #define MAX_HEADER_SIZE 6 /* enough for PES header + length */
47 #define MAX_CHECK_SIZE 65535
48 #define TS_MAX_PROBE_SIZE 2000000 /* do not forget to change this in cfg-common-opts.h, too */
49 #define NUM_CONSECUTIVE_TS_PACKETS 32
50 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348
51 #define MAX_A52_FRAME_SIZE 3840
52
53 #ifndef SIZE_MAX
54 #define SIZE_MAX ((size_t)-1)
55 #endif
56
57 #define TYPE_AUDIO 1
58 #define TYPE_VIDEO 2
59
60 int ts_prog;
61 int ts_keep_broken=0;
62 off_t ts_probe = 0;
63 int audio_substream_id = -1;
64 extern char *dvdsub_lang, *audio_lang; //for -alang
65
66 typedef enum
67 {
68 UNKNOWN = -1,
69 VIDEO_MPEG1 = 0x10000001,
70 VIDEO_MPEG2 = 0x10000002,
71 VIDEO_MPEG4 = 0x10000004,
72 VIDEO_H264 = 0x10000005,
73 VIDEO_AVC = mmioFOURCC('a', 'v', 'c', '1'),
74 VIDEO_VC1 = mmioFOURCC('W', 'V', 'C', '1'),
75 AUDIO_MP2 = 0x50,
76 AUDIO_A52 = 0x2000,
77 AUDIO_DTS = 0x2001,
78 AUDIO_LPCM_BE = 0x10001,
79 AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'),
80 AUDIO_TRUEHD = mmioFOURCC('T', 'R', 'H', 'D'),
81 SPU_DVD = 0x3000000,
82 SPU_DVB = 0x3000001,
83 SPU_TELETEXT = 0x3000002,
84 PES_PRIVATE1 = 0xBD00000,
85 SL_PES_STREAM = 0xD000000,
86 SL_SECTION = 0xD100000,
87 MP4_OD = 0xD200000,
88 } es_stream_type_t;
89
90 typedef struct {
91 uint8_t *buffer;
92 uint16_t buffer_len;
93 } ts_section_t;
94
95 typedef struct {
96 int size;
97 unsigned char *start;
98 uint16_t payload_size;
99 es_stream_type_t type, subtype;
100 double pts, last_pts;
101 int pid;
102 char lang[4];
103 int last_cc; // last cc code (-1 if first packet)
104 int is_synced;
105 ts_section_t section;
106 uint8_t *extradata;
107 int extradata_alloc, extradata_len;
108 struct {
109 uint8_t au_start, au_end, last_au_end;
110 } sl;
111 } ES_stream_t;
112
113 typedef struct {
114 void *sh;
115 int id;
116 int type;
117 } sh_av_t;
118
119 typedef struct MpegTSContext {
120 int packet_size; // raw packet size, including FEC if present e.g. 188 bytes
121 ES_stream_t *pids[NB_PID_MAX];
122 sh_av_t streams[NB_PID_MAX];
123 } MpegTSContext;
124
125
126 typedef struct {
127 demux_stream_t *ds;
128 demux_packet_t *pack;
129 int offset, buffer_size;
130 } av_fifo_t;
131
132 #define MAX_EXTRADATA_SIZE 64*1024
133 typedef struct {
134 int32_t object_type; //aka codec used
135 int32_t stream_type; //video, audio etc.
136 uint8_t buf[MAX_EXTRADATA_SIZE];
137 uint16_t buf_size;
138 uint8_t szm1;
139 } mp4_decoder_config_t;
140
141 typedef struct {
142 //flags
143 uint8_t flags;
144 uint8_t au_start;
145 uint8_t au_end;
146 uint8_t random_accesspoint;
147 uint8_t random_accesspoint_only;
148 uint8_t padding;
149 uint8_t use_ts;
150 uint8_t idle;
151 uint8_t duration;
152
153 uint32_t ts_resolution, ocr_resolution;
154 uint8_t ts_len, ocr_len, au_len, instant_bitrate_len, degr_len, au_seqnum_len, packet_seqnum_len;
155 uint32_t timescale;
156 uint16_t au_duration, cts_duration;
157 uint64_t ocr, dts, cts;
158 } mp4_sl_config_t;
159
160 typedef struct {
161 uint16_t id;
162 uint8_t flags;
163 mp4_decoder_config_t decoder;
164 mp4_sl_config_t sl;
165 } mp4_es_descr_t;
166
167 typedef struct {
168 uint16_t id;
169 uint8_t flags;
170 mp4_es_descr_t *es;
171 uint16_t es_cnt;
172 } mp4_od_t;
173
174 typedef struct {
175 uint8_t skip;
176 uint8_t table_id;
177 uint8_t ssi;
178 uint16_t section_length;
179 uint16_t ts_id;
180 uint8_t version_number;
181 uint8_t curr_next;
182 uint8_t section_number;
183 uint8_t last_section_number;
184 struct pat_progs_t {
185 uint16_t id;
186 uint16_t pmt_pid;
187 } *progs;
188 uint16_t progs_cnt;
189 ts_section_t section;
190 } pat_t;
191
192 typedef struct {
193 uint16_t progid;
194 uint8_t skip;
195 uint8_t table_id;
196 uint8_t ssi;
197 uint16_t section_length;
198 uint8_t version_number;
199 uint8_t curr_next;
200 uint8_t section_number;
201 uint8_t last_section_number;
202 uint16_t PCR_PID;
203 uint16_t prog_descr_length;
204 ts_section_t section;
205 uint16_t es_cnt;
206 struct pmt_es_t {
207 uint16_t pid;
208 uint32_t type; //it's 8 bit long, but cast to the right type as FOURCC
209 uint16_t descr_length;
210 uint8_t format_descriptor[5];
211 uint8_t lang[4];
212 uint16_t mp4_es_id;
213 } *es;
214 mp4_od_t iod, *od;
215 mp4_es_descr_t *mp4es;
216 int od_cnt, mp4es_cnt;
217 } pmt_t;
218
219 typedef struct {
220 uint64_t size;
221 float duration;
222 double first_pts;
223 double last_pts;
224 } TS_stream_info;
225
226 typedef struct {
227 MpegTSContext ts;
228 int last_pid;
229 av_fifo_t fifo[3]; //0 for audio, 1 for video, 2 for subs
230 pat_t pat;
231 pmt_t *pmt;
232 uint16_t pmt_cnt;
233 uint32_t prog;
234 uint32_t vbitrate;
235 int keep_broken;
236 int last_aid;
237 int last_vid;
238 char packet[TS_FEC_PACKET_SIZE];
239 TS_stream_info vstr, astr;
240 } ts_priv_t;
241
242
243 typedef struct {
244 es_stream_type_t type;
245 ts_section_t section;
246 } TS_pids_t;
247
248
249 #define IS_AUDIO(x) (((x) == AUDIO_MP2) || ((x) == AUDIO_A52) || ((x) == AUDIO_LPCM_BE) || ((x) == AUDIO_AAC) || ((x) == AUDIO_DTS) || ((x) == AUDIO_TRUEHD))
250 #define IS_VIDEO(x) (((x) == VIDEO_MPEG1) || ((x) == VIDEO_MPEG2) || ((x) == VIDEO_MPEG4) || ((x) == VIDEO_H264) || ((x) == VIDEO_AVC) || ((x) == VIDEO_VC1))
251 #define IS_SUB(x) (((x) == SPU_DVD) || ((x) == SPU_DVB) || ((x) == SPU_TELETEXT))
252
253 static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe);
254
255 static uint8_t get_packet_size(const unsigned char *buf, int size)
256 {
257 int i;
258
259 if (size < (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS))
260 return 0;
261
262 for(i=0; i<NUM_CONSECUTIVE_TS_PACKETS; i++)
263 {
264 if (buf[i * TS_PACKET_SIZE] != 0x47)
265 {
266 mp_msg(MSGT_DEMUX, MSGL_DBG2, "GET_PACKET_SIZE, pos %d, char: %2x\n", i, buf[i * TS_PACKET_SIZE]);
267 goto try_fec;
268 }
269 }
270 return TS_PACKET_SIZE;
271
272 try_fec:
273 for(i=0; i<NUM_CONSECUTIVE_TS_PACKETS; i++)
274 {
275 if (buf[i * TS_FEC_PACKET_SIZE] != 0x47){
276 mp_msg(MSGT_DEMUX, MSGL_DBG2, "GET_PACKET_SIZE, pos %d, char: %2x\n", i, buf[i * TS_PACKET_SIZE]);
277 goto try_philips;
278 }
279 }
280 return TS_FEC_PACKET_SIZE;
281
282 try_philips:
283 for(i=0; i<NUM_CONSECUTIVE_TS_PACKETS; i++)
284 {
285 if (buf[i * TS_PH_PACKET_SIZE] != 0x47)
286 return 0;
287 }
288 return TS_PH_PACKET_SIZE;
289 }
290
291 static int parse_avc_sps(uint8_t *buf, int len, int *w, int *h);
292 static inline uint8_t *pid_lang_from_pmt(ts_priv_t *priv, int pid);
293
294 static void ts_add_stream(demuxer_t * demuxer, ES_stream_t *es)
295 {
296 int i;
297 ts_priv_t *priv = (ts_priv_t*) demuxer->priv;
298
299 if(priv->ts.streams[es->pid].sh)
300 return;
301
302 if((IS_AUDIO(es->type) || IS_AUDIO(es->subtype)) && priv->last_aid+1 < MAX_A_STREAMS)
303 {
304 sh_audio_t *sh = new_sh_audio_aid(demuxer, priv->last_aid, es->pid);
305 if(sh)
306 {
307 const char *lang = pid_lang_from_pmt(priv, es->pid);
308 sh->needs_parsing = 1;
309 sh->format = IS_AUDIO(es->type) ? es->type : es->subtype;
310 sh->ds = demuxer->audio;
311
312 priv->ts.streams[es->pid].id = priv->last_aid;
313 priv->ts.streams[es->pid].sh = sh;
314 priv->ts.streams[es->pid].type = TYPE_AUDIO;
315 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 if (lang && lang[0])
317 mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_AID_%d_LANG=%s\n", es->pid, lang);
318 priv->last_aid++;
319 }
320
321 if(es->extradata && es->extradata_len)
322 {
323 sh->wf = malloc(sizeof (WAVEFORMATEX) + es->extradata_len);
324 sh->wf->cbSize = es->extradata_len;
325 memcpy(sh->wf + 1, es->extradata, es->extradata_len);
326 }
327 }
328
329 if((IS_VIDEO(es->type) || IS_VIDEO(es->subtype)) && priv->last_vid+1 < MAX_V_STREAMS)
330 {
331 sh_video_t *sh = new_sh_video_vid(demuxer, priv->last_vid, es->pid);
332 if(sh)
333 {
334 sh->format = IS_VIDEO(es->type) ? es->type : es->subtype;
335 sh->ds = demuxer->video;
336
337 priv->ts.streams[es->pid].id = priv->last_vid;
338 priv->ts.streams[es->pid].sh = sh;
339 priv->ts.streams[es->pid].type = TYPE_VIDEO;
340 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);
341 priv->last_vid++;
342
343
344 if(sh->format == VIDEO_AVC && es->extradata && es->extradata_len)
345 {
346 int w = 0, h = 0;
347 sh->bih = calloc(1, sizeof(BITMAPINFOHEADER) + es->extradata_len);
348 sh->bih->biSize= sizeof(BITMAPINFOHEADER) + es->extradata_len;
349 sh->bih->biCompression = sh->format;
350 memcpy(sh->bih + 1, es->extradata, es->extradata_len);
351 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "EXTRADATA(%d BYTES): \n", es->extradata_len);
352 for(i = 0;i < es->extradata_len; i++)
353 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "%02x ", (int) es->extradata[i]);
354 mp_msg(MSGT_DEMUXER,MSGL_DBG2,"\n");
355 if(parse_avc_sps(es->extradata, es->extradata_len, &w, &h))
356 {
357 sh->bih->biWidth = w;
358 sh->bih->biHeight = h;
359 }
360 }
361 }
362 }
363 }
364
365 static int ts_check_file(demuxer_t * demuxer)
366 {
367 const int buf_size = (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS);
368 unsigned char buf[TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS], done = 0, *ptr;
369 uint32_t _read, i, count = 0, is_ts;
370 int cc[NB_PID_MAX], last_cc[NB_PID_MAX], pid, cc_ok, c, good, bad;
371 uint8_t size = 0;
372 off_t pos = 0;
373 off_t init_pos;
374
375 mp_msg(MSGT_DEMUX, MSGL_V, "Checking for MPEG-TS...\n");
376
377 init_pos = stream_tell(demuxer->stream);
378 is_ts = 0;
379 while(! done)
380 {
381 i = 1;
382 c = 0;
383
384 while(((c=stream_read_char(demuxer->stream)) != 0x47)
385 && (c >= 0)
386 && (i < MAX_CHECK_SIZE)
387 && ! demuxer->stream->eof
388 ) i++;
389
390
391 if(c != 0x47)
392 {
393 mp_msg(MSGT_DEMUX, MSGL_V, "THIS DOESN'T LOOK LIKE AN MPEG-TS FILE!\n");
394 is_ts = 0;
395 done = 1;
396 continue;
397 }
398
399 pos = stream_tell(demuxer->stream) - 1;
400 buf[0] = c;
401 _read = stream_read(demuxer->stream, &buf[1], buf_size-1);
402
403 if(_read < buf_size-1)
404 {
405 mp_msg(MSGT_DEMUX, MSGL_V, "COULDN'T READ ENOUGH DATA, EXITING TS_CHECK\n");
406 stream_reset(demuxer->stream);
407 return 0;
408 }
409
410 size = get_packet_size(buf, buf_size);
411 if(size)
412 {
413 done = 1;
414 is_ts = 1;
415 }
416
417 if(pos - init_pos >= MAX_CHECK_SIZE)
418 {
419 done = 1;
420 is_ts = 0;
421 }
422 }
423
424 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);
425 stream_seek(demuxer->stream, pos);
426
427 if(! is_ts)
428 return 0;
429
430 //LET'S CHECK continuity counters
431 good = bad = 0;
432 for(count = 0; count < NB_PID_MAX; count++)
433 {
434 cc[count] = last_cc[count] = -1;
435 }
436
437 for(count = 0; count < NUM_CONSECUTIVE_TS_PACKETS; count++)
438 {
439 ptr = &(buf[size * count]);
440 pid = ((ptr[1] & 0x1f) << 8) | ptr[2];
441 mp_msg(MSGT_DEMUX, MSGL_DBG2, "BUF: %02x %02x %02x %02x, PID %d, SIZE: %d \n",
442 ptr[0], ptr[1], ptr[2], ptr[3], pid, size);
443
444 if((pid == 8191) || (pid < 16))
445 continue;
446
447 cc[pid] = (ptr[3] & 0xf);
448 cc_ok = (last_cc[pid] < 0) || ((((last_cc[pid] + 1) & 0x0f) == cc[pid]));
449 mp_msg(MSGT_DEMUX, MSGL_DBG2, "PID %d, COMPARE CC %d AND LAST_CC %d\n", pid, cc[pid], last_cc[pid]);
450 if(! cc_ok)
451 //return 0;
452 bad++;
453 else
454 good++;
455
456 last_cc[pid] = cc[pid];
457 }
458
459 mp_msg(MSGT_DEMUX, MSGL_V, "GOOD CC: %d, BAD CC: %d\n", good, bad);
460
461 if(good >= bad)
462 return size;
463 else
464 return 0;
465 }
466
467
468 static inline int32_t progid_idx_in_pmt(ts_priv_t *priv, uint16_t progid)
469 {
470 int x;
471
472 if(priv->pmt == NULL)
473 return -1;
474
475 for(x = 0; x < priv->pmt_cnt; x++)
476 {
477 if(priv->pmt[x].progid == progid)
478 return x;
479 }
480
481 return -1;
482 }
483
484
485 static inline int32_t progid_for_pid(ts_priv_t *priv, int pid, int32_t req) //finds the first program listing a pid
486 {
487 int i, j;
488 pmt_t *pmt;
489
490
491 if(priv->pmt == NULL)
492 return -1;
493
494
495 for(i=0; i < priv->pmt_cnt; i++)
496 {
497 pmt = &(priv->pmt[i]);
498
499 if(pmt->es == NULL)
500 return -1;
501
502 for(j = 0; j < pmt->es_cnt; j++)
503 {
504 if(pmt->es[j].pid == pid)
505 {
506 if((req == 0) || (req == pmt->progid))
507 return pmt->progid;
508 }
509 }
510
511 }
512 return -1;
513 }
514
515 static inline int32_t prog_pcr_pid(ts_priv_t *priv, int progid)
516 {
517 int i;
518
519 if(priv->pmt == NULL)
520 return -1;
521 for(i=0; i < priv->pmt_cnt; i++)
522 {
523 if(priv->pmt[i].progid == progid)
524 return priv->pmt[i].PCR_PID;
525 }
526 return -1;
527 }
528
529
530 static inline int pid_match_lang(ts_priv_t *priv, uint16_t pid, char *lang)
531 {
532 uint16_t i, j;
533 pmt_t *pmt;
534
535 if(priv->pmt == NULL)
536 return -1;
537
538 for(i=0; i < priv->pmt_cnt; i++)
539 {
540 pmt = &(priv->pmt[i]);
541
542 if(pmt->es == NULL)
543 return -1;
544
545 for(j = 0; j < pmt->es_cnt; j++)
546 {
547 if(pmt->es[j].pid != pid)
548 continue;
549
550 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);
551 if(strncmp(pmt->es[j].lang, lang, 3) == 0)
552 {
553 return 1;
554 }
555 }
556
557 }
558
559 return -1;
560 }
561
562 typedef struct {
563 int32_t atype, vtype, stype; //types
564 int32_t apid, vpid, spid; //stream ids
565 char slang[4], alang[4]; //languages
566 uint16_t prog;
567 off_t probe;
568 } tsdemux_init_t;
569
570 //stripped down version of a52_syncinfo() from liba52
571 //copyright belongs to Michel Lespinasse <walken@zoy.org> and Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
572 int mp_a52_framesize(uint8_t * buf, int *srate)
573 {
574 int rate[] = { 32, 40, 48, 56, 64, 80, 96, 112,
575 128, 160, 192, 224, 256, 320, 384, 448,
576 512, 576, 640
577 };
578 uint8_t halfrate[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
579 int frmsizecod, bitrate, half;
580
581 if((buf[0] != 0x0b) || (buf[1] != 0x77)) /* syncword */
582 return 0;
583
584 if(buf[5] >= 0x60) /* bsid >= 12 */
585 return 0;
586
587 half = halfrate[buf[5] >> 3];
588
589 frmsizecod = buf[4] & 63;
590 if(frmsizecod >= 38)
591 return 0;
592
593 bitrate = rate[frmsizecod >> 1];
594
595 switch(buf[4] & 0xc0)
596 {
597 case 0: /* 48 KHz */
598 *srate = 48000 >> half;
599 return 4 * bitrate;
600 case 0x40: /* 44.1 KHz */
601 *srate = 44100 >> half;
602 return 2 * (320 * bitrate / 147 + (frmsizecod & 1));
603 case 0x80: /* 32 KHz */
604 *srate = 32000 >> half;
605 return 6 * bitrate;
606 }
607
608 return 0;
609 }
610
611 //second stage: returns the count of A52 syncwords found
612 static int a52_check(char *buf, int len)
613 {
614 int cnt, frame_length, ok, srate;
615
616 cnt = ok = 0;
617 if(len < 8)
618 return 0;
619
620 while(cnt < len - 7)
621 {
622 if(buf[cnt] == 0x0B && buf[cnt+1] == 0x77)
623 {
624 frame_length = mp_a52_framesize(&buf[cnt], &srate);
625 if(frame_length>=7 && frame_length<=3840)
626 {
627 cnt += frame_length;
628 ok++;
629 }
630 else
631 cnt++;
632 }
633 else
634 cnt++;
635 }
636
637 mp_msg(MSGT_DEMUXER, MSGL_V, "A52_CHECK(%d input bytes), found %d frame syncwords of %d bytes length\n", len, ok, frame_length);
638 return ok;
639 }
640
641
642 static off_t ts_detect_streams(demuxer_t *demuxer, tsdemux_init_t *param)
643 {
644 int video_found = 0, audio_found = 0, sub_found = 0, i, num_packets = 0, req_apid, req_vpid, req_spid;
645 int is_audio, is_video, is_sub, has_tables;
646 int32_t p, chosen_pid = 0;
647 off_t pos=0, ret = 0, init_pos, end_pos;
648 ES_stream_t es;
649 unsigned char tmp[TS_FEC_PACKET_SIZE];
650 ts_priv_t *priv = (ts_priv_t*) demuxer->priv;
651 struct {
652 char *buf;
653 int pos;
654 } pes_priv1[8192], *pptr;
655 char *tmpbuf;
656
657 priv->last_pid = 8192; //invalid pid
658
659 req_apid = param->apid;
660 req_vpid = param->vpid;
661 req_spid = param->spid;
662
663 has_tables = 0;
664 memset(pes_priv1, 0, sizeof(pes_priv1));
665 init_pos = stream_tell(demuxer->stream);
666 mp_msg(MSGT_DEMUXER, MSGL_V, "PROBING UP TO %"PRIu64", PROG: %d\n", (uint64_t) param->probe, param->prog);
667 end_pos = init_pos + (param->probe ? param->probe : TS_MAX_PROBE_SIZE);
668 while(1)
669 {
670 pos = stream_tell(demuxer->stream);
671 if(pos > end_pos || demuxer->stream->eof)
672 break;
673
674 if(ts_parse(demuxer, &es, tmp, 1))
675 {
676 //Non PES-aligned A52 audio may escape detection if PMT is not present;
677 //in this case we try to find at least 3 A52 syncwords
678 if((es.type == PES_PRIVATE1) && (! audio_found) && req_apid > -2)
679 {
680 pptr = &pes_priv1[es.pid];
681 if(pptr->pos < 64*1024)
682 {
683 tmpbuf = realloc(pptr->buf, pptr->pos + es.size);
684 if(tmpbuf != NULL)
685 {
686 pptr->buf = tmpbuf;
687 memcpy(&(pptr->buf[ pptr->pos ]), es.start, es.size);
688 pptr->pos += es.size;
689 if(a52_check(pptr->buf, pptr->pos) > 2)
690 {
691 param->atype = AUDIO_A52;
692 param->apid = es.pid;
693 es.type = AUDIO_A52;
694 }
695 }
696 }
697 }
698
699 is_audio = IS_AUDIO(es.type) || ((es.type==SL_PES_STREAM) && IS_AUDIO(es.subtype));
700 is_video = IS_VIDEO(es.type) || ((es.type==SL_PES_STREAM) && IS_VIDEO(es.subtype));
701 is_sub = IS_SUB(es.type);
702
703
704 if((! is_audio) && (! is_video) && (! is_sub))
705 continue;
706 if(is_audio && req_apid==-2)
707 continue;
708
709 if(is_video)
710 {
711 chosen_pid = (req_vpid == es.pid);
712 if((! chosen_pid) && (req_vpid > 0))
713 continue;
714 }
715 else if(is_audio)
716 {
717 if(req_apid > 0)
718 {
719 chosen_pid = (req_apid == es.pid);
720 if(! chosen_pid)
721 continue;
722 }
723 else if(param->alang[0] > 0 && es.lang[0] > 0)
724 {
725 if(pid_match_lang(priv, es.pid, param->alang) == -1)
726 continue;
727
728 chosen_pid = 1;
729 param->apid = req_apid = es.pid;
730 }
731 }
732 else if(is_sub)
733 {
734 mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_SUBTITLE_ID=%d\n", es.pid);
735 if (es.lang[0] > 0)
736 mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_SID_%d_LANG=%s\n", es.pid, es.lang);
737 chosen_pid = (req_spid == es.pid);
738 if((! chosen_pid) && (req_spid > 0))
739 continue;
740 }
741
742 if(req_apid < 0 && (param->alang[0] == 0) && req_vpid < 0 && req_spid < 0)
743 chosen_pid = 1;
744
745 if((ret == 0) && chosen_pid)
746 {
747 ret = stream_tell(demuxer->stream);
748 }
749
750 p = progid_for_pid(priv, es.pid, param->prog);
751 if(p != -1)
752 {
753 has_tables++;
754 if(!param->prog && chosen_pid)
755 param->prog = p;
756 }
757
758 if((param->prog > 0) && (param->prog != p))
759 {
760 if(audio_found)
761 {
762 if(is_video && (req_vpid == es.pid))
763 {
764 param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype;
765 param->vpid = es.pid;
766 video_found = 1;
767 break;
768 }
769 }
770
771 if(video_found)
772 {
773 if(is_audio && (req_apid == es.pid))
774 {
775 param->atype = IS_AUDIO(es.type) ? es.type : es.subtype;
776 param->apid = es.pid;
777 audio_found = 1;
778 break;
779 }
780 }
781
782
783 continue;
784 }
785
786
787 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, param->prog);
788
789
790 if(is_video)
791 {
792 if((req_vpid == -1) || (req_vpid == es.pid))
793 {
794 param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype;
795 param->vpid = es.pid;
796 video_found = 1;
797 }
798 }
799
800
801 if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found && !param->probe)
802 {
803 //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only)
804 param->vtype = 0;
805 break;
806 }
807
808 if(is_sub)
809 {
810 if((req_spid == -1) || (req_spid == es.pid))
811 {
812 param->stype = es.type;
813 param->spid = es.pid;
814 sub_found = 1;
815 }
816 }
817
818 if(is_audio)
819 {
820 if((req_apid == -1) || (req_apid == es.pid))
821 {
822 param->atype = IS_AUDIO(es.type) ? es.type : es.subtype;
823 param->apid = es.pid;
824 audio_found = 1;
825 }
826 }
827
828 if(audio_found && (param->apid == es.pid) && (! video_found))
829 num_packets++;
830
831 if((has_tables==0) && (video_found && audio_found) && (pos >= 1000000))
832 break;
833 }
834 }
835
836 for(i=0; i<8192; i++)
837 {
838 if(pes_priv1[i].buf != NULL)
839 {
840 free(pes_priv1[i].buf);
841 pes_priv1[i].buf = NULL;
842 pes_priv1[i].pos = 0;
843 }
844 }
845
846 if(video_found)
847 {
848 if(param->vtype == VIDEO_MPEG1)
849 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG1(pid=%d) ", param->vpid);
850 else if(param->vtype == VIDEO_MPEG2)
851 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG2(pid=%d) ", param->vpid);
852 else if(param->vtype == VIDEO_MPEG4)
853 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG4(pid=%d) ", param->vpid);
854 else if(param->vtype == VIDEO_H264)
855 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO H264(pid=%d) ", param->vpid);
856 else if(param->vtype == VIDEO_VC1)
857 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO VC1(pid=%d) ", param->vpid);
858 else if(param->vtype == VIDEO_AVC)
859 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO AVC(NAL-H264, pid=%d) ", param->vpid);
860 }
861 else
862 {
863 param->vtype = UNKNOWN;
864 //WE DIDN'T MATCH ANY VIDEO STREAM
865 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! ");
866 }
867
868 if(param->atype == AUDIO_MP2)
869 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MPA(pid=%d)", param->apid);
870 else if(param->atype == AUDIO_A52)
871 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", param->apid);
872 else if(param->atype == AUDIO_DTS)
873 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO DTS(pid=%d)", param->apid);
874 else if(param->atype == AUDIO_LPCM_BE)
875 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", param->apid);
876 else if(param->atype == AUDIO_AAC)
877 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", param->apid);
878 else if(param->atype == AUDIO_TRUEHD)
879 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO TRUEHD(pid=%d)", param->apid);
880 else
881 {
882 audio_found = 0;
883 param->atype = UNKNOWN;
884 //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO
885 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO AUDIO! ");
886 }
887
888 if(IS_SUB(param->stype))
889 mp_msg(MSGT_DEMUXER, MSGL_INFO, " SUB %s(pid=%d) ", (param->stype==SPU_DVD ? "DVD" : param->stype==SPU_DVB ? "DVB" : "Teletext"), param->spid);
890 else
891 {
892 param->stype = UNKNOWN;
893 mp_msg(MSGT_DEMUXER, MSGL_INFO, " NO SUBS (yet)! ");
894 }
895
896 if(video_found || audio_found)
897 {
898 if(!param->prog)
899 {
900 p = progid_for_pid(priv, video_found ? param->vpid : param->apid, 0);
901 if(p != -1)
902 param->prog = p;
903 }
904
905 if(demuxer->stream->eof && (ret == 0))
906 ret = init_pos;
907 mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", param->prog);
908 }
909 else
910 mp_msg(MSGT_DEMUXER, MSGL_INFO, "\n");
911
912
913 for(i=0; i<8192; i++)
914 {
915 if(priv->ts.pids[i] != NULL)
916 {
917 priv->ts.pids[i]->payload_size = 0;
918 priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0;
919 priv->ts.pids[i]->last_cc = -1;
920 priv->ts.pids[i]->is_synced = 0;
921 }
922 }
923
924 return ret;
925 }
926
927 static int parse_avc_sps(uint8_t *buf, int len, int *w, int *h)
928 {
929 int sps, sps_len;
930 unsigned char *ptr;
931 mp_mpeg_header_t picture;
932 if(len < 6)
933 return 0;
934 sps = buf[5] & 0x1f;
935 if(!sps)
936 return 0;
937 sps_len = (buf[6] << 8) | buf[7];
938 if(!sps_len || (sps_len > len - 8))
939 return 0;
940 ptr = &(buf[8]);
941 picture.display_picture_width = picture.display_picture_height = 0;
942 h264_parse_sps(&picture, ptr, len - 8);
943 if(!picture.display_picture_width || !picture.display_picture_height)
944 return 0;
945 *w = picture.display_picture_width;
946 *h = picture.display_picture_height;
947 return 1;
948 }
949
950 static demuxer_t *demux_open_ts(demuxer_t * demuxer)
951 {
952 int i;
953 uint8_t packet_size;
954 sh_video_t *sh_video;
955 sh_audio_t *sh_audio;
956 off_t start_pos;
957 tsdemux_init_t params;
958 ts_priv_t * priv = demuxer->priv;
959
960 mp_msg(MSGT_DEMUX, MSGL_V, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n",
961 demuxer->audio->id, demuxer->video->id, demuxer->sub->id);
962
963
964 demuxer->type= DEMUXER_TYPE_MPEG_TS;
965
966
967 stream_reset(demuxer->stream);
968
969 packet_size = ts_check_file(demuxer);
970 if(!packet_size)
971 return NULL;
972
973 priv = calloc(1, sizeof(ts_priv_t));
974 if(priv == NULL)
975 {
976 mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n");
977 return NULL;
978 }
979
980 for(i=0; i < 8192; i++)
981 {
982 priv->ts.pids[i] = NULL;
983 priv->ts.streams[i].id = -3;
984 }
985 priv->pat.progs = NULL;
986 priv->pat.progs_cnt = 0;
987 priv->pat.section.buffer = NULL;
988 priv->pat.section.buffer_len = 0;
989
990 priv->pmt = NULL;
991 priv->pmt_cnt = 0;
992
993 priv->keep_broken = ts_keep_broken;
994 priv->ts.packet_size = packet_size;
995
996
997 demuxer->priv = priv;
998 if(demuxer->stream->type != STREAMTYPE_FILE)
999 demuxer->seekable = 1;
1000 else
1001 demuxer->seekable = 1;
1002
1003
1004 params.atype = params.vtype = params.stype = UNKNOWN;
1005 params.apid = demuxer->audio->id;
1006 params.vpid = demuxer->video->id;
1007 params.spid = demuxer->sub->id;
1008 params.prog = ts_prog;
1009 params.probe = ts_probe;
1010
1011 if(dvdsub_lang != NULL)
1012 {
1013 strncpy(params.slang, dvdsub_lang, 3);
1014 params.slang[3] = 0;
1015 }
1016 else
1017 memset(params.slang, 0, 4);
1018
1019 if(audio_lang != NULL)
1020 {
1021 strncpy(params.alang, audio_lang, 3);
1022 params.alang[3] = 0;
1023 }
1024 else
1025 memset(params.alang, 0, 4);
1026
1027 start_pos = ts_detect_streams(demuxer, &params);
1028
1029 demuxer->sub->id = params.spid;
1030 priv->prog = params.prog;
1031
1032 if(params.vtype != UNKNOWN)
1033 {
1034 ts_add_stream(demuxer, priv->ts.pids[params.vpid]);
1035 sh_video = priv->ts.streams[params.vpid].sh;
1036 demuxer->video->id = priv->ts.streams[params.vpid].id;
1037 sh_video->ds = demuxer->video;
1038 sh_video->format = params.vtype;
1039 demuxer->video->sh = sh_video;
1040 }
1041
1042 if(params.atype != UNKNOWN)
1043 {
1044 ES_stream_t *es = priv->ts.pids[params.apid];
1045
1046 if(!IS_AUDIO(es->type) && !IS_AUDIO(es->subtype) && IS_AUDIO(params.atype)) es->subtype = params.atype;
1047 ts_add_stream(demuxer, priv->ts.pids[params.apid]);
1048 sh_audio = priv->ts.streams[params.apid].sh;
1049 demuxer->audio->id = priv->ts.streams[params.apid].id;
1050 sh_audio->ds = demuxer->audio;
1051 sh_audio->format = params.atype;
1052 demuxer->audio->sh = sh_audio;
1053 }
1054
1055
1056 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);
1057
1058
1059 start_pos = (start_pos <= priv->ts.packet_size ? 0 : start_pos - priv->ts.packet_size);
1060 demuxer->movi_start = start_pos;
1061 demuxer->reference_clock = MP_NOPTS_VALUE;
1062 stream_reset(demuxer->stream);
1063 stream_seek(demuxer->stream, start_pos); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES?
1064
1065
1066 priv->last_pid = 8192; //invalid pid
1067
1068 for(i = 0; i < 3; i++)
1069 {
1070 priv->fifo[i].pack = NULL;
1071 priv->fifo[i].offset = 0;
1072 }
1073 priv->fifo[0].ds = demuxer->audio;
1074 priv->fifo[1].ds = demuxer->video;
1075 priv->fifo[2].ds = demuxer->sub;
1076
1077 priv->fifo[0].buffer_size = 1536;
1078 priv->fifo[1].buffer_size = 32767;
1079 priv->fifo[2].buffer_size = 32767;
1080
1081 priv->pat.section.buffer_len = 0;
1082 for(i = 0; i < priv->pmt_cnt; i++)
1083 priv->pmt[i].section.buffer_len = 0;
1084
1085 demuxer->filepos = stream_tell(demuxer->stream);
1086 return demuxer;
1087 }
1088
1089 static void demux_close_ts(demuxer_t * demuxer)
1090 {
1091 uint16_t i;
1092 ts_priv_t *priv = (ts_priv_t*) demuxer->priv;
1093
1094 if(priv)
1095 {
1096 if(priv->pat.section.buffer)
1097 free(priv->pat.section.buffer);
1098 if(priv->pat.progs)
1099 free(priv->pat.progs);
1100
1101 if(priv->pmt)
1102 {
1103 for(i = 0; i < priv->pmt_cnt; i++)
1104 {
1105 if(priv->pmt[i].section.buffer)
1106 free(priv->pmt[i].section.buffer);
1107 if(priv->pmt[i].es)
1108 free(priv->pmt[i].es);
1109 }
1110 free(priv->pmt);
1111 }
1112 free(priv);
1113 }
1114 demuxer->priv=NULL;
1115 }
1116
1117
1118 #define getbits mp_getbits
1119
1120 static int mp4_parse_sl_packet(pmt_t *pmt, uint8_t *buf, uint16_t packet_len, int pid, ES_stream_t *pes_es)
1121 {
1122 int i, n, m, mp4_es_id = -1;
1123 uint64_t v = 0;
1124 uint32_t pl_size = 0;
1125 int deg_flag = 0;
1126 mp4_es_descr_t *es = NULL;
1127 mp4_sl_config_t *sl = NULL;
1128 uint8_t au_start = 0, au_end = 0, rap_flag = 0, ocr_flag = 0, padding = 0, padding_bits = 0, idle = 0;
1129
1130 pes_es->is_synced = 0;
1131 mp_msg(MSGT_DEMUXER,MSGL_V, "mp4_parse_sl_packet, pid: %d, pmt: %pm, packet_len: %d\n", pid, pmt, packet_len);
1132 if(! pmt || !packet_len)
1133 return 0;
1134
1135 for(i = 0; i < pmt->es_cnt; i++)
1136 {
1137 if(pmt->es[i].pid == pid)
1138 mp4_es_id = pmt->es[i].mp4_es_id;
1139 }
1140 if(mp4_es_id < 0)
1141 return -1;
1142
1143 for(i = 0; i < pmt->mp4es_cnt; i++)
1144 {
1145 if(pmt->mp4es[i].id == mp4_es_id)
1146 es = &(pmt->mp4es[i]);
1147 }
1148 if(! es)
1149 return -1;
1150
1151 pes_es->subtype = es->decoder.object_type;
1152
1153 sl = &(es->sl);
1154 if(!sl)
1155 return -1;
1156
1157 //now es is the complete es_descriptor of out mp4 ES stream
1158 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "ID: %d, FLAGS: 0x%x, subtype: %x\n", es->id, sl->flags, pes_es->subtype);
1159
1160 n = 0;
1161 if(sl->au_start)
1162 pes_es->sl.au_start = au_start = getbits(buf, n++, 1);
1163 else
1164 pes_es->sl.au_start = (pes_es->sl.last_au_end ? 1 : 0);
1165 if(sl->au_end)
1166 pes_es->sl.au_end = au_end = getbits(buf, n++, 1);
1167
1168 if(!sl->au_start && !sl->au_end)
1169 {
1170 pes_es->sl.au_start = pes_es->sl.au_end = au_start = au_end = 1;
1171 }
1172 pes_es->sl.last_au_end = pes_es->sl.au_end;
1173
1174
1175 if(sl->ocr_len > 0)
1176 ocr_flag = getbits(buf, n++, 1);
1177 if(sl->idle)
1178 idle = getbits(buf, n++, 1);
1179 if(sl->padding)
1180 padding = getbits(buf, n++, 1);
1181 if(padding)
1182 {
1183 padding_bits = getbits(buf, n, 3);
1184 n += 3;
1185 }
1186
1187 if(idle || (padding && !padding_bits))
1188 {
1189 pes_es->payload_size = 0;
1190 return -1;
1191 }
1192
1193 //(! idle && (!padding || padding_bits != 0)) is true
1194 n += sl->packet_seqnum_len;
1195 if(sl->degr_len)
1196 deg_flag = getbits(buf, n++, 1);
1197 if(deg_flag)
1198 n += sl->degr_len;
1199
1200 if(ocr_flag)
1201 {
1202 n += sl->ocr_len;
1203 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "OCR: %d bits\n", sl->ocr_len);
1204 }
1205
1206 if(packet_len * 8 <= n)
1207 return -1;
1208
1209 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "\nAU_START: %d, AU_END: %d\n", au_start, au_end);
1210 if(au_start)
1211 {
1212 int dts_flag = 0, cts_flag = 0, ib_flag = 0;
1213
1214 if(sl->random_accesspoint)
1215 rap_flag = getbits(buf, n++, 1);
1216
1217 //check commented because it seems it's rarely used, and we need this flag set in case of au_start
1218 //the decoder will eventually discard the payload if it can't decode it
1219 //if(rap_flag || sl->random_accesspoint_only)
1220 pes_es->is_synced = 1;
1221
1222 n += sl->au_seqnum_len;
1223 if(packet_len * 8 <= n+8)
1224 return -1;
1225 if(sl->use_ts)
1226 {
1227 dts_flag = getbits(buf, n++, 1);
1228 cts_flag = getbits(buf, n++, 1);
1229 }
1230 if(sl->instant_bitrate_len)
1231 ib_flag = getbits(buf, n++, 1);
1232 if(packet_len * 8 <= n+8)
1233 return -1;
1234 if(dts_flag && (sl->ts_len > 0))
1235 {
1236 n += sl->ts_len;
1237 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "DTS: %d bits\n", sl->ts_len);
1238 }
1239 if(packet_len * 8 <= n+8)
1240 return -1;
1241 if(cts_flag && (sl->ts_len > 0))
1242 {
1243 int i = 0, m;
1244
1245 while(i < sl->ts_len)
1246 {
1247 m = FFMIN(8, sl->ts_len - i);
1248 v |= getbits(buf, n, m);
1249 if(sl->ts_len - i > 8)
1250 v <<= 8;
1251 i += m;
1252 n += m;
1253 if(packet_len * 8 <= n+8)
1254 return -1;
1255 }
1256
1257 pes_es->pts = (double) v / (double) sl->ts_resolution;
1258 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "CTS: %d bits, value: %"PRIu64"/%d = %.3f\n", sl->ts_len, v, sl->ts_resolution, pes_es->pts);
1259 }
1260
1261
1262 i = 0;
1263 pl_size = 0;
1264 while(i < sl->au_len)
1265 {
1266 m = FFMIN(8, sl->au_len - i);
1267 pl_size |= getbits(buf, n, m);
1268 if(sl->au_len - i > 8)
1269 pl_size <<= 8;
1270 i += m;
1271 n += m;
1272 if(packet_len * 8 <= n+8)
1273 return -1;
1274 }
1275 mp_msg(MSGT_DEMUXER,MSGL_DBG2, "AU_LEN: %u (%d bits)\n", pl_size, sl->au_len);
1276 if(ib_flag)
1277 n += sl->instant_bitrate_len;
1278 }
1279
1280 m = (n+7)/8;
1281 if(0 < pl_size && pl_size < pes_es->payload_size)
1282 pes_es->payload_size = pl_size;
1283
1284 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",
1285 n, m, pes_es->payload_size, pl_size, (int) rap_flag, (int) sl->random_accesspoint_only);
1286
1287 return m;
1288 }
1289
1290 //this function parses the extension fields in the PES header and returns the substream_id, or -1 in case of errors
1291 static int parse_pes_extension_fields(unsigned char *p, int pkt_len)
1292 {
1293 int skip;
1294 unsigned char flags;
1295
1296 if(!(p[7] & 0x1)) //no extension_field
1297 return -1;
1298 skip = 9;
1299 if(p[7] & 0x80)
1300 {
1301 skip += 5;
1302 if(p[7] & 0x40)
1303 skip += 5;
1304 }
1305 if(p[7] & 0x20) //escr_flag
1306 skip += 6;
1307 if(p[7] & 0x10) //es_rate_flag
1308 skip += 3;
1309 if(p[7] & 0x08)//dsm_trick_mode is unsupported, skip
1310 {
1311 skip = 0;//don't let's parse the extension fields
1312 }
1313 if(p[7] & 0x04) //additional_copy_info
1314 skip += 1;
1315 if(p[7] & 0x02) //pes_crc_flag
1316 skip += 2;
1317 if(skip >= pkt_len) //too few bytes
1318 return -1;
1319 flags = p[skip];
1320 skip++;
1321 if(flags & 0x80) //pes_private_data_flag
1322 skip += 16;
1323 if(skip >= pkt_len)
1324 return -1;
1325 if(flags & 0x40) //pack_header_field_flag
1326 {
1327 unsigned char l = p[skip];
1328 skip += l;
1329 }
1330 if(flags & 0x20) //program_packet_sequence_counter
1331 skip += 2;
1332 if(flags & 0x10) //p_std
1333 skip += 2;
1334 if(skip >= pkt_len)
1335 return -1;
1336 if(flags & 0x01) //finally the long desired pes_extension2
1337 {
1338 unsigned char l = p[skip]; //ext2 flag+len
1339 skip++;
1340 if((l == 0x81) && (skip < pkt_len))
1341 {
1342 int ssid = p[skip];
1343 mp_msg(MSGT_IDENTIFY, MSGL_V, "SUBSTREAM_ID=%d (0x%02X)\n", ssid, ssid);
1344 return ssid;
1345 }
1346 }
1347
1348 return -1;
1349 }
1350
1351 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)
1352 {
1353 unsigned char *p;
1354 uint32_t header_len;
1355 int64_t pts;
1356 uint32_t stream_id;
1357 uint32_t pkt_len, pes_is_aligned;
1358
1359 //Here we are always at the start of a PES packet
1360 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%p, %d): \n", buf, (uint32_t) packet_len);
1361
1362 if(packet_len == 0 || packet_len > 184)
1363 {
1364 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2, BUFFER LEN IS TOO SMALL OR TOO BIG: %d EXIT\n", packet_len);
1365 return 0;
1366 }
1367
1368 p = buf;
1369 pkt_len = packet_len;
1370
1371
1372 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: HEADER %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]);
1373 if (p[0] || p[1] || (p[2] != 1))
1374 {
1375 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: error HEADER %02x %02x %02x (should be 0x000001) \n", p[0], p[1], p[2]);
1376 return 0 ;
1377 }
1378
1379 packet_len -= 6;
1380 if(packet_len==0)
1381 {
1382 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: packet too short: %d, exit\n", packet_len);
1383 return 0;
1384 }
1385
1386 es->payload_size = (p[4] << 8 | p[5]);
1387 pes_is_aligned = (p[6] & 4);
1388
1389 stream_id = p[3];
1390
1391
1392 if (p[7] & 0x80)
1393 { /* pts available */
1394 pts = (int64_t)(p[9] & 0x0E) << 29 ;
1395 pts |= p[10] << 22 ;
1396 pts |= (p[11] & 0xFE) << 14 ;
1397 pts |= p[12] << 7 ;
1398 pts |= (p[13] & 0xFE) >> 1 ;
1399
1400 es->pts = pts / 90000.0;
1401 }
1402 else
1403 es->pts = 0.0;
1404
1405
1406 header_len = p[8];
1407
1408
1409 if (header_len + 9 > pkt_len) //9 are the bytes read up to the header_length field
1410 {
1411 mp_msg(MSGT_DEMUX, MSGL_DBG2, "demux_ts: illegal value for PES_header_data_length (0x%02x)\n", header_len);
1412 return 0;
1413 }
1414
1415 if(stream_id==0xfd)
1416 {
1417 int ssid = parse_pes_extension_fields(p, pkt_len);
1418 if((audio_substream_id!=-1) && (ssid != audio_substream_id))
1419 return 0;
1420 if(ssid == 0x72 && type_from_pmt != AUDIO_DTS)
1421 es->type = type_from_pmt = AUDIO_TRUEHD;
1422 }
1423
1424 p += header_len + 9;
1425 packet_len -= header_len + 3;
1426
1427 if(es->payload_size)
1428 es->payload_size -= header_len + 3;
1429
1430
1431 es->is_synced = 1; //only for SL streams we have to make sure it's really true, see below
1432 if (stream_id == 0xbd)
1433 {
1434 mp_msg(MSGT_DEMUX, MSGL_DBG3, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n",
1435 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80);
1436
1437
1438 /*
1439 * we check the descriptor tag first because some stations
1440 * do not include any of the A52 header info in their audio tracks
1441 * these "raw" streams may begin with a byte that looks like a stream type.
1442 */
1443
1444
1445 if(
1446 (type_from_pmt == AUDIO_A52) || /* A52 - raw */
1447 (p[0] == 0x0B && p[1] == 0x77) /* A52 - syncword */
1448 )
1449 {
1450 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 RAW OR SYNCWORD\n");
1451 es->start = p;
1452 es->size = packet_len;
1453 es->type = AUDIO_A52;
1454 es->payload_size -= packet_len;
1455
1456 return 1;
1457 }
1458 /* SPU SUBS */
1459 else if(type_from_pmt == SPU_DVB ||
1460 ((p[0] == 0x20) && pes_is_aligned)) // && p[1] == 0x00))
1461 {
1462 es->start = p;
1463 es->size = packet_len;
1464 es->type = SPU_DVB;
1465 es->payload_size -= packet_len;
1466
1467 return 1;
1468 }
1469 else if (pes_is_aligned && ((p[0] & 0xE0) == 0x20)) //SPU_DVD
1470 {
1471 //DVD SUBS
1472 es->start = p+1;
1473 es->size = packet_len-1;
1474 es->type = SPU_DVD;
1475 es->payload_size -= packet_len;
1476
1477 return 1;
1478 }
1479 else if (pes_is_aligned && (p[0] & 0xF8) == 0x80)
1480 {
1481 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 WITH HEADER\n");
1482 es->start = p+4;
1483 es->size = packet_len - 4;
1484 es->type = AUDIO_A52;
1485 es->payload_size -= packet_len;
1486
1487 return 1;
1488 }
1489 else if (pes_is_aligned && ((p[0]&0xf0) == 0xa0))
1490 {
1491 int pcm_offset;
1492
1493 for (pcm_offset=0; ++pcm_offset < packet_len-1 ; )
1494 {
1495 if (p[pcm_offset] == 0x01 && p[pcm_offset+1] == 0x80)
1496 { /* START */
1497 pcm_offset += 2;
1498 break;
1499 }
1500 }
1501
1502 es->start = p + pcm_offset;
1503 es->size = packet_len - pcm_offset;
1504 es->type = AUDIO_LPCM_BE;
1505 es->payload_size -= packet_len;
1506
1507 return 1;
1508 }
1509 else
1510 {
1511 mp_msg(MSGT_DEMUX, MSGL_DBG2, "PES_PRIVATE1\n");
1512 es->start = p;
1513 es->size = packet_len;
1514 es->type = (type_from_pmt == UNKNOWN ? PES_PRIVATE1 : type_from_pmt);
1515 es->payload_size -= packet_len;
1516
1517 return 1;
1518 }
1519 }
1520 else if(((stream_id >= 0xe0) && (stream_id <= 0xef)) || (stream_id == 0xfd && type_from_pmt != UNKNOWN))
1521 {
1522 es->start = p;
1523 es->size = packet_len;
1524 if(type_from_pmt != UNKNOWN)
1525 es->type = type_from_pmt;
1526 else
1527 es->type = VIDEO_MPEG2;
1528 if(es->payload_size)
1529 es->payload_size -= packet_len;
1530
1531 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: M2V size %d\n", es->size);
1532 return 1;
1533 }
1534 else if ((stream_id == 0xfa))
1535 {
1536 int l;
1537
1538 es->is_synced = 0;
1539 if(type_from_pmt != UNKNOWN) //MP4 A/V or SL
1540 {
1541 es->start = p;
1542 es->size = packet_len;
1543 es->type = type_from_pmt;
1544
1545 if(type_from_pmt == SL_PES_STREAM)
1546 {
1547 //if(pes_is_aligned)
1548 //{
1549 l = mp4_parse_sl_packet(pmt, p, packet_len, pid, es);
1550 mp_msg(MSGT_DEMUX, MSGL_DBG2, "L=%d, TYPE=%x\n", l, type_from_pmt);
1551 if(l < 0)
1552 {
1553 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: couldn't parse SL header, passing along full PES payload\n");
1554 l = 0;
1555 }
1556 //}
1557
1558 es->start += l;
1559 es->size -= l;
1560 }
1561
1562 if(es->payload_size)
1563 es->payload_size -= packet_len;
1564 return 1;
1565 }
1566 }
1567 else if ((stream_id & 0xe0) == 0xc0)
1568 {
1569 es->start = p;
1570 es->size = packet_len;
1571
1572 if(type_from_pmt != UNKNOWN)
1573 es->type = type_from_pmt;
1574 else
1575 es->type = AUDIO_MP2;
1576
1577 es->payload_size -= packet_len;
1578
1579 return 1;
1580 }
1581 else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present
1582 {
1583 es->start = p;
1584 es->size = packet_len;
1585 es->type = type_from_pmt;
1586 es->payload_size -= packet_len;
1587
1588 return 1;
1589 }
1590 else
1591 {
1592 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id);
1593 }
1594
1595 es->is_synced = 0;
1596 return 0;
1597 }
1598
1599
1600
1601
1602 static int ts_sync(stream_t *stream)
1603 {
1604 int c=0;
1605
1606 mp_msg(MSGT_DEMUX, MSGL_DBG3, "TS_SYNC \n");
1607
1608 while(((c=stream_read_char(stream)) != 0x47) && ! stream->eof);
1609
1610 if(c == 0x47)
1611 return c;
1612 else
1613 return 0;
1614 }
1615
1616
1617 static void ts_dump_streams(ts_priv_t *priv)
1618 {
1619 int i;
1620
1621 for(i = 0; i < 3; i++)
1622 {
1623 if((priv->fifo[i].pack != NULL) && (priv->fifo[i].offset != 0))
1624 {
1625 resize_demux_packet(priv->fifo[i].pack, priv->fifo[i].offset);
1626 ds_add_packet(priv->fifo[i].ds, priv->fifo[i].pack);
1627 priv->fifo[i].offset = 0;
1628 priv->fifo[i].pack = NULL;
1629 }
1630 }
1631 }
1632
1633
1634 static inline int32_t prog_idx_in_pat(ts_priv_t *priv, uint16_t progid)
1635 {
1636 int x;
1637
1638 if(priv->pat.progs == NULL)
1639 return -1;
1640
1641 for(x = 0; x < priv->pat.progs_cnt; x++)
1642 {
1643 if(priv->pat.progs[x].id == progid)
1644 return x;
1645 }
1646
1647 return -1;
1648 }
1649
1650
1651 static inline int32_t prog_id_in_pat(ts_priv_t *priv, uint16_t pid)
1652 {
1653 int x;
1654
1655 if(priv->pat.progs == NULL)
1656 return -1;
1657
1658 for(x = 0; x < priv->pat.progs_cnt; x++)
1659 {
1660 if(priv->pat.progs[x].pmt_pid == pid)
1661 return priv->pat.progs[x].id;
1662 }
1663
1664 return -1;
1665 }
1666
1667 static int collect_section(ts_section_t *section, int is_start, unsigned char *buff, int size)
1668 {
1669 uint8_t *ptr;
1670 uint16_t tlen;
1671 int skip, tid;
1672
1673 mp_msg(MSGT_DEMUX, MSGL_V, "COLLECT_SECTION, start: %d, size: %d, collected: %d\n", is_start, size, section->buffer_len);
1674 if(! is_start && !section->buffer_len)
1675 return 0;
1676
1677 if(is_start)
1678 {
1679 if(! section->buffer)
1680 {
1681 section->buffer = malloc(4096 + 256);
1682 if(section->buffer == NULL)
1683 return 0;
1684 }
1685 section->buffer_len = 0;
1686 }
1687
1688 if(size + section->buffer_len > 4096+256)
1689 {
1690 mp_msg(MSGT_DEMUX, MSGL_V, "COLLECT_SECTION, excessive len: %d + %d\n", section->buffer_len, size);
1691 return 0;
1692 }
1693
1694 memcpy(&(section->buffer[section->buffer_len]), buff, size);
1695 section->buffer_len += size;
1696
1697 if(section->buffer_len < 3)
1698 return 0;
1699
1700 skip = section->buffer[0];
1701 if(skip + 4 > section->buffer_len)
1702 return 0;
1703
1704 ptr = &(section->buffer[skip + 1]);
1705 tid = ptr[0];
1706 tlen = ((ptr[1] & 0x0f) << 8) | ptr[2];
1707 mp_msg(MSGT_DEMUX, MSGL_V, "SKIP: %d+1, TID: %d, TLEN: %d, COLLECTED: %d\n", skip, tid, tlen, section->buffer_len);
1708 if(section->buffer_len < (skip+1+3+tlen))
1709 {
1710 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DATA IS NOT ENOUGH, NEXT TIME\n");
1711 return 0;
1712 }
1713
1714 return skip+1;
1715 }
1716
1717 static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size)
1718 {
1719 int skip;
1720 unsigned char *ptr;
1721 unsigned char *base;
1722 int entries, i;
1723 uint16_t progid;
1724 struct pat_progs_t *tmp;
1725 ts_section_t *section;
1726
1727 section = &(priv->pat.section);
1728 skip = collect_section(section, is_start, buff, size);
1729 if(! skip)
1730 return 0;
1731
1732 ptr = &(section->buffer[skip]);
1733 //PARSING
1734 priv->pat.table_id = ptr[0];
1735 if(priv->pat.table_id != 0)
1736 return 0;
1737 priv->pat.ssi = (ptr[1] >> 7) & 0x1;
1738 priv->pat.curr_next = ptr[5] & 0x01;
1739 priv->pat.ts_id = (ptr[3] << 8 ) | ptr[4];
1740 priv->pat.version_number = (ptr[5] >> 1) & 0x1F;
1741 priv->pat.section_length = ((ptr[1] & 0x03) << 8 ) | ptr[2];
1742 priv->pat.section_number = ptr[6];
1743 priv->pat.last_section_number = ptr[7];
1744
1745 //check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]);
1746 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
1748 entries = (int) (priv->pat.section_length - 9) / 4; //entries per section
1749
1750 for(i=0; i < entries; i++)
1751 {
1752 int32_t idx;
1753 base = &ptr[8 + i*4];
1754 progid = (base[0] << 8) | base[1];
1755
1756 if((idx = prog_idx_in_pat(priv, progid)) == -1)
1757 {
1758 int sz = sizeof(struct pat_progs_t) * (priv->pat.progs_cnt+1);
1759 tmp = realloc_struct(priv->pat.progs, priv->pat.progs_cnt+1, sizeof(struct pat_progs_t));
1760 if(tmp == NULL)
1761 {
1762 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PAT: COULDN'T REALLOC %d bytes, NEXT\n", sz);
1763 break;
1764 }
1765 priv->pat.progs = tmp;
1766 idx = priv->pat.progs_cnt;
1767 priv->pat.progs_cnt++;
1768 }
1769
1770 priv->pat.progs[idx].id = progid;
1771 priv->pat.progs[idx].pmt_pid = ((base[2] & 0x1F) << 8) | base[3];
1772 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);
1773 mp_msg(MSGT_IDENTIFY, MSGL_V, "PROGRAM_ID=%d (0x%02X), PMT_PID: %d(0x%02X)\n",
1774 progid, progid, priv->pat.progs[idx].pmt_pid, priv->pat.progs[idx].pmt_pid);
1775 }
1776
1777 return 1;
1778 }
1779
1780
1781 static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid)
1782 {
1783 uint16_t i;
1784
1785 if(pmt == NULL)
1786 return -1;
1787
1788 if(pmt->es == NULL)
1789 return -1;
1790
1791 for(i = 0; i < pmt->es_cnt; i++)
1792 {
1793 if(pmt->es[i].pid == pid)
1794 return (int32_t) i;
1795 }
1796
1797 return -1;
1798 }
1799
1800
1801 static uint16_t get_mp4_desc_len(uint8_t *buf, int *len)
1802 {
1803 //uint16_t i = 0, size = 0;
1804 int i = 0, j, size = 0;
1805
1806 mp_msg(MSGT_DEMUX, MSGL_DBG2, "PARSE_MP4_DESC_LEN(%d), bytes: ", *len);
1807 j = FFMIN(*len, 4);
1808 while(i < j)
1809 {
1810 mp_msg(MSGT_DEMUX, MSGL_DBG2, " %x ", buf[i]);
1811 size |= (buf[i] & 0x7f);
1812 if(!(buf[i] & 0x80))
1813 break;
1814 size <<= 7;
1815 i++;
1816 }
1817 mp_msg(MSGT_DEMUX, MSGL_DBG2, ", SIZE=%d\n", size);
1818
1819 *len = i+1;
1820 return size;
1821 }
1822
1823
1824 static uint16_t parse_mp4_slconfig_descriptor(uint8_t *buf, int len, void *elem)
1825 {
1826 int i = 0;
1827 mp4_es_descr_t *es;
1828 mp4_sl_config_t *sl;
1829
1830 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_SLCONFIG_DESCRIPTOR(%d)\n", len);
1831 es = (mp4_es_descr_t *) elem;
1832 if(!es)
1833 {
1834 mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n");
1835 return len;
1836 }
1837 sl = &(es->sl);
1838
1839 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;
1840 sl->ocr = sl->dts = sl->cts = 0;
1841
1842 if(buf[0] == 0)
1843 {
1844 i++;
1845 sl->flags = buf[i];
1846 i++;
1847 sl->ts_resolution = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
1848 i += 4;
1849 sl->ocr_resolution = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
1850 i += 4;
1851 sl->ts_len = buf[i];
1852 i++;
1853 sl->ocr_len = buf[i];
1854 i++;
1855 sl->au_len = buf[i];
1856 i++;
1857 sl->instant_bitrate_len = buf[i];
1858 i++;
1859 sl->degr_len = (buf[i] >> 4) & 0x0f;
1860 sl->au_seqnum_len = ((buf[i] & 0x0f) << 1) | ((buf[i+1] >> 7) & 0x01);
1861 i++;
1862 sl->packet_seqnum_len = ((buf[i] >> 2) & 0x1f);
1863 i++;
1864
1865 }
1866 else if(buf[0] == 1)
1867 {
1868 sl->flags = 0;
1869 sl->ts_resolution = 1000;
1870 sl->ts_len = 32;
1871 i++;
1872 }
1873 else if(buf[0] == 2)
1874 {
1875 sl->flags = 4;
1876 i++;
1877 }
1878 else
1879 {
1880 sl->flags = 0;
1881 i++;
1882 }
1883
1884 sl->au_start = (sl->flags >> 7) & 0x1;
1885 sl->au_end = (sl->flags >> 6) & 0x1;
1886 sl->random_accesspoint = (sl->flags >> 5) & 0x1;
1887 sl->random_accesspoint_only = (sl->flags >> 4) & 0x1;
1888 sl->padding = (sl->flags >> 3) & 0x1;
1889 sl->use_ts = (sl->flags >> 2) & 0x1;
1890 sl->idle = (sl->flags >> 1) & 0x1;
1891 sl->duration = sl->flags & 0x1;
1892
1893 if(sl->duration)
1894 {
1895 sl->timescale = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
1896 i += 4;
1897 sl->au_duration = (buf[i] << 8) | buf[i+1];
1898 i += 2;
1899 sl->cts_duration = (buf[i] << 8) | buf[i+1];
1900 i += 2;
1901 }
1902 else //no support for fixed durations atm
1903 sl->timescale = sl->au_duration = sl->cts_duration = 0;
1904
1905 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",
1906 len, buf[0], sl->flags, sl->use_ts, sl->ts_len, sl->timescale, (uint64_t) sl->dts, (uint64_t) sl->cts);
1907
1908 return len;
1909 }
1910
1911 static int parse_mp4_descriptors(pmt_t *pmt, uint8_t *buf, int len, void *elem);
1912
1913 static uint16_t parse_mp4_decoder_config_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
1914 {
1915 int i = 0, j;
1916 mp4_es_descr_t *es;
1917 mp4_decoder_config_t *dec;
1918
1919 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DECODER_CONFIG_DESCRIPTOR(%d)\n", len);
1920 es = (mp4_es_descr_t *) elem;
1921 if(!es)
1922 {
1923 mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n");
1924 return len;
1925 }
1926 dec = (mp4_decoder_config_t*) &(es->decoder);
1927
1928 dec->object_type = buf[i];
1929 dec->stream_type = (buf[i+1]>>2) & 0x3f;
1930
1931 if(dec->object_type == 1 && dec->stream_type == 1)
1932 {
1933 dec->object_type = MP4_OD;
1934 dec->stream_type = MP4_OD;
1935 }
1936 else if(dec->stream_type == 4)
1937 {
1938 if(dec->object_type == 0x6a)
1939 dec->object_type = VIDEO_MPEG1;
1940 if(dec->object_type >= 0x60 && dec->object_type <= 0x65)
1941 dec->object_type = VIDEO_MPEG2;
1942 else if(dec->object_type == 0x20)
1943 dec->object_type = VIDEO_MPEG4;
1944 else if(dec->object_type == 0x21)
1945 dec->object_type = VIDEO_AVC;
1946 /*else if(dec->object_type == 0x22)
1947 fprintf(stderr, "TYPE 0x22\n");*/
1948 else dec->object_type = UNKNOWN;
1949 }
1950 else if(dec->stream_type == 5)
1951 {
1952 if(dec->object_type == 0x40)
1953 dec->object_type = AUDIO_AAC;
1954 else if(dec->object_type == 0x6b)
1955 dec->object_type = AUDIO_MP2;
1956 else if(dec->object_type >= 0x66 && dec->object_type <= 0x69)
1957 dec->object_type = AUDIO_MP2;
1958 else
1959 dec->object_type = UNKNOWN;
1960 }
1961 else
1962 dec->object_type = dec->stream_type = UNKNOWN;
1963
1964 if(dec->object_type != UNKNOWN)
1965 {
1966 //update the type of the current stream
1967 for(j = 0; j < pmt->es_cnt; j++)
1968 {
1969 if(pmt->es[j].mp4_es_id == es->id)
1970 {
1971 pmt->es[j].type = SL_PES_STREAM;
1972 }
1973 }
1974 }
1975
1976 if(len > 13)
1977 parse_mp4_descriptors(pmt, &buf[13], len-13, dec);
1978
1979 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);
1980
1981 return len;
1982 }
1983
1984 static uint16_t parse_mp4_decoder_specific_descriptor(uint8_t *buf, int len, void *elem)
1985 {
1986 int i;
1987 mp4_decoder_config_t *dec;
1988
1989 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DECODER_SPECIFIC_DESCRIPTOR(%d)\n", len);
1990 dec = (mp4_decoder_config_t *) elem;
1991 if(!dec)
1992 {
1993 mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n");
1994 return len;
1995 }
1996
1997 mp_msg(MSGT_DEMUX, MSGL_DBG2, "MP4 SPECIFIC INFO BYTES: \n");
1998 for(i=0; i<len; i++)
1999 mp_msg(MSGT_DEMUX, MSGL_DBG2, "%02x ", buf[i]);
2000 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\n");
2001
2002 if(len > MAX_EXTRADATA_SIZE)
2003 {
2004 mp_msg(MSGT_DEMUX, MSGL_ERR, "DEMUX_TS, EXTRADATA SUSPICIOUSLY BIG: %d, REFUSED\r\n", len);
2005 return len;
2006 }
2007 memcpy(dec->buf, buf, len);
2008 dec->buf_size = len;
2009
2010 return len;
2011 }
2012
2013 static uint16_t parse_mp4_es_descriptor(pmt_t *pmt, uint8_t *buf, int len)
2014 {
2015 int i = 0, j = 0, k, found;
2016 uint8_t flag;
2017 mp4_es_descr_t es, *target_es = NULL, *tmp;
2018
2019 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4ES: len=%d\n", len);
2020 memset(&es, 0, sizeof(mp4_es_descr_t));
2021 while(i < len)
2022 {
2023 es.id = (buf[i] << 8) | buf[i+1];
2024 mp_msg(MSGT_DEMUX, MSGL_V, "MP4ES_ID: %d\n", es.id);
2025 i += 2;
2026 flag = buf[i];
2027 i++;
2028 if(flag & 0x80)
2029 i += 2;
2030 if(flag & 0x40)
2031 i += buf[i]+1;
2032 if(flag & 0x20) //OCR, maybe we need it
2033 i += 2;
2034
2035 j = parse_mp4_descriptors(pmt, &buf[i], len-i, &es);
2036 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);
2037 if(es.decoder.object_type != UNKNOWN && es.decoder.stream_type != UNKNOWN)
2038 {
2039 found = 0;
2040 //search this ES_ID if we already have it
2041 for(k=0; k < pmt->mp4es_cnt; k++)
2042 {
2043 if(pmt->mp4es[k].id == es.id)
2044 {
2045 target_es = &(pmt->mp4es[k]);
2046 found = 1;
2047 }
2048 }
2049
2050 if(! found)
2051 {
2052 tmp = realloc_struct(pmt->mp4es, pmt->mp4es_cnt+1, sizeof(mp4_es_descr_t));
2053 if(tmp == NULL)
2054 {
2055 fprintf(stderr, "CAN'T REALLOC MP4_ES_DESCR\n");
2056 continue;
2057 }
2058 pmt->mp4es = tmp;
2059 target_es = &(pmt->mp4es[pmt->mp4es_cnt]);
2060 pmt->mp4es_cnt++;
2061 }
2062 memcpy(target_es, &es, sizeof(mp4_es_descr_t));
2063 mp_msg(MSGT_DEMUX, MSGL_V, "MP4ES_CNT: %d, ID=%d\n", pmt->mp4es_cnt, target_es->id);
2064 }
2065
2066 i += j;
2067 }
2068
2069 return len;
2070 }
2071
2072 static void parse_mp4_object_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
2073 {
2074 int i, j = 0, id;
2075
2076 i=0;
2077 id = (buf[0] << 2) | ((buf[1] & 0xc0) >> 6);
2078 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_OBJECT_DESCRIPTOR: len=%d, OD_ID=%d\n", len, id);
2079 if(buf[1] & 0x20)
2080 {
2081 i += buf[2] + 1; //url
2082 mp_msg(MSGT_DEMUX, MSGL_V, "URL\n");
2083 }
2084 else
2085 {
2086 i = 2;
2087
2088 while(i < len)
2089 {
2090 j = parse_mp4_descriptors(pmt, &(buf[i]), len-i, elem);
2091 mp_msg(MSGT_DEMUX, MSGL_V, "OBJD, NOW i = %d, j=%d, LEN=%d\n", i, j, len);
2092 i += j;
2093 }
2094 }
2095 }
2096
2097
2098 static void parse_mp4_iod(pmt_t *pmt, uint8_t *buf, int len, void *elem)
2099 {
2100 int i, j = 0;
2101 mp4_od_t *iod = &(pmt->iod);
2102
2103 iod->id = (buf[0] << 2) | ((buf[1] & 0xc0) >> 6);
2104 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_IOD: len=%d, IOD_ID=%d\n", len, iod->id);
2105 i = 2;
2106 if(buf[1] & 0x20)
2107 {
2108 i += buf[2] + 1; //url
2109 mp_msg(MSGT_DEMUX, MSGL_V, "URL\n");
2110 }
2111 else
2112 {
2113 i = 7;
2114 while(i < len)
2115 {
2116 j = parse_mp4_descriptors(pmt, &(buf[i]), len-i, elem);
2117 mp_msg(MSGT_DEMUX, MSGL_V, "IOD, NOW i = %d, j=%d, LEN=%d\n", i, j, len);
2118 i += j;
2119 }
2120 }
2121 }
2122
2123 static int parse_mp4_descriptors(pmt_t *pmt, uint8_t *buf, int len, void *elem)
2124 {
2125 int tag, descr_len, i = 0, j = 0;
2126
2127 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DESCRIPTORS, len=%d\n", len);
2128 if(! len)
2129 return len;
2130
2131 while(i < len)
2132 {
2133 tag = buf[i];
2134 j = len - i -1;
2135 descr_len = get_mp4_desc_len(&(buf[i+1]), &j);
2136 mp_msg(MSGT_DEMUX, MSGL_V, "TAG=%d (0x%x), DESCR_len=%d, len=%d, j=%d\n", tag, tag, descr_len, len, j);
2137 if(descr_len > len - j+1)
2138 {
2139 mp_msg(MSGT_DEMUX, MSGL_V, "descriptor is too long, exit\n");
2140 return len;
2141 }
2142 i += j+1;
2143
2144 switch(tag)
2145 {
2146 case 0x1:
2147 parse_mp4_object_descriptor(pmt, &(buf[i]), descr_len, elem);
2148 break;
2149 case 0x2:
2150 parse_mp4_iod(pmt, &(buf[i]), descr_len, elem);
2151 break;
2152 case 0x3:
2153 parse_mp4_es_descriptor(pmt, &(buf[i]), descr_len);
2154 break;
2155 case 0x4:
2156 parse_mp4_decoder_config_descriptor(pmt, &buf[i], descr_len, elem);
2157 break;
2158 case 0x05:
2159 parse_mp4_decoder_specific_descriptor(&buf[i], descr_len, elem);
2160 break;
2161 case 0x6:
2162 parse_mp4_slconfig_descriptor(&buf[i], descr_len, elem);
2163 break;
2164 default:
2165 mp_msg(MSGT_DEMUX, MSGL_V, "Unsupported mp4 descriptor 0x%x\n", tag);
2166 }
2167 i += descr_len;
2168 }
2169
2170 return len;
2171 }
2172
2173 static ES_stream_t *new_pid(ts_priv_t *priv, int pid)
2174 {
2175 ES_stream_t *tss;
2176
2177 tss = malloc(sizeof(ES_stream_t));
2178 if(! tss)
2179 return NULL;
2180 memset(tss, 0, sizeof(ES_stream_t));
2181 tss->pid = pid;
2182 tss->last_cc = -1;
2183 tss->type = UNKNOWN;
2184 tss->subtype = UNKNOWN;
2185 tss->is_synced = 0;
2186 tss->extradata = NULL;
2187 tss->extradata_alloc = tss->extradata_len = 0;
2188 priv->ts.pids[pid] = tss;
2189
2190 return tss;
2191 }
2192
2193
2194 static int parse_program_descriptors(pmt_t *pmt, uint8_t *buf, uint16_t len)
2195 {
2196 uint16_t i = 0, k, olen = len;
2197
2198 while(len > 0)
2199 {
2200 mp_msg(MSGT_DEMUX, MSGL_V, "PROG DESCR, TAG=%x, LEN=%d(%x)\n", buf[i], buf[i+1], buf[i+1]);
2201 if(buf[i+1] > len-2)
2202 {
2203 mp_msg(MSGT_DEMUX, MSGL_V, "ERROR, descriptor len is too long, skipping\n");
2204 return olen;
2205 }
2206
2207 if(buf[i] == 0x1d)
2208 {
2209 if(buf[i+3] == 2) //buggy versions of vlc muxer make this non-standard mess (missing iod_scope)
2210 k = 3;
2211 else
2212 k = 4; //this is standard compliant
2213 parse_mp4_descriptors(pmt, &buf[i+k], (int) buf[i+1]-(k-2), NULL);
2214 }
2215
2216 len -= 2 + buf[i+1];
2217 }
2218
2219 return olen;
2220 }
2221
2222 static int parse_descriptors(struct pmt_es_t *es, uint8_t *ptr)
2223 {
2224 int j, descr_len, len;
2225
2226 j = 0;
2227 len = es->descr_length;
2228 while(len > 2)
2229 {
2230 descr_len = ptr[j+1];
2231 mp_msg(MSGT_DEMUX, MSGL_V, "...descr id: 0x%x, len=%d\n", ptr[j], descr_len);
2232 if(descr_len > len)
2233 {
2234 mp_msg(MSGT_DEMUX, MSGL_ERR, "INVALID DESCR LEN for tag %02x: %d vs %d max, EXIT LOOP\n", ptr[j], descr_len, len);
2235 return -1;
2236 }
2237
2238
2239 if(ptr[j] == 0x6a || ptr[j] == 0x7a) //A52 Descriptor
2240 {
2241 if(es->type == 0x6)
2242 {
2243 es->type = AUDIO_A52;
2244 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n");
2245 }
2246 }
2247 else if(ptr[j] == 0x7b) //DVB DTS Descriptor
2248 {
2249 if(es->type == 0x6)
2250 {
2251 es->type = AUDIO_DTS;
2252 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB DTS Descriptor\n");
2253 }
2254 }
2255 else if(ptr[j] == 0x56) // Teletext
2256 {
2257 if(descr_len >= 5) {
2258 memcpy(es->lang, ptr+2, 3);
2259 es->lang[3] = 0;
2260 }
2261 es->type = SPU_TELETEXT;
2262 }
2263 else if(ptr[j] == 0x59) //Subtitling Descriptor
2264 {
2265 uint8_t subtype;
2266
2267 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Subtitling Descriptor\n");
2268 if(descr_len < 8)
2269 {
2270 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Descriptor length too short for DVB Subtitle Descriptor: %d, SKIPPING\n", descr_len);
2271 }
2272 else
2273 {
2274 memcpy(es->lang, &ptr[j+2], 3);
2275 es->lang[3] = 0;
2276 subtype = ptr[j+5];
2277 if(
2278 (subtype >= 0x10 && subtype <= 0x13) ||
2279 (subtype >= 0x20 && subtype <= 0x23)
2280 )
2281 {
2282 es->type = SPU_DVB;
2283 //page parameters: compo page 2 bytes, ancillary page 2 bytes
2284 }
2285 else
2286 es->type = UNKNOWN;
2287 }
2288 }
2289 else if(ptr[j] == 0x50) //Component Descriptor
2290 {
2291 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Component Descriptor\n");
2292 memcpy(es->lang, &ptr[j+5], 3);
2293 es->lang[3] = 0;
2294 }
2295 else if(ptr[j] == 0xa) //Language Descriptor
2296 {
2297 memcpy(es->lang, &ptr[j+2], 3);
2298 es->lang[3] = 0;
2299 mp_msg(MSGT_DEMUX, MSGL_V, "Language Descriptor: %s\n", es->lang);
2300 }
2301 else if(ptr[j] == 0x5) //Registration Descriptor (looks like e fourCC :) )
2302 {
2303 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor\n");
2304 if(descr_len < 4)
2305 {
2306 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor length too short: %d, SKIPPING\n", descr_len);
2307 }
2308 else
2309 {
2310 char *d;
2311 memcpy(es->format_descriptor, &ptr[j+2], 4);
2312 es->format_descriptor[4] = 0;
2313
2314 d = &ptr[j+2];
2315 if(d[0] == 'A' && d[1] == 'C' && d[2] == '-' && d[3] == '3')
2316 {
2317 es->type = AUDIO_A52;
2318 }
2319 else if(d[0] == 'D' && d[1] == 'T' && d[2] == 'S' && d[3] == '1')
2320 {
2321 es->type = AUDIO_DTS;
2322 }
2323 else if(d[0] == 'D' && d[1] == 'T' && d[2] == 'S' && d[3] == '2')
2324 {
2325 es->type = AUDIO_DTS;
2326 }
2327 else if(d[0] == 'V' && d[1] == 'C' && d[2] == '-' && d[3] == '1')
2328 {
2329 es->type = VIDEO_VC1;
2330 }
2331 else
2332 es->type = UNKNOWN;
2333 mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor);
2334 }
2335 }
2336 else if(ptr[j] == 0x1e)
2337 {
2338 es->mp4_es_id = (ptr[j+2] << 8) | ptr[j+3];
2339 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);
2340 }
2341 else
2342 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Unknown descriptor 0x%x, SKIPPING\n", ptr[j]);
2343
2344 len -= 2 + descr_len;
2345 j += 2 + descr_len;
2346 }
2347
2348 return 1;
2349 }
2350
2351 static int parse_sl_section(pmt_t *pmt, ts_section_t *section, int is_start, unsigned char *buff, int size)
2352 {
2353 int tid, len, skip;
2354 uint8_t *ptr;
2355 skip = collect_section(section, is_start, buff, size);
2356 if(! skip)
2357 return 0;
2358
2359 ptr = &(section->buffer[skip]);
2360 tid = ptr[0];
2361 len = ((ptr[1] & 0x0f) << 8) | ptr[2];
2362 mp_msg(MSGT_DEMUX, MSGL_V, "TABLEID: %d (av. %d), skip=%d, LEN: %d\n", tid, section->buffer_len, skip, len);
2363 if(len > 4093 || section->buffer_len < len || tid != 5)
2364 {
2365 mp_msg(MSGT_DEMUX, MSGL_V, "SECTION TOO LARGE or wrong section type, EXIT\n");
2366 return 0;
2367 }
2368
2369 if(! (ptr[5] & 1))
2370 return 0;
2371
2372 //8 is the current position, len - 9 is the amount of data available
2373 parse_mp4_descriptors(pmt, &ptr[8], len - 9, NULL);
2374
2375 return 1;
2376 }
2377
2378 static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size)
2379 {
2380 unsigned char *base, *es_base;
2381 pmt_t *pmt;
2382 int32_t idx, es_count, section_bytes;
2383 uint8_t m=0;
2384 int skip;
2385 pmt_t *tmp;
2386 struct pmt_es_t *tmp_es;
2387 ts_section_t *section;
2388 ES_stream_t *tss;
2389
2390 idx = progid_idx_in_pmt(priv, progid);
2391
2392 if(idx == -1)
2393 {
2394 int sz = (priv->pmt_cnt + 1) * sizeof(pmt_t);
2395 tmp = realloc_struct(priv->pmt, priv->pmt_cnt + 1, sizeof(pmt_t));
2396 if(tmp == NULL)
2397 {
2398 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz);
2399 return 0;
2400 }
2401 priv->pmt = tmp;
2402 idx = priv->pmt_cnt;
2403 memset(&(priv->pmt[idx]), 0, sizeof(pmt_t));
2404 priv->pmt_cnt++;
2405 priv->pmt[idx].progid = progid;
2406 }
2407
2408 pmt = &(priv->pmt[idx]);
2409
2410 section = &(pmt->section);
2411 skip = collect_section(section, is_start, buff, size);
2412 if(! skip)
2413 return 0;
2414
2415 base = &(section->buffer[skip]);
2416
2417 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",
2418 progid, pmt->section.buffer_len, is_start, pid, size, m, pmt->es_cnt, idx, pmt);
2419
2420 pmt->table_id = base[0];
2421 if(pmt->table_id != 2)
2422 return -1;
2423 pmt->ssi = base[1] & 0x80;
2424 pmt->section_length = (((base[1] & 0xf) << 8 ) | base[2]);
2425 pmt->version_number = (base[5] >> 1) & 0x1f;
2426 pmt->curr_next = (base[5] & 1);
2427 pmt->section_number = base[6];
2428 pmt->last_section_number = base[7];
2429 pmt->PCR_PID = ((base[8] & 0x1f) << 8 ) | base[9];
2430 pmt->prog_descr_length = ((base[10] & 0xf) << 8 ) | base[11];
2431 if(pmt->prog_descr_length > pmt->section_length - 9)
2432 {
2433 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, INVALID PROG_DESCR LENGTH (%d vs %d)\n", pmt->prog_descr_length, pmt->section_length - 9);
2434 return -1;
2435 }
2436
2437 if(pmt->prog_descr_length)
2438 parse_program_descriptors(pmt, &base[12], pmt->prog_descr_length);
2439
2440 es_base = &base[12 + pmt->prog_descr_length]; //the beginning of th ES loop
2441
2442 section_bytes= pmt->section_length - 13 - pmt->prog_descr_length;
2443 es_count = 0;
2444
2445 while(section_bytes >= 5)
2446 {
2447 int es_pid, es_type;
2448
2449 es_type = es_base[0];
2450 es_pid = ((es_base[1] & 0x1f) << 8) | es_base[2];
2451
2452 idx = es_pid_in_pmt(pmt, es_pid);
2453 if(idx == -1)
2454 {
2455 int sz = sizeof(struct pmt_es_t) * (pmt->es_cnt + 1);
2456 tmp_es = realloc_struct(pmt->es, pmt->es_cnt + 1, sizeof(struct pmt_es_t));
2457 if(tmp_es == NULL)
2458 {
2459 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz);
2460 continue;
2461 }
2462 pmt->es = tmp_es;
2463 idx = pmt->es_cnt;
2464 memset(&(pmt->es[idx]), 0, sizeof(struct pmt_es_t));
2465 pmt->es_cnt++;
2466 }
2467
2468 pmt->es[idx].descr_length = ((es_base[3] & 0xf) << 8) | es_base[4];
2469
2470
2471 if(pmt->es[idx].descr_length > section_bytes - 5)
2472 {
2473 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT\n",
2474 pmt->es[idx].descr_length, section_bytes - 5);
2475 return -1;
2476 }
2477
2478
2479 pmt->es[idx].pid = es_pid;
2480 if(es_type != 0x6)
2481 pmt->es[idx].type = UNKNOWN;
2482 else
2483 pmt->es[idx].type = es_type;
2484
2485 parse_descriptors(&pmt->es[idx], &es_base[5]);
2486
2487 switch(es_type)
2488 {
2489 case 1:
2490 pmt->es[idx].type = VIDEO_MPEG1;
2491 break;
2492 case 2:
2493 pmt->es[idx].type = VIDEO_MPEG2;
2494 break;
2495 case 3:
2496 case 4:
2497 pmt->es[idx].type = AUDIO_MP2;
2498 break;
2499 case 6:
2500 if(pmt->es[idx].type == 0x6) //this could have been ovrwritten by parse_descriptors
2501 pmt->es[idx].type = UNKNOWN;
2502 break;
2503 case 0x10:
2504 pmt->es[idx].type = VIDEO_MPEG4;
2505 break;
2506 case 0x0f:
2507 case 0x11:
2508 pmt->es[idx].type = AUDIO_AAC;
2509 break;
2510 case 0x1b:
2511 pmt->es[idx].type = VIDEO_H264;
2512 break;
2513 case 0x12:
2514 pmt->es[idx].type = SL_PES_STREAM;
2515 break;
2516 case 0x13:
2517 pmt->es[idx].type = SL_SECTION;
2518 break;
2519 case 0x81:
2520 pmt->es[idx].type = AUDIO_A52;
2521 break;
2522 case 0x8A:
2523 case 0x82:
2524 case 0x85:
2525 case 0x86:
2526 pmt->es[idx].type = AUDIO_DTS;
2527 break;
2528 case 0xEA:
2529 pmt->es[idx].type = VIDEO_VC1;
2530 break;
2531 default:
2532 mp_msg(MSGT_DEMUX, MSGL_DBG2, "UNKNOWN ES TYPE=0x%x\n", es_type);
2533 pmt->es[idx].type = UNKNOWN;
2534 }
2535
2536 tss = priv->ts.pids[es_pid]; //an ES stream
2537 if(tss == NULL)
2538 {
2539 tss = new_pid(priv, es_pid);
2540 if(tss)
2541 tss->type = pmt->es[idx].type;
2542 }
2543
2544 section_bytes -= 5 + pmt->es[idx].descr_length;
2545 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",
2546 progid, idx, es_count, pmt->es[idx].pid, pmt->es[idx].pid, pmt->es[idx].type, pmt->es[idx].descr_length, section_bytes);
2547
2548
2549 es_base += 5 + pmt->es[idx].descr_length;
2550
2551 es_count++;
2552 }
2553
2554 mp_msg(MSGT_DEMUX, MSGL_V, "----------------------------\n");
2555 return 1;
2556 }
2557
2558 static pmt_t* pmt_of_pid(ts_priv_t *priv, int pid, mp4_decoder_config_t **mp4_dec)
2559 {
2560 int32_t i, j, k;
2561
2562 if(priv->pmt)
2563 {
2564 for(i = 0; i < priv->pmt_cnt; i++)
2565 {
2566 if(priv->pmt[i].es && priv->pmt[i].es_cnt)
2567 {
2568 for(j = 0; j < priv->pmt[i].es_cnt; j++)
2569 {
2570 if(priv->pmt[i].es[j].pid == pid)
2571 {
2572 //search mp4_es_id
2573 if(priv->pmt[i].es[j].mp4_es_id)
2574 {
2575 for(k = 0; k < priv->pmt[i].mp4es_cnt; k++)
2576 {
2577 if(priv->pmt[i].mp4es[k].id == priv->pmt[i].es[j].mp4_es_id)
2578 {
2579 *mp4_dec = &(priv->pmt[i].mp4es[k].decoder);
2580 break;
2581 }
2582 }
2583 }
2584
2585 return &(priv->pmt[i]);
2586 }
2587 }
2588 }
2589 }
2590 }
2591
2592 return NULL;
2593 }
2594
2595
2596 static inline int32_t pid_type_from_pmt(ts_priv_t *priv, int pid)
2597 {
2598 int32_t pmt_idx, pid_idx, i, j;
2599
2600 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
2601
2602 if(pmt_idx != -1)
2603 {
2604 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
2605 if(pid_idx != -1)
2606 return priv->pmt[pmt_idx].es[pid_idx].type;
2607 }
2608 //else
2609 //{
2610 for(i = 0; i < priv->pmt_cnt; i++)
2611 {
2612 pmt_t *pmt = &(priv->pmt[i]);
2613 for(j = 0; j < pmt->es_cnt; j++)
2614 if(pmt->es[j].pid == pid)
2615 return pmt->es[j].type;
2616 }
2617 //}
2618
2619 return UNKNOWN;
2620 }
2621
2622
2623 static inline uint8_t *pid_lang_from_pmt(ts_priv_t *priv, int pid)
2624 {
2625 int32_t pmt_idx, pid_idx, i, j;
2626
2627 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
2628
2629 if(pmt_idx != -1)
2630 {
2631 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
2632 if(pid_idx != -1)
2633 return priv->pmt[pmt_idx].es[pid_idx].lang;
2634 }
2635 else
2636 {
2637 for(i = 0; i < priv->pmt_cnt; i++)
2638 {
2639 pmt_t *pmt = &(priv->pmt[i]);
2640 for(j = 0; j < pmt->es_cnt; j++)
2641 if(pmt->es[j].pid == pid)
2642 return pmt->es[j].lang;
2643 }
2644 }
2645
2646 return NULL;
2647 }
2648
2649
2650 static int fill_packet(demuxer_t *demuxer, demux_stream_t *ds, demux_packet_t **dp, int *dp_offset, TS_stream_info *si)
2651 {
2652 int ret = 0;
2653
2654 if((*dp != NULL) && (*dp_offset > 0))
2655 {
2656 ret = *dp_offset;
2657 resize_demux_packet(*dp, ret); //shrinked to the right size
2658 ds_add_packet(ds, *dp);
2659 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);
2660 if(si)
2661 {
2662 float diff = (*dp)->pts - si->last_pts;
2663 float dur;
2664
2665 if(abs(diff) > 1) //1 second, there's a discontinuity
2666 {
2667 si->duration += si->last_pts - si->first_pts;
2668 si->first_pts = si->last_pts = (*dp)->pts;
2669 }
2670 else
2671 {
2672 si->last_pts = (*dp)->pts;
2673 }
2674 si->size += ret;
2675 dur = si->duration + (si->last_pts - si->first_pts);
2676
2677 if(dur > 0 && ds == demuxer->video)
2678 {
2679 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
2680 if(dur > 1) //otherwise it may be unreliable
2681 priv->vbitrate = (uint32_t) ((float) si->size / dur);
2682 }
2683 }
2684 }
2685
2686 *dp = NULL;
2687 *dp_offset = 0;
2688
2689 return ret;
2690 }
2691
2692 static int fill_extradata(mp4_decoder_config_t * mp4_dec, ES_stream_t *tss)
2693 {
2694 uint8_t *tmp;
2695
2696 mp_msg(MSGT_DEMUX, MSGL_DBG2, "MP4_dec: %p, pid: %d\n", mp4_dec, tss->pid);
2697
2698 if(mp4_dec->buf_size > tss->extradata_alloc)
2699 {
2700 tmp = realloc(tss->extradata, mp4_dec->buf_size);
2701 if(!tmp)
2702 return 0;
2703 tss->extradata = tmp;
2704 tss->extradata_alloc = mp4_dec->buf_size;
2705 }
2706 memcpy(tss->extradata, mp4_dec->buf, mp4_dec->buf_size);
2707 tss->extradata_len = mp4_dec->buf_size;
2708 mp_msg(MSGT_DEMUX, MSGL_V, "EXTRADATA: %p, alloc=%d, len=%d\n", tss->extradata, tss->extradata_alloc, tss->extradata_len);
2709
2710 return tss->extradata_len;
2711 }
2712
2713 // 0 = EOF or no stream found
2714 // else = [-] number of bytes written to the packet
2715 static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, int probe)
2716 {
2717 ES_stream_t *tss;
2718 uint8_t done = 0;
2719 int buf_size, is_start, pid, base;
2720 int len, cc, cc_ok, afc, retv = 0, is_video, is_audio, is_sub;
2721 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
2722 stream_t *stream = demuxer->stream;
2723 char *p;
2724 demux_stream_t *ds = NULL;
2725 demux_packet_t **dp = NULL;
2726 int *dp_offset = 0, *buffer_size = 0;
2727 int32_t progid, pid_type, bad, ts_error;
2728 int junk = 0, rap_flag = 0;
2729 pmt_t *pmt;
2730 mp4_decoder_config_t *mp4_dec;
2731 TS_stream_info *si;
2732
2733
2734 while(! done)
2735 {
2736 bad = ts_error = 0;
2737 ds = (demux_stream_t*) NULL;
2738 dp = (demux_packet_t **) NULL;
2739 dp_offset = buffer_size = NULL;
2740 rap_flag = 0;
2741 mp4_dec = NULL;
2742 es->is_synced = 0;
2743 es->lang[0] = 0;
2744 si = NULL;
2745
2746 junk = priv->ts.packet_size - TS_PACKET_SIZE;
2747 buf_size = priv->ts.packet_size - junk;
2748
2749 if(stream_eof(stream))
2750 {
2751 if(! probe)
2752 {
2753 ts_dump_streams(priv);
2754 demuxer->filepos = stream_tell(demuxer->stream);
2755 }
2756
2757 return 0;
2758 }
2759
2760
2761 if(! ts_sync(stream))
2762 {
2763 mp_msg(MSGT_DEMUX, MSGL_INFO, "TS_PARSE: COULDN'T SYNC\n");
2764 return 0;
2765 }
2766
2767 len = stream_read(stream, &packet[1], 3);
2768 if (len != 3)
2769 return 0;
2770 buf_size -= 4;
2771
2772 if((packet[1] >> 7) & 0x01) //transport error
2773 ts_error = 1;
2774
2775
2776 is_start = packet[1] & 0x40;
2777 pid = ((packet[1] & 0x1f) << 8) | packet[2];
2778
2779 tss = priv->ts.pids[pid]; //an ES stream
2780 if(tss == NULL)
2781 {
2782 tss = new_pid(priv, pid);
2783 if(tss == NULL)
2784 continue;
2785 }
2786
2787 cc = (packet[3] & 0xf);
2788 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
2789 tss->last_cc = cc;
2790
2791 bad = ts_error; // || (! cc_ok);
2792 if(bad)
2793 {
2794 if(priv->keep_broken == 0)
2795 {
2796 stream_skip(stream, buf_size-1+junk);
2797 continue;
2798 }
2799
2800 is_start = 0; //queued to the packet data
2801 }
2802
2803 if(is_start)
2804 tss->is_synced = 1;
2805
2806 if((!is_start && !tss->is_synced) || ((pid > 1) && (pid < 16)) || (pid == 8191)) //invalid pid
2807 {
2808 stream_skip(stream, buf_size-1+junk);
2809 continue;
2810 }
2811
2812
2813 afc = (packet[3] >> 4) & 3;
2814 if(! (afc % 2)) //no payload in this TS packet
2815 {
2816 stream_skip(stream, buf_size-1+junk);
2817 continue;
2818 }
2819
2820 if(afc > 1)
2821 {
2822 int c;
2823 c = stream_read_char(stream);
2824 buf_size--;
2825 if(c < 0 || c > 183) //broken from the stream layer or invalid
2826 {
2827 stream_skip(stream, buf_size-1+junk);
2828 continue;
2829 }
2830
2831 //c==0 is allowed!
2832 if(c > 0)
2833 {
2834 uint8_t pcrbuf[188];
2835 int flags = stream_read_char(stream);
2836 int has_pcr;
2837 rap_flag = (flags & 0x40) >> 6;
2838 has_pcr = flags & 0x10;
2839
2840 buf_size--;
2841 c--;
2842 stream_read(stream, pcrbuf, c);
2843
2844 if(has_pcr)
2845 {
2846 int pcr_pid = prog_pcr_pid(priv, priv->prog);
2847 if(pcr_pid == pid)
2848 {
2849 uint64_t pcr, pcr_ext;
2850
2851 pcr = (int64_t)(pcrbuf[0]) << 25;
2852 pcr |= pcrbuf[1] << 17 ;
2853 pcr |= (pcrbuf[2]) << 9;
2854 pcr |= pcrbuf[3] << 1 ;
2855 pcr |= (pcrbuf[4] & 0x80) >> 7;
2856
2857 pcr_ext = (pcrbuf[4] & 0x01) << 8;
2858 pcr_ext |= pcrbuf[5];
2859
2860 pcr = pcr * 300 + pcr_ext;
2861
2862 demuxer->reference_clock = (double)pcr/(double)27000000.0;
2863 }
2864 }
2865
2866 buf_size -= c;
2867 if(buf_size == 0)
2868 continue;
2869 }
2870 }
2871
2872 //find the program that the pid belongs to; if (it's the right one or -1) && pid_type==SL_SECTION
2873 //call parse_sl_section()
2874 pmt = pmt_of_pid(priv, pid, &mp4_dec);
2875 if(mp4_dec)
2876 {
2877 fill_extradata(mp4_dec, tss);
2878 if(IS_VIDEO(mp4_dec->object_type) || IS_AUDIO(mp4_dec->object_type))
2879 {
2880 tss->type = SL_PES_STREAM;
2881 tss->subtype = mp4_dec->object_type;
2882 }
2883 }
2884
2885
2886 //TABLE PARSING
2887
2888 base = priv->ts.packet_size - buf_size;
2889
2890 priv->last_pid = pid;
2891
2892 is_video = IS_VIDEO(tss->type) || (tss->type==SL_PES_STREAM && IS_VIDEO(tss->subtype));
2893 is_audio = IS_AUDIO(tss->type) || (tss->type==SL_PES_STREAM && IS_AUDIO(tss->subtype)) || (tss->type == PES_PRIVATE1);
2894 is_sub = IS_SUB(tss->type);
2895 pid_type = pid_type_from_pmt(priv, pid);
2896
2897 // PES CONTENT STARTS HERE
2898 if(! probe)
2899 {
2900 if((is_video || is_audio) && is_start && !priv->ts.streams[pid].sh)
2901 ts_add_stream(demuxer, tss);
2902
2903 if((pid == demuxer->sub->id)) //or the lang is right
2904 {
2905 pid_type = SPU_DVD;
2906 }
2907
2908 if(is_video && (demuxer->video->id == priv->ts.streams[pid].id))
2909 {
2910 ds = demuxer->video;
2911
2912 dp = &priv->fifo[1].pack;
2913 dp_offset = &priv->fifo[1].offset;
2914 buffer_size = &priv->fifo[1].buffer_size;
2915 si = &priv->vstr;
2916 }
2917 else if(is_audio && (demuxer->audio->id == priv->ts.streams[pid].id))
2918 {
2919 ds = demuxer->audio;
2920
2921 dp = &priv->fifo[0].pack;
2922 dp_offset = &priv->fifo[0].offset;
2923 buffer_size = &priv->fifo[0].buffer_size;
2924 si = &priv->astr;
2925 }
2926 else if(is_sub
2927 || IS_SUB(pid_type))
2928 {
2929 //SUBS are infrequent, so the initial detection may fail
2930 // and we may need to add them at play-time
2931 if(demuxer->sub->id == -1)
2932 {
2933 uint16_t p;
2934 p = progid_for_pid(priv, tss->pid, priv->prog);
2935
2936 if(p == priv->prog)
2937 {
2938 int asgn = 0;
2939 uint8_t *lang;
2940
2941 if(dvdsub_lang)
2942 {
2943 if ((lang = pid_lang_from_pmt(priv, pid)))
2944 asgn = (strncmp(lang, dvdsub_lang, 3) == 0);
2945 }
2946 else //no language specified with -slang
2947 asgn = 1;
2948
2949 if(asgn)
2950 {
2951 demuxer->sub->id = tss->pid;
2952 mp_msg(MSGT_DEMUX, MSGL_INFO, "CHOSEN SUBs pid 0x%x (%d) FROM PROG %d\n", tss->pid, tss->pid, priv->prog);
2953 }
2954 }
2955 }
2956
2957 if(demuxer->sub->id == tss->pid)
2958 {
2959 ds = demuxer->sub;
2960
2961 dp = &priv->fifo[2].pack;
2962 dp_offset = &priv->fifo[2].offset;
2963 buffer_size = &priv->fifo[2].buffer_size;
2964 }
2965 else
2966 {
2967 stream_skip(stream, buf_size+junk);
2968 continue;
2969 }
2970 }
2971
2972 //IS IT TIME TO QUEUE DATA to the dp_packet?
2973 if(is_start && (dp != NULL))
2974 {
2975 retv = fill_packet(demuxer, ds, dp, dp_offset, si);
2976 }
2977
2978
2979 if(dp && *dp == NULL)
2980 {
2981 if(*buffer_size > MAX_PACK_BYTES)
2982 *buffer_size = MAX_PACK_BYTES;
2983 *dp = new_demux_packet(*buffer_size); //es->size
2984 *dp_offset = 0;
2985 if(! *dp)
2986 {
2987 fprintf(stderr, "fill_buffer, NEW_ADD_PACKET(%d)FAILED\n", *buffer_size);
2988 continue;
2989 }
2990 mp_msg(MSGT_DEMUX, MSGL_DBG2, "CREATED DP(%d)\n", *buffer_size);
2991 }
2992 }
2993
2994
2995 if(probe || !dp) //dp is NULL for tables and sections
2996 {
2997 p = &packet[base];
2998 }
2999 else //feeding
3000 {
3001 if(*dp_offset + buf_size > *buffer_size)
3002 {
3003 *buffer_size = *dp_offset + buf_size + TS_FEC_PACKET_SIZE;
3004 resize_demux_packet(*dp, *buffer_size);
3005 }
3006 p = &((*dp)->buffer[*dp_offset]);
3007 }
3008
3009 len = stream_read(stream, p, buf_size);
3010 if(len < buf_size)
3011 {
3012 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\r\nts_parse() couldn't read enough data: %d < %d\r\n", len, buf_size);
3013 continue;
3014 }
3015 stream_skip(stream, junk);
3016
3017 if(pid == 0)
3018 {
3019 parse_pat(priv, is_start, p, buf_size);
3020 continue;
3021 }
3022 else if((tss->type == SL_SECTION) && pmt)
3023 {
3024 int k, mp4_es_id = -1;
3025 ts_section_t *section;
3026 for(k = 0; k < pmt->mp4es_cnt; k++)
3027 {
3028 if(pmt->mp4es[k].decoder.object_type == MP4_OD && pmt->mp4es[k].decoder.stream_type == MP4_OD)
3029 mp4_es_id = pmt->mp4es[k].id;
3030 }
3031 mp_msg(MSGT_DEMUX, MSGL_DBG2, "MP4ESID: %d\n", mp4_es_id);
3032 for(k = 0; k < pmt->es_cnt; k++)
3033 {
3034 if(pmt->es[k].mp4_es_id == mp4_es_id)
3035 {
3036 section = &(tss->section);
3037 parse_sl_section(pmt, section, is_start, &packet[base], buf_size);
3038 }
3039 }
3040 continue;
3041 }
3042 else
3043 {
3044 progid = prog_id_in_pat(priv, pid);
3045 if(progid != -1)
3046 {
3047 if(pid != demuxer->video->id && pid != demuxer->audio->id && pid != demuxer->sub->id)
3048 {
3049 parse_pmt(priv, progid, pid, is_start, &packet[base], buf_size);
3050 continue;
3051 }
3052 else
3053 mp_msg(MSGT_DEMUX, MSGL_ERR, "Argh! Data pid %d used in the PMT, Skipping PMT parsing!\n", pid);
3054 }
3055 }
3056
3057 if(!probe && !dp)
3058 continue;
3059
3060 if(is_start)
3061 {
3062 uint8_t *lang = NULL;
3063
3064 mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n");
3065
3066 len = pes_parse2(p, buf_size, es, pid_type, pmt, pid);
3067 if(! len)
3068 {
3069 tss->is_synced = 0;
3070 continue;
3071 }
3072 es->pid = tss->pid;
3073 tss->is_synced |= es->is_synced || rap_flag;
3074 tss->payload_size = es->payload_size;
3075
3076 if((is_sub || is_audio) && (lang = pid_lang_from_pmt(priv, es->pid)))
3077 {
3078 memcpy(es->lang, lang, 3);
3079 es->lang[3] = 0;
3080 }
3081 else
3082 es->lang[0] = 0;
3083
3084 if(probe)
3085 {
3086 if(es->type == UNKNOWN)
3087 return 0;
3088
3089 tss->type = es->type;
3090 tss->subtype = es->subtype;
3091
3092 return 1;
3093 }
3094 else
3095 {
3096 if(es->pts == 0.0)
3097 es->pts = tss->pts = tss->last_pts;
3098 else
3099 tss->pts = tss->last_pts = es->pts;
3100
3101 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%p, len=%d\n",
3102 es->pid, es->payload_size, es->type, es->start, es->size);
3103
3104 demuxer->filepos = stream_tell(demuxer->stream) - es->size;
3105
3106 memmove(p, es->start, es->size);
3107 *dp_offset += es->size;
3108 (*dp)->flags = 0;
3109 (*dp)->pos = stream_tell(demuxer->stream);
3110 (*dp)->pts = es->pts;
3111
3112 if(retv > 0)
3113 return retv;
3114 else
3115 continue;
3116 }
3117 }
3118 else
3119 {
3120 uint16_t sz;
3121
3122 es->pid = tss->pid;
3123 es->type = tss->type;
3124 es->subtype = tss->subtype;
3125 es->pts = tss->pts = tss->last_pts;
3126 es->start = &packet[base];
3127
3128
3129 if(tss->payload_size > 0)
3130 {
3131 sz = FFMIN(tss->payload_size, buf_size);
3132 tss->payload_size -= sz;
3133 es->size = sz;
3134 }
3135 else
3136 {
3137 if(is_video)
3138 {
3139 sz = es->size = buf_size;
3140 }
3141 else
3142 {
3143 continue;
3144 }
3145 }
3146
3147
3148 if(! probe)
3149 {
3150 *dp_offset += sz;
3151
3152 if(*dp_offset >= MAX_PACK_BYTES)
3153 {
3154 (*dp)->pts = tss->last_pts;
3155 retv = fill_packet(demuxer, ds, dp, dp_offset, si);
3156 return 1;
3157 }
3158
3159 continue;
3160 }
3161 else
3162 {
3163 memcpy(es->start, p, sz);
3164
3165 if(es->size)
3166 return es->size;
3167 else
3168 continue;
3169 }
3170 }
3171 }
3172
3173 return 0;
3174 }
3175
3176
3177 void skip_audio_frame(sh_audio_t *sh_audio);
3178
3179 static void reset_fifos(demuxer_t *demuxer, int a, int v, int s)
3180 {
3181 ts_priv_t* priv = demuxer->priv;
3182 if(a)
3183 {
3184 if(priv->fifo[0].pack != NULL)
3185 {
3186 free_demux_packet(priv->fifo[0].pack);
3187 priv->fifo[0].pack = NULL;
3188 }
3189 priv->fifo[0].offset = 0;
3190 }
3191
3192 if(v)
3193 {
3194 if(priv->fifo[1].pack != NULL)
3195 {
3196 free_demux_packet(priv->fifo[1].pack);
3197 priv->fifo[1].pack = NULL;
3198 }
3199 priv->fifo[1].offset = 0;
3200 }
3201
3202 if(s)
3203 {
3204 if(priv->fifo[2].pack != NULL)
3205 {
3206 free_demux_packet(priv->fifo[2].pack);
3207 priv->fifo[2].pack = NULL;
3208 }
3209 priv->fifo[2].offset = 0;
3210 }
3211 demuxer->reference_clock = MP_NOPTS_VALUE;
3212 }
3213
3214
3215 static void demux_seek_ts(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
3216 {
3217 demux_stream_t *d_audio=demuxer->audio;
3218 demux_stream_t *d_video=demuxer->video;
3219 sh_audio_t *sh_audio=d_audio->sh;
3220 sh_video_t *sh_video=d_video->sh;
3221 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
3222 int i, video_stats;
3223 off_t newpos;
3224
3225 //================= seek in MPEG-TS ==========================
3226
3227 ts_dump_streams(demuxer->priv);
3228 reset_fifos(demuxer, sh_audio != NULL, sh_video != NULL, demuxer->sub->id > 0);
3229
3230 demux_flush(demuxer);
3231
3232
3233
3234 video_stats = (sh_video != NULL);
3235 if(video_stats)
3236 {
3237 mp_msg(MSGT_DEMUX, MSGL_V, "IBPS: %d, vb: %d\r\n", sh_video->i_bps, priv->vbitrate);
3238 if(priv->vbitrate)
3239 video_stats = priv->vbitrate;
3240 else
3241 video_stats = sh_video->i_bps;
3242 }
3243
3244 newpos = (flags & SEEK_ABSOLUTE) ? demuxer->movi_start : demuxer->filepos;
3245 if(flags & SEEK_FACTOR) // float seek 0..1
3246 newpos+=(demuxer->movi_end-demuxer->movi_start)*rel_seek_secs;
3247 else
3248 {
3249 // time seek (secs)
3250 if(! video_stats) // unspecified or VBR
3251 newpos += 2324*75*rel_seek_secs; // 174.3 kbyte/sec
3252 else
3253 newpos += video_stats*rel_seek_secs;
3254 }
3255
3256
3257 if(newpos < demuxer->movi_start)
3258 newpos = demuxer->movi_start; //begininng of stream
3259
3260 stream_seek(demuxer->stream, newpos);
3261 for(i = 0; i < 8192; i++)
3262 if(priv->ts.pids[i] != NULL)
3263 priv->ts.pids[i]->is_synced = 0;
3264
3265 videobuf_code_len = 0;
3266
3267 if(sh_video != NULL)
3268 ds_fill_buffer(d_video);
3269
3270 if(sh_audio != NULL)
3271 {
3272 ds_fill_buffer(d_audio);
3273 }
3274
3275 while(sh_video != NULL)
3276 {
3277 if(sh_audio && !d_audio->eof && d_video->pts && d_audio->pts)
3278 {
3279 double a_pts=d_audio->pts;
3280 a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(double)sh_audio->i_bps;
3281 if(d_video->pts > a_pts)
3282 {
3283 skip_audio_frame(sh_audio); // sync audio
3284 continue;
3285 }
3286 }
3287
3288
3289 i = sync_video_packet(d_video);
3290 if((sh_video->format == VIDEO_MPEG1) || (sh_video->format == VIDEO_MPEG2))
3291 {
3292 if(i==0x1B3 || i==0x1B8) break; // found it!
3293 }
3294 else if((sh_video->format == VIDEO_MPEG4) && (i==0x1B6))
3295 break;
3296 else if(sh_video->format == VIDEO_VC1 && (i==0x10E || i==0x10F))
3297 break;
3298 else //H264
3299 {
3300 if((i & ~0x60) == 0x105 || (i & ~0x60) == 0x107) break;
3301 }
3302
3303 if(!i || !skip_video_packet(d_video)) break; // EOF?
3304 }
3305 }
3306
3307
3308 static int demux_ts_fill_buffer(demuxer_t * demuxer, demux_stream_t *ds)
3309 {
3310 ES_stream_t es;
3311 ts_priv_t *priv = (ts_priv_t *)demuxer->priv;
3312
3313 return -ts_parse(demuxer, &es, priv->packet, 0);
3314 }
3315
3316
3317 static int ts_check_file_dmx(demuxer_t *demuxer)
3318 {
3319 return ts_check_file(demuxer) ? DEMUXER_TYPE_MPEG_TS : 0;
3320 }
3321
3322 static int is_usable_program(ts_priv_t *priv, pmt_t *pmt)
3323 {
3324 int j;
3325
3326 for(j = 0; j < pmt->es_cnt; j++)
3327 {
3328 if(priv->ts.pids[pmt->es[j].pid] == NULL || priv->ts.streams[pmt->es[j].pid].sh == NULL)
3329 continue;
3330 if(
3331 priv->ts.streams[pmt->es[j].pid].type == TYPE_VIDEO ||
3332 priv->ts.streams[pmt->es[j].pid].type == TYPE_AUDIO
3333 )
3334 return 1;
3335 }
3336
3337 return 0;
3338 }
3339
3340 static int demux_ts_control(demuxer_t *demuxer, int cmd, void *arg)
3341 {
3342 ts_priv_t* priv = (ts_priv_t *)demuxer->priv;
3343
3344 switch(cmd)
3345 {
3346 case DEMUXER_CTRL_SWITCH_AUDIO:
3347 case DEMUXER_CTRL_SWITCH_VIDEO:
3348 {
3349 void *sh = NULL;
3350 int i, n;
3351 int reftype, areset = 0, vreset = 0;
3352 demux_stream_t *ds;
3353
3354 if(cmd == DEMUXER_CTRL_SWITCH_VIDEO)
3355 {
3356 reftype = TYPE_VIDEO;
3357 ds = demuxer->video;
3358 vreset = 1;
3359 }
3360 else
3361 {
3362 reftype = TYPE_AUDIO;
3363 ds = demuxer->audio;
3364 areset = 1;
3365 }
3366 n = *((int*)arg);
3367 if(n == -2)
3368 {
3369 reset_fifos(demuxer, areset, vreset, 0);
3370 ds->id = -2;
3371 ds->sh = NULL;
3372 ds_free_packs(ds);
3373 *((int*)arg) = ds->id;
3374 return DEMUXER_CTRL_OK;
3375 }
3376
3377 if(n < 0)
3378 {
3379 for(i = 0; i < 8192; i++)
3380 {
3381 if(priv->ts.streams[i].id == ds->id && priv->ts.streams[i].type == reftype)
3382 break;
3383 }
3384
3385 while(!sh)
3386 {
3387 i = (i+1) % 8192;
3388 if(priv->ts.streams[i].type == reftype)
3389 {
3390 if(priv->ts.streams[i].id == ds->id) //we made a complete loop
3391 break;
3392 sh = priv->ts.streams[i].sh;
3393 }
3394 }
3395 }
3396 else //audio track <n>
3397 {
3398 if (n >= 8192 || priv->ts.streams[n].type != reftype) return DEMUXER_CTRL_NOTIMPL;
3399 i = n;
3400 sh = priv->ts.streams[i].sh;
3401 }
3402
3403 if(sh)
3404 {
3405 if(ds->id != priv->ts.streams[i].id)
3406 reset_fifos(demuxer, areset, vreset, 0);
3407 ds->id = priv->ts.streams[i].id;
3408 ds->sh = sh;
3409 ds_free_packs(ds);
3410 mp_msg(MSGT_DEMUX, MSGL_V, "\r\ndemux_ts, switched to audio pid %d, id: %d, sh: %p\r\n", i, ds->id, sh);
3411 }
3412
3413 *((int*)arg) = ds->id;
3414 return DEMUXER_CTRL_OK;
3415 }
3416
3417 case DEMUXER_CTRL_IDENTIFY_PROGRAM: //returns in prog->{aid,vid} the new ids that comprise a program
3418 {
3419 int i, j, cnt=0;
3420 int vid_done=0, aid_done=0;
3421 pmt_t *pmt = NULL;
3422 demux_program_t *prog = arg;
3423
3424 if(priv->pmt_cnt < 2)
3425 return DEMUXER_CTRL_NOTIMPL;
3426
3427 if(prog->progid == -1)
3428 {
3429 int cur_pmt_idx = 0;
3430
3431 for(i = 0; i < priv->pmt_cnt; i++)
3432 if(priv->pmt[i].progid == priv->prog)
3433 {
3434 cur_pmt_idx = i;
3435 break;
3436 }
3437
3438 i = (cur_pmt_idx + 1) % priv->pmt_cnt;
3439 while(i != cur_pmt_idx)
3440 {
3441 pmt = &priv->pmt[i];
3442 cnt = is_usable_program(priv, pmt);
3443 if(cnt)
3444 break;
3445 i = (i + 1) % priv->pmt_cnt;
3446 }
3447 }
3448 else
3449 {
3450 for(i = 0; i < priv->pmt_cnt; i++)
3451 if(priv->pmt[i].progid == prog->progid)
3452 {
3453 pmt = &priv->pmt[i]; //required program
3454 cnt = is_usable_program(priv, pmt);
3455 }
3456 }
3457
3458 if(!cnt)
3459 return DEMUXER_CTRL_NOTIMPL;
3460
3461 //finally some food
3462 prog->aid = prog->vid = -2; //no audio and no video by default
3463 for(j = 0; j < pmt->es_cnt; j++)
3464 {
3465 if(priv->ts.pids[pmt->es[j].pid] == NULL || priv->ts.streams[pmt->es[j].pid].sh == NULL)
3466 continue;
3467
3468 if(!vid_done && priv->ts.streams[pmt->es[j].pid].type == TYPE_VIDEO)
3469 {
3470 vid_done = 1;
3471 prog->vid = pmt->es[j].pid;
3472 }
3473 else if(!aid_done && priv->ts.streams[pmt->es[j].pid].type == TYPE_AUDIO)
3474 {
3475 aid_done = 1;
3476 prog->aid = pmt->es[j].pid;
3477 }
3478 }
3479
3480 priv->prog = prog->progid = pmt->progid;
3481 return DEMUXER_CTRL_OK;
3482 }
3483
3484 default:
3485 return DEMUXER_CTRL_NOTIMPL;
3486 }
3487 }
3488
3489
3490 const demuxer_desc_t demuxer_desc_mpeg_ts = {
3491 "MPEG-TS demuxer",
3492 "mpegts",
3493 "TS",
3494 "Nico Sabbi",
3495 "",
3496 DEMUXER_TYPE_MPEG_TS,
3497 0, // unsafe autodetect
3498 ts_check_file_dmx,
3499 demux_ts_fill_buffer,
3500 demux_open_ts,
3501 demux_close_ts,
3502 demux_seek_ts,
3503 demux_ts_control
3504 };
mplayer with SMedia Glamo drivers