Fraunhofer AAC codec.

License boilerplate update to follow.

Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5

1 files changed, 1529 insertions, 0 deletions

diff --git a/libAACdec/src/aacdec_hcr.cpp b/libAACdec/src/aacdec_hcr.cpp
new file mode 100644
index 0000000..09dca79
--- /dev/null
+++ b/libAACdec/src/aacdec_hcr.cpp
@@ -0,0 +1,1529 @@
+/*****************************  MPEG-4 AAC Decoder  ***************************
+
+                      (C) Copyright Fraunhofer IIS 2000-2008
+                               All Rights Reserved
+
+    Please be advised that this software and/or program delivery is
+    Confidential Information of Fraunhofer and subject to and covered by the
+
+    Fraunhofer IIS Software Evaluation Agreement
+    between Google Inc. and  Fraunhofer
+    effective and in full force since March 1, 2012.
+
+    You may use this software and/or program only under the terms and
+    conditions described in the above mentioned Fraunhofer IIS Software
+    Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+   $Id$
+   Author(s):   Robert Weidner (DSP Solutions)
+   Description: HCR Decoder: HCR initialization, preprocess HCR sideinfo,
+                decode priority codewords (PCWs)
+
+   This software and/or program is protected by copyright law and international
+   treaties. Any reproduction or distribution of this software and/or program,
+   or any portion of it, may result in severe civil and criminal penalties, and
+   will be prosecuted to the maximum extent possible under law.
+
+*******************************************************************************/
+
+#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,
+                                 INT                   quantSpecCoef,
+                                 USHORT               *pLeftStartOfSegment,
+                                 SCHAR                *pRemainingBitsInSegment,
+                                 int                  *pNumDecodedBits
+                                );
+
+static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM  bs,
+                          UINT                  codebookDim,
+                          const SCHAR          *pQuantVal,
+                          FIXP_DBL             *pQuantSpecCoef,
+                          int                  *quantSpecCoefIdx,
+                          USHORT               *pLeftStartOfSegment,
+                          SCHAR                *pRemainingBitsInSegment,
+                          int                  *pNumDecodedBits
+                         );
+
+static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM  bs,
+                                   const UINT           *pCurrentTree,
+                                   const SCHAR          *pQuantValBase,
+                                         USHORT         *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
+        );
+
+
+#if CHECK_SEGMENTATION_IMMEDIATELY
+static UCHAR errDetectPcwSegmentation(SCHAR       remainingBitsInSegment,
+                                      H_HCR_INFO  pHcr,
+                                      PCW_TYPE    kind,
+                                      FIXP_DBL   *qsc_base_of_cw,
+                                      UCHAR       dimension);
+#endif
+
+#if CHECK_SEGMENTATION_FINAL
+static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr);
+#endif
+
+/*---------------------------------------------------------------------------------------------
+     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)
+{
+  INT    globalHcrType = getHcrType(&pAacDecoderChannelInfo->pComData->overlay.aac.erHcrInfo);
+  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:   Sets up HCR ROM-Tables
+-------------------------------------------------------------------------------------------- */
+
+void HcrInitRom(H_HCR_INFO pHcr)
+{
+  pHcr->cbPairs.pMinOfCbPair     = aMinOfCbPair;
+  pHcr->cbPairs.pMaxOfCbPair     = aMaxOfCbPair;
+
+  pHcr->tableInfo.pMaxCwLength   = aMaxCwLen;
+  pHcr->tableInfo.pCbDimension   = aDimCb;
+  pHcr->tableInfo.pCbDimShift    = aDimCbShift;
+  pHcr->tableInfo.pCbSign        = aSignCb;
+  pHcr->tableInfo.pCbPriority    = aCbPriority;
+  pHcr->tableInfo.pLargestAbsVal = aLargestAbsoluteValue;
+}
+
+/*---------------------------------------------------------------------------------------------
+     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.bitstreamIndex                     = FDKgetBitCnt(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 = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group);
+          for (groupWin = winGroupLen; groupWin != 0; groupWin--, window++) {
+            cb = pCodeBook[group * 16 + band];
+            if (cb != cb_prev) {
+#if CHECK_VALID_HCR_INPUT /* short-block  1 of 2 */
+              errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog );
+              if (pHcr->decInOut.errorLog != 0 ) {
+                return ( pHcr->decInOut.errorLog );
+              }
+#endif
+              *pCodeBk++ = cb;
+              *pNumLinesInSec++ = numLine;
+              numSection++;
+
+              cb_prev = cb;
+              numLine = LINES_PER_UNIT;
+            }
+            else {
+              numLine += LINES_PER_UNIT;
+            }
+          }
+        }
+      }
+    }
+
+    numSection++;
+
+#if CHECK_VALID_HCR_INPUT /* short-block  2 of 2 */
+    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 );
+    }
+#endif
+
+    *pCodeBk = cb;
+    *pNumLinesInSec = numLine;
+    pHcr->decInOut.numSection = numSection;
+
+  } else /* end short block prepare SI */
+  {      /* long block */
+#if CHECK_VALID_HCR_INPUT /* long-block  1 of 1 */
+    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 );
+    }
+#endif  /* CHECK_VALID_HCR_INPUT */
+  }
+
+  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 );
+}
+
+
+
+
+#if USE_HCR_DUMMY
+
+/*---------------------------------------------------------------------------------------------
+
+     description:   This HCR - dummy  - function writes only a dirac-sequence in output buffer
+
+-------------------------------------------------------------------------------------------- */
+UINT HcrDecoder(H_HCR_INFO              pHcr,
+                const CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+                HANDLE_FDK_BITSTREAM    bs)
+{
+  for (SHORT i=0; i < 1024; i++ ) {
+    pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = FL2FXCONST_DBL(0.0f);
+    if ( i % 30 == 0) {
+      pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = (FIXP_DBL)HCR_DIRAC;
+    }
+  }
+  return 0;
+}
+
+#else /* USE_HCR_DUMMY */
+
+/*---------------------------------------------------------------------------------------------
+     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;
+#if DETECT_TOO_LONG_CW_READS
+  int        pTmp5;
+#endif
+
+  INT        bitCntOffst;
+  UINT       saveBitCnt = FDKgetBitCnt(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;
+#if DETECT_TOO_LONG_CW_READS
+  pTmp5 = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;
+#endif
+
+  /* ------- decode meaningful PCWs ------ */
+  DecodePCWs(bs, pHcr);
+
+  if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) == 0 ) {
+    /* ------ decode the non-PCWs -------- */
+    DecodeNonPCWs(bs, pHcr);
+  }
+
+
+#if CHECK_SEGMENTATION_FINAL
+  errDetectWithinSegmentationFinal(pHcr);
+#endif
+
+  /* restore */
+  pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = pTmp1;
+  pHcr->sectionInfo.extendedSortedCodebookIdx             = pTmp2;
+  pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx    = pTmp3;
+  pHcr->decInOut.quantizedSpectralCoefficientsIdx         = pTmp4;
+#if DETECT_TOO_LONG_CW_READS
+  pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx              = pTmp5;
+#endif
+
+  HcrReorderQuantizedSpectralCoefficients(pHcr, pAacDecoderChannelInfo, pSamplingRateInfo);
+
+  /* restore bitstream position */
+  bitCntOffst = saveBitCnt - FDKgetBitCnt(bs);
+  if( bitCntOffst ) {
+    FDKpushBiDirectional(bs, bitCntOffst);
+  }
+
+  return ( pHcr->decInOut.errorLog );
+}
+
+
+#endif  /* USE_HCR_DUMMY */
+
+
+
+
+/*---------------------------------------------------------------------------------------------
+     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                  = pHcr->tableInfo.pCbDimShift;
+  const USHORT   *pLargestAbsVal               = pHcr->tableInfo.pLargestAbsVal;
+  UCHAR    *pSortedCodebook                    = pHcr->sectionInfo.pSortedCodebook;
+  USHORT   *pNumSortedCodewordInSection        = pHcr->sectionInfo.pNumSortedCodewordInSection;
+  USHORT   *pReorderOffset                     = pHcr->sectionInfo.pReorderOffset;
+  FIXP_DBL *pTempValues                        = pHcr->segmentInfo.pTempValues;
+  FIXP_DBL *pBak                               = pHcr->segmentInfo.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 = FDKabs(qsc);
+#if VALID_LAV_ERROR_TRIGGER
+      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;
+        }
+      }
+#else
+      if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) {
+        *pTeVa++ = qsc;
+      }
+      else {
+        *pTeVa++ = Q_VALUE_INVALID;
+        lavErrorCnt += 1;
+      }
+#endif
+    }
+    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 = pHcr->segmentInfo.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     =   pHcr->tableInfo.pCbDimShift;
+  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          =   pHcr->tableInfo.pCbPriority;
+  const UCHAR   *pMinOfCbPair         =   pHcr->cbPairs.pMinOfCbPair;
+  const UCHAR   *pMaxOfCbPair         =   pHcr->cbPairs.pMaxOfCbPair;
+  const UCHAR   *pCbDimShift          =   pHcr->tableInfo.pCbDimShift;
+
+  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) {
+          UINT 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;
+  USHORT   segmentStart = 0;
+  UCHAR    segmentWidth;
+  UCHAR    lastSegmentWidth;
+  UCHAR    sortedCodebook;
+  UCHAR    endFlag = 0;
+  USHORT   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;
+  USHORT  *pLeftStartOfSegment           =   pHcr->segmentInfo.pLeftStartOfSegment;
+  USHORT  *pRightStartOfSegment          =   pHcr->segmentInfo.pRightStartOfSegment;
+  SCHAR   *pRemainingBitsInSegment       =   pHcr->segmentInfo.pRemainingBitsInSegment;
+  USHORT   bitstreamIndex                =   pHcr->decInOut.bitstreamIndex;
+  const UCHAR *pMaxCwLength              =   pHcr->tableInfo.pMaxCwLength;
+
+  for ( i=numSortedSection; i != 0; i-- ) {
+    sortedCodebook = *pSortedCodebook++;
+    segmentWidth = FDKmin(pMaxCwLength[sortedCodebook],lengthOfLongestCodeword);
+
+    for ( j = *pNumSortedCodewordInSection; j != 0 ; j-- ) {
+      /* width allows a new segment */
+      intermediateResult = bitstreamIndex + 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 - bitstreamIndex;
+
+        lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart;
+        *pRemainingBitsInSegment = lastSegmentWidth;
+        *pRightStartOfSegment = bitstreamIndex + 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;
+#if DETECT_TOO_LONG_CW_READS
+  UCHAR  *pMaxLenOfCbInExtSrtSec      = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;
+  SCHAR   lengthOfLongestCodeword     = pHcr->decInOut.lengthOfLongestCodeword;
+  const UCHAR   *pMaxCwLength         = pHcr->tableInfo.pMaxCwLength;
+#endif
+
+  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 */
+    }
+#if DETECT_TOO_LONG_CW_READS
+    pMaxLenOfCbInExtSrtSec[xSrtScCnt] = FDKmin(pMaxCwLength[pExtendedSortedCoBo[xSrtScCnt]],lengthOfLongestCodeword);
+#endif
+
+
+
+    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;
+  USHORT      *pLeftStartOfSegment                 = pHcr->segmentInfo.pLeftStartOfSegment;
+  SCHAR       *pRemainingBitsInSegment             = pHcr->segmentInfo.pRemainingBitsInSegment;
+#if DETECT_TOO_LONG_CW_READS
+  UCHAR       *pMaxLenOfCbInExtSrtSec              = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;
+  int          maxLenOfCbInExtSrtSecIdx            = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;
+  UCHAR        maxAllowedCwLen;
+  int          numDecodedBits;
+#endif
+  const UCHAR *pCbDimension =  pHcr->tableInfo.pCbDimension;
+  const UCHAR *pCbSign      =  pHcr->tableInfo.pCbSign;
+
+  /* clear result array */
+  //pQSC = &pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx];
+  //pQSC = *pQuantizedSpectralCoefficients;
+
+  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;
+    }
+    dimension       =  pCbDimension[codebook];         /* get dimension of codebook of this extended sort. sec. */
+    pCurrentTree    =  aHuffTable  [codebook];         /* convert codebook to pointer to QSCs */
+    pQuantValBase   =  aQuantTable [codebook];         /* convert codebook to index to table of QSCs */
+#if DETECT_TOO_LONG_CW_READS
+    maxAllowedCwLen = pMaxLenOfCbInExtSrtSec[maxLenOfCbInExtSrtSecIdx];
+    maxLenOfCbInExtSrtSecIdx++;
+    if (maxLenOfCbInExtSrtSecIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
+      return;
+    }
+#endif
+
+    /* switch for decoding with different codebooks: */
+    if ( pCbSign[codebook] == 0 ) {                    /* no sign bits follow after the codeword-body */
+      /* PCW_BodyONLY */
+      /*==============*/
+
+      for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) {
+        numDecodedBits = 0;
+
+        /* decode PCW_BODY */
+        pQuantVal = DecodePCW_Body(bs,
+                                   pCurrentTree,
+                                   pQuantValBase,
+                                   pLeftStartOfSegment,
+                                   pRemainingBitsInSegment,
+                                  &numDecodedBits
+                                  );
+
+        /* result is written out here because NO sign bits follow the body */
+        for( i=dimension; i != 0 ; i-- ) {
+          pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) *pQuantVal++;                               /* write quant. spec. coef. into spectrum; sign is already valid */
+          quantizedSpectralCoefficientsIdx++;
+          if (quantizedSpectralCoefficientsIdx >= 1024) {
+            return;
+          }
+        }
+
+        /* one more PCW should be decoded */
+
+#if DETECT_TOO_LONG_CW_READS
+        if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_ONLY_TOO_LONG) ) {
+          pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_BITS_DECODED;
+        }
+#endif
+
+#if CHECK_SEGMENTATION_IMMEDIATELY
+        if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY,pHcr,PCW_BODY,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) {
+          return;
+        }
+#endif
+        pLeftStartOfSegment++;                                             /* update pointer for decoding the next PCW */
+        pRemainingBitsInSegment++;                                         /* update pointer for decoding the next PCW */
+      }
+    }
+    else if (( pCbSign[codebook] == 1 ) && ( codebook < 11 )) {  /* possibly there follow 1,2,3 or 4 sign bits after the codeword-body */
+      /* PCW_Body and PCW_Sign */
+      /*=======================*/
+
+      for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--)
+      {
+        int err;
+        numDecodedBits  = 0;
+
+        pQuantVal = DecodePCW_Body(bs,
+                                   pCurrentTree,
+                                   pQuantValBase,
+                                   pLeftStartOfSegment,
+                                   pRemainingBitsInSegment,
+                                  &numDecodedBits
+                                  );
+
+        err = DecodePCW_Sign( bs,
+                              dimension,
+                              pQuantVal,
+                              pQuantizedSpectralCoefficients,
+                             &quantizedSpectralCoefficientsIdx,
+                              pLeftStartOfSegment,
+                              pRemainingBitsInSegment,
+                             &numDecodedBits
+                             );
+        if (err != 0) {
+          return;
+        }
+        /* one more PCW should be decoded */
+
+#if DETECT_TOO_LONG_CW_READS
+        if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_TOO_LONG) ) {
+          pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_BITS_DECODED;
+        }
+#endif
+
+#if CHECK_SEGMENTATION_IMMEDIATELY
+        if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN,pHcr,PCW_BODY_SIGN, pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) {
+          return;
+        }
+#endif
+        pLeftStartOfSegment++;
+        pRemainingBitsInSegment++;
+      }
+    }
+    else if (( pCbSign[codebook] == 1 ) && ( codebook >= 11 )) { /* possibly there follow some sign bits and maybe one or two escape sequences after the cw-body */
+      /* PCW_Body, PCW_Sign and maybe PCW_Escape */
+      /*=========================================*/
+
+      for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--)
+      {
+        int err;
+        numDecodedBits  = 0;
+
+        /* decode PCW_BODY */
+        pQuantVal = DecodePCW_Body(bs,
+                                   pCurrentTree,
+                                   pQuantValBase,
+                                   pLeftStartOfSegment,
+                                   pRemainingBitsInSegment,
+                                  &numDecodedBits
+                                  );
+
+        err = DecodePCW_Sign( bs,
+                              dimension,
+                              pQuantVal,
+                              pQuantizedSpectralCoefficients,
+                             &quantizedSpectralCoefficientsIdx,
+                              pLeftStartOfSegment,
+                              pRemainingBitsInSegment,
+                             &numDecodedBits
+                             );
+        if (err != 0) {
+          return;
+        }
+
+        /* decode PCW_ESCAPE if present */
+        quantizedSpectralCoefficientsIdx -= DIMENSION_OF_ESCAPE_CODEBOOK;
+
+        if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) {
+          pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs,
+                                                   pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx],
+                                                   pLeftStartOfSegment,
+                                                   pRemainingBitsInSegment,
+                                                  &numDecodedBits
+                                                 );
+        }
+        quantizedSpectralCoefficientsIdx++;
+        if (quantizedSpectralCoefficientsIdx >= 1024) {
+          return;
+        }
+
+        if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) {
+          pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs,
+                                                   pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx],
+                                                   pLeftStartOfSegment,
+                                                   pRemainingBitsInSegment,
+                                                  &numDecodedBits
+                                                 );
+        }
+        quantizedSpectralCoefficientsIdx++;
+        if (quantizedSpectralCoefficientsIdx >= 1024) {
+          return;
+        }
+
+        /* one more PCW should be decoded */
+
+#if DETECT_TOO_LONG_CW_READS
+        if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_ESC_TOO_LONG) ) {
+          pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_ESC_BITS_DECODED;
+        }
+#endif
+
+#if CHECK_SEGMENTATION_IMMEDIATELY
+        if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN_ESC,pHcr,PCW_BODY_SIGN_ESC,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-DIMENSION_OF_ESCAPE_CODEBOOK,DIMENSION_OF_ESCAPE_CODEBOOK)) {
+          return;
+        }
+#endif
+        pLeftStartOfSegment++;
+        pRemainingBitsInSegment++;
+      }
+    }
+
+    /* all PCWs belonging to this extended section should be decoded */
+    numExtendedSortedCodewordInSectionIdx++;
+    if (numExtendedSortedCodewordInSectionIdx >= MAX_SFB_HCR+MAX_HCR_SETS) {
+      return;
+    }
+  }
+  /* all PCWs should be decoded */
+
+  numExtendedSortedSectionsInSetsIdx++;
+  if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) {
+    return;
+  }
+
+  /* Write back indexes into structure */
+  pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx;
+  pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx;
+  pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx;
+  pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx;
+  pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = maxLenOfCbInExtSrtSecIdx;
+}
+
+#if CHECK_SEGMENTATION_IMMEDIATELY
+/*---------------------------------------------------------------------------------------------
+     description:   This function checks immediately after every decoded PCW, whether out of
+                    the current segment too many bits have been read or not. If an error occurrs,
+                    probably the sideinfo or the HCR-bitstream block holding the huffman
+                    encoded quantized spectral coefficients is distorted. In this case the two
+                    or four quantized spectral coefficients belonging to the current codeword
+                    are marked (for being detected by concealment later).
+-------------------------------------------------------------------------------------------- */
+static UCHAR errDetectPcwSegmentation(SCHAR       remainingBitsInSegment,
+                                      H_HCR_INFO  pHcr,
+                                      PCW_TYPE    kind,
+                                      FIXP_DBL   *qsc_base_of_cw,
+                                      UCHAR       dimension)
+{
+  SCHAR i;
+  if ( remainingBitsInSegment < 0 ) {
+    /* log the error */
+    switch (kind) {
+    case PCW_BODY:
+        pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY;
+        break;
+    case PCW_BODY_SIGN:
+        pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN;
+        break;
+    case PCW_BODY_SIGN_ESC:
+        pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN_ESC;
+        break;
+    }
+    /* mark the erred lines */
+    for ( i = dimension; i != 0; i-- ) {
+      *qsc_base_of_cw++ = (FIXP_DBL) Q_VALUE_INVALID;
+    }
+    return 1;
+  }
+  return 0;
+}
+#endif
+
+#if CHECK_SEGMENTATION_FINAL
+/*---------------------------------------------------------------------------------------------
+     description:   This function checks if all segments are empty after decoding. There
+                    are _no lines markded_ as invalid because it could not be traced back
+                    where from the remaining bits are.
+-------------------------------------------------------------------------------------------- */
+static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr)
+{
+  UCHAR   segmentationErrorFlag   = 0;
+  USHORT  i;
+  SCHAR  *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+  UINT    numSegment              = pHcr->segmentInfo.numSegment;
+
+  for ( i=numSegment; i != 0 ; i--) {
+    if (*pRemainingBitsInSegment++ != 0) {
+      segmentationErrorFlag = 1;
+    }
+  }
+  if (segmentationErrorFlag == 1) {
+    pHcr->decInOut.errorLog |= BIT_IN_SEGMENTATION_ERROR;
+  }
+}
+#endif
+
+/*---------------------------------------------------------------------------------------------
+     description:   This function walks one step within the decoding tree. Which branch is
+                    taken depends on the decoded carryBit input parameter.
+-------------------------------------------------------------------------------------------- */
+void  CarryBitToBranchValue(UCHAR  carryBit,
+                            UINT   treeNode,
+                            UINT  *branchValue,
+                            UINT  *branchNode)
+{
+  if (carryBit == 0) {
+    *branchNode = (treeNode & MASK_LEFT) >> LEFT_OFFSET; /* MASK_LEFT:  00FFF000 */
+  }
+  else {
+    *branchNode = treeNode & MASK_RIGHT;                 /* MASK_RIGHT: 00000FFF */
+  }
+
+  *branchValue = *branchNode & CLR_BIT_10;               /* clear bit 10 (if set) */
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   Decodes the body of a priority codeword (PCW)
+-----------------------------------------------------------------------------------------------
+        return:   - return value is pointer to first of two or four quantized spectral
+                    coefficients
+-------------------------------------------------------------------------------------------- */
+static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM  bs,
+                                   const UINT           *pCurrentTree,
+                                   const SCHAR          *pQuantValBase,
+                                         USHORT         *pLeftStartOfSegment,
+                                         SCHAR          *pRemainingBitsInSegment,
+                                         int            *pNumDecodedBits
+                                  )
+{
+  UCHAR carryBit;
+  UINT  branchNode;
+  UINT  treeNode;
+  UINT  branchValue;
+  const  SCHAR *pQuantVal;
+
+  /* decode PCW_BODY */
+  treeNode = *pCurrentTree;                                                 /* get first node of current tree belonging to current codebook */
+
+  /* decode whole PCW-codeword-body */
+  while (1) {
+
+    carryBit = HcrGetABitFromBitstream(bs,
+                                       pLeftStartOfSegment,
+                                       pLeftStartOfSegment,                 /* dummy */
+                                       FROM_LEFT_TO_RIGHT);
+    *pRemainingBitsInSegment -= 1;
+    *pNumDecodedBits += 1;
+
+    CarryBitToBranchValue(carryBit,
+                          treeNode,
+                          &branchValue,
+                          &branchNode);
+
+    if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {                        /* test bit 10 ; if set --> codeword-body is complete */
+      break;                                                                /* end of branch in tree reached  i.e. a whole PCW-Body is decoded */
+    }
+    else {
+      treeNode = *(pCurrentTree + branchValue);                             /* update treeNode for further step in decoding tree */
+    }
+
+  }
+
+  pQuantVal = pQuantValBase + branchValue;                                  /* update pointer to valid first of 2 or 4 quantized values */
+
+  return pQuantVal;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   This function decodes one escape sequence. In case of a escape codebook
+                    and in case of the absolute value of the quantized spectral value == 16,
+                    a escapeSequence is decoded in two steps:
+                      1. escape prefix
+                      2. escape word
+-------------------------------------------------------------------------------------------- */
+
+static INT  DecodeEscapeSequence(HANDLE_FDK_BITSTREAM  bs,
+                                 INT                   quantSpecCoef,
+                                 USHORT               *pLeftStartOfSegment,
+                                 SCHAR                *pRemainingBitsInSegment,
+                                 int                  *pNumDecodedBits
+                                )
+{
+  UINT  i;
+  INT   sign;
+  UINT  escapeOnesCounter = 0;
+  UINT  carryBit;
+  INT   escape_word = 0;
+
+  /* decode escape prefix */
+  while (1) {
+    carryBit = HcrGetABitFromBitstream(bs,
+                                       pLeftStartOfSegment,
+                                       pLeftStartOfSegment,                /* dummy */
+                                       FROM_LEFT_TO_RIGHT);
+    *pRemainingBitsInSegment -= 1;
+    *pNumDecodedBits += 1;
+
+    if (carryBit != 0) {
+      escapeOnesCounter += 1;
+    }
+    else {
+      escapeOnesCounter += 4;
+      break;
+    }
+  }
+
+  /* decode escape word */
+  for( i=escapeOnesCounter; i != 0 ; i-- ) {
+    carryBit = HcrGetABitFromBitstream(bs,
+                                       pLeftStartOfSegment,
+                                       pLeftStartOfSegment,                /* dummy */
+                                       FROM_LEFT_TO_RIGHT);
+    *pRemainingBitsInSegment -= 1;
+    *pNumDecodedBits += 1;
+
+    escape_word <<= 1;
+    escape_word = escape_word | carryBit;
+  }
+
+  sign = (quantSpecCoef >= 0) ? 1 : -1;
+
+  quantSpecCoef = sign * (((INT ) 1 << escapeOnesCounter) + escape_word);
+
+  return quantSpecCoef;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   Decodes the Signbits of a priority codeword (PCW) and writes out the
+                    resulting quantized spectral values into unsorted sections
+-----------------------------------------------------------------------------------------------
+        output:   - two or four lines at position in corresponding section (which are not
+                    located at the desired position, i.e. they must be reordered in the last
+                    of eight function of HCR)
+-----------------------------------------------------------------------------------------------
+        return:   - updated pQuantSpecCoef pointer (to next empty storage for a line)
+-------------------------------------------------------------------------------------------- */
+static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM  bs,
+                          UINT                  codebookDim,
+                          const SCHAR          *pQuantVal,
+                          FIXP_DBL             *pQuantSpecCoef,
+                          int                  *quantSpecCoefIdx,
+                          USHORT               *pLeftStartOfSegment,
+                          SCHAR                *pRemainingBitsInSegment,
+                          int                  *pNumDecodedBits
+                         )
+{
+  UINT     i;
+  UINT     carryBit;
+  INT      quantSpecCoef;
+
+  for( i=codebookDim; i != 0 ; i-- ) {
+    quantSpecCoef = *pQuantVal++;
+    if (quantSpecCoef != 0) {
+      carryBit = HcrGetABitFromBitstream(bs,
+                                         pLeftStartOfSegment,
+                                         pLeftStartOfSegment,    /* dummy */
+                                         FROM_LEFT_TO_RIGHT);
+      *pRemainingBitsInSegment -= 1;
+      *pNumDecodedBits += 1;
+      if (*pRemainingBitsInSegment < 0 || *pNumDecodedBits >= (1024>>1)) {
+        return -1;
+      }
+
+      /* adapt sign of values according to the decoded sign bit */
+      if (carryBit != 0) {
+        pQuantSpecCoef[*quantSpecCoefIdx] = -(FIXP_DBL)quantSpecCoef;
+      }
+      else {
+        pQuantSpecCoef[*quantSpecCoefIdx] =  (FIXP_DBL)quantSpecCoef;
+      }
+    }
+    else {
+      pQuantSpecCoef[*quantSpecCoefIdx] = FL2FXCONST_DBL(0.0f);
+    }
+    *quantSpecCoefIdx += 1 ;
+    if (*quantSpecCoefIdx >= 1024) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   Mutes spectral lines which have been marked as erroneous (Q_VALUE_INVALID)
+-------------------------------------------------------------------------------------------- */
+void HcrMuteErroneousLines(H_HCR_INFO hHcr)
+{
+  int c;
+  FIXP_DBL *RESTRICT pLong = SPEC_LONG(hHcr->decInOut.pQuantizedSpectralCoefficientsBase);
+
+  /* if there is a line with value Q_VALUE_INVALID mute it */
+  for (c = 0; c < 1024; c++) {
+    if (pLong[c] == (FIXP_DBL)Q_VALUE_INVALID) {
+#if HCR_LISTEN_TO_MUTED_LINES
+      pLong[c] = (FIXP_DBL)HCR_DIRAC;   /* marking */
+#else
+      pLong[c] = FL2FXCONST_DBL(0.0f);  /* muting */
+#endif
+    }
+  }
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   Sets global HCR type
+-------------------------------------------------------------------------------------------- */
+void setHcrType(H_HCR_INFO hHcr, MP4_ELEMENT_ID type)
+{
+  switch (type) {
+    case ID_SCE:
+      hHcr->globalHcrType = 0;
+      break;
+    case ID_CPE:
+      hHcr->globalHcrType = 1;
+      break;
+    default:
+      break;
+  }
+}
+
+
+/*---------------------------------------------------------------------------------------------
+     description:   Gets HCR type from the HCR data structure
+-----------------------------------------------------------------------------------------------
+        return:   - global HCR type
+-------------------------------------------------------------------------------------------- */
+INT getHcrType(H_HCR_INFO hHcr)
+{
+  return hHcr->globalHcrType;
+}
+
+
+
+