/* -----------------------------------------------------------------------------

Software License for The Fraunhofer FDK AAC Codec Library for Android

© Copyright  1995 - 2019 Fraunhofer-Gesellschaft zur Förderung der angewandten

Forschung e.V. All rights reserved.

 1.    INTRODUCTION

The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software

that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding

scheme for digital audio. This FDK AAC Codec software is intended to be used on

a wide variety of Android devices.

AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient

general perceptual audio codecs. AAC-ELD is considered the best-performing

full-bandwidth communications codec by independent studies and is widely

deployed. AAC has been standardized by ISO and IEC as part of the MPEG

specifications.

Patent licenses for necessary patent claims for the FDK AAC Codec (including

those of Fraunhofer) may be obtained through Via Licensing

(www.vialicensing.com) or through the respective patent owners individually for

the purpose of encoding or decoding bit streams in products that are compliant

with the ISO/IEC MPEG audio standards. Please note that most manufacturers of

Android devices already license these patent claims through Via Licensing or

directly from the patent owners, and therefore FDK AAC Codec software may

already be covered under those patent licenses when it is used for those

licensed purposes only.

Commercially-licensed AAC software libraries, including floating-point versions

with enhanced sound quality, are also available from Fraunhofer. Users are

encouraged to check the Fraunhofer website for additional applications

information and documentation.

2.    COPYRIGHT LICENSE

Redistribution and use in source and binary forms, with or without modification,

are permitted without payment of copyright license fees provided that you

satisfy the following conditions:

You must retain the complete text of this software license in redistributions of

the FDK AAC Codec or your modifications thereto in source code form.

You must retain the complete text of this software license in the documentation

and/or other materials provided with redistributions of the FDK AAC Codec or

your modifications thereto in binary form. You must make available free of

charge copies of the complete source code of the FDK AAC Codec and your

modifications thereto to recipients of copies in binary form.

The name of Fraunhofer may not be used to endorse or promote products derived

from this library without prior written permission.

You may not charge copyright license fees for anyone to use, copy or distribute

the FDK AAC Codec software or your modifications thereto.

Your modified versions of the FDK AAC Codec must carry prominent notices stating

that you changed the software and the date of any change. For modified versions

of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"

must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK

AAC Codec Library for Android."

3.    NO PATENT LICENSE

NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without

limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.

Fraunhofer provides no warranty of patent non-infringement with respect to this

software.

You may use this FDK AAC Codec software or modifications thereto only for

purposes that are authorized by appropriate patent licenses.

4.    DISCLAIMER

This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright

holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,

including but not limited to the implied warranties of merchantability and

fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,

or consequential damages, including but not limited to procurement of substitute

goods or services; loss of use, data, or profits, or business interruption,

however caused and on any theory of liability, whether in contract, strict

liability, or tort (including negligence), arising in any way out of the use of

this software, even if advised of the possibility of such damage.

5.    CONTACT INFORMATION

Fraunhofer Institute for Integrated Circuits IIS

Attention: Audio and Multimedia Departments - FDK AAC LL

Am Wolfsmantel 33

91058 Erlangen, Germany

www.iis.fraunhofer.de/amm

amm-info@iis.fraunhofer.de

----------------------------------------------------------------------------- */

/**************************** AAC decoder library ******************************

   Author(s):   Robert Weidner (DSP Solutions)

   Description: HCR Decoder: HCR initialization, preprocess HCR sideinfo,

                decode priority codewords (PCWs)

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

#include "aacdec_hcr.h"

#include "aacdec_hcr_types.h"

#include "aacdec_hcr_bit.h"

#include "aacdec_hcrs.h"

#include "aac_ram.h"

#include "aac_rom.h"

#include "channel.h"

#include "block.h"

#include "aacdecoder.h" /* for ID_CPE, ID_SCE ... */

#include "FDK_bitstream.h"

extern int mlFileChCurr;

static void errDetectorInHcrSideinfoShrt(SCHAR cb, SHORT numLine,

                                         UINT *errorWord);

static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword,

                                    SHORT lengthOfReorderedSpectralData,

                                    UINT *errorWord);

static void HcrCalcNumCodeword(H_HCR_INFO pHcr);

static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr);

static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr);

static void HcrExtendedSectionInfo(H_HCR_INFO pHcr);

static void DeriveNumberOfExtendedSortedSectionsInSets(

    UINT numSegment, USHORT *pNumExtendedSortedCodewordInSection,

    int numExtendedSortedCodewordInSectionIdx,

    USHORT *pNumExtendedSortedSectionsInSets,

    int numExtendedSortedSectionsInSetsIdx);

static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,

                                INT quantSpecCoef, INT *pLeftStartOfSegment,

                                SCHAR *pRemainingBitsInSegment,

                                int *pNumDecodedBits, UINT *errorWord);

static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,

                          UINT codebookDim, const SCHAR *pQuantVal,

                          FIXP_DBL *pQuantSpecCoef, int *quantSpecCoefIdx,

                          INT *pLeftStartOfSegment,

                          SCHAR *pRemainingBitsInSegment, int *pNumDecodedBits);

static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,

                                   const UINT *pCurrentTree,

                                   const SCHAR *pQuantValBase,

                                   INT *pLeftStartOfSegment,

                                   SCHAR *pRemainingBitsInSegment,

                                   int *pNumDecodedBits);

static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr);

static void HcrReorderQuantizedSpectralCoefficients(

    H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,

    const SamplingRateInfo *pSamplingRateInfo);

static UCHAR errDetectPcwSegmentation(SCHAR remainingBitsInSegment,

                                      H_HCR_INFO pHcr, PCW_TYPE kind,

                                      FIXP_DBL *qsc_base_of_cw,

                                      UCHAR dimension);

static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr);

/*---------------------------------------------------------------------------------------------

     description:   Check if codebook and numSect are within allowed range

(short only)

--------------------------------------------------------------------------------------------

*/

static void errDetectorInHcrSideinfoShrt(SCHAR cb, SHORT numLine,

                                         UINT *errorWord) {

  if (cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL) {

    *errorWord |= CB_OUT_OF_RANGE_SHORT_BLOCK;

  }

  if (numLine < 0 || numLine > 1024) {

    *errorWord |= LINE_IN_SECT_OUT_OF_RANGE_SHORT_BLOCK;

  }

}

/*---------------------------------------------------------------------------------------------

     description:   Check both HCR lengths

--------------------------------------------------------------------------------------------

*/

static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword,

                                    SHORT lengthOfReorderedSpectralData,

                                    UINT *errorWord) {

  if (lengthOfReorderedSpectralData < lengthOfLongestCodeword) {

    *errorWord |= HCR_SI_LENGTHS_FAILURE;

  }

}

/*---------------------------------------------------------------------------------------------

     description:   Decode (and adapt if necessary) the two HCR sideinfo

components: 'reordered_spectral_data_length' and 'longest_codeword_length'

--------------------------------------------------------------------------------------------

*/

void CHcr_Read(HANDLE_FDK_BITSTREAM bs,

               CAacDecoderChannelInfo *pAacDecoderChannelInfo,

               const MP4_ELEMENT_ID globalHcrType) {

  SHORT lengOfReorderedSpectralData;

  SCHAR lengOfLongestCodeword;

  pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData =

      0;

  pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = 0;

  /* ------- SI-Value No 1 ------- */

  lengOfReorderedSpectralData = FDKreadBits(bs, 14) + ERROR_LORSD;

  if (globalHcrType == ID_CPE) {

    if ((lengOfReorderedSpectralData >= 0) &&

        (lengOfReorderedSpectralData <= CPE_TOP_LENGTH)) {

      pAacDecoderChannelInfo->pDynData->specificTo.aac

          .lenOfReorderedSpectralData =

          lengOfReorderedSpectralData; /* the decoded value is within range */

    } else {

      if (lengOfReorderedSpectralData > CPE_TOP_LENGTH) {

        pAacDecoderChannelInfo->pDynData->specificTo.aac

            .lenOfReorderedSpectralData =

            CPE_TOP_LENGTH; /* use valid maximum */

      }

    }

  } else if (globalHcrType == ID_SCE || globalHcrType == ID_LFE ||

             globalHcrType == ID_CCE) {

    if ((lengOfReorderedSpectralData >= 0) &&

        (lengOfReorderedSpectralData <= SCE_TOP_LENGTH)) {

      pAacDecoderChannelInfo->pDynData->specificTo.aac

          .lenOfReorderedSpectralData =

          lengOfReorderedSpectralData; /* the decoded value is within range */

    } else {

      if (lengOfReorderedSpectralData > SCE_TOP_LENGTH) {

        pAacDecoderChannelInfo->pDynData->specificTo.aac

            .lenOfReorderedSpectralData =

            SCE_TOP_LENGTH; /* use valid maximum */

      }

    }

  }

  /* ------- SI-Value No 2 ------- */

  lengOfLongestCodeword = FDKreadBits(bs, 6) + ERROR_LOLC;

  if ((lengOfLongestCodeword >= 0) &&

      (lengOfLongestCodeword <= LEN_OF_LONGEST_CW_TOP_LENGTH)) {

    pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword =

        lengOfLongestCodeword; /* the decoded value is within range */

  } else {

    if (lengOfLongestCodeword > LEN_OF_LONGEST_CW_TOP_LENGTH) {

      pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword =

          LEN_OF_LONGEST_CW_TOP_LENGTH; /* use valid maximum */

    }

  }

}

/*---------------------------------------------------------------------------------------------

     description:   Set up HCR - must be called before every call to

HcrDecoder(). For short block a sorting algorithm is applied to get the SI in

the order that HCR could assemble the qsc's as if it is a long block.

-----------------------------------------------------------------------------------------------

        return:     error log

--------------------------------------------------------------------------------------------

*/

UINT HcrInit(H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,

             const SamplingRateInfo *pSamplingRateInfo,

             HANDLE_FDK_BITSTREAM bs) {

  CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;

  SHORT *pNumLinesInSec;

  UCHAR *pCodeBk;

  SHORT numSection;

  SCHAR cb;

  int numLine;

  int i;

  pHcr->decInOut.lengthOfReorderedSpectralData =

      pAacDecoderChannelInfo->pDynData->specificTo.aac

          .lenOfReorderedSpectralData;

  pHcr->decInOut.lengthOfLongestCodeword =

      pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword;

  pHcr->decInOut.pQuantizedSpectralCoefficientsBase =

      pAacDecoderChannelInfo->pSpectralCoefficient;

  pHcr->decInOut.quantizedSpectralCoefficientsIdx = 0;

  pHcr->decInOut.pCodebook =

      pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr;

  pHcr->decInOut.pNumLineInSect =

      pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr;

  pHcr->decInOut.numSection =

      pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection;

  pHcr->decInOut.errorLog = 0;

  pHcr->nonPcwSideinfo.pResultBase =

      SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);

  FDKsyncCache(bs);

  pHcr->decInOut.bitstreamAnchor = (INT)FDKgetValidBits(bs);

  if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) /* short block */

  {

    SHORT band;

    SHORT maxBand;

    SCHAR group;

    SCHAR winGroupLen;

    SCHAR window;

    SCHAR numUnitInBand;

    SCHAR cntUnitInBand;

    SCHAR groupWin;

    SCHAR cb_prev;

    UCHAR *pCodeBook;

    const SHORT *BandOffsets;

    SCHAR numOfGroups;

    pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook; /* in */

    pNumLinesInSec = pHcr->decInOut.pNumLineInSect;          /* out */

    pCodeBk = pHcr->decInOut.pCodebook;                      /* out */

    BandOffsets =

        GetScaleFactorBandOffsets(pIcsInfo, pSamplingRateInfo); /* aux */

    numOfGroups = GetWindowGroups(pIcsInfo);

    numLine = 0;

    numSection = 0;

    cb = pCodeBook[0];

    cb_prev = pCodeBook[0];

    /* convert HCR-sideinfo into a unitwise manner: When the cb changes, a new

     * section starts */

    *pCodeBk++ = cb_prev;

    maxBand = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);

    for (band = 0; band < maxBand;

         band++) { /* from low to high sfbs i.e. from low to high frequencies */

      numUnitInBand =

          ((BandOffsets[band + 1] - BandOffsets[band]) >>

           FOUR_LOG_DIV_TWO_LOG); /* get the number of units in current sfb */

      for (cntUnitInBand = numUnitInBand; cntUnitInBand != 0;

           cntUnitInBand--) { /* for every unit in the band */

        for (window = 0, group = 0; group < numOfGroups; group++) {

          winGroupLen = (SCHAR)GetWindowGroupLength(

              &pAacDecoderChannelInfo->icsInfo, group);

          for (groupWin = winGroupLen; groupWin != 0; groupWin--, window++) {

            cb = pCodeBook[group * 16 + band];

            if (cb != cb_prev) {

              errDetectorInHcrSideinfoShrt(cb, numLine,

                                           &pHcr->decInOut.errorLog);

              if (pHcr->decInOut.errorLog != 0) {

                return (pHcr->decInOut.errorLog);

              }

              *pCodeBk++ = cb;

              *pNumLinesInSec++ = numLine;

              numSection++;

              cb_prev = cb;

              numLine = LINES_PER_UNIT;

            } else {

              numLine += LINES_PER_UNIT;

            }

          }

        }

      }

    }

    numSection++;

    errDetectorInHcrSideinfoShrt(cb, numLine, &pHcr->decInOut.errorLog);

    if (numSection <= 0 || numSection > 1024 / 2) {

      pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_SHORT_BLOCK;

    }

    errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword,

                            pHcr->decInOut.lengthOfReorderedSpectralData,

                            &pHcr->decInOut.errorLog);

    if (pHcr->decInOut.errorLog != 0) {

      return (pHcr->decInOut.errorLog);

    }

    *pCodeBk = cb;

    *pNumLinesInSec = numLine;

    pHcr->decInOut.numSection = numSection;

  } else /* end short block prepare SI */

  {      /* long block */

    errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword,

                            pHcr->decInOut.lengthOfReorderedSpectralData,

                            &pHcr->decInOut.errorLog);

    numSection = pHcr->decInOut.numSection;

    pNumLinesInSec = pHcr->decInOut.pNumLineInSect;

    pCodeBk = pHcr->decInOut.pCodebook;

    if (numSection <= 0 || numSection > 64) {

      pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_LONG_BLOCK;

      numSection = 0;

    }

    for (i = numSection; i != 0; i--) {

      cb = *pCodeBk++;

      if (cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL) {

        pHcr->decInOut.errorLog |= CB_OUT_OF_RANGE_LONG_BLOCK;

      }

      numLine = *pNumLinesInSec++;

      /* FDK_ASSERT(numLine > 0); */

      if ((numLine <= 0) || (numLine > 1024)) {

        pHcr->decInOut.errorLog |= LINE_IN_SECT_OUT_OF_RANGE_LONG_BLOCK;

      }

    }

    if (pHcr->decInOut.errorLog != 0) {

      return (pHcr->decInOut.errorLog);

    }

  }

  pCodeBk = pHcr->decInOut.pCodebook;

  for (i = 0; i < numSection; i++) {

    if ((*pCodeBk == NOISE_HCB) || (*pCodeBk == INTENSITY_HCB2) ||

        (*pCodeBk == INTENSITY_HCB)) {

      *pCodeBk = 0;

    }

    pCodeBk++;

  }

  /* HCR-sideinfo-input is complete and seems to be valid */

  return (pHcr->decInOut.errorLog);

}

/*---------------------------------------------------------------------------------------------

     description:   This function decodes the codewords of the spectral

coefficients from the bitstream according to the HCR algorithm and stores the

quantized spectral coefficients in correct order in the output buffer.

--------------------------------------------------------------------------------------------

*/

UINT HcrDecoder(H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,

                const SamplingRateInfo *pSamplingRateInfo,

                HANDLE_FDK_BITSTREAM bs) {

  int pTmp1, pTmp2, pTmp3, pTmp4;

  int pTmp5;

  INT bitCntOffst;

  INT saveBitCnt = (INT)FDKgetValidBits(bs); /* save bitstream position */

  HcrCalcNumCodeword(pHcr);

  HcrSortCodebookAndNumCodewordInSection(pHcr);

  HcrPrepareSegmentationGrid(pHcr);

  HcrExtendedSectionInfo(pHcr);

  if ((pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK) != 0) {

    return (pHcr->decInOut.errorLog); /* sideinfo is massively corrupt, return

                                         from HCR without having decoded

                                         anything */

  }

  DeriveNumberOfExtendedSortedSectionsInSets(

      pHcr->segmentInfo.numSegment,

      pHcr->sectionInfo.pNumExtendedSortedCodewordInSection,

      pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx,

      pHcr->sectionInfo.pNumExtendedSortedSectionsInSets,

      pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx);

  /* store */

  pTmp1 = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx;

  pTmp2 = pHcr->sectionInfo.extendedSortedCodebookIdx;

  pTmp3 = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx;

  pTmp4 = pHcr->decInOut.quantizedSpectralCoefficientsIdx;

  pTmp5 = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;

  /* ------- decode meaningful PCWs ------ */

  DecodePCWs(bs, pHcr);

  if ((pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK) == 0) {

    /* ------ decode the non-PCWs -------- */

    DecodeNonPCWs(bs, pHcr);

  }

  errDetectWithinSegmentationFinal(pHcr);

  /* restore */

  pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = pTmp1;

  pHcr->sectionInfo.extendedSortedCodebookIdx = pTmp2;

  pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = pTmp3;

  pHcr->decInOut.quantizedSpectralCoefficientsIdx = pTmp4;

  pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = pTmp5;

  HcrReorderQuantizedSpectralCoefficients(pHcr, pAacDecoderChannelInfo,

                                          pSamplingRateInfo);

  /* restore bitstream position */

  bitCntOffst = (INT)FDKgetValidBits(bs) - saveBitCnt;

  if (bitCntOffst) {

    FDKpushBiDirectional(bs, bitCntOffst);

  }

  return (pHcr->decInOut.errorLog);

}

/*---------------------------------------------------------------------------------------------

     description:   This function reorders the quantized spectral coefficients

sectionwise for long- and short-blocks and compares to the LAV (Largest Absolute

Value of the current codebook) -- a counter is incremented if there is an error

                    detected.

                    Additional for short-blocks a unit-based-deinterleaving is

applied. Moreover (for short blocks) the scaling is derived (compare plain

huffman decoder).

--------------------------------------------------------------------------------------------

*/

static void HcrReorderQuantizedSpectralCoefficients(

    H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,

    const SamplingRateInfo *pSamplingRateInfo) {

  INT qsc;

  UINT abs_qsc;

  UINT i, j;

  USHORT numSpectralValuesInSection;

  FIXP_DBL *pTeVa;

  USHORT lavErrorCnt = 0;

  UINT numSection = pHcr->decInOut.numSection;

  SPECTRAL_PTR pQuantizedSpectralCoefficientsBase =

      pHcr->decInOut.pQuantizedSpectralCoefficientsBase;

  FIXP_DBL *pQuantizedSpectralCoefficients =

      SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase);

  const UCHAR *pCbDimShift = aDimCbShift;

  const USHORT *pLargestAbsVal = aLargestAbsoluteValue;

  UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook;

  USHORT *pNumSortedCodewordInSection =

      pHcr->sectionInfo.pNumSortedCodewordInSection;

  USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset;

  FIXP_DBL pTempValues[1024];

  FIXP_DBL *pBak = pTempValues;

  FDKmemclear(pTempValues, 1024 * sizeof(FIXP_DBL));

  /* long and short: check if decoded huffman-values (quantized spectral

   * coefficients) are within range */

  for (i = numSection; i != 0; i--) {

    numSpectralValuesInSection = *pNumSortedCodewordInSection++

                                 << pCbDimShift[*pSortedCodebook];

    pTeVa = &pTempValues[*pReorderOffset++];

    for (j = numSpectralValuesInSection; j != 0; j--) {

      qsc = *pQuantizedSpectralCoefficients++;

      abs_qsc = fAbs(qsc);

      if (abs_qsc <= pLargestAbsVal[*pSortedCodebook]) {

        *pTeVa++ = (FIXP_DBL)qsc; /* the qsc value is within range */

      } else {                    /* line is too high .. */

        if (abs_qsc ==

            Q_VALUE_INVALID) { /* .. because of previous marking --> dont set

                                  LAV flag (would be confusing), just copy out

                                  the already marked value */

          *pTeVa++ = (FIXP_DBL)qsc;

        } else { /* .. because a too high value was decoded for this cb --> set

                    LAV flag */

          *pTeVa++ = (FIXP_DBL)Q_VALUE_INVALID;

          lavErrorCnt += 1;

        }

      }

    }

    pSortedCodebook++;

  }

  if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) {

    FIXP_DBL *pOut;

    FIXP_DBL locMax;

    FIXP_DBL tmp;

    SCHAR groupoffset;

    SCHAR group;

    SCHAR band;

    SCHAR groupwin;

    SCHAR window;

    SCHAR numWinGroup;

    SHORT interm;

    SCHAR numSfbTransm;

    SCHAR winGroupLen;

    SHORT index;

    INT msb;

    INT lsb;

    SHORT *pScaleFacHcr = pAacDecoderChannelInfo->pDynData->aScaleFactor;

    SHORT *pSfbSclHcr = pAacDecoderChannelInfo->pDynData->aSfbScale;

    const SHORT *BandOffsets = GetScaleFactorBandOffsets(

        &pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);

    pBak = pTempValues;

    /* deinterleave unitwise for short blocks */

    for (window = 0; window < (8); window++) {

      pOut = SPEC(pQuantizedSpectralCoefficientsBase, window,

                  pAacDecoderChannelInfo->granuleLength);

      for (i = 0; i < (LINES_PER_UNIT_GROUP); i++) {

        pTeVa = pBak + (window << FOUR_LOG_DIV_TWO_LOG) +

                i * 32; /* distance of lines between unit groups has to be

                           constant for every framelength (32)!  */

        for (j = (LINES_PER_UNIT); j != 0; j--) {

          *pOut++ = *pTeVa++;

        }

      }

    }

    /* short blocks only */

    /* derive global scaling-value for every sfb and every window (as it is done

     * in plain-huffman-decoder at short blocks) */

    groupoffset = 0;

    numWinGroup = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo);

    numSfbTransm =

        GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);

    for (group = 0; group < numWinGroup; group++) {

      winGroupLen =

          GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo, group);

      for (band = 0; band < numSfbTransm; band++) {

        interm = group * 16 + band;

        msb = pScaleFacHcr[interm] >> 2;

        lsb = pScaleFacHcr[interm] & 3;

        for (groupwin = 0; groupwin < winGroupLen; groupwin++) {

          window = groupoffset + groupwin;

          pBak = SPEC(pQuantizedSpectralCoefficientsBase, window,

                      pAacDecoderChannelInfo->granuleLength);

          locMax = FL2FXCONST_DBL(0.0f);

          for (index = BandOffsets[band]; index < BandOffsets[band + 1];

               index += LINES_PER_UNIT) {

            pTeVa = &pBak[index];

            for (i = LINES_PER_UNIT; i != 0; i--) {

              tmp = (*pTeVa < FL2FXCONST_DBL(0.0f)) ? -*pTeVa++ : *pTeVa++;

              locMax = fixMax(tmp, locMax);

            }

          }

          if (fixp_abs(locMax) > (FIXP_DBL)MAX_QUANTIZED_VALUE) {

            locMax = (FIXP_DBL)MAX_QUANTIZED_VALUE;

          }

          pSfbSclHcr[window * 16 + band] =

              msb - GetScaleFromValue(

                        locMax, lsb); /* save global scale maxima in this sfb */

        }

      }

      groupoffset +=

          GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo, group);

    }

  } else {

    /* copy straight for long-blocks */

    pQuantizedSpectralCoefficients =

        SPEC_LONG(pQuantizedSpectralCoefficientsBase);

    for (i = 1024; i != 0; i--) {

      *pQuantizedSpectralCoefficients++ = *pBak++;

    }

  }

  if (lavErrorCnt != 0) {

    pHcr->decInOut.errorLog |= LAV_VIOLATION;

  }

}

/*---------------------------------------------------------------------------------------------

     description:   This function calculates the number of codewords

                    for each section (numCodewordInSection) and the number of

codewords for all sections (numCodeword). For zero and intensity codebooks a

entry is also done in the variable numCodewordInSection. It is assumed that the

codebook is a two tuples codebook. This is needed later for the calculation of

the base addresses for the reordering of the quantize spectral coefficients at

the end of the hcr tool. The variable numCodeword contain the number of

codewords which are really in the bitstream. Zero or intensity codebooks does

not increase the variable numCodewords.

-----------------------------------------------------------------------------------------------

        return:   -

--------------------------------------------------------------------------------------------

*/

static void HcrCalcNumCodeword(H_HCR_INFO pHcr) {

  int hcrSection;

  UINT numCodeword;

  UINT numSection = pHcr->decInOut.numSection;

  UCHAR *pCodebook = pHcr->decInOut.pCodebook;

  SHORT *pNumLineInSection = pHcr->decInOut.pNumLineInSect;

  const UCHAR *pCbDimShift = aDimCbShift;

  USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection;

  numCodeword = 0;

  for (hcrSection = numSection; hcrSection != 0; hcrSection--) {

    *pNumCodewordInSection = *pNumLineInSection++ >> pCbDimShift[*pCodebook];

    if (*pCodebook != 0) {

      numCodeword += *pNumCodewordInSection;

    }

    pNumCodewordInSection++;

    pCodebook++;

  }

  pHcr->sectionInfo.numCodeword = numCodeword;

}

/*---------------------------------------------------------------------------------------------

     description:   This function calculates the number

                    of sorted codebooks and sorts the codebooks and the

numCodewordInSection according to the priority.

--------------------------------------------------------------------------------------------

*/

static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr) {

  UINT i, j, k;

  UCHAR temp;

  UINT counter;

  UINT startOffset;

  UINT numZeroSection;

  UCHAR *pDest;

  UINT numSectionDec;

  UINT numSection = pHcr->decInOut.numSection;

  UCHAR *pCodebook = pHcr->decInOut.pCodebook;

  UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook;

  USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection;

  USHORT *pNumSortedCodewordInSection =

      pHcr->sectionInfo.pNumSortedCodewordInSection;

  UCHAR *pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch;

  USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset;

  const UCHAR *pCbPriority = aCbPriority;

  const UCHAR *pMinOfCbPair = aMinOfCbPair;

  const UCHAR *pMaxOfCbPair = aMaxOfCbPair;

  const UCHAR *pCbDimShift = aDimCbShift;

  UINT searchStart = 0;

  /* calculate *pNumSortedSection and store the priorities in array

   * pSortedCdebook */

  pDest = pSortedCodebook;

  numZeroSection = 0;

  for (i = numSection; i != 0; i--) {

    if (pCbPriority[*pCodebook] == 0) {

      numZeroSection += 1;

    }

    *pDest++ = pCbPriority[*pCodebook++];

  }

  pHcr->sectionInfo.numSortedSection =

      numSection - numZeroSection; /* numSortedSection contains no zero or

                                      intensity section */

  pCodebook = pHcr->decInOut.pCodebook;

  /* sort priorities of the codebooks in array pSortedCdebook[] */

  numSectionDec = numSection - 1;

  if (numSectionDec > 0) {

    counter = numSectionDec;

    for (j = numSectionDec; j != 0; j--) {

      for (i = 0; i < counter; i++) {

        /* swap priorities */

        if (pSortedCodebook[i + 1] > pSortedCodebook[i]) {

          temp = pSortedCodebook[i];

          pSortedCodebook[i] = pSortedCodebook[i + 1];

          pSortedCodebook[i + 1] = temp;

        }

      }

      counter -= 1;

    }

  }

  /* clear codebookSwitch array */

  for (i = numSection; i != 0; i--) {

    *pCodebookSwitch++ = 0;

  }

  pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch;

  /* sort sectionCodebooks and numCodwordsInSection and calculate

   * pReorderOffst[j] */

  for (j = 0; j < numSection; j++) {

    for (i = searchStart; i < numSection; i++) {

      if (pCodebookSwitch[i] == 0 &&

          (pMinOfCbPair[pSortedCodebook[j]] == pCodebook[i] ||

           pMaxOfCbPair[pSortedCodebook[j]] == pCodebook[i])) {

        pCodebookSwitch[i] = 1;

        pSortedCodebook[j] = pCodebook[i]; /* sort codebook */

        pNumSortedCodewordInSection[j] =

            pNumCodewordInSection[i]; /* sort NumCodewordInSection */

        startOffset = 0;

        for (k = 0; k < i; k++) { /* make entry in pReorderOffst */

          startOffset += pNumCodewordInSection[k] << pCbDimShift[pCodebook[k]];

        }

        pReorderOffset[j] =

            startOffset; /* offset for reordering the codewords */

        if (i == searchStart) {

          k = i;

          while (pCodebookSwitch[k++] == 1) searchStart++;

        }

        break;

      }

    }

  }

}

/*---------------------------------------------------------------------------------------------

     description:   This function calculates the segmentation, which includes

numSegment, leftStartOfSegment, rightStartOfSegment and remainingBitsInSegment.

                    The segmentation could be visualized a as kind of

'overlay-grid' for the bitstream-block holding the HCR-encoded

quantized-spectral-coefficients.

--------------------------------------------------------------------------------------------

*/

static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) {

  USHORT i, j;

  USHORT numSegment = 0;

  INT segmentStart = 0;

  UCHAR segmentWidth;

  UCHAR lastSegmentWidth;

  UCHAR sortedCodebook;

  UCHAR endFlag = 0;

  INT intermediateResult;

  SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword;

  SHORT lengthOfReorderedSpectralData =

      pHcr->decInOut.lengthOfReorderedSpectralData;

  UINT numSortedSection = pHcr->sectionInfo.numSortedSection;

  UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook;

  USHORT *pNumSortedCodewordInSection =

      pHcr->sectionInfo.pNumSortedCodewordInSection;

  INT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;

  INT *pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;

  SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;

  const UCHAR *pMaxCwLength = aMaxCwLen;

  for (i = numSortedSection; i != 0; i--) {

    sortedCodebook = *pSortedCodebook++;

    segmentWidth =

        fMin((INT)pMaxCwLength[sortedCodebook], (INT)lengthOfLongestCodeword);

    for (j = *pNumSortedCodewordInSection; j != 0; j--) {

      /* width allows a new segment */

      intermediateResult = segmentStart;

      if ((segmentStart + segmentWidth) <= lengthOfReorderedSpectralData) {

        /* store segment start, segment length and increment the number of

         * segments */

        *pLeftStartOfSegment++ = intermediateResult;

        *pRightStartOfSegment++ = intermediateResult + segmentWidth - 1;

        *pRemainingBitsInSegment++ = segmentWidth;

        segmentStart += segmentWidth;

        numSegment += 1;

      }

      /* width does not allow a new segment */

      else {

        /* correct the last segment length */

        pLeftStartOfSegment--;

        pRightStartOfSegment--;

        pRemainingBitsInSegment--;

        segmentStart = *pLeftStartOfSegment;

        lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart;

        *pRemainingBitsInSegment = lastSegmentWidth;

        *pRightStartOfSegment = segmentStart + lastSegmentWidth - 1;

        endFlag = 1;

        break;

      }

    }

    pNumSortedCodewordInSection++;

    if (endFlag != 0) {

      break;

    }

  }

  pHcr->segmentInfo.numSegment = numSegment;

}

/*---------------------------------------------------------------------------------------------

     description:   This function adapts the sorted section boundaries to the

boundaries of segmentation. If the section lengths does not fit completely into

the current segment, the section is spitted into two so called 'extended

                    sections'. The extended-section-info

(pNumExtendedSortedCodewordInSectin and pExtendedSortedCodebook) is updated in

this case.

--------------------------------------------------------------------------------------------

*/

static void HcrExtendedSectionInfo(H_HCR_INFO pHcr) {

  UINT srtSecCnt = 0; /* counter for sorted sections */

  UINT xSrtScCnt = 0; /* counter for extended sorted sections */

  UINT remainNumCwInSortSec;

  UINT inSegmentRemainNumCW;

  UINT numSortedSection = pHcr->sectionInfo.numSortedSection;

  UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook;

  USHORT *pNumSortedCodewordInSection =

      pHcr->sectionInfo.pNumSortedCodewordInSection;

  UCHAR *pExtendedSortedCoBo = pHcr->sectionInfo.pExtendedSortedCodebook;

  USHORT *pNumExtSortCwInSect =

      pHcr->sectionInfo.pNumExtendedSortedCodewordInSection;

  UINT numSegment = pHcr->segmentInfo.numSegment;

  UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;

  SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword;

  const UCHAR *pMaxCwLength = aMaxCwLen;

  remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];

  inSegmentRemainNumCW = numSegment;

  while (srtSecCnt < numSortedSection) {

    if (inSegmentRemainNumCW < remainNumCwInSortSec) {

      pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW;

      pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];

      remainNumCwInSortSec -= inSegmentRemainNumCW;

      inSegmentRemainNumCW = numSegment;

      /* data of a sorted section was not integrated in extended sorted section

       */

    } else if (inSegmentRemainNumCW == remainNumCwInSortSec) {

      pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW;

      pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];

      srtSecCnt++;

      remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];

      inSegmentRemainNumCW = numSegment;

      /* data of a sorted section was integrated in extended sorted section */

    } else { /* inSegmentRemainNumCW > remainNumCwInSortSec */

      pNumExtSortCwInSect[xSrtScCnt] = remainNumCwInSortSec;

      pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];

      inSegmentRemainNumCW -= remainNumCwInSortSec;

      srtSecCnt++;

      remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];

      /* data of a sorted section was integrated in extended sorted section */

    }

    pMaxLenOfCbInExtSrtSec[xSrtScCnt] =

        fMin((INT)pMaxCwLength[pExtendedSortedCoBo[xSrtScCnt]],

             (INT)lengthOfLongestCodeword);

    xSrtScCnt += 1;

    if (xSrtScCnt >= (MAX_SFB_HCR + MAX_HCR_SETS)) {

      pHcr->decInOut.errorLog |= EXTENDED_SORTED_COUNTER_OVERFLOW;

      return;

    }

  }

  pNumExtSortCwInSect[xSrtScCnt] = 0;

}

/*---------------------------------------------------------------------------------------------

     description:   This function calculates the number of extended sorted

sections which belong to the sets. Each set from set 0 (one and only set for the

PCWs) till to the last set gets a entry in the array to which

                    'pNumExtendedSortedSectinsInSets' points to.

                    Calculation: The entrys in

pNumExtendedSortedCodewordInSectin are added untill the value numSegment is

reached. Then the sum_variable is cleared and the calculation starts from the

beginning. As much extended sorted Sections are summed up to reach the value

numSegment, as much is the current entry in *pNumExtendedSortedCodewordInSectin.

--------------------------------------------------------------------------------------------

*/

static void DeriveNumberOfExtendedSortedSectionsInSets(

    UINT numSegment, USHORT *pNumExtendedSortedCodewordInSection,

    int numExtendedSortedCodewordInSectionIdx,

    USHORT *pNumExtendedSortedSectionsInSets,

    int numExtendedSortedSectionsInSetsIdx) {

  USHORT counter = 0;

  UINT cwSum = 0;

  USHORT *pNumExSortCwInSec = pNumExtendedSortedCodewordInSection;

  USHORT *pNumExSortSecInSets = pNumExtendedSortedSectionsInSets;

  while (pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx] != 0) {

    cwSum += pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx];

    numExtendedSortedCodewordInSectionIdx++;

    if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR + MAX_HCR_SETS)) {

      return;

    }

    if (cwSum > numSegment) {

      return;

    }

    counter++;

    if (counter > 1024 / 4) {

      return;

    }

    if (cwSum == numSegment) {

      pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter;

      numExtendedSortedSectionsInSetsIdx++;

      if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) {

        return;

      }

      counter = 0;

      cwSum = 0;

    }

  }

  pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] =

      counter; /* save last entry for the last - probably shorter - set */

}

/*---------------------------------------------------------------------------------------------

     description:   This function decodes all priority codewords (PCWs) in a

spectrum (within set 0). The calculation of the PCWs is managed in two loops.

The loopcounter of the outer loop is set to the first value pointer

                    pNumExtendedSortedSectionsInSets points to. This value

represents the number of extended sorted sections within set 0. The loopcounter

of the inner loop is set to the first value pointer

                    pNumExtendedSortedCodewordInSectin points to. The value

represents the number of extended sorted codewords in sections (the original

sections have been splitted to go along with the borders of the sets). Each time

the number of the extended sorted codewords in sections are de- coded, the

pointer 'pNumExtendedSortedCodewordInSectin' is incremented by one.

--------------------------------------------------------------------------------------------

*/

static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {

  UINT i;

  USHORT extSortSec;

  USHORT curExtSortCwInSec;

  UCHAR codebook;

  UCHAR dimension;

  const UINT *pCurrentTree;

  const SCHAR *pQuantValBase;

  const SCHAR *pQuantVal;

  USHORT *pNumExtendedSortedCodewordInSection =

      pHcr->sectionInfo.pNumExtendedSortedCodewordInSection;

  int numExtendedSortedCodewordInSectionIdx =

      pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx;

  UCHAR *pExtendedSortedCodebook = pHcr->sectionInfo.pExtendedSortedCodebook;

  int extendedSortedCodebookIdx = pHcr->sectionInfo.extendedSortedCodebookIdx;

  USHORT *pNumExtendedSortedSectionsInSets =

      pHcr->sectionInfo.pNumExtendedSortedSectionsInSets;

  int numExtendedSortedSectionsInSetsIdx =

      pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx;

  FIXP_DBL *pQuantizedSpectralCoefficients =

      SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase);

  int quantizedSpectralCoefficientsIdx =

      pHcr->decInOut.quantizedSpectralCoefficientsIdx;

  INT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;

  SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;

  UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;

  int maxLenOfCbInExtSrtSecIdx = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;

  UCHAR maxAllowedCwLen;

  int numDecodedBits;

  const UCHAR *pCbDimension = aDimCb;

  const UCHAR *pCbSign = aSignCb;

  /* clear result array */

  FDKmemclear(pQuantizedSpectralCoefficients + quantizedSpectralCoefficientsIdx,

              1024 * sizeof(FIXP_DBL));

  /* decode all PCWs in the extended sorted section(s) belonging to set 0 */

  for (extSortSec =

           pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx];

       extSortSec != 0; extSortSec--) {

    codebook =

        pExtendedSortedCodebook[extendedSortedCodebookIdx]; /* get codebook for

                                                               this extended

                                                               sorted section

                                                               and increment ptr

                                                               to cb of next

                                                               ext. sort sec */

    extendedSortedCodebookIdx++;

    if (extendedSortedCodebookIdx >= (MAX_SFB_HCR + MAX_HCR_SETS)) {

      return;