diff -r 000000000000 -r 951a5db380a0 videoeditorengine/mp3aacManipLib/AACGain/src/sbr_demux.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/mp3aacManipLib/AACGain/src/sbr_demux.cpp	Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,594 @@
+/*
+* 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);
+
+  /*-- Coupling mode. --*/
+  if(BsGetBits(bs, 1)) 
+  {
+    frameDataLeft->coupling = COUPLING_LEVEL;
+    frameDataRight->coupling = COUPLING_BAL;
+  }
+  else 
+  {
+    frameDataLeft->coupling = COUPLING_OFF;
+    frameDataRight->coupling = COUPLING_OFF;
+  }
+
+  /*-- Read grid info (left channel). --*/
+  sbrReadGridInfo(bs, headerData, frameDataLeft);
+
+  /*-- Read grid info (right channel). --*/
+  if(frameDataLeft->coupling) 
+    COPY_MEMORY(&frameDataRight->frameInfo, &frameDataLeft->frameInfo, sizeof(FRAME_INFO));
+  else 
+    sbrReadGridInfo(bs, headerData, frameDataRight);
+
+  /*-- Read direction info for envelope decoding. --*/
+  sbrGetDTDFData(frameDataLeft, bs);
+  sbrGetDTDFData(frameDataRight, bs);
+
+  /*-- Read inverse filtering modes for left channel. --*/
+  frameDataLeft->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);
+
+  if(frameDataLeft->coupling) 
+  {
+    frameDataRight->sbr_invf_mode = frameDataLeft->sbr_invf_mode;
+
+    /*-- Read Huffman coded envelope + noise values for left channel. --*/
+    sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);
+    sbrGetNoiseFloorData(headerData, frameDataLeft, bs);
+
+    /*-- Read Huffman coded envelope for right channel. --*/
+    sbrGetEnvelope(headerData, frameDataRight, bs, decVal);
+  }
+  else 
+  {
+    /*-- Read inverse filtering modes for right channel. --*/
+    frameDataRight->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);
+ 
+    /*-- Read Huffman coded envelope values. --*/
+    sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);
+    sbrGetEnvelope(headerData, frameDataRight, bs, decVal);
+
+    /*-- Read noise data for left channel. --*/
+    sbrGetNoiseFloorData(headerData, frameDataLeft, bs);
+  }
+
+  /*-- Read noise data for right channel. --*/
+  sbrGetNoiseFloorData(headerData, frameDataRight, bs);
+
+  /*-- Read additional sines, if any. --*/
+  sbrGetSineData(headerData, frameDataLeft, bs);
+  sbrGetSineData(headerData, frameDataRight, bs);
+
+  /*-- Read extension data, if any. --*/
+  sbrReadExtensionData(bs, sbrExtData, 0);
+
+  return (1);
+}