?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r996: add renderprofiles.C to POTFILES.in
[cinelerra_cv/mob.git] / libmpeg3 / mpeg3demux.c
bloba7ec1f88a19968dcc7730ed48d6249394018d822
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
mob repository