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