Home | History | Annotate | Download | only in src
      1 
      2 /* -----------------------------------------------------------------------------------------------------------
      3 Software License for The Fraunhofer FDK AAC Codec Library for Android
      4 
      5  Copyright  1995 - 2012 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V.
      6   All rights reserved.
      7 
      8  1.    INTRODUCTION
      9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
     10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
     11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
     12 
     13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
     14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
     15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
     16 of the MPEG specifications.
     17 
     18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
     19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
     20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
     21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
     22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
     23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
     24 
     25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
     26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
     27 applications information and documentation.
     28 
     29 2.    COPYRIGHT LICENSE
     30 
     31 Redistribution and use in source and binary forms, with or without modification, are permitted without
     32 payment of copyright license fees provided that you satisfy the following conditions:
     33 
     34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
     35 your modifications thereto in source code form.
     36 
     37 You must retain the complete text of this software license in the documentation and/or other materials
     38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
     39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
     40 modifications thereto to recipients of copies in binary form.
     41 
     42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
     43 prior written permission.
     44 
     45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
     46 software or your modifications thereto.
     47 
     48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
     49 and the date of any change. For modified versions of the FDK AAC Codec, the term
     50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
     51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
     52 
     53 3.    NO PATENT LICENSE
     54 
     55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
     56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
     57 respect to this software.
     58 
     59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
     60 by appropriate patent licenses.
     61 
     62 4.    DISCLAIMER
     63 
     64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
     65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
     66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
     68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
     69 or business interruption, however caused and on any theory of liability, whether in contract, strict
     70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
     71 advised of the possibility of such damage.
     72 
     73 5.    CONTACT INFORMATION
     74 
     75 Fraunhofer Institute for Integrated Circuits IIS
     76 Attention: Audio and Multimedia Departments - FDK AAC LL
     77 Am Wolfsmantel 33
     78 91058 Erlangen, Germany
     79 
     80 www.iis.fraunhofer.de/amm
     81 amm-info (at) iis.fraunhofer.de
     82 ----------------------------------------------------------------------------------------------------------- */
     83 
     84 /*****************************  MPEG-4 AAC Decoder  ***************************
     85 
     86    Author(s):   Robert Weidner (DSP Solutions)
     87    Description: HCR Decoder: HCR initialization, preprocess HCR sideinfo,
     88                 decode priority codewords (PCWs)
     89 
     90 *******************************************************************************/
     91 
     92 #include "aacdec_hcr.h"
     93 
     94 
     95 
     96 #include "aacdec_hcr_types.h"
     97 #include "aacdec_hcr_bit.h"
     98 #include "aacdec_hcrs.h"
     99 #include "aac_ram.h"
    100 #include "aac_rom.h"
    101 #include "channel.h"
    102 #include "block.h"
    103 
    104 #include "aacdecoder.h"     /* for ID_CPE, ID_SCE ... */
    105 #include "FDK_bitstream.h"
    106 
    107 extern int mlFileChCurr;
    108 
    109 static void errDetectorInHcrSideinfoShrt(SCHAR cb,
    110                                          SHORT numLine,
    111                                          UINT *errorWord);
    112 
    113 static void errDetectorInHcrLengths(SCHAR  lengthOfLongestCodeword,
    114                                     SHORT  lengthOfReorderedSpectralData,
    115                                     UINT  *errorWord);
    116 
    117 static void HcrCalcNumCodeword                    (H_HCR_INFO pHcr);
    118 static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr);
    119 static void HcrPrepareSegmentationGrid            (H_HCR_INFO pHcr);
    120 static void HcrExtendedSectionInfo                (H_HCR_INFO pHcr);
    121 
    122 static void DeriveNumberOfExtendedSortedSectionsInSets(UINT   numSegment,
    123                                                        USHORT  *pNumExtendedSortedCodewordInSection,
    124                                                        int      numExtendedSortedCodewordInSectionIdx,
    125                                                        USHORT  *pNumExtendedSortedSectionsInSets,
    126                                                        int      numExtendedSortedSectionsInSetsIdx);
    127 
    128 static INT  DecodeEscapeSequence(HANDLE_FDK_BITSTREAM  bs,
    129                                  INT                   quantSpecCoef,
    130                                  USHORT               *pLeftStartOfSegment,
    131                                  SCHAR                *pRemainingBitsInSegment,
    132                                  int                  *pNumDecodedBits
    133                                 );
    134 
    135 static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM  bs,
    136                           UINT                  codebookDim,
    137                           const SCHAR          *pQuantVal,
    138                           FIXP_DBL             *pQuantSpecCoef,
    139                           int                  *quantSpecCoefIdx,
    140                           USHORT               *pLeftStartOfSegment,
    141                           SCHAR                *pRemainingBitsInSegment,
    142                           int                  *pNumDecodedBits
    143                          );
    144 
    145 static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM  bs,
    146                                    const UINT           *pCurrentTree,
    147                                    const SCHAR          *pQuantValBase,
    148                                          USHORT         *pLeftStartOfSegment,
    149                                          SCHAR          *pRemainingBitsInSegment,
    150                                          int            *pNumDecodedBits
    151                                   );
    152 
    153 static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr);
    154 
    155 static void HcrReorderQuantizedSpectralCoefficients(
    156         H_HCR_INFO pHcr,
    157         CAacDecoderChannelInfo *pAacDecoderChannelInfo,
    158         const SamplingRateInfo *pSamplingRateInfo
    159         );
    160 
    161 
    162 #if CHECK_SEGMENTATION_IMMEDIATELY
    163 static UCHAR errDetectPcwSegmentation(SCHAR       remainingBitsInSegment,
    164                                       H_HCR_INFO  pHcr,
    165                                       PCW_TYPE    kind,
    166                                       FIXP_DBL   *qsc_base_of_cw,
    167                                       UCHAR       dimension);
    168 #endif
    169 
    170 #if CHECK_SEGMENTATION_FINAL
    171 static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr);
    172 #endif
    173 
    174 /*---------------------------------------------------------------------------------------------
    175      description:   Check if codebook and numSect are within allowed range (short only)
    176 -------------------------------------------------------------------------------------------- */
    177 static void errDetectorInHcrSideinfoShrt(SCHAR cb, SHORT numLine,UINT* errorWord)
    178 {
    179 
    180 
    181 
    182   if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) {
    183     *errorWord |= CB_OUT_OF_RANGE_SHORT_BLOCK;
    184   }
    185   if ( numLine < 0 || numLine > 1024 ) {
    186     *errorWord |= LINE_IN_SECT_OUT_OF_RANGE_SHORT_BLOCK;
    187   }
    188 }
    189 
    190 /*---------------------------------------------------------------------------------------------
    191      description:   Check both HCR lengths
    192 -------------------------------------------------------------------------------------------- */
    193 static void errDetectorInHcrLengths(SCHAR  lengthOfLongestCodeword,
    194                                     SHORT  lengthOfReorderedSpectralData,
    195                                     UINT  *errorWord)
    196 {
    197   if ( lengthOfReorderedSpectralData < lengthOfLongestCodeword ) {
    198     *errorWord |= HCR_SI_LENGTHS_FAILURE;
    199   }
    200 }
    201 
    202 /*---------------------------------------------------------------------------------------------
    203      description:   Decode (and adapt if necessary) the two HCR sideinfo components:
    204                     'reordered_spectral_data_length' and 'longest_codeword_length'
    205 -------------------------------------------------------------------------------------------- */
    206 
    207 void CHcr_Read(HANDLE_FDK_BITSTREAM    bs,
    208                CAacDecoderChannelInfo *pAacDecoderChannelInfo)
    209 {
    210   INT    globalHcrType = getHcrType(&pAacDecoderChannelInfo->pComData->overlay.aac.erHcrInfo);
    211   SHORT  lengOfReorderedSpectralData;
    212   SCHAR  lengOfLongestCodeword;
    213 
    214   pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = 0;
    215   pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword       = 0;
    216 
    217 
    218 
    219     /* ------- SI-Value No 1 ------- */
    220     lengOfReorderedSpectralData = FDKreadBits(bs,14) + ERROR_LORSD;
    221     if ( globalHcrType == ID_CPE ) {
    222       if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= CPE_TOP_LENGTH)) {
    223         pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */
    224       }
    225       else {
    226         if (lengOfReorderedSpectralData > CPE_TOP_LENGTH) {
    227           pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = CPE_TOP_LENGTH;            /* use valid maximum */
    228         }
    229       }
    230     }
    231     else if (globalHcrType == ID_SCE || globalHcrType == ID_LFE || globalHcrType == ID_CCE ) {
    232       if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= SCE_TOP_LENGTH)) {
    233         pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */
    234       }
    235       else {
    236         if (lengOfReorderedSpectralData > SCE_TOP_LENGTH) {
    237           pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = SCE_TOP_LENGTH;            /* use valid maximum */
    238         }
    239       }
    240     }
    241 
    242     /* ------- SI-Value No 2 ------- */
    243     lengOfLongestCodeword = FDKreadBits(bs,6) + ERROR_LOLC;
    244     if ((lengOfLongestCodeword >= 0) && (lengOfLongestCodeword <= LEN_OF_LONGEST_CW_TOP_LENGTH)) {
    245       pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = lengOfLongestCodeword;                /* the decoded value is within range */
    246     }
    247     else {
    248       if (lengOfLongestCodeword > LEN_OF_LONGEST_CW_TOP_LENGTH) {
    249         pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = LEN_OF_LONGEST_CW_TOP_LENGTH;       /* use valid maximum */
    250       }
    251     }
    252 }
    253 
    254 
    255 /*---------------------------------------------------------------------------------------------
    256      description:   Sets up HCR ROM-Tables
    257 -------------------------------------------------------------------------------------------- */
    258 
    259 void HcrInitRom(H_HCR_INFO pHcr)
    260 {
    261   pHcr->cbPairs.pMinOfCbPair     = aMinOfCbPair;
    262   pHcr->cbPairs.pMaxOfCbPair     = aMaxOfCbPair;
    263 
    264   pHcr->tableInfo.pMaxCwLength   = aMaxCwLen;
    265   pHcr->tableInfo.pCbDimension   = aDimCb;
    266   pHcr->tableInfo.pCbDimShift    = aDimCbShift;
    267   pHcr->tableInfo.pCbSign        = aSignCb;
    268   pHcr->tableInfo.pCbPriority    = aCbPriority;
    269   pHcr->tableInfo.pLargestAbsVal = aLargestAbsoluteValue;
    270 }
    271 
    272 /*---------------------------------------------------------------------------------------------
    273      description:   Set up HCR - must be called before every call to HcrDecoder().
    274                     For short block a sorting algorithm is applied to get the SI in the order
    275                     that HCR could assemble the qsc's as if it is a long block.
    276 -----------------------------------------------------------------------------------------------
    277         return:     error log
    278 -------------------------------------------------------------------------------------------- */
    279 
    280 UINT HcrInit(H_HCR_INFO              pHcr,
    281              CAacDecoderChannelInfo *pAacDecoderChannelInfo,
    282              const SamplingRateInfo *pSamplingRateInfo,
    283              HANDLE_FDK_BITSTREAM    bs)
    284 {
    285   CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
    286   SHORT *pNumLinesInSec;
    287   UCHAR *pCodeBk;
    288   SHORT  numSection;
    289   SCHAR  cb;
    290   int  numLine;
    291   int  i;
    292 
    293   pHcr->decInOut.lengthOfReorderedSpectralData      = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData;
    294   pHcr->decInOut.lengthOfLongestCodeword            = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword;
    295   pHcr->decInOut.pQuantizedSpectralCoefficientsBase = pAacDecoderChannelInfo->pSpectralCoefficient;
    296   pHcr->decInOut.quantizedSpectralCoefficientsIdx   = 0;
    297   pHcr->decInOut.pCodebook                          = pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr;
    298   pHcr->decInOut.pNumLineInSect                     = pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr;
    299   pHcr->decInOut.numSection                         = pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection;
    300   pHcr->decInOut.errorLog = 0;
    301   pHcr->nonPcwSideinfo.pResultBase                  = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
    302 
    303   FDKsyncCache(bs);
    304   pHcr->decInOut.bitstreamIndex                     = FDKgetBitCnt(bs);
    305 
    306   if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo))   /* short block */
    307   {
    308     SHORT  band;
    309     SHORT  maxBand;
    310     SCHAR  group;
    311     SCHAR  winGroupLen;
    312     SCHAR  window;
    313     SCHAR  numUnitInBand;
    314     SCHAR  cntUnitInBand;
    315     SCHAR  groupWin;
    316     SCHAR  cb_prev;
    317 
    318     UCHAR *pCodeBook;
    319     const SHORT *BandOffsets;
    320     SCHAR  numOfGroups;
    321 
    322 
    323     pCodeBook      = pAacDecoderChannelInfo->pDynData->aCodeBook;             /* in */
    324     pNumLinesInSec = pHcr->decInOut.pNumLineInSect;                               /* out */
    325     pCodeBk        = pHcr->decInOut.pCodebook;                                    /* out */
    326     BandOffsets    = GetScaleFactorBandOffsets(pIcsInfo, pSamplingRateInfo); /* aux */
    327     numOfGroups    = GetWindowGroups(pIcsInfo);
    328 
    329     numLine = 0;
    330     numSection = 0;
    331     cb      = pCodeBook[0];
    332     cb_prev = pCodeBook[0];
    333 
    334     /* convert HCR-sideinfo into a unitwise manner: When the cb changes, a new section starts */
    335 
    336     *pCodeBk++ = cb_prev;
    337 
    338     maxBand = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
    339     for (band = 0; band < maxBand; band++) {  /* from low to high sfbs i.e. from low to high frequencies  */
    340       numUnitInBand = ((BandOffsets[band+1] - BandOffsets[band]) >> FOUR_LOG_DIV_TWO_LOG); /* get the number of units in current sfb */
    341       for (cntUnitInBand = numUnitInBand;  cntUnitInBand != 0; cntUnitInBand-- ) { /* for every unit in the band */
    342         for (window = 0, group = 0; group < numOfGroups; group++) {
    343           winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group);
    344           for (groupWin = winGroupLen; groupWin != 0; groupWin--, window++) {
    345             cb = pCodeBook[group * 16 + band];
    346             if (cb != cb_prev) {
    347 #if CHECK_VALID_HCR_INPUT /* short-block  1 of 2 */
    348               errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog );
    349               if (pHcr->decInOut.errorLog != 0 ) {
    350                 return ( pHcr->decInOut.errorLog );
    351               }
    352 #endif
    353               *pCodeBk++ = cb;
    354               *pNumLinesInSec++ = numLine;
    355               numSection++;
    356 
    357               cb_prev = cb;
    358               numLine = LINES_PER_UNIT;
    359             }
    360             else {
    361               numLine += LINES_PER_UNIT;
    362             }
    363           }
    364         }
    365       }
    366     }
    367 
    368     numSection++;
    369 
    370 #if CHECK_VALID_HCR_INPUT /* short-block  2 of 2 */
    371     errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog );
    372     if ( numSection <= 0 || numSection > 1024/2 ) {
    373       pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_SHORT_BLOCK;
    374     }
    375     errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword,
    376                             pHcr->decInOut.lengthOfReorderedSpectralData,
    377                            &pHcr->decInOut.errorLog);
    378     if (pHcr->decInOut.errorLog != 0 ) {
    379       return ( pHcr->decInOut.errorLog );
    380     }
    381 #endif
    382 
    383     *pCodeBk = cb;
    384     *pNumLinesInSec = numLine;
    385     pHcr->decInOut.numSection = numSection;
    386 
    387   } else /* end short block prepare SI */
    388   {      /* long block */
    389 #if CHECK_VALID_HCR_INPUT /* long-block  1 of 1 */
    390     errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword,
    391                             pHcr->decInOut.lengthOfReorderedSpectralData,
    392                            &pHcr->decInOut.errorLog);
    393     numSection     = pHcr->decInOut.numSection;
    394     pNumLinesInSec = pHcr->decInOut.pNumLineInSect;
    395     pCodeBk        = pHcr->decInOut.pCodebook;
    396     if ( numSection <= 0 || numSection > 64 ) {
    397       pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_LONG_BLOCK;
    398       numSection = 0;
    399     }
    400 
    401     for ( i = numSection; i != 0; i-- )
    402     {
    403       cb = *pCodeBk++;
    404 
    405       if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) {
    406         pHcr->decInOut.errorLog |= CB_OUT_OF_RANGE_LONG_BLOCK;
    407       }
    408 
    409       numLine = *pNumLinesInSec++;
    410       /* FDK_ASSERT(numLine > 0); */
    411 
    412       if ( (numLine <= 0) || (numLine > 1024) ) {
    413         pHcr->decInOut.errorLog |= LINE_IN_SECT_OUT_OF_RANGE_LONG_BLOCK;
    414       }
    415     }
    416     if (pHcr->decInOut.errorLog != 0 ) {
    417       return ( pHcr->decInOut.errorLog );
    418     }
    419 #endif  /* CHECK_VALID_HCR_INPUT */
    420   }
    421 
    422   pCodeBk = pHcr->decInOut.pCodebook;
    423   for ( i = 0; i < numSection; i++ ) {
    424     if (
    425          (*pCodeBk == NOISE_HCB)      ||
    426          (*pCodeBk == INTENSITY_HCB2) ||
    427          (*pCodeBk == INTENSITY_HCB))
    428     {
    429       *pCodeBk = 0;
    430     }
    431     pCodeBk++;
    432   }
    433 
    434   /* HCR-sideinfo-input is complete and seems to be valid */
    435 
    436 
    437 
    438   return ( pHcr->decInOut.errorLog );
    439 }
    440 
    441 
    442 
    443 
    444 #if USE_HCR_DUMMY
    445 
    446 /*---------------------------------------------------------------------------------------------
    447 
    448      description:   This HCR - dummy  - function writes only a dirac-sequence in output buffer
    449 
    450 -------------------------------------------------------------------------------------------- */
    451 UINT HcrDecoder(H_HCR_INFO              pHcr,
    452                 const CAacDecoderChannelInfo *pAacDecoderChannelInfo,
    453                 HANDLE_FDK_BITSTREAM    bs)
    454 {
    455   for (SHORT i=0; i < 1024; i++ ) {
    456     pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = FL2FXCONST_DBL(0.0f);
    457     if ( i % 30 == 0) {
    458       pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = (FIXP_DBL)HCR_DIRAC;
    459     }
    460   }
    461   return 0;
    462 }
    463 
    464 #else /* USE_HCR_DUMMY */
    465 
    466 /*---------------------------------------------------------------------------------------------
    467      description:   This function decodes the codewords of the spectral coefficients from the
    468                     bitstream according to the HCR algorithm and stores the quantized spectral
    469                     coefficients in correct order in the output buffer.
    470 -------------------------------------------------------------------------------------------- */
    471 
    472 UINT HcrDecoder(H_HCR_INFO              pHcr,
    473                 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
    474                 const SamplingRateInfo       *pSamplingRateInfo,
    475                 HANDLE_FDK_BITSTREAM    bs)
    476 {
    477   int pTmp1, pTmp2, pTmp3, pTmp4;
    478 #if DETECT_TOO_LONG_CW_READS
    479   int        pTmp5;
    480 #endif
    481 
    482   INT        bitCntOffst;
    483   UINT       saveBitCnt = FDKgetBitCnt(bs);   /* save bitstream position */
    484 
    485   HcrCalcNumCodeword(pHcr);
    486 
    487   HcrSortCodebookAndNumCodewordInSection(pHcr);
    488 
    489   HcrPrepareSegmentationGrid(pHcr);
    490 
    491   HcrExtendedSectionInfo(pHcr);
    492 
    493   if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) != 0 ) {
    494     return ( pHcr->decInOut.errorLog );  /* sideinfo is massively corrupt, return from HCR without having decoded anything */
    495   }
    496 
    497   DeriveNumberOfExtendedSortedSectionsInSets(pHcr->segmentInfo.numSegment,
    498                                              pHcr->sectionInfo.pNumExtendedSortedCodewordInSection,
    499                                              pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx,
    500                                              pHcr->sectionInfo.pNumExtendedSortedSectionsInSets,
    501                                              pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx);
    502 
    503   /* store */
    504   pTmp1 = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx;
    505   pTmp2 = pHcr->sectionInfo.extendedSortedCodebookIdx;
    506   pTmp3 = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx;
    507   pTmp4 = pHcr->decInOut.quantizedSpectralCoefficientsIdx;
    508 #if DETECT_TOO_LONG_CW_READS
    509   pTmp5 = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;
    510 #endif
    511 
    512   /* ------- decode meaningful PCWs ------ */
    513   DecodePCWs(bs, pHcr);
    514 
    515   if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) == 0 ) {
    516     /* ------ decode the non-PCWs -------- */
    517     DecodeNonPCWs(bs, pHcr);
    518   }
    519 
    520 
    521 #if CHECK_SEGMENTATION_FINAL
    522   errDetectWithinSegmentationFinal(pHcr);
    523 #endif
    524 
    525   /* restore */
    526   pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = pTmp1;
    527   pHcr->sectionInfo.extendedSortedCodebookIdx             = pTmp2;
    528   pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx    = pTmp3;
    529   pHcr->decInOut.quantizedSpectralCoefficientsIdx         = pTmp4;
    530 #if DETECT_TOO_LONG_CW_READS
    531   pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx              = pTmp5;
    532 #endif
    533 
    534   HcrReorderQuantizedSpectralCoefficients(pHcr, pAacDecoderChannelInfo, pSamplingRateInfo);
    535 
    536   /* restore bitstream position */
    537   bitCntOffst = saveBitCnt - FDKgetBitCnt(bs);
    538   if( bitCntOffst ) {
    539     FDKpushBiDirectional(bs, bitCntOffst);
    540   }
    541 
    542   return ( pHcr->decInOut.errorLog );
    543 }
    544 
    545 
    546 #endif  /* USE_HCR_DUMMY */
    547 
    548 
    549 
    550 
    551 /*---------------------------------------------------------------------------------------------
    552      description:   This function reorders the quantized spectral coefficients sectionwise for
    553                     long- and short-blocks and compares to the LAV (Largest Absolute Value of
    554                     the current codebook) -- a counter is incremented if there is an error
    555                     detected.
    556                     Additional for short-blocks a unit-based-deinterleaving is applied.
    557                     Moreover (for short blocks) the scaling is derived (compare plain huffman
    558                     decoder).
    559 -------------------------------------------------------------------------------------------- */
    560 
    561 static void HcrReorderQuantizedSpectralCoefficients(
    562         H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,
    563         const SamplingRateInfo *pSamplingRateInfo
    564         )
    565 {
    566   INT       qsc;
    567   UINT      abs_qsc;
    568   UINT      i,j;
    569   USHORT    numSpectralValuesInSection;
    570   FIXP_DBL *pTeVa;
    571   USHORT    lavErrorCnt = 0;
    572 
    573   UINT      numSection                         = pHcr->decInOut.numSection;
    574   SPECTRAL_PTR  pQuantizedSpectralCoefficientsBase = pHcr->decInOut.pQuantizedSpectralCoefficientsBase;
    575   FIXP_DBL *pQuantizedSpectralCoefficients     = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase);
    576   const UCHAR    *pCbDimShift                  = pHcr->tableInfo.pCbDimShift;
    577   const USHORT   *pLargestAbsVal               = pHcr->tableInfo.pLargestAbsVal;
    578   UCHAR    *pSortedCodebook                    = pHcr->sectionInfo.pSortedCodebook;
    579   USHORT   *pNumSortedCodewordInSection        = pHcr->sectionInfo.pNumSortedCodewordInSection;
    580   USHORT   *pReorderOffset                     = pHcr->sectionInfo.pReorderOffset;
    581   FIXP_DBL *pTempValues                        = pHcr->segmentInfo.pTempValues;
    582   FIXP_DBL *pBak                               = pHcr->segmentInfo.pTempValues;
    583 
    584   FDKmemclear(pTempValues,1024*sizeof(FIXP_DBL));
    585 
    586   /* long and short: check if decoded huffman-values (quantized spectral coefficients) are within range */
    587   for ( i=numSection; i != 0; i-- ) {
    588     numSpectralValuesInSection = *pNumSortedCodewordInSection++ << pCbDimShift[*pSortedCodebook];
    589     pTeVa = &pTempValues[*pReorderOffset++];
    590     for( j = numSpectralValuesInSection; j != 0; j-- ) {
    591       qsc = *pQuantizedSpectralCoefficients++;
    592       abs_qsc = FDKabs(qsc);
    593 #if VALID_LAV_ERROR_TRIGGER
    594       if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) {
    595         *pTeVa++ = (FIXP_DBL)qsc;  /* the qsc value is within range */
    596       }
    597       else { /* line is too high .. */
    598         if ( abs_qsc == Q_VALUE_INVALID ) { /* .. because of previous marking --> dont set LAV flag (would be confusing), just copy out the already marked value */
    599           *pTeVa++ = (FIXP_DBL) qsc;
    600         }
    601         else {                              /* .. because a too high value was decoded for this cb --> set LAV flag */
    602           *pTeVa++ = (FIXP_DBL) Q_VALUE_INVALID;
    603           lavErrorCnt += 1;
    604         }
    605       }
    606 #else
    607       if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) {
    608         *pTeVa++ = qsc;
    609       }
    610       else {
    611         *pTeVa++ = Q_VALUE_INVALID;
    612         lavErrorCnt += 1;
    613       }
    614 #endif
    615     }
    616     pSortedCodebook++;
    617   }
    618 
    619   if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo))
    620   {
    621     FIXP_DBL *pOut;
    622     FIXP_DBL  locMax;
    623     FIXP_DBL  tmp;
    624     SCHAR     groupoffset;
    625     SCHAR     group;
    626     SCHAR     band;
    627     SCHAR     groupwin;
    628     SCHAR     window;
    629     SCHAR     numWinGroup;
    630     SHORT     interm;
    631     SCHAR     numSfbTransm;
    632     SCHAR     winGroupLen;
    633     SHORT     index;
    634     INT       msb;
    635     INT       lsb;
    636 
    637     SHORT   *pScaleFacHcr = pAacDecoderChannelInfo->pDynData->aScaleFactor;
    638     SHORT   *pSfbSclHcr   = pAacDecoderChannelInfo->pDynData->aSfbScale;
    639     const SHORT *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
    640 
    641     pBak = pHcr->segmentInfo.pTempValues;
    642     /* deinterleave unitwise for short blocks */
    643     for ( window = 0; window < (8); window++ ) {
    644       pOut = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength);
    645       for ( i=0; i < (LINES_PER_UNIT_GROUP); i++ ) {
    646         pTeVa = pBak + (window << FOUR_LOG_DIV_TWO_LOG) + i * 32;	/* distance of lines between unit groups has to be constant for every framelength (32)!  */
    647         for ( j=(LINES_PER_UNIT); j != 0; j-- ) {
    648           *pOut++ = *pTeVa++;
    649         }
    650       }
    651     }
    652 
    653     /* short blocks only */
    654     /* derive global scaling-value for every sfb and every window (as it is done in plain-huffman-decoder at short blocks) */
    655     groupoffset = 0;
    656 
    657     numWinGroup = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo);
    658     numSfbTransm = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
    659 
    660     for (group = 0; group < numWinGroup; group++) {
    661       winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group);
    662       for (band = 0; band < numSfbTransm; band++) {
    663         interm = group * 16 + band;
    664         msb = pScaleFacHcr[interm] >> 2;
    665         lsb = pScaleFacHcr[interm] & 3;
    666         for (groupwin = 0; groupwin < winGroupLen; groupwin++) {
    667           window = groupoffset + groupwin;
    668           pBak = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength);
    669           locMax = FL2FXCONST_DBL(0.0f);
    670           for (index = BandOffsets[band]; index < BandOffsets[band+1]; index += LINES_PER_UNIT) {
    671             pTeVa = &pBak[index];
    672             for ( i = LINES_PER_UNIT; i != 0; i --) {
    673               tmp = (*pTeVa < FL2FXCONST_DBL(0.0f))? -*pTeVa++ : *pTeVa++;
    674               locMax = fixMax(tmp,locMax);
    675             }
    676           }
    677           if ( fixp_abs(locMax) > (FIXP_DBL)MAX_QUANTIZED_VALUE ) {
    678             locMax = (FIXP_DBL)MAX_QUANTIZED_VALUE;
    679           }
    680           pSfbSclHcr[window*16+band] = msb - GetScaleFromValue(locMax, lsb);  /* save global scale maxima in this sfb */
    681         }
    682       }
    683       groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group);
    684     }
    685   } else
    686   {
    687     /* copy straight for long-blocks */
    688     pQuantizedSpectralCoefficients = SPEC_LONG(pQuantizedSpectralCoefficientsBase);
    689     for ( i = 1024; i != 0; i-- ) {
    690       *pQuantizedSpectralCoefficients++ = *pBak++;
    691     }
    692   }
    693 
    694   if ( lavErrorCnt != 0 ) {
    695     pHcr->decInOut.errorLog |= LAV_VIOLATION;
    696   }
    697 }
    698 
    699 
    700 /*---------------------------------------------------------------------------------------------
    701      description:   This function calculates the number of codewords
    702                     for each section (numCodewordInSection) and the number of codewords
    703                     for all sections (numCodeword).
    704                     For zero and intensity codebooks a entry is also done in the variable
    705                     numCodewordInSection. It is assumed that the codebook is a two tuples
    706                     codebook. This is needed later for the calculation of the base addresses
    707                     for the reordering of the quantize spectral coefficients at the end of the
    708                     hcr tool.
    709                     The variable numCodeword contain the number of codewords which are really
    710                     in the bitstream. Zero or intensity codebooks does not increase the
    711                     variable numCodewords.
    712 -----------------------------------------------------------------------------------------------
    713         return:   -
    714 -------------------------------------------------------------------------------------------- */
    715 
    716 static void HcrCalcNumCodeword(H_HCR_INFO pHcr)
    717 {
    718   int     hcrSection;
    719   UINT    numCodeword;
    720 
    721   UINT    numSection            =   pHcr->decInOut.numSection;
    722   UCHAR  *pCodebook             =   pHcr->decInOut.pCodebook;
    723   SHORT  *pNumLineInSection     =   pHcr->decInOut.pNumLineInSect;
    724   const UCHAR  *pCbDimShift     =   pHcr->tableInfo.pCbDimShift;
    725   USHORT *pNumCodewordInSection =   pHcr->sectionInfo.pNumCodewordInSection;
    726 
    727   numCodeword = 0;
    728   for ( hcrSection = numSection; hcrSection != 0; hcrSection-- ) {
    729     *pNumCodewordInSection = *pNumLineInSection++ >> pCbDimShift[*pCodebook];
    730     if ( *pCodebook != 0 ) {
    731       numCodeword += *pNumCodewordInSection;
    732     }
    733     pNumCodewordInSection++;
    734     pCodebook++;
    735   }
    736   pHcr->sectionInfo.numCodeword = numCodeword;
    737 }
    738 
    739 
    740 /*---------------------------------------------------------------------------------------------
    741      description:   This function calculates the number
    742                     of sorted codebooks and sorts the codebooks and the numCodewordInSection
    743                     according to the priority.
    744 -------------------------------------------------------------------------------------------- */
    745 
    746 static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr)
    747 {
    748 
    749   UINT    i,j,k;
    750   UCHAR   temp;
    751   UINT    counter;
    752   UINT    startOffset;
    753   UINT    numZeroSection;
    754   UCHAR  *pDest;
    755   UINT    numSectionDec;
    756 
    757   UINT    numSection                  =   pHcr->decInOut.numSection;
    758   UCHAR  *pCodebook                   =   pHcr->decInOut.pCodebook;
    759   UCHAR  *pSortedCodebook             =   pHcr->sectionInfo.pSortedCodebook;
    760   USHORT *pNumCodewordInSection       =   pHcr->sectionInfo.pNumCodewordInSection;
    761   USHORT *pNumSortedCodewordInSection =   pHcr->sectionInfo.pNumSortedCodewordInSection;
    762   UCHAR  *pCodebookSwitch             =   pHcr->sectionInfo.pCodebookSwitch;
    763   USHORT *pReorderOffset              =   pHcr->sectionInfo.pReorderOffset;
    764   const UCHAR   *pCbPriority          =   pHcr->tableInfo.pCbPriority;
    765   const UCHAR   *pMinOfCbPair         =   pHcr->cbPairs.pMinOfCbPair;
    766   const UCHAR   *pMaxOfCbPair         =   pHcr->cbPairs.pMaxOfCbPair;
    767   const UCHAR   *pCbDimShift          =   pHcr->tableInfo.pCbDimShift;
    768 
    769   UINT searchStart = 0;
    770 
    771   /* calculate *pNumSortedSection and store the priorities in array pSortedCdebook */
    772   pDest = pSortedCodebook;
    773   numZeroSection = 0;
    774   for ( i=numSection; i != 0; i-- ) {
    775     if ( pCbPriority[*pCodebook] == 0 ) {
    776       numZeroSection += 1;
    777     }
    778     *pDest++ = pCbPriority[*pCodebook++];
    779   }
    780   pHcr->sectionInfo.numSortedSection = numSection - numZeroSection;    /* numSortedSection contains no zero or intensity section */
    781   pCodebook = pHcr->decInOut.pCodebook;
    782 
    783   /* sort priorities of the codebooks in array pSortedCdebook[] */
    784   numSectionDec = numSection - 1;
    785   if ( numSectionDec > 0 ) {
    786     counter = numSectionDec;
    787     for ( j=numSectionDec; j != 0; j-- ) {
    788       for ( i=0; i < counter; i++ ) {
    789         /* swap priorities */
    790         if ( pSortedCodebook[i+1] > pSortedCodebook[i] ) {
    791           temp                 = pSortedCodebook[i];
    792           pSortedCodebook[i]   = pSortedCodebook[i+1];
    793           pSortedCodebook[i+1] = temp;
    794         }
    795       }
    796       counter -= 1;
    797     }
    798   }
    799 
    800   /* clear codebookSwitch array */
    801   for ( i = numSection; i != 0; i--) {
    802     *pCodebookSwitch++ = 0;
    803   }
    804   pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch;
    805 
    806   /* sort sectionCodebooks and numCodwordsInSection and calculate pReorderOffst[j] */
    807   for ( j = 0; j < numSection; j++ ) {
    808     for ( i = searchStart; i < numSection; i++ ) {
    809       if ( pCodebookSwitch[i] == 0 && ( pMinOfCbPair[pSortedCodebook[j]] == pCodebook[i]  ||  pMaxOfCbPair[pSortedCodebook[j]] == pCodebook[i] )) {
    810         pCodebookSwitch[i] = 1;
    811         pSortedCodebook[j] = pCodebook[i];                              /* sort codebook */
    812         pNumSortedCodewordInSection[j] = pNumCodewordInSection[i];      /* sort NumCodewordInSection */
    813 
    814         startOffset = 0;
    815         for ( k = 0; k < i; k++ ) {                                     /* make entry in pReorderOffst */
    816           startOffset += pNumCodewordInSection[k] << pCbDimShift[pCodebook[k]];
    817         }
    818         pReorderOffset[j] = startOffset;                                /* offset for reordering the codewords */
    819 
    820         if(i == searchStart) {
    821           UINT k = i;
    822           while(pCodebookSwitch[k++] == 1) searchStart++;
    823         }
    824         break;
    825       }
    826     }
    827   }
    828 }
    829 
    830 
    831 /*---------------------------------------------------------------------------------------------
    832      description:   This function calculates the segmentation, which includes numSegment,
    833                     leftStartOfSegment, rightStartOfSegment and remainingBitsInSegment.
    834                     The segmentation could be visualized a as kind of 'overlay-grid' for the
    835                     bitstream-block holding the HCR-encoded quantized-spectral-coefficients.
    836 -------------------------------------------------------------------------------------------- */
    837 
    838 static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr)
    839 {
    840   USHORT   i,j;
    841   USHORT   numSegment = 0;
    842   USHORT   segmentStart = 0;
    843   UCHAR    segmentWidth;
    844   UCHAR    lastSegmentWidth;
    845   UCHAR    sortedCodebook;
    846   UCHAR    endFlag = 0;
    847   USHORT   intermediateResult;
    848 
    849   SCHAR    lengthOfLongestCodeword       =   pHcr->decInOut.lengthOfLongestCodeword;
    850   SHORT    lengthOfReorderedSpectralData =   pHcr->decInOut.lengthOfReorderedSpectralData;
    851   UINT     numSortedSection              =   pHcr->sectionInfo.numSortedSection;
    852   UCHAR   *pSortedCodebook               =   pHcr->sectionInfo.pSortedCodebook;
    853   USHORT  *pNumSortedCodewordInSection   =   pHcr->sectionInfo.pNumSortedCodewordInSection;
    854   USHORT  *pLeftStartOfSegment           =   pHcr->segmentInfo.pLeftStartOfSegment;
    855   USHORT  *pRightStartOfSegment          =   pHcr->segmentInfo.pRightStartOfSegment;
    856   SCHAR   *pRemainingBitsInSegment       =   pHcr->segmentInfo.pRemainingBitsInSegment;
    857   USHORT   bitstreamIndex                =   pHcr->decInOut.bitstreamIndex;
    858   const UCHAR *pMaxCwLength              =   pHcr->tableInfo.pMaxCwLength;
    859 
    860   for ( i=numSortedSection; i != 0; i-- ) {
    861     sortedCodebook = *pSortedCodebook++;
    862     segmentWidth = FDKmin(pMaxCwLength[sortedCodebook],lengthOfLongestCodeword);
    863 
    864     for ( j = *pNumSortedCodewordInSection; j != 0 ; j-- ) {
    865       /* width allows a new segment */
    866       intermediateResult = bitstreamIndex + segmentStart;
    867       if ( (segmentStart + segmentWidth) <= lengthOfReorderedSpectralData ) {
    868         /* store segment start, segment length and increment the number of segments */
    869         *pLeftStartOfSegment++ = intermediateResult;
    870         *pRightStartOfSegment++ = intermediateResult + segmentWidth - 1;
    871         *pRemainingBitsInSegment++ = segmentWidth;
    872         segmentStart += segmentWidth;
    873         numSegment += 1;
    874       }
    875       /* width does not allow a new segment */
    876       else {
    877         /* correct the last segment length */
    878         pLeftStartOfSegment--;
    879         pRightStartOfSegment--;
    880         pRemainingBitsInSegment--;
    881         segmentStart = *pLeftStartOfSegment - bitstreamIndex;
    882 
    883         lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart;
    884         *pRemainingBitsInSegment = lastSegmentWidth;
    885         *pRightStartOfSegment = bitstreamIndex + segmentStart + lastSegmentWidth - 1;
    886         endFlag = 1;
    887         break;
    888       }
    889     }
    890     pNumSortedCodewordInSection++;
    891     if (endFlag != 0) {
    892       break;
    893     }
    894   }
    895   pHcr->segmentInfo.numSegment = numSegment;
    896 
    897 }
    898 
    899 
    900 /*---------------------------------------------------------------------------------------------
    901      description:   This function adapts the sorted section boundaries to the boundaries of
    902                     segmentation. If the section lengths does not fit completely into the
    903                     current segment, the section is spitted into two so called 'extended
    904                     sections'. The extended-section-info (pNumExtendedSortedCodewordInSectin
    905                     and pExtendedSortedCodebook) is updated in this case.
    906 
    907 -------------------------------------------------------------------------------------------- */
    908 
    909 static void HcrExtendedSectionInfo(H_HCR_INFO pHcr)
    910 {
    911   UINT    srtSecCnt = 0;         /* counter for sorted sections */
    912   UINT    xSrtScCnt = 0;         /* counter for extended sorted sections */
    913   UINT    remainNumCwInSortSec;
    914   UINT    inSegmentRemainNumCW;
    915 
    916   UINT    numSortedSection            = pHcr->sectionInfo.numSortedSection;
    917   UCHAR  *pSortedCodebook             = pHcr->sectionInfo.pSortedCodebook;
    918   USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection;
    919   UCHAR  *pExtendedSortedCoBo         = pHcr->sectionInfo.pExtendedSortedCodebook;
    920   USHORT *pNumExtSortCwInSect         = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection;
    921   UINT    numSegment                  = pHcr->segmentInfo.numSegment;
    922 #if DETECT_TOO_LONG_CW_READS
    923   UCHAR  *pMaxLenOfCbInExtSrtSec      = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;
    924   SCHAR   lengthOfLongestCodeword     = pHcr->decInOut.lengthOfLongestCodeword;
    925   const UCHAR   *pMaxCwLength         = pHcr->tableInfo.pMaxCwLength;
    926 #endif
    927 
    928   remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];
    929   inSegmentRemainNumCW = numSegment;
    930 
    931   while (srtSecCnt < numSortedSection) {
    932     if (inSegmentRemainNumCW < remainNumCwInSortSec) {
    933 
    934       pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW;
    935       pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];
    936 
    937       remainNumCwInSortSec -= inSegmentRemainNumCW;
    938       inSegmentRemainNumCW = numSegment;
    939       /* data of a sorted section was not integrated in extended sorted section */
    940     }
    941     else if (inSegmentRemainNumCW == remainNumCwInSortSec) {
    942       pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW;
    943       pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];
    944 
    945       srtSecCnt++;
    946       remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];
    947       inSegmentRemainNumCW = numSegment;
    948       /* data of a sorted section was integrated in extended sorted section */
    949     }
    950     else { /* inSegmentRemainNumCW > remainNumCwInSortSec */
    951       pNumExtSortCwInSect[xSrtScCnt] = remainNumCwInSortSec;
    952       pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt];
    953 
    954 
    955       inSegmentRemainNumCW -= remainNumCwInSortSec;
    956       srtSecCnt++;
    957       remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt];
    958       /* data of a sorted section was integrated in extended sorted section */
    959     }
    960 #if DETECT_TOO_LONG_CW_READS
    961     pMaxLenOfCbInExtSrtSec[xSrtScCnt] = FDKmin(pMaxCwLength[pExtendedSortedCoBo[xSrtScCnt]],lengthOfLongestCodeword);
    962 #endif
    963 
    964 
    965 
    966     xSrtScCnt += 1;
    967 
    968     if ( xSrtScCnt >= (MAX_SFB_HCR + MAX_HCR_SETS) ) {
    969       pHcr->decInOut.errorLog |= EXTENDED_SORTED_COUNTER_OVERFLOW;
    970       return;
    971     }
    972 
    973   }
    974   pNumExtSortCwInSect[xSrtScCnt] = 0;
    975 
    976 }
    977 
    978 
    979 /*---------------------------------------------------------------------------------------------
    980      description:   This function calculates the number of extended sorted sections which
    981                     belong to the sets. Each set from set 0 (one and only set for the PCWs)
    982                     till to the last set gets a entry in the array to which
    983                     'pNumExtendedSortedSectinsInSets' points to.
    984 
    985                     Calculation: The entrys in pNumExtendedSortedCodewordInSectin are added
    986                     untill the value numSegment is reached. Then the sum_variable is cleared
    987                     and the calculation starts from the beginning. As much extended sorted
    988                     Sections are summed up to reach the value numSegment, as much is the
    989                     current entry in *pNumExtendedSortedCodewordInSectin.
    990 -------------------------------------------------------------------------------------------- */
    991 static void DeriveNumberOfExtendedSortedSectionsInSets(UINT    numSegment,
    992                                                        USHORT *pNumExtendedSortedCodewordInSection,
    993                                                        int     numExtendedSortedCodewordInSectionIdx,
    994                                                        USHORT *pNumExtendedSortedSectionsInSets,
    995                                                        int     numExtendedSortedSectionsInSetsIdx)
    996 {
    997   USHORT  counter = 0;
    998   UINT    cwSum   = 0;
    999   USHORT *pNumExSortCwInSec   = pNumExtendedSortedCodewordInSection;
   1000   USHORT *pNumExSortSecInSets = pNumExtendedSortedSectionsInSets;
   1001 
   1002   while (pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx] != 0)
   1003   {
   1004     cwSum += pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx];
   1005     numExtendedSortedCodewordInSectionIdx++;
   1006     if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
   1007       return;
   1008     }
   1009     if (cwSum > numSegment) {
   1010       return;
   1011     }
   1012     counter++;
   1013     if (counter > 1024/4) {
   1014       return;
   1015     }
   1016     if ( cwSum == numSegment ) {
   1017       pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter;
   1018       numExtendedSortedSectionsInSetsIdx++;
   1019       if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) {
   1020         return;
   1021       }
   1022       counter = 0;
   1023       cwSum = 0;
   1024     }
   1025   }
   1026   pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter;   /* save last entry for the last - probably shorter - set */
   1027 }
   1028 
   1029 
   1030 /*---------------------------------------------------------------------------------------------
   1031      description:   This function decodes all priority codewords (PCWs) in a spectrum (within
   1032                     set 0). The calculation of the PCWs is managed in two loops. The
   1033                     loopcounter of the outer loop is set to the first value pointer
   1034                     pNumExtendedSortedSectionsInSets points to. This value represents the
   1035                     number of extended sorted sections within set 0.
   1036                     The loopcounter of the inner loop is set to the first value pointer
   1037                     pNumExtendedSortedCodewordInSectin points to. The value represents the
   1038                     number of extended sorted codewords in sections (the original sections have
   1039                     been splitted to go along with the borders of the sets).
   1040                     Each time the number of the extended sorted codewords in sections are de-
   1041                     coded, the pointer 'pNumExtendedSortedCodewordInSectin' is incremented by
   1042                     one.
   1043 -------------------------------------------------------------------------------------------- */
   1044 static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr)
   1045 {
   1046   UINT         i;
   1047   USHORT       extSortSec;
   1048   USHORT       curExtSortCwInSec;
   1049   UCHAR        codebook;
   1050   UCHAR        dimension;
   1051   const UINT  *pCurrentTree;
   1052   const SCHAR *pQuantValBase;
   1053   const SCHAR *pQuantVal;
   1054 
   1055   USHORT      *pNumExtendedSortedCodewordInSection = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection;
   1056   int          numExtendedSortedCodewordInSectionIdx = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx;
   1057   UCHAR       *pExtendedSortedCodebook             = pHcr->sectionInfo.pExtendedSortedCodebook;
   1058   int          extendedSortedCodebookIdx           = pHcr->sectionInfo.extendedSortedCodebookIdx;
   1059   USHORT      *pNumExtendedSortedSectionsInSets    = pHcr->sectionInfo.pNumExtendedSortedSectionsInSets;
   1060   int          numExtendedSortedSectionsInSetsIdx  = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx;
   1061   FIXP_DBL    *pQuantizedSpectralCoefficients      = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase);
   1062   int          quantizedSpectralCoefficientsIdx    = pHcr->decInOut.quantizedSpectralCoefficientsIdx;
   1063   USHORT      *pLeftStartOfSegment                 = pHcr->segmentInfo.pLeftStartOfSegment;
   1064   SCHAR       *pRemainingBitsInSegment             = pHcr->segmentInfo.pRemainingBitsInSegment;
   1065 #if DETECT_TOO_LONG_CW_READS
   1066   UCHAR       *pMaxLenOfCbInExtSrtSec              = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec;
   1067   int          maxLenOfCbInExtSrtSecIdx            = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx;
   1068   UCHAR        maxAllowedCwLen;
   1069   int          numDecodedBits;
   1070 #endif
   1071   const UCHAR *pCbDimension =  pHcr->tableInfo.pCbDimension;
   1072   const UCHAR *pCbSign      =  pHcr->tableInfo.pCbSign;
   1073 
   1074   /* clear result array */
   1075   //pQSC = &pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx];
   1076   //pQSC = *pQuantizedSpectralCoefficients;
   1077 
   1078   FDKmemclear(pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx,1024*sizeof(FIXP_DBL));
   1079 
   1080   /* decode all PCWs in the extended sorted section(s) belonging to set 0 */
   1081   for ( extSortSec = pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx]; extSortSec != 0; extSortSec-- ) {
   1082 
   1083     codebook        =  pExtendedSortedCodebook[extendedSortedCodebookIdx];   /* get codebook for this extended sorted section and increment ptr to cb of next ext. sort sec */
   1084     extendedSortedCodebookIdx++;
   1085     if (extendedSortedCodebookIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
   1086       return;
   1087     }
   1088     dimension       =  pCbDimension[codebook];         /* get dimension of codebook of this extended sort. sec. */
   1089     pCurrentTree    =  aHuffTable  [codebook];         /* convert codebook to pointer to QSCs */
   1090     pQuantValBase   =  aQuantTable [codebook];         /* convert codebook to index to table of QSCs */
   1091 #if DETECT_TOO_LONG_CW_READS
   1092     maxAllowedCwLen = pMaxLenOfCbInExtSrtSec[maxLenOfCbInExtSrtSecIdx];
   1093     maxLenOfCbInExtSrtSecIdx++;
   1094     if (maxLenOfCbInExtSrtSecIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
   1095       return;
   1096     }
   1097 #endif
   1098 
   1099     /* switch for decoding with different codebooks: */
   1100     if ( pCbSign[codebook] == 0 ) {                    /* no sign bits follow after the codeword-body */
   1101       /* PCW_BodyONLY */
   1102       /*==============*/
   1103 
   1104       for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) {
   1105         numDecodedBits = 0;
   1106 
   1107         /* decode PCW_BODY */
   1108         pQuantVal = DecodePCW_Body(bs,
   1109                                    pCurrentTree,
   1110                                    pQuantValBase,
   1111                                    pLeftStartOfSegment,
   1112                                    pRemainingBitsInSegment,
   1113                                   &numDecodedBits
   1114                                   );
   1115 
   1116         /* result is written out here because NO sign bits follow the body */
   1117         for( i=dimension; i != 0 ; i-- ) {
   1118           pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) *pQuantVal++;                               /* write quant. spec. coef. into spectrum; sign is already valid */
   1119           quantizedSpectralCoefficientsIdx++;
   1120           if (quantizedSpectralCoefficientsIdx >= 1024) {
   1121             return;
   1122           }
   1123         }
   1124 
   1125         /* one more PCW should be decoded */
   1126 
   1127 #if DETECT_TOO_LONG_CW_READS
   1128         if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_ONLY_TOO_LONG) ) {
   1129           pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_BITS_DECODED;
   1130         }
   1131 #endif
   1132 
   1133 #if CHECK_SEGMENTATION_IMMEDIATELY
   1134         if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY,pHcr,PCW_BODY,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) {
   1135           return;
   1136         }
   1137 #endif
   1138         pLeftStartOfSegment++;                                             /* update pointer for decoding the next PCW */
   1139         pRemainingBitsInSegment++;                                         /* update pointer for decoding the next PCW */
   1140       }
   1141     }
   1142     else if (( pCbSign[codebook] == 1 ) && ( codebook < 11 )) {  /* possibly there follow 1,2,3 or 4 sign bits after the codeword-body */
   1143       /* PCW_Body and PCW_Sign */
   1144       /*=======================*/
   1145 
   1146       for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--)
   1147       {
   1148         int err;
   1149         numDecodedBits  = 0;
   1150 
   1151         pQuantVal = DecodePCW_Body(bs,
   1152                                    pCurrentTree,
   1153                                    pQuantValBase,
   1154                                    pLeftStartOfSegment,
   1155                                    pRemainingBitsInSegment,
   1156                                   &numDecodedBits
   1157                                   );
   1158 
   1159         err = DecodePCW_Sign( bs,
   1160                               dimension,
   1161                               pQuantVal,
   1162                               pQuantizedSpectralCoefficients,
   1163                              &quantizedSpectralCoefficientsIdx,
   1164                               pLeftStartOfSegment,
   1165                               pRemainingBitsInSegment,
   1166                              &numDecodedBits
   1167                              );
   1168         if (err != 0) {
   1169           return;
   1170         }
   1171         /* one more PCW should be decoded */
   1172 
   1173 #if DETECT_TOO_LONG_CW_READS
   1174         if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_TOO_LONG) ) {
   1175           pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_BITS_DECODED;
   1176         }
   1177 #endif
   1178 
   1179 #if CHECK_SEGMENTATION_IMMEDIATELY
   1180         if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN,pHcr,PCW_BODY_SIGN, pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) {
   1181           return;
   1182         }
   1183 #endif
   1184         pLeftStartOfSegment++;
   1185         pRemainingBitsInSegment++;
   1186       }
   1187     }
   1188     else if (( pCbSign[codebook] == 1 ) && ( codebook >= 11 )) { /* possibly there follow some sign bits and maybe one or two escape sequences after the cw-body */
   1189       /* PCW_Body, PCW_Sign and maybe PCW_Escape */
   1190       /*=========================================*/
   1191 
   1192       for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--)
   1193       {
   1194         int err;
   1195         numDecodedBits  = 0;
   1196 
   1197         /* decode PCW_BODY */
   1198         pQuantVal = DecodePCW_Body(bs,
   1199                                    pCurrentTree,
   1200                                    pQuantValBase,
   1201                                    pLeftStartOfSegment,
   1202                                    pRemainingBitsInSegment,
   1203                                   &numDecodedBits
   1204                                   );
   1205 
   1206         err = DecodePCW_Sign( bs,
   1207                               dimension,
   1208                               pQuantVal,
   1209                               pQuantizedSpectralCoefficients,
   1210                              &quantizedSpectralCoefficientsIdx,
   1211                               pLeftStartOfSegment,
   1212                               pRemainingBitsInSegment,
   1213                              &numDecodedBits
   1214                              );
   1215         if (err != 0) {
   1216           return;
   1217         }
   1218 
   1219         /* decode PCW_ESCAPE if present */
   1220         quantizedSpectralCoefficientsIdx -= DIMENSION_OF_ESCAPE_CODEBOOK;
   1221 
   1222         if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) {
   1223           pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs,
   1224                                                    pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx],
   1225                                                    pLeftStartOfSegment,
   1226                                                    pRemainingBitsInSegment,
   1227                                                   &numDecodedBits
   1228                                                  );
   1229         }
   1230         quantizedSpectralCoefficientsIdx++;
   1231         if (quantizedSpectralCoefficientsIdx >= 1024) {
   1232           return;
   1233         }
   1234 
   1235         if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) {
   1236           pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs,
   1237                                                    pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx],
   1238                                                    pLeftStartOfSegment,
   1239                                                    pRemainingBitsInSegment,
   1240                                                   &numDecodedBits
   1241                                                  );
   1242         }
   1243         quantizedSpectralCoefficientsIdx++;
   1244         if (quantizedSpectralCoefficientsIdx >= 1024) {
   1245           return;
   1246         }
   1247 
   1248         /* one more PCW should be decoded */
   1249 
   1250 #if DETECT_TOO_LONG_CW_READS
   1251         if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_ESC_TOO_LONG) ) {
   1252           pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_ESC_BITS_DECODED;
   1253         }
   1254 #endif
   1255 
   1256 #if CHECK_SEGMENTATION_IMMEDIATELY
   1257         if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN_ESC,pHcr,PCW_BODY_SIGN_ESC,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-DIMENSION_OF_ESCAPE_CODEBOOK,DIMENSION_OF_ESCAPE_CODEBOOK)) {
   1258           return;
   1259         }
   1260 #endif
   1261         pLeftStartOfSegment++;
   1262         pRemainingBitsInSegment++;
   1263       }
   1264     }
   1265 
   1266     /* all PCWs belonging to this extended section should be decoded */
   1267     numExtendedSortedCodewordInSectionIdx++;
   1268     if (numExtendedSortedCodewordInSectionIdx >= MAX_SFB_HCR+MAX_HCR_SETS) {
   1269       return;
   1270     }
   1271   }
   1272   /* all PCWs should be decoded */
   1273 
   1274   numExtendedSortedSectionsInSetsIdx++;
   1275   if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) {
   1276     return;
   1277   }
   1278 
   1279   /* Write back indexes into structure */
   1280   pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx;
   1281   pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx;
   1282   pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx;
   1283   pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx;
   1284   pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = maxLenOfCbInExtSrtSecIdx;
   1285 }
   1286 
   1287 #if CHECK_SEGMENTATION_IMMEDIATELY
   1288 /*---------------------------------------------------------------------------------------------
   1289      description:   This function checks immediately after every decoded PCW, whether out of
   1290                     the current segment too many bits have been read or not. If an error occurrs,
   1291                     probably the sideinfo or the HCR-bitstream block holding the huffman
   1292                     encoded quantized spectral coefficients is distorted. In this case the two
   1293                     or four quantized spectral coefficients belonging to the current codeword
   1294                     are marked (for being detected by concealment later).
   1295 -------------------------------------------------------------------------------------------- */
   1296 static UCHAR errDetectPcwSegmentation(SCHAR       remainingBitsInSegment,
   1297                                       H_HCR_INFO  pHcr,
   1298                                       PCW_TYPE    kind,
   1299                                       FIXP_DBL   *qsc_base_of_cw,
   1300                                       UCHAR       dimension)
   1301 {
   1302   SCHAR i;
   1303   if ( remainingBitsInSegment < 0 ) {
   1304     /* log the error */
   1305     switch (kind) {
   1306     case PCW_BODY:
   1307         pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY;
   1308         break;
   1309     case PCW_BODY_SIGN:
   1310         pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN;
   1311         break;
   1312     case PCW_BODY_SIGN_ESC:
   1313         pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN_ESC;
   1314         break;
   1315     }
   1316     /* mark the erred lines */
   1317     for ( i = dimension; i != 0; i-- ) {
   1318       *qsc_base_of_cw++ = (FIXP_DBL) Q_VALUE_INVALID;
   1319     }
   1320     return 1;
   1321   }
   1322   return 0;
   1323 }
   1324 #endif
   1325 
   1326 #if CHECK_SEGMENTATION_FINAL
   1327 /*---------------------------------------------------------------------------------------------
   1328      description:   This function checks if all segments are empty after decoding. There
   1329                     are _no lines markded_ as invalid because it could not be traced back
   1330                     where from the remaining bits are.
   1331 -------------------------------------------------------------------------------------------- */
   1332 static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr)
   1333 {
   1334   UCHAR   segmentationErrorFlag   = 0;
   1335   USHORT  i;
   1336   SCHAR  *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
   1337   UINT    numSegment              = pHcr->segmentInfo.numSegment;
   1338 
   1339   for ( i=numSegment; i != 0 ; i--) {
   1340     if (*pRemainingBitsInSegment++ != 0) {
   1341       segmentationErrorFlag = 1;
   1342     }
   1343   }
   1344   if (segmentationErrorFlag == 1) {
   1345     pHcr->decInOut.errorLog |= BIT_IN_SEGMENTATION_ERROR;
   1346   }
   1347 }
   1348 #endif
   1349 
   1350 /*---------------------------------------------------------------------------------------------
   1351      description:   This function walks one step within the decoding tree. Which branch is
   1352                     taken depends on the decoded carryBit input parameter.
   1353 -------------------------------------------------------------------------------------------- */
   1354 void  CarryBitToBranchValue(UCHAR  carryBit,
   1355                             UINT   treeNode,
   1356                             UINT  *branchValue,
   1357                             UINT  *branchNode)
   1358 {
   1359   if (carryBit == 0) {
   1360     *branchNode = (treeNode & MASK_LEFT) >> LEFT_OFFSET; /* MASK_LEFT:  00FFF000 */
   1361   }
   1362   else {
   1363     *branchNode = treeNode & MASK_RIGHT;                 /* MASK_RIGHT: 00000FFF */
   1364   }
   1365 
   1366   *branchValue = *branchNode & CLR_BIT_10;               /* clear bit 10 (if set) */
   1367 }
   1368 
   1369 
   1370 /*---------------------------------------------------------------------------------------------
   1371      description:   Decodes the body of a priority codeword (PCW)
   1372 -----------------------------------------------------------------------------------------------
   1373         return:   - return value is pointer to first of two or four quantized spectral
   1374                     coefficients
   1375 -------------------------------------------------------------------------------------------- */
   1376 static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM  bs,
   1377                                    const UINT           *pCurrentTree,
   1378                                    const SCHAR          *pQuantValBase,
   1379                                          USHORT         *pLeftStartOfSegment,
   1380                                          SCHAR          *pRemainingBitsInSegment,
   1381                                          int            *pNumDecodedBits
   1382                                   )
   1383 {
   1384   UCHAR carryBit;
   1385   UINT  branchNode;
   1386   UINT  treeNode;
   1387   UINT  branchValue;
   1388   const  SCHAR *pQuantVal;
   1389 
   1390   /* decode PCW_BODY */
   1391   treeNode = *pCurrentTree;                                                 /* get first node of current tree belonging to current codebook */
   1392 
   1393   /* decode whole PCW-codeword-body */
   1394   while (1) {
   1395 
   1396     carryBit = HcrGetABitFromBitstream(bs,
   1397                                        pLeftStartOfSegment,
   1398                                        pLeftStartOfSegment,                 /* dummy */
   1399                                        FROM_LEFT_TO_RIGHT);
   1400     *pRemainingBitsInSegment -= 1;
   1401     *pNumDecodedBits += 1;
   1402 
   1403     CarryBitToBranchValue(carryBit,
   1404                           treeNode,
   1405                           &branchValue,
   1406                           &branchNode);
   1407 
   1408     if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {                        /* test bit 10 ; if set --> codeword-body is complete */
   1409       break;                                                                /* end of branch in tree reached  i.e. a whole PCW-Body is decoded */
   1410     }
   1411     else {
   1412       treeNode = *(pCurrentTree + branchValue);                             /* update treeNode for further step in decoding tree */
   1413     }
   1414 
   1415   }
   1416 
   1417   pQuantVal = pQuantValBase + branchValue;                                  /* update pointer to valid first of 2 or 4 quantized values */
   1418 
   1419   return pQuantVal;
   1420 }
   1421 
   1422 
   1423 /*---------------------------------------------------------------------------------------------
   1424      description:   This function decodes one escape sequence. In case of a escape codebook
   1425                     and in case of the absolute value of the quantized spectral value == 16,
   1426                     a escapeSequence is decoded in two steps:
   1427                       1. escape prefix
   1428                       2. escape word
   1429 -------------------------------------------------------------------------------------------- */
   1430 
   1431 static INT  DecodeEscapeSequence(HANDLE_FDK_BITSTREAM  bs,
   1432                                  INT                   quantSpecCoef,
   1433                                  USHORT               *pLeftStartOfSegment,
   1434                                  SCHAR                *pRemainingBitsInSegment,
   1435                                  int                  *pNumDecodedBits
   1436                                 )
   1437 {
   1438   UINT  i;
   1439   INT   sign;
   1440   UINT  escapeOnesCounter = 0;
   1441   UINT  carryBit;
   1442   INT   escape_word = 0;
   1443 
   1444   /* decode escape prefix */
   1445   while (1) {
   1446     carryBit = HcrGetABitFromBitstream(bs,
   1447                                        pLeftStartOfSegment,
   1448                                        pLeftStartOfSegment,                /* dummy */
   1449                                        FROM_LEFT_TO_RIGHT);
   1450     *pRemainingBitsInSegment -= 1;
   1451     *pNumDecodedBits += 1;
   1452 
   1453     if (carryBit != 0) {
   1454       escapeOnesCounter += 1;
   1455     }
   1456     else {
   1457       escapeOnesCounter += 4;
   1458       break;
   1459     }
   1460   }
   1461 
   1462   /* decode escape word */
   1463   for( i=escapeOnesCounter; i != 0 ; i-- ) {
   1464     carryBit = HcrGetABitFromBitstream(bs,
   1465                                        pLeftStartOfSegment,
   1466                                        pLeftStartOfSegment,                /* dummy */
   1467                                        FROM_LEFT_TO_RIGHT);
   1468     *pRemainingBitsInSegment -= 1;
   1469     *pNumDecodedBits += 1;
   1470 
   1471     escape_word <<= 1;
   1472     escape_word = escape_word | carryBit;
   1473   }
   1474 
   1475   sign = (quantSpecCoef >= 0) ? 1 : -1;
   1476 
   1477   quantSpecCoef = sign * (((INT ) 1 << escapeOnesCounter) + escape_word);
   1478 
   1479   return quantSpecCoef;
   1480 }
   1481 
   1482 
   1483 /*---------------------------------------------------------------------------------------------
   1484      description:   Decodes the Signbits of a priority codeword (PCW) and writes out the
   1485                     resulting quantized spectral values into unsorted sections
   1486 -----------------------------------------------------------------------------------------------
   1487         output:   - two or four lines at position in corresponding section (which are not
   1488                     located at the desired position, i.e. they must be reordered in the last
   1489                     of eight function of HCR)
   1490 -----------------------------------------------------------------------------------------------
   1491         return:   - updated pQuantSpecCoef pointer (to next empty storage for a line)
   1492 -------------------------------------------------------------------------------------------- */
   1493 static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM  bs,
   1494                           UINT                  codebookDim,
   1495                           const SCHAR          *pQuantVal,
   1496                           FIXP_DBL             *pQuantSpecCoef,
   1497                           int                  *quantSpecCoefIdx,
   1498                           USHORT               *pLeftStartOfSegment,
   1499                           SCHAR                *pRemainingBitsInSegment,
   1500                           int                  *pNumDecodedBits
   1501                          )
   1502 {
   1503   UINT     i;
   1504   UINT     carryBit;
   1505   INT      quantSpecCoef;
   1506 
   1507   for( i=codebookDim; i != 0 ; i-- ) {
   1508     quantSpecCoef = *pQuantVal++;
   1509     if (quantSpecCoef != 0) {
   1510       carryBit = HcrGetABitFromBitstream(bs,
   1511                                          pLeftStartOfSegment,
   1512                                          pLeftStartOfSegment,    /* dummy */
   1513                                          FROM_LEFT_TO_RIGHT);
   1514       *pRemainingBitsInSegment -= 1;
   1515       *pNumDecodedBits += 1;
   1516       if (*pRemainingBitsInSegment < 0 || *pNumDecodedBits >= (1024>>1)) {
   1517         return -1;
   1518       }
   1519 
   1520       /* adapt sign of values according to the decoded sign bit */
   1521       if (carryBit != 0) {
   1522         pQuantSpecCoef[*quantSpecCoefIdx] = -(FIXP_DBL)quantSpecCoef;
   1523       }
   1524       else {
   1525         pQuantSpecCoef[*quantSpecCoefIdx] =  (FIXP_DBL)quantSpecCoef;
   1526       }
   1527     }
   1528     else {
   1529       pQuantSpecCoef[*quantSpecCoefIdx] = FL2FXCONST_DBL(0.0f);
   1530     }
   1531     *quantSpecCoefIdx += 1 ;
   1532     if (*quantSpecCoefIdx >= 1024) {
   1533       return -1;
   1534     }
   1535   }
   1536   return 0;
   1537 }
   1538 
   1539 
   1540 /*---------------------------------------------------------------------------------------------
   1541      description:   Mutes spectral lines which have been marked as erroneous (Q_VALUE_INVALID)
   1542 -------------------------------------------------------------------------------------------- */
   1543 void HcrMuteErroneousLines(H_HCR_INFO hHcr)
   1544 {
   1545   int c;
   1546   FIXP_DBL *RESTRICT pLong = SPEC_LONG(hHcr->decInOut.pQuantizedSpectralCoefficientsBase);
   1547 
   1548   /* if there is a line with value Q_VALUE_INVALID mute it */
   1549   for (c = 0; c < 1024; c++) {
   1550     if (pLong[c] == (FIXP_DBL)Q_VALUE_INVALID) {
   1551 #if HCR_LISTEN_TO_MUTED_LINES
   1552       pLong[c] = (FIXP_DBL)HCR_DIRAC;   /* marking */
   1553 #else
   1554       pLong[c] = FL2FXCONST_DBL(0.0f);  /* muting */
   1555 #endif
   1556     }
   1557   }
   1558 }
   1559 
   1560 
   1561 /*---------------------------------------------------------------------------------------------
   1562      description:   Sets global HCR type
   1563 -------------------------------------------------------------------------------------------- */
   1564 void setHcrType(H_HCR_INFO hHcr, MP4_ELEMENT_ID type)
   1565 {
   1566   switch (type) {
   1567     case ID_SCE:
   1568       hHcr->globalHcrType = 0;
   1569       break;
   1570     case ID_CPE:
   1571       hHcr->globalHcrType = 1;
   1572       break;
   1573     default:
   1574       break;
   1575   }
   1576 }
   1577 
   1578 
   1579 /*---------------------------------------------------------------------------------------------
   1580      description:   Gets HCR type from the HCR data structure
   1581 -----------------------------------------------------------------------------------------------
   1582         return:   - global HCR type
   1583 -------------------------------------------------------------------------------------------- */
   1584 INT getHcrType(H_HCR_INFO hHcr)
   1585 {
   1586   return hHcr->globalHcrType;
   1587 }
   1588 
   1589 
   1590 
   1591 
   1592