libmpeg3/mpeg3demux.c

   1 #include "libmpeg3.h"
   2 #include "mpeg3io.h"
   3 #include "mpeg3protos.h"
   4 #include "workarounds.h"
   5
   6 #include <errno.h>
   7 #include <math.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #define ABS(x) ((x) >= 0 ? (x) : -(x))
  12
  13 /* Don't advance pointer */
  14 static inline unsigned char packet_next_char(mpeg3_demuxer_t *demuxer)
  15 {
  16 //printf(__FUNCTION__ " called\n");
  17         return demuxer->raw_data[demuxer->raw_offset];
  18 }
  19
  20 /* Advance pointer */
  21 static unsigned char packet_read_char(mpeg3_demuxer_t *demuxer)
  22 {
  23         unsigned char result = demuxer->raw_data[demuxer->raw_offset++];
  24 //printf(__FUNCTION__ " called\n");
  25         return result;
  26 }
  27
  28 static inline unsigned int packet_read_int16(mpeg3_demuxer_t *demuxer)
  29 {
  30         unsigned int a, b, result;
  31 //printf(__FUNCTION__ " called\n");
  32         a = demuxer->raw_data[demuxer->raw_offset++];
  33         b = demuxer->raw_data[demuxer->raw_offset++];
  34         result = (a << 8) | b;
  35
  36         return result;
  37 }
  38
  39 static inline unsigned int packet_next_int24(mpeg3_demuxer_t *demuxer)
  40 {
  41         unsigned int a, b, c, result;
  42 //printf(__FUNCTION__ " called\n");
  43         a = demuxer->raw_data[demuxer->raw_offset];
  44         b = demuxer->raw_data[demuxer->raw_offset + 1];
  45         c = demuxer->raw_data[demuxer->raw_offset + 2];
  46         result = (a << 16) | (b << 8) | c;
  47
  48         return result;
  49 }
  50
  51 static inline unsigned int packet_read_int24(mpeg3_demuxer_t *demuxer)
  52 {
  53         unsigned int a, b, c, result;
  54 //printf(__FUNCTION__ " called\n");
  55         a = demuxer->raw_data[demuxer->raw_offset++];
  56         b = demuxer->raw_data[demuxer->raw_offset++];
  57         c = demuxer->raw_data[demuxer->raw_offset++];
  58         result = (a << 16) | (b << 8) | c;
  59
  60         return result;
  61 }
  62
  63 static inline unsigned int packet_read_int32(mpeg3_demuxer_t *demuxer)
  64 {
  65         unsigned int a, b, c, d, result;
  66 //printf(__FUNCTION__ " called\n");
  67         a = demuxer->raw_data[demuxer->raw_offset++];
  68         b = demuxer->raw_data[demuxer->raw_offset++];
  69         c = demuxer->raw_data[demuxer->raw_offset++];
  70         d = demuxer->raw_data[demuxer->raw_offset++];
  71         result = (a << 24) | (b << 16) | (c << 8) | d;
  72
  73         return result;
  74 }
  75
  76 static inline unsigned int packet_skip(mpeg3_demuxer_t *demuxer, long length)
  77 {
  78 //printf(__FUNCTION__ " called\n");
  79         demuxer->raw_offset += length;
  80         return 0;
  81 }
  82
  83 static int get_adaptation_field(mpeg3_demuxer_t *demuxer)
  84 {
  85         long length;
  86         int pcr_flag;
  87
  88         demuxer->adaptation_fields++;
  89 /* get adaptation field length */
  90         length = packet_read_char(demuxer);
  91
  92         if(length > 0)
  93         {
  94 /* get first byte */
  95                 pcr_flag = (packet_read_char(demuxer) >> 4) & 1;
  96
  97                 if(pcr_flag)
  98                 {
  99                 unsigned long clk_ref_base = packet_read_int32(demuxer);
 100                 unsigned int clk_ref_ext = packet_read_int16(demuxer);
 101
 102                         if (clk_ref_base > 0x7fffffff)
 103                         {   /* correct for invalid numbers */
 104                                 clk_ref_base = 0;               /* ie. longer than 32 bits when multiplied by 2 */
 105                                 clk_ref_ext = 0;                /* multiplied by 2 corresponds to shift left 1 (<<=1) */
 106                         }
 107                         else
 108                         {
 109                                 clk_ref_base <<= 1; /* Create space for bit */
 110                                 clk_ref_base |= (clk_ref_ext >> 15);          /* Take bit */
 111                                 clk_ref_ext &= 0x01ff;                        /* Only lower 9 bits */
 112                         }
 113                         demuxer->time = ((double)clk_ref_base + clk_ref_ext / 300) / 90000;
 114                 if(length) packet_skip(demuxer, length - 7);
 115                 }
 116                 else
 117                 packet_skip(demuxer, length - 1);
 118         }
 119
 120         return 0;
 121 }
 122
 123 static int get_program_association_table(mpeg3_demuxer_t *demuxer)
 124 {
 125         demuxer->program_association_tables++;
 126         demuxer->table_id = packet_read_char(demuxer);
 127         demuxer->section_length = packet_read_int16(demuxer) & 0xfff;
 128         demuxer->transport_stream_id = packet_read_int16(demuxer);
 129         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 130         return 0;
 131 }
 132
 133 static int get_data_buffer(mpeg3_demuxer_t *demuxer)
 134 {
 135         while(demuxer->raw_offset < demuxer->raw_size &&
 136                 demuxer->data_size < MPEG3_RAW_SIZE)
 137         {
 138                 demuxer->data_buffer[demuxer->data_size++] =
 139                         demuxer->raw_data[demuxer->raw_offset++];
 140         }
 141         return 0;
 142 }
 143
 144 static int get_pes_packet_header(mpeg3_demuxer_t *demuxer, unsigned long *pts, unsigned long *dts)
 145 {
 146         unsigned int pes_header_bytes = 0;
 147         unsigned int pts_dts_flags;
 148         int pes_header_data_length;
 149
 150 /* drop first 8 bits */
 151         packet_read_char(demuxer);
 152         pts_dts_flags = (packet_read_char(demuxer) >> 6) & 0x3;
 153         pes_header_data_length = packet_read_char(demuxer);
 154
 155
 156 /* Get Presentation Time stamps and Decoding Time Stamps */
 157         if(pts_dts_flags == 2)
 158         {
 159                 *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 160                 *pts <<= 15;
 161                 *pts |= (packet_read_int16(demuxer) >> 1);
 162                 *pts <<= 15;
 163                 *pts |= (packet_read_int16(demuxer) >> 1);
 164                 pes_header_bytes += 5;
 165         }
 166         else if(pts_dts_flags == 3)
 167         {
 168                 *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 169                 *pts <<= 15;
 170                 *pts |= (packet_read_int16(demuxer) >> 1);
 171                 *pts <<= 15;
 172                 *pts |= (packet_read_int16(demuxer) >> 1);
 173                 *dts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 174                 *dts <<= 15;
 175                 *dts |= (packet_read_int16(demuxer) >> 1);
 176                 *dts <<= 15;
 177                 *dts |= (packet_read_int16(demuxer) >> 1);
 178                 pes_header_bytes += 10;
 179   }
 180
 181         demuxer->time = (double)*pts / 90000;
 182 //printf("get_pes_packet_header %f\n", demuxer->time);
 183
 184 /* extract other stuff here! */
 185         packet_skip(demuxer, pes_header_data_length - pes_header_bytes);
 186         return 0;
 187 }
 188
 189 static int get_unknown_data(mpeg3_demuxer_t *demuxer)
 190 {
 191         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 192         return 0;
 193 }
 194
 195 // Combine the pid and the stream id into one unit
 196 #define CUSTOM_ID(pid, stream_id) (((pid << 8) | stream_id) & 0xffff)
 197
 198
 199 static int get_pes_packet_data(mpeg3_demuxer_t *demuxer, unsigned int stream_id)
 200 {
 201         unsigned long pts = 0, dts = 0;
 202         get_pes_packet_header(demuxer, &pts, &dts);
 203
 204
 205 //printf("get_pes_packet_data %x\n", CUSTOM_ID(demuxer->pid, stream_id));
 206         if(stream_id == 0xbd)
 207         {
 208 // Don't know if the next byte is the true stream id like in program stream
 209                 stream_id = 0x0;
 210
 211                 if(demuxer->read_all)
 212                         demuxer->astream_table[CUSTOM_ID(demuxer->pid, stream_id)] = AUDIO_AC3;
 213                 if(demuxer->astream == -1)
 214                     demuxer->astream = CUSTOM_ID(demuxer->pid, stream_id);
 215
 216         if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->astream &&
 217                         demuxer->do_audio)
 218                 {
 219                         demuxer->pes_audio_time = (double)pts / 90000;
 220                         demuxer->audio_pid = demuxer->pid;
 221                         return get_data_buffer(demuxer);
 222         }
 223         }
 224         else
 225         if((stream_id >> 4) == 12 || (stream_id >> 4) == 13)
 226         {
 227 /* Just pick the first available stream if no ID is set */
 228                 if(demuxer->read_all)
 229                         demuxer->astream_table[CUSTOM_ID(demuxer->pid, stream_id)] = AUDIO_MPEG;
 230                 if(demuxer->astream == -1)
 231                     demuxer->astream = CUSTOM_ID(demuxer->pid, stream_id);
 232
 233         if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->astream &&
 234                         demuxer->do_audio)
 235                 {
 236                         demuxer->pes_audio_time = (double)pts / 90000;
 237                         demuxer->audio_pid = demuxer->pid;
 238
 239                         return get_data_buffer(demuxer);
 240         }
 241         }
 242         else
 243         if((stream_id >> 4) == 14)
 244         {
 245 //printf("get_pes_packet_data video %x\n", stream_id);
 246 /* Just pick the first available stream if no ID is set */
 247                 if(demuxer->read_all)
 248                         demuxer->vstream_table[CUSTOM_ID(demuxer->pid, stream_id)] = 1;
 249                 else
 250                 if(demuxer->vstream == -1)
 251                         demuxer->vstream = (CUSTOM_ID(demuxer->pid, stream_id));
 252
 253
 254 //printf("get_pes_packet_data %x %d\n", stream_id, demuxer->payload_unit_start_indicator);
 255                 if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->vstream &&
 256                         demuxer->do_video)
 257                 {
 258                         demuxer->pes_video_time = (double)pts / 90000;
 259                         demuxer->video_pid = demuxer->pid;
 260 /*
 261  * printf("get_pes_packet_data video %04x %llx\n",
 262  * stream_id,
 263  * mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs));
 264  * int i;
 265  * for(i = demuxer->raw_offset; i < demuxer->raw_size; i++)
 266  * printf("%02x ", demuxer->raw_data[i], stdout);
 267  * printf("\n");
 268  */
 269
 270
 271                         return get_data_buffer(demuxer);
 272                 }
 273         }
 274         else
 275         {
 276                 return get_unknown_data(demuxer);
 277         }
 278
 279         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 280
 281         return 0;
 282 }
 283
 284 static int get_pes_packet(mpeg3_demuxer_t *demuxer)
 285 {
 286         unsigned int stream_id;
 287
 288         demuxer->pes_packets++;
 289
 290
 291
 292 /* Skip startcode */
 293         packet_read_int24(demuxer);
 294         stream_id = packet_read_char(demuxer);
 295
 296
 297
 298 /* Skip pes packet length */
 299         packet_read_int16(demuxer);
 300
 301         if(stream_id != MPEG3_PRIVATE_STREAM_2 &&
 302                 stream_id != MPEG3_PADDING_STREAM)
 303         {
 304                 return get_pes_packet_data(demuxer, stream_id);
 305         }
 306         else
 307         if(stream_id == MPEG3_PRIVATE_STREAM_2)
 308         {
 309 /* Dump private data! */
 310                 fprintf(stderr, "stream_id == MPEG3_PRIVATE_STREAM_2\n");
 311                 packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 312                 return 0;
 313         }
 314         else
 315         if(stream_id == MPEG3_PADDING_STREAM)
 316         {
 317                 packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 318                 return 0;
 319         }
 320         else
 321         {
 322         fprintf(stderr, "unknown stream_id in pes packet");
 323                 return 1;
 324         }
 325         return 0;
 326 }
 327
 328 static int get_payload(mpeg3_demuxer_t *demuxer)
 329 {
 330 //printf("get_payload 1 %x %d\n", demuxer->pid, demuxer->payload_unit_start_indicator);
 331         if(demuxer->payload_unit_start_indicator)
 332         {
 333         if(demuxer->pid==0)
 334                         get_program_association_table(demuxer);
 335         else
 336                 if(packet_next_int24(demuxer) == MPEG3_PACKET_START_CODE_PREFIX)
 337                         get_pes_packet(demuxer);
 338         else
 339                         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 340         }
 341         else
 342         {
 343 //printf("get_payload 2\n");
 344         if(demuxer->pid == demuxer->audio_pid && demuxer->do_audio)
 345                 {
 346                         get_data_buffer(demuxer);
 347                 }
 348         else
 349                 if(demuxer->pid == demuxer->video_pid && demuxer->do_video)
 350                 {
 351                         get_data_buffer(demuxer);
 352                 }
 353         else
 354                         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 355         }
 356         return 0;
 357 }
 358
 359 /* Read a transport packet */
 360 static int read_transport(mpeg3_demuxer_t *demuxer)
 361 {
 362         mpeg3_t *file = (mpeg3_t*)demuxer->file;
 363         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 364         int result = 0;
 365         unsigned int bits;
 366         int table_entry;
 367
 368 /* Packet size is known for transport streams */
 369         demuxer->raw_size = file->packet_size;
 370         demuxer->raw_offset = 0;
 371
 372         if(result)
 373         {
 374                 perror("read_transport");
 375                 return 1;
 376         }
 377
 378 //printf("read transport 1 %llx %llx\n", title->fs->current_byte, title->fs->total_bytes);
 379 // Search for Sync byte */
 380         do
 381         {
 382                 bits = mpeg3io_read_char(title->fs);
 383         }while(!mpeg3io_eof(title->fs) && !result && bits != MPEG3_SYNC_BYTE);
 384
 385 /* Hit EOF */
 386         if(mpeg3io_eof(title->fs) || result) return 1;
 387 /*
 388  * printf("read transport 2 bits=%x tell=%llx packet_size=%x\n",
 389  * bits,
 390  * mpeg3io_tell(title->fs),
 391  * file->packet_size);
 392  */
 393
 394         if(bits == MPEG3_SYNC_BYTE && !result)
 395         {
 396                 demuxer->raw_data[0] = MPEG3_SYNC_BYTE;
 397                 result = mpeg3io_read_data(demuxer->raw_data + 1,
 398                         file->packet_size - 1,
 399                         title->fs);
 400         }
 401         else
 402         {
 403                 demuxer->absolute_byte = mpeg3io_tell(title->fs) +
 404                         title->start_byte;
 405                 return 1;
 406         }
 407
 408         packet_read_char(demuxer);
 409     bits =  packet_read_int24(demuxer) & 0x00ffffff;
 410 //printf("read transport 3 tell=%x bits=%x\n", mpeg3io_tell(title->fs), bits);
 411     demuxer->transport_error_indicator = (bits >> 23) & 0x1;
 412     demuxer->payload_unit_start_indicator = (bits >> 22) & 0x1;
 413     demuxer->pid = (bits >> 8) & 0x00001fff;
 414     demuxer->transport_scrambling_control = (bits >> 6) & 0x3;
 415     demuxer->adaptation_field_control = (bits >> 4) & 0x3;
 416     demuxer->continuity_counter = bits & 0xf;
 417 //printf("read_transport 1 %llx %08x %d\n", mpeg3io_tell(title->fs), bits, demuxer->payload_unit_start_indicator);
 418
 419 //printf("read_transport 4 %x\n", demuxer->pid);
 420         if(demuxer->transport_error_indicator)
 421         {
 422                 fprintf(stderr, "demuxer->transport_error_indicator\n");
 423                 demuxer->absolute_byte = mpeg3io_tell(title->fs) +
 424                         title->start_byte;
 425                 return 1;
 426         }
 427
 428 //printf("read_transport 5 %x\n", demuxer->pid);
 429     if (demuxer->pid == 0x1fff)
 430         {
 431                 demuxer->is_padding = 1;  /* padding; just go to next */
 432     }
 433         else
 434         {
 435                 demuxer->is_padding = 0;
 436         }
 437
 438 //printf("read_transport 6 %x\n", demuxer->pid);
 439 /* Get pid from table */
 440         for(table_entry = 0, result = 0;
 441                 table_entry < demuxer->total_pids;
 442                 table_entry++)
 443         {
 444                 if(demuxer->pid == demuxer->pid_table[table_entry])
 445                 {
 446                         result = 1;
 447                         break;
 448                 }
 449         }
 450
 451 //printf("read_transport 7 %x\n", demuxer->pid);
 452
 453
 454
 455 /* Not in pid table */
 456         if(!result)
 457         {
 458                 demuxer->pid_table[table_entry] = demuxer->pid;
 459                 demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;  /* init */
 460                 demuxer->total_pids++;
 461         }
 462         result = 0;
 463
 464 /* Abort if padding.  Should abort after demuxer->pid == 0x1fff for speed. */
 465         if(demuxer->is_padding)
 466         {
 467                 demuxer->absolute_byte = mpeg3io_tell(title->fs) +
 468                         title->start_byte;
 469                 return 0;
 470         }
 471
 472
 473 #if 0
 474 /* Check counters */
 475     if(demuxer->pid != MPEG3_PROGRAM_ASSOCIATION_TABLE &&
 476                 demuxer->pid != MPEG3_CONDITIONAL_ACCESS_TABLE &&
 477         (demuxer->adaptation_field_control == 1 || demuxer->adaptation_field_control == 3))
 478         {
 479                 if(demuxer->continuity_counters[table_entry] != demuxer->continuity_counter)
 480                 {
 481 //                      fprintf(stderr, "demuxer->continuity_counters[table_entry] != demuxer->continuity_counter\n");
 482 /* Reset it */
 483                         demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;
 484                 }
 485                 if(++(demuxer->continuity_counters[table_entry]) > 15) demuxer->continuity_counters[table_entry] = 0;
 486         }
 487 #endif
 488
 489
 490
 491
 492
 493
 494
 495     if(demuxer->adaptation_field_control == 2 ||
 496                 demuxer->adaptation_field_control == 3)
 497         result = get_adaptation_field(demuxer);
 498
 499 // Need to enter in astream and vstream table:
 500 // PID ored with stream_id
 501     if(demuxer->adaptation_field_control == 1 ||
 502                 demuxer->adaptation_field_control == 3)
 503         result = get_payload(demuxer);
 504
 505         demuxer->absolute_byte = mpeg3io_tell(title->fs) +
 506                 title->start_byte;
 507         return result;
 508 }
 509
 510 static int get_system_header(mpeg3_demuxer_t *demuxer)
 511 {
 512         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 513         int length = mpeg3io_read_int16(title->fs);
 514         mpeg3io_seek_relative(title->fs, length);
 515         return 0;
 516 }
 517
 518 static unsigned long get_timestamp(mpeg3_demuxer_t *demuxer)
 519 {
 520         unsigned long timestamp;
 521         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 522
 523 /* Only low 4 bits (7==1111) */
 524         timestamp = (mpeg3io_read_char(title->fs) >> 1) & 7;
 525         timestamp <<= 15;
 526         timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
 527         timestamp <<= 15;
 528         timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
 529         return timestamp;
 530 }
 531
 532 static int get_pack_header(mpeg3_demuxer_t *demuxer)
 533 {
 534         unsigned long i, j;
 535         unsigned long clock_ref, clock_ref_ext;
 536         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 537
 538 /* Get the time code */
 539         if((mpeg3io_next_char(title->fs) >> 4) == 2)
 540         {
 541 /* MPEG-1 */
 542                         demuxer->time = (double)get_timestamp(demuxer) / 90000;
 543 /* Skip 3 bytes */
 544                         mpeg3io_read_int24(title->fs);
 545         }
 546         else
 547         if(mpeg3io_next_char(title->fs) & 0x40)
 548         {
 549                 i = mpeg3io_read_int32(title->fs);
 550                 j = mpeg3io_read_int16(title->fs);
 551
 552                 if(i & 0x40000000 || (i >> 28) == 2)
 553                 {
 554                 clock_ref = ((i & 0x38000000) << 3);
 555                 clock_ref |= ((i & 0x03fff800) << 4);
 556                 clock_ref |= ((i & 0x000003ff) << 5);
 557                 clock_ref |= ((j & 0xf800) >> 11);
 558                 clock_ref_ext = (j >> 1) & 0x1ff;
 559
 560                         demuxer->time = (double)(clock_ref + clock_ref_ext / 300) / 90000;
 561 /* Skip 3 bytes */
 562                         mpeg3io_read_int24(title->fs);
 563                         i = mpeg3io_read_char(title->fs) & 0x7;
 564
 565 /* stuffing */
 566                         mpeg3io_seek_relative(title->fs, i);
 567                 }
 568         }
 569         else
 570         {
 571                 mpeg3io_seek_relative(title->fs, 2);
 572         }
 573         return 0;
 574 }
 575
 576 /* Program packet reading core */
 577 static int get_ps_pes_packet(mpeg3_demuxer_t *demuxer, unsigned int header)
 578 {
 579         unsigned long pts = 0, dts = 0;
 580         int stream_id;
 581         int pes_packet_length;
 582         int64_t pes_packet_start;
 583         long decryption_offset;
 584         int i;
 585         mpeg3_t *file = demuxer->file;
 586         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 587         int scrambling = 0;
 588         int data_start = demuxer->data_size;
 589 /* Format if audio */
 590         int do_pcm = 0;
 591
 592         stream_id = header & 0xff;
 593         pes_packet_length = mpeg3io_read_int16(title->fs);
 594         pes_packet_start = mpeg3io_tell(title->fs);
 595
 596
 597
 598 /*
 599  * printf(__FUNCTION__ " pes_packet_start=%llx pes_packet_length=%x data_size=%x\n",
 600  * pes_packet_start,
 601  * pes_packet_length,
 602  * demuxer->data_size);
 603  */
 604
 605
 606
 607
 608
 609         if(stream_id != MPEG3_PRIVATE_STREAM_2 &&
 610                 stream_id != MPEG3_PADDING_STREAM)
 611         {
 612                 if((mpeg3io_next_char(title->fs) >> 6) == 0x02)
 613                 {
 614 /* Get MPEG-2 packet */
 615                         int pes_header_bytes = 0;
 616                 int pts_dts_flags;
 617                         int pes_header_data_length;
 618
 619
 620                         demuxer->last_packet_decryption = mpeg3io_tell(title->fs);
 621                         scrambling = mpeg3io_read_char(title->fs) & 0x30;
 622 //scrambling = 1;
 623 /* Reset scrambling bit for the mpeg3cat utility */
 624 //                      if(scrambling) demuxer->raw_data[demuxer->raw_offset - 1] &= 0xcf;
 625 // Force packet length if scrambling
 626                         if(scrambling) pes_packet_length = 0x800 -
 627                                 pes_packet_start +
 628                                 demuxer->last_packet_start;
 629
 630
 631                 pts_dts_flags = (mpeg3io_read_char(title->fs) >> 6) & 0x3;
 632                         pes_header_data_length = mpeg3io_read_char(title->fs);
 633
 634
 635
 636 /* Get Presentation and Decoding Time Stamps */
 637                         if(pts_dts_flags == 2)
 638                         {
 639                                 pts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 640                                 pts <<= 15;
 641                                 pts |= (mpeg3io_read_int16(title->fs) >> 1);
 642                                 pts <<= 15;
 643                                 pts |= (mpeg3io_read_int16(title->fs) >> 1);
 644                                 pes_header_bytes += 5;
 645                         }
 646                 else
 647                         if(pts_dts_flags == 3)
 648                         {
 649                         pts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 650                         pts <<= 15;
 651                         pts |= (mpeg3io_read_int16(title->fs) >> 1);
 652                         pts <<= 15;
 653                         pts |= (mpeg3io_read_int16(title->fs) >> 1);
 654
 655                         dts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 656                         dts <<= 15;
 657                         dts |= (mpeg3io_read_int16(title->fs) >> 1);
 658                         dts <<= 15;
 659                         dts |= (mpeg3io_read_int16(title->fs) >> 1);
 660                         pes_header_bytes += 10;
 661                 }
 662
 663 //printf("get_ps_pes_packet do_audio=%d do_video=%d pts=%x dts=%x\n",
 664 //      demuxer->do_audio, demuxer->do_video, pts, dts);
 665
 666 /* Skip unknown */
 667                 mpeg3io_seek_relative(title->fs,
 668                                 pes_header_data_length - pes_header_bytes);
 669                 }
 670                 else
 671                 {
 672                         int pts_dts_flags;
 673 /* Get MPEG-1 packet */
 674                         while(mpeg3io_next_char(title->fs) == 0xff)
 675                         {
 676                                 mpeg3io_read_char(title->fs);
 677                         }
 678
 679 /* Skip STD buffer scale */
 680                         if((mpeg3io_next_char(title->fs) & 0x40) == 0x40)
 681                         {
 682                                 mpeg3io_seek_relative(title->fs, 2);
 683                         }
 684
 685 /* Decide which timestamps are available */
 686                         pts_dts_flags = mpeg3io_next_char(title->fs);
 687
 688                         if(pts_dts_flags >= 0x30)
 689                         {
 690 /* Get the presentation and decoding time stamp */
 691                                 pts = get_timestamp(demuxer);
 692                                 dts = get_timestamp(demuxer);
 693                         }
 694                         else
 695                         if(pts_dts_flags >= 0x20)
 696                         {
 697 /* Get just the presentation time stamp */
 698                                 pts = get_timestamp(demuxer);
 699                         }
 700                         else
 701                         if(pts_dts_flags == 0x0f)
 702                         {
 703 /* End of timestamps */
 704                                 mpeg3io_read_char(title->fs);
 705                         }
 706                         else
 707                         {
 708                                 return 1;     /* Error */
 709                         }
 710                 }
 711
 712 /* Now extract the payload. */
 713                 if((stream_id >> 4) == 0xc || (stream_id >> 4) == 0xd)
 714                 {
 715 /* Audio data */
 716 /* Take first stream ID if -1 */
 717                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 718
 719
 720
 721
 722                         if(demuxer->read_all)
 723                                 demuxer->astream_table[stream_id & 0x0f] = AUDIO_MPEG;
 724                         else
 725                         if(demuxer->astream == -1)
 726                                 demuxer->astream = stream_id & 0x0f;
 727
 728
 729
 730
 731                         if(pts > 0) demuxer->pes_audio_time = (double)pts / 60000;
 732
 733
 734                         if((stream_id & 0x0f) == demuxer->astream && demuxer->do_audio)
 735                         {
 736                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
 737                                 mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size,
 738                                         pes_packet_length,
 739                                         title->fs);
 740                                 demuxer->data_size += pes_packet_length;
 741                         }
 742                         else
 743                         {
 744                         mpeg3io_seek_relative(title->fs, pes_packet_length);
 745                         }
 746                 }
 747         else
 748                 if((stream_id >> 4) == 0xe)
 749                 {
 750 /* Video data */
 751 /* Take first stream ID if -1 */
 752                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 753
 754
 755
 756                         if(demuxer->read_all)
 757                                 demuxer->vstream_table[stream_id & 0x0f] = 1;
 758                         else
 759                         if(demuxer->vstream == -1)
 760                                 demuxer->vstream = stream_id & 0x0f;
 761
 762                         if(pts > 0) demuxer->pes_video_time = (double)pts / 60000;
 763
 764
 765
 766             if((stream_id & 0x0f) == demuxer->vstream && demuxer->do_video)
 767                         {
 768 //printf(__FUNCTION__ " stream_id=%x size=%x\n", stream_id, pes_packet_length);
 769                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
 770                                 mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size,
 771                                         pes_packet_length,
 772                                         title->fs);
 773
 774                                 demuxer->data_size += pes_packet_length;
 775                 }
 776                 else
 777                         {
 778                         mpeg3io_seek_relative(title->fs, pes_packet_length);
 779                 }
 780         }
 781         else
 782                 if((stream_id == 0xbd || stream_id == 0xbf) &&
 783                         mpeg3io_next_char(title->fs) != 0xff &&
 784                         ((mpeg3io_next_char(title->fs) & 0xf0) != 0x20))
 785                 {
 786                         int format;
 787 /* DVD audio data */
 788 /* Get the audio format */
 789                         if((mpeg3io_next_char(title->fs) & 0xf0) == 0xa0)
 790                                 format = AUDIO_PCM;
 791                         else
 792                                 format = AUDIO_AC3;
 793
 794 // Picks up bogus data if (& 0xf) or (& 0x7f)
 795                         stream_id = mpeg3io_next_char(title->fs);
 796                         if(pts > 0) demuxer->pes_audio_time = (double)pts / 60000;
 797
 798 //printf("get_ps_pes_packet %x\n", stream_id);
 799 /* Take first stream ID if not building TOC. */
 800                         if(demuxer->read_all)
 801                                 demuxer->astream_table[stream_id] = format;
 802                         else
 803                         if(demuxer->astream == -1)
 804                                 demuxer->astream = stream_id;
 805
 806
 807
 808
 809
 810
 811
 812 //printf("get_ps_pes_packet 5 %x\n", format);
 813                 if(stream_id == demuxer->astream && demuxer->do_audio)
 814                         {
 815                                 demuxer->aformat = format;
 816                                 mpeg3io_read_int32(title->fs);
 817
 818                                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 819                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
 820
 821                                 if(format == AUDIO_PCM) do_pcm = 1;
 822 //printf("get_ps_pes_packet 5 %x\n", decryption_offset);
 823
 824
 825
 826                                 mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size,
 827                                         pes_packet_length,
 828                                         title->fs);
 829                                 demuxer->data_size += pes_packet_length;
 830                 }
 831                 else
 832                         {
 833                                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 834                         mpeg3io_seek_relative(title->fs, pes_packet_length);
 835                 }
 836 //printf("get_ps_pes_packet 6 %d\n", demuxer->astream_table[0x20]);
 837         }
 838         else
 839                 if(stream_id == 0xbc || 1)
 840                 {
 841                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 842                 mpeg3io_seek_relative(title->fs, pes_packet_length);
 843         }
 844         }
 845         else
 846         if(stream_id == MPEG3_PRIVATE_STREAM_2 || stream_id == MPEG3_PADDING_STREAM)
 847         {
 848                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
 849         mpeg3io_seek_relative(title->fs, pes_packet_length);
 850 //printf(__FUNCTION__ " 2 %llx\n", mpeg3io_tell(title->fs));
 851         }
 852
 853
 854
 855
 856
 857 // Advance 2048 bytes if scrambled.  We might pick up a spurrius
 858 // packet start code in the scrambled data otherwise.
 859         if(scrambling &&
 860                 demuxer->last_packet_start + 0x800 > mpeg3io_tell(title->fs))
 861         {
 862                 mpeg3io_seek_relative(title->fs,
 863                         demuxer->last_packet_start + 0x800 - mpeg3io_tell(title->fs));
 864         }
 865
 866
 867
 868
 869
 870 // Descramble if desired
 871         if(demuxer->data_size && scrambling)
 872         {
 873 //printf(__FUNCTION__ " data_size=%x decryption_offset=%x\n", demuxer->data_size, decryption_offset);
 874                 if(mpeg3_decrypt_packet(title->fs->css,
 875                         demuxer->data_buffer,
 876                         decryption_offset))
 877                 {
 878                         fprintf(stderr, "get_ps_pes_packet: Decryption not available\n");
 879                         return 1;
 880                 }
 881         }
 882
 883
 884
 885
 886
 887
 888 /* Synthesize PCM header and delete MPEG header for PCM data */
 889 /* Must be done after decryption */
 890         if(do_pcm)
 891         {
 892                 unsigned char code;
 893                 int bits_code;
 894                 int bits;
 895                 int samplerate_code;
 896                 int samplerate;
 897                 unsigned char *output = demuxer->data_buffer + data_start;
 898                 int j;
 899
 900 /* Shift audio back */
 901                 code = output[1];
 902                 for(i = demuxer->data_size - 1, j = demuxer->data_size + PCM_HEADERSIZE - 3 - 1;
 903                         i >= data_start;
 904                         i--, j--)
 905                         *(demuxer->data_buffer + j) = *(demuxer->data_buffer + i);
 906                 demuxer->data_size += PCM_HEADERSIZE - 3;
 907
 908                 bits_code = (code >> 6) & 3;
 909                 samplerate_code = (code & 0x10);
 910
 911
 912                 output[0] = 0x7f;
 913                 output[1] = 0x7f;
 914                 output[2] = 0x80;
 915                 output[3] = 0x7f;
 916 /* Samplerate */
 917                 switch(samplerate_code)
 918                 {
 919                         case 1:
 920                                 samplerate = 96000;
 921                                 break;
 922                         default:
 923                                 samplerate = 48000;
 924                                 break;
 925                 }
 926
 927                 *(int32_t*)(output + 4) = samplerate;
 928 /* Bits */
 929                 switch(bits_code)
 930                 {
 931                         case 0: bits = 16; break;
 932                         case 1: bits = 20; break;
 933                         case 2: bits = 24; break;
 934                         default: bits = 16; break;
 935                 }
 936                 *(int32_t*)(output + 8) = bits;
 937 /* Channels */
 938                 *(int32_t*)(output + 12) = (code & 0x7) + 1;
 939 /* Framesize */
 940                 *(int32_t*)(output + 16) = pes_packet_length -
 941                         3 +
 942                         PCM_HEADERSIZE;
 943 //printf(__FUNCTION__ " %02x%02x%02x %d\n", code1, code, code2, pes_packet_length - 3);
 944         }
 945
 946
 947
 948
 949
 950
 951
 952
 953 //printf(__FUNCTION__ " 3 %llx %x\n", mpeg3io_tell(title->fs), demuxer->data_size);
 954
 955
 956 //if(mpeg3io_tell(title->fs) - demuxer->last_packet_start != 0x800)
 957 //printf(__FUNCTION__ " packet size == %llx\n", mpeg3io_tell(title->fs) - demuxer->last_packet_start);
 958
 959 //printf(__FUNCTION__ " pes_audio_time=%f pes_video_time=%f\n", demuxer->pes_audio_time, demuxer->pes_video_time);
 960
 961         return 0;
 962 }
 963
 964 int mpeg3demux_read_program(mpeg3_demuxer_t *demuxer)
 965 {
 966         int result = 0;
 967         int count = 0;
 968         mpeg3_t *file = demuxer->file;
 969         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 970         unsigned int header = 0;
 971         int pack_count = 0;
 972
 973         demuxer->data_size = 0;
 974 //printf("mpeg3demux_read_program 1 %d %llx %llx\n", result, title->fs->current_byte, title->fs->total_bytes);
 975
 976         if(mpeg3io_eof(title->fs)) return 1;
 977
 978 //printf("mpeg3demux_read_program 2 %d %x %llx\n", result, title->fs->current_byte, title->fs->total_bytes);
 979
 980
 981
 982
 983
 984
 985
 986 /* Search for next header */
 987 /* Parse packet until the next packet start code */
 988         while(!result && !mpeg3io_eof(title->fs))
 989         {
 990                 header = mpeg3io_read_int32(title->fs);
 991
 992
 993
 994                 if(header == MPEG3_PACK_START_CODE)
 995                 {
 996
 997
 998 // Second start code in this call.  Don't read it.
 999                         if(pack_count)
1000                         {
1001                                 mpeg3io_seek_relative(title->fs, -4);
1002                                 break;
1003                         }
1004
1005                         demuxer->last_packet_start = mpeg3io_tell(title->fs) - 4;
1006                         result = get_pack_header(demuxer);
1007 //printf("mpeg3demux_read_program MPEG3_PACK_START_CODE %d\n", result);
1008                         pack_count++;
1009
1010
1011
1012                 }
1013                 else
1014                 if(header == MPEG3_SYSTEM_START_CODE && pack_count)
1015                 {
1016
1017
1018
1019                         result = get_system_header(demuxer);
1020 //printf("mpeg3demux_read_program MPEG3_SYSTEM_START_CODE %d\n", result);
1021
1022
1023
1024                 }
1025                 else
1026                 if((header >> 8) == MPEG3_PACKET_START_CODE_PREFIX && pack_count)
1027                 {
1028
1029
1030                         result = get_ps_pes_packet(demuxer, header);
1031 //printf("mpeg3demux_read_program MPEG3_PACKET_START_CODE_PREFIX %d %08x\n", result, header);
1032
1033
1034
1035                 }
1036                 else
1037                 {
1038 // Try again.
1039 //printf(__FUNCTION__ " %llx %08x\n", mpeg3io_tell(title->fs), header);
1040                         mpeg3io_seek_relative(title->fs, -3);
1041                 }
1042         }
1043 //printf("mpeg3demux_read_program 3 %d %x %llx\n", result, title->fs->current_byte, title->fs->total_bytes);
1044
1045
1046
1047
1048
1049
1050
1051 // Ignore errors in the parsing.  Just quit if eof.
1052         result = 0;
1053
1054
1055
1056
1057
1058
1059         demuxer->last_packet_end = mpeg3io_tell(title->fs);
1060
1061 /*
1062  * if(demuxer->last_packet_end - demuxer->last_packet_start != 0x800)
1063  * printf(__FUNCTION__ " packet_size=%llx data_size=%x pack_count=%d packet_start=%llx packet_end=%llx\n",
1064  * demuxer->last_packet_end - demuxer->last_packet_start,
1065  * demuxer->data_size,
1066  * pack_count,
1067  * demuxer->last_packet_start,
1068  * demuxer->last_packet_end);
1069  */
1070 //printf("mpeg3demux_read_program 5 %d\n", result);
1071
1072 //printf("read_program 3\n");
1073 //      if(!result) result = mpeg3io_eof(title->fs);
1074
1075         demuxer->absolute_byte = mpeg3io_tell(title->fs) +
1076                 title->start_byte;
1077         return result;
1078 }
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118 int mpeg3_advance_cell(mpeg3_demuxer_t *demuxer)
1119 {
1120         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1121
1122         mpeg3io_seek(title->fs, demuxer->absolute_byte - title->start_byte);
1123
1124 //printf("mpeg3_advance_cell %llx %llx\n",demuxer->absolute_byte , title->start_byte);
1125 /* Don't do anything when constructing cell table */
1126         if(!title->cell_table ||
1127                 !title->cell_table_size ||
1128                 demuxer->read_all)
1129         {
1130                 return 0;
1131         }
1132
1133         mpeg3demux_cell_t *cell = &title->cell_table[demuxer->title_cell];
1134
1135
1136 //printf("mpeg3_advance_cell 1\n");
1137 /* Don't do anything if we're in the cell and it's the right program */
1138         if(demuxer->reverse)
1139         {
1140 /*
1141  * printf("mpeg3_advance_cell 1 %llx %llx %llx %llx %llx\n",
1142  * demuxer->absolute_byte,
1143  * cell->start_byte,
1144  * cell->end_byte,
1145  * title->start_byte,
1146  * title->end_byte);fflush(stdout);
1147  */
1148                 if(demuxer->absolute_byte > cell->start_byte + title->start_byte &&
1149                         demuxer->absolute_byte <= cell->end_byte + title->start_byte &&
1150                         cell->program == demuxer->current_program)
1151                 {
1152                         return 0;
1153                 }
1154         }
1155         else
1156         {
1157                 if(demuxer->absolute_byte >= cell->start_byte + title->start_byte &&
1158                         demuxer->absolute_byte < cell->end_byte + title->start_byte &&
1159                         cell->program == demuxer->current_program)
1160                         return 0;
1161         }
1162
1163 //printf("mpeg3_advance_cell 10\n");
1164         int result = 0;
1165         int last_cell = demuxer->title_cell;
1166         int last_title = demuxer->current_title;
1167         int64_t last_byte = demuxer->absolute_byte;
1168         int got_it = 0;
1169
1170 /*
1171  * printf("mpeg3_advance_cell 2 %llx %llx %llx %llx %llx\n",
1172  * demuxer->absolute_byte,
1173  * cell->start_byte + title->start_byte,
1174  * cell->end_byte + title->start_byte,
1175  * title->start_byte,
1176  * title->end_byte);fflush(stdout);
1177  */
1178
1179 /* Find first cell on or after current position */
1180         if(demuxer->reverse)
1181         {
1182                 for(demuxer->current_title = demuxer->total_titles - 1;
1183                         demuxer->current_title >= 0;
1184                         demuxer->current_title--)
1185                 {
1186                         title = demuxer->titles[demuxer->current_title];
1187                         if(title->start_byte < demuxer->absolute_byte)
1188                         {
1189                                 for(demuxer->title_cell = title->cell_table_size - 1;
1190                                         demuxer->title_cell >= 0;
1191                                         demuxer->title_cell--)
1192                                 {
1193                                         cell = &title->cell_table[demuxer->title_cell];
1194                                         if(cell->start_byte + title->start_byte < demuxer->absolute_byte &&
1195                                                 cell->program == demuxer->current_program)
1196                                         {
1197                                                 got_it = 1;
1198                                                 if(demuxer->absolute_byte > cell->end_byte + title->start_byte)
1199                                                         demuxer->absolute_byte = cell->end_byte + title->start_byte;
1200                                                 break;
1201                                         }
1202                                 }
1203                         }
1204                         if(got_it) break;
1205                 }
1206
1207                 if(!got_it)
1208                 {
1209                         demuxer->current_title = 0;
1210                         demuxer->title_cell = 0;
1211                         result = 1;
1212                 }
1213 //printf("mpeg3_advance_cell 10\n");
1214         }
1215         else
1216         {
1217 //printf("mpeg3_advance_cell 20\n");
1218                 for(demuxer->current_title = 0;
1219                         demuxer->current_title < demuxer->total_titles;
1220                         demuxer->current_title++)
1221                 {
1222                         title = demuxer->titles[demuxer->current_title];
1223                         if(title->end_byte > demuxer->absolute_byte)
1224                         {
1225                                 for(demuxer->title_cell = 0;
1226                                         demuxer->title_cell < title->cell_table_size;
1227                                         demuxer->title_cell++)
1228                                 {
1229                                         cell = &title->cell_table[demuxer->title_cell];
1230                                         if(cell->end_byte + title->start_byte > demuxer->absolute_byte &&
1231                                                 cell->program == demuxer->current_program)
1232                                         {
1233                                                 got_it = 1;
1234                                                 if(demuxer->absolute_byte < cell->start_byte + title->start_byte)
1235                                                         demuxer->absolute_byte = cell->start_byte + title->start_byte;
1236                                                 break;
1237                                         }
1238                                 }
1239                         }
1240                         if(got_it) break;
1241                 }
1242
1243                 if(!got_it)
1244                 {
1245                         demuxer->current_title = demuxer->total_titles - 1;
1246                         title = demuxer->titles[demuxer->current_title];
1247                         demuxer->title_cell = title->cell_table_size - 1;
1248                         result = 1;
1249                 }
1250 //printf("mpeg3_advance_cell 30\n");
1251         }
1252
1253
1254 /*
1255  * printf("mpeg3_advance_cell 40 %llx %llx %llx %llx %llx\n",
1256  * demuxer->absolute_byte,
1257  * cell->start_byte + title->start_byte,
1258  * cell->end_byte + title->start_byte,
1259  * title->start_byte,
1260  * title->end_byte);fflush(stdout);
1261  */
1262
1263
1264         if(demuxer->current_title != last_title)
1265         {
1266                 mpeg3demux_open_title(demuxer, demuxer->current_title);
1267         }
1268
1269         title = demuxer->titles[demuxer->current_title];
1270         if(demuxer->absolute_byte != title->start_byte + mpeg3io_tell(title->fs))
1271         {
1272                 mpeg3io_seek(title->fs, demuxer->absolute_byte - title->start_byte);
1273         }
1274
1275 //printf("mpeg3_advance_cell 40\n", demuxer->absolute_byte);
1276         return result;
1277 }
1278
1279
1280
1281
1282
1283
1284
1285 static int next_code(mpeg3_demuxer_t *demuxer,
1286         uint32_t code)
1287 {
1288         uint32_t result = 0;
1289         int error = 0;
1290         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1291         mpeg3_fs_t *fd = title->fs;
1292
1293         while(result != code &&
1294                 !error)
1295         {
1296                 title = demuxer->titles[demuxer->current_title];
1297                 result <<= 8;
1298                 result |= (unsigned char)mpeg3io_read_char(title->fs);
1299                 demuxer->absolute_byte++;
1300                 error = mpeg3_advance_cell(demuxer);
1301         }
1302         return error;
1303 }
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314 /* Read packet in the forward direction */
1315 int mpeg3_read_next_packet(mpeg3_demuxer_t *demuxer)
1316 {
1317         int result = 0;
1318         long current_position;
1319         mpeg3_t *file = demuxer->file;
1320         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1321 /*
1322  * printf("mpeg3_read_next_packet 1 %d %llx\n", result, demuxer->absolute_byte);
1323  * fflush(stdout);
1324  */
1325
1326 /* Reset output buffer */
1327         demuxer->data_size = 0;
1328         demuxer->data_position = 0;
1329
1330 /* Switch to forward direction. */
1331         if(demuxer->reverse)
1332         {
1333 /* Don't reread anything if we're at the beginning of the file. */
1334                 if(demuxer->absolute_byte < 0)
1335                 {
1336                         demuxer->absolute_byte = 0;
1337                         result = mpeg3_advance_cell(demuxer);
1338 /* First character was the -1 byte which brings us to 0 after this function. */
1339                         result = 1;
1340                 }
1341                 else
1342 /* Transport or elementary stream */
1343                 if(file->packet_size > 0)
1344                 {
1345                         demuxer->absolute_byte += file->packet_size;
1346                         result = mpeg3_advance_cell(demuxer);
1347                 }
1348                 else
1349                 {
1350 /* Packet just read */
1351                         if(!result) result = next_code(demuxer,
1352                                 MPEG3_PACK_START_CODE);
1353 /* Next packet */
1354                         if(!result) result = next_code(demuxer,
1355                                 MPEG3_PACK_START_CODE);
1356                 }
1357
1358                 demuxer->reverse = 0;
1359         }
1360
1361
1362
1363
1364
1365
1366 //printf("mpeg3_read_next_packet 2 %llx\n", demuxer->absolute_byte);
1367
1368 /* Read packets until the output buffer is full */
1369         if(!result)
1370         {
1371                 do
1372                 {
1373                         title = demuxer->titles[demuxer->current_title];
1374
1375                         if(!result)
1376                         {
1377                                 if(file->is_transport_stream)
1378                                 {
1379                                         result = read_transport(demuxer);
1380                                         if(!result) result = mpeg3_advance_cell(demuxer);
1381                                 }
1382                                 else
1383                                 if(file->is_program_stream)
1384                                 {
1385                                         result = mpeg3demux_read_program(demuxer);
1386                                         if(!result) result = mpeg3_advance_cell(demuxer);
1387                                 }
1388                                 else
1389                                 {
1390 /* Read elementary stream. */
1391                                         result = mpeg3io_read_data(demuxer->data_buffer,
1392                                                 file->packet_size, title->fs);
1393                                         if(!result)
1394                                         {
1395                                                 demuxer->data_size = file->packet_size;
1396                                                 demuxer->absolute_byte += file->packet_size;
1397                                                 result = mpeg3_advance_cell(demuxer);
1398                                         }
1399                                 }
1400                         }
1401                 }while(!result &&
1402                         demuxer->data_size == 0 &&
1403                         (demuxer->do_audio || demuxer->do_video));
1404         }
1405 //printf("mpeg3_read_next_packet 3\n");
1406
1407 /*
1408  * printf("mpeg3_read_next_packet 2 %d %llx\n", result, demuxer->absolute_byte);
1409  * fflush(stdout);
1410  */
1411         return result;
1412 }
1413
1414
1415
1416
1417 static int prev_code(mpeg3_demuxer_t *demuxer,
1418         uint32_t code)
1419 {
1420         uint32_t result = 0;
1421         int error = 0;
1422         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1423         mpeg3_fs_t *fd = title->fs;
1424
1425
1426         while(result != code &&
1427                 demuxer->absolute_byte > 0 &&
1428                 !error)
1429         {
1430                 result >>= 8;
1431                 title = demuxer->titles[demuxer->current_title];
1432                 mpeg3io_seek(title->fs, demuxer->absolute_byte - title->start_byte - 1LL);
1433 //printf("1 %llx %llx\n", demuxer->absolute_byte, title->start_byte);fflush(stdout);
1434                 result |= ((uint32_t)mpeg3io_read_char(title->fs)) << 24;
1435 //printf("2\n");fflush(stdout);
1436                 demuxer->absolute_byte--;
1437                 error = mpeg3_advance_cell(demuxer);
1438         }
1439         return error;
1440 }
1441
1442
1443
1444
1445
1446 /* Read the packet right before the packet we're currently on. */
1447 int mpeg3_read_prev_packet(mpeg3_demuxer_t *demuxer)
1448 {
1449         int result = 0;
1450         mpeg3_t *file = demuxer->file;
1451         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1452
1453         demuxer->data_size = 0;
1454         demuxer->data_position = 0;
1455
1456 /*
1457  * printf("mpeg3_read_prev_packet 1 %d %d %d %d %llx\n",
1458  * demuxer->total_titles,
1459  * demuxer->current_title,
1460  * title->cell_table_size,
1461  * demuxer->title_cell,
1462  * demuxer->absolute_byte);fflush(stdout);
1463  */
1464
1465
1466 //printf("mpeg3_read_prev_packet 1 %d %d %llx\n", result, demuxer->current_title, mpeg3io_tell(title->fs));
1467 /* Switch to reverse direction */
1468         if(!demuxer->reverse)
1469         {
1470                 demuxer->reverse = 1;
1471
1472 /* Transport stream or elementary stream case */
1473                 if(file->packet_size > 0)
1474                 {
1475                         demuxer->absolute_byte -= file->packet_size;
1476                         result = mpeg3_advance_cell(demuxer);
1477                 }
1478                 else
1479 /* Program stream */
1480                 {
1481 //printf("mpeg3_read_prev_packet 1 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1482                         result = prev_code(demuxer,
1483                                 MPEG3_PACK_START_CODE);
1484 //printf("mpeg3_read_prev_packet 2 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1485                 }
1486
1487         }
1488
1489
1490
1491
1492
1493
1494
1495 /* Go to beginning of previous packet */
1496         do
1497         {
1498                 title = demuxer->titles[demuxer->current_title];
1499
1500 /*
1501  * printf("mpeg3_read_prev_packet 2 %d %llx %llx\n",
1502  * demuxer->current_title,
1503  * demuxer->absolute_byte,
1504  * title->start_byte);
1505  */
1506
1507 /* Transport stream or elementary stream case */
1508                 if(file->packet_size > 0)
1509                 {
1510                         demuxer->absolute_byte -= file->packet_size;
1511                         result = mpeg3_advance_cell(demuxer);
1512                 }
1513                 else
1514                 {
1515                         if(!result) result = prev_code(demuxer,
1516                                 MPEG3_PACK_START_CODE);
1517                 }
1518
1519 //printf("mpeg3_read_prev_packet 3 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1520
1521
1522 /* Read packet and then rewind it */
1523                 title = demuxer->titles[demuxer->current_title];
1524                 if(file->is_transport_stream && !result)
1525                 {
1526                         result = read_transport(demuxer);
1527
1528                         if(demuxer->absolute_byte > 0)
1529                         {
1530                                 demuxer->absolute_byte -= file->packet_size;
1531                                 result = mpeg3_advance_cell(demuxer);
1532                         }
1533                 }
1534                 else
1535                 if(file->is_program_stream && !result)
1536                 {
1537                         int64_t current_position = demuxer->absolute_byte;
1538
1539 /* Read packet */
1540                         result = mpeg3demux_read_program(demuxer);
1541
1542 //printf("mpeg3_read_prev_packet 5 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1543 /* Rewind packet */
1544                         while(demuxer->absolute_byte > current_position &&
1545                                 !result)
1546                         {
1547                                 result = prev_code(demuxer,
1548                                         MPEG3_PACK_START_CODE);
1549                         }
1550 //printf("mpeg3_read_prev_packet 6 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1551                 }
1552                 else
1553                 if(!result)
1554                 {
1555 /* Elementary stream */
1556 /* Read the packet forwards and seek back to the start */
1557                         result = mpeg3io_read_data(demuxer->data_buffer,
1558                                 file->packet_size,
1559                                 title->fs);
1560
1561                         if(!result)
1562                         {
1563                                 demuxer->data_size = file->packet_size;
1564                                 result = mpeg3io_seek(title->fs, demuxer->absolute_byte);
1565                         }
1566                 }
1567 //printf("mpeg3_read_prev_packet 4 %d %llx\n", demuxer->current_title, demuxer->absolute_byte);
1568         }while(!result &&
1569                 demuxer->data_size == 0 &&
1570                 (demuxer->do_audio || demuxer->do_video));
1571
1572
1573 //printf("mpeg3_read_prev_packet 5 %d %d %llx\n", result, demuxer->current_title, demuxer->absolute_byte);fflush(stdout);
1574         return result;
1575 }
1576
1577
1578 /* For audio */
1579 int mpeg3demux_read_data(mpeg3_demuxer_t *demuxer,
1580                 unsigned char *output,
1581                 long size)
1582 {
1583         int result = 0;
1584         demuxer->error_flag = 0;
1585
1586 //printf("mpeg3demux_read_data 1 %d\n", demuxer->data_position);
1587         if(demuxer->data_position >= 0)
1588         {
1589 /* Read forwards */
1590                 long i;
1591                 for(i = 0; i < size && !result; )
1592                 {
1593                         int fragment_size = size - i;
1594                         if(fragment_size > demuxer->data_size - demuxer->data_position)
1595                                 fragment_size = demuxer->data_size - demuxer->data_position;
1596                         memcpy(output + i, demuxer->data_buffer + demuxer->data_position, fragment_size);
1597                         demuxer->data_position += fragment_size;
1598                         i += fragment_size;
1599
1600                         if(i < size)
1601                         {
1602                                 result = mpeg3_read_next_packet(demuxer);
1603                         }
1604                 }
1605         }
1606         else
1607         {
1608                 int64_t current_position;
1609 /* Read backwards a full packet. */
1610 /* Only good for reading less than the size of a full packet, but */
1611 /* this routine should only be used for searching for previous markers. */
1612                 current_position = demuxer->data_position;
1613                 result = mpeg3_read_prev_packet(demuxer);
1614                 if(!result) demuxer->data_position = demuxer->data_size + current_position;
1615                 memcpy(output, demuxer->data_buffer + demuxer->data_position, size);
1616                 demuxer->data_position += size;
1617         }
1618
1619 //printf("mpeg3demux_read_data 2\n");
1620         demuxer->error_flag = result;
1621         return result;
1622 }
1623
1624 unsigned char mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer)
1625 {
1626         demuxer->error_flag = 0;
1627
1628         if(demuxer->data_position >= demuxer->data_size)
1629                 demuxer->error_flag = mpeg3_read_next_packet(demuxer);
1630         demuxer->next_char = demuxer->data_buffer[demuxer->data_position++];
1631
1632         return demuxer->next_char;
1633 }
1634
1635 unsigned char mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer)
1636 {
1637         demuxer->error_flag = 0;
1638         demuxer->data_position--;
1639         if(demuxer->data_position < 0)
1640         {
1641                 demuxer->error_flag = mpeg3_read_prev_packet(demuxer);
1642                 if(!demuxer->error_flag) demuxer->data_position = demuxer->data_size - 1;
1643         }
1644         demuxer->next_char = demuxer->data_buffer[demuxer->data_position];
1645         return demuxer->next_char;
1646 }
1647
1648
1649
1650 int mpeg3demux_open_title(mpeg3_demuxer_t *demuxer, int title_number)
1651 {
1652         mpeg3_title_t *title;
1653
1654         if(title_number < demuxer->total_titles)
1655         {
1656                 if(demuxer->current_title >= 0)
1657                 {
1658                         mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
1659                         demuxer->current_title = -1;
1660                 }
1661
1662                 title = demuxer->titles[title_number];
1663
1664                 if(mpeg3io_open_file(title->fs))
1665                 {
1666                         demuxer->error_flag = 1;
1667                         fprintf(stderr, "mpeg3demux_open_title %s: %s", title->fs->path, strerror(errno));
1668                 }
1669                 else
1670                 {
1671                         demuxer->current_title = title_number;
1672                 }
1673         }
1674
1675
1676         return demuxer->error_flag;
1677 }
1678
1679 /* Assign program numbers to interleaved programs */
1680 int mpeg3demux_assign_programs(mpeg3_demuxer_t *demuxer)
1681 {
1682         int current_program = 0;
1683         int current_title = 0;
1684         int title_cell = 0;
1685         double current_time;
1686         mpeg3demux_cell_t *cell;
1687         int total_programs = 1;
1688         int i, j;
1689         int program_exists, last_program_assigned = 0;
1690         int total_cells;
1691         mpeg3_title_t **titles = demuxer->titles;
1692
1693         for(i = 0, total_cells = 0; i < demuxer->total_titles; i++)
1694         {
1695                 total_cells += demuxer->titles[i]->cell_table_size;
1696                 for(j = 0; j < demuxer->titles[i]->cell_table_size; j++)
1697                 {
1698                         cell = &demuxer->titles[i]->cell_table[j];
1699                         if(cell->program > total_programs - 1)
1700                                 total_programs = cell->program + 1;
1701                 }
1702         }
1703
1704
1705
1706         demuxer->current_program = 0;
1707         return 0;
1708 }
1709
1710 int mpeg3demux_copy_titles(mpeg3_demuxer_t *dst, mpeg3_demuxer_t *src)
1711 {
1712         long i;
1713         mpeg3_t *file = dst->file;
1714         mpeg3_title_t *dst_title, *src_title;
1715
1716         dst->total_titles = src->total_titles;
1717         dst->total_programs = src->total_programs;
1718         for(i = 0; i < MPEG3_MAX_STREAMS; i++)
1719         {
1720                 dst->astream_table[i] = src->astream_table[i];
1721                 dst->vstream_table[i] = src->vstream_table[i];
1722         }
1723         for(i = 0; i < src->total_titles; i++)
1724         {
1725                 src_title = src->titles[i];
1726                 dst_title = dst->titles[i] = mpeg3_new_title(file, src->titles[i]->fs->path);
1727                 mpeg3_copy_title(dst_title, src_title);
1728         }
1729
1730         mpeg3demux_open_title(dst, src->current_title);
1731         dst->title_cell = 0;
1732         return 0;
1733 }
1734
1735 /* ==================================================================== */
1736 /*                            Entry points */
1737 /* ==================================================================== */
1738
1739 mpeg3_demuxer_t* mpeg3_new_demuxer(mpeg3_t *file, int do_audio, int do_video, int stream_id)
1740 {
1741         mpeg3_demuxer_t *demuxer = calloc(1, sizeof(mpeg3_demuxer_t));
1742         int i;
1743
1744 /* The demuxer will change the default packet size for its own use. */
1745         demuxer->file = file;
1746         demuxer->do_audio = do_audio;
1747         demuxer->do_video = do_video;
1748
1749 /* Allocate buffer + padding */
1750         demuxer->raw_data = calloc(1, MPEG3_RAW_SIZE);
1751         demuxer->data_buffer = calloc(1, MPEG3_RAW_SIZE);
1752 /* System specific variables */
1753         demuxer->audio_pid = stream_id;
1754         demuxer->video_pid = stream_id;
1755         demuxer->astream = stream_id;
1756         demuxer->vstream = stream_id;
1757         demuxer->current_title = -1;
1758         demuxer->pes_audio_time = -1;
1759         demuxer->pes_video_time = -1;
1760 //printf("mpeg3_new_demuxer %f\n", demuxer->time);
1761
1762
1763         return demuxer;
1764 }
1765
1766 int mpeg3_delete_demuxer(mpeg3_demuxer_t *demuxer)
1767 {
1768         int i;
1769
1770         if(demuxer->current_title >= 0)
1771         {
1772                 mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
1773         }
1774
1775         for(i = 0; i < demuxer->total_titles; i++)
1776         {
1777                 mpeg3_delete_title(demuxer->titles[i]);
1778         }
1779
1780         free(demuxer->data_buffer);
1781         free(demuxer->raw_data);
1782         free(demuxer);
1783         return 0;
1784 }
1785
1786
1787 int mpeg3demux_eof(mpeg3_demuxer_t *demuxer)
1788 {
1789         if(demuxer->current_title >= 0)
1790         {
1791                 if(mpeg3io_eof(demuxer->titles[demuxer->current_title]->fs) &&
1792                         demuxer->current_title >= demuxer->total_titles - 1)
1793                         return 1;
1794         }
1795
1796         return 0;
1797 }
1798
1799 int mpeg3demux_bof(mpeg3_demuxer_t *demuxer)
1800 {
1801         if(demuxer->current_title >= 0)
1802         {
1803                 if(mpeg3io_bof(demuxer->titles[demuxer->current_title]->fs) &&
1804                         demuxer->current_title <= 0)
1805                         return 1;
1806         }
1807         return 0;
1808 }
1809
1810 void mpeg3demux_start_reverse(mpeg3_demuxer_t *demuxer)
1811 {
1812         demuxer->reverse = 1;
1813 }
1814
1815 void mpeg3demux_start_forward(mpeg3_demuxer_t *demuxer)
1816 {
1817         demuxer->reverse = 0;
1818 }
1819
1820 /* Seek to absolute byte */
1821 int mpeg3demux_seek_byte(mpeg3_demuxer_t *demuxer, int64_t byte)
1822 {
1823         mpeg3_t *file = demuxer->file;
1824
1825 /*
1826  * int i;
1827  * for(i = 0; i < demuxer->total_titles; i++) mpeg3_dump_title(demuxer->titles[i]);
1828  */
1829
1830         demuxer->absolute_byte = byte;
1831         demuxer->data_position = 0;
1832         demuxer->data_size = 0;
1833
1834 /* Get on a packet boundary only for transport streams. */
1835         if(file->is_transport_stream &&
1836                 file->packet_size)
1837         {
1838                 demuxer->absolute_byte -= demuxer->absolute_byte % file->packet_size;
1839         }
1840
1841         int result = mpeg3_advance_cell(demuxer);
1842
1843         return result;
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854         int64_t current_position;
1855         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1856
1857         demuxer->data_position = 0;
1858         demuxer->data_size = 0;
1859         demuxer->error_flag = mpeg3io_seek(title->fs, byte);
1860
1861         if(!demuxer->error_flag &&
1862                 file->is_transport_stream &&
1863                 file->packet_size)
1864         {
1865 /* Get on a packet boundary only for transport streams. */
1866                 current_position = mpeg3io_tell(title->fs);
1867                 if(byte % file->packet_size)
1868                 {
1869                         demuxer->error_flag |= mpeg3io_seek(title->fs,
1870                                 current_position -
1871                                 (current_position % file->packet_size));
1872                 }
1873         }
1874
1875         demuxer->absolute_byte = title->start_byte + mpeg3io_tell(title->fs);
1876
1877 // Get current cell
1878         for(demuxer->title_cell = 0;
1879                 demuxer->title_cell < title->cell_table_size;
1880                 demuxer->title_cell++)
1881         {
1882                 if(title->cell_table[demuxer->title_cell].start_byte <= byte &&
1883                         title->cell_table[demuxer->title_cell].end_byte > byte)
1884                 {
1885                         break;
1886                 }
1887         }
1888
1889         if(demuxer->title_cell >= title->cell_table_size)
1890                 demuxer->title_cell = title->cell_table_size - 1;
1891
1892
1893         return demuxer->error_flag;
1894 }
1895
1896
1897
1898
1899
1900
1901
1902
1903 double mpeg3demux_get_time(mpeg3_demuxer_t *demuxer)
1904 {
1905         return demuxer->time;
1906 }
1907
1908 double mpeg3demux_audio_pts(mpeg3_demuxer_t *demuxer)
1909 {
1910         return demuxer->pes_audio_time;
1911 }
1912
1913 double mpeg3demux_video_pts(mpeg3_demuxer_t *demuxer)
1914 {
1915         return demuxer->pes_video_time;
1916 }
1917
1918 void mpeg3demux_reset_pts(mpeg3_demuxer_t *demuxer)
1919 {
1920         demuxer->pes_audio_time = -1;
1921         demuxer->pes_video_time = -1;
1922 }
1923
1924 double mpeg3demux_scan_pts(mpeg3_demuxer_t *demuxer)
1925 {
1926         int64_t start_position = mpeg3demux_tell_byte(demuxer);
1927         int64_t end_position = start_position + MPEG3_PTS_RANGE;
1928         int64_t current_position = start_position;
1929         int result = 0;
1930
1931         mpeg3demux_reset_pts(demuxer);
1932         while(!result &&
1933                 current_position < end_position &&
1934                 ((demuxer->do_audio && demuxer->pes_audio_time < 0) ||
1935                 (demuxer->do_video && demuxer->pes_video_time < 0)))
1936         {
1937                 result = mpeg3_read_next_packet(demuxer);
1938                 current_position = mpeg3demux_tell_byte(demuxer);
1939         }
1940
1941 // Seek back to starting point
1942         mpeg3demux_seek_byte(demuxer, start_position);
1943
1944         if(demuxer->do_audio) return demuxer->pes_audio_time;
1945         if(demuxer->do_video) return demuxer->pes_video_time;
1946 }
1947
1948 int mpeg3demux_goto_pts(mpeg3_demuxer_t *demuxer, double pts)
1949 {
1950         int64_t start_position = mpeg3demux_tell_byte(demuxer);
1951         int64_t end_position = start_position + MPEG3_PTS_RANGE;
1952         int64_t current_position = start_position;
1953         int result = 0;
1954
1955 // Search forward for nearest pts
1956         mpeg3demux_reset_pts(demuxer);
1957         while(!result && current_position < end_position)
1958         {
1959                 result = mpeg3_read_next_packet(demuxer);
1960                 if(demuxer->pes_audio_time > pts) break;
1961                 current_position = mpeg3demux_tell_byte(demuxer);
1962         }
1963
1964 // Search backward for nearest pts
1965         end_position = current_position - MPEG3_PTS_RANGE;
1966         mpeg3_read_prev_packet(demuxer);
1967         while(!result &&
1968                 current_position > end_position)
1969         {
1970                 result = mpeg3_read_prev_packet(demuxer);
1971                 if(demuxer->pes_audio_time < pts) break;
1972                 current_position = mpeg3demux_tell_byte(demuxer);
1973         }
1974 }
1975
1976
1977 int64_t mpeg3demux_tell_byte(mpeg3_demuxer_t *demuxer)
1978 {
1979         return demuxer->absolute_byte;
1980
1981
1982
1983         int i;
1984         int64_t result = 0;
1985         for(i = 0; i < demuxer->current_title; i++)
1986         {
1987                 result += demuxer->titles[i]->total_bytes;
1988         }
1989         result += mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs);
1990         return result;
1991 }
1992
1993
1994 int64_t mpeg3demux_movie_size(mpeg3_demuxer_t *demuxer)
1995 {
1996         int64_t result = 0;
1997         int i;
1998         for(i = 0; i < demuxer->total_titles; i++)
1999                 result += demuxer->titles[i]->total_bytes;
2000         return result;
2001 }
2002
2003 int64_t mpeg3demuxer_title_bytes(mpeg3_demuxer_t *demuxer)
2004 {
2005         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
2006         return title->total_bytes;
2007 }
2008
2009 mpeg3_demuxer_t* mpeg3_get_demuxer(mpeg3_t *file)
2010 {
2011         if(file->is_program_stream || file->is_transport_stream)
2012         {
2013                 if(file->total_astreams) return file->atrack[0]->demuxer;
2014                 else
2015                 if(file->total_vstreams) return file->vtrack[0]->demuxer;
2016         }
2017         return 0;
2018 }