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         a = demuxer->raw_data[demuxer->raw_offset++];
  67         b = demuxer->raw_data[demuxer->raw_offset++];
  68         c = demuxer->raw_data[demuxer->raw_offset++];
  69         d = demuxer->raw_data[demuxer->raw_offset++];
  70         result = (a << 24) | (b << 16) | (c << 8) | d;
  71
  72         return result;
  73 }
  74
  75 static inline unsigned int packet_skip(mpeg3_demuxer_t *demuxer, int length)
  76 {
  77         demuxer->raw_offset += length;
  78         return 0;
  79 }
  80
  81 static int get_adaptation_field(mpeg3_demuxer_t *demuxer)
  82 {
  83         int length;
  84         int pcr_flag;
  85
  86 //printf("get_adaptation_field %d\n", demuxer->adaptation_field_control);
  87         demuxer->adaptation_fields++;
  88 /* get adaptation field length */
  89         length = packet_read_char(demuxer);
  90
  91         if(length > 0)
  92         {
  93 /* get first byte */
  94                 pcr_flag = (packet_read_char(demuxer) >> 4) & 1;
  95
  96                 if(pcr_flag)
  97                 {
  98                 unsigned int clk_ref_base = packet_read_int32(demuxer);
  99                 unsigned int clk_ref_ext = packet_read_int16(demuxer);
 100
 101                         if (clk_ref_base > 0x7fffffff)
 102                         {
 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 /* Create space for bit */
 110                                 clk_ref_base <<= 1;
 111                                 clk_ref_base |= (clk_ref_ext >> 15);          /* Take bit */
 112                                 clk_ref_ext &= 0x01ff;                        /* Only lower 9 bits */
 113                         }
 114                         demuxer->time = ((double)clk_ref_base + clk_ref_ext / 300) / 90000;
 115                 if(length) packet_skip(demuxer, length - 7);
 116
 117                         if(demuxer->dump)
 118                         {
 119                                 printf(" pcr_flag=%x time=%f\n", pcr_flag, demuxer->time);
 120                         }
 121                 }
 122                 else
 123                         packet_skip(demuxer, length - 1);
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int get_program_association_table(mpeg3_demuxer_t *demuxer)
 130 {
 131         demuxer->program_association_tables++;
 132         demuxer->table_id = packet_read_char(demuxer);
 133         demuxer->section_length = packet_read_int16(demuxer) & 0xfff;
 134         demuxer->transport_stream_id = packet_read_int16(demuxer);
 135         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 136         if(demuxer->dump)
 137         {
 138                 printf(" table_id=0x%x section_length=%d transport_stream_id=0x%x\n",
 139                         demuxer->table_id,
 140                         demuxer->section_length,
 141                         demuxer->transport_stream_id);
 142         }
 143         return 0;
 144 }
 145
 146 static int get_transport_payload(mpeg3_demuxer_t *demuxer,
 147         int is_audio,
 148         int is_video)
 149 {
 150         int bytes = demuxer->raw_size - demuxer->raw_offset;
 151
 152         if(bytes < 0)
 153         {
 154                 fprintf(stderr, "get_transport_payload: got negative payload size!\n");
 155                 return 1;
 156         }
 157 /*
 158  *      if(demuxer->data_size + bytes > MPEG3_RAW_SIZE)
 159  *              bytes = MPEG3_RAW_SIZE - demuxer->data_size;
 160  */
 161 //printf("get_transport_payload 2 %d %d %d\n", bytes, demuxer->read_all, is_audio);
 162
 163         if(demuxer->read_all && is_audio)
 164         {
 165 /*
 166  * if(demuxer->pid == 0x1100)
 167  * printf("get_transport_payload 1 0x%x %d\n", demuxer->audio_pid, bytes);
 168  */
 169                 memcpy(demuxer->audio_buffer + demuxer->audio_size,
 170                         demuxer->raw_data + demuxer->raw_offset,
 171                         bytes);
 172                 demuxer->audio_size += bytes;
 173         }
 174         else
 175         if(demuxer->read_all && is_video)
 176         {
 177 //printf("get_transport_payload 2\n");
 178                 memcpy(demuxer->video_buffer + demuxer->video_size,
 179                         demuxer->raw_data + demuxer->raw_offset,
 180                         bytes);
 181                 demuxer->video_size += bytes;
 182         }
 183         else
 184         {
 185                 memcpy(demuxer->data_buffer + demuxer->data_size,
 186                         demuxer->raw_data + demuxer->raw_offset,
 187                         bytes);
 188                 demuxer->data_size += bytes;
 189 /*
 190  * printf("get_transport_payload 10 pid=0x%x bytes=0x%x data_size=0x%x\n",
 191  * demuxer->pid,
 192  * bytes,
 193  * demuxer->data_size);
 194  */
 195         }
 196
 197         demuxer->raw_offset += bytes;
 198         return 0;
 199 }
 200
 201 static int get_pes_packet_header(mpeg3_demuxer_t *demuxer,
 202         unsigned int *pts,
 203         unsigned int *dts)
 204 {
 205         unsigned int pes_header_bytes = 0;
 206         unsigned int pts_dts_flags;
 207         int pes_header_data_length;
 208
 209 /* drop first 8 bits */
 210         packet_read_char(demuxer);
 211         pts_dts_flags = (packet_read_char(demuxer) >> 6) & 0x3;
 212         pes_header_data_length = packet_read_char(demuxer);
 213
 214
 215 /* Get Presentation Time stamps and Decoding Time Stamps */
 216         if(pts_dts_flags == 2)
 217         {
 218                 *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 219                 *pts <<= 15;
 220                 *pts |= (packet_read_int16(demuxer) >> 1);
 221                 *pts <<= 15;
 222                 *pts |= (packet_read_int16(demuxer) >> 1);
 223                 pes_header_bytes += 5;
 224         }
 225         else
 226         if(pts_dts_flags == 3)
 227         {
 228                 *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 229                 *pts <<= 15;
 230                 *pts |= (packet_read_int16(demuxer) >> 1);
 231                 *pts <<= 15;
 232                 *pts |= (packet_read_int16(demuxer) >> 1);
 233                 *dts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
 234                 *dts <<= 15;
 235                 *dts |= (packet_read_int16(demuxer) >> 1);
 236                 *dts <<= 15;
 237                 *dts |= (packet_read_int16(demuxer) >> 1);
 238                 pes_header_bytes += 10;
 239         }
 240
 241         demuxer->time = (double)*pts / 90000;
 242
 243         if(demuxer->dump)
 244         {
 245                 printf(" pts_dts_flags=0x%02x pts=%f dts=%f\n",
 246                         pts_dts_flags,
 247                         (double)*pts / 90000,
 248                         (double)*dts / 90000);
 249         }
 250
 251
 252 /* extract other stuff here! */
 253         packet_skip(demuxer, pes_header_data_length - pes_header_bytes);
 254         return 0;
 255 }
 256
 257 static int get_unknown_data(mpeg3_demuxer_t *demuxer)
 258 {
 259         int bytes = demuxer->raw_size - demuxer->raw_offset;
 260         memcpy(demuxer->data_buffer + demuxer->data_size,
 261                         demuxer->raw_data + demuxer->raw_offset,
 262                         bytes);
 263         demuxer->data_size += bytes;
 264         demuxer->raw_offset += bytes;
 265         return 0;
 266 }
 267
 268
 269
 270 static int get_transport_pes_packet(mpeg3_demuxer_t *demuxer)
 271 {
 272         unsigned int pts = 0, dts = 0;
 273         get_pes_packet_header(demuxer, &pts, &dts);
 274
 275
 276         if(demuxer->stream_id == 0xbd ||
 277 // Blu-Ray
 278                 demuxer->stream_id == 0xfd)
 279         {
 280 //printf("get_transport_pes_packet %x\n", demuxer->pid);
 281 // AC3 audio
 282                 demuxer->stream_id = 0x0;
 283                 demuxer->got_audio = 1;
 284                 demuxer->custom_id = demuxer->pid;
 285
 286                 if(demuxer->read_all)
 287                         demuxer->astream_table[demuxer->custom_id] = AUDIO_AC3;
 288                 if(demuxer->astream == -1)
 289                     demuxer->astream = demuxer->custom_id;
 290
 291                 if(demuxer->dump)
 292                 {
 293                         printf("get_transport_pes_packet: offset=%llx 0x%x bytes AC3 custom_id=0x%x astream=0x%x do_audio=%d\n",
 294                                 mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs),
 295                                 demuxer->raw_size - demuxer->raw_offset,
 296                                 demuxer->custom_id,
 297                                 demuxer->astream,
 298                                 demuxer->do_audio);
 299                 }
 300
 301         if((demuxer->custom_id == demuxer->astream &&
 302                         demuxer->do_audio) ||
 303                         demuxer->read_all)
 304                 {
 305                         demuxer->pes_audio_time = (double)pts / 90000;
 306                         demuxer->audio_pid = demuxer->pid;
 307                         return get_transport_payload(demuxer, 1, 0);
 308         }
 309
 310         }
 311         else
 312         if((demuxer->stream_id >> 4) == 12 || (demuxer->stream_id >> 4) == 13)
 313         {
 314 // MPEG audio
 315                 demuxer->custom_id = demuxer->pid;
 316                 demuxer->got_audio = 1;
 317
 318 /* Just pick the first available stream if no ID is set */
 319                 if(demuxer->read_all)
 320                         demuxer->astream_table[demuxer->custom_id] = AUDIO_MPEG;
 321                 if(demuxer->astream == -1)
 322                     demuxer->astream = demuxer->custom_id;
 323
 324                 if(demuxer->dump)
 325                 {
 326                         printf(" 0x%x bytes MP2 audio\n", demuxer->raw_size - demuxer->raw_offset);
 327                 }
 328
 329         if((demuxer->custom_id == demuxer->astream &&
 330                         demuxer->do_audio) ||
 331                         demuxer->read_all)
 332                 {
 333                         demuxer->pes_audio_time = (double)pts / 90000;
 334                         demuxer->audio_pid = demuxer->pid;
 335
 336                         return get_transport_payload(demuxer, 1, 0);
 337         }
 338         }
 339         else
 340         if((demuxer->stream_id >> 4) == 14)
 341         {
 342 // Video
 343                 demuxer->custom_id = demuxer->pid;
 344                 demuxer->got_video = 1;
 345
 346
 347 /* Just pick the first available stream if no ID is set */
 348                 if(demuxer->read_all)
 349                         demuxer->vstream_table[demuxer->custom_id] = 1;
 350                 else
 351                 if(demuxer->vstream == -1)
 352                         demuxer->vstream = demuxer->custom_id;
 353
 354
 355                 if(demuxer->dump)
 356                 {
 357                         printf(" 0x%x bytes video data\n", demuxer->raw_size - demuxer->raw_offset);
 358                 }
 359
 360                 if((demuxer->custom_id == demuxer->vstream &&
 361                         demuxer->do_video) ||
 362                         demuxer->read_all)
 363                 {
 364                         demuxer->pes_video_time = (double)pts / 90000;
 365                         demuxer->video_pid = demuxer->pid;
 366
 367
 368                         return get_transport_payload(demuxer, 0, 1);
 369                 }
 370         }
 371
 372         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 373
 374         return 0;
 375 }
 376
 377 static int get_pes_packet(mpeg3_demuxer_t *demuxer)
 378 {
 379         demuxer->pes_packets++;
 380
 381
 382
 383 /* Skip startcode */
 384         packet_read_int24(demuxer);
 385         demuxer->stream_id = packet_read_char(demuxer);
 386
 387
 388         if(demuxer->dump)
 389         {
 390                 printf(" stream_id=0x%02x\n", demuxer->stream_id);
 391         }
 392
 393 /* Skip pes packet length */
 394         packet_read_int16(demuxer);
 395
 396         if(demuxer->stream_id != MPEG3_PRIVATE_STREAM_2 &&
 397                 demuxer->stream_id != MPEG3_PADDING_STREAM)
 398         {
 399                 return get_transport_pes_packet(demuxer);
 400         }
 401         else
 402         if(demuxer->stream_id == MPEG3_PRIVATE_STREAM_2)
 403         {
 404                 packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 405                 return 0;
 406         }
 407         else
 408         if(demuxer->stream_id == MPEG3_PADDING_STREAM)
 409         {
 410                 packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 411                 return 0;
 412         }
 413         else
 414         {
 415         fprintf(stderr, "unknown stream_id in pes packet");
 416                 return 1;
 417         }
 418         return 0;
 419 }
 420
 421 static int get_payload(mpeg3_demuxer_t *demuxer)
 422 {
 423 //printf("get_payload 1 pid=0x%x unit_start=%d\n", demuxer->pid, demuxer->payload_unit_start_indicator);
 424         if(demuxer->payload_unit_start_indicator)
 425         {
 426         if(demuxer->pid == 0)
 427                         get_program_association_table(demuxer);
 428         else
 429                 if(packet_next_int24(demuxer) == MPEG3_PACKET_START_CODE_PREFIX)
 430                         get_pes_packet(demuxer);
 431         else
 432                         packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 433         }
 434         else
 435         {
 436                 if(demuxer->dump)
 437                 {
 438                         printf(" 0x%x bytes elementary data\n", demuxer->raw_size - demuxer->raw_offset);
 439                 }
 440
 441 /*
 442  * if(demuxer->pid == 0x1100) printf("get_payload 1 0x%x\n", demuxer->audio_pid);
 443  */
 444         if(demuxer->pid == demuxer->audio_pid &&
 445                         (demuxer->do_audio ||
 446                         demuxer->read_all))
 447                 {
 448                         if(demuxer->do_audio) demuxer->got_audio = 1;
 449
 450                         if(demuxer->dump)
 451                         {
 452                                 printf("get_payload: offset=%llx 0x%x bytes AC3 pid=0x%x\n",
 453                                         mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs),
 454                                         demuxer->raw_size - demuxer->raw_offset,
 455                                         demuxer->pid);
 456                         }
 457
 458                         get_transport_payload(demuxer, 1, 0);
 459                 }
 460         else
 461                 if(demuxer->pid == demuxer->video_pid &&
 462                         (demuxer->do_video ||
 463                         demuxer->read_all))
 464                 {
 465                         if(demuxer->do_video) demuxer->got_video = 1;
 466                         get_transport_payload(demuxer, 0, 1);
 467                 }
 468         else
 469                 if(demuxer->read_all)
 470                 {
 471                         get_transport_payload(demuxer, 0, 0);
 472 //                      packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
 473                 }
 474         }
 475         return 0;
 476 }
 477
 478 /* Read a transport packet */
 479 static int read_transport(mpeg3_demuxer_t *demuxer)
 480 {
 481 demuxer->dump = 0;
 482         mpeg3_t *file = (mpeg3_t*)demuxer->file;
 483         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 484         int result = 0;
 485         unsigned int bits;
 486         int table_entry;
 487
 488 /* Packet size is known for transport streams */
 489         demuxer->raw_size = file->packet_size;
 490         demuxer->raw_offset = 0;
 491         demuxer->stream_id = 0;
 492         demuxer->got_audio = 0;
 493         demuxer->got_video = 0;
 494         demuxer->custom_id = -1;
 495
 496
 497         if(result)
 498         {
 499                 perror("read_transport");
 500                 return 1;
 501         }
 502
 503 //fprintf(stderr, "read transport 1 %llx %llx\n", title->fs->current_byte, title->fs->total_bytes);
 504
 505 // Skip BD header
 506         if(file->is_bd)
 507                 mpeg3io_read_int32(title->fs);
 508
 509 // Search for Sync byte */
 510         do
 511         {
 512                 bits = mpeg3io_read_char(title->fs);
 513         }while(!mpeg3io_eof(title->fs) && !result && bits != MPEG3_SYNC_BYTE);
 514
 515 /* Hit EOF */
 516         if(mpeg3io_eof(title->fs) || result) return 1;
 517
 518         if(bits == MPEG3_SYNC_BYTE && !result)
 519         {
 520 // Store byte just read as first byte
 521                 demuxer->raw_data[0] = MPEG3_SYNC_BYTE;
 522
 523 // Read packet
 524                 int fragment_size = file->packet_size - 1;
 525 // Skip BD header
 526                 if(file->is_bd)
 527                 {
 528                         fragment_size -= 4;
 529                         demuxer->raw_size -= 4;
 530                 }
 531                 result = mpeg3io_read_data(demuxer->raw_data + 1,
 532                         fragment_size,
 533                         title->fs);
 534         }
 535         else
 536         {
 537 // Failed
 538                 demuxer->program_byte = mpeg3io_tell(title->fs) +
 539                         title->start_byte;
 540                 return 1;
 541         }
 542
 543
 544 // Sync byte
 545         packet_read_char(demuxer);
 546     bits =  packet_read_int24(demuxer) & 0x00ffffff;
 547     demuxer->transport_error_indicator = (bits >> 23) & 0x1;
 548     demuxer->payload_unit_start_indicator = (bits >> 22) & 0x1;
 549     demuxer->pid = demuxer->custom_id = (bits >> 8) & 0x00001fff;
 550
 551     demuxer->transport_scrambling_control = (bits >> 6) & 0x3;
 552     demuxer->adaptation_field_control = (bits >> 4) & 0x3;
 553     demuxer->continuity_counter = bits & 0xf;
 554
 555
 556 // This caused an audio track to not be created.
 557         if(demuxer->transport_error_indicator)
 558         {
 559 //              fprintf(stderr, "demuxer->transport_error_indicator at %llx\n",
 560 //                      mpeg3io_tell(title->fs));
 561                 demuxer->program_byte = mpeg3io_tell(title->fs) +
 562                         title->start_byte;
 563                 return 0;
 564         }
 565
 566     if (demuxer->pid == 0x1fff)
 567         {
 568                 demuxer->is_padding = 1;  /* padding; just go to next */
 569     }
 570         else
 571         {
 572                 demuxer->is_padding = 0;
 573         }
 574
 575 /* Get pid from table */
 576         for(table_entry = 0, result = 0;
 577                 table_entry < demuxer->total_pids;
 578                 table_entry++)
 579         {
 580                 if(demuxer->pid == demuxer->pid_table[table_entry])
 581                 {
 582                         result = 1;
 583                         break;
 584                 }
 585         }
 586
 587
 588
 589
 590 /* Not in pid table */
 591         if(!result && demuxer->total_pids < MPEG3_PIDMAX)
 592         {
 593                 demuxer->pid_table[table_entry] = demuxer->pid;
 594                 demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;  /* init */
 595                 demuxer->total_pids++;
 596         }
 597         result = 0;
 598
 599         if(demuxer->dump)
 600         {
 601                 printf("offset=0x%llx pid=0x%02x continuity=0x%02x padding=%d adaptation=%d unit_start=%d\n",
 602                         demuxer->program_byte,
 603                         demuxer->pid,
 604                         demuxer->continuity_counter,
 605                         demuxer->is_padding,
 606                         demuxer->adaptation_field_control,
 607                         demuxer->payload_unit_start_indicator);
 608         }
 609
 610
 611 /* Abort if padding.  Should abort after demuxer->pid == 0x1fff for speed. */
 612         if(demuxer->is_padding)
 613         {
 614                 demuxer->program_byte = mpeg3io_tell(title->fs) +
 615                         title->start_byte;
 616                 return 0;
 617         }
 618
 619
 620
 621
 622     if(demuxer->adaptation_field_control & 0x2)
 623         result = get_adaptation_field(demuxer);
 624
 625 // Need to enter in astream and vstream table:
 626 // PID ored with stream_id
 627     if(demuxer->adaptation_field_control & 0x1)
 628         result = get_payload(demuxer);
 629
 630         demuxer->program_byte = mpeg3io_tell(title->fs) +
 631                 title->start_byte;
 632         return result;
 633 }
 634
 635 static int get_system_header(mpeg3_demuxer_t *demuxer)
 636 {
 637         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 638         int length = mpeg3io_read_int16(title->fs);
 639         mpeg3io_seek_relative(title->fs, length);
 640         return 0;
 641 }
 642
 643 static unsigned int get_timestamp(mpeg3_demuxer_t *demuxer)
 644 {
 645         unsigned int timestamp;
 646         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 647
 648 /* Only low 4 bits (7==1111) */
 649         timestamp = (mpeg3io_read_char(title->fs) >> 1) & 7;
 650         timestamp <<= 15;
 651         timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
 652         timestamp <<= 15;
 653         timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
 654         return timestamp;
 655 }
 656
 657 static int get_pack_header(mpeg3_demuxer_t *demuxer)
 658 {
 659         unsigned int i, j;
 660         unsigned int clock_ref, clock_ref_ext;
 661         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 662
 663 /* Get the time code */
 664         if((mpeg3io_next_char(title->fs) >> 4) == 2)
 665         {
 666 /* MPEG-1 */
 667                         demuxer->time = (double)get_timestamp(demuxer) / 90000;
 668 /* Skip 3 bytes */
 669                         mpeg3io_read_int24(title->fs);
 670         }
 671         else
 672         if(mpeg3io_next_char(title->fs) & 0x40)
 673         {
 674                 i = mpeg3io_read_int32(title->fs);
 675                 j = mpeg3io_read_int16(title->fs);
 676
 677                 if(i & 0x40000000 || (i >> 28) == 2)
 678                 {
 679                 clock_ref = ((i & 0x38000000) << 3);
 680                 clock_ref |= ((i & 0x03fff800) << 4);
 681                 clock_ref |= ((i & 0x000003ff) << 5);
 682                 clock_ref |= ((j & 0xf800) >> 11);
 683                 clock_ref_ext = (j >> 1) & 0x1ff;
 684
 685                         demuxer->time = (double)(clock_ref + clock_ref_ext / 300) / 90000;
 686 /* Skip 3 bytes */
 687                         mpeg3io_read_int24(title->fs);
 688                         i = mpeg3io_read_char(title->fs) & 0x7;
 689
 690 /* stuffing */
 691                         mpeg3io_seek_relative(title->fs, i);
 692                 }
 693         }
 694         else
 695         {
 696                 mpeg3io_seek_relative(title->fs, 2);
 697         }
 698         return 0;
 699 }
 700
 701
 702
 703 static int get_program_payload(mpeg3_demuxer_t *demuxer,
 704         int bytes,
 705         int is_audio,
 706         int is_video)
 707 {
 708         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 709
 710         if(demuxer->read_all && is_audio)
 711         {
 712                 mpeg3io_read_data(demuxer->audio_buffer + demuxer->audio_size,
 713                         bytes,
 714                         title->fs);
 715                 demuxer->audio_size += bytes;
 716         }
 717         else
 718         if(demuxer->read_all && is_video)
 719         {
 720                 mpeg3io_read_data(demuxer->video_buffer + demuxer->video_size,
 721                         bytes,
 722                         title->fs);
 723                 demuxer->video_size += bytes;
 724         }
 725         else
 726         {
 727                 mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size,
 728                         bytes,
 729                         title->fs);
 730                 demuxer->data_size += bytes;
 731         }
 732
 733
 734         return 0;
 735 }
 736
 737
 738
 739
 740
 741
 742 static int handle_scrambling(mpeg3_demuxer_t *demuxer,
 743         int decryption_offset)
 744 {
 745         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 746
 747 // Advance 2048 bytes if scrambled.  We might pick up a spurrius
 748 // packet start code in the scrambled data otherwise.
 749         if(demuxer->last_packet_start + 0x800 > mpeg3io_tell(title->fs))
 750         {
 751                 mpeg3io_seek_relative(title->fs,
 752                         demuxer->last_packet_start + 0x800 - mpeg3io_tell(title->fs));
 753         }
 754
 755
 756
 757 // Descramble if desired.
 758         if(demuxer->data_size ||
 759                 demuxer->audio_size ||
 760                 demuxer->video_size)
 761         {
 762                 unsigned char *buffer_ptr = 0;
 763                 if(demuxer->data_size) buffer_ptr = demuxer->data_buffer;
 764                 else
 765                 if(demuxer->audio_size) buffer_ptr = demuxer->audio_buffer;
 766                 else
 767                 if(demuxer->video_size) buffer_ptr = demuxer->video_buffer;
 768
 769
 770 //printf(__FUNCTION__ " data_size=%x decryption_offset=%x\n", demuxer->data_size, decryption_offset);
 771                 if(mpeg3_decrypt_packet(title->fs->css,
 772                         buffer_ptr,
 773                         decryption_offset))
 774                 {
 775                         fprintf(stderr, "handle_scrambling: Decryption not available\n");
 776                         return 1;
 777                 }
 778         }
 779
 780         return 0;
 781 }
 782
 783 static void remove_subtitle(mpeg3_demuxer_t *demuxer, int number)
 784 {
 785         int i, j;
 786         mpeg3_delete_subtitle(demuxer->subtitles[number]);
 787         for(j = number; j < demuxer->total_subtitles - 1; j++)
 788         {
 789                 demuxer->subtitles[j] = demuxer->subtitles[j + 1];
 790         }
 791         demuxer->total_subtitles--;
 792 }
 793
 794 static void remove_subtitle_ptr(mpeg3_demuxer_t *demuxer, mpeg3_subtitle_t *ptr)
 795 {
 796         int i, number = demuxer->total_subtitles;
 797         for(i = 0; i < demuxer->total_subtitles; i++)
 798         {
 799                 if(demuxer->subtitles[i] == ptr)
 800                 {
 801                         number = i;
 802                         break;
 803                 }
 804         }
 805
 806         for(i = number; i < demuxer->total_subtitles - 1; i++)
 807         {
 808                 demuxer->subtitles[i] = demuxer->subtitles[i + 1];
 809         }
 810         demuxer->total_subtitles--;
 811 }
 812
 813 /* Create new subtitle object if none with the same id is in the table */
 814 static mpeg3_subtitle_t* new_subtitle(mpeg3_demuxer_t *demuxer,
 815         int id,
 816         int64_t offset)
 817 {
 818         mpeg3_subtitle_t *subtitle = 0;
 819         int i, j;
 820
 821 /* Get subtitle object for the stream and total subtitle objects for the stream */
 822         int total = 0;
 823         int got_it = 0;
 824         for(i = 0; i < demuxer->total_subtitles; i++)
 825         {
 826                 if(demuxer->subtitles[i]->id == id) total++;
 827
 828                 if(demuxer->subtitles[i]->id == id &&
 829                         !demuxer->subtitles[i]->done &&
 830                         !got_it)
 831                 {
 832                         subtitle = demuxer->subtitles[i];
 833                         got_it = 1;
 834                 }
 835         }
 836
 837 /* Make new subtitle object */
 838         if(!subtitle)
 839         {
 840                 demuxer->total_subtitles++;
 841                 demuxer->subtitles = realloc(demuxer->subtitles,
 842                         sizeof(mpeg3_subtitle_t*) * demuxer->total_subtitles);
 843                 subtitle = demuxer->subtitles[demuxer->total_subtitles - 1] =
 844                         calloc(sizeof(mpeg3_subtitle_t), 1);
 845                 subtitle->id = id;
 846                 subtitle->offset = offset;
 847         }
 848
 849 /* Delete oldest subtitle */
 850         if(total > MPEG3_MAX_SUBTITLES)
 851         {
 852                 for(i = 0; i < demuxer->total_subtitles - 1; i++)
 853                 {
 854                         if(demuxer->subtitles[i]->id == id)
 855                         {
 856                                 remove_subtitle(demuxer, i);
 857                                 break;
 858                         }
 859                 }
 860         }
 861
 862         return subtitle;
 863 }
 864
 865
 866 static void handle_subtitle(mpeg3_t *file,
 867         mpeg3_demuxer_t *demuxer,
 868         mpeg3_subtitle_t *subtitle,
 869         int bytes)
 870 {
 871         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
 872         int i;
 873
 874 /* Allocate memory */
 875         if(!subtitle->data)
 876         {
 877                 subtitle->data = malloc(bytes);
 878         }
 879         else
 880         {
 881                 subtitle->data = realloc(subtitle->data,
 882                         subtitle->size + bytes);
 883         }
 884
 885 /* Add data to latest subtitle packet. */
 886         mpeg3io_read_data(subtitle->data + subtitle->size,
 887                 bytes,
 888                 title->fs);
 889
 890 /*
 891  * static FILE *test = 0;
 892  * if(!test) test = fopen("/tmp/debug", "w");
 893  * if(stream_id == 0x20) fwrite(subtitle->data + subtitle->size, pes_packet_length, 1, test);
 894  * fflush(test);
 895  */
 896         subtitle->size += bytes;
 897
 898 /* Assume complete subtitle object has been loaded and align it in the buffer */
 899         for(i = 0; i < subtitle->size - 1; i++)
 900         {
 901 /* Assume next two bytes are size of the subtitle */
 902                 unsigned char *ptr = subtitle->data + i;
 903                 int packet_size = (ptr[0] << 8) | (ptr[1]);
 904
 905 /* i is the first byte of a subtitle packet and the packet is complete */
 906                 if(i + packet_size <= subtitle->size &&
 907                         *(ptr + packet_size - 1) == 0xff)
 908                 {
 909
 910
 911 /* Move trailing data to a new object */
 912 /* This just crashed and we don't think it's supposed to happen. */
 913 /*
 914  *                      if(i + packet_size < subtitle->size)
 915  *                      {
 916  *                              mpeg3_subtitle_t *subtitle2 = new_subtitle(demuxer,
 917  *                                      subtitle->id,
 918  *                                      demuxer->program_byte);
 919  *                              subtitle2->size = subtitle->size - i - packet_size;
 920  *                              subtitle2->data = malloc(subtitle2->size);
 921  *                              memcpy(subtitle2->data, subtitle->data + i + packet_size, subtitle2->size);
 922  * printf("mpeg3demux handle_subtitle: 2 subtitles in packet subtitle2->size=%d\n", subtitle2->size);
 923  *                      }
 924  */
 925
 926 /* Move packet to subtitle track */
 927                         memcpy(subtitle->data, subtitle->data + i, packet_size);
 928                         subtitle->size = packet_size;
 929                         subtitle->done = 1;
 930
 931                         remove_subtitle_ptr(demuxer, subtitle);
 932                         mpeg3_strack_t *strack = mpeg3_create_strack(file, subtitle->id);
 933                         mpeg3_append_subtitle(strack, subtitle);
 934                         demuxer->got_subtitle = 1;
 935 /*
 936  * printf("handle_subtitle: id=0x%x pid=%x size=%d offset=0x%llx table_size=%d\n",
 937  * subtitle->id,
 938  * demuxer->pid,
 939  * subtitle->size,
 940  * subtitle->offset,
 941  * demuxer->total_subtitles);
 942  */
 943                         break;
 944                 }
 945         }
 946 }
 947
 948
 949
 950 static int handle_pcm(mpeg3_demuxer_t *demuxer, int bytes)
 951 {
 952 /* Synthesize PCM header and delete MPEG header for PCM data */
 953 /* Must be done after decryption */
 954         unsigned char code;
 955         int bits_code;
 956         int bits;
 957         int samplerate_code;
 958         int samplerate;
 959         unsigned char *output = 0;
 960         unsigned char *data_buffer = 0;
 961         int data_start = 0;
 962         int *data_size = 0;
 963         int i, j;
 964
 965
 966
 967
 968         if(demuxer->read_all && demuxer->audio_size)
 969         {
 970                 output = demuxer->audio_buffer + demuxer->audio_start;
 971                 data_buffer = demuxer->audio_buffer;
 972                 data_start = demuxer->audio_start;
 973                 data_size = &demuxer->audio_size;
 974         }
 975         else
 976         {
 977                 output = demuxer->data_buffer + demuxer->data_start;
 978                 data_buffer = demuxer->data_buffer;
 979                 data_start = demuxer->data_start;
 980                 data_size = &demuxer->data_size;
 981         }
 982
 983
 984
 985
 986 /* Shift audio back */
 987         code = output[1];
 988         for(i = *data_size - 1, j = *data_size + PCM_HEADERSIZE - 3 - 1;
 989                 i >= data_start;
 990                 i--, j--)
 991                 *(data_buffer + j) = *(data_buffer + i);
 992         *data_size += PCM_HEADERSIZE - 3;
 993
 994         bits_code = (code >> 6) & 3;
 995         samplerate_code = (code & 0x10);
 996
 997
 998         output[0] = 0x7f;
 999         output[1] = 0x7f;
1000         output[2] = 0x80;
1001         output[3] = 0x7f;
1002 /* Samplerate */
1003         switch(samplerate_code)
1004         {
1005                 case 1:
1006                         samplerate = 96000;
1007                         break;
1008                 default:
1009                         samplerate = 48000;
1010                         break;
1011         }
1012
1013         *(int32_t*)(output + 4) = samplerate;
1014 /* Bits */
1015         switch(bits_code)
1016         {
1017                 case 0: bits = 16; break;
1018                 case 1: bits = 20; break;
1019                 case 2: bits = 24; break;
1020                 default: bits = 16; break;
1021         }
1022         *(int32_t*)(output + 8) = bits;
1023 /* Channels */
1024         *(int32_t*)(output + 12) = (code & 0x7) + 1;
1025 /* Framesize */
1026         *(int32_t*)(output + 16) = bytes -
1027                 3 +
1028                 PCM_HEADERSIZE;
1029
1030
1031
1032
1033 //printf(__FUNCTION__ " %02x%02x%02x %d\n", code1, code, code2, pes_packet_length - 3);
1034 }
1035
1036
1037
1038
1039
1040
1041 /* Program packet reading core */
1042 static int get_program_pes_packet(mpeg3_demuxer_t *demuxer, unsigned int header)
1043 {
1044         unsigned int pts = 0, dts = 0;
1045         int pes_packet_length;
1046         int64_t pes_packet_start;
1047         int decryption_offset;
1048         int i;
1049         mpeg3_t *file = demuxer->file;
1050         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1051         int scrambling = 0;
1052 /* Format if audio */
1053         int do_pcm = 0;
1054
1055         demuxer->data_start = demuxer->data_size;
1056         demuxer->audio_start = demuxer->audio_size;
1057         demuxer->video_start = demuxer->video_size;
1058
1059         demuxer->stream_id = header & 0xff;
1060         pes_packet_length = mpeg3io_read_int16(title->fs);
1061         pes_packet_start = mpeg3io_tell(title->fs);
1062
1063
1064
1065 /*
1066  * printf(__FUNCTION__ " pes_packet_start=%llx pes_packet_length=%x data_size=%x\n",
1067  * pes_packet_start,
1068  * pes_packet_length,
1069  * demuxer->data_size);
1070  */
1071
1072
1073
1074
1075
1076         if(demuxer->stream_id != MPEG3_PRIVATE_STREAM_2 &&
1077                 demuxer->stream_id != MPEG3_PADDING_STREAM)
1078         {
1079                 if((mpeg3io_next_char(title->fs) >> 6) == 0x02)
1080                 {
1081 /* Get MPEG-2 packet */
1082                         int pes_header_bytes = 0;
1083                 int pts_dts_flags;
1084                         int pes_header_data_length;
1085
1086
1087                         demuxer->last_packet_decryption = mpeg3io_tell(title->fs);
1088                         scrambling = mpeg3io_read_char(title->fs) & 0x30;
1089 //scrambling = 1;
1090 /* Reset scrambling bit for the mpeg3cat utility */
1091 //                      if(scrambling) demuxer->raw_data[demuxer->raw_offset - 1] &= 0xcf;
1092 // Force packet length if scrambling
1093                         if(scrambling) pes_packet_length = 0x800 -
1094                                 pes_packet_start +
1095                                 demuxer->last_packet_start;
1096
1097
1098                 pts_dts_flags = (mpeg3io_read_char(title->fs) >> 6) & 0x3;
1099                         pes_header_data_length = mpeg3io_read_char(title->fs);
1100
1101
1102
1103 /* Get Presentation and Decoding Time Stamps */
1104                         if(pts_dts_flags == 2)
1105                         {
1106                                 pts = get_timestamp(demuxer);
1107                                 if(demuxer->dump)
1108                                 {
1109                                         printf("pts=%d\n", pts);
1110                                 }
1111                                 pes_header_bytes += 5;
1112                         }
1113                 else
1114                         if(pts_dts_flags == 3)
1115                         {
1116                                 pts = get_timestamp(demuxer);
1117                                 dts = get_timestamp(demuxer);
1118                                 if(demuxer->dump)
1119                                 {
1120                                         printf("pts=%d dts=%d\n", pts, dts);
1121                                 }
1122 /*
1123  *                      pts = (mpeg3io_read_char(title->fs) >> 1) & 7;
1124  *                      pts <<= 15;
1125  *                      pts |= (mpeg3io_read_int16(title->fs) >> 1);
1126  *                      pts <<= 15;
1127  *                      pts |= (mpeg3io_read_int16(title->fs) >> 1);
1128  */
1129
1130 /*
1131  *                      dts = (mpeg3io_read_char(title->fs) >> 1) & 7;
1132  *                      dts <<= 15;
1133  *                      dts |= (mpeg3io_read_int16(title->fs) >> 1);
1134  *                      dts <<= 15;
1135  *                      dts |= (mpeg3io_read_int16(title->fs) >> 1);
1136  */
1137                         pes_header_bytes += 10;
1138                 }
1139
1140 //printf("get_program_pes_packet do_audio=%d do_video=%d pts=%x dts=%x\n",
1141 //      demuxer->do_audio, demuxer->do_video, pts, dts);
1142
1143 /* Skip unknown */
1144                 mpeg3io_seek_relative(title->fs,
1145                                 pes_header_data_length - pes_header_bytes);
1146                 }
1147                 else
1148                 {
1149                         int pts_dts_flags;
1150 /* Get MPEG-1 packet */
1151                         while(mpeg3io_next_char(title->fs) == 0xff)
1152                         {
1153                                 mpeg3io_read_char(title->fs);
1154                         }
1155
1156 /* Skip STD buffer scale */
1157                         if((mpeg3io_next_char(title->fs) & 0x40) == 0x40)
1158                         {
1159                                 mpeg3io_seek_relative(title->fs, 2);
1160                         }
1161
1162 /* Decide which timestamps are available */
1163                         pts_dts_flags = mpeg3io_next_char(title->fs);
1164
1165                         if(pts_dts_flags >= 0x30)
1166                         {
1167 /* Get the presentation and decoding time stamp */
1168                                 pts = get_timestamp(demuxer);
1169                                 dts = get_timestamp(demuxer);
1170                         }
1171                         else
1172                         if(pts_dts_flags >= 0x20)
1173                         {
1174 /* Get just the presentation time stamp */
1175                                 pts = get_timestamp(demuxer);
1176                         }
1177                         else
1178                         if(pts_dts_flags == 0x0f)
1179                         {
1180 /* End of timestamps */
1181                                 mpeg3io_read_char(title->fs);
1182                         }
1183                         else
1184                         {
1185                                 return 1;     /* Error */
1186                         }
1187                 }
1188
1189 /* Now extract the payload. */
1190                 if((demuxer->stream_id >> 4) == 0xc || (demuxer->stream_id >> 4) == 0xd)
1191                 {
1192 /* Audio data */
1193 /* Take first stream ID if -1 */
1194                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1195
1196                         demuxer->got_audio = 1;
1197                         demuxer->custom_id = demuxer->stream_id & 0x0f;
1198
1199
1200                         if(demuxer->read_all)
1201                                 demuxer->astream_table[demuxer->custom_id] = AUDIO_MPEG;
1202                         else
1203                         if(demuxer->astream == -1)
1204                                 demuxer->astream = demuxer->custom_id;
1205
1206
1207
1208
1209                         if(pts > 0) demuxer->pes_audio_time = (double)pts / 60000;
1210
1211
1212                         if(demuxer->custom_id == demuxer->astream &&
1213                                 demuxer->do_audio ||
1214                                 demuxer->read_all)
1215                         {
1216                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
1217                                 if(demuxer->dump)
1218                                 {
1219                                         printf(" MP2 audio data offset=%llx custom_id=%x size=%x\n",
1220                                                 demuxer->program_byte,
1221                                                 demuxer->custom_id,
1222                                                 pes_packet_length);
1223                                 }
1224
1225                                 get_program_payload(demuxer, pes_packet_length, 1, 0);
1226                         }
1227                         else
1228                         {
1229                         mpeg3io_seek_relative(title->fs, pes_packet_length);
1230                         }
1231                 }
1232         else
1233                 if((demuxer->stream_id >> 4) == 0xe)
1234                 {
1235 /* Video data */
1236 /* Take first stream ID if -1 */
1237                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1238
1239                         demuxer->got_video = 1;
1240                         demuxer->custom_id = demuxer->stream_id & 0x0f;
1241
1242
1243                         if(demuxer->read_all)
1244                                 demuxer->vstream_table[demuxer->custom_id] = 1;
1245                         else
1246                         if(demuxer->vstream == -1)
1247                                 demuxer->vstream = demuxer->custom_id;
1248
1249                         if(pts > 0) demuxer->pes_video_time = (double)pts / 60000;
1250
1251
1252
1253             if(demuxer->custom_id == demuxer->vstream &&
1254                                 demuxer->do_video ||
1255                                 demuxer->read_all)
1256                         {
1257                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
1258                                 if(demuxer->dump)
1259                                 {
1260                                         printf(" video offset=%llx custom_id=%x size=%x\n",
1261                                                 demuxer->program_byte,
1262                                                 demuxer->custom_id,
1263                                                 pes_packet_length);
1264                                 }
1265
1266
1267                                 get_program_payload(demuxer,
1268                                         pes_packet_length,
1269                                         0,
1270                                         1);
1271                 }
1272                 else
1273                         {
1274                                 if(demuxer->dump)
1275                                 {
1276                                         printf(" skipping video size=%x\n", pes_packet_length);
1277                                 }
1278                         mpeg3io_seek_relative(title->fs, pes_packet_length);
1279                 }
1280         }
1281         else
1282                 if((demuxer->stream_id == 0xbd || demuxer->stream_id == 0xbf) &&
1283                         mpeg3io_next_char(title->fs) != 0xff &&
1284                         ((mpeg3io_next_char(title->fs) & 0xf0) == 0x20))
1285                 {
1286 /* DVD subtitle data */
1287                         mpeg3_subtitle_t *subtitle = 0;
1288                         int stream_id = demuxer->stream_id = mpeg3io_read_char(title->fs);
1289                         subtitle = new_subtitle(demuxer,
1290                                 stream_id,
1291                                 demuxer->program_byte);
1292
1293 /* Get data length */
1294                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1295
1296                         handle_subtitle(file, demuxer, subtitle, pes_packet_length);
1297 //printf("mpeg3_demux id=0x%02x size=%d total_size=%d\n", stream_id, pes_packet_length, subtitle->size);
1298
1299                 }
1300                 else
1301                 if((demuxer->stream_id == 0xbd || demuxer->stream_id == 0xbf) &&
1302                         mpeg3io_next_char(title->fs) != 0xff &&
1303                         ((mpeg3io_next_char(title->fs) & 0xf0) == 0x80))
1304                 {
1305                         int format;
1306 /* DVD audio data */
1307 /* Get the audio format */
1308                         if((mpeg3io_next_char(title->fs) & 0xf0) == 0xa0)
1309                                 format = AUDIO_PCM;
1310                         else
1311                                 format = AUDIO_AC3;
1312
1313
1314 // Picks up bogus data if (& 0xf) or (& 0x7f)
1315                         demuxer->stream_id = mpeg3io_next_char(title->fs);
1316                         if(pts > 0) demuxer->pes_audio_time = (double)pts / 60000;
1317
1318                         demuxer->got_audio = 1;
1319                         demuxer->custom_id = demuxer->stream_id;
1320
1321
1322 /* Take first stream ID if not building TOC. */
1323                         if(demuxer->read_all)
1324                                 demuxer->astream_table[demuxer->custom_id] = format;
1325                         else
1326                         if(demuxer->astream == -1)
1327                                 demuxer->astream = demuxer->custom_id;
1328
1329
1330
1331
1332
1333
1334
1335                 if(demuxer->custom_id == demuxer->astream &&
1336                                 demuxer->do_audio ||
1337                                 demuxer->read_all)
1338                         {
1339                                 demuxer->aformat = format;
1340                                 mpeg3io_read_int32(title->fs);
1341
1342                                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1343                                 decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
1344
1345                                 if(format == AUDIO_PCM) do_pcm = 1;
1346 //printf("get_program_pes_packet 5 %x\n", decryption_offset);
1347
1348                                 if(demuxer->dump)
1349                                 {
1350                                         printf(" AC3 audio data size=%x\n", pes_packet_length);
1351                                 }
1352
1353                                 get_program_payload(demuxer,
1354                                         pes_packet_length,
1355                                         1,
1356                                         0);
1357                 }
1358                 else
1359                         {
1360                                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1361                         mpeg3io_seek_relative(title->fs, pes_packet_length);
1362                 }
1363 //printf("get_program_pes_packet 6 %d\n", demuxer->astream_table[0x20]);
1364         }
1365         else
1366                 if(demuxer->stream_id == 0xbc || 1)
1367                 {
1368                         pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1369                 mpeg3io_seek_relative(title->fs, pes_packet_length);
1370         }
1371         }
1372         else
1373         if(demuxer->stream_id == MPEG3_PRIVATE_STREAM_2 || demuxer->stream_id == MPEG3_PADDING_STREAM)
1374         {
1375                 pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
1376         mpeg3io_seek_relative(title->fs, pes_packet_length);
1377         }
1378
1379
1380
1381
1382         if(scrambling) handle_scrambling(demuxer, decryption_offset);
1383
1384
1385
1386         if(do_pcm) handle_pcm(demuxer, pes_packet_length);
1387
1388
1389
1390
1391
1392
1393
1394
1395         return 0;
1396 }
1397
1398 int mpeg3demux_read_program(mpeg3_demuxer_t *demuxer)
1399 {
1400         int result = 0;
1401         int count = 0;
1402         mpeg3_t *file = demuxer->file;
1403         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1404         unsigned int header = 0;
1405         int pack_count = 0;
1406
1407         demuxer->got_audio = 0;
1408         demuxer->got_video = 0;
1409         demuxer->stream_id = 0;
1410         demuxer->custom_id = -1;
1411         demuxer->got_subtitle = 0;
1412
1413         if(mpeg3io_eof(title->fs)) return 1;
1414
1415 //printf("mpeg3demux_read_program 2 %d %x %llx\n", result, title->fs->current_byte, title->fs->total_bytes);
1416
1417
1418
1419
1420
1421
1422
1423 /* Search for next header */
1424 /* Parse packet until the next packet start code */
1425         while(!result && !mpeg3io_eof(title->fs))
1426         {
1427                 header = mpeg3io_read_int32(title->fs);
1428
1429
1430                 if(header == MPEG3_PACK_START_CODE)
1431                 {
1432
1433
1434 // Second start code in this call.  Don't read it.
1435                         if(pack_count)
1436                         {
1437                                 mpeg3io_seek_relative(title->fs, -4);
1438                                 break;
1439                         }
1440
1441                         demuxer->last_packet_start = mpeg3io_tell(title->fs) - 4;
1442                         result = get_pack_header(demuxer);
1443                         pack_count++;
1444
1445
1446
1447                 }
1448                 else
1449                 if(header == MPEG3_SYSTEM_START_CODE && pack_count)
1450                 {
1451
1452
1453
1454                         result = get_system_header(demuxer);
1455
1456
1457
1458                 }
1459                 else
1460                 if((header >> 8) == MPEG3_PACKET_START_CODE_PREFIX && pack_count)
1461                 {
1462
1463
1464                         result = get_program_pes_packet(demuxer, header);
1465
1466
1467
1468                 }
1469                 else
1470                 {
1471 // Try again.
1472                         mpeg3io_seek_relative(title->fs, -3);
1473                 }
1474         }
1475
1476
1477
1478
1479
1480
1481
1482 // Ignore errors in the parsing.  Just quit if eof.
1483         result = 0;
1484
1485
1486
1487
1488
1489
1490         demuxer->last_packet_end = mpeg3io_tell(title->fs);
1491
1492 /*
1493  * if(demuxer->last_packet_end - demuxer->last_packet_start != 0x800)
1494  * printf(__FUNCTION__ " packet_size=%llx data_size=%x pack_count=%d packet_start=%llx packet_end=%llx\n",
1495  * demuxer->last_packet_end - demuxer->last_packet_start,
1496  * demuxer->data_size,
1497  * pack_count,
1498  * demuxer->last_packet_start,
1499  * demuxer->last_packet_end);
1500  */
1501 //printf("mpeg3demux_read_program 5 %d\n", result);
1502
1503 //printf("read_program 3\n");
1504 //      if(!result) result = mpeg3io_eof(title->fs);
1505
1506         demuxer->program_byte =
1507                 mpeg3_absolute_to_program(demuxer, mpeg3io_tell(title->fs) +
1508                         title->start_byte);
1509         return result;
1510 }
1511
1512
1513
1514
1515 // Point the current title and current cell to the program byte.
1516 static int get_current_cell(mpeg3_demuxer_t *demuxer)
1517 {
1518         int got_it = 0;
1519         int result = 0;
1520
1521 /* Find first cell on or after current position */
1522         if(demuxer->reverse)
1523         {
1524                 for(demuxer->current_title = demuxer->total_titles - 1;
1525                         demuxer->current_title >= 0;
1526                         demuxer->current_title--)
1527                 {
1528                         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1529                         for(demuxer->title_cell = title->cell_table_size - 1;
1530                                 demuxer->title_cell >= 0;
1531                                 demuxer->title_cell--)
1532                         {
1533                                 mpeg3_cell_t *cell = &title->cell_table[demuxer->title_cell];
1534                                 if(cell->program_start < demuxer->program_byte &&
1535                                         cell->program == demuxer->current_program)
1536                                 {
1537                                         got_it = 1;
1538                                         if(demuxer->program_byte > cell->program_end)
1539                                                 demuxer->program_byte = cell->program_end;
1540                                         break;
1541                                 }
1542                         }
1543                         if(got_it) break;
1544                 }
1545
1546                 if(!got_it)
1547                 {
1548                         demuxer->current_title = 0;
1549                         demuxer->title_cell = 0;
1550                         result = 1;
1551                 }
1552         }
1553         else
1554         {
1555                 for(demuxer->current_title = 0;
1556                         demuxer->current_title < demuxer->total_titles;
1557                         demuxer->current_title++)
1558                 {
1559                         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1560                         for(demuxer->title_cell = 0;
1561                                 demuxer->title_cell < title->cell_table_size;
1562                                 demuxer->title_cell++)
1563                         {
1564                                 mpeg3_cell_t *cell = &title->cell_table[demuxer->title_cell];
1565                                 if(cell->program_end > demuxer->program_byte &&
1566                                         cell->program == demuxer->current_program)
1567                                 {
1568                                         got_it = 1;
1569                                         if(demuxer->program_byte < cell->program_start)
1570                                                 demuxer->program_byte = cell->program_start;
1571                                         break;
1572                                 }
1573                         }
1574                         if(got_it) break;
1575                 }
1576
1577                 if(!got_it)
1578                 {
1579                         demuxer->current_title = demuxer->total_titles - 1;
1580                         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1581                         demuxer->title_cell = title->cell_table_size - 1;
1582                         result = 1;
1583                 }
1584         }
1585
1586
1587 //printf("get_current_cell 2 %p %d %d\n", demuxer, demuxer->current_title, demuxer->title_cell);
1588         return result;
1589 }
1590
1591
1592
1593
1594
1595 int mpeg3_seek_phys(mpeg3_demuxer_t *demuxer)
1596 {
1597         int result = 0;
1598
1599 // This happens if the video header is bigger than the buffer size in a table
1600 // of contents scan.
1601         if(demuxer->current_title < 0 ||
1602                 demuxer->current_title >= demuxer->total_titles)
1603         {
1604                 printf("mpeg3_seek_phys demuxer=%p read_all=%d do_audio=%d do_video=%d demuxer->current_title=%d\n",
1605                         demuxer,
1606                         demuxer->read_all,
1607                         demuxer->do_audio,
1608                         demuxer->do_video,
1609                         demuxer->current_title);
1610                 return 1;
1611         }
1612
1613         if(!demuxer->titles) return 1;
1614
1615         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1616 //printf("mpeg3_seek_phys: %p %d %d\n", title->cell_table, demuxer->current_title, demuxer->title_cell);
1617
1618         if(!title->cell_table) return 1;
1619
1620         mpeg3_cell_t *cell = &title->cell_table[demuxer->title_cell];
1621
1622
1623 /* Don't do anything if we're in the cell and it's the right program */
1624         if(demuxer->reverse)
1625         {
1626                 if(demuxer->program_byte > cell->program_start &&
1627                         demuxer->program_byte <= cell->program_end &&
1628                         cell->program == demuxer->current_program)
1629                 {
1630                         goto do_phys_seek;
1631                 }
1632         }
1633         else
1634         {
1635 // End of stream
1636 //printf("mpeg3_seek_phys %lld %lld\n", demuxer->program_byte, demuxer->stream_end);
1637                 if(demuxer->stream_end > 0 &&
1638                         demuxer->program_byte >= demuxer->stream_end) return 1;
1639
1640 // In same cell
1641                 if(demuxer->program_byte >= cell->program_start &&
1642                         demuxer->program_byte < cell->program_end &&
1643                         cell->program == demuxer->current_program)
1644                         goto do_phys_seek;
1645         }
1646
1647
1648
1649 // Need to change cells if we get here.
1650         int last_cell = demuxer->title_cell;
1651         int last_title = demuxer->current_title;
1652         int64_t last_byte = demuxer->program_byte;
1653         int got_it = 0;
1654
1655         result = get_current_cell(demuxer);
1656 // End of file
1657         if(result) return 1;
1658
1659         if(demuxer->current_title != last_title)
1660         {
1661                 mpeg3demux_open_title(demuxer, demuxer->current_title);
1662         }
1663
1664         title = demuxer->titles[demuxer->current_title];
1665         cell = &title->cell_table[demuxer->title_cell];
1666
1667
1668 do_phys_seek:
1669         mpeg3io_seek(title->fs,
1670                 demuxer->program_byte - cell->program_start + cell->title_start);
1671
1672         return result;
1673 }
1674
1675
1676
1677
1678
1679
1680
1681 static int next_code(mpeg3_demuxer_t *demuxer,
1682         uint32_t code)
1683 {
1684         uint32_t result = 0;
1685         int error = 0;
1686         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1687         mpeg3_fs_t *fd = title->fs;
1688
1689         while(result != code &&
1690                 !error)
1691         {
1692                 title = demuxer->titles[demuxer->current_title];
1693                 result <<= 8;
1694                 result |= (unsigned char)mpeg3io_read_char(title->fs);
1695                 demuxer->program_byte++;
1696                 error = mpeg3_seek_phys(demuxer);
1697         }
1698         return error;
1699 }
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710 /* Read packet in the forward direction */
1711 int mpeg3_read_next_packet(mpeg3_demuxer_t *demuxer)
1712 {
1713         if(demuxer->current_title < 0) return 1;
1714
1715         int result = 0;
1716         int current_position;
1717         mpeg3_t *file = demuxer->file;
1718         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1719
1720
1721 /* Reset output buffer */
1722         demuxer->data_size = 0;
1723         demuxer->data_position = 0;
1724         demuxer->audio_size = 0;
1725         demuxer->video_size = 0;
1726
1727 /* Switch to forward direction. */
1728         if(demuxer->reverse)
1729         {
1730 /* Don't reread anything if we're at the beginning of the file. */
1731                 if(demuxer->program_byte < 0)
1732                 {
1733                         demuxer->program_byte = 0;
1734                         result = mpeg3_seek_phys(demuxer);
1735 /* First character was the -1 byte which brings us to 0 after this function. */
1736                         result = 1;
1737                 }
1738                 else
1739 /* Transport or elementary stream */
1740                 if(file->packet_size > 0)
1741                 {
1742                         demuxer->program_byte += file->packet_size;
1743                         result = mpeg3_seek_phys(demuxer);
1744                 }
1745                 else
1746                 {
1747 /* Packet just read */
1748                         if(!result) result = next_code(demuxer,
1749                                 MPEG3_PACK_START_CODE);
1750 /* Next packet */
1751                         if(!result) result = next_code(demuxer,
1752                                 MPEG3_PACK_START_CODE);
1753                 }
1754
1755                 demuxer->reverse = 0;
1756         }
1757
1758
1759
1760
1761
1762
1763
1764 /* Read packets until the output buffer is full. */
1765 /* Read a single packet if not fetching audio or video. */
1766         if(!result)
1767         {
1768                 do
1769                 {
1770                         title = demuxer->titles[demuxer->current_title];
1771 //printf("mpeg3_read_next_packet 10 %llx\n", mpeg3io_tell(title->fs));
1772
1773                         if(!result)
1774                         {
1775                                 if(file->is_transport_stream)
1776                                 {
1777                                         result = mpeg3_seek_phys(demuxer);
1778                                         if(!result) result = read_transport(demuxer);
1779                                 }
1780                                 else
1781                                 if(file->is_program_stream)
1782                                 {
1783                                         result = mpeg3_seek_phys(demuxer);
1784                                         if(!result) result = mpeg3demux_read_program(demuxer);
1785                                 }
1786                                 else
1787                                 if(demuxer->read_all && file->is_audio_stream)
1788                                 {
1789 /* Read elementary stream. */
1790                                         result = mpeg3io_read_data(demuxer->audio_buffer,
1791                                                 file->packet_size, title->fs);
1792                                         demuxer->audio_size = file->packet_size;
1793                                         demuxer->program_byte += file->packet_size;
1794                                         result |= mpeg3_seek_phys(demuxer);
1795                                 }
1796                                 else
1797                                 if(demuxer->read_all && file->is_video_stream)
1798                                 {
1799 /* Read elementary stream. */
1800                                         result = mpeg3io_read_data(demuxer->video_buffer,
1801                                                 file->packet_size, title->fs);
1802                                                 demuxer->video_size = file->packet_size;
1803                                                 demuxer->program_byte += file->packet_size;
1804                                                 result |= mpeg3_seek_phys(demuxer);
1805                                 }
1806                                 else
1807                                 {
1808                                         result = mpeg3io_read_data(demuxer->data_buffer,
1809                                                 file->packet_size, title->fs);
1810                                         demuxer->data_size = file->packet_size;
1811                                         demuxer->program_byte += file->packet_size;
1812 //printf("mpeg3_read_next_packet 1 %llx\n", mpeg3demux_tell_byte(demuxer));
1813                                         result |= mpeg3_seek_phys(demuxer);
1814 //printf("mpeg3_read_next_packet 2 %llx\n", mpeg3demux_tell_byte(demuxer));
1815                                 }
1816                         }
1817 /*
1818  * printf("mpeg3_read_next_packet 100 result=%d data_size=0x%x\n",
1819  * result,
1820  * demuxer->data_size);
1821  */
1822                 }while(!result &&
1823                         demuxer->data_size == 0 &&
1824                         (demuxer->do_audio || demuxer->do_video));
1825         }
1826
1827         return result;
1828 }
1829
1830
1831
1832
1833 static int prev_code(mpeg3_demuxer_t *demuxer,
1834         uint32_t code)
1835 {
1836         uint32_t result = 0;
1837         int error = 0;
1838         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1839         mpeg3_fs_t *fd = title->fs;
1840
1841
1842         while(result != code &&
1843                 demuxer->program_byte > 0 &&
1844                 !error)
1845         {
1846                 result >>= 8;
1847                 title = demuxer->titles[demuxer->current_title];
1848                 mpeg3io_seek(title->fs, demuxer->program_byte - title->start_byte - 1LL);
1849                 result |= ((uint32_t)mpeg3io_read_char(title->fs)) << 24;
1850                 demuxer->program_byte--;
1851                 error = mpeg3_seek_phys(demuxer);
1852         }
1853         return error;
1854 }
1855
1856
1857
1858
1859
1860 /* Read the packet right before the packet we're currently on. */
1861 int mpeg3_read_prev_packet(mpeg3_demuxer_t *demuxer)
1862 {
1863         int result = 0;
1864         mpeg3_t *file = demuxer->file;
1865         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
1866
1867         demuxer->data_size = 0;
1868         demuxer->data_position = 0;
1869
1870
1871
1872 /* Switch to reverse direction */
1873         if(!demuxer->reverse)
1874         {
1875                 demuxer->reverse = 1;
1876
1877 /* Transport stream or elementary stream case */
1878                 if(file->packet_size > 0)
1879                 {
1880                         demuxer->program_byte -= file->packet_size;
1881                         result = mpeg3_seek_phys(demuxer);
1882                 }
1883                 else
1884 /* Program stream */
1885                 {
1886                         result = prev_code(demuxer,
1887                                 MPEG3_PACK_START_CODE);
1888                 }
1889
1890         }
1891
1892
1893
1894
1895
1896
1897
1898 /* Go to beginning of previous packet */
1899         do
1900         {
1901                 title = demuxer->titles[demuxer->current_title];
1902
1903 /* Transport stream or elementary stream case */
1904                 if(file->packet_size > 0)
1905                 {
1906 printf("mpeg3_read_prev_packet 1 result=%d title=%d tell=%llx program_byte=%llx\n", result, demuxer->current_title, mpeg3io_tell(title->fs), demuxer->program_byte);
1907                         demuxer->program_byte -= file->packet_size;
1908                         result = mpeg3_seek_phys(demuxer);
1909 printf("mpeg3_read_prev_packet 100 result=%d title=%d tell=%llx program_byte=%llx\n", result, demuxer->current_title, mpeg3io_tell(title->fs), demuxer->program_byte);
1910                 }
1911                 else
1912                 {
1913                         if(!result) result = prev_code(demuxer,
1914                                 MPEG3_PACK_START_CODE);
1915                 }
1916
1917
1918
1919 /* Read packet and then rewind it */
1920                 title = demuxer->titles[demuxer->current_title];
1921                 if(file->is_transport_stream && !result)
1922                 {
1923                         result = read_transport(demuxer);
1924
1925                         if(demuxer->program_byte > 0)
1926                         {
1927                                 demuxer->program_byte -= file->packet_size;
1928                                 result = mpeg3_seek_phys(demuxer);
1929                         }
1930                 }
1931                 else
1932                 if(file->is_program_stream && !result)
1933                 {
1934                         int64_t current_position = demuxer->program_byte;
1935
1936 /* Read packet */
1937                         result = mpeg3demux_read_program(demuxer);
1938
1939 /* Rewind packet */
1940                         while(demuxer->program_byte > current_position &&
1941                                 !result)
1942                         {
1943                                 result = prev_code(demuxer,
1944                                         MPEG3_PACK_START_CODE);
1945                         }
1946                 }
1947                 else
1948                 if(!result)
1949                 {
1950 /* Elementary stream */
1951 /* Read the packet forwards and seek back to the start */
1952                         result = mpeg3io_read_data(demuxer->data_buffer,
1953                                 file->packet_size,
1954                                 title->fs);
1955
1956                         if(!result)
1957                         {
1958                                 demuxer->data_size = file->packet_size;
1959                                 result = mpeg3io_seek(title->fs, demuxer->program_byte);
1960                         }
1961                 }
1962         }while(!result &&
1963                 demuxer->data_size == 0 &&
1964                 (demuxer->do_audio || demuxer->do_video));
1965
1966
1967         return result;
1968 }
1969
1970
1971 /* For audio */
1972 int mpeg3demux_read_data(mpeg3_demuxer_t *demuxer,
1973                 unsigned char *output,
1974                 int size)
1975 {
1976         int result = 0;
1977         demuxer->error_flag = 0;
1978 //printf("mpeg3demux_read_data 1\n");
1979
1980         if(demuxer->data_position >= 0)
1981         {
1982 /* Read forwards */
1983                 int i;
1984                 for(i = 0; i < size && !result; )
1985                 {
1986                         int fragment_size = size - i;
1987                         if(fragment_size > demuxer->data_size - demuxer->data_position)
1988                                 fragment_size = demuxer->data_size - demuxer->data_position;
1989                         memcpy(output + i, demuxer->data_buffer + demuxer->data_position, fragment_size);
1990                         demuxer->data_position += fragment_size;
1991                         i += fragment_size;
1992
1993                         if(i < size)
1994                         {
1995                                 result = mpeg3_read_next_packet(demuxer);
1996                         }
1997 /*
1998  * printf("mpeg3demux_read_data 10 offset=%llx pid=0x%x bytes=0x%x i=0x%x\n",
1999  * mpeg3demux_tell_byte(demuxer),
2000  * demuxer->pid,
2001  * demuxer->data_size,
2002  * i);
2003  */
2004                 }
2005 //printf("mpeg3demux_read_data 10\n");
2006         }
2007         else
2008         {
2009                 int current_position;
2010 /* Read backwards a full packet. */
2011 /* Only good for reading less than the size of a full packet, but */
2012 /* this routine should only be used for searching for previous markers. */
2013                 current_position = demuxer->data_position;
2014                 result = mpeg3_read_prev_packet(demuxer);
2015                 if(!result) demuxer->data_position = demuxer->data_size + current_position;
2016                 memcpy(output, demuxer->data_buffer + demuxer->data_position, size);
2017                 demuxer->data_position += size;
2018         }
2019
2020 //printf("mpeg3demux_read_data 2\n");
2021         demuxer->error_flag = result;
2022         return result;
2023 }
2024
2025 unsigned char mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer)
2026 {
2027         demuxer->error_flag = 0;
2028         demuxer->next_char = -1;
2029
2030         if(demuxer->data_position >= demuxer->data_size)
2031         {
2032                 demuxer->error_flag = mpeg3_read_next_packet(demuxer);
2033         }
2034
2035         if(!demuxer->error_flag)
2036                 demuxer->next_char = demuxer->data_buffer[demuxer->data_position++];
2037
2038         return demuxer->next_char;
2039 }
2040
2041 unsigned char mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer)
2042 {
2043         demuxer->error_flag = 0;
2044         demuxer->data_position--;
2045         if(demuxer->data_position < 0)
2046         {
2047                 demuxer->error_flag = mpeg3_read_prev_packet(demuxer);
2048                 if(!demuxer->error_flag) demuxer->data_position = demuxer->data_size - 1;
2049         }
2050
2051         if(demuxer->data_position >= 0)
2052         {
2053                 demuxer->next_char = demuxer->data_buffer[demuxer->data_position];
2054         }
2055         return demuxer->next_char;
2056 }
2057
2058
2059
2060 int mpeg3demux_open_title(mpeg3_demuxer_t *demuxer, int title_number)
2061 {
2062         mpeg3_title_t *title;
2063
2064         if(title_number < demuxer->total_titles &&
2065                 title_number >= 0)
2066         {
2067                 if(demuxer->current_title >= 0)
2068                 {
2069                         mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
2070                         demuxer->current_title = -1;
2071                 }
2072
2073                 title = demuxer->titles[title_number];
2074
2075                 if(mpeg3io_open_file(title->fs))
2076                 {
2077                         demuxer->error_flag = 1;
2078                         fprintf(stderr, "mpeg3demux_open_title %s: %s", title->fs->path, strerror(errno));
2079                 }
2080                 else
2081                 {
2082                         demuxer->current_title = title_number;
2083                 }
2084         }
2085         else
2086         {
2087                 fprintf(stderr, "mpeg3demux_open_title title_number = %d\n",
2088                         title_number);
2089         }
2090
2091
2092         return demuxer->error_flag;
2093 }
2094
2095 int mpeg3demux_copy_titles(mpeg3_demuxer_t *dst, mpeg3_demuxer_t *src)
2096 {
2097         int i;
2098         mpeg3_t *file = dst->file;
2099         mpeg3_title_t *dst_title, *src_title;
2100
2101         dst->total_titles = src->total_titles;
2102         dst->total_programs = src->total_programs;
2103
2104         for(i = 0; i < MPEG3_MAX_STREAMS; i++)
2105         {
2106                 dst->astream_table[i] = src->astream_table[i];
2107                 dst->vstream_table[i] = src->vstream_table[i];
2108         }
2109
2110         for(i = 0; i < src->total_titles; i++)
2111         {
2112                 src_title = src->titles[i];
2113                 dst_title = dst->titles[i] = mpeg3_new_title(file,
2114                         src->titles[i]->fs->path);
2115                 mpeg3_copy_title(dst_title, src_title);
2116         }
2117
2118         mpeg3demux_open_title(dst, src->current_title);
2119         dst->title_cell = 0;
2120         return 0;
2121 }
2122
2123 /* ==================================================================== */
2124 /*                            Entry points */
2125 /* ==================================================================== */
2126
2127 mpeg3_demuxer_t* mpeg3_new_demuxer(mpeg3_t *file, int do_audio, int do_video, int custom_id)
2128 {
2129         mpeg3_demuxer_t *demuxer = calloc(1, sizeof(mpeg3_demuxer_t));
2130         int i;
2131
2132 /* The demuxer will change the default packet size for its own use. */
2133         demuxer->file = file;
2134         demuxer->do_audio = do_audio;
2135         demuxer->do_video = do_video;
2136
2137 /* Allocate buffer + padding */
2138         demuxer->raw_data = calloc(1, MPEG3_RAW_SIZE);
2139         demuxer->data_buffer = calloc(1, MPEG3_RAW_SIZE);
2140         demuxer->data_allocated = MPEG3_RAW_SIZE;
2141
2142         demuxer->audio_buffer = calloc(1, MPEG3_RAW_SIZE);
2143         demuxer->audio_allocated = MPEG3_RAW_SIZE;
2144
2145         demuxer->video_buffer = calloc(1, MPEG3_RAW_SIZE);
2146         demuxer->video_allocated = MPEG3_RAW_SIZE;
2147
2148 /* System specific variables */
2149         demuxer->audio_pid = custom_id;
2150         demuxer->video_pid = custom_id;
2151         demuxer->astream = custom_id;
2152         demuxer->vstream = custom_id;
2153         demuxer->current_title = -1;
2154         demuxer->pes_audio_time = -1;
2155         demuxer->pes_video_time = -1;
2156 //printf("mpeg3_new_demuxer %f\n", demuxer->time);
2157         demuxer->stream_end = -1;
2158
2159         return demuxer;
2160 }
2161
2162 int mpeg3_delete_demuxer(mpeg3_demuxer_t *demuxer)
2163 {
2164         int i;
2165
2166         if(demuxer->current_title >= 0)
2167         {
2168                 mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
2169         }
2170
2171         for(i = 0; i < demuxer->total_titles; i++)
2172         {
2173                 mpeg3_delete_title(demuxer->titles[i]);
2174         }
2175
2176         if(demuxer->data_buffer) free(demuxer->data_buffer);
2177         if(demuxer->raw_data) free(demuxer->raw_data);
2178         if(demuxer->audio_buffer) free(demuxer->audio_buffer);
2179         if(demuxer->video_buffer) free(demuxer->video_buffer);
2180         for(i = 0; i < demuxer->total_subtitles; i++)
2181         {
2182                 mpeg3_delete_subtitle(demuxer->subtitles[i]);
2183         }
2184         if(demuxer->subtitles) free(demuxer->subtitles);
2185         free(demuxer);
2186         return 0;
2187 }
2188
2189
2190 int mpeg3demux_eof(mpeg3_demuxer_t *demuxer)
2191 {
2192         mpeg3_t *file = demuxer->file;
2193         if(file->seekable)
2194         {
2195                 if(demuxer->current_title >= 0)
2196                 {
2197                         if(mpeg3io_eof(demuxer->titles[demuxer->current_title]->fs) &&
2198                                 demuxer->current_title >= demuxer->total_titles - 1)
2199                                 return 1;
2200                 }
2201
2202 // Same operation performed in mpeg3_seek_phys
2203                 if(demuxer->stream_end > 0 &&
2204                         demuxer->program_byte >= demuxer->stream_end) return 1;
2205         }
2206         else
2207         {
2208                 if(demuxer->data_position >= demuxer->data_size) return 1;
2209         }
2210
2211         return 0;
2212 }
2213
2214 int mpeg3demux_bof(mpeg3_demuxer_t *demuxer)
2215 {
2216         if(demuxer->current_title >= 0)
2217         {
2218                 if(mpeg3io_bof(demuxer->titles[demuxer->current_title]->fs) &&
2219                         demuxer->current_title <= 0)
2220                         return 1;
2221         }
2222         return 0;
2223 }
2224
2225 void mpeg3demux_start_reverse(mpeg3_demuxer_t *demuxer)
2226 {
2227         demuxer->reverse = 1;
2228 }
2229
2230 void mpeg3demux_start_forward(mpeg3_demuxer_t *demuxer)
2231 {
2232         demuxer->reverse = 0;
2233 }
2234
2235 /* Seek to absolute byte */
2236 int mpeg3demux_seek_byte(mpeg3_demuxer_t *demuxer, int64_t byte)
2237 {
2238         mpeg3_t *file = demuxer->file;
2239
2240 /*
2241  * int i;
2242  * for(i = 0; i < demuxer->total_titles; i++) mpeg3_dump_title(demuxer->titles[i]);
2243  */
2244
2245         demuxer->program_byte = byte;
2246         demuxer->data_position = 0;
2247         demuxer->data_size = 0;
2248
2249 /* Get on a packet boundary only for transport streams. */
2250         if(file->is_transport_stream &&
2251                 file->packet_size)
2252         {
2253                 demuxer->program_byte -= demuxer->program_byte % file->packet_size;
2254         }
2255
2256         int result = mpeg3_seek_phys(demuxer);
2257 /*
2258  * printf("mpeg3demux_seek_byte 1 %d %d %lld %lld\n",
2259  * demuxer->do_video, result, byte, demuxer->program_byte);
2260  */
2261
2262         return result;
2263 }
2264
2265
2266 int mpeg3_finished_subtitles(mpeg3_demuxer_t *demuxer, int id)
2267 {
2268         int i;
2269         int total = 0;
2270         for(i = 0; i < demuxer->total_subtitles; i++)
2271         {
2272                 if(demuxer->subtitles[i]->done &&
2273                         (id < 0 ||
2274                         demuxer->subtitles[i]->id == id)) total++;
2275         }
2276         return total;
2277 }
2278
2279
2280
2281
2282
2283
2284
2285 double mpeg3demux_get_time(mpeg3_demuxer_t *demuxer)
2286 {
2287         return demuxer->time;
2288 }
2289
2290 double mpeg3demux_audio_pts(mpeg3_demuxer_t *demuxer)
2291 {
2292         return demuxer->pes_audio_time;
2293 }
2294
2295 double mpeg3demux_video_pts(mpeg3_demuxer_t *demuxer)
2296 {
2297         return demuxer->pes_video_time;
2298 }
2299
2300 void mpeg3demux_reset_pts(mpeg3_demuxer_t *demuxer)
2301 {
2302         demuxer->pes_audio_time = -1;
2303         demuxer->pes_video_time = -1;
2304 }
2305
2306 double mpeg3demux_scan_pts(mpeg3_demuxer_t *demuxer)
2307 {
2308         int64_t start_position = mpeg3demux_tell_byte(demuxer);
2309         int64_t end_position = start_position + MPEG3_PTS_RANGE;
2310         int64_t current_position = start_position;
2311         int result = 0;
2312
2313         mpeg3demux_reset_pts(demuxer);
2314         while(!result &&
2315                 current_position < end_position &&
2316                 ((demuxer->do_audio && demuxer->pes_audio_time < 0) ||
2317                 (demuxer->do_video && demuxer->pes_video_time < 0)))
2318         {
2319                 result = mpeg3_read_next_packet(demuxer);
2320                 current_position = mpeg3demux_tell_byte(demuxer);
2321         }
2322
2323 // Seek back to starting point
2324         mpeg3demux_seek_byte(demuxer, start_position);
2325
2326         if(demuxer->do_audio) return demuxer->pes_audio_time;
2327         if(demuxer->do_video) return demuxer->pes_video_time;
2328 }
2329
2330 int mpeg3demux_goto_pts(mpeg3_demuxer_t *demuxer, double pts)
2331 {
2332         int64_t start_position = mpeg3demux_tell_byte(demuxer);
2333         int64_t end_position = start_position + MPEG3_PTS_RANGE;
2334         int64_t current_position = start_position;
2335         int result = 0;
2336
2337 // Search forward for nearest pts
2338         mpeg3demux_reset_pts(demuxer);
2339         while(!result && current_position < end_position)
2340         {
2341                 result = mpeg3_read_next_packet(demuxer);
2342                 if(demuxer->pes_audio_time > pts) break;
2343                 current_position = mpeg3demux_tell_byte(demuxer);
2344         }
2345
2346 // Search backward for nearest pts
2347         end_position = current_position - MPEG3_PTS_RANGE;
2348         mpeg3_read_prev_packet(demuxer);
2349         while(!result &&
2350                 current_position > end_position)
2351         {
2352                 result = mpeg3_read_prev_packet(demuxer);
2353                 if(demuxer->pes_audio_time < pts) break;
2354                 current_position = mpeg3demux_tell_byte(demuxer);
2355         }
2356 }
2357
2358
2359 int64_t mpeg3demux_tell_byte(mpeg3_demuxer_t *demuxer)
2360 {
2361         return demuxer->program_byte;
2362 }
2363
2364 int mpeg3demux_tell_program(mpeg3_demuxer_t *demuxer)
2365 {
2366         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
2367         if(!title->cell_table || !title->cell_table_size) return 0;
2368         mpeg3_cell_t *cell = &title->cell_table[demuxer->title_cell];
2369         return cell->program;
2370 }
2371
2372 int64_t mpeg3_absolute_to_program(mpeg3_demuxer_t *demuxer,
2373         int64_t byte)
2374 {
2375         int i, j;
2376
2377 //fprintf(stderr, "%d\n", demuxer->data_size);
2378 // Can only offset to current cell since we can't know what cell the
2379 // byte corresponds to.
2380         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
2381         mpeg3_cell_t *cell = &title->cell_table[demuxer->title_cell];
2382         return byte -
2383                 cell->title_start -
2384                 title->start_byte +
2385                 cell->program_start;
2386 }
2387
2388 int64_t mpeg3demux_movie_size(mpeg3_demuxer_t *demuxer)
2389 {
2390         if(!demuxer->total_bytes)
2391         {
2392                 int64_t result = 0;
2393                 int i, j;
2394                 for(i = 0; i < demuxer->total_titles; i++)
2395                 {
2396                         mpeg3_title_t *title = demuxer->titles[i];
2397                         for(j = 0; j < title->cell_table_size; j++)
2398                         {
2399                                 mpeg3_cell_t *cell = &title->cell_table[j];
2400                                 if(cell->program == demuxer->current_program)
2401                                         result += cell->program_end - cell->program_start;
2402                         }
2403 //                      result += demuxer->titles[i]->total_bytes;
2404                 }
2405                 demuxer->total_bytes = result;
2406         }
2407         return demuxer->total_bytes;
2408 }
2409
2410 int64_t mpeg3demuxer_title_bytes(mpeg3_demuxer_t *demuxer)
2411 {
2412         mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
2413         return title->total_bytes;
2414 }
2415
2416 mpeg3_demuxer_t* mpeg3_get_demuxer(mpeg3_t *file)
2417 {
2418         if(file->is_program_stream || file->is_transport_stream)
2419         {
2420                 if(file->total_astreams) return file->atrack[0]->demuxer;
2421                 else
2422                 if(file->total_vstreams) return file->vtrack[0]->demuxer;
2423         }
2424         return 0;
2425 }
2426
2427 void mpeg3demux_append_data(mpeg3_demuxer_t *demuxer,
2428         unsigned char *data,
2429         int bytes)
2430 {
2431         int new_data_size = demuxer->data_size + bytes;
2432         if(new_data_size >= demuxer->data_allocated)
2433         {
2434                 demuxer->data_allocated = new_data_size * 2;
2435                 demuxer->data_buffer = realloc(demuxer->data_buffer,
2436                         demuxer->data_allocated);
2437         }
2438
2439         memcpy(demuxer->data_buffer + demuxer->data_size,
2440                 data,
2441                 bytes);
2442         demuxer->data_size += bytes;
2443 }
2444
2445 void mpeg3demux_shift_data(mpeg3_demuxer_t *demuxer,
2446         int bytes)
2447 {
2448         int i, j;
2449         for(i = 0, j = bytes; j < demuxer->data_size; i++, j++)
2450         {
2451                 demuxer->data_buffer[i] = demuxer->data_buffer[j];
2452         }
2453         demuxer->data_size -= bytes;
2454         demuxer->data_position -= bytes;
2455 }
2456
2457
2458
2459
2460
2461