Remove FDK-AAC

1 files changed, 0 insertions, 1215 deletions

diff --git a/libAACdec/src/rvlc.cpp b/libAACdec/src/rvlc.cpp
deleted file mode 100644
index 16f0bf5..0000000
--- a/libAACdec/src/rvlc.cpp
+++ /dev/null
@@ -1,1215 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
-
- 1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
-
-2.    COPYRIGHT LICENSE
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
-
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
-
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
-modifications thereto to recipients of copies in binary form.
-
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
-
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
-
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
-
-3.    NO PATENT LICENSE
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
-
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
-
-4.    DISCLAIMER
-
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
-
-5.    CONTACT INFORMATION
-
-Fraunhofer Institute for Integrated Circuits IIS
-Attention: Audio and Multimedia Departments - FDK AAC LL
-Am Wolfsmantel 33
-91058 Erlangen, Germany
-
-www.iis.fraunhofer.de/amm
-amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*!
-  \file
-  \brief  RVLC Decoder
-  \author Robert Weidner
-*/
-
-#include "rvlc.h"
-
-
-#include "block.h"
-
-#include "aac_rom.h"
-#include "rvlcbit.h"
-#include "rvlcconceal.h"
-#include "aacdec_hcr.h"
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcInit
-
-     description:  init RVLC by data from channelinfo, which was decoded previously and
-                   set up pointers
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
-                   - pointer bitstream structure
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcInit (CErRvlcInfo            *pRvlc,
-               CAacDecoderChannelInfo *pAacDecoderChannelInfo,
-               HANDLE_FDK_BITSTREAM    bs)
-{
-  /* RVLC common initialization part 2 of 2 */
-  SHORT     *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
-  SHORT     *pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
-  SHORT     *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
-  SHORT     *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
-  int bnds;
-
-  pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = 0;
-
-  pRvlc->numDecodedEscapeWordsEsc = 0;
-  pRvlc->numDecodedEscapeWordsFwd = 0;
-  pRvlc->numDecodedEscapeWordsBwd = 0;
-
-  pRvlc->intensity_used = 0;
-  pRvlc->errorLogRvlc   = 0;
-
-  pRvlc->conceal_max = CONCEAL_MAX_INIT;
-  pRvlc->conceal_min = CONCEAL_MIN_INIT;
-
-  pRvlc->conceal_max_esc = CONCEAL_MAX_INIT;
-  pRvlc->conceal_min_esc = CONCEAL_MIN_INIT;
-
-  pRvlc->pHuffTreeRvlcEscape  = aHuffTreeRvlcEscape;
-  pRvlc->pHuffTreeRvlCodewds  = aHuffTreeRvlCodewds;
-
-  /* init scf arrays (for savety (in case of there are only zero codebooks)) */
-  for (bnds = 0; bnds < RVLC_MAX_SFB; bnds++) {
-    pScfFwd[bnds] = 0;
-    pScfBwd[bnds] = 0;
-    pScfEsc[bnds] = 0;
-    pScaleFactor[bnds] = 0;
-  }
-
-  /* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2)) */
-  FDKsyncCache (bs);
-
-  pRvlc->bitstreamIndexRvlFwd = FDKgetBitCnt(bs); /* first bit within RVL coded block as start address for  forward decoding */
-  pRvlc->bitstreamIndexRvlBwd = FDKgetBitCnt(bs) + pRvlc->length_of_rvlc_sf - 1; /* last bit within RVL coded block as start address for backward decoding */
-
-  /* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS data (if present) */
-  FDKpushFor (bs, pRvlc->length_of_rvlc_sf);
-
-  if ( pRvlc->sf_escapes_present != 0 ) {
-
-    /* locate internal bitstream ptr at escapes (which is the second part) */
-    FDKsyncCache (bs);
-    pRvlc->bitstreamIndexEsc = FDKgetBitCnt(bs);
-
-    /* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present)   to make decoder continue */
-    /* decoding of RVLC should work despite this second pushFor during initialization because        */
-    /* bitstream initialization is valid for both ESC2 data parts (RVL-coded values and ESC-coded values) */
-    FDKpushFor (bs, pRvlc->length_of_rvlc_escapes);
-  }
-
-#if VERBOSE_RVLC_INIT
-  DebugOutputInit(pRvlc,pAacDecoderChannelInfo);
-#endif
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcCheckIntensityCb
-
-     description:  Check if a intensity codebook is used in the current channel.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
------------------------------------------------------------------------------------------------
-        output:    - intensity_used: 0 no intensity codebook is used
-                                     1 intensity codebook is used
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcCheckIntensityCb (CErRvlcInfo            *pRvlc,
-                           CAacDecoderChannelInfo *pAacDecoderChannelInfo)
-{
-  int group, band, bnds;
-
-  pRvlc->intensity_used = 0;
-
-  for (group=0; group < pRvlc->numWindowGroups; group++) {
-    for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
-      bnds = 16*group+band;
-      if ( (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB) || (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB2) ) {
-        pRvlc->intensity_used = 1;
-        break;
-      }
-    }
-  }
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcDecodeEscapeWord
-
-     description:  Decode a huffman coded RVLC Escape-word. This value is part of a DPCM coded
-                   scalefactor.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
------------------------------------------------------------------------------------------------
-        return:    - a single RVLC-Escape value which had to be applied to a DPCM value (which
-                     has a absolute value of 7)
--------------------------------------------------------------------------------------------- */
-
-static
-SCHAR rvlcDecodeEscapeWord (CErRvlcInfo          *pRvlc,
-                            HANDLE_FDK_BITSTREAM  bs)
-{
-  int           i;
-  SCHAR         value;
-  UCHAR         carryBit;
-  UINT          treeNode;
-  UINT          branchValue;
-  UINT          branchNode;
-
-  USHORT*       pBitstreamIndexEsc;
-  const UINT*   pEscTree;
-
-  pEscTree = pRvlc->pHuffTreeRvlcEscape;
-  pBitstreamIndexEsc = &(pRvlc->bitstreamIndexEsc);
-  treeNode = *pEscTree;                                             /* init at starting node */
-
-  for (i=MAX_LEN_RVLC_ESCAPE_WORD-1; i >= 0; i--) {
-    carryBit = rvlcReadBitFromBitstream(bs,                         /* get next bit */
-                                        pBitstreamIndexEsc,
-                                        FWD);
-
-    CarryBitToBranchValue(carryBit,                                 /* huffman decoding, do a single step in huffman decoding tree */
-                          treeNode,
-                          &branchValue,
-                          &branchNode);
-
-    if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {                /* test bit 10 ; if set --> a RVLC-escape-word is completely decoded */
-      value = (SCHAR) branchNode & CLR_BIT_10;
-      pRvlc->length_of_rvlc_escapes -= (MAX_LEN_RVLC_ESCAPE_WORD - i);
-
-      if (pRvlc->length_of_rvlc_escapes < 0) {
-        pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
-        value = -1;
-      }
-
-      return value;
-    }
-    else {
-      treeNode = *(pEscTree + branchValue);                         /* update treeNode for further step in decoding tree */
-    }
-  }
-
-  pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
-
-  return -1;                                                        /* should not be reached */
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcDecodeEscapes
-
-     description:  Decodes all huffman coded RVLC Escape Words.
-                   Here a difference to the pseudo-code-implementation from standard can be 
-                   found. A while loop (and not two nested for loops) is used for two reasons:
-
-                   1. The plain huffman encoded escapes are decoded before the RVL-coded 
-                      scalefactors. Therefore the escapes are present in the second step 
-                      when decoding the RVL-coded-scalefactor values in forward and 
-                      backward direction.
-
-                      When the RVL-coded scalefactors are decoded and there a escape is 
-                      needed, then it is just taken out of the array in ascending order.
-
-                   2. It's faster.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - handle to FDK bitstream
------------------------------------------------------------------------------------------------
-        return:    - 0 ok     the decoded escapes seem to be valid
-                   - 1 error  there was a error detected during decoding escapes
-                              --> all escapes are invalid
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcDecodeEscapes (CErRvlcInfo          *pRvlc,
-                        SHORT                *pEsc,
-                        HANDLE_FDK_BITSTREAM  bs)
-{
-  SCHAR  escWord;
-  SCHAR  escCnt=0;
-  SHORT* pEscBitCntSum;
-
-  pEscBitCntSum = &(pRvlc->length_of_rvlc_escapes);
-
-  /* Decode all RVLC-Escape words with a plain Huffman-Decoder */
-  while ( *pEscBitCntSum > 0 ) {
-    escWord = rvlcDecodeEscapeWord(pRvlc, bs);
-
-    if (escWord >= 0) {
-
-      pEsc[escCnt] = escWord;
-      escCnt++;
-    }
-    else {
-      pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
-      pRvlc->numDecodedEscapeWordsEsc = escCnt;
-
-      return;
-    }
-  } /* all RVLC escapes decoded */
-
-  pRvlc->numDecodedEscapeWordsEsc = escCnt;
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     decodeRVLCodeword
-
-     description:  Decodes a RVL-coded dpcm-word (-part).
------------------------------------------------------------------------------------------------
-        input:     - FDK bitstream handle
-                   - pointer rvlc structure
------------------------------------------------------------------------------------------------
-        return:    - a dpcm value which is within range [0,1,..,14] in case of no errors.
-                     The offset of 7 must be subtracted to get a valid dpcm scalefactor value.
-                     In case of errors a forbidden codeword is detected --> returning -1
--------------------------------------------------------------------------------------------- */
-
-SCHAR decodeRVLCodeword (HANDLE_FDK_BITSTREAM  bs, CErRvlcInfo *pRvlc)
-{
-  int     i;
-  SCHAR   value;
-  UCHAR   carryBit;
-  UINT    branchValue;
-  UINT    branchNode;
-
-  const UINT *pRvlCodeTree = pRvlc->pHuffTreeRvlCodewds;
-  UCHAR   direction        = pRvlc->direction;
-  USHORT *pBitstrIndxRvl   = pRvlc->pBitstrIndxRvl_RVL;
-  UINT    treeNode         = *pRvlCodeTree;
-
-  for (i=MAX_LEN_RVLC_CODE_WORD-1; i >= 0; i--) { 
-    carryBit = rvlcReadBitFromBitstream(bs,             /* get next bit */
-                                        pBitstrIndxRvl,
-                                        direction);
-
-    CarryBitToBranchValue(carryBit,                     /* huffman decoding, do a single step in huffman decoding tree */
-                          treeNode,
-                          &branchValue,
-                          &branchNode);
-
-    if ((branchNode & TEST_BIT_10) == TEST_BIT_10) {    /* test bit 10 ; if set --> a RVLC-codeword is completely decoded */
-      value = (SCHAR) (branchNode & CLR_BIT_10);
-      *pRvlc->pRvlBitCnt_RVL -= (MAX_LEN_RVLC_CODE_WORD - i);  
-      
-      /* check available bits for decoding */
-      if (*pRvlc->pRvlBitCnt_RVL < 0) {
-        if (direction ==  FWD) { 
-          pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_FWD; }
-        else { 
-          pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_BWD; }
-        value = -1;                                     /* signalize an error in return value, because too many bits was decoded */
-      }
-      
-      /* check max value of dpcm value */
-      if (value > MAX_ALLOWED_DPCM_INDEX) {
-        if (direction ==  FWD) { 
-          pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD; 
-        }
-        else { 
-          pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD; 
-        }
-        value = -1;                                     /* signalize an error in return value, because a forbidden cw was detected*/
-      }                                                       
-
-      return value;                                     /* return a dpcm value with offset +7 or an error status */
-    }
-    else {
-      treeNode = *(pRvlCodeTree + branchValue);         /* update treeNode for further step in decoding tree */
-    }
-  }
-  
-  return -1;  
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcDecodeForward
-
-     description:  Decode RVL-coded codewords in forward direction.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
-                   - handle to FDK bitstream
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcDecodeForward (CErRvlcInfo            *pRvlc,
-                        CAacDecoderChannelInfo *pAacDecoderChannelInfo,
-                        HANDLE_FDK_BITSTREAM    bs)
-{
-  int band  = 0;
-  int group = 0;
-  int bnds  = 0;
-
-  SHORT dpcm;
-
-  SHORT  factor   = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET;
-  SHORT  position = - SF_OFFSET;
-  SHORT  noisenrg = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;
-
-  SHORT* pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
-  SHORT* pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
-  UCHAR* pEscFwdCnt = &(pRvlc->numDecodedEscapeWordsFwd);
-  
-  pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_fwd);
-  pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlFwd);
-
-  *pEscFwdCnt       = 0;
-  pRvlc->direction  = FWD;
-  pRvlc->noise_used = 0;
-  pRvlc->sf_used    = 0;
-  pRvlc->lastScf    = 0;
-  pRvlc->lastNrg    = 0;
-  pRvlc->lastIs     = 0;         
-
-  rvlcCheckIntensityCb(pRvlc,pAacDecoderChannelInfo);
-
-  /* main loop fwd long */
-  for (group=0; group < pRvlc->numWindowGroups; group++) {
-    for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
-      bnds = 16*group+band;
-
-      switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
-
-      case ZERO_HCB :
-        pScfFwd[bnds] = 0;
-        break;
-
-      case INTENSITY_HCB2 :
-      case INTENSITY_HCB  :
-        /* store dpcm_is_position */
-        dpcm = decodeRVLCodeword(bs, pRvlc);
-        if ( dpcm < 0 ) {
-          pRvlc->conceal_max = bnds;
-          return;
-        }
-        dpcm -= TABLE_OFFSET;
-        if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-          if (pRvlc->length_of_rvlc_escapes) {
-            pRvlc->conceal_max = bnds;
-            return;
-          }
-          else {
-            if (dpcm == MIN_RVL) { 
-              dpcm -= *pScfEsc++; 
-            }
-            else { 
-              dpcm += *pScfEsc++; 
-            }
-            (*pEscFwdCnt)++;
-            if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
-              pRvlc->conceal_max_esc = bnds;
-            }
-          }
-        }
-        position += dpcm;
-        pScfFwd[bnds] = position;
-        pRvlc->lastIs = position;
-        break;
-
-      case NOISE_HCB :
-        if (pRvlc->noise_used == 0) {
-          pRvlc->noise_used = 1;
-          pRvlc->first_noise_band = bnds;
-          noisenrg += pRvlc->dpcm_noise_nrg;
-          pScfFwd[bnds] = 100 + noisenrg;                  
-          pRvlc->lastNrg = noisenrg;
-        }
-        else {
-          dpcm = decodeRVLCodeword(bs, pRvlc);
-          if ( dpcm < 0 ) {
-            pRvlc->conceal_max = bnds;
-            return;
-          }
-          dpcm -= TABLE_OFFSET;
-          if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-            if (pRvlc->length_of_rvlc_escapes) {
-              pRvlc->conceal_max = bnds;
-              return;
-            }
-            else {
-              if (dpcm == MIN_RVL) { 
-                dpcm -= *pScfEsc++; 
-              }
-              else { 
-                dpcm += *pScfEsc++; 
-              }
-              (*pEscFwdCnt)++;
-              if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
-                pRvlc->conceal_max_esc = bnds;
-              }
-            }
-          }
-          noisenrg += dpcm;
-          pScfFwd[bnds] = 100 + noisenrg;
-          pRvlc->lastNrg = noisenrg;         
-        }
-        pAacDecoderChannelInfo->data.aac.PnsData.pnsUsed[bnds] = 1;
-        break ;
-
-      default :
-        pRvlc->sf_used = 1;
-        dpcm = decodeRVLCodeword(bs, pRvlc);
-        if ( dpcm < 0 ) {
-          pRvlc->conceal_max = bnds;
-          return;
-        }
-        dpcm -= TABLE_OFFSET;
-        if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-          if (pRvlc->length_of_rvlc_escapes) {
-            pRvlc->conceal_max = bnds;
-            return;
-          }
-          else {
-            if (dpcm == MIN_RVL) { 
-              dpcm -= *pScfEsc++; }
-            else { 
-              dpcm += *pScfEsc++; 
-            }
-            (*pEscFwdCnt)++;
-            if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
-              pRvlc->conceal_max_esc = bnds;
-            }
-          }
-        }
-        factor += dpcm;
-        pScfFwd[bnds] = factor;
-        pRvlc->lastScf = factor;
-        break;
-      }
-    }
-  }
-
-  /* postfetch fwd long */
-  if (pRvlc->intensity_used) {
-    dpcm = decodeRVLCodeword(bs, pRvlc);      /* dpcm_is_last_position */
-    if ( dpcm < 0 ) {
-      pRvlc->conceal_max = bnds;
-      return;
-    }
-    dpcm -= TABLE_OFFSET;
-    if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-      if (pRvlc->length_of_rvlc_escapes) {
-        pRvlc->conceal_max = bnds;
-        return;
-      }
-      else {
-        if (dpcm == MIN_RVL) { 
-          dpcm -= *pScfEsc++; 
-        }
-        else { 
-          dpcm += *pScfEsc++; 
-        }
-        (*pEscFwdCnt)++;  
-        if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
-          pRvlc->conceal_max_esc = bnds;
-        }
-      }
-    }
-    pRvlc->dpcm_is_last_position = dpcm;
-  }
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcDecodeBackward
-
-     description:  Decode RVL-coded codewords in backward direction.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
-                   - handle FDK bitstream
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcDecodeBackward (CErRvlcInfo            *pRvlc,
-                         CAacDecoderChannelInfo *pAacDecoderChannelInfo,
-                         HANDLE_FDK_BITSTREAM    bs)
-{
-  SHORT  band, group, dpcm, offset;
-  SHORT  bnds = pRvlc->maxSfbTransmitted-1;
-
-  SHORT  factor     = pRvlc->rev_global_gain - SF_OFFSET;
-  SHORT  position   = pRvlc->dpcm_is_last_position - SF_OFFSET;
-  SHORT  noisenrg   = pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256;
-
-  SHORT *pScfBwd    = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
-  SHORT *pScfEsc    = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
-  UCHAR *pEscEscCnt = &(pRvlc->numDecodedEscapeWordsEsc);
-  UCHAR *pEscBwdCnt = &(pRvlc->numDecodedEscapeWordsBwd);
-
-  pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_bwd);
-  pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlBwd);
-
-  *pEscBwdCnt = 0;
-  pRvlc->direction = BWD;
-  pScfEsc += *pEscEscCnt - 1;             /* set pScfEsc to last entry */
-  pRvlc->firstScf = 0;
-  pRvlc->firstNrg = 0;
-  pRvlc->firstIs = 0;
-
-  /* prefetch long BWD */
-  if (pRvlc->intensity_used) {
-    dpcm = decodeRVLCodeword(bs, pRvlc);      /* dpcm_is_last_position */
-    if ( dpcm < 0 ) {
-      pRvlc->dpcm_is_last_position = 0;
-      pRvlc->conceal_min = bnds;
-      return;
-    }
-    dpcm -= TABLE_OFFSET;
-    if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-      if (pRvlc->length_of_rvlc_escapes) {
-        pRvlc->conceal_min = bnds;
-        return;
-      }
-      else {
-        if (dpcm == MIN_RVL) {
-          dpcm -= *pScfEsc--;
-        }
-        else {
-          dpcm += *pScfEsc--;
-        }
-        (*pEscBwdCnt)++;  
-        if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
-          pRvlc->conceal_min_esc = bnds;
-        }
-      }
-    }
-    pRvlc->dpcm_is_last_position = dpcm;
-  }
-
-  /* main loop long BWD */
-  for (group=pRvlc->numWindowGroups-1; group >= 0; group--) {
-    for (band=pRvlc->maxSfbTransmitted-1; band >= 0; band--) {
-      bnds = 16*group+band;
-      if ((band == 0) && (pRvlc->numWindowGroups != 1))
-        offset = 16 - pRvlc->maxSfbTransmitted + 1;
-      else
-        offset = 1;
-
-      switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
-
-      case ZERO_HCB :
-        pScfBwd[bnds] = 0;
-        break;
-
-      case INTENSITY_HCB2 :
-      case INTENSITY_HCB  :
-        /* store dpcm_is_position */
-        dpcm = decodeRVLCodeword(bs, pRvlc);
-        if ( dpcm < 0 ) {
-          pScfBwd[bnds] = position;
-          pRvlc->conceal_min = FDKmax(0,bnds-offset);
-          return;
-        }
-        dpcm -= TABLE_OFFSET;
-        if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-          if (pRvlc->length_of_rvlc_escapes) {
-            pScfBwd[bnds] = position;
-            pRvlc->conceal_min = FDKmax(0,bnds-offset);
-            return;
-          }
-          else {
-            if (dpcm == MIN_RVL) {
-              dpcm -= *pScfEsc--;
-            }
-            else {
-              dpcm += *pScfEsc--;
-            }
-            (*pEscBwdCnt)++;
-            if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
-              pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
-            }
-          }
-        }
-        pScfBwd[bnds] = position;
-        position -= dpcm;  
-        pRvlc->firstIs = position; 
-        break;
-
-      case NOISE_HCB :
-        if ( bnds == pRvlc->first_noise_band ) {
-          pScfBwd[bnds] = pRvlc->dpcm_noise_nrg + pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;         
-          pRvlc->firstNrg = pScfBwd[bnds];
-        }
-        else {
-          dpcm = decodeRVLCodeword(bs, pRvlc);
-          if ( dpcm < 0 ) {
-            pScfBwd[bnds] = noisenrg;
-            pRvlc->conceal_min = FDKmax(0,bnds-offset);
-            return;
-          }
-          dpcm -= TABLE_OFFSET;
-          if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-            if (pRvlc->length_of_rvlc_escapes) {
-              pScfBwd[bnds] = noisenrg;
-              pRvlc->conceal_min = FDKmax(0,bnds-offset);
-              return;
-            }
-            else {
-              if (dpcm == MIN_RVL) {
-                dpcm -= *pScfEsc--;
-              }
-              else {
-                dpcm += *pScfEsc--;
-              }
-              (*pEscBwdCnt)++;
-              if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
-                pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
-              }
-            }
-          }
-          pScfBwd[bnds] = noisenrg;
-          noisenrg -= dpcm;
-          pRvlc->firstNrg = noisenrg;
-        }
-        break ;
-
-      default :
-        dpcm = decodeRVLCodeword(bs, pRvlc);
-        if ( dpcm < 0 ) {
-          pScfBwd[bnds] = factor;
-          pRvlc->conceal_min = FDKmax(0,bnds-offset);
-          return;
-        }
-        dpcm -= TABLE_OFFSET;
-        if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
-          if (pRvlc->length_of_rvlc_escapes) {
-            pScfBwd[bnds] = factor;
-            pRvlc->conceal_min = FDKmax(0,bnds-offset);
-            return;
-          }
-          else {
-            if (dpcm == MIN_RVL) {
-              dpcm -= *pScfEsc--;
-            }
-            else {
-              dpcm += *pScfEsc--;
-            }
-            (*pEscBwdCnt)++;
-            if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
-              pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
-            }
-          }
-        }
-        pScfBwd[bnds] = factor;
-        factor -= dpcm;
-        pRvlc->firstScf = factor;
-        break;
-      }
-    }
-  }
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     rvlcFinalErrorDetection             
-
-     description:  Call RVLC concealment if error was detected in decoding process
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-static
-void rvlcFinalErrorDetection (CAacDecoderChannelInfo  *pAacDecoderChannelInfo,
-                              CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo)
-{
-  CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
-  UCHAR ErrorStatusComplete       = 0;
-  UCHAR ErrorStatusLengthFwd      = 0;
-  UCHAR ErrorStatusLengthBwd      = 0;
-  UCHAR ErrorStatusLengthEscapes  = 0;
-  UCHAR ErrorStatusFirstScf       = 0;
-  UCHAR ErrorStatusLastScf        = 0;
-  UCHAR ErrorStatusFirstNrg       = 0;
-  UCHAR ErrorStatusLastNrg        = 0;
-  UCHAR ErrorStatusFirstIs        = 0;
-  UCHAR ErrorStatusLastIs         = 0;
-  UCHAR ErrorStatusForbiddenCwFwd = 0;
-  UCHAR ErrorStatusForbiddenCwBwd = 0;
-  UCHAR ErrorStatusNumEscapesFwd  = 0;
-  UCHAR ErrorStatusNumEscapesBwd  = 0;
-  UCHAR ConcealStatus             = 1;
-  UCHAR currentBlockType;  /* short: 0, not short: 1*/
-
-#if VERBOSE_RVLC_OUTPUT
-  CHAR  Strategy[60]="No";
-  SHORT conceal_max;
-  SHORT conceal_min;
-#endif
-
-  pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 1;
-
-  /* invalid escape words, bit counter unequal zero, forbidden codeword detected */
-  if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD)
-    ErrorStatusForbiddenCwFwd = 1;
-
-  if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD)
-    ErrorStatusForbiddenCwBwd = 1;
-
-  /* bit counter forward unequal zero */
-  if (pRvlc->length_of_rvlc_sf_fwd)
-    ErrorStatusLengthFwd = 1;
-
-  /* bit counter backward unequal zero */
-  if (pRvlc->length_of_rvlc_sf_bwd)
-    ErrorStatusLengthBwd = 1;
-
-  /* bit counter escape sequences unequal zero */
-  if (pRvlc->sf_escapes_present)
-    if (pRvlc->length_of_rvlc_escapes)
-      ErrorStatusLengthEscapes = 1;
-
-  if (pRvlc->sf_used) {
-    /* first decoded scf does not match to global gain in backward direction */
-    if (pRvlc->firstScf != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET) ) 
-      ErrorStatusFirstScf = 1;
-
-    /* last decoded scf does not match to rev global gain in forward direction */
-    if (pRvlc->lastScf != (pRvlc->rev_global_gain - SF_OFFSET) ) 
-      ErrorStatusLastScf = 1;
-  }
-
-  if (pRvlc->noise_used) {
-    /* first decoded nrg does not match to dpcm_noise_nrg in backward direction */
-    if (pRvlc->firstNrg != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain + pRvlc->dpcm_noise_nrg - SF_OFFSET -90 - 256) ) 
-      ErrorStatusFirstNrg = 1;
-
-    /* last decoded nrg does not match to dpcm_noise_last_position in forward direction */
-    if (pRvlc->lastNrg != (pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256) ) 
-      ErrorStatusLastNrg = 1;
-  }
-
-  if (pRvlc->intensity_used) {
-    /* first decoded is position does not match in backward direction */
-    if (pRvlc->firstIs != (-SF_OFFSET) ) 
-      ErrorStatusFirstIs = 1;
-
-    /* last decoded is position does not match in forward direction */
-    if (pRvlc->lastIs != (pRvlc->dpcm_is_last_position - SF_OFFSET) ) 
-      ErrorStatusLastIs = 1;
-  }
-
-  /* decoded escapes and used escapes in forward direction do not fit */
-  if ((pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_max == CONCEAL_MAX_INIT)) {
-    ErrorStatusNumEscapesFwd = 1;
-  }
-
-  /* decoded escapes and used escapes in backward direction do not fit */
-  if ((pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
-    ErrorStatusNumEscapesBwd = 1;
-  }
-
-#if VERBOSE_RVLC_OUTPUT
-  conceal_max = pRvlc->conceal_max;
-  conceal_min = pRvlc->conceal_min;
-#endif
-
-  if (    ErrorStatusLengthEscapes
-      || ( 
-           (   (pRvlc->conceal_max == CONCEAL_MAX_INIT) 
-            && (pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc)
-            && (ErrorStatusLastScf || ErrorStatusLastNrg || ErrorStatusLastIs) )
-           
-            && 
-
-           (   (pRvlc->conceal_min == CONCEAL_MIN_INIT) 
-            && (pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc)
-            && (ErrorStatusFirstScf || ErrorStatusFirstNrg || ErrorStatusFirstIs) ) 
-         )    
-      || (   (pRvlc->conceal_max == CONCEAL_MAX_INIT) 
-          && ((pRvlc->rev_global_gain - SF_OFFSET - pRvlc->lastScf) < -15)
-         )
-      || (   (pRvlc->conceal_min == CONCEAL_MIN_INIT) 
-          && ((pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - pRvlc->firstScf) < -15)
-         )
-     ) {
-    if ((pRvlc->conceal_max == CONCEAL_MAX_INIT) || (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
-      pRvlc->conceal_max = 0; 
-      pRvlc->conceal_min = FDKmax(0, (pRvlc->numWindowGroups-1)*16+pRvlc->maxSfbTransmitted-1);
-    }
-    else {
-      pRvlc->conceal_max = FDKmin(pRvlc->conceal_max,pRvlc->conceal_max_esc); 
-      pRvlc->conceal_min = FDKmax(pRvlc->conceal_min,pRvlc->conceal_min_esc);
-    }
-  }
-
-  ErrorStatusComplete =    ErrorStatusLastScf || ErrorStatusFirstScf || ErrorStatusLastNrg || ErrorStatusFirstNrg
-                        || ErrorStatusLastIs || ErrorStatusFirstIs || ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd 
-                        || ErrorStatusLengthFwd || ErrorStatusLengthBwd || ErrorStatusLengthEscapes || ErrorStatusNumEscapesFwd 
-                        || ErrorStatusNumEscapesBwd;
-
-  currentBlockType = (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) ? 0 : 1;
-
-   
-  if (!ErrorStatusComplete) {
-    int band;
-    int group;
-    int bnds;
-    int lastSfbIndex;
-
-    lastSfbIndex = (pRvlc->numWindowGroups > 1) ? 16 : 64;
-
-    for (group=0; group < pRvlc->numWindowGroups; group++) {
-      for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
-        bnds = 16*group+band;
-        pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousScaleFactor[bnds] = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
-      }
-    }
-
-    for (group=0; group < pRvlc->numWindowGroups; group++)
-    {
-      for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
-        bnds = 16*group+band;
-        pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = pAacDecoderChannelInfo->pDynData->aCodeBook[bnds];
-      }
-      for (; band <lastSfbIndex; band++) {
-        bnds = 16*group+band;
-        FDK_ASSERT(bnds >= 0 && bnds < RVLC_MAX_SFB);
-        pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = ZERO_HCB;
-      }
-    }
-  }
-  else {
-    int band;
-    int group;
-
-    /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
-       of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just 
-       after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward decoding, backward decoding
-       and previous frame. */
-    if (   ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT)) && (pRvlc->conceal_min <= pRvlc->conceal_max) 
-        && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK
-        && pRvlc->sf_concealment && ConcealStatus )
-    {
-      BidirectionalEstimation_UseScfOfPrevFrameAsReference (pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
-      ConcealStatus=0;
-#if VERBOSE_RVLC_OUTPUT
-      FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseScfOfPrevFrameAsReference)");
-#endif
-    }
-
-    /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
-       of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just 
-       after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward and backward decoding. */
-    if (   (pRvlc->conceal_min <= pRvlc->conceal_max)  && ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT))
-        && !(pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType))
-        && ConcealStatus )
-    {
-      BidirectionalEstimation_UseLowerScfOfCurrentFrame (pAacDecoderChannelInfo);
-      ConcealStatus=0;
-#if VERBOSE_RVLC_OUTPUT
-      FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseLowerScfOfCurrentFrame)");
-#endif
-    }
-
-    /* No errors were detected in decoding of escapes and dpcm values however the first and last value 
-       of a group (is,nrg,sf) is incorrect */                        
-    if (   (pRvlc->conceal_min <= pRvlc->conceal_max)  && ((ErrorStatusLastScf && ErrorStatusFirstScf) 
-        || (ErrorStatusLastNrg && ErrorStatusFirstNrg) || (ErrorStatusLastIs && ErrorStatusFirstIs)) 
-        && !(ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd || ErrorStatusLengthEscapes ) && ConcealStatus)
-    {
-      StatisticalEstimation (pAacDecoderChannelInfo);
-      ConcealStatus=0;
-#if VERBOSE_RVLC_OUTPUT
-      FDKstrcpy(Strategy,"Yes (StatisticalEstimation)");
-#endif
-    }
-
-    /* A error with more bits in decoding of escapes and dpcm values was detected. Use the smaller scalefactor from forward 
-       decoding, backward decoding and previous frame. */
-    if (   (pRvlc->conceal_min <= pRvlc->conceal_max) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment
-        && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && ConcealStatus )
-    {
-      PredictiveInterpolation(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
-      ConcealStatus=0;
-#if VERBOSE_RVLC_OUTPUT
-      FDKstrcpy(Strategy,"Yes (PredictiveInterpolation)");
-#endif
-    }
-
-    /* Call frame concealment, because no better strategy was found. Setting the scalefactors to zero is done for debugging 
-       purposes */
-    if (ConcealStatus) {
-      for (group=0; group < pRvlc->numWindowGroups; group++) {
-        for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
-          pAacDecoderChannelInfo->pDynData->aScaleFactor[16*group+band] = 0;
-        }
-      }
-      pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
-#if VERBOSE_RVLC_OUTPUT
-      FDKstrcpy(Strategy,"Yes (FrameConcealment)");
-#endif
-    }
-  }
-
-#if VERBOSE_RVLC_OUTPUT
-  DebugOutputDistortedBitstreams(pRvlc,pAacDecoderChannelInfo,ErrorStatusLengthFwd,ErrorStatusLengthBwd,
-                                 ErrorStatusLengthEscapes,ErrorStatusFirstScf,ErrorStatusLastScf,
-                                 ErrorStatusFirstNrg,ErrorStatusLastNrg,ErrorStatusFirstIs,ErrorStatusLastIs,
-                                 ErrorStatusForbiddenCwFwd,ErrorStatusForbiddenCwBwd,ErrorStatusNumEscapesFwd,
-                                 ErrorStatusNumEscapesBwd,conceal_max,conceal_min,Strategy);
-#endif
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     CRvlc_Read             
-
-     description:  Read RVLC ESC1 data (side info) from bitstream.
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
-                   - pointer bitstream structure
------------------------------------------------------------------------------------------------
-        return:    -
--------------------------------------------------------------------------------------------- */
-
-void CRvlc_Read (
-                 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
-                 HANDLE_FDK_BITSTREAM    bs)
-{
-  CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
-
-  int  group,band;
-
-  /* RVLC long specific initialization  Init part 1 of 2 */
-  pRvlc->numWindowGroups   = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo);
-  pRvlc->maxSfbTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
-  pRvlc->noise_used               =  0;                  /* noise detection */
-  pRvlc->dpcm_noise_nrg           =  0;                  /* only for debugging */
-  pRvlc->dpcm_noise_last_position =  0;                  /* only for debugging */
-  pRvlc->length_of_rvlc_escapes   = -1; /* default value is used for error detection and concealment */
-
-  /* read only error sensitivity class 1 data (ESC 1 - data) */
-  pRvlc->sf_concealment    = FDKreadBits(bs,1);                    /* #1 */
-  pRvlc->rev_global_gain   = FDKreadBits(bs,8);                    /* #2 */
-
-  if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) {
-    pRvlc->length_of_rvlc_sf = FDKreadBits(bs,11);                 /* #3 */
-  }            
-  else {
-    pRvlc->length_of_rvlc_sf = FDKreadBits(bs,9);                  /* #3 */
-  }
-
-  /* check if noise codebook is used */
-  for (group = 0; group < pRvlc->numWindowGroups; group++) {
-    for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
-      if (pAacDecoderChannelInfo->pDynData->aCodeBook[16*group+band] == NOISE_HCB) {
-        pRvlc->noise_used = 1;
-        break;  
-      }
-    }
-  }
-
-  if (pRvlc->noise_used) 
-    pRvlc->dpcm_noise_nrg = FDKreadBits(bs, 9);              /* #4  PNS */    
-
-  pRvlc->sf_escapes_present = FDKreadBits(bs, 1);            /* #5      */
-
-  if ( pRvlc->sf_escapes_present) {
-    pRvlc->length_of_rvlc_escapes = FDKreadBits(bs, 8);      /* #6      */
-  }
-
-  if (pRvlc->noise_used) { 
-    pRvlc->dpcm_noise_last_position = FDKreadBits(bs, 9);    /* #7  PNS */    
-    pRvlc->length_of_rvlc_sf -= 9;
-  }
-
-  pRvlc->length_of_rvlc_sf_fwd = pRvlc->length_of_rvlc_sf;
-  pRvlc->length_of_rvlc_sf_bwd = pRvlc->length_of_rvlc_sf;
-}
-
-
-/*---------------------------------------------------------------------------------------------
-     function:     CRvlc_Decode             
-
-     description:  Decode rvlc data
-                   The function reads both the escape sequences and the scalefactors in forward
-                   and backward direction. If an error occured during decoding process which can 
-                   not be concealed with the rvlc concealment frame concealment will be initiated. 
-                   Then the element "rvlcCurrentScaleFactorOK" in the decoder channel info is set 
-                   to 0 otherwise it is set to 1. 
------------------------------------------------------------------------------------------------
-        input:     - pointer rvlc structure
-                   - pointer channel info structure
-                   - pointer to persistent channel info structure
-                   - pointer bitstream structure
------------------------------------------------------------------------------------------------
-        return:    ErrorStatus = AAC_DEC_OK
--------------------------------------------------------------------------------------------- */
-
-void CRvlc_Decode (
-        CAacDecoderChannelInfo  *pAacDecoderChannelInfo,
-        CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
-        HANDLE_FDK_BITSTREAM     bs
-        )
-{
-  CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
-  INT  bitCntOffst;
-  UINT saveBitCnt;
-
-  rvlcInit(pRvlc,pAacDecoderChannelInfo,bs);  
-
-  /* save bitstream position */
-  saveBitCnt = FDKgetBitCnt(bs);
-
-#if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_SF
-  GenerateSingleBitError(pRvlc,
-                         &(pRvlc->bitstreamIndexRvlFwd),
-                         pRvlc->length_of_rvlc_sf,
-                         0);
-#endif
-
-#if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_ESC
-  if (pRvlc->sf_escapes_present)
-    GenerateSingleBitError(pRvlc,
-                           &(pRvlc->bitstreamIndexEsc),
-                           pRvlc->length_of_rvlc_escapes,
-                           1);
-#endif
-
-  if ( pRvlc->sf_escapes_present)
-    rvlcDecodeEscapes(pRvlc, pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc, bs);
-
-  rvlcDecodeForward(pRvlc,pAacDecoderChannelInfo, bs);    
-  rvlcDecodeBackward(pRvlc,pAacDecoderChannelInfo, bs);
-  rvlcFinalErrorDetection(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
-
-  pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = pRvlc->intensity_used;
-  pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used;
-
-  /* restore bitstream position */
-  bitCntOffst = saveBitCnt - FDKgetBitCnt(bs);
-  if( bitCntOffst ) {
-    FDKpushBiDirectional(bs, bitCntOffst);
-  }
-}
-
-void CRvlc_ElementCheck (
-        CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
-        CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
-        const UINT flags,
-        const INT elChannels
-        )
-{
-  int ch;
-
-  /* Required for MPS residuals. */
-  if (pAacDecoderStaticChannelInfo == NULL) {
-    return;
-  }
-
-  /* RVLC specific sanity checks */
-  if ( (flags & AC_ER_RVLC) && (elChannels == 2)) { /* to be reviewed */
-    if ( ( (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) ||
-           (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) )
-        &&  pAacDecoderChannelInfo[0]->pComData->jointStereoData.MsMaskPresent  ) {
-      pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
-      pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
-    }
-
-    if (   (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0)
-        && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 1)
-        && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcIntensityUsed == 1) ){
-      pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
-    }
-  }
-
-  for (ch = 0; ch < elChannels; ch ++)
-  {
-    pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousBlockType = (GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) == EightShortSequence) ? 0 : 1;
-    if (flags & AC_ER_RVLC) {
-      pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK;
-    }
-    else {
-      pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = 0;
-    }
-  }
-}
-
-