/*

* 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:

*

*/

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

  huffdec3.cpp - Huffman decoding and inverse scaling routines for AAC decoder.

  Author(s): Juha Ojanpera

  Copyright (c) 2000-2004 by Nokia Research Center, Speech and Audio Systems.

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

/*-- Projetc Headers. --*/

#include "tool2.h"

#include "dec_huf.h"

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

  Title:       DecodeSpectralCodeword

  Purpose:     Decodes one spectral Huffman codeword from the bitstream.

  Usage:       y = DecodeSpectralCodeword(huf_info, bs)

  Input:       huf_info - Huffman codebook parameters

               bs       - bitstream parameters

  Output:      y        - decoded Huffman index

  Author(s):   Juha Ojanpera

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

INLINE uint32

DecodeSpectralCodeword(Huffman_DecInfo *huf_info, TBitStream *bs)

{

  int16 len;

  int32 codeword, items;

  const Huffman_DecCode *huf_code;

  items = 1;

  huf_code = huf_info->huf;

  /*-- The first 5 LSB bits contain the length of codeword. --*/

  codeword = (int32) BsGetBits(bs, (int16)(huf_code->huf_param & 31));

  while(items < huf_info->cb_len && codeword != huf_code->codeword)

  {

    items++;

    huf_code++;

    len = (int16) (huf_code->huf_param & 31);

    if(len)

    {

      codeword <<= len;

      codeword |= BsGetBits(bs, len);

    }

  }

  /*-- Remove the length part from the decoded symbol. --*/

  return (huf_code->huf_param >> 5);

}

const uint32 hCbBitMask[20] =

{0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF,

0x1FFFL, 0x3FFFL, 0x7FFFL, 0xFFFFL, 0x1FFFFL, 0x3FFFFL, 0x7FFFFL};

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

  Title:        DecodeSfCodeword

  Purpose:      Decodes one scalefactor Huffman codeword from the bitstream.

  Usage:        y = DecodeCodeword(huf_info, bs)

  Input:        huf_info - Huffman codebook parameters

                bs       - bitstream parameters

  Output:       y        - decoded Huffman index

  Explanation:  The Huffman parameters are packed as follows :

                bits 0  -  4 : Length of codeword

                     5  - 23 : Huffman codeword

                     24 - 31 : Huffman symbol

  Author(s):    Juha Ojanpera

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

INLINE uint32

DecodeSfCodeword(Huffman_DecSfInfo *huf_info, TBitStream *bs)

{

#define SFCW_MASK ((1 << 19) - 1)

#define EXTRACT_SFCW(x) ((x >> 5) & SFCW_MASK)

  int16 bitsLeft;

  uint32 lookaheadBits;

  int32 codeword, len, items;

  const uint32 *sf_param = huf_info->sf_param;

  items = 1;

  /*-- Maximum codeword length is 19 bits! --*/

  lookaheadBits = BsLookAhead(bs, 19);

  bitsLeft = (int16) (19 - (*sf_param & 31));

  codeword = lookaheadBits >> bitsLeft;

  while(items < huf_info->cb_len && codeword != (int32) EXTRACT_SFCW(*sf_param))

  {

    items++;

    sf_param++;

    len = (int16) (*sf_param & 31);

    if(len)

    {

      bitsLeft -= len;

      codeword <<= len;

      codeword |= (lookaheadBits >> bitsLeft) & hCbBitMask[len];

    }

  }

  BsSkipNBits(bs, 19 - bitsLeft);

  return (*sf_param >> 24);

}

uint32 

GetHcb(Huffman_DecSfInfo *huf_info, TBitStream *bs)

{

  return (DecodeSfCodeword(huf_info, bs));

}

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

  Title:        huf_sfac

  Purpose:      Reads scalefactors from the bitstream.

  Usage:        y = huf_sfac(bs, cip, group, cb_map, global_gain, factors, max_sfb)

  Input:        bs          - bitstream parameters

                cip :

                 info       - block (long/short) parameters

                group       - grouping info

                cb_map      - codebook for each sfb

                global_gain - start value for the difference decoding of scalefactors

                max_sfb     - max # of sfb's present in this channel

  Output:       y           - TRUE on success, FALSE otherwise

                cip :

                 is_present - TRUE if IS stereo is used, FALSE otherwise

  Author(s):    Juha Ojanpera

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

int16

huf_sfac(TBitStream *bs, TCh_Info *cip, uint8 *group, uint8 *cb_map,

         int16 global_gain, int16 *factors, uint8 max_sfb)

{

  Huffman_DecSfInfo *sf_huf;

  int16 i, b, bb, n, is_pos;

  int16 noise_pcm_flag, noise_nrg;

  sf_huf = cip->sf_huf;

  noise_pcm_flag = 1;

  /* 

   * Scale factors are dpcm relative to global gain,

   * intensity positions are dpcm relative to zero

   */

  is_pos = 0;

  noise_nrg = (int16) (global_gain - NOISE_OFFSET);

  cip->is_present = cip->pns_present = FALSE;

  /*-- Get scale factors. --*/

  n = cip->info->sfb_per_sbk[0];

  for(b = 0, bb = 0; b < cip->info->nsbk; )

  {

    b = *group++;

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

    {

      switch(cb_map[i])

      {

        /*-- Zero book. --*/

        case ZERO_HCB:

          factors[i] = 0;

          break;

        /*-- Invalid books. --*/

        case BOOKSCL:

          return (FALSE);

        /*-- Intensity books. --*/

        case INTENSITY_HCB:

        case INTENSITY_HCB2:

          cip->is_present = TRUE;

          is_pos = (int16) (is_pos + DecodeSfCodeword(sf_huf, bs) - MIDFAC);

          factors[i] = is_pos;          

          break;

        /*-- Noise books. --*/

        case NOISE_HCB:

          cip->pns_present = TRUE;

          if(noise_pcm_flag)

          {

            noise_pcm_flag = 0;

            noise_nrg = (int16) (noise_nrg + BsGetBits(bs, NOISE_PCM_BITS) - NOISE_PCM_OFFSET);

          }

          else

            noise_nrg = (int16) (noise_nrg + DecodeSfCodeword(sf_huf, bs) - MIDFAC);

          factors[i] = noise_nrg;

          break;

        /*-- Spectral books. --*/

        default:

          global_gain = (int16) (global_gain + DecodeSfCodeword(sf_huf, bs) - MIDFAC);

          factors[i] = (int16) (global_gain & TEXP_MASK);

          break;

      }

    }

    /*-- Expand short block grouping. --*/

    if(!cip->info->islong)

      for(bb++; bb < b; bb++)

      {

        COPY_MEMORY(factors + n, factors, n * sizeof(int16));

        factors += n;

      }

    cb_map += n; factors += n;

  }

  return (TRUE);

}

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

  Title:        unpack_index...

  Purpose:      Translates Huffman index into n-tuple spectral values.

  Usage:        unpack_index(index, quant)

  Input:        index - decoded Huffman index

  Output:       quant - quantized spectral values

  Explanation:  The index contains already the translated n-tuple spectral 

                values due to computational reasons. The unpacking routines

                will only extract the codebook dependent bit fields within

                'index' to obtain the quantized values. 

  Author(s):    Juha Ojanpera

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

/*

 * 2-tuple, quantized values are unsigned.

 */

INLINE void

unpack_index2noOff(uint32 index, int16 *quant)

{

  quant[0] = (index >> 5) & 31; quant[1] = index & 31;

}

/*

 * 2-tuple, quantized values are signed.

 */

INLINE void

unpack_index2Off(uint32 index, int16 *quant)

{

  quant[0] = (index >> 4) & 7; if(index & 128) quant[0] = -quant[0];

  quant[1] = index & 7;        if(index & 8)   quant[1] = -quant[1];

}

/*

 * 4-tuple, quantized values are unsigned.

 */

INLINE void

unpack_index4noOff(uint32 index, int16 *quant)

{

  quant[0] = (index >> 6) & 3; quant[1] = (index >> 4) & 3;

  quant[2] = (index >> 2) & 3; quant[3] = index & 3;

}

/*

 * 4-tuple, quantized values are signed.

 */

INLINE void

unpack_index4Off(uint32 index, int16 *quant)

{

  quant[0] = (index >> 6) & 1; if(index & 128) quant[0] = -quant[0];

  quant[1] = (index >> 4) & 1; if(index & 32)  quant[1] = -quant[1];

  quant[2] = (index >> 2) & 1; if(index & 8)   quant[2] = -quant[2];

  quant[3] = index & 1;        if(index & 2)   quant[3] = -quant[3];

}

/*

 * Reads, at maximum, 2 sign bits from the bitstream.

 */

INLINE void

get_sign_bits2(int16 *q, TBitStream *bs)

{

  /*-- 1 signals negative, as in 2's complement. --*/

  if(q[0]) { if(BsGetBits(bs, 1)) q[0] = -q[0]; }

  if(q[1]) { if(BsGetBits(bs, 1)) q[1] = -q[1]; }

}

/*

 * Reads, at maximum, 4 sign bits from the bitstream.

 */

INLINE void

get_sign_bits4(int16 *q, TBitStream *bs)

{

  /*-- 1 signals negative, as in 2's complement. --*/

  if(q[0]) { if(BsGetBits(bs, 1)) q[0] = -q[0]; }

  if(q[1]) { if(BsGetBits(bs, 1)) q[1] = -q[1]; }

  if(q[2]) { if(BsGetBits(bs, 1)) q[2] = -q[2]; }

  if(q[3]) { if(BsGetBits(bs, 1)) q[3] = -q[3]; }

}

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

  Title:        getescape

  Purpose:      Decodes escape sequences for codebook 11.

  Usage:        y = getescape(bs, q)

  Input:        bs - bitstream parameters

                q  - decoded quantized value (0-16)

  Output:       y - actual quantized value

  Author(s):    Juha Ojanpera

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

INLINE int16

getescape(TBitStream *bs, int16 q)

{

  int16 i;

  i = q;

  /*-- Value 16 is used to indicate that the actual value is escape coded. --*/

  if(q == 16 || q == -16)

  {

    /*

     * The length of escape sequence, according to the AAC standard,

     * is less than 24 bits.

     */

    for(i = 4; i < 24; i++)

      if(BsGetBits(bs, 1) == 0)

        break;

    i = (int16) (BsGetBits(bs, i) + (1 << i));

    if(q < 0)

      i = -i;

  }

  return (i);

}

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

  Title:        huf_spec

  Purpose:      Huffman decodes and inverse scales quantized spectral values.

  Usage:        y = huf_spec(bs, info, nsect, sect, quant, huf, parseOnly)

  Input:        bs         - bitstream parameters

                info       - block (long/short) parameters

                nsect      - # of sections present in this channel

                sect       - sectioning (codebook and length of section) info        

                huf        - Spectral Huffman tables

                parseOnly  - 1 if bitstream need to be only parsed, 0 otherwise

  Output:       y          - # of spectral bins decoded

                quant      - quantized spectral coefficients

  Author(s):    Juha Ojanpera

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

int16

huf_spec(TBitStream *bs, CInfo *info, int16 nsect, uint8 *sect, int16 *quant, 

         Huffman_DecInfo **huf, uint8 parseOnly)

{

  uint32 temp;

  int16 i, j, k, stop, *qp;

  qp = quant;

  for(k = 0, i = nsect; i; i--, sect += 2)

  {

    register Huffman_DecInfo *huf_info;

    int16 table = sect[0];

    int16 top = sect[1];

    if(top > 200 || top < 1) goto error_exit;

    stop = info->bk_sfb_top[top - 1];

    switch(table)

    {

      /*-- 4-tuple signed quantized coefficients. --*/

      case 1:

      case 2:

        huf_info = huf[table - 1];

        for (j = k; j < stop; j += 4, qp += 4)

        {

          temp = DecodeSpectralCodeword(huf_info, bs);

          if(!parseOnly) unpack_index4Off(temp, qp);

        }

        break;

      /*-- 4-tuple unsigned quantized coefficients. --*/

      case 3:

      case 4:

        huf_info = huf[table - 1];    

        for (j = k; j < stop; j += 4, qp += 4)

        {

          temp = DecodeSpectralCodeword(huf_info, bs);

          unpack_index4noOff(temp, qp);

          get_sign_bits4(qp, bs);

        }

        break;

      /*-- 2-tuple unsigned quantized coefficients. --*/

      case 5:

      case 6:

        huf_info = huf[table - 1];

        for (j = k; j < stop; j += 2, qp += 2)

        {

          temp = DecodeSpectralCodeword(huf_info, bs);

          if(!parseOnly) unpack_index2Off(temp, qp);

        }

        break;

      /*-- 2-tuple signed quantized coefficients. --*/

      case 7:

      case 8:

      case 9:

      case 10:

        huf_info = huf[table - 1];

        for (j = k; j < stop; j += 2, qp += 2)

        {

          temp = DecodeSpectralCodeword(huf_info, bs);

          unpack_index2noOff(temp, qp);

          get_sign_bits2(qp, bs);

        }

        break;

      /*-- 2-tuple signed quantized coefficients (escape codebook). --*/

      case 11:

        huf_info = huf[table - 1];

        for (j = k; j < stop; j += 2, qp += 2)

        {

          temp = DecodeSpectralCodeword(huf_info, bs);

          unpack_index2noOff(temp, qp);

          get_sign_bits2(qp, bs);

          qp[0] = getescape(bs, qp[0]);

          qp[1] = getescape(bs, qp[1]);

        }

        break;

      default:

        if(stop > k)

        {

          if(!parseOnly) ZERO_MEMORY(qp, (stop - k) * sizeof(int16));

          qp = quant + stop;

        } 

        else goto error_exit;

        break;

    }

    k = stop;

  }

  if(!parseOnly) if(k < LN2) ZERO_MEMORY(quant + k, (LN2 - k) * sizeof(int16));

  return (k);

 error_exit:

  return (0);

}