libAACdec/src/block.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):   Josef Hoepfl
  87    Description: long/short-block decoding
  88
  89 ******************************************************************************/
  90
  91 #include "block.h"
  92
  93 #include "aac_rom.h"
  94 #include "FDK_bitstream.h"
  95 #include "FDK_tools_rom.h"
  96
  97
  98
  99
 100 #include "aacdec_hcr.h"
 101 #include "rvlc.h"
 102
 103
 104 #if defined(__arm__)
 105 #include "arm/block_arm.cpp"
 106 #endif
 107
 108 /*!
 109   \brief Read escape sequence of codeword
 110
 111   The function reads the escape sequence from the bitstream,
 112   if the absolute value of the quantized coefficient has the
 113   value 16.
 114
 115   \return  quantized coefficient
 116 */
 117 LONG CBlock_GetEscape(HANDLE_FDK_BITSTREAM bs, /*!< pointer to bitstream */
 118                      const LONG q)        /*!< quantized coefficient */
 119 {
 120   LONG i, off, neg ;
 121
 122   if (q < 0)
 123   {
 124     if (q != -16) return q;
 125     neg = 1;
 126   }
 127   else
 128   {
 129     if (q != +16) return q;
 130     neg = 0;
 131   }
 132
 133   for (i=4; ; i++)
 134   {
 135     if (FDKreadBits(bs,1) == 0)
 136       break;
 137   }
 138
 139   if (i > 16)
 140   {
 141     if (i - 16 > CACHE_BITS) { /* cannot read more than "CACHE_BITS" bits at once in the function FDKreadBits() */
 142       return (MAX_QUANTIZED_VALUE + 1); /* returning invalid value that will be captured later */
 143     }
 144
 145     off = FDKreadBits(bs,i-16) << 16;
 146     off |= FDKreadBits(bs,16);
 147   }
 148   else
 149   {
 150     off = FDKreadBits(bs,i);
 151   }
 152
 153   i = off + (1 << i);
 154
 155   if (neg) i = -i;
 156
 157   return i;
 158 }
 159
 160 AAC_DECODER_ERROR CBlock_ReadScaleFactorData(
 161         CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 162         HANDLE_FDK_BITSTREAM bs,
 163         UINT flags
 164         )
 165 {
 166   int temp;
 167   int band;
 168   int group;
 169   int position = 0; /* accu for intensity delta coding */
 170   int factor = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain; /* accu for scale factor delta coding */
 171   UCHAR *pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
 172   SHORT *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
 173   const CodeBookDescription *hcb =&AACcodeBookDescriptionTable[BOOKSCL];
 174
 175   int ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
 176   for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
 177   {
 178     for (band=0; band < ScaleFactorBandsTransmitted; band++)
 179     {
 180       switch (pCodeBook[group*16+band]) {
 181
 182       case ZERO_HCB: /* zero book */
 183         pScaleFactor[group*16+band] = 0;
 184         break;
 185
 186       default: /* decode scale factor */
 187         {
 188           temp = CBlock_DecodeHuffmanWord(bs,hcb);
 189           factor += temp - 60; /* MIDFAC 1.5 dB */
 190         }
 191         pScaleFactor[group*16+band] = factor - 100;
 192         break;
 193
 194       case INTENSITY_HCB: /* intensity steering */
 195       case INTENSITY_HCB2:
 196         temp = CBlock_DecodeHuffmanWord(bs,hcb);
 197         position += temp - 60;
 198         pScaleFactor[group*16+band] = position - 100;
 199         break;
 200
 201       case NOISE_HCB: /* PNS */
 202         if (flags & (AC_MPS_RES|AC_USAC|AC_RSVD50)) {
 203           return AAC_DEC_PARSE_ERROR;
 204         }
 205         CPns_Read( &pAacDecoderChannelInfo->data.aac.PnsData, bs, hcb, pAacDecoderChannelInfo->pDynData->aScaleFactor, pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain, band, group);
 206         break;
 207       }
 208     }
 209   }
 210
 211   return AAC_DEC_OK;
 212 }
 213
 214 void CBlock_ScaleSpectralData(CAacDecoderChannelInfo *pAacDecoderChannelInfo, SamplingRateInfo *pSamplingRateInfo)
 215 {
 216   int band;
 217   int window;
 218   const SHORT * RESTRICT pSfbScale  = pAacDecoderChannelInfo->pDynData->aSfbScale;
 219   SHORT * RESTRICT pSpecScale = pAacDecoderChannelInfo->specScale;
 220   int groupwin,group;
 221   const SHORT * RESTRICT BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
 222   SPECTRAL_PTR RESTRICT pSpectralCoefficient = pAacDecoderChannelInfo->pSpectralCoefficient;
 223
 224
 225   FDKmemclear(pSpecScale, 8*sizeof(SHORT));
 226
 227   int max_band = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
 228   for (window=0, group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
 229   {
 230     for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); groupwin++, window++)
 231     {
 232       int SpecScale_window = pSpecScale[window];
 233       FIXP_DBL *pSpectrum = SPEC(pSpectralCoefficient, window,  pAacDecoderChannelInfo->granuleLength);
 234
 235       /* find scaling for current window */
 236       for (band=0; band < max_band; band++)
 237       {
 238         SpecScale_window = fMax(SpecScale_window, (int)pSfbScale[window*16+band]);
 239       }
 240
 241       if (pAacDecoderChannelInfo->pDynData->TnsData.Active) {
 242         SpecScale_window += TNS_SCALE;
 243       }
 244
 245       /* store scaling of current window */
 246       pSpecScale[window] = SpecScale_window;
 247
 248 #ifdef FUNCTION_CBlock_ScaleSpectralData_func1
 249
 250       CBlock_ScaleSpectralData_func1(pSpectrum, max_band, BandOffsets, SpecScale_window, pSfbScale, window);
 251
 252 #else /* FUNCTION_CBlock_ScaleSpectralData_func1 */
 253       for (band=0; band < max_band; band++)
 254       {
 255         int scale = SpecScale_window - pSfbScale[window*16+band];
 256         if (scale)
 257         {
 258           /* following relation can be used for optimizations: (BandOffsets[i]%4) == 0 for all i */
 259           int max_index = BandOffsets[band+1];
 260           for (int index = BandOffsets[band]; index < max_index; index++)
 261           {
 262             pSpectrum[index] >>= scale;
 263           }
 264         }
 265       }
 266 #endif  /* FUNCTION_CBlock_ScaleSpectralData_func1 */
 267     }
 268   }
 269
 270 }
 271
 272 AAC_DECODER_ERROR CBlock_ReadSectionData(HANDLE_FDK_BITSTREAM bs,
 273                                          CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 274                                          const SamplingRateInfo *pSamplingRateInfo,
 275                                          const UINT  flags)
 276 {
 277   int top, band;
 278   int sect_len, sect_len_incr;
 279   int group;
 280   UCHAR sect_cb;
 281   UCHAR *pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
 282   /* HCR input (long) */
 283   SHORT *pNumLinesInSec    = pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr;
 284   int    numLinesInSecIdx  = 0;
 285   UCHAR *pHcrCodeBook      = pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr;
 286   const SHORT *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
 287   pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection = 0;
 288   AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
 289
 290   FDKmemclear(pCodeBook, sizeof(UCHAR)*(8*16));
 291
 292   const int nbits = (IsLongBlock(&pAacDecoderChannelInfo->icsInfo) == 1) ? 5 : 3;
 293
 294   int sect_esc_val = (1 << nbits) - 1 ;
 295
 296   UCHAR ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
 297   for (group=0; group<GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
 298   {
 299     for (band=0; band < ScaleFactorBandsTransmitted; )
 300     {
 301       sect_len = 0;
 302       if ( flags & AC_ER_VCB11 )  {
 303         sect_cb = (UCHAR) FDKreadBits(bs,5);
 304       }
 305       else
 306         sect_cb = (UCHAR) FDKreadBits(bs,4);
 307
 308       if ( ((flags & AC_ER_VCB11) == 0) || ( sect_cb < 11 ) || ((sect_cb > 11) && (sect_cb < 16)) ) {
 309         sect_len_incr = FDKreadBits(bs, nbits);
 310         while (sect_len_incr == sect_esc_val)
 311         {
 312           sect_len += sect_esc_val;
 313           sect_len_incr = FDKreadBits(bs, nbits);
 314         }
 315       }
 316       else {
 317         sect_len_incr = 1;
 318       }
 319
 320       sect_len += sect_len_incr;
 321
 322
 323       top = band + sect_len;
 324
 325       if (flags & AC_ER_HCR) {
 326         /* HCR input (long) -- collecting sideinfo (for HCR-_long_ only) */
 327         pNumLinesInSec[numLinesInSecIdx] = BandOffsets[top] - BandOffsets[band];
 328         numLinesInSecIdx++;
 329         if (numLinesInSecIdx >= MAX_SFB_HCR) {
 330           return AAC_DEC_PARSE_ERROR;
 331         }
 332         if (
 333              (sect_cb == BOOKSCL) )
 334         {
 335           return AAC_DEC_INVALID_CODE_BOOK;
 336         } else {
 337           *pHcrCodeBook++ = sect_cb;
 338         }
 339         pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection++;
 340       }
 341
 342       /* Check spectral line limits */
 343       if (IsLongBlock( &(pAacDecoderChannelInfo->icsInfo) ))
 344       {
 345         if (top > 64) {
 346           return AAC_DEC_DECODE_FRAME_ERROR;
 347         }
 348       } else { /* short block */
 349         if (top + group*16 > (8 * 16)) {
 350           return AAC_DEC_DECODE_FRAME_ERROR;
 351         }
 352       }
 353
 354       /* Check if decoded codebook index is feasible */
 355       if ( (sect_cb == BOOKSCL)
 356        || ( (sect_cb == INTENSITY_HCB || sect_cb == INTENSITY_HCB2) && pAacDecoderChannelInfo->pDynData->RawDataInfo.CommonWindow == 0)
 357          )
 358       {
 359         return AAC_DEC_INVALID_CODE_BOOK;
 360       }
 361
 362       /* Store codebook index */
 363       for (; band < top; band++)
 364       {
 365         pCodeBook[group*16+band] = sect_cb;
 366       }
 367     }
 368   }
 369
 370
 371   return ErrorStatus;
 372 }
 373
 374 /* mso: provides a faster way to i-quantize a whole band in one go */
 375
 376 /**
 377  * \brief inverse quantize one sfb. Each value of the sfb is processed according to the
 378  *        formula: spectrum[i] = Sign(spectrum[i]) * Matissa(spectrum[i])^(4/3) * 2^(lsb/4).
 379  * \param spectrum pointer to first line of the sfb to be inverse quantized.
 380  * \param noLines number of lines belonging to the sfb.
 381  * \param lsb last 2 bits of the scale factor of the sfb.
 382  * \param scale max allowed shift scale for the sfb.
 383  */
 384 static
 385 void InverseQuantizeBand( FIXP_DBL * RESTRICT spectrum,
 386                               INT noLines,
 387                               INT lsb,
 388                               INT scale )
 389 {
 390     const FIXP_DBL * RESTRICT InverseQuantTabler=(FIXP_DBL *)InverseQuantTable;
 391     const FIXP_DBL * RESTRICT MantissaTabler=(FIXP_DBL *)MantissaTable[lsb];
 392     const SCHAR* RESTRICT ExponentTabler=(SCHAR*)ExponentTable[lsb];
 393
 394     FIXP_DBL *ptr = spectrum;
 395     FIXP_DBL signedValue;
 396
 397     FDK_ASSERT(noLines>2);
 398     for (INT i=noLines; i--; )
 399     {
 400         if ((signedValue = *ptr++) != FL2FXCONST_DBL(0))
 401         {
 402           FIXP_DBL value = fAbs(signedValue);
 403           UINT freeBits = CntLeadingZeros(value);
 404           UINT exponent = 32 - freeBits;
 405
 406           UINT x = (UINT) (LONG)value << (INT) freeBits;
 407           x <<= 1;                                  /* shift out sign bit to avoid masking later on */
 408           UINT tableIndex = x >> 24;
 409           x = (x >> 20) &  0x0F;
 410
 411           UINT r0=(UINT)(LONG)InverseQuantTabler[tableIndex+0];
 412           UINT r1=(UINT)(LONG)InverseQuantTabler[tableIndex+1];
 413           UINT temp= (r1 - r0)*x + (r0 << 4);
 414
 415           value = fMultDiv2((FIXP_DBL)temp, MantissaTabler[exponent]);
 416
 417           /* + 1 compensates fMultDiv2() */
 418           scaleValueInPlace(&value, scale + ExponentTabler[exponent] + 1);
 419
 420           signedValue = (signedValue < (FIXP_DBL)0) ? -value : value;
 421           ptr[-1] = signedValue;
 422         }
 423     }
 424 }
 425
 426 AAC_DECODER_ERROR CBlock_InverseQuantizeSpectralData(CAacDecoderChannelInfo *pAacDecoderChannelInfo, SamplingRateInfo *pSamplingRateInfo)
 427 {
 428   int window, group, groupwin, band;
 429   int ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
 430   UCHAR *RESTRICT pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
 431   SHORT *RESTRICT pSfbScale = pAacDecoderChannelInfo->pDynData->aSfbScale;
 432   SHORT *RESTRICT pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
 433   const SHORT *RESTRICT BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
 434
 435   FDKmemclear(pAacDecoderChannelInfo->pDynData->aSfbScale, (8*16)*sizeof(SHORT));
 436
 437   for (window=0, group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
 438   {
 439     for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); groupwin++, window++)
 440     {
 441       /* inverse quantization */
 442       for (band=0; band < ScaleFactorBandsTransmitted; band++)
 443       {
 444         FIXP_DBL *pSpectralCoefficient = SPEC(pAacDecoderChannelInfo->pSpectralCoefficient, window, pAacDecoderChannelInfo->granuleLength) + BandOffsets[band];
 445
 446         int noLines = BandOffsets[band+1] - BandOffsets[band];
 447         int bnds = group*16+band;
 448         int i;
 449
 450         if ((pCodeBook[bnds] == ZERO_HCB)
 451          || (pCodeBook[bnds] == INTENSITY_HCB)
 452          || (pCodeBook[bnds] == INTENSITY_HCB2)
 453            )
 454           continue;
 455
 456         if (pCodeBook[bnds] == NOISE_HCB)
 457         {
 458           /* Leave headroom for PNS values. + 1 because ceil(log2(2^(0.25*3))) = 1,
 459              worst case of additional headroom required because of the scalefactor. */
 460           pSfbScale[window*16+band] = (pScaleFactor [bnds] >> 2) + 1 ;
 461           continue;
 462         }
 463
 464         /* Find max spectral line value of the current sfb */
 465         FIXP_DBL locMax = (FIXP_DBL)0;
 466
 467         for (i = noLines; i-- ; ) {
 468           /* Expensive memory access */
 469           locMax = fMax(fixp_abs(pSpectralCoefficient[i]), locMax);
 470         }
 471
 472         /* Cheap robustness improvement - Do not remove!!! */
 473         if (fixp_abs(locMax) > (FIXP_DBL)MAX_QUANTIZED_VALUE) {
 474           return AAC_DEC_DECODE_FRAME_ERROR;
 475         }
 476
 477         /*
 478            The inverse quantized spectral lines are defined by:
 479         pSpectralCoefficient[i] = Sign(pSpectralCoefficient[i]) * 2^(0.25*pScaleFactor[bnds]) * pSpectralCoefficient[i]^(4/3)
 480            This is equivalent to:
 481         pSpectralCoefficient[i]    = Sign(pSpectralCoefficient[i]) * (2^(pScaleFactor[bnds] % 4) * pSpectralCoefficient[i]^(4/3))
 482         pSpectralCoefficient_e[i] += pScaleFactor[bnds]/4
 483         */
 484         {
 485           int msb = pScaleFactor [bnds] >> 2 ;
 486           int lsb = pScaleFactor [bnds] & 0x03 ;
 487
 488           int scale = GetScaleFromValue(locMax, lsb);
 489
 490           pSfbScale[window*16+band] = msb - scale;
 491           InverseQuantizeBand(pSpectralCoefficient, noLines, lsb, scale);
 492         }
 493       }
 494     }
 495   }
 496
 497
 498   return AAC_DEC_OK;
 499 }
 500
 501
 502 AAC_DECODER_ERROR  CBlock_ReadSpectralData(HANDLE_FDK_BITSTREAM bs,
 503                                            CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 504                                            const SamplingRateInfo *pSamplingRateInfo,
 505                                            const UINT  flags)
 506 {
 507   int i,index;
 508   int window,group,groupwin,groupoffset,band;
 509   UCHAR *RESTRICT pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
 510   const SHORT *RESTRICT BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
 511
 512   SPECTRAL_PTR pSpectralCoefficient = pAacDecoderChannelInfo->pSpectralCoefficient;
 513   FIXP_DBL locMax;
 514
 515   int ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
 516
 517   FDK_ASSERT(BandOffsets != NULL);
 518
 519   FDKmemclear(pSpectralCoefficient, sizeof(SPECTRUM));
 520
 521   if ( (flags & AC_ER_HCR) == 0 )
 522   {
 523     groupoffset = 0;
 524
 525     /* plain huffman decoder  short */
 526     for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
 527     {
 528       for (band=0; band < ScaleFactorBandsTransmitted; band++)
 529       {
 530         int bnds = group*16+band;
 531         UCHAR currentCB = pCodeBook[bnds];
 532
 533         /* patch to run plain-huffman-decoder with vcb11 input codebooks (LAV-checking might be possible below using the virtual cb and a LAV-table) */
 534         if ((currentCB >= 16) && (currentCB <= 31)) {
 535           pCodeBook[bnds] = currentCB = 11;
 536         }
 537         if ( !((currentCB == ZERO_HCB)
 538             || (currentCB == NOISE_HCB)
 539             || (currentCB == INTENSITY_HCB)
 540             || (currentCB == INTENSITY_HCB2)) )
 541         {
 542           const CodeBookDescription *hcb = &AACcodeBookDescriptionTable[currentCB];
 543           int step = hcb->Dimension;
 544           int offset = hcb->Offset;
 545           int bits = hcb->numBits;
 546           int mask = (1<<bits)-1;
 547
 548           for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); groupwin++)
 549           {
 550             window = groupoffset + groupwin;
 551
 552             FIXP_DBL *mdctSpectrum = SPEC(pSpectralCoefficient, window, pAacDecoderChannelInfo->granuleLength);
 553
 554             locMax = (FIXP_DBL)0 ;
 555
 556             for (index=BandOffsets[band]; index < BandOffsets[band+1]; index+=step)
 557             {
 558               int idx = CBlock_DecodeHuffmanWord(bs,hcb);
 559
 560               for (i=0; i<step; i++) {
 561                 FIXP_DBL tmp;
 562
 563                 tmp = (FIXP_DBL)((idx & mask)-offset);
 564                 idx >>= bits;
 565
 566                 if (offset == 0) {
 567                   if (tmp != FIXP_DBL(0))
 568                     tmp = (FDKreadBits(bs,1))? -tmp : tmp;
 569                 }
 570                 mdctSpectrum[index+i] = tmp;
 571               }
 572
 573               if (currentCB == ESCBOOK)
 574               {
 575                 mdctSpectrum[index+0] = (FIXP_DBL)CBlock_GetEscape(bs, (LONG)mdctSpectrum[index+0]);
 576                 mdctSpectrum[index+1] = (FIXP_DBL)CBlock_GetEscape(bs, (LONG)mdctSpectrum[index+1]);
 577
 578               }
 579             }
 580           }
 581         }
 582       }
 583       groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group);
 584     }
 585     /* plain huffman decoding (short) finished */
 586   }
 587   /* HCR - Huffman Codeword Reordering  short */
 588   else  /* if ( flags & AC_ER_HCR ) */
 589   {
 590     H_HCR_INFO hHcr = &pAacDecoderChannelInfo->pComData->overlay.aac.erHcrInfo;
 591     int hcrStatus = 0;
 592
 593     /* advanced Huffman decoding starts here (HCR decoding :) */
 594     if ( pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData != 0 ) {
 595
 596       /* HCR initialization short */
 597       hcrStatus = HcrInit(hHcr, pAacDecoderChannelInfo, pSamplingRateInfo, bs);
 598
 599       if (hcrStatus != 0) {
 600         return AAC_DEC_DECODE_FRAME_ERROR;
 601       }
 602
 603       /* HCR decoding short */
 604       hcrStatus = HcrDecoder(hHcr, pAacDecoderChannelInfo, pSamplingRateInfo, bs);
 605
 606       if (hcrStatus != 0) {
 607 #if HCR_ERROR_CONCEALMENT
 608         HcrMuteErroneousLines(hHcr);
 609 #else
 610         return AAC_DEC_DECODE_FRAME_ERROR;
 611 #endif /* HCR_ERROR_CONCEALMENT */
 612       }
 613
 614       FDKpushFor (bs, pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData);
 615     }
 616   }
 617   /* HCR - Huffman Codeword Reordering short finished */
 618
 619
 620
 621   if ( IsLongBlock(&pAacDecoderChannelInfo->icsInfo) && !(flags & (AC_ELD|AC_SCALABLE)) )
 622   {
 623     /* apply pulse data */
 624     CPulseData_Apply(&pAacDecoderChannelInfo->pDynData->specificTo.aac.PulseData,
 625                       GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo),
 626                       SPEC_LONG(pSpectralCoefficient));
 627   }
 628
 629
 630   return AAC_DEC_OK;
 631 }
 632
 633
 634
 635 void ApplyTools ( CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
 636                   const SamplingRateInfo *pSamplingRateInfo,
 637                   const UINT flags,
 638                   const int channel )
 639 {
 640
 641   if ( !(flags & (AC_USAC|AC_RSVD50|AC_MPS_RES)) ) {
 642     CPns_Apply(
 643            &pAacDecoderChannelInfo[channel]->data.aac.PnsData,
 644            &pAacDecoderChannelInfo[channel]->icsInfo,
 645             pAacDecoderChannelInfo[channel]->pSpectralCoefficient,
 646             pAacDecoderChannelInfo[channel]->specScale,
 647             pAacDecoderChannelInfo[channel]->pDynData->aScaleFactor,
 648             pSamplingRateInfo,
 649             pAacDecoderChannelInfo[channel]->granuleLength,
 650             channel
 651             );
 652   }
 653
 654   CTns_Apply (
 655          &pAacDecoderChannelInfo[channel]->pDynData->TnsData,
 656          &pAacDecoderChannelInfo[channel]->icsInfo,
 657           pAacDecoderChannelInfo[channel]->pSpectralCoefficient,
 658           pSamplingRateInfo,
 659           pAacDecoderChannelInfo[channel]->granuleLength
 660           );
 661 }
 662
 663 static
 664 int getWindow2Nr(int length, int shape)
 665 {
 666   int nr = 0;
 667
 668   if (shape == 2) {
 669     /* Low Overlap, 3/4 zeroed */
 670     nr = (length * 3)>>2;
 671   }
 672
 673   return nr;
 674 }
 675
 676 void CBlock_FrequencyToTime(CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
 677                             CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 678                             INT_PCM outSamples[],
 679                             const SHORT frameLen,
 680                             const int stride,
 681                             const int frameOk,
 682                             FIXP_DBL *pWorkBuffer1 )
 683 {
 684   int fr, fl, tl, nSamples, nSpec;
 685
 686   /* Determine left slope length (fl), right slope length (fr) and transform length (tl).
 687      USAC: The slope length may mismatch with the previous frame in case of LPD / FD
 688            transitions. The adjustment is handled by the imdct implementation.
 689   */
 690   tl = frameLen;
 691   nSpec = 1;
 692
 693   switch( pAacDecoderChannelInfo->icsInfo.WindowSequence ) {
 694     default:
 695     case OnlyLongSequence:
 696       fl = frameLen;
 697       fr = frameLen - getWindow2Nr(frameLen, GetWindowShape(&pAacDecoderChannelInfo->icsInfo));
 698       break;
 699     case LongStopSequence:
 700       fl = frameLen >> 3;
 701       fr = frameLen;
 702       break;
 703     case LongStartSequence: /* or StopStartSequence */
 704       fl = frameLen;
 705       fr = frameLen >> 3;
 706       break;
 707     case EightShortSequence:
 708       fl = fr = frameLen >> 3;
 709       tl >>= 3;
 710       nSpec = 8;
 711       break;
 712   }
 713
 714   {
 715     int i;
 716
 717     {
 718       FIXP_DBL *tmp = pAacDecoderChannelInfo->pComData->workBufferCore1->mdctOutTemp;
 719
 720       nSamples = imdct_block(
 721              &pAacDecoderStaticChannelInfo->IMdct,
 722               tmp,
 723               SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient),
 724               pAacDecoderChannelInfo->specScale,
 725               nSpec,
 726               frameLen,
 727               tl,
 728               FDKgetWindowSlope(fl, GetWindowShape(&pAacDecoderChannelInfo->icsInfo)),
 729               fl,
 730               FDKgetWindowSlope(fr, GetWindowShape(&pAacDecoderChannelInfo->icsInfo)),
 731               fr,
 732               (FIXP_DBL)0 );
 733
 734       for (i=0; i<frameLen; i++) {
 735         outSamples[i*stride] = IMDCT_SCALE(tmp[i]);
 736       }
 737     }
 738   }
 739
 740   FDK_ASSERT(nSamples == frameLen);
 741
 742 }
 743
 744 #include "ldfiltbank.h"
 745 void CBlock_FrequencyToTimeLowDelay( CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
 746                                      CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 747                                      INT_PCM outSamples[],
 748                                      const short frameLen,
 749                                      const char stride )
 750 {
 751   InvMdctTransformLowDelay_fdk (
 752           SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient),
 753           pAacDecoderChannelInfo->specScale[0],
 754           outSamples,
 755           pAacDecoderStaticChannelInfo->pOverlapBuffer,
 756           stride,
 757           frameLen
 758           );
 759 }