libAACdec/src/rvlc.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 /*!
  85   \file
  86   \brief  RVLC Decoder
  87   \author Robert Weidner
  88 */
  89
  90 #include "rvlc.h"
  91
  92
  93 #include "block.h"
  94
  95 #include "aac_rom.h"
  96 #include "rvlcbit.h"
  97 #include "rvlcconceal.h"
  98 #include "aacdec_hcr.h"
  99
 100 /*---------------------------------------------------------------------------------------------
 101      function:     rvlcInit
 102
 103      description:  init RVLC by data from channelinfo, which was decoded previously and
 104                    set up pointers
 105 -----------------------------------------------------------------------------------------------
 106         input:     - pointer rvlc structure
 107                    - pointer channel info structure
 108                    - pointer bitstream structure
 109 -----------------------------------------------------------------------------------------------
 110         return:    -
 111 -------------------------------------------------------------------------------------------- */
 112
 113 static
 114 void rvlcInit (CErRvlcInfo            *pRvlc,
 115                CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 116                HANDLE_FDK_BITSTREAM    bs)
 117 {
 118   /* RVLC common initialization part 2 of 2 */
 119   SHORT     *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
 120   SHORT     *pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
 121   SHORT     *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
 122   SHORT     *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
 123   int bnds;
 124
 125   pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = 0;
 126
 127   pRvlc->numDecodedEscapeWordsEsc = 0;
 128   pRvlc->numDecodedEscapeWordsFwd = 0;
 129   pRvlc->numDecodedEscapeWordsBwd = 0;
 130
 131   pRvlc->intensity_used = 0;
 132   pRvlc->errorLogRvlc   = 0;
 133
 134   pRvlc->conceal_max = CONCEAL_MAX_INIT;
 135   pRvlc->conceal_min = CONCEAL_MIN_INIT;
 136
 137   pRvlc->conceal_max_esc = CONCEAL_MAX_INIT;
 138   pRvlc->conceal_min_esc = CONCEAL_MIN_INIT;
 139
 140   pRvlc->pHuffTreeRvlcEscape  = aHuffTreeRvlcEscape;
 141   pRvlc->pHuffTreeRvlCodewds  = aHuffTreeRvlCodewds;
 142
 143   /* init scf arrays (for savety (in case of there are only zero codebooks)) */
 144   for (bnds = 0; bnds < RVLC_MAX_SFB; bnds++) {
 145     pScfFwd[bnds] = 0;
 146     pScfBwd[bnds] = 0;
 147     pScfEsc[bnds] = 0;
 148     pScaleFactor[bnds] = 0;
 149   }
 150
 151   /* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2)) */
 152   FDKsyncCache (bs);
 153
 154   pRvlc->bitstreamIndexRvlFwd = FDKgetBitCnt(bs); /* first bit within RVL coded block as start address for  forward decoding */
 155   pRvlc->bitstreamIndexRvlBwd = FDKgetBitCnt(bs) + pRvlc->length_of_rvlc_sf - 1; /* last bit within RVL coded block as start address for backward decoding */
 156
 157   /* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS data (if present) */
 158   FDKpushFor (bs, pRvlc->length_of_rvlc_sf);
 159
 160   if ( pRvlc->sf_escapes_present != 0 ) {
 161
 162     /* locate internal bitstream ptr at escapes (which is the second part) */
 163     FDKsyncCache (bs);
 164     pRvlc->bitstreamIndexEsc = FDKgetBitCnt(bs);
 165
 166     /* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present)   to make decoder continue */
 167     /* decoding of RVLC should work despite this second pushFor during initialization because        */
 168     /* bitstream initialization is valid for both ESC2 data parts (RVL-coded values and ESC-coded values) */
 169     FDKpushFor (bs, pRvlc->length_of_rvlc_escapes);
 170   }
 171
 172 #if VERBOSE_RVLC_INIT
 173   DebugOutputInit(pRvlc,pAacDecoderChannelInfo);
 174 #endif
 175 }
 176
 177
 178 /*---------------------------------------------------------------------------------------------
 179      function:     rvlcCheckIntensityCb
 180
 181      description:  Check if a intensity codebook is used in the current channel.
 182 -----------------------------------------------------------------------------------------------
 183         input:     - pointer rvlc structure
 184                    - pointer channel info structure
 185 -----------------------------------------------------------------------------------------------
 186         output:    - intensity_used: 0 no intensity codebook is used
 187                                      1 intensity codebook is used
 188 -----------------------------------------------------------------------------------------------
 189         return:    -
 190 -------------------------------------------------------------------------------------------- */
 191
 192 static
 193 void rvlcCheckIntensityCb (CErRvlcInfo            *pRvlc,
 194                            CAacDecoderChannelInfo *pAacDecoderChannelInfo)
 195 {
 196   int group, band, bnds;
 197
 198   pRvlc->intensity_used = 0;
 199
 200   for (group=0; group < pRvlc->numWindowGroups; group++) {
 201     for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
 202       bnds = 16*group+band;
 203       if ( (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB) || (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB2) ) {
 204         pRvlc->intensity_used = 1;
 205         break;
 206       }
 207     }
 208   }
 209 }
 210
 211
 212 /*---------------------------------------------------------------------------------------------
 213      function:     rvlcDecodeEscapeWord
 214
 215      description:  Decode a huffman coded RVLC Escape-word. This value is part of a DPCM coded
 216                    scalefactor.
 217 -----------------------------------------------------------------------------------------------
 218         input:     - pointer rvlc structure
 219 -----------------------------------------------------------------------------------------------
 220         return:    - a single RVLC-Escape value which had to be applied to a DPCM value (which
 221                      has a absolute value of 7)
 222 -------------------------------------------------------------------------------------------- */
 223
 224 static
 225 SCHAR rvlcDecodeEscapeWord (CErRvlcInfo          *pRvlc,
 226                             HANDLE_FDK_BITSTREAM  bs)
 227 {
 228   int           i;
 229   SCHAR         value;
 230   UCHAR         carryBit;
 231   UINT          treeNode;
 232   UINT          branchValue;
 233   UINT          branchNode;
 234
 235   USHORT*       pBitstreamIndexEsc;
 236   const UINT*   pEscTree;
 237
 238   pEscTree = pRvlc->pHuffTreeRvlcEscape;
 239   pBitstreamIndexEsc = &(pRvlc->bitstreamIndexEsc);
 240   treeNode = *pEscTree;                                             /* init at starting node */
 241
 242   for (i=MAX_LEN_RVLC_ESCAPE_WORD-1; i >= 0; i--) {
 243     carryBit = rvlcReadBitFromBitstream(bs,                         /* get next bit */
 244                                         pBitstreamIndexEsc,
 245                                         FWD);
 246
 247     CarryBitToBranchValue(carryBit,                                 /* huffman decoding, do a single step in huffman decoding tree */
 248                           treeNode,
 249                           &branchValue,
 250                           &branchNode);
 251
 252     if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {                /* test bit 10 ; if set --> a RVLC-escape-word is completely decoded */
 253       value = (SCHAR) branchNode & CLR_BIT_10;
 254       pRvlc->length_of_rvlc_escapes -= (MAX_LEN_RVLC_ESCAPE_WORD - i);
 255
 256       if (pRvlc->length_of_rvlc_escapes < 0) {
 257         pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
 258         value = -1;
 259       }
 260
 261       return value;
 262     }
 263     else {
 264       treeNode = *(pEscTree + branchValue);                         /* update treeNode for further step in decoding tree */
 265     }
 266   }
 267
 268   pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
 269
 270   return -1;                                                        /* should not be reached */
 271 }
 272
 273
 274 /*---------------------------------------------------------------------------------------------
 275      function:     rvlcDecodeEscapes
 276
 277      description:  Decodes all huffman coded RVLC Escape Words.
 278                    Here a difference to the pseudo-code-implementation from standard can be
 279                    found. A while loop (and not two nested for loops) is used for two reasons:
 280
 281                    1. The plain huffman encoded escapes are decoded before the RVL-coded
 282                       scalefactors. Therefore the escapes are present in the second step
 283                       when decoding the RVL-coded-scalefactor values in forward and
 284                       backward direction.
 285
 286                       When the RVL-coded scalefactors are decoded and there a escape is
 287                       needed, then it is just taken out of the array in ascending order.
 288
 289                    2. It's faster.
 290 -----------------------------------------------------------------------------------------------
 291         input:     - pointer rvlc structure
 292                    - handle to FDK bitstream
 293 -----------------------------------------------------------------------------------------------
 294         return:    - 0 ok     the decoded escapes seem to be valid
 295                    - 1 error  there was a error detected during decoding escapes
 296                               --> all escapes are invalid
 297 -------------------------------------------------------------------------------------------- */
 298
 299 static
 300 void rvlcDecodeEscapes (CErRvlcInfo          *pRvlc,
 301                         SHORT                *pEsc,
 302                         HANDLE_FDK_BITSTREAM  bs)
 303 {
 304   SCHAR  escWord;
 305   SCHAR  escCnt=0;
 306   SHORT* pEscBitCntSum;
 307
 308   pEscBitCntSum = &(pRvlc->length_of_rvlc_escapes);
 309
 310   /* Decode all RVLC-Escape words with a plain Huffman-Decoder */
 311   while ( *pEscBitCntSum > 0 ) {
 312     escWord = rvlcDecodeEscapeWord(pRvlc, bs);
 313
 314     if (escWord >= 0) {
 315
 316       pEsc[escCnt] = escWord;
 317       escCnt++;
 318     }
 319     else {
 320       pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
 321       pRvlc->numDecodedEscapeWordsEsc = escCnt;
 322
 323       return;
 324     }
 325   } /* all RVLC escapes decoded */
 326
 327   pRvlc->numDecodedEscapeWordsEsc = escCnt;
 328 }
 329
 330
 331 /*---------------------------------------------------------------------------------------------
 332      function:     decodeRVLCodeword
 333
 334      description:  Decodes a RVL-coded dpcm-word (-part).
 335 -----------------------------------------------------------------------------------------------
 336         input:     - FDK bitstream handle
 337                    - pointer rvlc structure
 338 -----------------------------------------------------------------------------------------------
 339         return:    - a dpcm value which is within range [0,1,..,14] in case of no errors.
 340                      The offset of 7 must be subtracted to get a valid dpcm scalefactor value.
 341                      In case of errors a forbidden codeword is detected --> returning -1
 342 -------------------------------------------------------------------------------------------- */
 343
 344 SCHAR decodeRVLCodeword (HANDLE_FDK_BITSTREAM  bs, CErRvlcInfo *pRvlc)
 345 {
 346   int     i;
 347   SCHAR   value;
 348   UCHAR   carryBit;
 349   UINT    branchValue;
 350   UINT    branchNode;
 351
 352   const UINT *pRvlCodeTree = pRvlc->pHuffTreeRvlCodewds;
 353   UCHAR   direction        = pRvlc->direction;
 354   USHORT *pBitstrIndxRvl   = pRvlc->pBitstrIndxRvl_RVL;
 355   UINT    treeNode         = *pRvlCodeTree;
 356
 357   for (i=MAX_LEN_RVLC_CODE_WORD-1; i >= 0; i--) {
 358     carryBit = rvlcReadBitFromBitstream(bs,             /* get next bit */
 359                                         pBitstrIndxRvl,
 360                                         direction);
 361
 362     CarryBitToBranchValue(carryBit,                     /* huffman decoding, do a single step in huffman decoding tree */
 363                           treeNode,
 364                           &branchValue,
 365                           &branchNode);
 366
 367     if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {    /* test bit 10 ; if set --> a RVLC-codeword is completely decoded */
 368       value = (SCHAR) (branchNode & CLR_BIT_10);
 369       *pRvlc->pRvlBitCnt_RVL -= (MAX_LEN_RVLC_CODE_WORD - i);
 370
 371       /* check available bits for decoding */
 372       if (*pRvlc->pRvlBitCnt_RVL < 0) {
 373         if (direction ==  FWD) {
 374           pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_FWD; }
 375         else {
 376           pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_BWD; }
 377         value = -1;                                     /* signalize an error in return value, because too many bits was decoded */
 378       }
 379
 380       /* check max value of dpcm value */
 381       if (value > MAX_ALLOWED_DPCM_INDEX) {
 382         if (direction ==  FWD) {
 383           pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD;
 384         }
 385         else {
 386           pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD;
 387         }
 388         value = -1;                                     /* signalize an error in return value, because a forbidden cw was detected*/
 389       }
 390
 391       return value;                                     /* return a dpcm value with offset +7 or an error status */
 392     }
 393     else {
 394       treeNode = *(pRvlCodeTree + branchValue);         /* update treeNode for further step in decoding tree */
 395     }
 396   }
 397
 398   return -1;
 399 }
 400
 401
 402 /*---------------------------------------------------------------------------------------------
 403      function:     rvlcDecodeForward
 404
 405      description:  Decode RVL-coded codewords in forward direction.
 406 -----------------------------------------------------------------------------------------------
 407         input:     - pointer rvlc structure
 408                    - pointer channel info structure
 409                    - handle to FDK bitstream
 410 -----------------------------------------------------------------------------------------------
 411         return:    -
 412 -------------------------------------------------------------------------------------------- */
 413
 414 static
 415 void rvlcDecodeForward (CErRvlcInfo            *pRvlc,
 416                         CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 417                         HANDLE_FDK_BITSTREAM    bs)
 418 {
 419   int band  = 0;
 420   int group = 0;
 421   int bnds  = 0;
 422
 423   SHORT dpcm;
 424
 425   SHORT  factor   = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET;
 426   SHORT  position = - SF_OFFSET;
 427   SHORT  noisenrg = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;
 428
 429   SHORT* pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
 430   SHORT* pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
 431   UCHAR* pEscFwdCnt = &(pRvlc->numDecodedEscapeWordsFwd);
 432
 433   pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_fwd);
 434   pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlFwd);
 435
 436   *pEscFwdCnt       = 0;
 437   pRvlc->direction  = FWD;
 438   pRvlc->noise_used = 0;
 439   pRvlc->sf_used    = 0;
 440   pRvlc->lastScf    = 0;
 441   pRvlc->lastNrg    = 0;
 442   pRvlc->lastIs     = 0;
 443
 444   rvlcCheckIntensityCb(pRvlc,pAacDecoderChannelInfo);
 445
 446   /* main loop fwd long */
 447   for (group=0; group < pRvlc->numWindowGroups; group++) {
 448     for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
 449       bnds = 16*group+band;
 450
 451       switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
 452
 453       case ZERO_HCB :
 454         pScfFwd[bnds] = 0;
 455         break;
 456
 457       case INTENSITY_HCB2 :
 458       case INTENSITY_HCB  :
 459         /* store dpcm_is_position */
 460         dpcm = decodeRVLCodeword(bs, pRvlc);
 461         if ( dpcm < 0 ) {
 462           pRvlc->conceal_max = bnds;
 463           return;
 464         }
 465         dpcm -= TABLE_OFFSET;
 466         if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 467           if (pRvlc->length_of_rvlc_escapes) {
 468             pRvlc->conceal_max = bnds;
 469             return;
 470           }
 471           else {
 472             if (dpcm == MIN_RVL) {
 473               dpcm -= *pScfEsc++;
 474             }
 475             else {
 476               dpcm += *pScfEsc++;
 477             }
 478             (*pEscFwdCnt)++;
 479             if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
 480               pRvlc->conceal_max_esc = bnds;
 481             }
 482           }
 483         }
 484         position += dpcm;
 485         pScfFwd[bnds] = position;
 486         pRvlc->lastIs = position;
 487         break;
 488
 489       case NOISE_HCB :
 490         if (pRvlc->noise_used == 0) {
 491           pRvlc->noise_used = 1;
 492           pRvlc->first_noise_band = bnds;
 493           noisenrg += pRvlc->dpcm_noise_nrg;
 494           pScfFwd[bnds] = 100 + noisenrg;
 495           pRvlc->lastNrg = noisenrg;
 496         }
 497         else {
 498           dpcm = decodeRVLCodeword(bs, pRvlc);
 499           if ( dpcm < 0 ) {
 500             pRvlc->conceal_max = bnds;
 501             return;
 502           }
 503           dpcm -= TABLE_OFFSET;
 504           if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 505             if (pRvlc->length_of_rvlc_escapes) {
 506               pRvlc->conceal_max = bnds;
 507               return;
 508             }
 509             else {
 510               if (dpcm == MIN_RVL) {
 511                 dpcm -= *pScfEsc++;
 512               }
 513               else {
 514                 dpcm += *pScfEsc++;
 515               }
 516               (*pEscFwdCnt)++;
 517               if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
 518                 pRvlc->conceal_max_esc = bnds;
 519               }
 520             }
 521           }
 522           noisenrg += dpcm;
 523           pScfFwd[bnds] = 100 + noisenrg;
 524           pRvlc->lastNrg = noisenrg;
 525         }
 526         pAacDecoderChannelInfo->data.aac.PnsData.pnsUsed[bnds] = 1;
 527         break ;
 528
 529       default :
 530         pRvlc->sf_used = 1;
 531         dpcm = decodeRVLCodeword(bs, pRvlc);
 532         if ( dpcm < 0 ) {
 533           pRvlc->conceal_max = bnds;
 534           return;
 535         }
 536         dpcm -= TABLE_OFFSET;
 537         if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 538           if (pRvlc->length_of_rvlc_escapes) {
 539             pRvlc->conceal_max = bnds;
 540             return;
 541           }
 542           else {
 543             if (dpcm == MIN_RVL) {
 544               dpcm -= *pScfEsc++; }
 545             else {
 546               dpcm += *pScfEsc++;
 547             }
 548             (*pEscFwdCnt)++;
 549             if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
 550               pRvlc->conceal_max_esc = bnds;
 551             }
 552           }
 553         }
 554         factor += dpcm;
 555         pScfFwd[bnds] = factor;
 556         pRvlc->lastScf = factor;
 557         break;
 558       }
 559     }
 560   }
 561
 562   /* postfetch fwd long */
 563   if (pRvlc->intensity_used) {
 564     dpcm = decodeRVLCodeword(bs, pRvlc);      /* dpcm_is_last_position */
 565     if ( dpcm < 0 ) {
 566       pRvlc->conceal_max = bnds;
 567       return;
 568     }
 569     dpcm -= TABLE_OFFSET;
 570     if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 571       if (pRvlc->length_of_rvlc_escapes) {
 572         pRvlc->conceal_max = bnds;
 573         return;
 574       }
 575       else {
 576         if (dpcm == MIN_RVL) {
 577           dpcm -= *pScfEsc++;
 578         }
 579         else {
 580           dpcm += *pScfEsc++;
 581         }
 582         (*pEscFwdCnt)++;
 583         if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
 584           pRvlc->conceal_max_esc = bnds;
 585         }
 586       }
 587     }
 588     pRvlc->dpcm_is_last_position = dpcm;
 589   }
 590 }
 591
 592
 593 /*---------------------------------------------------------------------------------------------
 594      function:     rvlcDecodeBackward
 595
 596      description:  Decode RVL-coded codewords in backward direction.
 597 -----------------------------------------------------------------------------------------------
 598         input:     - pointer rvlc structure
 599                    - pointer channel info structure
 600                    - handle FDK bitstream
 601 -----------------------------------------------------------------------------------------------
 602         return:    -
 603 -------------------------------------------------------------------------------------------- */
 604
 605 static
 606 void rvlcDecodeBackward (CErRvlcInfo            *pRvlc,
 607                          CAacDecoderChannelInfo *pAacDecoderChannelInfo,
 608                          HANDLE_FDK_BITSTREAM    bs)
 609 {
 610   SHORT  band, group, dpcm, offset;
 611   SHORT  bnds = pRvlc->maxSfbTransmitted-1;
 612
 613   SHORT  factor     = pRvlc->rev_global_gain - SF_OFFSET;
 614   SHORT  position   = pRvlc->dpcm_is_last_position - SF_OFFSET;
 615   SHORT  noisenrg   = pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256;
 616
 617   SHORT *pScfBwd    = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
 618   SHORT *pScfEsc    = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
 619   UCHAR *pEscEscCnt = &(pRvlc->numDecodedEscapeWordsEsc);
 620   UCHAR *pEscBwdCnt = &(pRvlc->numDecodedEscapeWordsBwd);
 621
 622   pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_bwd);
 623   pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlBwd);
 624
 625   *pEscBwdCnt = 0;
 626   pRvlc->direction = BWD;
 627   pScfEsc += *pEscEscCnt - 1;             /* set pScfEsc to last entry */
 628   pRvlc->firstScf = 0;
 629   pRvlc->firstNrg = 0;
 630   pRvlc->firstIs = 0;
 631
 632   /* prefetch long BWD */
 633   if (pRvlc->intensity_used) {
 634     dpcm = decodeRVLCodeword(bs, pRvlc);      /* dpcm_is_last_position */
 635     if ( dpcm < 0 ) {
 636       pRvlc->dpcm_is_last_position = 0;
 637       pRvlc->conceal_min = bnds;
 638       return;
 639     }
 640     dpcm -= TABLE_OFFSET;
 641     if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 642       if (pRvlc->length_of_rvlc_escapes) {
 643         pRvlc->conceal_min = bnds;
 644         return;
 645       }
 646       else {
 647         if (dpcm == MIN_RVL) {
 648           dpcm -= *pScfEsc--;
 649         }
 650         else {
 651           dpcm += *pScfEsc--;
 652         }
 653         (*pEscBwdCnt)++;
 654         if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
 655           pRvlc->conceal_min_esc = bnds;
 656         }
 657       }
 658     }
 659     pRvlc->dpcm_is_last_position = dpcm;
 660   }
 661
 662   /* main loop long BWD */
 663   for (group=pRvlc->numWindowGroups-1; group >= 0; group--) {
 664     for (band=pRvlc->maxSfbTransmitted-1; band >= 0; band--) {
 665       bnds = 16*group+band;
 666       if ((band == 0) && (pRvlc->numWindowGroups != 1))
 667         offset = 16 - pRvlc->maxSfbTransmitted + 1;
 668       else
 669         offset = 1;
 670
 671       switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
 672
 673       case ZERO_HCB :
 674         pScfBwd[bnds] = 0;
 675         break;
 676
 677       case INTENSITY_HCB2 :
 678       case INTENSITY_HCB  :
 679         /* store dpcm_is_position */
 680         dpcm = decodeRVLCodeword(bs, pRvlc);
 681         if ( dpcm < 0 ) {
 682           pScfBwd[bnds] = position;
 683           pRvlc->conceal_min = FDKmax(0,bnds-offset);
 684           return;
 685         }
 686         dpcm -= TABLE_OFFSET;
 687         if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 688           if (pRvlc->length_of_rvlc_escapes) {
 689             pScfBwd[bnds] = position;
 690             pRvlc->conceal_min = FDKmax(0,bnds-offset);
 691             return;
 692           }
 693           else {
 694             if (dpcm == MIN_RVL) {
 695               dpcm -= *pScfEsc--;
 696             }
 697             else {
 698               dpcm += *pScfEsc--;
 699             }
 700             (*pEscBwdCnt)++;
 701             if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
 702               pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
 703             }
 704           }
 705         }
 706         pScfBwd[bnds] = position;
 707         position -= dpcm;
 708         pRvlc->firstIs = position;
 709         break;
 710
 711       case NOISE_HCB :
 712         if ( bnds == pRvlc->first_noise_band ) {
 713           pScfBwd[bnds] = pRvlc->dpcm_noise_nrg + pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;
 714           pRvlc->firstNrg = pScfBwd[bnds];
 715         }
 716         else {
 717           dpcm = decodeRVLCodeword(bs, pRvlc);
 718           if ( dpcm < 0 ) {
 719             pScfBwd[bnds] = noisenrg;
 720             pRvlc->conceal_min = FDKmax(0,bnds-offset);
 721             return;
 722           }
 723           dpcm -= TABLE_OFFSET;
 724           if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 725             if (pRvlc->length_of_rvlc_escapes) {
 726               pScfBwd[bnds] = noisenrg;
 727               pRvlc->conceal_min = FDKmax(0,bnds-offset);
 728               return;
 729             }
 730             else {
 731               if (dpcm == MIN_RVL) {
 732                 dpcm -= *pScfEsc--;
 733               }
 734               else {
 735                 dpcm += *pScfEsc--;
 736               }
 737               (*pEscBwdCnt)++;
 738               if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
 739                 pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
 740               }
 741             }
 742           }
 743           pScfBwd[bnds] = noisenrg;
 744           noisenrg -= dpcm;
 745           pRvlc->firstNrg = noisenrg;
 746         }
 747         break ;
 748
 749       default :
 750         dpcm = decodeRVLCodeword(bs, pRvlc);
 751         if ( dpcm < 0 ) {
 752           pScfBwd[bnds] = factor;
 753           pRvlc->conceal_min = FDKmax(0,bnds-offset);
 754           return;
 755         }
 756         dpcm -= TABLE_OFFSET;
 757         if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
 758           if (pRvlc->length_of_rvlc_escapes) {
 759             pScfBwd[bnds] = factor;
 760             pRvlc->conceal_min = FDKmax(0,bnds-offset);
 761             return;
 762           }
 763           else {
 764             if (dpcm == MIN_RVL) {
 765               dpcm -= *pScfEsc--;
 766             }
 767             else {
 768               dpcm += *pScfEsc--;
 769             }
 770             (*pEscBwdCnt)++;
 771             if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
 772               pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
 773             }
 774           }
 775         }
 776         pScfBwd[bnds] = factor;
 777         factor -= dpcm;
 778         pRvlc->firstScf = factor;
 779         break;
 780       }
 781     }
 782   }
 783 }
 784
 785
 786 /*---------------------------------------------------------------------------------------------
 787      function:     rvlcFinalErrorDetection
 788
 789      description:  Call RVLC concealment if error was detected in decoding process
 790 -----------------------------------------------------------------------------------------------
 791         input:     - pointer rvlc structure
 792                    - pointer channel info structure
 793 -----------------------------------------------------------------------------------------------
 794         return:    -
 795 -------------------------------------------------------------------------------------------- */
 796
 797 static
 798 void rvlcFinalErrorDetection (CAacDecoderChannelInfo  *pAacDecoderChannelInfo,
 799                               CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo)
 800 {
 801   CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
 802   UCHAR ErrorStatusComplete       = 0;
 803   UCHAR ErrorStatusLengthFwd      = 0;
 804   UCHAR ErrorStatusLengthBwd      = 0;
 805   UCHAR ErrorStatusLengthEscapes  = 0;
 806   UCHAR ErrorStatusFirstScf       = 0;
 807   UCHAR ErrorStatusLastScf        = 0;
 808   UCHAR ErrorStatusFirstNrg       = 0;
 809   UCHAR ErrorStatusLastNrg        = 0;
 810   UCHAR ErrorStatusFirstIs        = 0;
 811   UCHAR ErrorStatusLastIs         = 0;
 812   UCHAR ErrorStatusForbiddenCwFwd = 0;
 813   UCHAR ErrorStatusForbiddenCwBwd = 0;
 814   UCHAR ErrorStatusNumEscapesFwd  = 0;
 815   UCHAR ErrorStatusNumEscapesBwd  = 0;
 816   UCHAR ConcealStatus             = 1;
 817   UCHAR currentBlockType;  /* short: 0, not short: 1*/
 818
 819 #if VERBOSE_RVLC_OUTPUT
 820   CHAR  Strategy[60]="No";
 821   SHORT conceal_max;
 822   SHORT conceal_min;
 823 #endif
 824
 825   pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 1;
 826
 827   /* invalid escape words, bit counter unequal zero, forbidden codeword detected */
 828   if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD)
 829     ErrorStatusForbiddenCwFwd = 1;
 830
 831   if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD)
 832     ErrorStatusForbiddenCwBwd = 1;
 833
 834   /* bit counter forward unequal zero */
 835   if (pRvlc->length_of_rvlc_sf_fwd)
 836     ErrorStatusLengthFwd = 1;
 837
 838   /* bit counter backward unequal zero */
 839   if (pRvlc->length_of_rvlc_sf_bwd)
 840     ErrorStatusLengthBwd = 1;
 841
 842   /* bit counter escape sequences unequal zero */
 843   if (pRvlc->sf_escapes_present)
 844     if (pRvlc->length_of_rvlc_escapes)
 845       ErrorStatusLengthEscapes = 1;
 846
 847   if (pRvlc->sf_used) {
 848     /* first decoded scf does not match to global gain in backward direction */
 849     if (pRvlc->firstScf != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET) )
 850       ErrorStatusFirstScf = 1;
 851
 852     /* last decoded scf does not match to rev global gain in forward direction */
 853     if (pRvlc->lastScf != (pRvlc->rev_global_gain - SF_OFFSET) )
 854       ErrorStatusLastScf = 1;
 855   }
 856
 857   if (pRvlc->noise_used) {
 858     /* first decoded nrg does not match to dpcm_noise_nrg in backward direction */
 859     if (pRvlc->firstNrg != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain + pRvlc->dpcm_noise_nrg - SF_OFFSET -90 - 256) )
 860       ErrorStatusFirstNrg = 1;
 861
 862     /* last decoded nrg does not match to dpcm_noise_last_position in forward direction */
 863     if (pRvlc->lastNrg != (pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256) )
 864       ErrorStatusLastNrg = 1;
 865   }
 866
 867   if (pRvlc->intensity_used) {
 868     /* first decoded is position does not match in backward direction */
 869     if (pRvlc->firstIs != (-SF_OFFSET) )
 870       ErrorStatusFirstIs = 1;
 871
 872     /* last decoded is position does not match in forward direction */
 873     if (pRvlc->lastIs != (pRvlc->dpcm_is_last_position - SF_OFFSET) )
 874       ErrorStatusLastIs = 1;
 875   }
 876
 877   /* decoded escapes and used escapes in forward direction do not fit */
 878   if ((pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_max == CONCEAL_MAX_INIT)) {
 879     ErrorStatusNumEscapesFwd = 1;
 880   }
 881
 882   /* decoded escapes and used escapes in backward direction do not fit */
 883   if ((pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
 884     ErrorStatusNumEscapesBwd = 1;
 885   }
 886
 887 #if VERBOSE_RVLC_OUTPUT
 888   conceal_max = pRvlc->conceal_max;
 889   conceal_min = pRvlc->conceal_min;
 890 #endif
 891
 892   if (    ErrorStatusLengthEscapes
 893       || (
 894            (   (pRvlc->conceal_max == CONCEAL_MAX_INIT)
 895             && (pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc)
 896             && (ErrorStatusLastScf || ErrorStatusLastNrg || ErrorStatusLastIs) )
 897
 898             &&
 899
 900            (   (pRvlc->conceal_min == CONCEAL_MIN_INIT)
 901             && (pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc)
 902             && (ErrorStatusFirstScf || ErrorStatusFirstNrg || ErrorStatusFirstIs) )
 903          )
 904       || (   (pRvlc->conceal_max == CONCEAL_MAX_INIT)
 905           && ((pRvlc->rev_global_gain - SF_OFFSET - pRvlc->lastScf) < -15)
 906          )
 907       || (   (pRvlc->conceal_min == CONCEAL_MIN_INIT)
 908           && ((pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - pRvlc->firstScf) < -15)
 909          )
 910      ) {
 911     if ((pRvlc->conceal_max == CONCEAL_MAX_INIT) || (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
 912       pRvlc->conceal_max = 0;
 913       pRvlc->conceal_min = FDKmax(0, (pRvlc->numWindowGroups-1)*16+pRvlc->maxSfbTransmitted-1);
 914     }
 915     else {
 916       pRvlc->conceal_max = FDKmin(pRvlc->conceal_max,pRvlc->conceal_max_esc);
 917       pRvlc->conceal_min = FDKmax(pRvlc->conceal_min,pRvlc->conceal_min_esc);
 918     }
 919   }
 920
 921   ErrorStatusComplete =    ErrorStatusLastScf || ErrorStatusFirstScf || ErrorStatusLastNrg || ErrorStatusFirstNrg
 922                         || ErrorStatusLastIs || ErrorStatusFirstIs || ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd
 923                         || ErrorStatusLengthFwd || ErrorStatusLengthBwd || ErrorStatusLengthEscapes || ErrorStatusNumEscapesFwd
 924                         || ErrorStatusNumEscapesBwd;
 925
 926   currentBlockType = (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) ? 0 : 1;
 927
 928
 929   if (!ErrorStatusComplete) {
 930     int band;
 931     int group;
 932     int bnds;
 933     int lastSfbIndex;
 934
 935     lastSfbIndex = (pRvlc->numWindowGroups > 1) ? 16 : 64;
 936
 937     for (group=0; group < pRvlc->numWindowGroups; group++) {
 938       for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
 939         bnds = 16*group+band;
 940         pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousScaleFactor[bnds] = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
 941       }
 942     }
 943
 944     for (group=0; group < pRvlc->numWindowGroups; group++)
 945     {
 946       for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
 947         bnds = 16*group+band;
 948         pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = pAacDecoderChannelInfo->pDynData->aCodeBook[bnds];
 949       }
 950       for (; band <lastSfbIndex; band++) {
 951         bnds = 16*group+band;
 952         FDK_ASSERT(bnds >= 0 && bnds < RVLC_MAX_SFB);
 953         pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = ZERO_HCB;
 954       }
 955     }
 956   }
 957   else {
 958     int band;
 959     int group;
 960
 961     /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
 962        of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just
 963        after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward decoding, backward decoding
 964        and previous frame. */
 965     if (   ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT)) && (pRvlc->conceal_min <= pRvlc->conceal_max)
 966         && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK
 967         && pRvlc->sf_concealment && ConcealStatus )
 968     {
 969       BidirectionalEstimation_UseScfOfPrevFrameAsReference (pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
 970       ConcealStatus=0;
 971 #if VERBOSE_RVLC_OUTPUT
 972       FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseScfOfPrevFrameAsReference)");
 973 #endif
 974     }
 975
 976     /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
 977        of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just
 978        after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward and backward decoding. */
 979     if (   (pRvlc->conceal_min <= pRvlc->conceal_max)  && ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT))
 980         && !(pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType))
 981         && ConcealStatus )
 982     {
 983       BidirectionalEstimation_UseLowerScfOfCurrentFrame (pAacDecoderChannelInfo);
 984       ConcealStatus=0;
 985 #if VERBOSE_RVLC_OUTPUT
 986       FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseLowerScfOfCurrentFrame)");
 987 #endif
 988     }
 989
 990     /* No errors were detected in decoding of escapes and dpcm values however the first and last value
 991        of a group (is,nrg,sf) is incorrect */
 992     if (   (pRvlc->conceal_min <= pRvlc->conceal_max)  && ((ErrorStatusLastScf && ErrorStatusFirstScf)
 993         || (ErrorStatusLastNrg && ErrorStatusFirstNrg) || (ErrorStatusLastIs && ErrorStatusFirstIs))
 994         && !(ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd || ErrorStatusLengthEscapes ) && ConcealStatus)
 995     {
 996       StatisticalEstimation (pAacDecoderChannelInfo);
 997       ConcealStatus=0;
 998 #if VERBOSE_RVLC_OUTPUT
 999       FDKstrcpy(Strategy,"Yes (StatisticalEstimation)");
1000 #endif
1001     }
1002
1003     /* A error with more bits in decoding of escapes and dpcm values was detected. Use the smaller scalefactor from forward
1004        decoding, backward decoding and previous frame. */
1005     if (   (pRvlc->conceal_min <= pRvlc->conceal_max) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment
1006         && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && ConcealStatus )
1007     {
1008       PredictiveInterpolation(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
1009       ConcealStatus=0;
1010 #if VERBOSE_RVLC_OUTPUT
1011       FDKstrcpy(Strategy,"Yes (PredictiveInterpolation)");
1012 #endif
1013     }
1014
1015     /* Call frame concealment, because no better strategy was found. Setting the scalefactors to zero is done for debugging
1016        purposes */
1017     if (ConcealStatus) {
1018       for (group=0; group < pRvlc->numWindowGroups; group++) {
1019         for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
1020           pAacDecoderChannelInfo->pDynData->aScaleFactor[16*group+band] = 0;
1021         }
1022       }
1023       pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1024 #if VERBOSE_RVLC_OUTPUT
1025       FDKstrcpy(Strategy,"Yes (FrameConcealment)");
1026 #endif
1027     }
1028   }
1029
1030 #if VERBOSE_RVLC_OUTPUT
1031   DebugOutputDistortedBitstreams(pRvlc,pAacDecoderChannelInfo,ErrorStatusLengthFwd,ErrorStatusLengthBwd,
1032                                  ErrorStatusLengthEscapes,ErrorStatusFirstScf,ErrorStatusLastScf,
1033                                  ErrorStatusFirstNrg,ErrorStatusLastNrg,ErrorStatusFirstIs,ErrorStatusLastIs,
1034                                  ErrorStatusForbiddenCwFwd,ErrorStatusForbiddenCwBwd,ErrorStatusNumEscapesFwd,
1035                                  ErrorStatusNumEscapesBwd,conceal_max,conceal_min,Strategy);
1036 #endif
1037 }
1038
1039
1040 /*---------------------------------------------------------------------------------------------
1041      function:     CRvlc_Read
1042
1043      description:  Read RVLC ESC1 data (side info) from bitstream.
1044 -----------------------------------------------------------------------------------------------
1045         input:     - pointer rvlc structure
1046                    - pointer channel info structure
1047                    - pointer bitstream structure
1048 -----------------------------------------------------------------------------------------------
1049         return:    -
1050 -------------------------------------------------------------------------------------------- */
1051
1052 void CRvlc_Read (
1053                  CAacDecoderChannelInfo *pAacDecoderChannelInfo,
1054                  HANDLE_FDK_BITSTREAM    bs)
1055 {
1056   CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
1057
1058   int  group,band;
1059
1060   /* RVLC long specific initialization  Init part 1 of 2 */
1061   pRvlc->numWindowGroups   = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo);
1062   pRvlc->maxSfbTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
1063   pRvlc->noise_used               =  0;                  /* noise detection */
1064   pRvlc->dpcm_noise_nrg           =  0;                  /* only for debugging */
1065   pRvlc->dpcm_noise_last_position =  0;                  /* only for debugging */
1066   pRvlc->length_of_rvlc_escapes   = -1; /* default value is used for error detection and concealment */
1067
1068   /* read only error sensitivity class 1 data (ESC 1 - data) */
1069   pRvlc->sf_concealment    = FDKreadBits(bs,1);                    /* #1 */
1070   pRvlc->rev_global_gain   = FDKreadBits(bs,8);                    /* #2 */
1071
1072   if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) {
1073     pRvlc->length_of_rvlc_sf = FDKreadBits(bs,11);                 /* #3 */
1074   }
1075   else {
1076     pRvlc->length_of_rvlc_sf = FDKreadBits(bs,9);                  /* #3 */
1077   }
1078
1079   /* check if noise codebook is used */
1080   for (group = 0; group < pRvlc->numWindowGroups; group++) {
1081     for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
1082       if (pAacDecoderChannelInfo->pDynData->aCodeBook[16*group+band] == NOISE_HCB) {
1083         pRvlc->noise_used = 1;
1084         break;
1085       }
1086     }
1087   }
1088
1089   if (pRvlc->noise_used)
1090     pRvlc->dpcm_noise_nrg = FDKreadBits(bs, 9);              /* #4  PNS */
1091
1092   pRvlc->sf_escapes_present = FDKreadBits(bs, 1);            /* #5      */
1093
1094   if ( pRvlc->sf_escapes_present) {
1095     pRvlc->length_of_rvlc_escapes = FDKreadBits(bs, 8);      /* #6      */
1096   }
1097
1098   if (pRvlc->noise_used) {
1099     pRvlc->dpcm_noise_last_position = FDKreadBits(bs, 9);    /* #7  PNS */
1100     pRvlc->length_of_rvlc_sf -= 9;
1101   }
1102
1103   pRvlc->length_of_rvlc_sf_fwd = pRvlc->length_of_rvlc_sf;
1104   pRvlc->length_of_rvlc_sf_bwd = pRvlc->length_of_rvlc_sf;
1105 }
1106
1107
1108 /*---------------------------------------------------------------------------------------------
1109      function:     CRvlc_Decode
1110
1111      description:  Decode rvlc data
1112                    The function reads both the escape sequences and the scalefactors in forward
1113                    and backward direction. If an error occured during decoding process which can
1114                    not be concealed with the rvlc concealment frame concealment will be initiated.
1115                    Then the element "rvlcCurrentScaleFactorOK" in the decoder channel info is set
1116                    to 0 otherwise it is set to 1.
1117 -----------------------------------------------------------------------------------------------
1118         input:     - pointer rvlc structure
1119                    - pointer channel info structure
1120                    - pointer to persistent channel info structure
1121                    - pointer bitstream structure
1122 -----------------------------------------------------------------------------------------------
1123         return:    ErrorStatus = AAC_DEC_OK
1124 -------------------------------------------------------------------------------------------- */
1125
1126 void CRvlc_Decode (
1127         CAacDecoderChannelInfo  *pAacDecoderChannelInfo,
1128         CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
1129         HANDLE_FDK_BITSTREAM     bs
1130         )
1131 {
1132   CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
1133   INT  bitCntOffst;
1134   UINT saveBitCnt;
1135
1136   rvlcInit(pRvlc,pAacDecoderChannelInfo,bs);
1137
1138   /* save bitstream position */
1139   saveBitCnt = FDKgetBitCnt(bs);
1140
1141 #if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_SF
1142   GenerateSingleBitError(pRvlc,
1143                          &(pRvlc->bitstreamIndexRvlFwd),
1144                          pRvlc->length_of_rvlc_sf,
1145                          0);
1146 #endif
1147
1148 #if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_ESC
1149   if (pRvlc->sf_escapes_present)
1150     GenerateSingleBitError(pRvlc,
1151                            &(pRvlc->bitstreamIndexEsc),
1152                            pRvlc->length_of_rvlc_escapes,
1153                            1);
1154 #endif
1155
1156   if ( pRvlc->sf_escapes_present)
1157     rvlcDecodeEscapes(pRvlc, pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc, bs);
1158
1159   rvlcDecodeForward(pRvlc,pAacDecoderChannelInfo, bs);
1160   rvlcDecodeBackward(pRvlc,pAacDecoderChannelInfo, bs);
1161   rvlcFinalErrorDetection(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
1162
1163   pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = pRvlc->intensity_used;
1164   pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used;
1165
1166   /* restore bitstream position */
1167   bitCntOffst = saveBitCnt - FDKgetBitCnt(bs);
1168   if( bitCntOffst ) {
1169     FDKpushBiDirectional(bs, bitCntOffst);
1170   }
1171 }
1172
1173 void CRvlc_ElementCheck (
1174         CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
1175         CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
1176         const UINT flags,
1177         const INT elChannels
1178         )
1179 {
1180   int ch;
1181
1182   /* Required for MPS residuals. */
1183   if (pAacDecoderStaticChannelInfo == NULL) {
1184     return;
1185   }
1186
1187   /* RVLC specific sanity checks */
1188   if ( (flags & AC_ER_RVLC) && (elChannels == 2)) { /* to be reviewed */
1189     if ( ( (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) ||
1190            (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) )
1191         &&  pAacDecoderChannelInfo[0]->pComData->jointStereoData.MsMaskPresent  ) {
1192       pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1193       pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1194     }
1195
1196     if (   (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0)
1197         && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 1)
1198         && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcIntensityUsed == 1) ){
1199       pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1200     }
1201   }
1202
1203   for (ch = 0; ch < elChannels; ch ++)
1204   {
1205     pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousBlockType = (GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) == EightShortSequence) ? 0 : 1;
1206     if (flags & AC_ER_RVLC) {
1207       pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK;
1208     }
1209     else {
1210       pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = 0;
1211     }
1212   }
1213 }
1214
1215