src/lib/doslib/ext/libmad/frame.c

   1 /*
   2  * libmad - MPEG audio decoder library
   3  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * $Id: frame.c,v 1.29 2004/02/04 22:59:19 rob Exp $
  20  */
  21
  22 # ifdef HAVE_CONFIG_H
  23 #  include "config.h"
  24 # endif
  25
  26 # include "global.h"
  27
  28 # include <stdlib.h>
  29 # include <stdio.h>
  30
  31 # include "bit.h"
  32 # include "stream.h"
  33 # include "frame.h"
  34 # include "timer.h"
  35 # include "layer12.h"
  36 # include "layer3.h"
  37
  38 static
  39 unsigned long const bitrate_table[5][15] = {
  40   /* MPEG-1 */
  41   { 0,  32000,  64000,  96000, 128000, 160000, 192000, 224000,  /* Layer I   */
  42        256000, 288000, 320000, 352000, 384000, 416000, 448000 },
  43   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer II  */
  44        128000, 160000, 192000, 224000, 256000, 320000, 384000 },
  45   { 0,  32000,  40000,  48000,  56000,  64000,  80000,  96000,  /* Layer III */
  46        112000, 128000, 160000, 192000, 224000, 256000, 320000 },
  47
  48   /* MPEG-2 LSF */
  49   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer I   */
  50        128000, 144000, 160000, 176000, 192000, 224000, 256000 },
  51   { 0,   8000,  16000,  24000,  32000,  40000,  48000,  56000,  /* Layers    */
  52         64000,  80000,  96000, 112000, 128000, 144000, 160000 } /* II & III  */
  53 };
  54
  55 static
  56 unsigned int const samplerate_table[3] = { 44100, 48000, 32000 };
  57
  58 static
  59 int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = {
  60   mad_layer_I,
  61   mad_layer_II,
  62   mad_layer_III
  63 };
  64
  65 /*
  66  * NAME:        header->init()
  67  * DESCRIPTION: initialize header struct
  68  */
  69 void mad_header_init(struct mad_header *header)
  70 {
  71   header->layer          = 0;
  72   header->mode           = 0;
  73   header->mode_extension = 0;
  74   header->emphasis       = 0;
  75
  76   header->bitrate        = 0;
  77   header->samplerate     = 0;
  78
  79   header->crc_check      = 0;
  80   header->crc_target     = 0;
  81
  82   header->flags          = 0;
  83   header->private_bits   = 0;
  84
  85   header->duration       = mad_timer_zero;
  86 }
  87
  88 /*
  89  * NAME:        frame->init()
  90  * DESCRIPTION: initialize frame struct
  91  */
  92 void mad_frame_init(struct mad_frame *frame)
  93 {
  94   mad_header_init(&frame->header);
  95
  96   frame->options = 0;
  97
  98   frame->overlap = 0;
  99   mad_frame_mute(frame);
 100 }
 101
 102 /*
 103  * NAME:        frame->finish()
 104  * DESCRIPTION: deallocate any dynamic memory associated with frame
 105  */
 106 void mad_frame_finish(struct mad_frame *frame)
 107 {
 108   mad_header_finish(&frame->header);
 109
 110   if (frame->overlap) {
 111     free(frame->overlap);
 112     frame->overlap = 0;
 113   }
 114 }
 115
 116 /*
 117  * NAME:        decode_header()
 118  * DESCRIPTION: read header data and following CRC word
 119  */
 120 static
 121 int decode_header(struct mad_header *header, struct mad_stream *stream)
 122 {
 123   unsigned int index;
 124
 125   header->flags        = 0;
 126   header->private_bits = 0;
 127
 128   /* header() */
 129
 130   /* syncword */
 131   mad_bit_skip(&stream->ptr, 11);
 132
 133   /* MPEG 2.5 indicator (really part of syncword) */
 134   if (mad_bit_read(&stream->ptr, 1) == 0)
 135     header->flags |= MAD_FLAG_MPEG_2_5_EXT;
 136
 137   /* ID */
 138   if (mad_bit_read(&stream->ptr, 1) == 0)
 139     header->flags |= MAD_FLAG_LSF_EXT;
 140   else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
 141     stream->error = MAD_ERROR_LOSTSYNC;
 142     return -1;
 143   }
 144
 145   /* layer */
 146   header->layer = 4 - mad_bit_read(&stream->ptr, 2);
 147
 148   if (header->layer == 4) {
 149     stream->error = MAD_ERROR_BADLAYER;
 150     return -1;
 151   }
 152
 153   /* protection_bit */
 154   if (mad_bit_read(&stream->ptr, 1) == 0) {
 155     header->flags    |= MAD_FLAG_PROTECTION;
 156     header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
 157   }
 158
 159   /* bitrate_index */
 160   index = mad_bit_read(&stream->ptr, 4);
 161
 162   if (index == 15) {
 163     stream->error = MAD_ERROR_BADBITRATE;
 164     return -1;
 165   }
 166
 167   if (header->flags & MAD_FLAG_LSF_EXT)
 168     header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
 169   else
 170     header->bitrate = bitrate_table[header->layer - 1][index];
 171
 172   /* sampling_frequency */
 173   index = mad_bit_read(&stream->ptr, 2);
 174
 175   if (index == 3) {
 176     stream->error = MAD_ERROR_BADSAMPLERATE;
 177     return -1;
 178   }
 179
 180   header->samplerate = samplerate_table[index];
 181
 182   if (header->flags & MAD_FLAG_LSF_EXT) {
 183     header->samplerate /= 2;
 184
 185     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
 186       header->samplerate /= 2;
 187   }
 188
 189   /* padding_bit */
 190   if (mad_bit_read(&stream->ptr, 1))
 191     header->flags |= MAD_FLAG_PADDING;
 192
 193   /* private_bit */
 194   if (mad_bit_read(&stream->ptr, 1))
 195     header->private_bits |= MAD_PRIVATE_HEADER;
 196
 197   /* mode */
 198   header->mode = 3 - mad_bit_read(&stream->ptr, 2);
 199
 200   /* mode_extension */
 201   header->mode_extension = mad_bit_read(&stream->ptr, 2);
 202
 203   /* copyright */
 204   if (mad_bit_read(&stream->ptr, 1))
 205     header->flags |= MAD_FLAG_COPYRIGHT;
 206
 207   /* original/copy */
 208   if (mad_bit_read(&stream->ptr, 1))
 209     header->flags |= MAD_FLAG_ORIGINAL;
 210
 211   /* emphasis */
 212   header->emphasis = mad_bit_read(&stream->ptr, 2);
 213
 214 # if defined(OPT_STRICT)
 215   /*
 216    * ISO/IEC 11172-3 says this is a reserved emphasis value, but
 217    * streams exist which use it anyway. Since the value is not important
 218    * to the decoder proper, we allow it unless OPT_STRICT is defined.
 219    */
 220   if (header->emphasis == MAD_EMPHASIS_RESERVED) {
 221     stream->error = MAD_ERROR_BADEMPHASIS;
 222     return -1;
 223   }
 224 # endif
 225
 226   /* error_check() */
 227
 228   /* crc_check */
 229   if (header->flags & MAD_FLAG_PROTECTION)
 230     header->crc_target = mad_bit_read(&stream->ptr, 16);
 231
 232   return 0;
 233 }
 234
 235 /*
 236  * NAME:        free_bitrate()
 237  * DESCRIPTION: attempt to discover the bitstream's free bitrate
 238  */
 239 static
 240 int free_bitrate(struct mad_stream *stream, struct mad_header const *header)
 241 {
 242   struct mad_bitptr keep_ptr;
 243   unsigned long rate = 0;
 244   unsigned int pad_slot, slots_per_frame;
 245   unsigned char const *ptr = 0;
 246
 247   keep_ptr = stream->ptr;
 248
 249   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
 250   slots_per_frame = (header->layer == MAD_LAYER_III &&
 251                      (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
 252
 253   while (mad_stream_sync(stream) == 0) {
 254     struct mad_stream peek_stream;
 255     struct mad_header peek_header;
 256
 257     peek_stream = *stream;
 258     peek_header = *header;
 259
 260     if (decode_header(&peek_header, &peek_stream) == 0 &&
 261         peek_header.layer == header->layer &&
 262         peek_header.samplerate == header->samplerate) {
 263       unsigned int N;
 264
 265       ptr = mad_bit_nextbyte(&stream->ptr);
 266
 267       N = ptr - stream->this_frame;
 268
 269       if (header->layer == MAD_LAYER_I) {
 270         rate = (unsigned long) header->samplerate *
 271           (N - 4 * pad_slot + 4) / 48 / 1000;
 272       }
 273       else {
 274         rate = (unsigned long) header->samplerate *
 275           (N - pad_slot + 1) / slots_per_frame / 1000;
 276       }
 277
 278       if (rate >= 8)
 279         break;
 280     }
 281
 282     mad_bit_skip(&stream->ptr, 8);
 283   }
 284
 285   stream->ptr = keep_ptr;
 286
 287   if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) {
 288     stream->error = MAD_ERROR_LOSTSYNC;
 289     return -1;
 290   }
 291
 292   stream->freerate = rate * 1000;
 293
 294   return 0;
 295 }
 296
 297 /*
 298  * NAME:        header->decode()
 299  * DESCRIPTION: read the next frame header from the stream
 300  */
 301 int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
 302 {
 303   register unsigned char const *ptr, *end;
 304   unsigned int pad_slot, N;
 305
 306   ptr = stream->next_frame;
 307   end = stream->bufend;
 308
 309   if (ptr == 0) {
 310     stream->error = MAD_ERROR_BUFPTR;
 311     goto fail;
 312   }
 313
 314   /* stream skip */
 315   if (stream->skiplen) {
 316     if (!stream->sync)
 317       ptr = stream->this_frame;
 318
 319     if (end - ptr < stream->skiplen) {
 320       stream->skiplen   -= end - ptr;
 321       stream->next_frame = end;
 322
 323       stream->error = MAD_ERROR_BUFLEN;
 324       goto fail;
 325     }
 326
 327     ptr += stream->skiplen;
 328     stream->skiplen = 0;
 329
 330     stream->sync = 1;
 331   }
 332
 333  sync:
 334   /* synchronize */
 335   if (stream->sync) {
 336     if (end - ptr < MAD_BUFFER_GUARD) {
 337       stream->next_frame = ptr;
 338
 339       stream->error = MAD_ERROR_BUFLEN;
 340       goto fail;
 341     }
 342     else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
 343       /* mark point where frame sync word was expected */
 344       stream->this_frame = ptr;
 345       stream->next_frame = ptr + 1;
 346
 347       stream->error = MAD_ERROR_LOSTSYNC;
 348       goto fail;
 349     }
 350   }
 351   else {
 352     mad_bit_init(&stream->ptr, ptr);
 353
 354     if (mad_stream_sync(stream) == -1) {
 355       if (end - stream->next_frame >= MAD_BUFFER_GUARD)
 356         stream->next_frame = end - MAD_BUFFER_GUARD;
 357
 358       stream->error = MAD_ERROR_BUFLEN;
 359       goto fail;
 360     }
 361
 362     ptr = mad_bit_nextbyte(&stream->ptr);
 363   }
 364
 365   /* begin processing */
 366   stream->this_frame = ptr;
 367   stream->next_frame = ptr + 1;  /* possibly bogus sync word */
 368
 369   mad_bit_init(&stream->ptr, stream->this_frame);
 370
 371   if (decode_header(header, stream) == -1)
 372     goto fail;
 373
 374   /* calculate frame duration */
 375   mad_timer_set(&header->duration, 0,
 376                 32 * MAD_NSBSAMPLES(header), header->samplerate);
 377
 378   /* calculate free bit rate */
 379   if (header->bitrate == 0) {
 380     if ((stream->freerate == 0 || !stream->sync ||
 381          (header->layer == MAD_LAYER_III && stream->freerate > 640000)) &&
 382         free_bitrate(stream, header) == -1)
 383       goto fail;
 384
 385     header->bitrate = stream->freerate;
 386     header->flags  |= MAD_FLAG_FREEFORMAT;
 387   }
 388
 389   /* calculate beginning of next frame */
 390   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
 391
 392   if (header->layer == MAD_LAYER_I)
 393     N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4;
 394   else {
 395     unsigned int slots_per_frame;
 396
 397     slots_per_frame = (header->layer == MAD_LAYER_III &&
 398                        (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
 399
 400     N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot;
 401   }
 402
 403   /* verify there is enough data left in buffer to decode this frame */
 404   if (N + MAD_BUFFER_GUARD > end - stream->this_frame) {
 405     stream->next_frame = stream->this_frame;
 406
 407     stream->error = MAD_ERROR_BUFLEN;
 408     goto fail;
 409   }
 410
 411   stream->next_frame = stream->this_frame + N;
 412
 413   if (!stream->sync) {
 414     /* check that a valid frame header follows this frame */
 415
 416     ptr = stream->next_frame;
 417     if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
 418       ptr = stream->next_frame = stream->this_frame + 1;
 419       goto sync;
 420     }
 421
 422     stream->sync = 1;
 423   }
 424
 425   header->flags |= MAD_FLAG_INCOMPLETE;
 426
 427   return 0;
 428
 429  fail:
 430   stream->sync = 0;
 431
 432   return -1;
 433 }
 434
 435 /*
 436  * NAME:        frame->decode()
 437  * DESCRIPTION: decode a single frame from a bitstream
 438  */
 439 int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream)
 440 {
 441   frame->options = stream->options;
 442
 443   /* header() */
 444   /* error_check() */
 445
 446   if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) &&
 447       mad_header_decode(&frame->header, stream) == -1)
 448     goto fail;
 449
 450   /* audio_data() */
 451
 452   frame->header.flags &= ~MAD_FLAG_INCOMPLETE;
 453
 454   if (decoder_table[frame->header.layer - 1](stream, frame) == -1) {
 455     if (!MAD_RECOVERABLE(stream->error))
 456       stream->next_frame = stream->this_frame;
 457
 458     goto fail;
 459   }
 460
 461   /* ancillary_data() */
 462
 463   if (frame->header.layer != MAD_LAYER_III) {
 464     struct mad_bitptr next_frame;
 465
 466     mad_bit_init(&next_frame, stream->next_frame);
 467
 468     stream->anc_ptr    = stream->ptr;
 469     stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame);
 470
 471     mad_bit_finish(&next_frame);
 472   }
 473
 474   return 0;
 475
 476  fail:
 477   stream->anc_bitlen = 0;
 478   return -1;
 479 }
 480
 481 /*
 482  * NAME:        frame->mute()
 483  * DESCRIPTION: zero all subband values so the frame becomes silent
 484  */
 485 void mad_frame_mute(struct mad_frame *frame)
 486 {
 487   unsigned int s, sb;
 488
 489   for (s = 0; s < 36; ++s) {
 490     for (sb = 0; sb < 32; ++sb) {
 491       frame->sbsample[0][s][sb] =
 492       frame->sbsample[1][s][sb] = 0;
 493     }
 494   }
 495
 496   if (frame->overlap) {
 497     for (s = 0; s < 18; ++s) {
 498       for (sb = 0; sb < 32; ++sb) {
 499         (*frame->overlap)[0][sb][s] =
 500         (*frame->overlap)[1][sb][s] = 0;
 501       }
 502     }
 503   }
 504 }