libmad/frame.c

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