/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:

*

*/

/*

  \file

  \brief SBR codec implementation $Revision: 1.1.1.1.4.1 $

*/

/**************************************************************************

  sbr_demux.cpp - SBR bitstream demultiplexer implementations.

  Author(s): Juha Ojanpera

  Copyright (c) 2004 by Nokia Research Center, Multimedia Technologies.

  *************************************************************************/

/*-- Project Headers. --*/

#include "sbr_rom.h"

#include "env_extr.h"

typedef const int8 (*Huffman)[2];

/*

  \brief   Decodes Huffman codeword from TBitStream

  \return  Decoded Huffman value.

*/

int16

DecodeHuffmanCW(Huffman h, TBitStream *bs)

{

  int16 value, bit, index = 0;

  while(index >= 0) 

  {

    bit = (int16) BsGetBits(bs, 1);

    index = h[index][bit];

  }

  value = index + 64;

  return (value);

}

/*

  \brief   Reads direction control data from TBitStream

*/

void

sbrGetDTDFData(SbrFrameData *frameData, TBitStream *bs)

{

  frameData->domain_vec = (uint8) BsGetBits(bs, frameData->frameInfo.nEnvelopes);

  frameData->domain_vec_noise = (uint8) BsGetBits(bs, frameData->frameInfo.nNoiseEnvelopes);

}

/*

  \brief   Reads noise-floor-level data from TBitStream

*/

void

sbrGetNoiseFloorData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)

{

  int16 i, j, k, noNoiseBands;

  Huffman hcb_noiseF, hcb_noise;

  noNoiseBands = headerData->hFreqBandData->nNfb;

  if(frameData->coupling == COUPLING_BAL) 

  {

    hcb_noise = (Huffman) &sbr_huffBook_NoiseBalance11T;

    hcb_noiseF = (Huffman) &sbr_huffBook_EnvBalance11F;

  }

  else 

  {

    hcb_noise = (Huffman) &sbr_huffBook_NoiseLevel11T;

    hcb_noiseF = (Huffman) &sbr_huffBook_EnvLevel11F;

  }

  k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nNoiseEnvelopes;

  for(i = 0; i < frameData->frameInfo.nNoiseEnvelopes; i++, k++) 

  {

    uint8 codValue;

    int16 index = i * noNoiseBands;

    codValue = frameData->domain_vec_noise & bitArray[k];

    if(!codValue) 

    {

      frameData->sbrNoiseFloorLevel[index++] = (int16) BsGetBits(bs, 5);

      for(j = 1; j < noNoiseBands; j++, index++) 

        frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noiseF, bs);

    }

    else 

    {

      for(j = 0; j < noNoiseBands; j++, index++)

        frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noise, bs);

    }

  }

}

/*

  \brief   Reads envelope data from TBitStream

  \return  One on success.

*/

int16

sbrGetEnvelope(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs, int16 decVal)

{

  Huffman hcb_t, hcb_f;

  uint8 no_band[MAX_ENVELOPES];

  int16 i, j, k, delta, offset, ampRes;

  int16 start_bits, start_bits_balance;

  ampRes = headerData->ampResolution;

  if(frameData->frameInfo.frameClass == FIXFIX && frameData->frameInfo.nEnvelopes == 1)

    ampRes = SBR_AMP_RES_1_5;

  if(ampRes == SBR_AMP_RES_3_0)

  {

    start_bits = 6;

    start_bits_balance = 5;

  }

  else

  {

    start_bits = 7;

    start_bits_balance = 6;

  }

  k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;

  for(i = 0; i < frameData->frameInfo.nEnvelopes; i++, k++) 

  {

    uint8 resValue = (frameData->frameInfo.freqRes & bitArray[k]) ? 1 : 0;

    no_band[i] = headerData->hFreqBandData->nSfb[resValue];

  }

  if(frameData->coupling == COUPLING_BAL) 

  {

    if(ampRes == SBR_AMP_RES_1_5) 

    {

      hcb_t = (Huffman) &sbr_huffBook_EnvBalance10T;

      hcb_f = (Huffman) &sbr_huffBook_EnvBalance10F;

    }

    else 

    {

      hcb_t = (Huffman) &sbr_huffBook_EnvBalance11T;

      hcb_f = (Huffman) &sbr_huffBook_EnvBalance11F;

    }

  }

  else 

  {

    if(ampRes == SBR_AMP_RES_1_5) 

    {

      hcb_t = (Huffman) &sbr_huffBook_EnvLevel10T;

      hcb_f = (Huffman) &sbr_huffBook_EnvLevel10F;

    }

    else 

    {

      hcb_t = (Huffman) &sbr_huffBook_EnvLevel11T;

      hcb_f = (Huffman) &sbr_huffBook_EnvLevel11F;

    }

  }

  decVal = (ampRes) ? decVal : decVal << 1;

  k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;

  for(j = 0, offset = 0; j < frameData->frameInfo.nEnvelopes; j++, k++) 

  {

    uint8 codValue = frameData->domain_vec & bitArray[k];

    if(!codValue) 

    {

      if(frameData->coupling == COUPLING_BAL)

        frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits_balance);

      else 

      {

        frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits);

        frameData->iEnvelope[offset] -= decVal;

        if(frameData->iEnvelope[offset] < 0)

          frameData->iEnvelope[offset] = 0;          

      }

    }

    for(i = (1 - ((codValue) ? 1 : 0)); i < no_band[j]; i++) 

    {

      if(!codValue) 

        delta = DecodeHuffmanCW(hcb_f, bs);

      else 

      {

        delta = DecodeHuffmanCW(hcb_t, bs);

        if(i == 0)

          delta -= decVal;

      }

      frameData->iEnvelope[offset + i] = delta;

    }

    offset += no_band[j];

  }

  return (1);

}

/*

  \brief   Extracts the frame information from the TBitStream

  \return  One on success

*/

int16

sbrReadGridInfo(TBitStream *bs, SbrHeaderData *headerData, SbrFrameData *frameData)

{

  uint8 tmp;

  FRAME_INFO *frameInfo;

  SbrGridInfo *sbrGridInfo;

  int16 pointer_bits, nEnv, k, staticFreqRes;

  nEnv = 0;

  frameInfo = &frameData->frameInfo;

  sbrGridInfo = &frameData->sbrGridInfo;

  frameInfo->frameClass = (uint8) BsGetBits(bs, 2);

  switch(frameInfo->frameClass) 

  {

    case FIXFIX:

      sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);

      staticFreqRes = (int16) BsGetBits(bs, 1);

      nEnv = (int16) (1 << sbrGridInfo->bs_num_env);

      if(sbrGridInfo->bs_num_env < 3 && headerData->numberTimeSlots == 16)

        COPY_MEMORY(frameInfo, &(sbr_staticFrameInfo[sbrGridInfo->bs_num_env]), sizeof(FRAME_INFO));

      if(!staticFreqRes)

        frameInfo->freqRes = 0;

      break;

    case FIXVAR:

    case VARFIX:

      sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);

      sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);

      nEnv = sbrGridInfo->bs_num_env + 1;

      for(k = 0; k < sbrGridInfo->bs_num_env; k++) 

        sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);

      pointer_bits = (int16) (FloatFR_logDualis(sbrGridInfo->bs_num_env + 2) + 0.992188f);

      sbrGridInfo->bs_pointer = (uint8) BsGetBits(bs, pointer_bits);

      break;

  }

  switch(frameInfo->frameClass) 

  {

    case FIXVAR:

      frameInfo->freqRes = 0;

      tmp = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);

      for(k = sbrGridInfo->bs_num_env; k >= 0; k--)

      {

        frameInfo->freqRes <<= 1;

        frameInfo->freqRes  |= tmp & 0x1;

        tmp >>= 1;

      }

      break;

    case VARFIX:

      frameInfo->freqRes = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);

      break;

    case VARVAR:

      sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);

      sbrGridInfo->bs_var_board[1] = (uint8) BsGetBits(bs, 2);

      sbrGridInfo->bs_num_rel[0] = (uint8) BsGetBits(bs, 2);

      sbrGridInfo->bs_num_rel[1] = (uint8) BsGetBits(bs, 2);

      nEnv = sbrGridInfo->bs_num_rel[0] + sbrGridInfo->bs_num_rel[1] + 1;

      for(k = 0; k < sbrGridInfo->bs_num_rel[0]; k++)

        sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);

      for(k = 0; k < sbrGridInfo->bs_num_rel[1]; k++) 

        sbrGridInfo->bs_rel_board_1[k] = (uint8) BsGetBits(bs, 2);

      pointer_bits = (int16) (FloatFR_logDualis(nEnv + 1) + 0.992188f);

      sbrGridInfo->bs_pointer = (int16) BsGetBits(bs, pointer_bits);

      frameInfo->freqRes = (uint8) BsGetBits(bs, nEnv);

      break;

  }

  frameInfo->nEnvelopes = (uint8) nEnv;

  frameInfo->nNoiseEnvelopes = (nEnv == 1) ? 1 : 2;

  return (1);

}

/*

  \brief     Initializes SBR header data

*/

void

initHeaderData(SbrHeaderData *headerData, FreqBandData *freqBandData,

               int32 sampleRate, int16 samplesPerFrame)

{

  FreqBandData *hFreq = freqBandData;

  COPY_MEMORY(headerData, &sbr_defaultHeader, sizeof(SbrHeaderData));

  headerData->hFreqBandData = hFreq;

  headerData->codecFrameSize = samplesPerFrame;

  headerData->outSampleRate = SBR_UPSAMPLE_FAC * sampleRate;

  headerData->numberTimeSlots = samplesPerFrame >> (4 + headerData->timeStep);

}

/*

  \brief   Reads header data from TBitStream

  \return  Processing status - HEADER_RESET or HEADER_OK

*/

SBR_HEADER_STATUS

sbrGetHeaderData(SbrHeaderData *h_sbr_header, TBitStream *bs)

{

  SbrHeaderData lastHeader;

  uint8 headerExtra1, headerExtra2;

  COPY_MEMORY(&lastHeader, h_sbr_header, sizeof(SbrHeaderData));

  h_sbr_header->ampResolution = (uint8) BsGetBits(bs, 1);

  h_sbr_header->startFreq = (uint8) BsGetBits(bs, 4);

  h_sbr_header->stopFreq = (uint8) BsGetBits(bs, 4);

  h_sbr_header->xover_band = (uint8) BsGetBits(bs, 3);

  BsGetBits(bs, 2);

  headerExtra1 = (uint8) BsGetBits(bs, 1);

  headerExtra2 = (uint8) BsGetBits(bs, 1);

  if(headerExtra1) 

  {

    h_sbr_header->freqScale = (uint8) BsGetBits(bs, 2);

    h_sbr_header->alterScale = (uint8) BsGetBits(bs, 1);

    h_sbr_header->noise_bands = (uint8) BsGetBits(bs, 2);

  }

  else 

  {

    h_sbr_header->freqScale   = SBR_FREQ_SCALE_DEF;

    h_sbr_header->alterScale  = SBR_ALTER_SCALE_DEF;

    h_sbr_header->noise_bands = SBR_NOISE_BANDS_DEF;

  }

  if(headerExtra2) 

  {

    h_sbr_header->limiterBands = (uint8) BsGetBits(bs, 2);

    h_sbr_header->limiterGains = (uint8) BsGetBits(bs, 2);

    h_sbr_header->interpolFreq = (uint8) BsGetBits(bs, 1);

    h_sbr_header->smoothingLength = (uint8) BsGetBits(bs, 1);

  }

  else 

  {

    h_sbr_header->limiterBands    = SBR_LIMITER_BANDS_DEF;

    h_sbr_header->limiterGains    = SBR_LIMITER_GAINS_DEF;

    h_sbr_header->interpolFreq    = SBR_INTERPOL_FREQ_DEF;

    h_sbr_header->smoothingLength = SBR_SMOOTHING_LENGTH_DEF;

  }

  if(h_sbr_header->syncState != SBR_ACTIVE                ||

     lastHeader.startFreq    != h_sbr_header->startFreq   ||

     lastHeader.stopFreq     != h_sbr_header->stopFreq    ||

     lastHeader.xover_band   != h_sbr_header->xover_band  ||

     lastHeader.freqScale    != h_sbr_header->freqScale   ||

     lastHeader.alterScale   != h_sbr_header->alterScale  ||

     lastHeader.noise_bands  != h_sbr_header->noise_bands) 

    return (HEADER_RESET); /*-- New settings --*/

  return (HEADER_OK);

}

/*

  \brief   Reads additional harmonics parameters

  \return  Number of bits read

*/

static int16

sbrGetSineData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)

{

  int16 bitsRead;

  bitsRead = 1;

  frameData->isSinesPresent = (uint8) BsGetBits(bs, 1);

  if(frameData->isSinesPresent)

  {

    int16 rSfb;

    bitsRead += headerData->hFreqBandData->nSfb[1];

    rSfb = (headerData->hFreqBandData->nSfb[1] > 32) ? 32 : headerData->hFreqBandData->nSfb[1];

    frameData->addHarmonics[0] = (uint8) BsGetBits(bs, rSfb);

    if(headerData->hFreqBandData->nSfb[1] > 32)

    {

      rSfb = headerData->hFreqBandData->nSfb[1] - 32;

      frameData->addHarmonics[1] = (uint8) BsGetBits(bs, rSfb);

    }

  }

  return (bitsRead);

}

/*

  \brief      Reads extension data from the TBitStream

*/

static void 

sbrReadExtensionData(TBitStream *bs, SbrExtensionData *sbrExtData, uint8 isMono)

{

  sbrExtData->writePsData = 0;

  sbrExtData->extensionDataPresent = (uint8) BsGetBits(bs, 1);

  if(sbrExtData->extensionDataPresent) 

  {

    int16 i, nBitsLeft, cnt;

    cnt = (int16) BsGetBits(bs, 4);

    if(cnt == 15)

      cnt += (int16) BsGetBits(bs, 8);

    sbrExtData->byteCount = MIN(cnt, sbrExtData->extDataBufLen);

    nBitsLeft = cnt << 3;

    while(nBitsLeft > 7) 

    {

      sbrExtData->extension_id = (uint8) BsGetBits(bs, 2);

      if(!(sbrExtData->extension_id == SBR_PARAMETRIC_STEREO_ID && isMono))

        sbrExtData->extension_id = 0;

      else

        sbrExtData->writePsData = 1;

      nBitsLeft -= 2;

      cnt = (int16) ((uint16) nBitsLeft >> 3);

      if(sbrExtData->extDataBufLen)

      {

        for(i = 0; i < MIN(cnt, sbrExtData->extDataBufLen); i++)

          sbrExtData->extensioData[i] = (uint8) BsGetBits(bs, 8);

        for( ; i < cnt; i++)

          BsGetBits(bs, 8);

      }

      else

        for(i = 0; i < cnt; i++)

          BsGetBits(bs, 8);

      nBitsLeft -= cnt << 3;

    }

    BsGetBits(bs, nBitsLeft);

  }

}

/*

  \brief   Reads TBitStream elements of one channel

  \return  One on success

*/

int16

sbrGetSCE(SbrHeaderData *headerData, SbrFrameData *frameData,

          SbrExtensionData *sbrExtData, TBitStream *bs, 

          int16 decVal, uint8 isMono)

{

  frameData->coupling = COUPLING_OFF;

  /*-- Data present. --*/

  frameData->dataPresent = (int16) BsGetBits(bs, 1);

  if(frameData->dataPresent) BsGetBits(bs, 4);

  /*-- Read grid info. --*/

  sbrReadGridInfo(bs, headerData, frameData);

  /*-- Read direction info for envelope decoding. --*/

  sbrGetDTDFData(frameData, bs);

  /*-- Read inverse filtering modes. --*/

  frameData->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);

  /*-- Read Huffman coded envelope values. --*/

  sbrGetEnvelope(headerData, frameData, bs, decVal);

  /*-- Read noise data. --*/

  sbrGetNoiseFloorData(headerData, frameData, bs);

  /*-- Read sine data, if any. --*/

  sbrGetSineData(headerData, frameData, bs);

  /*-- Read extension data, if any. --*/

  sbrReadExtensionData(bs, sbrExtData, isMono);

  return (1);

}

/*

  \brief      Reads TBitStream elements of a channel pair

  \return     One on success

*/

int16

sbrGetCPE(SbrHeaderData *headerData, SbrFrameData *frameDataLeft,

          SbrFrameData *frameDataRight, SbrExtensionData *sbrExtData,

          TBitStream *bs, int16 decVal)

{

  /*-- Data present. -*/

  frameDataLeft->dataPresent = (uint8) BsGetBits(bs, 1);

  if(frameDataLeft->dataPresent)

    BsGetBits(bs, 8);