libAACdec/src/aacdec_hcr.cpp

   1
   2 /* -----------------------------------------------------------------------------------------------------------
   3 Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5 © Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung 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@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