frame.cpp

00001 /*
00002  * libmad - MPEG audio decoder library
00003  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018  *
00019  * $Id: frame.c,v 1.1 2010/11/23 20:12:57 andy Exp $
00020  */
00021 
00022 #  include "config.h"
00023 
00024 # include "global.h"
00025 
00026 # include <stdlib.h>
00027 
00028 # include "bit.h"
00029 # include "stream.h"
00030 # include "frame.h"
00031 # include "timer.h"
00032 # include "layer12.h"
00033 # include "layer3.h"
00034 
00035 static
00036 unsigned long const bitrate_table[5][15] = {
00037   /* MPEG-1 */
00038   { 0,  32000,  64000,  96000, 128000, 160000, 192000, 224000,  /* Layer I   */
00039        256000, 288000, 320000, 352000, 384000, 416000, 448000 },
00040   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer II  */
00041        128000, 160000, 192000, 224000, 256000, 320000, 384000 },
00042   { 0,  32000,  40000,  48000,  56000,  64000,  80000,  96000,  /* Layer III */
00043        112000, 128000, 160000, 192000, 224000, 256000, 320000 },
00044 
00045   /* MPEG-2 LSF */
00046   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer I   */
00047        128000, 144000, 160000, 176000, 192000, 224000, 256000 },
00048   { 0,   8000,  16000,  24000,  32000,  40000,  48000,  56000,  /* Layers    */
00049         64000,  80000,  96000, 112000, 128000, 144000, 160000 } /* II & III  */
00050 };
00051 
00052 static
00053 unsigned int const samplerate_table[3] = { 44100, 48000, 32000 };
00054 
00055 static
00056 int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = {
00057   mad_layer_I,
00058   mad_layer_II,
00059   mad_layer_III
00060 };
00061 
00062 /*
00063  * NAME:    header->init()
00064  * DESCRIPTION: initialize header struct
00065  */
00066 void mad_header_init(struct mad_header *header)
00067 {
00068   header->layer          = (enum mad_layer)0;
00069   header->mode           = (enum mad_mode)0;
00070   header->mode_extension = 0;
00071   header->emphasis       = (enum mad_emphasis)0;
00072 
00073   header->bitrate        = 0;
00074   header->samplerate     = 0;
00075 
00076   header->crc_check      = 0;
00077   header->crc_target     = 0;
00078 
00079   header->flags          = 0;
00080   header->private_bits   = 0;
00081 
00082   header->duration       = mad_timer_zero;
00083 }
00084 
00085 /*
00086  * NAME:    frame->init()
00087  * DESCRIPTION: initialize frame struct
00088  */
00089 void mad_frame_init(struct mad_frame *frame)
00090 {
00091   mad_header_init(&frame->header);
00092 
00093   frame->options = 0;
00094 
00095 //###  frame->overlap = 0;
00096   mad_frame_mute(frame);
00097 }
00098 
00099 /*
00100  * NAME:    frame->finish()
00101  * DESCRIPTION: deallocate any dynamic memory associated with frame
00102  */
00103 void mad_frame_finish(struct mad_frame *frame)
00104 {
00105   mad_header_finish(&frame->header);
00106 /* ###
00107   if (frame->overlap) {
00108     free(frame->overlap);
00109     frame->overlap = 0;
00110   }
00111   */
00112 }
00113 
00114 /*
00115  * NAME:    decode_header()
00116  * DESCRIPTION: read header data and following CRC word
00117  */
00118 static
00119 int decode_header(struct mad_header *header, struct mad_stream *stream)
00120 {
00121   unsigned int index;
00122 
00123   header->flags        = 0;
00124   header->private_bits = 0;
00125 
00126   /* header() */
00127 
00128   /* syncword */
00129   mad_bit_skip(&stream->ptr, 11);
00130 
00131   /* MPEG 2.5 indicator (really part of syncword) */
00132   if (mad_bit_read(&stream->ptr, 1) == 0)
00133     header->flags |= MAD_FLAG_MPEG_2_5_EXT;
00134 
00135   /* ID */
00136   if (mad_bit_read(&stream->ptr, 1) == 0)
00137     header->flags |= MAD_FLAG_LSF_EXT;
00138   else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
00139     stream->error = MAD_ERROR_LOSTSYNC;
00140     return -1;
00141   }
00142 
00143   /* layer */
00144   header->layer = (enum mad_layer)(4 - mad_bit_read(&stream->ptr, 2));
00145 
00146   if (header->layer == 4) {
00147     stream->error = MAD_ERROR_BADLAYER;
00148     return -1;
00149   }
00150 
00151   /* protection_bit */
00152   if (mad_bit_read(&stream->ptr, 1) == 0) {
00153     header->flags    |= MAD_FLAG_PROTECTION;
00154     header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
00155   }
00156 
00157   /* bitrate_index */
00158   index = mad_bit_read(&stream->ptr, 4);
00159 
00160   if (index == 15) {
00161     stream->error = MAD_ERROR_BADBITRATE;
00162     return -1;
00163   }
00164 
00165   if (header->flags & MAD_FLAG_LSF_EXT)
00166     header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
00167   else
00168     header->bitrate = bitrate_table[header->layer - 1][index];
00169 
00170   /* sampling_frequency */
00171   index = mad_bit_read(&stream->ptr, 2);
00172 
00173   if (index == 3) {
00174     stream->error = MAD_ERROR_BADSAMPLERATE;
00175     return -1;
00176   }
00177 
00178   header->samplerate = samplerate_table[index];
00179 
00180   if (header->flags & MAD_FLAG_LSF_EXT) {
00181     header->samplerate /= 2;
00182 
00183     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
00184       header->samplerate /= 2;
00185   }
00186 
00187   /* padding_bit */
00188   if (mad_bit_read(&stream->ptr, 1))
00189     header->flags |= MAD_FLAG_PADDING;
00190 
00191   /* private_bit */
00192   if (mad_bit_read(&stream->ptr, 1))
00193     header->private_bits |= MAD_PRIVATE_HEADER;
00194 
00195   /* mode */
00196   header->mode = (enum mad_mode)(3 - mad_bit_read(&stream->ptr, 2));
00197 
00198   /* mode_extension */
00199   header->mode_extension = mad_bit_read(&stream->ptr, 2);
00200 
00201   /* copyright */
00202   if (mad_bit_read(&stream->ptr, 1))
00203     header->flags |= MAD_FLAG_COPYRIGHT;
00204 
00205   /* original/copy */
00206   if (mad_bit_read(&stream->ptr, 1))
00207     header->flags |= MAD_FLAG_ORIGINAL;
00208 
00209   /* emphasis */
00210   header->emphasis = (enum mad_emphasis)mad_bit_read(&stream->ptr, 2);
00211 
00212 # if defined(OPT_STRICT)
00213   /*
00214    * ISO/IEC 11172-3 says this is a reserved emphasis value, but
00215    * streams exist which use it anyway. Since the value is not important
00216    * to the decoder proper, we allow it unless OPT_STRICT is defined.
00217    */
00218   if (header->emphasis == MAD_EMPHASIS_RESERVED) {
00219     stream->error = MAD_ERROR_BADEMPHASIS;
00220     return -1;
00221   }
00222 # endif
00223 
00224   /* error_check() */
00225 
00226   /* crc_check */
00227   if (header->flags & MAD_FLAG_PROTECTION)
00228     header->crc_target = mad_bit_read(&stream->ptr, 16);
00229 
00230   return 0;
00231 }
00232 
00233 /*
00234  * NAME:    free_bitrate()
00235  * DESCRIPTION: attempt to discover the bitstream's free bitrate
00236  */
00237 static
00238 int free_bitrate(struct mad_stream *stream, struct mad_header const *header)
00239 {
00240   struct mad_bitptr keep_ptr;
00241   unsigned long rate = 0;
00242   unsigned int pad_slot, slots_per_frame;
00243   unsigned char const *ptr = 0;
00244 
00245   keep_ptr = stream->ptr;
00246 
00247   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
00248   slots_per_frame = (header->layer == MAD_LAYER_III &&
00249              (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
00250 
00251   while (mad_stream_sync(stream) == 0) {
00252     struct mad_stream peek_stream;
00253     struct mad_header peek_header;
00254 
00255     peek_stream = *stream;
00256     peek_header = *header;
00257 
00258     if (decode_header(&peek_header, &peek_stream) == 0 &&
00259     peek_header.layer == header->layer &&
00260     peek_header.samplerate == header->samplerate) {
00261       unsigned int N;
00262 
00263       ptr = mad_bit_nextbyte(&stream->ptr);
00264 
00265       N = ptr - stream->this_frame;
00266 
00267       if (header->layer == MAD_LAYER_I) {
00268     rate = (unsigned long) header->samplerate *
00269       (N - 4 * pad_slot + 4) / 48 / 1000;
00270       }
00271       else {
00272     rate = (unsigned long) header->samplerate *
00273       (N - pad_slot + 1) / slots_per_frame / 1000;
00274       }
00275 
00276       if (rate >= 8)
00277     break;
00278     }
00279 
00280     mad_bit_skip(&stream->ptr, 8);
00281   }
00282 
00283   stream->ptr = keep_ptr;
00284 
00285   if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) {
00286     stream->error = MAD_ERROR_LOSTSYNC;
00287     return -1;
00288   }
00289 
00290   stream->freerate = rate * 1000;
00291 
00292   return 0;
00293 }
00294 
00295 /*
00296  * NAME:    header->decode()
00297  * DESCRIPTION: read the next frame header from the stream
00298  */
00299 int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
00300 {
00301   register unsigned char const *ptr, *end;
00302   unsigned int pad_slot, N;
00303 
00304   ptr = stream->next_frame;
00305   end = stream->bufend;
00306 
00307   if (ptr == 0) {
00308     stream->error = MAD_ERROR_BUFPTR;
00309     goto fail;
00310   }
00311 
00312   /* stream skip */
00313   if (stream->skiplen) {
00314     if (!stream->sync)
00315       ptr = stream->this_frame;
00316 
00317     if (end - ptr < stream->skiplen) {
00318       stream->skiplen   -= end - ptr;
00319       stream->next_frame = end;
00320 
00321       stream->error = MAD_ERROR_BUFLEN;
00322       goto fail;
00323     }
00324 
00325     ptr += stream->skiplen;
00326     stream->skiplen = 0;
00327 
00328     stream->sync = 1;
00329   }
00330 
00331  sync:
00332   /* synchronize */
00333   if (stream->sync) {
00334     if (end - ptr < MAD_BUFFER_GUARD) {
00335       stream->next_frame = ptr;
00336 
00337       stream->error = MAD_ERROR_BUFLEN;
00338       goto fail;
00339     }
00340     else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
00341       /* mark point where frame sync word was expected */
00342       stream->this_frame = ptr;
00343       stream->next_frame = ptr + 1;
00344 
00345       stream->error = MAD_ERROR_LOSTSYNC;
00346       goto fail;
00347     }
00348   }
00349   else {
00350     mad_bit_init(&stream->ptr, ptr);
00351 
00352     if (mad_stream_sync(stream) == -1) {
00353       if (end - stream->next_frame >= MAD_BUFFER_GUARD)
00354     stream->next_frame = end - MAD_BUFFER_GUARD;
00355 
00356       stream->error = MAD_ERROR_BUFLEN;
00357       goto fail;
00358     }
00359 
00360     ptr = mad_bit_nextbyte(&stream->ptr);
00361   }
00362 
00363   /* begin processing */
00364   stream->this_frame = ptr;
00365   stream->next_frame = ptr + 1;  /* possibly bogus sync word */
00366 
00367   mad_bit_init(&stream->ptr, stream->this_frame);
00368 
00369   if (decode_header(header, stream) == -1)
00370     goto fail;
00371 
00372   /* calculate frame duration */
00373   mad_timer_set(&header->duration, 0,
00374         32 * MAD_NSBSAMPLES(header), header->samplerate);
00375 
00376   /* calculate free bit rate */
00377   if (header->bitrate == 0) {
00378     if ((stream->freerate == 0 || !stream->sync ||
00379      (header->layer == MAD_LAYER_III && stream->freerate > 640000)) &&
00380     free_bitrate(stream, header) == -1)
00381       goto fail;
00382 
00383     header->bitrate = stream->freerate;
00384     header->flags  |= MAD_FLAG_FREEFORMAT;
00385   }
00386 
00387   /* calculate beginning of next frame */
00388   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
00389 
00390   if (header->layer == MAD_LAYER_I)
00391     N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4;
00392   else {
00393     unsigned int slots_per_frame;
00394 
00395     slots_per_frame = (header->layer == MAD_LAYER_III &&
00396                (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
00397 
00398     N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot;
00399   }
00400 
00401   /* verify there is enough data left in buffer to decode this frame */
00402   if (N + MAD_BUFFER_GUARD > end - stream->this_frame) {
00403     stream->next_frame = stream->this_frame;
00404 
00405     stream->error = MAD_ERROR_BUFLEN;
00406     goto fail;
00407   }
00408 
00409   stream->next_frame = stream->this_frame + N;
00410 
00411   if (!stream->sync) {
00412     /* check that a valid frame header follows this frame */
00413 
00414     ptr = stream->next_frame;
00415     if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
00416       ptr = stream->next_frame = stream->this_frame + 1;
00417       goto sync;
00418     }
00419 
00420     stream->sync = 1;
00421   }
00422 
00423   header->flags |= MAD_FLAG_INCOMPLETE;
00424 
00425   return 0;
00426 
00427  fail:
00428   stream->sync = 0;
00429 
00430   return -1;
00431 }
00432 
00433 /*
00434  * NAME:    frame->decode()
00435  * DESCRIPTION: decode a single frame from a bitstream
00436  */
00437 int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream)
00438 {
00439   frame->options = stream->options;
00440 
00441   /* header() */
00442   /* error_check() */
00443 
00444   if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) &&
00445       mad_header_decode(&frame->header, stream) == -1)
00446     goto fail;
00447 
00448   /* audio_data() */
00449 
00450   frame->header.flags &= ~MAD_FLAG_INCOMPLETE;
00451 
00452   if (decoder_table[frame->header.layer - 1](stream, frame) == -1) {
00453     if (!MAD_RECOVERABLE(stream->error))
00454       stream->next_frame = stream->this_frame;
00455 
00456     goto fail;
00457   }
00458 
00459   /* ancillary_data() */
00460 
00461   if (frame->header.layer != MAD_LAYER_III) {
00462     struct mad_bitptr next_frame;
00463 
00464     mad_bit_init(&next_frame, stream->next_frame);
00465 
00466     stream->anc_ptr    = stream->ptr;
00467     stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame);
00468 
00469     mad_bit_finish(&next_frame);
00470   }
00471 
00472   return 0;
00473 
00474  fail:
00475   stream->anc_bitlen = 0;
00476   return -1;
00477 }
00478 
00479 /*
00480  * NAME:    frame->mute()
00481  * DESCRIPTION: zero all subband values so the frame becomes silent
00482  */
00483 void mad_frame_mute(struct mad_frame *frame)
00484 {
00485   unsigned int s, sb;
00486 
00487   for (s = 0; s < 36; ++s) {
00488     for (sb = 0; sb < 32; ++sb) {
00489       frame->sbsample[0][s][sb] =
00490       frame->sbsample[1][s][sb] = 0;
00491     }
00492   }
00493 
00494   if (frame->overlap) {
00495     for (s = 0; s < 18; ++s) {
00496       for (sb = 0; sb < 32; ++sb) {
00497     (frame->overlap)[0][sb][s] =
00498     (frame->overlap)[1][sb][s] = 0;
00499       }
00500     }
00501   }
00502 }