libs/mpega/wrap_mpega.c

   1 #include "wrap_mpega.h"
   2
   3 #include <proto/dos.h>
   4 #include <aros/asmcall.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <math.h>
   8
   9 #include "audio.h"
  10 #include "stream.h"
  11 #include "frame.h"
  12 #include "synth.h"
  13 #include "resample.h"
  14 #include "filter.h"
  15 #include "timer.h"
  16 #include "tag.h"
  17
  18 #define DEFAULT_BUFFER_SIZE 8192
  19
  20 typedef struct
  21 {
  22     BPTR fh;
  23     UBYTE *buffer;
  24     ULONG streamsize;
  25     ULONG streamskip;
  26     ULONG sampleskip;
  27
  28     MPEGA_CTRL *ctrl;
  29     MPEGA_ACCESS *access;
  30
  31     struct mad_stream stream;
  32     struct mad_frame frame;
  33     struct mad_synth synth;
  34
  35     struct tag tag;
  36     mad_timer_t timer;
  37
  38     struct audio_dither left_dither;
  39     struct audio_dither right_dither;
  40
  41     mad_fixed_t gain;
  42     mad_fixed_t replaygain;
  43
  44     struct resample_state resample[2];
  45     mad_fixed_t resampled[2][1152];
  46 } DecHandle;
  47
  48 #define CALLHOOK(hook, object, message, base)          \
  49     AROS_UFC4(IPTR, ((struct Hook *) hook)->h_Entry, \
  50         AROS_UFCA(struct Hook *, hook, A0),          \
  51     AROS_UFCA(APTR, object, A2),                 \
  52     AROS_UFCA(APTR, message, A1),                 \
  53     AROS_UFCA(APTR, base, A4))
  54
  55
  56 static __inline void SetStreamValues(MPEGA_STREAM *mpega_stream, struct mad_header *header)
  57 {
  58     switch (header->mode)
  59     {
  60         case MAD_MODE_SINGLE_CHANNEL:
  61             mpega_stream->mode = MPEGA_MODE_MONO;
  62             break;
  63
  64         case MAD_MODE_DUAL_CHANNEL:
  65             mpega_stream->mode = MPEGA_MODE_DUAL;
  66             break;
  67
  68         case MAD_MODE_JOINT_STEREO:
  69             mpega_stream->mode = MPEGA_MODE_J_STEREO;
  70             break;
  71
  72         case MAD_MODE_STEREO:
  73             mpega_stream->mode = MPEGA_MODE_STEREO;
  74             break;
  75
  76         default:
  77             mpega_stream->mode = -1;
  78             break;
  79     }
  80
  81     mpega_stream->norm = ((header->flags & MAD_FLAG_LSF_EXT) ? 2 : 1);
  82     mpega_stream->layer = header->layer;
  83     mpega_stream->bitrate = header->bitrate / 1000;
  84     mpega_stream->frequency = header->samplerate;
  85     mpega_stream->channels = ((header->mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2);
  86
  87     mpega_stream->private_bit = ((header->private_bits & MAD_PRIVATE_HEADER) ? 1 : 0);
  88     mpega_stream->copyright = ((header->flags & MAD_FLAG_COPYRIGHT) ? 1 : 0);
  89     mpega_stream->original = ((header->flags & MAD_FLAG_ORIGINAL) ? 1 : 0);
  90 }
  91
  92 static __inline void ClearStreamValues(MPEGA_STREAM *mpega_stream)
  93 {
  94     /* Dummy values */
  95     mpega_stream->mode = MPEGA_MODE_J_STEREO;
  96     mpega_stream->norm = 1;
  97     mpega_stream->layer = 3;
  98     mpega_stream->bitrate = 128;
  99     mpega_stream->frequency = 44100;
 100     mpega_stream->channels = 2;
 101
 102     mpega_stream->private_bit = 0;
 103     mpega_stream->copyright = 0;
 104     mpega_stream->original = 0;
 105
 106     mpega_stream->ms_duration = 1000;
 107
 108     mpega_stream->dec_channels = 2;
 109     mpega_stream->dec_quality = 2;
 110     mpega_stream->dec_frequency = 44100;
 111 }
 112
 113 static __inline void SetStreamOptions(MPEGA_STREAM *mpega_stream, MPEGA_CTRL *ctrl, DecHandle *dechandle)
 114 {
 115     MPEGA_LAYER *layer = ((mpega_stream->layer == 3) ? (&ctrl->layer_3) : (&ctrl->layer_1_2));
 116     MPEGA_OUTPUT *output;
 117     LONG freq;
 118
 119     if (layer->force_mono || mpega_stream->channels == 1)
 120     {
 121         output = &layer->mono;
 122         mpega_stream->dec_channels = 1;
 123     } else {
 124         output = &layer->stereo;
 125         mpega_stream->dec_channels = 2;
 126     }
 127
 128     if (output->quality == 0)
 129     {
 130         switch (output->freq_div)
 131         {
 132             case 4:
 133                 if ((freq = mpega_stream->frequency / 4) > 8000)
 134                 {
 135                     mad_stream_options(&dechandle->stream, MAD_OPTION_QUARTSAMPLERATE);
 136                     mpega_stream->dec_frequency = freq;
 137                     break;
 138                 }
 139                 /* Fall through */
 140
 141             case 2:
 142                 if ((freq = mpega_stream->frequency / 2) > 8000)
 143                 {
 144                     mad_stream_options(&dechandle->stream, MAD_OPTION_HALFSAMPLERATE);
 145                     mpega_stream->dec_frequency = freq;
 146                     break;
 147                 }
 148                 /* Fall through */
 149
 150             case 0:
 151                 if ((freq = mpega_stream->frequency) > output->freq_max)
 152                 {
 153                     LONG freqdiv = freq / output->freq_max;
 154
 155                     switch (freqdiv)
 156                     {
 157                         case 6:
 158                         case 5:
 159                         case 4:
 160                             freq /= 4;
 161                             mad_stream_options(&dechandle->stream, MAD_OPTION_QUARTSAMPLERATE);
 162
 163                             resample_init(&dechandle->resample[0], freq, output->freq_max);
 164                             if (mpega_stream->dec_channels == 2)
 165                                 resample_init(&dechandle->resample[1], freq, output->freq_max);
 166
 167                             mpega_stream->dec_frequency = output->freq_max;
 168                             break;
 169
 170                         case 3:
 171                         case 2:
 172                             freq /= 2;
 173                             mad_stream_options(&dechandle->stream, MAD_OPTION_HALFSAMPLERATE);
 174
 175                             resample_init(&dechandle->resample[0], freq, output->freq_max);
 176                             if (mpega_stream->dec_channels == 2)
 177                                 resample_init(&dechandle->resample[1], freq, output->freq_max);
 178
 179                             mpega_stream->dec_frequency = output->freq_max;
 180                             break;
 181
 182                         default:
 183                             mad_stream_options(&dechandle->stream, 0);
 184
 185                             resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
 186                             if (mpega_stream->dec_channels == 2)
 187                                 resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
 188
 189                             mpega_stream->dec_frequency = freq;
 190                             break;
 191                     }
 192
 193                     break;
 194                 }
 195                 /* Fall through */
 196
 197             default:
 198                 mad_stream_options(&dechandle->stream, 0);
 199                 mpega_stream->dec_frequency = mpega_stream->frequency;
 200                 break;
 201         }
 202     } else {
 203         switch (output->freq_div)
 204         {
 205             case 4:
 206                 if ((freq = mpega_stream->frequency / 4) > 8000)
 207                 {
 208                     resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
 209                     if (mpega_stream->dec_channels == 2)
 210                         resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
 211
 212                     mpega_stream->dec_frequency = freq;
 213                     break;
 214                 }
 215                 /* Fall through */
 216
 217             case 2:
 218                 if ((freq = mpega_stream->frequency / 2) > 8000)
 219                 {
 220                     resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
 221                     if (mpega_stream->dec_channels == 2)
 222                         resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
 223
 224                     mpega_stream->dec_frequency = freq;
 225                     break;
 226                 }
 227                 /* Fall through */
 228
 229             case 0:
 230                 if ((freq = mpega_stream->frequency) > output->freq_max)
 231                 {
 232                     resample_init(&dechandle->resample[0], freq, output->freq_max);
 233                     if (mpega_stream->dec_channels == 2)
 234                         resample_init(&dechandle->resample[1], freq, output->freq_max);
 235
 236                     mpega_stream->dec_frequency = output->freq_max;
 237                     break;
 238                 }
 239                 /* Fall through */
 240
 241             default:
 242                 mpega_stream->dec_frequency = mpega_stream->frequency;
 243                 break;
 244         }
 245     }
 246
 247     if ((mpega_stream->dec_quality = output->quality) < 2)
 248     {
 249         dechandle->stream.options |= MAD_OPTION_IGNORECRC;
 250         dechandle->gain = MAD_F_ONE;
 251     }
 252 }
 253
 254 static __inline ULONG CheckID3(UBYTE *buffer)
 255 {
 256     ULONG size = 0;
 257
 258     if (buffer[0]=='I' && buffer[1]=='D' && buffer[2]=='3' && buffer[3]<0xFF && buffer[4]<0xFF && buffer[6]<0x80 && buffer[7]<0x80 && buffer[8]<0x80 && buffer[9]<0x80)
 259     {
 260         size = 10 + (((buffer[6] & 0x7F) << 21) | ((buffer[7] & 0x7F) << 14) | ((buffer[8] & 0x7F) << 7) | buffer[9] & 0x7F);
 261
 262         if (buffer[5] & 0x10)
 263             size += 10;
 264     }
 265
 266     return size;
 267 }
 268
 269 static __inline LONG ReadFunc(DecHandle *dechandle, UBYTE *buffer, LONG len, APTR a4base)
 270 {
 271     MPEGA_CTRL *ctrl = dechandle->ctrl;
 272     LONG bytes;
 273
 274     if (ctrl->bs_access == NULL)
 275     {
 276         bytes = Read(dechandle->fh, buffer, len);
 277     } else {
 278         MPEGA_ACCESS *access = dechandle->access;
 279
 280         access->func = MPEGA_BSFUNC_READ;
 281         access->data.read.buffer = buffer;
 282         access->data.read.num_bytes = len;
 283
 284         bytes = CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access, a4base);
 285     }
 286
 287     return bytes;
 288 }
 289
 290 static LONG InitDecoder(MPEGA_STREAM *mpega_stream, MPEGA_CTRL *ctrl, APTR a4base)
 291 {
 292     DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 293     ULONG skip;
 294     LONG bytes;
 295
 296     ClearStreamValues(mpega_stream);
 297
 298     mad_stream_init(&dechandle->stream);
 299     mad_frame_init(&dechandle->frame);
 300     mad_synth_init(&dechandle->synth);
 301
 302     tag_init(&dechandle->tag);
 303     resample_init(&dechandle->resample[0], 44100, 44100);
 304     resample_init(&dechandle->resample[1], 44100, 44100);
 305     mad_timer_reset(&dechandle->timer);
 306     dechandle->gain = dechandle->replaygain = MAD_F_ONE;
 307
 308     bytes = ReadFunc(dechandle, dechandle->buffer, ctrl->stream_buffer_size, a4base);
 309
 310     if (bytes <= 0)
 311     {
 312         if (ctrl->check_mpeg) return 0;
 313
 314         /* Force MAD_ERROR_BUFLEN on first decode */
 315         bzero(dechandle->buffer, MAD_BUFFER_GUARD);
 316         mad_stream_buffer(&dechandle->stream, dechandle->buffer, 0);
 317
 318         return 1;
 319     }
 320
 321     dechandle->streamskip = skip = CheckID3(dechandle->buffer);
 322     if (dechandle->streamsize == 0) dechandle->streamsize = ((bytes > skip) ? (bytes) : (skip));
 323
 324     /* Ensure that we have something to decode */
 325     if (skip > (bytes - 2000))
 326     {
 327         LONG len = 0, size = bytes;
 328
 329         if (skip < size)
 330         {
 331             bytes = len = size - skip;
 332             bcopy(dechandle->buffer + (size - len), dechandle->buffer, len);
 333             skip = size;
 334         }
 335
 336         while (skip >= size)
 337         {
 338             skip -= size;
 339             size = ReadFunc(dechandle, dechandle->buffer + len, ctrl->stream_buffer_size - len, a4base);
 340
 341             if (size <= 0) return 0;
 342         }
 343
 344         if (skip)
 345         {
 346             bytes = len = size - skip;
 347             bcopy(dechandle->buffer + (size - len), dechandle->buffer, len);
 348             size = ReadFunc(dechandle, dechandle->buffer + len, ctrl->stream_buffer_size - len, a4base);
 349         }
 350
 351         if (size > 0) bytes += size;
 352     }
 353
 354     bzero(dechandle->buffer + bytes, MAD_BUFFER_GUARD);
 355     mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes);
 356
 357     dechandle->stream.sync = 0;
 358     mad_stream_options(&dechandle->stream, MAD_OPTION_IGNORECRC);
 359
 360     if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1)
 361     {
 362         while (MAD_RECOVERABLE(dechandle->stream.error))
 363         {
 364             dechandle->stream.error = 0;
 365             if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == 0) break;
 366         }
 367
 368         if (dechandle->stream.error)
 369         {
 370             mad_stream_options(&dechandle->stream, 0);
 371             if (ctrl->check_mpeg || dechandle->streamsize <= (bytes + skip)) return 0;
 372
 373             return 1;
 374         }
 375     }
 376
 377     mad_stream_options(&dechandle->stream, 0);
 378     SetStreamValues(mpega_stream, &dechandle->frame.header);
 379
 380     if (tag_parse(&dechandle->tag, &dechandle->stream) == 0)
 381     {
 382         skip = dechandle->stream.next_frame - dechandle->buffer;
 383         dechandle->streamskip += skip;
 384
 385         if (dechandle->tag.flags & TAG_LAME)
 386         {
 387             struct tag_rgain *rgain = &dechandle->tag.lame.replay_gain[0];
 388
 389             /*** TODO: Skip Encoder Delay samples when decoding the first frames ***/
 390             dechandle->sampleskip = dechandle->tag.lame.start_delay;
 391
 392             if (dechandle->streamsize <= (bytes+skip) && dechandle->tag.lame.music_length > (bytes+skip))
 393                 dechandle->streamsize = dechandle->tag.lame.music_length;
 394
 395             if (dechandle->tag.lame.replay_gain[1].name == TAG_RGAIN_NAME_AUDIOPHILE && dechandle->tag.lame.replay_gain[1].originator != TAG_RGAIN_ORIGINATOR_UNSPECIFIED)
 396                 rgain = &dechandle->tag.lame.replay_gain[1];
 397
 398             if ((rgain->name == TAG_RGAIN_NAME_RADIO || rgain->name == TAG_RGAIN_NAME_AUDIOPHILE) && rgain->originator != TAG_RGAIN_ORIGINATOR_UNSPECIFIED)
 399             {
 400                 double db = (double)(rgain->adjustment + 60) / 10;    /* 6.0 dB pregain */
 401
 402                 if (db > 18.0 || db < -175.0) db = (db > 18.0) ? 18.0 : -175.0;
 403                 dechandle->gain = dechandle->replaygain = mad_f_tofixed(exp(db/20*M_LN10));
 404             }
 405         }
 406
 407         if (dechandle->tag.flags & TAG_VBR && dechandle->tag.xing.flags & TAG_XING_FRAMES)
 408         {
 409             ULONG seconds;
 410             mad_timer_t total = dechandle->frame.header.duration;
 411
 412             mad_timer_multiply(&total, dechandle->tag.xing.frames);
 413             mpega_stream->ms_duration = mad_timer_count(total, MAD_UNITS_MILLISECONDS);
 414             seconds = ((mpega_stream->ms_duration > 1000) ? (mpega_stream->ms_duration / 1000) : (1));
 415
 416             if (dechandle->tag.xing.flags & TAG_XING_BYTES)
 417             {
 418                 mpega_stream->bitrate = ((dechandle->tag.xing.bytes / 125) / seconds);
 419             } else {
 420                 mpega_stream->bitrate = (((dechandle->streamsize - dechandle->streamskip) / 125) / seconds);
 421             }
 422         }
 423         else mpega_stream->ms_duration = ((dechandle->streamsize - dechandle->streamskip) * 8) / ((mpega_stream->bitrate) ? (mpega_stream->bitrate) : (8));
 424     } else {
 425         skip = dechandle->stream.this_frame - dechandle->buffer;
 426         dechandle->streamskip += skip;
 427
 428         if (dechandle->streamsize)
 429         {
 430 #if 0
 431             mad_timer_t total = dechandle->frame.header.duration;
 432
 433             mad_timer_multiply(&total, ((dechandle->streamsize - dechandle->streamskip) / (dechandle->stream.next_frame - dechandle->stream.this_frame)));
 434             mpega_stream->ms_duration = mad_timer_count(total, MAD_UNITS_MILLISECONDS);
 435 #else
 436             /* This will overflow on files over 500MB, but is more accurate than the above */
 437             mpega_stream->ms_duration = ((dechandle->streamsize - dechandle->streamskip) * 8) / ((mpega_stream->bitrate) ? (mpega_stream->bitrate) : (8));
 438 #endif
 439         }
 440
 441         mad_stream_buffer(&dechandle->stream, dechandle->buffer + skip, bytes - skip);
 442         mad_frame_mute(&dechandle->frame);
 443     }
 444
 445     SetStreamOptions(mpega_stream, ctrl, dechandle);
 446
 447     return 1;
 448 }
 449
 450 static void FinishDecoder(DecHandle *dechandle)
 451 {
 452     resample_finish(&dechandle->resample[0]);
 453     resample_finish(&dechandle->resample[1]);
 454     tag_finish(&dechandle->tag);
 455     mad_synth_finish(&dechandle->synth);
 456     mad_frame_finish(&dechandle->frame);
 457     mad_stream_finish(&dechandle->stream);
 458 }
 459
 460 static __inline LONG ValidateFrequency(LONG freq)
 461 {
 462     if (freq <= 0) return 48000;
 463     if (freq <= 8000) return 8000;
 464     if (freq <= 11025) return 11025;
 465     if (freq <= 12000) return 12000;
 466     if (freq <= 16000) return 16000;
 467     if (freq <= 22050) return 22050;
 468     if (freq <= 24000) return 24000;
 469     if (freq <= 32000) return 32000;
 470     if (freq <= 44100) return 44100;
 471
 472     return 48000;
 473 }
 474
 475 static __inline void ValidateCtrl(MPEGA_CTRL *ctrl)
 476 {
 477     if (ctrl->stream_buffer_size <= 0)
 478         ctrl->stream_buffer_size = DEFAULT_BUFFER_SIZE;
 479
 480     if (ctrl->layer_1_2.mono.freq_div < 0)
 481         ctrl->layer_1_2.mono.freq_div = 0;
 482
 483     if (ctrl->layer_1_2.mono.freq_div > 2)
 484         ctrl->layer_1_2.mono.freq_div = 4;
 485
 486     if (ctrl->layer_1_2.mono.quality < 0)
 487         ctrl->layer_1_2.mono.quality = 0;
 488
 489     if (ctrl->layer_1_2.mono.quality > 2)
 490         ctrl->layer_1_2.mono.quality = 2;
 491
 492     if (ctrl->layer_1_2.stereo.freq_div < 0)
 493         ctrl->layer_1_2.stereo.freq_div = 0;
 494
 495     if (ctrl->layer_1_2.stereo.freq_div > 2)
 496         ctrl->layer_1_2.stereo.freq_div = 4;
 497
 498     if (ctrl->layer_1_2.stereo.quality < 0)
 499         ctrl->layer_1_2.stereo.quality = 0;
 500
 501     if (ctrl->layer_1_2.stereo.quality > 2)
 502         ctrl->layer_1_2.stereo.quality = 2;
 503
 504     ctrl->layer_1_2.mono.freq_max = ValidateFrequency(ctrl->layer_1_2.mono.freq_max);
 505     ctrl->layer_1_2.stereo.freq_max = ValidateFrequency(ctrl->layer_1_2.stereo.freq_max);
 506
 507     if (ctrl->layer_3.mono.freq_div < 0)
 508         ctrl->layer_3.mono.freq_div = 0;
 509
 510     if (ctrl->layer_3.mono.freq_div > 2)
 511         ctrl->layer_3.mono.freq_div = 4;
 512
 513     if (ctrl->layer_3.mono.quality < 0)
 514         ctrl->layer_3.mono.quality = 0;
 515
 516     if (ctrl->layer_3.mono.quality > 2)
 517         ctrl->layer_3.mono.quality = 2;
 518
 519     if (ctrl->layer_3.stereo.freq_div < 0)
 520         ctrl->layer_3.stereo.freq_div = 0;
 521
 522     if (ctrl->layer_3.stereo.freq_div > 2)
 523         ctrl->layer_3.stereo.freq_div = 4;
 524
 525     if (ctrl->layer_3.stereo.quality < 0)
 526         ctrl->layer_3.stereo.quality = 0;
 527
 528     if (ctrl->layer_3.stereo.quality > 2)
 529         ctrl->layer_3.stereo.quality = 2;
 530
 531     ctrl->layer_3.mono.freq_max = ValidateFrequency(ctrl->layer_3.mono.freq_max);
 532     ctrl->layer_3.stereo.freq_max = ValidateFrequency(ctrl->layer_3.stereo.freq_max);
 533 }
 534
 535 static __inline LONG OutputPCM(MPEGA_STREAM *mpega_stream, DecHandle *dechandle, WORD *pcm[MPEGA_MAX_CHANNELS])
 536 {
 537     WORD *outleft = pcm[0];
 538     WORD *outright = pcm[1];
 539     mad_fixed_t const *left = dechandle->synth.pcm.samples[0];
 540     mad_fixed_t const *right = dechandle->synth.pcm.samples[1];
 541     ULONG len = dechandle->synth.pcm.length;
 542     LONG nsamples, sample0, sample1;
 543
 544     nsamples = len;
 545
 546     if (mpega_stream->dec_channels == 1 || !outright)
 547     {
 548         if (dechandle->resample[0].ratio != MAD_F_ONE)
 549         {
 550             nsamples = resample_block(&dechandle->resample[0], len, left, dechandle->resampled[0]);
 551             left = dechandle->resampled[0];
 552         }
 553
 554         if (mpega_stream->dec_quality < 2)
 555         {
 556             while (len--)
 557             {
 558                 sample0 = audio_linear_round(16, *left++);
 559
 560                 *outleft++ = sample0 & 0x0000FFFF;
 561             }
 562         } else {
 563             while (len--)
 564             {
 565                 sample0 = audio_linear_dither(16, *left++, &dechandle->left_dither);
 566
 567                 *outleft++ = sample0 & 0x0000FFFF;
 568             }
 569         }
 570     } else {    /* Stereo */
 571         if (dechandle->resample[0].ratio != MAD_F_ONE)
 572         {
 573             nsamples = resample_block(&dechandle->resample[0], len, left, dechandle->resampled[0]);
 574             resample_block(&dechandle->resample[1], len, right, dechandle->resampled[1]);
 575             left = dechandle->resampled[0];
 576             right = dechandle->resampled[1];
 577         }
 578
 579         if (mpega_stream->dec_quality < 2)
 580         {
 581             while (len--)
 582             {
 583                 sample0 = audio_linear_round(16, *left++);
 584                 sample1 = audio_linear_round(16, *right++);
 585
 586                 *outleft++ = sample0 & 0x0000FFFF;
 587                 *outright++ = sample1 & 0x0000FFFF;
 588             }
 589         } else {
 590             while (len--)
 591             {
 592                 sample0 = audio_linear_dither(16, *left++, &dechandle->left_dither);
 593                 sample1 = audio_linear_dither(16, *right++, &dechandle->right_dither);
 594
 595                 *outleft++ = sample0 & 0x0000FFFF;
 596                 *outright++ = sample1 & 0x0000FFFF;
 597             }
 598         }
 599     }
 600
 601     return nsamples;
 602 }
 603
 604
 605 MPEGA_STREAM *WRAP_MPEGA_open(char *stream_name, MPEGA_CTRL *ctrl, APTR a4base)
 606 {
 607     if (ctrl)
 608     {
 609         MPEGA_STREAM *mpega_stream;
 610
 611         if ((mpega_stream = malloc(sizeof(MPEGA_STREAM))))
 612         {
 613             DecHandle *dechandle;
 614
 615             if ((dechandle = calloc(1, sizeof(DecHandle))))
 616             {
 617                 mpega_stream->handle = dechandle;
 618
 619                 dechandle->fh = NULL;
 620                 dechandle->access = NULL;
 621
 622                 if ((dechandle->ctrl = malloc(sizeof(MPEGA_CTRL))))
 623                 {
 624                     bcopy(ctrl, dechandle->ctrl, sizeof(MPEGA_CTRL));
 625                     ValidateCtrl(dechandle->ctrl);
 626
 627                     if (ctrl->bs_access == NULL)
 628                     {
 629                         if (stream_name)
 630                         {
 631                             if ((dechandle->fh = Open(stream_name, MODE_OLDFILE)))
 632                             {
 633                                 struct FileInfoBlock *fib;
 634
 635                                 dechandle->streamsize = 0;
 636
 637                                 if ((fib = malloc(sizeof(struct FileInfoBlock))))
 638                                 {
 639                                     if (ExamineFH(dechandle->fh, fib))
 640                                     {
 641                                         dechandle->streamsize = fib->fib_Size;
 642                                     }
 643
 644                                     free(fib);
 645                                 }
 646
 647                                 if ((dechandle->buffer = malloc(dechandle->ctrl->stream_buffer_size + MAD_BUFFER_GUARD)))
 648                                 {
 649                                     if (InitDecoder(mpega_stream, dechandle->ctrl, a4base) != 0)
 650                                     {
 651                                         return mpega_stream;
 652                                     }
 653
 654                                     free(dechandle->buffer);
 655                                 }
 656
 657                                 Close(dechandle->fh);
 658                             }
 659                         }
 660                     } else {
 661                         MPEGA_ACCESS *access;
 662
 663                         if ((access = malloc(sizeof(MPEGA_ACCESS))))
 664                         {
 665                             dechandle->access = access;
 666
 667                             access->func = MPEGA_BSFUNC_OPEN;
 668                             access->data.open.stream_name = stream_name;
 669                             access->data.open.buffer_size = dechandle->ctrl->stream_buffer_size;
 670                             access->data.open.stream_size = 0;
 671
 672                             if ((dechandle->fh = (BPTR)CALLHOOK(ctrl->bs_access, NULL, access, a4base)))
 673                             {
 674                                 dechandle->streamsize = access->data.open.stream_size;
 675                                 if (access->data.open.buffer_size > 0) dechandle->ctrl->stream_buffer_size = access->data.open.buffer_size;
 676
 677                                 if ((dechandle->buffer = malloc(dechandle->ctrl->stream_buffer_size + MAD_BUFFER_GUARD)))
 678                                 {
 679                                     if (InitDecoder(mpega_stream, dechandle->ctrl, a4base) != 0)
 680                                     {
 681                                         return mpega_stream;
 682                                     }
 683
 684                                     free(dechandle->buffer);
 685                                 }
 686
 687                                 access->func = MPEGA_BSFUNC_CLOSE;
 688                                 CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access, a4base);
 689                             }
 690
 691                             free(access);
 692                         }
 693                     }
 694
 695                     free(dechandle->ctrl);
 696                 }
 697
 698                 free(dechandle);
 699             }
 700
 701             free(mpega_stream);
 702         }
 703     }
 704
 705     return NULL;
 706 }
 707
 708 void WRAP_MPEGA_close(MPEGA_STREAM *mpega_stream, APTR a4base)
 709 {
 710     if (mpega_stream)
 711     {
 712         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 713
 714         if (dechandle)
 715         {
 716             MPEGA_CTRL *ctrl = dechandle->ctrl;
 717
 718             FinishDecoder(dechandle);
 719
 720             if (ctrl->bs_access == NULL)
 721             {
 722                 if (dechandle->fh) Close(dechandle->fh);
 723             } else {
 724                 MPEGA_ACCESS *access = dechandle->access;
 725
 726                 access->func = MPEGA_BSFUNC_CLOSE;
 727
 728                 CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access, a4base);
 729             }
 730
 731             if (dechandle->ctrl) free(dechandle->ctrl);
 732             if (dechandle->buffer) free(dechandle->buffer);
 733             if (dechandle->access) free(dechandle->access);
 734
 735             free(dechandle);
 736         }
 737
 738         free(mpega_stream);
 739     }
 740 }
 741
 742 LONG WRAP_MPEGA_decode_frame(MPEGA_STREAM *mpega_stream, WORD *pcm[MPEGA_MAX_CHANNELS], APTR a4base)
 743 {
 744     if (mpega_stream && pcm && pcm[0])
 745     {
 746         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 747         MPEGA_CTRL *ctrl = dechandle->ctrl;
 748
 749         if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1)
 750         {
 751             LONG error = dechandle->stream.error;
 752
 753             if (error == MAD_ERROR_BUFLEN)
 754             {
 755                 LONG bytes = ctrl->stream_buffer_size, len = 0;
 756
 757                 if (dechandle->stream.next_frame)
 758                 {
 759                     bcopy(dechandle->stream.next_frame, dechandle->buffer, len = &dechandle->buffer[bytes] - dechandle->stream.next_frame);
 760                 }
 761
 762                 bytes = ReadFunc(dechandle, dechandle->buffer + len, bytes - len, a4base);
 763
 764                 if (bytes == 0) return MPEGA_ERR_EOF;
 765                 if (bytes < 0) return MPEGA_ERR_BADVALUE;
 766
 767                 bzero(dechandle->buffer + bytes + len, MAD_BUFFER_GUARD);
 768                 mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes + len);
 769
 770                 if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1) error = dechandle->stream.error;
 771                 else error = 0;
 772             }
 773
 774             if (error)
 775             {
 776                 switch (error)
 777                 {
 778                     case MAD_ERROR_BUFPTR:
 779                         return MPEGA_ERR_BADVALUE;
 780                         break;
 781
 782                     case MAD_ERROR_NOMEM:
 783                         return MPEGA_ERR_MEM;
 784                         break;
 785
 786                     case MAD_ERROR_LOSTSYNC:
 787                         return MPEGA_ERR_NO_SYNC;
 788                         break;
 789
 790                     case MAD_ERROR_BADBIGVALUES:
 791                     case MAD_ERROR_BADBLOCKTYPE:
 792                     case MAD_ERROR_BADSCFSI:
 793                     case MAD_ERROR_BADHUFFDATA:
 794                         if (mpega_stream->dec_quality > 0) return MPEGA_ERR_BADFRAME;
 795                         break;
 796
 797                     case MAD_ERROR_BADLAYER:
 798                     case MAD_ERROR_BADBITRATE:
 799                     case MAD_ERROR_BADSAMPLERATE:
 800                     case MAD_ERROR_BADEMPHASIS:
 801                     case MAD_ERROR_BADCRC:
 802                     case MAD_ERROR_BADBITALLOC:
 803                     case MAD_ERROR_BADSCALEFACTOR:
 804                     case MAD_ERROR_BADMODE:
 805                     case MAD_ERROR_BADFRAMELEN:
 806                     case MAD_ERROR_BADDATAPTR:
 807                     case MAD_ERROR_BADPART3LEN:
 808                     case MAD_ERROR_BADHUFFTABLE:
 809                     case MAD_ERROR_BADSTEREO:
 810                         return MPEGA_ERR_BADFRAME;
 811                         break;
 812
 813                     default:
 814                         return -error;
 815                         break;
 816                 }
 817             }
 818         }
 819
 820         mad_timer_add(&dechandle->timer, dechandle->frame.header.duration);
 821
 822         SetStreamValues(mpega_stream, &dechandle->frame.header);
 823         SetStreamOptions(mpega_stream, ctrl, dechandle);
 824
 825         if (dechandle->gain != MAD_F_ONE)
 826             gain_filter(dechandle->gain, &dechandle->frame);
 827
 828         mad_synth_frame(&dechandle->synth, &dechandle->frame);
 829
 830         return OutputPCM(mpega_stream, dechandle, pcm);
 831     }
 832
 833     return MPEGA_ERR_BADVALUE;
 834 }
 835
 836 LONG WRAP_MPEGA_seek(MPEGA_STREAM *mpega_stream, ULONG ms_time_position, APTR a4base)
 837 {
 838     if (mpega_stream)
 839     {
 840         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 841         MPEGA_CTRL *ctrl = dechandle->ctrl;
 842         LONG pos, error;
 843
 844         if (dechandle->tag.flags & TAG_VBR && dechandle->tag.xing.flags & TAG_XING_TOC)
 845         {
 846             int step, i = 99;
 847
 848             if (dechandle->tag.xing.flags & TAG_XING_BYTES)
 849             {
 850                 step = dechandle->tag.xing.bytes / 256;
 851             } else {
 852                 step = (dechandle->streamsize - dechandle->streamskip) / 256;
 853             }
 854
 855             if (ms_time_position < mpega_stream->ms_duration)
 856             {
 857                 i = ((mpega_stream->ms_duration > 100) ? (ms_time_position / (mpega_stream->ms_duration / 100)) : (0));
 858                 if (i > 99) i = 99;
 859             }
 860
 861             pos = (step * dechandle->tag.xing.toc[i]) + dechandle->streamskip;
 862         } else {
 863             pos = ((((ULONG)mpega_stream->bitrate * 125UL) * (ms_time_position / 1000)) + dechandle->streamskip);
 864         }
 865
 866         if (ctrl->bs_access == NULL)
 867         {
 868             error = Seek(dechandle->fh, pos, OFFSET_BEGINNING);
 869
 870             if (error > 0) error = 0;
 871         } else {
 872             MPEGA_ACCESS *access = dechandle->access;
 873
 874             access->func = MPEGA_BSFUNC_SEEK;
 875             access->data.seek.abs_byte_seek_pos = pos;
 876
 877             error = CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access, a4base);
 878         }
 879
 880         if (error == 0)
 881         {
 882             LONG bytes;
 883
 884             bytes = ReadFunc(dechandle, dechandle->buffer, ctrl->stream_buffer_size, a4base);
 885
 886             if (bytes == 0) return MPEGA_ERR_EOF;
 887             if (bytes < 0) return MPEGA_ERR_BADVALUE;
 888
 889             bzero(dechandle->buffer + bytes, MAD_BUFFER_GUARD);
 890             mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes);
 891
 892             mad_frame_mute(&dechandle->frame);
 893             mad_synth_mute(&dechandle->synth);
 894             dechandle->stream.sync = 0;
 895
 896             /* If we seek somewhere other than the beginning we need to flush out junk audio */
 897             if (pos > dechandle->streamskip)
 898             {
 899                 mad_frame_decode(&dechandle->frame, &dechandle->stream);
 900                 mad_frame_decode(&dechandle->frame, &dechandle->stream);
 901                 mad_synth_frame(&dechandle->synth, &dechandle->frame);
 902             }
 903
 904 //            mad_timer_set(&dechandle->timer, 0, pos - dechandle->streamskip, (ULONG)mpega_stream->bitrate * 125);
 905             mad_timer_set(&dechandle->timer, 0, ms_time_position, 1000);
 906
 907             return 0;
 908         }
 909     }
 910
 911     return MPEGA_ERR_BADVALUE;
 912 }
 913
 914 LONG WRAP_MPEGA_time(MPEGA_STREAM *mpega_stream, ULONG *ms_time_position)
 915 {
 916     if (mpega_stream && ms_time_position)
 917     {
 918         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 919
 920         *ms_time_position = mad_timer_count(dechandle->timer, MAD_UNITS_MILLISECONDS);
 921         return 0;
 922     }
 923
 924     return MPEGA_ERR_BADVALUE;
 925 }
 926
 927 LONG WRAP_MPEGA_find_sync(UBYTE *buffer, LONG buffer_size)
 928 {
 929     if (buffer && buffer_size > 75)
 930     {
 931         LONG i = 0;
 932
 933         while (i < buffer_size - 1)
 934         {
 935             if ((buffer[i] == 0xFF) && ((buffer[i+1] & 0xE0) == 0xE0)) return i;
 936             ++i;
 937         }
 938
 939         return MPEGA_ERR_NO_SYNC;
 940     }
 941
 942     return MPEGA_ERR_BADVALUE;
 943 }
 944
 945 LONG WRAP_MPEGA_scale(MPEGA_STREAM *mpega_stream, LONG scale_percent)
 946 {
 947     if (mpega_stream)
 948     {
 949         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
 950
 951         if (scale_percent <= 0) dechandle->gain = ((mad_fixed_t)0x00000001L);
 952         else
 953         {
 954             mad_fixed_t scaled;
 955
 956             if (scale_percent > 800) scale_percent = 800;
 957             scaled = ((dechandle->replaygain/100)*scale_percent)+1;
 958
 959             if (scaled > MAD_F_MAX || scaled < ((mad_fixed_t)0x00000001L)) dechandle->gain = MAD_F_MAX;
 960             else dechandle->gain = scaled;
 961         }
 962
 963         return 0;
 964     }
 965
 966     return MPEGA_ERR_BADVALUE;
 967 }
 968