libmpeg3/audio/mpeg3audio.c

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