1 #include "mpeg3private.h"
2 #include "mpeg3protos.h"
3
4 #include <math.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8
9
10 static pthread_mutex_t *decode_lock = 0;
11
12
toc_error()13 static void toc_error()
14 {
15 fprintf(stderr,
16 "mpeg3audio: sample accurate seeking without a table of contents \n"
17 "is no longer supported. Use mpeg3toc <mpeg file> <table of contents>\n"
18 "to generate a table of contents and load the table of contents instead.\n");
19 }
20
21
rewind_audio(mpeg3audio_t * audio)22 static int rewind_audio(mpeg3audio_t *audio)
23 {
24 mpeg3_atrack_t *track = audio->track;
25 if(track->sample_offsets)
26 mpeg3demux_seek_byte(track->demuxer, track->sample_offsets[0]);
27 else
28 mpeg3demux_seek_byte(track->demuxer, 0);
29 return 0;
30 }
31
32 /* Advance to next header and read it. */
read_header(mpeg3audio_t * audio)33 static int read_header(mpeg3audio_t *audio)
34 {
35 int i;
36 int try = 0;
37 int got_it = 0;
38 int result = 0;
39 mpeg3_atrack_t *track = audio->track;
40 mpeg3_t *file = audio->file;
41
42 switch(track->format)
43 {
44 case AUDIO_AC3:
45 //printf("read_header %d audio->packet_position=%d\n", __LINE__, audio->packet_position);
46 #if 1
47 audio->packet_position = 8;
48 result = mpeg3demux_read_data(track->demuxer,
49 audio->packet_buffer + 1,
50 7);
51
52
53 do
54 {
55 try++;
56 for(i = 0; i < 7; i++)
57 audio->packet_buffer[i] = audio->packet_buffer[i + 1];
58
59 if(!result)
60 {
61 audio->packet_buffer[7] =
62 mpeg3demux_read_char(track->demuxer);
63 result = mpeg3demux_eof(track->demuxer);
64 }
65 //printf("read_header 10 %d\n", mpeg3demux_eof(track->demuxer));
66
67 if(!result)
68 {
69 got_it = (mpeg3_ac3_header(audio->ac3_decoder,
70 audio->packet_buffer) != 0);
71 }
72 else
73 break;
74
75 /*
76 * printf("read_header 100 offset=%llx got_it=%d\n",
77 * mpeg3demux_tell_byte(track->demuxer),
78 * got_it);
79 */
80 }while(!result && !got_it && try < 0x10000);
81
82
83 if(!result)
84 {
85 if(audio->ac3_decoder->channels > track->channels)
86 track->channels = audio->ac3_decoder->channels;
87 track->sample_rate = audio->ac3_decoder->samplerate;
88 audio->framesize = audio->ac3_decoder->framesize;
89 if(track->sample_rate <= 0) track->sample_rate = 48000;
90 //printf("read_header %d %d %d\n", track->channels, track->sample_rate, audio->framesize);
91 }
92 if(track->sample_rate <= 0) track->sample_rate = 48000;
93 #endif
94
95 #if 0
96 // Load starting bytes + 1 for the first shift
97 if(audio->packet_position < 9)
98 {
99 result = mpeg3demux_read_data(track->demuxer,
100 audio->packet_buffer + 1,
101 8);
102 audio->packet_position = 9;
103 }
104
105
106 do
107 {
108 try++;
109
110 // Shift out byte
111 for(i = 0; i < 7; i++)
112 audio->packet_buffer[i] = audio->packet_buffer[i + 1];
113 audio->packet_position--;
114
115 if(!result && audio->packet_position < 8)
116 {
117 audio->packet_buffer[7] =
118 mpeg3demux_read_char(track->demuxer);
119 result = mpeg3demux_eof(track->demuxer);
120 audio->packet_position = 8;
121 }
122
123 if(!result)
124 {
125 got_it = (mpeg3_ac3_header(audio->ac3_decoder,
126 audio->packet_buffer) != 0);
127 }
128 else
129 break;
130
131 /*
132 * printf("read_header 100 offset=%llx got_it=%d\n",
133 * mpeg3demux_tell_byte(track->demuxer),
134 * got_it);
135 */
136 }while(!result && !got_it && try < 0x10000);
137
138
139 if(!result)
140 {
141 if(audio->ac3_decoder->channels > track->channels)
142 track->channels = audio->ac3_decoder->channels;
143 track->sample_rate = audio->ac3_decoder->samplerate;
144 audio->framesize = audio->ac3_decoder->framesize;
145 if(track->sample_rate <= 0) track->sample_rate = 48000;
146 //printf("read_header %d %d %d\n", track->channels, track->sample_rate, audio->framesize);
147 }
148 if(track->sample_rate <= 0) track->sample_rate = 48000;
149 #endif
150
151 break;
152
153
154
155 case AUDIO_MPEG:
156 /* Layer 1 not supported */
157 if(audio->layer_decoder->layer == 1)
158 {
159 result = 1;
160 }
161
162 // Load starting bytes + 1 for the first shift
163 if(audio->packet_position == 0)
164 {
165 result = mpeg3demux_read_data(track->demuxer,
166 audio->packet_buffer + 1,
167 4);
168 audio->packet_position = 5;
169 }
170
171 do
172 {
173 try++;
174
175 // Shift packet out 1 byte
176 for(i = 0; i < audio->packet_position - 1; i++)
177 {
178 audio->packet_buffer[i] = audio->packet_buffer[i + 1];
179 }
180 audio->packet_position--;
181
182 //printf("%c", audio->packet_buffer[0]);
183 // Abort if end of data buffer & mpeg3audio_decode is required for more data.
184 if(!file->seekable &&
185 audio->packet_position < 4 &&
186 track->demuxer->data_position >= track->demuxer->data_size)
187 result = 1;
188 //printf("read_header %d data_position=%d data_size=%d\n",
189 //__LINE__, track->demuxer->data_position, track->demuxer->data_size);
190
191 // Read new byte
192 if(!result && audio->packet_position < 4)
193 {
194 audio->packet_buffer[audio->packet_position] =
195 mpeg3demux_read_char(track->demuxer);
196 audio->packet_position++;
197 result = mpeg3demux_eof(track->demuxer);
198 }
199
200
201 // if(!result)
202 {
203 // printf("read_header %d got_it=%d packet=%02x%02x%02x%02x\n",
204 // __LINE__,
205 // got_it,
206 // (unsigned char)audio->packet_buffer[0],
207 // (unsigned char)audio->packet_buffer[1],
208 // (unsigned char)audio->packet_buffer[2],
209 // (unsigned char)audio->packet_buffer[3]);
210 got_it = (mpeg3_layer_header(audio->layer_decoder,
211 audio->packet_buffer) != 0);
212
213
214 }
215
216 // ID3 tags need the try counts to skip the tags
217 if(!got_it && audio->layer_decoder->id3_state != MPEG3_ID3_IDLE)
218 try = 0;
219 }while(!result && !got_it && try < 0x10000);
220
221 if(!result)
222 {
223 if(audio->layer_decoder->channels > track->channels)
224 track->channels = audio->layer_decoder->channels;
225 track->sample_rate = audio->layer_decoder->samplerate;
226 audio->framesize = audio->layer_decoder->framesize;
227 }
228 break;
229
230 case AUDIO_PCM:
231 // Load starting bytes + 1 for the first shift
232 if(audio->packet_position < PCM_HEADERSIZE)
233 {
234 result = mpeg3demux_read_data(track->demuxer,
235 audio->packet_buffer + 1,
236 PCM_HEADERSIZE);
237 audio->packet_position = PCM_HEADERSIZE + 1;
238 }
239
240 do
241 {
242 try++;
243
244 for(i = 0; i < PCM_HEADERSIZE - 1; i++)
245 audio->packet_buffer[i] = audio->packet_buffer[i + 1];
246 audio->packet_position--;
247
248 if(!result && audio->packet_position < PCM_HEADERSIZE)
249 {
250 audio->packet_buffer[PCM_HEADERSIZE - 1] =
251 mpeg3demux_read_char(track->demuxer);
252 result = mpeg3demux_eof(track->demuxer);
253 audio->packet_position = PCM_HEADERSIZE;
254 }
255
256 if(!result)
257 {
258 got_it = (mpeg3_pcm_header(audio->pcm_decoder,
259 audio->packet_buffer) != 0);
260 }
261 }while(!result && !got_it && try < 0x10000);
262
263 if(!result)
264 {
265 if(audio->pcm_decoder->channels > track->channels)
266 track->channels = audio->pcm_decoder->channels;
267 track->sample_rate = audio->pcm_decoder->samplerate;
268 audio->framesize = audio->pcm_decoder->framesize;
269 }
270 break;
271 }
272 return result;
273 }
274
275
delete_struct(mpeg3audio_t * audio)276 static int delete_struct(mpeg3audio_t *audio)
277 {
278 int i;
279 mpeg3_atrack_t *track = audio->track;
280
281 if(audio->output)
282 {
283 for(i = 0; i < track->channels; i++)
284 free(audio->output[i]);
285 free(audio->output);
286 }
287 if(audio->ac3_decoder) mpeg3_delete_ac3(audio->ac3_decoder);
288 if(audio->layer_decoder) mpeg3_delete_layer(audio->layer_decoder);
289 if(audio->pcm_decoder) mpeg3_delete_pcm(audio->pcm_decoder);
290 free(audio);
291 return 0;
292 }
293
294
295
296
297
read_frame(mpeg3audio_t * audio,int render)298 static int read_frame(mpeg3audio_t *audio, int render)
299 {
300 int result = 0;
301 mpeg3_atrack_t *track = audio->track;
302 mpeg3_t *file = audio->file;
303 float **temp_output = 0;
304 int samples = 0;
305 int i;
306 int old_channels = track->channels;
307
308 // Liba52 is not reentrant
309 if(track->format == AUDIO_AC3)
310 {
311 pthread_mutex_lock(decode_lock);
312 }
313
314 /* Find and read next header */
315 result = read_header(audio);
316
317
318 /* Read rest of frame */
319 if(!result)
320 {
321 result = mpeg3demux_read_data(track->demuxer,
322 audio->packet_buffer + audio->packet_position,
323 audio->framesize - audio->packet_position);
324 }
325
326 /* Handle increase in channel count, for ATSC */
327 if(old_channels < track->channels)
328 {
329 float **new_output = calloc(sizeof(float*), track->channels);
330 for(i = 0; i < track->channels; i++)
331 {
332 new_output[i] = calloc(sizeof(float), audio->output_allocated);
333 if(i < old_channels)
334 memcpy(new_output[i],
335 audio->output[i],
336 sizeof(float) * audio->output_size);
337 }
338 for(i = 0; i < old_channels; i++)
339 free(audio->output[i]);
340 free(audio->output);
341 audio->output = new_output;
342 }
343
344
345
346 if(render)
347 {
348 temp_output = malloc(sizeof(float*) * track->channels);
349 for(i = 0; i < track->channels; i++)
350 {
351 temp_output[i] = audio->output[i] + audio->output_size;
352 }
353 }
354
355
356 if(!result)
357 {
358 switch(track->format)
359 {
360 case AUDIO_AC3:
361 samples = mpeg3audio_doac3(audio->ac3_decoder,
362 audio->packet_buffer,
363 audio->framesize,
364 temp_output,
365 render);
366 //printf("read_frame %d\n", samples);
367 break;
368
369 case AUDIO_MPEG:
370 switch(audio->layer_decoder->layer)
371 {
372 case 2:
373 samples = mpeg3audio_dolayer2(audio->layer_decoder,
374 audio->packet_buffer,
375 audio->framesize,
376 temp_output,
377 render);
378
379 break;
380
381 case 3:
382 samples = mpeg3audio_dolayer3(audio->layer_decoder,
383 audio->packet_buffer,
384 audio->framesize,
385 temp_output,
386 render);
387 break;
388
389 default:
390 result = 1;
391 break;
392 }
393 break;
394
395 case AUDIO_PCM:
396 samples = mpeg3audio_dopcm(audio->pcm_decoder,
397 audio->packet_buffer,
398 audio->framesize,
399 temp_output,
400 render);
401 break;
402 }
403 }
404
405
406 audio->output_size += samples;
407 if(render)
408 {
409 free(temp_output);
410 }
411
412 // Liba52 is not reentrant
413 if(track->format == AUDIO_AC3)
414 {
415 pthread_mutex_unlock(decode_lock);
416 }
417
418
419 // Shift demuxer data
420 if(!file->seekable)
421 mpeg3demux_shift_data(track->demuxer, track->demuxer->data_position);
422
423 return samples;
424 }
425
426
427
428
429
430
431 /* Get the length. */
432 /* Use chunksize if demuxer has a table of contents */
433 /* For elementary streams use sample count over a certain number of
434 bytes to guess total samples */
435 /* For program streams use timecode */
get_length(mpeg3audio_t * audio)436 static int get_length(mpeg3audio_t *audio)
437 {
438 int result = 0;
439 mpeg3_t *file = audio->file;
440 mpeg3_atrack_t *track = audio->track;
441 int samples = 0;
442
443 // Table of contents
444 if(track->sample_offsets)
445 {
446 int try = 0;
447
448 /* Get stream parameters for header validation */
449 while(samples == 0)
450 {
451 samples = read_frame(audio, 0);
452 }
453
454 result = track->total_samples;
455 }
456 else
457 // Estimate using multiplexed stream size in seconds
458 if(!file->is_audio_stream)
459 {
460 /* Get stream parameters for header validation */
461 /* Need a table of contents */
462 while(samples == 0)
463 {
464 samples = read_frame(audio, 0);
465 }
466
467 // result = (long)(mpeg3demux_length(track->demuxer) *
468 // track->sample_rate);
469 result = 0;
470 }
471 else
472 // Estimate using average bitrate
473 {
474 long test_bytes = 0;
475 long max_bytes = 0x40000;
476 long test_samples = 0;
477 int error = 0;
478 int64_t total_bytes = mpeg3demux_movie_size(track->demuxer);
479
480 while(!error && test_bytes < max_bytes)
481 {
482 int samples = read_frame(audio, 0);
483 if(!samples) error = 1;
484 test_samples += samples;
485 test_bytes += audio->framesize;
486 }
487 result = (long)(((double)total_bytes / test_bytes) * test_samples + 0.5);
488 }
489
490 audio->output_size = 0;
491 rewind_audio(audio);
492
493 return result;
494 }
495
496
497
498
499
calculate_format(mpeg3_t * file,mpeg3_atrack_t * track)500 int calculate_format(mpeg3_t *file, mpeg3_atrack_t *track)
501 {
502 int result = 0;
503 mpeg3audio_t *audio = track->audio;
504
505 /* Determine the format of the stream. */
506 /* If it isn't in the first 8 bytes give up and go to a movie. */
507 if(track->format == AUDIO_UNKNOWN)
508 {
509 unsigned char header[8];
510 // Need these 8 bytes later on for header parsing
511 if(!mpeg3demux_read_data(track->demuxer,
512 header,
513 8))
514 {
515 //printf("calculate_format %lld\n", mpeg3demux_tell_byte(track->demuxer));
516 if(!mpeg3_ac3_check(header))
517 track->format = AUDIO_AC3;
518 else
519 track->format = AUDIO_MPEG;
520 }
521 else
522 result = 1;
523
524 if(audio)
525 {
526
527 memcpy(audio->packet_buffer + 1, header, 8);
528 audio->packet_position = 9;
529 }
530 }
531
532 return result;
533 }
534
535
536
537
538
mpeg3audio_new(mpeg3_t * file,mpeg3_atrack_t * track,int format)539 mpeg3audio_t* mpeg3audio_new(mpeg3_t *file,
540 mpeg3_atrack_t *track,
541 int format)
542 {
543 mpeg3audio_t *audio = calloc(1, sizeof(mpeg3audio_t));
544 mpeg3_demuxer_t *demuxer = track->demuxer;
545 int result = 0;
546 int i;
547
548 if(!decode_lock)
549 {
550 pthread_mutexattr_t attr;
551 pthread_mutexattr_init(&attr);
552 decode_lock = calloc(1, sizeof(pthread_mutex_t));
553 pthread_mutex_init(decode_lock, &attr);
554 }
555
556 audio->file = file;
557 audio->track = track;
558
559 audio->byte_seek = -1;
560 audio->sample_seek = -1;
561 track->format = format;
562
563 if(file->seekable)
564 if(calculate_format(file, track)) result = 1;
565
566 //printf("mpeg3audio_new %lld\n", mpeg3demux_tell_byte(track->demuxer));
567 /* get stream parameters */
568 if(!result && file->seekable)
569 {
570 switch(track->format)
571 {
572 case AUDIO_AC3:
573 audio->ac3_decoder = mpeg3_new_ac3();
574 break;
575 case AUDIO_MPEG:
576 audio->layer_decoder = mpeg3_new_layer();
577 break;
578 case AUDIO_PCM:
579 audio->pcm_decoder = mpeg3_new_pcm();
580 break;
581 }
582
583
584
585 rewind_audio(audio);
586
587
588
589
590 result = read_header(audio);
591 if(file->is_audio_stream)
592 audio->start_byte = mpeg3demux_tell_byte(demuxer) -
593 file->packet_size;
594 // printf("mpeg3audio_new 1 %d %d %d start_byte=0x%llx\n",
595 // track->format,
596 // audio->layer_decoder->layer,
597 // result,
598 // audio->start_byte);
599 }
600
601
602 /* Set up the output buffer */
603 if(!result && file->seekable)
604 {
605 audio->output = calloc(sizeof(float*), track->channels);
606 audio->output_allocated = 4;
607 for(i = 0; i < track->channels; i++)
608 {
609 audio->output[i] = calloc(sizeof(float), audio->output_allocated);
610 }
611 }
612
613
614 /* Calculate Length */
615 if(!result && file->seekable)
616 {
617 rewind_audio(audio);
618 track->total_samples = get_length(audio);
619 }
620 else
621 if(file->seekable)
622 {
623 delete_struct(audio);
624 audio = 0;
625 }
626
627
628
629
630
631
632
633
634
635 return audio;
636 }
637
638
639
640
641
642
643
seek(mpeg3audio_t * audio)644 static int seek(mpeg3audio_t *audio)
645 {
646 int result = 0;
647 mpeg3_t *file = audio->file;
648 mpeg3_atrack_t *track = audio->track;
649 mpeg3_demuxer_t *demuxer = track->demuxer;
650 int seeked = 0;
651
652 /* Stream is unseekable */
653 if(!file->seekable) return 0;
654
655 /* Sample seek was requested */
656 if(audio->sample_seek >= 0)
657 {
658
659 /* Doesn't work with VBR streams + ID3 tags */
660 /*
661 * printf("seek %d %d %d %d %d\n",
662 * __LINE__,
663 * audio->sample_seek,
664 * track->current_position,
665 * audio->output_position,
666 * audio->output_position + audio->output_size);
667 */
668
669
670 /* Don't do anything if the destination is inside the sample buffer */
671 if(audio->sample_seek >= audio->output_position &&
672 audio->sample_seek <= audio->output_position + audio->output_size)
673 {
674 ;
675 }
676 else
677 /* Use table of contents */
678 if(track->sample_offsets)
679 {
680 int index;
681 int64_t byte;
682
683 index = audio->sample_seek / MPEG3_AUDIO_CHUNKSIZE;
684 if(index >= track->total_sample_offsets) index = track->total_sample_offsets - 1;
685 byte = track->sample_offsets[index];
686
687 mpeg3demux_seek_byte(demuxer, byte);
688
689 audio->output_position = index * MPEG3_AUDIO_CHUNKSIZE;
690 audio->output_size = 0;
691 seeked = 1;
692 }
693 else
694 if(!file->is_audio_stream)
695 /* Use demuxer */
696 {
697 toc_error();
698 /*
699 * double time_position = (double)audio->sample_seek / track->sample_rate;
700 * result |= mpeg3demux_seek_time(demuxer, time_position);
701 */
702 audio->output_position = audio->sample_seek;
703 audio->output_size = 0;
704 seeked = 1;
705 }
706 else
707 /* Use bitrate for elementary stream */
708 {
709 int64_t total_bytes = mpeg3demux_movie_size(demuxer) -
710 audio->start_byte;
711 int64_t byte = (int64_t)((double)audio->sample_seek /
712 track->total_samples *
713 total_bytes +
714 audio->start_byte);
715 //printf("seek %d byte=%lld\n", __LINE__, byte);
716
717 mpeg3demux_seek_byte(demuxer, byte);
718 audio->output_position = audio->sample_seek;
719 audio->output_size = 0;
720 seeked = 1;
721 }
722 }
723 else
724 /* Percentage seek was requested */
725 if(audio->byte_seek >= 0)
726 {
727 mpeg3demux_seek_byte(demuxer, audio->byte_seek);
728
729 // Scan for pts if we're the first to seek.
730 /*
731 * if(file->percentage_pts < 0)
732 * {
733 * file->percentage_pts = mpeg3demux_scan_pts(demuxer);
734 * }
735 * else
736 * {
737 * mpeg3demux_goto_pts(demuxer, file->percentage_pts);
738 * }
739 */
740
741 audio->output_position = 0;
742 audio->output_size = 0;
743 seeked = 1;
744 }
745
746 if(seeked)
747 {
748 mpeg3demux_reset_pts(demuxer);
749 switch(track->format)
750 {
751 case AUDIO_MPEG:
752 mpeg3_layer_reset(audio->layer_decoder);
753 break;
754 }
755 }
756 audio->sample_seek = -1;
757 audio->byte_seek = -1;
758
759 return 0;
760 }
761
762
763
764
765
766
767
768
769
770
771 /* ================================================================ */
772 /* ENTRY POINTS */
773 /* ================================================================ */
774
775
776
mpeg3audio_delete(mpeg3audio_t * audio)777 int mpeg3audio_delete(mpeg3audio_t *audio)
778 {
779 delete_struct(audio);
780 return 0;
781 }
782
mpeg3audio_seek_byte(mpeg3audio_t * audio,int64_t byte)783 int mpeg3audio_seek_byte(mpeg3audio_t *audio, int64_t byte)
784 {
785 audio->byte_seek = byte;
786 return 0;
787 }
788
mpeg3audio_seek_sample(mpeg3audio_t * audio,long sample)789 int mpeg3audio_seek_sample(mpeg3audio_t *audio, long sample)
790 {
791 mpeg3_atrack_t *track = audio->track;
792 // Doesn't work for rereading audio during percentage seeking
793 // if(sample > track->total_samples) sample = track->total_samples;
794 if(sample < 0) sample = 0;
795 audio->sample_seek = sample;
796 return 0;
797 }
798
799 /* Read raw frames for the mpeg3cat utility */
mpeg3audio_read_raw(mpeg3audio_t * audio,unsigned char * output,long * size,long max_size)800 int mpeg3audio_read_raw(mpeg3audio_t *audio,
801 unsigned char *output,
802 long *size,
803 long max_size)
804 {
805 int result = 0;
806 int i;
807 mpeg3_atrack_t *track = audio->track;
808 *size = 0;
809
810
811 switch(track->format)
812 {
813 case AUDIO_AC3:
814 /* Just write the AC3 stream */
815 result = mpeg3demux_read_data(track->demuxer,
816 output,
817 0x800);
818 *size = 0x800;
819 break;
820
821 case AUDIO_MPEG:
822 /* Fix the mpeg stream */
823 if(!result)
824 {
825 if(mpeg3demux_read_data(track->demuxer,
826 output,
827 0x800))
828 return 1;
829
830 *size += 0x800;
831 }
832 break;
833
834 case AUDIO_PCM:
835 // This is required to strip the headers
836 if(mpeg3demux_read_data(track->demuxer,
837 output,
838 audio->framesize))
839 return 1;
840 *size = audio->framesize;
841 break;
842 }
843 return result;
844
845
846
847
848 #if 0
849 // This probably doesn't work.
850 result = read_header(audio);
851 switch(track->format)
852 {
853 case AUDIO_AC3:
854 /* Just write the AC3 stream */
855 result = mpeg3demux_read_data(track->demuxer,
856 output,
857 audio->framesize);
858 *size = audio->framesize;
859 //printf("mpeg3audio_read_raw 1 %d\n", audio->framesize);
860 break;
861
862 case AUDIO_MPEG:
863 /* Fix the mpeg stream */
864 if(!result)
865 {
866 if(mpeg3demux_read_data(track->demuxer,
867 output,
868 audio->framesize))
869 return 1;
870
871 *size += audio->framesize;
872 }
873 break;
874
875 case AUDIO_PCM:
876 if(mpeg3demux_read_data(track->demuxer,
877 output,
878 audio->framesize))
879 return 1;
880 *size = audio->framesize;
881 break;
882 }
883 return result;
884 #endif
885
886 }
887
mpeg3_shift_audio(mpeg3audio_t * audio,int diff)888 void mpeg3_shift_audio(mpeg3audio_t *audio, int diff)
889 {
890 int i, j, k;
891 mpeg3_atrack_t *track = audio->track;
892
893 for(k = 0; k < track->channels; k++)
894 {
895 for(i = 0, j = diff; j < audio->output_size; i++, j++)
896 {
897 audio->output[k][i] = audio->output[k][j];
898 }
899 }
900 audio->output_size -= diff;
901 audio->output_position += diff;
902 }
903
904
905
906 /* Channel is 0 to channels - 1 */
mpeg3audio_decode_audio(mpeg3audio_t * audio,float * output_f,short * output_i,int channel,int len)907 int mpeg3audio_decode_audio(mpeg3audio_t *audio,
908 float *output_f,
909 short *output_i,
910 int channel,
911 int len)
912 {
913 mpeg3_t *file = audio->file;
914 mpeg3_atrack_t *track = audio->track;
915 int i, j, k;
916 int try = 0;
917 /* Always render since now the TOC contains index files. */
918 int render = 1;
919 long new_size;
920
921
922 /* Minimum amount of data must be present for streaming mode */
923 if(!file->seekable &&
924 track->demuxer->data_size < MPEG3_AUDIO_STREAM_SIZE) return 1;
925
926
927 /* Get header for streaming mode */
928 if(track->format == AUDIO_UNKNOWN)
929 if(calculate_format(file, track)) return 1;
930
931 if(track->format == AUDIO_AC3 && !audio->ac3_decoder)
932 audio->ac3_decoder = mpeg3_new_ac3();
933 else
934 if(track->format == AUDIO_MPEG && !audio->layer_decoder)
935 audio->layer_decoder = mpeg3_new_layer();
936 else
937 if(track->format == AUDIO_PCM && !audio->pcm_decoder)
938 audio->pcm_decoder = mpeg3_new_pcm();
939
940
941
942 /* Handle seeking requests */
943 seek(audio);
944
945 new_size = track->current_position +
946 len +
947 MAXFRAMESAMPLES -
948 audio->output_position;
949
950 /* Expand output until enough room exists for new data */
951 if(new_size > audio->output_allocated)
952 {
953
954 for(i = 0; i < track->channels; i++)
955 {
956 float *new_output;
957 new_output = calloc(sizeof(float), new_size);
958 memcpy(new_output, audio->output[i], sizeof(float) * audio->output_size);
959 free(audio->output[i]);
960 audio->output[i] = new_output;
961 }
962 audio->output_allocated = new_size;
963 }
964
965
966
967
968 /* Decode frames until the output is ready */
969 while(1)
970 {
971 if(audio->output_position + audio->output_size >=
972 track->current_position + len ||
973 try >= 256 ||
974 mpeg3demux_eof(track->demuxer)) break;
975
976
977
978 if(!file->seekable &&
979 track->demuxer->data_size <
980 MPEG3_AUDIO_STREAM_SIZE) break;
981
982 int samples = read_frame(audio, render);
983
984 if(!samples)
985 try++;
986 else
987 try = 0;
988 }
989
990
991 /* Copy the buffer to the output */
992 if(channel >= track->channels) channel = track->channels - 1;
993
994 if(output_f)
995 {
996 for(i = 0, j = track->current_position - audio->output_position;
997 i < len && j < audio->output_size;
998 i++, j++)
999 {
1000 output_f[i] = audio->output[channel][j];
1001 }
1002 for( ; i < len; i++)
1003 {
1004 output_f[i] = 0;
1005 }
1006 }
1007 else
1008 if(output_i)
1009 {
1010 int sample;
1011 for(i = 0, j = track->current_position - audio->output_position;
1012 i < len && j < audio->output_size;
1013 i++, j++)
1014 {
1015 sample = (int)(audio->output[channel][j] * 32767);
1016 if(sample > 32767) sample = 32767;
1017 else
1018 if(sample < -32768) sample = -32768;
1019
1020 output_i[i] = sample;
1021 }
1022 for( ; i < len; i++)
1023 {
1024 output_i[i] = 0;
1025 }
1026 }
1027
1028
1029
1030 /* Shift audio back */
1031 if(audio->output_size > MPEG3_AUDIO_HISTORY)
1032 {
1033 int diff = audio->output_size - MPEG3_AUDIO_HISTORY;
1034 mpeg3_shift_audio(audio, diff);
1035 }
1036 //printf("mpeg3audio_decode_audio %d %d\n", __LINE__, audio->output_size);
1037
1038
1039 if(audio->output_size > 0)
1040 return 0;
1041 else
1042 return 1;
1043 }
1044
1045
1046
1047
1048
1049
1050