cinelerra-5.1/libzmpeg3/audio/audio.C

   1 #include "../libzmpeg3.h"
   2
   3 static class audio_decode_t {
   4   pthread_mutex_t zlock;
   5 public:
   6   audio_decode_t() {
   7     pthread_mutexattr_t attr;
   8     pthread_mutexattr_init(&attr);
   9     pthread_mutex_init(&zlock, &attr);
  10   }
  11   ~audio_decode_t() {
  12     pthread_mutex_destroy(&zlock);
  13   }
  14   void lock() { pthread_mutex_lock(&zlock); }
  15   void unlock() { pthread_mutex_unlock(&zlock); }
  16 } audio_decode;
  17
  18 static void toc_error()
  19 {
  20   zerr( "mpeg3audio: sample accurate seeking without a table of contents \n"
  21     "is no longer supported.  Use mpeg3toc <mpeg file> <table of contents>\n"
  22     "to generate a table of contents and load the table of contents instead.\n");
  23 }
  24
  25
  26 int zaudio_t::
  27 rewind_audio()
  28 {
  29   if( track->sample_offsets )
  30     track->demuxer->seek_byte(track->sample_offsets[0]);
  31   else
  32     track->demuxer->seek_byte(0);
  33   track->reset_pts();
  34   packet_position = 0;
  35   return 0;
  36 }
  37
  38 /* Advance to next header and read it. */
  39 int zaudio_t::
  40 read_header()
  41 {
  42   int count = 0x10000;
  43   int got_it = 0;
  44   int result = 1;
  45   int pos = 0;
  46
  47   switch(track->format) {
  48   case afmt_AC3:
  49     while( count > 0 && !track->demuxer->eof() ) {
  50       if( pos >= (int)sizeof(packet_buffer)-8 ) {
  51         memmove(packet_buffer, &packet_buffer[pos], packet_position-=pos);
  52         pos = 0;
  53       }
  54       if( packet_position-pos < 8 ) {
  55         packet_buffer[packet_position++] = track->demuxer->read_char();
  56         continue;
  57       }
  58       got_it = ac3_decoder->ac3_header(&packet_buffer[pos]);
  59       if( got_it ) break;
  60       ++pos;  --count;
  61     }
  62
  63     if( got_it ) {
  64       channels = ac3_decoder->channels;
  65       samplerate = ac3_decoder->samplerate;
  66       framesize = ac3_decoder->framesize;
  67       result = 0;
  68     }
  69     break;
  70
  71   case afmt_MPEG:
  72     /* Layer 1 not supported */
  73     if( layer_decoder->layer == 1 ) break;
  74
  75     /* Load starting bytes and check format when not seekable */
  76     if( !src->seekable && !packet_position && !track->total_sample_offsets ) {
  77       if( src->demuxer->payload_unit_start_indicator ) {
  78         if( track->demuxer->read_data(packet_buffer,packet_position=4) ) break;
  79         /* reject mp4 data */
  80         if( !zaudio_decoder_layer_t::id3_check(packet_buffer) &&
  81               zaudio_decoder_layer_t::layer_check(packet_buffer) ) {
  82           zerrs("bad mp3 header, pid=%04x, track ignored\n", track->pid);
  83           track->format = afmt_IGNORE;
  84           result = -1;
  85         }
  86       }
  87     }
  88
  89     while( count > 0 && !track->demuxer->eof() ) {
  90       if( pos >= (int)sizeof(packet_buffer)-4 ) {
  91         memmove(packet_buffer, &packet_buffer[pos], packet_position-=pos);
  92         pos = 0;
  93       }
  94       if( packet_position-pos < 4 ) {
  95         packet_buffer[packet_position++] = track->demuxer->read_char();
  96         continue;
  97       }
  98       got_it = layer_decoder->layer3_header(&packet_buffer[pos]);
  99       if( got_it ) break;
 100 //zmsgs("%d got_it=%d packet=%02x%02x%02x%02x\n", __LINE__,
 101 //  got_it, (uint8_t)packet_buffer[pos+0], (uint8_t)packet_buffer[pos+1],
 102 //  (uint8_t)packet_buffer[pos+2], (uint8_t)packet_buffer[pos+3]);
 103       ++pos;  --count;
 104       /* ID3 tags need to reset the count to skip the tags */
 105       if( layer_decoder->id3_state != id3_IDLE ) count = 0x10000;
 106     }
 107
 108     if( got_it ) {
 109       channels = layer_decoder->channels;
 110       samplerate = layer_decoder->samplerate;
 111       framesize = layer_decoder->framesize;
 112       result = 0;
 113     }
 114     break;
 115
 116   case afmt_PCM:
 117     while( count > 0 && !track->demuxer->eof() ) {
 118       if( pos >= (int)sizeof(packet_buffer)-PCM_HEADERSIZE ) {
 119         memmove(packet_buffer, &packet_buffer[pos], packet_position-=pos);
 120         pos = 0;
 121       }
 122       if( packet_position-pos < PCM_HEADERSIZE ) {
 123         packet_buffer[packet_position++] = track->demuxer->read_char();
 124         continue;
 125       }
 126       got_it = pcm_decoder->pcm_header(&packet_buffer[pos]);
 127       if( got_it ) break;
 128       ++pos;  --count;
 129     }
 130
 131     if( got_it ) {
 132       channels = pcm_decoder->channels;
 133       samplerate = pcm_decoder->samplerate;
 134       framesize = pcm_decoder->framesize;
 135       result = 0;
 136     }
 137     break;
 138
 139   default:
 140     result = -1;
 141     break;
 142   }
 143
 144   if( pos > 0 )
 145     memmove(packet_buffer, &packet_buffer[pos], packet_position-=pos);
 146
 147   if( track->demuxer->error() )
 148     result = 1;
 149   if( !result ) {
 150     if( channels > track->channels )
 151       track->channels = channels;
 152     track->sample_rate = samplerate;
 153   }
 154 //zmsgs("%d %d %d\n", track->channels, track->sample_rate, framesize);
 155
 156   return result;
 157 }
 158
 159 zaudio_t::
 160 ~audio_t()
 161 {
 162   if( output ) {
 163     for( int i=0; i<output_channels; ++i )
 164       delete [] output[i];
 165     delete [] output;
 166   }
 167   if( ac3_decoder ) delete ac3_decoder;
 168   if( layer_decoder ) delete layer_decoder;
 169   if( pcm_decoder ) delete pcm_decoder;
 170 }
 171
 172 void zaudio_t::
 173 update_channels()
 174 {
 175   int i;
 176   float **new_output = new float *[channels];
 177   if( output_channels < channels ) {
 178     for( i=0; i<output_channels; ++i )
 179       new_output[i] = output[i];
 180     while( i < channels ) // more channels
 181       new_output[i++] = new float[output_allocated];
 182   }
 183   else {
 184     for( i=0; i<channels; ++i )
 185       new_output[i] = output[i];
 186     while( i < output_channels ) // fewer channels
 187       delete [] output[i++];
 188   }
 189   delete [] output;
 190   output = new_output;
 191   output_channels = channels;
 192 }
 193
 194 int zaudio_t::
 195 read_frame(int render)
 196 {
 197   zdemuxer_t *demux = track->demuxer;
 198   int samples = -1;
 199
 200   /* Find and read next header */
 201   int result = read_header();
 202 //if( src->seekable ) {
 203 //  int64_t app_pos = track->apparent_position();
 204 //  int64_t aud_pos = audio_position();
 205 //  double atime = track->get_audio_time();
 206 //  int64_t pts_pos = atime * track->sample_rate + 0.5;
 207 //  zmsgs(" apr_pos %jd/%jd + %jd  %jd + %jd\n",
 208 //    app_pos, aud_pos, app_pos-aud_pos, pts_pos, pts_pos-aud_pos);
 209 //}
 210   if( !result ) {
 211     /* Handle changes in channel count, for ATSC */
 212     if( output_channels != channels )
 213       update_channels();
 214     /* try to read rest of frame */
 215     int len = framesize - packet_position;
 216     uint8_t *bfr = packet_buffer + packet_position;
 217     if( !src->seekable ) {
 218       int data_length = demux->zdata.length();
 219       if( data_length < len ) len = data_length;
 220     }
 221     if( !(result = demux->read_data(bfr, len)) )
 222       packet_position += len;
 223   }
 224
 225   if( !result && packet_position >= framesize ) {
 226     float *out[output_channels];
 227     for( int i=0; i<output_channels; ++i )
 228       out[i] = output[i] + output_size;
 229
 230     switch(track->format) {
 231     case afmt_AC3:
 232       audio_decode.lock(); /* Liba52 is not reentrant */
 233       samples = ac3_decoder->do_ac3(packet_buffer,framesize,out,render);
 234       audio_decode.unlock();
 235 //zmsgs("ac3 %d samples\n", samples);
 236       break;
 237     case afmt_MPEG:
 238       switch( layer_decoder->layer ) {
 239       case 2:
 240         samples = layer_decoder->do_layer2(packet_buffer,framesize,out,render);
 241         break;
 242       case 3:
 243         samples = layer_decoder->do_layer3(packet_buffer,framesize,out,render);
 244         break;
 245       }
 246       break;
 247     case afmt_PCM:
 248       samples = pcm_decoder->do_pcm(packet_buffer,framesize,out,render);
 249       break;
 250     }
 251     if( samples > 0 )
 252       output_size += samples;
 253     packet_position = 0;
 254   }
 255
 256   return samples;
 257 }
 258
 259 /* Get the length. */
 260 /* Use chunksize if demuxer has a table of contents */
 261 /* For elementary streams use sample count over a certain number of */
 262 /*  bytes to guess total samples */
 263 /* For program streams use timecode */
 264 int zaudio_t::
 265 get_length()
 266 {
 267   int result = 0;
 268   int samples = 0;
 269   int64_t stream_end = track->demuxer->stream_end;
 270   int64_t total_bytes = track->demuxer->movie_size();
 271   int64_t stream_max = total_bytes;
 272   if( stream_max > 0x1000000 ) stream_max = 0x1000000;
 273   track->demuxer->stream_end = stream_max;
 274   rewind_audio();
 275   /* Table of contents */
 276   if( track->sample_offsets || !src->is_audio_stream() ) {
 277     /* Estimate using multiplexed stream size in seconds */
 278     /* Get stream parameters for header validation */
 279     /* Need a table of contents */
 280     for( int retry=0; retry<100 && samples<=0; ++retry ) {
 281       samples = read_frame(0);
 282     }
 283     result = track->sample_offsets ? track->total_samples : 0;
 284     /* : (long)(track->demuxer->length() * track->sample_rate); */
 285   }
 286   else { /* Estimate using average bitrate */
 287     long test_bytes = 0;
 288     long max_bytes = 0x40000;
 289     long test_samples = 0;
 290     while( test_bytes < max_bytes ) {
 291       int samples = read_frame(0);
 292       if( samples <= 0 ) break;
 293       test_samples += samples;
 294       test_bytes += framesize;
 295     }
 296     result = (long)(((double)total_bytes / test_bytes) * test_samples + 0.5);
 297   }
 298
 299   track->demuxer->stream_end = stream_end;
 300   output_size = 0;
 301   rewind_audio();
 302   return result;
 303 }
 304
 305 int zatrack_t::
 306 calculate_format(zmpeg3_t *src)
 307 {
 308   uint8_t header[8];
 309   int result = 0;
 310   /* Determine the format of the stream.  */
 311   /* If it isn't in the first 8 bytes give up and go to a movie. */
 312   switch( format ) {
 313   case afmt_UNKNOWN:
 314     /* Need these 8 bytes later on for header parsing */
 315     result = demuxer->read_data(header, sizeof(header));
 316 //zmsgs("%jd\n", demuxer->tell_byte());
 317     if( !result )
 318       format = !zaudio_decoder_ac3_t::ac3_check(header) ? afmt_AC3 : afmt_MPEG;
 319     if( audio ) {
 320       memcpy(audio->packet_buffer+1, header, sizeof(header));
 321       audio->packet_position = 9;
 322     }
 323     break;
 324   case afmt_IGNORE:
 325     result = 1;
 326     break;
 327   default:
 328     break;
 329   }
 330
 331   return result;
 332 }
 333
 334 int zaudio_t::
 335 init_audio(zmpeg3_t *zsrc, zatrack_t *ztrack, int zformat)
 336 {
 337   int result = 0;
 338   src = zsrc;
 339   track = ztrack;
 340   demuxer_t *demux = track->demuxer;
 341   byte_seek = -1;
 342   sample_seek = -1;
 343   track->format = zformat;
 344
 345   if( zsrc->seekable )
 346     result = track->calculate_format(src);
 347 //zmsgs("%jd\n", demux->tell_byte());
 348   /* get stream parameters */
 349   if( !result && zsrc->seekable ) {
 350     switch( track->format ) {
 351     case afmt_AC3:
 352       ac3_decoder = new audio_decoder_ac3_t();
 353       break;
 354     case afmt_MPEG:
 355       layer_decoder = new audio_decoder_layer_t();
 356       break;
 357     case afmt_PCM:
 358       pcm_decoder = new audio_decoder_pcm_t();
 359       break;
 360     default:
 361       result = 1;
 362     }
 363     if( !result ) {
 364       int64_t stream_end = demux->stream_end;
 365       //if( !track->sample_offsets )
 366       {
 367         if( zsrc->is_transport_stream() )
 368           demux->stream_end = START_BYTE + MAX_TS_PROBE;
 369         else if( src->is_program_stream() )
 370           demux->stream_end = START_BYTE + MAX_PGM_PROBE;
 371       }
 372       rewind_audio();
 373       result = read_header();
 374       if( !result && src->is_audio_stream() )
 375         start_byte = demux->tell_byte() - zsrc->packet_size;
 376       demux->stream_end = stream_end;
 377     }
 378 //zmsgs("1 %d %d %d start_byte=0x%jx\n", track->format,
 379 // layer_decoder->layer, result, start_byte);
 380   }
 381   return result;
 382 }
 383
 384 zaudio_t *zmpeg3_t::
 385 new_audio_t(zatrack_t *ztrack, int zformat)
 386 {
 387   audio_t *new_audio = new audio_t();
 388   int result = new_audio->init_audio(this,ztrack,zformat);
 389   /* Calculate Length */
 390   if( !result && seekable ) {
 391     new_audio->rewind_audio();
 392     ztrack->total_samples = new_audio->get_length();
 393   }
 394   else if( seekable ) {
 395     delete new_audio;
 396     new_audio = 0;
 397   }
 398   return new_audio;
 399 }
 400
 401
 402
 403 int zaudio_t::
 404 seek()
 405 {
 406   demuxer_t *demux = track->demuxer;
 407   int seeked = 0;
 408 /* Stream is unseekable */
 409   if( !src->seekable ) return 0;
 410 /* Sample seek was requested */
 411   if( sample_seek >= 0 ) {
 412     sample_seek += track->nudge;
 413     if( sample_seek < 0 ) sample_seek = 0;
 414 /* Doesn't work with VBR streams + ID3 tags */
 415 //zmsgs("%d %jd %jd %jd %jd\n", __LINE__, sample_seek,
 416 //  track->current_position, output_position, audio_position());
 417 /* Don't do anything if the destination is inside the sample buffer */
 418     if( sample_seek < output_position ||
 419         sample_seek >= audio_position() ) {
 420       if( sample_seek != output_position ) {
 421         /* Use table of contents */
 422         if( track->sample_offsets ) {
 423           int index = sample_seek / AUDIO_CHUNKSIZE;
 424           if( index >= track->total_sample_offsets )
 425             index = track->total_sample_offsets - 1;
 426           /* incase of padding */
 427           int64_t byte = track->sample_offsets[index];
 428           while( index > 0 && byte == track->sample_offsets[index-1] ) --index;
 429           output_position = (int64_t)index * AUDIO_CHUNKSIZE;
 430           output_size = 0;
 431           demux->seek_byte(byte);
 432         }
 433         else if( sample_seek > 0 && !src->is_audio_stream() ) { /* Use demuxer */
 434           toc_error();
 435 /*        double time_position = (double)sample_seek / track->sample_rate; */
 436 /*        result |= mpeg3demux_seek_time(demuxer, time_position); */
 437           output_position = sample_seek;
 438         }
 439         else { /* Use bitrate for elementary stream */
 440           int64_t total_bytes = demux->movie_size() - start_byte;
 441           int64_t byte = (int64_t)(total_bytes *
 442             ((double)sample_seek)/track->total_samples) + start_byte;
 443 //zmsgs("%d byte=%jd\n", __LINE__, byte);
 444           output_position = sample_seek;
 445           output_size = 0;
 446           demux->seek_byte(byte);
 447         }
 448         seeked = 1;
 449       }
 450     }
 451     sample_seek = -1;
 452   }
 453   else if( byte_seek >= 0 ) {
 454     output_position = 0;
 455     output_size = 0;
 456     /* Percentage seek was requested */
 457     demux->seek_byte(byte_seek);
 458     /* Scan for pts if we're the first to seek. */
 459     /* if( src->percentage_pts < 0 ) */
 460     /*   file->percentage_pts = demux->scan_pts(); */
 461     /* else */
 462     /*   demux->goto_pts(src->percentage_pts); */
 463     seeked = 1;
 464     byte_seek = -1;
 465   }
 466
 467   if( seeked ) {
 468     packet_position = 0;
 469     track->reset_pts();
 470     switch( track->format ) {
 471     case afmt_MPEG:
 472       layer_decoder->layer_reset();
 473       break;
 474     }
 475   }
 476
 477   return 0;
 478 }
 479
 480 /* ================================*/
 481 /*          ENTRY POINTS           */
 482 /* ================================*/
 483
 484 int zaudio_t::
 485 seek_byte(int64_t byte)
 486 {
 487   byte_seek = byte;
 488   return 0;
 489 }
 490
 491 int zaudio_t::
 492 seek_sample(long sample)
 493 {
 494 /* Doesn't work for rereading audio during percentage seeking */
 495 /*  if(sample > track->total_samples) sample = track->total_samples; */
 496   sample_seek = (int64_t)sample;
 497   return 0;
 498 }
 499
 500 /* Read raw frames for the mpeg3cat utility */
 501 int zaudio_t::
 502 read_raw(uint8_t *output, long *size, long max_size)
 503 {
 504   *size = 0;
 505   switch( track->format ) {
 506   case afmt_AC3: /* Just write the AC3 stream */
 507     if( track->demuxer->read_data(output, 0x800) ) return 1;
 508     *size = 0x800;
 509     break;
 510
 511   case afmt_MPEG: /* Fix the mpeg stream */
 512     if( track->demuxer->read_data(output, 0x800) ) return 1;
 513     *size = 0x800;
 514     break;
 515
 516   case afmt_PCM: /* This is required to strip the headers */
 517     if( track->demuxer->read_data(output, framesize) ) return 1;
 518     *size = framesize;
 519     break;
 520   }
 521
 522   return 0;
 523 #if 0
 524 /* This probably doesn't work. */
 525   result = read_header(audio);
 526   switch( track->format ) {
 527   case afmt_AC3: /* Just write the AC3 stream */
 528     result = track->demuxer->read_data(output, framesize);
 529     *size = framesize;
 530 //zmsgs("1 %d\n", framesize);
 531     break;
 532   case afmt_MPEG: /* Fix the mpeg stream */
 533     if( !result ) {
 534       if(track->demuxer->read_data(output, framesize)) return 1;
 535       *size += framesize;
 536     }
 537     break;
 538   case afmt_PCM:
 539     if(track->demuxer->read_data(output, framesize)) return 1;
 540     *size = framesize;
 541     break;
 542   }
 543   return result;
 544 #endif
 545 }
 546
 547 void zaudio_t::
 548 shift_audio(int64_t diff)
 549 {
 550   int len = diff > 0 ? output_size - diff : 0;
 551   if( len > 0 ) {
 552     for( int i=0; i<output_channels; ++i )
 553       memmove(output[i], output[i]+diff, len*sizeof(*output[i]));
 554     output_position += diff;
 555     output_size -= diff;
 556   }
 557   else {
 558     output_position += output_size;
 559     output_size = 0;
 560   }
 561 }
 562
 563 /* zero pad data to match pts */
 564 int zaudio_t::
 565 audio_pts_padding()
 566 {
 567   int result = 0, silence = 0;
 568   if( track->audio_time >= 0 && src->pts_padding > 0 ) {
 569     int64_t pts_pos = track->audio_time * track->sample_rate + 0.5;
 570     int padding = pts_pos - track->pts_position;
 571     if( padding > 0 ) {
 572       if( track->askip <= 0 ) {
 573         int limit = track->sample_rate/8;
 574         if( padding > limit ) {
 575           int64_t aud_pos = audio_position();
 576           zmsgs("audio start padding  pid %02x @ %12jd (%12.6f) %d samples\n",
 577                 track->pid, aud_pos, track->get_audio_time(), padding);
 578           track->askip = 1;
 579           result = 1;
 580         }
 581       }
 582       else if( padding > track->sample_rate )
 583         result = silence = 1;
 584       else if( !(++track->askip & 1) )
 585         result = 1;
 586       if( result ) {
 587         if( padding > AUDIO_MAX_DECODE ) padding = AUDIO_MAX_DECODE;
 588         int avail = output_allocated - output_size;
 589         if( padding > avail ) padding = avail;
 590         if( padding > 0 ) {
 591           int n = track->sample_rate/20;
 592           if( output_size < n ) silence = 1;
 593           if( silence ) {
 594             for( int chan=0; chan<output_channels; ++chan ) {
 595               float *out = output[chan] + output_size;
 596               for( int i=0; i<padding; ++i ) *out++ = 0;
 597             }
 598           }
 599           else {
 600             int k = output_size - n;
 601             for( int chan=0; chan<output_channels; ++chan ) {
 602               float *out = output[chan] + output_size;
 603               float *pad = output[chan] + k;
 604               for( int i=0; i<padding; ++i ) *out++ = *pad++;
 605             }
 606           }
 607           output_size += padding;
 608           track->pts_position += padding;
 609         }
 610       }
 611     }
 612     else if( track->askip > 0 ) {
 613       int64_t aud_pos = audio_position();
 614       zmsgs("audio end   padding  pid %02x @ %12jd (%12.6f) %d\n",
 615             track->pid, aud_pos, track->get_audio_time(), (1+track->askip)/2);
 616       track->askip = 0;
 617     }
 618   }
 619   return result;
 620 }
 621
 622 int zaudio_t::
 623 audio_pts_skipping(int samples)
 624 {
 625   int result = 0;
 626   if( track->audio_time >= 0 && src->pts_padding > 0 ) {
 627     int64_t pts_pos = track->audio_time * track->sample_rate + 0.5;
 628     int skipping = track->pts_position - pts_pos;
 629     if( skipping > 0 ) {
 630       if( track->askip >= 0 ) {
 631         int limit = track->sample_rate/8;
 632         if( skipping > 3*limit ) {
 633           int64_t aud_pos = audio_position();
 634           zmsgs("audio start skipping pid %02x @ %12jd (%12.6f) %d samples\n",
 635                 track->pid, aud_pos, track->get_audio_time(), skipping);
 636           track->askip = -1;
 637           result = 1;
 638         }
 639       }
 640       else if( !(--track->askip & 1) || skipping > track->sample_rate )
 641         result = 1;
 642       if( result ) {
 643         if( samples < skipping ) skipping = samples;
 644         if( output_size < skipping ) skipping = output_size;
 645         output_size -= skipping;
 646         track->pts_position -= skipping;
 647       }
 648     }
 649     else if( track->askip < 0 ) {
 650       int64_t aud_pos = audio_position();
 651       zmsgs("audio end   skipping pid %02x @ %12jd (%12.6f) %d\n",
 652             track->pid, aud_pos, track->get_audio_time(), (1-track->askip)/2);
 653       track->askip = 0;
 654     }
 655   }
 656   return result;
 657 }
 658
 659 void zaudio_t::
 660 update_audio_history()
 661 {
 662   int64_t diff = track->track_position() - output_position;
 663   if( diff ) shift_audio(diff);
 664 }
 665
 666 /* Channel is 0 to channels - 1 */
 667 /* Always render since now the TOC contains index files. */
 668 int zaudio_t::
 669 decode_audio(void *output_v, int atyp, int channel, int len)
 670 {
 671   int i, j, k;
 672   zdemuxer_t *demux = track->demuxer;
 673 //zmsgs("decode_audio(out_pos=%jd-%jd, aud_pos %jd, seek %jd  ch=%d, len=%d)\n",
 674 //  output_position, audio_position(), track->track_position(),
 675 //  (sample_seek<0 ? sample_seek : sample_seek+track->nudge), channel, len);
 676
 677   /* Get header for streaming mode */
 678   if( track->format == afmt_IGNORE ) return 1;
 679   if( track->format == afmt_UNKNOWN ) {
 680     if( track->calculate_format(src) ) return 1;
 681   }
 682   if( track->format == afmt_AC3 && !ac3_decoder )
 683     ac3_decoder = new audio_decoder_ac3_t();
 684   else if( track->format == afmt_MPEG && !layer_decoder )
 685     layer_decoder = new audio_decoder_layer_t();
 686   else if( track->format == afmt_PCM && !pcm_decoder )
 687     pcm_decoder = new audio_decoder_pcm_t();
 688   /* Handle seeking requests */
 689   seek();
 690   int64_t end_pos = track->track_position() + len;
 691   long new_size = end_pos - output_position + MAXFRAMESAMPLEZ;
 692   /* Expand output until enough room exists for new data */
 693   if( new_size > output_allocated ) {
 694     for( i=0; i<output_channels; ++i ) {
 695       float *old_output = output[i];
 696       float *new_output = new float[new_size];
 697       if( output_size ) {
 698         int len = output_size * sizeof(new_output[0]);
 699         memmove(new_output, old_output, len);
 700         len = (new_size-output_size) * sizeof(new_output[0]);
 701         memset(new_output+output_size, 0, len);
 702       }
 703       delete [] output[i];
 704       output[i] = new_output;
 705     }
 706     output_allocated = new_size;
 707   }
 708
 709
 710   /* Decode frames until the output is ready */
 711   int retry = 0;
 712
 713   while( retry < 256 ) {
 714     int64_t aud_pos = audio_position();
 715     int64_t demand = end_pos - aud_pos;
 716     if( demand <= 0 ) break;
 717     if( audio_pts_padding() ) continue;
 718     if( output_allocated-output_size < AUDIO_MAX_DECODE ) break;
 719 //zmsgs(" out_pos/sz %jd/%d=aud_pos %jd, end_pos %jd, demand %jd,
 720 //  tell/eof %jd/%d\n", output_position, output_size, aud_pos, end_pos,
 721 //  demand, demux->tell_byte(), demux->eof());
 722     if( demux->eof() ) break;
 723     int needed_history = len > AUDIO_HISTORY ? len : AUDIO_HISTORY;
 724     /* if overflowing, shift audio back */
 725     if( src->seekable && output_size > needed_history ) {
 726       int diff = demand + output_size - needed_history;
 727       shift_audio(diff);
 728     }
 729     int samples = read_frame(1);
 730     if( samples < 0 ) break;
 731     if( !samples ) { ++retry; continue; }
 732     retry = 0;
 733     if( audio_pts_skipping(samples) ) continue;
 734     track->update_frame_pts();
 735     track->update_audio_time();
 736   }
 737
 738   /* Copy the buffer to the output */
 739   if( !track->channels ) return 1;
 740   if( channel >= track->channels )
 741     channel = track->channels - 1;
 742   i = 0;
 743   j = track->track_position() - output_position;
 744   k = output_size - j;
 745   if( k > len ) k = len;
 746   float *out = j >= 0 && channel < output_channels ?
 747     output[channel] + j : 0;
 748
 749   /* transmit data in specified format */
 750   switch( atyp ) {
 751   case atyp_NONE:
 752     break;
 753   case atyp_DOUBLE: {
 754     double *output_d = (double *)output_v;
 755     if( out ) while( i < k )
 756       output_d[i++] = *out++;
 757     while( i < len ) output_d[i++] = 0.;
 758     break; }
 759   case atyp_FLOAT: {
 760     float *output_f = (float *)output_v;
 761     if( out )
 762       memmove(output_f,out,(i=k)*sizeof(output_f[0]));
 763     while( i < len ) output_f[i++] = 0.;
 764     break; }
 765   case atyp_INT: {
 766     int *output_i = (int *)output_v;
 767     if( out ) while( i < k )
 768       output_i[i++] = clip((int)(*out++ * 0x7fffff),-0x800000,0x7fffff);
 769     while( i < len ) output_i[i++] = 0;
 770     break; }
 771   case atyp_SHORT: {
 772     short *output_s = (short *)output_v;
 773     if( out ) while( i < k )
 774       output_s[i++] = clip((int)(*out++ * 0x7fff),-0x8000,0x7fff);
 775     while( i < len ) output_s[i++] = 0;
 776     break; }
 777   default:
 778     return 1;
 779   }
 780
 781 //zmsgs("output_size=%d chan=%d len=%d\n",output_size,channel,len);
 782   return output_size > 0 ? 0 : 1;
 783 }
 784