Mercurial > mplayer.hg

comparison libmpdemux/demux_ts.c @ 11190:dad43bc55cfc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
big demux_ts fix from Nico <nsabbi@libero.it>
author attila
date Mon, 20 Oct 2003 13:35:55 +0000
parents d4cf5407d7c6
children ec3dac7d17a0
comparison
equal deleted inserted replaced
11189:8b43f6485ac0 11190:dad43bc55cfc
32 #include "stream.h" 32 #include "stream.h"
33 #include "demuxer.h" 33 #include "demuxer.h"
34 #include "stheader.h" 34 #include "stheader.h"
35 35
36 #include "bswap.h" 36 #include "bswap.h"
37 #include "../unrarlib.h"
37 38
38 39
39 #define TS_FEC_PACKET_SIZE 204 40 #define TS_FEC_PACKET_SIZE 204
40 #define TS_PACKET_SIZE 188 41 #define TS_PACKET_SIZE 188
41 #define NB_PID_MAX 8192 42 #define NB_PID_MAX 8192
42 43
43 #define MAX_HEADER_SIZE 6 /* enough for PES header + length */ 44 #define MAX_HEADER_SIZE 6 /* enough for PES header + length */
44 #define MAX_CHECK_SIZE 65535 45 #define MAX_CHECK_SIZE 65535
45 #define MAX_PROBE_SIZE 2000000 46 #define TS_MAX_PROBE_SIZE 2000000 /* dont forget to change this in cfg-common.h too */
46 #define NUM_CONSECUTIVE_TS_PACKETS 32 47 #define NUM_CONSECUTIVE_TS_PACKETS 32
47 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348 48 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348
48 49
49 50
50 int ts_prog; 51 int ts_prog;
52 int ts_keep_broken=0;
53 off_t ts_probe = TS_MAX_PROBE_SIZE;
54 extern char *dvdsub_lang, *audio_lang; //for -alang
51 55
52 typedef enum 56 typedef enum
53 { 57 {
54 UNKNOWN = -1, 58 UNKNOWN = -1,
55 VIDEO_MPEG1 = 0x10000001, 59 VIDEO_MPEG1 = 0x10000001,
56 VIDEO_MPEG2 = 0x10000002, 60 VIDEO_MPEG2 = 0x10000002,
57 VIDEO_MPEG4 = 0x10000004, 61 VIDEO_MPEG4 = 0x10000004,
58 AUDIO_MP2 = 0x50, 62 AUDIO_MP2 = 0x50,
59 AUDIO_A52 = 0x2000, 63 AUDIO_A52 = 0x2000,
60 AUDIO_LPCM_BE = 0x10001, 64 AUDIO_LPCM_BE = 0x10001,
61 AUDIO_AAC = (('A' << 24) | ('4' << 16) | ('P' << 8) | 'M') 65 AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'),
62 /*,
63 SPU_DVD = 0x3000000, 66 SPU_DVD = 0x3000000,
64 SPU_DVB = 0x3000001, 67 SPU_DVB = 0x3000001
65 */
66 } es_stream_type_t; 68 } es_stream_type_t;
67 69
68 70
69 typedef struct { 71 typedef struct {
70 int size; 72 int size;
71 unsigned char *start; 73 unsigned char *start;
72 uint16_t payload_size; 74 uint16_t payload_size;
73 es_stream_type_t type; 75 es_stream_type_t type;
74 float pts, last_pts; 76 float pts, last_pts;
75 int pid; 77 int pid;
78 char lang[4];
76 int last_cc; // last cc code (-1 if first packet) 79 int last_cc; // last cc code (-1 if first packet)
80 uint64_t seen;
77 } ES_stream_t; 81 } ES_stream_t;
78 82
79 83
80 typedef struct MpegTSContext { 84 typedef struct MpegTSContext {
81 int packet_size; // raw packet size, including FEC if present e.g. 188 bytes 85 int packet_size; // raw packet size, including FEC if present e.g. 188 bytes
104 uint16_t id; 108 uint16_t id;
105 uint16_t pmt_pid; 109 uint16_t pmt_pid;
106 } *progs; 110 } *progs;
107 uint16_t progs_cnt; 111 uint16_t progs_cnt;
108 char buffer[65535]; 112 char buffer[65535];
109 uint8_t buffer_len; 113 uint16_t buffer_len;
110 } pat_t; 114 } pat_t;
111 115
112 typedef struct { 116 typedef struct {
113 uint16_t progid; 117 uint16_t progid;
114 uint8_t skip; 118 uint8_t skip;
115 uint8_t table_id; 119 uint8_t table_id;
120 uint8_t section_number; 124 uint8_t section_number;
121 uint8_t last_section_number; 125 uint8_t last_section_number;
122 uint16_t PCR_PID; 126 uint16_t PCR_PID;
123 uint16_t prog_descr_length; 127 uint16_t prog_descr_length;
124 char buffer[2048]; 128 char buffer[2048];
125 uint8_t buffer_len; 129 uint16_t buffer_len;
126 uint16_t es_cnt; 130 uint16_t es_cnt;
127 struct pmt_es_t { 131 struct pmt_es_t {
128 uint16_t pid; 132 uint16_t pid;
129 uint32_t type; //it's 8 bit long, but cast to the right type as FOURCC 133 uint32_t type; //it's 8 bit long, but cast to the right type as FOURCC
130 uint16_t descr_length; 134 uint16_t descr_length;
135 uint8_t format_descriptor[5];
136 uint8_t lang[4];
131 } *es; 137 } *es;
132 } pmt_t; 138 } pmt_t;
133 139
134 typedef struct { 140 typedef struct {
135 MpegTSContext ts; 141 MpegTSContext ts;
136 int is_synced; //synced to the beginning of priv->last_pid PES header
137 int last_afc; //bytes read from the last adaption field
138 int last_pid; 142 int last_pid;
139 int is_start; 143 av_fifo_t fifo[3]; //0 for audio, 1 for video, 2 for subs
140 int eof;
141 av_fifo_t fifo[2]; //0 for audio, 1 for video
142 pat_t pat; 144 pat_t pat;
143 pmt_t *pmt; 145 pmt_t *pmt;
144 uint16_t pmt_cnt; 146 uint16_t pmt_cnt;
145 uint32_t prog; 147 uint32_t prog;
148 int keep_broken;
146 } ts_priv_t; 149 } ts_priv_t;
147 150
148 151
149 static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe); 152 static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe);
150 extern void resync_audio_stream( sh_audio_t *sh_audio ); 153 extern void resync_audio_stream( sh_audio_t *sh_audio );
183 unsigned char buf[TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS], done = 0, *ptr; 186 unsigned char buf[TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS], done = 0, *ptr;
184 uint32_t _read, i, count = 0, is_ts; 187 uint32_t _read, i, count = 0, is_ts;
185 int cc[NB_PID_MAX], last_cc[NB_PID_MAX], pid, cc_ok, c, good, bad; 188 int cc[NB_PID_MAX], last_cc[NB_PID_MAX], pid, cc_ok, c, good, bad;
186 uint8_t size = 0; 189 uint8_t size = 0;
187 off_t pos = 0; 190 off_t pos = 0;
191 off_t init_pos;
188 192
189 mp_msg(MSGT_DEMUX, MSGL_V, "Checking for MPEG-TS...\n"); 193 mp_msg(MSGT_DEMUX, MSGL_V, "Checking for MPEG-TS...\n");
190 194
195 init_pos = stream_tell(demuxer->stream);
191 is_ts = 0; 196 is_ts = 0;
192 while(! done) 197 while(! done)
193 { 198 {
194 i = 1; 199 i = 1;
195 c = 0; 200 c = 0;
225 { 230 {
226 done = 1; 231 done = 1;
227 is_ts = 1; 232 is_ts = 1;
228 } 233 }
229 234
230 if(pos >= MAX_CHECK_SIZE) 235 if(pos - init_pos >= MAX_CHECK_SIZE)
231 { 236 {
232 done = 1; 237 done = 1;
233 is_ts = 0; 238 is_ts = 0;
234 } 239 }
235 } 240 }
236 241
237 mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %u, FOUND %x, packet_size= %d\n", pos, c, size); 242 mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %llu, FOUND %x, packet_size= %d, SEEMS A TS? %d\n", (uint64_t) pos, c, size, is_ts);
238 stream_seek(demuxer->stream, pos); 243 stream_seek(demuxer->stream, pos);
239 244
240 if(! is_ts) 245 if(! is_ts)
241 return 0; 246 return 0;
242 247
324 } 329 }
325 return -1; 330 return -1;
326 } 331 }
327 332
328 333
329 static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int *fapid, int *fvpid, int32_t *prog) 334 static inline int pid_match_lang(ts_priv_t *priv, uint16_t pid, char *lang)
330 { 335 {
331 int video_found = 0, audio_found = 0, i, num_packets = 0, req_apid, req_vpid; 336 uint16_t i, j;
332 int is_audio, is_video, has_tables; 337 pmt_t *pmt;
333 int32_t p, chosen_pid; 338
334 off_t pos=0; 339 if(priv->pmt == NULL)
340 return -1;
341
342 for(i=0; i < priv->pmt_cnt; i++)
343 {
344 pmt = &(priv->pmt[i]);
345
346 if(pmt->es == NULL)
347 return -1;
348
349 for(j = 0; j < pmt->es_cnt; j++)
350 {
351 if(pmt->es[j].pid != pid)
352 continue;
353
354 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);
355 if(strncmp(pmt->es[j].lang, lang, 3) == 0)
356 {
357 return 1;
358 }
359 }
360
361 }
362
363 return -1;
364 }
365
366 typedef struct {
367 int32_t atype, vtype, stype; //types
368 int32_t apid, vpid, spid; //stream ids
369 char slang[4], alang[4]; //languages
370 int16_t prog;
371 off_t probe;
372 } tsdemux_init_t;
373
374 static off_t ts_detect_streams(demuxer_t *demuxer, tsdemux_init_t *param)
375 {
376 int video_found = 0, audio_found = 0, sub_found = 0, i, num_packets = 0, req_apid, req_vpid, req_spid;
377 int is_audio, is_video, is_sub, has_tables;
378 int32_t p, chosen_pid = 0;
379 off_t pos=0, ret = 0, init_pos;
335 ES_stream_t es; 380 ES_stream_t es;
336 unsigned char tmp[TS_FEC_PACKET_SIZE]; 381 unsigned char tmp[TS_FEC_PACKET_SIZE];
337 ts_priv_t *priv = (ts_priv_t*) demuxer->priv; 382 ts_priv_t *priv = (ts_priv_t*) demuxer->priv;
338 383
339 priv->is_synced = 0;
340 priv->last_afc = 0;
341 priv->last_pid = 8192; //invalid pid 384 priv->last_pid = 8192; //invalid pid
342 priv->is_start = 0; 385
343 priv->eof = 0; 386 req_apid = param->apid;
344 387 req_vpid = param->vpid;
345 req_apid = *fapid; 388 req_spid = param->spid;
346 req_vpid = *fvpid;
347 389
348 has_tables = 0; 390 has_tables = 0;
349 mp_msg(MSGT_DEMUXER, MSGL_INFO, "PROBING UP TO %u, PROG: %d\n", MAX_PROBE_SIZE, *prog); 391 init_pos = stream_tell(demuxer->stream);
350 while(pos <= MAX_PROBE_SIZE) 392 mp_msg(MSGT_DEMUXER, MSGL_INFO, "PROBING UP TO %llu, PROG: %d\n", (uint64_t) param->probe, param->prog);
393 while((pos <= init_pos + param->probe) && (! demuxer->stream->eof))
351 { 394 {
352 pos = stream_tell(demuxer->stream); 395 pos = stream_tell(demuxer->stream);
353 if(ts_parse(demuxer, &es, tmp, 1)) 396 if(ts_parse(demuxer, &es, tmp, 1))
354 { 397 {
355 is_audio = ((es.type == AUDIO_MP2) || (es.type == AUDIO_A52) || (es.type == AUDIO_LPCM_BE) || (es.type == AUDIO_AAC)); 398 is_audio = ((es.type == AUDIO_MP2) || (es.type == AUDIO_A52) || (es.type == AUDIO_LPCM_BE) || (es.type == AUDIO_AAC));
356 is_video = ((es.type == VIDEO_MPEG1) || (es.type == VIDEO_MPEG2) || (es.type == VIDEO_MPEG4)); 399 is_video = ((es.type == VIDEO_MPEG1) || (es.type == VIDEO_MPEG2) || (es.type == VIDEO_MPEG4));
357 400 is_sub = ((es.type == SPU_DVD) || (es.type == SPU_DVB));
358 if((! is_audio) && (! is_video)) 401
402
403 if((! is_audio) && (! is_video) && (! is_sub))
359 continue; 404 continue;
360 405
361 if(is_video) 406 if(is_video)
362 { 407 {
363 chosen_pid = (req_vpid == es.pid); 408 chosen_pid = (req_vpid == es.pid);
364 if((! chosen_pid) && (req_vpid > 0)) 409 if((! chosen_pid) && (req_vpid > 0))
365 continue; 410 continue;
366 } 411 }
367 else if(is_audio) 412 else if(is_audio)
368 { 413 {
369 chosen_pid = (req_apid == es.pid); 414 if(req_apid > 0)
370 if((! chosen_pid) && (req_apid > 0)) 415 {
416 chosen_pid = (req_apid == es.pid);
417 if(! chosen_pid)
418 continue;
419 }
420 else if(param->alang[0] > 0)
421 {
422 if(pid_match_lang(priv, es.pid, param->alang) == -1)
423 continue;
424
425 chosen_pid = 1;
426 param->apid = req_apid = es.pid;
427 }
428 }
429 else if(is_sub)
430 {
431 chosen_pid = (req_spid == es.pid);
432 if((! chosen_pid) && (req_spid > 0))
371 continue; 433 continue;
372 } 434 }
373 435
374 if(req_vpid < 0 && req_apid < 0) 436 if(req_apid < 0 && (param->alang[0] == 0) && req_vpid < 0 && req_spid < 0)
375 chosen_pid = 1; 437 chosen_pid = 1;
376 438
377 p = progid_for_pid(priv, es.pid, *prog); 439 if((ret == 0) && chosen_pid)
440 {
441 ret = stream_tell(demuxer->stream);
442 }
443
444 p = progid_for_pid(priv, es.pid, param->prog);
378 if(p != -1) 445 if(p != -1)
379 has_tables++; 446 has_tables++;
380 447
381 if((*prog == 0) && (p != -1)) 448 if((param->prog == 0) && (p != -1))
382 { 449 {
383 if(chosen_pid) 450 if(chosen_pid)
384 *prog = p; 451 param->prog = p;
385 } 452 }
386 453
387 if((*prog > 0) && (*prog != p)) 454 if((param->prog > 0) && (param->prog != p))
388 { 455 {
389 if(audio_found) 456 if(audio_found)
390 { 457 {
391 if(is_video && (req_vpid == es.pid)) 458 if(is_video && (req_vpid == es.pid))
392 { 459 {
393 *v = es.type; 460 param->vtype = es.type;
394 *fvpid = es.pid; 461 param->vpid = es.pid;
395 video_found = 1; 462 video_found = 1;
396 break; 463 break;
397 } 464 }
398 } 465 }
399 466
400 if(video_found) 467 if(video_found)
401 { 468 {
402 if(is_audio && (req_apid == es.pid)) 469 if(is_audio && (req_apid == es.pid))
403 { 470 {
404 *a = es.type; 471 param->atype = es.type;
405 *fapid = es.pid; 472 param->apid = es.pid;
406 audio_found = 1; 473 audio_found = 1;
407 break; 474 break;
408 } 475 }
409 } 476 }
410 477
411 478
412 continue; 479 continue;
413 } 480 }
414 481
415 482
416 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, *prog); 483 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, param->prog);
417 484
418 485
419 if(is_video) 486 if(is_video)
420 { 487 {
421 if((req_vpid == -1) || (req_vpid == es.pid)) 488 if((req_vpid == -1) || (req_vpid == es.pid))
422 { 489 {
423 *v = es.type; 490 param->vtype = es.type;
424 *fvpid = es.pid; 491 param->vpid = es.pid;
425 video_found = 1; 492 video_found = 1;
426 } 493 }
427 } 494 }
428 495
429 496
430 if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found) 497 if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found)
431 { 498 {
432 //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only) 499 //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only)
433 *v = 0; 500 param->vtype = 0;
434 break; 501 break;
435 } 502 }
436 503
504 if(is_sub)
505 {
506 if((req_spid == -1) || (req_spid == es.pid))
507 {
508 param->stype = es.type;
509 param->spid = es.pid;
510 sub_found = 1;
511 }
512 }
437 513
438 if(is_audio) 514 if(is_audio)
439 { 515 {
440 if((req_apid == -1) || (req_apid == es.pid)) 516 if((req_apid == -1) || (req_apid == es.pid))
441 { 517 {
442 *a = es.type; 518 param->atype = es.type;
443 *fapid = es.pid; 519 param->apid = es.pid;
444 audio_found = 1; 520 audio_found = 1;
445 } 521 }
446 } 522 }
447 523
448 if(audio_found && (*fapid == es.pid) && (! video_found)) 524 if(audio_found && (param->apid == es.pid) && (! video_found))
449 num_packets++; 525 num_packets++;
450 526
451 if((req_apid == -2) && video_found) 527 if((req_apid == -2) && video_found)
452 { 528 {
453 *a = 0; 529 param->atype = 0;
454 break; 530 break;
455 } 531 }
456 532
457 if((has_tables==0) && (video_found && audio_found) && (pos >= 1000000)) 533 if((has_tables==0) && (video_found && audio_found) && (pos >= 1000000))
458 break; 534 break;
459 } 535 }
460 } 536 }
461 537
462 if(video_found) 538 if(video_found)
463 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG%d(pid=%d)...", (*v == VIDEO_MPEG1 ? 1 : (*v == VIDEO_MPEG2 ? 2 : 4)), *fvpid); 539 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG%d(pid=%d)...", (param->vtype == VIDEO_MPEG1 ? 1 : (param->vtype == VIDEO_MPEG2 ? 2 : 4)), param->vpid);
464 else 540 else
465 { 541 {
466 //WE DIDN'T MATCH ANY VIDEO STREAM 542 video_found = 0;
467 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! "); 543 param->vtype = UNKNOWN;
468 } 544 //WE DIDN'T MATCH ANY VIDEO STREAM
469 545 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! ");
470 if(*a == AUDIO_MP2) 546 }
471 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MP2(pid=%d)", *fapid); 547
472 else if(*a == AUDIO_A52) 548 if(param->atype == AUDIO_MP2)
473 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", *fapid); 549 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MP2(pid=%d)", param->apid);
474 else if(*a == AUDIO_LPCM_BE) 550 else if(param->atype == AUDIO_A52)
475 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", *fapid); 551 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", param->apid);
476 else if(*a == AUDIO_AAC) 552 else if(param->atype == AUDIO_LPCM_BE)
477 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", *fapid); 553 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", param->apid);
554 else if(param->atype == AUDIO_AAC)
555 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", param->apid);
478 else 556 else
479 { 557 {
558 audio_found = 0;
559 param->atype = UNKNOWN;
480 //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO 560 //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO
481 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO AUDIO! "); 561 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO AUDIO! ");
482 } 562 }
483 563
484 mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", *prog); 564 if(param->stype == SPU_DVD || param->stype == SPU_DVB)
565 mp_msg(MSGT_DEMUXER, MSGL_INFO, " SUB DVx(pid=%d) ", param->spid);
566 else
567 {
568 param->stype = UNKNOWN;
569 mp_msg(MSGT_DEMUXER, MSGL_INFO, " NO SUBS (yet)! ");
570 }
571
572 if(video_found || audio_found)
573 {
574 if(demuxer->stream->eof && (ret == 0))
575 ret = init_pos;
576 mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", param->prog);
577 }
578 else
579 mp_msg(MSGT_DEMUXER, MSGL_INFO, "\n");
580
485 581
486 for(i=0; i<8192; i++) 582 for(i=0; i<8192; i++)
487 { 583 {
488 if(priv->ts.pids[i] != NULL) 584 if(priv->ts.pids[i] != NULL)
489 { 585 {
490 priv->ts.pids[i]->payload_size = 0; 586 priv->ts.pids[i]->payload_size = 0;
491 priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0; 587 priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0;
492 //priv->ts.pids[i]->type = UNKNOWN; 588 priv->ts.pids[i]->seen = 0;
493 } 589 priv->ts.pids[i]->last_cc = -1;
494 } 590 }
495 } 591 }
496 592
593 return ret;
594 }
497 595
498 596
499 demuxer_t *demux_open_ts(demuxer_t * demuxer) 597 demuxer_t *demux_open_ts(demuxer_t * demuxer)
500 { 598 {
501 int i; 599 int i;
502 uint8_t packet_size; 600 uint8_t packet_size;
503 sh_video_t *sh_video; 601 sh_video_t *sh_video;
504 sh_audio_t *sh_audio; 602 sh_audio_t *sh_audio;
505 uint32_t at = 0, vt = 0; 603 off_t start_pos;
604 tsdemux_init_t params;
506 ts_priv_t * priv = (ts_priv_t*) demuxer->priv; 605 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
507 demuxer_t *od; 606
508 607 mp_msg(MSGT_DEMUX, MSGL_INFO, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n",
509 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n",
510 demuxer->audio->id, demuxer->video->id, demuxer->sub->id); 608 demuxer->audio->id, demuxer->video->id, demuxer->sub->id);
511 609
512 610
513 demuxer->type= DEMUXER_TYPE_MPEG_TS; 611 demuxer->type= DEMUXER_TYPE_MPEG_TS;
514 612
515 613
516 stream_reset(demuxer->stream); 614 stream_reset(demuxer->stream);
517 stream_seek(demuxer->stream, 0);
518 615
519 packet_size = ts_check_file(demuxer); 616 packet_size = ts_check_file(demuxer);
520 if(!packet_size) 617 if(!packet_size)
521 return NULL; 618 return NULL;
522 619
523 priv = malloc(sizeof(ts_priv_t)); 620 priv = malloc(sizeof(ts_priv_t));
524 if(priv == NULL) 621 if(priv == NULL)
525 { 622 {
526 mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate %lu bytes, exit\n", 623 mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n");
527 sizeof(ts_priv_t));
528 return NULL; 624 return NULL;
529 } 625 }
530 626
531 for(i=0; i < 8192; i++) 627 for(i=0; i < 8192; i++)
532 priv->ts.pids[i] = NULL; 628 priv->ts.pids[i] = NULL;
534 priv->pat.progs_cnt = 0; 630 priv->pat.progs_cnt = 0;
535 631
536 priv->pmt = NULL; 632 priv->pmt = NULL;
537 priv->pmt_cnt = 0; 633 priv->pmt_cnt = 0;
538 634
635 priv->keep_broken = ts_keep_broken;
539 priv->ts.packet_size = packet_size; 636 priv->ts.packet_size = packet_size;
540 637
541 638
542 demuxer->priv = priv; 639 demuxer->priv = priv;
543 if(demuxer->stream->type != STREAMTYPE_FILE) 640 if(demuxer->stream->type != STREAMTYPE_FILE)
544 demuxer->seekable = 0; 641 demuxer->seekable = 1;
545 else 642 else
546 demuxer->seekable = 1; 643 demuxer->seekable = 1;
547 644
548 stream_seek(demuxer->stream, 0); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES? 645
549 ts_detect_streams(demuxer, &at, &vt, &demuxer->audio->id, &demuxer->video->id, &ts_prog); 646 params.atype = params.vtype = params.stype = UNKNOWN;
550 mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...\n", at, demuxer->audio->id, vt, demuxer->video->id); 647 params.apid = demuxer->audio->id;
551 648 params.vpid = demuxer->video->id;
552 649 params.spid = demuxer->sub->id;
553 if(vt) 650 params.prog = ts_prog;
554 { 651 params.probe = ts_probe;
555 if(vt == VIDEO_MPEG4) 652
653 if(dvdsub_lang != NULL)
654 {
655 strncpy(params.slang, dvdsub_lang, 3);
656 params.slang[3] = 0;
657 }
658 else
659 memset(params.slang, 0, 4);
660
661 if(audio_lang != NULL)
662 {
663 strncpy(params.alang, audio_lang, 3);
664 params.alang[3] = 0;
665 }
666 else
667 memset(params.alang, 0, 4);
668
669 start_pos = ts_detect_streams(demuxer, &params);
670
671 demuxer->audio->id = params.apid;
672 demuxer->video->id = params.vpid;
673 demuxer->sub->id = params.spid;
674 priv->prog = params.prog;
675
676
677 if(params.vtype != UNKNOWN)
678 {
679 if(params.vtype == VIDEO_MPEG4)
556 demuxer->file_format= DEMUXER_TYPE_MPEG4_IN_TS; 680 demuxer->file_format= DEMUXER_TYPE_MPEG4_IN_TS;
557 681
558 sh_video = new_sh_video(demuxer, 0); 682 sh_video = new_sh_video(demuxer, 0);
559 sh_video->ds = demuxer->video; 683 sh_video->ds = demuxer->video;
560 sh_video->format = vt; 684 sh_video->format = params.vtype;
561 demuxer->video->sh = sh_video; 685 demuxer->video->sh = sh_video;
562 686 }
563 mp_msg(MSGT_DEMUXER,MSGL_INFO, "OPENED_SH_VIDEO\n"); 687
564 } 688 if(params.atype != UNKNOWN)
565
566 if(at)
567 { 689 {
568 sh_audio = new_sh_audio(demuxer, 0); 690 sh_audio = new_sh_audio(demuxer, 0);
569 sh_audio->ds = demuxer->audio; 691 sh_audio->ds = demuxer->audio;
570 sh_audio->format = at; 692 sh_audio->format = params.atype;
571 demuxer->audio->sh = sh_audio; 693 demuxer->audio->sh = sh_audio;
572 694 }
573 mp_msg(MSGT_DEMUXER,MSGL_INFO, "OPENED_SH_AUDIO\n"); 695
574 } 696
575 697 mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...POS=%llu\n", params.atype, demuxer->audio->id, params.vtype, demuxer->video->id, (uint64_t) start_pos);
576 698
577 mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer2\n"); 699
578 700 start_pos = (start_pos <= priv->ts.packet_size ? 0 : start_pos - priv->ts.packet_size);
579 /* 701 demuxer->movi_start = start_pos;
580 demuxer->movi_start = 0; 702 stream_reset(demuxer->stream);
581 demuxer->movi_end = demuxer->stream->end_pos; 703 stream_seek(demuxer->stream, start_pos); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES?
582 */ 704
583 705
584 stream_seek(demuxer->stream, 0); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES?
585
586
587
588 priv->is_synced = 0;
589 priv->last_afc = 0;
590 priv->last_pid = 8192; //invalid pid 706 priv->last_pid = 8192; //invalid pid
591 priv->is_start = 0; 707
592 708 for(i = 0; i < 3; i++)
593 for(i=0; i< 2; i++)
594 { 709 {
595 priv->fifo[i].pack = NULL; 710 priv->fifo[i].pack = NULL;
596 priv->fifo[i].offset = 0; 711 priv->fifo[i].offset = 0;
597 priv->fifo[i].broken = 1; 712 priv->fifo[i].broken = 1;
598 } 713 }
599 priv->fifo[0].ds = demuxer->audio; 714 priv->fifo[0].ds = demuxer->audio;
600 priv->fifo[1].ds = demuxer->video; 715 priv->fifo[1].ds = demuxer->video;
716 priv->fifo[2].ds = demuxer->sub;
601 717
602 priv->fifo[0].buffer_size = 1536; 718 priv->fifo[0].buffer_size = 1536;
603 priv->fifo[1].buffer_size = 32767; 719 priv->fifo[1].buffer_size = 32767;
604 priv->eof = 0; 720 priv->fifo[2].buffer_size = 32767;
605 721
606 priv->pat.buffer_len = 0; 722 priv->pat.buffer_len = 0;
607 723
608 demuxer->filepos = stream_tell(demuxer->stream); 724 demuxer->filepos = stream_tell(demuxer->stream);
609 return demuxer; 725 return demuxer;
610 } 726 }
611 727
612
613
614
615
616
617 void demux_close_ts(demuxer_t * demuxer) 728 void demux_close_ts(demuxer_t * demuxer)
618 { 729 {
619 if(demuxer->priv) 730 if(demuxer->priv)
620 { 731 {
621 free(demuxer->priv); 732 free(demuxer->priv);
622 demuxer->priv=NULL; 733 demuxer->priv=NULL;
623 } 734 }
624 } 735 }
625
626
627
628
629 736
630 static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt) 737 static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt)
631 { 738 {
632 unsigned char *p; 739 unsigned char *p;
633 uint32_t header_len; 740 uint32_t header_len;
639 //uint8_t es_rate_flag, escr_flag, pts_flag; 746 //uint8_t es_rate_flag, escr_flag, pts_flag;
640 //int64_t escr, dts; 747 //int64_t escr, dts;
641 //uint32_t es_rate; 748 //uint32_t es_rate;
642 749
643 //Here we are always at the start of a PES packet 750 //Here we are always at the start of a PES packet
644 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%X, %d): \n", buf, packet_len); 751 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%p, %d): \n", buf, (uint32_t) packet_len);
645 752
646 if(packet_len == 0) 753 if(packet_len == 0)
647 { 754 {
648 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(,PACKET_LEN = 0, EXIT\n"); 755 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(,PACKET_LEN = 0, EXIT\n");
649 return 0; 756 return 0;
667 return 0 ; 774 return 0 ;
668 } 775 }
669 776
670 packet_len -= 6; 777 packet_len -= 6;
671 if(packet_len==0) 778 if(packet_len==0)
779 {
780 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: packet too short: %d, exit\n", packet_len);
672 return 0; 781 return 0;
782 }
673 783
674 es->payload_size = (p[4] << 8 | p[5]); 784 es->payload_size = (p[4] << 8 | p[5]);
675 785
676 stream_id = p[3]; 786 stream_id = p[3];
677 787
727 } 837 }
728 838
729 p += header_len + 9; 839 p += header_len + 9;
730 packet_len -= header_len + 3; 840 packet_len -= header_len + 3;
731 841
842 /*
843 if(packet_len <= 0)
844 mp_msg(MSGT_DEMUX, MSGL_INFO, "\n\nNow: %d, prima: %d, ORIG: %d\n\n\n", packet_len, packet_len+3+header_len, pkt_len);
845 */
846
732 if(es->payload_size) 847 if(es->payload_size)
733 es->payload_size -= header_len + 3; 848 es->payload_size -= header_len + 3;
734 849
735 850
736 if (stream_id == 0xbd) 851 if (stream_id == 0xbd)
739 854
740 mp_msg(MSGT_DEMUX, MSGL_DBG3, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n", 855 mp_msg(MSGT_DEMUX, MSGL_DBG3, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n",
741 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80); 856 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80);
742 857
743 track = p[0] & 0x0F; 858 track = p[0] & 0x0F;
744 mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 TRACK: %d\n", track); 859 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 TRACK: %d\n", track);
745 860
746 861
747 /* 862 /*
748 * we check the descriptor tag first because some stations 863 * we check the descriptor tag first because some stations
749 * do not include any of the ac3 header info in their audio tracks 864 * do not include any of the A52 header info in their audio tracks
750 * these "raw" streams may begin with a byte that looks like a stream type. 865 * these "raw" streams may begin with a byte that looks like a stream type.
751 */ 866 */
752 867
753 868
754 if( 869 if(
755 (type_from_pmt == AUDIO_A52) || /* ac3 - raw */ 870 (type_from_pmt == AUDIO_A52) || /* A52 - raw */
756 (p[0] == 0x0B && p[1] == 0x77) /* ac3 - syncword */ 871 (p[0] == 0x0B && p[1] == 0x77) /* A52 - syncword */
757 ) 872 )
758 { 873 {
759 mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 RAW OR SYNCWORD\n"); 874 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 RAW OR SYNCWORD\n");
760 es->start = p; 875 es->start = p;
761 es->size = packet_len; 876 es->size = packet_len;
762 es->type = AUDIO_A52; 877 es->type = AUDIO_A52;
763 es->payload_size -= packet_len; 878 es->payload_size -= packet_len;
764 879
765 return es->size; 880 return 1;
766 } 881 }
767 /* 882 /* SPU SUBS */
768 SUBS, it seems they are not streams in g1, what to do? 883 else if(type_from_pmt == SPU_DVB ||
769 else if (//m->descriptor_tag == 0x06 && 884 (p[0] == 0x20)) // && p[1] == 0x00))
770 p[0] == 0x20 && p[1] == 0x00) 885 {
771 {
772 // DVBSUB
773 long payload_len = ((buf[4] << 8) | buf[5]) - header_len - 3;
774 es->start = p; 886 es->start = p;
775 es->size = packet_len; 887 es->size = packet_len;
776 es->type = SPU_DVB + payload_len; 888 es->type = SPU_DVB;
777 es->payload_size -= packet_len; 889 es->payload_size -= packet_len;
778 890
779 return es->size; 891 return 1;
780 } 892 }
781 893 else if ((p[0] & 0xE0) == 0x20) //SPU_DVD
782 else if ((p[0] & 0xE0) == 0x20) 894 {
783 { 895 //DVD SUBS
784 spu_id = (p[0] & 0x1f);
785 es->start = p+1; 896 es->start = p+1;
786 es->size = packet_len-1; 897 es->size = packet_len-1;
787 es->type = SPU_DVD + spu_id; 898 es->type = SPU_DVD;
788 es->payload_size -= packet_len; 899 es->payload_size -= packet_len;
789 900
790 return es->size; 901 return 1;
791 } 902 }
792 */
793 else if ((p[0] & 0xF0) == 0x80) 903 else if ((p[0] & 0xF0) == 0x80)
794 { 904 {
795 mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 WITH HEADER\n"); 905 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 WITH HEADER\n");
796 es->start = p+4; 906 es->start = p+4;
797 es->size = packet_len - 4; 907 es->size = packet_len - 4;
798 es->type = AUDIO_A52; 908 es->type = AUDIO_A52;
799 es->payload_size -= packet_len; 909 es->payload_size -= packet_len;
800 910
801 return es->size; 911 return 1;
802 } 912 }
803 else if ((p[0]&0xf0) == 0xa0) 913 else if ((p[0]&0xf0) == 0xa0)
804 { 914 {
805 int pcm_offset; 915 int pcm_offset;
806 916
816 es->start = p + pcm_offset; 926 es->start = p + pcm_offset;
817 es->size = packet_len - pcm_offset; 927 es->size = packet_len - pcm_offset;
818 es->type = AUDIO_LPCM_BE; 928 es->type = AUDIO_LPCM_BE;
819 es->payload_size -= packet_len; 929 es->payload_size -= packet_len;
820 930
821 return es->size; 931 return 1;
822 } 932 }
823 } 933 }
824 else if ((stream_id >= 0xbc) && ((stream_id & 0xf0) == 0xe0)) 934 else if ((stream_id >= 0xbc) && ((stream_id & 0xf0) == 0xe0))
825 { 935 {
826 es->start = p; 936 es->start = p;
827 es->size = packet_len; 937 es->size = packet_len;
828 es->type = VIDEO_MPEG2; 938 es->type = VIDEO_MPEG2;
829 if(es->payload_size) 939 if(es->payload_size)
830 es->payload_size -= packet_len; 940 es->payload_size -= packet_len;
831 941
832 return es->size; 942 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: M2V size %d\n", es->size);
943 return 1;
833 } 944 }
834 else if ((stream_id == 0xfa)) 945 else if ((stream_id == 0xfa))
835 { 946 {
836 if(type_from_pmt != -1) //MP4 A/V 947 if(type_from_pmt != -1) //MP4 A/V
837 { 948 {
839 es->size = packet_len; 950 es->size = packet_len;
840 es->type = type_from_pmt; 951 es->type = type_from_pmt;
841 if(es->payload_size) 952 if(es->payload_size)
842 es->payload_size -= packet_len; 953 es->payload_size -= packet_len;
843 954
844 return es->size; 955 return 1;
845 } 956 }
846 } 957 }
847 else if ((stream_id & 0xe0) == 0xc0) 958 else if ((stream_id & 0xe0) == 0xc0)
848 { 959 {
849 int track; 960 int profile = 0, srate = 0, channels = 0;
850 961 uint32_t hdr, l = 0;
851 track = stream_id & 0x1f; 962
963 hdr = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
964 if((hdr & 0xfff00000) == 0xfff00000)
965 {
966 // ADTS AAC shows with MPA layer 4 (00 in the layer bitstream)
967 l = 4 - ((hdr & 0x00060000) >> 17);
968 profile = ((hdr & 0x0000C000) >> 14);
969 srate = ((hdr & 0x00003c00) >> 10);
970 channels = ((hdr & 0x000001E0) >> 5);
971 }
972 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\n\naudio header: %2X %2X %2X %2X\nLAYER: %d, PROFILE: %d, SRATE=%d, CHANNELS=%d\n\n", p[0], p[1], p[3], p[4], l, profile, srate, channels);
973
852 es->start = p; 974 es->start = p;
853 es->size = packet_len; 975 es->size = packet_len;
854 es->type = AUDIO_MP2; 976
977
978 //if((type_from_pmt == 0x0f) || (l == 4)) //see in parse_pmt()
979 if(l==4)
980 es->type = AUDIO_AAC;
981 else
982 es->type = AUDIO_MP2;
983
855 es->payload_size -= packet_len; 984 es->payload_size -= packet_len;
856 985
857 return es->size; 986 return 1;
858 } 987 }
859 else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present 988 else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present
860 { 989 {
861 es->start = p; 990 es->start = p;
862 es->size = packet_len; 991 es->size = packet_len;
863 es->type = type_from_pmt; 992 es->type = type_from_pmt;
864 es->payload_size -= packet_len; 993 es->payload_size -= packet_len;
865 994
866 return es->size; 995 return 1;
867 } 996 }
868
869 else 997 else
870 { 998 {
871 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id); 999 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id);
872 } 1000 }
873 1001
894 1022
895 static void ts_dump_streams(ts_priv_t *priv) 1023 static void ts_dump_streams(ts_priv_t *priv)
896 { 1024 {
897 int i; 1025 int i;
898 1026
899 for(i = 0; i < 2; i++) 1027 for(i = 0; i < 3; i++)
900 { 1028 {
901 if((priv->fifo[i].pack != NULL) && (priv->fifo[i].offset != 0)) 1029 if((priv->fifo[i].pack != NULL) && (priv->fifo[i].offset != 0))
902 { 1030 {
903 resize_demux_packet(priv->fifo[i].pack, priv->fifo[i].offset); 1031 resize_demux_packet(priv->fifo[i].pack, priv->fifo[i].offset);
904 ds_add_packet(priv->fifo[i].ds, priv->fifo[i].pack); 1032 ds_add_packet(priv->fifo[i].ds, priv->fifo[i].pack);
905 } 1033 priv->fifo[i].offset = 0;
906 } 1034 priv->fifo[i].pack = NULL;
907 1035 }
908 priv->eof = 1; 1036 priv->fifo[i].broken = 1;
1037 }
909 } 1038 }
910 1039
911 1040
912 static inline int32_t prog_idx_in_pat(ts_priv_t *priv, uint16_t progid) 1041 static inline int32_t prog_idx_in_pat(ts_priv_t *priv, uint16_t progid)
913 { 1042 {
940 } 1069 }
941 1070
942 return -1; 1071 return -1;
943 } 1072 }
944 1073
1074 /*
1075 DON'T REMOVE, I'LL NEED IT IN THE (NEAR) FUTURE)
1076 static int check_crc32(uint32_t val, uint8_t *ptr, uint16_t len, uint8_t *vbase)
1077 {
1078 uint32_t tab_crc32, calc_crc32;
1079
1080 calc_crc32 = CalcCRC32(val, ptr, len);
1081
1082 tab_crc32 = (vbase[0] << 24) | (vbase[1] << 16) | (vbase[2] << 8) | vbase[3];
1083
1084 printf("CRC32, TAB: %x, CALC: %x, eq: %x\n", tab_crc32, calc_crc32, tab_crc32 == calc_crc32);
1085 return (tab_crc32 == calc_crc32);
1086
1087 }
1088 */
945 1089
946 static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size) 1090 static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size)
947 { 1091 {
948 uint8_t skip, m = 0; 1092 uint8_t skip, m = 0;
949 unsigned char *ptr; 1093 unsigned char *ptr;
950 unsigned char *base; //, *crc; 1094 unsigned char *base;
951 int entries, i, sections; 1095 int entries, i, sections;
952 uint16_t progid; 1096 uint16_t progid;
953 //uint32_t o_crc, calc_crc;
954 1097
955 //PRE-FILLING 1098 //PRE-FILLING
956 if(! is_start) 1099 if(! is_start)
957 { 1100 {
958 if(priv->pat.buffer_len == 0) //a broken packet 1101 if(priv->pat.buffer_len == 0) //a broken packet
994 priv->pat.version_number = (ptr[5] >> 1) & 0x1F; 1137 priv->pat.version_number = (ptr[5] >> 1) & 0x1F;
995 priv->pat.section_length = ((ptr[1] & 0x03) << 8 ) | ptr[2]; 1138 priv->pat.section_length = ((ptr[1] & 0x03) << 8 ) | ptr[2];
996 priv->pat.section_number = ptr[6]; 1139 priv->pat.section_number = ptr[6];
997 priv->pat.last_section_number = ptr[7]; 1140 priv->pat.last_section_number = ptr[7];
998 1141
999 /*CRC CHECK
1000 crc = &(priv->pat.buffer[priv->pat.section_length - 4]);
1001 o_crc = (crc[0] << 24) | (crc[1] << 16) | (crc[2] << 8) | crc[3];
1002 calc_crc = CalcCRC32(0xFFFFFFFFL, priv->pat.buffer, priv->pat.section_length);
1003 printf("CRC ORIGINALE: %x, CALCOLATO: %x\n", o_crc, calc_crc);
1004 */
1005
1006 1142
1007 if((! priv->pat.curr_next) || (priv->pat.table_id != 0)) // || (! priv->pat.ssi)) 1143 if((! priv->pat.curr_next) || (priv->pat.table_id != 0)) // || (! priv->pat.ssi))
1008 return 0; 1144 return 0;
1009 1145
1010 1146
1018 priv->pat.section_length, priv->pat.buffer_len - 3); 1154 priv->pat.section_length, priv->pat.buffer_len - 3);
1019 1155
1020 return -1; //KEEP ON FILLING THE TABLE 1156 return -1; //KEEP ON FILLING THE TABLE
1021 } 1157 }
1022 1158
1159 //check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]);
1160
1023 entries = (int) (priv->pat.section_length - 9) / 4; //entries per section 1161 entries = (int) (priv->pat.section_length - 9) / 4; //entries per section
1024 1162
1025 1163
1026 for(i=0; i < entries; i++) 1164 for(i=0; i < entries; i++)
1027 { 1165 {
1052 } 1190 }
1053 1191
1054 1192
1055 static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid) 1193 static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid)
1056 { 1194 {
1057 int i; 1195 uint16_t i;
1058 1196
1059 if(pmt == NULL) 1197 if(pmt == NULL)
1060 return -1; 1198 return -1;
1061 1199
1062 if(pmt->es == NULL) 1200 if(pmt->es == NULL)
1063 return -1; 1201 return -1;
1064 1202
1065 for(i = 0; i < pmt->es_cnt; i++) 1203 for(i = 0; i < pmt->es_cnt; i++)
1066 { 1204 {
1067 if(pmt->es[i].pid == pid) 1205 if(pmt->es[i].pid == pid)
1068 return i; 1206 return (int32_t) i;
1069 } 1207 }
1070 1208
1071 return -1; 1209 return -1;
1210 }
1211
1212
1213 static int parse_descriptors(struct pmt_es_t *es, uint8_t *ptr)
1214 {
1215 int j, descr_len, len;
1216
1217 j = 0;
1218 len = es->descr_length;
1219 while(len > 2)
1220 {
1221 descr_len = ptr[j+1];
1222 mp_msg(MSGT_DEMUX, MSGL_DBG2, "...descr id: 0x%x, len=%d\n", ptr[j], descr_len);
1223 if(descr_len > len)
1224 {
1225 mp_msg(MSGT_DEMUX, MSGL_DBG2, "INVALID DESCR LEN: %d vs %d max, EXIT LOOP\n", descr_len, len);
1226 return -1;
1227 }
1228
1229
1230 if(ptr[j] == 0x6a) //A52 Descriptor
1231 {
1232 es->type = AUDIO_A52;
1233 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n");
1234 }
1235 else if(ptr[j] == 0x59) //Subtitling Descriptor
1236 {
1237 uint8_t subtype;
1238
1239 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Subtitling Descriptor\n");
1240 if(descr_len < 8)
1241 {
1242 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Descriptor length too short for DVB Subtitle Descriptor: %d, SKIPPING\n", descr_len);
1243 }
1244 else
1245 {
1246 memcpy(es->lang, &ptr[j+2], 3);
1247 es->lang[3] = 0;
1248 subtype = ptr[j+5];
1249 if(
1250 (subtype >= 0x10 && subtype <= 0x13) ||
1251 (subtype >= 0x20 && subtype <= 0x23)
1252 )
1253 {
1254 es->type = SPU_DVB;
1255 //page parameters: compo page 2 bytes, ancillary page 2 bytes
1256 }
1257 else
1258 es->type = UNKNOWN;
1259 }
1260 }
1261 else if(ptr[j] == 0x50) //Component Descriptor
1262 {
1263 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Component Descriptor\n");
1264 memcpy(es->lang, &ptr[j+5], 3);
1265 es->lang[3] = 0;
1266 }
1267 else if(ptr[j] == 0xa) //Language Descriptor
1268 {
1269 memcpy(es->lang, &ptr[j+2], 3);
1270 es->lang[3] = 0;
1271 mp_msg(MSGT_DEMUX, MSGL_V, "Language Descriptor: %s\n", es->lang);
1272 }
1273 else if(ptr[j] == 0x5) //Registration Descriptor (looks like e fourCC :) )
1274 {
1275 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor\n");
1276 if(descr_len < 4)
1277 {
1278 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor length too short: %d, SKIPPING\n", descr_len);
1279 }
1280 else
1281 {
1282 char *d;
1283 memcpy(es->format_descriptor, &ptr[j+2], 4);
1284 es->format_descriptor[4] = 0;
1285
1286 d = &ptr[j+2];
1287 if(d[0] == 'A' && d[1] == 'C' && d[2] == '-' && d[3] == '3')
1288 {
1289 es->type = AUDIO_A52;
1290 }
1291 else
1292 es->type = UNKNOWN;
1293 mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor);
1294 }
1295 }
1296 else
1297 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Unknown descriptor 0x%x, SKIPPING\n", ptr[j]);
1298
1299 len -= 2 + descr_len;
1300 j += 2 + descr_len;
1301 }
1302
1303 return 1;
1072 } 1304 }
1073 1305
1074 1306
1075 1307
1076 static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size) 1308 static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size)
1086 { 1318 {
1087 int sz = (priv->pmt_cnt + 1) * sizeof(pmt_t); 1319 int sz = (priv->pmt_cnt + 1) * sizeof(pmt_t);
1088 priv->pmt = (pmt_t *) realloc(priv->pmt, sz); 1320 priv->pmt = (pmt_t *) realloc(priv->pmt, sz);
1089 if(priv->pmt == NULL) 1321 if(priv->pmt == NULL)
1090 { 1322 {
1091 mp_msg(MSGT_DEMUX, MSGL_ERR, "FILL_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz); 1323 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz);
1092 return NULL; 1324 return NULL;
1093 } 1325 }
1094 1326
1095 idx = priv->pmt_cnt; 1327 idx = priv->pmt_cnt;
1096 memset(&(priv->pmt[idx]), 0, sizeof(pmt_t)); 1328 memset(&(priv->pmt[idx]), 0, sizeof(pmt_t));
1125 1357
1126 if(m == size) 1358 if(m == size)
1127 return 0; 1359 return 0;
1128 } 1360 }
1129 1361
1362
1363 if(size-m + pmt->buffer_len > 2048)
1364 {
1365 mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d, PID=%d), ERROR! PMT TOO LONG, IGNORING\n", progid, pid);
1366 pmt->buffer_len = 0;
1367 return NULL;
1368 }
1369
1130 memcpy(&(pmt->buffer[pmt->buffer_len]), &buff[m], size - m); 1370 memcpy(&(pmt->buffer[pmt->buffer_len]), &buff[m], size - m);
1131 pmt->progid = progid; 1371 pmt->progid = progid;
1132 pmt->buffer_len += size - m; 1372 pmt->buffer_len += size - m;
1133 1373
1134 1374 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",
1135 mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d), PMT_len: %d, IS_START: %d, TSPID: %d\n", 1375 progid, pmt->buffer_len, is_start, pid, size, m, pmt->es_cnt, idx, pmt);
1136 progid, pmt->buffer_len, is_start, pid);
1137 1376
1138 base = pmt->buffer; 1377 base = pmt->buffer;
1139 1378
1140 1379
1141 pmt->table_id = base[0]; 1380 pmt->table_id = base[0];
1155 1394
1156 1395
1157 if(pmt->section_length + 3 > pmt->buffer_len) 1396 if(pmt->section_length + 3 > pmt->buffer_len)
1158 { 1397 {
1159 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, SECTION LENGTH TOO LARGE FOR CURRENT BUFFER (%d vs %d), NEXT TIME\n", pmt->section_length, pmt->buffer_len); 1398 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, SECTION LENGTH TOO LARGE FOR CURRENT BUFFER (%d vs %d), NEXT TIME\n", pmt->section_length, pmt->buffer_len);
1399
1160 return -1; 1400 return -1;
1161 } 1401 }
1162 1402
1163 if(pmt->prog_descr_length > pmt->section_length - 9) 1403 if(pmt->prog_descr_length > pmt->section_length - 9)
1164 { 1404 {
1188 { 1428 {
1189 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz); 1429 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz);
1190 continue; 1430 continue;
1191 } 1431 }
1192 idx = pmt->es_cnt; 1432 idx = pmt->es_cnt;
1433 memset(&(pmt->es[idx]), 0, sizeof(struct pmt_es_t));
1193 pmt->es_cnt++; 1434 pmt->es_cnt++;
1194 } 1435 }
1195 1436
1196 pmt->es[idx].descr_length = ((es_base[3] & 0xf) << 8) | es_base[4]; 1437 pmt->es[idx].descr_length = ((es_base[3] & 0xf) << 8) | es_base[4];
1197 1438
1198 1439
1199 if(pmt->es[idx].descr_length > section_bytes - 5) 1440 if(pmt->es[idx].descr_length > section_bytes - 5)
1200 { 1441 {
1201 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT %d bytes for PMT_ES\n", 1442 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT\n",
1202 pmt->es[idx].descr_length, section_bytes - 5, section_bytes); 1443 pmt->es[idx].descr_length, section_bytes - 5);
1203 return -1; 1444 return -1;
1204 } 1445 }
1205 1446
1206 1447
1207 pmt->es[idx].pid = es_pid; 1448 pmt->es[idx].pid = es_pid;
1208 pmt->es[idx].type = es_type; 1449 pmt->es[idx].type = es_type;
1450
1451 pmt->es[idx].type = UNKNOWN;
1209 1452
1210 switch(es_type) 1453 switch(es_type)
1211 { 1454 {
1212 case 1: 1455 case 1:
1213 pmt->es[idx].type = VIDEO_MPEG1; 1456 pmt->es[idx].type = VIDEO_MPEG1;
1215 case 2: 1458 case 2:
1216 pmt->es[idx].type = VIDEO_MPEG2; 1459 pmt->es[idx].type = VIDEO_MPEG2;
1217 break; 1460 break;
1218 case 3: 1461 case 3:
1219 case 4: 1462 case 4:
1463 parse_descriptors(&pmt->es[idx], &es_base[5]);
1220 pmt->es[idx].type = AUDIO_MP2; 1464 pmt->es[idx].type = AUDIO_MP2;
1221 break; 1465 break;
1222 case 6: 1466 case 6:
1223 { 1467 parse_descriptors(&pmt->es[idx], &es_base[5]);
1224 int j; 1468 if(pmt->es[idx].type == 0x6)
1225 for(j = 5; j < pmt->es[idx].descr_length; j += es_base[j+1] + 2) //possible DVB-AC3 1469 pmt->es[idx].type = UNKNOWN;
1226 if(es_base[j] == 0x6a) 1470 break;
1227 pmt->es[idx].type = AUDIO_A52;
1228 }
1229 break;
1230
1231 case 0x10: 1471 case 0x10:
1232 pmt->es[idx].type = VIDEO_MPEG4; 1472 pmt->es[idx].type = VIDEO_MPEG4;
1233 break; 1473 break;
1234 case 0x11: 1474 case 0x11:
1475 parse_descriptors(&pmt->es[idx], &es_base[5]);
1235 pmt->es[idx].type = AUDIO_AAC; 1476 pmt->es[idx].type = AUDIO_AAC;
1236 break; 1477 break;
1478
1479 /* seems to indicate an AAC in a certain broadcaster's tables, but
1480 it's deceiving, so it's commented out
1481 case 0x0f:
1482 parse_descriptors(&pmt->es[idx], &es_base[5]);
1483 pmt->es[idx].type = 0x0f;
1484 break;
1485 */
1237 1486
1238 case 0x81: 1487 case 0x81:
1239 pmt->es[idx].type = AUDIO_A52; 1488 pmt->es[idx].type = AUDIO_A52;
1240 break; 1489 break;
1241 } 1490
1242 1491 default:
1492 {
1493 if(es_type > 0x80)
1494 {
1495 parse_descriptors(&pmt->es[idx], &es_base[5]);
1496 }
1497 else
1498 {
1499 mp_msg(MSGT_DEMUX, MSGL_DBG2, "UNKNOWN ES TYPE=0x%x\n", es_type);
1500 pmt->es[idx].type = UNKNOWN;
1501 }
1502 }
1503 }
1243 1504
1244 section_bytes -= 5 + pmt->es[idx].descr_length; 1505 section_bytes -= 5 + pmt->es[idx].descr_length;
1245 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", 1506 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",
1246 progid, idx, es_count, pmt->es[idx].pid, pmt->es[idx].pid, pmt->es[idx].type, pmt->es[idx].descr_length, section_bytes); 1507 progid, idx, es_count, pmt->es[idx].pid, pmt->es[idx].pid, pmt->es[idx].type, pmt->es[idx].descr_length, section_bytes);
1247 1508
1249 es_base += 5 + pmt->es[idx].descr_length; 1510 es_base += 5 + pmt->es[idx].descr_length;
1250 1511
1251 es_count++; 1512 es_count++;
1252 } 1513 }
1253 1514
1515 mp_msg(MSGT_DEMUX, MSGL_V, "----------------------------\n");
1254 return 1; 1516 return 1;
1255 } 1517 }
1256 1518
1519
1520 static inline int32_t pid_type_from_pmt(ts_priv_t *priv, int pid)
1521 {
1522 int32_t pmt_idx, pid_idx, i, j;
1523
1524 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
1525
1526 if(pmt_idx != -1)
1527 {
1528 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
1529 if(pid_idx != -1)
1530 return priv->pmt[pmt_idx].es[pid_idx].type;
1531 }
1532 //else
1533 //{
1534 for(i = 0; i < priv->pmt_cnt; i++)
1535 {
1536 pmt_t *pmt = &(priv->pmt[i]);
1537 for(j = 0; j < pmt->es_cnt; j++)
1538 if(pmt->es[j].pid == pid)
1539 return pmt->es[j].type;
1540 }
1541 //}
1542
1543 return UNKNOWN;
1544 }
1545
1546
1547 static inline uint8_t *pid_lang_from_pmt(ts_priv_t *priv, int pid)
1548 {
1549 int32_t pmt_idx, pid_idx, i, j;
1550
1551 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
1552
1553 if(pmt_idx != -1)
1554 {
1555 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
1556 if(pid_idx != -1)
1557 return priv->pmt[pmt_idx].es[pid_idx].lang;
1558 }
1559 else
1560 {
1561 for(i = 0; i < priv->pmt_cnt; i++)
1562 {
1563 pmt_t *pmt = &(priv->pmt[i]);
1564 for(j = 0; j < pmt->es_cnt; j++)
1565 if(pmt->es[j].pid == pid)
1566 return pmt->es[j].lang;
1567 }
1568 }
1569
1570 return NULL;
1571 }
1572
1573
1574 static int fill_packet(demuxer_t *demuxer, demux_stream_t *ds, demux_packet_t **dp, int *dp_offset, int *broken)
1575 {
1576 int ret = 0;
1577
1578 if((*dp != NULL) && (*dp_offset > 0))
1579 {
1580 if(*broken == 0)
1581 {
1582 ret = *dp_offset;
1583 resize_demux_packet(*dp, ret); //shrinked to the right size
1584 ds_add_packet(ds, *dp);
1585 mp_msg(MSGT_DEMUX, MSGL_V, "ADDED %d bytes to %s fifo, PTS=%f\n", ret, (ds == demuxer->audio ? "audio" : (ds == demuxer->video ? "video" : "sub")), (*dp)->pts);
1586 }
1587 else
1588 {
1589 ret = 0;
1590 mp_msg(MSGT_DEMUX, MSGL_V, "BROKEN PES, DISCARDING\n");
1591 free_demux_packet(*dp);
1592 }
1593 }
1594
1595 *broken = 1;
1596 *dp = NULL;
1597 *dp_offset = 0;
1598
1599 return ret;
1600 }
1257 1601
1258 // 0 = EOF or no stream found 1602 // 0 = EOF or no stream found
1259 // else = [-] number of bytes written to the packet 1603 // else = [-] number of bytes written to the packet
1260 static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, int probe) 1604 static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, int probe)
1261 { 1605 {
1262 ES_stream_t *tss; 1606 ES_stream_t *tss;
1263 uint8_t done = 0; 1607 uint8_t done = 0;
1264 int buf_size, is_start; 1608 int buf_size, is_start, pid, base;
1265 int len, pid, cc, cc_ok, afc, _read; 1609 int len, cc, cc_ok, afc, retv = 0, is_video, is_audio, is_sub;
1266 ts_priv_t * priv = (ts_priv_t*) demuxer->priv; 1610 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
1267 stream_t *stream = demuxer->stream; 1611 stream_t *stream = demuxer->stream;
1268 char *p, tmp[TS_FEC_PACKET_SIZE]; 1612 char *p, tmp[TS_FEC_PACKET_SIZE];
1269 demux_stream_t *ds = NULL; 1613 demux_stream_t *ds = NULL;
1270 demux_packet_t **dp = NULL; 1614 demux_packet_t **dp = NULL;
1271 int *dp_offset = 0, *buffer_size = 0, *broken = NULL; 1615 int *dp_offset = 0, *buffer_size = 0, *broken = NULL;
1272 int32_t progid, pid_idx, pid_type; 1616 int32_t progid, pid_type;
1273 1617
1274 1618
1275 while(! done) 1619 while(! done)
1276 { 1620 {
1621 ds = (demux_stream_t*) NULL;
1622 dp = (demux_packet_t **) NULL;
1623 broken = dp_offset = buffer_size = NULL;
1624
1625 buf_size = priv->ts.packet_size;
1626
1277 if(stream_eof(stream)) 1627 if(stream_eof(stream))
1278 { 1628 {
1279 if(! priv->eof) 1629 if(! probe)
1280 { 1630 {
1281 ts_dump_streams(priv); 1631 ts_dump_streams(priv);
1282 demuxer->filepos = stream_tell(demuxer->stream); 1632 demuxer->filepos = stream_tell(demuxer->stream);
1283 return -1; 1633 }
1284 } 1634
1285 else 1635 return 0;
1286 return 0; 1636 }
1287 } 1637
1288 1638
1289 1639 if(! ts_sync(stream))
1290 if(! priv->is_synced) 1640 {
1291 { 1641 mp_msg(MSGT_DEMUX, MSGL_V, "TS_PARSE: COULDN'T SYNC\n");
1292 if(! ts_sync(stream)) 1642 return 0;
1293 { 1643 }
1294 mp_msg(MSGT_DEMUX, MSGL_V, "TS_PARSE: COULDN'T SYNC\n"); 1644
1295 return 0; 1645 len = stream_read(stream, &packet[1], 3);
1296 } 1646 if (len != 3)
1297 1647 return 0;
1298 len = stream_read(stream, &packet[1], 3); 1648
1299 if (len != 3) 1649 if((packet[1] >> 7) & 0x01) //transport error
1300 return 0; 1650 continue;
1301 } 1651
1302 _read = 4; 1652 buf_size -= 4;
1303 1653
1304 if(! priv->is_synced) 1654 is_start = packet[1] & 0x40;
1305 { 1655 pid = ((packet[1] & 0x1f) << 8) | packet[2];
1306 is_start = packet[1] & 0x40;
1307 pid = ((packet[1] & 0x1f) << 8) | packet[2];
1308 }
1309 else
1310 {
1311 is_start = priv->is_start;
1312 pid = priv->last_pid;
1313 }
1314 1656
1315 tss = priv->ts.pids[pid]; //an ES stream 1657 tss = priv->ts.pids[pid]; //an ES stream
1316 if(tss == NULL) 1658 if(tss == NULL)
1317 { 1659 {
1318 tss = malloc(sizeof(ES_stream_t)); 1660 tss = malloc(sizeof(ES_stream_t));
1321 memset(tss, 0, sizeof(ES_stream_t)); 1663 memset(tss, 0, sizeof(ES_stream_t));
1322 tss->pid = pid; 1664 tss->pid = pid;
1323 tss->last_cc = -1; 1665 tss->last_cc = -1;
1324 tss->type = UNKNOWN; 1666 tss->type = UNKNOWN;
1325 tss->payload_size = 0; 1667 tss->payload_size = 0;
1326 priv->ts.pids[pid] = tss; 1668 tss->seen = 0;
1327 mp_msg(MSGT_DEMUX, MSGL_INFO, "\nNew TS pid=%u\n", pid); 1669 priv->ts.pids[pid] = tss;
1328 } 1670 }
1329 1671
1330 1672
1331 1673
1332 if(((pid > 1) && (pid < 16)) || (pid == 8191)) //invalid pid 1674 if(((pid > 1) && (pid < 16)) || (pid == 8191)) //invalid pid
1333 continue; 1675 continue;
1334 1676
1335 cc = (packet[3] & 0xf); 1677 cc = (packet[3] & 0xf);
1336 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc)); 1678 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
1337 if(! cc_ok)
1338 {
1339 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse: CCCheck NOT OK: %d -> %d\n", tss->last_cc, cc);
1340 }
1341 tss->last_cc = cc; 1679 tss->last_cc = cc;
1342 1680
1343 1681 if(cc_ok)
1344 if(! priv->is_synced) 1682 {
1345 { 1683 /* skip adaptation field, but only if cc_ok is not corrupt,
1346 priv->last_afc = 0; 1684 otherwise we may throw away good data */
1347 /* skip adaptation field */
1348 afc = (packet[3] >> 4) & 3; 1685 afc = (packet[3] >> 4) & 3;
1349 if (afc == 0) /* reserved value */ 1686 if (afc == 0) /* reserved value */
1350 continue; 1687 continue;
1351 if (afc == 2) /* adaptation field only */ 1688 if (afc == 2) /* adaptation field only */
1352 continue; 1689 continue;
1353 if (afc == 3) 1690 if (afc == 3)
1354 { 1691 {
1355 int c; 1692 int c;
1356 stream_read(stream, &packet[_read], 1); 1693 c = stream_read_char(stream);
1357 c = packet[_read]; 1694 buf_size--;
1358 _read++; 1695
1359 1696 c = min(c, buf_size);
1360 c = min(c, priv->ts.packet_size - _read); 1697 stream_skip(stream, c);
1361 stream_read(stream, &packet[_read], c); 1698 buf_size -= c;
1362 _read += c; 1699 if(buf_size == 0)
1363 1700 continue;
1364 priv->last_afc = c + 1; 1701
1365 mp_msg(MSGT_DEMUX, MSGL_DBG2, "AFC: %d\n", priv->last_afc); 1702 afc = c + 1;
1366 1703 }
1367 if(_read == priv->ts.packet_size) 1704 else
1705 afc = 0;
1706 }
1707 else
1708 {
1709 // logically this packet should be dropped, but if I do it
1710 // certain streams play corrupted. Maybe the decoders know
1711 // how to deal with it, but at least I consider the packet
1712 // as "not initial"
1713 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse: CC Check NOT OK: PID=%d, %d -> %d\n\n", tss->pid, tss->last_cc, cc);
1714
1715 if(priv->keep_broken == 0)
1368 continue; 1716 continue;
1369 } 1717
1370 } 1718 is_start = 0;
1371 else 1719 }
1372 { 1720
1373 _read += priv->last_afc; 1721 tss->seen++;
1374 priv->last_afc = 0; 1722 if(tss->seen == 16 && cc_ok) //at least a complete round
1375 } 1723 mp_msg(MSGT_DEMUX, MSGL_V, "\nNew TS pid=%u\n", pid);
1376 1724
1377 // PES CONTENT STARTS HERE 1725
1378 1726 //TABLE PARSING
1379 buf_size = priv->ts.packet_size - _read; 1727
1380 1728 base = priv->ts.packet_size - buf_size;
1381 //LET'S PARSE TABLES
1382
1383 if(pid == 0) 1729 if(pid == 0)
1384 { 1730 {
1385 stream_read(stream,&packet[_read], buf_size); 1731 stream_read(stream,&packet[base], buf_size);
1386 parse_pat(priv, is_start, &packet[_read], buf_size); 1732 parse_pat(priv, is_start, &packet[base], buf_size);
1387 priv->is_synced = 0;
1388 continue; 1733 continue;
1389 } 1734 }
1390 else 1735 else
1391 { 1736 {
1392 progid = prog_id_in_pat(priv, pid); 1737 progid = prog_id_in_pat(priv, pid);
1393 if(((progid != -1) || (pid == 16))) 1738 if(((progid != -1) || (pid == 16)))
1394 { 1739 {
1395 stream_read(stream,&packet[_read], buf_size); 1740 if(pid != demuxer->video->id && pid != demuxer->audio->id && pid != demuxer->sub->id)
1396 parse_pmt(priv, progid, pid, is_start, &packet[_read], buf_size); 1741 {
1397 priv->is_synced = 0; 1742 stream_read(stream,&packet[base], buf_size);
1398 continue; 1743 parse_pmt(priv, progid, pid, is_start, &packet[base], buf_size);
1399 } 1744 continue;
1400 } 1745 }
1401 1746 else
1402 1747 mp_msg(MSGT_DEMUX, MSGL_ERR, "Argh! Data pid used in the PMT, Skipping PMT parsing!\n");
1403 1748 }
1749 }
1750
1751
1752 priv->last_pid = pid;
1753
1754 is_video = ((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4));
1755 is_audio = ((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC));
1756 is_sub = ((tss->type == SPU_DVD) || (tss->type == SPU_DVB));
1757 pid_type = pid_type_from_pmt(priv, pid);
1758
1759 // PES CONTENT STARTS HERE
1404 if(! probe) 1760 if(! probe)
1405 { 1761 {
1406 if(((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4)) 1762 if((pid == demuxer->sub->id)) //or the lang is right
1407 && (demuxer->video->id == tss->pid)) 1763 {
1764 pid_type = SPU_DVD;
1765 }
1766
1767 if(is_video && (demuxer->video->id == tss->pid))
1408 { 1768 {
1409 ds = demuxer->video; 1769 ds = demuxer->video;
1410 1770
1411 dp = &priv->fifo[1].pack; 1771 dp = &priv->fifo[1].pack;
1412 dp_offset = &priv->fifo[1].offset; 1772 dp_offset = &priv->fifo[1].offset;
1413 buffer_size = &priv->fifo[1].buffer_size; 1773 buffer_size = &priv->fifo[1].buffer_size;
1414 broken = &priv->fifo[1].broken; 1774 broken = &priv->fifo[1].broken;
1415 } 1775 }
1416 else if(((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC)) 1776 else if(is_audio && (demuxer->audio->id == tss->pid))
1417 && (demuxer->audio->id == tss->pid))
1418 { 1777 {
1419 ds = demuxer->audio; 1778 ds = demuxer->audio;
1420 1779
1421 dp = &priv->fifo[0].pack; 1780 dp = &priv->fifo[0].pack;
1422 dp_offset = &priv->fifo[0].offset; 1781 dp_offset = &priv->fifo[0].offset;
1423 buffer_size = &priv->fifo[0].buffer_size; 1782 buffer_size = &priv->fifo[0].buffer_size;
1424 broken = &priv->fifo[0].broken; 1783 broken = &priv->fifo[0].broken;
1425 } 1784 }
1426 else 1785 else if(is_sub
1427 { 1786 || (pid_type == SPU_DVD) || (pid_type == SPU_DVB))
1428 stream_skip(stream, buf_size); 1787 {
1429 _read += buf_size; 1788 //SUBS are infrequent, so the initial detection may fail
1430 continue; 1789 // and we may need to add them at play-time
1431 } 1790 if(demuxer->sub->id == -1)
1432
1433 //IS IT TIME TO QUEUE DATA to the dp_packet?
1434 if(is_start && (*dp != NULL) && (*dp_offset > 0))
1435 {
1436 priv->last_pid = pid;
1437 priv->is_synced = 1;
1438 priv->is_start = is_start;
1439
1440 if(! *broken)
1441 { 1791 {
1442 int ret = *dp_offset; 1792 uint16_t p;
1443 resize_demux_packet(*dp, ret); //shrinked to the right size 1793 p = progid_for_pid(priv, tss->pid, priv->prog);
1444 1794
1445 ds_add_packet(ds, *dp); 1795 if(p == priv->prog)
1446 mp_msg(MSGT_DEMUX, MSGL_V, "ADDED %d bytes to %s fifo, PTS=%f\n", ret, (ds == demuxer->audio ? "audio" : "video"), (*dp)->pts); 1796 {
1447 1797 int asgn = 0;
1448 1798 uint8_t *lang;
1449 *dp = NULL; 1799
1450 *dp_offset = 0; 1800 if(!strcmp(dvdsub_lang, ""))
1451 1801 asgn = 1;
1452 return -ret; 1802 else
1803 {
1804 lang = pid_lang_from_pmt(priv, pid);
1805 if(lang != NULL)
1806 asgn = (strncmp(lang, dvdsub_lang, 3) == 0);
1807 else
1808 asgn = 0;
1809 }
1810
1811 if(asgn)
1812 {
1813 demuxer->sub->id = tss->pid;
1814 mp_msg(MSGT_DEMUX, MSGL_INFO, "CHOSEN SUBs pid 0x%x (%d) FROM PROG %d\n", tss->pid, tss->pid, priv->prog);
1815 }
1816 }
1817 else
1818 {
1819 mp_msg(MSGT_DEMUX, MSGL_V, "DISCARDED SUBs pid 0x%x (%d) NOT CHOSEN OR NOT IN PROG %d\n", tss->pid, tss->pid, priv->prog);
1820 }
1821 }
1822
1823 if(demuxer->sub->id == tss->pid)
1824 {
1825 ds = demuxer->sub;
1826
1827 dp = &priv->fifo[2].pack;
1828 dp_offset = &priv->fifo[2].offset;
1829 buffer_size = &priv->fifo[2].buffer_size;
1830 broken = &priv->fifo[2].broken;
1453 } 1831 }
1454 else 1832 else
1455 { 1833 {
1456 mp_msg(MSGT_DEMUX, MSGL_V, "BROKEN PES, DISCARDING\n"); 1834 stream_skip(stream, buf_size);
1457 free_demux_packet(*dp);
1458
1459 *dp = NULL;
1460 *dp_offset = 0;
1461
1462 continue; 1835 continue;
1463 } 1836 }
1464 } 1837 }
1465 1838 else
1466 priv->last_pid = pid; 1839 {
1840 stream_skip(stream, buf_size);
1841 continue;
1842 }
1843
1844 //IS IT TIME TO QUEUE DATA to the dp_packet?
1845 if(is_start && (dp != NULL))
1846 {
1847 retv = fill_packet(demuxer, ds, dp, dp_offset, broken);
1848 }
1849
1467 1850
1468 if(*dp == NULL) 1851 if(*dp == NULL)
1469 { 1852 {
1470 *dp = new_demux_packet(*buffer_size); //es->size 1853 *dp = new_demux_packet(*buffer_size); //es->size
1471 *dp_offset = 0; 1854 *dp_offset = 0;
1478 } 1861 }
1479 1862
1480 mp_msg(MSGT_DEMUX, MSGL_DBG2, "NOW PACKET_SIZE = %d, DP_OFFSET = %d\n", *buffer_size, *dp_offset); 1863 mp_msg(MSGT_DEMUX, MSGL_DBG2, "NOW PACKET_SIZE = %d, DP_OFFSET = %d\n", *buffer_size, *dp_offset);
1481 } 1864 }
1482 1865
1483 priv->is_synced = 0;
1484 1866
1485 1867
1486 if(is_start) 1868 if(is_start)
1487 { 1869 {
1488 mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n"); 1870 mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n");
1489 1871
1490 //priv->is_synced = 0; 1872 p = &packet[base];
1491
1492 p = &packet[_read];
1493 stream_read(stream, p, buf_size); 1873 stream_read(stream, p, buf_size);
1494 _read += buf_size;
1495
1496 pid_idx = es_pid_in_pmt(priv->pmt, pid);
1497 if(pid_idx == -1)
1498 pid_type = UNKNOWN;
1499 else
1500 pid_type = priv->pmt->es[pid_idx].type;
1501
1502 1874
1503 len = pes_parse2(p, buf_size, es, pid_type); 1875 len = pes_parse2(p, buf_size, es, pid_type);
1504 1876
1505 if(len) 1877 if(len > 0)
1506 { 1878 {
1507 if(es->type == UNKNOWN) 1879 if(es->type == UNKNOWN)
1508 continue; 1880 continue;
1509 1881
1510 es->pid = tss->pid; 1882 es->pid = tss->pid;
1516 if(es->pts == 0.0f) 1888 if(es->pts == 0.0f)
1517 es->pts = tss->pts = tss->last_pts; 1889 es->pts = tss->pts = tss->last_pts;
1518 else 1890 else
1519 tss->pts = tss->last_pts = es->pts; 1891 tss->pts = tss->last_pts = es->pts;
1520 1892
1521 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%X, len=%d\n", 1893 mp_msg(MSGT_DEMUX, MSGL_V, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%p, len=%d\n",
1522 es->pid, es->payload_size, es->type, es->start, es->size); 1894 es->pid, es->payload_size, es->type, es->start, es->size);
1523 1895
1524 tss->payload_size = es->payload_size; 1896 tss->payload_size = es->payload_size;
1525 1897
1526 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NOW tss->PSIZE=%u\n", tss->payload_size);
1527
1528 demuxer->filepos = stream_tell(demuxer->stream) - es->size; 1898 demuxer->filepos = stream_tell(demuxer->stream) - es->size;
1529 1899
1530 if(probe) 1900 if(probe)
1531 return es->size; 1901 return 1; //es->size;
1532 else 1902 else
1533 { 1903 {
1534 *broken = 0; 1904 *broken = 0;
1535 if(*dp_offset + es->size > *buffer_size) 1905 if(es->size > 0)
1536 { 1906 {
1537 *buffer_size = *dp_offset + es->size + TS_FEC_PACKET_SIZE; 1907 if(*dp_offset + es->size > *buffer_size)
1538 resize_demux_packet(*dp, *buffer_size); 1908 {
1539 //we'll skip at least one RESIZE() in the next iteration of ts_parse() 1909 *buffer_size = *dp_offset + es->size + TS_FEC_PACKET_SIZE;
1540 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size); 1910 resize_demux_packet(*dp, *buffer_size);
1911 //we'll skip at least one RESIZE() in the next iteration of ts_parse()
1912 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size);
1913 }
1914 memcpy(&((*dp)->buffer[*dp_offset]), es->start, es->size);
1915 *dp_offset += es->size;
1916 (*dp)->flags = 0;
1917 (*dp)->pos = stream_tell(demuxer->stream);
1918 (*dp)->pts = es->pts;
1541 } 1919 }
1542 memcpy(&((*dp)->buffer[*dp_offset]), es->start, es->size); 1920
1543 *dp_offset += es->size; 1921 if(retv > 0)
1544 (*dp)->flags = 0; 1922 return retv;
1545 (*dp)->pts = es->pts; 1923 else
1546 (*dp)->pos = stream_tell(demuxer->stream); 1924 continue;
1547 *broken = 0;
1548 mp_msg(MSGT_DEMUX, MSGL_DBG2, "INIT PACKET, TYPE=%x, PTS: %f\n", es->type, es->pts);
1549
1550 continue;
1551 } 1925 }
1552 } 1926 }
1553 else 1927 else
1554 return 0; 1928 return 0;
1555 } 1929 }
1565 1939
1566 1940
1567 es->pid = tss->pid; 1941 es->pid = tss->pid;
1568 es->type = tss->type; 1942 es->type = tss->type;
1569 es->pts = tss->pts = tss->last_pts; 1943 es->pts = tss->pts = tss->last_pts;
1570 es->start = &packet[_read]; 1944 es->start = &packet[base];
1571 1945
1572 1946
1573 if(tss->payload_size) 1947 if(tss->payload_size > 0)
1574 { 1948 {
1575 sz = min(tss->payload_size, buf_size); 1949 sz = min(tss->payload_size, buf_size);
1576 tss->payload_size -= sz; 1950 tss->payload_size -= sz;
1577 es->size = sz; 1951 es->size = sz;
1578 } 1952 }
1579 else 1953 else
1580 { 1954 {
1581 if((es->type == VIDEO_MPEG1) || (es->type == VIDEO_MPEG2) || (es->type == VIDEO_MPEG4)) 1955 if(is_video)
1956 {
1582 sz = es->size = buf_size; 1957 sz = es->size = buf_size;
1958 }
1583 else 1959 else
1584 { 1960 {
1585 stream_skip(stream, buf_size); 1961 stream_skip(stream, buf_size);
1586 continue; 1962 continue;
1587 } 1963 }
1594 { 1970 {
1595 *buffer_size = *dp_offset + sz + TS_FEC_PACKET_SIZE; 1971 *buffer_size = *dp_offset + sz + TS_FEC_PACKET_SIZE;
1596 resize_demux_packet(*dp, *buffer_size); 1972 resize_demux_packet(*dp, *buffer_size);
1597 //we'll skip at least one RESIZE() in the next iteration of ts_parse() 1973 //we'll skip at least one RESIZE() in the next iteration of ts_parse()
1598 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size); 1974 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size);
1975 //mp_msg(MSGT_DEMUX, MSGL_INFO, "SECOND TYPE=%x, bytes=%d, afc=%d, psize=%d, tell=%llu\n", es->type, sz, afc, tss->payload_size, (uint64_t) stream_tell(demuxer->stream));
1599 } 1976 }
1600
1601 1977
1602 stream_read(stream, &((*dp)->buffer[*dp_offset]), sz); 1978 stream_read(stream, &((*dp)->buffer[*dp_offset]), sz);
1603 *dp_offset += sz; 1979 *dp_offset += sz;
1604 1980
1605 if(buf_size - sz) 1981 if(buf_size - sz > 0)
1982 {
1606 stream_skip(stream, buf_size - sz); 1983 stream_skip(stream, buf_size - sz);
1984 }
1607 1985
1608 continue; 1986 continue;
1609 } 1987 }
1610 else 1988 else
1611 { 1989 {
1612 stream_read(stream, es->start, sz); 1990 stream_read(stream, es->start, sz);
1613 if(buf_size - sz) stream_read(stream, tmp, buf_size-sz); 1991 if(buf_size - sz) stream_read(stream, tmp, buf_size-sz);
1614
1615 _read += buf_size;
1616 1992
1617 if(es->size) 1993 if(es->size)
1618 return es->size; 1994 return es->size;
1619 else 1995 else
1620 continue; 1996 continue;
1627 2003
1628 2004
1629 extern void resync_audio_stream(sh_audio_t *sh_audio); 2005 extern void resync_audio_stream(sh_audio_t *sh_audio);
1630 extern void skip_audio_frame(sh_audio_t *sh_audio); 2006 extern void skip_audio_frame(sh_audio_t *sh_audio);
1631 2007
1632 static void reset_fifos(ts_priv_t* priv, int a, int v) 2008 static void reset_fifos(ts_priv_t* priv, int a, int v, int s)
1633 { 2009 {
1634 if(a) 2010 if(a)
1635 { 2011 {
1636 priv->fifo[0].pack = NULL; 2012 if(priv->fifo[0].pack != NULL)
2013 {
2014 free_demux_packet(priv->fifo[0].pack);
2015 priv->fifo[0].pack = NULL;
2016 }
1637 priv->fifo[0].offset = 0; 2017 priv->fifo[0].offset = 0;
1638 priv->fifo[0].buffer_size = 0;
1639 priv->fifo[0].broken = 1; 2018 priv->fifo[0].broken = 1;
1640 priv->is_synced = 0;
1641 } 2019 }
1642 2020
1643 if(v) 2021 if(v)
1644 { 2022 {
1645 priv->fifo[1].pack = NULL; 2023 if(priv->fifo[1].pack != NULL)
2024 {
2025 free_demux_packet(priv->fifo[1].pack);
2026 priv->fifo[1].pack = NULL;
2027 }
1646 priv->fifo[1].offset = 0; 2028 priv->fifo[1].offset = 0;
1647 priv->fifo[1].buffer_size = 0;
1648 priv->fifo[1].broken = 1; 2029 priv->fifo[1].broken = 1;
1649 priv->is_synced = 0; 2030 }
1650 } 2031
1651 } 2032 if(s)
1652 2033 {
1653 void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) 2034 if(priv->fifo[2].pack != NULL)
2035 {
2036 free_demux_packet(priv->fifo[2].pack);
2037 priv->fifo[2].pack = NULL;
2038 }
2039 priv->fifo[2].offset = 0;
2040 priv->fifo[2].broken = 1;
2041 }
2042 }
2043
2044 extern int videobuf_code_len;
2045 extern int sync_video_packet(demux_stream_t *);
2046 extern int skip_video_packet(demux_stream_t *);
2047
2048 void demux_seek_ts(demuxer_t *demuxer, float rel_seek_secs, int flags)
1654 { 2049 {
1655 demux_stream_t *d_audio=demuxer->audio; 2050 demux_stream_t *d_audio=demuxer->audio;
1656 demux_stream_t *d_video=demuxer->video; 2051 demux_stream_t *d_video=demuxer->video;
2052 demux_stream_t *d_sub=demuxer->sub;
1657 sh_audio_t *sh_audio=d_audio->sh; 2053 sh_audio_t *sh_audio=d_audio->sh;
1658 sh_video_t *sh_video=d_video->sh; 2054 sh_video_t *sh_video=d_video->sh;
1659 ts_priv_t * priv = (ts_priv_t*) demuxer->priv; 2055 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
1660 int i, video_stats; 2056 int i, video_stats;
1661 2057 off_t newpos;
1662 //================= seek in MPEG ========================== 2058
1663 off_t newpos = (flags&1)?demuxer->movi_start:demuxer->filepos; 2059 //================= seek in MPEG-TS ==========================
1664 2060
1665 ts_dump_streams(demuxer->priv); 2061 ts_dump_streams(demuxer->priv);
1666 reset_fifos(priv, sh_audio != NULL, sh_video != NULL); 2062 reset_fifos(priv, sh_audio != NULL, sh_video != NULL, demuxer->sub->id > 0);
2063
2064
2065 if(sh_audio != NULL)
2066 ds_free_packs(d_audio);
2067 if(sh_video != NULL)
2068 ds_free_packs(d_video);
2069 if(demuxer->sub->id > 0)
2070 ds_free_packs(d_sub);
1667 2071
1668 2072
1669 video_stats = (sh_video != NULL); 2073 video_stats = (sh_video != NULL);
1670 if(video_stats) 2074 if(video_stats)
1671 video_stats = sh_video->i_bps; 2075 video_stats = sh_video->i_bps;
1672 2076
2077 newpos = (flags & 1) ? demuxer->movi_start : demuxer->filepos;
1673 if(flags & 2) // float seek 0..1 2078 if(flags & 2) // float seek 0..1
1674 newpos+=(demuxer->movi_end-demuxer->movi_start)*rel_seek_secs; 2079 newpos+=(demuxer->movi_end-demuxer->movi_start)*rel_seek_secs;
1675 else 2080 else
1676 { 2081 {
1677 // time seek (secs) 2082 // time seek (secs)
1681 else 2086 else
1682 newpos += video_stats*rel_seek_secs; 2087 newpos += video_stats*rel_seek_secs;
1683 } 2088 }
1684 2089
1685 2090
1686 if(newpos<demuxer->movi_start) 2091 if(newpos < demuxer->movi_start)
1687 newpos = demuxer->movi_start = 0; //begininng of stream 2092 newpos = demuxer->movi_start; //begininng of stream
1688 2093
1689 #ifdef _LARGEFILE_SOURCE 2094 #ifdef _LARGEFILE_SOURCE
1690 newpos &= ~((long long) (STREAM_BUFFER_SIZE - 1)); /* sector boundary */ 2095 newpos &= ~((long long) (STREAM_BUFFER_SIZE - 1)); /* sector boundary */
1691 #else 2096 #else
1692 newpos &= ~(STREAM_BUFFER_SIZE - 1); /* sector boundary */ 2097 newpos &= ~(STREAM_BUFFER_SIZE - 1); /* sector boundary */
1693 #endif 2098 #endif
1694 2099
1695 reset_fifos(priv, sh_audio != NULL, sh_video != NULL);
1696
1697 if(sh_audio != NULL)
1698 ds_free_packs(d_audio);
1699 if(sh_video != NULL)
1700 ds_free_packs(d_video);
1701
1702 stream_seek(demuxer->stream, newpos); 2100 stream_seek(demuxer->stream, newpos);
1703 2101
2102 videobuf_code_len = 0;
1704 2103
1705 if(sh_video != NULL) 2104 if(sh_video != NULL)
1706 ds_fill_buffer(d_video); 2105 ds_fill_buffer(d_video);
1707 2106
1708 if(sh_audio != NULL) 2107 if(sh_audio != NULL)
1715 { 2114 {
1716 if(sh_audio && !d_audio->eof && d_video->pts && d_audio->pts) 2115 if(sh_audio && !d_audio->eof && d_video->pts && d_audio->pts)
1717 { 2116 {
1718 float a_pts=d_audio->pts; 2117 float a_pts=d_audio->pts;
1719 a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(float)sh_audio->i_bps; 2118 a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(float)sh_audio->i_bps;
1720 if(d_video->pts>a_pts) 2119 if(d_video->pts > a_pts)
1721 { 2120 {
1722 skip_audio_frame(sh_audio); // sync audio 2121 skip_audio_frame(sh_audio); // sync audio
1723 continue; 2122 continue;
1724 } 2123 }
1725 } 2124 }
1726 2125
1727 2126
1728 i = sync_video_packet(d_video); 2127 i = sync_video_packet(d_video);
1729 if(sh_video->format == VIDEO_MPEG1 || sh_video->format == VIDEO_MPEG2) 2128 if((sh_video->format == VIDEO_MPEG1) || (sh_video->format == VIDEO_MPEG2))
1730 { 2129 {
1731 if(i==0x1B3 || i==0x1B8) break; // found it! 2130 if(i==0x1B3 || i==0x1B8) break; // found it!
1732 } 2131 }
1733 else //MPEG4 2132 else //MPEG4
1734 { 2133 {