bitstream.c

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 
 
/**************************************************************************************
 * Fixed-point MP3 decoder
 * Jon Recker (jrecker@real.com), Ken Cooke (kenc@real.com)
 * June 2003
 *
 * bitstream.c - bitstream unpacking, frame header parsing, side info parsing
 **************************************************************************************/
 
#include "coder.h"
#include "assembly.h"
 
/**************************************************************************************
 * Function:    SetBitstreamPointer
 *
 * Description: initialize bitstream reader
 *
 * Inputs:      pointer to BitStreamInfo struct
 *              number of bytes in bitstream
 *              pointer to byte-aligned buffer of data to read from
 *
 * Outputs:     filled bitstream info struct
 *
 * Return:      none
 **************************************************************************************/
void SetBitstreamPointer(BitStreamInfo *bsi, int nBytes, unsigned char *buf)
{
  /* init bitstream */
  bsi->bytePtr = buf;
  bsi->iCache = 0;    /* 4-byte unsigned int */
  bsi->cachedBits = 0;  /* i.e. zero bits in cache */
  bsi->nBytes = nBytes;
}
 
/**************************************************************************************
 * Function:    RefillBitstreamCache
 *
 * Description: read new data from bitstream buffer into bsi cache
 *
 * Inputs:      pointer to initialized BitStreamInfo struct
 *
 * Outputs:     updated bitstream info struct
 *
 * Return:      none
 *
 * Notes:       only call when iCache is completely drained (resets bitOffset to 0)
 *              always loads 4 new bytes except when bsi->nBytes < 4 (end of buffer)
 *              stores data as big-endian in cache, regardless of machine endian-ness
 *
 * TODO:        optimize for ARM
 *              possibly add little/big-endian modes for doing 32-bit loads
 **************************************************************************************/
static __inline void RefillBitstreamCache(BitStreamInfo *bsi)
{
  int nBytes = bsi->nBytes;
 
  /* optimize for common case, independent of machine endian-ness */
  if (nBytes >= 4) {
    bsi->iCache  = (*bsi->bytePtr++) << 24;
    bsi->iCache |= (*bsi->bytePtr++) << 16;
    bsi->iCache |= (*bsi->bytePtr++) <<  8;
    bsi->iCache |= (*bsi->bytePtr++);
    bsi->cachedBits = 32;
    bsi->nBytes -= 4;
  } else {
    bsi->iCache = 0;
    while (nBytes--) {
      bsi->iCache |= (*bsi->bytePtr++);
      bsi->iCache <<= 8;
    }
    bsi->iCache <<= ((3 - bsi->nBytes)*8);
    bsi->cachedBits = 8*bsi->nBytes;
    bsi->nBytes = 0;
  }
}
 
/**************************************************************************************
 * Function:    GetBits
 *
 * Description: get bits from bitstream, advance bitstream pointer
 *
 * Inputs:      pointer to initialized BitStreamInfo struct
 *              number of bits to get from bitstream
 *
 * Outputs:     updated bitstream info struct
 *
 * Return:      the next nBits bits of data from bitstream buffer
 *
 * Notes:       nBits must be in range [0, 31], nBits outside this range masked by 0x1f
 *              for speed, does not indicate error if you overrun bit buffer 
 *              if nBits = 0, returns 0 (useful for scalefactor unpacking)
 *
 * TODO:        optimize for ARM
 **************************************************************************************/
unsigned int GetBits(BitStreamInfo *bsi, int nBits)
{
  unsigned int data, lowBits;
 
  nBits &= 0x1f;              /* nBits mod 32 to avoid unpredictable results like >> by negative amount */
  data = bsi->iCache >> (31 - nBits);   /* unsigned >> so zero-extend */
  data >>= 1;               /* do as >> 31, >> 1 so that nBits = 0 works okay (returns 0) */
  bsi->iCache <<= nBits;          /* left-justify cache */
  bsi->cachedBits -= nBits;       /* how many bits have we drawn from the cache so far */
 
  /* if we cross an int boundary, refill the cache */
  if (bsi->cachedBits < 0) {
    lowBits = -bsi->cachedBits;
    RefillBitstreamCache(bsi);
    data |= bsi->iCache >> (32 - lowBits);    /* get the low-order bits */
  
    bsi->cachedBits -= lowBits;     /* how many bits have we drawn from the cache so far */
    bsi->iCache <<= lowBits;      /* left-justify cache */
  }
 
  return data;
}
 
/**************************************************************************************
 * Function:    CalcBitsUsed
 *
 * Description: calculate how many bits have been read from bitstream
 *
 * Inputs:      pointer to initialized BitStreamInfo struct
 *              pointer to start of bitstream buffer
 *              bit offset into first byte of startBuf (0-7) 
 *
 * Outputs:     none
 *
 * Return:      number of bits read from bitstream, as offset from startBuf:startOffset
 **************************************************************************************/
int CalcBitsUsed(BitStreamInfo *bsi, unsigned char *startBuf, int startOffset)
{
  int bitsUsed;
 
  bitsUsed  = (int)(bsi->bytePtr - startBuf) * 8;
  bitsUsed -= bsi->cachedBits;
  bitsUsed -= startOffset;
 
  return bitsUsed;
}
 
/**************************************************************************************
 * Function:    CheckPadBit
 *
 * Description: check whether padding byte is present in an MP3 frame
 *
 * Inputs:      MP3DecInfo struct with valid FrameHeader struct 
 *                (filled by UnpackFrameHeader())
 *
 * Outputs:     none
 *
 * Return:      1 if pad bit is set, 0 if not, -1 if null input pointer
 **************************************************************************************/
int CheckPadBit(MP3DecInfo *mp3DecInfo)
{
  FrameHeader *fh;
 
  /* validate pointers */
  if (!mp3DecInfo || !mp3DecInfo->FrameHeaderPS)
    return -1;
 
  fh = ((FrameHeader *)(mp3DecInfo->FrameHeaderPS));
 
  return (fh->paddingBit ? 1 : 0);
}
 
/**************************************************************************************
 * Function:    UnpackFrameHeader
 *
 * Description: parse the fields of the MP3 frame header
 *
 * Inputs:      buffer pointing to a complete MP3 frame header (4 bytes, plus 2 if CRC)
 *
 * Outputs:     filled frame header info in the MP3DecInfo structure
 *              updated platform-specific FrameHeader struct
 *
 * Return:      length (in bytes) of frame header (for caller to calculate offset to
 *                first byte following frame header)
 *              -1 if null frameHeader or invalid header
 *
 * TODO:        check for valid modes, depending on capabilities of decoder
 *              test CRC on actual stream (verify no endian problems)
 **************************************************************************************/
int UnpackFrameHeader(MP3DecInfo *mp3DecInfo, unsigned char *buf)
{
 
  int verIdx;
  FrameHeader *fh;
 
  /* validate pointers and sync word */
  if (!mp3DecInfo || !mp3DecInfo->FrameHeaderPS || (buf[0] & SYNCWORDH) != SYNCWORDH || (buf[1] & SYNCWORDL) != SYNCWORDL)
    return -1;
 
  fh = ((FrameHeader *)(mp3DecInfo->FrameHeaderPS));
 
  /* read header fields - use bitmasks instead of GetBits() for speed, since format never varies */
  verIdx =         (buf[1] >> 3) & 0x03;
  fh->ver =        (MPEGVersion)( verIdx == 0 ? MPEG25 : ((verIdx & 0x01) ? MPEG1 : MPEG2) );
  fh->layer = 4 - ((buf[1] >> 1) & 0x03);     /* easy mapping of index to layer number, 4 = error */
  fh->crc =   1 - ((buf[1] >> 0) & 0x01);
  fh->brIdx =      (buf[2] >> 4) & 0x0f;
  fh->srIdx =      (buf[2] >> 2) & 0x03;
  fh->paddingBit = (buf[2] >> 1) & 0x01;
  fh->privateBit = (buf[2] >> 0) & 0x01;
  fh->sMode =      (StereoMode)((buf[3] >> 6) & 0x03);      /* maps to correct enum (see definition) */    
  fh->modeExt =    (buf[3] >> 4) & 0x03;
  fh->copyFlag =   (buf[3] >> 3) & 0x01;
  fh->origFlag =   (buf[3] >> 2) & 0x01;
  fh->emphasis =   (buf[3] >> 0) & 0x03;
 
  /* check parameters to avoid indexing tables with bad values */
  if (fh->srIdx == 3 || fh->layer == 4 || fh->brIdx == 15)
    return -1;
 
  fh->sfBand = &sfBandTable[fh->ver][fh->srIdx];  /* for readability (we reference sfBandTable many times in decoder) */
  if (fh->sMode != Joint)   /* just to be safe (dequant, stproc check fh->modeExt) */
    fh->modeExt = 0;
 
  /* init user-accessible data */
  mp3DecInfo->nChans = (fh->sMode == Mono ? 1 : 2);
  mp3DecInfo->samprate = samplerateTab[fh->ver][fh->srIdx];
  mp3DecInfo->nGrans = (fh->ver == MPEG1 ? NGRANS_MPEG1 : NGRANS_MPEG2);
  mp3DecInfo->nGranSamps = ((int)samplesPerFrameTab[fh->ver][fh->layer - 1]) / mp3DecInfo->nGrans;
  mp3DecInfo->layer = fh->layer;
  mp3DecInfo->version = fh->ver;
 
  /* get bitrate and nSlots from table, unless brIdx == 0 (free mode) in which case caller must figure it out himself
   * question - do we want to overwrite mp3DecInfo->bitrate with 0 each time if it's free mode, and
   *  copy the pre-calculated actual free bitrate into it in mp3dec.c (according to the spec, 
   *  this shouldn't be necessary, since it should be either all frames free or none free)
   */
  if (fh->brIdx) {
    mp3DecInfo->bitrate = ((int)bitrateTab[fh->ver][fh->layer - 1][fh->brIdx]) * 1000;
  
    /* nSlots = total frame bytes (from table) - sideInfo bytes - header - CRC (if present) + pad (if present) */
    mp3DecInfo->nSlots = (int)slotTab[fh->ver][fh->srIdx][fh->brIdx] - 
      (int)sideBytesTab[fh->ver][(fh->sMode == Mono ? 0 : 1)] - 
      4 - (fh->crc ? 2 : 0) + (fh->paddingBit ? 1 : 0);
  } else {
    /* do not support free mode */
    return -1;
  }
 
  /* load crc word, if enabled, and return length of frame header (in bytes) */
  if (fh->crc) {
    fh->CRCWord = ((int)buf[4] << 8 | (int)buf[5] << 0);
    return 6;
  } else {
    fh->CRCWord = 0;
    return 4;
  }
}
 
/**************************************************************************************
 * Function:    UnpackSideInfo
 *
 * Description: parse the fields of the MP3 side info header
 *
 * Inputs:      MP3DecInfo structure filled by UnpackFrameHeader()
 *              buffer pointing to the MP3 side info data
 *
 * Outputs:     updated mainDataBegin in MP3DecInfo struct
 *              updated private (platform-specific) SideInfo struct
 *
 * Return:      length (in bytes) of side info data
 *              -1 if null input pointers
 **************************************************************************************/
int UnpackSideInfo(MP3DecInfo *mp3DecInfo, unsigned char *buf)
{
  int gr, ch, bd, nBytes;
  BitStreamInfo bitStreamInfo, *bsi;
  FrameHeader *fh;
  SideInfo *si;
  SideInfoSub *sis;
 
  /* validate pointers and sync word */
  if (!mp3DecInfo || !mp3DecInfo->FrameHeaderPS || !mp3DecInfo->SideInfoPS)
    return -1;
 
  fh = ((FrameHeader *)(mp3DecInfo->FrameHeaderPS));
  si = ((SideInfo *)(mp3DecInfo->SideInfoPS));
 
  bsi = &bitStreamInfo;
  if (fh->ver == MPEG1) {
    /* MPEG 1 */
    nBytes = (fh->sMode == Mono ? SIBYTES_MPEG1_MONO : SIBYTES_MPEG1_STEREO);
    SetBitstreamPointer(bsi, nBytes, buf);
    si->mainDataBegin = GetBits(bsi, 9);
    si->privateBits =   GetBits(bsi, (fh->sMode == Mono ? 5 : 3));
 
    for (ch = 0; ch < mp3DecInfo->nChans; ch++)
      for (bd = 0; bd < MAX_SCFBD; bd++)
        si->scfsi[ch][bd] = GetBits(bsi, 1);
  } else {
    /* MPEG 2, MPEG 2.5 */
    nBytes = (fh->sMode == Mono ? SIBYTES_MPEG2_MONO : SIBYTES_MPEG2_STEREO);
    SetBitstreamPointer(bsi, nBytes, buf);
    si->mainDataBegin = GetBits(bsi, 8);
    si->privateBits =   GetBits(bsi, (fh->sMode == Mono ? 1 : 2));
  }
 
  for(gr =0; gr < mp3DecInfo->nGrans; gr++) {
    for (ch = 0; ch < mp3DecInfo->nChans; ch++) {
      sis = &si->sis[gr][ch];           /* side info subblock for this granule, channel */
 
      sis->part23Length =    GetBits(bsi, 12);
      sis->nBigvals =        GetBits(bsi, 9);
      sis->globalGain =      GetBits(bsi, 8);
      sis->sfCompress =      GetBits(bsi, (fh->ver == MPEG1 ? 4 : 9));
      sis->winSwitchFlag =   GetBits(bsi, 1);
 
      if(sis->winSwitchFlag) {
        /* this is a start, stop, short, or mixed block */
        sis->blockType =       GetBits(bsi, 2);   /* 0 = normal, 1 = start, 2 = short, 3 = stop */
        sis->mixedBlock =      GetBits(bsi, 1);   /* 0 = not mixed, 1 = mixed */
        sis->tableSelect[0] =  GetBits(bsi, 5);
        sis->tableSelect[1] =  GetBits(bsi, 5);
        sis->tableSelect[2] =  0;         /* unused */
        sis->subBlockGain[0] = GetBits(bsi, 3);
        sis->subBlockGain[1] = GetBits(bsi, 3);
        sis->subBlockGain[2] = GetBits(bsi, 3);
 
        /* TODO - check logic */
        if (sis->blockType == 0) {
          /* this should not be allowed, according to spec */
          sis->nBigvals = 0;
          sis->part23Length = 0;
          sis->sfCompress = 0;
        } else if (sis->blockType == 2 && sis->mixedBlock == 0) {
          /* short block, not mixed */
          sis->region0Count = 8;
        } else {
          /* start, stop, or short-mixed */
          sis->region0Count = 7;
        }
        sis->region1Count = 20 - sis->region0Count;
      } else {
        /* this is a normal block */
        sis->blockType = 0;
        sis->mixedBlock = 0;
        sis->tableSelect[0] =  GetBits(bsi, 5);
        sis->tableSelect[1] =  GetBits(bsi, 5);
        sis->tableSelect[2] =  GetBits(bsi, 5);
        sis->region0Count =    GetBits(bsi, 4);
        sis->region1Count =    GetBits(bsi, 3);
      }
      sis->preFlag =           (fh->ver == MPEG1 ? GetBits(bsi, 1) : 0);
      sis->sfactScale =        GetBits(bsi, 1);
      sis->count1TableSelect = GetBits(bsi, 1);
    }
  }
  mp3DecInfo->mainDataBegin = si->mainDataBegin;  /* needed by main decode loop */
 
  ASSERT(nBytes == CalcBitsUsed(bsi, buf, 0) >> 3);
 
  return nBytes;  
}