Remove FDK-AAC

36 files changed, 0 insertions, 17793 deletions

diff --git a/libSBRdec/include/sbrdecoder.h b/libSBRdec/include/sbrdecoder.h
deleted file mode 100644
index 13707e0..0000000
--- a/libSBRdec/include/sbrdecoder.h
+++ /dev/null
@@ -1,337 +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
------------------------------------------------------------------------------------------------------------ */
-
-/************************  Fraunhofer IIS SBR decoder library ******************
-
-   Author(s):
-   Description: SBR decoder front-end prototypes and definitions.
-
-******************************************************************************/
-
-#ifndef __SBRDECODER_H
-#define __SBRDECODER_H
-
-#include "common_fix.h"
-
-#include "FDK_bitstream.h"
-#include "FDK_audio.h"
-
-
-#define SBR_DEBUG_EXTHLP "\
---- SBR ---\n\
-    0x00000010 Ancillary data and SBR-Header\n\
-    0x00000020 SBR-Side info\n\
-    0x00000040 Decoded SBR-bitstream data, e.g. envelope data\n\
-    0x00000080 SBR-Bitstream statistics\n\
-    0x00000100 Miscellaneous SBR-messages\n\
-    0x00000200 SBR-Energies and gains in the adjustor\n\
-    0x00000400 Fatal SBR errors\n\
-    0x00000800 Transposer coefficients for inverse filtering\n\
-"
-
-/* Capability flags */
-#define CAPF_SBR_LP          0x00000001   /*!< Flag indicating library's capability of Low Power mode.            */
-#define CAPF_SBR_HQ          0x00000002   /*!< Flag indicating library's capability of High Quality mode.         */
-#define CAPF_SBR_DRM_BS      0x00000004   /*!< Flag indicating library's capability to decode DRM SBR data.       */
-#define CAPF_SBR_CONCEALMENT 0x00000008   /*!< Flag indicating library's capability to conceal erroneous frames.  */
-#define CAPF_SBR_DRC         0x00000010   /*!< Flag indicating library's capability for Dynamic Range Control.    */
-#define CAPF_SBR_PS_MPEG     0x00000020   /*!< Flag indicating library's capability to do MPEG Parametric Stereo. */
-#define CAPF_SBR_PS_DRM      0x00000040   /*!< Flag indicating library's capability to do DRM Parametric Stereo.  */
-
-typedef enum
-{
-  SBRDEC_OK = 0,                       /*!< All fine.                                                       */
-  /* SBRDEC_CONCEAL,                                                                                        */
-  /* SBRDEC_NOSYNCH,                                                                                        */
-  /* SBRDEC_ILLEGAL_PROGRAM,                                                                                */
-  /* SBRDEC_ILLEGAL_TAG,                                                                                    */
-  /* SBRDEC_ILLEGAL_CHN_CONFIG,                                                                             */
-  /* SBRDEC_ILLEGAL_SECTION,                                                                                */
-  /* SBRDEC_ILLEGAL_SCFACTORS,                                                                              */
-  /* SBRDEC_ILLEGAL_PULSE_DATA,                                                                             */
-  /* SBRDEC_MAIN_PROFILE_NOT_IMPLEMENTED,                                                                   */
-  /* SBRDEC_GC_NOT_IMPLEMENTED,                                                                             */
-  /* SBRDEC_ILLEGAL_PLUS_ELE_ID,                                                                            */
-  SBRDEC_CREATE_ERROR,                 /*!<                                                                 */
-  SBRDEC_NOT_INITIALIZED,              /*!<                                                                 */
-  SBRDEC_MEM_ALLOC_FAILED,             /*!< Memory allocation failed. Probably not enough memory available. */
-  SBRDEC_PARSE_ERROR,                  /*!<                                                                 */
-  SBRDEC_UNSUPPORTED_CONFIG,           /*!<                                                                 */
-  SBRDEC_SET_PARAM_FAIL                /*!<                                                                 */
-} SBR_ERROR;
-
-typedef enum
-{
-  SBR_SYSTEM_BITSTREAM_DELAY,          /*!< System: Switch to enable an additional SBR bitstream delay of one frame. */
-  SBR_QMF_MODE,                        /*!< Set QMF mode, either complex or low power. */
-  SBR_LD_QMF_TIME_ALIGN,               /*!< Set QMF type, either LD-MPS or CLDFB. Relevant for ELD streams only. */
-  SBR_BS_INTERRUPTION                  /*!< Signal bit stream interruption. Value is ignored. */
-} SBRDEC_PARAM;
-
-typedef struct SBR_DECODER_INSTANCE *HANDLE_SBRDECODER;
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-/**
- * \brief        Allocates and initializes one SBR decoder instance.
- * \param pSelf  Pointer to where a SBR decoder handle is copied into.
- * \return       Error code.
- */
-SBR_ERROR sbrDecoder_Open ( HANDLE_SBRDECODER *pSelf );
-
-/**
- * \brief  Initialize a SBR decoder runtime instance. Must be called before decoding starts.
- *
- * \param self             Handle to a SBR decoder instance.
- * \param sampleRateIn     Input samplerate of the SBR decoder instance.
- * \param sampleRateOut    Output samplerate of the SBR decoder instance.
- * \param samplesPerFrame  Number of samples per frames.
- * \param coreCodec        Audio Object Type (AOT) of the core codec.
- * \param elementID        Table with MPEG-4 element Ids in canonical order.
- * \param forceReset       Flag that enforces a complete decoder reset.
- *
- * \return  Error code.
- */
-SBR_ERROR sbrDecoder_InitElement (
-        HANDLE_SBRDECODER       self,
-        const int               sampleRateIn,
-        const int               sampleRateOut,
-        const int               samplesPerFrame,
-        const AUDIO_OBJECT_TYPE coreCodec,
-        const MP4_ELEMENT_ID    elementID,
-        const int               elementIndex
-        );
-
-/**
- * \brief pass out of band SBR header to SBR decoder
- *
- * \param self         Handle to a SBR decoder instance.
- * \param hBs          bit stream handle data source.
- * \param elementID    SBR element ID.
- * \param elementIndex SBR element index.
- *
- * \return  Error code.
- */
-INT sbrDecoder_Header (
-        HANDLE_SBRDECODER       self,
-        HANDLE_FDK_BITSTREAM    hBs,
-        const INT sampleRateIn,
-        const INT sampleRateOut,
-        const INT samplesPerFrame,
-        const AUDIO_OBJECT_TYPE coreCodec,
-        const MP4_ELEMENT_ID    elementID,
-        const INT               elementIndex
-        );
-
-/**
- * \brief        Set a parameter of the SBR decoder runtime instance.
- * \param self   SBR decoder handle.
- * \param param  Parameter which will be set if successfull.
- * \param value  New parameter value.
- * \return       Error code.
- */
-SBR_ERROR sbrDecoder_SetParam ( HANDLE_SBRDECODER   self,
-                                const SBRDEC_PARAM  param,
-                                const INT           value );
-
-/**
- * \brief  Feed DRC channel data into a SBR decoder runtime instance.
- *
- * \param self                    SBR decoder handle.
- * \param ch                      Channel number to which the DRC data is associated to.
- * \param numBands                Number of DRC bands.
- * \param pNextFact_mag           Pointer to a table with the DRC factor magnitudes.
- * \param nextFact_exp            Exponent for all DRC factors.
- * \param drcInterpolationScheme  DRC interpolation scheme.
- * \param winSequence             Window sequence from core coder (eight short or one long window).
- * \param pBandTop                Pointer to a table with the top borders for all DRC bands.
- *
- * \return  Error code.
- */
-SBR_ERROR sbrDecoder_drcFeedChannel ( HANDLE_SBRDECODER  self,
-                                      INT                ch,
-                                      UINT               numBands,
-                                      FIXP_DBL          *pNextFact_mag,
-                                      INT                nextFact_exp,
-                                      SHORT              drcInterpolationScheme,
-                                      UCHAR              winSequence,
-                                      USHORT            *pBandTop );
-
-/**
- * \brief  Disable SBR DRC for a certain channel.
- *
- * \param hSbrDecoder  SBR decoder handle.
- * \param ch           Number of the channel that has to be disabled.
- *
- * \return  None.
- */
-void sbrDecoder_drcDisable ( HANDLE_SBRDECODER  self,
-                             INT                ch );
-
-
-/**
- * \brief  Parse one SBR element data extension data block. The bit stream position will
- *         be placed at the end of the SBR payload block. The remaining bits will be returned
- *         into *count if a payload length is given (byPayLen > 0). If no SBR payload length is
- *         given (bsPayLen < 0) then the bit stream position on return will be random after this
- *         function call in case of errors, and any further decoding will be completely pointless.
- *
- * \param self           SBR decoder handle.
- * \param hBs            Bit stream handle as data source.
- * \param count          Pointer to an integer where the amount of parsed SBR payload bits is stored into.
- * \param bsPayLen       If > 0 this value is the SBR payload length. If < 0, the SBR payload length is unknown.
- * \param flags          CRC flag (0: EXT_SBR_DATA; 1: EXT_SBR_DATA_CRC)
- * \param prev_element   Previous MPEG-4 element ID.
- * \param element_index  Index of the current element.
- *
- * \return  Error code.
- */
-SBR_ERROR sbrDecoder_Parse (
-        HANDLE_SBRDECODER  self,
-        HANDLE_FDK_BITSTREAM hBs,
-        int *count,
-        int  bsPayLen,
-        int  crcFlag,
-        MP4_ELEMENT_ID prev_element,
-        int element_index,
-        int fGlobalIndependencyFlag
-        );
-
-/**
- * \brief  This function decodes the given SBR bitstreams and applies SBR to the given time data.
- * 
- * SBR-processing works InPlace. I.e. the calling function has to provide
- * a time domain buffer timeData which can hold the completely decoded
- * result.
- *
- * Left and right channel are read and stored according to the
- * interleaving flag, frame length and number of channels.
- *
- * \param self            Handle of an open SBR decoder instance.
- * \param hSbrBs          SBR Bitstream handle.
- * \param timeData        Pointer to input and finally upsampled output data.
- * \param numChannels     Pointer to a buffer holding the number of channels in time data buffer.
- * \param sampleRate      Output samplerate.
- * \param channelMapping  Channel mapping indices.
- * \param interleaved     Flag indicating if time data is stored interleaved (1: Interleaved time data, 0: non-interleaved timedata).
- * \param coreDecodedOk   Flag indicating if the core decoder did not find any error (0: core decoder found errors, 1: no errors).
- * \param psDecoded       Pointer to a buffer holding a flag. Input: PS is possible, Output: PS has been rendered.
- *
- * \return  Error code.
- */
-SBR_ERROR sbrDecoder_Apply ( HANDLE_SBRDECODER    self,
-                             INT_PCM             *timeData,
-                             int                 *numChannels,
-                             int                 *sampleRate,
-                             const UCHAR          channelMapping[(6)],
-                             const int            interleaved,
-                             const int            coreDecodedOk,
-                             UCHAR               *psDecoded );
-
-
-/**
- * \brief       Close SBR decoder instance and free memory.
- * \param self  SBR decoder handle.
- * \return      Error Code.
- */
-SBR_ERROR sbrDecoder_Close ( HANDLE_SBRDECODER *self );
-
-
-/**
- * \brief       Get SBR decoder library information.
- * \param info  Pointer to a LIB_INFO struct, where library information is written to.
- * \return      0 on success, -1 if invalid handle or if no free element is available to write information to.
- */
-INT sbrDecoder_GetLibInfo( LIB_INFO *info );    
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/libSBRdec/src/arm/env_calc_arm.cpp b/libSBRdec/src/arm/env_calc_arm.cpp
deleted file mode 100644
index 12b17d8..0000000
--- a/libSBRdec/src/arm/env_calc_arm.cpp
+++ /dev/null
@@ -1,148 +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
------------------------------------------------------------------------------------------------------------ */
-
-/********************************  Fraunhofer IIS  ***************************
-
-   Author(s):   Arthur Tritthart
-   Description: (ARM optimised) SBR domain coding
-
-******************************************************************************/
-#ifndef INCLUSION_GUARD_CALC_ENV_ARM
-#define INCLUSION_GUARD_CALC_ENV_ARM
-
-
-/*!
-  \brief   Compute maximal value of a complex array (re/im) of a given width
-           Negative values are temporarily logically or'ed with 0xFFFFFFFF
-           instead of negating the value, if the sign bit is set.
-  \param   maxVal  Preset maximal value
-  \param   reTmp   real input signal
-  \param   imTmp   imaginary input signal
-  \return  new maximal value
-*/
-
-#ifdef FUNCTION_FDK_get_maxval
-__asm FIXP_DBL FDK_get_maxval (FIXP_DBL maxVal, FIXP_DBL *reTmp, FIXP_DBL *imTmp, int width )
-{
-
-  /* Register map:
-     r0    maxVal
-     r1    reTmp
-     r2    imTmp
-     r3    width
-     r4    real
-     r5    imag
-  */
-    PUSH    {r4-r5}
-
-    MOVS    r3, r3, ASR #1
-    ADC     r3, r3, #0
-    BCS     FDK_get_maxval_loop_2nd_part
-    BEQ     FDK_get_maxval_loop_end
-
-FDK_get_maxval_loop
-    LDR     r4, [r1], #4
-    LDR     r5, [r2], #4
-    EOR     r4, r4, r4, ASR #31
-    EOR     r5, r5, r5, ASR #31
-    ORR     r0, r0, r4
-    ORR     r0, r0, r5
-
-FDK_get_maxval_loop_2nd_part
-    LDR     r4, [r1], #4
-    LDR     r5, [r2], #4
-    EOR     r4, r4, r4, ASR #31
-    EOR     r5, r5, r5, ASR #31
-    ORR     r0, r0, r4
-    ORR     r0, r0, r5
-
-    SUBS    r3, r3, #1
-    BNE     FDK_get_maxval_loop
-
-FDK_get_maxval_loop_end
-    POP     {r4-r5}
-    BX      lr
-}
-#endif /* FUNCTION_FDK_get_maxval */
-
-#endif /* INCLUSION_GUARD_CALC_ENV_ARM */
diff --git a/libSBRdec/src/arm/lpp_tran_arm.cpp b/libSBRdec/src/arm/lpp_tran_arm.cpp
deleted file mode 100644
index 78bbc2c..0000000
--- a/libSBRdec/src/arm/lpp_tran_arm.cpp
+++ /dev/null
@@ -1,151 +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
------------------------------------------------------------------------------------------------------------ */
-
-/********************************  Fraunhofer IIS  ***************************
-
-   Author(s):   Arthur Tritthart
-   Description: (ARM optimised) LPP transposer subroutines
-
-******************************************************************************/
-
-
-#if defined(__arm__)
-
-
-#define FUNCTION_LPPTRANSPOSER_func1
-
-#ifdef FUNCTION_LPPTRANSPOSER_func1
-
-/* Note: This code requires only 43 cycles per iteration instead of 61 on ARM926EJ-S */
-__attribute__ ((noinline)) static void lppTransposer_func1(
-  FIXP_DBL *lowBandReal,
-  FIXP_DBL *lowBandImag,
-  FIXP_DBL **qmfBufferReal,
-  FIXP_DBL **qmfBufferImag,
-  int loops,
-  int hiBand,
-  int dynamicScale,
-  int descale,
-  FIXP_SGL a0r,
-  FIXP_SGL a0i,
-  FIXP_SGL a1r,
-  FIXP_SGL a1i)
-{
-
-  FIXP_DBL real1, real2, imag1, imag2, accu1, accu2;
-
-  real2 = lowBandReal[-2];
-  real1 = lowBandReal[-1];
-  imag2 = lowBandImag[-2];
-  imag1 = lowBandImag[-1];
-  for(int i=0; i < loops; i++)
-  {
-    accu1 = fMultDiv2(         a0r,real1);
-    accu2 = fMultDiv2(         a0i,imag1);
-    accu1 = fMultAddDiv2(accu1,a1r,real2);
-    accu2 = fMultAddDiv2(accu2,a1i,imag2);
-    real2 = fMultDiv2(         a1i,real2);
-    accu1 = accu1 - accu2;
-    accu1 = accu1 >> dynamicScale;
-
-    accu2 = fMultAddDiv2(real2,a1r,imag2);
-    real2 = real1;
-    imag2 = imag1;
-    accu2 = fMultAddDiv2(accu2,a0i,real1);
-    real1 = lowBandReal[i];
-    accu2 = fMultAddDiv2(accu2,a0r,imag1);
-    imag1 = lowBandImag[i];
-    accu2 = accu2 >> dynamicScale;
-
-    accu1 <<= 1;
-    accu2 <<= 1;
-
-    qmfBufferReal[i][hiBand] = accu1 + (real1>>descale);
-    qmfBufferImag[i][hiBand] = accu2 + (imag1>>descale);
-  }
-}
-#endif  /* #ifdef FUNCTION_LPPTRANSPOSER_func1 */
-#endif  /* __arm__ */
-
-
-
diff --git a/libSBRdec/src/env_calc.cpp b/libSBRdec/src/env_calc.cpp
deleted file mode 100644
index ade57fc..0000000
--- a/libSBRdec/src/env_calc.cpp
+++ /dev/null
@@ -1,2229 +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  Envelope calculation  
-
-  The envelope adjustor compares the energies present in the transposed
-  highband to the reference energies conveyed with the bitstream.
-  The highband is amplified (sometimes) or attenuated (mostly) to the
-  desired level.
-
-  The spectral shape of the reference energies can be changed several times per
-  frame if necessary. Each set of energy values corresponding to a certain range
-  in time will be called an <em>envelope</em> here.
-  The bitstream supports several frequency scales and two resolutions. Normally,
-  one or more QMF-subbands are grouped to one SBR-band. An envelope contains
-  reference energies for each SBR-band.
-  In addition to the energy envelopes, noise envelopes are transmitted that
-  define the ratio of energy which is generated by adding noise instead of
-  transposing the lowband. The noise envelopes are given in a coarser time
-  and frequency resolution.
-  If a signal contains strong tonal components, synthetic sines can be
-  generated in individual SBR bands.
-
-  An overlap buffer of 6 QMF-timeslots is used to allow a more
-  flexible alignment of the envelopes in time that is not restricted to the
-  core codec's frame borders.
-  Therefore the envelope adjustor has access to the spectral data of the
-  current frame as well as the last 6 QMF-timeslots of the previous frame.
-  However, in average only the data of 1 frame is being processed as
-  the adjustor is called once per frame.
-
-  Depending on the frequency range set in the bitstream, only QMF-subbands between
-  <em>lowSubband</em> and <em>highSubband</em> are adjusted.
-
-  Scaling of spectral data to maximize SNR (see #QMF_SCALE_FACTOR) as well as a special Mantissa-Exponent format
-  ( see  calculateSbrEnvelope() ) are being used. The main entry point for this modules is calculateSbrEnvelope().
-
-  \sa sbr_scale.h, #QMF_SCALE_FACTOR, calculateSbrEnvelope(), \ref documentationOverview
-*/
-
-
-#include "env_calc.h"
-
-#include "sbrdec_freq_sca.h"
-#include "env_extr.h"
-#include "transcendent.h"
-#include "sbr_ram.h"
-#include "sbr_rom.h"
-
-#include "genericStds.h"           /* need FDKpow() for debug outputs */
-
-#if defined(__arm__)
-#include "arm/env_calc_arm.cpp"
-#endif
-
-typedef struct
-{
-    FIXP_DBL nrgRef[MAX_FREQ_COEFFS];
-    FIXP_DBL nrgEst[MAX_FREQ_COEFFS];
-    FIXP_DBL nrgGain[MAX_FREQ_COEFFS];
-    FIXP_DBL noiseLevel[MAX_FREQ_COEFFS];
-    FIXP_DBL nrgSine[MAX_FREQ_COEFFS];
-
-    SCHAR   nrgRef_e[MAX_FREQ_COEFFS];
-    SCHAR   nrgEst_e[MAX_FREQ_COEFFS];
-    SCHAR   nrgGain_e[MAX_FREQ_COEFFS];
-    SCHAR   noiseLevel_e[MAX_FREQ_COEFFS];
-    SCHAR   nrgSine_e[MAX_FREQ_COEFFS];
-}
-ENV_CALC_NRGS;
-
-/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer,
-                                  SCHAR   *filtBuffer_e,
-                                  FIXP_DBL *NrgGain,
-                                  SCHAR   *NrgGain_e,
-                                  int    subbands);
-
-/*static*/ void calcNrgPerSubband(FIXP_DBL  **analysBufferReal,
-                              FIXP_DBL  **analysBufferImag,
-                              int       lowSubband, int highSubband,
-                              int       start_pos,  int next_pos,
-                              SCHAR     frameExp,
-                              FIXP_DBL *nrgEst,
-                              SCHAR    *nrgEst_e );
-
-/*static*/ void calcNrgPerSfb(FIXP_DBL  **analysBufferReal,
-                          FIXP_DBL  **analysBufferImag,
-                          int       nSfb,
-                          UCHAR    *freqBandTable,
-                          int       start_pos,  int next_pos,
-                          SCHAR     input_e,
-                          FIXP_DBL *nrg_est,
-                          SCHAR    *nrg_est_e );
-
-/*static*/ void calcSubbandGain(FIXP_DBL  nrgRef, SCHAR nrgRef_e, ENV_CALC_NRGS* nrgs, int c,
-                            FIXP_DBL  tmpNoise, SCHAR tmpNoise_e,
-                            UCHAR     sinePresentFlag,
-                            UCHAR     sineMapped,
-                            int       noNoiseFlag);
-
-/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
-                        int        lowSubband,
-                        int        highSubband,
-                        FIXP_DBL  *sumRef_m,
-                        SCHAR     *sumRef_e,
-                        FIXP_DBL  *ptrAvgGain_m,
-                        SCHAR     *ptrAvgGain_e);
-
-/*static*/ void adjustTimeSlotLC(FIXP_DBL  *ptrReal,
-                           ENV_CALC_NRGS* nrgs,
-                           UCHAR *ptrHarmIndex,
-                           int    lowSubbands,
-                           int    noSubbands,
-                           int    scale_change,
-                           int    noNoiseFlag,
-                           int   *ptrPhaseIndex,
-                           int    fCldfb);
-/*static*/ void adjustTimeSlotHQ(FIXP_DBL  *ptrReal,
-                           FIXP_DBL  *ptrImag,
-                           HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
-                           ENV_CALC_NRGS* nrgs,
-                           int    lowSubbands,
-                           int    noSubbands,
-                           int    scale_change,
-                           FIXP_SGL smooth_ratio,
-                           int    noNoiseFlag,
-                           int    filtBufferNoiseShift);
-
-
-/*!
-  \brief     Map sine flags from bitstream to QMF bands
-
-  The bitstream carries only 1 sine flag per band and frame.
-  This function maps every sine flag from the bitstream to a specific QMF subband
-  and to a specific envelope where the sine shall start.
-  The result is stored in the vector sineMapped which contains one entry per
-  QMF subband. The value of an entry specifies the envelope where a sine
-  shall start. A value of #MAX_ENVELOPES indicates that no sine is present
-  in the subband.
-  The missing harmonics flags from the previous frame (harmFlagsPrev) determine
-  if a sine starts at the beginning of the frame or at the transient position.
-  Additionally, the flags in harmFlagsPrev are being updated by this function
-  for the next frame.
-*/
-/*static*/ void mapSineFlags(UCHAR *freqBandTable, /*!< Band borders (there's only 1 flag per band) */
-                         int nSfb,                     /*!< Number of bands in the table */
-                         UCHAR *addHarmonics,           /*!< vector with 1 flag per sfb */
-                         int *harmFlagsPrev,           /*!< Packed 'addHarmonics' */
-                         int tranEnv,                  /*!< Transient position */
-                         SCHAR *sineMapped)            /*!< Resulting vector of sine start positions for each QMF band */
-
-{
-  int i;
-  int lowSubband2 = freqBandTable[0]<<1;
-  int bitcount = 0;
-  int oldflags = *harmFlagsPrev;
-  int newflags = 0;
-
-  /*
-    Format of harmFlagsPrev:
-
-    first word = flags for highest 16 sfb bands in use
-    second word = flags for next lower 16 sfb bands (if present)
-    third word = flags for lowest 16 sfb bands (if present)
-
-    Up to MAX_FREQ_COEFFS sfb bands can be flagged for a sign.
-    The lowest bit of the first word corresponds to the _highest_ sfb band in use.
-    This is ensures that each flag is  mapped to the same QMF band even after a
-    change of the crossover-frequency.
-  */
-
-
-  /* Reset the output vector first */
-  FDKmemset(sineMapped, MAX_ENVELOPES,MAX_FREQ_COEFFS); /* MAX_ENVELOPES means 'no sine' */
-
-  freqBandTable += nSfb;
-  addHarmonics  += nSfb-1;
-
-  for (i=nSfb; i!=0; i--) {
-    int ui = *freqBandTable--;                 /* Upper limit of the current scale factor band. */
-    int li = *freqBandTable;                   /* Lower limit of the current scale factor band. */
-
-    if ( *addHarmonics-- ) {                   /* There is a sine in this band */
-
-      unsigned int mask = 1 << bitcount;
-      newflags |= mask;                        /* Set flag */
-
-      /*
-        If there was a sine in the last frame, let it continue from the first envelope on
-        else start at the transient position.
-      */
-      sineMapped[(ui+li-lowSubband2) >> 1] = ( oldflags & mask ) ? 0 : tranEnv;
-    }
-
-    if ((++bitcount == 16) || i==1) {
-      bitcount = 0;
-      *harmFlagsPrev++ = newflags;
-      oldflags = *harmFlagsPrev;               /* Fetch 16 of the old flags */
-      newflags = 0;
-    }
-  }
-}
-
-
-/*!
-  \brief     Reduce gain-adjustment induced aliasing for real valued filterbank.
-*/
-/*static*/ void
-aliasingReduction(FIXP_DBL* degreeAlias,       /*!< estimated aliasing for each QMF channel */
-                  ENV_CALC_NRGS* nrgs,
-                  int*      useAliasReduction, /*!< synthetic sine engergy for each subband, used as flag */
-                  int       noSubbands)        /*!< number of QMF channels to process */
-{
-  FIXP_DBL* nrgGain   = nrgs->nrgGain;          /*!< subband gains to be modified */
-  SCHAR*    nrgGain_e = nrgs->nrgGain_e;        /*!< subband gains to be modified (exponents) */
-  FIXP_DBL* nrgEst    = nrgs->nrgEst;           /*!< subband energy before amplification */
-  SCHAR*    nrgEst_e  = nrgs->nrgEst_e;         /*!< subband energy before amplification (exponents) */
-  int grouping = 0, index = 0, noGroups, k;
-  int groupVector[MAX_FREQ_COEFFS];
-
-  /* Calculate grouping*/
-  for (k = 0; k < noSubbands-1; k++ ){
-    if ( (degreeAlias[k + 1] != FL2FXCONST_DBL(0.0f)) && useAliasReduction[k] ) {
-      if(grouping==0){
-        groupVector[index++] = k;
-        grouping = 1;
-      }
-      else{
-        if(groupVector[index-1] + 3 == k){
-          groupVector[index++] = k + 1;
-          grouping = 0;
-        }
-      }
-    }
-    else{
-      if(grouping){
-        if(useAliasReduction[k])
-          groupVector[index++] = k + 1;
-        else
-          groupVector[index++] = k;
-        grouping = 0;
-      }
-    }
-  }
-
-  if(grouping){
-    groupVector[index++] = noSubbands;
-  }
-  noGroups = index >> 1;
-
-
-  /*Calculate new gain*/
-  for (int group = 0; group < noGroups; group ++) {
-    FIXP_DBL nrgOrig = FL2FXCONST_DBL(0.0f);    /* Original signal energy in current group of bands */
-    SCHAR    nrgOrig_e = 0;
-    FIXP_DBL nrgAmp = FL2FXCONST_DBL(0.0f);     /* Amplified signal energy in group (using current gains) */
-    SCHAR    nrgAmp_e = 0;
-    FIXP_DBL nrgMod = FL2FXCONST_DBL(0.0f);   /* Signal energy in group when applying modified gains */
-    SCHAR    nrgMod_e = 0;
-    FIXP_DBL groupGain;         /* Total energy gain in group */
-    SCHAR    groupGain_e;
-    FIXP_DBL compensation;      /* Compensation factor for the energy change when applying modified gains */
-    SCHAR    compensation_e;
-
-    int startGroup = groupVector[2*group];
-    int stopGroup  = groupVector[2*group+1];
-
-    /* Calculate total energy in group before and after amplification with current gains: */
-    for(k = startGroup; k < stopGroup; k++){
-      /* Get original band energy */
-      FIXP_DBL tmp = nrgEst[k];
-      SCHAR    tmp_e = nrgEst_e[k];
-
-      FDK_add_MantExp(tmp, tmp_e, nrgOrig, nrgOrig_e, &nrgOrig, &nrgOrig_e);
-
-      /* Multiply band energy with current gain */
-      tmp = fMult(tmp,nrgGain[k]);
-      tmp_e = tmp_e + nrgGain_e[k];
-
-      FDK_add_MantExp(tmp, tmp_e, nrgAmp, nrgAmp_e, &nrgAmp, &nrgAmp_e);
-    }
-
-    /* Calculate total energy gain in group */
-    FDK_divide_MantExp(nrgAmp, nrgAmp_e,
-                       nrgOrig, nrgOrig_e,
-                       &groupGain, &groupGain_e);
-
-    for(k = startGroup; k < stopGroup; k++){
-      FIXP_DBL tmp;
-      SCHAR    tmp_e;
-
-      FIXP_DBL alpha = degreeAlias[k];
-      if (k < noSubbands - 1) {
-        if (degreeAlias[k + 1] > alpha)
-          alpha = degreeAlias[k + 1];
-      }
-
-      /* Modify gain depending on the degree of aliasing */
-      FDK_add_MantExp( fMult(alpha,groupGain), groupGain_e,
-                       fMult(/*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - alpha,nrgGain[k]), nrgGain_e[k],
-                       &nrgGain[k], &nrgGain_e[k] );
-
-      /* Apply modified gain to original energy */
-      tmp = fMult(nrgGain[k],nrgEst[k]);
-      tmp_e = nrgGain_e[k] + nrgEst_e[k];
-
-      /* Accumulate energy with modified gains applied */
-      FDK_add_MantExp( tmp, tmp_e,
-                       nrgMod, nrgMod_e,
-                       &nrgMod, &nrgMod_e );
-    }
-
-    /* Calculate compensation factor to retain the energy of the amplified signal */
-    FDK_divide_MantExp(nrgAmp, nrgAmp_e,
-                       nrgMod, nrgMod_e,
-                       &compensation, &compensation_e);
-
-    /* Apply compensation factor to all gains of the group */
-    for(k = startGroup; k < stopGroup; k++){
-      nrgGain[k] = fMult(nrgGain[k],compensation);
-      nrgGain_e[k] = nrgGain_e[k] + compensation_e;
-    }
-  }
-}
-
-
- /* Convert headroom bits to exponent */
-#define SCALE2EXP(s) (15-(s))
-#define EXP2SCALE(e) (15-(e))
-
-/*!
-  \brief  Apply spectral envelope to subband samples
-
-  This function is called from sbr_dec.cpp in each frame.
-
-  To enhance accuracy and due to the usage of tables for squareroots and
-  inverse, some calculations are performed with the operands being split
-  into mantissa and exponent. The variable names in the source code carry
-  the suffixes <em>_m</em> and  <em>_e</em> respectively. The control data
-  in #hFrameData containts envelope data which is represented by this format but
-  stored in single words. (See requantizeEnvelopeData() for details). This data
-  is unpacked within calculateSbrEnvelope() to follow the described suffix convention.
-
-  The actual value (comparable to the corresponding float-variable in the
-  research-implementation) of a mantissa/exponent-pair can be calculated as
-
-  \f$ value = value\_m * 2^{value\_e} \f$
-
-  All energies and noise levels decoded from the bitstream suit for an
-  original signal magnitude of \f$\pm 32768 \f$ rather than \f$ \pm 1\f$. Therefore,
-  the scale factor <em>hb_scale</em> passed into this function will be converted
-  to an 'input exponent' (#input_e), which fits the internal representation.
-
-  Before the actual processing, an exponent #adj_e for resulting adjusted
-  samples is derived from the maximum reference energy.
-
-  Then, for each envelope, the following steps are performed:
-
-  \li Calculate energy in the signal to be adjusted. Depending on the the value of
-      #interpolFreq (interpolation mode), this is either done seperately
-      for each QMF-subband or for each SBR-band.
-      The resulting energies are stored in #nrgEst_m[#MAX_FREQ_COEFFS] (mantissas)
-      and #nrgEst_e[#MAX_FREQ_COEFFS] (exponents).
-  \li Calculate gain and noise level for each subband:<br>
-      \f$ gain  = \sqrt{ \frac{nrgRef}{nrgEst} \cdot (1 - noiseRatio) }
-          \hspace{2cm}
-          noise = \sqrt{ nrgRef \cdot noiseRatio }
-      \f$<br>
-      where <em>noiseRatio</em> and <em>nrgRef</em> are extracted from the
-      bitstream and <em>nrgEst</em> is the subband energy before adjustment.
-      The resulting gains are stored in #nrgGain_m[#MAX_FREQ_COEFFS]
-      (mantissas) and #nrgGain_e[#MAX_FREQ_COEFFS] (exponents), the noise levels
-      are stored in #noiseLevel_m[#MAX_FREQ_COEFFS] and #noiseLevel_e[#MAX_FREQ_COEFFS]
-      (exponents).
-      The sine levels are stored in #nrgSine_m[#MAX_FREQ_COEFFS]
-      and #nrgSine_e[#MAX_FREQ_COEFFS].
-  \li Noise limiting: The gain for each subband is limited both absolutely
-      and relatively compared to the total gain over all subbands.
-  \li Boost gain: Calculate and apply boost factor for each limiter band
-      in order to compensate for the energy loss imposed by the limiting.
-  \li Apply gains and add noise: The gains and noise levels are applied
-      to all timeslots of the current envelope. A short FIR-filter (length 4
-      QMF-timeslots) can be used to smooth the sudden change at the envelope borders.
-      Each complex subband sample of the current timeslot is multiplied by the
-      smoothed gain, then random noise with the calculated level is added.
-
-  \note
-  To reduce the stack size, some of the local arrays could be located within
-  the time output buffer. Of the 512 samples temporarily available there,
-  about half the size is already used by #SBR_FRAME_DATA. A pointer to the
-  remaining free memory could be supplied by an additional argument to calculateSbrEnvelope()
-  in sbr_dec:
-
-  \par
-  \code
-    calculateSbrEnvelope (&hSbrDec->sbrScaleFactor,
-                          &hSbrDec->SbrCalculateEnvelope,
-                          hHeaderData,
-                          hFrameData,
-                          QmfBufferReal,
-                          QmfBufferImag,
-                          timeOutPtr + sizeof(SBR_FRAME_DATA)/sizeof(Float) + 1);
-  \endcode
-
-  \par
-  Within calculateSbrEnvelope(), some pointers could be defined instead of the arrays
-  #nrgRef_m, #nrgRef_e, #nrgEst_m, #nrgEst_e, #noiseLevel_m:
-
-  \par
-  \code
-    fract*        nrgRef_m = timeOutPtr;
-    SCHAR*        nrgRef_e = nrgRef_m + MAX_FREQ_COEFFS;
-    fract*        nrgEst_m = nrgRef_e + MAX_FREQ_COEFFS;
-    SCHAR*        nrgEst_e = nrgEst_m + MAX_FREQ_COEFFS;
-    fract*        noiseLevel_m = nrgEst_e + MAX_FREQ_COEFFS;
-  \endcode
-
-  <br>
-*/
-void
-calculateSbrEnvelope (QMF_SCALE_FACTOR  *sbrScaleFactor,           /*!< Scaling factors */
-                      HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env, /*!< Handle to struct filled by the create-function */
-                      HANDLE_SBR_HEADER_DATA hHeaderData,          /*!< Static control data */
-                      HANDLE_SBR_FRAME_DATA  hFrameData,           /*!< Control data of current frame */
-                      FIXP_DBL **analysBufferReal,                 /*!< Real part of subband samples to be processed */
-                      FIXP_DBL **analysBufferImag,                 /*!< Imag part of subband samples to be processed */
-                      const int useLP,
-                      FIXP_DBL *degreeAlias,                       /*!< Estimated aliasing for each QMF channel */
-                      const UINT flags,
-                      const int frameErrorFlag
-                      )
-{
-  int c, i, j, envNoise = 0;
-  UCHAR*   borders = hFrameData->frameInfo.borders;
-
-  FIXP_SGL *noiseLevels       = hFrameData->sbrNoiseFloorLevel;
-  HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
-
-  int lowSubband  = hFreq->lowSubband;
-  int highSubband = hFreq->highSubband;
-  int noSubbands  = highSubband - lowSubband;
-
-  int    noNoiseBands = hFreq->nNfb;
-  int    no_cols      = hHeaderData->numberTimeSlots * hHeaderData->timeStep;
-  UCHAR  first_start  = borders[0] * hHeaderData->timeStep;
-
-  SCHAR  sineMapped[MAX_FREQ_COEFFS];
-  SCHAR  ov_adj_e = SCALE2EXP(sbrScaleFactor->ov_hb_scale);
-  SCHAR  adj_e = 0;
-  SCHAR  output_e;
-  SCHAR  final_e = 0;
-
-  SCHAR  maxGainLimit_e = (frameErrorFlag) ? MAX_GAIN_CONCEAL_EXP : MAX_GAIN_EXP;
-
-  int useAliasReduction[64];
-  UCHAR smooth_length = 0;
-
-  FIXP_SGL * pIenv = hFrameData->iEnvelope;
-
-  /*
-    Extract sine flags for all QMF bands
-  */
-  mapSineFlags(hFreq->freqBandTable[1],
-               hFreq->nSfb[1],
-               hFrameData->addHarmonics,
-               h_sbr_cal_env->harmFlagsPrev,
-               hFrameData->frameInfo.tranEnv,
-               sineMapped);
-
-
-  /*
-    Scan for maximum in bufferd noise levels.
-    This is needed in case that we had strong noise in the previous frame
-    which is smoothed into the current frame.
-    The resulting exponent is used as start value for the maximum search
-    in reference energies
-  */
-  if (!useLP)
-    adj_e = h_sbr_cal_env->filtBufferNoise_e - getScalefactor(h_sbr_cal_env->filtBufferNoise, noSubbands);
-
-  /*
-    Scan for maximum reference energy to be able
-    to select appropriate values for adj_e and final_e.
-  */
-
-  for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
-    INT maxSfbNrg_e = -FRACT_BITS+NRG_EXP_OFFSET; /* start value for maximum search */
-
-    /* Fetch frequency resolution for current envelope: */
-    for (j=hFreq->nSfb[hFrameData->frameInfo.freqRes[i]]; j!=0; j--) {
-      maxSfbNrg_e = fixMax(maxSfbNrg_e,(INT)((LONG)(*pIenv++) & MASK_E));
-    }
-    maxSfbNrg_e -= NRG_EXP_OFFSET;
-
-    /* Energy -> magnitude (sqrt halfens exponent) */
-    maxSfbNrg_e = (maxSfbNrg_e+1) >> 1;  /* +1 to go safe (round to next higher int) */
-
-    /* Some safety margin is needed for 2 reasons:
-       - The signal energy is not equally spread over all subband samples in
-         a specific sfb of an envelope (Nrg could be too high by a factor of
-         envWidth * sfbWidth)
-       - Smoothing can smear high gains of the previous envelope into the current
-    */
-    maxSfbNrg_e += 6;
-
-    if (borders[i] < hHeaderData->numberTimeSlots)
-      /* This envelope affects timeslots that belong to the output frame */
-      adj_e = (maxSfbNrg_e > adj_e) ? maxSfbNrg_e : adj_e;
-
-    if (borders[i+1] > hHeaderData->numberTimeSlots)
-      /* This envelope affects timeslots after the output frame */
-      final_e =  (maxSfbNrg_e > final_e) ? maxSfbNrg_e : final_e;
-
-  }
-
-  /*
-    Calculate adjustment factors and apply them for every envelope.
-  */
-  pIenv = hFrameData->iEnvelope;
-
-  for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
-
-    int k, noNoiseFlag;
-    SCHAR  noise_e, input_e = SCALE2EXP(sbrScaleFactor->hb_scale);
-    C_ALLOC_SCRATCH_START(pNrgs, ENV_CALC_NRGS, 1);
-
-    /*
-      Helper variables.
-    */
-    UCHAR start_pos = hHeaderData->timeStep * borders[i];  /* Start-position in time (subband sample) for current envelope. */
-    UCHAR stop_pos = hHeaderData->timeStep * borders[i+1]; /* Stop-position in time (subband sample) for current envelope. */
-    UCHAR freq_res = hFrameData->frameInfo.freqRes[i];     /* Frequency resolution for current envelope. */
-
-
-    /* Always do fully initialize the temporary energy table. This prevents negative energies and extreme gain factors in
-       cases where the number of limiter bands exceeds the number of subbands. The latter can be caused by undetected bit
-       errors and is tested by some streams from the certification set. */
-    FDKmemclear(pNrgs, sizeof(ENV_CALC_NRGS));
-
-    /* If the start-pos of the current envelope equals the stop pos of the current
-       noise envelope, increase the pointer (i.e. choose the next noise-floor).*/
-    if (borders[i] == hFrameData->frameInfo.bordersNoise[envNoise+1]){
-      noiseLevels += noNoiseBands;   /* The noise floor data is stored in a row [noiseFloor1 noiseFloor2...].*/
-      envNoise++;
-    }
-
-    if(i==hFrameData->frameInfo.tranEnv || i==h_sbr_cal_env->prevTranEnv) /* attack */
-    {
-      noNoiseFlag = 1;
-      if (!useLP)
-        smooth_length = 0;  /* No smoothing on attacks! */
-    }
-    else {
-      noNoiseFlag = 0;
-      if (!useLP)
-        smooth_length = (1 - hHeaderData->bs_data.smoothingLength) << 2;  /* can become either 0 or 4 */
-    }
-
-
-    /*
-      Energy estimation in transposed highband.
-    */
-    if (hHeaderData->bs_data.interpolFreq)
-      calcNrgPerSubband(analysBufferReal,
-                        (useLP) ? NULL : analysBufferImag,
-                        lowSubband, highSubband,
-                        start_pos, stop_pos,
-                        input_e,
-                        pNrgs->nrgEst,
-                        pNrgs->nrgEst_e);
-    else
-      calcNrgPerSfb(analysBufferReal,
-                    (useLP) ? NULL : analysBufferImag,
-                    hFreq->nSfb[freq_res],
-                    hFreq->freqBandTable[freq_res],
-                    start_pos, stop_pos,
-                    input_e,
-                    pNrgs->nrgEst,
-                    pNrgs->nrgEst_e);
-
-    /*
-      Calculate subband gains
-    */
-    {
-      UCHAR * table = hFreq->freqBandTable[freq_res];
-      UCHAR * pUiNoise = &hFreq->freqBandTableNoise[1]; /*! Upper limit of the current noise floor band. */
-
-      FIXP_SGL * pNoiseLevels = noiseLevels;
-
-      FIXP_DBL tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
-      SCHAR    tmpNoise_e = (UCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
-
-      int cc = 0;
-      c = 0;
-      for (j = 0; j < hFreq->nSfb[freq_res]; j++) {
-
-        FIXP_DBL refNrg   = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pIenv) & MASK_M));
-        SCHAR    refNrg_e = (SCHAR)((LONG)(*pIenv) & MASK_E) - NRG_EXP_OFFSET;
-
-        UCHAR sinePresentFlag = 0;
-        int li = table[j];
-        int ui = table[j+1];
-
-        for (k=li; k<ui; k++) {
-          sinePresentFlag |= (i >= sineMapped[cc]);
-          cc++;
-        }
-
-        for (k=li; k<ui; k++) {
-          if (k >= *pUiNoise) {
-            tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
-            tmpNoise_e = (SCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
-
-            pUiNoise++;
-          }
-
-          FDK_ASSERT(k >= lowSubband);
-
-          if (useLP)
-            useAliasReduction[k-lowSubband] = !sinePresentFlag;
-
-          pNrgs->nrgSine[c] = FL2FXCONST_DBL(0.0f);
-          pNrgs->nrgSine_e[c] = 0;
-
-          calcSubbandGain(refNrg, refNrg_e, pNrgs, c,
-                          tmpNoise, tmpNoise_e,
-                          sinePresentFlag, i >= sineMapped[c],
-                          noNoiseFlag);
-
-          pNrgs->nrgRef[c]   = refNrg;
-          pNrgs->nrgRef_e[c] = refNrg_e;
-
-          c++;
-        }
-        pIenv++;
-      }
-    }
-
-    /*
-      Noise limiting
-    */
-
-    for (c = 0; c < hFreq->noLimiterBands; c++) {
-
-      FIXP_DBL sumRef, boostGain, maxGain;
-      FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
-      SCHAR   sumRef_e, boostGain_e, maxGain_e, accu_e = 0;
-
-      calcAvgGain(pNrgs,
-                  hFreq->limiterBandTable[c], hFreq->limiterBandTable[c+1],
-                  &sumRef, &sumRef_e,
-                  &maxGain, &maxGain_e);
-
-      /* Multiply maxGain with limiterGain: */
-      maxGain = fMult(maxGain, FDK_sbrDecoder_sbr_limGains_m[hHeaderData->bs_data.limiterGains]);
-      maxGain_e += FDK_sbrDecoder_sbr_limGains_e[hHeaderData->bs_data.limiterGains];
-
-      /* Scale mantissa of MaxGain into range between 0.5 and 1: */
-      if (maxGain == FL2FXCONST_DBL(0.0f))
-        maxGain_e = -FRACT_BITS;
-      else {
-        SCHAR charTemp = CountLeadingBits(maxGain);
-        maxGain_e -= charTemp;
-        maxGain  <<= (int)charTemp;
-      }
-
-      if (maxGain_e >= maxGainLimit_e) { /* upper limit (e.g. 96 dB) */
-        maxGain = FL2FXCONST_DBL(0.5f);
-        maxGain_e = maxGainLimit_e;
-      }
-
-
-      /* Every subband gain is compared to the scaled "average gain"
-         and limited if necessary: */
-      for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c+1]; k++) {
-        if ( (pNrgs->nrgGain_e[k] > maxGain_e) || (pNrgs->nrgGain_e[k] == maxGain_e && pNrgs->nrgGain[k]>maxGain) ) {
-
-          FIXP_DBL noiseAmp;
-          SCHAR    noiseAmp_e;
-
-          FDK_divide_MantExp(maxGain, maxGain_e, pNrgs->nrgGain[k], pNrgs->nrgGain_e[k], &noiseAmp, &noiseAmp_e);
-          pNrgs->noiseLevel[k]    = fMult(pNrgs->noiseLevel[k],noiseAmp);
-          pNrgs->noiseLevel_e[k] += noiseAmp_e;
-          pNrgs->nrgGain[k]       = maxGain;
-          pNrgs->nrgGain_e[k]     = maxGain_e;
-        }
-      }
-
-      /* -- Boost gain
-        Calculate and apply boost factor for each limiter band:
-        1. Check how much energy would be present when using the limited gain
-        2. Calculate boost factor by comparison with reference energy
-        3. Apply boost factor to compensate for the energy loss due to limiting
-      */
-      for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
-
-        /* 1.a  Add energy of adjusted signal (using preliminary gain) */
-        FIXP_DBL  tmp   = fMult(pNrgs->nrgGain[k],pNrgs->nrgEst[k]);
-        SCHAR     tmp_e = pNrgs->nrgGain_e[k] + pNrgs->nrgEst_e[k];
-        FDK_add_MantExp(tmp, tmp_e, accu, accu_e, &accu, &accu_e);
-
-        /* 1.b  Add sine energy (if present) */
-        if(pNrgs->nrgSine[k] != FL2FXCONST_DBL(0.0f)) {
-          FDK_add_MantExp(pNrgs->nrgSine[k], pNrgs->nrgSine_e[k], accu, accu_e, &accu, &accu_e);
-        }
-        else {
-          /* 1.c  Add noise energy (if present) */
-          if(noNoiseFlag == 0) {
-            FDK_add_MantExp(pNrgs->noiseLevel[k], pNrgs->noiseLevel_e[k], accu, accu_e, &accu, &accu_e);
-          }
-        }
-      }
-
-      /* 2.a  Calculate ratio of wanted energy and accumulated energy */
-      if (accu == (FIXP_DBL)0) { /* If divisor is 0, limit quotient to +4 dB */
-        boostGain = FL2FXCONST_DBL(0.6279716f);
-        boostGain_e = 2;
-      } else {
-        INT div_e;
-        boostGain = fDivNorm(sumRef, accu, &div_e);
-        boostGain_e = sumRef_e - accu_e + div_e;
-      }
-
-
-      /* 2.b Result too high? --> Limit the boost factor to +4 dB */
-      if((boostGain_e  > 3) ||
-         (boostGain_e == 2 && boostGain > FL2FXCONST_DBL(0.6279716f)) ||
-         (boostGain_e == 3 && boostGain > FL2FXCONST_DBL(0.3139858f)) )
-      {
-        boostGain = FL2FXCONST_DBL(0.6279716f);
-        boostGain_e = 2;
-      }
-      /* 3.  Multiply all signal components with the boost factor */
-      for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
-        pNrgs->nrgGain[k]   = fMultDiv2(pNrgs->nrgGain[k],boostGain);
-        pNrgs->nrgGain_e[k] = pNrgs->nrgGain_e[k] + boostGain_e + 1;
-
-        pNrgs->nrgSine[k]   = fMultDiv2(pNrgs->nrgSine[k],boostGain);
-        pNrgs->nrgSine_e[k] = pNrgs->nrgSine_e[k] + boostGain_e + 1;
-
-        pNrgs->noiseLevel[k]   = fMultDiv2(pNrgs->noiseLevel[k],boostGain);
-        pNrgs->noiseLevel_e[k] = pNrgs->noiseLevel_e[k] + boostGain_e + 1;
-      }
-    }
-    /* End of noise limiting */
-
-    if (useLP)
-      aliasingReduction(degreeAlias+lowSubband,
-                        pNrgs,
-                        useAliasReduction,
-                        noSubbands);
-
-    /* For the timeslots within the range for the output frame,
-       use the same scale for the noise levels.
-       Drawback: If the envelope exceeds the frame border, the noise levels
-                 will have to be rescaled later to fit final_e of
-                 the gain-values.
-    */
-    noise_e = (start_pos < no_cols) ? adj_e : final_e;
-
-    /*
-      Convert energies to amplitude levels
-    */
-    for (k=0; k<noSubbands; k++) {
-      FDK_sqrt_MantExp(&pNrgs->nrgSine[k],    &pNrgs->nrgSine_e[k],    &noise_e);
-      FDK_sqrt_MantExp(&pNrgs->nrgGain[k],    &pNrgs->nrgGain_e[k],    &pNrgs->nrgGain_e[k]);
-      FDK_sqrt_MantExp(&pNrgs->noiseLevel[k], &pNrgs->noiseLevel_e[k], &noise_e);
-    }
-
-
-
-    /*
-      Apply calculated gains and adaptive noise
-    */
-
-    /* assembleHfSignals() */
-    {
-      int scale_change, sc_change;
-      FIXP_SGL smooth_ratio;
-      int filtBufferNoiseShift=0;
-
-      /* Initialize smoothing buffers with the first valid values */
-      if (h_sbr_cal_env->startUp)
-      {
-        if (!useLP) {
-          h_sbr_cal_env->filtBufferNoise_e = noise_e;
-
-          FDKmemcpy(h_sbr_cal_env->filtBuffer_e,    pNrgs->nrgGain_e,  noSubbands*sizeof(SCHAR));
-          FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
-          FDKmemcpy(h_sbr_cal_env->filtBuffer,      pNrgs->nrgGain,    noSubbands*sizeof(FIXP_DBL));
-
-        }
-        h_sbr_cal_env->startUp = 0;
-      }
-
-      if (!useLP) {
-
-        equalizeFiltBufferExp(h_sbr_cal_env->filtBuffer,    /* buffered */
-                              h_sbr_cal_env->filtBuffer_e,  /* buffered */
-                              pNrgs->nrgGain,               /* current  */
-                              pNrgs->nrgGain_e,             /* current  */
-                              noSubbands);
-
-        /* Adapt exponent of buffered noise levels to the current exponent
-           so they can easily be smoothed */
-        if((h_sbr_cal_env->filtBufferNoise_e - noise_e)>=0) {
-          int shift = fixMin(DFRACT_BITS-1,(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
-          for (k=0; k<noSubbands; k++)
-            h_sbr_cal_env->filtBufferNoise[k] <<= shift;
-        }
-        else {
-          int shift = fixMin(DFRACT_BITS-1,-(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
-          for (k=0; k<noSubbands; k++)
-            h_sbr_cal_env->filtBufferNoise[k] >>= shift;
-        }
-
-        h_sbr_cal_env->filtBufferNoise_e = noise_e;
-      }
-
-      /* find best scaling! */
-      scale_change = -(DFRACT_BITS-1);
-      for(k=0;k<noSubbands;k++) {
-          scale_change = fixMax(scale_change,(int)pNrgs->nrgGain_e[k]);
-      }
-      sc_change = (start_pos<no_cols)? adj_e - input_e : final_e - input_e;
-
-      if ((scale_change-sc_change+1)<0)
-          scale_change-=(scale_change-sc_change+1);
-
-      scale_change = (scale_change-sc_change)+1;
-
-      for(k=0;k<noSubbands;k++) {
-          int sc = scale_change-pNrgs->nrgGain_e[k] + (sc_change-1);
-          pNrgs->nrgGain[k]  >>= sc;
-          pNrgs->nrgGain_e[k] += sc;
-      }
-
-      if (!useLP) {
-        for(k=0;k<noSubbands;k++) {
-          int sc = scale_change-h_sbr_cal_env->filtBuffer_e[k] + (sc_change-1);
-          h_sbr_cal_env->filtBuffer[k] >>= sc;
-        }
-      }
-
-      for (j = start_pos; j < stop_pos; j++)
-      {
-        /* This timeslot is located within the first part of the processing buffer
-           and will be fed into the QMF-synthesis for the current frame.
-               adj_e - input_e
-           This timeslot will not yet be fed into the QMF so we do not care
-           about the adj_e.
-               sc_change = final_e - input_e
-        */
-        if ( (j==no_cols) && (start_pos<no_cols) )
-        {
-          int shift = (int) (noise_e - final_e);
-          if (!useLP)
-            filtBufferNoiseShift = shift;               /* shifting of h_sbr_cal_env->filtBufferNoise[k] will be applied in function adjustTimeSlotHQ() */
-          if (shift>=0) {
-            shift = fixMin(DFRACT_BITS-1,shift);
-            for (k=0; k<noSubbands; k++) {
-              pNrgs->nrgSine[k] <<= shift;
-              pNrgs->noiseLevel[k]  <<= shift;
-              /*
-              if (!useLP)
-                h_sbr_cal_env->filtBufferNoise[k]  <<= shift;
-              */
-            }
-          }
-          else {
-            shift = fixMin(DFRACT_BITS-1,-shift);
-            for (k=0; k<noSubbands; k++) {
-              pNrgs->nrgSine[k] >>= shift;
-              pNrgs->noiseLevel[k]  >>= shift;
-              /*
-              if (!useLP)
-                h_sbr_cal_env->filtBufferNoise[k]  >>= shift;
-              */
-            }
-          }
-
-          /* update noise scaling */
-          noise_e = final_e;
-          if (!useLP)
-            h_sbr_cal_env->filtBufferNoise_e = noise_e;  /* scaling value unused! */
-
-          /* update gain buffer*/
-          sc_change -= (final_e - input_e);
-
-          if (sc_change<0) {
-            for(k=0;k<noSubbands;k++) {
-                pNrgs->nrgGain[k]  >>= -sc_change;
-                pNrgs->nrgGain_e[k] += -sc_change;
-            }
-            if (!useLP) {
-              for(k=0;k<noSubbands;k++) {
-                    h_sbr_cal_env->filtBuffer[k] >>= -sc_change;
-              }
-            }
-          } else {
-            scale_change+=sc_change;
-          }
-
-        } // if
-
-        if (!useLP) {
-
-          /* Prevent the smoothing filter from running on constant levels */
-          if (j-start_pos < smooth_length)
-            smooth_ratio = FDK_sbrDecoder_sbr_smoothFilter[j-start_pos];
-
-          else
-            smooth_ratio = FL2FXCONST_SGL(0.0f);
-
-          adjustTimeSlotHQ(&analysBufferReal[j][lowSubband],
-                           &analysBufferImag[j][lowSubband],
-                           h_sbr_cal_env,
-                           pNrgs,
-                           lowSubband,
-                           noSubbands,
-                           scale_change,
-                           smooth_ratio,
-                           noNoiseFlag,
-                           filtBufferNoiseShift);
-        }
-        else
-        {
-          adjustTimeSlotLC(&analysBufferReal[j][lowSubband],
-                           pNrgs,
-                          &h_sbr_cal_env->harmIndex,
-                           lowSubband,
-                           noSubbands,
-                           scale_change,
-                           noNoiseFlag,
-                          &h_sbr_cal_env->phaseIndex,
-                           (flags & SBRDEC_ELD_GRID));
-        }
-      } // for
-
-      if (!useLP) {
-        /* Update time-smoothing-buffers for gains and noise levels
-           The gains and the noise values of the current envelope are copied into the buffer.
-           This has to be done at the end of each envelope as the values are required for
-           a smooth transition to the next envelope. */
-        FDKmemcpy(h_sbr_cal_env->filtBuffer,      pNrgs->nrgGain,    noSubbands*sizeof(FIXP_DBL));
-        FDKmemcpy(h_sbr_cal_env->filtBuffer_e,    pNrgs->nrgGain_e,  noSubbands*sizeof(SCHAR));
-        FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
-      }
-
-    }
-    C_ALLOC_SCRATCH_END(pNrgs, ENV_CALC_NRGS, 1);
-  }
-
-  /* Rescale output samples */
-  {
-    FIXP_DBL maxVal;
-    int ov_reserve, reserve;
-
-    /* Determine headroom in old adjusted samples */
-    maxVal = maxSubbandSample( analysBufferReal,
-                              (useLP) ? NULL : analysBufferImag,
-                               lowSubband,
-                               highSubband,
-                               0,
-                               first_start);
-
-    ov_reserve = fNorm(maxVal);
-
-    /* Determine headroom in new adjusted samples */
-    maxVal = maxSubbandSample( analysBufferReal,
-                               (useLP) ? NULL : analysBufferImag,
-                               lowSubband,
-                               highSubband,
-                               first_start,
-                               no_cols);
-
-    reserve = fNorm(maxVal);
-
-    /* Determine common output exponent */
-    if (ov_adj_e - ov_reserve  >  adj_e - reserve ) /* set output_e to the maximum */
-      output_e = ov_adj_e - ov_reserve;
-    else
-      output_e = adj_e - reserve;
-
-    /* Rescale old samples */
-    rescaleSubbandSamples( analysBufferReal,
-                           (useLP) ? NULL : analysBufferImag,
-                           lowSubband, highSubband,
-                           0, first_start,
-                           ov_adj_e - output_e);
-
-    /* Rescale new samples */
-    rescaleSubbandSamples( analysBufferReal,
-                           (useLP) ? NULL : analysBufferImag,
-                           lowSubband, highSubband,
-                           first_start, no_cols,
-                           adj_e - output_e);
-  }
-
-  /* Update hb_scale */
-  sbrScaleFactor->hb_scale = EXP2SCALE(output_e);
-
-  /* Save the current final exponent for the next frame: */
-  sbrScaleFactor->ov_hb_scale = EXP2SCALE(final_e);
-
-
-  /* We need to remeber to the next frame that the transient
-     will occur in the first envelope (if tranEnv == nEnvelopes). */
-  if(hFrameData->frameInfo.tranEnv == hFrameData->frameInfo.nEnvelopes)
-    h_sbr_cal_env->prevTranEnv = 0;
-  else
-    h_sbr_cal_env->prevTranEnv = -1;
-
-}
-
-
-/*!
-  \brief   Create envelope instance
-
-  Must be called once for each channel before calculateSbrEnvelope() can be used.
-
-  \return  errorCode, 0 if successful
-*/
-SBR_ERROR
-createSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs,   /*!< pointer to envelope instance */
-                       HANDLE_SBR_HEADER_DATA hHeaderData, /*!< static SBR control data, initialized with defaults */
-                       const int chan,                     /*!< Channel for which to assign buffers */
-                       const UINT flags)
-{
-  SBR_ERROR err = SBRDEC_OK;
-  int i;
-
-  /* Clear previous missing harmonics flags */
-  for (i=0; i<(MAX_FREQ_COEFFS+15)>>4; i++) {
-    hs->harmFlagsPrev[i] = 0;
-  }
-  hs->harmIndex = 0;
-
-  /*
-    Setup pointers for time smoothing.
-    The buffer itself will be initialized later triggered by the startUp-flag.
-  */
-  hs->prevTranEnv = -1;
-
-
-  /* initialization */
-  resetSbrEnvelopeCalc(hs);
-
-  if (chan==0) { /* do this only once */
-    err = resetFreqBandTables(hHeaderData, flags);
-  }
-
-  return err;
-}
-
-/*!
-  \brief   Create envelope instance
-
-  Must be called once for each channel before calculateSbrEnvelope() can be used.
-
-  \return  errorCode, 0 if successful
-*/
-int
-deleteSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs)
-{
-  return 0;
-}
-
-
-/*!
-  \brief   Reset envelope instance
-
-  This function must be called for each channel on a change of configuration.
-  Note that resetFreqBandTables should also be called in this case.
-
-  \return  errorCode, 0 if successful
-*/
-void
-resetSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hCalEnv) /*!< pointer to envelope instance */
-{
-  hCalEnv->phaseIndex = 0;
-
-  /* Noise exponent needs to be reset because the output exponent for the next frame depends on it */
-  hCalEnv->filtBufferNoise_e = 0;
-
-  hCalEnv->startUp = 1;
-}
-
-
-/*!
-  \brief  Equalize exponents of the buffered gain values and the new ones
-
-  After equalization of exponents, the FIR-filter addition for smoothing
-  can be performed.
-  This function is called once for each envelope before adjusting.
-*/
-/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer,     /*!< bufferd gains */
-                                  SCHAR    *filtBuffer_e,   /*!< exponents of bufferd gains */
-                                  FIXP_DBL *nrgGain,        /*!< gains for current envelope */
-                                  SCHAR    *nrgGain_e,      /*!< exponents of gains for current envelope */
-                                  int       subbands)       /*!< Number of QMF subbands */
-{
-  int   band;
-  int  diff;
-
-  for (band=0; band<subbands; band++){
-    diff = (int) (nrgGain_e[band] - filtBuffer_e[band]);
-    if (diff>0) {
-      filtBuffer[band] >>= diff;   /* Compensate for the scale change by shifting the mantissa. */
-      filtBuffer_e[band] += diff;  /* New gain is bigger, use its exponent */
-    }
-    else if (diff<0) {
-      /* The buffered gains seem to be larger, but maybe there
-         are some unused bits left in the mantissa */
-
-      int reserve = CntLeadingZeros(fixp_abs(filtBuffer[band]))-1;
-
-      if ((-diff) <= reserve) {
-        /* There is enough space in the buffered mantissa so
-           that we can take the new exponent as common.
-        */
-        filtBuffer[band] <<= (-diff);
-        filtBuffer_e[band] += diff;  /* becomes equal to *ptrNewExp */
-      }
-      else {
-        filtBuffer[band] <<= reserve;   /* Shift the mantissa as far as possible: */
-        filtBuffer_e[band] -= reserve;  /* Compensate in the exponent: */
-
-        /* For the remaining difference, change the new gain value */
-        diff = fixMin(-(reserve + diff),DFRACT_BITS-1);
-        nrgGain[band] >>= diff;
-        nrgGain_e[band] += diff;
-      }
-    }
-  }
-}
-
-/*!
-  \brief  Shift left the mantissas of all subband samples
-          in the giventime and frequency range by the specified number of bits.
-
-  This function is used to rescale the audio data in the overlap buffer
-  which has already been envelope adjusted with the last frame.
-*/
-void rescaleSubbandSamples(FIXP_DBL ** re,   /*!< Real part of input and output subband samples */
-                           FIXP_DBL ** im,   /*!< Imaginary part of input and output subband samples */
-                           int lowSubband,   /*!< Begin of frequency range to process */
-                           int highSubband,  /*!< End of frequency range to process */
-                           int start_pos,    /*!< Begin of time rage (QMF-timeslot) */
-                           int next_pos,     /*!< End of time rage (QMF-timeslot) */
-                           int shift)        /*!< number of bits to shift */
-{
-  int width = highSubband-lowSubband;
-
-  if ( (width > 0) && (shift!=0) ) {
-    if (im!=NULL) {
-      for (int l=start_pos; l<next_pos; l++) {
-          scaleValues(&re[l][lowSubband], width, shift);
-          scaleValues(&im[l][lowSubband], width, shift);
-      }
-    } else
-    {
-      for (int l=start_pos; l<next_pos; l++) {
-          scaleValues(&re[l][lowSubband], width, shift);
-      }
-    }
-  }
-}
-
-
-/*!
-  \brief   Determine headroom for shifting
-
-  Determine by how much the spectrum can be shifted left
-  for better accuracy in later processing.
-
-  \return  Number of free bits in the biggest spectral value
-*/
-
-FIXP_DBL maxSubbandSample( FIXP_DBL ** re,   /*!< Real part of input and output subband samples */
-                           FIXP_DBL ** im,   /*!< Real part of input and output subband samples */
-                           int lowSubband,   /*!< Begin of frequency range to process */
-                           int highSubband,  /*!< Number of QMF bands to process */
-                           int start_pos,    /*!< Begin of time rage (QMF-timeslot) */
-                           int next_pos      /*!< End of time rage (QMF-timeslot) */
-                          )
-{
-  FIXP_DBL maxVal = FL2FX_DBL(0.0f);
-  unsigned int width = highSubband - lowSubband;
-
-  FDK_ASSERT(width <= (64));
-
-  if ( width > 0 ) {
-    if (im!=NULL) 
-    {
-      for (int l=start_pos; l<next_pos; l++) 
-      {
-#ifdef FUNCTION_FDK_get_maxval
-        maxVal = FDK_get_maxval(maxVal, &re[l][lowSubband], &im[l][lowSubband], width);
-#else
-        int k=width;
-        FIXP_DBL *reTmp = &re[l][lowSubband];
-        FIXP_DBL *imTmp = &im[l][lowSubband];
-        do{
-          FIXP_DBL tmp1 = *(reTmp++);
-          FIXP_DBL tmp2 = *(imTmp++);
-          maxVal |= (FIXP_DBL)((LONG)(tmp1)^((LONG)tmp1>>(DFRACT_BITS-1)));
-          maxVal |= (FIXP_DBL)((LONG)(tmp2)^((LONG)tmp2>>(DFRACT_BITS-1)));
-        } while(--k!=0);
-#endif
-      }
-    } else
-    {
-      for (int l=start_pos; l<next_pos; l++) {
-        int k=width;
-        FIXP_DBL *reTmp = &re[l][lowSubband];
-        do{
-          FIXP_DBL tmp = *(reTmp++);
-          maxVal |= (FIXP_DBL)((LONG)(tmp)^((LONG)tmp>>(DFRACT_BITS-1)));
-        }while(--k!=0);
-      }
-    }
-  }
-
-  return(maxVal);
-}
-
-#define SHIFT_BEFORE_SQUARE (3) /* (7/2) */
-/*!<
-  If the accumulator does not provide enough overflow bits or
-  does not provide a high dynamic range, the below energy calculation
-  requires an additional shift operation for each sample.
-  On the other hand, doing the shift allows using a single-precision
-  multiplication for the square (at least 16bit x 16bit).
-  For even values of OVRFLW_BITS (0, 2, 4, 6), saturated arithmetic
-  is required for the energy accumulation.
-  Theoretically, the sample-squares can sum up to a value of 76,
-  requiring 7 overflow bits. However since such situations are *very*
-  rare, accu can be limited to 64.
-  In case native saturated arithmetic is not available, overflows
-  can be prevented by replacing the above #define by
-    #define SHIFT_BEFORE_SQUARE ((8 - OVRFLW_BITS) / 2)
-  which will result in slightly reduced accuracy.
-*/
-
-/*!
-  \brief  Estimates the mean energy of each filter-bank channel for the
-          duration of the current envelope
-
-  This function is used when interpolFreq is true.
-*/
-/*static*/ void calcNrgPerSubband(FIXP_DBL  **analysBufferReal, /*!< Real part of subband samples */
-                              FIXP_DBL  **analysBufferImag, /*!< Imaginary part of subband samples */
-                              int       lowSubband,           /*!< Begin of the SBR frequency range */
-                              int       highSubband,          /*!< High end of the SBR frequency range */
-                              int       start_pos,            /*!< First QMF-slot of current envelope */
-                              int       next_pos,             /*!< Last QMF-slot of current envelope + 1 */
-                              SCHAR     frameExp,             /*!< Common exponent for all input samples */
-                              FIXP_DBL *nrgEst,               /*!< resulting Energy (0..1) */
-                              SCHAR    *nrgEst_e )            /*!< Exponent of resulting Energy */
-{
-  FIXP_SGL invWidth;
-  SCHAR  preShift;
-  SCHAR  shift;
-  FIXP_DBL sum;
-  int k,l;
-
-  /* Divide by width of envelope later: */
-  invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
-  /* The common exponent needs to be doubled because all mantissas are squared: */
-  frameExp = frameExp << 1;
-
-  for (k=lowSubband; k<highSubband; k++) {
-    FIXP_DBL  bufferReal[(((1024)/(32))+(6))];
-    FIXP_DBL  bufferImag[(((1024)/(32))+(6))];
-    FIXP_DBL maxVal = FL2FX_DBL(0.0f);
-
-    if (analysBufferImag!=NULL)
-    {
-      for (l=start_pos;l<next_pos;l++) 
-      {
-        bufferImag[l] = analysBufferImag[l][k];
-        maxVal |= (FIXP_DBL)((LONG)(bufferImag[l])^((LONG)bufferImag[l]>>(DFRACT_BITS-1)));
-        bufferReal[l] = analysBufferReal[l][k];
-        maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
-      }
-    }
-    else
-    {
-      for (l=start_pos;l<next_pos;l++)
-      {
-        bufferReal[l] = analysBufferReal[l][k];
-        maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
-      }
-    }
-
-    if (maxVal!=FL2FXCONST_DBL(0.f)) {
-
-
-      /* If the accu does not provide enough overflow bits, we cannot
-         shift the samples up to the limit.
-         Instead, keep up to 3 free bits in each sample, i.e. up to
-         6 bits after calculation of square.
-         Please note the comment on saturated arithmetic above!
-      */
-      FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
-      preShift = CntLeadingZeros(maxVal)-1;
-      preShift -= SHIFT_BEFORE_SQUARE;
-
-      if (preShift>=0) {
-        if (analysBufferImag!=NULL) {
-          for (l=start_pos; l<next_pos; l++) {
-            FIXP_DBL temp1 = bufferReal[l] << (int)preShift;
-            FIXP_DBL temp2 = bufferImag[l] << (int)preShift;
-            accu = fPow2AddDiv2(accu, temp1);
-            accu = fPow2AddDiv2(accu, temp2);
-          }
-        } else
-        {
-          for (l=start_pos; l<next_pos; l++) {
-            FIXP_DBL temp = bufferReal[l] << (int)preShift;
-            accu = fPow2AddDiv2(accu, temp);
-          }
-        }
-      }
-      else {    /* if negative shift value */
-        int negpreShift = -preShift;
-        if (analysBufferImag!=NULL) {
-          for (l=start_pos; l<next_pos; l++) {
-            FIXP_DBL temp1 = bufferReal[l] >> (int)negpreShift;
-            FIXP_DBL temp2 = bufferImag[l] >> (int)negpreShift;
-            accu = fPow2AddDiv2(accu, temp1);
-            accu = fPow2AddDiv2(accu, temp2);
-          }
-        } else
-        {
-          for (l=start_pos; l<next_pos; l++) {
-            FIXP_DBL temp = bufferReal[l] >> (int)negpreShift;
-            accu = fPow2AddDiv2(accu, temp);
-          }
-        }
-      }
-      accu <<= 1;
-
-      /* Convert double precision to Mantissa/Exponent: */
-      shift = fNorm(accu);
-      sum = accu << (int)shift;
-
-      /* Divide by width of envelope and apply frame scale: */
-      *nrgEst++ = fMult(sum, invWidth);
-      shift += 2 * preShift;
-      if (analysBufferImag!=NULL)
-        *nrgEst_e++ = frameExp - shift;
-      else
-        *nrgEst_e++ = frameExp - shift + 1;  /* +1 due to missing imag. part */
-    } /* maxVal!=0 */
-    else {
-
-      /* Prevent a zero-mantissa-number from being misinterpreted
-         due to its exponent. */
-      *nrgEst++ = FL2FXCONST_DBL(0.0f);
-      *nrgEst_e++ = 0;
-    }
-  }
-}
-
-/*!
-  \brief   Estimates the mean energy of each Scale factor band for the
-           duration of the current envelope.
-
-  This function is used when interpolFreq is false.
-*/
-/*static*/ void calcNrgPerSfb(FIXP_DBL  **analysBufferReal,  /*!< Real part of subband samples */
-                          FIXP_DBL  **analysBufferImag,  /*!< Imaginary part of subband samples */
-                          int       nSfb,                /*!< Number of scale factor bands */
-                          UCHAR    *freqBandTable,       /*!< First Subband for each Sfb */
-                          int       start_pos,           /*!< First QMF-slot of current envelope */
-                          int       next_pos,            /*!< Last QMF-slot of current envelope + 1 */
-                          SCHAR     input_e,             /*!< Common exponent for all input samples */
-                          FIXP_DBL *nrgEst,              /*!< resulting Energy (0..1) */
-                          SCHAR    *nrgEst_e )           /*!< Exponent of resulting Energy */
-{
-  FIXP_SGL  invWidth;
-  FIXP_DBL  temp;
-  SCHAR  preShift;
-  SCHAR   shift, sum_e;
-  FIXP_DBL  sum;
-
-  int j,k,l,li,ui;
-  FIXP_DBL sumAll, sumLine; /* Single precision would be sufficient,
-                             but overflow bits are required for accumulation */
-
-  /* Divide by width of envelope later: */
-  invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
-  /* The common exponent needs to be doubled because all mantissas are squared: */
-  input_e = input_e << 1;
-
-  for(j=0; j<nSfb; j++) {
-    li = freqBandTable[j];
-    ui = freqBandTable[j+1];
-
-    FIXP_DBL maxVal = maxSubbandSample( analysBufferReal,
-                                        analysBufferImag,
-                                        li,
-                                        ui,
-                                        start_pos,
-                                        next_pos );
-
-    if (maxVal!=FL2FXCONST_DBL(0.f)) {
-
-      preShift = CntLeadingZeros(maxVal)-1;
-
-      /* If the accu does not provide enough overflow bits, we cannot
-         shift the samples up to the limit.
-         Instead, keep up to 3 free bits in each sample, i.e. up to
-         6 bits after calculation of square.
-         Please note the comment on saturated arithmetic above!
-      */
-      preShift -= SHIFT_BEFORE_SQUARE;
-
-      sumAll = FL2FXCONST_DBL(0.0f);
-
-
-      for (k=li; k<ui; k++) {
-
-        sumLine = FL2FXCONST_DBL(0.0f);
-
-        if (analysBufferImag!=NULL) {
-          if (preShift>=0) {
-            for (l=start_pos; l<next_pos; l++) {
-              temp   = analysBufferReal[l][k] << (int)preShift;
-              sumLine += fPow2Div2(temp);
-              temp   = analysBufferImag[l][k] << (int)preShift;
-              sumLine += fPow2Div2(temp);
-
-            }
-          } else {
-            for (l=start_pos; l<next_pos; l++) {
-              temp   = analysBufferReal[l][k] >> -(int)preShift;
-              sumLine += fPow2Div2(temp);
-              temp   = analysBufferImag[l][k] >> -(int)preShift;
-              sumLine += fPow2Div2(temp);
-            }
-          }
-        } else
-        {
-          if (preShift>=0) {
-            for (l=start_pos; l<next_pos; l++) {
-              temp   = analysBufferReal[l][k] << (int)preShift;
-              sumLine += fPow2Div2(temp);
-            }
-          } else {
-            for (l=start_pos; l<next_pos; l++) {
-              temp   = analysBufferReal[l][k] >> -(int)preShift;
-              sumLine += fPow2Div2(temp);
-            }
-          }
-        }
-
-        /* The number of QMF-channels per SBR bands may be up to 15.
-           Shift right to avoid overflows in sum over all channels. */
-        sumLine = sumLine >> (4-1);
-        sumAll  += sumLine;
-      }
-
-      /* Convert double precision to Mantissa/Exponent: */
-      shift = fNorm(sumAll);
-      sum = sumAll << (int)shift;
-
-      /* Divide by width of envelope: */
-      sum = fMult(sum,invWidth);
-
-      /* Divide by width of Sfb: */
-      sum = fMult(sum, FX_DBL2FX_SGL(GetInvInt(ui-li)));
-
-      /* Set all Subband energies in the Sfb to the average energy: */
-      if (analysBufferImag!=NULL)
-        sum_e = input_e + 4 - shift;  /* -4 to compensate right-shift */
-      else
-        sum_e = input_e + 4 + 1 - shift;  /* -4 to compensate right-shift; +1 due to missing imag. part */
-
-      sum_e -= 2 * preShift;
-    } /* maxVal!=0 */
-    else {
-
-      /* Prevent a zero-mantissa-number from being misinterpreted
-         due to its exponent. */
-      sum = FL2FXCONST_DBL(0.0f);
-      sum_e = 0;
-    }
-
-    for (k=li; k<ui; k++)
-    {
-      *nrgEst++   = sum;
-      *nrgEst_e++ = sum_e;
-    }
-  }
-}
-
-
-/*!
-  \brief  Calculate gain, noise, and additional sine level for one subband.
-
-  The resulting energy gain is given by mantissa and exponent.
-*/
-/*static*/ void calcSubbandGain(FIXP_DBL  nrgRef,            /*!< Reference Energy according to envelope data */
-                            SCHAR     nrgRef_e,          /*!< Reference Energy according to envelope data (exponent) */
-                            ENV_CALC_NRGS* nrgs,
-                            int       i,
-                            FIXP_DBL  tmpNoise,          /*!< Relative noise level */
-                            SCHAR     tmpNoise_e,        /*!< Relative noise level (exponent) */
-                            UCHAR     sinePresentFlag,   /*!< Indicates if sine is present on band */
-                            UCHAR     sineMapped,        /*!< Indicates if sine must be added */
-                            int       noNoiseFlag)       /*!< Flag to suppress noise addition */
-{
-  FIXP_DBL  nrgEst          = nrgs->nrgEst[i];            /*!< Energy in transposed signal */
-  SCHAR     nrgEst_e        = nrgs->nrgEst_e[i];          /*!< Energy in transposed signal (exponent) */
-  FIXP_DBL *ptrNrgGain      = &nrgs->nrgGain[i];          /*!< Resulting energy gain */
-  SCHAR    *ptrNrgGain_e    = &nrgs->nrgGain_e[i];        /*!< Resulting energy gain (exponent) */
-  FIXP_DBL *ptrNoiseLevel   = &nrgs->noiseLevel[i];       /*!< Resulting absolute noise energy */
-  SCHAR    *ptrNoiseLevel_e = &nrgs->noiseLevel_e[i];     /*!< Resulting absolute noise energy (exponent) */
-  FIXP_DBL *ptrNrgSine      = &nrgs->nrgSine[i];          /*!< Additional sine energy */
-  SCHAR    *ptrNrgSine_e    = &nrgs->nrgSine_e[i];        /*!< Additional sine energy (exponent) */
-
-  FIXP_DBL a, b, c;
-  SCHAR    a_e, b_e, c_e;
-
-  /*
-     This addition of 1 prevents divisions by zero in the reference code.
-     For very small energies in nrgEst, it prevents the gains from becoming
-     very high which could cause some trouble due to the smoothing.
-  */
-  b_e = (int)(nrgEst_e - 1);
-  if (b_e>=0) {
-    nrgEst = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (nrgEst >> 1);
-    nrgEst_e += 1;  /* shift by 1 bit to avoid overflow */
-
-  } else {
-    nrgEst = (nrgEst >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
-    nrgEst_e = 2;  /* shift by 1 bit to avoid overflow */
-  }
-
-  /*  A = NrgRef * TmpNoise */
-  a = fMult(nrgRef,tmpNoise);
-  a_e = nrgRef_e + tmpNoise_e;
-
-  /*  B = 1 + TmpNoise */
-  b_e = (int)(tmpNoise_e - 1);
-  if (b_e>=0) {
-    b = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (tmpNoise >> 1);
-    b_e = tmpNoise_e + 1;  /* shift by 1 bit to avoid overflow */
-  } else {
-    b = (tmpNoise >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
-    b_e = 2;  /* shift by 1 bit to avoid overflow */
-  }
-
-  /*  noiseLevel = A / B = (NrgRef * TmpNoise) / (1 + TmpNoise) */
-  FDK_divide_MantExp( a,  a_e,
-                      b,  b_e,
-                      ptrNoiseLevel, ptrNoiseLevel_e);
-
-  if (sinePresentFlag) {
-
-    /*  C = (1 + TmpNoise) * NrgEst */
-    c = fMult(b,nrgEst);
-    c_e = b_e + nrgEst_e;
-
-    /*  gain = A / C = (NrgRef * TmpNoise) / (1 + TmpNoise) * NrgEst */
-    FDK_divide_MantExp( a,  a_e,
-                        c,  c_e,
-                        ptrNrgGain, ptrNrgGain_e);
-
-    if (sineMapped) {
-
-      /*  sineLevel = nrgRef/ (1 + TmpNoise) */
-      FDK_divide_MantExp( nrgRef,  nrgRef_e,
-                          b,  b_e,
-                          ptrNrgSine, ptrNrgSine_e);
-    }
-  }
-  else {
-    if (noNoiseFlag) {
-      /*  B = NrgEst */
-      b = nrgEst;
-      b_e = nrgEst_e;
-    }
-    else {
-      /*  B = NrgEst * (1 + TmpNoise) */
-      b = fMult(b,nrgEst);
-      b_e = b_e + nrgEst_e;
-    }
-
-
-    /*  gain = nrgRef / B */
-    FDK_divide_MantExp( nrgRef,  nrgRef_e,
-                        b,  b_e,
-                        ptrNrgGain, ptrNrgGain_e);
-  }
-}
-
-
-/*!
-  \brief  Calculate "average gain" for the specified subband range.
-
-  This is rather a gain of the average magnitude than the average
-  of gains!
-  The result is used as a relative limit for all gains within the
-  current "limiter band" (a certain frequency range).
-*/
-/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
-                        int        lowSubband,    /*!< Begin of the limiter band */
-                        int        highSubband,   /*!< High end of the limiter band */
-                        FIXP_DBL  *ptrSumRef,
-                        SCHAR     *ptrSumRef_e,
-                        FIXP_DBL  *ptrAvgGain,  /*!< Resulting overall gain (mantissa) */
-                        SCHAR     *ptrAvgGain_e)  /*!< Resulting overall gain (exponent) */
-{
-  FIXP_DBL  *nrgRef   = nrgs->nrgRef;       /*!< Reference Energy according to envelope data */
-  SCHAR     *nrgRef_e = nrgs->nrgRef_e;     /*!< Reference Energy according to envelope data (exponent) */
-  FIXP_DBL  *nrgEst   = nrgs->nrgEst;       /*!< Energy in transposed signal */
-  SCHAR     *nrgEst_e = nrgs->nrgEst_e;     /*!< Energy in transposed signal (exponent) */
-
-  FIXP_DBL sumRef = 1;
-  FIXP_DBL sumEst = 1;
-  SCHAR    sumRef_e = -FRACT_BITS;
-  SCHAR    sumEst_e = -FRACT_BITS;
-  int      k;
-
-  for (k=lowSubband; k<highSubband; k++){
-    /* Add nrgRef[k] to sumRef: */
-    FDK_add_MantExp( sumRef, sumRef_e,
-                     nrgRef[k], nrgRef_e[k],
-                     &sumRef, &sumRef_e );
-
-    /* Add nrgEst[k] to sumEst: */
-    FDK_add_MantExp( sumEst, sumEst_e,
-                     nrgEst[k], nrgEst_e[k],
-                     &sumEst, &sumEst_e );
-  }
-
-  FDK_divide_MantExp(sumRef, sumRef_e,
-                     sumEst, sumEst_e,
-                     ptrAvgGain, ptrAvgGain_e);
-
-  *ptrSumRef = sumRef;
-  *ptrSumRef_e = sumRef_e;
-}
-
-
-/*!
-  \brief   Amplify one timeslot of the signal with the calculated gains
-           and add the noisefloor.
-*/
-
-/*static*/ void adjustTimeSlotLC(FIXP_DBL *ptrReal,       /*!< Subband samples to be adjusted, real part */
-                             ENV_CALC_NRGS* nrgs,
-                             UCHAR    *ptrHarmIndex,  /*!< Harmonic index */
-                             int       lowSubband,    /*!< Lowest QMF-channel in the currently used SBR range. */
-                             int       noSubbands,    /*!< Number of QMF subbands */
-                             int       scale_change,  /*!< Number of bits to shift adjusted samples */
-                             int       noNoiseFlag,   /*!< Flag to suppress noise addition */
-                             int      *ptrPhaseIndex, /*!< Start index to random number array */
-                             int       fCldfb)        /*!< CLDFB 80 flag */
-{
-  FIXP_DBL *pGain       = nrgs->nrgGain;     /*!< Gains of current envelope */
-  FIXP_DBL *pNoiseLevel = nrgs->noiseLevel;  /*!< Noise levels of current envelope */
-  FIXP_DBL *pSineLevel  = nrgs->nrgSine;     /*!< Sine levels */
-
-  int    k;
-  int    index = *ptrPhaseIndex;
-  UCHAR  harmIndex = *ptrHarmIndex;
-  UCHAR  freqInvFlag = (lowSubband & 1);
-  FIXP_DBL  signalReal, sineLevel, sineLevelNext, sineLevelPrev;
-  int    tone_count = 0;
-  int    sineSign = 1;
-
-  #define C1   ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.00815f))
-  #define C1_CLDFB ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.16773f))
-
-  /*
-    First pass for k=0 pulled out of the loop:
-  */
-
-  index = (index + 1) & (SBR_NF_NO_RANDOM_VAL - 1);
-
-  /*
-    The next multiplication constitutes the actual envelope adjustment
-    of the signal and should be carried out with full accuracy
-    (supplying #FRACT_BITS valid bits).
-  */
-  signalReal    = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
-  sineLevel     = *pSineLevel++;
-  sineLevelNext = (noSubbands > 1) ? pSineLevel[0] : FL2FXCONST_DBL(0.0f);
-
-  if (sineLevel!=FL2FXCONST_DBL(0.0f)) tone_count++;
-
-  else if (!noNoiseFlag)
-        /* Add noisefloor to the amplified signal */
-        signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
-
-  if (fCldfb) {
-
-    if (!(harmIndex&0x1)) {
-      /* harmIndex 0,2 */
-      signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
-      *ptrReal++ = signalReal;
-    }
-    else {
-      /* harmIndex 1,3 in combination with freqInvFlag */
-      int shift = (int) (scale_change+1);
-      shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
-
-      FIXP_DBL tmp1 = scaleValue( fMultDiv2(C1_CLDFB, sineLevel), -shift );
-
-      FIXP_DBL tmp2 = fMultDiv2(C1_CLDFB, sineLevelNext);
-
-
-      /* save switch and compare operations and reduce to XOR statement */
-      if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
-          *(ptrReal-1) += tmp1;
-          signalReal   -= tmp2;
-      } else {
-          *(ptrReal-1) -= tmp1;
-          signalReal   += tmp2;
-      }
-      *ptrReal++ = signalReal;
-      freqInvFlag = !freqInvFlag;
-    }
-
-  } else
-  {
-    if (!(harmIndex&0x1)) {
-      /* harmIndex 0,2 */
-      signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
-      *ptrReal++ = signalReal;
-    }
-    else {
-      /* harmIndex 1,3 in combination with freqInvFlag */
-      int shift = (int) (scale_change+1);
-      shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
-
-      FIXP_DBL tmp1 = (shift>=0) ? ( fMultDiv2(C1, sineLevel) >> shift )
-                                 : ( fMultDiv2(C1, sineLevel) << (-shift) );
-      FIXP_DBL tmp2 = fMultDiv2(C1, sineLevelNext);
-
-
-      /* save switch and compare operations and reduce to XOR statement */
-      if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
-          *(ptrReal-1) += tmp1;
-          signalReal   -= tmp2;
-      } else {
-          *(ptrReal-1) -= tmp1;
-          signalReal   += tmp2;
-      }
-      *ptrReal++ = signalReal;
-      freqInvFlag = !freqInvFlag;
-    }
-  }
-
-  pNoiseLevel++;
-
-  if ( noSubbands > 2 ) {
-    if (!(harmIndex&0x1)) {
-      /* harmIndex 0,2 */
-      if(!harmIndex) 
-      {
-        sineSign = 0;
-      }
-
-      for (k=noSubbands-2; k!=0; k--) {
-        FIXP_DBL sinelevel = *pSineLevel++;
-        index++;
-        if (((signalReal = (sineSign ? -sinelevel : sinelevel)) == FL2FXCONST_DBL(0.0f))  && !noNoiseFlag) 
-        {
-          /* Add noisefloor to the amplified signal */
-          index &= (SBR_NF_NO_RANDOM_VAL - 1);
-          signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
-        }
-        
-        /* The next multiplication constitutes the actual envelope adjustment of the signal. */
-        signalReal += fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
-
-        pNoiseLevel++;
-        *ptrReal++ = signalReal;
-      } /* for ... */
-    }
-    else {
-      /* harmIndex 1,3 in combination with freqInvFlag */
-      if (harmIndex==1) freqInvFlag = !freqInvFlag;
-
-      for (k=noSubbands-2; k!=0; k--) {
-        index++;
-        /* The next multiplication constitutes the actual envelope adjustment of the signal. */
-        signalReal = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
-
-        if (*pSineLevel++!=FL2FXCONST_DBL(0.0f)) tone_count++;
-        else if (!noNoiseFlag) {
-          /* Add noisefloor to the amplified signal */
-          index &= (SBR_NF_NO_RANDOM_VAL - 1);
-          signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
-        }
-
-        pNoiseLevel++;
-
-        if (tone_count <= 16) {
-          FIXP_DBL addSine = fMultDiv2((pSineLevel[-2] - pSineLevel[0]), C1);
-          signalReal += (freqInvFlag) ? (-addSine) : (addSine);
-        }
-
-        *ptrReal++ = signalReal;
-        freqInvFlag = !freqInvFlag;
-      } /* for ... */
-    }
-  }
-
-  if (noSubbands > -1) {
-    index++;
-    /* The next multiplication constitutes the actual envelope adjustment of the signal. */
-    signalReal    = fMultDiv2(*ptrReal,*pGain) << ((int)scale_change);
-    sineLevelPrev = fMultDiv2(pSineLevel[-1],FL2FX_SGL(0.0163f));
-    sineLevel     = pSineLevel[0];
-
-    if (pSineLevel[0]!=FL2FXCONST_DBL(0.0f)) tone_count++;
-    else if (!noNoiseFlag) {
-        /* Add noisefloor to the amplified signal */
-        index &= (SBR_NF_NO_RANDOM_VAL - 1);
-        signalReal = signalReal + (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
-    }
-
-    if (!(harmIndex&0x1)) {
-      /* harmIndex 0,2 */
-      *ptrReal = signalReal + ( (sineSign) ? -sineLevel : sineLevel);
-    }
-    else {
-      /* harmIndex 1,3 in combination with freqInvFlag */
-      if(tone_count <= 16){
-        if (freqInvFlag) {
-          *ptrReal++   = signalReal - sineLevelPrev;
-          if (noSubbands + lowSubband < 63)
-            *ptrReal = *ptrReal + fMultDiv2(C1, sineLevel);
-        }
-        else {
-          *ptrReal++ = signalReal + sineLevelPrev;
-          if (noSubbands + lowSubband < 63)
-            *ptrReal = *ptrReal - fMultDiv2(C1, sineLevel);
-        }
-      }
-      else *ptrReal = signalReal;
-    }
-  }
-  *ptrHarmIndex = (harmIndex + 1) & 3;
-  *ptrPhaseIndex = index & (SBR_NF_NO_RANDOM_VAL - 1);
-}
-void adjustTimeSlotHQ(FIXP_DBL *RESTRICT ptrReal,           /*!< Subband samples to be adjusted, real part */
-                      FIXP_DBL *RESTRICT ptrImag,               /*!< Subband samples to be adjusted, imag part */
-                      HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
-                      ENV_CALC_NRGS* nrgs,
-                      int       lowSubband,            /*!< Lowest QMF-channel in the currently used SBR range. */
-                      int       noSubbands,            /*!< Number of QMF subbands */
-                      int       scale_change,          /*!< Number of bits to shift adjusted samples */
-                      FIXP_SGL  smooth_ratio,          /*!< Impact of last envelope */
-                      int       noNoiseFlag,           /*!< Start index to random number array */
-                      int       filtBufferNoiseShift)  /*!< Shift factor of filtBufferNoise */
-{
-
-  FIXP_DBL *RESTRICT gain       = nrgs->nrgGain;        /*!< Gains of current envelope */
-  FIXP_DBL *RESTRICT noiseLevel = nrgs->noiseLevel;     /*!< Noise levels of current envelope */
-  FIXP_DBL *RESTRICT pSineLevel = nrgs->nrgSine;        /*!< Sine levels */
-
-  FIXP_DBL *RESTRICT filtBuffer      = h_sbr_cal_env->filtBuffer;      /*!< Gains of last envelope */
-  FIXP_DBL *RESTRICT filtBufferNoise = h_sbr_cal_env->filtBufferNoise; /*!< Noise levels of last envelope */
-  UCHAR    *RESTRICT ptrHarmIndex    =&h_sbr_cal_env->harmIndex;       /*!< Harmonic index */
-  int      *RESTRICT ptrPhaseIndex   =&h_sbr_cal_env->phaseIndex;      /*!< Start index to random number array */
-
-  int    k;
-  FIXP_DBL signalReal, signalImag;
-  FIXP_DBL noiseReal,  noiseImag;
-  FIXP_DBL  smoothedGain, smoothedNoise;
-  FIXP_SGL direct_ratio = /*FL2FXCONST_SGL(1.0f) */ (FIXP_SGL)MAXVAL_SGL - smooth_ratio;
-  int    index = *ptrPhaseIndex;
-  UCHAR   harmIndex = *ptrHarmIndex;
-  register int freqInvFlag = (lowSubband & 1);
-  FIXP_DBL sineLevel;
-  int shift;
-
-  *ptrPhaseIndex = (index+noSubbands) & (SBR_NF_NO_RANDOM_VAL - 1);
-  *ptrHarmIndex = (harmIndex + 1) & 3;
-
-  /*
-    Possible optimization:
-    smooth_ratio and harmIndex stay constant during the loop.
-    It might be faster to include a separate loop in each path.
-
-    the check for smooth_ratio is now outside the loop and the workload
-    of the whole function decreased by about 20 %
-  */
-
-  filtBufferNoiseShift += 1;      /* due to later use of fMultDiv2 instead of fMult */
-  if (filtBufferNoiseShift<0)
-    shift = fixMin(DFRACT_BITS-1,-filtBufferNoiseShift);
-  else
-    shift = fixMin(DFRACT_BITS-1, filtBufferNoiseShift);
-
-  if (smooth_ratio > FL2FXCONST_SGL(0.0f)) {
-
-    for (k=0; k<noSubbands; k++) {
-      /*
-        Smoothing: The old envelope has been bufferd and a certain ratio
-        of the old gains and noise levels is used.
-      */
-
-      smoothedGain = fMult(smooth_ratio,filtBuffer[k]) +
-                     fMult(direct_ratio,gain[k]);
-
-      if (filtBufferNoiseShift<0) {
-        smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])>>shift) +
-                         fMult(direct_ratio,noiseLevel[k]);
-      }
-      else {
-        smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])<<shift) +
-                         fMult(direct_ratio,noiseLevel[k]);
-      }
-
-      /*
-        The next 2 multiplications constitute the actual envelope adjustment
-        of the signal and should be carried out with full accuracy
-        (supplying #DFRACT_BITS valid bits).
-      */
-      signalReal = fMultDiv2(*ptrReal,smoothedGain)<<((int)scale_change);
-      signalImag = fMultDiv2(*ptrImag,smoothedGain)<<((int)scale_change);
-
-      index++;
-
-      if (pSineLevel[k] != FL2FXCONST_DBL(0.0f)) {
-        sineLevel = pSineLevel[k];
-
-        switch(harmIndex) {
-        case 0:
-          *ptrReal++ = (signalReal + sineLevel);
-          *ptrImag++ = (signalImag);
-          break;
-        case 2:
-          *ptrReal++ = (signalReal - sineLevel);
-          *ptrImag++ = (signalImag);
-          break;
-        case 1:
-          *ptrReal++ = (signalReal);
-          if (freqInvFlag)
-            *ptrImag++ = (signalImag - sineLevel);
-          else
-            *ptrImag++ = (signalImag + sineLevel);
-          break;
-        case 3:
-          *ptrReal++ = signalReal;
-          if (freqInvFlag)
-            *ptrImag++ = (signalImag + sineLevel);
-          else
-            *ptrImag++ = (signalImag - sineLevel);
-          break;
-        }
-      }
-      else {
-        if (noNoiseFlag) {
-          /* Just the amplified signal is saved */
-          *ptrReal++ = (signalReal);
-          *ptrImag++ = (signalImag);
-        }
-        else {
-          /* Add noisefloor to the amplified signal */
-          index &= (SBR_NF_NO_RANDOM_VAL - 1);
-          noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise)<<4;
-          noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise)<<4;
-          *ptrReal++ = (signalReal + noiseReal);
-          *ptrImag++ = (signalImag + noiseImag);
-        }
-      }
-      freqInvFlag ^= 1;
-    }
-
-  }
-  else 
-  {
-    for (k=0; k<noSubbands; k++) 
-    {
-      smoothedGain  = gain[k];
-      signalReal = fMultDiv2(*ptrReal, smoothedGain) << scale_change;
-      signalImag = fMultDiv2(*ptrImag, smoothedGain) << scale_change;
-
-      index++;
-
-      if ((sineLevel = pSineLevel[k]) != FL2FXCONST_DBL(0.0f)) 
-      {
-        switch (harmIndex) 
-        {
-        case 0:
-          signalReal += sineLevel;
-          break;
-        case 1:
-          if (freqInvFlag)
-            signalImag -= sineLevel;
-          else
-            signalImag += sineLevel;
-          break;
-        case 2:
-          signalReal -= sineLevel;
-          break;
-        case 3:
-          if (freqInvFlag)
-            signalImag += sineLevel;
-          else
-            signalImag -= sineLevel;
-          break;
-        }
-      }
-      else 
-      {
-        if (noNoiseFlag == 0)
-        {
-          /* Add noisefloor to the amplified signal */
-          smoothedNoise = noiseLevel[k];
-          index &= (SBR_NF_NO_RANDOM_VAL - 1);
-          noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise);
-          noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise);
-          signalReal += noiseReal<<4;
-          signalImag += noiseImag<<4;
-        }
-      }
-      *ptrReal++ = signalReal;
-      *ptrImag++ = signalImag;
-
-      freqInvFlag ^= 1;
-    }
-  }
-}
-
-
-/*!
-  \brief   Reset limiter bands.
-
-  Build frequency band table for the gain limiter dependent on
-  the previously generated transposer patch areas.
-
-  \return  SBRDEC_OK if ok,  SBRDEC_UNSUPPORTED_CONFIG on error
-*/
-SBR_ERROR
-ResetLimiterBands ( UCHAR *limiterBandTable,   /*!< Resulting band borders in QMF channels */
-                    UCHAR *noLimiterBands,     /*!< Resulting number of limiter band */
-                    UCHAR *freqBandTable,      /*!< Table with possible band borders */
-                    int noFreqBands,                   /*!< Number of bands in freqBandTable */
-                    const PATCH_PARAM *patchParam,     /*!< Transposer patch parameters */
-                    int noPatches,                     /*!< Number of transposer patches */
-                    int limiterBands)                  /*!< Selected 'band density' from bitstream */
-{
-  int i, k, isPatchBorder[2], loLimIndex, hiLimIndex, tempNoLim, nBands;
-  UCHAR workLimiterBandTable[MAX_FREQ_COEFFS / 2 + MAX_NUM_PATCHES + 1];
-  int patchBorders[MAX_NUM_PATCHES + 1];
-  int kx, k2;
-  FIXP_DBL temp;
-
-  int lowSubband = freqBandTable[0];
-  int highSubband = freqBandTable[noFreqBands];
-
-  /* 1 limiter band. */
-  if(limiterBands == 0) {
-    limiterBandTable[0] = 0;
-    limiterBandTable[1] = highSubband - lowSubband;
-    nBands = 1;
-  } else {
-    for (i = 0; i < noPatches; i++) {
-      patchBorders[i] = patchParam[i].guardStartBand - lowSubband;
-    }
-    patchBorders[i] = highSubband - lowSubband;
-
-    /* 1.2, 2, or 3 limiter bands/octave plus bandborders at patchborders. */
-    for (k = 0; k <= noFreqBands; k++) {
-      workLimiterBandTable[k] = freqBandTable[k] - lowSubband;
-    }
-    for (k = 1; k < noPatches; k++) {
-      workLimiterBandTable[noFreqBands + k] = patchBorders[k];
-    }
-
-    tempNoLim = nBands = noFreqBands + noPatches - 1;
-    shellsort(workLimiterBandTable, tempNoLim + 1);
-
-    loLimIndex = 0;
-    hiLimIndex = 1;
-
-
-    while (hiLimIndex <= tempNoLim) {
-      k2 = workLimiterBandTable[hiLimIndex] + lowSubband;
-      kx = workLimiterBandTable[loLimIndex] + lowSubband;
-
-      temp = FX_SGL2FX_DBL(FDK_getNumOctavesDiv8(kx,k2)); /* Number of octaves */
-      temp = fMult(temp, FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4[limiterBands]);
-
-      if (temp < FL2FXCONST_DBL (0.49f)>>5) {
-        if (workLimiterBandTable[hiLimIndex] == workLimiterBandTable[loLimIndex]) {
-          workLimiterBandTable[hiLimIndex] = highSubband;
-          nBands--;
-          hiLimIndex++;
-          continue;
-        }
-        isPatchBorder[0] = isPatchBorder[1] = 0;
-        for (k = 0; k <= noPatches; k++) {
-          if (workLimiterBandTable[hiLimIndex] == patchBorders[k]) {
-            isPatchBorder[1] = 1;
-            break;
-          }
-        }
-        if (!isPatchBorder[1]) {
-          workLimiterBandTable[hiLimIndex] = highSubband;
-          nBands--;
-          hiLimIndex++;
-          continue;
-        }
-        for (k = 0; k <= noPatches; k++) {
-          if (workLimiterBandTable[loLimIndex] == patchBorders[k]) {
-            isPatchBorder[0] = 1;
-            break;
-          }
-        }
-        if (!isPatchBorder[0]) {
-          workLimiterBandTable[loLimIndex] = highSubband;
-          nBands--;
-        }
-      }
-      loLimIndex = hiLimIndex;
-      hiLimIndex++;
-
-    }
-    shellsort(workLimiterBandTable, tempNoLim + 1);
-
-    /* Test if algorithm exceeded maximum allowed limiterbands */
-    if( nBands > MAX_NUM_LIMITERS || nBands <= 0) {
-      return SBRDEC_UNSUPPORTED_CONFIG;
-    }
-
-    /* Copy limiterbands from working buffer into final destination */
-    for (k = 0; k <= nBands; k++) {
-      limiterBandTable[k] = workLimiterBandTable[k];
-    }
-  }
-  *noLimiterBands = nBands;
-
-  return SBRDEC_OK;
-}
-
diff --git a/libSBRdec/src/env_calc.h b/libSBRdec/src/env_calc.h
deleted file mode 100644
index 8154166..0000000
--- a/libSBRdec/src/env_calc.h
+++ /dev/null
@@ -1,165 +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  Envelope calculation prototypes  
-*/
-#ifndef __ENV_CALC_H
-#define __ENV_CALC_H
-
-#include "sbrdecoder.h"
-#include "env_extr.h"  /* for HANDLE_SBR_HEADER_DATA */
-#include "sbr_scale.h"
-
-
-typedef struct
-{
-  FIXP_DBL  filtBuffer[MAX_FREQ_COEFFS];          /*!< previous gains (required for smoothing) */
-  FIXP_DBL  filtBufferNoise[MAX_FREQ_COEFFS];     /*!< previous noise levels (required for smoothing) */
-  SCHAR     filtBuffer_e[MAX_FREQ_COEFFS];        /*!< Exponents of previous gains */
-  SCHAR     filtBufferNoise_e;                    /*!< Common exponent of previous noise levels */
-
-  int startUp;               /*!< flag to signal initial conditions in buffers */
-  int phaseIndex;            /*!< Index for randomPase array */
-  int prevTranEnv;           /*!< The transient envelope of the previous frame. */
-
-  int harmFlagsPrev[(MAX_FREQ_COEFFS+15)/16];
-  /*!< Words with 16 flags each indicating where a sine was added in the previous frame.*/
-  UCHAR harmIndex;            /*!< Current phase of synthetic sine */
-
-}
-SBR_CALCULATE_ENVELOPE;
-
-typedef SBR_CALCULATE_ENVELOPE *HANDLE_SBR_CALCULATE_ENVELOPE;
-
-
-
-void
-calculateSbrEnvelope (QMF_SCALE_FACTOR  *sbrScaleFactor,
-                      HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
-                      HANDLE_SBR_HEADER_DATA hHeaderData,
-                      HANDLE_SBR_FRAME_DATA hFrameData,
-                      FIXP_DBL **analysBufferReal,
-                      FIXP_DBL **analysBufferImag,                 /*!< Imag part of subband samples to be processed */
-                      const int useLP,
-                      FIXP_DBL *degreeAlias,                       /*!< Estimated aliasing for each QMF channel */
-                      const UINT flags,
-                      const int frameErrorFlag
-                      );
-
-SBR_ERROR
-createSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hSbrCalculateEnvelope,
-                       HANDLE_SBR_HEADER_DATA hHeaderData,
-                       const int chan,
-                       const UINT flags);
-
-int
-deleteSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hSbrCalculateEnvelope);
-
-void
-resetSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hCalEnv);
-
-SBR_ERROR
-ResetLimiterBands ( UCHAR *limiterBandTable,
-                    UCHAR *noLimiterBands,
-                    UCHAR *freqBandTable,
-                    int noFreqBands,
-                    const PATCH_PARAM *patchParam,
-                    int noPatches,
-                    int limiterBands);
-
-void rescaleSubbandSamples( FIXP_DBL ** re,
-                            FIXP_DBL ** im,
-                            int lowSubband, int noSubbands,
-                            int start_pos,  int next_pos,
-                            int shift);
-
-FIXP_DBL maxSubbandSample( FIXP_DBL ** analysBufferReal_m,
-                           FIXP_DBL ** analysBufferImag_m,
-                           int lowSubband,
-                           int highSubband,
-                           int start_pos,
-                           int stop_pos);
-
-#endif // __ENV_CALC_H
diff --git a/libSBRdec/src/env_dec.cpp b/libSBRdec/src/env_dec.cpp
deleted file mode 100644
index 24b2d3b..0000000
--- a/libSBRdec/src/env_dec.cpp
+++ /dev/null
@@ -1,852 +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  envelope decoding  
-  This module provides envelope decoding and error concealment algorithms. The main
-  entry point is decodeSbrData().
-
-  \sa decodeSbrData(),\ref documentationOverview
-*/
-
-#include "env_dec.h"
-
-#include "env_extr.h"
-#include "transcendent.h"
-
-#include "genericStds.h"
-
-
-static void decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
-                            HANDLE_SBR_FRAME_DATA h_sbr_data,
-                            HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
-                            HANDLE_SBR_PREV_FRAME_DATA h_prev_data_otherChannel);
-static void sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                    HANDLE_SBR_FRAME_DATA h_data_left,
-                                    HANDLE_SBR_FRAME_DATA h_data_right);
-static void requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                    int ampResolution);
-static void deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                              HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                              HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static void decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                    HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static void timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                         HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                         HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static int checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,
-                              HANDLE_SBR_FRAME_DATA h_sbr_data,
-                              HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-
-
-
-#define SBR_ENERGY_PAN_OFFSET   (12 << ENV_EXP_FRACT)
-#define SBR_MAX_ENERGY          (35 << ENV_EXP_FRACT)
-
-#define DECAY                   ( 1 << ENV_EXP_FRACT)
-
-#if ENV_EXP_FRACT
-#define DECAY_COUPLING          ( 1 << (ENV_EXP_FRACT-1) ) /*!< corresponds to a value of 0.5 */
-#else
-#define DECAY_COUPLING            1  /*!< If the energy data is not shifted, use 1 instead of 0.5 */
-#endif
-
-
-/*!
-  \brief  Convert table index
-*/
-static int indexLow2High(int offset, /*!< mapping factor */
-                         int index,  /*!< index to scalefactor band */
-                         int res)    /*!< frequency resolution */
-{
-  if(res == 0)
-  {
-    if (offset >= 0)
-    {
-        if (index < offset)
-          return(index);
-        else
-          return(2*index - offset);
-    }
-    else
-    {
-        offset = -offset;
-        if (index < offset)
-          return(2*index+index);
-        else
-          return(2*index + offset);
-    }
-  }
-  else
-    return(index);
-}
-
-
-/*!
-  \brief  Update previous envelope value for delta-coding
-
-  The current envelope values needs to be stored for delta-coding
-  in the next frame.  The stored envelope is always represented with
-  the high frequency resolution.  If the current envelope uses the
-  low frequency resolution, the energy value will be mapped to the
-  corresponding high-res bands.
-*/
-static void mapLowResEnergyVal(FIXP_SGL currVal,  /*!< current energy value */
-                               FIXP_SGL* prevData,/*!< pointer to previous data vector */
-                               int offset,      /*!< mapping factor */
-                               int index,       /*!< index to scalefactor band */
-                               int res)         /*!< frequeny resolution */
-{
-  if(res == 0)
-  {
-    if (offset >= 0)
-    {
-        if(index < offset)
-            prevData[index] = currVal;
-        else
-        {
-            prevData[2*index - offset] = currVal;
-            prevData[2*index+1 - offset] = currVal;
-        }
-    }
-    else
-    {
-        offset = -offset;
-        if (index < offset)
-        {
-            prevData[3*index] = currVal;
-            prevData[3*index+1] = currVal;
-            prevData[3*index+2] = currVal;
-        }
-        else
-        {
-            prevData[2*index + offset] = currVal;
-            prevData[2*index + 1 + offset] = currVal;
-        }
-    }
-  }
-  else
-    prevData[index] = currVal;
-}
-
-
-
-/*!
-  \brief    Convert raw envelope and noisefloor data to energy levels
-
-  This function is being called by sbrDecoder_ParseElement() and provides two important algorithms:
-
-  First the function decodes envelopes and noise floor levels as described in requantizeEnvelopeData()
-  and sbr_envelope_unmapping(). The function also implements concealment algorithms in case there are errors
-  within the sbr data. For both operations fractional arithmetic is used.
-  Therefore you might encounter different output values on your target
-  system compared to the reference implementation.
-*/
-void
-decodeSbrData (HANDLE_SBR_HEADER_DATA hHeaderData,          /*!< Static control data */
-               HANDLE_SBR_FRAME_DATA h_data_left,           /*!< pointer to left channel frame data */
-               HANDLE_SBR_PREV_FRAME_DATA h_prev_data_left, /*!< pointer to left channel previous frame data */
-               HANDLE_SBR_FRAME_DATA h_data_right,          /*!< pointer to right channel frame data */
-               HANDLE_SBR_PREV_FRAME_DATA h_prev_data_right)/*!< pointer to right channel previous frame data */
-{
-  FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
-  int errLeft;
-
-  /* Save previous energy values to be able to reuse them later for concealment. */
-  FDKmemcpy (tempSfbNrgPrev, h_prev_data_left->sfb_nrg_prev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
-
-  decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
-  decodeNoiseFloorlevels (hHeaderData, h_data_left, h_prev_data_left);
-
-  if(h_data_right != NULL) {
-    errLeft = hHeaderData->frameErrorFlag;
-    decodeEnvelope (hHeaderData, h_data_right, h_prev_data_right, h_prev_data_left);
-    decodeNoiseFloorlevels (hHeaderData, h_data_right, h_prev_data_right);
-
-    if (!errLeft && hHeaderData->frameErrorFlag) {
-      /* If an error occurs in the right channel where the left channel seemed ok,
-         we apply concealment also on the left channel. This ensures that the coupling
-         modes of both channels match and that we have the same number of envelopes in
-         coupling mode.
-         However, as the left channel has already been processed before, the resulting
-         energy levels are not the same as if the left channel had been concealed
-         during the first call of decodeEnvelope().
-      */
-      /* Restore previous energy values for concealment, because the values have been
-         overwritten by the first call of decodeEnvelope(). */
-      FDKmemcpy (h_prev_data_left->sfb_nrg_prev, tempSfbNrgPrev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
-      /* Do concealment */
-      decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
-    }
-
-    if (h_data_left->coupling) {
-      sbr_envelope_unmapping (hHeaderData, h_data_left, h_data_right);
-    }
-  }
-
-  /* Display the data for debugging: */
-}
-
-
-/*!
-  \brief   Convert from coupled channels to independent L/R data
-*/
-static void
-sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
-                        HANDLE_SBR_FRAME_DATA h_data_left,  /*!< pointer to left channel */
-                        HANDLE_SBR_FRAME_DATA h_data_right) /*!< pointer to right channel */
-{
-  int i;
-  FIXP_SGL tempL_m, tempR_m, tempRplus1_m, newL_m, newR_m;
-  SCHAR   tempL_e, tempR_e, tempRplus1_e, newL_e, newR_e;
-
-
-  /* 1. Unmap (already dequantized) coupled envelope energies */
-
-  for (i = 0; i < h_data_left->nScaleFactors; i++) {
-    tempR_m = (FIXP_SGL)((LONG)h_data_right->iEnvelope[i] & MASK_M);
-    tempR_e = (SCHAR)((LONG)h_data_right->iEnvelope[i] & MASK_E);
-
-    tempR_e -= (18 + NRG_EXP_OFFSET);  /* -18 = ld(UNMAPPING_SCALE / h_data_right->nChannels) */
-    tempL_m = (FIXP_SGL)((LONG)h_data_left->iEnvelope[i] & MASK_M);
-    tempL_e = (SCHAR)((LONG)h_data_left->iEnvelope[i] & MASK_E);
-
-    tempL_e -= NRG_EXP_OFFSET;
-
-    /* Calculate tempRight+1 */
-    FDK_add_MantExp( tempR_m, tempR_e,
-                     FL2FXCONST_SGL(0.5f), 1,  /* 1.0 */
-                     &tempRplus1_m, &tempRplus1_e);
-
-    FDK_divide_MantExp( tempL_m, tempL_e+1,  /*  2 * tempLeft */
-                       tempRplus1_m, tempRplus1_e,
-                       &newR_m, &newR_e );
-
-    if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
-      newR_m >>= 1;
-      newR_e += 1;
-    }
-
-    newL_m = FX_DBL2FX_SGL(fMult(tempR_m,newR_m));
-    newL_e = tempR_e + newR_e;
-
-    h_data_right->iEnvelope[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
-                                  (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NRG_EXP_OFFSET) & MASK_E);
-    h_data_left->iEnvelope[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
-                                  (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NRG_EXP_OFFSET) & MASK_E);
-  }
-
-  /* 2. Dequantize and unmap coupled noise floor levels */
-
-  for (i = 0; i < hHeaderData->freqBandData.nNfb * h_data_left->frameInfo.nNoiseEnvelopes; i++) {
-
-    tempL_e = (SCHAR)(6 - (LONG)h_data_left->sbrNoiseFloorLevel[i]);
-    tempR_e = (SCHAR)((LONG)h_data_right->sbrNoiseFloorLevel[i] - 12) /*SBR_ENERGY_PAN_OFFSET*/;
-
-    /* Calculate tempR+1 */
-    FDK_add_MantExp( FL2FXCONST_SGL(0.5f), 1+tempR_e, /* tempR */
-                     FL2FXCONST_SGL(0.5f), 1,         /*  1.0  */
-                     &tempRplus1_m, &tempRplus1_e);
-
-    /* Calculate 2*tempLeft/(tempR+1) */
-    FDK_divide_MantExp( FL2FXCONST_SGL(0.5f), tempL_e+2,  /*  2 * tempLeft */
-                       tempRplus1_m, tempRplus1_e,
-                       &newR_m, &newR_e );
-
-    /* if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
-      newR_m >>= 1;
-      newR_e += 1;
-    } */
-
-    /* L = tempR * R */
-    newL_m = newR_m;
-    newL_e = newR_e + tempR_e;
-    h_data_right->sbrNoiseFloorLevel[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
-                                           (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NOISE_EXP_OFFSET) & MASK_E);
-    h_data_left->sbrNoiseFloorLevel[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
-                                           (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NOISE_EXP_OFFSET) & MASK_E);
-  }
-}
-
-
-/*!
-  \brief    Simple alternative to the real SBR concealment
-
-  If the real frameInfo is not available due to a frame loss, a replacement will
-  be constructed with 1 envelope spanning the whole frame (FIX-FIX).
-  The delta-coded energies are set to negative values, resulting in a fade-down.
-  In case of coupling, the balance-channel will move towards the center.
-*/
-static void
-leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                   HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
-                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
-                   )
-{
-  FIXP_SGL target;  /* targeted level for sfb_nrg_prev during fade-down */
-  FIXP_SGL step;    /* speed of fade */
-  int i;
-
-  int currentStartPos = h_prev_data->stopPos - hHeaderData->numberTimeSlots;
-  int currentStopPos = hHeaderData->numberTimeSlots;
-
-
-  /* Use some settings of the previous frame */
-  h_sbr_data->ampResolutionCurrentFrame = h_prev_data->ampRes;
-  h_sbr_data->coupling = h_prev_data->coupling;
-  for(i=0;i<MAX_INVF_BANDS;i++)
-    h_sbr_data->sbr_invf_mode[i] = h_prev_data->sbr_invf_mode[i];
-
-  /* Generate concealing control data */
-
-  h_sbr_data->frameInfo.nEnvelopes = 1;
-  h_sbr_data->frameInfo.borders[0] = currentStartPos;
-  h_sbr_data->frameInfo.borders[1] = currentStopPos;
-  h_sbr_data->frameInfo.freqRes[0] = 1;
-  h_sbr_data->frameInfo.tranEnv = -1;  /* no transient */
-  h_sbr_data->frameInfo.nNoiseEnvelopes = 1;
-  h_sbr_data->frameInfo.bordersNoise[0] = currentStartPos;
-  h_sbr_data->frameInfo.bordersNoise[1] = currentStopPos;
-
-  h_sbr_data->nScaleFactors = hHeaderData->freqBandData.nSfb[1];
-
-  /* Generate fake envelope data */
-
-  h_sbr_data->domain_vec[0] = 1;
-
-  if (h_sbr_data->coupling == COUPLING_BAL) {
-    target = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
-    step = (FIXP_SGL)DECAY_COUPLING;
-  }
-  else {
-    target = FL2FXCONST_SGL(0.0f);
-    step   = (FIXP_SGL)DECAY;
-  }
-  if (hHeaderData->bs_info.ampResolution == 0) {
-    target <<= 1;
-    step   <<= 1;
-  }
-
-  for (i=0; i < h_sbr_data->nScaleFactors; i++) {
-    if (h_prev_data->sfb_nrg_prev[i] > target)
-      h_sbr_data->iEnvelope[i] = -step;
-    else
-      h_sbr_data->iEnvelope[i] = step;
-  }
-
-  /* Noisefloor levels are always cleared ... */
-
-  h_sbr_data->domain_vec_noise[0] = 1;
-  for (i=0; i < hHeaderData->freqBandData.nNfb; i++)
-    h_sbr_data->sbrNoiseFloorLevel[i] = FL2FXCONST_SGL(0.0f);
-
-  /* ... and so are the sines */
-  FDKmemclear(h_sbr_data->addHarmonics, MAX_FREQ_COEFFS);
-}
-
-
-/*!
-  \brief   Build reference energies and noise levels from bitstream elements
-*/
-static void
-decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
-                HANDLE_SBR_PREV_FRAME_DATA h_prev_data, /*!< pointer to data of last frame */
-                HANDLE_SBR_PREV_FRAME_DATA otherChannel /*!< other channel's last frame data */
-                )
-{
-  int i;
-  int fFrameError = hHeaderData->frameErrorFlag;
-  FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
-
-  if (!fFrameError) {
-    /*
-      To avoid distortions after bad frames, set the error flag if delta coding in time occurs.
-      However, SBR can take a little longer to come up again.
-    */
-    if ( h_prev_data->frameErrorFlag ) {
-      if (h_sbr_data->domain_vec[0] != 0) {
-        fFrameError = 1;
-      }
-    } else {
-      /* Check that the previous stop position and the current start position match.
-         (Could be done in checkFrameInfo(), but the previous frame data is not available there) */
-      if ( h_sbr_data->frameInfo.borders[0] != h_prev_data->stopPos - hHeaderData->numberTimeSlots ) {
-        /* Both the previous as well as the current frame are flagged to be ok, but they do not match! */
-        if (h_sbr_data->domain_vec[0] == 1) {
-          /* Prefer concealment over delta-time coding between the mismatching frames */
-          fFrameError = 1;
-        }
-        else {
-          /* Close the gap in time by triggering timeCompensateFirstEnvelope() */
-          fFrameError = 1;
-        }
-      }
-    }
-  }
-
-
-  if (fFrameError)       /* Error is detected */
-    {
-      leanSbrConcealment(hHeaderData,
-                         h_sbr_data,
-                         h_prev_data);
-
-      /* decode the envelope data to linear PCM */
-      deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
-    }
-  else                          /*Do a temporary dummy decoding and check that the envelope values are within limits */
-    {
-      if (h_prev_data->frameErrorFlag) {
-        timeCompensateFirstEnvelope (hHeaderData, h_sbr_data, h_prev_data);
-        if (h_sbr_data->coupling != h_prev_data->coupling) {
-          /*
-            Coupling mode has changed during concealment.
-             The stored energy levels need to be converted.
-           */
-          for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
-            /* Former Level-Channel will be used for both channels */
-            if (h_prev_data->coupling == COUPLING_BAL)
-              h_prev_data->sfb_nrg_prev[i] = otherChannel->sfb_nrg_prev[i];
-            /* Former L/R will be combined as the new Level-Channel */
-            else if (h_sbr_data->coupling == COUPLING_LEVEL)
-              h_prev_data->sfb_nrg_prev[i] = (h_prev_data->sfb_nrg_prev[i] + otherChannel->sfb_nrg_prev[i]) >> 1;
-            else if (h_sbr_data->coupling == COUPLING_BAL)
-              h_prev_data->sfb_nrg_prev[i] = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
-          }
-        }
-      }
-      FDKmemcpy (tempSfbNrgPrev, h_prev_data->sfb_nrg_prev,
-              MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
-
-      deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
-
-      fFrameError = checkEnvelopeData (hHeaderData, h_sbr_data, h_prev_data);
-
-      if (fFrameError)
-        {
-          hHeaderData->frameErrorFlag = 1;
-          FDKmemcpy (h_prev_data->sfb_nrg_prev, tempSfbNrgPrev,
-                  MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
-          decodeEnvelope (hHeaderData, h_sbr_data, h_prev_data, otherChannel);
-          return;
-        }
-    }
-
-  requantizeEnvelopeData (h_sbr_data, h_sbr_data->ampResolutionCurrentFrame);
-
-  hHeaderData->frameErrorFlag = fFrameError;
-}
-
-
-/*!
-  \brief   Verify that envelope energies are within the allowed range
-  \return  0 if all is fine, 1 if an envelope value was too high
-*/
-static int
-checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                   HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
-                   )
-{
-  FIXP_SGL *iEnvelope = h_sbr_data->iEnvelope;
-  FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
-  int    i = 0, errorFlag = 0;
-  FIXP_SGL sbr_max_energy =
-    (h_sbr_data->ampResolutionCurrentFrame == 1) ? SBR_MAX_ENERGY : (SBR_MAX_ENERGY << 1);
-
-  /*
-    Range check for current energies
-  */
-  for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
-    if (iEnvelope[i] > sbr_max_energy) {
-      errorFlag = 1;
-    }
-    if (iEnvelope[i] < FL2FXCONST_SGL(0.0f)) {
-      errorFlag = 1;
-      /* iEnvelope[i] = FL2FXCONST_SGL(0.0f); */
-    }
-  }
-
-  /*
-    Range check for previous energies
-  */
-  for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
-    sfb_nrg_prev[i] = fixMax(sfb_nrg_prev[i], FL2FXCONST_SGL(0.0f));
-    sfb_nrg_prev[i] = fixMin(sfb_nrg_prev[i], sbr_max_energy);
-  }
-
-  return (errorFlag);
-}
-
-
-/*!
-  \brief   Verify that the noise levels are within the allowed range
-
-  The function is equivalent to checkEnvelopeData().
-  When the noise-levels are being decoded, it is already too late for
-  concealment. Therefore the noise levels are simply limited here.
-*/
-static void
-limitNoiseLevels(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                 HANDLE_SBR_FRAME_DATA h_sbr_data)       /*!< pointer to current data */
-{
-  int i;
-  int nNfb = hHeaderData->freqBandData.nNfb;
-
-  /*
-    Set range limits. The exact values depend on the coupling mode.
-    However this limitation is primarily intended to avoid unlimited
-    accumulation of the delta-coded noise levels.
-  */
-  #define lowerLimit   ((FIXP_SGL)0)     /* lowerLimit actually refers to the _highest_ noise energy */
-  #define upperLimit   ((FIXP_SGL)35)    /* upperLimit actually refers to the _lowest_ noise energy */
-
-  /*
-    Range check for current noise levels
-  */
-  for (i = 0; i < h_sbr_data->frameInfo.nNoiseEnvelopes * nNfb; i++) {
-    h_sbr_data->sbrNoiseFloorLevel[i] = fixMin(h_sbr_data->sbrNoiseFloorLevel[i], upperLimit);
-    h_sbr_data->sbrNoiseFloorLevel[i] = fixMax(h_sbr_data->sbrNoiseFloorLevel[i], lowerLimit);
-  }
-}
-
-
-/*!
-  \brief   Compensate for the wrong timing that might occur after a frame error.
-*/
-static void
-timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
-                             HANDLE_SBR_FRAME_DATA h_sbr_data,   /*!< pointer to actual data */
-                             HANDLE_SBR_PREV_FRAME_DATA h_prev_data)  /*!< pointer to data of last frame */
-{
-  int i, nScalefactors;
-  FRAME_INFO *pFrameInfo = &h_sbr_data->frameInfo;
-  UCHAR *nSfb = hHeaderData->freqBandData.nSfb;
-  int estimatedStartPos = h_prev_data->stopPos - hHeaderData->numberTimeSlots;
-  int refLen, newLen, shift;
-  FIXP_SGL  deltaExp;
-
-  /* Original length of first envelope according to bitstream */
-  refLen = pFrameInfo->borders[1] - pFrameInfo->borders[0];
-  /* Corrected length of first envelope (concealing can make the first envelope longer) */
-  newLen = pFrameInfo->borders[1] - estimatedStartPos;
-
-  if (newLen <= 0) {
-    /* An envelope length of <= 0 would not work, so we don't use it.
-       May occur if the previous frame was flagged bad due to a mismatch
-       of the old and new frame infos. */
-    newLen = refLen;
-    estimatedStartPos = pFrameInfo->borders[0];
-  }
-
-  deltaExp = FDK_getNumOctavesDiv8(newLen, refLen);
-
-  /* Shift by -3 to rescale ld-table, ampRes-1 to enable coarser steps */
-  shift = (FRACT_BITS - 1 - ENV_EXP_FRACT - 1 + h_sbr_data->ampResolutionCurrentFrame - 3);
-  deltaExp = deltaExp >> shift;
-  pFrameInfo->borders[0] = estimatedStartPos;
-  pFrameInfo->bordersNoise[0] = estimatedStartPos;
-
-  if (h_sbr_data->coupling != COUPLING_BAL) {
-    nScalefactors = (pFrameInfo->freqRes[0]) ? nSfb[1] : nSfb[0];
-
-    for (i = 0; i < nScalefactors; i++)
-      h_sbr_data->iEnvelope[i] = h_sbr_data->iEnvelope[i] + deltaExp;
-  }
-}
-
-
-
-/*!
-  \brief   Convert each envelope value from logarithmic to linear domain
-
-  Energy levels are transmitted in powers of 2, i.e. only the exponent
-  is extracted from the bitstream.
-  Therefore, normally only integer exponents can occur. However during
-  fading (in case of a corrupt bitstream), a fractional part can also
-  occur. The data in the array iEnvelope is shifted left by ENV_EXP_FRACT
-  compared to an integer representation so that numbers smaller than 1
-  can be represented.
-
-  This function calculates a mantissa corresponding to the fractional
-  part of the exponent for each reference energy. The array iEnvelope
-  is converted in place to save memory. Input and output data must
-  be interpreted differently, as shown in the below figure:
-
-  \image html  EnvelopeData.png
-
-  The data is then used in calculateSbrEnvelope().
-*/
-static void
-requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
-{
-  int i;
-  FIXP_SGL mantissa;
-  int ampShift = 1 - ampResolution;
-  int exponent;
-
-  /* In case that ENV_EXP_FRACT is changed to something else but 0 or 8,
-     the initialization of this array has to be adapted!
-  */
-#if ENV_EXP_FRACT
-  static const FIXP_SGL pow2[ENV_EXP_FRACT] =
-  {
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 1))), /* 0.7071 */
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 2))), /* 0.5946 */
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 3))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 4))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 5))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 6))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 7))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 8)))  /* 0.5013 */
-  };
-
-  int bit, mask;
-#endif
-
-  for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
-    exponent = (LONG)h_sbr_data->iEnvelope[i];
-
-#if ENV_EXP_FRACT
-
-    exponent = exponent >> ampShift;
-    mantissa = 0.5f;
-
-    /* Amplify mantissa according to the fractional part of the
-       exponent (result will be between 0.500000 and 0.999999)
-    */
-    mask = 1;  /* begin with lowest bit of exponent */
-
-    for ( bit=ENV_EXP_FRACT-1; bit>=0; bit-- ) {
-      if (exponent & mask) {
-        /* The current bit of the exponent is set,
-           multiply mantissa with the corresponding factor: */
-        mantissa = (FIXP_SGL)( (mantissa * pow2[bit]) << 1);
-      }
-      /* Advance to next bit */
-      mask = mask << 1;
-    }
-
-    /* Make integer part of exponent right aligned */
-    exponent = exponent >> ENV_EXP_FRACT;
-
-#else
-    /* In case of the high amplitude resolution, 1 bit of the exponent gets lost by the shift.
-       This will be compensated by a mantissa of 0.5*sqrt(2) instead of 0.5 if that bit is 1. */
-    mantissa = (exponent & ampShift) ? FL2FXCONST_SGL(0.707106781186548f) : FL2FXCONST_SGL(0.5f);
-    exponent = exponent >> ampShift;
-#endif
-
-    /*
-      Mantissa was set to 0.5 (instead of 1.0, therefore increase exponent by 1).
-      Multiply by L=nChannels=64 by increasing exponent by another 6.
-      => Increase exponent by 7
-    */
-    exponent += 7 + NRG_EXP_OFFSET;
-
-    /* Combine mantissa and exponent and write back the result */
-    h_sbr_data->iEnvelope[i] = (FIXP_SGL)(((LONG)mantissa & MASK_M) | (exponent & MASK_E));
-
-  }
-}
-
-
-/*!
-  \brief   Build new reference energies from old ones and delta coded data
-*/
-static void
-deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                                  HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                                  HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
-{
-  int i, domain, no_of_bands, band, freqRes;
-
-  FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
-  FIXP_SGL *ptr_nrg = h_sbr_data->iEnvelope;
-
-  int offset = 2 * hHeaderData->freqBandData.nSfb[0] - hHeaderData->freqBandData.nSfb[1];
-
-  for (i = 0; i < h_sbr_data->frameInfo.nEnvelopes; i++) {
-    domain = h_sbr_data->domain_vec[i];
-    freqRes = h_sbr_data->frameInfo.freqRes[i];
-
-    FDK_ASSERT(freqRes >= 0 && freqRes <= 1);
-
-    no_of_bands = hHeaderData->freqBandData.nSfb[freqRes];
-
-    FDK_ASSERT(no_of_bands < (64));
-
-    if (domain == 0)
-    {
-      mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, 0, freqRes);
-      ptr_nrg++;
-      for (band = 1; band < no_of_bands; band++)
-      {
-        *ptr_nrg = *ptr_nrg + *(ptr_nrg-1);
-        mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
-        ptr_nrg++;
-      }
-    }
-    else
-    {
-      for (band = 0; band < no_of_bands; band++)
-      {
-        *ptr_nrg = *ptr_nrg + sfb_nrg_prev[indexLow2High(offset, band, freqRes)];
-        mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
-        ptr_nrg++;
-      }
-    }
-  }
-}
-
-
-/*!
-  \brief   Build new noise levels from old ones and delta coded data
-*/
-static void
-decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                        HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                        HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
-{
-  int i;
-  int nNfb = hHeaderData->freqBandData.nNfb;
-  int nNoiseFloorEnvelopes = h_sbr_data->frameInfo.nNoiseEnvelopes;
-
-  /* Decode first noise envelope */
-
-  if (h_sbr_data->domain_vec_noise[0] == 0) {
-    FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[0];
-    for (i = 1; i < nNfb; i++) {
-      noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
-      h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
-    }
-  }
-  else {
-    for (i = 0; i < nNfb; i++) {
-      h_sbr_data->sbrNoiseFloorLevel[i] += h_prev_data->prevNoiseLevel[i];
-    }
-  }
-
-  /* If present, decode the second noise envelope
-     Note:  nNoiseFloorEnvelopes can only be 1 or 2 */
-
-  if (nNoiseFloorEnvelopes > 1) {
-    if (h_sbr_data->domain_vec_noise[1] == 0) {
-      FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[nNfb];
-      for (i = nNfb + 1; i < 2*nNfb; i++) {
-        noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
-        h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
-      }
-    }
-    else {
-      for (i = 0; i < nNfb; i++) {
-        h_sbr_data->sbrNoiseFloorLevel[i + nNfb] += h_sbr_data->sbrNoiseFloorLevel[i];
-      }
-    }
-  }
-
-  limitNoiseLevels(hHeaderData, h_sbr_data);
-
-  /* Update prevNoiseLevel with the last noise envelope */
-  for (i = 0; i < nNfb; i++)
-    h_prev_data->prevNoiseLevel[i] = h_sbr_data->sbrNoiseFloorLevel[i + nNfb*(nNoiseFloorEnvelopes-1)];
-
-
-  /* Requantize the noise floor levels in COUPLING_OFF-mode */
-  if (!h_sbr_data->coupling) {
-    int nf_e;
-
-    for (i = 0; i < nNoiseFloorEnvelopes*nNfb; i++) {
-      nf_e = 6 - (LONG)h_sbr_data->sbrNoiseFloorLevel[i] + 1 + NOISE_EXP_OFFSET;
-      /* +1 to compensate for a mantissa of 0.5 instead of 1.0 */
-
-      h_sbr_data->sbrNoiseFloorLevel[i] =
-        (FIXP_SGL)( ((LONG)FL2FXCONST_SGL(0.5f)) +  /* mantissa */
-                  (nf_e & MASK_E) ); /* exponent */
-
-    }
-  }
-}
diff --git a/libSBRdec/src/env_dec.h b/libSBRdec/src/env_dec.h
deleted file mode 100644
index 6f6dae3..0000000
--- a/libSBRdec/src/env_dec.h
+++ /dev/null
@@ -1,101 +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  Envelope decoding  
-*/
-#ifndef __ENV_DEC_H
-#define __ENV_DEC_H
-
-#include "sbrdecoder.h"
-#include "env_extr.h"
-
-void decodeSbrData (HANDLE_SBR_HEADER_DATA hHeaderData,
-                    HANDLE_SBR_FRAME_DATA h_data_left,
-                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data_left,
-                    HANDLE_SBR_FRAME_DATA h_data_right,
-                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data_right);
-
-
-#endif
diff --git a/libSBRdec/src/env_extr.cpp b/libSBRdec/src/env_extr.cpp
deleted file mode 100644
index 6cb0b99..0000000
--- a/libSBRdec/src/env_extr.cpp
+++ /dev/null
@@ -1,1395 +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  Envelope extraction  
-  The functions provided by this module are mostly called by applySBR(). After it is
-  determined that there is valid SBR data, sbrGetHeaderData() might be called if the current
-  SBR data contains an \ref SBR_HEADER_ELEMENT as opposed to a \ref SBR_STANDARD_ELEMENT. This function
-  may return various error codes as defined in #SBR_HEADER_STATUS . Most importantly it returns HEADER_RESET when decoder
-  settings need to be recalculated according to the SBR specifications. In that case applySBR()
-  will initiatite the required re-configuration.
-
-  The header data is stored in a #SBR_HEADER_DATA structure.
-
-  The actual SBR data for the current frame is decoded into SBR_FRAME_DATA stuctures by sbrGetChannelPairElement()
-  [for stereo streams] and sbrGetSingleChannelElement() [for mono streams]. There is no fractional arithmetic involved.
-
-  Once the information is extracted, the data needs to be further prepared before the actual decoding process.
-  This is done in decodeSbrData().
-
-  \sa Description of buffer management in applySBR(). \ref documentationOverview
-
-  <h1>About the SBR data format:</h1>
-
-  Each frame includes SBR data (side chain information), and can be either the \ref SBR_HEADER_ELEMENT or the \ref SBR_STANDARD_ELEMENT.
-  Parts of the data can be protected by a CRC checksum.
-
-  \anchor SBR_HEADER_ELEMENT <h2>The SBR_HEADER_ELEMENT</h2>
-
-  The SBR_HEADER_ELEMENT can be transmitted with every frame, however, it typically is send every second or so. It contains fundamental
-  information such as SBR sampling frequency and frequency range as well as control signals that do not require frequent changes. It also
-  includes the \ref SBR_STANDARD_ELEMENT.
-
-  Depending on the changes between the information in a current SBR_HEADER_ELEMENT and the previous SBR_HEADER_ELEMENT, the SBR decoder might need
-  to be reset and reconfigured (e.g. new tables need to be calculated).
-
-  \anchor SBR_STANDARD_ELEMENT <h2>The SBR_STANDARD_ELEMENT</h2>
-
-  This data can be subdivided into "side info" and "raw data", where side info is defined as signals needed to decode the raw data
-  and some decoder tuning signals. Raw data is referred to as PCM and Huffman coded envelope and noise floor estimates. The side info also
-  includes information about the time-frequency grid for the current frame.
-
-  \sa \ref documentationOverview
-*/
-
-#include "env_extr.h"
-
-#include "sbr_ram.h"
-#include "sbr_rom.h"
-#include "huff_dec.h"
-
-
-#include "psbitdec.h"
-
-#define DRM_PARAMETRIC_STEREO   0
-#define EXTENSION_ID_PS_CODING  2
-
-
-static int extractFrameInfo (HANDLE_FDK_BITSTREAM   hBs,
-                             HANDLE_SBR_HEADER_DATA hHeaderData,
-                             HANDLE_SBR_FRAME_DATA  h_frame_data,
-                             const UINT             nrOfChannels,
-                             const UINT             flags
-                            );
-
-
-static int sbrGetEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
-                           HANDLE_SBR_FRAME_DATA  h_frame_data,
-                           HANDLE_FDK_BITSTREAM   hBs,
-                           const UINT flags);
-
-static void sbrGetDirectionControlData (HANDLE_SBR_FRAME_DATA hFrameData,
-                                        HANDLE_FDK_BITSTREAM hBs);
-
-static void sbrGetNoiseFloorData (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                  HANDLE_SBR_FRAME_DATA  h_frame_data,
-                                  HANDLE_FDK_BITSTREAM   hBs);
-
-static int checkFrameInfo (FRAME_INFO *pFrameInfo, int numberOfTimeSlots, int overlap, int timeStep);
-
-SBR_ERROR
-initHeaderData (
-        HANDLE_SBR_HEADER_DATA  hHeaderData,
-        const int               sampleRateIn,
-        const int               sampleRateOut,
-        const int               samplesPerFrame,
-        const UINT              flags
-        )
-{
-  HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
-  SBR_ERROR sbrError = SBRDEC_OK;
-  int numAnalysisBands;
-
-  if ( sampleRateIn == sampleRateOut ) {
-    hHeaderData->sbrProcSmplRate = sampleRateOut<<1;
-    numAnalysisBands = 32;
-  } else {
-    hHeaderData->sbrProcSmplRate = sampleRateOut;
-    if ( (sampleRateOut>>1) == sampleRateIn) {
-      /* 1:2 */
-      numAnalysisBands = 32;
-    } else if ( (sampleRateOut>>2) == sampleRateIn ) {
-      /* 1:4 */
-      numAnalysisBands = 32;
-    } else if ( (sampleRateOut*3)>>3 == (sampleRateIn*8)>>3 ) {
-      /* 3:8, 3/4 core frame length */
-      numAnalysisBands = 24;
-    } else {
-      sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-      goto bail;
-    }
-  }
-
-  /* Fill in default values first */
-  hHeaderData->syncState          = SBR_NOT_INITIALIZED;
-  hHeaderData->status             = 0;
-  hHeaderData->frameErrorFlag     = 0;
-
-  hHeaderData->bs_info.ampResolution     = 1;
-  hHeaderData->bs_info.xover_band        = 0;
-  hHeaderData->bs_info.sbr_preprocessing = 0;
-
-  hHeaderData->bs_data.startFreq       = 5;
-  hHeaderData->bs_data.stopFreq        = 0;
-  hHeaderData->bs_data.freqScale       = 2;
-  hHeaderData->bs_data.alterScale      = 1;
-  hHeaderData->bs_data.noise_bands     = 2;
-  hHeaderData->bs_data.limiterBands    = 2;
-  hHeaderData->bs_data.limiterGains    = 2;
-  hHeaderData->bs_data.interpolFreq    = 1;
-  hHeaderData->bs_data.smoothingLength = 1;
-
-  hHeaderData->timeStep = (flags & SBRDEC_ELD_GRID) ? 1 : 2;
-
-  /* Setup pointers to frequency band tables */
-  hFreq->freqBandTable[0]  = hFreq->freqBandTableLo;
-  hFreq->freqBandTable[1] = hFreq->freqBandTableHi;
-
-  /* Patch some entries */
-  if (sampleRateOut > 24000) {    /* Trigger an error if SBR is going to be processed without     */
-    hHeaderData->bs_data.startFreq = 7;   /*   having read these frequency values from bit stream before. */
-    hHeaderData->bs_data.stopFreq  = 3;
-  }
-
-  /* One SBR timeslot corresponds to the amount of samples equal to the amount of analysis bands, divided by the timestep. */
-  hHeaderData->numberTimeSlots = (samplesPerFrame/numAnalysisBands) >> (hHeaderData->timeStep - 1);
-  if (hHeaderData->numberTimeSlots > (16)) {
-    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  hHeaderData->numberOfAnalysisBands = numAnalysisBands;
-
-bail:
-  return sbrError;
-}
-
-
-/*!
-  \brief   Initialize the SBR_PREV_FRAME_DATA struct
-*/
-void
-initSbrPrevFrameData (HANDLE_SBR_PREV_FRAME_DATA h_prev_data, /*!< handle to struct SBR_PREV_FRAME_DATA */
-                      int timeSlots)                          /*!< Framelength in SBR-timeslots */
-{
-  int i;
-
-  /* Set previous energy and noise levels to 0 for the case
-     that decoding starts in the middle of a bitstream */
-  for (i=0; i < MAX_FREQ_COEFFS; i++)
-    h_prev_data->sfb_nrg_prev[i] = (FIXP_DBL)0;
-  for (i=0; i < MAX_NOISE_COEFFS; i++)
-    h_prev_data->prevNoiseLevel[i] = (FIXP_DBL)0;
-  for (i=0; i < MAX_INVF_BANDS; i++)
-    h_prev_data->sbr_invf_mode[i] = INVF_OFF;
-
-  h_prev_data->stopPos = timeSlots;
-  h_prev_data->coupling = COUPLING_OFF;
-  h_prev_data->ampRes = 0;
-}
-
-
-/*!
-  \brief   Read header data from bitstream
-
-  \return  error status - 0 if ok
-*/
-SBR_HEADER_STATUS
-sbrGetHeaderData (HANDLE_SBR_HEADER_DATA hHeaderData,
-                  HANDLE_FDK_BITSTREAM   hBs,
-                  const UINT             flags,
-                  const int              fIsSbrData)
-{
-  SBR_HEADER_DATA_BS *pBsData;
-  SBR_HEADER_DATA_BS lastHeader;
-  SBR_HEADER_DATA_BS_INFO lastInfo;
-  int headerExtra1=0, headerExtra2=0;
-
-  /* Copy SBR bit stream header to temporary header */
-  lastHeader = hHeaderData->bs_data;
-  lastInfo   = hHeaderData->bs_info;
-
-  /* Read new header from bitstream */
-  {
-    pBsData = &hHeaderData->bs_data;
-  }
-
-  {
-    hHeaderData->bs_info.ampResolution = FDKreadBits (hBs, 1);
-  }
-
-  pBsData->startFreq = FDKreadBits (hBs, 4);
-  pBsData->stopFreq = FDKreadBits (hBs, 4);
-
-  {
-    hHeaderData->bs_info.xover_band = FDKreadBits (hBs, 3);
-    FDKreadBits (hBs, 2);
-  }
-
-  headerExtra1 = FDKreadBits (hBs, 1);
-  headerExtra2 = FDKreadBits (hBs, 1);
-
-  /* Handle extra header information */
-  if( headerExtra1) 
-  {
-    pBsData->freqScale = FDKreadBits (hBs, 2);
-    pBsData->alterScale = FDKreadBits (hBs, 1);
-    pBsData->noise_bands = FDKreadBits (hBs, 2);
-  }
-  else {
-    pBsData->freqScale   = 2;
-    pBsData->alterScale  = 1;
-    pBsData->noise_bands = 2;
-  }
-
-  if (headerExtra2) {
-    pBsData->limiterBands = FDKreadBits (hBs, 2);
-    pBsData->limiterGains = FDKreadBits (hBs, 2);
-    pBsData->interpolFreq = FDKreadBits (hBs, 1);
-    pBsData->smoothingLength = FDKreadBits (hBs, 1);
-  }
-  else {
-    pBsData->limiterBands    = 2;
-    pBsData->limiterGains    = 2;
-    pBsData->interpolFreq    = 1;
-    pBsData->smoothingLength = 1;
-  }
-
-  /* Look for new settings. IEC 14496-3, 4.6.18.3.1 */
-  if(hHeaderData->syncState != SBR_ACTIVE ||
-     lastHeader.startFreq   != pBsData->startFreq   ||
-     lastHeader.stopFreq    != pBsData->stopFreq    ||
-     lastHeader.freqScale   != pBsData->freqScale   ||
-     lastHeader.alterScale  != pBsData->alterScale  ||
-     lastHeader.noise_bands != pBsData->noise_bands ||
-     lastInfo.xover_band    != hHeaderData->bs_info.xover_band) {
-    return HEADER_RESET; /* New settings */
-  }
-
-  return HEADER_OK;
-}
-
-/*!
-  \brief   Get missing harmonics parameters (only used for AAC+SBR)
-
-  \return  error status - 0 if ok
-*/
-int
-sbrGetSyntheticCodedData(HANDLE_SBR_HEADER_DATA hHeaderData,
-                         HANDLE_SBR_FRAME_DATA  hFrameData,
-                         HANDLE_FDK_BITSTREAM   hBs)
-{
-  int i, bitsRead = 0;
-
-  int flag = FDKreadBits(hBs,1);
-  bitsRead++;
-
-  if(flag){
-    for(i=0;i<hHeaderData->freqBandData.nSfb[1];i++){
-      hFrameData->addHarmonics[i]  = FDKreadBits (hBs, 1 );
-      bitsRead++;
-    }
-  }
-  else {
-    for(i=0; i<MAX_FREQ_COEFFS; i++)
-      hFrameData->addHarmonics[i]  = 0;
-  }
-  return(bitsRead);
-}
-
-/*!
-  \brief      Reads extension data from the bitstream
-
-  The bitstream format allows up to 4 kinds of extended data element.
-  Extended data may contain several elements, each identified by a 2-bit-ID.
-  So far, no extended data elements are defined hence the first 2 parameters
-  are unused. The data should be skipped in order to update the number
-  of read bits for the consistency check in applySBR().
-*/
-static int  extractExtendedData(
-                                HANDLE_SBR_HEADER_DATA hHeaderData,    /*!< handle to SBR header */
-                                HANDLE_FDK_BITSTREAM   hBs             /*!< Handle to the bit buffer */
-                               ,HANDLE_PS_DEC hParametricStereoDec     /*!< Parametric Stereo Decoder */
-                                ) {
-  INT nBitsLeft;
-  int extended_data;
-  int i, frameOk = 1;
-
-
-  extended_data = FDKreadBits(hBs, 1);
-
-  if (extended_data) {
-    int cnt;
-    int bPsRead = 0;
-
-    cnt = FDKreadBits(hBs, 4);
-    if (cnt == (1<<4)-1)
-      cnt += FDKreadBits(hBs, 8);
-
-
-    nBitsLeft = 8 * cnt;
-
-    /* sanity check for cnt */
-    if (nBitsLeft > (INT)FDKgetValidBits(hBs)) {
-      /* limit nBitsLeft */
-      nBitsLeft = (INT)FDKgetValidBits(hBs);
-      /* set frame error */
-      frameOk = 0;
-    }
-
-    while (nBitsLeft > 7) {
-      int extension_id = FDKreadBits(hBs, 2);
-      nBitsLeft -= 2;
-
-      switch(extension_id) {
-
-
-
-        case EXTENSION_ID_PS_CODING:
-
-        /* Read PS data from bitstream */
-
-        if (hParametricStereoDec != NULL) {
-          if(bPsRead && !hParametricStereoDec->bsData[hParametricStereoDec->bsReadSlot].mpeg.bPsHeaderValid) {
-            cnt = nBitsLeft >> 3; /* number of remaining bytes */
-            for (i=0; i<cnt; i++)
-              FDKreadBits(hBs, 8);
-            nBitsLeft -= cnt * 8;
-          } else {
-            nBitsLeft -= ReadPsData(hParametricStereoDec, hBs, nBitsLeft);
-            bPsRead = 1;
-          }
-        }
-
-          /* parametric stereo detected, could set channelMode accordingly here  */
-          /*                                                                     */
-          /* "The usage of this parametric stereo extension to HE-AAC is         */
-          /* signalled implicitly in the bitstream. Hence, if an sbr_extension() */
-          /* with bs_extension_id==EXTENSION_ID_PS is found in the SBR part of   */
-          /* the bitstream, a decoder supporting the combination of SBR and PS   */
-          /* shall operate the PS tool to generate a stereo output signal."      */
-          /* source: ISO/IEC 14496-3:2001/FDAM 2:2004(E)                         */
-
-        break;
-
-
-      default:
-        cnt = nBitsLeft >> 3; /* number of remaining bytes */
-        for (i=0; i<cnt; i++)
-          FDKreadBits(hBs, 8);
-        nBitsLeft -= cnt * 8;
-        break;
-      }
-    }
-
-    if (nBitsLeft < 0) {
-      frameOk = 0;
-      goto bail;
-    }
-    else {
-      /* Read fill bits for byte alignment */
-      FDKreadBits(hBs, nBitsLeft);
-    }
-  }
-
-bail:
-  return (frameOk);
-}
-
-
-/*!
-  \brief   Read bitstream elements of one channel
-
-  \return  SbrFrameOK:  1=ok, 0=error
-*/
-int
-sbrGetSingleChannelElement (HANDLE_SBR_HEADER_DATA hHeaderData,          /*!< Static control data */
-                            HANDLE_SBR_FRAME_DATA  hFrameData,           /*!< Control data of current frame */
-                            HANDLE_FDK_BITSTREAM   hBs,                  /*!< Handle to struct BIT_BUF */
-                            HANDLE_PS_DEC          hParametricStereoDec, /*!< Handle to PS decoder */
-                            const UINT             flags,
-                            const int              overlap
-                           )
-{
-  int i;
-
-
-  hFrameData->coupling = COUPLING_OFF;
-
-  {
-    /* Reserved bits */
-    if (FDKreadBits(hBs, 1)) {  /* bs_data_extra */
-      FDKreadBits(hBs, 4);
-      if (flags & SBRDEC_SYNTAX_SCAL) {
-        FDKreadBits(hBs, 4);
-      }
-    }
-  }
-
-  if (flags & SBRDEC_SYNTAX_SCAL) {
-    FDKreadBits (hBs, 1);     /* bs_coupling */
-  }
-
-  /*
-    Grid control
-  */
-  if ( !extractFrameInfo ( hBs, hHeaderData, hFrameData, 1, flags) )
-   return 0;
-
-  if ( !checkFrameInfo (&hFrameData->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
-    return 0;
-
-
-  /*
-    Fetch domain vectors (time or frequency direction for delta-coding)
-  */
-  sbrGetDirectionControlData (hFrameData, hBs);
-
-  for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
-    hFrameData->sbr_invf_mode[i] =
-      (INVF_MODE) FDKreadBits (hBs, 2);
-  }
-
-
-
-  /* raw data */
-  if ( !sbrGetEnvelope (hHeaderData, hFrameData, hBs, flags) )
-    return 0;
-
-
-  sbrGetNoiseFloorData (hHeaderData, hFrameData, hBs);
-
-  sbrGetSyntheticCodedData(hHeaderData, hFrameData, hBs);
-
-  {
-    /* sbr extended data */
-    if (! extractExtendedData(
-                               hHeaderData,
-                               hBs
-                              ,hParametricStereoDec
-                               )) {
-      return 0;
-    }
-  }
-
-  return 1;
-}
-
-
-
-/*!
-  \brief      Read bitstream elements of a channel pair
-  \return     SbrFrameOK
-*/
-int
-sbrGetChannelPairElement (HANDLE_SBR_HEADER_DATA hHeaderData,    /*!< Static control data */
-                          HANDLE_SBR_FRAME_DATA  hFrameDataLeft, /*!< Dynamic control data for first channel */
-                          HANDLE_SBR_FRAME_DATA  hFrameDataRight,/*!< Dynamic control data for second channel */
-                          HANDLE_FDK_BITSTREAM   hBs,            /*!< handle to struct BIT_BUF */
-                          const UINT flags,
-                          const int overlap )
-{
-  int i, bit;
-
-
-  /* Reserved bits */
-  if (FDKreadBits(hBs, 1)) {  /* bs_data_extra */
-    FDKreadBits(hBs, 4);
-    FDKreadBits(hBs, 4);
-  }
-
-  /* Read coupling flag */
-  bit = FDKreadBits (hBs, 1);
-
-  if (bit) {
-    hFrameDataLeft->coupling = COUPLING_LEVEL;
-    hFrameDataRight->coupling = COUPLING_BAL;
-  }
-  else {
-    hFrameDataLeft->coupling = COUPLING_OFF;
-    hFrameDataRight->coupling = COUPLING_OFF;
-  }
-
-
-  /*
-    Grid control
-  */
-  if ( !extractFrameInfo (hBs, hHeaderData, hFrameDataLeft, 2, flags) )
-    return 0;
-
-  if ( !checkFrameInfo (&hFrameDataLeft->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
-    return 0;
-
-  if (hFrameDataLeft->coupling) {
-    FDKmemcpy (&hFrameDataRight->frameInfo, &hFrameDataLeft->frameInfo, sizeof(FRAME_INFO));
-    hFrameDataRight->ampResolutionCurrentFrame = hFrameDataLeft->ampResolutionCurrentFrame;
-  }
-  else {
-    if ( !extractFrameInfo (hBs, hHeaderData, hFrameDataRight, 2, flags) )
-      return 0;
-
-    if ( !checkFrameInfo (&hFrameDataRight->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
-      return 0;
-  }
-
-  /*
-    Fetch domain vectors (time or frequency direction for delta-coding)
-  */
-  sbrGetDirectionControlData (hFrameDataLeft, hBs);
-  sbrGetDirectionControlData (hFrameDataRight, hBs);
-
-  for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
-    hFrameDataLeft->sbr_invf_mode[i] = (INVF_MODE) FDKreadBits (hBs, 2);
-  }
-
-  if (hFrameDataLeft->coupling) {
-    for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
-      hFrameDataRight->sbr_invf_mode[i] = hFrameDataLeft->sbr_invf_mode[i];
-    }
-
-
-    if ( !sbrGetEnvelope (hHeaderData, hFrameDataLeft, hBs, flags) ) {
-      return 0;
-    }
-
-    sbrGetNoiseFloorData (hHeaderData, hFrameDataLeft, hBs);
-
-    if ( !sbrGetEnvelope (hHeaderData, hFrameDataRight, hBs, flags) ) {
-      return 0;
-    }
-  }
-  else {
-
-    for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
-      hFrameDataRight->sbr_invf_mode[i] = (INVF_MODE) FDKreadBits (hBs, 2);
-    }
-
-
-
-    if ( !sbrGetEnvelope (hHeaderData, hFrameDataLeft, hBs, flags) )
-      return 0;
-
-    if ( !sbrGetEnvelope (hHeaderData, hFrameDataRight, hBs, flags) )
-      return 0;
-
-    sbrGetNoiseFloorData (hHeaderData, hFrameDataLeft, hBs);
-
-  }
-  sbrGetNoiseFloorData (hHeaderData, hFrameDataRight, hBs);
-
-  sbrGetSyntheticCodedData(hHeaderData, hFrameDataLeft, hBs);
-  sbrGetSyntheticCodedData(hHeaderData, hFrameDataRight, hBs);
-
-  {
-    if (! extractExtendedData(
-                               hHeaderData,
-                               hBs
-                              ,NULL
-                             ) ) {
-      return 0;
-    }
-  }
-
-  return 1;
-}
-
-
-
-
-/*!
-  \brief   Read direction control data from bitstream
-*/
-void
-sbrGetDirectionControlData (HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
-                            HANDLE_FDK_BITSTREAM  hBs)          /*!< handle to struct BIT_BUF */
-{
-  int i;
-
-  for (i = 0; i < h_frame_data->frameInfo.nEnvelopes; i++) {
-    h_frame_data->domain_vec[i] = FDKreadBits (hBs, 1);
-  }
-
-  for (i = 0; i < h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
-    h_frame_data->domain_vec_noise[i] = FDKreadBits (hBs, 1);
-  }
-}
-
-
-
-/*!
-  \brief   Read noise-floor-level data from bitstream
-*/
-void
-sbrGetNoiseFloorData (HANDLE_SBR_HEADER_DATA hHeaderData,  /*!< Static control data */
-                      HANDLE_SBR_FRAME_DATA  h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
-                      HANDLE_FDK_BITSTREAM   hBs)          /*!< handle to struct BIT_BUF */
-{
-  int i,j;
-  int delta;
-  COUPLING_MODE coupling;
-  int noNoiseBands = hHeaderData->freqBandData.nNfb;
-
-  Huffman hcb_noiseF;
-  Huffman hcb_noise;
-  int envDataTableCompFactor;
-
-  coupling = h_frame_data->coupling;
-
-
-  /*
-    Select huffman codebook depending on coupling mode
-  */
-  if (coupling == COUPLING_BAL) {
-    hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseBalance11T;
-    hcb_noiseF = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F;  /* "sbr_huffBook_NoiseBalance11F" */
-    envDataTableCompFactor = 1;
-  }
-  else {
-    hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseLevel11T;
-    hcb_noiseF = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F;    /* "sbr_huffBook_NoiseLevel11F" */
-    envDataTableCompFactor = 0;
-  }
-
-  /*
-    Read raw noise-envelope data
-  */
-  for (i=0; i<h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
-
-
-    if (h_frame_data->domain_vec_noise[i] == 0) {
-      if (coupling == COUPLING_BAL) {
-        h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands] =
-          (FIXP_SGL) (((int)FDKreadBits (hBs, 5)) << envDataTableCompFactor);
-      }
-      else {
-        h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands] =
-          (FIXP_SGL) (int)FDKreadBits (hBs, 5);
-      }
-
-      for (j = 1; j < noNoiseBands; j++) {
-        delta = DecodeHuffmanCW(hcb_noiseF, hBs);
-        h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands+j] = (FIXP_SGL) (delta << envDataTableCompFactor);
-      }
-    }
-    else {
-      for (j = 0; j < noNoiseBands; j++) {
-        delta = DecodeHuffmanCW(hcb_noise, hBs);
-        h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands+j] = (FIXP_SGL) (delta << envDataTableCompFactor);
-      }
-    }
-  }
-}
-
-
-/*!
-  \brief   Read envelope data from bitstream
-*/
-static int
-sbrGetEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,  /*!< Static control data */
-                HANDLE_SBR_FRAME_DATA  h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
-                HANDLE_FDK_BITSTREAM   hBs,          /*!< handle to struct BIT_BUF */
-                const UINT             flags)
-{
-  int i, j;
-  UCHAR no_band[MAX_ENVELOPES];
-  int delta = 0;
-  int offset = 0;
-  COUPLING_MODE coupling = h_frame_data->coupling;
-  int ampRes = hHeaderData->bs_info.ampResolution;
-  int nEnvelopes = h_frame_data->frameInfo.nEnvelopes;
-  int envDataTableCompFactor;
-  int start_bits, start_bits_balance;
-  Huffman hcb_t, hcb_f;
-
-  h_frame_data->nScaleFactors = 0;
-
-  if ( (h_frame_data->frameInfo.frameClass == 0) && (nEnvelopes == 1) ) {
-    if (flags & SBRDEC_ELD_GRID)
-      ampRes = h_frame_data->ampResolutionCurrentFrame;
-    else
-      ampRes = 0;
-  }
-  h_frame_data->ampResolutionCurrentFrame = ampRes;
-
-  /*
-    Set number of bits for first value depending on amplitude resolution
-  */
-  if(ampRes == 1)
-  {
-    start_bits = 6;
-    start_bits_balance = 5;
-  }
-  else
-  {
-    start_bits = 7;
-    start_bits_balance = 6;
-  }
-
-  /*
-    Calculate number of values for each envelope and alltogether
-  */
-  for (i = 0; i < nEnvelopes; i++) {
-    no_band[i] = hHeaderData->freqBandData.nSfb[h_frame_data->frameInfo.freqRes[i]];
-    h_frame_data->nScaleFactors += no_band[i];
-  }
-  if (h_frame_data->nScaleFactors > MAX_NUM_ENVELOPE_VALUES)
-    return 0;
-
-  /*
-    Select Huffman codebook depending on coupling mode and amplitude resolution
-  */
-  if (coupling == COUPLING_BAL) {
-    envDataTableCompFactor = 1;
-    if (ampRes == 0) {
-      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10T;
-      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10F;
-    }
-    else {
-      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11T;
-      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F;
-    }
-  }
-  else {
-    envDataTableCompFactor = 0;
-    if (ampRes == 0) {
-      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10T;
-      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10F;
-    }
-    else {
-      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11T;
-      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F;
-    }
-  }
-
-  /*
-    Now read raw envelope data
-  */
-  for (j = 0, offset = 0; j < nEnvelopes; j++) {
-
-
-    if (h_frame_data->domain_vec[j] == 0) {
-      if (coupling == COUPLING_BAL) {
-        h_frame_data->iEnvelope[offset] =
-          (FIXP_SGL) (( (int)FDKreadBits(hBs, start_bits_balance)) << envDataTableCompFactor);
-      }
-      else {
-        h_frame_data->iEnvelope[offset] =
-          (FIXP_SGL) (int)FDKreadBits (hBs, start_bits);
-      }
-    }
-
-    for (i = (1 - h_frame_data->domain_vec[j]); i < no_band[j]; i++) {
-
-      if (h_frame_data->domain_vec[j] == 0) {
-        delta = DecodeHuffmanCW(hcb_f, hBs);
-      }
-      else {
-        delta = DecodeHuffmanCW(hcb_t, hBs);
-      }
-
-      h_frame_data->iEnvelope[offset + i] = (FIXP_SGL) (delta << envDataTableCompFactor);
-    }
-    offset += no_band[j];
-  }
-
-#if ENV_EXP_FRACT
-  /* Convert from int to scaled fract (ENV_EXP_FRACT bits for the fractional part) */
-  for (i = 0; i < h_frame_data->nScaleFactors; i++) {
-    h_frame_data->iEnvelope[i] <<= ENV_EXP_FRACT;
-  }
-#endif
-
-  return 1;
-}
-
-
-//static const FRAME_INFO v_frame_info1_8 = { 0, 1, {0, 8}, {1}, -1, 1, {0, 8} };
-static const FRAME_INFO v_frame_info2_8 = { 0, 2, {0, 4, 8}, {1, 1}, -1, 2, {0, 4, 8} };
-static const FRAME_INFO v_frame_info4_8 = { 0, 4, {0, 2, 4, 6, 8}, {1, 1, 1, 1}, -1, 2, {0, 4, 8} };
-
-/***************************************************************************/
-/*!
-  \brief    Generates frame info for FIXFIXonly frame class used for low delay version
-
-  \return   nothing
- ****************************************************************************/
- static void generateFixFixOnly ( FRAME_INFO *hSbrFrameInfo,
-                                  int tranPosInternal,
-                                  int numberTimeSlots
-                                )
-{
-    int nEnv, i, tranIdx;
-    const int *pTable;
-
-    switch (numberTimeSlots) {
-        case 8:
-            pTable = FDK_sbrDecoder_envelopeTable_8[tranPosInternal];
-            break;
-        case 15:
-            pTable = FDK_sbrDecoder_envelopeTable_15[tranPosInternal];
-            break;
-        case 16:
-            pTable = FDK_sbrDecoder_envelopeTable_16[tranPosInternal];
-            break;
-        default:
-            FDK_ASSERT(0);
-    }
-
-    /* look number of envelopes in table */
-    nEnv = pTable[0];
-    /* look up envelope distribution in table */
-    for (i=1; i<nEnv; i++)
-        hSbrFrameInfo->borders[i] = pTable[i+2];
-    /* open and close frame border */
-    hSbrFrameInfo->borders[0]    = 0;
-    hSbrFrameInfo->borders[nEnv] = numberTimeSlots;
-    hSbrFrameInfo->nEnvelopes = nEnv;
-
-   /* transient idx */
-    tranIdx = hSbrFrameInfo->tranEnv = pTable[1];
-
-    /* add noise floors */
-    hSbrFrameInfo->bordersNoise[0] = 0;
-    hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[tranIdx?tranIdx:1];
-    hSbrFrameInfo->bordersNoise[2] = numberTimeSlots;
-    /* nEnv is always > 1, so nNoiseEnvelopes is always 2 (IEC 14496-3 4.6.19.3.2) */
-    hSbrFrameInfo->nNoiseEnvelopes = 2;
-}
-
-/*!
-  \brief  Extracts LowDelaySBR control data from the bitstream.
-
-  \return zero for bitstream error, one for correct.
-*/
-static int
-extractLowDelayGrid (HANDLE_FDK_BITSTREAM hBitBuf,          /*!< bitbuffer handle */
-                     HANDLE_SBR_HEADER_DATA hHeaderData,
-                     HANDLE_SBR_FRAME_DATA h_frame_data, /*!< contains the FRAME_INFO struct to be filled */
-                     int timeSlots
-                    )
-{
-  FRAME_INFO * pFrameInfo = &h_frame_data->frameInfo;
-  INT numberTimeSlots = hHeaderData->numberTimeSlots;
-  INT temp = 0, k;
-
-      /* FIXFIXonly framing case */
-      h_frame_data->frameInfo.frameClass = 0;
-
-      /* get the transient position from the bitstream */
-      switch (timeSlots){
-        case 8:
-          /* 3bit transient position (temp={0;..;7}) */
-          temp = FDKreadBits( hBitBuf, 3);
-          break;
-
-        case 16:
-        case 15:
-          /* 4bit transient position (temp={0;..;15}) */
-          temp = FDKreadBits( hBitBuf, 4);
-          break;
-
-        default:
-          return 0;
-      }
-
-      /* calculate borders according to the transient position */
-      generateFixFixOnly ( pFrameInfo,
-                           temp,
-                           numberTimeSlots
-                         );
-
-      /* decode freq res: */
-      for (k = 0; k < pFrameInfo->nEnvelopes; k++) {
-          pFrameInfo->freqRes[k] = (UCHAR) FDKreadBits (hBitBuf, 1); /* f = F [1 bits] */          
-      }
-
-
-  return 1;
-}
-
-/*!
-  \brief   Extract the frame information (structure FRAME_INFO) from the bitstream
-  \return  Zero for bitstream error, one for correct.
-*/
-int
-extractFrameInfo ( HANDLE_FDK_BITSTREAM   hBs,          /*!< bitbuffer handle */
-                   HANDLE_SBR_HEADER_DATA hHeaderData,  /*!< Static control data */
-                   HANDLE_SBR_FRAME_DATA  h_frame_data, /*!< pointer to memory where the frame-info will be stored */
-                   const UINT             nrOfChannels,
-                   const UINT             flags
-                 )
-{
-  FRAME_INFO * pFrameInfo = &h_frame_data->frameInfo;
-  int numberTimeSlots = hHeaderData->numberTimeSlots;
-  int pointer_bits = 0, nEnv = 0, b = 0, border, i, n = 0,
-    k, p, aL, aR, nL, nR,
-    temp = 0, staticFreqRes;
-  UCHAR frameClass;
-
-  if (flags & SBRDEC_ELD_GRID) {
-      /* CODEC_AACLD (LD+SBR) only uses the normal 0 Grid for non-transient Frames and the LowDelayGrid for transient Frames */
-      frameClass = FDKreadBits (hBs, 1); /* frameClass = [1 bit] */
-      if ( frameClass == 1 ) {
-        /* if frameClass == 1, extract LowDelaySbrGrid, otherwise extract normal SBR-Grid for FIXIFX */
-        /* extract the AACLD-Sbr-Grid */
-        pFrameInfo->frameClass = frameClass;
-        extractLowDelayGrid (hBs, hHeaderData, h_frame_data, numberTimeSlots);
-        return 1;
-      }
-  } else
-  {
-    frameClass = FDKreadBits (hBs, 2); /* frameClass = C [2 bits] */
-  }
-
-
-  switch (frameClass) {
-  case 0:
-    temp = FDKreadBits (hBs, 2);     /* E [2 bits ] */
-    nEnv = (int) (1 << temp);    /* E -> e */
-
-    if ((flags & SBRDEC_ELD_GRID) && (nEnv == 1))
-      h_frame_data->ampResolutionCurrentFrame = FDKreadBits( hBs, 1); /* new ELD Syntax 07-11-09 */
-
-    staticFreqRes = FDKreadBits (hBs, 1);
-
-    {
-      if (nEnv > MAX_ENVELOPES_HEAAC)
-        return 0;
-    }
-
-    b = nEnv + 1;
-    switch (nEnv) {
-    case 1:
-      switch (numberTimeSlots) {
-        case 15:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_15, sizeof(FRAME_INFO));
-          break;
-        case 16:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_16, sizeof(FRAME_INFO));
-          break;
-        default:
-          FDK_ASSERT(0);
-      }
-      break;
-    case 2:
-      switch (numberTimeSlots) {
-        case 15:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_15, sizeof(FRAME_INFO));
-          break;
-        case 16:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_16, sizeof(FRAME_INFO));
-          break;
-        default:
-          FDK_ASSERT(0);
-      }
-      break;
-    case 4:
-      switch (numberTimeSlots) {
-        case 15:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_15, sizeof(FRAME_INFO));
-          break;
-        case 16:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_16, sizeof(FRAME_INFO));
-          break;
-        default:
-          FDK_ASSERT(0);
-      }
-      break;
-    case 8:
-#if (MAX_ENVELOPES >= 8)
-      switch (numberTimeSlots) {
-        case 15:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_15, sizeof(FRAME_INFO));
-          break;
-        case 16:
-          FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_16, sizeof(FRAME_INFO));
-          break;
-        default:
-          FDK_ASSERT(0);
-      }
-      break;
-#else
-      return 0;
-#endif
-    }
-    /* Apply correct freqRes (High is default) */
-    if (!staticFreqRes) {
-      for (i = 0; i < nEnv ; i++)
-        pFrameInfo->freqRes[i] = 0;
-    }
-
-    break;
-  case 1:
-  case 2:
-    temp = FDKreadBits (hBs, 2);  /* A [2 bits] */
-
-    n    = FDKreadBits (hBs, 2);  /* n = N [2 bits] */
-
-    nEnv = n + 1;                             /* # envelopes */
-    b = nEnv + 1;                             /* # borders   */
-
-    break;
-  }
-
-  switch (frameClass) {
-  case 1:
-    /* Decode borders: */
-    pFrameInfo->borders[0] = 0;               /* first border          */
-    border = temp + numberTimeSlots;          /* A -> aR               */
-    i = b-1;                                  /* frame info index for last border */
-    pFrameInfo->borders[i] = border;          /* last border                      */
-
-    for (k = 0; k < n; k++) {
-      temp = FDKreadBits (hBs, 2);/* R [2 bits] */
-      border -= (2 * temp + 2);               /* R -> r                */
-      pFrameInfo->borders[--i] = border;
-    }
-
-
-    /* Decode pointer: */
-    pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n+1));
-    p = FDKreadBits (hBs, pointer_bits);     /* p = P [pointer_bits bits] */
-
-    if (p > n+1)
-      return 0;
-
-    pFrameInfo->tranEnv = p ? n + 2 - p : -1;
-
-
-    /* Decode freq res: */
-    for (k = n; k >= 0; k--) {
-      pFrameInfo->freqRes[k] = FDKreadBits (hBs, 1); /* f = F [1 bits] */
-    }
-
-
-    /* Calculate noise floor middle border: */
-    if (p == 0 || p == 1)
-      pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
-    else
-      pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
-
-    break;
-
-  case 2:
-    /* Decode borders: */
-    border = temp;                            /* A -> aL */
-    pFrameInfo->borders[0] = border;          /* first border */
-
-    for (k = 1; k <= n; k++) {
-      temp = FDKreadBits (hBs, 2);/* R [2 bits] */
-      border += (2 * temp + 2);               /* R -> r                */
-      pFrameInfo->borders[k] = border;
-    }
-    pFrameInfo->borders[k] = numberTimeSlots; /* last border */
-
-
-    /* Decode pointer: */
-    pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n+1));
-    p = FDKreadBits (hBs, pointer_bits);     /* p = P [pointer_bits bits] */
-    if (p > n+1)
-      return 0;
-
-    if (p == 0 || p == 1)
-      pFrameInfo->tranEnv = -1;
-    else
-      pFrameInfo->tranEnv = p - 1;
-
-
-
-    /* Decode freq res: */
-    for (k = 0; k <= n; k++) {
-      pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
-    }
-
-
-
-    /* Calculate noise floor middle border: */
-    switch (p) {
-    case 0:
-      pFrameInfo->bordersNoise[1] = pFrameInfo->borders[1];
-      break;
-    case 1:
-      pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
-      break;
-    default:
-      pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
-      break;
-    }
-
-    break;
-
-  case 3:
-    /* v_ctrlSignal = [frameClass,aL,aR,nL,nR,v_rL,v_rR,p,v_fLR]; */
-
-    aL = FDKreadBits (hBs, 2);       /* AL [2 bits], AL -> aL */
-
-    aR = FDKreadBits (hBs, 2) + numberTimeSlots;     /* AR [2 bits], AR -> aR */
-
-    nL = FDKreadBits (hBs, 2);       /* nL = NL [2 bits] */
-
-    nR = FDKreadBits (hBs, 2);       /* nR = NR [2 bits] */
-
-
-
-    /*-------------------------------------------------------------------------
-      Calculate help variables
-      --------------------------------------------------------------------------*/
-
-    /* general: */
-    nEnv = nL + nR + 1;            /* # envelopes */
-    if (nEnv > MAX_ENVELOPES)
-      return 0;
-    b = nEnv + 1;                  /* # borders   */
-
-
-
-    /*-------------------------------------------------------------------------
-      Decode envelopes
-      --------------------------------------------------------------------------*/
-
-
-    /* L-borders:   */
-    border            = aL;                   /* first border */
-    pFrameInfo->borders[0] = border;
-
-    for (k = 1; k <= nL; k++) {
-      temp = FDKreadBits (hBs, 2);/* R [2 bits] */
-      border += (2 * temp + 2);               /* R -> r                */
-      pFrameInfo->borders[k] = border;
-    }
-
-
-    /* R-borders:  */
-    border = aR;                              /* last border */
-    i      = nEnv;
-
-    pFrameInfo->borders[i] = border;
-
-    for (k = 0; k < nR; k++) {
-      temp = FDKreadBits (hBs, 2);/* R [2 bits] */
-      border -= (2 * temp + 2);               /* R -> r                */
-      pFrameInfo->borders[--i] = border;
-    }
-
-
-    /* decode pointer: */
-    pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(nL+nR+1));
-    p = FDKreadBits (hBs, pointer_bits);     /* p = P [pointer_bits bits] */
-
-    if (p > nL+nR+1)
-      return 0;
-
-    pFrameInfo->tranEnv = p ? b - p : -1;
-
-
-
-    /* decode freq res: */
-    for (k = 0; k < nEnv; k++) {
-      pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
-    }
-
-
-
-    /*-------------------------------------------------------------------------
-      Decode noise floors
-      --------------------------------------------------------------------------*/
-    pFrameInfo->bordersNoise[0] = aL;
-
-    if (nEnv == 1) {
-      /* 1 noise floor envelope: */
-      pFrameInfo->bordersNoise[1] = aR;
-    }
-    else {
-      /* 2 noise floor envelopes */
-      if (p == 0 || p == 1)
-        pFrameInfo->bordersNoise[1] = pFrameInfo->borders[nEnv - 1];
-      else
-        pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
-      pFrameInfo->bordersNoise[2] = aR;
-    }
-    break;
-  }
-
-
-  /*
-    Store number of envelopes, noise floor envelopes and frame class
-  */
-  pFrameInfo->nEnvelopes = nEnv;
-
-  if (nEnv == 1)
-    pFrameInfo->nNoiseEnvelopes = 1;
-  else
-    pFrameInfo->nNoiseEnvelopes = 2;
-
-  pFrameInfo->frameClass = frameClass;
-
-  if (pFrameInfo->frameClass == 2 || pFrameInfo->frameClass == 1) {
-    /* calculate noise floor first and last borders: */
-    pFrameInfo->bordersNoise[0] = pFrameInfo->borders[0];
-    pFrameInfo->bordersNoise[pFrameInfo->nNoiseEnvelopes] = pFrameInfo->borders[nEnv];
-  }
-
-
-  return 1;
-}
-
-
-/*!
-  \brief   Check if the frameInfo vector has reasonable values.
-  \return  Zero for error, one for correct
-*/
-static int
-checkFrameInfo (FRAME_INFO * pFrameInfo, /*!< pointer to frameInfo */
-                int numberOfTimeSlots,   /*!< QMF time slots per frame */
-                int overlap,             /*!< Amount of overlap QMF time slots */
-                int timeStep)            /*!< QMF slots to SBR slots step factor */
-{
-  int maxPos,i,j;
-  int startPos;
-  int stopPos;
-  int tranEnv;
-  int startPosNoise;
-  int stopPosNoise;
-  int nEnvelopes = pFrameInfo->nEnvelopes;
-  int nNoiseEnvelopes = pFrameInfo->nNoiseEnvelopes;
-
-  if(nEnvelopes < 1 || nEnvelopes > MAX_ENVELOPES)
-    return 0;
-
-  if(nNoiseEnvelopes > MAX_NOISE_ENVELOPES)
-    return 0;
-
-  startPos        = pFrameInfo->borders[0];
-  stopPos         = pFrameInfo->borders[nEnvelopes];
-  tranEnv         = pFrameInfo->tranEnv;
-  startPosNoise   = pFrameInfo->bordersNoise[0];
-  stopPosNoise    = pFrameInfo->bordersNoise[nNoiseEnvelopes];
-
-  if (overlap < 0 || overlap > (6)) {
-    return 0;
-  }
-  if (timeStep < 1 || timeStep > 2) {
-    return 0;
-  }
-  maxPos = numberOfTimeSlots + (overlap/timeStep);
-
-  /* Check that the start and stop positions of the frame are reasonable values. */
-  if( (startPos < 0) || (startPos >= stopPos) )
-    return 0;
-  if( startPos > maxPos-numberOfTimeSlots ) /* First env. must start in or directly after the overlap buffer */
-    return 0;
-  if( stopPos < numberOfTimeSlots ) /* One complete frame must be ready for output after processing */
-    return 0;
-  if(stopPos > maxPos)
-    return 0;
-
-  /* Check that the  start border for every envelope is strictly later in time */
-  for(i=0;i<nEnvelopes;i++) {
-    if(pFrameInfo->borders[i] >= pFrameInfo->borders[i+1])
-      return 0;
-  }
-
-  /* Check that the envelope to be shortened is actually among the envelopes */
-  if(tranEnv>nEnvelopes)
-    return 0;
-
-
-  /* Check the noise borders */
-  if(nEnvelopes==1 && nNoiseEnvelopes>1)
-    return 0;
-
-  if(startPos != startPosNoise || stopPos != stopPosNoise)
-    return 0;
-
-
-  /* Check that the  start border for every noise-envelope is strictly later in time*/
-  for(i=0; i<nNoiseEnvelopes; i++) {
-    if(pFrameInfo->bordersNoise[i] >= pFrameInfo->bordersNoise[i+1])
-      return 0;
-  }
-
-  /* Check that every noise border is the same as an envelope border*/
-  for(i=0; i<nNoiseEnvelopes; i++) {
-    startPosNoise = pFrameInfo->bordersNoise[i];
-
-    for(j=0; j<nEnvelopes; j++) {
-      if(pFrameInfo->borders[j] == startPosNoise)
-        break;
-    }
-    if(j==nEnvelopes)
-      return 0;
-  }
-
-  return 1;
-}
diff --git a/libSBRdec/src/env_extr.h b/libSBRdec/src/env_extr.h
deleted file mode 100644
index 5db6d3d..0000000
--- a/libSBRdec/src/env_extr.h
+++ /dev/null
@@ -1,319 +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  Envelope extraction prototypes  
-*/
-
-#ifndef __ENVELOPE_EXTRACTION_H
-#define __ENVELOPE_EXTRACTION_H
-
-#include "sbrdecoder.h"
-
-#include "FDK_bitstream.h"
-#include "lpp_tran.h"
-
-#include "psdec.h"
-
-#define ENV_EXP_FRACT 0
-/*!< Shift raw envelope data to support fractional numbers.
-  Can be set to 8 instead of 0 to enhance accuracy during concealment.
-  This is not required for conformance and #requantizeEnvelopeData() will
-  become more expensive.
-*/
-
-#define EXP_BITS 6
-/*!< Size of exponent-part of a pseudo float envelope value (should be at least 6).
-  The remaining bits in each word are used for the mantissa (should be at least 10).
-  This format is used in the arrays iEnvelope[] and sbrNoiseFloorLevel[]
-  in the FRAME_DATA struct which must fit in a certain part of the output buffer
-  (See buffer management in sbr_dec.cpp).
-  Exponents and mantissas could also be stored in separate arrays.
-  Accessing the exponent or the mantissa would be simplified and the masks #MASK_E
-  resp. #MASK_M would   no longer be required.
-*/
-
-#define MASK_M (((1 << (FRACT_BITS - EXP_BITS)) - 1) << EXP_BITS)  /*!< Mask for extracting the mantissa of a pseudo float envelope value */
-#define MASK_E ((1 << EXP_BITS) - 1)           /*!< Mask for extracting the exponent of a pseudo float envelope value */
-
-#define SIGN_EXT ( ((SCHAR)-1) ^ MASK_E)        /*!< a CHAR-constant with all bits above our sign-bit set */
-#define ROUNDING ( (FIXP_SGL)(1<<(EXP_BITS-1)) ) /*!< 0.5-offset for rounding the mantissa of a pseudo-float envelope value */
-#define NRG_EXP_OFFSET  16                     /*!< Will be added to the reference energy's exponent to prevent negative numbers */
-#define NOISE_EXP_OFFSET  38                   /*!< Will be added to the noise level exponent to prevent negative numbers */
-
-typedef enum
-{
-  HEADER_NOT_PRESENT,
-  HEADER_OK,
-  HEADER_RESET
-}
-SBR_HEADER_STATUS;
-
-typedef enum
-{
-  SBR_NOT_INITIALIZED,
-  UPSAMPLING,
-  SBR_HEADER,
-  SBR_ACTIVE
-}
-SBR_SYNC_STATE;
-
-
-typedef enum
-{
-  COUPLING_OFF = 0,
-  COUPLING_LEVEL,
-  COUPLING_BAL
-}
-COUPLING_MODE;
-
-typedef struct
-{
-  UCHAR nSfb[2];           /*!< Number of SBR-bands for low and high freq-resolution */
-  UCHAR nNfb;              /*!< Actual number of noise bands to read from the bitstream*/
-  UCHAR numMaster;         /*!< Number of SBR-bands in v_k_master */
-  UCHAR lowSubband;        /*!< QMF-band where SBR frequency range starts */
-  UCHAR highSubband;       /*!< QMF-band where SBR frequency range ends */
-  UCHAR limiterBandTable[MAX_NUM_LIMITERS+1]; /*!< Limiter band table. */
-  UCHAR noLimiterBands;    /*!< Number of limiter bands. */
-  UCHAR nInvfBands;        /*!< Number of bands for inverse filtering */
-  UCHAR *freqBandTable[2]; /*!< Pointers to freqBandTableLo and freqBandTableHi */
-  UCHAR freqBandTableLo[MAX_FREQ_COEFFS/2+1];
-                                   /*!< Mapping of SBR bands to QMF bands for low frequency resolution */
-  UCHAR freqBandTableHi[MAX_FREQ_COEFFS+1];
-                                   /*!< Mapping of SBR bands to QMF bands for high frequency resolution */
-  UCHAR freqBandTableNoise[MAX_NOISE_COEFFS+1];
-                                   /*!< Mapping of SBR noise bands to QMF bands */
-  UCHAR v_k_master[MAX_FREQ_COEFFS+1];
-                                   /*!< Master BandTable which freqBandTable is derived from */
-}
-FREQ_BAND_DATA;
-
-typedef FREQ_BAND_DATA *HANDLE_FREQ_BAND_DATA;
-
-#define SBRDEC_ELD_GRID        1
-#define SBRDEC_SYNTAX_SCAL     2
-#define SBRDEC_SYNTAX_USAC     4
-#define SBRDEC_SYNTAX_RSVD50   8
-#define SBRDEC_LOW_POWER      16  /* Flag indicating that Low Power QMF mode shall be used. */
-#define SBRDEC_PS_DECODED     32  /* Flag indicating that PS was decoded and rendered. */
-#define SBRDEC_LD_MPS_QMF    512  /* Flag indicating that the LD-MPS QMF shall be used. */
-
-#define SBRDEC_HDR_STAT_RESET  1
-#define SBRDEC_HDR_STAT_UPDATE 2
-
-typedef struct {
-  UCHAR ampResolution;       /*!< Amplitude resolution of envelope values (0: 1.5dB, 1: 3dB) */
-  UCHAR xover_band;          /*!< Start index in #v_k_master[] used for dynamic crossover frequency */
-  UCHAR sbr_preprocessing;   /*!< SBR prewhitening flag. */
-} SBR_HEADER_DATA_BS_INFO;
-
-typedef struct {
-  /* Changes in these variables causes a reset of the decoder */
-  UCHAR startFreq;           /*!< Index for SBR start frequency */
-  UCHAR stopFreq;            /*!< Index for SBR highest frequency */
-  UCHAR freqScale;           /*!< 0: linear scale,  1-3 logarithmic scales */
-  UCHAR alterScale;          /*!< Flag for coarser frequency resolution */
-  UCHAR noise_bands;         /*!< Noise bands per octave, read from bitstream*/
-
-  /* don't require reset */
-  UCHAR limiterBands;        /*!< Index for number of limiter bands per octave */
-  UCHAR limiterGains;        /*!< Index to select gain limit */
-  UCHAR interpolFreq;        /*!< Select gain calculation method (1: per QMF channel, 0: per SBR band) */
-  UCHAR smoothingLength;     /*!< Smoothing of gains over time (0: on  1: off) */
-
-} SBR_HEADER_DATA_BS;
-
-typedef struct
-{
-  SBR_SYNC_STATE syncState;    /*!< The current initialization status of the header */
-
-  UCHAR status;                /*!< Flags field used for signaling a reset right before the processing starts and an update from config (e.g. ASC). */
-  UCHAR frameErrorFlag;        /*!< Frame data valid flag. CAUTION: This variable will be overwritten by the flag stored in the element structure.
-                                    This is necessary because of the frame delay. There it might happen that different slots use the same header. */
-  UCHAR numberTimeSlots;       /*!< AAC: 16,15 */
-  UCHAR numberOfAnalysisBands; /*!< Number of QMF analysis bands */
-  UCHAR timeStep;              /*!< Time resolution of SBR in QMF-slots */
-  UINT  sbrProcSmplRate;       /*!< SBR processing sampling frequency (!= OutputSamplingRate)
-                                     (always: CoreSamplingRate * UpSamplingFactor; even in single rate mode) */
-
-  SBR_HEADER_DATA_BS      bs_data;  /*!< current SBR header. */
-  SBR_HEADER_DATA_BS_INFO bs_info;  /*!< SBR info. */
-
-  FREQ_BAND_DATA freqBandData;  /*!< Pointer to struct #FREQ_BAND_DATA */
-}
-SBR_HEADER_DATA;
-
-typedef SBR_HEADER_DATA *HANDLE_SBR_HEADER_DATA;
-
-
-typedef struct
-{
-  UCHAR frameClass;               /*!< Select grid type */
-  UCHAR nEnvelopes;               /*!< Number of envelopes */
-  UCHAR borders[MAX_ENVELOPES+1]; /*!< Envelope borders (in SBR-timeslots, e.g. mp3PRO: 0..11) */
-  UCHAR freqRes[MAX_ENVELOPES];   /*!< Frequency resolution for each envelope (0=low, 1=high) */
-  SCHAR  tranEnv;                 /*!< Transient envelope, -1 if none */
-  UCHAR nNoiseEnvelopes;          /*!< Number of noise envelopes */
-  UCHAR bordersNoise[MAX_NOISE_ENVELOPES+1];/*!< borders of noise envelopes */
-}
-FRAME_INFO;
-
-
-typedef struct
-{
-  FIXP_SGL sfb_nrg_prev[MAX_FREQ_COEFFS];    /*!< Previous envelope (required for differential-coded values) */
-  FIXP_SGL prevNoiseLevel[MAX_NOISE_COEFFS]; /*!< Previous noise envelope (required for differential-coded values) */
-  COUPLING_MODE coupling;                    /*!< Stereo-mode of previous frame */
-  INVF_MODE sbr_invf_mode[MAX_INVF_BANDS];   /*!< Previous strength of filtering in transposer */
-  UCHAR ampRes;                              /*!< Previous amplitude resolution (0: 1.5dB, 1: 3dB) */
-  UCHAR stopPos;                             /*!< Position in time where last envelope ended */
-  UCHAR frameErrorFlag;                      /*!< Previous frame status */
-}
-SBR_PREV_FRAME_DATA;
-
-typedef SBR_PREV_FRAME_DATA *HANDLE_SBR_PREV_FRAME_DATA;
-
-
-typedef struct
-{
-  int nScaleFactors;                    /*!< total number of scalefactors in frame */
-
-  FRAME_INFO frameInfo;                 /*!< time grid for current frame */
-  UCHAR domain_vec[MAX_ENVELOPES];      /*!< Bitfield containing direction of delta-coding for each envelope (0:frequency, 1:time) */
-  UCHAR domain_vec_noise[MAX_NOISE_ENVELOPES]; /*!< Same as above, but for noise envelopes */
-
-  INVF_MODE sbr_invf_mode[MAX_INVF_BANDS]; /*!< Strength of filtering in transposer */
-  COUPLING_MODE coupling;                  /*!< Stereo-mode */
-  int ampResolutionCurrentFrame;           /*!< Amplitude resolution of envelope values (0: 1.5dB, 1: 3dB) */
-
-  UCHAR addHarmonics[MAX_FREQ_COEFFS];     /*!< Flags for synthetic sine addition */
-
-  FIXP_SGL iEnvelope[MAX_NUM_ENVELOPE_VALUES];       /*!< Envelope data */
-  FIXP_SGL sbrNoiseFloorLevel[MAX_NUM_NOISE_VALUES]; /*!< Noise envelope data */
-}
-SBR_FRAME_DATA;
-
-typedef SBR_FRAME_DATA *HANDLE_SBR_FRAME_DATA;
-
-void initSbrPrevFrameData (HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
-                           int timeSlots);
-
-
-int sbrGetSingleChannelElement (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                HANDLE_SBR_FRAME_DATA  hFrameData,
-                                HANDLE_FDK_BITSTREAM   hBitBuf,
-                                HANDLE_PS_DEC hParametricStereoDec,
-                                const UINT             flags,
-                                const int              overlap
-                               );
-
-int sbrGetChannelPairElement (HANDLE_SBR_HEADER_DATA hHeaderData,
-                              HANDLE_SBR_FRAME_DATA  hFrameDataLeft,
-                              HANDLE_SBR_FRAME_DATA  hFrameDataRight,
-                              HANDLE_FDK_BITSTREAM   hBitBuf,
-                              const UINT             flags,
-                              const int              overlap);
-
-SBR_HEADER_STATUS
-sbrGetHeaderData (HANDLE_SBR_HEADER_DATA headerData,
-                  HANDLE_FDK_BITSTREAM   hBitBuf,
-                  const UINT             flags,
-                  const int              fIsSbrData);
-
-/*!
-  \brief     Initialize SBR header data
-
-  Copy default values to the header data struct and patch some entries
-  depending on the core codec.
-*/
-SBR_ERROR
-initHeaderData (
-        HANDLE_SBR_HEADER_DATA  hHeaderData,
-        const int               sampleRateIn,
-        const int               sampleRateOut,
-        const int               samplesPerFrame,
-        const UINT              flags
-        );
-#endif
diff --git a/libSBRdec/src/huff_dec.cpp b/libSBRdec/src/huff_dec.cpp
deleted file mode 100644
index 31d686d..0000000
--- a/libSBRdec/src/huff_dec.cpp
+++ /dev/null
@@ -1,120 +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  Huffman Decoder  
-*/
-
-#include "huff_dec.h"
-
-/***************************************************************************/
-/*!
-  \brief     Decodes one huffman code word
-
-  Reads bits from the bitstream until a valid codeword is found.
-  The table entries are interpreted either as index to the next entry
-  or - if negative - as the codeword.
-
-  \return    decoded value
-
-  \author
-
-****************************************************************************/
-int
-DecodeHuffmanCW (Huffman h,                /*!< pointer to huffman codebook table */
-                 HANDLE_FDK_BITSTREAM hBs) /*!< Handle to Bitbuffer */
-{
-  SCHAR index = 0;
-  int value, bit;
-
-  while (index >= 0) {
-    bit = FDKreadBits (hBs, 1);
-    index = h[index][bit];
-  }
-
-  value = index+64; /* Add offset */
-
-
-  return value;
-}
diff --git a/libSBRdec/src/huff_dec.h b/libSBRdec/src/huff_dec.h
deleted file mode 100644
index 5443658..0000000
--- a/libSBRdec/src/huff_dec.h
+++ /dev/null
@@ -1,100 +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  Huffman Decoder  
-*/
-#ifndef __HUFF_DEC_H
-#define __HUFF_DEC_H
-
-#include "sbrdecoder.h"
-#include "FDK_bitstream.h"
-
-typedef const SCHAR (*Huffman)[2];
-
-int
-DecodeHuffmanCW (Huffman h,
-                 HANDLE_FDK_BITSTREAM hBitBuf);
-
-#endif
diff --git a/libSBRdec/src/lpp_tran.cpp b/libSBRdec/src/lpp_tran.cpp
deleted file mode 100644
index 117e739..0000000
--- a/libSBRdec/src/lpp_tran.cpp
+++ /dev/null
@@ -1,986 +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  Low Power Profile Transposer,  
-  This module provides the transposer. The main entry point is lppTransposer(). The function generates
-  high frequency content by copying data from the low band (provided by core codec) into the high band.
-  This process is also referred to as "patching". The function also implements spectral whitening by means of
-  inverse filtering based on LPC coefficients.
-
-  Together with the QMF filterbank the transposer can be tested using a supplied test program. See main_audio.cpp for details.
-  This module does use fractional arithmetic and the accuracy of the computations has an impact on the overall sound quality.
-  The module also needs to take into account the different scaling of spectral data.
-
-  \sa lppTransposer(), main_audio.cpp, sbr_scale.h, \ref documentationOverview
-*/
-
-#include "lpp_tran.h"
-
-#include "sbr_ram.h"
-#include "sbr_rom.h"
-
-#include "genericStds.h"
-#include "autocorr2nd.h"
-
-
-
-#if defined(__arm__)
-#include "arm/lpp_tran_arm.cpp"
-#endif
-
-
-
-#define LPC_SCALE_FACTOR  2
-
-
-/*!
- *
- * \brief Get bandwidth expansion factor from filtering level
- *
- * Returns a filter parameter (bandwidth expansion factor) depending on
- * the desired filtering level signalled in the bitstream.
- * When switching the filtering level from LOW to OFF, an additional
- * level is being inserted to achieve a smooth transition.
- */
-
-#ifndef FUNCTION_mapInvfMode
-static FIXP_DBL
-mapInvfMode (INVF_MODE mode,
-             INVF_MODE prevMode,
-             WHITENING_FACTORS whFactors)
-{
-  switch (mode) {
-  case INVF_LOW_LEVEL:
-    if(prevMode == INVF_OFF)
-      return whFactors.transitionLevel;
-    else
-      return whFactors.lowLevel;
-
-  case INVF_MID_LEVEL:
-    return whFactors.midLevel;
-
-  case INVF_HIGH_LEVEL:
-    return whFactors.highLevel;
-
-  default:
-    if(prevMode == INVF_LOW_LEVEL)
-      return whFactors.transitionLevel;
-    else
-      return whFactors.off;
-  }
-}
-#endif /* #ifndef FUNCTION_mapInvfMode */
-
-/*!
- *
- * \brief Perform inverse filtering level emphasis
- *
- * Retrieve bandwidth expansion factor and apply smoothing for each filter band
- *
- */
-
-#ifndef FUNCTION_inverseFilteringLevelEmphasis
-static void
-inverseFilteringLevelEmphasis(HANDLE_SBR_LPP_TRANS hLppTrans,/*!< Handle of lpp transposer  */
-                              UCHAR nInvfBands,              /*!< Number of bands for inverse filtering */
-                              INVF_MODE *sbr_invf_mode,      /*!< Current inverse filtering modes */
-                              INVF_MODE *sbr_invf_mode_prev, /*!< Previous inverse filtering modes */
-                              FIXP_DBL * bwVector            /*!< Resulting filtering levels */
-                              )
-{
-  for(int i = 0; i < nInvfBands; i++) {
-    FIXP_DBL accu;
-    FIXP_DBL bwTmp = mapInvfMode (sbr_invf_mode[i],
-                                  sbr_invf_mode_prev[i],
-                                  hLppTrans->pSettings->whFactors);
-
-    if(bwTmp < hLppTrans->bwVectorOld[i]) {
-      accu = fMultDiv2(FL2FXCONST_DBL(0.75f),bwTmp) +
-             fMultDiv2(FL2FXCONST_DBL(0.25f),hLppTrans->bwVectorOld[i]);
-    }
-    else {
-      accu = fMultDiv2(FL2FXCONST_DBL(0.90625f),bwTmp) +
-             fMultDiv2(FL2FXCONST_DBL(0.09375f),hLppTrans->bwVectorOld[i]);
-    }
-
-    if (accu <  FL2FXCONST_DBL(0.015625f)>>1)
-      bwVector[i] = FL2FXCONST_DBL(0.0f);
-    else
-      bwVector[i] = fixMin(accu<<1,FL2FXCONST_DBL(0.99609375f));
-  }
-}
-#endif /* #ifndef FUNCTION_inverseFilteringLevelEmphasis */
-
-/* Resulting autocorrelation determinant exponent */
-#define ACDET_EXP (2*(DFRACT_BITS+sbrScaleFactor->lb_scale+10-ac.det_scale))
-#define AC_EXP (-sbrScaleFactor->lb_scale+LPC_SCALE_FACTOR)
-#define ALPHA_EXP (-sbrScaleFactor->lb_scale+LPC_SCALE_FACTOR+1)
-/* Resulting transposed QMF values exponent 16 bit normalized samplebits assumed. */
-#define QMFOUT_EXP ((SAMPLE_BITS-15)-sbrScaleFactor->lb_scale)
-
-/*!
- *
- * \brief Perform transposition by patching of subband samples.
- * This function serves as the main entry point into the module. The function determines the areas for the
- * patching process (these are the source range as well as the target range) and implements spectral whitening
- * by means of inverse filtering. The function autoCorrelation2nd() is an auxiliary function for calculating the
- * LPC coefficients for the filtering.  The actual calculation of the LPC coefficients and the implementation
- * of the filtering are done as part of lppTransposer().
- *
- * Note that the filtering is done on all available QMF subsamples, whereas the patching is only done on those QMF
- * subsamples that will be used in the next QMF synthesis. The filtering is also implemented before the patching
- * includes further dependencies on parameters from the SBR data.
- *
- */
-
-void lppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,    /*!< Handle of lpp transposer  */
-                    QMF_SCALE_FACTOR  *sbrScaleFactor, /*!< Scaling factors */
-                    FIXP_DBL **qmfBufferReal,          /*!< Pointer to pointer to real part of subband samples (source) */
-
-                    FIXP_DBL *degreeAlias,             /*!< Vector for results of aliasing estimation */
-                    FIXP_DBL **qmfBufferImag,          /*!< Pointer to pointer to imaginary part of subband samples (source) */
-                    const int useLP,
-                    const int timeStep,                /*!< Time step of envelope */
-                    const int firstSlotOffs,           /*!< Start position in time */
-                    const int lastSlotOffs,            /*!< Number of overlap-slots into next frame */
-                    const int nInvfBands,              /*!< Number of bands for inverse filtering */
-                    INVF_MODE *sbr_invf_mode,          /*!< Current inverse filtering modes */
-                    INVF_MODE *sbr_invf_mode_prev      /*!< Previous inverse filtering modes */
-                    )
-{
-  INT    bwIndex[MAX_NUM_PATCHES];
-  FIXP_DBL  bwVector[MAX_NUM_PATCHES];       /*!< pole moving factors */
-
-  int    i;
-  int    loBand, start, stop;
-  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;
-  PATCH_PARAM *patchParam = pSettings->patchParam;
-  int    patch;
-
-  FIXP_SGL  alphar[LPC_ORDER], a0r, a1r;
-  FIXP_SGL  alphai[LPC_ORDER], a0i=0, a1i=0;
-  FIXP_SGL  bw = FL2FXCONST_SGL(0.0f);
-
-  int    autoCorrLength;
-
-  FIXP_DBL k1, k1_below=0, k1_below2=0;
-
-  ACORR_COEFS ac;
-  int    startSample;
-  int    stopSample;
-  int    stopSampleClear;
-
-  int comLowBandScale;
-  int ovLowBandShift;
-  int lowBandShift;
-/*  int ovHighBandShift;*/
-  int targetStopBand;
-
-
-  alphai[0] = FL2FXCONST_SGL(0.0f);
-  alphai[1] = FL2FXCONST_SGL(0.0f);
-
-
-  startSample = firstSlotOffs * timeStep;
-  stopSample  = pSettings->nCols + lastSlotOffs * timeStep;
-
-
-  inverseFilteringLevelEmphasis(hLppTrans, nInvfBands, sbr_invf_mode, sbr_invf_mode_prev, bwVector);
-
-  stopSampleClear = stopSample;
-
-  autoCorrLength = pSettings->nCols + pSettings->overlap;
-
-  /* Set upper subbands to zero:
-     This is required in case that the patches do not cover the complete highband
-     (because the last patch would be too short).
-     Possible optimization: Clearing bands up to usb would be sufficient here. */
-  targetStopBand = patchParam[pSettings->noOfPatches-1].targetStartBand
-                 + patchParam[pSettings->noOfPatches-1].numBandsInPatch;
-
-  int memSize = ((64) - targetStopBand) * sizeof(FIXP_DBL);
-
-  if (!useLP) {
-    for (i = startSample; i < stopSampleClear; i++) {
-      FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);
-      FDKmemclear(&qmfBufferImag[i][targetStopBand], memSize);
-    }
-  } else
-  for (i = startSample; i < stopSampleClear; i++) {
-    FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);
-  }
-
-  /* init bwIndex for each patch */
-  FDKmemclear(bwIndex, pSettings->noOfPatches*sizeof(INT));
-
-  /*
-    Calc common low band scale factor
-  */
-  comLowBandScale = fixMin(sbrScaleFactor->ov_lb_scale,sbrScaleFactor->lb_scale);
-
-  ovLowBandShift =  sbrScaleFactor->ov_lb_scale - comLowBandScale;
-  lowBandShift   =  sbrScaleFactor->lb_scale - comLowBandScale;
-  /*  ovHighBandShift = firstSlotOffs == 0 ? ovLowBandShift:0;*/
-
-  /* outer loop over bands to do analysis only once for each band */
-
-  if (!useLP) {
-    start = pSettings->lbStartPatching;
-    stop = pSettings->lbStopPatching;
-  } else
-  {
-    start = fixMax(1, pSettings->lbStartPatching - 2);
-    stop = patchParam[0].targetStartBand;
-  }
-
-
-  for ( loBand = start; loBand <  stop; loBand++ ) {
-
-    FIXP_DBL  lowBandReal[(((1024)/(32))+(6))+LPC_ORDER];
-    FIXP_DBL *plowBandReal = lowBandReal;
-    FIXP_DBL **pqmfBufferReal = qmfBufferReal;
-    FIXP_DBL  lowBandImag[(((1024)/(32))+(6))+LPC_ORDER];
-    FIXP_DBL *plowBandImag = lowBandImag;
-    FIXP_DBL **pqmfBufferImag = qmfBufferImag;
-    int resetLPCCoeffs=0;
-    int dynamicScale = DFRACT_BITS-1-LPC_SCALE_FACTOR;
-    int acDetScale = 0; /* scaling of autocorrelation determinant */
-
-    for(i=0;i<LPC_ORDER;i++){
-      *plowBandReal++ = hLppTrans->lpcFilterStatesReal[i][loBand];
-      if (!useLP)
-        *plowBandImag++ = hLppTrans->lpcFilterStatesImag[i][loBand];
-    }
-
-    /*
-      Take old slope length qmf slot source values out of (overlap)qmf buffer
-    */
-    if (!useLP) {
-      for(i=0;i<pSettings->nCols+pSettings->overlap;i++){
-        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
-        *plowBandImag++ = (*pqmfBufferImag++)[loBand];
-      }
-    } else
-    {
-      /* pSettings->overlap is always even */
-      FDK_ASSERT((pSettings->overlap & 1) == 0);
-
-      for(i=0;i<((pSettings->overlap+pSettings->nCols)>>1);i++) {
-        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
-        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
-      }
-      if (pSettings->nCols & 1) {
-        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
-      }
-    }
-
-    /*
-      Determine dynamic scaling value.
-     */
-    dynamicScale = fixMin(dynamicScale, getScalefactor(lowBandReal, LPC_ORDER+pSettings->overlap) + ovLowBandShift);
-    dynamicScale = fixMin(dynamicScale, getScalefactor(&lowBandReal[LPC_ORDER+pSettings->overlap], pSettings->nCols) + lowBandShift);
-    if (!useLP) {
-      dynamicScale = fixMin(dynamicScale, getScalefactor(lowBandImag, LPC_ORDER+pSettings->overlap) + ovLowBandShift);
-      dynamicScale = fixMin(dynamicScale, getScalefactor(&lowBandImag[LPC_ORDER+pSettings->overlap], pSettings->nCols) + lowBandShift);
-    }
-    dynamicScale = fixMax(0, dynamicScale-1); /* one additional bit headroom to prevent -1.0 */
-
-    /*
-      Scale temporal QMF buffer.
-     */
-    scaleValues(&lowBandReal[0], LPC_ORDER+pSettings->overlap, dynamicScale-ovLowBandShift);
-    scaleValues(&lowBandReal[LPC_ORDER+pSettings->overlap], pSettings->nCols, dynamicScale-lowBandShift);
-
-    if (!useLP) {
-      scaleValues(&lowBandImag[0], LPC_ORDER+pSettings->overlap, dynamicScale-ovLowBandShift);
-      scaleValues(&lowBandImag[LPC_ORDER+pSettings->overlap], pSettings->nCols, dynamicScale-lowBandShift);
-    }
-
-
-      if (!useLP) {
-        acDetScale += autoCorr2nd_cplx(&ac, lowBandReal+LPC_ORDER, lowBandImag+LPC_ORDER, autoCorrLength);
-      }
-      else
-      {
-        acDetScale += autoCorr2nd_real(&ac, lowBandReal+LPC_ORDER, autoCorrLength);
-      }
-
-      /* Examine dynamic of determinant in autocorrelation. */
-      acDetScale += 2*(comLowBandScale + dynamicScale);
-      acDetScale *= 2;              /* two times reflection coefficent scaling */
-      acDetScale += ac.det_scale;   /* ac scaling of determinant */
-
-      /* In case of determinant < 10^-38, resetLPCCoeffs=1 has to be enforced. */
-      if (acDetScale>126 ) {
-        resetLPCCoeffs = 1;
-      }
-
-
-    alphar[1] = FL2FXCONST_SGL(0.0f);
-    if (!useLP)
-      alphai[1] = FL2FXCONST_SGL(0.0f);
-
-    if (ac.det != FL2FXCONST_DBL(0.0f)) {
-      FIXP_DBL tmp,absTmp,absDet;
-
-      absDet = fixp_abs(ac.det);
-
-      if (!useLP) {
-        tmp = ( fMultDiv2(ac.r01r,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) -
-              ( (fMultDiv2(ac.r01i,ac.r12i) + fMultDiv2(ac.r02r,ac.r11r)) >> (LPC_SCALE_FACTOR-1) );
-      } else
-      {
-        tmp = ( fMultDiv2(ac.r01r,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) -
-              ( fMultDiv2(ac.r02r,ac.r11r) >> (LPC_SCALE_FACTOR-1) );
-      }
-      absTmp = fixp_abs(tmp);
-
-      /*
-        Quick check: is first filter coeff >= 1(4)
-       */
-      {
-        INT scale;
-        FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);
-        scale = scale+ac.det_scale;
-
-        if ( (scale > 0) && (result >= (FIXP_DBL)MAXVAL_DBL>>scale) ) {
-          resetLPCCoeffs = 1;
-        }
-        else {
-          alphar[1] = FX_DBL2FX_SGL(scaleValue(result,scale));
-          if((tmp<FL2FX_DBL(0.0f)) ^ (ac.det<FL2FX_DBL(0.0f))) {
-            alphar[1] = -alphar[1];
-          }
-        }
-      }
-
-      if (!useLP)
-      {
-        tmp =  ( fMultDiv2(ac.r01i,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) +
-               ( (fMultDiv2(ac.r01r,ac.r12i) - (FIXP_DBL)fMultDiv2(ac.r02i,ac.r11r)) >> (LPC_SCALE_FACTOR-1) ) ;
-
-        absTmp = fixp_abs(tmp);
-
-        /*
-        Quick check: is second filter coeff >= 1(4)
-        */
-        {
-          INT scale;
-          FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);
-          scale = scale+ac.det_scale;
-
-          if ( (scale > 0) && (result >= /*FL2FXCONST_DBL(1.f)*/ (FIXP_DBL)MAXVAL_DBL>>scale) ) {
-            resetLPCCoeffs = 1;
-          }
-          else {
-            alphai[1] = FX_DBL2FX_SGL(scaleValue(result,scale));
-            if((tmp<FL2FX_DBL(0.0f)) ^ (ac.det<FL2FX_DBL(0.0f))) {
-              alphai[1] = -alphai[1];
-            }
-          }
-        }
-      }
-    }
-
-    alphar[0] =  FL2FXCONST_SGL(0.0f);
-    if (!useLP)
-      alphai[0] = FL2FXCONST_SGL(0.0f);
-
-    if ( ac.r11r != FL2FXCONST_DBL(0.0f) ) {
-
-      /* ac.r11r is always >=0 */
-      FIXP_DBL tmp,absTmp;
-
-      if (!useLP) {
-        tmp = (ac.r01r>>(LPC_SCALE_FACTOR+1)) +
-              (fMultDiv2(alphar[1],ac.r12r) + fMultDiv2(alphai[1],ac.r12i));
-      } else
-      {
-        if(ac.r01r>=FL2FXCONST_DBL(0.0f))
-          tmp = (ac.r01r>>(LPC_SCALE_FACTOR+1)) + fMultDiv2(alphar[1],ac.r12r);
-        else
-          tmp = -((-ac.r01r)>>(LPC_SCALE_FACTOR+1)) + fMultDiv2(alphar[1],ac.r12r);
-      }
-
-      absTmp = fixp_abs(tmp);
-
-      /*
-        Quick check: is first filter coeff >= 1(4)
-      */
-
-      if (absTmp >= (ac.r11r>>1)) {
-        resetLPCCoeffs=1;
-      }
-      else {
-        INT scale;
-        FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);
-        alphar[0] =  FX_DBL2FX_SGL(scaleValue(result,scale+1));
-
-        if((tmp>FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))
-          alphar[0] = -alphar[0];
-      }
-
-      if (!useLP)
-      {
-        tmp = (ac.r01i>>(LPC_SCALE_FACTOR+1)) +
-              (fMultDiv2(alphai[1],ac.r12r) - fMultDiv2(alphar[1],ac.r12i));
-
-        absTmp = fixp_abs(tmp);
-
-        /*
-        Quick check: is second filter coeff >= 1(4)
-        */
-        if (absTmp >= (ac.r11r>>1)) {
-          resetLPCCoeffs=1;
-        }
-        else {
-          INT scale;
-          FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);
-          alphai[0] = FX_DBL2FX_SGL(scaleValue(result,scale+1));
-          if((tmp>FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))
-            alphai[0] = -alphai[0];
-        }
-      }
-    }
-
-
-    if (!useLP)
-    {
-      /* Now check the quadratic criteria */
-      if( (fMultDiv2(alphar[0],alphar[0]) + fMultDiv2(alphai[0],alphai[0])) >= FL2FXCONST_DBL(0.5f) )
-        resetLPCCoeffs=1;
-      if( (fMultDiv2(alphar[1],alphar[1]) + fMultDiv2(alphai[1],alphai[1])) >= FL2FXCONST_DBL(0.5f) )
-        resetLPCCoeffs=1;
-    }
-
-    if(resetLPCCoeffs){
-      alphar[0] = FL2FXCONST_SGL(0.0f);
-      alphar[1] = FL2FXCONST_SGL(0.0f);
-      if (!useLP)
-      {
-        alphai[0] = FL2FXCONST_SGL(0.0f);
-        alphai[1] = FL2FXCONST_SGL(0.0f);
-      }
-    }
-
-    if (useLP)
-    {
-
-      /* Aliasing detection */
-      if(ac.r11r==FL2FXCONST_DBL(0.0f)) {
-        k1 = FL2FXCONST_DBL(0.0f);
-      }
-      else {
-        if ( fixp_abs(ac.r01r) >= fixp_abs(ac.r11r) ) {
-          if ( fMultDiv2(ac.r01r,ac.r11r) < FL2FX_DBL(0.0f)) {
-            k1 = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_SGL(1.0f)*/;
-          }else {
-            /* Since this value is squared later, it must not ever become -1.0f. */
-            k1 = (FIXP_DBL)(MINVAL_DBL+1) /*FL2FXCONST_SGL(-1.0f)*/;
-          }
-        }
-        else {
-          INT scale;
-          FIXP_DBL result = fDivNorm(fixp_abs(ac.r01r), fixp_abs(ac.r11r), &scale);
-          k1 = scaleValue(result,scale);
-
-          if(!((ac.r01r<FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))) {
-            k1 = -k1;
-          }
-        }
-      }
-      if(loBand > 1){
-        /* Check if the gain should be locked */
-        FIXP_DBL deg = /*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - fPow2(k1_below);
-        degreeAlias[loBand] = FL2FXCONST_DBL(0.0f);
-        if (((loBand & 1) == 0) && (k1 < FL2FXCONST_DBL(0.0f))){
-          if (k1_below < FL2FXCONST_DBL(0.0f)) {         /* 2-Ch Aliasing Detection */
-            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;
-            if ( k1_below2 > FL2FXCONST_DBL(0.0f) ) {    /* 3-Ch Aliasing Detection */
-              degreeAlias[loBand-1] = deg;
-            }
-          }
-          else if ( k1_below2 > FL2FXCONST_DBL(0.0f) ) { /* 3-Ch Aliasing Detection */
-            degreeAlias[loBand]   = deg;
-          }
-        }
-        if (((loBand & 1) == 1) && (k1 > FL2FXCONST_DBL(0.0f))){
-          if (k1_below > FL2FXCONST_DBL(0.0f)) {         /* 2-CH Aliasing Detection */
-            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;
-            if ( k1_below2 < FL2FXCONST_DBL(0.0f) ) {    /* 3-CH Aliasing Detection */
-              degreeAlias[loBand-1] = deg;
-            }
-          }
-          else if ( k1_below2 < FL2FXCONST_DBL(0.0f) ) { /* 3-CH Aliasing Detection */
-            degreeAlias[loBand]   = deg;
-          }
-        }
-      }
-      /* remember k1 values of the 2 QMF channels below the current channel */
-      k1_below2 = k1_below;
-      k1_below = k1;
-    }
-
-    patch = 0;
-
-    while ( patch < pSettings->noOfPatches ) { /* inner loop over every patch */
-
-      int hiBand = loBand + patchParam[patch].targetBandOffs;
-
-      if ( loBand < patchParam[patch].sourceStartBand
-           || loBand >= patchParam[patch].sourceStopBand
-           //|| hiBand >= hLppTrans->pSettings->noChannels
-           ) {
-        /* Lowband not in current patch - proceed */
-        patch++;
-        continue;
-      }
-
-      FDK_ASSERT( hiBand < (64) );
-
-      /* bwIndex[patch] is already initialized with value from previous band inside this patch */
-      while (hiBand >= pSettings->bwBorders[bwIndex[patch]])
-        bwIndex[patch]++;
-
-
-      /*
-        Filter Step 2: add the left slope with the current filter to the buffer
-                       pure source values are already in there
-      */
-      bw = FX_DBL2FX_SGL(bwVector[bwIndex[patch]]);
-
-      a0r = FX_DBL2FX_SGL(fMult(bw,alphar[0])); /* Apply current bandwidth expansion factor */
-
-
-      if (!useLP)
-        a0i = FX_DBL2FX_SGL(fMult(bw,alphai[0]));
-      bw =  FX_DBL2FX_SGL(fPow2(bw));
-      a1r = FX_DBL2FX_SGL(fMult(bw,alphar[1]));
-      if (!useLP)
-        a1i = FX_DBL2FX_SGL(fMult(bw,alphai[1]));
-
-
-
-      /*
-        Filter Step 3: insert the middle part which won't be windowed
-      */
-
-      if ( bw <= FL2FXCONST_SGL(0.0f) ) {
-        if (!useLP) {
-          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
-          for(i = startSample; i < stopSample; i++ ) {
-            qmfBufferReal[i][hiBand] = lowBandReal[LPC_ORDER+i]>>descale;
-            qmfBufferImag[i][hiBand] = lowBandImag[LPC_ORDER+i]>>descale;
-          }
-        } else
-        {
-          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
-          for(i = startSample; i < stopSample; i++ ) {
-            qmfBufferReal[i][hiBand] = lowBandReal[LPC_ORDER+i]>>descale;
-          }
-        }
-      }
-      else {  /* bw <= 0 */
-
-        if (!useLP) {
-          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
-#ifdef FUNCTION_LPPTRANSPOSER_func1
-          lppTransposer_func1(lowBandReal+LPC_ORDER+startSample,lowBandImag+LPC_ORDER+startSample,
-                              qmfBufferReal+startSample,qmfBufferImag+startSample,
-                              stopSample-startSample, (int) hiBand,
-                              dynamicScale,descale,
-                              a0r, a0i, a1r, a1i);
-#else
-          for(i = startSample; i < stopSample; i++ ) {
-            FIXP_DBL accu1, accu2;
-
-            accu1 = (fMultDiv2(a0r,lowBandReal[LPC_ORDER+i-1]) - fMultDiv2(a0i,lowBandImag[LPC_ORDER+i-1]) +
-                     fMultDiv2(a1r,lowBandReal[LPC_ORDER+i-2]) - fMultDiv2(a1i,lowBandImag[LPC_ORDER+i-2]))>>dynamicScale;
-            accu2 = (fMultDiv2(a0i,lowBandReal[LPC_ORDER+i-1]) + fMultDiv2(a0r,lowBandImag[LPC_ORDER+i-1]) +
-                     fMultDiv2(a1i,lowBandReal[LPC_ORDER+i-2]) + fMultDiv2(a1r,lowBandImag[LPC_ORDER+i-2]))>>dynamicScale;
-
-            qmfBufferReal[i][hiBand] = (lowBandReal[LPC_ORDER+i]>>descale) + (accu1<<1);
-            qmfBufferImag[i][hiBand] = (lowBandImag[LPC_ORDER+i]>>descale) + (accu2<<1);
-          }
-#endif
-        } else
-        {
-          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
-
-          FDK_ASSERT(dynamicScale >= 0);
-          for(i = startSample; i < stopSample; i++ ) {
-            FIXP_DBL accu1;
-
-            accu1 = (fMultDiv2(a0r,lowBandReal[LPC_ORDER+i-1]) + fMultDiv2(a1r,lowBandReal[LPC_ORDER+i-2]))>>dynamicScale;
-
-            qmfBufferReal[i][hiBand] = (lowBandReal[LPC_ORDER+i]>>descale) + (accu1<<1);
-          }
-        }
-      } /* bw <= 0 */
-
-      patch++;
-
-    }  /* inner loop over patches */
-
-     /*
-     * store the unmodified filter coefficients if there is
-     * an overlapping envelope
-     *****************************************************************/
-
-
-  }  /* outer loop over bands (loBand) */
-
-  if (useLP)
-  {
-    for ( loBand = pSettings->lbStartPatching; loBand <  pSettings->lbStopPatching; loBand++ ) {
-      patch = 0;
-      while ( patch < pSettings->noOfPatches ) {
-
-        UCHAR hiBand = loBand + patchParam[patch].targetBandOffs;
-
-        if ( loBand < patchParam[patch].sourceStartBand
-          || loBand >= patchParam[patch].sourceStopBand
-          || hiBand >= (64)              /* Highband out of range (biterror) */
-          ) {
-          /* Lowband not in current patch or highband out of range (might be caused by biterrors)- proceed */
-          patch++;
-          continue;
-        }
-
-        if(hiBand != patchParam[patch].targetStartBand)
-          degreeAlias[hiBand] = degreeAlias[loBand];
-
-        patch++;
-      }
-    }/* end  for loop */
-  }
-
- for (i = 0; i < nInvfBands; i++ ) {
-   hLppTrans->bwVectorOld[i] = bwVector[i];
- }
-
-  /*
-    set high band scale factor
-  */
-  sbrScaleFactor->hb_scale = comLowBandScale-(LPC_SCALE_FACTOR);
-
-}
-
-/*!
- *
- * \brief Initialize one low power transposer instance
- *
- *
- */
-SBR_ERROR
-createLppTransposer (HANDLE_SBR_LPP_TRANS hs, /*!< Handle of low power transposer  */
-                     TRANSPOSER_SETTINGS *pSettings, /*!< Pointer to settings */
-                     const int  highBandStartSb, /*!< ? */
-                     UCHAR *v_k_master,         /*!< Master table */
-                     const int numMaster,       /*!< Valid entries in master table */
-                     const int usb,             /*!< Highband area stop subband */
-                     const int timeSlots,       /*!< Number of time slots */
-                     const int nCols,           /*!< Number of colums (codec qmf bank) */
-                     UCHAR *noiseBandTable,     /*!< Mapping of SBR noise bands to QMF bands */
-                     const int  noNoiseBands,   /*!< Number of noise bands */
-                     UINT   fs,                 /*!< Sample Frequency */
-                     const int chan,            /*!< Channel number */
-                     const int overlap
-                     )
-{
-  /* FB inverse filtering settings */
-  hs->pSettings = pSettings;
-
-  pSettings->nCols = nCols;
-  pSettings->overlap = overlap;
-
-  switch (timeSlots) {
-
-  case 15:
-  case 16:
-    break;
-
-  default:
-    return SBRDEC_UNSUPPORTED_CONFIG; /* Unimplemented */
-  }
-
-  if (chan==0) {
-    /* Init common data only once */
-    hs->pSettings->nCols = nCols;
-
-    return resetLppTransposer (hs,
-                               highBandStartSb,
-                               v_k_master,
-                               numMaster,
-                               noiseBandTable,
-                               noNoiseBands,
-                               usb,
-                               fs);
-  }
-  return SBRDEC_OK;
-}
-
-
-static int findClosestEntry(UCHAR goalSb, UCHAR *v_k_master, UCHAR numMaster, UCHAR direction)
-{
-  int index;
-
-  if( goalSb <= v_k_master[0] )
-    return v_k_master[0];
-
-  if( goalSb >= v_k_master[numMaster] )
-    return v_k_master[numMaster];
-
-  if(direction) {
-    index = 0;
-    while( v_k_master[index] < goalSb ) {
-      index++;
-    }
-  } else {
-    index = numMaster;
-    while( v_k_master[index] > goalSb ) {
-      index--;
-    }
-  }
-
-  return v_k_master[index];
-}
-
-
-/*!
- *
- * \brief Reset memory for one lpp transposer instance
- *
- * \return SBRDEC_OK on success, SBRDEC_UNSUPPORTED_CONFIG on error
- */
-SBR_ERROR
-resetLppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,  /*!< Handle of lpp transposer  */
-                    UCHAR  highBandStartSb,          /*!< High band area: start subband */
-                    UCHAR *v_k_master,               /*!< Master table */
-                    UCHAR  numMaster,                /*!< Valid entries in master table */
-                    UCHAR *noiseBandTable,           /*!< Mapping of SBR noise bands to QMF bands */
-                    UCHAR  noNoiseBands,             /*!< Number of noise bands */
-                    UCHAR  usb,                      /*!< High band area: stop subband */
-                    UINT   fs                        /*!< SBR output sampling frequency */
-                    )
-{
-  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;
-  PATCH_PARAM  *patchParam = pSettings->patchParam;
-
-  int i, patch;
-  int targetStopBand;
-  int sourceStartBand;
-  int patchDistance;
-  int numBandsInPatch;
-
-  int lsb = v_k_master[0];                 /* Start subband expressed in "non-critical" sampling terms*/
-  int xoverOffset = highBandStartSb - lsb; /* Calculate distance in QMF bands between k0 and kx */
-  int startFreqHz;
-
-  int desiredBorder;
-
-  usb = fixMin(usb, v_k_master[numMaster]); /* Avoid endless loops (compare with float code). */
-
-  /*
-   * Plausibility check
-   */
-
-  if ( lsb - SHIFT_START_SB < 4 ) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-
-  /*
-   * Initialize the patching parameter
-   */
-  /* ISO/IEC 14496-3 (Figure 4.48): goalSb = round( 2.048e6 / fs ) */
-  desiredBorder    = (((2048000*2) / fs) + 1) >> 1;
-
-  desiredBorder = findClosestEntry(desiredBorder, v_k_master, numMaster, 1); /* Adapt region to master-table */
-
-  /* First patch */
-  sourceStartBand = SHIFT_START_SB + xoverOffset;
-  targetStopBand = lsb + xoverOffset; /* upperBand */
-
-  /* Even (odd) numbered channel must be patched to even (odd) numbered channel */
-  patch = 0;
-  while(targetStopBand < usb) {
-
-    /* Too many patches?
-       Allow MAX_NUM_PATCHES+1 patches here.
-       we need to check later again, since patch might be the highest patch
-       AND contain less than 3 bands => actual number of patches will be reduced by 1.
-    */
-    if (patch > MAX_NUM_PATCHES) {
-      return SBRDEC_UNSUPPORTED_CONFIG;
-    }
-
-    patchParam[patch].guardStartBand = targetStopBand;
-    patchParam[patch].targetStartBand = targetStopBand;
-
-    numBandsInPatch = desiredBorder - targetStopBand;                   /* Get the desired range of the patch */
-
-    if ( numBandsInPatch >= lsb - sourceStartBand ) {
-      /* Desired number bands are not available -> patch whole source range */
-      patchDistance   = targetStopBand - sourceStartBand;        /* Get the targetOffset */
-      patchDistance   = patchDistance & ~1;                      /* Rounding off odd numbers and make all even */
-      numBandsInPatch = lsb - (targetStopBand - patchDistance);  /* Update number of bands to be patched */
-      numBandsInPatch = findClosestEntry(targetStopBand + numBandsInPatch, v_k_master, numMaster, 0) -
-                        targetStopBand;  /* Adapt region to master-table */
-    }
-
-    /* Desired number bands are available -> get the minimal even patching distance */
-    patchDistance   = numBandsInPatch + targetStopBand - lsb;  /* Get minimal distance */
-    patchDistance   = (patchDistance + 1) & ~1;                /* Rounding up odd numbers and make all even */
-
-    if (numBandsInPatch > 0) {
-      patchParam[patch].sourceStartBand = targetStopBand - patchDistance;
-      patchParam[patch].targetBandOffs  = patchDistance;
-      patchParam[patch].numBandsInPatch = numBandsInPatch;
-      patchParam[patch].sourceStopBand  = patchParam[patch].sourceStartBand + numBandsInPatch;
-
-      targetStopBand += patchParam[patch].numBandsInPatch;
-      patch++;
-    }
-
-    /* All patches but first */
-    sourceStartBand = SHIFT_START_SB;
-
-    /* Check if we are close to desiredBorder */
-    if( desiredBorder - targetStopBand < 3)  /* MPEG doc */
-    {
-      desiredBorder = usb;
-    }
-
-  }
-
-  patch--;
-
-  /* If highest patch contains less than three subband: skip it */
-  if ( (patch>0) && (patchParam[patch].numBandsInPatch < 3) ) {
-    patch--;
-    targetStopBand = patchParam[patch].targetStartBand + patchParam[patch].numBandsInPatch;
-  }
-
-  /* now check if we don't have one too many */
-  if (patch >= MAX_NUM_PATCHES) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  pSettings->noOfPatches = patch + 1;
-
-  /* Check lowest and highest source subband */
-  pSettings->lbStartPatching = targetStopBand;
-  pSettings->lbStopPatching  = 0;
-  for ( patch = 0; patch < pSettings->noOfPatches; patch++ ) {
-    pSettings->lbStartPatching = fixMin( pSettings->lbStartPatching, patchParam[patch].sourceStartBand );
-    pSettings->lbStopPatching  = fixMax( pSettings->lbStopPatching, patchParam[patch].sourceStopBand );
-  }
-
-  for(i = 0 ; i < noNoiseBands; i++){
-    pSettings->bwBorders[i] = noiseBandTable[i+1];
-  }
-
-  /*
-   * Choose whitening factors
-   */
-
-  startFreqHz = ( (lsb + xoverOffset)*fs ) >> 7;  /* Shift does a division by 2*(64) */
-
-  for( i = 1; i < NUM_WHFACTOR_TABLE_ENTRIES; i++ )
-  {
-    if( startFreqHz < FDK_sbrDecoder_sbr_whFactorsIndex[i])
-      break;
-  }
-  i--;
-
-  pSettings->whFactors.off = FDK_sbrDecoder_sbr_whFactorsTable[i][0];
-  pSettings->whFactors.transitionLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][1];
-  pSettings->whFactors.lowLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][2];
-  pSettings->whFactors.midLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][3];
-  pSettings->whFactors.highLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][4];
-
-  return SBRDEC_OK;
-}
diff --git a/libSBRdec/src/lpp_tran.h b/libSBRdec/src/lpp_tran.h
deleted file mode 100644
index 003a547..0000000
--- a/libSBRdec/src/lpp_tran.h
+++ /dev/null
@@ -1,242 +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  Low Power Profile Transposer,  
-*/
-
-#ifndef _LPP_TRANS_H
-#define _LPP_TRANS_H
-
-#include "sbrdecoder.h"
-#include "qmf.h"
-
-/*
-  Common
-*/
-#define QMF_OUT_SCALE            8
-
-/*
-  Env-Adjust
-*/
-#define MAX_NOISE_ENVELOPES      2
-#define MAX_NOISE_COEFFS         5
-#define MAX_NUM_NOISE_VALUES     (MAX_NOISE_ENVELOPES * MAX_NOISE_COEFFS)
-#define MAX_NUM_LIMITERS         12
-
-/* Set MAX_ENVELOPES to the largest value of all supported BSFORMATs
-   by overriding MAX_ENVELOPES in the correct order: */
-#define MAX_ENVELOPES_HEAAC      5
-#define MAX_ENVELOPES            MAX_ENVELOPES_HEAAC
-
-#define MAX_FREQ_COEFFS          48
-#define MAX_FREQ_COEFFS_FS44100  35
-#define MAX_FREQ_COEFFS_FS48000  32
-
-
-#define MAX_NUM_ENVELOPE_VALUES  (MAX_ENVELOPES * MAX_FREQ_COEFFS)
-
-#define MAX_GAIN_EXP             34
-/* Maximum gain will be sqrt(0.5 * 2^MAX_GAIN_EXP)
-   example: 34=99dB   */
-#define MAX_GAIN_CONCEAL_EXP     1
-/* Maximum gain will be sqrt(0.5 * 2^MAX_GAIN_CONCEAL_EXP) in concealment case (0dB) */
-
-/*
-  LPP Transposer
-*/
-#define LPC_ORDER                2
-
-#define MAX_INVF_BANDS           MAX_NOISE_COEFFS
-
-#define MAX_NUM_PATCHES          6
-#define SHIFT_START_SB           1              /*!< lowest subband of source range */
-
-typedef enum
-{
-  INVF_OFF = 0,
-  INVF_LOW_LEVEL,
-  INVF_MID_LEVEL,
-  INVF_HIGH_LEVEL,
-  INVF_SWITCHED /* not a real choice but used here to control behaviour */
-}
-INVF_MODE;
-
-
-/** parameter set for one single patch */
-typedef struct {
-  UCHAR  sourceStartBand;   /*!< first band in lowbands where to take the samples from */
-  UCHAR  sourceStopBand;    /*!< first band in lowbands which is not included in the patch anymore */
-  UCHAR  guardStartBand;    /*!< first band in highbands to be filled with zeros in order to
-                                         reduce interferences between patches */
-  UCHAR  targetStartBand;   /*!< first band in highbands to be filled with whitened lowband signal */
-  UCHAR  targetBandOffs;    /*!< difference between 'startTargetBand' and 'startSourceBand' */
-  UCHAR  numBandsInPatch;   /*!< number of consecutive bands in this one patch */
-} PATCH_PARAM;
-
-
-/** whitening factors for different levels of whitening
-    need to be initialized corresponding to crossover frequency */
-typedef struct {
-  FIXP_DBL  off;                       /*!< bw factor for signal OFF */
-  FIXP_DBL  transitionLevel;
-  FIXP_DBL  lowLevel;                  /*!< bw factor for signal LOW_LEVEL */
-  FIXP_DBL  midLevel;                  /*!< bw factor for signal MID_LEVEL */
-  FIXP_DBL  highLevel;                 /*!< bw factor for signal HIGH_LEVEL */
-} WHITENING_FACTORS;
-
-
-/*! The transposer settings are calculated on a header reset and are shared by both channels. */
-typedef struct {
-  UCHAR  nCols;                       /*!< number subsamples of a codec frame */
-  UCHAR  noOfPatches;                 /*!< number of patches */
-  UCHAR  lbStartPatching;             /*!< first band of lowbands that will be patched */
-  UCHAR  lbStopPatching;              /*!< first band that won't be patched anymore*/
-  UCHAR  bwBorders[MAX_NUM_NOISE_VALUES]; /*!< spectral bands with different inverse filtering levels */
-
-  PATCH_PARAM    patchParam[MAX_NUM_PATCHES]; /*!< new parameter set for patching */
-  WHITENING_FACTORS whFactors;                /*!< the pole moving factors for certain whitening levels as indicated
-                                                   in the bitstream depending on the crossover frequency */
-  UCHAR  overlap;                             /*!< Overlap size */
-} TRANSPOSER_SETTINGS;
-
-
-typedef struct
-{
-  TRANSPOSER_SETTINGS *pSettings;                /*!< Common settings for both channels */
-  FIXP_DBL  bwVectorOld[MAX_NUM_PATCHES];        /*!< pole moving factors of past frame */
-  FIXP_DBL  lpcFilterStatesReal[LPC_ORDER][(32)];     /*!< pointer array to save filter states */
-  FIXP_DBL  lpcFilterStatesImag[LPC_ORDER][(32)];     /*!< pointer array to save filter states */
-}
-SBR_LPP_TRANS;
-
-typedef SBR_LPP_TRANS *HANDLE_SBR_LPP_TRANS;
-
-
-void lppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,
-                    QMF_SCALE_FACTOR  *sbrScaleFactor,
-                    FIXP_DBL **qmfBufferReal,
-
-                    FIXP_DBL *degreeAlias,
-                    FIXP_DBL **qmfBufferImag,
-                    const int useLP,
-                    const int timeStep,
-                    const int firstSlotOffset,
-                    const int lastSlotOffset,
-                    const int nInvfBands,
-                    INVF_MODE *sbr_invf_mode,
-                    INVF_MODE *sbr_invf_mode_prev
-                    );
-
-
-SBR_ERROR
-createLppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,
-                     TRANSPOSER_SETTINGS *pSettings,
-                     const int  highBandStartSb,
-                     UCHAR *v_k_master,
-                     const int  numMaster,
-                     const int  usb,
-                     const int  timeSlots,
-                     const int  nCols,
-                     UCHAR *noiseBandTable,
-                     const int  noNoiseBands,
-                     UINT   fs,
-                     const int  chan,
-                     const int overlap);
-
-
-SBR_ERROR
-resetLppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,
-                    UCHAR  highBandStartSb,
-                    UCHAR *v_k_master,
-                    UCHAR  numMaster,
-                    UCHAR *noiseBandTable,
-                    UCHAR  noNoiseBands,
-                    UCHAR  usb,
-                    UINT   fs);
-
-
-
-#endif /* _LPP_TRANS_H */
-
diff --git a/libSBRdec/src/psbitdec.cpp b/libSBRdec/src/psbitdec.cpp
deleted file mode 100644
index 29bddf7..0000000
--- a/libSBRdec/src/psbitdec.cpp
+++ /dev/null
@@ -1,593 +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
------------------------------------------------------------------------------------------------------------ */
-
-#include "psbitdec.h"
-
-
-#include "sbr_rom.h"
-#include "huff_dec.h"
-
-/* PS dec privat functions */
-SBR_ERROR ResetPsDec(HANDLE_PS_DEC h_ps_d);
-void ResetPsDeCor   (HANDLE_PS_DEC h_ps_d);
-
-/***************************************************************************/
-/*!
-  \brief  huffman decoding by codebook table
-
-  \return index of huffman codebook table
-
-****************************************************************************/
-static SCHAR
-decode_huff_cw (Huffman h,                      /*!< pointer to huffman codebook table */
-                HANDLE_FDK_BITSTREAM hBitBuf,   /*!< Handle to Bitbuffer */
-                int *length)                    /*!< length of huffman codeword (or NULL) */
-{
-  UCHAR bit = 0;
-  SCHAR index = 0;
-  UCHAR bitCount = 0;
-
-  while (index >= 0) {
-    bit = FDKreadBits (hBitBuf, 1);
-    bitCount++;
-    index = h[index][bit];
-  }
-  if (length) {
-    *length = bitCount;
-  }
-  return( index+64 ); /* Add offset */
-}
-
-/***************************************************************************/
-/*!
-  \brief  helper function - limiting of value to min/max values
-
-  \return limited value
-
-****************************************************************************/
-
-static SCHAR
-limitMinMax(SCHAR i,
-            SCHAR min,
-            SCHAR max)
-{
-  if (i<min)
-    return min;
-  else if (i>max)
-    return max;
-  else
-    return i;
-}
-
-/***************************************************************************/
-/*!
-  \brief  Decodes delta values in-place and updates
-          data buffers according to quantization classes.
-
-  When delta coded in frequency the first element is deltacode from zero.
-  aIndex buffer is decoded from delta values to actual values.
-
-  \return none
-
-****************************************************************************/
-static void
-deltaDecodeArray(SCHAR enable,
-                 SCHAR *aIndex,          /*!< ICC/IID parameters */
-                 SCHAR *aPrevFrameIndex, /*!< ICC/IID parameters  of previous frame */
-                 SCHAR DtDf,
-                 UCHAR nrElements,       /*!< as conveyed in bitstream */
-                                         /*!< output array size: nrElements*stride */
-                 UCHAR stride,           /*!< 1=dflt, 2=half freq. resolution */
-                 SCHAR minIdx,
-                 SCHAR maxIdx)
-{
-  int i;
-
-  /* Delta decode */
-  if ( enable==1 ) {
-    if (DtDf == 0)  {   /* Delta coded in freq */
-      aIndex[0] = 0 + aIndex[0];
-      aIndex[0] = limitMinMax(aIndex[0],minIdx,maxIdx);
-      for (i = 1; i < nrElements; i++) {
-        aIndex[i] = aIndex[i-1] + aIndex[i];
-        aIndex[i] = limitMinMax(aIndex[i],minIdx,maxIdx);
-      }
-    }
-    else { /* Delta time */
-      for (i = 0; i < nrElements; i++) {
-        aIndex[i] = aPrevFrameIndex[i*stride] + aIndex[i];
-        aIndex[i] = limitMinMax(aIndex[i],minIdx,maxIdx);
-      }
-    }
-  }
-  else { /* No data is sent, set index to zero */
-    for (i = 0; i < nrElements; i++) {
-      aIndex[i] = 0;
-    }
-  }
-  if (stride==2) {
-    for (i=nrElements*stride-1; i>0; i--) {
-      aIndex[i] = aIndex[i>>1];
-    }
-  }
-}
-
-/***************************************************************************/
-/*!
-  \brief Mapping of ICC/IID parameters to 20 stereo bands
-
-  \return none
-
-****************************************************************************/
-static void map34IndexTo20 (SCHAR *aIndex, /*!< decoded ICC/IID parameters */
-                            UCHAR noBins)  /*!< number of stereo bands     */
-{
-  aIndex[0]  = (2*aIndex[0]+aIndex[1])/3;
-  aIndex[1]  = (aIndex[1]+2*aIndex[2])/3;
-  aIndex[2]  = (2*aIndex[3]+aIndex[4])/3;
-  aIndex[3]  = (aIndex[4]+2*aIndex[5])/3;
-  aIndex[4]  = (aIndex[6]+aIndex[7])/2;
-  aIndex[5]  = (aIndex[8]+aIndex[9])/2;
-  aIndex[6]  = aIndex[10];
-  aIndex[7]  = aIndex[11];
-  aIndex[8]  = (aIndex[12]+aIndex[13])/2;
-  aIndex[9]  = (aIndex[14]+aIndex[15])/2;
-  aIndex[10] = aIndex[16];
-  /* For IPD/OPD it stops here */
-
-  if (noBins == NO_HI_RES_BINS)
-  {
-    aIndex[11] = aIndex[17];
-    aIndex[12] = aIndex[18];
-    aIndex[13] = aIndex[19];
-    aIndex[14] = (aIndex[20]+aIndex[21])/2;
-    aIndex[15] = (aIndex[22]+aIndex[23])/2;
-    aIndex[16] = (aIndex[24]+aIndex[25])/2;
-    aIndex[17] = (aIndex[26]+aIndex[27])/2;
-    aIndex[18] = (aIndex[28]+aIndex[29]+aIndex[30]+aIndex[31])/4;
-    aIndex[19] = (aIndex[32]+aIndex[33])/2;
-  }
-}
-
-/***************************************************************************/
-/*!
-  \brief  Decodes delta coded IID, ICC, IPD and OPD indices
-
-  \return PS processing flag. If set to 1
-
-****************************************************************************/
-int
-DecodePs( struct PS_DEC *h_ps_d,      /*!< PS handle */
-          const UCHAR    frameError ) /*!< Flag telling that frame had errors */
-{
-  MPEG_PS_BS_DATA *pBsData;
-  UCHAR gr, env;
-  int   bPsHeaderValid, bPsDataAvail;
-
-  /* Shortcuts to avoid deferencing and keep the code readable */
-  pBsData = &h_ps_d->bsData[h_ps_d->processSlot].mpeg;
-  bPsHeaderValid = pBsData->bPsHeaderValid;
-  bPsDataAvail = (h_ps_d->bPsDataAvail[h_ps_d->processSlot] == ppt_mpeg) ? 1 : 0;
-
- /***************************************************************************************
-  * Decide whether to process or to conceal PS data or not.                             */
-
-  if ( ( h_ps_d->psDecodedPrv && !frameError && !bPsDataAvail)
-    || (!h_ps_d->psDecodedPrv && (frameError || !bPsDataAvail || !bPsHeaderValid)) ) {
-    /* Don't apply PS processing.
-     * Declare current PS header and bitstream data invalid. */
-    pBsData->bPsHeaderValid = 0;
-    h_ps_d->bPsDataAvail[h_ps_d->processSlot] = ppt_none;
-    return (0);
-  }
-
-  if (frameError || !bPsHeaderValid)
-  { /* no new PS data available (e.g. frame loss) */
-    /* => keep latest data constant (i.e. FIX with noEnv=0) */
-    pBsData->noEnv = 0;
-  }
-
- /***************************************************************************************
-  * Decode bitstream payload or prepare parameter for concealment:
-  */
-  for (env=0; env<pBsData->noEnv; env++) {
-    SCHAR *aPrevIidIndex;
-    SCHAR *aPrevIccIndex;
-
-    UCHAR noIidSteps = pBsData->bFineIidQ?NO_IID_STEPS_FINE:NO_IID_STEPS;
-
-    if (env==0) {
-      aPrevIidIndex = h_ps_d->specificTo.mpeg.aIidPrevFrameIndex;
-      aPrevIccIndex = h_ps_d->specificTo.mpeg.aIccPrevFrameIndex;
-    }
-    else {
-      aPrevIidIndex = pBsData->aaIidIndex[env-1];
-      aPrevIccIndex = pBsData->aaIccIndex[env-1];
-    }
-
-    deltaDecodeArray(pBsData->bEnableIid,
-                     pBsData->aaIidIndex[env],
-                     aPrevIidIndex,
-                     pBsData->abIidDtFlag[env],
-                     FDK_sbrDecoder_aNoIidBins[pBsData->freqResIid],
-                     (pBsData->freqResIid)?1:2,
-                     -noIidSteps,
-                     noIidSteps);
-
-    deltaDecodeArray(pBsData->bEnableIcc,
-                     pBsData->aaIccIndex[env],
-                     aPrevIccIndex,
-                     pBsData->abIccDtFlag[env],
-                     FDK_sbrDecoder_aNoIccBins[pBsData->freqResIcc],
-                     (pBsData->freqResIcc)?1:2,
-                     0,
-                     NO_ICC_STEPS-1);
-  }   /* for (env=0; env<pBsData->noEnv; env++) */
-
-  /* handling of FIX noEnv=0 */
-  if (pBsData->noEnv==0) {
-    /* set noEnv=1, keep last parameters or force 0 if not enabled */
-    pBsData->noEnv = 1;
-
-    if (pBsData->bEnableIid) {
-      for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) {
-        pBsData->aaIidIndex[pBsData->noEnv-1][gr] =
-          h_ps_d->specificTo.mpeg.aIidPrevFrameIndex[gr];
-      }
-    }
-    else {
-      for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) {
-        pBsData->aaIidIndex[pBsData->noEnv-1][gr] = 0;
-      }
-    }
-
-    if (pBsData->bEnableIcc) {
-      for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) {
-        pBsData->aaIccIndex[pBsData->noEnv-1][gr] =
-          h_ps_d->specificTo.mpeg.aIccPrevFrameIndex[gr];
-      }
-    }
-    else {
-      for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) {
-        pBsData->aaIccIndex[pBsData->noEnv-1][gr] = 0;
-      }
-    }
-  }
-
-  /* Update previous frame index buffers */
-  for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) {
-    h_ps_d->specificTo.mpeg.aIidPrevFrameIndex[gr] =
-      pBsData->aaIidIndex[pBsData->noEnv-1][gr];
-  }
-  for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) {
-    h_ps_d->specificTo.mpeg.aIccPrevFrameIndex[gr] =
-      pBsData->aaIccIndex[pBsData->noEnv-1][gr];
-  }
-
-  /* PS data from bitstream (if avail) was decoded now */
-  h_ps_d->bPsDataAvail[h_ps_d->processSlot] = ppt_none;
-
-  /* handling of env borders for FIX & VAR */
-  if (pBsData->bFrameClass == 0) {
-    /* FIX_BORDERS NoEnv=0,1,2,4 */
-    pBsData->aEnvStartStop[0] = 0;
-    for (env=1; env<pBsData->noEnv; env++) {
-      pBsData->aEnvStartStop[env] =
-        (env * h_ps_d->noSubSamples) / pBsData->noEnv;
-    }
-    pBsData->aEnvStartStop[pBsData->noEnv] = h_ps_d->noSubSamples;
-    /* 1024 (32 slots) env borders:  0, 8, 16, 24, 32 */
-    /*  960 (30 slots) env borders:  0, 7, 15, 22, 30 */
-  }
-  else {   /* if (h_ps_d->bFrameClass == 0) */
-    /* VAR_BORDERS NoEnv=1,2,3,4 */
-    pBsData->aEnvStartStop[0] = 0;
-
-    /* handle case aEnvStartStop[noEnv]<noSubSample for VAR_BORDERS by
-       duplicating last PS parameters and incrementing noEnv */
-    if (pBsData->aEnvStartStop[pBsData->noEnv] < h_ps_d->noSubSamples) {
-      for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) {
-        pBsData->aaIidIndex[pBsData->noEnv][gr] =
-          pBsData->aaIidIndex[pBsData->noEnv-1][gr];
-      }
-      for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) {
-        pBsData->aaIccIndex[pBsData->noEnv][gr] =
-          pBsData->aaIccIndex[pBsData->noEnv-1][gr];
-      }
-      pBsData->noEnv++;
-      pBsData->aEnvStartStop[pBsData->noEnv] = h_ps_d->noSubSamples;
-    }
-
-    /* enforce strictly monotonic increasing borders */
-    for (env=1; env<pBsData->noEnv; env++) {
-      UCHAR thr;
-      thr = (UCHAR)h_ps_d->noSubSamples - (pBsData->noEnv - env);
-      if (pBsData->aEnvStartStop[env] > thr) {
-        pBsData->aEnvStartStop[env] = thr;
-      }
-      else {
-        thr = pBsData->aEnvStartStop[env-1]+1;
-        if (pBsData->aEnvStartStop[env] < thr) {
-          pBsData->aEnvStartStop[env] = thr;
-        }
-      }
-    }
-  }   /* if (h_ps_d->bFrameClass == 0) ... else */
-
-  /* copy data prior to possible 20<->34 in-place mapping */
-  for (env=0; env<pBsData->noEnv; env++) {
-    UCHAR i;
-    for (i=0; i<NO_HI_RES_IID_BINS; i++) {
-      h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][i] = pBsData->aaIidIndex[env][i];
-    }
-    for (i=0; i<NO_HI_RES_ICC_BINS; i++) {
-      h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][i] = pBsData->aaIccIndex[env][i];
-    }
-  }
-
-
-  /* MPEG baseline PS */
-  /* Baseline version of PS always uses the hybrid filter structure with 20 stereo bands. */
-  /* If ICC/IID parameters for 34 stereo bands are decoded they have to be mapped to 20   */
-  /* stereo bands.                                                                        */
-  /* Additionaly the IPD/OPD parameters won't be used.                                    */
-
-  for (env=0; env<pBsData->noEnv; env++) {
-    if (pBsData->freqResIid == 2)
-      map34IndexTo20 (h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env], NO_HI_RES_IID_BINS);
-    if (pBsData->freqResIcc == 2)
-      map34IndexTo20 (h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env], NO_HI_RES_ICC_BINS);
-
-    /* IPD/OPD is disabled in baseline version and thus was removed here */
-  }
-
-  return (1);
-}
-
-
-/***************************************************************************/
-/*!
-
-  \brief  Reads parametric stereo data from bitstream
-
-  \return
-
-****************************************************************************/
-unsigned int
-ReadPsData (HANDLE_PS_DEC h_ps_d,          /*!< handle to struct PS_DEC */
-            HANDLE_FDK_BITSTREAM hBitBuf,  /*!< handle to struct BIT_BUF */
-            int nBitsLeft                  /*!< max number of bits available */
-           )
-{
-  MPEG_PS_BS_DATA *pBsData;
-
-  UCHAR     gr, env;
-  SCHAR     dtFlag;
-  INT       startbits;
-  Huffman   CurrentTable;
-  SCHAR     bEnableHeader;
-
-  if (!h_ps_d)
-    return 0;
-
-  pBsData = &h_ps_d->bsData[h_ps_d->bsReadSlot].mpeg;
-
-  if (h_ps_d->bsReadSlot != h_ps_d->bsLastSlot) {
-    /* Copy last header data */
-    FDKmemcpy(pBsData, &h_ps_d->bsData[h_ps_d->bsLastSlot].mpeg, sizeof(MPEG_PS_BS_DATA));
-  }
-
-
-  startbits = (INT) FDKgetValidBits(hBitBuf);
-
-  bEnableHeader = (SCHAR) FDKreadBits (hBitBuf, 1);
-
-  /* Read header */
-  if (bEnableHeader) {
-    pBsData->bPsHeaderValid = 1;
-    pBsData->bEnableIid = (UCHAR) FDKreadBits (hBitBuf, 1);
-    if (pBsData->bEnableIid) {
-      pBsData->modeIid = (UCHAR) FDKreadBits (hBitBuf, 3);
-    }
-
-    pBsData->bEnableIcc = (UCHAR) FDKreadBits (hBitBuf, 1);
-    if (pBsData->bEnableIcc) {
-      pBsData->modeIcc = (UCHAR) FDKreadBits (hBitBuf, 3);
-    }
-
-    pBsData->bEnableExt = (UCHAR) FDKreadBits (hBitBuf, 1);
-  }
-
-  pBsData->bFrameClass = (UCHAR) FDKreadBits (hBitBuf, 1);
-  if (pBsData->bFrameClass == 0) {
-    /* FIX_BORDERS NoEnv=0,1,2,4 */
-    pBsData->noEnv = FDK_sbrDecoder_aFixNoEnvDecode[(UCHAR) FDKreadBits (hBitBuf, 2)];
-    /* all additional handling of env borders is now in DecodePs() */
-  }
-  else {
-    /* VAR_BORDERS NoEnv=1,2,3,4 */
-    pBsData->noEnv = 1+(UCHAR) FDKreadBits (hBitBuf, 2);
-    for (env=1; env<pBsData->noEnv+1; env++)
-      pBsData->aEnvStartStop[env] = ((UCHAR) FDKreadBits (hBitBuf, 5)) + 1;
-    /* all additional handling of env borders is now in DecodePs() */
-  }
-
-  /* verify that IID & ICC modes (quant grid, freq res) are supported */
-  if ((pBsData->modeIid > 5) || (pBsData->modeIcc > 5)) {
-    /* no useful PS data could be read from bitstream */
-    h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_none;
-    /* discard all remaining bits */
-    nBitsLeft -= startbits - FDKgetValidBits(hBitBuf);
-    while (nBitsLeft) {
-      int i = nBitsLeft;
-      if (i>8) {
-        i = 8;
-      }
-      FDKreadBits (hBitBuf, i);
-      nBitsLeft -= i;
-    }
-    return (startbits - FDKgetValidBits(hBitBuf));
-  }
-
-  if (pBsData->modeIid > 2){
-    pBsData->freqResIid = pBsData->modeIid-3;
-    pBsData->bFineIidQ = 1;
-  }
-  else{
-    pBsData->freqResIid = pBsData->modeIid;
-    pBsData->bFineIidQ = 0;
-  }
-
-  if (pBsData->modeIcc > 2){
-    pBsData->freqResIcc = pBsData->modeIcc-3;
-  }
-  else{
-    pBsData->freqResIcc = pBsData->modeIcc;
-  }
-
-
-  /* Extract IID data */
-  if (pBsData->bEnableIid) {
-    for (env=0; env<pBsData->noEnv; env++) {
-      dtFlag = (SCHAR)FDKreadBits (hBitBuf, 1);
-      if (!dtFlag)
-      {
-        if (pBsData->bFineIidQ)
-          CurrentTable = (Huffman)&aBookPsIidFineFreqDecode;
-        else
-          CurrentTable = (Huffman)&aBookPsIidFreqDecode;
-      }
-      else
-      {
-        if (pBsData->bFineIidQ)
-         CurrentTable = (Huffman)&aBookPsIidFineTimeDecode;
-        else
-          CurrentTable = (Huffman)&aBookPsIidTimeDecode;
-      }
-
-      for (gr = 0; gr < FDK_sbrDecoder_aNoIidBins[pBsData->freqResIid]; gr++)
-        pBsData->aaIidIndex[env][gr] = decode_huff_cw(CurrentTable,hBitBuf,NULL);
-      pBsData->abIidDtFlag[env] = dtFlag;
-    }
-  }
-
-  /* Extract ICC data */
-  if (pBsData->bEnableIcc) {
-    for (env=0; env<pBsData->noEnv; env++) {
-      dtFlag = (SCHAR)FDKreadBits (hBitBuf, 1);
-      if (!dtFlag)
-        CurrentTable = (Huffman)&aBookPsIccFreqDecode;
-      else
-        CurrentTable = (Huffman)&aBookPsIccTimeDecode;
-
-      for (gr = 0; gr < FDK_sbrDecoder_aNoIccBins[pBsData->freqResIcc]; gr++)
-        pBsData->aaIccIndex[env][gr] = decode_huff_cw(CurrentTable,hBitBuf,NULL);
-      pBsData->abIccDtFlag[env] = dtFlag;
-    }
-  }
-
-  if (pBsData->bEnableExt) {
-
-    /*!
-    Decoders that support only the baseline version of the PS tool are allowed
-    to ignore the IPD/OPD data, but according header data has to be parsed.
-    ISO/IEC 14496-3 Subpart 8 Annex 4
-    */
-
-    int cnt = FDKreadBits(hBitBuf, PS_EXTENSION_SIZE_BITS);
-    if (cnt == (1<<PS_EXTENSION_SIZE_BITS)-1) {
-      cnt += FDKreadBits(hBitBuf, PS_EXTENSION_ESC_COUNT_BITS);
-    }
-    while (cnt--)
-      FDKreadBits(hBitBuf, 8);
-  }
-
-
-  /* new PS data was read from bitstream */
-  h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_mpeg;
-
-
-
-  return (startbits - FDKgetValidBits(hBitBuf));
-}
-
diff --git a/libSBRdec/src/psbitdec.h b/libSBRdec/src/psbitdec.h
deleted file mode 100644
index a2d4d6c..0000000
--- a/libSBRdec/src/psbitdec.h
+++ /dev/null
@@ -1,103 +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
------------------------------------------------------------------------------------------------------------ */
-
-#ifndef __PSBITDEC_H
-#define __PSBITDEC_H
-
-#include "sbrdecoder.h"
-
-
-#include "psdec.h"
-
-
-unsigned int
-ReadPsData (struct PS_DEC  *h_ps_d,
-            HANDLE_FDK_BITSTREAM  hBs,
-            int nBitsLeft);
-
-int
-DecodePs(struct PS_DEC *h_ps_d,
-         const UCHAR    frameError);
-
-
-#endif /* __PSBITDEC_H */
diff --git a/libSBRdec/src/psdec.cpp b/libSBRdec/src/psdec.cpp
deleted file mode 100644
index 965917a..0000000
--- a/libSBRdec/src/psdec.cpp
+++ /dev/null
@@ -1,1414 +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  parametric stereo decoder  
-*/
-
-#include "psdec.h"
-
-
-
-#include "FDK_bitbuffer.h"
-#include "psdec_hybrid.h"
-
-#include "sbr_rom.h"
-#include "sbr_ram.h"
-
-#include "FDK_tools_rom.h"
-
-#include "genericStds.h"
-
-#include "FDK_trigFcts.h"
-
-
-/********************************************************************/
-/*                       MLQUAL DEFINES                             */
-/********************************************************************/
-
-  #define FRACT_ZERO FRACT_BITS-1
-/********************************************************************/
-
-SBR_ERROR ResetPsDec( HANDLE_PS_DEC h_ps_d );
-
-void ResetPsDeCor( HANDLE_PS_DEC h_ps_d );
-
-
-/***** HELPERS *****/
-
-static void assignTimeSlotsPS (FIXP_DBL *bufAdr, FIXP_DBL **bufPtr, const int numSlots, const int numChan);
-
-
-
-/*******************/
-
-#define DIV3 FL2FXCONST_DBL(1.f/3.f)     /* division 3.0 */
-#define DIV1_5 FL2FXCONST_DBL(2.f/3.f)   /* division 1.5 */
-
-/***************************************************************************/
-/*!
-  \brief  Creates one instance of the PS_DEC struct
-
-  \return Error info
-
-****************************************************************************/
-int
-CreatePsDec( HANDLE_PS_DEC *h_PS_DEC,   /*!< pointer to the module state */
-             int aacSamplesPerFrame
-           )
-{
-  SBR_ERROR errorInfo = SBRDEC_OK;
-  HANDLE_PS_DEC  h_ps_d;
-  int i;
-
-  if (*h_PS_DEC == NULL) {
-    /* Get ps dec ram */
-    h_ps_d = GetRam_ps_dec();
-    if (h_ps_d == NULL) {
-      errorInfo = SBRDEC_MEM_ALLOC_FAILED;
-      goto bail;
-    }
-  } else {
-    /* Reset an open instance */
-    h_ps_d = *h_PS_DEC;
-  }
-
-   /* initialisation */
-  switch (aacSamplesPerFrame) {
-  case 960:
-    h_ps_d->noSubSamples = 30;              /* col */
-    break;
-  case 1024:
-    h_ps_d->noSubSamples = 32;              /* col */
-    break;
-  default:
-    h_ps_d->noSubSamples = -1;
-    break;
-  }
-
-  if (h_ps_d->noSubSamples >  MAX_NUM_COL
-   || h_ps_d->noSubSamples <= 0)
-  {
-    goto bail;
-  }
-  h_ps_d->noChannels   = NO_QMF_CHANNELS;   /* row */
-
-  h_ps_d->psDecodedPrv   =  0;
-  h_ps_d->procFrameBased = -1;
-  for (i = 0; i < (1)+1; i++) {
-    h_ps_d->bPsDataAvail[i]  =  ppt_none;
-  }
-
-
-  for (i = 0; i < (1)+1; i++) {
-    FDKmemclear(&h_ps_d->bsData[i].mpeg, sizeof(MPEG_PS_BS_DATA));
-  }
-
-  errorInfo = ResetPsDec( h_ps_d );
-
-  if ( errorInfo != SBRDEC_OK )
-    goto bail;
-
-  ResetPsDeCor( h_ps_d );
-
-  *h_PS_DEC = h_ps_d;
-
-
-
-  return 0;
-
-bail:
-  DeletePsDec(&h_ps_d);
-
-  return -1;
-} /*END CreatePsDec */
-
-/***************************************************************************/
-/*!
-  \brief  Delete one instance of the PS_DEC struct
-
-  \return Error info
-
-****************************************************************************/
-int
-DeletePsDec( HANDLE_PS_DEC *h_PS_DEC)  /*!< pointer to the module state */
-{
-  if (*h_PS_DEC == NULL) {
-    return -1;
-  }
-
-
-  FreeRam_ps_dec(h_PS_DEC);
-
-
-  return 0;
-} /*END DeletePsDec */
-
-/***************************************************************************/
-/*!
-  \brief resets some values of the PS handle to default states
-
-  \return
-
-****************************************************************************/
-SBR_ERROR ResetPsDec( HANDLE_PS_DEC h_ps_d )  /*!< pointer to the module state */
-{
-  SBR_ERROR errorInfo = SBRDEC_OK;
-  INT i;
-
-  const UCHAR noQmfBandsInHybrid20 = 3;
-  /* const UCHAR noQmfBandsInHybrid34 = 5; */
-
-  const UCHAR aHybridResolution20[] = { HYBRID_8_CPLX,
-                                        HYBRID_2_REAL,
-                                        HYBRID_2_REAL };
-
-  h_ps_d->specificTo.mpeg.delayBufIndex   = 0;
-
-  /* explicitly init state variables to safe values (until first ps header arrives) */
-
-  h_ps_d->specificTo.mpeg.lastUsb        =  0;
-
-  h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = -(DFRACT_BITS-1);
-
-  FDKmemclear(h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf, (NO_QMF_CHANNELS-FIRST_DELAY_SB)*sizeof(UCHAR));
-  h_ps_d->specificTo.mpeg.noSampleDelay = delayIndexQmf[0];
-
-  for (i=0 ; i < NO_SERIAL_ALLPASS_LINKS; i++) {
-    h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[i] = 0;
-  }
-
-  h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufReal;
-
-  assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
-                     &h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[1],
-                      h_ps_d->specificTo.mpeg.noSampleDelay-1,
-                      (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
-
-  h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufImag;
-
-  assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
-                     &h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[1],
-                      h_ps_d->specificTo.mpeg.noSampleDelay-1,
-                      (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
-
-  /* Hybrid Filter Bank 1 creation. */
-  errorInfo = InitHybridFilterBank ( &h_ps_d->specificTo.mpeg.hybrid,
-                                      h_ps_d->noSubSamples,
-                                      noQmfBandsInHybrid20,
-                                      aHybridResolution20 );
-
-  for ( i = 0; i < NO_IID_GROUPS; i++ )
-  {
-    h_ps_d->specificTo.mpeg.h11rPrev[i] = FL2FXCONST_DBL(0.5f);
-    h_ps_d->specificTo.mpeg.h12rPrev[i] = FL2FXCONST_DBL(0.5f);
-  }
-
-  FDKmemclear( h_ps_d->specificTo.mpeg.h21rPrev, sizeof( h_ps_d->specificTo.mpeg.h21rPrev ) );
-  FDKmemclear( h_ps_d->specificTo.mpeg.h22rPrev, sizeof( h_ps_d->specificTo.mpeg.h22rPrev ) );
-
-  return errorInfo;
-}
-
-/***************************************************************************/
-/*!
-  \brief  clear some buffers used in decorrelation process
-
-  \return
-
-****************************************************************************/
-void ResetPsDeCor( HANDLE_PS_DEC h_ps_d )  /*!< pointer to the module state */
-{
-  INT i;
-
-  FDKmemclear(h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
-  FDKmemclear(h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
-  FDKmemclear(h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
-  FDKmemclear(h_ps_d->specificTo.mpeg.aPowerPrevScal, NO_MID_RES_BINS*sizeof(SCHAR));
-
-  for (i=0 ; i < FIRST_DELAY_SB ; i++) {
-    FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-    FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-  }
-  for (i=0 ; i < NO_SUB_QMF_CHANNELS ; i++) {
-    FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-    FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-  }
-
-}
-
-/*******************************************************************************/
-
-/* slot based funcion prototypes */
-
-static void deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d,
-
-                                  FIXP_DBL    *mHybridRealLeft,
-                                  FIXP_DBL    *mHybridImagLeft,
-                                  SCHAR        sf_mHybridLeft,
-
-                                  FIXP_DBL    *rIntBufferLeft,
-                                  FIXP_DBL    *iIntBufferLeft,
-                                  SCHAR        sf_IntBuffer,
-
-                                  FIXP_DBL    *mHybridRealRight,
-                                  FIXP_DBL    *mHybridImagRight,
-
-                                  FIXP_DBL    *rIntBufferRight,
-                                  FIXP_DBL    *iIntBufferRight );
-
-static void applySlotBasedRotation( HANDLE_PS_DEC h_ps_d,
-
-                                    FIXP_DBL  *mHybridRealLeft,
-                                    FIXP_DBL  *mHybridImagLeft,
-
-                                    FIXP_DBL  *QmfLeftReal,
-                                    FIXP_DBL  *QmfLeftImag,
-
-                                    FIXP_DBL  *mHybridRealRight,
-                                    FIXP_DBL  *mHybridImagRight,
-
-                                    FIXP_DBL  *QmfRightReal,
-                                    FIXP_DBL  *QmfRightImag
-                                  );
-
-
-/***************************************************************************/
-/*!
-  \brief  Get scale factor for all ps delay buffer.
-
-  \return
-
-****************************************************************************/
-static
-int getScaleFactorPsStatesBuffer(HANDLE_PS_DEC   h_ps_d)
-{
-  INT i;
-  int scale = DFRACT_BITS-1;
-
-  for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS));
-  }
-
-  for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB));
-  }
-
-  for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
-  }
-
-  for (i=0; i<FIRST_DELAY_SB; i++) {
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
-  }
-
-  for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
-  }
-
-  for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++)
-  {
-    INT len;
-    if (i==0)
-      len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
-    else
-      len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
-
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len));
-    scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len));
-  }
-
-  return (scale);
-}
-
-/***************************************************************************/
-/*!
-  \brief  Rescale all ps delay buffer.
-
-  \return
-
-****************************************************************************/
-static
-void scalePsStatesBuffer(HANDLE_PS_DEC h_ps_d,
-                         int           scale)
-{
-  INT i;
-
-  if (scale < 0)
-    scale = fixMax((INT)scale,(INT)-(DFRACT_BITS-1));
-  else
-    scale = fixMin((INT)scale,(INT)DFRACT_BITS-1);
-
-  for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
-    scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS, scale );
-  }
-
-  for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
-    scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB, scale );
-  }
-
-  for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
-    scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
-  }
-
-  for (i=0; i<FIRST_DELAY_SB; i++) {
-    scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
-  }
-
-  for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
-    scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
-  }
-
-  for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++) {
-    INT len;
-    if (i==0)
-      len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
-    else
-      len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
-
-    scaleValues( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len, scale );
-    scaleValues( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len, scale );
-  }
-
-  scale <<= 1;
-
-  scaleValues( h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS, scale );
-  scaleValues( h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS, scale );
-  scaleValues( h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS, scale );
-}
-
-/***************************************************************************/
-/*!
-  \brief  Scale input channel to the same scalefactor and rescale hybrid
-          filterbank values
-
-  \return
-
-****************************************************************************/
-
-void scalFilterBankValues( HANDLE_PS_DEC   h_ps_d,
-                           FIXP_DBL      **fixpQmfReal,
-                           FIXP_DBL      **fixpQmfImag,
-                           int             lsb,
-                           int             scaleFactorLowBandSplitLow,
-                           int             scaleFactorLowBandSplitHigh,
-                           SCHAR          *scaleFactorLowBand_lb,
-                           SCHAR          *scaleFactorLowBand_hb,
-                           int             scaleFactorHighBands,
-                           INT            *scaleFactorHighBand,
-                           INT             noCols
-                         )
-{
-  INT maxScal;
-
-  INT i;
-
-  scaleFactorHighBands        =  -scaleFactorHighBands;
-  scaleFactorLowBandSplitLow  =  -scaleFactorLowBandSplitLow;
-  scaleFactorLowBandSplitHigh =  -scaleFactorLowBandSplitHigh;
-
-  /* get max scale factor */
-  maxScal = fixMax(scaleFactorHighBands,fixMax(scaleFactorLowBandSplitLow, scaleFactorLowBandSplitHigh ));
-
-  {
-    int headroom  = getScaleFactorPsStatesBuffer(h_ps_d);
-    maxScal   = fixMax(maxScal,(INT)(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-headroom));
-    maxScal  += 1;
-  }
-
-  /* scale whole left channel to the same scale factor */
-
-  /* low band ( overlap buffer ) */
-  if ( maxScal != scaleFactorLowBandSplitLow ) {
-    INT scale = scaleFactorLowBandSplitLow - maxScal;
-    for ( i=0; i<(6); i++ ) {
-      scaleValues( fixpQmfReal[i], lsb, scale );
-      scaleValues( fixpQmfImag[i], lsb, scale );
-    }
-  }
-  /* low band ( current frame ) */
-  if ( maxScal != scaleFactorLowBandSplitHigh ) {
-    INT scale = scaleFactorLowBandSplitHigh - maxScal;
-    /* for ( i=(6); i<(6)+MAX_NUM_COL; i++ ) { */
-    for ( i=(6); i<(6)+noCols; i++ ) {
-      scaleValues( fixpQmfReal[i], lsb, scale );
-      scaleValues( fixpQmfImag[i], lsb, scale );
-    }
-  }
-  /* high band */
-  if ( maxScal != scaleFactorHighBands ) {
-    INT scale = scaleFactorHighBands - maxScal;
-    /* for ( i=0; i<MAX_NUM_COL; i++ ) { */
-    for ( i=0; i<noCols; i++ ) {
-      scaleValues( &fixpQmfReal[i][lsb], (64)-lsb, scale );
-      scaleValues( &fixpQmfImag[i][lsb], (64)-lsb, scale );
-    }
-  }
-
-  if ( maxScal != h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer )
-    scalePsStatesBuffer(h_ps_d,(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-maxScal));
-
-  h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer = maxScal;
-  h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = maxScal;
-
-  *scaleFactorHighBand += maxScal - scaleFactorHighBands;
-
-  h_ps_d->rescal = maxScal - scaleFactorLowBandSplitHigh;
-  h_ps_d->sf_IntBuffer = maxScal;
-
-  *scaleFactorLowBand_lb += maxScal - scaleFactorLowBandSplitLow;
-  *scaleFactorLowBand_hb += maxScal - scaleFactorLowBandSplitHigh;
-}
-
-void rescalFilterBankValues( HANDLE_PS_DEC   h_ps_d,                      /* parametric stereo decoder handle     */
-                             FIXP_DBL      **QmfBufferReal,               /* qmf filterbank values                */
-                             FIXP_DBL      **QmfBufferImag,               /* qmf filterbank values                */
-                             int             lsb,                         /* sbr start subband                    */
-                             INT             noCols)
-{
-  int i;
-  /* scale back 6 timeslots look ahead for hybrid filterbank to original value */
-  for ( i=noCols; i<noCols + (6); i++ ) {
-    scaleValues( QmfBufferReal[i], lsb, h_ps_d->rescal );
-    scaleValues( QmfBufferImag[i], lsb, h_ps_d->rescal );
-  }
-}
-
-/***************************************************************************/
-/*!
-  \brief  Generate decorrelated side channel using allpass/delay
-
-  \return
-
-****************************************************************************/
-static void
-deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d,            /*!< pointer to the module state */
-
-                      FIXP_DBL    *mHybridRealLeft,    /*!< left (mono) hybrid values real */
-                      FIXP_DBL    *mHybridImagLeft,    /*!< left (mono) hybrid values imag */
-                      SCHAR        sf_mHybridLeft,     /*!< scalefactor for left (mono) hybrid bands */
-
-                      FIXP_DBL    *rIntBufferLeft,     /*!< real qmf bands left (mono) (38x64) */
-                      FIXP_DBL    *iIntBufferLeft,     /*!< real qmf bands left (mono) (38x64) */
-                      SCHAR        sf_IntBuffer,       /*!< scalefactor for all left and right qmf bands   */
-
-                      FIXP_DBL    *mHybridRealRight,   /*!< right (decorrelated) hybrid values real */
-                      FIXP_DBL    *mHybridImagRight,   /*!< right (decorrelated) hybrid values imag */
-
-                      FIXP_DBL    *rIntBufferRight,    /*!< real qmf bands right (decorrelated) (38x64) */
-                      FIXP_DBL    *iIntBufferRight )   /*!< real qmf bands right (decorrelated) (38x64) */
-{
-
-  INT  i, m, sb, gr, bin;
-
-  FIXP_DBL peakDiff, nrg, transRatio;
-
-  FIXP_DBL *RESTRICT aaLeftReal;
-  FIXP_DBL *RESTRICT aaLeftImag;
-
-  FIXP_DBL *RESTRICT aaRightReal;
-  FIXP_DBL *RESTRICT aaRightImag;
-
-  FIXP_DBL *RESTRICT pRealDelayBuffer;
-  FIXP_DBL *RESTRICT pImagDelayBuffer;
-
-  C_ALLOC_SCRATCH_START(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
-  C_ALLOC_SCRATCH_START(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
-
-/*!
-<pre>
-   parameter index       qmf bands             hybrid bands
-  ----------------------------------------------------------------------------
-         0                   0                      0,7
-         1                   0                      1,6
-         2                   0                      2
-         3                   0                      3           HYBRID BANDS
-         4                   1                      9
-         5                   1                      8
-         6                   2                     10
-         7                   2                     11
-  ----------------------------------------------------------------------------
-         8                   3
-         9                   4
-        10                   5
-        11                   6
-        12                   7
-        13                   8
-        14                   9,10      (2 )                      QMF BANDS
-        15                   11 - 13   (3 )
-        16                   14 - 17   (4 )
-        17                   18 - 22   (5 )
-        18                   23 - 34   (12)
-        19                   35 - 63   (29)
-  ----------------------------------------------------------------------------
-</pre>
-*/
-
-  #define FLTR_SCALE 3
-
-  /* hybrid bands (parameter index 0 - 7) */
-  aaLeftReal  = mHybridRealLeft;
-  aaLeftImag  = mHybridImagLeft;
-
-  aaPowerSlot[0] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[0],  aaLeftReal[0]),  aaLeftImag[0],  aaLeftImag[0] ) >> FLTR_SCALE ) +
-                   ( fMultAddDiv2( fMultDiv2(aaLeftReal[7],  aaLeftReal[7]),  aaLeftImag[7],  aaLeftImag[7] ) >> FLTR_SCALE );
-
-  aaPowerSlot[1] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[1],  aaLeftReal[1]),  aaLeftImag[1],  aaLeftImag[1] ) >> FLTR_SCALE ) +
-                   ( fMultAddDiv2( fMultDiv2(aaLeftReal[6],  aaLeftReal[6]),  aaLeftImag[6],  aaLeftImag[6] ) >> FLTR_SCALE );
-
-  aaPowerSlot[2] =   fMultAddDiv2( fMultDiv2(aaLeftReal[2],  aaLeftReal[2]),  aaLeftImag[2],  aaLeftImag[2] ) >> FLTR_SCALE;
-  aaPowerSlot[3] =   fMultAddDiv2( fMultDiv2(aaLeftReal[3],  aaLeftReal[3]),  aaLeftImag[3],  aaLeftImag[3] ) >> FLTR_SCALE;
-
-  aaPowerSlot[4] =   fMultAddDiv2( fMultDiv2(aaLeftReal[9],  aaLeftReal[9]),  aaLeftImag[9],  aaLeftImag[9] ) >> FLTR_SCALE;
-  aaPowerSlot[5] =   fMultAddDiv2( fMultDiv2(aaLeftReal[8],  aaLeftReal[8]),  aaLeftImag[8],  aaLeftImag[8] ) >> FLTR_SCALE;
-
-  aaPowerSlot[6] =   fMultAddDiv2( fMultDiv2(aaLeftReal[10], aaLeftReal[10]), aaLeftImag[10], aaLeftImag[10] ) >> FLTR_SCALE;
-  aaPowerSlot[7] =   fMultAddDiv2( fMultDiv2(aaLeftReal[11], aaLeftReal[11]), aaLeftImag[11], aaLeftImag[11] ) >> FLTR_SCALE;
-
-  /* qmf bands (parameter index 8 - 19) */
-  for ( bin = 8; bin < NO_MID_RES_BINS; bin++ ) {
-    FIXP_DBL slotNrg = FL2FXCONST_DBL(0.f);
-
-    for ( i = groupBorders20[bin+2]; i < groupBorders20[bin+3]; i++ ) {  /* max loops: 29 */
-      slotNrg += fMultAddDiv2 ( fMultDiv2(rIntBufferLeft[i], rIntBufferLeft[i]), iIntBufferLeft[i], iIntBufferLeft[i]) >> FLTR_SCALE;
-    }
-    aaPowerSlot[bin] = slotNrg;
-
-  }
-
-
-  /* calculation of transient ratio */
-  for (bin=0; bin < NO_MID_RES_BINS; bin++) {   /* noBins = 20 ( BASELINE_PS ) */
-
-    h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = fMult( h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin], PEAK_DECAY_FACTOR );
-
-    if (h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] < aaPowerSlot[bin]) {
-      h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = aaPowerSlot[bin];
-    }
-
-    /* calculate PSmoothPeakDecayDiffNrg */
-    peakDiff = fMultAdd ( (h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]>>1),
-                 INT_FILTER_COEFF, h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] - aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]);
-
-    /* save peakDiff for the next frame */
-    h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin] = peakDiff;
-
-    nrg = h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] + fMult( INT_FILTER_COEFF, aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] );
-
-    /* Negative energies don't exist. But sometimes they appear due to rounding. */
-
-    nrg = fixMax(nrg,FL2FXCONST_DBL(0.f));
-
-    /* save nrg for the next frame */
-    h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] = nrg;
-
-    nrg = fMult( nrg, TRANSIENT_IMPACT_FACTOR );
-
-    /* save transient impact factor */
-    if ( peakDiff <= nrg || peakDiff == FL2FXCONST_DBL(0.0) ) {
-      aaTransRatioSlot[bin] = (FIXP_DBL)MAXVAL_DBL /* FL2FXCONST_DBL(1.0f)*/;
-    }
-    else if ( nrg <= FL2FXCONST_DBL(0.0f) ) {
-        aaTransRatioSlot[bin] = FL2FXCONST_DBL(0.f);
-      }
-    else {
-      /* scale to denominator */
-      INT scale_left = fixMax(0, CntLeadingZeros(peakDiff) - 1);
-      aaTransRatioSlot[bin] = schur_div( nrg<<scale_left, peakDiff<<scale_left, 16);
-    }
-  } /* bin */
-
-
-
-
-  #define DELAY_GROUP_OFFSET    20
-  #define NR_OF_DELAY_GROUPS     2
-
-  FIXP_DBL rTmp, iTmp, rTmp0, iTmp0, rR0, iR0;
-
-  INT TempDelay     = h_ps_d->specificTo.mpeg.delayBufIndex;  /* set delay indices */
-
-  pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[TempDelay];
-  pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[TempDelay];
-
-  aaLeftReal  = mHybridRealLeft;
-  aaLeftImag  = mHybridImagLeft;
-  aaRightReal = mHybridRealRight;
-  aaRightImag = mHybridImagRight;
-
-  /************************/
-  /* ICC groups :  0 -  9 */
-  /************************/
-
-  /* gr = ICC groups */
-  for (gr=0; gr < SUBQMF_GROUPS; gr++) {
-
-    transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
-
-    /* sb = subQMF/QMF subband */
-    sb = groupBorders20[gr];
-
-    /* Update delay buffers, sample delay allpass = 2 */
-    rTmp0 = pRealDelayBuffer[sb];
-    iTmp0 = pImagDelayBuffer[sb];
-
-    pRealDelayBuffer[sb] = aaLeftReal[sb];
-    pImagDelayBuffer[sb] = aaLeftImag[sb];
-
-    /* delay by fraction */
-    cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReSubQmf20[sb], aaFractDelayPhaseFactorImSubQmf20[sb]);
-    rR0<<=1;
-    iR0<<=1;
-
-    FIXP_DBL *pAaaRealDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[sb];
-    FIXP_DBL *pAaaImagDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[sb];
-
-    for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
-
-      INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
-
-      /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
-      rTmp0 = pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer];
-      iTmp0 = pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer];
-
-      /* delay by fraction */
-      cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReSubQmf20[sb][m], aaFractDelayPhaseFactorSerImSubQmf20[sb][m]);
-
-      rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], rR0)) << 1;
-      iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], iR0)) << 1;
-
-      pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], rTmp);
-      pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], iTmp);
-
-      rR0 = rTmp;
-      iR0 = iTmp;
-
-      pAaaRealDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
-      pAaaImagDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
-
-    } /* m */
-
-    /* duck if a past transient is found */
-    aaRightReal[sb] = fMult(transRatio, rR0);
-    aaRightImag[sb] = fMult(transRatio, iR0);
-
-  } /* gr */
-
-
-  scaleValues( mHybridRealLeft,  NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
-  scaleValues( mHybridImagLeft,  NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
-  scaleValues( mHybridRealRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
-  scaleValues( mHybridImagRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
-
-
-  /************************/
-
-  aaLeftReal  = rIntBufferLeft;
-  aaLeftImag  = iIntBufferLeft;
-  aaRightReal = rIntBufferRight;
-  aaRightImag = iIntBufferRight;
-
-  pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[TempDelay];
-  pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[TempDelay];
-
-  /************************/
-  /* ICC groups : 10 - 19 */
-  /************************/
-
-
-  /* gr = ICC groups */
-  for (gr=SUBQMF_GROUPS; gr < NO_IID_GROUPS - NR_OF_DELAY_GROUPS; gr++) {
-
-    transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
-
-    /* sb = subQMF/QMF subband */
-    for (sb = groupBorders20[gr]; sb < groupBorders20[gr+1]; sb++) {
-      FIXP_DBL resR, resI;
-
-      /* decayScaleFactor = 1.0f + decay_cutoff * DECAY_SLOPE - DECAY_SLOPE * sb; DECAY_SLOPE = 0.05 */
-      FIXP_DBL decayScaleFactor = decayScaleFactTable[sb];
-
-      /* Update delay buffers, sample delay allpass = 2 */
-      rTmp0 = pRealDelayBuffer[sb];
-      iTmp0 = pImagDelayBuffer[sb];
-
-      pRealDelayBuffer[sb] = aaLeftReal[sb];
-      pImagDelayBuffer[sb] = aaLeftImag[sb];
-
-      /* delay by fraction */
-      cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReQmf[sb], aaFractDelayPhaseFactorImQmf[sb]);
-      rR0<<=1;
-      iR0<<=1;
-
-      resR = fMult(decayScaleFactor, rR0);
-      resI = fMult(decayScaleFactor, iR0);
-
-      FIXP_DBL *pAaaRealDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[sb];
-      FIXP_DBL *pAaaImagDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[sb];
-
-      for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
-
-        INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
-
-        /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
-        rTmp0 = pAaaRealDelayRBufferSerQmf[tmpDelayRSer];
-        iTmp0 = pAaaImagDelayRBufferSerQmf[tmpDelayRSer];
-
-        /* delay by fraction */
-        cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReQmf[sb][m], aaFractDelayPhaseFactorSerImQmf[sb][m]);
-
-        rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], resR))<<1;
-        iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], resI))<<1;
-
-        resR = fMult(decayScaleFactor, rTmp);
-        resI = fMult(decayScaleFactor, iTmp);
-
-        pAaaRealDelayRBufferSerQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], resR);
-        pAaaImagDelayRBufferSerQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], resI);
-
-        rR0 = rTmp;
-        iR0 = iTmp;
-
-        pAaaRealDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
-        pAaaImagDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
-
-      } /* m */
-
-      /* duck if a past transient is found */
-      aaRightReal[sb] = fMult(transRatio, rR0);
-      aaRightImag[sb] = fMult(transRatio, iR0);
-
-    } /* sb */
-  } /* gr */
-
-  /************************/
-  /* ICC groups : 20,  21 */
-  /************************/
-
-
-  /* gr = ICC groups */
-  for (gr=DELAY_GROUP_OFFSET; gr < NO_IID_GROUPS; gr++) {
-
-    INT sbStart = groupBorders20[gr];
-    INT sbStop  = groupBorders20[gr+1];
-
-    UCHAR *pDelayBufIdx = &h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf[sbStart-FIRST_DELAY_SB];
-
-    transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
-
-    /* sb = subQMF/QMF subband */
-    for (sb = sbStart; sb < sbStop; sb++) {
-
-      /* Update delay buffers */
-      rR0 = h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
-      iR0 = h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
-
-      h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftReal[sb];
-      h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftImag[sb];
-
-      /* duck if a past transient is found */
-      aaRightReal[sb] = fMult(transRatio, rR0);
-      aaRightImag[sb] = fMult(transRatio, iR0);
-
-      if (++(*pDelayBufIdx) >= delayIndexQmf[sb]) {
-        *pDelayBufIdx = 0;
-      }
-      pDelayBufIdx++;
-
-    } /* sb */
-  } /* gr */
-
-
-  /* Update delay buffer index */
-  if (++h_ps_d->specificTo.mpeg.delayBufIndex >= NO_SAMPLE_DELAY_ALLPASS)
-    h_ps_d->specificTo.mpeg.delayBufIndex = 0;
-
-  for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
-    if (++h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] >= aAllpassLinkDelaySer[m])
-      h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] = 0;
-  }
-
-
-  scaleValues( &rIntBufferLeft[NO_QMF_BANDS_HYBRID20],  NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
-  scaleValues( &iIntBufferLeft[NO_QMF_BANDS_HYBRID20],  NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
-  scaleValues( &rIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
-  scaleValues( &iIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
-
-  /* free memory on scratch */
-  C_ALLOC_SCRATCH_END(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
-  C_ALLOC_SCRATCH_END(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
-}
-
-
-void initSlotBasedRotation( HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */
-                            int env,
-                            int usb
-                            ) {
-
-  INT     group = 0;
-  INT     bin =  0;
-  INT     noIidSteps;
-
-/*  const UCHAR *pQuantizedIIDs;*/
-
-  FIXP_SGL  invL;
-  FIXP_DBL  ScaleL, ScaleR;
-  FIXP_DBL  Alpha, Beta;
-  FIXP_DBL  h11r, h12r, h21r, h22r;
-
-  const FIXP_DBL  *PScaleFactors;
-
-  /* Overwrite old values in delay buffers when upper subband is higher than in last frame */
-  if (env == 0) {
-
-    if ((usb > h_ps_d->specificTo.mpeg.lastUsb) && h_ps_d->specificTo.mpeg.lastUsb) {
-
-      INT i,k,length;
-
-      for (i=h_ps_d->specificTo.mpeg.lastUsb ; i < FIRST_DELAY_SB; i++) {
-        FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-        FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
-      }
-
-      for (k=0 ; k<NO_SAMPLE_DELAY_ALLPASS; k++) {
-        FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], FIRST_DELAY_SB*sizeof(FIXP_DBL));
-      }
-      length = (usb-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
-      if(length>0) {
-        FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0], length);
-        FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0], length);
-      }
-      length = (fixMin(NO_DELAY_BUFFER_BANDS,(INT)usb)-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
-      if(length>0) {
-        for (k=1 ; k < h_ps_d->specificTo.mpeg.noSampleDelay; k++) {
-          FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], length);
-          FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[k], length);
-        }
-      }
-    }
-    h_ps_d->specificTo.mpeg.lastUsb = usb;
-  } /* env == 0 */
-
-  if (h_ps_d->bsData[h_ps_d->processSlot].mpeg.bFineIidQ)
-  {
-    PScaleFactors = ScaleFactorsFine; /* values are shiftet right by one */
-    noIidSteps = NO_IID_STEPS_FINE;
-    /*pQuantizedIIDs = quantizedIIDsFine;*/
-  }
-
-  else
-  {
-    PScaleFactors = ScaleFactors; /* values are shiftet right by one */
-    noIidSteps = NO_IID_STEPS;
-    /*pQuantizedIIDs = quantizedIIDs;*/
-  }
-
-
-  /* dequantize and decode */
-  for ( group = 0; group < NO_IID_GROUPS; group++ ) {
-
-    bin = bins2groupMap20[group];
-
-    /*!
-    <h3> type 'A' rotation </h3>
-    mixing procedure R_a, used in baseline version<br>
-
-     Scale-factor vectors c1 and c2 are precalculated in initPsTables () and stored in
-     scaleFactors[] and scaleFactorsFine[] = pScaleFactors [].
-     From the linearized IID parameters (intensity differences), two scale factors are
-     calculated. They are used to obtain the coefficients h11... h22.
-    */
-
-    /* ScaleR and ScaleL are scaled by 1 shift right */
-
-    ScaleR = PScaleFactors[noIidSteps + h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][bin]];
-    ScaleL = PScaleFactors[noIidSteps - h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][bin]];
-
-    Beta   = fMult (fMult( Alphas[h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][bin]], ( ScaleR - ScaleL )), FIXP_SQRT05);
-    Alpha  = Alphas[h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][bin]]>>1;
-
-    /* Alpha and Beta are now both scaled by 2 shifts right */
-
-    /* calculate the coefficients h11... h22 from scale-factors and ICC parameters */
-
-    /* h values are scaled by 1 shift right */
-    {
-      FIXP_DBL trigData[4];
-
-      inline_fixp_cos_sin(Beta + Alpha, Beta - Alpha, 2, trigData);
-      h11r = fMult( ScaleL, trigData[0]);
-      h12r = fMult( ScaleR, trigData[2]);
-      h21r = fMult( ScaleL, trigData[1]);
-      h22r = fMult( ScaleR, trigData[3]);
-    }
-    /*****************************************************************************************/
-    /* Interpolation of the matrices H11... H22:                                             */
-    /*                                                                                       */
-    /* H11(k,n) = H11(k,n[e]) + (n-n[e]) * (H11(k,n[e+1] - H11(k,n[e])) / (n[e+1] - n[e])    */
-    /* ...                                                                                   */
-    /*****************************************************************************************/
-
-    /* invL = 1/(length of envelope) */
-    invL = FX_DBL2FX_SGL(GetInvInt(h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env + 1] - h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env]));
-
-    h_ps_d->specificTo.mpeg.coef.H11r[group]  = h_ps_d->specificTo.mpeg.h11rPrev[group];
-    h_ps_d->specificTo.mpeg.coef.H12r[group]  = h_ps_d->specificTo.mpeg.h12rPrev[group];
-    h_ps_d->specificTo.mpeg.coef.H21r[group]  = h_ps_d->specificTo.mpeg.h21rPrev[group];
-    h_ps_d->specificTo.mpeg.coef.H22r[group]  = h_ps_d->specificTo.mpeg.h22rPrev[group];
-
-    h_ps_d->specificTo.mpeg.coef.DeltaH11r[group]  = fMult ( h11r - h_ps_d->specificTo.mpeg.coef.H11r[group], invL );
-    h_ps_d->specificTo.mpeg.coef.DeltaH12r[group]  = fMult ( h12r - h_ps_d->specificTo.mpeg.coef.H12r[group], invL );
-    h_ps_d->specificTo.mpeg.coef.DeltaH21r[group]  = fMult ( h21r - h_ps_d->specificTo.mpeg.coef.H21r[group], invL );
-    h_ps_d->specificTo.mpeg.coef.DeltaH22r[group]  = fMult ( h22r - h_ps_d->specificTo.mpeg.coef.H22r[group], invL );
-
-    /* update prev coefficients for interpolation in next envelope */
-
-    h_ps_d->specificTo.mpeg.h11rPrev[group] = h11r;
-    h_ps_d->specificTo.mpeg.h12rPrev[group] = h12r;
-    h_ps_d->specificTo.mpeg.h21rPrev[group] = h21r;
-    h_ps_d->specificTo.mpeg.h22rPrev[group] = h22r;
-
-  } /* group loop */
-}
-
-
-static void applySlotBasedRotation( HANDLE_PS_DEC h_ps_d,        /*!< pointer to the module state */
-
-                                    FIXP_DBL  *mHybridRealLeft,  /*!< hybrid values real left  */
-                                    FIXP_DBL  *mHybridImagLeft,  /*!< hybrid values imag left  */
-
-                                    FIXP_DBL  *QmfLeftReal,      /*!< real bands left qmf channel */
-                                    FIXP_DBL  *QmfLeftImag,      /*!< imag bands left qmf channel */
-
-                                    FIXP_DBL  *mHybridRealRight, /*!< hybrid values real right  */
-                                    FIXP_DBL  *mHybridImagRight, /*!< hybrid values imag right  */
-
-                                    FIXP_DBL  *QmfRightReal,     /*!< real bands right qmf channel */
-                                    FIXP_DBL  *QmfRightImag      /*!< imag bands right qmf channel */
-                                   )
-{
-  INT     group;
-  INT     subband;
-
-  FIXP_DBL *RESTRICT HybrLeftReal;
-  FIXP_DBL *RESTRICT HybrLeftImag;
-  FIXP_DBL *RESTRICT HybrRightReal;
-  FIXP_DBL *RESTRICT HybrRightImag;
-
-  FIXP_DBL tmpLeft, tmpRight;
-
-
-  /**********************************************************************************************/
-  /*!
-  <h2> Mapping </h2>
-
-  The number of stereo bands that is actually used depends on the number of availble
-  parameters for IID and ICC:
-  <pre>
-   nr. of IID para.| nr. of ICC para. | nr. of Stereo bands
-   ----------------|------------------|-------------------
-     10,20         |     10,20        |        20
-     10,20         |     34           |        34
-     34            |     10,20        |        34
-     34            |     34           |        34
-  </pre>
-  In the case the number of parameters for IIS and ICC differs from the number of stereo
-  bands, a mapping from the lower number to the higher number of parameters is applied.
-  Index mapping of IID and ICC parameters is already done in psbitdec.cpp. Further mapping is
-  not needed here in baseline version.
-  **********************************************************************************************/
-
-  /************************************************************************************************/
-  /*!
-  <h2> Mixing </h2>
-
-  To generate the QMF subband signals for the subband samples n = n[e]+1 ,,, n_[e+1] the
-  parameters at position n[e] and n[e+1] are required as well as the subband domain signals
-  s_k(n) and d_k(n) for n = n[e]+1... n_[e+1]. n[e] represents the start position for
-  envelope e. The border positions n[e] are handled in DecodePS().
-
-  The stereo sub subband signals are constructed as:
-  <pre>
-  l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n)
-  r_k(n) = H21(k,n) s_k(n) + H22(k,n) d_k(n)
-  </pre>
-  In order to obtain the matrices H11(k,n)... H22 (k,n), the vectors h11(b)... h22(b) need to
-  be calculated first (b: parameter index). Depending on ICC mode either mixing procedure R_a
-  or R_b is used for that. For both procedures, the parameters for parameter position n[e+1]
-  is used.
-  ************************************************************************************************/
-
-
-  /************************************************************************************************/
-  /*!
-  <h2>Phase parameters </h2>
-  With disabled phase parameters (which is the case in baseline version), the H-matrices are
-  just calculated by:
-
-  <pre>
-  H11(k,n[e+1] = h11(b(k))
-  (...)
-  b(k): parameter index according to mapping table
-  </pre>
-
-  <h2>Processing of the samples in the sub subbands </h2>
-  this loop includes the interpolation of the coefficients Hxx
-  ************************************************************************************************/
-
-
-  /* loop thru all groups ... */
-  HybrLeftReal  = mHybridRealLeft;
-  HybrLeftImag  = mHybridImagLeft;
-  HybrRightReal = mHybridRealRight;
-  HybrRightImag = mHybridImagRight;
-
-  /******************************************************/
-  /* construct stereo sub subband signals according to: */
-  /*                                                    */
-  /* l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n)         */
-  /* r_k(n) = H12(k,n) s_k(n) + H22(k,n) d_k(n)         */
-  /******************************************************/
-  for ( group = 0; group < SUBQMF_GROUPS; group++ ) {
-
-    h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
-    h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
-    h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
-    h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
-
-    subband = groupBorders20[group];
-
-    tmpLeft  = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
-    tmpRight = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
-    HybrLeftReal [subband] = tmpLeft<<1;
-    HybrRightReal[subband] = tmpRight<<1;
-
-    tmpLeft  = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
-    tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
-    HybrLeftImag [subband] = tmpLeft;
-    HybrRightImag[subband] = tmpRight;
-  }
-
-  /* continue in the qmf buffers */
-  HybrLeftReal  = QmfLeftReal;
-  HybrLeftImag  = QmfLeftImag;
-  HybrRightReal = QmfRightReal;
-  HybrRightImag = QmfRightImag;
-
-  for (; group < NO_IID_GROUPS; group++ ) {
-
-    h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
-    h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
-    h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
-    h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
-
-    for ( subband = groupBorders20[group]; subband < groupBorders20[group + 1]; subband++ )
-    {
-      tmpLeft  = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
-      tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
-      HybrLeftReal [subband] = tmpLeft;
-      HybrRightReal[subband] = tmpRight;
-
-      tmpLeft  = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
-      tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
-      HybrLeftImag [subband] = tmpLeft;
-      HybrRightImag[subband] = tmpRight;
-
-    } /* subband */
-  }
-}
-
-
-/***************************************************************************/
-/*!
-  \brief  Applies IID, ICC, IPD and OPD parameters to the current frame.
-
-  \return none
-
-****************************************************************************/
-void
-ApplyPsSlot( HANDLE_PS_DEC h_ps_d,         /*!< handle PS_DEC*/
-             FIXP_DBL  **rIntBufferLeft,   /*!< real bands left qmf channel (38x64)  */
-             FIXP_DBL  **iIntBufferLeft,   /*!< imag bands left qmf channel (38x64)  */
-             FIXP_DBL  *rIntBufferRight,   /*!< real bands right qmf channel (38x64) */
-             FIXP_DBL  *iIntBufferRight    /*!< imag bands right qmf channel (38x64) */
-           )
-{
-
-  /*!
-  The 64-band QMF representation of the monaural signal generated by the SBR tool
-  is used as input of the PS tool. After the PS processing, the outputs of the left
-  and right hybrid synthesis filterbanks are used to generate the stereo output
-  signal.
-
-  <pre>
-
-             -------------            ----------            -------------
-            | Hybrid      | M_n[k,m] |          | L_n[k,m] | Hybrid      | l[n]
-   m[n] --->| analysis    |--------->|          |--------->| synthesis   |----->
-            | filter bank |          |          |          | filter bank |
-             -------------           | Stereo   |           -------------
-                   |                 | recon-   |
-                   |                 | stuction |
-                  \|/                |          |
-             -------------           |          |
-            | De-         | D_n[k,m] |          |
-            | correlation |--------->|          |
-             -------------           |          |           -------------
-                                     |          | R_n[k,m] | Hybrid      | r[n]
-                                     |          |--------->| synthesis   |----->
-   IID, ICC ------------------------>|          |          | filter bank |
-  (IPD, OPD)                          ----------            -------------
-
-  m[n]:      QMF represantation of the mono input
-  M_n[k,m]:  (sub-)sub-band domain signals of the mono input
-  D_n[k,m]:  decorrelated (sub-)sub-band domain signals
-  L_n[k,m]:  (sub-)sub-band domain signals of the left output
-  R_n[k,m]:  (sub-)sub-band domain signals of the right output
-  l[n],r[n]: left/right output signals
-
-  </pre>
-  */
-
-  /* get temporary hybrid qmf values of one timeslot */
-  C_ALLOC_SCRATCH_START(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_START(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_START(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_START(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-
-  SCHAR sf_IntBuffer     = h_ps_d->sf_IntBuffer;
-
-  /* clear workbuffer */
-  FDKmemclear(hybridRealLeft,  NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
-  FDKmemclear(hybridImagLeft,  NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
-  FDKmemclear(hybridRealRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
-  FDKmemclear(hybridImagRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
-
-
-  /*!
-  Hybrid analysis filterbank:
-  The lower 3 (5) of the 64 QMF subbands are further split to provide better frequency resolution.
-  for PS processing.
-  For the 10 and 20 stereo bands configuration, the QMF band H_0(w) is split
-  up into 8 (sub-) sub-bands and the QMF bands H_1(w) and H_2(w) are spit into 2 (sub-)
-  4th. (See figures 8.20 and 8.22 of ISO/IEC 14496-3:2001/FDAM 2:2004(E) )
-  */
-
-
-  if (h_ps_d->procFrameBased == 1)    /* If we have switched from frame to slot based processing  */
-  {                                   /* fill hybrid delay buffer.                                */
-    h_ps_d->procFrameBased = 0;
-
-    fillHybridDelayLine( rIntBufferLeft,
-                         iIntBufferLeft,
-                         hybridRealLeft,
-                         hybridImagLeft,
-                         hybridRealRight,
-                         hybridImagRight,
-                        &h_ps_d->specificTo.mpeg.hybrid );
-  }
-
-  slotBasedHybridAnalysis ( rIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values                         */
-                            iIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values                         */
-                            hybridRealLeft,                      /* hybrid filterbank values                      */
-                            hybridImagLeft,                      /* hybrid filterbank values                      */
-                           &h_ps_d->specificTo.mpeg.hybrid);          /* hybrid filterbank handle                      */
-
-
-  SCHAR hybridScal = h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer;
-
-
-  /*!
-  Decorrelation:
-  By means of all-pass filtering and delaying, the (sub-)sub-band samples s_k(n) are
-  converted into de-correlated (sub-)sub-band samples d_k(n).
-  - k: frequency in hybrid spectrum
-  - n: time index
-  */
-
-  deCorrelateSlotBased( h_ps_d,              /* parametric stereo decoder handle       */
-                        hybridRealLeft,      /* left hybrid time slot                  */
-                        hybridImagLeft,
-                        hybridScal,      /* scale factor of left hybrid time slot  */
-                        rIntBufferLeft[0],   /* left qmf time slot                     */
-                        iIntBufferLeft[0],
-                        sf_IntBuffer,        /* scale factor of left and right qmf time slot */
-                        hybridRealRight,     /* right hybrid time slot                 */
-                        hybridImagRight,
-                        rIntBufferRight,     /* right qmf time slot                    */
-                        iIntBufferRight );
-
-
-
-  /*!
-  Stereo Processing:
-  The sets of (sub-)sub-band samples s_k(n) and d_k(n) are processed according to
-  the stereo cues which are defined per stereo band.
-  */
-
-
-  applySlotBasedRotation( h_ps_d,            /* parametric stereo decoder handle       */
-                          hybridRealLeft,    /* left hybrid time slot                  */
-                          hybridImagLeft,
-                          rIntBufferLeft[0], /* left qmf time slot                     */
-                          iIntBufferLeft[0],
-                          hybridRealRight,   /* right hybrid time slot                 */
-                          hybridImagRight,
-                          rIntBufferRight,   /* right qmf time slot                    */
-                          iIntBufferRight );
-
-
-
-
-  /*!
-  Hybrid synthesis filterbank:
-  The stereo processed hybrid subband signals l_k(n) and r_k(n) are fed into the hybrid synthesis
-  filterbanks which are identical to the 64 complex synthesis filterbank of the SBR tool. The
-  input to the filterbank are slots of 64 QMF samples. For each slot the filterbank outputs one
-  block of 64 samples of one reconstructed stereo channel. The hybrid synthesis filterbank is
-  computed seperatly for the left and right channel.
-  */
-
-
-  /* left channel */
-  slotBasedHybridSynthesis ( hybridRealLeft,         /* one timeslot of hybrid filterbank values */
-                             hybridImagLeft,
-                             rIntBufferLeft[0],      /* one timeslot of qmf filterbank values    */
-                             iIntBufferLeft[0],
-                            &h_ps_d->specificTo.mpeg.hybrid );      /* hybrid filterbank handle                 */
-
-  /* right channel */
-  slotBasedHybridSynthesis ( hybridRealRight,        /* one timeslot of hybrid filterbank values */
-                             hybridImagRight,
-                             rIntBufferRight,        /* one timeslot of qmf filterbank values    */
-                             iIntBufferRight,
-                            &h_ps_d->specificTo.mpeg.hybrid );      /* hybrid filterbank handle                 */
-
-
-
-
-
-
-
-  /* free temporary hybrid qmf values of one timeslot */
-  C_ALLOC_SCRATCH_END(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_END(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_END(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-  C_ALLOC_SCRATCH_END(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
-
-}/* END ApplyPsSlot */
-
-
-/***************************************************************************/
-/*!
-
-  \brief  assigns timeslots to an array
-
-  \return
-
-****************************************************************************/
-
-static void assignTimeSlotsPS (FIXP_DBL *bufAdr,
-                               FIXP_DBL **bufPtr,
-                               const int numSlots,
-                               const int numChan)
-{
-  FIXP_DBL  *ptr;
-  int slot;
-  ptr = bufAdr;
-  for(slot=0; slot < numSlots; slot++) {
-   bufPtr [slot] = ptr;
-    ptr += numChan;
-  }
-}
-
diff --git a/libSBRdec/src/psdec.h b/libSBRdec/src/psdec.h
deleted file mode 100644
index 3dbc76d..0000000
--- a/libSBRdec/src/psdec.h
+++ /dev/null
@@ -1,352 +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  Sbr decoder  
-*/
-#ifndef __PSDEC_H
-#define __PSDEC_H
-
-#include "sbrdecoder.h"
-
-
-
-/* This PS decoder implements the baseline version. So it always uses the     */
-/* hybrid filter structure for 20 stereo bands and does not implemet IPD/OPD  */
-/* synthesis. The baseline version has to support the complete PS bitstream   */
-/* syntax. But IPD/OPD data is ignored and set to 0. If 34 stereo band config */
-/* is used in the bitstream for IIS/ICC the decoded parameters are mapped to  */
-/* 20 stereo bands.                                                           */
-
-
-#include "FDK_bitstream.h"
-
-#include "psdec_hybrid.h"
-
-#define SCAL_HEADROOM                     ( 2 )
-
-#define PS_EXTENSION_SIZE_BITS            ( 4 )
-#define PS_EXTENSION_ESC_COUNT_BITS       ( 8 )
-
-#define NO_QMF_CHANNELS                   ( 64 )
-#define MAX_NUM_COL                       ( 32 )
-
-
-  #define NO_QMF_BANDS_HYBRID20           ( 3  )
-  #define NO_SUB_QMF_CHANNELS             ( 12 )
-
-  #define NRG_INT_COEFF                   ( 0.75f )
-  #define INT_FILTER_COEFF                (FL2FXCONST_DBL( 1.0f - NRG_INT_COEFF ))
-  #define PEAK_DECAY_FACTOR               (FL2FXCONST_DBL( 0.765928338364649f ))
-  #define TRANSIENT_IMPACT_FACTOR         (FL2FXCONST_DBL( 2.0 / 3.0 ))
-
-  #define NO_SERIAL_ALLPASS_LINKS         ( 3 )
-  #define MAX_NO_PS_ENV                   ( 4 + 1 )   /* +1 needed for VAR_BORDER */
-
-  #define MAX_DELAY_BUFFER_SIZE           ( 14 )
-  #define NO_DELAY_BUFFER_BANDS           ( 35 )
-
-  #define NO_HI_RES_BINS                  ( 34 )
-  #define NO_MID_RES_BINS                 ( 20 )
-  #define NO_LOW_RES_BINS                 ( 10 )
-
-  #define FIRST_DELAY_SB                  ( 23 )
-  #define NO_SAMPLE_DELAY_ALLPASS         ( 2 )
-  #define NO_DELAY_LENGTH_VECTORS         ( 12 )     /* d(m): d(0)=3 + d(1)=4 + d(2)=5 */
-
-  #define NO_HI_RES_IID_BINS              ( NO_HI_RES_BINS )
-  #define NO_HI_RES_ICC_BINS              ( NO_HI_RES_BINS )
-
-  #define NO_MID_RES_IID_BINS             ( NO_MID_RES_BINS )
-  #define NO_MID_RES_ICC_BINS             ( NO_MID_RES_BINS )
-
-  #define NO_LOW_RES_IID_BINS             ( NO_LOW_RES_BINS )
-  #define NO_LOW_RES_ICC_BINS             ( NO_LOW_RES_BINS )
-
-  #define SUBQMF_GROUPS                   ( 10 )
-  #define QMF_GROUPS                      ( 12 )
-
-  #define SUBQMF_GROUPS_HI_RES            ( 32 )
-  #define QMF_GROUPS_HI_RES               ( 18 )
-
-  #define NO_IID_GROUPS                   ( SUBQMF_GROUPS + QMF_GROUPS )
-  #define NO_IID_GROUPS_HI_RES            ( SUBQMF_GROUPS_HI_RES + QMF_GROUPS_HI_RES )
-
-  #define NO_IID_STEPS                    ( 7 )  /* 1 .. + 7 */
-  #define NO_IID_STEPS_FINE               ( 15 ) /* 1 .. +15 */
-  #define NO_ICC_STEPS                    ( 8 )  /* 0 .. + 7 */
-
-  #define NO_IID_LEVELS                   ( 2 * NO_IID_STEPS + 1 )      /* - 7 ..  + 7 */
-  #define NO_IID_LEVELS_FINE              ( 2 * NO_IID_STEPS_FINE + 1 ) /* -15 ..  +15 */
-  #define NO_ICC_LEVELS                   ( NO_ICC_STEPS )              /*   0 ..  + 7 */
-
-  #define FIXP_SQRT05                     ((FIXP_DBL)0x5a827980) /* 1/SQRT2 */
-
-  struct PS_DEC_COEFFICIENTS {
-
-    FIXP_DBL H11r[NO_IID_GROUPS];                       /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL H12r[NO_IID_GROUPS];                       /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL H21r[NO_IID_GROUPS];                       /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL H22r[NO_IID_GROUPS];                       /*!< coefficients of the sub-subband groups                               */
-
-    FIXP_DBL DeltaH11r[NO_IID_GROUPS];                  /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL DeltaH12r[NO_IID_GROUPS];                  /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL DeltaH21r[NO_IID_GROUPS];                  /*!< coefficients of the sub-subband groups                               */
-    FIXP_DBL DeltaH22r[NO_IID_GROUPS];                  /*!< coefficients of the sub-subband groups                               */
-
-    SCHAR aaIidIndexMapped[MAX_NO_PS_ENV][NO_HI_RES_IID_BINS];       /*!< The mapped IID index for all envelopes and all IID bins */
-    SCHAR aaIccIndexMapped[MAX_NO_PS_ENV][NO_HI_RES_ICC_BINS];       /*!< The mapped ICC index for all envelopes and all ICC bins */
-
-  };
-
-
-
-
-typedef enum {
-  ppt_none = 0,
-  ppt_mpeg = 1,
-  ppt_drm  = 2
-} PS_PAYLOAD_TYPE;
-
-
-typedef struct {
-  UCHAR bPsHeaderValid;                                      /*!< set if new header is available from bitstream                 */
-
-  UCHAR bEnableIid;                                          /*!< One bit denoting the presence of IID parameters               */
-  UCHAR bEnableIcc;                                          /*!< One bit denoting the presence of ICC parameters               */
-  UCHAR bEnableExt;                                          /*!< The PS extension layer is enabled using the enable_ext bit.
-                                                                  If it is set to %1 the IPD and OPD parameters are sent.
-                                                                  If it is disabled, i.e. %0, the extension layer is skipped.   */
-
-  UCHAR modeIid;                                             /*!< The configuration of IID parameters (number of bands and
-                                                                  quantisation grid, iid_quant) is determined by iid_mode.      */
-  UCHAR modeIcc;                                             /*!< The configuration of Inter-channel Coherence parameters
-                                                                  (number of bands and quantisation grid) is determined by
-                                                                  icc_mode.                                                     */
-
-  UCHAR freqResIid;                                          /*!< 0=low, 1=mid or 2=high frequency resolution for iid           */
-  UCHAR freqResIcc;                                          /*!< 0=low, 1=mid or 2=high frequency resolution for icc           */
-
-  UCHAR bFineIidQ;                                           /*!< Use fine Iid quantisation.                                    */
-
-  UCHAR bFrameClass;                                         /*!< The frame_class bit determines whether the parameter
-                                                                  positions of the current frame are uniformly spaced
-                                                                  accross the frame or they are defined using the positions
-                                                                  described by border_position.                                 */
-
-  UCHAR noEnv;                                               /*!< The number of envelopes per frame                             */
-  UCHAR aEnvStartStop[MAX_NO_PS_ENV+1];                      /*!< In case of variable parameter spacing the parameter
-                                                                  positions are determined by border_position                   */
-
-  SCHAR abIidDtFlag[MAX_NO_PS_ENV];                                /*!< Deltacoding time/freq flag for IID, 0 => freq           */
-  SCHAR abIccDtFlag[MAX_NO_PS_ENV];                                /*!< Deltacoding time/freq flag for ICC, 0 => freq           */
-
-  SCHAR aaIidIndex[MAX_NO_PS_ENV][NO_HI_RES_IID_BINS];             /*!< The IID index for all envelopes and all IID bins        */
-  SCHAR aaIccIndex[MAX_NO_PS_ENV][NO_HI_RES_ICC_BINS];             /*!< The ICC index for all envelopes and all ICC bins        */
-
-} MPEG_PS_BS_DATA;
-
-
-
-struct PS_DEC {
-
-  SCHAR noSubSamples;
-  SCHAR noChannels;
-
-  SCHAR procFrameBased;                                      /*!< Helper to detected switching from frame based to slot based
-                                                                  processing                                                    */
-
-  PS_PAYLOAD_TYPE bPsDataAvail[(1)+1];   /*!< set if new data available from bitstream                      */
-  UCHAR psDecodedPrv;                                        /*!< set if PS has been processed in the last frame                */
-
-  /* helpers for frame delay line */
-  UCHAR bsLastSlot;                                          /*!< Index of last read slot.                                      */
-  UCHAR bsReadSlot;                                          /*!< Index of current read slot for additional delay.              */
-  UCHAR processSlot;                                         /*!< Index of current slot for processing (need for add. delay).   */
-
-
-  INT  rescal;
-  INT  sf_IntBuffer;
-
-  union {  /* Bitstream data */
-    MPEG_PS_BS_DATA  mpeg;                                   /*!< Struct containing all MPEG specific PS data from bitstream.   */
-  } bsData[(1)+1];
-
-  shouldBeUnion {  /* Static data */
-    struct {
-      SCHAR aIidPrevFrameIndex[NO_HI_RES_IID_BINS];          /*!< The IID index for previous frame                              */
-      SCHAR aIccPrevFrameIndex[NO_HI_RES_ICC_BINS];          /*!< The ICC index for previous frame                              */
-
-      UCHAR delayBufIndex;                                         /*!< Pointer to where the latest sample is in buffer         */
-      UCHAR noSampleDelay;                                         /*!< How many QMF samples delay is used.                     */
-      UCHAR lastUsb;                                               /*!< uppermost WMF delay band of last frame                  */
-
-      UCHAR aDelayRBufIndexSer[NO_SERIAL_ALLPASS_LINKS];             /*!< Delay buffer for reverb filter                        */
-      UCHAR aDelayBufIndexDelayQmf[NO_QMF_CHANNELS-FIRST_DELAY_SB];  /*!< Delay buffer for ICC group 20 & 21                    */
-
-      SCHAR scaleFactorPsDelayBuffer;                                /*!< Scale factor for ps delay buffer                      */
-
-      /* hybrid filter bank delay lines */
-      FIXP_DBL aaQmfDelayBufReal[(NO_QMF_CHANNELS-FIRST_DELAY_SB) + (MAX_DELAY_BUFFER_SIZE-1)*(NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB)];
-      FIXP_DBL aaQmfDelayBufImag[(NO_QMF_CHANNELS-FIRST_DELAY_SB) + (MAX_DELAY_BUFFER_SIZE-1)*(NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB)];
-
-      FIXP_DBL *pAaRealDelayBufferQmf[MAX_DELAY_BUFFER_SIZE];          /*!< Real part delay buffer                                  */
-      FIXP_DBL *pAaImagDelayBufferQmf[MAX_DELAY_BUFFER_SIZE];          /*!< Imaginary part delay buffer                             */
-
-      FIXP_DBL aaRealDelayBufferQmf[NO_SAMPLE_DELAY_ALLPASS][FIRST_DELAY_SB]; /*!< Real part delay buffer     */
-      FIXP_DBL aaImagDelayBufferQmf[NO_SAMPLE_DELAY_ALLPASS][FIRST_DELAY_SB]; /*!< Imaginary part delay buffer*/
-
-      FIXP_DBL aaRealDelayBufferSubQmf[NO_SAMPLE_DELAY_ALLPASS][NO_SUB_QMF_CHANNELS];          /*!< Real part delay buffer          */
-      FIXP_DBL aaImagDelayBufferSubQmf[NO_SAMPLE_DELAY_ALLPASS][NO_SUB_QMF_CHANNELS];          /*!< Imaginary part delay buffer     */
-
-      FIXP_DBL aaaRealDelayRBufferSerQmf[FIRST_DELAY_SB][NO_DELAY_LENGTH_VECTORS];             /*!< Real part delay buffer          */
-      FIXP_DBL aaaImagDelayRBufferSerQmf[FIRST_DELAY_SB][NO_DELAY_LENGTH_VECTORS];             /*!< Imaginary part delay buffer     */
-
-      FIXP_DBL aaaRealDelayRBufferSerSubQmf[NO_SUB_QMF_CHANNELS][NO_DELAY_LENGTH_VECTORS];     /*!< Real part delay buffer          */
-      FIXP_DBL aaaImagDelayRBufferSerSubQmf[NO_SUB_QMF_CHANNELS][NO_DELAY_LENGTH_VECTORS];     /*!< Imaginary part delay buffer     */
-
-      HYBRID hybrid;                                      /*!< hybrid filter bank struct 1 or 2.                          */
-
-      FIXP_DBL aPrevNrgBin[NO_MID_RES_BINS];              /*!< energy of previous frame                                             */
-      FIXP_DBL aPrevPeakDiffBin[NO_MID_RES_BINS];         /*!< peak difference of previous frame                                    */
-      FIXP_DBL aPeakDecayFastBin[NO_MID_RES_BINS];        /*!< Saved max. peak decay value per bin                                  */
-      SCHAR aPowerPrevScal[NO_MID_RES_BINS];              /*!< Last power value (each bin) of previous frame                        */
-
-      FIXP_DBL h11rPrev[NO_IID_GROUPS];                   /*!< previous calculated h(xy) coefficients                               */
-      FIXP_DBL h12rPrev[NO_IID_GROUPS];                   /*!< previous calculated h(xy) coefficients                               */
-      FIXP_DBL h21rPrev[NO_IID_GROUPS];                   /*!< previous calculated h(xy) coefficients                               */
-      FIXP_DBL h22rPrev[NO_IID_GROUPS];                   /*!< previous calculated h(xy) coefficients                               */
-
-      PS_DEC_COEFFICIENTS  coef;                         /*!< temporal coefficients (reusable scratch memory)                 */
-
-    } mpeg;
-
-  } specificTo;
-
-
-};
-
-typedef struct PS_DEC *HANDLE_PS_DEC;
-
-
-int CreatePsDec(HANDLE_PS_DEC *h_PS_DEC, int aacSamplesPerFrame);
-
-int DeletePsDec(HANDLE_PS_DEC *h_PS_DEC);
-
-void
-scalFilterBankValues( HANDLE_PS_DEC   h_ps_d,                        /* parametric stereo decoder handle     */
-                      FIXP_DBL      **fixpQmfReal,                   /* qmf filterbank values                */
-                      FIXP_DBL      **fixpQmfImag,                   /* qmf filterbank values                */
-                      int             lsb,                           /* sbr start subband                    */
-                      int             scaleFactorLowBandSplitLow,
-                      int             scaleFactorLowBandSplitHigh,
-                      SCHAR          *scaleFactorLowBand_lb,
-                      SCHAR          *scaleFactorLowBand_hb,
-                      int             scaleFactorHighBands,
-                      INT            *scaleFactorHighBand,
-                      INT             noCols);
-
-void
-rescalFilterBankValues( HANDLE_PS_DEC   h_ps_d,                      /* parametric stereo decoder handle     */
-                        FIXP_DBL      **QmfBufferReal,               /* qmf filterbank values                */
-                        FIXP_DBL      **QmfBufferImag,               /* qmf filterbank values                */
-                        int             lsb,                         /* sbr start subband                    */
-                        INT             noCols);
-
-
-void
-initSlotBasedRotation( HANDLE_PS_DEC h_ps_d,
-                       int env,
-                       int usb);
-
-void
-ApplyPsSlot( HANDLE_PS_DEC h_ps_d,            /* parametric stereo decoder handle    */
-             FIXP_DBL **rIntBufferLeft,       /* real values of left qmf timeslot    */
-             FIXP_DBL **iIntBufferLeft,       /* imag values of left qmf timeslot    */
-             FIXP_DBL *rIntBufferRight,       /* real values of right qmf timeslot   */
-             FIXP_DBL *iIntBufferRight);      /* imag values of right qmf timeslot   */
-
-
-
-#endif  /* __PSDEC_H */
diff --git a/libSBRdec/src/psdec_hybrid.cpp b/libSBRdec/src/psdec_hybrid.cpp
deleted file mode 100644
index cbd0e92..0000000
--- a/libSBRdec/src/psdec_hybrid.cpp
+++ /dev/null
@@ -1,652 +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
------------------------------------------------------------------------------------------------------------ */
-
-#include "psdec_hybrid.h"
-
-
-#include "fft.h"
-#include "sbr_ram.h"
-
-#include "FDK_tools_rom.h"
-#include "sbr_rom.h"
-
-/*******************************************************************************
- Functionname:  InitHybridFilterBank
- *******************************************************************************
-
- Description:   Init one instance of HANDLE_HYBRID stuct
-
- Arguments:
-
- Return:        none
-
-*******************************************************************************/
-
-
-SBR_ERROR
-InitHybridFilterBank ( HANDLE_HYBRID hs,          /*!< Handle to HYBRID struct. */
-                       SCHAR frameSize,           /*!< Framesize (in Qmf súbband samples). */
-                       SCHAR noBands,             /*!< Number of Qmf bands for hybrid filtering. */
-                       const UCHAR *pResolution ) /*!< Resolution in Qmf bands (length noBands). */
-{
-  SCHAR i;
-  UCHAR maxNoChannels = 0;
-
-  for (i = 0; i < noBands; i++) {
-    hs->pResolution[i] = pResolution[i];
-    if(pResolution[i] > maxNoChannels)
-      maxNoChannels = pResolution[i];
-  }
-
-  hs->nQmfBands     = noBands;
-  hs->frameSize     = frameSize;
-  hs->qmfBufferMove = HYBRID_FILTER_LENGTH - 1;
-
-  hs->sf_mQmfBuffer = 0;
-
-  return SBRDEC_OK;
-}
-
-/*******************************************************************************
- Functionname:  dualChannelFiltering
- *******************************************************************************
-
- Description:   fast 2-channel real-valued filtering with 6-tap delay.
-
- Arguments:
-
- Return:        none
-
-*******************************************************************************/
-
-/*!
-2 channel filter
-<pre>
-   Filter Coefs:
-   0.0,
-   0.01899487526049,
-   0.0,
-   -0.07293139167538,
-   0.0,
-   0.30596630545168,
-   0.5,
-   0.30596630545168,
-   0.0,
-   -0.07293139167538,
-   0.0,
-   0.01899487526049,
-   0.0
-
-
-   Filter design:
-   h[q,n] = g[n] * cos(2pi/2 * q * (n-6) );  n = 0..12,  q = 0,1;
-
-   ->  h[0,n] = g[n] * 1;
-   ->  h[1,n] = g[n] * pow(-1,n);
-</pre>
-*/
-
-static void slotBasedDualChannelFiltering( const FIXP_DBL *pQmfReal,
-                                           const FIXP_DBL *pQmfImag,
-
-                                           FIXP_DBL       *mHybridReal,
-                                           FIXP_DBL       *mHybridImag)
-{
-
-  FIXP_DBL  t1, t3, t5, t6;
-
-  /* symmetric filter coefficients */
-
-  /*  you don't have to shift the result after fMult because of p2_13_20 <= 0.5 */
-  t1 = fMultDiv2(p2_13_20[1] , ( (pQmfReal[1] >> 1) + (pQmfReal[11] >> 1)));
-  t3 = fMultDiv2(p2_13_20[3] , ( (pQmfReal[3] >> 1) + (pQmfReal[ 9] >> 1)));
-  t5 = fMultDiv2(p2_13_20[5] , ( (pQmfReal[5] >> 1) + (pQmfReal[ 7] >> 1)));
-  t6 = fMultDiv2(p2_13_20[6] ,   (pQmfReal[6] >> 1) );
-
-  mHybridReal[0] = (t1 + t3 + t5 + t6) << 2;
-  mHybridReal[1] = (- t1 - t3 - t5 + t6) << 2;
-
-  t1 = fMultDiv2(p2_13_20[1] , ( (pQmfImag[1] >> 1) + (pQmfImag[11] >> 1)));
-  t3 = fMultDiv2(p2_13_20[3] , ( (pQmfImag[3] >> 1) + (pQmfImag[ 9] >> 1)));
-  t5 = fMultDiv2(p2_13_20[5] , ( (pQmfImag[5] >> 1) + (pQmfImag[ 7] >> 1)));
-  t6 = fMultDiv2(p2_13_20[6] ,    pQmfImag[6] >> 1 );
-
-  mHybridImag[0] = (t1 + t3 + t5 + t6) << 2;
-  mHybridImag[1] = (- t1 - t3 - t5 + t6) << 2;
-}
-
-
-/*******************************************************************************
- Functionname:  eightChannelFiltering
- *******************************************************************************
-
- Description:   fast 8-channel complex-valued filtering with 6-tap delay.
-
- Arguments:
-
- Return:        none
-
-*******************************************************************************/
-/*!
-   8 channel filter
-
-   Implementation using a FFT of length 8
-<pre>
-   prototype filter coefficients:
-   0.00746082949812   0.02270420949825   0.04546865930473   0.07266113929591   0.09885108575264   0.11793710567217
-   0.125
-   0.11793710567217   0.09885108575264   0.07266113929591   0.04546865930473   0.02270420949825   0.00746082949812
-
-   Filter design:
-   N = 13; Q = 8;
-   h[q,n]       = g[n] * exp(j * 2 * pi / Q * (q + .5) * (n - 6));  n = 0..(N-1),  q = 0..(Q-1);
-
-   Time Signal:   x[t];
-   Filter Bank Output
-   y[q,t] = conv(x[t],h[q,t]) = conv(h[q,t],x[t]) = sum(x[k] * h[q, t - k] ) = sum(h[q, k] * x[t - k] ); k = 0..(N-1);
-
-   y[q,t] =   x[t - 12]*h[q, 12]  +  x[t - 11]*h[q, 11]  +  x[t - 10]*h[q, 10]  +  x[t -  9]*h[q,  9]
-           +  x[t -  8]*h[q,  8]  +  x[t -  7]*h[q,  7]
-           +  x[t -  6]*h[q,  6]
-           +  x[t -  5]*h[q,  5]  +  x[t -  4]*h[q,  4]
-           +  x[t -  3]*h[q,  3]  +  x[t -  2]*h[q,  2]  +  x[t -  1]*h[q,  1]  +  x[t -  0]*h[q,  0];
-
-   h'[q, n] = h[q,(N-1)-n] = g[n] * exp(j * 2 * pi / Q * (q + .5) * (6 - n));  n = 0..(N-1),  q = 0..(Q-1);
-
-   y[q,t] =   x[t - 12]*h'[q,  0]  +  x[t - 11]*h'[q,  1]  +  x[t - 10]*h'[q,  2]  +  x[t -  9]*h'[q,  3]
-           +  x[t -  8]*h'[q,  4]  +  x[t -  7]*h'[q,  5]
-           +  x[t -  6]*h'[q,  6]
-           +  x[t -  5]*h'[q,  7]  +  x[t -  4]*h'[q,  8]
-           +  x[t -  3]*h'[q,  9]  +  x[t -  2]*h'[q, 10]  +  x[t -  1]*h'[q, 11]  +  x[t -  0]*h'[q, 12];
-
-   Try to split off FFT Modulation Term:
-   FFT(x[t], q) = sum(x[t+k]*exp(-j*2*pi/N *q * k))
-                                           c                                           m
-   Step 1:  h'[q,n] = g[n] * ( exp(j * 2 * pi / 8 * .5 * (6 - n)) ) * ( exp (j * 2 * pi / 8 * q * (6 - n)) );
-
-    h'[q,n] = g[n] *c[n] * m[q,n]; (see above)
-    c[n]    = exp( j * 2 * pi / 8 * .5 * (6 - n) );
-    m[q,n]  = exp( j * 2 * pi / 8 *  q * (6 - n) );
-
-    y[q,t] = x[t -  0]*g[0]*c[0]*m[q,0]  +  x[t -  1]*g[1]*c[ 1]*m[q, 1]  + ...
-             ...                         +  x[t - 12]*g[2]*c[12]*m[q,12];
-
-                                                                              |
-    n                   m                            *exp(-j*2*pi)            |   n'                   fft
--------------------------------------------------------------------------------------------------------------------------
-    0       exp( j * 2 * pi / 8 * q * 6) ->  exp(-j * 2 * pi / 8 * q * 2)     |   2         exp(-j * 2 * pi / 8 * q * 0)
-    1       exp( j * 2 * pi / 8 * q * 5) ->  exp(-j * 2 * pi / 8 * q * 3)     |   3         exp(-j * 2 * pi / 8 * q * 1)
-    2       exp( j * 2 * pi / 8 * q * 4) ->  exp(-j * 2 * pi / 8 * q * 4)     |   4         exp(-j * 2 * pi / 8 * q * 2)
-    3       exp( j * 2 * pi / 8 * q * 3) ->  exp(-j * 2 * pi / 8 * q * 5)     |   5         exp(-j * 2 * pi / 8 * q * 3)
-    4       exp( j * 2 * pi / 8 * q * 2) ->  exp(-j * 2 * pi / 8 * q * 6)     |   6         exp(-j * 2 * pi / 8 * q * 4)
-    5       exp( j * 2 * pi / 8 * q * 1) ->  exp(-j * 2 * pi / 8 * q * 7)     |   7         exp(-j * 2 * pi / 8 * q * 5)
-    6       exp( j * 2 * pi / 8 * q * 0)                                      |   0         exp(-j * 2 * pi / 8 * q * 6)
-    7       exp(-j * 2 * pi / 8 * q * 1)                                      |   1         exp(-j * 2 * pi / 8 * q * 7)
-    8       exp(-j * 2 * pi / 8 * q * 2)                                      |   2
-    9       exp(-j * 2 * pi / 8 * q * 3)                                      |   3
-    10      exp(-j * 2 * pi / 8 * q * 4)                                      |   4
-    11      exp(-j * 2 * pi / 8 * q * 5)                                      |   5
-    12      exp(-j * 2 * pi / 8 * q * 6)                                      |   6
-
-
-    now use fft modulation coefficients
-    m[6]  =       = fft[0]
-    m[7]  =       = fft[1]
-    m[8]  = m[ 0] = fft[2]
-    m[9]  = m[ 1] = fft[3]
-    m[10] = m[ 2] = fft[4]
-    m[11] = m[ 3] = fft[5]
-    m[12] = m[ 4] = fft[6]
-            m[ 5] = fft[7]
-
-    y[q,t] = (                       x[t- 6]*g[ 6]*c[ 6] ) * fft[q,0]  +
-             (                       x[t- 7]*g[ 7]*c[ 7] ) * fft[q,1]  +
-             ( x[t- 0]*g[ 0]*c[ 0] + x[t- 8]*g[ 8]*c[ 8] ) * fft[q,2]  +
-             ( x[t- 1]*g[ 1]*c[ 1] + x[t- 9]*g[ 9]*c[ 9] ) * fft[q,3]  +
-             ( x[t- 2]*g[ 2]*c[ 2] + x[t-10]*g[10]*c[10] ) * fft[q,4]  +
-             ( x[t- 3]*g[ 3]*c[ 3] + x[t-11]*g[11]*c[11] ) * fft[q,5]  +
-             ( x[t- 4]*g[ 4]*c[ 4] + x[t-12]*g[12]*c[12] ) * fft[q,6]  +
-             ( x[t- 5]*g[ 5]*c[ 5]                       ) * fft[q,7];
-
-    pre twiddle factors c[n] = exp(j * 2 * pi / 8 * .5 * (6 - n));
-    n                c]           |  n                c[n]         |  n                c[n]
----------------------------------------------------------------------------------------------------
-    0       exp( j * 6 * pi / 8)  |  1       exp( j * 5 * pi / 8)  |  2       exp( j * 4 * pi / 8)
-    3       exp( j * 3 * pi / 8)  |  4       exp( j * 2 * pi / 8)  |  5       exp( j * 1 * pi / 8)
-    6       exp( j * 0 * pi / 8)  |  7       exp(-j * 1 * pi / 8)  |  8       exp(-j * 2 * pi / 8)
-    9       exp(-j * 3 * pi / 8)  | 10       exp(-j * 4 * pi / 8)  | 11       exp(-j * 5 * pi / 8)
-   12       exp(-j * 6 * pi / 8)  |                                |
-</pre>
-*/
-
-/* defining rotation factors for *ChannelFiltering */
-
-#define cos0Pi    FL2FXCONST_DBL( 1.f)
-#define sin0Pi    FL2FXCONST_DBL( 0.f)
-
-#define cos1Pi    FL2FXCONST_DBL(-1.f)
-#define sin1Pi    FL2FXCONST_DBL( 0.f)
-
-#define cos1Pi_2  FL2FXCONST_DBL( 0.f)
-#define sin1Pi_2  FL2FXCONST_DBL( 1.f)
-
-#define cos1Pi_3  FL2FXCONST_DBL( 0.5f)
-#define sin1Pi_3  FL2FXCONST_DBL( 0.86602540378444f)
-
-#define cos0Pi_4  cos0Pi
-#define cos1Pi_4  FL2FXCONST_DBL(0.70710678118655f)
-#define cos2Pi_4  cos1Pi_2
-#define cos3Pi_4  (-cos1Pi_4)
-#define cos4Pi_4  (-cos0Pi_4)
-#define cos5Pi_4  cos3Pi_4
-#define cos6Pi_4  cos2Pi_4
-
-#define sin0Pi_4  sin0Pi
-#define sin1Pi_4  FL2FXCONST_DBL(0.70710678118655f)
-#define sin2Pi_4  sin1Pi_2
-#define sin3Pi_4  sin1Pi_4
-#define sin4Pi_4  sin0Pi_4
-#define sin5Pi_4  (-sin3Pi_4)
-#define sin6Pi_4  (-sin2Pi_4)
-
-#define cos0Pi_8  cos0Pi
-#define cos1Pi_8  FL2FXCONST_DBL(0.92387953251129f)
-#define cos2Pi_8  cos1Pi_4
-#define cos3Pi_8  FL2FXCONST_DBL(0.38268343236509f)
-#define cos4Pi_8  cos2Pi_4
-#define cos5Pi_8  (-cos3Pi_8)
-#define cos6Pi_8  (-cos2Pi_8)
-
-#define sin0Pi_8  sin0Pi
-#define sin1Pi_8  cos3Pi_8
-#define sin2Pi_8  sin1Pi_4
-#define sin3Pi_8  cos1Pi_8
-#define sin4Pi_8  sin2Pi_4
-#define sin5Pi_8  sin3Pi_8
-#define sin6Pi_8  sin1Pi_4
-
-#if defined(ARCH_PREFER_MULT_32x16)
-  #define FIXP_HYB FIXP_SGL
-  #define FIXP_CAST FX_DBL2FX_SGL
-#else
-  #define FIXP_HYB FIXP_DBL
-  #define FIXP_CAST
-#endif
-
-static const FIXP_HYB  cr[13] =
-{
-   FIXP_CAST(cos6Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos4Pi_8),
-   FIXP_CAST(cos3Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos1Pi_8),
-   FIXP_CAST(cos0Pi_8),
-   FIXP_CAST(cos1Pi_8), FIXP_CAST(cos2Pi_8), FIXP_CAST(cos3Pi_8),
-   FIXP_CAST(cos4Pi_8), FIXP_CAST(cos5Pi_8), FIXP_CAST(cos6Pi_8)
-};
-
-static const FIXP_HYB  ci[13] =
-{
-   FIXP_CAST( sin6Pi_8), FIXP_CAST( sin5Pi_8), FIXP_CAST( sin4Pi_8),
-   FIXP_CAST( sin3Pi_8), FIXP_CAST( sin2Pi_8), FIXP_CAST( sin1Pi_8),
-   FIXP_CAST( sin0Pi_8) ,
-   FIXP_CAST(-sin1Pi_8), FIXP_CAST(-sin2Pi_8), FIXP_CAST(-sin3Pi_8),
-   FIXP_CAST(-sin4Pi_8), FIXP_CAST(-sin5Pi_8), FIXP_CAST(-sin6Pi_8)
-};
-
-static void slotBasedEightChannelFiltering( const FIXP_DBL *pQmfReal,
-                                            const FIXP_DBL *pQmfImag,
-
-                                            FIXP_DBL  *mHybridReal,
-                                            FIXP_DBL  *mHybridImag)
-{
-
-  int bin;
-  FIXP_DBL _fft[128 + ALIGNMENT_DEFAULT - 1];
-  FIXP_DBL *fft = (FIXP_DBL *)ALIGN_PTR(_fft);
-
-#if defined(ARCH_PREFER_MULT_32x16)
-  const FIXP_SGL *p = p8_13_20; /* BASELINE_PS */
-#else
-  const FIXP_DBL *p = p8_13_20; /* BASELINE_PS */
-#endif
-
-  /* pre twiddeling */
-
-  /*   x*(a*b + c*d) = fMultDiv2(x, fMultAddDiv2(fMultDiv2(a, b), c, d)) */
-  /*   x*(a*b - c*d) = fMultDiv2(x, fMultSubDiv2(fMultDiv2(a, b), c, d)) */
-  FIXP_DBL accu1, accu2, accu3, accu4;
-
-  #define TWIDDLE_1(n_0,n_1,n_2)                                                        \
-         cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]);  \
-         accu1 = fMultDiv2(p[n_0], accu1);                                              \
-         accu2 = fMultDiv2(p[n_0], accu2);                                              \
-         cplxMultDiv2(&accu3, &accu4, pQmfReal[n_1], pQmfImag[n_1], cr[n_1], ci[n_1]);  \
-         accu3 = fMultDiv2(p[n_1], accu3);                                              \
-         accu4 = fMultDiv2(p[n_1], accu4);                                              \
-         fft[FIXP_FFT_IDX_R(n_2)] = accu1 + accu3;                                      \
-         fft[FIXP_FFT_IDX_I(n_2)] = accu2 + accu4;
-
-  #define TWIDDLE_0(n_0,n_1)                                                            \
-         cplxMultDiv2(&accu1, &accu2, pQmfReal[n_0], pQmfImag[n_0], cr[n_0], ci[n_0]);  \
-         fft[FIXP_FFT_IDX_R(n_1)] = fMultDiv2(p[n_0], accu1);                           \
-         fft[FIXP_FFT_IDX_I(n_1)] = fMultDiv2(p[n_0], accu2);
-
-  TWIDDLE_0( 6, 0)
-  TWIDDLE_0( 7, 1)
-
-  TWIDDLE_1( 0, 8, 2)
-  TWIDDLE_1( 1, 9, 3)
-  TWIDDLE_1( 2,10, 4)
-  TWIDDLE_1( 3,11, 5)
-  TWIDDLE_1( 4,12, 6)
-
-  TWIDDLE_0( 5, 7)
-
-  fft_8 (fft);
-
-  /* resort fft data into output array*/
-  for(bin=0; bin<8;bin++ ) {
-    mHybridReal[bin] = fft[FIXP_FFT_IDX_R(bin)] << 4;
-    mHybridImag[bin] = fft[FIXP_FFT_IDX_I(bin)] << 4;
-  }
-}
-
-
-/*******************************************************************************
- Functionname:  fillHybridDelayLine
- *******************************************************************************
-
- Description:   The delay line of the hybrid filter is filled and copied from
-                left to right.
-
- Return:        none
-
-*******************************************************************************/
-
-void
-fillHybridDelayLine( FIXP_DBL **fixpQmfReal,          /*!< Qmf real Values    */
-                     FIXP_DBL **fixpQmfImag,          /*!< Qmf imag Values    */
-                     FIXP_DBL   fixpHybridLeftR[12],  /*!< Hybrid real Values left channel  */
-                     FIXP_DBL   fixpHybridLeftI[12],  /*!< Hybrid imag Values left channel  */
-                     FIXP_DBL   fixpHybridRightR[12], /*!< Hybrid real Values right channel */
-                     FIXP_DBL   fixpHybridRightI[12], /*!< Hybrid imag Values right channel */
-                     HANDLE_HYBRID hHybrid )
-{
-  int i;
-
-  for (i = 0; i < HYBRID_FILTER_DELAY; i++) {
-    slotBasedHybridAnalysis ( fixpQmfReal[i],
-                              fixpQmfReal[i],
-                              fixpHybridLeftR,
-                              fixpHybridLeftI,
-                              hHybrid );
-  }
-
-  FDKmemcpy(fixpHybridRightR, fixpHybridLeftR, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS);
-  FDKmemcpy(fixpHybridRightI, fixpHybridLeftI, sizeof(FIXP_DBL)*NO_SUB_QMF_CHANNELS);
-}
-
-
-/*******************************************************************************
- Functionname:  slotBasedHybridAnalysis
- *******************************************************************************
-
- Description:   The lower QMF subbands are further split to provide better
-                frequency resolution for PS processing.
-
-  Return:        none
-
-*******************************************************************************/
-
-
-void
-slotBasedHybridAnalysis ( FIXP_DBL *fixpQmfReal,      /*!< Qmf real Values */
-                          FIXP_DBL *fixpQmfImag,      /*!< Qmf imag Values */
-
-                          FIXP_DBL  fixpHybridReal[12],   /*!< Hybrid real Values */
-                          FIXP_DBL  fixpHybridImag[12],   /*!< Hybrid imag Values */
-
-                          HANDLE_HYBRID hHybrid)
-{
-  int  k, band;
-  HYBRID_RES hybridRes;
-  int  chOffset = 0;
-
-  C_ALLOC_SCRATCH_START(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH);
-
-  FIXP_DBL *pTempImagSlot = pTempRealSlot + HYBRID_FILTER_LENGTH;
-  FIXP_DBL *pWorkRealSlot = pTempImagSlot + HYBRID_FILTER_LENGTH;
-  FIXP_DBL *pWorkImagSlot = pWorkRealSlot + HYBRID_FILTER_LENGTH;
-
-  /*!
-  Hybrid filtering is applied to the first hHybrid->nQmfBands QMF bands (3 when 10 or 20 stereo bands
-  are used, 5 when 34 stereo bands are used). For the remaining QMF bands a delay would be necessary.
-  But there is no need to implement a delay because there is a look-ahead of HYBRID_FILTER_DELAY = 6
-  QMF samples in the low-band buffer.
-  */
-
-  for(band = 0; band < hHybrid->nQmfBands; band++) {
-
-    /*  get hybrid resolution per qmf band                */
-    /*  in case of baseline ps 10/20 band stereo mode :   */
-    /*                                                    */
-    /*             qmfBand[0] : 8 ( HYBRID_8_CPLX )       */
-    /*             qmfBand[1] : 2 ( HYBRID_2_REAL )       */
-    /*             qmfBand[2] : 2 ( HYBRID_2_REAL )       */
-    /*                                                    */
-    /*  (split the 3 lower qmf band to 12 hybrid bands)   */
-
-    hybridRes = (HYBRID_RES)hHybrid->pResolution[band];
-
-    FDKmemcpy(pWorkRealSlot, hHybrid->mQmfBufferRealSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
-    FDKmemcpy(pWorkImagSlot, hHybrid->mQmfBufferImagSlot[band], hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
-
-    pWorkRealSlot[hHybrid->qmfBufferMove] = fixpQmfReal[band];
-    pWorkImagSlot[hHybrid->qmfBufferMove] = fixpQmfImag[band];
-
-    FDKmemcpy(hHybrid->mQmfBufferRealSlot[band], pWorkRealSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
-    FDKmemcpy(hHybrid->mQmfBufferImagSlot[band], pWorkImagSlot + 1, hHybrid->qmfBufferMove * sizeof(FIXP_DBL));
-
-    if (fixpQmfReal) {
-
-      /* actual filtering only if output signal requested */
-      switch( hybridRes ) {
-
-      /* HYBRID_2_REAL & HYBRID_8_CPLX are only needful for baseline ps */
-      case HYBRID_2_REAL:
-
-        slotBasedDualChannelFiltering( pWorkRealSlot,
-                                       pWorkImagSlot,
-                                       pTempRealSlot,
-                                       pTempImagSlot);
-        break;
-
-      case HYBRID_8_CPLX:
-
-        slotBasedEightChannelFiltering( pWorkRealSlot,
-                                        pWorkImagSlot,
-                                        pTempRealSlot,
-                                        pTempImagSlot);
-        break;
-
-      default:
-        FDK_ASSERT(0);
-      }
-
-      for(k = 0; k < (SCHAR)hybridRes; k++) {
-        fixpHybridReal [chOffset + k] = pTempRealSlot[k];
-        fixpHybridImag [chOffset + k] = pTempImagSlot[k];
-      }
-      chOffset += hybridRes;
-    } /* if (mHybridReal) */
-  }
-
-  /* group hybrid channels 3+4 -> 3 and 2+5 -> 2 */
-  fixpHybridReal[3] += fixpHybridReal[4];
-  fixpHybridImag[3] += fixpHybridImag[4];
-  fixpHybridReal[4] = (FIXP_DBL)0;
-  fixpHybridImag[4] = (FIXP_DBL)0;
-
-  fixpHybridReal[2] += fixpHybridReal[5];
-  fixpHybridImag[2] += fixpHybridImag[5];
-  fixpHybridReal[5] = (FIXP_DBL)0;
-  fixpHybridImag[5] = (FIXP_DBL)0;
-
-  /* free memory on scratch */
-  C_ALLOC_SCRATCH_END(pTempRealSlot, FIXP_DBL, 4*HYBRID_FILTER_LENGTH);
-
-}
-
-
-/*******************************************************************************
- Functionname:  slotBasedHybridSynthesis
- *******************************************************************************
-
- Description:  The coefficients offering higher resolution for the lower QMF
-               channel are simply added prior to the synthesis with the 54
-               subbands QMF.
-
- Arguments:
-
- Return:        none
-
-*******************************************************************************/
-
-/*! <pre>
-      l,r0(n) ---\
-      l,r1(n) ---- + --\
-      l,r2(n) ---/      \
-                         + --> F0(w)
-      l,r3(n) ---\      /
-      l,r4(n) ---- + --/
-      l,r5(n) ---/
-
-
-      l,r6(n) ---\
-                  + ---------> F1(w)
-      l,r7(n) ---/
-
-
-      l,r8(n) ---\
-                  + ---------> F2(w)
-      l,r9(n) ---/
-
-    </pre>
-      Hybrid QMF synthesis filterbank for the 10 and 20 stereo-bands configurations. The
-      coefficients offering higher resolution for the lower QMF channel are simply added
-      prior to the synthesis with the 54 subbands QMF.
-
-      [see ISO/IEC 14496-3:2001/FDAM 2:2004(E) - Page 52]
-*/
-
-
-void
-slotBasedHybridSynthesis ( FIXP_DBL  *fixpHybridReal,  /*!< Hybrid real Values */
-                           FIXP_DBL  *fixpHybridImag,  /*!< Hybrid imag Values */
-                           FIXP_DBL  *fixpQmfReal,     /*!< Qmf real Values */
-                           FIXP_DBL  *fixpQmfImag,     /*!< Qmf imag Values */
-                           HANDLE_HYBRID hHybrid )     /*!< Handle to HYBRID struct. */
-{
-  int  k, band;
-
-  HYBRID_RES hybridRes;
-  int  chOffset = 0;
-
-  for(band = 0; band < hHybrid->nQmfBands; band++) {
-
-    FIXP_DBL qmfReal = FL2FXCONST_DBL(0.f);
-    FIXP_DBL qmfImag = FL2FXCONST_DBL(0.f);
-    hybridRes = (HYBRID_RES)hHybrid->pResolution[band];
-
-    for(k = 0; k < (SCHAR)hybridRes; k++) {
-      qmfReal += fixpHybridReal[chOffset + k];
-      qmfImag += fixpHybridImag[chOffset + k];
-    }
-
-    fixpQmfReal[band] = qmfReal;
-    fixpQmfImag[band] = qmfImag;
-
-    chOffset += hybridRes;
-  }
-}
-
-
-
diff --git a/libSBRdec/src/psdec_hybrid.h b/libSBRdec/src/psdec_hybrid.h
deleted file mode 100644
index fcf9e3e..0000000
--- a/libSBRdec/src/psdec_hybrid.h
+++ /dev/null
@@ -1,165 +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
------------------------------------------------------------------------------------------------------------ */
-
-#ifndef __HYBRID_H
-#define __HYBRID_H
-
-#include "sbrdecoder.h"
-
-
-#define HYBRID_FILTER_LENGTH  13
-#define HYBRID_FILTER_DELAY    6
-
-
-#define FAST_FILTER2
-#define FAST_FILTER4
-#define FAST_FILTER8
-#define FAST_FILTER12
-
-#define FFT_IDX_R(a)  (2*a)
-#define FFT_IDX_I(a)  (2*a+1)
-
-#define FIXP_FFT_IDX_R(a)   (a<<1)
-#define FIXP_FFT_IDX_I(a)  ((a<<1) + 1)
-
-
-typedef enum {
-
-  HYBRID_2_REAL     = 2,
-  HYBRID_4_CPLX     = 4,
-  HYBRID_8_CPLX     = 8,
-  HYBRID_12_CPLX    = 12
-
-} HYBRID_RES;
-
-typedef struct
-{
-  SCHAR   nQmfBands;
-  SCHAR   frameSize;
-  SCHAR   qmfBufferMove;
-
-  UCHAR   pResolution[3];
-
-  FIXP_DBL mQmfBufferRealSlot[3][HYBRID_FILTER_LENGTH];   /**< Stores old Qmf samples. */
-  FIXP_DBL mQmfBufferImagSlot[3][HYBRID_FILTER_LENGTH];
-  SCHAR sf_mQmfBuffer;
-
-} HYBRID;
-
-typedef HYBRID *HANDLE_HYBRID;
-
-void
-fillHybridDelayLine( FIXP_DBL **fixpQmfReal,
-                     FIXP_DBL **fixpQmfImag,
-                     FIXP_DBL   fixpHybridLeftR[12],
-                     FIXP_DBL   fixpHybridLeftI[12],
-                     FIXP_DBL   fixpHybridRightR[12],
-                     FIXP_DBL   fixpHybridRightI[12],
-                     HANDLE_HYBRID hHybrid );
-
-void
-slotBasedHybridAnalysis ( FIXP_DBL *fixpQmfReal,
-                          FIXP_DBL *fixpQmfImag,
-
-                          FIXP_DBL  *fixpHybridReal,
-                          FIXP_DBL  *fixpHybridImag,
-
-                          HANDLE_HYBRID hHybrid);
-
-
-void
-slotBasedHybridSynthesis ( FIXP_DBL  *fixpHybridReal,
-                           FIXP_DBL  *fixpHybridImag,
-
-                           FIXP_DBL  *fixpQmfReal,
-                           FIXP_DBL  *fixpQmfImag,
-
-                           HANDLE_HYBRID hHybrid );
-
-SBR_ERROR InitHybridFilterBank ( HANDLE_HYBRID  hHybrid,
-                                 SCHAR frameSize,
-                                 SCHAR noBands,
-                                 const UCHAR *pResolution );
-
-
-#endif /* __HYBRID_H */
diff --git a/libSBRdec/src/sbr_crc.cpp b/libSBRdec/src/sbr_crc.cpp
deleted file mode 100644
index a495f10..0000000
--- a/libSBRdec/src/sbr_crc.cpp
+++ /dev/null
@@ -1,183 +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  CRC check coutines  
-*/
-
-#include "sbr_crc.h"
-
-#include "FDK_bitstream.h"
-#include "transcendent.h"
-
-#define MAXCRCSTEP    16
-#define MAXCRCSTEP_LD  4
-
-/*!
-  \brief     crc calculation
-*/
-static ULONG
-calcCRC (HANDLE_CRC hCrcBuf, ULONG bValue, int nBits)
-{
-  int i;
-  ULONG bMask = (1UL << (nBits - 1));
-
-  for (i = 0; i < nBits; i++, bMask >>= 1) {
-    USHORT flag = (hCrcBuf->crcState & hCrcBuf->crcMask) ? 1 : 0;
-    USHORT flag1 = (bMask & bValue) ? 1 : 0;
-
-    flag ^= flag1;
-    hCrcBuf->crcState <<= 1;
-    if (flag)
-      hCrcBuf->crcState ^= hCrcBuf->crcPoly;
-  }
-
-  return (hCrcBuf->crcState);
-}
-
-
-/*!
-  \brief     crc
-*/
-static int
-getCrc (HANDLE_FDK_BITSTREAM hBs, ULONG NrBits)
-{
-  int i;
-  CRC_BUFFER CrcBuf;
-
-  CrcBuf.crcState = SBR_CRC_START;
-  CrcBuf.crcPoly  = SBR_CRC_POLY;
-  CrcBuf.crcMask  = SBR_CRC_MASK;
-
-  int CrcStep = NrBits>>MAXCRCSTEP_LD;
-
-  int CrcNrBitsRest = (NrBits - CrcStep * MAXCRCSTEP);
-  ULONG bValue;
-
-  for (i = 0; i < CrcStep; i++) {
-    bValue = FDKreadBits (hBs, MAXCRCSTEP);
-    calcCRC (&CrcBuf, bValue, MAXCRCSTEP);
-  }
-
-  bValue = FDKreadBits (hBs, CrcNrBitsRest);
-  calcCRC (&CrcBuf, bValue, CrcNrBitsRest);
-
-  return (CrcBuf.crcState & SBR_CRC_RANGE);
-
-}
-
-
-/*!
-  \brief   crc interface
-  \return  1: CRC OK, 0: CRC check failure
-*/
-int
-SbrCrcCheck (HANDLE_FDK_BITSTREAM hBs, /*!< handle to bit-buffer  */
-             LONG NrBits)              /*!< max. CRC length       */
-{
-  int crcResult = 1;
-  ULONG NrCrcBits;
-  ULONG crcCheckResult;
-  LONG NrBitsAvailable;
-  ULONG crcCheckSum;
-
-  crcCheckSum = FDKreadBits (hBs, 10);
-
-  NrBitsAvailable = FDKgetValidBits(hBs);
-  if (NrBitsAvailable <= 0){
-    return 0;
-  }
-
-  NrCrcBits = fixMin ((INT)NrBits, (INT)NrBitsAvailable);
-
-  crcCheckResult = getCrc (hBs, NrCrcBits);
-  FDKpushBack(hBs, (NrBitsAvailable - FDKgetValidBits(hBs)) );
-
-
-  if (crcCheckResult != crcCheckSum) {
-    crcResult = 0;
-  }
-
-  return (crcResult);
-}
diff --git a/libSBRdec/src/sbr_crc.h b/libSBRdec/src/sbr_crc.h
deleted file mode 100644
index 30b8329..0000000
--- a/libSBRdec/src/sbr_crc.h
+++ /dev/null
@@ -1,123 +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  CRC checking routines  
-*/
-#ifndef __SBR_CRC_H
-#define __SBR_CRC_H
-
-#include "sbrdecoder.h"
-
-#include "FDK_bitstream.h"
-
-/* some useful crc polynoms:
-
-crc5: x^5+x^4+x^2+x^1+1
-crc6: x^6+x^5+x^3+x^2+x+1
-crc7: x^7+x^6+x^2+1
-crc8: x^8+x^2+x+x+1
-*/
-
-/* default SBR CRC */  /* G(x) = x^10 + x^9 + x^5 + x^4 + x + 1 */
-#define SBR_CRC_POLY                  0x0233
-#define SBR_CRC_MASK                  0x0200
-#define SBR_CRC_START                 0x0000
-#define SBR_CRC_RANGE                 0x03FF
-
-typedef struct
-{
-  USHORT crcState;
-  USHORT crcMask;
-  USHORT crcPoly;
-}
-CRC_BUFFER;
-
-typedef CRC_BUFFER *HANDLE_CRC;
-
-int SbrCrcCheck (HANDLE_FDK_BITSTREAM hBitBuf,
-                 LONG                 NrCrcBits);
-
-
-#endif
diff --git a/libSBRdec/src/sbr_deb.cpp b/libSBRdec/src/sbr_deb.cpp
deleted file mode 100644
index 9baff2e..0000000
--- a/libSBRdec/src/sbr_deb.cpp
+++ /dev/null
@@ -1,90 +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  Print selected debug messages   
-*/
-
-#include "sbr_deb.h"
-
diff --git a/libSBRdec/src/sbr_deb.h b/libSBRdec/src/sbr_deb.h
deleted file mode 100644
index cb954ba..0000000
--- a/libSBRdec/src/sbr_deb.h
+++ /dev/null
@@ -1,94 +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  Debugging aids   
-*/
-
-#ifndef __SBR_DEB_H
-#define __SBR_DEB_H
-
-#include "sbrdecoder.h"
-
-#endif
diff --git a/libSBRdec/src/sbr_dec.cpp b/libSBRdec/src/sbr_dec.cpp
deleted file mode 100644
index 1282338..0000000
--- a/libSBRdec/src/sbr_dec.cpp
+++ /dev/null
@@ -1,1050 +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  Sbr decoder  
-  This module provides the actual decoder implementation. The SBR data (side information) is already
-  decoded. Only three functions are provided:
-
-  \li 1.) createSbrDec(): One time initialization
-  \li 2.) resetSbrDec(): Called by sbr_Apply() when the information contained in an SBR_HEADER_ELEMENT requires a reset
-  and recalculation of important SBR structures.
-  \li 3.) sbr_dec(): The actual decoder. Calls the different tools such as filterbanks, lppTransposer(), and calculateSbrEnvelope()
-  [the envelope adjuster].
-
-  \sa sbr_dec(), \ref documentationOverview
-*/
-
-#include "sbr_dec.h"
-
-#include "sbr_ram.h"
-#include "env_extr.h"
-#include "env_calc.h"
-#include "scale.h"
-
-#include "genericStds.h"
-
-#include "sbrdec_drc.h"
-
-
-
-static void assignLcTimeSlots( HANDLE_SBR_DEC hSbrDec,                     /*!< handle to Decoder channel */
-                               FIXP_DBL  **QmfBufferReal,
-                               int noCols )
-{
-  int slot, i;
-  FIXP_DBL  *ptr;
-
-  /* Number of QMF timeslots in the overlap buffer: */
-  ptr = hSbrDec->pSbrOverlapBuffer;
-  for(slot=0; slot<hSbrDec->LppTrans.pSettings->overlap; slot++) {
-    QmfBufferReal[slot] = ptr; ptr += (64);
-  }
-
-  /* Assign timeslots to Workbuffer1 */
-  ptr = hSbrDec->WorkBuffer1;
-  for(i=0; i<noCols; i++) {
-    QmfBufferReal[slot] = ptr; ptr += (64);
-    slot++;
-  }
-}
-
-
-static void assignHqTimeSlots( HANDLE_SBR_DEC hSbrDec,                     /*!< handle to Decoder channel */
-                               FIXP_DBL  **QmfBufferReal,
-                               FIXP_DBL  **QmfBufferImag,
-                               int noCols )
-{
-  FIXP_DBL  *ptr;
-  int slot;
-
-  /* Number of QMF timeslots in one half of a frame (size of Workbuffer1 or 2): */
-  int halflen = (noCols >> 1) + hSbrDec->LppTrans.pSettings->overlap;
-  int totCols = noCols + hSbrDec->LppTrans.pSettings->overlap;
-
-  /* Number of QMF timeslots in the overlap buffer: */
-  ptr = hSbrDec->pSbrOverlapBuffer;
-  for(slot=0; slot<hSbrDec->LppTrans.pSettings->overlap; slot++) {
-    QmfBufferReal[slot] = ptr; ptr += (64);
-    QmfBufferImag[slot] = ptr; ptr += (64);
-  }
-
-  /* Assign first half of timeslots to Workbuffer1 */
-  ptr = hSbrDec->WorkBuffer1;
-  for(; slot<halflen; slot++) {
-    QmfBufferReal[slot] = ptr; ptr += (64);
-    QmfBufferImag[slot] = ptr; ptr += (64);
-  }
-
-  /* Assign second half of timeslots to Workbuffer2 */
-  ptr = hSbrDec->WorkBuffer2;
-  for(; slot<totCols; slot++) {
-    QmfBufferReal[slot] = ptr; ptr += (64);
-    QmfBufferImag[slot] = ptr; ptr += (64);
-  }
-}
-
-
-static void assignTimeSlots( HANDLE_SBR_DEC hSbrDec,                     /*!< handle to Decoder channel */
-                             int noCols,
-                             int useLP )
-{
- /* assign qmf time slots */
-  hSbrDec->useLP = useLP;
-  if (useLP) {
-    hSbrDec->SynthesisQMF.flags |= QMF_FLAG_LP;
-    hSbrDec->AnalysiscQMF.flags |= QMF_FLAG_LP;
-  } else {
-    hSbrDec->SynthesisQMF.flags &= ~QMF_FLAG_LP;
-    hSbrDec->AnalysiscQMF.flags &= ~QMF_FLAG_LP;
-  }
-  if (!useLP)
-    assignHqTimeSlots( hSbrDec, hSbrDec->QmfBufferReal, hSbrDec->QmfBufferImag, noCols );
-  else
-  {
-    assignLcTimeSlots( hSbrDec, hSbrDec->QmfBufferReal, noCols );
-  }
-}
-
-static void changeQmfType( HANDLE_SBR_DEC hSbrDec,                     /*!< handle to Decoder channel */
-                           int useLdTimeAlign )
-{
-  UINT synQmfFlags = hSbrDec->SynthesisQMF.flags;
-  UINT anaQmfFlags = hSbrDec->AnalysiscQMF.flags;
-  int  resetSynQmf = 0;
-  int  resetAnaQmf = 0;
-
-  /* assign qmf type */
-  if (useLdTimeAlign) {
-    if (synQmfFlags & QMF_FLAG_CLDFB) {
-      /* change the type to MPSLD */
-      synQmfFlags &= ~QMF_FLAG_CLDFB;
-      synQmfFlags |=  QMF_FLAG_MPSLDFB;
-      resetSynQmf = 1;
-    }
-    if (anaQmfFlags & QMF_FLAG_CLDFB) {
-      /* change the type to MPSLD */
-      anaQmfFlags &= ~QMF_FLAG_CLDFB;
-      anaQmfFlags |=  QMF_FLAG_MPSLDFB;
-      resetAnaQmf = 1;
-    }
-  } else {
-    if (synQmfFlags & QMF_FLAG_MPSLDFB) {
-      /* change the type to CLDFB */
-      synQmfFlags &= ~QMF_FLAG_MPSLDFB;
-      synQmfFlags |=  QMF_FLAG_CLDFB;
-      resetSynQmf = 1;
-    }
-    if (anaQmfFlags & QMF_FLAG_MPSLDFB) {
-      /* change the type to CLDFB */
-      anaQmfFlags &= ~QMF_FLAG_MPSLDFB;
-      anaQmfFlags |=  QMF_FLAG_CLDFB;
-      resetAnaQmf = 1;
-    }
-  }
-
-  if (resetAnaQmf) {
-    int qmfErr = qmfInitAnalysisFilterBank (
-           &hSbrDec->AnalysiscQMF,
-            hSbrDec->anaQmfStates,
-            hSbrDec->AnalysiscQMF.no_col,
-            hSbrDec->AnalysiscQMF.lsb,
-            hSbrDec->AnalysiscQMF.usb,
-            hSbrDec->AnalysiscQMF.no_channels,
-            anaQmfFlags | QMF_FLAG_KEEP_STATES
-            );
-    if (qmfErr != 0) {
-      FDK_ASSERT(0);
-    }
-  }
-
-  if (resetSynQmf) {
-    int qmfErr = qmfInitSynthesisFilterBank (
-           &hSbrDec->SynthesisQMF,
-            hSbrDec->pSynQmfStates,
-            hSbrDec->SynthesisQMF.no_col,
-            hSbrDec->SynthesisQMF.lsb,
-            hSbrDec->SynthesisQMF.usb,
-            hSbrDec->SynthesisQMF.no_channels,
-            synQmfFlags | QMF_FLAG_KEEP_STATES
-            );
-
-    if (qmfErr != 0) {
-      FDK_ASSERT(0);
-    }
-  }
-}
-
-
-/*!
-  \brief      SBR decoder core function for one channel
-
-  \image html  BufferMgmtDetailed-1632.png
-
-  Besides the filter states of the QMF filter bank and the LPC-states of
-  the LPP-Transposer, processing is mainly based on four buffers:
-  #timeIn, #timeOut, #WorkBuffer2 and #OverlapBuffer. The #WorkBuffer2
-  is reused for all channels and might be used by the core decoder, a
-  static overlap buffer is required for each channel. Du to in-place
-  processing, #timeIn and #timeOut point to identical locations.
-
-  The spectral data is organized in so-called slots, each slot
-  containing 64 bands of complex data. The number of slots per frame is
-  dependend on the frame size. For mp3PRO, there are 18 slots per frame
-  and 6 slots per #OverlapBuffer. It is not necessary to have the slots
-  in located consecutive address ranges.
-
-  To optimize memory usage and to minimize the number of memory
-  accesses, the memory management is organized as follows (Slot numbers
-  based on mp3PRO):
-
-  1.) Input time domain signal is located in #timeIn, the last slots
-  (0..5) of the spectral data of the previous frame are located in the
-  #OverlapBuffer. In addition, #frameData of the current frame resides
-  in the upper part of #timeIn.
-
-  2.) During the cplxAnalysisQmfFiltering(), 32 samples from #timeIn are transformed
-  into a slot of up to 32 complex spectral low band values at a
-  time. The first spectral slot -- nr. 6 -- is written at slot number
-  zero of #WorkBuffer2. #WorkBuffer2 will be completely filled with
-  spectral data.
-
-  3.) LPP-Transposition in lppTransposer() is processed on 24 slots. During the
-  transposition, the high band part of the spectral data is replicated
-  based on the low band data.
-
-  Envelope Adjustment is processed on the high band part of the spectral
-  data only by calculateSbrEnvelope().
-
-  4.) The cplxSynthesisQmfFiltering() creates 64 time domain samples out
-  of a slot of 64 complex spectral values at a time. The first 6 slots
-  in #timeOut are filled from the results of spectral slots 0..5 in the
-  #OverlapBuffer. The consecutive slots in timeOut are now filled with
-  the results of spectral slots 6..17.
-
-  5.) The preprocessed slots 18..23 have to be stored in the
-  #OverlapBuffer.
-
-*/
-
-void
-sbr_dec ( HANDLE_SBR_DEC hSbrDec,            /*!< handle to Decoder channel */
-          INT_PCM *timeIn,                   /*!< pointer to input time signal */
-          INT_PCM *timeOut,                  /*!< pointer to output time signal */
-          HANDLE_SBR_DEC hSbrDecRight,       /*!< handle to Decoder channel right */
-          INT_PCM *timeOutRight,             /*!< pointer to output time signal */
-          const int strideIn,                /*!< Time data traversal strideIn */
-          const int strideOut,               /*!< Time data traversal strideOut */
-          HANDLE_SBR_HEADER_DATA hHeaderData,/*!< Static control data */
-          HANDLE_SBR_FRAME_DATA hFrameData,  /*!< Control data of current frame */
-          HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,  /*!< Some control data of last frame */
-          const int applyProcessing,         /*!< Flag for SBR operation */
-          HANDLE_PS_DEC h_ps_d,
-          const UINT flags
-         )
-{
-  int i, slot, reserve;
-  int saveLbScale;
-  int ov_len;
-  int lastSlotOffs;
-  FIXP_DBL maxVal;
-
-  /* 1+1/3 frames of spectral data: */
-  FIXP_DBL **QmfBufferReal = hSbrDec->QmfBufferReal;
-  FIXP_DBL **QmfBufferImag = hSbrDec->QmfBufferImag;
-
- /* Number of QMF timeslots in the overlap buffer: */
- ov_len = hSbrDec->LppTrans.pSettings->overlap;
-
- /* Number of QMF slots per frame */
-  int noCols = hHeaderData->numberTimeSlots * hHeaderData->timeStep;
-
- /* assign qmf time slots */
-  if ( ((flags & SBRDEC_LOW_POWER ) ? 1 : 0) != ((hSbrDec->SynthesisQMF.flags & QMF_FLAG_LP) ? 1 : 0) ) {
-    assignTimeSlots( hSbrDec, hHeaderData->numberTimeSlots * hHeaderData->timeStep, flags & SBRDEC_LOW_POWER);
-  }
-
-  if (flags & SBRDEC_ELD_GRID) {
-    /* Choose the right low delay filter bank */
-    changeQmfType( hSbrDec, (flags & SBRDEC_LD_MPS_QMF) ? 1 : 0 );
-  }
-
-  /*
-    low band codec signal subband filtering
-   */
-
-  {
-    C_AALLOC_SCRATCH_START(qmfTemp, FIXP_DBL, 2*(64));
-
-    qmfAnalysisFiltering( &hSbrDec->AnalysiscQMF,
-                           QmfBufferReal + ov_len,
-                           QmfBufferImag + ov_len,
-                          &hSbrDec->sbrScaleFactor,
-                           timeIn,
-                           strideIn,
-                           qmfTemp
-                         );
-
-    C_AALLOC_SCRATCH_END(qmfTemp, FIXP_DBL, 2*(64));
-  }
-
-  /*
-    Clear upper half of spectrum
-  */
-  {
-    int nAnalysisBands = hHeaderData->numberOfAnalysisBands;
-
-    if (! (flags & SBRDEC_LOW_POWER)) {
-      for (slot = ov_len; slot < noCols+ov_len; slot++) {
-        FDKmemclear(&QmfBufferReal[slot][nAnalysisBands],((64)-nAnalysisBands)*sizeof(FIXP_DBL));
-        FDKmemclear(&QmfBufferImag[slot][nAnalysisBands],((64)-nAnalysisBands)*sizeof(FIXP_DBL));
-      }
-    } else
-    for (slot = ov_len; slot < noCols+ov_len; slot++) {
-      FDKmemclear(&QmfBufferReal[slot][nAnalysisBands],((64)-nAnalysisBands)*sizeof(FIXP_DBL));
-    }
-  }
-
-
-
-  /*
-    Shift spectral data left to gain accuracy in transposer and adjustor
-  */
-  maxVal = maxSubbandSample( QmfBufferReal,
-                            (flags & SBRDEC_LOW_POWER) ? NULL : QmfBufferImag,
-                             0,
-                             hSbrDec->AnalysiscQMF.lsb,
-                             ov_len,
-                             noCols+ov_len );
-
-  reserve = fixMax(0,CntLeadingZeros(maxVal)-1) ;
-  reserve = fixMin(reserve,DFRACT_BITS-1-hSbrDec->sbrScaleFactor.lb_scale);
-
-  /* If all data is zero, lb_scale could become too large */
-  rescaleSubbandSamples( QmfBufferReal,
-                         (flags & SBRDEC_LOW_POWER) ? NULL : QmfBufferImag,
-                         0,
-                         hSbrDec->AnalysiscQMF.lsb,
-                         ov_len,
-                         noCols+ov_len,
-                         reserve);
-
-  hSbrDec->sbrScaleFactor.lb_scale += reserve;
-
-  /*
-    save low band scale, wavecoding or parametric stereo may modify it
-  */
-  saveLbScale = hSbrDec->sbrScaleFactor.lb_scale;
-
-
-  if (applyProcessing)
-  {
-    UCHAR * borders = hFrameData->frameInfo.borders;
-    lastSlotOffs =  borders[hFrameData->frameInfo.nEnvelopes] - hHeaderData->numberTimeSlots;
-
-    FIXP_DBL degreeAlias[(64)];
-
-    /* The transposer will override most values in degreeAlias[].
-       The array needs to be cleared at least from lowSubband to highSubband before. */
-    if (flags & SBRDEC_LOW_POWER)
-      FDKmemclear(&degreeAlias[hHeaderData->freqBandData.lowSubband], (hHeaderData->freqBandData.highSubband-hHeaderData->freqBandData.lowSubband)*sizeof(FIXP_DBL));
-
-    /*
-      Inverse filtering of lowband and transposition into the SBR-frequency range
-    */
-
-    lppTransposer ( &hSbrDec->LppTrans,
-                    &hSbrDec->sbrScaleFactor,
-                    QmfBufferReal,
-                    degreeAlias,                  // only used if useLP = 1
-                    QmfBufferImag,
-                    flags & SBRDEC_LOW_POWER,
-                    hHeaderData->timeStep,
-                    borders[0],
-                    lastSlotOffs,
-                    hHeaderData->freqBandData.nInvfBands,
-                    hFrameData->sbr_invf_mode,
-                    hPrevFrameData->sbr_invf_mode );
-
-
-
-
-
-    /*
-      Adjust envelope of current frame.
-    */
-
-    calculateSbrEnvelope (&hSbrDec->sbrScaleFactor,
-                          &hSbrDec->SbrCalculateEnvelope,
-                          hHeaderData,
-                          hFrameData,
-                          QmfBufferReal,
-                          QmfBufferImag,
-                          flags & SBRDEC_LOW_POWER,
-
-                          degreeAlias,
-                          flags,
-                          (hHeaderData->frameErrorFlag || hPrevFrameData->frameErrorFlag));
-
-
-    /*
-      Update hPrevFrameData (to be used in the next frame)
-    */
-    for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
-      hPrevFrameData->sbr_invf_mode[i] = hFrameData->sbr_invf_mode[i];
-    }
-    hPrevFrameData->coupling = hFrameData->coupling;
-    hPrevFrameData->stopPos = borders[hFrameData->frameInfo.nEnvelopes];
-    hPrevFrameData->ampRes = hFrameData->ampResolutionCurrentFrame;
-  }
-  else {
-    /* Reset hb_scale if no highband is present, because hb_scale is considered in the QMF-synthesis */
-    hSbrDec->sbrScaleFactor.hb_scale = saveLbScale;
-  }
-
-
-  for (i=0; i<LPC_ORDER; i++){
-    /*
-      Store the unmodified qmf Slots values (required for LPC filtering)
-    */
-    if (! (flags & SBRDEC_LOW_POWER)) {
-      FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesReal[i], QmfBufferReal[noCols-LPC_ORDER+i], hSbrDec->AnalysiscQMF.lsb*sizeof(FIXP_DBL));
-      FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesImag[i], QmfBufferImag[noCols-LPC_ORDER+i], hSbrDec->AnalysiscQMF.lsb*sizeof(FIXP_DBL));
-    } else
-    FDKmemcpy(hSbrDec->LppTrans.lpcFilterStatesReal[i], QmfBufferReal[noCols-LPC_ORDER+i], hSbrDec->AnalysiscQMF.lsb*sizeof(FIXP_DBL));
-  }
-
-  /*
-    Synthesis subband filtering.
-  */
-
-  if ( ! (flags & SBRDEC_PS_DECODED) ) {
-
-    {
-      int outScalefactor = 0;
-
-      if (h_ps_d != NULL) {
-        h_ps_d->procFrameBased = 1;  /* we here do frame based processing */
-      }
-
-
-      sbrDecoder_drcApply(&hSbrDec->sbrDrcChannel,
-                           QmfBufferReal,
-                           (flags & SBRDEC_LOW_POWER) ? NULL : QmfBufferImag,
-                           hSbrDec->SynthesisQMF.no_col,
-                          &outScalefactor
-                          );
-
-
-
-      qmfChangeOutScalefactor(&hSbrDec->SynthesisQMF, outScalefactor );
-
-      {
-        C_AALLOC_SCRATCH_START(qmfTemp, FIXP_DBL, 2*(64));
-
-        qmfSynthesisFiltering( &hSbrDec->SynthesisQMF,
-                                QmfBufferReal,
-                                (flags & SBRDEC_LOW_POWER) ? NULL : QmfBufferImag,
-                               &hSbrDec->sbrScaleFactor,
-                                hSbrDec->LppTrans.pSettings->overlap,
-                                timeOut,
-                                strideOut,
-                                qmfTemp);
-
-        C_AALLOC_SCRATCH_END(qmfTemp, FIXP_DBL, 2*(64));
-      }
-
-    }
-
-  } else { /* (flags & SBRDEC_PS_DECODED) */
-    INT i, sdiff, outScalefactor, scaleFactorLowBand, scaleFactorHighBand;
-    SCHAR scaleFactorLowBand_ov, scaleFactorLowBand_no_ov;
-
-    HANDLE_QMF_FILTER_BANK synQmf      = &hSbrDec->SynthesisQMF;
-    HANDLE_QMF_FILTER_BANK synQmfRight = &hSbrDecRight->SynthesisQMF;
-
-    /* adapt scaling */
-    sdiff = hSbrDec->sbrScaleFactor.lb_scale - reserve;                  /* Scaling difference         */
-    scaleFactorHighBand   = sdiff - hSbrDec->sbrScaleFactor.hb_scale;    /* Scale of current high band */
-    scaleFactorLowBand_ov = sdiff - hSbrDec->sbrScaleFactor.ov_lb_scale; /* Scale of low band overlapping QMF data */
-    scaleFactorLowBand_no_ov = sdiff - hSbrDec->sbrScaleFactor.lb_scale; /* Scale of low band current QMF data     */
-    outScalefactor  = 0;                                                 /* Initial output scale */
-
-    if (h_ps_d->procFrameBased == 1)    /* If we have switched from frame to slot based processing copy filter states */
-    { /* procFrameBased will be unset later */
-      /* copy filter states from left to right */
-      FDKmemcpy(synQmfRight->FilterStates, synQmf->FilterStates, ((640)-(64))*sizeof(FIXP_QSS));
-    }
-
-    /* scale ALL qmf vales ( real and imag ) of mono / left channel to the
-       same scale factor ( ov_lb_sf, lb_sf and hq_sf )                      */
-    scalFilterBankValues( h_ps_d,                             /* parametric stereo decoder handle     */
-                          QmfBufferReal,                      /* qmf filterbank values                */
-                          QmfBufferImag,                      /* qmf filterbank values                */
-                          synQmf->lsb,                        /* sbr start subband                    */
-                          hSbrDec->sbrScaleFactor.ov_lb_scale,
-                          hSbrDec->sbrScaleFactor.lb_scale,
-                         &scaleFactorLowBand_ov,              /* adapt scaling values */
-                         &scaleFactorLowBand_no_ov,           /* adapt scaling values */
-                          hSbrDec->sbrScaleFactor.hb_scale,   /* current frame ( highband ) */
-                         &scaleFactorHighBand,
-                          synQmf->no_col);
-
-    /* use the same synthese qmf values for left and right channel */
-    synQmfRight->no_col = synQmf->no_col;
-    synQmfRight->lsb    = synQmf->lsb;
-    synQmfRight->usb    = synQmf->usb;
-
-    int env=0;
-
-      outScalefactor += (SCAL_HEADROOM+1); /* psDiffScale! */
-
-    {
-      C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, 2*(64));
-
-      int maxShift = 0;
-
-      if (hSbrDec->sbrDrcChannel.enable != 0) {
-        if (hSbrDec->sbrDrcChannel.prevFact_exp > maxShift) {
-          maxShift = hSbrDec->sbrDrcChannel.prevFact_exp;
-        }
-        if (hSbrDec->sbrDrcChannel.currFact_exp > maxShift) {
-          maxShift = hSbrDec->sbrDrcChannel.currFact_exp;
-        }
-        if (hSbrDec->sbrDrcChannel.nextFact_exp > maxShift) {
-          maxShift = hSbrDec->sbrDrcChannel.nextFact_exp;
-        }
-      }
-
-      /* copy DRC data to right channel (with PS both channels use the same DRC gains) */
-      FDKmemcpy(&hSbrDecRight->sbrDrcChannel, &hSbrDec->sbrDrcChannel, sizeof(SBRDEC_DRC_CHANNEL));
-
-      for (i = 0; i < synQmf->no_col; i++) {  /* ----- no_col loop ----- */
-
-        INT outScalefactorR, outScalefactorL;
-        outScalefactorR = outScalefactorL = outScalefactor;
-
-        /* qmf timeslot of right channel */
-        FIXP_DBL* rQmfReal = pWorkBuffer;
-        FIXP_DBL* rQmfImag = pWorkBuffer + 64;
-
-
-        {
-          if ( i == h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env] ) {
-            initSlotBasedRotation( h_ps_d, env, hHeaderData->freqBandData.highSubband );
-            env++;
-          }
-
-          ApplyPsSlot( h_ps_d,                   /* parametric stereo decoder handle  */
-                      (QmfBufferReal + i),       /* one timeslot of left/mono channel */
-                      (QmfBufferImag + i),       /* one timeslot of left/mono channel */
-                       rQmfReal,                 /* one timeslot or right channel     */
-                       rQmfImag);                /* one timeslot or right channel     */
-        }
-
-
-        scaleFactorLowBand = (i<(6)) ? scaleFactorLowBand_ov : scaleFactorLowBand_no_ov;
-
-
-        sbrDecoder_drcApplySlot ( /* right channel */
-                                 &hSbrDecRight->sbrDrcChannel,
-                                  rQmfReal,
-                                  rQmfImag,
-                                  i,
-                                  synQmfRight->no_col,
-                                  maxShift
-                                );
-
-        outScalefactorR += maxShift;
-
-        sbrDecoder_drcApplySlot ( /* left channel */
-                                 &hSbrDec->sbrDrcChannel,
-                                 *(QmfBufferReal + i),
-                                 *(QmfBufferImag + i),
-                                  i,
-                                  synQmf->no_col,
-                                  maxShift
-                                );
-
-        outScalefactorL += maxShift;
-
-
-        /* scale filter states for left and right channel */
-        qmfChangeOutScalefactor( synQmf, outScalefactorL );
-        qmfChangeOutScalefactor( synQmfRight, outScalefactorR );
-
-        {
-
-          qmfSynthesisFilteringSlot( synQmfRight,
-                                     rQmfReal,                /* QMF real buffer */
-                                     rQmfImag,                /* QMF imag buffer */
-                                     scaleFactorLowBand,
-                                     scaleFactorHighBand,
-                                     timeOutRight+(i*synQmf->no_channels*strideOut),
-                                     strideOut,
-                                     pWorkBuffer);
-
-          qmfSynthesisFilteringSlot( synQmf,
-                                   *(QmfBufferReal + i),      /* QMF real buffer */
-                                   *(QmfBufferImag + i),      /* QMF imag buffer */
-                                     scaleFactorLowBand,
-                                     scaleFactorHighBand,
-                                     timeOut+(i*synQmf->no_channels*strideOut),
-                                     strideOut,
-                                     pWorkBuffer);
-
-        }
-      } /* no_col loop  i  */
-
-      /* scale back (6) timeslots look ahead for hybrid filterbank to original value */
-      rescalFilterBankValues( h_ps_d,
-                              QmfBufferReal,
-                              QmfBufferImag,
-                              synQmf->lsb,
-                              synQmf->no_col );
-
-      C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, 2*(64));
-    }
-  }
-
-  sbrDecoder_drcUpdateChannel( &hSbrDec->sbrDrcChannel );
-
-
-  /*
-    Update overlap buffer
-    Even bands above usb are copied to avoid outdated spectral data in case
-    the stop frequency raises.
-  */
-
-  if (hSbrDec->LppTrans.pSettings->overlap > 0)
-  {
-    if (! (flags & SBRDEC_LOW_POWER)) {
-      for ( i=0; i<hSbrDec->LppTrans.pSettings->overlap; i++ ) {
-        FDKmemcpy(QmfBufferReal[i], QmfBufferReal[i+noCols], (64)*sizeof(FIXP_DBL));
-        FDKmemcpy(QmfBufferImag[i], QmfBufferImag[i+noCols], (64)*sizeof(FIXP_DBL));
-      }
-    } else
-      for ( i=0; i<hSbrDec->LppTrans.pSettings->overlap; i++ ) {
-        FDKmemcpy(QmfBufferReal[i], QmfBufferReal[i+noCols], (64)*sizeof(FIXP_DBL));
-      }
-  }
-
-  hSbrDec->sbrScaleFactor.ov_lb_scale = saveLbScale;
-
-  /* Save current frame status */
-  hPrevFrameData->frameErrorFlag = hHeaderData->frameErrorFlag;
-
-} // sbr_dec()
-
-
-/*!
-  \brief     Creates sbr decoder structure
-  \return    errorCode, 0 if successful
-*/
-SBR_ERROR
-createSbrDec (SBR_CHANNEL * hSbrChannel,
-              HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
-              TRANSPOSER_SETTINGS *pSettings,
-              const int     downsampleFac,        /*!< Downsampling factor */
-              const UINT    qmfFlags,             /*!< flags -> 1: HQ/LP selector, 2: CLDFB */
-              const UINT    flags,
-              const int     overlap, 
-              int           chan)                 /*!< Channel for which to assign buffers etc. */
-
-{
-  SBR_ERROR err = SBRDEC_OK;
-  int timeSlots = hHeaderData->numberTimeSlots;   /* Number of SBR slots per frame */
-  int noCols = timeSlots * hHeaderData->timeStep; /* Number of QMF slots per frame */
-  HANDLE_SBR_DEC hs = &(hSbrChannel->SbrDec);
-
-  /* Initialize scale factors */
-  hs->sbrScaleFactor.ov_lb_scale  = 0;
-  hs->sbrScaleFactor.ov_hb_scale  = 0;
-  hs->sbrScaleFactor.hb_scale     = 0;
-
-
-  /*
-    create envelope calculator
-  */
-  err = createSbrEnvelopeCalc (&hs->SbrCalculateEnvelope,
-                               hHeaderData,
-                               chan,
-                               flags);
-  if (err != SBRDEC_OK) {
-    return err;
-  }
-
-  /*
-    create QMF filter banks
-  */
-  {
-    int qmfErr;
-    /* Adapted QMF analysis post-twiddles for down-sampled HQ SBR */
-    const UINT downSampledFlag = (downsampleFac==2) ? QMF_FLAG_DOWNSAMPLED : 0;
-
-    qmfErr = qmfInitAnalysisFilterBank (
-                    &hs->AnalysiscQMF,
-                     hs->anaQmfStates,
-                     noCols,
-                     hHeaderData->freqBandData.lowSubband,
-                     hHeaderData->freqBandData.highSubband,
-                     hHeaderData->numberOfAnalysisBands,
-                     (qmfFlags & (~QMF_FLAG_KEEP_STATES)) | downSampledFlag
-                     );
-    if (qmfErr != 0) {
-      return SBRDEC_UNSUPPORTED_CONFIG;
-    }
-  }
-  if (hs->pSynQmfStates == NULL) {
-    hs->pSynQmfStates = GetRam_sbr_QmfStatesSynthesis(chan);
-    if (hs->pSynQmfStates == NULL)
-      return SBRDEC_MEM_ALLOC_FAILED;
-  }
-
-  {
-    int qmfErr;
-
-    qmfErr = qmfInitSynthesisFilterBank (
-           &hs->SynthesisQMF,
-            hs->pSynQmfStates,
-            noCols,
-            hHeaderData->freqBandData.lowSubband,
-            hHeaderData->freqBandData.highSubband,
-            (64) / downsampleFac,
-            qmfFlags & (~QMF_FLAG_KEEP_STATES)
-            );
-
-    if (qmfErr != 0) {
-      return SBRDEC_UNSUPPORTED_CONFIG;
-    }
-  }
-  initSbrPrevFrameData (&hSbrChannel->prevFrameData, timeSlots);
-
-  /*
-    create transposer
-  */
-  err = createLppTransposer (&hs->LppTrans,
-                             pSettings,
-                             hHeaderData->freqBandData.lowSubband,
-                             hHeaderData->freqBandData.v_k_master,
-                             hHeaderData->freqBandData.numMaster,
-                             hs->SynthesisQMF.usb,
-                             timeSlots,
-                             hs->AnalysiscQMF.no_col,
-                             hHeaderData->freqBandData.freqBandTableNoise,
-                             hHeaderData->freqBandData.nNfb,
-                             hHeaderData->sbrProcSmplRate,
-                             chan,
-                             overlap );
-  if (err != SBRDEC_OK) {
-    return err;
-  }
-
-  /* The CLDFB does not have overlap */
-  if ((qmfFlags & QMF_FLAG_CLDFB) == 0) {
-    if (hs->pSbrOverlapBuffer == NULL) {
-      hs->pSbrOverlapBuffer = GetRam_sbr_OverlapBuffer(chan);
-      if (hs->pSbrOverlapBuffer == NULL)  {
-        return SBRDEC_MEM_ALLOC_FAILED;
-      }
-    } else {
-      /* Clear overlap buffer */
-      FDKmemclear( hs->pSbrOverlapBuffer,
-                   sizeof(FIXP_DBL) * 2 * (6) * (64)
-                 );
-    }
-  }
-
-  /* assign qmf time slots */
-  assignTimeSlots( &hSbrChannel->SbrDec, hHeaderData->numberTimeSlots * hHeaderData->timeStep, qmfFlags & QMF_FLAG_LP);
-
-  return err;
-}
-
-/*!
-  \brief     Delete sbr decoder structure
-  \return    errorCode, 0 if successful
-*/
-int
-deleteSbrDec (SBR_CHANNEL * hSbrChannel)
-{
-  HANDLE_SBR_DEC hs = &hSbrChannel->SbrDec;
-
-  deleteSbrEnvelopeCalc (&hs->SbrCalculateEnvelope);
-
-  /* delete QMF filter states */
-  if (hs->pSynQmfStates != NULL) {
-    FreeRam_sbr_QmfStatesSynthesis(&hs->pSynQmfStates);
-  }
-
-
-  if (hs->pSbrOverlapBuffer != NULL) {
-    FreeRam_sbr_OverlapBuffer(&hs->pSbrOverlapBuffer);
-  }
-
-  return 0;
-}
-
-
-/*!
-  \brief     resets sbr decoder structure
-  \return    errorCode, 0 if successful
-*/
-SBR_ERROR
-resetSbrDec (HANDLE_SBR_DEC hSbrDec,
-             HANDLE_SBR_HEADER_DATA hHeaderData,
-             HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,
-             const int useLP,
-             const int downsampleFac
-             )
-{
-  SBR_ERROR sbrError = SBRDEC_OK;
-  
-  int old_lsb = hSbrDec->SynthesisQMF.lsb;
-  int new_lsb = hHeaderData->freqBandData.lowSubband;
-  int l, startBand, stopBand, startSlot, size;
-
-  int source_scale, target_scale, delta_scale, target_lsb, target_usb, reserve;
-  FIXP_DBL maxVal;
-
-  /* overlapBuffer point to first (6) slots */
-  FIXP_DBL  **OverlapBufferReal = hSbrDec->QmfBufferReal;
-  FIXP_DBL  **OverlapBufferImag = hSbrDec->QmfBufferImag;
-
-  /* assign qmf time slots */
-  assignTimeSlots( hSbrDec, hHeaderData->numberTimeSlots * hHeaderData->timeStep, useLP);
-
-
-
-  resetSbrEnvelopeCalc (&hSbrDec->SbrCalculateEnvelope);
-
-  hSbrDec->SynthesisQMF.lsb = hHeaderData->freqBandData.lowSubband;
-  hSbrDec->SynthesisQMF.usb = fixMin((INT)hSbrDec->SynthesisQMF.no_channels, (INT)hHeaderData->freqBandData.highSubband);
-
-  hSbrDec->AnalysiscQMF.lsb = hSbrDec->SynthesisQMF.lsb;
-  hSbrDec->AnalysiscQMF.usb = hSbrDec->SynthesisQMF.usb;
-
-
-  /*
-    The following initialization of spectral data in the overlap buffer
-    is required for dynamic x-over or a change of the start-freq for 2 reasons:
-
-    1. If the lowband gets _wider_, unadjusted data would remain
-
-    2. If the lowband becomes _smaller_, the highest bands of the old lowband
-       must be cleared because the whitening would be affected
-  */
-  startBand = old_lsb;
-  stopBand  = new_lsb;
-  startSlot = hHeaderData->timeStep * (hPrevFrameData->stopPos - hHeaderData->numberTimeSlots);
-  size      = fixMax(0,stopBand-startBand);
-
-  /* keep already adjusted data in the x-over-area */
-  if (!useLP) {
-    for (l=startSlot; l<hSbrDec->LppTrans.pSettings->overlap; l++) {
-      FDKmemclear(&OverlapBufferReal[l][startBand], size*sizeof(FIXP_DBL));
-      FDKmemclear(&OverlapBufferImag[l][startBand], size*sizeof(FIXP_DBL));
-    }
-  } else
-  for (l=startSlot; l<hSbrDec->LppTrans.pSettings->overlap ; l++) {
-    FDKmemclear(&OverlapBufferReal[l][startBand], size*sizeof(FIXP_DBL));
-  }
-
-
-  /*
-    reset LPC filter states
-  */
-  startBand = fixMin(old_lsb,new_lsb);
-  stopBand  = fixMax(old_lsb,new_lsb);
-  size      = fixMax(0,stopBand-startBand);
-
-  FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesReal[0][startBand], size*sizeof(FIXP_DBL));
-  FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesReal[1][startBand], size*sizeof(FIXP_DBL));
-  if (!useLP) {
-    FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesImag[0][startBand], size*sizeof(FIXP_DBL));
-    FDKmemclear(&hSbrDec->LppTrans.lpcFilterStatesImag[1][startBand], size*sizeof(FIXP_DBL));
-  }
-
-
-  /*
-    Rescale already processed spectral data between old and new x-over frequency.
-    This must be done because of the separate scalefactors for lowband and highband.
-  */
-  startBand = fixMin(old_lsb,new_lsb);
-  stopBand =  fixMax(old_lsb,new_lsb);
-
-  if (new_lsb > old_lsb) {
-    /* The x-over-area was part of the highband before and will now belong to the lowband */
-    source_scale = hSbrDec->sbrScaleFactor.ov_hb_scale;
-    target_scale = hSbrDec->sbrScaleFactor.ov_lb_scale;
-    target_lsb   = 0;
-    target_usb   = old_lsb;
-  }
-  else {
-    /* The x-over-area was part of the lowband before and will now belong to the highband */
-    source_scale = hSbrDec->sbrScaleFactor.ov_lb_scale;
-    target_scale = hSbrDec->sbrScaleFactor.ov_hb_scale;
-    /* jdr: The values old_lsb and old_usb might be wrong because the previous frame might have been "upsamling". */
-    target_lsb   = hSbrDec->SynthesisQMF.lsb;
-    target_usb   = hSbrDec->SynthesisQMF.usb;
-  }
-
-  /* Shift left all samples of the x-over-area as much as possible
-     An unnecessary coarse scale could cause ov_lb_scale or ov_hb_scale to be
-     adapted and the accuracy in the next frame would seriously suffer! */
-
-  maxVal = maxSubbandSample( OverlapBufferReal,
-                             (useLP) ? NULL : OverlapBufferImag,
-                             startBand,
-                             stopBand,
-                             0,
-                             startSlot);
-
-  reserve = CntLeadingZeros(maxVal)-1;
-  reserve = fixMin(reserve,DFRACT_BITS-1-source_scale);
-
-  rescaleSubbandSamples( OverlapBufferReal,
-                         (useLP) ? NULL : OverlapBufferImag,
-                         startBand,
-                         stopBand,
-                         0,
-                         startSlot,
-                         reserve);
-  source_scale += reserve;
-
-  delta_scale = target_scale - source_scale;
-
-  if (delta_scale > 0) { /* x-over-area is dominant */
-    delta_scale = -delta_scale;
-    startBand = target_lsb;
-    stopBand = target_usb;
-
-    if (new_lsb > old_lsb) {
-      /* The lowband has to be rescaled */
-      hSbrDec->sbrScaleFactor.ov_lb_scale = source_scale;
-    }
-    else {
-      /* The highband has be be rescaled */
-      hSbrDec->sbrScaleFactor.ov_hb_scale = source_scale;
-    }
-  }
-
-  FDK_ASSERT(startBand <= stopBand);
-
-  if (!useLP) {
-    for (l=0; l<startSlot; l++) {
-      scaleValues( OverlapBufferReal[l] + startBand, stopBand-startBand, delta_scale );
-      scaleValues( OverlapBufferImag[l] + startBand, stopBand-startBand, delta_scale );
-    }
-  } else
-  for (l=0; l<startSlot; l++) {
-    scaleValues( OverlapBufferReal[l] + startBand, stopBand-startBand, delta_scale );
-  }
-
-
-  /*
-    Initialize transposer and limiter
-  */
-  sbrError = resetLppTransposer (&hSbrDec->LppTrans,
-                                 hHeaderData->freqBandData.lowSubband,
-                                 hHeaderData->freqBandData.v_k_master,
-                                 hHeaderData->freqBandData.numMaster,
-                                 hHeaderData->freqBandData.freqBandTableNoise,
-                                 hHeaderData->freqBandData.nNfb,
-                                 hHeaderData->freqBandData.highSubband,
-                                 hHeaderData->sbrProcSmplRate);
-  if (sbrError != SBRDEC_OK)
-    return sbrError;
-
-  sbrError = ResetLimiterBands ( hHeaderData->freqBandData.limiterBandTable,
-                                 &hHeaderData->freqBandData.noLimiterBands,
-                                 hHeaderData->freqBandData.freqBandTable[0],
-                                 hHeaderData->freqBandData.nSfb[0],
-                                 hSbrDec->LppTrans.pSettings->patchParam,
-                                 hSbrDec->LppTrans.pSettings->noOfPatches,
-                                 hHeaderData->bs_data.limiterBands);
-
-
-  return sbrError;
-}
diff --git a/libSBRdec/src/sbr_dec.h b/libSBRdec/src/sbr_dec.h
deleted file mode 100644
index 175e7b2..0000000
--- a/libSBRdec/src/sbr_dec.h
+++ /dev/null
@@ -1,210 +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  Sbr decoder  
-*/
-#ifndef __SBR_DEC_H
-#define __SBR_DEC_H
-
-#include "sbrdecoder.h"
-
-#include "lpp_tran.h"
-#include "qmf.h"
-#include "env_calc.h"
-#include "FDK_audio.h"
-
-
-#include "sbrdec_drc.h"
-
-#define SACDEC_ALIGNMENT_FIX
-
-typedef struct
-{
-  QMF_FILTER_BANK     AnalysiscQMF;
-  QMF_FILTER_BANK     SynthesisQMF;
-
-  SBR_CALCULATE_ENVELOPE  SbrCalculateEnvelope;
-  SBR_LPP_TRANS           LppTrans;
-
-  QMF_SCALE_FACTOR sbrScaleFactor;
-  QMF_SCALE_FACTOR sbrScaleFactorRight;
-
-  /*! Delayed spectral data needed for the dynamic framing of SBR. Not required in case of CLDFB */
-  FIXP_DBL * pSbrOverlapBuffer;
-
-  /* References to workbuffers */
-  FIXP_DBL * WorkBuffer1;
-  FIXP_DBL * WorkBuffer2;
-
-  /* QMF filter states */
-  FIXP_QAS   anaQmfStates[(320)];
-  FIXP_QSS * pSynQmfStates;
-
-  /* Reference pointer arrays for QMF time slots,
-     mixed among overlap and current slots. */
-  FIXP_DBL * QmfBufferReal[(((1024)/(32))+(6))];
-  FIXP_DBL * QmfBufferImag[(((1024)/(32))+(6))];
-  int useLP;
-
-  /* QMF domain extension time slot reference pointer array */
-
-  SBRDEC_DRC_CHANNEL  sbrDrcChannel;
-
-} SBR_DEC;
-
-typedef SBR_DEC *HANDLE_SBR_DEC;
-
-
-typedef struct
-{
-  SBR_FRAME_DATA      frameData[(1)+1];
-  SBR_PREV_FRAME_DATA prevFrameData;
-  SBR_DEC SbrDec;
-}
-SBR_CHANNEL;
-
-typedef SBR_CHANNEL *HANDLE_SBR_CHANNEL;
-
-void
-SbrDecodeAndProcess (HANDLE_SBR_DEC hSbrDec,
-                     INT_PCM *timeIn,
-                     HANDLE_SBR_HEADER_DATA hHeaderData,
-                     HANDLE_SBR_FRAME_DATA hFrameData,
-                     HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,
-                     int applyProcessing,
-                     int channelNr
-                     , UCHAR useLP
-                     );
-
-
-void
-SbrConstructTimeOutput (HANDLE_SBR_DEC hSbrDec,            /*!< handle to Decoder channel */
-                        INT_PCM *timeOut,                    /*!< pointer to output time signal */
-                        HANDLE_SBR_HEADER_DATA hHeaderData,/*!< Static control data */
-                        HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,  /*!< Some control data of last frame */
-                        int channelNr
-                       ,UCHAR useLP
-                        );
-
-
-void
-sbr_dec (HANDLE_SBR_DEC hSbrDec,            /*!< handle to Decoder channel */
-         INT_PCM *timeIn,                   /*!< pointer to input time signal */
-         INT_PCM *timeOut,                  /*!< pointer to output time signal */
-         HANDLE_SBR_DEC hSbrDecRight,       /*!< handle to Decoder channel right */
-         INT_PCM *timeOutRight,             /*!< pointer to output time signal */
-         const int strideIn,                /*!< Time data traversal strideIn */
-         const int strideOut,               /*!< Time data traversal strideOut */
-         HANDLE_SBR_HEADER_DATA hHeaderData,/*!< Static control data */
-         HANDLE_SBR_FRAME_DATA hFrameData,  /*!< Control data of current frame */
-         HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,  /*!< Some control data of last frame */
-         const int applyProcessing,         /*!< Flag for SBR operation */
-         HANDLE_PS_DEC h_ps_d,
-         const UINT flags
-        );
-
-
-
-SBR_ERROR
-createSbrDec (SBR_CHANNEL * hSbrChannel,
-              HANDLE_SBR_HEADER_DATA hHeaderData,
-              TRANSPOSER_SETTINGS *pSettings,
-              const int downsampleFac,
-              const UINT qmfFlags,
-              const UINT flags,
-              const int overlap,
-              int chan);
-
-int
-deleteSbrDec (SBR_CHANNEL * hSbrChannel);
-
-SBR_ERROR
-resetSbrDec (HANDLE_SBR_DEC hSbrDec,
-             HANDLE_SBR_HEADER_DATA hHeaderData,
-             HANDLE_SBR_PREV_FRAME_DATA hPrevFrameData,
-             const int useLP,
-             const int downsampleFac);
-
-#endif
diff --git a/libSBRdec/src/sbr_ram.cpp b/libSBRdec/src/sbr_ram.cpp
deleted file mode 100644
index 6ae941f..0000000
--- a/libSBRdec/src/sbr_ram.cpp
+++ /dev/null
@@ -1,194 +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 Memory layout
-   
-
-  This module declares all static and dynamic memory spaces
-*/
-
-#include "sbr_ram.h"
-
-
-
-
-#define WORKBUFFER1_TAG 0
-#define WORKBUFFER2_TAG 1
-
-/*!
-  \name StaticSbrData
-
-  Static memory areas, must not be overwritten in other sections of the decoder
-*/
-/* @{ */
-
-/*! SBR Decoder main structure */
-C_ALLOC_MEM(Ram_SbrDecoder, struct SBR_DECODER_INSTANCE, 1)
-/*! SBR Decoder element data  <br>
-  Dimension: (4) */
-C_ALLOC_MEM2(Ram_SbrDecElement, SBR_DECODER_ELEMENT, 1, (4))
-/*! SBR Decoder individual channel data  <br>
-  Dimension: (6) */
-C_ALLOC_MEM2(Ram_SbrDecChannel, SBR_CHANNEL, 1, (6)+1)
-
-/*! Filter states for QMF-synthesis.  <br>
-  Dimension: #(6) * (#QMF_FILTER_STATE_SYN_SIZE-#(64)) */
-C_AALLOC_MEM2_L(Ram_sbr_QmfStatesSynthesis, FIXP_QSS, (640)-(64), (6)+1, SECT_DATA_L1)
-
-/*! Delayed spectral data needed for the dynamic framing of SBR.
-  For mp3PRO, 1/3 of a frame is buffered (#(6) 6) */
-C_AALLOC_MEM2(Ram_sbr_OverlapBuffer, FIXP_DBL, 2 * (6) * (64), (6)+1)
-
-/*! Static Data of PS */
-
-C_ALLOC_MEM(Ram_ps_dec, PS_DEC, 1)
-
-
-/* @} */
-
-
-/*!
-  \name DynamicSbrData
-
-  Dynamic memory areas, might be reused in other algorithm sections,
-  e.g. the core decoder
-  <br>
-  Depending on the mode set by DONT_USE_CORE_WORKBUFFER, workbuffers are
-  defined additionally to the CoreWorkbuffer.
-  <br>
-  The size of WorkBuffers is ((1024)/(32))*(64) = 2048.
-  <br>
-  WorkBuffer2 is a pointer to the CoreWorkBuffer wich is reused here in the SBR part. In case of
-  DONT_USE_CORE_WORKBUFFER, the CoreWorkbuffer is not used and the according
-  Workbuffer2 is defined locally in this file.
-  <br>
-  WorkBuffer1 is reused in the AAC core (-> aacdecoder.cpp, aac_ram.cpp)
-  <br>
-
-  Use of WorkBuffers:
-  <pre>
-
-    -------------------------------------------------------------
-    AAC core:
-
-      CoreWorkbuffer: spectral coefficients
-      WorkBuffer1:    CAacDecoderChannelInfo, CAacDecoderDynamicData
-
-    -------------------------------------------------------------
-    SBR part:
-      ----------------------------------------------
-      Low Power Mode (useLP=1 or LOW_POWER_SBR_ONLY), see assignLcTimeSlots()
-
-        SLOT_BASED_PROTOTYPE_SYN_FILTER
-
-        WorkBuffer1                                WorkBuffer2(=CoreWorkbuffer)
-         ________________                           ________________
-        | RealLeft       |                         | RealRight      |
-        |________________|                         |________________|
-
-      ----------------------------------------------
-      High Quality Mode (!LOW_POWER_SBR_ONLY and useLP=0), see assignHqTimeSlots()
-
-         SLOTBASED_PS
-
-         WorkBuffer1                                WorkBuffer2(=CoreWorkbuffer)
-         ________________                           ________________
-        | Real/Imag      |  interleaved            | Real/Imag      |  interleaved
-        |________________|  first half actual ch   |________________|  second half actual ch
-
-    -------------------------------------------------------------
-
-  </pre>
-
-*/
-/* @{ */
-C_ALLOC_MEM_OVERLAY(Ram_SbrDecWorkBuffer1, FIXP_DBL, ((1024)/(32))*(64), SECT_DATA_L1, WORKBUFFER1_TAG)
-C_ALLOC_MEM_OVERLAY(Ram_SbrDecWorkBuffer2, FIXP_DBL, ((1024)/(32))*(64), SECT_DATA_L2, WORKBUFFER2_TAG)
-
-/* @} */
-
-
-
-
diff --git a/libSBRdec/src/sbr_ram.h b/libSBRdec/src/sbr_ram.h
deleted file mode 100644
index 8fc2dae..0000000
--- a/libSBRdec/src/sbr_ram.h
+++ /dev/null
@@ -1,158 +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 Memory layout
- 
-*/
-#ifndef _SBR_RAM_H_
-#define _SBR_RAM_H_
-
-#include "sbrdecoder.h"
-
-#include "env_extr.h"
-#include "sbr_dec.h"
-
-
-
-#define SBRDEC_MAX_CH_PER_ELEMENT  (2)
-
-typedef struct
-{
-  SBR_CHANNEL          *pSbrChannel[SBRDEC_MAX_CH_PER_ELEMENT];
-  TRANSPOSER_SETTINGS   transposerSettings; /* Common transport settings for each individual channel of an element */
-  HANDLE_FDK_BITSTREAM  hBs;
-
-  MP4_ELEMENT_ID        elementID;          /* Element ID set during initialization. Can be used for concealment */
-  int                   nChannels;          /* Number of elements output channels (=2 in case of PS) */
-
-  UCHAR frameErrorFlag[(1)+1];  /* Frame error status (for every slot in the delay line).
-                                                       Will be copied into header at the very beginning of decodeElement() routine. */
-
-  UCHAR useFrameSlot;          /* Index which defines which slot will be decoded/filled next (used with additional delay) */
-  UCHAR useHeaderSlot[(1)+1];   /* Index array that provides the link between header and frame data
-                                                       (important when processing with additional delay). */
-} SBR_DECODER_ELEMENT;
-
-
-struct SBR_DECODER_INSTANCE
-{
-  SBR_DECODER_ELEMENT  *pSbrElement[(4)];
-  SBR_HEADER_DATA       sbrHeader[(4)][(1)+1];      /* Sbr header for each individual channel of an element */
-
-  FIXP_DBL *workBuffer1;
-  FIXP_DBL *workBuffer2;
-
-  HANDLE_PS_DEC  hParametricStereoDec;
-
-  /* Global parameters */
-  AUDIO_OBJECT_TYPE coreCodec; /* AOT of core codec */
-  int numSbrElements;
-  int numSbrChannels;
-  INT sampleRateIn;            /* SBR decoder input sampling rate; might be different than the transposer input sampling rate. */
-  INT sampleRateOut;           /* Sampling rate of the SBR decoder output audio samples. */
-  USHORT codecFrameSize;
-  UCHAR synDownsampleFac;
-  UCHAR numDelayFrames;        /* The current number of additional delay frames used for processing. */
-
-  UINT flags;
-
-};
-
-H_ALLOC_MEM(Ram_SbrDecElement, SBR_DECODER_ELEMENT)
-H_ALLOC_MEM(Ram_SbrDecChannel, SBR_CHANNEL)
-H_ALLOC_MEM(Ram_SbrDecoder, struct SBR_DECODER_INSTANCE)
-
-H_ALLOC_MEM(Ram_sbr_QmfStatesSynthesis, FIXP_QSS)
-H_ALLOC_MEM(Ram_sbr_OverlapBuffer, FIXP_DBL)
-
-
-H_ALLOC_MEM(Ram_ps_dec, PS_DEC)
-
-
-H_ALLOC_MEM_OVERLAY(Ram_SbrDecWorkBuffer1, FIXP_DBL)
-H_ALLOC_MEM_OVERLAY(Ram_SbrDecWorkBuffer2, FIXP_DBL)
-
-
-#endif /* _SBR_RAM_H_ */
diff --git a/libSBRdec/src/sbr_rom.cpp b/libSBRdec/src/sbr_rom.cpp
deleted file mode 100644
index e84c3cd..0000000
--- a/libSBRdec/src/sbr_rom.cpp
+++ /dev/null
@@ -1,1414 +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  Definition of constant tables
-   
-
-  This module contains most of the constant data that can be stored in ROM.
-*/
-
-#include "sbr_rom.h"
-
-
-
-
-/*!
-  \name   StartStopBands
-  \brief  Start and stop subbands of the highband.
-
-  k_o = startMin + offset[bs_start_freq];
-  startMin = {3000,4000,5000} * (128/FS_sbr) / FS_sbr < 32Khz, 32Khz <= FS_sbr < 64KHz, 64KHz <= FS_sbr
-  The stop subband can also be calculated to save memory by defining #CALC_STOP_BAND.
-*/
-//@{
-const UCHAR FDK_sbrDecoder_sbr_start_freq_16[16] = {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_22[16] = {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 28, 30};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_24[16] = {11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 27, 29, 32};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_32[16] = {10, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 27, 29, 32};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_40[16] = {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 26, 28, 30, 32};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_44[16] = { 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 23, 25, 28, 32};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_48[16] = { 7,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 22, 24, 27, 31};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_64[16] = { 6,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 21, 23, 26, 30};
-const UCHAR FDK_sbrDecoder_sbr_start_freq_88[16] = { 5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 16, 18, 20, 23, 27, 31};
-//@}
-
-
-/*!
-  \name   Whitening
-  \brief  Coefficients for spectral whitening in the transposer
-*/
-//@{
-/*! Assignment of whitening tuning depending on the crossover frequency */
-const USHORT FDK_sbrDecoder_sbr_whFactorsIndex[NUM_WHFACTOR_TABLE_ENTRIES] = {
-  0,
-  5000,
-  6000,
-  6500,
-  7000,
-  7500,
-  8000,
-  9000,
-  10000
-};
-
-/*!
-  \brief Whithening levels tuning table
-
-  With the current tuning, there are some redundant entries:
-
-  \li  NUM_WHFACTOR_TABLE_ENTRIES can be reduced by 3,
-  \li  the first coloumn can be eliminated.
-
-*/
-const FIXP_DBL FDK_sbrDecoder_sbr_whFactorsTable[NUM_WHFACTOR_TABLE_ENTRIES][6] = {
-  /* OFF_LEVEL, TRANSITION_LEVEL, LOW_LEVEL, MID_LEVEL, HIGH_LEVEL */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* < 5000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 5000 < 6000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 6000 < 6500 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 6500 < 7000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 7000 < 7500 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 7500 < 8000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 8000 < 9000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* 9000 < 10000 */
-  {  FL2FXCONST_DBL(0.00f), FL2FXCONST_DBL(0.6f), FL2FXCONST_DBL(0.75f), FL2FXCONST_DBL(0.90f), FL2FXCONST_DBL(0.98f)},  /* > 10000 */
-};
-
-
-//@}
-
-
-/*!
-  \name   EnvAdj
-  \brief  Constants and tables used for envelope adjustment
-*/
-//@{
-
-/*! Mantissas of gain limits */
-const FIXP_SGL FDK_sbrDecoder_sbr_limGains_m[4] =
-{
-  FL2FXCONST_SGL(0.5011932025f),   /*!< -3 dB. Gain limit when limiterGains in frameData is 0 */
-  FL2FXCONST_SGL(0.5f),            /*!< 0 dB.  Gain limit when limiterGains in frameData is 1 */
-  FL2FXCONST_SGL(0.9976346258f),   /*!< +3 dB. Gain limit when limiterGains in frameData is 2 */
-  FL2FXCONST_SGL(0.6776263578f)    /*!< Inf.   Gain limit when limiterGains in frameData is 3 */
-};
-
-/*! Exponents of gain limits */
-const UCHAR FDK_sbrDecoder_sbr_limGains_e[4] =
-{
-  0, 1, 1, 67
-};
-
-/*! Constants for calculating the number of limiter bands */
-const FIXP_SGL FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4[4] =
-{
-  FL2FXCONST_SGL(1.0f / 4.0f),
-  FL2FXCONST_SGL(1.2f / 4.0f),
-  FL2FXCONST_SGL(2.0f / 4.0f),
-  FL2FXCONST_SGL(3.0f / 4.0f)
-};
-
-/*! Ratio of old gains and noise levels for the first 4 timeslots of an envelope */
-const FIXP_SGL FDK_sbrDecoder_sbr_smoothFilter[4] = {
-  FL2FXCONST_SGL(0.66666666666666f),
-  FL2FXCONST_SGL(0.36516383427084f),
-  FL2FXCONST_SGL(0.14699433520835f),
-  FL2FXCONST_SGL(0.03183050093751f)
-};
-
-
-/*! Real and imaginary part of random noise which will be modulated
-  to the desired level. An accuracy of 13 bits is sufficient for these
-  random numbers.
-*/
-const FIXP_SGL FDK_sbrDecoder_sbr_randomPhase[SBR_NF_NO_RANDOM_VAL][2] = {
-  { FL2FXCONST_SGL(-0.99948153278296f / 8.0), FL2FXCONST_SGL(-0.59483417516607f / 8.0) },
-  { FL2FXCONST_SGL( 0.97113454393991f / 8.0), FL2FXCONST_SGL(-0.67528515225647f / 8.0) },
-  { FL2FXCONST_SGL( 0.14130051758487f / 8.0), FL2FXCONST_SGL(-0.95090983575689f / 8.0) },
-  { FL2FXCONST_SGL(-0.47005496701697f / 8.0), FL2FXCONST_SGL(-0.37340549728647f / 8.0) },
-  { FL2FXCONST_SGL( 0.80705063769351f / 8.0), FL2FXCONST_SGL( 0.29653668284408f / 8.0) },
-  { FL2FXCONST_SGL(-0.38981478896926f / 8.0), FL2FXCONST_SGL( 0.89572605717087f / 8.0) },
-  { FL2FXCONST_SGL(-0.01053049862020f / 8.0), FL2FXCONST_SGL(-0.66959058036166f / 8.0) },
-  { FL2FXCONST_SGL(-0.91266367957293f / 8.0), FL2FXCONST_SGL(-0.11522938140034f / 8.0) },
-  { FL2FXCONST_SGL( 0.54840422910309f / 8.0), FL2FXCONST_SGL( 0.75221367176302f / 8.0) },
-  { FL2FXCONST_SGL( 0.40009252867955f / 8.0), FL2FXCONST_SGL(-0.98929400334421f / 8.0) },
-  { FL2FXCONST_SGL(-0.99867974711855f / 8.0), FL2FXCONST_SGL(-0.88147068645358f / 8.0) },
-  { FL2FXCONST_SGL(-0.95531076805040f / 8.0), FL2FXCONST_SGL( 0.90908757154593f / 8.0) },
-  { FL2FXCONST_SGL(-0.45725933317144f / 8.0), FL2FXCONST_SGL(-0.56716323646760f / 8.0) },
-  { FL2FXCONST_SGL(-0.72929675029275f / 8.0), FL2FXCONST_SGL(-0.98008272727324f / 8.0) },
-  { FL2FXCONST_SGL( 0.75622801399036f / 8.0), FL2FXCONST_SGL( 0.20950329995549f / 8.0) },
-  { FL2FXCONST_SGL( 0.07069442601050f / 8.0), FL2FXCONST_SGL(-0.78247898470706f / 8.0) },
-  { FL2FXCONST_SGL( 0.74496252926055f / 8.0), FL2FXCONST_SGL(-0.91169004445807f / 8.0) },
-  { FL2FXCONST_SGL(-0.96440182703856f / 8.0), FL2FXCONST_SGL(-0.94739918296622f / 8.0) },
-  { FL2FXCONST_SGL( 0.30424629369539f / 8.0), FL2FXCONST_SGL(-0.49438267012479f / 8.0) },
-  { FL2FXCONST_SGL( 0.66565033746925f / 8.0), FL2FXCONST_SGL( 0.64652935542491f / 8.0) },
-  { FL2FXCONST_SGL( 0.91697008020594f / 8.0), FL2FXCONST_SGL( 0.17514097332009f / 8.0) },
-  { FL2FXCONST_SGL(-0.70774918760427f / 8.0), FL2FXCONST_SGL( 0.52548653416543f / 8.0) },
-  { FL2FXCONST_SGL(-0.70051415345560f / 8.0), FL2FXCONST_SGL(-0.45340028808763f / 8.0) },
-  { FL2FXCONST_SGL(-0.99496513054797f / 8.0), FL2FXCONST_SGL(-0.90071908066973f / 8.0) },
-  { FL2FXCONST_SGL( 0.98164490790123f / 8.0), FL2FXCONST_SGL(-0.77463155528697f / 8.0) },
-  { FL2FXCONST_SGL(-0.54671580548181f / 8.0), FL2FXCONST_SGL(-0.02570928536004f / 8.0) },
-  { FL2FXCONST_SGL(-0.01689629065389f / 8.0), FL2FXCONST_SGL( 0.00287506445732f / 8.0) },
-  { FL2FXCONST_SGL(-0.86110349531986f / 8.0), FL2FXCONST_SGL( 0.42548583726477f / 8.0) },
-  { FL2FXCONST_SGL(-0.98892980586032f / 8.0), FL2FXCONST_SGL(-0.87881132267556f / 8.0) },
-  { FL2FXCONST_SGL( 0.51756627678691f / 8.0), FL2FXCONST_SGL( 0.66926784710139f / 8.0) },
-  { FL2FXCONST_SGL(-0.99635026409640f / 8.0), FL2FXCONST_SGL(-0.58107730574765f / 8.0) },
-  { FL2FXCONST_SGL(-0.99969370862163f / 8.0), FL2FXCONST_SGL( 0.98369989360250f / 8.0) },
-  { FL2FXCONST_SGL( 0.55266258627194f / 8.0), FL2FXCONST_SGL( 0.59449057465591f / 8.0) },
-  { FL2FXCONST_SGL( 0.34581177741673f / 8.0), FL2FXCONST_SGL( 0.94879421061866f / 8.0) },
-  { FL2FXCONST_SGL( 0.62664209577999f / 8.0), FL2FXCONST_SGL(-0.74402970906471f / 8.0) },
-  { FL2FXCONST_SGL(-0.77149701404973f / 8.0), FL2FXCONST_SGL(-0.33883658042801f / 8.0) },
-  { FL2FXCONST_SGL(-0.91592244254432f / 8.0), FL2FXCONST_SGL( 0.03687901376713f / 8.0) },
-  { FL2FXCONST_SGL(-0.76285492357887f / 8.0), FL2FXCONST_SGL(-0.91371867919124f / 8.0) },
-  { FL2FXCONST_SGL( 0.79788337195331f / 8.0), FL2FXCONST_SGL(-0.93180971199849f / 8.0) },
-  { FL2FXCONST_SGL( 0.54473080610200f / 8.0), FL2FXCONST_SGL(-0.11919206037186f / 8.0) },
-  { FL2FXCONST_SGL(-0.85639281671058f / 8.0), FL2FXCONST_SGL( 0.42429854760451f / 8.0) },
-  { FL2FXCONST_SGL(-0.92882402971423f / 8.0), FL2FXCONST_SGL( 0.27871809078609f / 8.0) },
-  { FL2FXCONST_SGL(-0.11708371046774f / 8.0), FL2FXCONST_SGL(-0.99800843444966f / 8.0) },
-  { FL2FXCONST_SGL( 0.21356749817493f / 8.0), FL2FXCONST_SGL(-0.90716295627033f / 8.0) },
-  { FL2FXCONST_SGL(-0.76191692573909f / 8.0), FL2FXCONST_SGL( 0.99768118356265f / 8.0) },
-  { FL2FXCONST_SGL( 0.98111043100884f / 8.0), FL2FXCONST_SGL(-0.95854459734407f / 8.0) },
-  { FL2FXCONST_SGL(-0.85913269895572f / 8.0), FL2FXCONST_SGL( 0.95766566168880f / 8.0) },
-  { FL2FXCONST_SGL(-0.93307242253692f / 8.0), FL2FXCONST_SGL( 0.49431757696466f / 8.0) },
-  { FL2FXCONST_SGL( 0.30485754879632f / 8.0), FL2FXCONST_SGL(-0.70540034357529f / 8.0) },
-  { FL2FXCONST_SGL( 0.85289650925190f / 8.0), FL2FXCONST_SGL( 0.46766131791044f / 8.0) },
-  { FL2FXCONST_SGL( 0.91328082618125f / 8.0), FL2FXCONST_SGL(-0.99839597361769f / 8.0) },
-  { FL2FXCONST_SGL(-0.05890199924154f / 8.0), FL2FXCONST_SGL( 0.70741827819497f / 8.0) },
-  { FL2FXCONST_SGL( 0.28398686150148f / 8.0), FL2FXCONST_SGL( 0.34633555702188f / 8.0) },
-  { FL2FXCONST_SGL( 0.95258164539612f / 8.0), FL2FXCONST_SGL(-0.54893416026939f / 8.0) },
-  { FL2FXCONST_SGL(-0.78566324168507f / 8.0), FL2FXCONST_SGL(-0.75568541079691f / 8.0) },
-  { FL2FXCONST_SGL(-0.95789495447877f / 8.0), FL2FXCONST_SGL(-0.20423194696966f / 8.0) },
-  { FL2FXCONST_SGL( 0.82411158711197f / 8.0), FL2FXCONST_SGL( 0.96654618432562f / 8.0) },
-  { FL2FXCONST_SGL(-0.65185446735885f / 8.0), FL2FXCONST_SGL(-0.88734990773289f / 8.0) },
-  { FL2FXCONST_SGL(-0.93643603134666f / 8.0), FL2FXCONST_SGL( 0.99870790442385f / 8.0) },
-  { FL2FXCONST_SGL( 0.91427159529618f / 8.0), FL2FXCONST_SGL(-0.98290505544444f / 8.0) },
-  { FL2FXCONST_SGL(-0.70395684036886f / 8.0), FL2FXCONST_SGL( 0.58796798221039f / 8.0) },
-  { FL2FXCONST_SGL( 0.00563771969365f / 8.0), FL2FXCONST_SGL( 0.61768196727244f / 8.0) },
-  { FL2FXCONST_SGL( 0.89065051931895f / 8.0), FL2FXCONST_SGL( 0.52783352697585f / 8.0) },
-  { FL2FXCONST_SGL(-0.68683707712762f / 8.0), FL2FXCONST_SGL( 0.80806944710339f / 8.0) },
-  { FL2FXCONST_SGL( 0.72165342518718f / 8.0), FL2FXCONST_SGL(-0.69259857349564f / 8.0) },
-  { FL2FXCONST_SGL(-0.62928247730667f / 8.0), FL2FXCONST_SGL( 0.13627037407335f / 8.0) },
-  { FL2FXCONST_SGL( 0.29938434065514f / 8.0), FL2FXCONST_SGL(-0.46051329682246f / 8.0) },
-  { FL2FXCONST_SGL(-0.91781958879280f / 8.0), FL2FXCONST_SGL(-0.74012716684186f / 8.0) },
-  { FL2FXCONST_SGL( 0.99298717043688f / 8.0), FL2FXCONST_SGL( 0.40816610075661f / 8.0) },
-  { FL2FXCONST_SGL( 0.82368298622748f / 8.0), FL2FXCONST_SGL(-0.74036047190173f / 8.0) },
-  { FL2FXCONST_SGL(-0.98512833386833f / 8.0), FL2FXCONST_SGL(-0.99972330709594f / 8.0) },
-  { FL2FXCONST_SGL(-0.95915368242257f / 8.0), FL2FXCONST_SGL(-0.99237800466040f / 8.0) },
-  { FL2FXCONST_SGL(-0.21411126572790f / 8.0), FL2FXCONST_SGL(-0.93424819052545f / 8.0) },
-  { FL2FXCONST_SGL(-0.68821476106884f / 8.0), FL2FXCONST_SGL(-0.26892306315457f / 8.0) },
-  { FL2FXCONST_SGL( 0.91851997982317f / 8.0), FL2FXCONST_SGL( 0.09358228901785f / 8.0) },
-  { FL2FXCONST_SGL(-0.96062769559127f / 8.0), FL2FXCONST_SGL( 0.36099095133739f / 8.0) },
-  { FL2FXCONST_SGL( 0.51646184922287f / 8.0), FL2FXCONST_SGL(-0.71373332873917f / 8.0) },
-  { FL2FXCONST_SGL( 0.61130721139669f / 8.0), FL2FXCONST_SGL( 0.46950141175917f / 8.0) },
-  { FL2FXCONST_SGL( 0.47336129371299f / 8.0), FL2FXCONST_SGL(-0.27333178296162f / 8.0) },
-  { FL2FXCONST_SGL( 0.90998308703519f / 8.0), FL2FXCONST_SGL( 0.96715662938132f / 8.0) },
-  { FL2FXCONST_SGL( 0.44844799194357f / 8.0), FL2FXCONST_SGL( 0.99211574628306f / 8.0) },
-  { FL2FXCONST_SGL( 0.66614891079092f / 8.0), FL2FXCONST_SGL( 0.96590176169121f / 8.0) },
-  { FL2FXCONST_SGL( 0.74922239129237f / 8.0), FL2FXCONST_SGL(-0.89879858826087f / 8.0) },
-  { FL2FXCONST_SGL(-0.99571588506485f / 8.0), FL2FXCONST_SGL( 0.52785521494349f / 8.0) },
-  { FL2FXCONST_SGL( 0.97401082477563f / 8.0), FL2FXCONST_SGL(-0.16855870075190f / 8.0) },
-  { FL2FXCONST_SGL( 0.72683747733879f / 8.0), FL2FXCONST_SGL(-0.48060774432251f / 8.0) },
-  { FL2FXCONST_SGL( 0.95432193457128f / 8.0), FL2FXCONST_SGL( 0.68849603408441f / 8.0) },
-  { FL2FXCONST_SGL(-0.72962208425191f / 8.0), FL2FXCONST_SGL(-0.76608443420917f / 8.0) },
-  { FL2FXCONST_SGL(-0.85359479233537f / 8.0), FL2FXCONST_SGL( 0.88738125901579f / 8.0) },
-  { FL2FXCONST_SGL(-0.81412430338535f / 8.0), FL2FXCONST_SGL(-0.97480768049637f / 8.0) },
-  { FL2FXCONST_SGL(-0.87930772356786f / 8.0), FL2FXCONST_SGL( 0.74748307690436f / 8.0) },
-  { FL2FXCONST_SGL(-0.71573331064977f / 8.0), FL2FXCONST_SGL(-0.98570608178923f / 8.0) },
-  { FL2FXCONST_SGL( 0.83524300028228f / 8.0), FL2FXCONST_SGL( 0.83702537075163f / 8.0) },
-  { FL2FXCONST_SGL(-0.48086065601423f / 8.0), FL2FXCONST_SGL(-0.98848504923531f / 8.0) },
-  { FL2FXCONST_SGL( 0.97139128574778f / 8.0), FL2FXCONST_SGL( 0.80093621198236f / 8.0) },
-  { FL2FXCONST_SGL( 0.51992825347895f / 8.0), FL2FXCONST_SGL( 0.80247631400510f / 8.0) },
-  { FL2FXCONST_SGL(-0.00848591195325f / 8.0), FL2FXCONST_SGL(-0.76670128000486f / 8.0) },
-  { FL2FXCONST_SGL(-0.70294374303036f / 8.0), FL2FXCONST_SGL( 0.55359910445577f / 8.0) },
-  { FL2FXCONST_SGL(-0.95894428168140f / 8.0), FL2FXCONST_SGL(-0.43265504344783f / 8.0) },
-  { FL2FXCONST_SGL( 0.97079252950321f / 8.0), FL2FXCONST_SGL( 0.09325857238682f / 8.0) },
-  { FL2FXCONST_SGL(-0.92404293670797f / 8.0), FL2FXCONST_SGL( 0.85507704027855f / 8.0) },
-  { FL2FXCONST_SGL(-0.69506469500450f / 8.0), FL2FXCONST_SGL( 0.98633412625459f / 8.0) },
-  { FL2FXCONST_SGL( 0.26559203620024f / 8.0), FL2FXCONST_SGL( 0.73314307966524f / 8.0) },
-  { FL2FXCONST_SGL( 0.28038443336943f / 8.0), FL2FXCONST_SGL( 0.14537913654427f / 8.0) },
-  { FL2FXCONST_SGL(-0.74138124825523f / 8.0), FL2FXCONST_SGL( 0.99310339807762f / 8.0) },
-  { FL2FXCONST_SGL(-0.01752795995444f / 8.0), FL2FXCONST_SGL(-0.82616635284178f / 8.0) },
-  { FL2FXCONST_SGL(-0.55126773094930f / 8.0), FL2FXCONST_SGL(-0.98898543862153f / 8.0) },
-  { FL2FXCONST_SGL( 0.97960898850996f / 8.0), FL2FXCONST_SGL(-0.94021446752851f / 8.0) },
-  { FL2FXCONST_SGL(-0.99196309146936f / 8.0), FL2FXCONST_SGL( 0.67019017358456f / 8.0) },
-  { FL2FXCONST_SGL(-0.67684928085260f / 8.0), FL2FXCONST_SGL( 0.12631491649378f / 8.0) },
-  { FL2FXCONST_SGL( 0.09140039465500f / 8.0), FL2FXCONST_SGL(-0.20537731453108f / 8.0) },
-  { FL2FXCONST_SGL(-0.71658965751996f / 8.0), FL2FXCONST_SGL(-0.97788200391224f / 8.0) },
-  { FL2FXCONST_SGL( 0.81014640078925f / 8.0), FL2FXCONST_SGL( 0.53722648362443f / 8.0) },
-  { FL2FXCONST_SGL( 0.40616991671205f / 8.0), FL2FXCONST_SGL(-0.26469008598449f / 8.0) },
-  { FL2FXCONST_SGL(-0.67680188682972f / 8.0), FL2FXCONST_SGL( 0.94502052337695f / 8.0) },
-  { FL2FXCONST_SGL( 0.86849774348749f / 8.0), FL2FXCONST_SGL(-0.18333598647899f / 8.0) },
-  { FL2FXCONST_SGL(-0.99500381284851f / 8.0), FL2FXCONST_SGL(-0.02634122068550f / 8.0) },
-  { FL2FXCONST_SGL( 0.84329189340667f / 8.0), FL2FXCONST_SGL( 0.10406957462213f / 8.0) },
-  { FL2FXCONST_SGL(-0.09215968531446f / 8.0), FL2FXCONST_SGL( 0.69540012101253f / 8.0) },
-  { FL2FXCONST_SGL( 0.99956173327206f / 8.0), FL2FXCONST_SGL(-0.12358542001404f / 8.0) },
-  { FL2FXCONST_SGL(-0.79732779473535f / 8.0), FL2FXCONST_SGL(-0.91582524736159f / 8.0) },
-  { FL2FXCONST_SGL( 0.96349973642406f / 8.0), FL2FXCONST_SGL( 0.96640458041000f / 8.0) },
-  { FL2FXCONST_SGL(-0.79942778496547f / 8.0), FL2FXCONST_SGL( 0.64323902822857f / 8.0) },
-  { FL2FXCONST_SGL(-0.11566039853896f / 8.0), FL2FXCONST_SGL( 0.28587846253726f / 8.0) },
-  { FL2FXCONST_SGL(-0.39922954514662f / 8.0), FL2FXCONST_SGL( 0.94129601616966f / 8.0) },
-  { FL2FXCONST_SGL( 0.99089197565987f / 8.0), FL2FXCONST_SGL(-0.92062625581587f / 8.0) },
-  { FL2FXCONST_SGL( 0.28631285179909f / 8.0), FL2FXCONST_SGL(-0.91035047143603f / 8.0) },
-  { FL2FXCONST_SGL(-0.83302725605608f / 8.0), FL2FXCONST_SGL(-0.67330410892084f / 8.0) },
-  { FL2FXCONST_SGL( 0.95404443402072f / 8.0), FL2FXCONST_SGL( 0.49162765398743f / 8.0) },
-  { FL2FXCONST_SGL(-0.06449863579434f / 8.0), FL2FXCONST_SGL( 0.03250560813135f / 8.0) },
-  { FL2FXCONST_SGL(-0.99575054486311f / 8.0), FL2FXCONST_SGL( 0.42389784469507f / 8.0) },
-  { FL2FXCONST_SGL(-0.65501142790847f / 8.0), FL2FXCONST_SGL( 0.82546114655624f / 8.0) },
-  { FL2FXCONST_SGL(-0.81254441908887f / 8.0), FL2FXCONST_SGL(-0.51627234660629f / 8.0) },
-  { FL2FXCONST_SGL(-0.99646369485481f / 8.0), FL2FXCONST_SGL( 0.84490533520752f / 8.0) },
-  { FL2FXCONST_SGL( 0.00287840603348f / 8.0), FL2FXCONST_SGL( 0.64768261158166f / 8.0) },
-  { FL2FXCONST_SGL( 0.70176989408455f / 8.0), FL2FXCONST_SGL(-0.20453028573322f / 8.0) },
-  { FL2FXCONST_SGL( 0.96361882270190f / 8.0), FL2FXCONST_SGL( 0.40706967140989f / 8.0) },
-  { FL2FXCONST_SGL(-0.68883758192426f / 8.0), FL2FXCONST_SGL( 0.91338958840772f / 8.0) },
-  { FL2FXCONST_SGL(-0.34875585502238f / 8.0), FL2FXCONST_SGL( 0.71472290693300f / 8.0) },
-  { FL2FXCONST_SGL( 0.91980081243087f / 8.0), FL2FXCONST_SGL( 0.66507455644919f / 8.0) },
-  { FL2FXCONST_SGL(-0.99009048343881f / 8.0), FL2FXCONST_SGL( 0.85868021604848f / 8.0) },
-  { FL2FXCONST_SGL( 0.68865791458395f / 8.0), FL2FXCONST_SGL( 0.55660316809678f / 8.0) },
-  { FL2FXCONST_SGL(-0.99484402129368f / 8.0), FL2FXCONST_SGL(-0.20052559254934f / 8.0) },
-  { FL2FXCONST_SGL( 0.94214511408023f / 8.0), FL2FXCONST_SGL(-0.99696425367461f / 8.0) },
-  { FL2FXCONST_SGL(-0.67414626793544f / 8.0), FL2FXCONST_SGL( 0.49548221180078f / 8.0) },
-  { FL2FXCONST_SGL(-0.47339353684664f / 8.0), FL2FXCONST_SGL(-0.85904328834047f / 8.0) },
-  { FL2FXCONST_SGL( 0.14323651387360f / 8.0), FL2FXCONST_SGL(-0.94145598222488f / 8.0) },
-  { FL2FXCONST_SGL(-0.29268293575672f / 8.0), FL2FXCONST_SGL( 0.05759224927952f / 8.0) },
-  { FL2FXCONST_SGL( 0.43793861458754f / 8.0), FL2FXCONST_SGL(-0.78904969892724f / 8.0) },
-  { FL2FXCONST_SGL(-0.36345126374441f / 8.0), FL2FXCONST_SGL( 0.64874435357162f / 8.0) },
-  { FL2FXCONST_SGL(-0.08750604656825f / 8.0), FL2FXCONST_SGL( 0.97686944362527f / 8.0) },
-  { FL2FXCONST_SGL(-0.96495267812511f / 8.0), FL2FXCONST_SGL(-0.53960305946511f / 8.0) },
-  { FL2FXCONST_SGL( 0.55526940659947f / 8.0), FL2FXCONST_SGL( 0.78891523734774f / 8.0) },
-  { FL2FXCONST_SGL( 0.73538215752630f / 8.0), FL2FXCONST_SGL( 0.96452072373404f / 8.0) },
-  { FL2FXCONST_SGL(-0.30889773919437f / 8.0), FL2FXCONST_SGL(-0.80664389776860f / 8.0) },
-  { FL2FXCONST_SGL( 0.03574995626194f / 8.0), FL2FXCONST_SGL(-0.97325616900959f / 8.0) },
-  { FL2FXCONST_SGL( 0.98720684660488f / 8.0), FL2FXCONST_SGL( 0.48409133691962f / 8.0) },
-  { FL2FXCONST_SGL(-0.81689296271203f / 8.0), FL2FXCONST_SGL(-0.90827703628298f / 8.0) },
-  { FL2FXCONST_SGL( 0.67866860118215f / 8.0), FL2FXCONST_SGL( 0.81284503870856f / 8.0) },
-  { FL2FXCONST_SGL(-0.15808569732583f / 8.0), FL2FXCONST_SGL( 0.85279555024382f / 8.0) },
-  { FL2FXCONST_SGL( 0.80723395114371f / 8.0), FL2FXCONST_SGL(-0.24717418514605f / 8.0) },
-  { FL2FXCONST_SGL( 0.47788757329038f / 8.0), FL2FXCONST_SGL(-0.46333147839295f / 8.0) },
-  { FL2FXCONST_SGL( 0.96367554763201f / 8.0), FL2FXCONST_SGL( 0.38486749303242f / 8.0) },
-  { FL2FXCONST_SGL(-0.99143875716818f / 8.0), FL2FXCONST_SGL(-0.24945277239809f / 8.0) },
-  { FL2FXCONST_SGL( 0.83081876925833f / 8.0), FL2FXCONST_SGL(-0.94780851414763f / 8.0) },
-  { FL2FXCONST_SGL(-0.58753191905341f / 8.0), FL2FXCONST_SGL( 0.01290772389163f / 8.0) },
-  { FL2FXCONST_SGL( 0.95538108220960f / 8.0), FL2FXCONST_SGL(-0.85557052096538f / 8.0) },
-  { FL2FXCONST_SGL(-0.96490920476211f / 8.0), FL2FXCONST_SGL(-0.64020970923102f / 8.0) },
-  { FL2FXCONST_SGL(-0.97327101028521f / 8.0), FL2FXCONST_SGL( 0.12378128133110f / 8.0) },
-  { FL2FXCONST_SGL( 0.91400366022124f / 8.0), FL2FXCONST_SGL( 0.57972471346930f / 8.0) },
-  { FL2FXCONST_SGL(-0.99925837363824f / 8.0), FL2FXCONST_SGL( 0.71084847864067f / 8.0) },
-  { FL2FXCONST_SGL(-0.86875903507313f / 8.0), FL2FXCONST_SGL(-0.20291699203564f / 8.0) },
-  { FL2FXCONST_SGL(-0.26240034795124f / 8.0), FL2FXCONST_SGL(-0.68264554369108f / 8.0) },
-  { FL2FXCONST_SGL(-0.24664412953388f / 8.0), FL2FXCONST_SGL(-0.87642273115183f / 8.0) },
-  { FL2FXCONST_SGL( 0.02416275806869f / 8.0), FL2FXCONST_SGL( 0.27192914288905f / 8.0) },
-  { FL2FXCONST_SGL( 0.82068619590515f / 8.0), FL2FXCONST_SGL(-0.85087787994476f / 8.0) },
-  { FL2FXCONST_SGL( 0.88547373760759f / 8.0), FL2FXCONST_SGL(-0.89636802901469f / 8.0) },
-  { FL2FXCONST_SGL(-0.18173078152226f / 8.0), FL2FXCONST_SGL(-0.26152145156800f / 8.0) },
-  { FL2FXCONST_SGL( 0.09355476558534f / 8.0), FL2FXCONST_SGL( 0.54845123045604f / 8.0) },
-  { FL2FXCONST_SGL(-0.54668414224090f / 8.0), FL2FXCONST_SGL( 0.95980774020221f / 8.0) },
-  { FL2FXCONST_SGL( 0.37050990604091f / 8.0), FL2FXCONST_SGL(-0.59910140383171f / 8.0) },
-  { FL2FXCONST_SGL(-0.70373594262891f / 8.0), FL2FXCONST_SGL( 0.91227665827081f / 8.0) },
-  { FL2FXCONST_SGL(-0.34600785879594f / 8.0), FL2FXCONST_SGL(-0.99441426144200f / 8.0) },
-  { FL2FXCONST_SGL(-0.68774481731008f / 8.0), FL2FXCONST_SGL(-0.30238837956299f / 8.0) },
-  { FL2FXCONST_SGL(-0.26843291251234f / 8.0), FL2FXCONST_SGL( 0.83115668004362f / 8.0) },
-  { FL2FXCONST_SGL( 0.49072334613242f / 8.0), FL2FXCONST_SGL(-0.45359708737775f / 8.0) },
-  { FL2FXCONST_SGL( 0.38975993093975f / 8.0), FL2FXCONST_SGL( 0.95515358099121f / 8.0) },
-  { FL2FXCONST_SGL(-0.97757125224150f / 8.0), FL2FXCONST_SGL( 0.05305894580606f / 8.0) },
-  { FL2FXCONST_SGL(-0.17325552859616f / 8.0), FL2FXCONST_SGL(-0.92770672250494f / 8.0) },
-  { FL2FXCONST_SGL( 0.99948035025744f / 8.0), FL2FXCONST_SGL( 0.58285545563426f / 8.0) },
-  { FL2FXCONST_SGL(-0.64946246527458f / 8.0), FL2FXCONST_SGL( 0.68645507104960f / 8.0) },
-  { FL2FXCONST_SGL(-0.12016920576437f / 8.0), FL2FXCONST_SGL(-0.57147322153312f / 8.0) },
-  { FL2FXCONST_SGL(-0.58947456517751f / 8.0), FL2FXCONST_SGL(-0.34847132454388f / 8.0) },
-  { FL2FXCONST_SGL(-0.41815140454465f / 8.0), FL2FXCONST_SGL( 0.16276422358861f / 8.0) },
-  { FL2FXCONST_SGL( 0.99885650204884f / 8.0), FL2FXCONST_SGL( 0.11136095490444f / 8.0) },
-  { FL2FXCONST_SGL(-0.56649614128386f / 8.0), FL2FXCONST_SGL(-0.90494866361587f / 8.0) },
-  { FL2FXCONST_SGL( 0.94138021032330f / 8.0), FL2FXCONST_SGL( 0.35281916733018f / 8.0) },
-  { FL2FXCONST_SGL(-0.75725076534641f / 8.0), FL2FXCONST_SGL( 0.53650549640587f / 8.0) },
-  { FL2FXCONST_SGL( 0.20541973692630f / 8.0), FL2FXCONST_SGL(-0.94435144369918f / 8.0) },
-  { FL2FXCONST_SGL( 0.99980371023351f / 8.0), FL2FXCONST_SGL( 0.79835913565599f / 8.0) },
-  { FL2FXCONST_SGL( 0.29078277605775f / 8.0), FL2FXCONST_SGL( 0.35393777921520f / 8.0) },
-  { FL2FXCONST_SGL(-0.62858772103030f / 8.0), FL2FXCONST_SGL( 0.38765693387102f / 8.0) },
-  { FL2FXCONST_SGL( 0.43440904467688f / 8.0), FL2FXCONST_SGL(-0.98546330463232f / 8.0) },
-  { FL2FXCONST_SGL(-0.98298583762390f / 8.0), FL2FXCONST_SGL( 0.21021524625209f / 8.0) },
-  { FL2FXCONST_SGL( 0.19513029146934f / 8.0), FL2FXCONST_SGL(-0.94239832251867f / 8.0) },
-  { FL2FXCONST_SGL(-0.95476662400101f / 8.0), FL2FXCONST_SGL( 0.98364554179143f / 8.0) },
-  { FL2FXCONST_SGL( 0.93379635304810f / 8.0), FL2FXCONST_SGL(-0.70881994583682f / 8.0) },
-  { FL2FXCONST_SGL(-0.85235410573336f / 8.0), FL2FXCONST_SGL(-0.08342347966410f / 8.0) },
-  { FL2FXCONST_SGL(-0.86425093011245f / 8.0), FL2FXCONST_SGL(-0.45795025029466f / 8.0) },
-  { FL2FXCONST_SGL( 0.38879779059045f / 8.0), FL2FXCONST_SGL( 0.97274429344593f / 8.0) },
-  { FL2FXCONST_SGL( 0.92045124735495f / 8.0), FL2FXCONST_SGL(-0.62433652524220f / 8.0) },
-  { FL2FXCONST_SGL( 0.89162532251878f / 8.0), FL2FXCONST_SGL( 0.54950955570563f / 8.0) },
-  { FL2FXCONST_SGL(-0.36834336949252f / 8.0), FL2FXCONST_SGL( 0.96458298020975f / 8.0) },
-  { FL2FXCONST_SGL( 0.93891760988045f / 8.0), FL2FXCONST_SGL(-0.89968353740388f / 8.0) },
-  { FL2FXCONST_SGL( 0.99267657565094f / 8.0), FL2FXCONST_SGL(-0.03757034316958f / 8.0) },
-  { FL2FXCONST_SGL(-0.94063471614176f / 8.0), FL2FXCONST_SGL( 0.41332338538963f / 8.0) },
-  { FL2FXCONST_SGL( 0.99740224117019f / 8.0), FL2FXCONST_SGL(-0.16830494996370f / 8.0) },
-  { FL2FXCONST_SGL(-0.35899413170555f / 8.0), FL2FXCONST_SGL(-0.46633226649613f / 8.0) },
-  { FL2FXCONST_SGL( 0.05237237274947f / 8.0), FL2FXCONST_SGL(-0.25640361602661f / 8.0) },
-  { FL2FXCONST_SGL( 0.36703583957424f / 8.0), FL2FXCONST_SGL(-0.38653265641875f / 8.0) },
-  { FL2FXCONST_SGL( 0.91653180367913f / 8.0), FL2FXCONST_SGL(-0.30587628726597f / 8.0) },
-  { FL2FXCONST_SGL( 0.69000803499316f / 8.0), FL2FXCONST_SGL( 0.90952171386132f / 8.0) },
-  { FL2FXCONST_SGL(-0.38658751133527f / 8.0), FL2FXCONST_SGL( 0.99501571208985f / 8.0) },
-  { FL2FXCONST_SGL(-0.29250814029851f / 8.0), FL2FXCONST_SGL( 0.37444994344615f / 8.0) },
-  { FL2FXCONST_SGL(-0.60182204677608f / 8.0), FL2FXCONST_SGL( 0.86779651036123f / 8.0) },
-  { FL2FXCONST_SGL(-0.97418588163217f / 8.0), FL2FXCONST_SGL( 0.96468523666475f / 8.0) },
-  { FL2FXCONST_SGL( 0.88461574003963f / 8.0), FL2FXCONST_SGL( 0.57508405276414f / 8.0) },
-  { FL2FXCONST_SGL( 0.05198933055162f / 8.0), FL2FXCONST_SGL( 0.21269661669964f / 8.0) },
-  { FL2FXCONST_SGL(-0.53499621979720f / 8.0), FL2FXCONST_SGL( 0.97241553731237f / 8.0) },
-  { FL2FXCONST_SGL(-0.49429560226497f / 8.0), FL2FXCONST_SGL( 0.98183865291903f / 8.0) },
-  { FL2FXCONST_SGL(-0.98935142339139f / 8.0), FL2FXCONST_SGL(-0.40249159006933f / 8.0) },
-  { FL2FXCONST_SGL(-0.98081380091130f / 8.0), FL2FXCONST_SGL(-0.72856895534041f / 8.0) },
-  { FL2FXCONST_SGL(-0.27338148835532f / 8.0), FL2FXCONST_SGL( 0.99950922447209f / 8.0) },
-  { FL2FXCONST_SGL( 0.06310802338302f / 8.0), FL2FXCONST_SGL(-0.54539587529618f / 8.0) },
-  { FL2FXCONST_SGL(-0.20461677199539f / 8.0), FL2FXCONST_SGL(-0.14209977628489f / 8.0) },
-  { FL2FXCONST_SGL( 0.66223843141647f / 8.0), FL2FXCONST_SGL( 0.72528579940326f / 8.0) },
-  { FL2FXCONST_SGL(-0.84764345483665f / 8.0), FL2FXCONST_SGL( 0.02372316801261f / 8.0) },
-  { FL2FXCONST_SGL(-0.89039863483811f / 8.0), FL2FXCONST_SGL( 0.88866581484602f / 8.0) },
-  { FL2FXCONST_SGL( 0.95903308477986f / 8.0), FL2FXCONST_SGL( 0.76744927173873f / 8.0) },
-  { FL2FXCONST_SGL( 0.73504123909879f / 8.0), FL2FXCONST_SGL(-0.03747203173192f / 8.0) },
-  { FL2FXCONST_SGL(-0.31744434966056f / 8.0), FL2FXCONST_SGL(-0.36834111883652f / 8.0) },
-  { FL2FXCONST_SGL(-0.34110827591623f / 8.0), FL2FXCONST_SGL( 0.40211222807691f / 8.0) },
-  { FL2FXCONST_SGL( 0.47803883714199f / 8.0), FL2FXCONST_SGL(-0.39423219786288f / 8.0) },
-  { FL2FXCONST_SGL( 0.98299195879514f / 8.0), FL2FXCONST_SGL( 0.01989791390047f / 8.0) },
-  { FL2FXCONST_SGL(-0.30963073129751f / 8.0), FL2FXCONST_SGL(-0.18076720599336f / 8.0) },
-  { FL2FXCONST_SGL( 0.99992588229018f / 8.0), FL2FXCONST_SGL(-0.26281872094289f / 8.0) },
-  { FL2FXCONST_SGL(-0.93149731080767f / 8.0), FL2FXCONST_SGL(-0.98313162570490f / 8.0) },
-  { FL2FXCONST_SGL( 0.99923472302773f / 8.0), FL2FXCONST_SGL(-0.80142993767554f / 8.0) },
-  { FL2FXCONST_SGL(-0.26024169633417f / 8.0), FL2FXCONST_SGL(-0.75999759855752f / 8.0) },
-  { FL2FXCONST_SGL(-0.35712514743563f / 8.0), FL2FXCONST_SGL( 0.19298963768574f / 8.0) },
-  { FL2FXCONST_SGL(-0.99899084509530f / 8.0), FL2FXCONST_SGL( 0.74645156992493f / 8.0) },
-  { FL2FXCONST_SGL( 0.86557171579452f / 8.0), FL2FXCONST_SGL( 0.55593866696299f / 8.0) },
-  { FL2FXCONST_SGL( 0.33408042438752f / 8.0), FL2FXCONST_SGL( 0.86185953874709f / 8.0) },
-  { FL2FXCONST_SGL( 0.99010736374716f / 8.0), FL2FXCONST_SGL( 0.04602397576623f / 8.0) },
-  { FL2FXCONST_SGL(-0.66694269691195f / 8.0), FL2FXCONST_SGL(-0.91643611810148f / 8.0) },
-  { FL2FXCONST_SGL( 0.64016792079480f / 8.0), FL2FXCONST_SGL( 0.15649530836856f / 8.0) },
-  { FL2FXCONST_SGL( 0.99570534804836f / 8.0), FL2FXCONST_SGL( 0.45844586038111f / 8.0) },
-  { FL2FXCONST_SGL(-0.63431466947340f / 8.0), FL2FXCONST_SGL( 0.21079116459234f / 8.0) },
-  { FL2FXCONST_SGL(-0.07706847005931f / 8.0), FL2FXCONST_SGL(-0.89581437101329f / 8.0) },
-  { FL2FXCONST_SGL( 0.98590090577724f / 8.0), FL2FXCONST_SGL( 0.88241721133981f / 8.0) },
-  { FL2FXCONST_SGL( 0.80099335254678f / 8.0), FL2FXCONST_SGL(-0.36851896710853f / 8.0) },
-  { FL2FXCONST_SGL( 0.78368131392666f / 8.0), FL2FXCONST_SGL( 0.45506999802597f / 8.0) },
-  { FL2FXCONST_SGL( 0.08707806671691f / 8.0), FL2FXCONST_SGL( 0.80938994918745f / 8.0) },
-  { FL2FXCONST_SGL(-0.86811883080712f / 8.0), FL2FXCONST_SGL( 0.39347308654705f / 8.0) },
-  { FL2FXCONST_SGL(-0.39466529740375f / 8.0), FL2FXCONST_SGL(-0.66809432114456f / 8.0) },
-  { FL2FXCONST_SGL( 0.97875325649683f / 8.0), FL2FXCONST_SGL(-0.72467840967746f / 8.0) },
-  { FL2FXCONST_SGL(-0.95038560288864f / 8.0), FL2FXCONST_SGL( 0.89563219587625f / 8.0) },
-  { FL2FXCONST_SGL( 0.17005239424212f / 8.0), FL2FXCONST_SGL( 0.54683053962658f / 8.0) },
-  { FL2FXCONST_SGL(-0.76910792026848f / 8.0), FL2FXCONST_SGL(-0.96226617549298f / 8.0) },
-  { FL2FXCONST_SGL( 0.99743281016846f / 8.0), FL2FXCONST_SGL( 0.42697157037567f / 8.0) },
-  { FL2FXCONST_SGL( 0.95437383549973f / 8.0), FL2FXCONST_SGL( 0.97002324109952f / 8.0) },
-  { FL2FXCONST_SGL( 0.99578905365569f / 8.0), FL2FXCONST_SGL(-0.54106826257356f / 8.0) },
-  { FL2FXCONST_SGL( 0.28058259829990f / 8.0), FL2FXCONST_SGL(-0.85361420634036f / 8.0) },
-  { FL2FXCONST_SGL( 0.85256524470573f / 8.0), FL2FXCONST_SGL(-0.64567607735589f / 8.0) },
-  { FL2FXCONST_SGL(-0.50608540105128f / 8.0), FL2FXCONST_SGL(-0.65846015480300f / 8.0) },
-  { FL2FXCONST_SGL(-0.97210735183243f / 8.0), FL2FXCONST_SGL(-0.23095213067791f / 8.0) },
-  { FL2FXCONST_SGL( 0.95424048234441f / 8.0), FL2FXCONST_SGL(-0.99240147091219f / 8.0) },
-  { FL2FXCONST_SGL(-0.96926570524023f / 8.0), FL2FXCONST_SGL( 0.73775654896574f / 8.0) },
-  { FL2FXCONST_SGL( 0.30872163214726f / 8.0), FL2FXCONST_SGL( 0.41514960556126f / 8.0) },
-  { FL2FXCONST_SGL(-0.24523839572639f / 8.0), FL2FXCONST_SGL( 0.63206633394807f / 8.0) },
-  { FL2FXCONST_SGL(-0.33813265086024f / 8.0), FL2FXCONST_SGL(-0.38661779441897f / 8.0) },
-  { FL2FXCONST_SGL(-0.05826828420146f / 8.0), FL2FXCONST_SGL(-0.06940774188029f / 8.0) },
-  { FL2FXCONST_SGL(-0.22898461455054f / 8.0), FL2FXCONST_SGL( 0.97054853316316f / 8.0) },
-  { FL2FXCONST_SGL(-0.18509915019881f / 8.0), FL2FXCONST_SGL( 0.47565762892084f / 8.0) },
-  { FL2FXCONST_SGL(-0.10488238045009f / 8.0), FL2FXCONST_SGL(-0.87769947402394f / 8.0) },
-  { FL2FXCONST_SGL(-0.71886586182037f / 8.0), FL2FXCONST_SGL( 0.78030982480538f / 8.0) },
-  { FL2FXCONST_SGL( 0.99793873738654f / 8.0), FL2FXCONST_SGL( 0.90041310491497f / 8.0) },
-  { FL2FXCONST_SGL( 0.57563307626120f / 8.0), FL2FXCONST_SGL(-0.91034337352097f / 8.0) },
-  { FL2FXCONST_SGL( 0.28909646383717f / 8.0), FL2FXCONST_SGL( 0.96307783970534f / 8.0) },
-  { FL2FXCONST_SGL( 0.42188998312520f / 8.0), FL2FXCONST_SGL( 0.48148651230437f / 8.0) },
-  { FL2FXCONST_SGL( 0.93335049681047f / 8.0), FL2FXCONST_SGL(-0.43537023883588f / 8.0) },
-  { FL2FXCONST_SGL(-0.97087374418267f / 8.0), FL2FXCONST_SGL( 0.86636445711364f / 8.0) },
-  { FL2FXCONST_SGL( 0.36722871286923f / 8.0), FL2FXCONST_SGL( 0.65291654172961f / 8.0) },
-  { FL2FXCONST_SGL(-0.81093025665696f / 8.0), FL2FXCONST_SGL( 0.08778370229363f / 8.0) },
-  { FL2FXCONST_SGL(-0.26240603062237f / 8.0), FL2FXCONST_SGL(-0.92774095379098f / 8.0) },
-  { FL2FXCONST_SGL( 0.83996497984604f / 8.0), FL2FXCONST_SGL( 0.55839849139647f / 8.0) },
-  { FL2FXCONST_SGL(-0.99909615720225f / 8.0), FL2FXCONST_SGL(-0.96024605713970f / 8.0) },
-  { FL2FXCONST_SGL( 0.74649464155061f / 8.0), FL2FXCONST_SGL( 0.12144893606462f / 8.0) },
-  { FL2FXCONST_SGL(-0.74774595569805f / 8.0), FL2FXCONST_SGL(-0.26898062008959f / 8.0) },
-  { FL2FXCONST_SGL( 0.95781667469567f / 8.0), FL2FXCONST_SGL(-0.79047927052628f / 8.0) },
-  { FL2FXCONST_SGL( 0.95472308713099f / 8.0), FL2FXCONST_SGL(-0.08588776019550f / 8.0) },
-  { FL2FXCONST_SGL( 0.48708332746299f / 8.0), FL2FXCONST_SGL( 0.99999041579432f / 8.0) },
-  { FL2FXCONST_SGL( 0.46332038247497f / 8.0), FL2FXCONST_SGL( 0.10964126185063f / 8.0) },
-  { FL2FXCONST_SGL(-0.76497004940162f / 8.0), FL2FXCONST_SGL( 0.89210929242238f / 8.0) },
-  { FL2FXCONST_SGL( 0.57397389364339f / 8.0), FL2FXCONST_SGL( 0.35289703373760f / 8.0) },
-  { FL2FXCONST_SGL( 0.75374316974495f / 8.0), FL2FXCONST_SGL( 0.96705214651335f / 8.0) },
-  { FL2FXCONST_SGL(-0.59174397685714f / 8.0), FL2FXCONST_SGL(-0.89405370422752f / 8.0) },
-  { FL2FXCONST_SGL( 0.75087906691890f / 8.0), FL2FXCONST_SGL(-0.29612672982396f / 8.0) },
-  { FL2FXCONST_SGL(-0.98607857336230f / 8.0), FL2FXCONST_SGL( 0.25034911730023f / 8.0) },
-  { FL2FXCONST_SGL(-0.40761056640505f / 8.0), FL2FXCONST_SGL(-0.90045573444695f / 8.0) },
-  { FL2FXCONST_SGL( 0.66929266740477f / 8.0), FL2FXCONST_SGL( 0.98629493401748f / 8.0) },
-  { FL2FXCONST_SGL(-0.97463695257310f / 8.0), FL2FXCONST_SGL(-0.00190223301301f / 8.0) },
-  { FL2FXCONST_SGL( 0.90145509409859f / 8.0), FL2FXCONST_SGL( 0.99781390365446f / 8.0) },
-  { FL2FXCONST_SGL(-0.87259289048043f / 8.0), FL2FXCONST_SGL( 0.99233587353666f / 8.0) },
-  { FL2FXCONST_SGL(-0.91529461447692f / 8.0), FL2FXCONST_SGL(-0.15698707534206f / 8.0) },
-  { FL2FXCONST_SGL(-0.03305738840705f / 8.0), FL2FXCONST_SGL(-0.37205262859764f / 8.0) },
-  { FL2FXCONST_SGL( 0.07223051368337f / 8.0), FL2FXCONST_SGL(-0.88805001733626f / 8.0) },
-  { FL2FXCONST_SGL( 0.99498012188353f / 8.0), FL2FXCONST_SGL( 0.97094358113387f / 8.0) },
-  { FL2FXCONST_SGL(-0.74904939500519f / 8.0), FL2FXCONST_SGL( 0.99985483641521f / 8.0) },
-  { FL2FXCONST_SGL( 0.04585228574211f / 8.0), FL2FXCONST_SGL( 0.99812337444082f / 8.0) },
-  { FL2FXCONST_SGL(-0.89054954257993f / 8.0), FL2FXCONST_SGL(-0.31791913188064f / 8.0) },
-  { FL2FXCONST_SGL(-0.83782144651251f / 8.0), FL2FXCONST_SGL( 0.97637632547466f / 8.0) },
-  { FL2FXCONST_SGL( 0.33454804933804f / 8.0), FL2FXCONST_SGL(-0.86231516800408f / 8.0) },
-  { FL2FXCONST_SGL(-0.99707579362824f / 8.0), FL2FXCONST_SGL( 0.93237990079441f / 8.0) },
-  { FL2FXCONST_SGL(-0.22827527843994f / 8.0), FL2FXCONST_SGL( 0.18874759397997f / 8.0) },
-  { FL2FXCONST_SGL( 0.67248046289143f / 8.0), FL2FXCONST_SGL(-0.03646211390569f / 8.0) },
-  { FL2FXCONST_SGL(-0.05146538187944f / 8.0), FL2FXCONST_SGL(-0.92599700120679f / 8.0) },
-  { FL2FXCONST_SGL( 0.99947295749905f / 8.0), FL2FXCONST_SGL( 0.93625229707912f / 8.0) },
-  { FL2FXCONST_SGL( 0.66951124390363f / 8.0), FL2FXCONST_SGL( 0.98905825623893f / 8.0) },
-  { FL2FXCONST_SGL(-0.99602956559179f / 8.0), FL2FXCONST_SGL(-0.44654715757688f / 8.0) },
-  { FL2FXCONST_SGL( 0.82104905483590f / 8.0), FL2FXCONST_SGL( 0.99540741724928f / 8.0) },
-  { FL2FXCONST_SGL( 0.99186510988782f / 8.0), FL2FXCONST_SGL( 0.72023001312947f / 8.0) },
-  { FL2FXCONST_SGL(-0.65284592392918f / 8.0), FL2FXCONST_SGL( 0.52186723253637f / 8.0) },
-  { FL2FXCONST_SGL( 0.93885443798188f / 8.0), FL2FXCONST_SGL(-0.74895312615259f / 8.0) },
-  { FL2FXCONST_SGL( 0.96735248738388f / 8.0), FL2FXCONST_SGL( 0.90891816978629f / 8.0) },
-  { FL2FXCONST_SGL(-0.22225968841114f / 8.0), FL2FXCONST_SGL( 0.57124029781228f / 8.0) },
-  { FL2FXCONST_SGL(-0.44132783753414f / 8.0), FL2FXCONST_SGL(-0.92688840659280f / 8.0) },
-  { FL2FXCONST_SGL(-0.85694974219574f / 8.0), FL2FXCONST_SGL( 0.88844532719844f / 8.0) },
-  { FL2FXCONST_SGL( 0.91783042091762f / 8.0), FL2FXCONST_SGL(-0.46356892383970f / 8.0) },
-  { FL2FXCONST_SGL( 0.72556974415690f / 8.0), FL2FXCONST_SGL(-0.99899555770747f / 8.0) },
-  { FL2FXCONST_SGL(-0.99711581834508f / 8.0), FL2FXCONST_SGL( 0.58211560180426f / 8.0) },
-  { FL2FXCONST_SGL( 0.77638976371966f / 8.0), FL2FXCONST_SGL( 0.94321834873819f / 8.0) },
-  { FL2FXCONST_SGL( 0.07717324253925f / 8.0), FL2FXCONST_SGL( 0.58638399856595f / 8.0) },
-  { FL2FXCONST_SGL(-0.56049829194163f / 8.0), FL2FXCONST_SGL( 0.82522301569036f / 8.0) },
-  { FL2FXCONST_SGL( 0.98398893639988f / 8.0), FL2FXCONST_SGL( 0.39467440420569f / 8.0) },
-  { FL2FXCONST_SGL( 0.47546946844938f / 8.0), FL2FXCONST_SGL( 0.68613044836811f / 8.0) },
-  { FL2FXCONST_SGL( 0.65675089314631f / 8.0), FL2FXCONST_SGL( 0.18331637134880f / 8.0) },
-  { FL2FXCONST_SGL( 0.03273375457980f / 8.0), FL2FXCONST_SGL(-0.74933109564108f / 8.0) },
-  { FL2FXCONST_SGL(-0.38684144784738f / 8.0), FL2FXCONST_SGL( 0.51337349030406f / 8.0) },
-  { FL2FXCONST_SGL(-0.97346267944545f / 8.0), FL2FXCONST_SGL(-0.96549364384098f / 8.0) },
-  { FL2FXCONST_SGL(-0.53282156061942f / 8.0), FL2FXCONST_SGL(-0.91423265091354f / 8.0) },
-  { FL2FXCONST_SGL( 0.99817310731176f / 8.0), FL2FXCONST_SGL( 0.61133572482148f / 8.0) },
-  { FL2FXCONST_SGL(-0.50254500772635f / 8.0), FL2FXCONST_SGL(-0.88829338134294f / 8.0) },
-  { FL2FXCONST_SGL( 0.01995873238855f / 8.0), FL2FXCONST_SGL( 0.85223515096765f / 8.0) },
-  { FL2FXCONST_SGL( 0.99930381973804f / 8.0), FL2FXCONST_SGL( 0.94578896296649f / 8.0) },
-  { FL2FXCONST_SGL( 0.82907767600783f / 8.0), FL2FXCONST_SGL(-0.06323442598128f / 8.0) },
-  { FL2FXCONST_SGL(-0.58660709669728f / 8.0), FL2FXCONST_SGL( 0.96840773806582f / 8.0) },
-  { FL2FXCONST_SGL(-0.17573736667267f / 8.0), FL2FXCONST_SGL(-0.48166920859485f / 8.0) },
-  { FL2FXCONST_SGL( 0.83434292401346f / 8.0), FL2FXCONST_SGL(-0.13023450646997f / 8.0) },
-  { FL2FXCONST_SGL( 0.05946491307025f / 8.0), FL2FXCONST_SGL( 0.20511047074866f / 8.0) },
-  { FL2FXCONST_SGL( 0.81505484574602f / 8.0), FL2FXCONST_SGL(-0.94685947861369f / 8.0) },
-  { FL2FXCONST_SGL(-0.44976380954860f / 8.0), FL2FXCONST_SGL( 0.40894572671545f / 8.0) },
-  { FL2FXCONST_SGL(-0.89746474625671f / 8.0), FL2FXCONST_SGL( 0.99846578838537f / 8.0) },
-  { FL2FXCONST_SGL( 0.39677256130792f / 8.0), FL2FXCONST_SGL(-0.74854668609359f / 8.0) },
-  { FL2FXCONST_SGL(-0.07588948563079f / 8.0), FL2FXCONST_SGL( 0.74096214084170f / 8.0) },
-  { FL2FXCONST_SGL( 0.76343198951445f / 8.0), FL2FXCONST_SGL( 0.41746629422634f / 8.0) },
-  { FL2FXCONST_SGL(-0.74490104699626f / 8.0), FL2FXCONST_SGL( 0.94725911744610f / 8.0) },
-  { FL2FXCONST_SGL( 0.64880119792759f / 8.0), FL2FXCONST_SGL( 0.41336660830571f / 8.0) },
-  { FL2FXCONST_SGL( 0.62319537462542f / 8.0), FL2FXCONST_SGL(-0.93098313552599f / 8.0) },
-  { FL2FXCONST_SGL( 0.42215817594807f / 8.0), FL2FXCONST_SGL(-0.07712787385208f / 8.0) },
-  { FL2FXCONST_SGL( 0.02704554141885f / 8.0), FL2FXCONST_SGL(-0.05417518053666f / 8.0) },
-  { FL2FXCONST_SGL( 0.80001773566818f / 8.0), FL2FXCONST_SGL( 0.91542195141039f / 8.0) },
-  { FL2FXCONST_SGL(-0.79351832348816f / 8.0), FL2FXCONST_SGL(-0.36208897989136f / 8.0) },
-  { FL2FXCONST_SGL( 0.63872359151636f / 8.0), FL2FXCONST_SGL( 0.08128252493444f / 8.0) },
-  { FL2FXCONST_SGL( 0.52890520960295f / 8.0), FL2FXCONST_SGL( 0.60048872455592f / 8.0) },
-  { FL2FXCONST_SGL( 0.74238552914587f / 8.0), FL2FXCONST_SGL( 0.04491915291044f / 8.0) },
-  { FL2FXCONST_SGL( 0.99096131449250f / 8.0), FL2FXCONST_SGL(-0.19451182854402f / 8.0) },
-  { FL2FXCONST_SGL(-0.80412329643109f / 8.0), FL2FXCONST_SGL(-0.88513818199457f / 8.0) },
-  { FL2FXCONST_SGL(-0.64612616129736f / 8.0), FL2FXCONST_SGL( 0.72198674804544f / 8.0) },
-  { FL2FXCONST_SGL( 0.11657770663191f / 8.0), FL2FXCONST_SGL(-0.83662833815041f / 8.0) },
-  { FL2FXCONST_SGL(-0.95053182488101f / 8.0), FL2FXCONST_SGL(-0.96939905138082f / 8.0) },
-  { FL2FXCONST_SGL(-0.62228872928622f / 8.0), FL2FXCONST_SGL( 0.82767262846661f / 8.0) },
-  { FL2FXCONST_SGL( 0.03004475787316f / 8.0), FL2FXCONST_SGL(-0.99738896333384f / 8.0) },
-  { FL2FXCONST_SGL(-0.97987214341034f / 8.0), FL2FXCONST_SGL( 0.36526129686425f / 8.0) },
-  { FL2FXCONST_SGL(-0.99986980746200f / 8.0), FL2FXCONST_SGL(-0.36021610299715f / 8.0) },
-  { FL2FXCONST_SGL( 0.89110648599879f / 8.0), FL2FXCONST_SGL(-0.97894250343044f / 8.0) },
-  { FL2FXCONST_SGL( 0.10407960510582f / 8.0), FL2FXCONST_SGL( 0.77357793811619f / 8.0) },
-  { FL2FXCONST_SGL( 0.95964737821728f / 8.0), FL2FXCONST_SGL(-0.35435818285502f / 8.0) },
-  { FL2FXCONST_SGL( 0.50843233159162f / 8.0), FL2FXCONST_SGL( 0.96107691266205f / 8.0) },
-  { FL2FXCONST_SGL( 0.17006334670615f / 8.0), FL2FXCONST_SGL(-0.76854025314829f / 8.0) },
-  { FL2FXCONST_SGL( 0.25872675063360f / 8.0), FL2FXCONST_SGL( 0.99893303933816f / 8.0) },
-  { FL2FXCONST_SGL(-0.01115998681937f / 8.0), FL2FXCONST_SGL( 0.98496019742444f / 8.0) },
-  { FL2FXCONST_SGL(-0.79598702973261f / 8.0), FL2FXCONST_SGL( 0.97138411318894f / 8.0) },
-  { FL2FXCONST_SGL(-0.99264708948101f / 8.0), FL2FXCONST_SGL(-0.99542822402536f / 8.0) },
-  { FL2FXCONST_SGL(-0.99829663752818f / 8.0), FL2FXCONST_SGL( 0.01877138824311f / 8.0) },
-  { FL2FXCONST_SGL(-0.70801016548184f / 8.0), FL2FXCONST_SGL( 0.33680685948117f / 8.0) },
-  { FL2FXCONST_SGL(-0.70467057786826f / 8.0), FL2FXCONST_SGL( 0.93272777501857f / 8.0) },
-  { FL2FXCONST_SGL( 0.99846021905254f / 8.0), FL2FXCONST_SGL(-0.98725746254433f / 8.0) },
-  { FL2FXCONST_SGL(-0.63364968534650f / 8.0), FL2FXCONST_SGL(-0.16473594423746f / 8.0) },
-  { FL2FXCONST_SGL(-0.16258217500792f / 8.0), FL2FXCONST_SGL(-0.95939125400802f / 8.0) },
-  { FL2FXCONST_SGL(-0.43645594360633f / 8.0), FL2FXCONST_SGL(-0.94805030113284f / 8.0) },
-  { FL2FXCONST_SGL(-0.99848471702976f / 8.0), FL2FXCONST_SGL( 0.96245166923809f / 8.0) },
-  { FL2FXCONST_SGL(-0.16796458968998f / 8.0), FL2FXCONST_SGL(-0.98987511890470f / 8.0) },
-  { FL2FXCONST_SGL(-0.87979225745213f / 8.0), FL2FXCONST_SGL(-0.71725725041680f / 8.0) },
-  { FL2FXCONST_SGL( 0.44183099021786f / 8.0), FL2FXCONST_SGL(-0.93568974498761f / 8.0) },
-  { FL2FXCONST_SGL( 0.93310180125532f / 8.0), FL2FXCONST_SGL(-0.99913308068246f / 8.0) },
-  { FL2FXCONST_SGL(-0.93941931782002f / 8.0), FL2FXCONST_SGL(-0.56409379640356f / 8.0) },
-  { FL2FXCONST_SGL(-0.88590003188677f / 8.0), FL2FXCONST_SGL( 0.47624600491382f / 8.0) },
-  { FL2FXCONST_SGL( 0.99971463703691f / 8.0), FL2FXCONST_SGL(-0.83889954253462f / 8.0) },
-  { FL2FXCONST_SGL(-0.75376385639978f / 8.0), FL2FXCONST_SGL( 0.00814643438625f / 8.0) },
-  { FL2FXCONST_SGL( 0.93887685615875f / 8.0), FL2FXCONST_SGL(-0.11284528204636f / 8.0) },
-  { FL2FXCONST_SGL( 0.85126435782309f / 8.0), FL2FXCONST_SGL( 0.52349251543547f / 8.0) },
-  { FL2FXCONST_SGL( 0.39701421446381f / 8.0), FL2FXCONST_SGL( 0.81779634174316f / 8.0) },
-  { FL2FXCONST_SGL(-0.37024464187437f / 8.0), FL2FXCONST_SGL(-0.87071656222959f / 8.0) },
-  { FL2FXCONST_SGL(-0.36024828242896f / 8.0), FL2FXCONST_SGL( 0.34655735648287f / 8.0) },
-  { FL2FXCONST_SGL(-0.93388812549209f / 8.0), FL2FXCONST_SGL(-0.84476541096429f / 8.0) },
-  { FL2FXCONST_SGL(-0.65298804552119f / 8.0), FL2FXCONST_SGL(-0.18439575450921f / 8.0) },
-  { FL2FXCONST_SGL( 0.11960319006843f / 8.0), FL2FXCONST_SGL( 0.99899346780168f / 8.0) },
-  { FL2FXCONST_SGL( 0.94292565553160f / 8.0), FL2FXCONST_SGL( 0.83163906518293f / 8.0) },
-  { FL2FXCONST_SGL( 0.75081145286948f / 8.0), FL2FXCONST_SGL(-0.35533223142265f / 8.0) },
-  { FL2FXCONST_SGL( 0.56721979748394f / 8.0), FL2FXCONST_SGL(-0.24076836414499f / 8.0) },
-  { FL2FXCONST_SGL( 0.46857766746029f / 8.0), FL2FXCONST_SGL(-0.30140233457198f / 8.0) },
-  { FL2FXCONST_SGL( 0.97312313923635f / 8.0), FL2FXCONST_SGL(-0.99548191630031f / 8.0) },
-  { FL2FXCONST_SGL(-0.38299976567017f / 8.0), FL2FXCONST_SGL( 0.98516909715427f / 8.0) },
-  { FL2FXCONST_SGL( 0.41025800019463f / 8.0), FL2FXCONST_SGL( 0.02116736935734f / 8.0) },
-  { FL2FXCONST_SGL( 0.09638062008048f / 8.0), FL2FXCONST_SGL( 0.04411984381457f / 8.0) },
-  { FL2FXCONST_SGL(-0.85283249275397f / 8.0), FL2FXCONST_SGL( 0.91475563922421f / 8.0) },
-  { FL2FXCONST_SGL( 0.88866808958124f / 8.0), FL2FXCONST_SGL(-0.99735267083226f / 8.0) },
-  { FL2FXCONST_SGL(-0.48202429536989f / 8.0), FL2FXCONST_SGL(-0.96805608884164f / 8.0) },
-  { FL2FXCONST_SGL( 0.27572582416567f / 8.0), FL2FXCONST_SGL( 0.58634753335832f / 8.0) },
-  { FL2FXCONST_SGL(-0.65889129659168f / 8.0), FL2FXCONST_SGL( 0.58835634138583f / 8.0) },
-  { FL2FXCONST_SGL( 0.98838086953732f / 8.0), FL2FXCONST_SGL( 0.99994349600236f / 8.0) },
-  { FL2FXCONST_SGL(-0.20651349620689f / 8.0), FL2FXCONST_SGL( 0.54593044066355f / 8.0) },
-  { FL2FXCONST_SGL(-0.62126416356920f / 8.0), FL2FXCONST_SGL(-0.59893681700392f / 8.0) },
-  { FL2FXCONST_SGL( 0.20320105410437f / 8.0), FL2FXCONST_SGL(-0.86879180355289f / 8.0) },
-  { FL2FXCONST_SGL(-0.97790548600584f / 8.0), FL2FXCONST_SGL( 0.96290806999242f / 8.0) },
-  { FL2FXCONST_SGL( 0.11112534735126f / 8.0), FL2FXCONST_SGL( 0.21484763313301f / 8.0) },
-  { FL2FXCONST_SGL(-0.41368337314182f / 8.0), FL2FXCONST_SGL( 0.28216837680365f / 8.0) },
-  { FL2FXCONST_SGL( 0.24133038992960f / 8.0), FL2FXCONST_SGL( 0.51294362630238f / 8.0) },
-  { FL2FXCONST_SGL(-0.66393410674885f / 8.0), FL2FXCONST_SGL(-0.08249679629081f / 8.0) },
-  { FL2FXCONST_SGL(-0.53697829178752f / 8.0), FL2FXCONST_SGL(-0.97649903936228f / 8.0) },
-  { FL2FXCONST_SGL(-0.97224737889348f / 8.0), FL2FXCONST_SGL( 0.22081333579837f / 8.0) },
-  { FL2FXCONST_SGL( 0.87392477144549f / 8.0), FL2FXCONST_SGL(-0.12796173740361f / 8.0) },
-  { FL2FXCONST_SGL( 0.19050361015753f / 8.0), FL2FXCONST_SGL( 0.01602615387195f / 8.0) },
-  { FL2FXCONST_SGL(-0.46353441212724f / 8.0), FL2FXCONST_SGL(-0.95249041539006f / 8.0) },
-  { FL2FXCONST_SGL(-0.07064096339021f / 8.0), FL2FXCONST_SGL(-0.94479803205886f / 8.0) },
-  { FL2FXCONST_SGL(-0.92444085484466f / 8.0), FL2FXCONST_SGL(-0.10457590187436f / 8.0) },
-  { FL2FXCONST_SGL(-0.83822593578728f / 8.0), FL2FXCONST_SGL(-0.01695043208885f / 8.0) },
-  { FL2FXCONST_SGL( 0.75214681811150f / 8.0), FL2FXCONST_SGL(-0.99955681042665f / 8.0) },
-  { FL2FXCONST_SGL(-0.42102998829339f / 8.0), FL2FXCONST_SGL( 0.99720941999394f / 8.0) },
-  { FL2FXCONST_SGL(-0.72094786237696f / 8.0), FL2FXCONST_SGL(-0.35008961934255f / 8.0) },
-  { FL2FXCONST_SGL( 0.78843311019251f / 8.0), FL2FXCONST_SGL( 0.52851398958271f / 8.0) },
-  { FL2FXCONST_SGL( 0.97394027897442f / 8.0), FL2FXCONST_SGL(-0.26695944086561f / 8.0) },
-  { FL2FXCONST_SGL( 0.99206463477946f / 8.0), FL2FXCONST_SGL(-0.57010120849429f / 8.0) },
-  { FL2FXCONST_SGL( 0.76789609461795f / 8.0), FL2FXCONST_SGL(-0.76519356730966f / 8.0) },
-  { FL2FXCONST_SGL(-0.82002421836409f / 8.0), FL2FXCONST_SGL(-0.73530179553767f / 8.0) },
-  { FL2FXCONST_SGL( 0.81924990025724f / 8.0), FL2FXCONST_SGL( 0.99698425250579f / 8.0) },
-  { FL2FXCONST_SGL(-0.26719850873357f / 8.0), FL2FXCONST_SGL( 0.68903369776193f / 8.0) },
-  { FL2FXCONST_SGL(-0.43311260380975f / 8.0), FL2FXCONST_SGL( 0.85321815947490f / 8.0) },
-  { FL2FXCONST_SGL( 0.99194979673836f / 8.0), FL2FXCONST_SGL( 0.91876249766422f / 8.0) },
-  { FL2FXCONST_SGL(-0.80692001248487f / 8.0), FL2FXCONST_SGL(-0.32627540663214f / 8.0) },
-  { FL2FXCONST_SGL( 0.43080003649976f / 8.0), FL2FXCONST_SGL(-0.21919095636638f / 8.0) },
-  { FL2FXCONST_SGL( 0.67709491937357f / 8.0), FL2FXCONST_SGL(-0.95478075822906f / 8.0) },
-  { FL2FXCONST_SGL( 0.56151770568316f / 8.0), FL2FXCONST_SGL(-0.70693811747778f / 8.0) },
-  { FL2FXCONST_SGL( 0.10831862810749f / 8.0), FL2FXCONST_SGL(-0.08628837174592f / 8.0) },
-  { FL2FXCONST_SGL( 0.91229417540436f / 8.0), FL2FXCONST_SGL(-0.65987351408410f / 8.0) },
-  { FL2FXCONST_SGL(-0.48972893932274f / 8.0), FL2FXCONST_SGL( 0.56289246362686f / 8.0) },
-  { FL2FXCONST_SGL(-0.89033658689697f / 8.0), FL2FXCONST_SGL(-0.71656563987082f / 8.0) },
-  { FL2FXCONST_SGL( 0.65269447475094f / 8.0), FL2FXCONST_SGL( 0.65916004833932f / 8.0) },
-  { FL2FXCONST_SGL( 0.67439478141121f / 8.0), FL2FXCONST_SGL(-0.81684380846796f / 8.0) },
-  { FL2FXCONST_SGL(-0.47770832416973f / 8.0), FL2FXCONST_SGL(-0.16789556203025f / 8.0) },
-  { FL2FXCONST_SGL(-0.99715979260878f / 8.0), FL2FXCONST_SGL(-0.93565784007648f / 8.0) },
-  { FL2FXCONST_SGL(-0.90889593602546f / 8.0), FL2FXCONST_SGL( 0.62034397054380f / 8.0) },
-  { FL2FXCONST_SGL(-0.06618622548177f / 8.0), FL2FXCONST_SGL(-0.23812217221359f / 8.0) },
-  { FL2FXCONST_SGL( 0.99430266919728f / 8.0), FL2FXCONST_SGL( 0.18812555317553f / 8.0) },
-  { FL2FXCONST_SGL( 0.97686402381843f / 8.0), FL2FXCONST_SGL(-0.28664534366620f / 8.0) },
-  { FL2FXCONST_SGL( 0.94813650221268f / 8.0), FL2FXCONST_SGL(-0.97506640027128f / 8.0) },
-  { FL2FXCONST_SGL(-0.95434497492853f / 8.0), FL2FXCONST_SGL(-0.79607978501983f / 8.0) },
-  { FL2FXCONST_SGL(-0.49104783137150f / 8.0), FL2FXCONST_SGL( 0.32895214359663f / 8.0) },
-  { FL2FXCONST_SGL( 0.99881175120751f / 8.0), FL2FXCONST_SGL( 0.88993983831354f / 8.0) },
-  { FL2FXCONST_SGL( 0.50449166760303f / 8.0), FL2FXCONST_SGL(-0.85995072408434f / 8.0) },
-  { FL2FXCONST_SGL( 0.47162891065108f / 8.0), FL2FXCONST_SGL(-0.18680204049569f / 8.0) },
-  { FL2FXCONST_SGL(-0.62081581361840f / 8.0), FL2FXCONST_SGL( 0.75000676218956f / 8.0) },
-  { FL2FXCONST_SGL(-0.43867015250812f / 8.0), FL2FXCONST_SGL( 0.99998069244322f / 8.0) },
-  { FL2FXCONST_SGL( 0.98630563232075f / 8.0), FL2FXCONST_SGL(-0.53578899600662f / 8.0) },
-  { FL2FXCONST_SGL(-0.61510362277374f / 8.0), FL2FXCONST_SGL(-0.89515019899997f / 8.0) },
-  { FL2FXCONST_SGL(-0.03841517601843f / 8.0), FL2FXCONST_SGL(-0.69888815681179f / 8.0) },
-  { FL2FXCONST_SGL(-0.30102157304644f / 8.0), FL2FXCONST_SGL(-0.07667808922205f / 8.0) },
-  { FL2FXCONST_SGL( 0.41881284182683f / 8.0), FL2FXCONST_SGL( 0.02188098922282f / 8.0) },
-  { FL2FXCONST_SGL(-0.86135454941237f / 8.0), FL2FXCONST_SGL( 0.98947480909359f / 8.0) },
-  { FL2FXCONST_SGL( 0.67226861393788f / 8.0), FL2FXCONST_SGL(-0.13494389011014f / 8.0) },
-  { FL2FXCONST_SGL(-0.70737398842068f / 8.0), FL2FXCONST_SGL(-0.76547349325992f / 8.0) },
-  { FL2FXCONST_SGL( 0.94044946687963f / 8.0), FL2FXCONST_SGL( 0.09026201157416f / 8.0) },
-  { FL2FXCONST_SGL(-0.82386352534327f / 8.0), FL2FXCONST_SGL( 0.08924768823676f / 8.0) },
-  { FL2FXCONST_SGL(-0.32070666698656f / 8.0), FL2FXCONST_SGL( 0.50143421908753f / 8.0) },
-  { FL2FXCONST_SGL( 0.57593163224487f / 8.0), FL2FXCONST_SGL(-0.98966422921509f / 8.0) },
-  { FL2FXCONST_SGL(-0.36326018419965f / 8.0), FL2FXCONST_SGL( 0.07440243123228f / 8.0) },
-  { FL2FXCONST_SGL( 0.99979044674350f / 8.0), FL2FXCONST_SGL(-0.14130287347405f / 8.0) },
-  { FL2FXCONST_SGL(-0.92366023326932f / 8.0), FL2FXCONST_SGL(-0.97979298068180f / 8.0) },
-  { FL2FXCONST_SGL(-0.44607178518598f / 8.0), FL2FXCONST_SGL(-0.54233252016394f / 8.0) },
-  { FL2FXCONST_SGL( 0.44226800932956f / 8.0), FL2FXCONST_SGL( 0.71326756742752f / 8.0) },
-  { FL2FXCONST_SGL( 0.03671907158312f / 8.0), FL2FXCONST_SGL( 0.63606389366675f / 8.0) },
-  { FL2FXCONST_SGL( 0.52175424682195f / 8.0), FL2FXCONST_SGL(-0.85396826735705f / 8.0) },
-  { FL2FXCONST_SGL(-0.94701139690956f / 8.0), FL2FXCONST_SGL(-0.01826348194255f / 8.0) },
-  { FL2FXCONST_SGL(-0.98759606946049f / 8.0), FL2FXCONST_SGL( 0.82288714303073f / 8.0) },
-  { FL2FXCONST_SGL( 0.87434794743625f / 8.0), FL2FXCONST_SGL( 0.89399495655433f / 8.0) },
-  { FL2FXCONST_SGL(-0.93412041758744f / 8.0), FL2FXCONST_SGL( 0.41374052024363f / 8.0) },
-  { FL2FXCONST_SGL( 0.96063943315511f / 8.0), FL2FXCONST_SGL( 0.93116709541280f / 8.0) },
-  { FL2FXCONST_SGL( 0.97534253457837f / 8.0), FL2FXCONST_SGL( 0.86150930812689f / 8.0) },
-  { FL2FXCONST_SGL( 0.99642466504163f / 8.0), FL2FXCONST_SGL( 0.70190043427512f / 8.0) },
-  { FL2FXCONST_SGL(-0.94705089665984f / 8.0), FL2FXCONST_SGL(-0.29580042814306f / 8.0) },
-  { FL2FXCONST_SGL( 0.91599807087376f / 8.0), FL2FXCONST_SGL(-0.98147830385781f / 8.0) }
-};
-//@}
-
-/*
-static const FIXP_SGL harmonicPhase [2][4] = {
-  { 1.0, 0.0, -1.0,  0.0},
-  { 0.0, 1.0,  0.0, -1.0}
-};
-*/
-
-
-/* The CLDFB-80 is not linear phase (unsymmetric), but the exact
-   phase difference between adjacent bands, at exact positions
-   (in this case exactly in the frequency band centre), can of
-   course be determined anyway. While the standard symmetric QMF
-   bank has a phase difference of 0.5*pi, the CLDFB-80
-   bank has the difference 0.2337*pi. */
-const FIXP_SGL harmonicPhaseX [2][4] = {
-  { FL2FXCONST_SGL( 7.423735494778151e-001), FL2FXCONST_SGL(-6.699862036159475e-001),
-    FL2FXCONST_SGL(-7.423735494778152e-001), FL2FXCONST_SGL( 6.699862036159474e-001) },
-  { FL2FXCONST_SGL( 7.423735494778151e-001), FL2FXCONST_SGL( 6.699862036159476e-001),
-    FL2FXCONST_SGL(-7.423735494778151e-001), FL2FXCONST_SGL(-6.699862036159476e-001) }
-};
-
-/* tables for SBR and AAC LD */
-/* table for 8 time slot index */
-const int FDK_sbrDecoder_envelopeTable_8 [8][5] = {
-/* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
-/* borders from left to right side; -1 = not in use */
-    /*[|T-|------]*/  { 2, 0, 0, 1, -1 },
-    /*[|-T-|-----]*/  { 2, 0, 0, 2, -1 },
-    /*[--|T-|----]*/  { 3, 1, 1, 2,  4 },
-    /*[---|T-|---]*/  { 3, 1, 1, 3,  5 },
-    /*[----|T-|--]*/  { 3, 1, 1, 4,  6 },
-    /*[-----|T--|]*/  { 2, 1, 1, 5, -1 },
-    /*[------|T-|]*/  { 2, 1, 1, 6, -1 },
-    /*[-------|T|]*/  { 2, 1, 1, 7, -1 },
-};
-
-/* table for 15 time slot index */
-const int FDK_sbrDecoder_envelopeTable_15 [15][6] = {
-    /* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
-    /* length from left to right side; -1 = not in use */
-    /*[|T---|------------]*/ { 2, 0, 0, 4, -1, -1},
-    /*[|-T---|-----------]*/ { 2, 0, 0, 5, -1, -1},
-    /*[|--|T---|---------]*/ { 3, 1, 1, 2,  6, -1},
-    /*[|---|T---|--------]*/ { 3, 1, 1, 3,  7, -1},
-    /*[|----|T---|-------]*/ { 3, 1, 1, 4,  8, -1},
-    /*[|-----|T---|------]*/ { 3, 1, 1, 5,  9, -1},
-    /*[|------|T---|-----]*/ { 3, 1, 1, 6, 10, -1},
-    /*[|-------|T---|----]*/ { 3, 1, 1, 7, 11, -1},
-    /*[|--------|T---|---]*/ { 3, 1, 1, 8, 12, -1},
-    /*[|---------|T---|--]*/ { 3, 1, 1, 9, 13, -1},
-    /*[|----------|T----|]*/ { 2, 1, 1,10, -1, -1},
-    /*[|-----------|T---|]*/ { 2, 1, 1,11, -1, -1},
-    /*[|------------|T--|]*/ { 2, 1, 1,12, -1, -1},
-    /*[|-------------|T-|]*/ { 2, 1, 1,13, -1, -1},
-    /*[|--------------|T|]*/ { 2, 1, 1,14, -1, -1},
-};
-
-/* table for 16 time slot index */
-const int FDK_sbrDecoder_envelopeTable_16 [16][6] = {
-    /* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
-    /* length from left to right side; -1 = not in use */
-    /*[|T---|------------|]*/ { 2, 0, 0, 4, -1, -1},
-    /*[|-T---|-----------|]*/ { 2, 0, 0, 5, -1, -1},
-    /*[|--|T---|----------]*/ { 3, 1, 1, 2,  6, -1},
-    /*[|---|T---|---------]*/ { 3, 1, 1, 3,  7, -1},
-    /*[|----|T---|--------]*/ { 3, 1, 1, 4,  8, -1},
-    /*[|-----|T---|-------]*/ { 3, 1, 1, 5,  9, -1},
-    /*[|------|T---|------]*/ { 3, 1, 1, 6, 10, -1},
-    /*[|-------|T---|-----]*/ { 3, 1, 1, 7, 11, -1},
-    /*[|--------|T---|----]*/ { 3, 1, 1, 8, 12, -1},
-    /*[|---------|T---|---]*/ { 3, 1, 1, 9, 13, -1},
-    /*[|----------|T---|--]*/ { 3, 1, 1,10, 14, -1},
-    /*[|-----------|T----|]*/ { 2, 1, 1,11, -1, -1},
-    /*[|------------|T---|]*/ { 2, 1, 1,12, -1, -1},
-    /*[|-------------|T--|]*/ { 2, 1, 1,13, -1, -1},
-    /*[|--------------|T-|]*/ { 2, 1, 1,14, -1, -1},
-    /*[|---------------|T|]*/ { 2, 1, 1,15, -1, -1},
-};
-
-/*!
-  \name FrameInfoDefaults
-
-  Predefined envelope positions for the FIX-FIX case (static framing)
-*/
-//@{
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info1_15 = { 0, 1, {0, 15,  0,  0,  0, 0}, {1, 0, 0, 0, 0}, -1, 1, {0, 15,  0} };
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info2_15 = { 0, 2, {0,  8, 15,  0,  0, 0}, {1, 1, 0, 0, 0}, -1, 2, {0,  8, 15} };
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info4_15 = { 0, 4, {0,  4,  8, 12, 15, 0}, {1, 1, 1, 1, 0}, -1, 2, {0,  8, 15} };
-#if (MAX_ENVELOPES >= 8)
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info8_15 = { 0, 8, {0, 2, 4, 6, 8, 10, 12, 14, 15}, {1, 1, 1, 1, 1, 1, 1, 1}, -1, 2, {0, 8, 15} };
-#endif
-
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info1_16 = { 0, 1, {0, 16,  0,  0,  0, 0}, {1, 0, 0, 0, 0}, -1, 1, {0, 16, 0} };
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info2_16 = { 0, 2, {0,  8, 16,  0,  0, 0}, {1, 1, 0, 0, 0}, -1, 2, {0, 8, 16} };
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info4_16 = { 0, 4, {0,  4,  8, 12, 16, 0}, {1, 1, 1, 1, 0}, -1, 2, {0, 8, 16} };
-
-#if (MAX_ENVELOPES >= 8)
-const FRAME_INFO FDK_sbrDecoder_sbr_frame_info8_16 = { 0, 8, {0, 2, 4, 6, 8, 10, 12, 14, 16}, {1, 1, 1, 1, 1, 1, 1, 1}, -1, 2, {0, 8, 16} };
-#endif
-
-
-//@}
-
-/*!
-  \name SBR_HuffmanTables
-
-  SBR Huffman Table Overview:        \n
-                                     \n
- o envelope level,   1.5 dB:         \n
-    1)  sbr_huffBook_EnvLevel10T[120][2]   \n
-    2)  sbr_huffBook_EnvLevel10F[120][2]   \n
-                                     \n
- o envelope balance, 1.5 dB:         \n
-    3)  sbr_huffBook_EnvBalance10T[48][2]  \n
-    4)  sbr_huffBook_EnvBalance10F[48][2]  \n
-                                     \n
- o envelope level,   3.0 dB:         \n
-    5)  sbr_huffBook_EnvLevel11T[62][2]    \n
-    6)  sbr_huffBook_EnvLevel11F[62][2]    \n
-                                     \n
- o envelope balance, 3.0 dB:         \n
-    7)  sbr_huffBook_EnvBalance11T[24][2]  \n
-    8)  sbr_huffBook_EnvBalance11F[24][2]  \n
-                                     \n
- o noise level,      3.0 dB:         \n
-    9)  sbr_huffBook_NoiseLevel11T[62][2]  \n
-    -) (sbr_huffBook_EnvLevel11F[62][2] is used for freq dir)\n
-                                     \n
- o noise balance,    3.0 dB:         \n
-   10)  sbr_huffBook_NoiseBalance11T[24][2]\n
-    -) (sbr_huffBook_EnvBalance11F[24][2] is used for freq dir)\n
-                                     \n
-  (1.5 dB is never used for noise)
-
-*/
-//@{
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel10T[120][2] = {
-  {   1,   2 },    { -64, -65 },    {   3,   4 },    { -63, -66 },
-  {   5,   6 },    { -62, -67 },    {   7,   8 },    { -61, -68 },
-  {   9,  10 },    { -60, -69 },    {  11,  12 },    { -59, -70 },
-  {  13,  14 },    { -58, -71 },    {  15,  16 },    { -57, -72 },
-  {  17,  18 },    { -73, -56 },    {  19,  21 },    { -74,  20 },
-  { -55, -75 },    {  22,  26 },    {  23,  24 },    { -54, -76 },
-  { -77,  25 },    { -53, -78 },    {  27,  34 },    {  28,  29 },
-  { -52, -79 },    {  30,  31 },    { -80, -51 },    {  32,  33 },
-  { -83, -82 },    { -81, -50 },    {  35,  57 },    {  36,  40 },
-  {  37,  38 },    { -88, -84 },    { -48,  39 },    { -90, -85 },
-  {  41,  46 },    {  42,  43 },    { -49, -87 },    {  44,  45 },
-  { -89, -86 },    {-124,-123 },    {  47,  50 },    {  48,  49 },
-  {-122,-121 },    {-120,-119 },    {  51,  54 },    {  52,  53 },
-  {-118,-117 },    {-116,-115 },    {  55,  56 },    {-114,-113 },
-  {-112,-111 },    {  58,  89 },    {  59,  74 },    {  60,  67 },
-  {  61,  64 },    {  62,  63 },    {-110,-109 },    {-108,-107 },
-  {  65,  66 },    {-106,-105 },    {-104,-103 },    {  68,  71 },
-  {  69,  70 },    {-102,-101 },    {-100, -99 },    {  72,  73 },
-  { -98, -97 },    { -96, -95 },    {  75,  82 },    {  76,  79 },
-  {  77,  78 },    { -94, -93 },    { -92, -91 },    {  80,  81 },
-  { -47, -46 },    { -45, -44 },    {  83,  86 },    {  84,  85 },
-  { -43, -42 },    { -41, -40 },    {  87,  88 },    { -39, -38 },
-  { -37, -36 },    {  90, 105 },    {  91,  98 },    {  92,  95 },
-  {  93,  94 },    { -35, -34 },    { -33, -32 },    {  96,  97 },
-  { -31, -30 },    { -29, -28 },    {  99, 102 },    { 100, 101 },
-  { -27, -26 },    { -25, -24 },    { 103, 104 },    { -23, -22 },
-  { -21, -20 },    { 106, 113 },    { 107, 110 },    { 108, 109 },
-  { -19, -18 },    { -17, -16 },    { 111, 112 },    { -15, -14 },
-  { -13, -12 },    { 114, 117 },    { 115, 116 },    { -11, -10 },
-  {  -9,  -8 },    { 118, 119 },    {  -7,  -6 },    {  -5,  -4 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel10F[120][2] = {
-  {   1,   2 },    { -64, -65 },    {   3,   4 },    { -63, -66 },
-  {   5,   6 },    { -67, -62 },    {   7,   8 },    { -68, -61 },
-  {   9,  10 },    { -69, -60 },    {  11,  13 },    { -70,  12 },
-  { -59, -71 },    {  14,  16 },    { -58,  15 },    { -72, -57 },
-  {  17,  19 },    { -73,  18 },    { -56, -74 },    {  20,  23 },
-  {  21,  22 },    { -55, -75 },    { -54, -53 },    {  24,  27 },
-  {  25,  26 },    { -76, -52 },    { -77, -51 },    {  28,  31 },
-  {  29,  30 },    { -50, -78 },    { -79, -49 },    {  32,  36 },
-  {  33,  34 },    { -48, -47 },    { -80,  35 },    { -81, -82 },
-  {  37,  47 },    {  38,  41 },    {  39,  40 },    { -83, -46 },
-  { -45, -84 },    {  42,  44 },    { -85,  43 },    { -44, -43 },
-  {  45,  46 },    { -88, -87 },    { -86, -90 },    {  48,  66 },
-  {  49,  56 },    {  50,  53 },    {  51,  52 },    { -92, -42 },
-  { -41, -39 },    {  54,  55 },    {-105, -89 },    { -38, -37 },
-  {  57,  60 },    {  58,  59 },    { -94, -91 },    { -40, -36 },
-  {  61,  63 },    { -20,  62 },    {-115,-110 },    {  64,  65 },
-  {-108,-107 },    {-101, -97 },    {  67,  89 },    {  68,  75 },
-  {  69,  72 },    {  70,  71 },    { -95, -93 },    { -34, -27 },
-  {  73,  74 },    { -22, -17 },    { -16,-124 },    {  76,  82 },
-  {  77,  79 },    {-123,  78 },    {-122,-121 },    {  80,  81 },
-  {-120,-119 },    {-118,-117 },    {  83,  86 },    {  84,  85 },
-  {-116,-114 },    {-113,-112 },    {  87,  88 },    {-111,-109 },
-  {-106,-104 },    {  90, 105 },    {  91,  98 },    {  92,  95 },
-  {  93,  94 },    {-103,-102 },    {-100, -99 },    {  96,  97 },
-  { -98, -96 },    { -35, -33 },    {  99, 102 },    { 100, 101 },
-  { -32, -31 },    { -30, -29 },    { 103, 104 },    { -28, -26 },
-  { -25, -24 },    { 106, 113 },    { 107, 110 },    { 108, 109 },
-  { -23, -21 },    { -19, -18 },    { 111, 112 },    { -15, -14 },
-  { -13, -12 },    { 114, 117 },    { 115, 116 },    { -11, -10 },
-  {  -9,  -8 },    { 118, 119 },    {  -7,  -6 },    {  -5,  -4 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance10T[48][2] = {
-  { -64,   1 },    { -63,   2 },    { -65,   3 },    { -62,   4 },
-  { -66,   5 },    { -61,   6 },    { -67,   7 },    { -60,   8 },
-  { -68,   9 },    {  10,  11 },    { -69, -59 },    {  12,  13 },
-  { -70, -58 },    {  14,  28 },    {  15,  21 },    {  16,  18 },
-  { -57,  17 },    { -71, -56 },    {  19,  20 },    { -88, -87 },
-  { -86, -85 },    {  22,  25 },    {  23,  24 },    { -84, -83 },
-  { -82, -81 },    {  26,  27 },    { -80, -79 },    { -78, -77 },
-  {  29,  36 },    {  30,  33 },    {  31,  32 },    { -76, -75 },
-  { -74, -73 },    {  34,  35 },    { -72, -55 },    { -54, -53 },
-  {  37,  41 },    {  38,  39 },    { -52, -51 },    { -50,  40 },
-  { -49, -48 },    {  42,  45 },    {  43,  44 },    { -47, -46 },
-  { -45, -44 },    {  46,  47 },    { -43, -42 },    { -41, -40 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance10F[48][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    { -66,   4 },
-  { -62,   5 },    { -61,   6 },    { -67,   7 },    { -68,   8 },
-  { -60,   9 },    {  10,  11 },    { -69, -59 },    { -70,  12 },
-  { -58,  13 },    {  14,  17 },    { -71,  15 },    { -57,  16 },
-  { -56, -73 },    {  18,  32 },    {  19,  25 },    {  20,  22 },
-  { -72,  21 },    { -88, -87 },    {  23,  24 },    { -86, -85 },
-  { -84, -83 },    {  26,  29 },    {  27,  28 },    { -82, -81 },
-  { -80, -79 },    {  30,  31 },    { -78, -77 },    { -76, -75 },
-  {  33,  40 },    {  34,  37 },    {  35,  36 },    { -74, -55 },
-  { -54, -53 },    {  38,  39 },    { -52, -51 },    { -50, -49 },
-  {  41,  44 },    {  42,  43 },    { -48, -47 },    { -46, -45 },
-  {  45,  46 },    { -44, -43 },    { -42,  47 },    { -41, -40 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel11T[62][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    { -66,   4 },
-  { -62,   5 },    { -67,   6 },    { -61,   7 },    { -68,   8 },
-  { -60,   9 },    {  10,  11 },    { -69, -59 },    {  12,  14 },
-  { -70,  13 },    { -71, -58 },    {  15,  18 },    {  16,  17 },
-  { -72, -57 },    { -73, -74 },    {  19,  22 },    { -56,  20 },
-  { -55,  21 },    { -54, -77 },    {  23,  31 },    {  24,  25 },
-  { -75, -76 },    {  26,  27 },    { -78, -53 },    {  28,  29 },
-  { -52, -95 },    { -94,  30 },    { -93, -92 },    {  32,  47 },
-  {  33,  40 },    {  34,  37 },    {  35,  36 },    { -91, -90 },
-  { -89, -88 },    {  38,  39 },    { -87, -86 },    { -85, -84 },
-  {  41,  44 },    {  42,  43 },    { -83, -82 },    { -81, -80 },
-  {  45,  46 },    { -79, -51 },    { -50, -49 },    {  48,  55 },
-  {  49,  52 },    {  50,  51 },    { -48, -47 },    { -46, -45 },
-  {  53,  54 },    { -44, -43 },    { -42, -41 },    {  56,  59 },
-  {  57,  58 },    { -40, -39 },    { -38, -37 },    {  60,  61 },
-  { -36, -35 },    { -34, -33 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel11F[62][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    { -66,   4 },
-  { -62,   5 },    { -67,   6 },    {   7,   8 },    { -61, -68 },
-  {   9,  10 },    { -60, -69 },    {  11,  12 },    { -59, -70 },
-  {  13,  14 },    { -58, -71 },    {  15,  16 },    { -57, -72 },
-  {  17,  19 },    { -56,  18 },    { -55, -73 },    {  20,  24 },
-  {  21,  22 },    { -74, -54 },    { -53,  23 },    { -75, -76 },
-  {  25,  30 },    {  26,  27 },    { -52, -51 },    {  28,  29 },
-  { -77, -79 },    { -50, -49 },    {  31,  39 },    {  32,  35 },
-  {  33,  34 },    { -78, -46 },    { -82, -88 },    {  36,  37 },
-  { -83, -48 },    { -47,  38 },    { -86, -85 },    {  40,  47 },
-  {  41,  44 },    {  42,  43 },    { -80, -44 },    { -43, -42 },
-  {  45,  46 },    { -39, -87 },    { -84, -40 },    {  48,  55 },
-  {  49,  52 },    {  50,  51 },    { -95, -94 },    { -93, -92 },
-  {  53,  54 },    { -91, -90 },    { -89, -81 },    {  56,  59 },
-  {  57,  58 },    { -45, -41 },    { -38, -37 },    {  60,  61 },
-  { -36, -35 },    { -34, -33 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance11T[24][2] = {
-  { -64,   1 },    { -63,   2 },    { -65,   3 },    { -66,   4 },
-  { -62,   5 },    { -61,   6 },    { -67,   7 },    { -68,   8 },
-  { -60,   9 },    {  10,  16 },    {  11,  13 },    { -69,  12 },
-  { -76, -75 },    {  14,  15 },    { -74, -73 },    { -72, -71 },
-  {  17,  20 },    {  18,  19 },    { -70, -59 },    { -58, -57 },
-  {  21,  22 },    { -56, -55 },    { -54,  23 },    { -53, -52 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance11F[24][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    { -66,   4 },
-  { -62,   5 },    { -61,   6 },    { -67,   7 },    { -68,   8 },
-  { -60,   9 },    {  10,  13 },    { -69,  11 },    { -59,  12 },
-  { -58, -76 },    {  14,  17 },    {  15,  16 },    { -75, -74 },
-  { -73, -72 },    {  18,  21 },    {  19,  20 },    { -71, -70 },
-  { -57, -56 },    {  22,  23 },    { -55, -54 },    { -53, -52 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_NoiseLevel11T[62][2] = {
-  { -64,   1 },    { -63,   2 },    { -65,   3 },    { -66,   4 },
-  { -62,   5 },    { -67,   6 },    {   7,   8 },    { -61, -68 },
-  {   9,  30 },    {  10,  15 },    { -60,  11 },    { -69,  12 },
-  {  13,  14 },    { -59, -53 },    { -95, -94 },    {  16,  23 },
-  {  17,  20 },    {  18,  19 },    { -93, -92 },    { -91, -90 },
-  {  21,  22 },    { -89, -88 },    { -87, -86 },    {  24,  27 },
-  {  25,  26 },    { -85, -84 },    { -83, -82 },    {  28,  29 },
-  { -81, -80 },    { -79, -78 },    {  31,  46 },    {  32,  39 },
-  {  33,  36 },    {  34,  35 },    { -77, -76 },    { -75, -74 },
-  {  37,  38 },    { -73, -72 },    { -71, -70 },    {  40,  43 },
-  {  41,  42 },    { -58, -57 },    { -56, -55 },    {  44,  45 },
-  { -54, -52 },    { -51, -50 },    {  47,  54 },    {  48,  51 },
-  {  49,  50 },    { -49, -48 },    { -47, -46 },    {  52,  53 },
-  { -45, -44 },    { -43, -42 },    {  55,  58 },    {  56,  57 },
-  { -41, -40 },    { -39, -38 },    {  59,  60 },    { -37, -36 },
-  { -35,  61 },    { -34, -33 }
-};
-
-const SCHAR FDK_sbrDecoder_sbr_huffBook_NoiseBalance11T[24][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    {   4,   9 },
-  { -66,   5 },    { -62,   6 },    {   7,   8 },    { -76, -75 },
-  { -74, -73 },    {  10,  17 },    {  11,  14 },    {  12,  13 },
-  { -72, -71 },    { -70, -69 },    {  15,  16 },    { -68, -67 },
-  { -61, -60 },    {  18,  21 },    {  19,  20 },    { -59, -58 },
-  { -57, -56 },    {  22,  23 },    { -55, -54 },    { -53, -52 }
-};
-//@}
-
-
-
-
-/*!
-  \name  parametric stereo
-  \brief constants used by the parametric stereo part of the decoder
-
-*/
-
-
-/* constants used in psbitdec.cpp */
-
-/* FIX_BORDER can have 0, 1, 2, 4 envelopes */
-const UCHAR FDK_sbrDecoder_aFixNoEnvDecode[4] = {0, 1, 2, 4};
-
-
-/* IID & ICC Huffman codebooks */
-const SCHAR aBookPsIidTimeDecode[28][2] = {
-  { -64,   1 },    { -65,   2 },    { -63,   3 },    { -66,   4 },
-  { -62,   5 },    { -67,   6 },    { -61,   7 },    { -68,   8 },
-  { -60,   9 },    { -69,  10 },    { -59,  11 },    { -70,  12 },
-  { -58,  13 },    { -57,  14 },    { -71,  15 },    {  16,  17 },
-  { -56, -72 },    {  18,  21 },    {  19,  20 },    { -55, -78 },
-  { -77, -76 },    {  22,  25 },    {  23,  24 },    { -75, -74 },
-  { -73, -54 },    {  26,  27 },    { -53, -52 },    { -51, -50 }
-};
-
-const SCHAR aBookPsIidFreqDecode[28][2] = {
-  { -64,   1 },    {   2,   3 },    { -63, -65 },    {   4,   5 },
-  { -62, -66 },    {   6,   7 },    { -61, -67 },    {   8,   9 },
-  { -68, -60 },    { -59,  10 },    { -69,  11 },    { -58,  12 },
-  { -70,  13 },    { -71,  14 },    { -57,  15 },    {  16,  17 },
-  { -56, -72 },    {  18,  19 },    { -55, -54 },    {  20,  21 },
-  { -73, -53 },    {  22,  24 },    { -74,  23 },    { -75, -78 },
-  {  25,  26 },    { -77, -76 },    { -52,  27 },    { -51, -50 }
-};
-
-const SCHAR aBookPsIccTimeDecode[14][2] = {
-  { -64,   1 },    { -63,   2 },    { -65,   3 },    { -62,   4 },
-  { -66,   5 },    { -61,   6 },    { -67,   7 },    { -60,   8 },
-  { -68,   9 },    { -59,  10 },    { -69,  11 },    { -58,  12 },
-  { -70,  13 },    { -71, -57 }
-};
-
-const SCHAR aBookPsIccFreqDecode[14][2] = {
-  { -64,   1 },    { -63,   2 },    { -65,   3 },    { -62,   4 },
-  { -66,   5 },    { -61,   6 },    { -67,   7 },    { -60,   8 },
-  { -59,   9 },    { -68,  10 },    { -58,  11 },    { -69,  12 },
-  { -57,  13 },    { -70, -71 }
-};
-
-/* IID-fine Huffman codebooks */
-
-const SCHAR aBookPsIidFineTimeDecode[60][2] = {
-  {   1, -64 },    { -63,   2 },    {   3, -65 },    {   4,  59 },
-  {   5,   7 },    {   6, -67 },    { -68, -60 },    { -61,   8 },
-  {   9,  11 },    { -59,  10 },    { -70, -58 },    {  12,  41 },
-  {  13,  20 },    {  14, -71 },    { -55,  15 },    { -53,  16 },
-  {  17, -77 },    {  18,  19 },    { -85, -84 },    { -46, -45 },
-  { -57,  21 },    {  22,  40 },    {  23,  29 },    { -51,  24 },
-  {  25,  26 },    { -83, -82 },    {  27,  28 },    { -90, -38 },
-  { -92, -91 },    {  30,  37 },    {  31,  34 },    {  32,  33 },
-  { -35, -34 },    { -37, -36 },    {  35,  36 },    { -94, -93 },
-  { -89, -39 },    {  38, -79 },    {  39, -81 },    { -88, -40 },
-  { -74, -54 },    {  42, -69 },    {  43,  44 },    { -72, -56 },
-  {  45,  52 },    {  46,  50 },    {  47, -76 },    { -49,  48 },
-  { -47,  49 },    { -87, -41 },    { -52,  51 },    { -78, -50 },
-  {  53, -73 },    {  54, -75 },    {  55,  57 },    {  56, -80 },
-  { -86, -42 },    { -48,  58 },    { -44, -43 },    { -66, -62 }
-};
-
-
-const SCHAR aBookPsIidFineFreqDecode[60][2] = {
-  {   1, -64 },    {   2,   4 },    {   3, -65 },    { -66, -62 },
-  { -63,   5 },    {   6,   7 },    { -67, -61 },    {   8,   9 },
-  { -68, -60 },    {  10,  11 },    { -69, -59 },    {  12,  13 },
-  { -70, -58 },    {  14,  18 },    { -57,  15 },    {  16, -72 },
-  { -54,  17 },    { -75, -53 },    {  19,  37 },    { -56,  20 },
-  {  21, -73 },    {  22,  29 },    {  23, -76 },    {  24, -78 },
-  {  25,  28 },    {  26,  27 },    { -85, -43 },    { -83, -45 },
-  { -81, -47 },    { -52,  30 },    { -50,  31 },    {  32, -79 },
-  {  33,  34 },    { -82, -46 },    {  35,  36 },    { -90, -89 },
-  { -92, -91 },    {  38, -71 },    { -55,  39 },    {  40, -74 },
-  {  41,  50 },    {  42, -77 },    { -49,  43 },    {  44,  47 },
-  {  45,  46 },    { -86, -42 },    { -88, -87 },    {  48,  49 },
-  { -39, -38 },    { -41, -40 },    { -51,  51 },    {  52,  59 },
-  {  53,  56 },    {  54,  55 },    { -35, -34 },    { -37, -36 },
-  {  57,  58 },    { -94, -93 },    { -84, -44 },    { -80, -48 }
-};
-
-/* constants used in psdec.cpp */
-
-const FIXP_DBL decayScaleFactTable[64] = {
-
- FL2FXCONST_DBL(1.000000), FL2FXCONST_DBL(1.000000), FL2FXCONST_DBL(1.000000), FL2FXCONST_DBL(1.000000),
- FL2FXCONST_DBL(0.950000), FL2FXCONST_DBL(0.900000), FL2FXCONST_DBL(0.850000), FL2FXCONST_DBL(0.800000),
- FL2FXCONST_DBL(0.750000), FL2FXCONST_DBL(0.700000), FL2FXCONST_DBL(0.650000), FL2FXCONST_DBL(0.600000),
- FL2FXCONST_DBL(0.550000), FL2FXCONST_DBL(0.500000), FL2FXCONST_DBL(0.450000), FL2FXCONST_DBL(0.400000),
- FL2FXCONST_DBL(0.350000), FL2FXCONST_DBL(0.300000), FL2FXCONST_DBL(0.250000), FL2FXCONST_DBL(0.200000),
- FL2FXCONST_DBL(0.150000), FL2FXCONST_DBL(0.100000), FL2FXCONST_DBL(0.050000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000),
- FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000), FL2FXCONST_DBL(0.000000) };
-
-/* the values of the following 3 tables are shiftet right by 1 ! */
-const FIXP_DBL ScaleFactors[NO_IID_LEVELS] = {
-
-    0x5a5ded00, 0x59cd0400, 0x58c29680, 0x564c2e80, 0x52a3d480,
-    0x4c8be080, 0x46df3080, 0x40000000, 0x384ba5c0, 0x304c2980,
-    0x24e9f640, 0x1b4a2940, 0x11b5c0a0, 0x0b4e2540, 0x0514ea90
-};
-
-const FIXP_DBL ScaleFactorsFine[NO_IID_LEVELS_FINE] = {
-
-    0x5a825c00, 0x5a821c00, 0x5a815100, 0x5a7ed000, 0x5a76e600,
-    0x5a5ded00, 0x5a39b880, 0x59f1fd00, 0x5964d680, 0x5852ca00,
-    0x564c2e80, 0x54174480, 0x50ea7500, 0x4c8be080, 0x46df3080,
-    0x40000000, 0x384ba5c0, 0x304c2980, 0x288dd240, 0x217a2900,
-    0x1b4a2940, 0x13c5ece0, 0x0e2b0090, 0x0a178ef0, 0x072ab798,
-    0x0514ea90, 0x02dc5944, 0x019bf87c, 0x00e7b173, 0x00824b8b,
-    0x00494568
-};
-const FIXP_DBL Alphas[NO_ICC_LEVELS] = {
-
-    0x00000000, 0x0b6b5be0, 0x12485f80, 0x1da2fa40,
-    0x2637ebc0, 0x3243f6c0, 0x466b7480, 0x6487ed80
-};
-
-#if defined(ARCH_PREFER_MULT_32x16)
-#define  FIXP_PS FIXP_SGL
-#define  FXP_CAST(a) FX_DBL2FX_SGL((FIXP_DBL)a)
-#define  FL2FXCONST_PS FL2FXCONST_SGL
-#else
-#define  FIXP_PS FIXP_DBL
-#define  FXP_CAST
-#define  FL2FXCONST_PS FL2FXCONST_DBL
-#endif
-
-const FIXP_PS aAllpassLinkDecaySer[NO_SERIAL_ALLPASS_LINKS] = {
-FXP_CAST(0x53625b00), FXP_CAST(0x4848af00), FXP_CAST(0x3ea94d00) };
-
-const FIXP_PS aaFractDelayPhaseFactorReQmf[NO_QMF_CHANNELS] = {
-FXP_CAST(0x68b92180), FXP_CAST(0xde396900), FXP_CAST(0x80650380), FXP_CAST(0xcb537e40), FXP_CAST(0x5beb8f00), FXP_CAST(0x72f29200), FXP_CAST(0xf1f43c50), FXP_CAST(0x83896280),
-FXP_CAST(0xb9b99c00), FXP_CAST(0x4cda8f00), FXP_CAST(0x7a576e00), FXP_CAST(0x060799e0), FXP_CAST(0x89be5280), FXP_CAST(0xa9dab600), FXP_CAST(0x3be51b00), FXP_CAST(0x7eb91900),
-FXP_CAST(0x19f4f540), FXP_CAST(0x92dcb380), FXP_CAST(0x9c1ad700), FXP_CAST(0x29761940), FXP_CAST(0x7ffbf500), FXP_CAST(0x2d3eb180), FXP_CAST(0x9eab0a00), FXP_CAST(0x90d0aa80),
-FXP_CAST(0x1601bcc0), FXP_CAST(0x7e180e80), FXP_CAST(0x3f6b3940), FXP_CAST(0xacdeeb00), FXP_CAST(0x88435b00), FXP_CAST(0x0202a768), FXP_CAST(0x79194f80), FXP_CAST(0x5007fd00),
-FXP_CAST(0xbd1ecf00), FXP_CAST(0x82a8d100), FXP_CAST(0xedf6e5e0), FXP_CAST(0x711f3500), FXP_CAST(0x5eac4480), FXP_CAST(0xcf0447c0), FXP_CAST(0x80245f80), FXP_CAST(0xda5cd4c0),
-FXP_CAST(0x665c0800), FXP_CAST(0x6afbc500), FXP_CAST(0xe21e85e0), FXP_CAST(0x80c5e500), FXP_CAST(0xc7b003c0), FXP_CAST(0x59139f80), FXP_CAST(0x74a8e400), FXP_CAST(0xf5f51f40),
-FXP_CAST(0x84896680), FXP_CAST(0xb6662b00), FXP_CAST(0x4999b600), FXP_CAST(0x7b76a300), FXP_CAST(0x0a0b0650), FXP_CAST(0x8b572b80), FXP_CAST(0xa6ec4580), FXP_CAST(0x384fda80),
-FXP_CAST(0x7f3a1f00), FXP_CAST(0x1de19ec0), FXP_CAST(0x95045000), FXP_CAST(0x99a3e180), FXP_CAST(0x25a30740), FXP_CAST(0x7fdb9e80), FXP_CAST(0x30fbdb00), FXP_CAST(0xa153d500) };
-
-const FIXP_PS aaFractDelayPhaseFactorImQmf[NO_QMF_CHANNELS] = {
-FXP_CAST(0xb6663a80), FXP_CAST(0x84896200), FXP_CAST(0xf5f50c70), FXP_CAST(0x74a8dc80), FXP_CAST(0x5913ad00), FXP_CAST(0xc7b01480), FXP_CAST(0x80c5e300), FXP_CAST(0xe21e73a0),
-FXP_CAST(0x6afbba80), FXP_CAST(0x665c1380), FXP_CAST(0xda5ce6c0), FXP_CAST(0x80246080), FXP_CAST(0xcf043640), FXP_CAST(0x5eac3800), FXP_CAST(0x711f3e00), FXP_CAST(0xedf6f8a0),
-FXP_CAST(0x82a8d500), FXP_CAST(0xbd1ebe80), FXP_CAST(0x5007ee00), FXP_CAST(0x79195580), FXP_CAST(0x0202ba40), FXP_CAST(0x88436180), FXP_CAST(0xacdedc80), FXP_CAST(0x3f6b28c0),
-FXP_CAST(0x7e181180), FXP_CAST(0x1601cf40), FXP_CAST(0x90d0b380), FXP_CAST(0x9eaafd80), FXP_CAST(0x2d3e9fc0), FXP_CAST(0x7ffbf580), FXP_CAST(0x29762b00), FXP_CAST(0x9c1ae280),
-FXP_CAST(0x92dca980), FXP_CAST(0x19f4e2c0), FXP_CAST(0x7eb91680), FXP_CAST(0x3be52b80), FXP_CAST(0xa9dac400), FXP_CAST(0x89be4b80), FXP_CAST(0x06078710), FXP_CAST(0x7a576880),
-FXP_CAST(0x4cda9e00), FXP_CAST(0xb9b9ac00), FXP_CAST(0x83895e00), FXP_CAST(0xf1f42990), FXP_CAST(0x72f28a00), FXP_CAST(0x5beb9c00), FXP_CAST(0xcb538f40), FXP_CAST(0x80650200),
-FXP_CAST(0xde3956c0), FXP_CAST(0x68b91680), FXP_CAST(0x68b92c00), FXP_CAST(0xde397b40), FXP_CAST(0x80650500), FXP_CAST(0xcb536d00), FXP_CAST(0x5beb8180), FXP_CAST(0x72f29a80),
-FXP_CAST(0xf1f44f10), FXP_CAST(0x83896700), FXP_CAST(0xb9b98c80), FXP_CAST(0x4cda8000), FXP_CAST(0x7a577380), FXP_CAST(0x0607acb8), FXP_CAST(0x89be5a00), FXP_CAST(0xa9daa800) };
-
-const FIXP_PS aaFractDelayPhaseFactorReSubQmf20[NO_SUB_QMF_CHANNELS] = {
-FXP_CAST(0x7e807380), FXP_CAST(0x72b9bb00), FXP_CAST(0x5c44ee80), FXP_CAST(0x3d3938c0), FXP_CAST(0x80000000), FXP_CAST(0x80000000),
-FXP_CAST(0x72b9bb00), FXP_CAST(0x7e807380), FXP_CAST(0xba914700), FXP_CAST(0x050677b0), FXP_CAST(0x895cc380), FXP_CAST(0x834e4900) };
-
-const FIXP_PS aaFractDelayPhaseFactorImSubQmf20[NO_SUB_QMF_CHANNELS] = {
-FXP_CAST(0xec791720), FXP_CAST(0xc73ca080), FXP_CAST(0xa748ea00), FXP_CAST(0x8f976980), FXP_CAST(0x00000000), FXP_CAST(0x00000000),
-FXP_CAST(0x38c35f80), FXP_CAST(0x1386e8e0), FXP_CAST(0x9477d000), FXP_CAST(0x80194380), FXP_CAST(0xcff26140), FXP_CAST(0x1ce70d40) };
-
-const FIXP_PS aaFractDelayPhaseFactorSerReQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS] = {
-{FXP_CAST(0x63e52480), FXP_CAST(0x30fbc540), FXP_CAST(0x6d73af00)}, {FXP_CAST(0xc7b01280), FXP_CAST(0x89be5100), FXP_CAST(0xf7c31cb0)}, {FXP_CAST(0x83896200), FXP_CAST(0x7641af00), FXP_CAST(0x8aee2700)},
-{FXP_CAST(0x0202b330), FXP_CAST(0xcf043ac0), FXP_CAST(0x9bfab500)}, {FXP_CAST(0x7d572c80), FXP_CAST(0xcf043ac0), FXP_CAST(0x1893b960)}, {FXP_CAST(0x34ac7fc0), FXP_CAST(0x7641af00), FXP_CAST(0x7abf7980)},
-{FXP_CAST(0x99a3ee00), FXP_CAST(0x89be5100), FXP_CAST(0x58eead80)}, {FXP_CAST(0x9eab0580), FXP_CAST(0x30fbc540), FXP_CAST(0xd77dae40)}, {FXP_CAST(0x3be52140), FXP_CAST(0x30fbc540), FXP_CAST(0x819b8500)},
-{FXP_CAST(0x7b769d80), FXP_CAST(0x89be5100), FXP_CAST(0xb3a12280)}, {FXP_CAST(0xf9f86878), FXP_CAST(0x7641af00), FXP_CAST(0x37c519c0)}, {FXP_CAST(0x81e7ef80), FXP_CAST(0xcf043ac0), FXP_CAST(0x7ff16880)},
-{FXP_CAST(0xcf043cc0), FXP_CAST(0xcf043ac0), FXP_CAST(0x3e8b2340)}, {FXP_CAST(0x68b92280), FXP_CAST(0x7641af00), FXP_CAST(0xb9e4a900)}, {FXP_CAST(0x5eac3980), FXP_CAST(0x89be5100), FXP_CAST(0x80a05200)},
-{FXP_CAST(0xc094cd00), FXP_CAST(0x30fbc540), FXP_CAST(0xd051dc80)}, {FXP_CAST(0x85a89400), FXP_CAST(0x30fbc540), FXP_CAST(0x53483b00)}, {FXP_CAST(0x0a0af5e0), FXP_CAST(0x89be5100), FXP_CAST(0x7cb1b680)},
-{FXP_CAST(0x7eb91900), FXP_CAST(0x7641af00), FXP_CAST(0x2006e8c0)}, {FXP_CAST(0x2d3ea680), FXP_CAST(0xcf043ac0), FXP_CAST(0xa0ec1c00)}, {FXP_CAST(0x95044180), FXP_CAST(0xcf043ac0), FXP_CAST(0x880d2180)},
-{FXP_CAST(0xa4147300), FXP_CAST(0x7641af00), FXP_CAST(0xf0282870)}, {FXP_CAST(0x42e13f80), FXP_CAST(0x89be5100), FXP_CAST(0x694c4a00)}, {FXP_CAST(0x79195200), FXP_CAST(0x30fbc540), FXP_CAST(0x71374780)},
-{FXP_CAST(0xf1f43550), FXP_CAST(0x30fbc540), FXP_CAST(0xff6593ea)}, {FXP_CAST(0x80c5e280), FXP_CAST(0x89be5100), FXP_CAST(0x8e39ec00)}, {FXP_CAST(0xd689e480), FXP_CAST(0x7641af00), FXP_CAST(0x97648100)},
-{FXP_CAST(0x6d235300), FXP_CAST(0xcf043ac0), FXP_CAST(0x110a20c0)}, {FXP_CAST(0x5913a800), FXP_CAST(0xcf043ac0), FXP_CAST(0x785d4f80)}, {FXP_CAST(0xb9b99a00), FXP_CAST(0x7641af00), FXP_CAST(0x5e440880)},
-{FXP_CAST(0x88436100), FXP_CAST(0x89be5100), FXP_CAST(0xdece7000)}, {FXP_CAST(0x12091320), FXP_CAST(0x30fbc540), FXP_CAST(0x8309f800)}, {FXP_CAST(0x7f9afd00), FXP_CAST(0x30fbc540), FXP_CAST(0xada33f00)},
-{FXP_CAST(0x25a31700), FXP_CAST(0x89be5100), FXP_CAST(0x30cc3600)}, {FXP_CAST(0x90d0ab80), FXP_CAST(0x7641af00), FXP_CAST(0x7f7cbe80)}, {FXP_CAST(0xa9dabf00), FXP_CAST(0xcf043ac0), FXP_CAST(0x45182580)},
-{FXP_CAST(0x4999cb80), FXP_CAST(0xcf043ac0), FXP_CAST(0xc0681c80)}, {FXP_CAST(0x7641ac80), FXP_CAST(0x7641af00), FXP_CAST(0x80194380)}, {FXP_CAST(0xe9fe3300), FXP_CAST(0x89be5100), FXP_CAST(0xc95184c0)},
-{FXP_CAST(0x80246000), FXP_CAST(0x30fbc540), FXP_CAST(0x4d55d800)}, {FXP_CAST(0xde396fc0), FXP_CAST(0x30fbc540), FXP_CAST(0x7e324000)}, {FXP_CAST(0x711f3f00), FXP_CAST(0x89be5100), FXP_CAST(0x275ce480)},
-{FXP_CAST(0x53211700), FXP_CAST(0x7641af00), FXP_CAST(0xa6343580)}, {FXP_CAST(0xb3256780), FXP_CAST(0xcf043ac0), FXP_CAST(0x85997b80)}, {FXP_CAST(0x8b572680), FXP_CAST(0xcf043ac0), FXP_CAST(0xe89ba660)},
-{FXP_CAST(0x19f4f780), FXP_CAST(0x7641af00), FXP_CAST(0x64c4e100)}, {FXP_CAST(0x7ffbf580), FXP_CAST(0x89be5100), FXP_CAST(0x7493a380)}, {FXP_CAST(0x1de18100), FXP_CAST(0x30fbc540), FXP_CAST(0x070897f0)},
-{FXP_CAST(0x8d0d6a80), FXP_CAST(0x30fbc540), FXP_CAST(0x91ed6f00)}, {FXP_CAST(0xaff81380), FXP_CAST(0x89be5100), FXP_CAST(0x932db000)}, {FXP_CAST(0x5007fb00), FXP_CAST(0x7641af00), FXP_CAST(0x0970feb0)},
-{FXP_CAST(0x72f28d00), FXP_CAST(0xcf043ac0), FXP_CAST(0x758d6500)}, {FXP_CAST(0xe21e6cc0), FXP_CAST(0xcf043ac0), FXP_CAST(0x63436f80)}, {FXP_CAST(0x80040b00), FXP_CAST(0x7641af00), FXP_CAST(0xe63d7600)},
-{FXP_CAST(0xe60b1ae0), FXP_CAST(0x89be5100), FXP_CAST(0x84ea5c80)}, {FXP_CAST(0x74a8e100), FXP_CAST(0x30fbc540), FXP_CAST(0xa7f07500)}, {FXP_CAST(0x4cda8980), FXP_CAST(0x30fbc540), FXP_CAST(0x29a6d340)},
-{FXP_CAST(0xacdeda80), FXP_CAST(0x89be5100), FXP_CAST(0x7e93d600)}, {FXP_CAST(0x8ee0c980), FXP_CAST(0x7641af00), FXP_CAST(0x4b662680)}, {FXP_CAST(0x21c6a280), FXP_CAST(0xcf043ac0), FXP_CAST(0xc7258c80)},
-{FXP_CAST(0x7fdb9f00), FXP_CAST(0xcf043ac0), FXP_CAST(0x8006d500)}, {FXP_CAST(0x1601ba60), FXP_CAST(0x7641af00), FXP_CAST(0xc2830940)}, {FXP_CAST(0x89be4c80), FXP_CAST(0x89be5100), FXP_CAST(0x471cf100)},
-{FXP_CAST(0xb6664400), FXP_CAST(0x30fbc540), FXP_CAST(0x7f3fb800)}};
-
-const FIXP_PS aaFractDelayPhaseFactorSerImQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS] = {
-{FXP_CAST(0xaff80c80), FXP_CAST(0x89be5100), FXP_CAST(0xbda29e00)}, {FXP_CAST(0x8d0d6f00), FXP_CAST(0x30fbc540), FXP_CAST(0x8043ee80)}, {FXP_CAST(0x1de18a20), FXP_CAST(0x30fbc540), FXP_CAST(0xcc3e7840)},
-{FXP_CAST(0x7ffbf500), FXP_CAST(0x89be5100), FXP_CAST(0x4fdfc180)}, {FXP_CAST(0x19f4ee40), FXP_CAST(0x7641af00), FXP_CAST(0x7d9e4c00)}, {FXP_CAST(0x8b572300), FXP_CAST(0xcf043ac0), FXP_CAST(0x244a2940)},
-{FXP_CAST(0xb3256f00), FXP_CAST(0xcf043ac0), FXP_CAST(0xa3f0a500)}, {FXP_CAST(0x53211e00), FXP_CAST(0x7641af00), FXP_CAST(0x86944500)}, {FXP_CAST(0x711f3a80), FXP_CAST(0x89be5100), FXP_CAST(0xebc72040)},
-{FXP_CAST(0xde3966c0), FXP_CAST(0x30fbc540), FXP_CAST(0x66b87e00)}, {FXP_CAST(0x80246080), FXP_CAST(0x30fbc540), FXP_CAST(0x73362c00)}, {FXP_CAST(0xe9fe3c40), FXP_CAST(0x89be5100), FXP_CAST(0x03d1d110)},
-{FXP_CAST(0x7641b000), FXP_CAST(0x7641af00), FXP_CAST(0x90520c80)}, {FXP_CAST(0x4999c380), FXP_CAST(0xcf043ac0), FXP_CAST(0x94e80a80)}, {FXP_CAST(0xa9dab800), FXP_CAST(0xcf043ac0), FXP_CAST(0x0ca570e0)},
-{FXP_CAST(0x90d0b000), FXP_CAST(0x7641af00), FXP_CAST(0x76c9bc80)}, {FXP_CAST(0x25a32000), FXP_CAST(0x89be5100), FXP_CAST(0x61338500)}, {FXP_CAST(0x7f9afc80), FXP_CAST(0x30fbc540), FXP_CAST(0xe318f060)},
-{FXP_CAST(0x120909c0), FXP_CAST(0x30fbc540), FXP_CAST(0x84124e00)}, {FXP_CAST(0x88435d80), FXP_CAST(0x89be5100), FXP_CAST(0xaa4d2f80)}, {FXP_CAST(0xb9b9a200), FXP_CAST(0x7641af00), FXP_CAST(0x2cae1800)},
-{FXP_CAST(0x5913ae80), FXP_CAST(0xcf043ac0), FXP_CAST(0x7f040680)}, {FXP_CAST(0x6d234e00), FXP_CAST(0xcf043ac0), FXP_CAST(0x48c6a100)}, {FXP_CAST(0xd689db80), FXP_CAST(0x7641af00), FXP_CAST(0xc44860c0)},
-{FXP_CAST(0x80c5e380), FXP_CAST(0x89be5100), FXP_CAST(0x80005d00)}, {FXP_CAST(0xf1f43eb0), FXP_CAST(0x30fbc540), FXP_CAST(0xc55a3a00)}, {FXP_CAST(0x79195500), FXP_CAST(0x30fbc540), FXP_CAST(0x49c3de00)},
-{FXP_CAST(0x42e13700), FXP_CAST(0x89be5100), FXP_CAST(0x7edc5b00)}, {FXP_CAST(0xa4146c80), FXP_CAST(0x7641af00), FXP_CAST(0x2b8c2c00)}, {FXP_CAST(0x95044680), FXP_CAST(0xcf043ac0), FXP_CAST(0xa968c100)},
-{FXP_CAST(0x2d3eaf40), FXP_CAST(0xcf043ac0), FXP_CAST(0x8460fd80)}, {FXP_CAST(0x7eb91780), FXP_CAST(0x7641af00), FXP_CAST(0xe44621e0)}, {FXP_CAST(0x0a0aec80), FXP_CAST(0x89be5100), FXP_CAST(0x61fb5c00)},
-{FXP_CAST(0x85a89100), FXP_CAST(0x30fbc540), FXP_CAST(0x76555780)}, {FXP_CAST(0xc094d500), FXP_CAST(0x30fbc540), FXP_CAST(0x0b71f790)}, {FXP_CAST(0x5eac4000), FXP_CAST(0x89be5100), FXP_CAST(0x94401a80)},
-{FXP_CAST(0x68b91d80), FXP_CAST(0x7641af00), FXP_CAST(0x90ea3980)}, {FXP_CAST(0xcf043440), FXP_CAST(0xcf043ac0), FXP_CAST(0x05067a08)}, {FXP_CAST(0x81e7f180), FXP_CAST(0xcf043ac0), FXP_CAST(0x73bb6d00)},
-{FXP_CAST(0xf9f871e0), FXP_CAST(0x7641af00), FXP_CAST(0x65ff0e00)}, {FXP_CAST(0x7b76a000), FXP_CAST(0x89be5100), FXP_CAST(0xea9664c0)}, {FXP_CAST(0x3be518c0), FXP_CAST(0x30fbc540), FXP_CAST(0x8633e880)},
-{FXP_CAST(0x9eaaff00), FXP_CAST(0x30fbc540), FXP_CAST(0xa4c84500)}, {FXP_CAST(0x99a3f400), FXP_CAST(0x89be5100), FXP_CAST(0x2571eac0)}, {FXP_CAST(0x34ac8840), FXP_CAST(0x7641af00), FXP_CAST(0x7dd82b00)},
-{FXP_CAST(0x7d572a80), FXP_CAST(0xcf043ac0), FXP_CAST(0x4eed8400)}, {FXP_CAST(0x0202a9c4), FXP_CAST(0xcf043ac0), FXP_CAST(0xcb249700)}, {FXP_CAST(0x83896000), FXP_CAST(0x7641af00), FXP_CAST(0x80318200)},
-{FXP_CAST(0xc7b01b00), FXP_CAST(0x89be5100), FXP_CAST(0xbeab7580)}, {FXP_CAST(0x63e52a80), FXP_CAST(0x30fbc540), FXP_CAST(0x4364b700)}, {FXP_CAST(0x63e51f00), FXP_CAST(0x30fbc540), FXP_CAST(0x7fa6bd00)},
-{FXP_CAST(0xc7b00a00), FXP_CAST(0x89be5100), FXP_CAST(0x32a67940)}, {FXP_CAST(0x83896400), FXP_CAST(0x7641af00), FXP_CAST(0xaf2fd200)}, {FXP_CAST(0x0202bc9c), FXP_CAST(0xcf043ac0), FXP_CAST(0x829e6e80)},
-{FXP_CAST(0x7d572e80), FXP_CAST(0xcf043ac0), FXP_CAST(0xdcde6b80)}, {FXP_CAST(0x34ac7700), FXP_CAST(0x7641af00), FXP_CAST(0x5ce4e280)}, {FXP_CAST(0x99a3e880), FXP_CAST(0x89be5100), FXP_CAST(0x79089c00)},
-{FXP_CAST(0x9eab0b80), FXP_CAST(0x30fbc540), FXP_CAST(0x1307ae80)}, {FXP_CAST(0x3be52980), FXP_CAST(0x30fbc540), FXP_CAST(0x98906880)}, {FXP_CAST(0x7b769b00), FXP_CAST(0x89be5100), FXP_CAST(0x8d51b300)},
-{FXP_CAST(0xf9f85f10), FXP_CAST(0x7641af00), FXP_CAST(0xfd62ee24)}, {FXP_CAST(0x81e7ee00), FXP_CAST(0xcf043ac0), FXP_CAST(0x70439680)}, {FXP_CAST(0xcf044580), FXP_CAST(0xcf043ac0), FXP_CAST(0x6a6d9600)},
-{FXP_CAST(0x68b92800), FXP_CAST(0x7641af00), FXP_CAST(0xf2275f80)}};
-
-const FIXP_PS aaFractDelayPhaseFactorSerReSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS] = {
-{FXP_CAST(0x7e2df000), FXP_CAST(0x7a7d0580), FXP_CAST(0x7ed03e00)}, {FXP_CAST(0x6fec9a80), FXP_CAST(0x5133cc80), FXP_CAST(0x7573df00)}, {FXP_CAST(0x55063900), FXP_CAST(0x0c8bd360), FXP_CAST(0x636c0400)},
-{FXP_CAST(0x3084ca00), FXP_CAST(0xc3a94580), FXP_CAST(0x4a0d6700)}, {FXP_CAST(0x80000000), FXP_CAST(0x80000000), FXP_CAST(0x80000000)}, {FXP_CAST(0x80000000), FXP_CAST(0x80000000), FXP_CAST(0x80000000)},
-{FXP_CAST(0x6fec9a80), FXP_CAST(0x5133cc80), FXP_CAST(0x7573df00)}, {FXP_CAST(0x7e2df000), FXP_CAST(0x7a7d0580), FXP_CAST(0x7ed03e00)}, {FXP_CAST(0xa4c84280), FXP_CAST(0xb8e31300), FXP_CAST(0xd5af0140)},
-{FXP_CAST(0xf0f488a0), FXP_CAST(0x8275a100), FXP_CAST(0x1a72e360)}, {FXP_CAST(0x80aaa680), FXP_CAST(0x471ced00), FXP_CAST(0x9d2ead80)}, {FXP_CAST(0x9477d100), FXP_CAST(0x7d8a5f00), FXP_CAST(0x8151df80)}};
-
-const FIXP_PS aaFractDelayPhaseFactorSerImSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS] = {
-{FXP_CAST(0xea7d08a0), FXP_CAST(0xdad7f3c0), FXP_CAST(0xee9c9f60)}, {FXP_CAST(0xc1e54140), FXP_CAST(0x9d0dfe80), FXP_CAST(0xcd1e7300)}, {FXP_CAST(0xa051a580), FXP_CAST(0x809dc980), FXP_CAST(0xaf61c400)},
-{FXP_CAST(0x898d4e00), FXP_CAST(0x8f1d3400), FXP_CAST(0x97988280)}, {FXP_CAST(0x00000000), FXP_CAST(0x00000000), FXP_CAST(0x00000000)}, {FXP_CAST(0x00000000), FXP_CAST(0x00000000), FXP_CAST(0x00000000)},
-{FXP_CAST(0x3e1abec0), FXP_CAST(0x62f20180), FXP_CAST(0x32e18d00)}, {FXP_CAST(0x1582f760), FXP_CAST(0x25280c40), FXP_CAST(0x116360a0)}, {FXP_CAST(0xa6343800), FXP_CAST(0x6a6d9880), FXP_CAST(0x87327a00)},
-{FXP_CAST(0x80e32200), FXP_CAST(0xe70747c0), FXP_CAST(0x82c32b00)}, {FXP_CAST(0xf2f42420), FXP_CAST(0x6a6d9880), FXP_CAST(0xaea47080)}, {FXP_CAST(0x456eba00), FXP_CAST(0xe70747c0), FXP_CAST(0xedaa8640)}};
-
-const FIXP_PS p8_13_20[13] =
-{
-  FL2FXCONST_PS(0.00746082949812f),  FL2FXCONST_PS(0.02270420949825f),  FL2FXCONST_PS(0.04546865930473f),  FL2FXCONST_PS(0.07266113929591f),
-  FL2FXCONST_PS(0.09885108575264f),  FL2FXCONST_PS(0.11793710567217f),  FL2FXCONST_PS(0.125f           ),  FL2FXCONST_PS(0.11793710567217f),
-  FL2FXCONST_PS(0.09885108575264f),  FL2FXCONST_PS(0.07266113929591f),  FL2FXCONST_PS(0.04546865930473f),  FL2FXCONST_PS(0.02270420949825f),
-  FL2FXCONST_PS(0.00746082949812f)
-};
-
-const FIXP_PS p2_13_20[13] =
-{
-  FL2FXCONST_PS(0.0f), FL2FXCONST_PS( 0.01899487526049f),  FL2FXCONST_PS(0.0f), FL2FXCONST_PS(-0.07293139167538f),
-  FL2FXCONST_PS(0.0f), FL2FXCONST_PS( 0.30596630545168f),  FL2FXCONST_PS(0.5f), FL2FXCONST_PS( 0.30596630545168f),
-  FL2FXCONST_PS(0.0f), FL2FXCONST_PS(-0.07293139167538f),  FL2FXCONST_PS(0.0f), FL2FXCONST_PS( 0.01899487526049f),
-  FL2FXCONST_PS(0.0f)
-};
-
-
-
-const UCHAR aAllpassLinkDelaySer[] = {    3,     4,     5};
-
-const UCHAR delayIndexQmf[NO_QMF_CHANNELS] = {
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-  14, 14, 14,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
-};
-
-const UCHAR groupBorders20[NO_IID_GROUPS + 1] =
-{
-   6,  7,  0,  1,  2,  3,                            /* 6 subqmf subbands - 0th qmf subband */
-   9,  8,                                            /* 2 subqmf subbands - 1st qmf subband */
-  10, 11,                                            /* 2 subqmf subbands - 2nd qmf subband */
-   3,  4,  5,  6,  7,  8,
-   9,  11, 14, 18, 23, 35, 64
-};
-
-const UCHAR groupBorders34[NO_IID_GROUPS_HI_RES + 1] =
-{
-   0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,   /* 12 subqmf subbands - 0th qmf subband */
-  12, 13, 14, 15, 16, 17, 18, 19,                    /*  8 subqmf subbands - 1st qmf subband */
-  20, 21, 22, 23,                                    /*  4 subqmf subbands - 2nd qmf subband */
-  24, 25, 26, 27,                                    /*  4 subqmf subbands - 3nd qmf subband */
-  28, 29, 30, 31,                                    /*  4 subqmf subbands - 4nd qmf subband */
-  32-27, 33-27, 34-27, 35-27, 36-27, 37-27, 38-27,
-  40-27, 42-27, 44-27, 46-27, 48-27, 51-27, 54-27,
-  57-27, 60-27, 64-27, 68-27, 91-27
-};
-
-const UCHAR bins2groupMap20[NO_IID_GROUPS] =
-{
-  1, 0,
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-};
-
-const UCHAR quantizedIIDs[NO_IID_STEPS] =
-{
-    2, 4, 7, 10, 14, 18, 25
-};
-const UCHAR quantizedIIDsFine[NO_IID_STEPS_FINE] =
-{
-    2, 4, 6, 8, 10, 13, 16, 19, 22, 25, 30, 35, 40, 45, 50
-};
-
-const UCHAR FDK_sbrDecoder_aNoIidBins[3] = {NO_LOW_RES_IID_BINS,
-                           NO_MID_RES_IID_BINS,
-                           NO_HI_RES_IID_BINS};
-
-const UCHAR FDK_sbrDecoder_aNoIccBins[3] = {NO_LOW_RES_ICC_BINS,
-                           NO_MID_RES_ICC_BINS,
-                           NO_HI_RES_ICC_BINS};
-
-
-
-/************************************************************************/
-/*!
-   \brief   Create lookup tables for some arithmetic functions
-
-   The tables would normally be defined as const arrays,
-   but initialization at run time allows to specify their accuracy.
-*/
-/************************************************************************/
-
-/*   1/x-table:  (example for INV_TABLE_BITS 8)
-
-     The table covers an input range from 0.5 to 1.0 with a step size of 1/512,
-     starting at 0.5 + 1/512.
-     Each table entry corresponds to an input interval starting 1/1024 below the
-     exact value and ending 1/1024 above it.
-
-     The table is actually a 0.5/x-table, so that the output range is again
-     0.5...1.0 and the exponent of the result must be increased by 1.
-
-     Input range           Index in table      result
-     -------------------------------------------------------------------
-     0.500000...0.500976          -            0.5 / 0.500000 = 1.000000
-     0.500976...0.502930          0            0.5 / 0.501953 = 0.996109
-     0.502930...0.500488          1            0.5 / 0.503906 = 0.992248
-             ...
-     0.999023...1.000000         255           0.5 / 1.000000 = 0.500000
-
-       for (i=0; i<INV_TABLE_SIZE; i++) {
-         d = 0.5f / ( 0.5f+(double)(i+1)/(INV_TABLE_SIZE*2) ) ;
-         invTable[i] = FL2FX_SGL(d);
-       }
-*/
-const FIXP_SGL FDK_sbrDecoder_invTable[INV_TABLE_SIZE] =
-{
-  0x7f80, 0x7f01, 0x7e83, 0x7e07, 0x7d8b, 0x7d11, 0x7c97, 0x7c1e,
-  0x7ba6, 0x7b2f, 0x7ab9, 0x7a44, 0x79cf, 0x795c, 0x78e9, 0x7878,
-  0x7807, 0x7796, 0x7727, 0x76b9, 0x764b, 0x75de, 0x7572, 0x7506,
-  0x749c, 0x7432, 0x73c9, 0x7360, 0x72f9, 0x7292, 0x722c, 0x71c6,
-  0x7161, 0x70fd, 0x709a, 0x7037, 0x6fd5, 0x6f74, 0x6f13, 0x6eb3,
-  0x6e54, 0x6df5, 0x6d97, 0x6d39, 0x6cdc, 0x6c80, 0x6c24, 0x6bc9,
-  0x6b6f, 0x6b15, 0x6abc, 0x6a63, 0x6a0b, 0x69b3, 0x695c, 0x6906,
-  0x68b0, 0x685a, 0x6806, 0x67b1, 0x675e, 0x670a, 0x66b8, 0x6666,
-  0x6614, 0x65c3, 0x6572, 0x6522, 0x64d2, 0x6483, 0x6434, 0x63e6,
-  0x6399, 0x634b, 0x62fe, 0x62b2, 0x6266, 0x621b, 0x61d0, 0x6185,
-  0x613b, 0x60f2, 0x60a8, 0x6060, 0x6017, 0x5fcf, 0x5f88, 0x5f41,
-  0x5efa, 0x5eb4, 0x5e6e, 0x5e28, 0x5de3, 0x5d9f, 0x5d5a, 0x5d17,
-  0x5cd3, 0x5c90, 0x5c4d, 0x5c0b, 0x5bc9, 0x5b87, 0x5b46, 0x5b05,
-  0x5ac4, 0x5a84, 0x5a44, 0x5a05, 0x59c6, 0x5987, 0x5949, 0x590a,
-  0x58cd, 0x588f, 0x5852, 0x5815, 0x57d9, 0x579d, 0x5761, 0x5725,
-  0x56ea, 0x56af, 0x5675, 0x563b, 0x5601, 0x55c7, 0x558e, 0x5555,
-  0x551c, 0x54e3, 0x54ab, 0x5473, 0x543c, 0x5405, 0x53ce, 0x5397,
-  0x5360, 0x532a, 0x52f4, 0x52bf, 0x5289, 0x5254, 0x521f, 0x51eb,
-  0x51b7, 0x5183, 0x514f, 0x511b, 0x50e8, 0x50b5, 0x5082, 0x5050,
-  0x501d, 0x4feb, 0x4fba, 0x4f88, 0x4f57, 0x4f26, 0x4ef5, 0x4ec4,
-  0x4e94, 0x4e64, 0x4e34, 0x4e04, 0x4dd5, 0x4da6, 0x4d77, 0x4d48,
-  0x4d19, 0x4ceb, 0x4cbd, 0x4c8f, 0x4c61, 0x4c34, 0x4c07, 0x4bd9,
-  0x4bad, 0x4b80, 0x4b54, 0x4b27, 0x4afb, 0x4acf, 0x4aa4, 0x4a78,
-  0x4a4d, 0x4a22, 0x49f7, 0x49cd, 0x49a2, 0x4978, 0x494e, 0x4924,
-  0x48fa, 0x48d1, 0x48a7, 0x487e, 0x4855, 0x482d, 0x4804, 0x47dc,
-  0x47b3, 0x478b, 0x4763, 0x473c, 0x4714, 0x46ed, 0x46c5, 0x469e,
-  0x4677, 0x4651, 0x462a, 0x4604, 0x45de, 0x45b8, 0x4592, 0x456c,
-  0x4546, 0x4521, 0x44fc, 0x44d7, 0x44b2, 0x448d, 0x4468, 0x4444,
-  0x441f, 0x43fb, 0x43d7, 0x43b3, 0x4390, 0x436c, 0x4349, 0x4325,
-  0x4302, 0x42df, 0x42bc, 0x4299, 0x4277, 0x4254, 0x4232, 0x4210,
-  0x41ee, 0x41cc, 0x41aa, 0x4189, 0x4167, 0x4146, 0x4125, 0x4104,
-  0x40e3, 0x40c2, 0x40a1, 0x4081, 0x4060, 0x4040, 0x4020, 0x4000
-};
-
diff --git a/libSBRdec/src/sbr_rom.h b/libSBRdec/src/sbr_rom.h
deleted file mode 100644
index c318870..0000000
--- a/libSBRdec/src/sbr_rom.h
+++ /dev/null
@@ -1,234 +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 Declaration of constant tables
-
-*/
-#ifndef __rom_H
-#define __rom_H
-
-#include "sbrdecoder.h"
-#include "env_extr.h"
-#include "qmf.h"
-
-#define INV_INT_TABLE_SIZE      49
-#define SBR_NF_NO_RANDOM_VAL  512   /*!< Size of random number array for noise floor */
-
-/*
-  Frequency scales
-*/
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_16[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_22[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_24[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_32[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_40[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_44[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_48[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_64[16];
-extern const UCHAR FDK_sbrDecoder_sbr_start_freq_88[16];
-
-/*
-  Low-Power-Profile Transposer
-*/
-#define NUM_WHFACTOR_TABLE_ENTRIES  9
-extern const USHORT FDK_sbrDecoder_sbr_whFactorsIndex[NUM_WHFACTOR_TABLE_ENTRIES];
-extern const FIXP_DBL FDK_sbrDecoder_sbr_whFactorsTable[NUM_WHFACTOR_TABLE_ENTRIES][6];
-
-
-
-/*
-  Envelope Adjustor
-*/
-extern const FIXP_SGL FDK_sbrDecoder_sbr_limGains_m[4];
-extern const UCHAR    FDK_sbrDecoder_sbr_limGains_e[4];
-extern const FIXP_SGL FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4[4];
-extern const FIXP_SGL FDK_sbrDecoder_sbr_smoothFilter[4];
-extern const FIXP_SGL FDK_sbrDecoder_sbr_randomPhase[SBR_NF_NO_RANDOM_VAL][2];
-extern const FIXP_SGL harmonicPhaseX [2][4];
-
-/*
-  Envelope Extractor
-*/
-extern const int FDK_sbrDecoder_envelopeTable_8  [8][5];
-extern const int FDK_sbrDecoder_envelopeTable_15 [15][6];
-extern const int FDK_sbrDecoder_envelopeTable_16 [16][6];
-
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info1_15;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info2_15;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info4_15;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info8_15;
-
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info1_16;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info2_16;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info4_16;
-extern const FRAME_INFO FDK_sbrDecoder_sbr_frame_info8_16;
-
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel10T[120][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel10F[120][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance10T[48][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance10F[48][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel11T[62][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvLevel11F[62][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance11T[24][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_EnvBalance11F[24][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_NoiseLevel11T[62][2];
-extern const SCHAR FDK_sbrDecoder_sbr_huffBook_NoiseBalance11T[24][2];
-
-
-/*
- Parametric stereo
-*/
-
-
-extern const FIXP_DBL decayScaleFactTable[NO_QMF_CHANNELS];
-
-/* FIX_BORDER can have 0, 1, 2, 4 envelops */
-extern const UCHAR FDK_sbrDecoder_aFixNoEnvDecode[4];
-
-/* IID & ICC Huffman codebooks */
-extern const SCHAR aBookPsIidTimeDecode[28][2];
-extern const SCHAR aBookPsIidFreqDecode[28][2];
-extern const SCHAR aBookPsIccTimeDecode[14][2];
-extern const SCHAR aBookPsIccFreqDecode[14][2];
-
-/* IID-fine Huffman codebooks */
-
-extern const SCHAR aBookPsIidFineTimeDecode[60][2];
-extern const SCHAR aBookPsIidFineFreqDecode[60][2];
-
-/* the values of the following 3 tables are shiftet right by 1 ! */
-extern const FIXP_DBL ScaleFactors[NO_IID_LEVELS];
-extern const FIXP_DBL ScaleFactorsFine[NO_IID_LEVELS_FINE];
-extern const FIXP_DBL Alphas[NO_ICC_LEVELS];
-
-#if defined(ARCH_PREFER_MULT_32x16)
-extern const FIXP_SGL aAllpassLinkDecaySer[NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_SGL aaFractDelayPhaseFactorReQmf[NO_QMF_CHANNELS];
-extern const FIXP_SGL aaFractDelayPhaseFactorImQmf[NO_QMF_CHANNELS];
-extern const FIXP_SGL aaFractDelayPhaseFactorReSubQmf20[NO_SUB_QMF_CHANNELS];
-extern const FIXP_SGL aaFractDelayPhaseFactorImSubQmf20[NO_SUB_QMF_CHANNELS];
-
-extern const FIXP_SGL aaFractDelayPhaseFactorSerReQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_SGL aaFractDelayPhaseFactorSerImQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_SGL aaFractDelayPhaseFactorSerReSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_SGL aaFractDelayPhaseFactorSerImSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-
-extern const FIXP_SGL p8_13_20[13];
-extern const FIXP_SGL p2_13_20[13];
-
-#else
-extern const FIXP_DBL aAllpassLinkDecaySer[NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_DBL aaFractDelayPhaseFactorReQmf[NO_QMF_CHANNELS];
-extern const FIXP_DBL aaFractDelayPhaseFactorImQmf[NO_QMF_CHANNELS];
-extern const FIXP_DBL aaFractDelayPhaseFactorReSubQmf20[NO_SUB_QMF_CHANNELS];
-extern const FIXP_DBL aaFractDelayPhaseFactorImSubQmf20[NO_SUB_QMF_CHANNELS];
-
-extern const FIXP_DBL aaFractDelayPhaseFactorSerReQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_DBL aaFractDelayPhaseFactorSerImQmf[NO_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_DBL aaFractDelayPhaseFactorSerReSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-extern const FIXP_DBL aaFractDelayPhaseFactorSerImSubQmf20[NO_SUB_QMF_CHANNELS][NO_SERIAL_ALLPASS_LINKS];
-
-extern const FIXP_DBL p8_13_20[13];
-extern const FIXP_DBL p2_13_20[13];
-#endif
-
-extern const UCHAR aAllpassLinkDelaySer[3];
-extern const UCHAR delayIndexQmf[NO_QMF_CHANNELS];
-extern const UCHAR groupBorders20[NO_IID_GROUPS + 1];
-extern const UCHAR groupBorders34[NO_IID_GROUPS_HI_RES + 1];
-extern const UCHAR bins2groupMap20[NO_IID_GROUPS];
-extern const UCHAR quantizedIIDs[NO_IID_STEPS];
-extern const UCHAR quantizedIIDsFine[NO_IID_STEPS_FINE];
-extern const UCHAR FDK_sbrDecoder_aNoIidBins[3];
-extern const UCHAR FDK_sbrDecoder_aNoIccBins[3];
-
-
-/* Lookup tables for some arithmetic functions */
-
-#define INV_TABLE_BITS 8
-#define INV_TABLE_SIZE (1<<INV_TABLE_BITS)
-extern const FIXP_SGL FDK_sbrDecoder_invTable[INV_TABLE_SIZE];
-
-#endif // __rom_H
diff --git a/libSBRdec/src/sbr_scale.h b/libSBRdec/src/sbr_scale.h
deleted file mode 100644
index 5fccd71..0000000
--- a/libSBRdec/src/sbr_scale.h
+++ /dev/null
@@ -1,123 +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 Sbr scaling factors,  
-To deal with the dynamic range in the different processing stages, a
-fixed point specific code has to rely on scaling factors. A floating
-point code carries a scaling factor -- the exponent -- for each value,
-so scaling is not necessary there.
-
-The output of the core decoder (low band) is scaled up to cover as much
-as possible bits for each value. As high band and low band are processed
-in different algorithm sections, they require their own scaling
-factors. In addition, any static buffers, e.g. filter states, require a
-separate scaling factor as well. The code takes care to do the proper
-adjustment, if scaling factors of a filter state and the time signal differ.
-
-\sa #QMF_SCALE_FACTOR, \ref documentationOverview
-*/
-
-#ifndef __SBR_SCALE_H
-#define __SBR_SCALE_H
-
-/*!
-\verbatim
-  scale:
-    0             left aligned e.g. |max| >=0.5
-    FRACT_BITS-1  zero e.g |max| = 0
-\endverbatim
-
-  Dynamic scaling is used to achieve sufficient accuracy even when the signal
-  energy is low.  The dynamic framing of SBR produces a variable overlap area
-  where samples from the previous QMF-Analysis are stored. Depending on the
-  start position and stop position of the current SBR envelopes, the processing
-  buffer consists of differently scaled regions like illustrated in the below
-  figure.
-
-  \image html scales.png Scale
-*/
-
-
-#endif
diff --git a/libSBRdec/src/sbrdec_drc.cpp b/libSBRdec/src/sbrdec_drc.cpp
deleted file mode 100644
index a834c0b..0000000
--- a/libSBRdec/src/sbrdec_drc.cpp
+++ /dev/null
@@ -1,525 +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
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Christian Griebel
-   Description: Dynamic range control (DRC) decoder tool for SBR
-
-******************************************************************************/
-
-#include "sbrdec_drc.h"
-
-
-/* DRC - Offset table for QMF interpolation. */
-static const int offsetTab[2][16] =
-{
-  { 0, 4, 8, 12, 16, 20, 24, 28, 0, 0, 0, 0, 0, 0, 0, 0 },  /* 1024 framing */
-  { 0, 4, 8, 12, 16, 19, 22, 26, 0, 0, 0, 0, 0, 0, 0, 0 }   /*  960 framing */
-};
-
-/*!
-  \brief Initialize DRC QMF factors
-
-  \hDrcData Handle to DRC channel data.
-
-  \return none
-*/
-void sbrDecoder_drcInitChannel (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData )
-{
-  int band;
-
-  if (hDrcData == NULL) {
-    return;
-  }
-
-  for (band = 0; band < (64); band++) {
-    hDrcData->prevFact_mag[band] = FL2FXCONST_DBL(0.5f);
-  }
-
-  for (band = 0; band < SBRDEC_MAX_DRC_BANDS; band++) {
-    hDrcData->currFact_mag[band] = FL2FXCONST_DBL(0.5f);
-    hDrcData->nextFact_mag[band] = FL2FXCONST_DBL(0.5f);
-  }
-
-  hDrcData->prevFact_exp = 1;
-  hDrcData->currFact_exp = 1;
-  hDrcData->nextFact_exp = 1;
-
-  hDrcData->numBandsCurr = 1;
-  hDrcData->numBandsNext = 1;
-
-  hDrcData->winSequenceCurr = 0;
-  hDrcData->winSequenceNext = 0;
-
-  hDrcData->drcInterpolationSchemeCurr = 0;
-  hDrcData->drcInterpolationSchemeNext = 0;
-
-  hDrcData->enable = 0;
-}
-
-
-/*!
-  \brief Swap DRC QMF scaling factors after they have been applied.
-
-  \hDrcData Handle to DRC channel data.
-
-  \return none
-*/
-void sbrDecoder_drcUpdateChannel (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData )
-{
-  if (hDrcData == NULL) {
-    return;
-  }
-  if (hDrcData->enable != 1) {
-    return;
-  }
-
-  /* swap previous data */
-  FDKmemcpy( hDrcData->currFact_mag,
-             hDrcData->nextFact_mag,
-             SBRDEC_MAX_DRC_BANDS * sizeof(FIXP_DBL) );
-
-  hDrcData->currFact_exp = hDrcData->nextFact_exp;
-
-  hDrcData->numBandsCurr = hDrcData->numBandsNext;
-
-  FDKmemcpy( hDrcData->bandTopCurr,
-             hDrcData->bandTopNext,
-             SBRDEC_MAX_DRC_BANDS * sizeof(USHORT) );
-
-  hDrcData->drcInterpolationSchemeCurr = hDrcData->drcInterpolationSchemeNext;
-
-  hDrcData->winSequenceCurr = hDrcData->winSequenceNext;
-}
-
-
-/*!
-  \brief Apply DRC factors slot based.
-
-  \hDrcData Handle to DRC channel data.
-  \qmfRealSlot Pointer to real valued QMF data of one time slot.
-  \qmfImagSlot Pointer to the imaginary QMF data of one time slot.
-  \col Number of the time slot.
-  \numQmfSubSamples Total number of time slots for one frame.
-  \scaleFactor Pointer to the out scale factor of the time slot.
-
-  \return None.
-*/
-void sbrDecoder_drcApplySlot (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData,
-    FIXP_DBL   *qmfRealSlot,
-    FIXP_DBL   *qmfImagSlot,
-    int  col,
-    int  numQmfSubSamples,
-    int  maxShift
-  )
-{
-  const int *offset;
-
-  int band, bottomMdct, topMdct, bin, useLP;
-  int indx = numQmfSubSamples - (numQmfSubSamples >> 1) - 10;   /* l_border */
-  int frameLenFlag = (numQmfSubSamples == 30) ? 1 : 0;
-
-  const FIXP_DBL *fact_mag = NULL;
-  INT fact_exp = 0;
-  UINT numBands = 0;
-  USHORT *bandTop = NULL;
-  int shortDrc = 0;
-
-  FIXP_DBL alphaValue = FL2FXCONST_DBL(0.0f);
-
-  if (hDrcData == NULL) {
-    return;
-  }
-  if (hDrcData->enable != 1) {
-    return;
-  }
-
-  offset = offsetTab[frameLenFlag];
-
-  useLP = (qmfImagSlot == NULL) ? 1 : 0;
-
-  col += indx;
-  bottomMdct = 0;
-  bin = 0;
-
-  /* get respective data and calc interpolation factor */
-  if (col < (numQmfSubSamples>>1)) {  /* first half of current frame */
-    if (hDrcData->winSequenceCurr != 2) { /* long window */
-      int j = col + (numQmfSubSamples>>1);
-
-      if (hDrcData->drcInterpolationSchemeCurr == 0) {
-        INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
-
-        alphaValue = (FIXP_DBL)(j * k);
-      }
-      else {
-        if (j >= offset[hDrcData->drcInterpolationSchemeCurr - 1]) {
-          alphaValue = (FIXP_DBL)MAXVAL_DBL;
-        }
-      }
-    }
-    else {  /* short windows */
-      shortDrc = 1;
-    }
-
-    fact_mag = hDrcData->currFact_mag;
-    fact_exp = hDrcData->currFact_exp;
-    numBands = hDrcData->numBandsCurr;
-    bandTop = hDrcData->bandTopCurr;
-  }
-  else if (col < numQmfSubSamples) {  /* second half of current frame */
-    if (hDrcData->winSequenceNext != 2) { /* next: long window */
-      int j = col - (numQmfSubSamples>>1);
-
-      if (hDrcData->drcInterpolationSchemeNext == 0) {
-        INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
-
-        alphaValue = (FIXP_DBL)(j * k);
-      }
-      else {
-        if (j >= offset[hDrcData->drcInterpolationSchemeNext - 1]) {
-          alphaValue = (FIXP_DBL)MAXVAL_DBL;
-        }
-      }
-
-      fact_mag = hDrcData->nextFact_mag;
-      fact_exp = hDrcData->nextFact_exp;
-      numBands = hDrcData->numBandsNext;
-      bandTop = hDrcData->bandTopNext;
-    }
-    else {  /* next: short windows */
-      if (hDrcData->winSequenceCurr != 2) {  /* current: long window */
-        alphaValue = (FIXP_DBL)0;
-
-        fact_mag = hDrcData->nextFact_mag;
-        fact_exp = hDrcData->nextFact_exp;
-        numBands = hDrcData->numBandsNext;
-        bandTop = hDrcData->bandTopNext;
-      }
-      else {  /* current: short windows */
-        shortDrc = 1;
-
-        fact_mag = hDrcData->currFact_mag;
-        fact_exp = hDrcData->currFact_exp;
-        numBands = hDrcData->numBandsCurr;
-        bandTop = hDrcData->bandTopCurr;
-      }
-    }
-  }
-  else {  /* first half of next frame */
-    if (hDrcData->winSequenceNext != 2) { /* long window */
-      int j = col - (numQmfSubSamples>>1);
-
-      if (hDrcData->drcInterpolationSchemeNext == 0) {
-        INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
-
-        alphaValue = (FIXP_DBL)(j * k);
-      }
-      else {
-        if (j >= offset[hDrcData->drcInterpolationSchemeNext - 1]) {
-          alphaValue = (FIXP_DBL)MAXVAL_DBL;
-        }
-      }
-    }
-    else {  /* short windows */
-      shortDrc = 1;
-    }
-
-    fact_mag = hDrcData->nextFact_mag;
-    fact_exp = hDrcData->nextFact_exp;
-    numBands = hDrcData->numBandsNext;
-    bandTop = hDrcData->bandTopNext;
-
-    col -= numQmfSubSamples;
-  }
-
-
-  /* process bands */
-  for (band = 0; band < (int)numBands; band++) {
-    int bottomQmf, topQmf;
-
-    FIXP_DBL drcFact_mag = (FIXP_DBL)MAXVAL_DBL;
-
-    topMdct = (bandTop[band]+1) << 2;
-
-    if (!shortDrc) {  /* long window */
-      if (frameLenFlag) {
-        /* 960 framing */
-        bottomMdct = 30 * (bottomMdct / 30);
-        topMdct    = 30 * (topMdct / 30);
-
-        bottomQmf = fMultIfloor((FIXP_DBL)0x4444444, bottomMdct);
-        topQmf    = fMultIfloor((FIXP_DBL)0x4444444, topMdct);
-      }
-      else {
-        /* 1024 framing */
-        bottomMdct &= ~0x1f;
-        topMdct    &= ~0x1f;
-
-        bottomQmf = bottomMdct >> 5;
-        topQmf    = topMdct >> 5;
-      }
-
-      if (band == ((int)numBands-1)) {
-        topQmf = (64);
-      }
-    
-      for (bin = bottomQmf; bin < topQmf; bin++) {
-        FIXP_DBL drcFact1_mag = hDrcData->prevFact_mag[bin];
-        FIXP_DBL drcFact2_mag = fact_mag[band];
-
-        /* normalize scale factors */
-        if (hDrcData->prevFact_exp < maxShift) {
-          drcFact1_mag >>= maxShift - hDrcData->prevFact_exp;
-        }
-        if (fact_exp < maxShift) {
-          drcFact2_mag >>= maxShift - fact_exp;
-        }
-
-        /* interpolate */
-        if (alphaValue == (FIXP_DBL)0) {
-          drcFact_mag = drcFact1_mag;
-        } else if (alphaValue == (FIXP_DBL)MAXVAL_DBL) {
-          drcFact_mag = drcFact2_mag;
-        } else {
-          drcFact_mag = fMult(alphaValue, drcFact2_mag) + fMult(((FIXP_DBL)MAXVAL_DBL - alphaValue), drcFact1_mag);
-        }
-
-        /* apply scaling */
-        qmfRealSlot[bin] = fMult(qmfRealSlot[bin], drcFact_mag);
-        if (!useLP) {
-          qmfImagSlot[bin] = fMult(qmfImagSlot[bin], drcFact_mag);
-        }
-
-        /* save previous factors */
-        if (col == (numQmfSubSamples>>1)-1) {
-          hDrcData->prevFact_mag[bin] = fact_mag[band];
-        }
-      }
-    }
-    else {  /* short windows */
-      int startSample, stopSample;
-      FIXP_DBL invFrameSizeDiv8 = (frameLenFlag) ? (FIXP_DBL)0x1111111 : (FIXP_DBL)0x1000000;
-
-      if (frameLenFlag) {
-        /*  960 framing */
-        bottomMdct = 30/8 * (bottomMdct*8/30);
-        topMdct    = 30/8 * (topMdct*8/30);
-      }
-      else {
-        /* 1024 framing */
-        bottomMdct &= ~0x03;
-        topMdct    &= ~0x03;
-      }
-
-      /* startSample is truncated to the nearest corresponding start subsample in
-         the QMF of the short window bottom is present in:*/
-      startSample  = ((fMultIfloor( invFrameSizeDiv8, bottomMdct ) & 0x7) * numQmfSubSamples) >> 3;
-
-      /* stopSample is rounded upwards to the nearest corresponding stop subsample
-         in the QMF of the short window top is present in. */
-      stopSample  = ((fMultIceil( invFrameSizeDiv8, topMdct ) & 0xf) * numQmfSubSamples) >> 3;
-
-      bottomQmf = fMultIfloor( invFrameSizeDiv8, ((bottomMdct%(numQmfSubSamples<<2)) << 5) );
-      topQmf    = fMultIfloor( invFrameSizeDiv8, ((topMdct%(numQmfSubSamples<<2)) << 5) );
-
-      /* extend last band */
-      if (band == ((int)numBands-1)) {
-        topQmf = (64);
-        stopSample = numQmfSubSamples;
-      }
-
-      if (topQmf == 0) {
-        topQmf = (64);
-      }
-
-      /* save previous factors */
-      if (stopSample == numQmfSubSamples) {
-        int tmpBottom = bottomQmf;
-
-        if (((numQmfSubSamples-1) & ~0x03) > startSample) {
-            tmpBottom = 0;    /* band starts in previous short window */
-        }
-
-        for (bin = tmpBottom; bin < topQmf; bin++) {
-          hDrcData->prevFact_mag[bin] = fact_mag[band];
-        }
-      }
-
-      /* apply */
-      if ((col >= startSample) && (col < stopSample)) {
-        if ((col & ~0x03) > startSample) {
-            bottomQmf = 0;    /* band starts in previous short window */
-        }
-        if (col < ((stopSample-1) & ~0x03)) {
-            topQmf = (64);   /* band ends in next short window */
-        }
-
-        drcFact_mag = fact_mag[band];
-
-        /* normalize scale factor */
-        if (fact_exp < maxShift) {
-          drcFact_mag >>= maxShift - fact_exp;
-        }
-
-        /* apply scaling */
-        for (bin = bottomQmf; bin < topQmf; bin++) {
-          qmfRealSlot[bin] = fMult(qmfRealSlot[bin], drcFact_mag);
-          if (!useLP) {
-            qmfImagSlot[bin] = fMult(qmfImagSlot[bin], drcFact_mag);
-          }
-        }
-      }
-    }
-
-    bottomMdct = topMdct;
-  }   /* end of bands loop */
-
-  if (col == (numQmfSubSamples>>1)-1) {
-    hDrcData->prevFact_exp = fact_exp;
-  }
-}
-
-
-/*!
-  \brief Apply DRC factors frame based.
-
-  \hDrcData Handle to DRC channel data.
-  \qmfRealSlot Pointer to real valued QMF data of the whole frame.
-  \qmfImagSlot Pointer to the imaginary QMF data of the whole frame.
-  \numQmfSubSamples Total number of time slots for one frame.
-  \scaleFactor Pointer to the out scale factor of the frame.
-
-  \return None.
-*/
-void sbrDecoder_drcApply (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData,
-    FIXP_DBL **QmfBufferReal,
-    FIXP_DBL **QmfBufferImag,
-    int  numQmfSubSamples,
-    int *scaleFactor
-  )
-{
-  int col;
-  int maxShift = 0;
-
-  if (hDrcData == NULL) {
-    return;
-  }
-  if (hDrcData->enable == 0) {
-    return;  /* Avoid changing the scaleFactor even though the processing is disabled. */
-  }
-
-  /* get max scale factor */
-  if (hDrcData->prevFact_exp > maxShift) {
-    maxShift = hDrcData->prevFact_exp;
-  }
-  if (hDrcData->currFact_exp > maxShift) {
-    maxShift = hDrcData->currFact_exp;
-  }
-  if (hDrcData->nextFact_exp > maxShift) {
-    maxShift = hDrcData->nextFact_exp;
-  }
-
-  for (col = 0; col < numQmfSubSamples; col++)
-  {
-    FIXP_DBL *qmfSlotReal = QmfBufferReal[col];
-    FIXP_DBL *qmfSlotImag = (QmfBufferImag == NULL) ? NULL : QmfBufferImag[col];
-
-    sbrDecoder_drcApplySlot (
-      hDrcData,
-      qmfSlotReal,
-      qmfSlotImag,
-      col,
-      numQmfSubSamples,
-      maxShift
-    );
-  }
-
-  *scaleFactor += maxShift;
-}
-
diff --git a/libSBRdec/src/sbrdec_drc.h b/libSBRdec/src/sbrdec_drc.h
deleted file mode 100644
index 872c6a0..0000000
--- a/libSBRdec/src/sbrdec_drc.h
+++ /dev/null
@@ -1,151 +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
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG-4 AAC Decoder  **************************
-
-   Author(s):   Christian Griebel
-   Description: Dynamic range control (DRC) decoder tool for SBR
-
-******************************************************************************/
-
-#ifndef _SBRDEC_DRC_H_
-#define _SBRDEC_DRC_H_
-
-#include "sbrdecoder.h"
-
-
-
-#define SBRDEC_MAX_DRC_CHANNELS  (6)
-#define SBRDEC_MAX_DRC_BANDS     ( 16 )
-
-typedef struct
-{
-  FIXP_DBL prevFact_mag[(64)];
-  INT      prevFact_exp;
-
-  FIXP_DBL currFact_mag[SBRDEC_MAX_DRC_BANDS];
-  FIXP_DBL nextFact_mag[SBRDEC_MAX_DRC_BANDS];
-  INT      currFact_exp;
-  INT      nextFact_exp;
-
-  UINT     numBandsCurr;
-  UINT     numBandsNext;
-  USHORT   bandTopCurr[SBRDEC_MAX_DRC_BANDS];
-  USHORT   bandTopNext[SBRDEC_MAX_DRC_BANDS];
-
-  SHORT    drcInterpolationSchemeCurr;
-  SHORT    drcInterpolationSchemeNext;
-
-  SHORT    enable;
-
-  UCHAR    winSequenceCurr;
-  UCHAR    winSequenceNext;
-
-} SBRDEC_DRC_CHANNEL;
-
-typedef SBRDEC_DRC_CHANNEL * HANDLE_SBR_DRC_CHANNEL;
-
-
-void sbrDecoder_drcInitChannel (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData );
-
-void sbrDecoder_drcUpdateChannel (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData );
-
-void sbrDecoder_drcApplySlot (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData,
-    FIXP_DBL *qmfRealSlot,
-    FIXP_DBL *qmfImagSlot,
-    int  col,
-    int  numQmfSubSamples,
-    int  maxShift );
-
-void sbrDecoder_drcApply (
-    HANDLE_SBR_DRC_CHANNEL  hDrcData,
-    FIXP_DBL **QmfBufferReal,
-    FIXP_DBL **QmfBufferImag,
-    int  numQmfSubSamples,
-    int *scaleFactor );
-
-
-#endif  /* _SBRDEC_DRC_H_ */
diff --git a/libSBRdec/src/sbrdec_freq_sca.cpp b/libSBRdec/src/sbrdec_freq_sca.cpp
deleted file mode 100644
index 8adfbb1..0000000
--- a/libSBRdec/src/sbrdec_freq_sca.cpp
+++ /dev/null
@@ -1,812 +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  Frequency scale calculation  
-*/
-
-#include "sbrdec_freq_sca.h"
-
-#include "transcendent.h"
-#include "sbr_rom.h"
-#include "env_extr.h"
-
-#include "genericStds.h"      /* need log() for debug-code only */
-
-#define MAX_OCTAVE         29
-#define MAX_SECOND_REGION  50
-
-
-static int  numberOfBands(FIXP_SGL bpo_div16, int start, int stop, int warpFlag);
-static void CalcBands(UCHAR * diff, UCHAR start, UCHAR stop, UCHAR num_bands);
-static SBR_ERROR modifyBands(UCHAR max_band, UCHAR * diff, UCHAR length);
-static void cumSum(UCHAR start_value, UCHAR* diff, UCHAR length, UCHAR *start_adress);
-
-
-
-/*!
-  \brief     Retrieve QMF-band where the SBR range starts
-
-  Convert startFreq which was read from the bitstream into a
-  QMF-channel number.
-
-  \return  Number of start band
-*/
-static UCHAR
-getStartBand(UINT   fs,               /*!< Output sampling frequency */
-             UCHAR  startFreq,        /*!< Index to table of possible start bands */
-             UINT   headerDataFlags)  /*!< Info to SBR mode */
-{
-  INT  band;
-  UINT fsMapped;
-
-    fsMapped = fs;
-
-  switch (fsMapped) {
-    case 96000:
-    case 88200:
-      band = FDK_sbrDecoder_sbr_start_freq_88[startFreq];
-      break;
-    case 64000:
-      band = FDK_sbrDecoder_sbr_start_freq_64[startFreq];
-      break;
-    case 48000:
-      band = FDK_sbrDecoder_sbr_start_freq_48[startFreq];
-      break;
-    case 44100:
-      band = FDK_sbrDecoder_sbr_start_freq_44[startFreq];
-      break;
-    case 32000:
-      band = FDK_sbrDecoder_sbr_start_freq_32[startFreq];
-      break;
-    case 24000:
-      band = FDK_sbrDecoder_sbr_start_freq_24[startFreq];
-      break;
-    case 22050:
-      band = FDK_sbrDecoder_sbr_start_freq_22[startFreq];
-      break;
-    case 16000:
-      band = FDK_sbrDecoder_sbr_start_freq_16[startFreq];
-      break;
-    default:
-      band = 255;
-  }
-
-  return band;
-}
-
-
-/*!
-  \brief     Retrieve QMF-band where the SBR range starts
-
-  Convert startFreq which was read from the bitstream into a
-  QMF-channel number.
-
-  \return  Number of start band
-*/
-static UCHAR
-getStopBand(UINT   fs,               /*!< Output sampling frequency */
-            UCHAR  stopFreq,         /*!< Index to table of possible start bands */
-            UINT   headerDataFlags,  /*!< Info to SBR mode */
-            UCHAR  k0)               /*!< Start freq index */
-{
-  UCHAR k2;
-
-  if (stopFreq < 14) {
-    INT    stopMin;
-    UCHAR  diff_tot[MAX_OCTAVE + MAX_SECOND_REGION];
-    UCHAR *diff0 = diff_tot;
-    UCHAR *diff1 = diff_tot+MAX_OCTAVE;
-
-    if (fs < 32000) {
-      stopMin = (((2*6000*2*(64)) / fs) + 1) >> 1;
-    }
-    else {
-      if (fs < 64000) {
-        stopMin = (((2*8000*2*(64)) / fs) + 1) >> 1;
-      }
-      else {
-        stopMin = (((2*10000*2*(64)) / fs) + 1) >> 1;
-      }
-    }
-
-    /*
-      Choose a stop band between k1 and 64 depending on stopFreq (0..13),
-      based on a logarithmic scale.
-      The vectors diff0 and diff1 are used temporarily here.
-    */
-    CalcBands( diff0, stopMin, 64, 13);
-    shellsort( diff0, 13);
-    cumSum(stopMin, diff0, 13, diff1);
-    k2 = diff1[stopFreq];
-  }
-  else if (stopFreq==14)
-    k2 = 2*k0;
-  else
-    k2 = 3*k0;
-
-  /* Limit to Nyquist */
-  if (k2 > (64))
-    k2 = (64);
-
-
-  /* Range checks */
-  /* 1 <= difference <= 48; 1 <= fs <= 96000 */
-  if ( ((k2 - k0) > MAX_FREQ_COEFFS) || (k2 <= k0) ) {
-    return 255;
-  }
-
-  if (headerDataFlags & (SBRDEC_SYNTAX_USAC|SBRDEC_SYNTAX_RSVD50)) {
-    /* 1 <= difference <= 35; 42000 <= fs <= 96000 */
-    if ( (fs >= 42000) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS44100 ) ) {
-      return 255;
-    }
-    /* 1 <= difference <= 32; 46009 <= fs <= 96000 */
-    if ( (fs >= 46009) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS48000 ) ) {
-      return 255;
-    }
-  }
-  else {
-    /* 1 <= difference <= 35; fs == 44100 */
-    if ( (fs == 44100) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS44100 ) ) {
-      return 255;
-    }
-    /* 1 <= difference <= 32; 48000 <= fs <= 96000 */
-    if ( (fs >= 48000) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS48000 ) ) {
-      return 255;
-    }
-  }
-
-  return k2;
-}
-
-
-/*!
-  \brief     Generates master frequency tables
-
-  Frequency tables are calculated according to the selected domain
-  (linear/logarithmic) and granularity.
-  IEC 14496-3 4.6.18.3.2.1
-
-  \return  errorCode, 0 if successful
-*/
-SBR_ERROR
-sbrdecUpdateFreqScale(UCHAR * v_k_master,    /*!< Master table to be created */
-                      UCHAR *numMaster,      /*!< Number of entries in master table */
-                      UINT   fs,             /*!< SBR working sampling rate */
-                      HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Control data from bitstream */
-                      UINT flags)
-{
-  FIXP_SGL bpo_div16;        /* bands_per_octave divided by 16 */
-  INT      dk=0;
-
-  /* Internal variables */
-  UCHAR  k0, k2, i;
-  UCHAR  num_bands0 = 0;
-  UCHAR  num_bands1 = 0;
-  UCHAR  diff_tot[MAX_OCTAVE + MAX_SECOND_REGION];
-  UCHAR *diff0 = diff_tot;
-  UCHAR *diff1 = diff_tot+MAX_OCTAVE;
-  INT    k2_achived;
-  INT    k2_diff;
-  INT    incr=0;
-
-  /*
-    Determine start band
-  */
-  k0 = getStartBand(fs, hHeaderData->bs_data.startFreq, flags);
-  if (k0 == 255) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  /*
-    Determine stop band
-  */
-  k2 = getStopBand(fs, hHeaderData->bs_data.stopFreq, flags, k0);
-  if (k2 == 255) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  if(hHeaderData->bs_data.freqScale>0) { /* Bark */
-    INT k1;
-
-    if(hHeaderData->bs_data.freqScale==1) {
-      bpo_div16 = FL2FXCONST_SGL(12.0f/16.0f);
-    }
-    else if(hHeaderData->bs_data.freqScale==2) {
-      bpo_div16 = FL2FXCONST_SGL(10.0f/16.0f);
-    }
-    else {
-      bpo_div16 =  FL2FXCONST_SGL(8.0f/16.0f);
-    }
-
-
-    if( 1000 * k2 > 2245 * k0 ) { /* Two or more regions */
-      k1 = 2*k0;
-
-      num_bands0 = numberOfBands(bpo_div16, k0, k1, 0);
-      num_bands1 = numberOfBands(bpo_div16, k1, k2, hHeaderData->bs_data.alterScale );
-      if ( num_bands0 < 1) {
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-      if ( num_bands1 < 1 ) {
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-
-      CalcBands(diff0, k0, k1, num_bands0);
-      shellsort( diff0, num_bands0);
-      if (diff0[0] == 0) {
-#ifdef DEBUG_TOOLS
-#endif
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-
-      cumSum(k0, diff0, num_bands0, v_k_master);
-
-      CalcBands(diff1, k1, k2, num_bands1);
-      shellsort( diff1, num_bands1);
-      if(diff0[num_bands0-1] > diff1[0]) {
-        SBR_ERROR err;
-
-        err = modifyBands(diff0[num_bands0-1],diff1, num_bands1);
-        if (err)
-          return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-
-      /* Add 2nd region */
-      cumSum(k1, diff1, num_bands1, &v_k_master[num_bands0]);
-      *numMaster = num_bands0 + num_bands1;     /* Output nr of bands */
-
-    }
-    else { /* Only one region */
-      k1=k2;
-
-      num_bands0 = numberOfBands(bpo_div16, k0, k1, 0);
-      if ( num_bands0 < 1) {
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-      CalcBands(diff0, k0, k1, num_bands0);
-      shellsort(diff0, num_bands0);
-      if (diff0[0] == 0) {
-#ifdef DEBUG_TOOLS
-#endif
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-
-      cumSum(k0, diff0, num_bands0, v_k_master);
-      *numMaster = num_bands0;        /* Output nr of bands */
-
-    }
-  }
-  else { /* Linear mode */
-     if (hHeaderData->bs_data.alterScale==0) {
-        dk = 1;
-        /* FLOOR to get to few number of bands (next lower even number) */
-        num_bands0 = (k2 - k0) & 254;
-      } else {
-        dk = 2;
-        num_bands0 = ( ((k2 - k0) >> 1) + 1 ) & 254; /* ROUND to the closest fit */
-      }
-
-      if (num_bands0 < 1) {
-        return SBRDEC_UNSUPPORTED_CONFIG;
-        /* We must return already here because 'i' can become negative below. */
-      }
-
-      k2_achived = k0 + num_bands0*dk;
-      k2_diff = k2 - k2_achived;
-
-      for(i=0;i<num_bands0;i++)
-        diff_tot[i] = dk;
-
-      /* If linear scale wasn't achieved */
-      /* and we got too wide SBR area */
-      if (k2_diff < 0) {
-          incr = 1;
-          i = 0;
-      }
-
-      /* If linear scale wasn't achieved */
-      /* and we got too small SBR area */
-      if (k2_diff > 0) {
-          incr = -1;
-          i = num_bands0-1;
-      }
-
-      /* Adjust diff vector to get sepc. SBR range */
-      while (k2_diff != 0) {
-        diff_tot[i] = diff_tot[i] - incr;
-        i = i + incr;
-        k2_diff = k2_diff + incr;
-      }
-
-      cumSum(k0, diff_tot, num_bands0, v_k_master);/* cumsum */
-    *numMaster = num_bands0;  /* Output nr of bands */
-  }
-
-  if (*numMaster < 1) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-
-  /*
-    Print out the calculated table
-  */
-
-  return SBRDEC_OK;
-}
-
-
-/*!
-  \brief     Calculate frequency ratio of one SBR band
-
-  All SBR bands should span a constant frequency range in the logarithmic
-  domain. This function calculates the ratio of any SBR band's upper and lower
-  frequency.
-
- \return    num_band-th root of k_start/k_stop
-*/
-static FIXP_SGL calcFactorPerBand(int k_start, int k_stop, int num_bands)
-{
-/* Scaled bandfactor and step 1 bit right to avoid overflow
- * use double data type */
-  FIXP_DBL bandfactor = FL2FXCONST_DBL(0.25f); /* Start value */
-  FIXP_DBL step = FL2FXCONST_DBL(0.125f);      /* Initial increment for factor */
-
-  int    direction = 1;
-
-/* Because saturation can't be done in INT IIS,
- * changed start and stop data type from FIXP_SGL to FIXP_DBL */
-  FIXP_DBL start = k_start << (DFRACT_BITS-8);
-  FIXP_DBL stop = k_stop << (DFRACT_BITS-8);
-
-  FIXP_DBL temp;
-
-  int   j, i=0;
-
-  while ( step > FL2FXCONST_DBL(0.0f)) {
-    i++;
-    temp = stop;
-
-    /* Calculate temp^num_bands: */
-    for (j=0; j<num_bands; j++)
-      //temp = fMult(temp,bandfactor);
-      temp = fMultDiv2(temp,bandfactor)<<2;
-
-    if (temp<start) { /* Factor too strong, make it weaker */
-      if (direction == 0)
-        /* Halfen step. Right shift is not done as fract because otherwise the
-           lowest bit cannot be cleared due to rounding */
-        step = (FIXP_DBL)((LONG)step >> 1);
-      direction = 1;
-      bandfactor = bandfactor + step;
-    }
-    else {  /* Factor is too weak: make it stronger */
-      if (direction == 1)
-        step = (FIXP_DBL)((LONG)step >> 1);
-      direction = 0;
-      bandfactor = bandfactor - step;
-    }
-
-    if (i>100) {
-      step = FL2FXCONST_DBL(0.0f);
-    }
-  }
-  return FX_DBL2FX_SGL(bandfactor<<1);
-}
-
-
-/*!
-  \brief     Calculate number of SBR bands between start and stop band
-
-  Given the number of bands per octave, this function calculates how many
-  bands fit in the given frequency range.
-  When the warpFlag is set, the 'band density' is decreased by a factor
-  of 1/1.3
-
-  \return    number of bands
-*/
-static int
-numberOfBands(FIXP_SGL bpo_div16, /*!< Input: number of bands per octave divided by 16 */
-              int    start,     /*!< First QMF band of SBR frequency range */
-              int    stop,      /*!< Last QMF band of SBR frequency range + 1 */
-              int    warpFlag)  /*!< Stretching flag */
-{
-  FIXP_SGL num_bands_div128;
-  int    num_bands;
-
-  num_bands_div128 = FX_DBL2FX_SGL(fMult(FDK_getNumOctavesDiv8(start,stop),bpo_div16));
-
-  if (warpFlag) {
-    /* Apply the warp factor of 1.3 to get wider bands.  We use a value
-       of 32768/25200 instead of the exact value to avoid critical cases
-       of rounding.
-    */
-    num_bands_div128 = FX_DBL2FX_SGL(fMult(num_bands_div128, FL2FXCONST_SGL(25200.0/32768.0)));
-  }
-
-  /* add scaled 1 for rounding to even numbers: */
-  num_bands_div128 = num_bands_div128 + FL2FXCONST_SGL( 1.0f/128.0f );
-  /* scale back to right aligned integer and double the value: */
-  num_bands = 2 * ((LONG)num_bands_div128 >> (FRACT_BITS - 7));
-
-  return(num_bands);
-}
-
-
-/*!
-  \brief     Calculate width of SBR bands
-
-  Given the desired number of bands within the SBR frequency range,
-  this function calculates the width of each SBR band in QMF channels.
-  The bands get wider from start to stop (bark scale).
-*/
-static void
-CalcBands(UCHAR * diff,    /*!< Vector of widths to be calculated */
-          UCHAR start,     /*!< Lower end of subband range */
-          UCHAR stop,      /*!< Upper end of subband range */
-          UCHAR num_bands) /*!< Desired number of bands */
-{
-  int i;
-  int previous;
-  int current;
-  FIXP_SGL exact, temp;
-  FIXP_SGL bandfactor = calcFactorPerBand(start, stop, num_bands);
-
-  previous = stop; /* Start with highest QMF channel */
-  exact = (FIXP_SGL)(stop << (FRACT_BITS-8)); /* Shift left to gain some accuracy */
-
-  for(i=num_bands-1; i>=0; i--) {
-    /* Calculate border of next lower sbr band */
-    exact = FX_DBL2FX_SGL(fMult(exact,bandfactor));
-
-    /* Add scaled 0.5 for rounding:
-       We use a value 128/256 instead of 0.5 to avoid some critical cases of rounding. */
-    temp = exact +  FL2FXCONST_SGL(128.0/32768.0);
-
-    /* scale back to right alinged integer: */
-    current = (LONG)temp >> (FRACT_BITS-8);
-
-    /* Save width of band i */
-    diff[i] = previous - current;
-    previous = current;
-  }
-}
-
-
-/*!
-  \brief     Calculate cumulated sum vector from delta vector
-*/
-static void
-cumSum(UCHAR start_value, UCHAR* diff, UCHAR length, UCHAR *start_adress)
-{
-  int i;
-  start_adress[0]=start_value;
-  for(i=1; i<=length; i++)
-    start_adress[i] = start_adress[i-1] + diff[i-1];
-}
-
-
-/*!
-  \brief     Adapt width of frequency bands in the second region
-
-  If SBR spans more than 2 octaves, the upper part of a bark-frequency-scale
-  is calculated separately. This function tries to avoid that the second region
-  starts with a band smaller than the highest band of the first region.
-*/
-static SBR_ERROR
-modifyBands(UCHAR max_band_previous, UCHAR * diff, UCHAR length)
-{
-  int change = max_band_previous - diff[0];
-
-  /* Limit the change so that the last band cannot get narrower than the first one */
-  if ( change > (diff[length-1]-diff[0])>>1 )
-    change = (diff[length-1]-diff[0])>>1;
-
-  diff[0] += change;
-  diff[length-1] -= change;
-  shellsort(diff, length);
-
-  return SBRDEC_OK;
-}
-
-
-/*!
-  \brief   Update high resolution frequency band table
-*/
-static void
-sbrdecUpdateHiRes(UCHAR * h_hires,
-                  UCHAR * num_hires,
-                  UCHAR * v_k_master,
-                  UCHAR num_bands,
-                  UCHAR xover_band)
-{
-  UCHAR i;
-
-  *num_hires = num_bands-xover_band;
-
-  for(i=xover_band; i<=num_bands; i++) {
-    h_hires[i-xover_band] = v_k_master[i];
-  }
-}
-
-
-/*!
-  \brief  Build low resolution table out of high resolution table
-*/
-static void
-sbrdecUpdateLoRes(UCHAR * h_lores,
-                  UCHAR * num_lores,
-                  UCHAR * h_hires,
-                  UCHAR num_hires)
-{
-  UCHAR i;
-
-  if( (num_hires & 1) == 0) {
-    /* If even number of hires bands */
-    *num_lores = num_hires >> 1;
-    /* Use every second lores=hires[0,2,4...] */
-    for(i=0; i<=*num_lores; i++)
-      h_lores[i] = h_hires[i*2];
-  }
-  else {
-    /* Odd number of hires, which means xover is odd */
-    *num_lores = (num_hires+1) >> 1;
-    /* Use lores=hires[0,1,3,5 ...] */
-    h_lores[0] = h_hires[0];
-    for(i=1; i<=*num_lores; i++) {
-      h_lores[i] = h_hires[i*2-1];
-    }
-  }
-}
-
-
-/*!
-  \brief   Derive a low-resolution frequency-table from the master frequency table
-*/
-void
-sbrdecDownSampleLoRes(UCHAR *v_result,
-                      UCHAR num_result,
-                      UCHAR *freqBandTableRef,
-                      UCHAR num_Ref)
-{
-  int step;
-  int i,j;
-  int org_length,result_length;
-  int v_index[MAX_FREQ_COEFFS>>1];
-
-  /* init */
-  org_length = num_Ref;
-  result_length = num_result;
-
-  v_index[0] = 0;   /* Always use left border */
-  i=0;
-  while(org_length > 0) {
-    /* Create downsample vector */
-    i++;
-    step = org_length / result_length;
-    org_length = org_length - step;
-    result_length--;
-    v_index[i] = v_index[i-1] + step;
-  }
-
-  for(j=0;j<=i;j++) {
-    /* Use downsample vector to index LoResolution vector */
-    v_result[j]=freqBandTableRef[v_index[j]];
-  }
-
-}
-
-
-/*!
-  \brief   Sorting routine
-*/
-void shellsort(UCHAR *in, UCHAR n)
-{
-
-  int i, j, v, w;
-  int inc = 1;
-
-  do
-    inc = 3 * inc + 1;
-  while (inc <= n);
-
-  do {
-    inc = inc / 3;
-    for (i = inc; i < n; i++) {
-      v = in[i];
-      j = i;
-      while ((w=in[j-inc]) > v) {
-        in[j] = w;
-        j -= inc;
-        if (j < inc)
-          break;
-      }
-      in[j] = v;
-    }
-  } while (inc > 1);
-
-}
-
-
-
-/*!
-  \brief   Reset frequency band tables
-  \return  errorCode, 0 if successful
-*/
-SBR_ERROR
-resetFreqBandTables(HANDLE_SBR_HEADER_DATA hHeaderData, const UINT flags)
-{
-  SBR_ERROR err = SBRDEC_OK;
-  int k2,kx, lsb, usb;
-  int     intTemp;
-  UCHAR    nBandsLo, nBandsHi;
-  HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
-
-  /* Calculate master frequency function */
-  err = sbrdecUpdateFreqScale(hFreq->v_k_master,
-                              &hFreq->numMaster,
-                              hHeaderData->sbrProcSmplRate,
-                              hHeaderData,
-                              flags);
-
-  if ( err || (hHeaderData->bs_info.xover_band > hFreq->numMaster) ) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  /* Derive Hiresolution from master frequency function */
-  sbrdecUpdateHiRes(hFreq->freqBandTable[1], &nBandsHi, hFreq->v_k_master, hFreq->numMaster, hHeaderData->bs_info.xover_band );
-  /* Derive Loresolution from Hiresolution */
-  sbrdecUpdateLoRes(hFreq->freqBandTable[0], &nBandsLo, hFreq->freqBandTable[1], nBandsHi);
-
-
-  hFreq->nSfb[0] = nBandsLo;
-  hFreq->nSfb[1] = nBandsHi;
-
-  /* Check index to freqBandTable[0] */
-  if ( !(nBandsLo > 0) || (nBandsLo > (MAX_FREQ_COEFFS>>1)) ) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  lsb = hFreq->freqBandTable[0][0];
-  usb = hFreq->freqBandTable[0][nBandsLo];
-
-  /* Additional check for lsb */
-  if ( (lsb > (32)) || (lsb >= usb) ) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-
-  /* Calculate number of noise bands */
-
-  k2 = hFreq->freqBandTable[1][nBandsHi];
-  kx = hFreq->freqBandTable[1][0];
-
-  if (hHeaderData->bs_data.noise_bands == 0)
-  {
-    hFreq->nNfb = 1;
-  }
-  else /* Calculate no of noise bands 1,2 or 3 bands/octave */
-  {
-    /* Fetch number of octaves divided by 32 */
-    intTemp = (LONG)FDK_getNumOctavesDiv8(kx,k2) >> 2;
-
-    /* Integer-Multiplication with number of bands: */
-    intTemp = intTemp * hHeaderData->bs_data.noise_bands;
-
-    /* Add scaled 0.5 for rounding: */
-    intTemp = intTemp + (LONG)FL2FXCONST_SGL(0.5f/32.0f);
-
-    /* Convert to right-aligned integer: */
-    intTemp = intTemp >> (FRACT_BITS - 1 /*sign*/ - 5 /* rescale */);
-
-    /* Compare with float calculation */
-    FDK_ASSERT( intTemp ==  (int)((hHeaderData->bs_data.noise_bands * FDKlog( (float)k2/kx) / (float)(FDKlog(2.0)))+0.5) );
-
-    if( intTemp==0)
-      intTemp=1;
-
-    hFreq->nNfb = intTemp;
-  }
-
-  hFreq->nInvfBands = hFreq->nNfb;
-
-  if( hFreq->nNfb > MAX_NOISE_COEFFS ) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  /* Get noise bands */
-  sbrdecDownSampleLoRes(hFreq->freqBandTableNoise,
-                        hFreq->nNfb,
-                        hFreq->freqBandTable[0],
-                        nBandsLo);
-
-
-
-
-  hFreq->lowSubband  = lsb;
-  hFreq->highSubband = usb;
-
-  return SBRDEC_OK;
-}
diff --git a/libSBRdec/src/sbrdec_freq_sca.h b/libSBRdec/src/sbrdec_freq_sca.h
deleted file mode 100644
index cfe4f0e..0000000
--- a/libSBRdec/src/sbrdec_freq_sca.h
+++ /dev/null
@@ -1,107 +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   Frequency scale prototypes  
-*/
-#ifndef __FREQ_SCA_H
-#define __FREQ_SCA_H
-
-#include "sbrdecoder.h"
-#include "env_extr.h"
-
-int
-sbrdecUpdateFreqScale(UCHAR * v_k_master,
-                      UCHAR *numMaster,
-                      HANDLE_SBR_HEADER_DATA headerData);
-
-void sbrdecDownSampleLoRes(UCHAR *v_result, UCHAR num_result,
-                           UCHAR *freqBandTableRef, UCHAR num_Ref);
-
-void shellsort(UCHAR *in, UCHAR n);
-
-SBR_ERROR
-resetFreqBandTables(HANDLE_SBR_HEADER_DATA hHeaderData, const UINT flags);
-
-#endif
diff --git a/libSBRdec/src/sbrdecoder.cpp b/libSBRdec/src/sbrdecoder.cpp
deleted file mode 100644
index 26b2ea2..0000000
--- a/libSBRdec/src/sbrdecoder.cpp
+++ /dev/null
@@ -1,1546 +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  SBR decoder frontend
-  This module provides a frontend to the SBR decoder. The function openSBR() is called for
-  initialization. The function sbrDecoder_Apply() is called for each frame. sbr_Apply() will call the
-  required functions to decode the raw SBR data (provided by env_extr.cpp), to decode the envelope data and noise floor levels [decodeSbrData()],
-  and to finally apply SBR to the current frame [sbr_dec()].
-
-  \sa sbrDecoder_Apply(), \ref documentationOverview
-*/
-
-/*!
-  \page documentationOverview Overview of important information resources and source code documentation
-
-  The primary source code documentation is based on generated and cross-referenced HTML files using
-  <a HREF="http://www.doxygen.org">doxygen</a>. As part of this documentation
-  you can find more extensive descriptions about key concepts and algorithms at the following locations:
-
-  <h2>Programming</h2>
-
-  \li Buffer management: sbrDecoder_Apply() and sbr_dec()
-  \li Internal scale factors to maximize SNR on fixed point processors: #QMF_SCALE_FACTOR
-  \li Special mantissa-exponent format: Created in requantizeEnvelopeData() and used in calculateSbrEnvelope()
-
-  <h2>Algorithmic details</h2>
-  \li About the SBR data format: \ref SBR_HEADER_ELEMENT and \ref SBR_STANDARD_ELEMENT
-  \li Details about the bitstream decoder: env_extr.cpp
-  \li Details about the QMF filterbank and the provided polyphase implementation: qmf_dec.cpp
-  \li Details about the transposer: lpp_tran.cpp
-  \li Details about the envelope adjuster: env_calc.cpp
-
-*/
-
-#include "sbrdecoder.h"
-
-#include "FDK_bitstream.h"
-
-#include "sbrdec_freq_sca.h"
-#include "env_extr.h"
-#include "sbr_dec.h"
-#include "env_dec.h"
-#include "sbr_crc.h"
-#include "sbr_ram.h"
-#include "sbr_rom.h"
-#include "lpp_tran.h"
-#include "transcendent.h"
-
-
-#include "sbrdec_drc.h"
-
-#include "psbitdec.h"
-
-
-/* Decoder library info */
-#define SBRDECODER_LIB_VL0 2
-#define SBRDECODER_LIB_VL1 2
-#define SBRDECODER_LIB_VL2 3
-#define SBRDECODER_LIB_TITLE "SBR Decoder"
-#define SBRDECODER_LIB_BUILD_DATE __DATE__
-#define SBRDECODER_LIB_BUILD_TIME __TIME__
-
-
-
-
-static UCHAR getHeaderSlot( UCHAR currentSlot, UCHAR hdrSlotUsage[(1)+1] )
-{
-  UINT  occupied = 0;
-  int   s;
-  UCHAR slot = hdrSlotUsage[currentSlot];
-
-  FDK_ASSERT((1)+1 < 32);
-
-  for (s = 0; s < (1)+1; s++) {
-    if ( (hdrSlotUsage[s] == slot)
-      && (s != slot) ) {
-      occupied = 1;
-      break;
-    }
-  }
-
-  if (occupied) {
-    occupied = 0;
-
-    for (s = 0; s < (1)+1; s++) {
-      occupied |= 1 << hdrSlotUsage[s];
-    }
-    for (s = 0; s < (1)+1; s++) {
-      if ( !(occupied & 0x1) ) {
-        slot = s;
-        break;
-      }
-      occupied >>= 1;
-    }
-  }
-
-  return slot;
-}
-
-static void copySbrHeader( HANDLE_SBR_HEADER_DATA hDst, const HANDLE_SBR_HEADER_DATA hSrc )
-{
-  /* copy the whole header memory (including pointers) */
-  FDKmemcpy( hDst, hSrc, sizeof(SBR_HEADER_DATA) );
-
-  /* update pointers */
-  hDst->freqBandData.freqBandTable[0]  = hDst->freqBandData.freqBandTableLo;
-  hDst->freqBandData.freqBandTable[1] = hDst->freqBandData.freqBandTableHi;
-}
-
-
-/*!
-  \brief Reset SBR decoder.
-
-  Reset should only be called if SBR has been sucessfully detected by
-  an appropriate checkForPayload() function.
-
-  \return Error code.
-*/
-static
-SBR_ERROR sbrDecoder_ResetElement (
-        HANDLE_SBRDECODER    self,
-        int                  sampleRateIn,
-        int                  sampleRateOut,
-        int                  samplesPerFrame,
-        const MP4_ELEMENT_ID elementID,
-        const int            elementIndex,
-        const int            overlap
-        )
-{
-  SBR_ERROR sbrError = SBRDEC_OK;
-  HANDLE_SBR_HEADER_DATA hSbrHeader;
-  UINT qmfFlags = 0;
-
-  int i, synDownsampleFac;
-
-  /* Check in/out samplerates */
-  if ( sampleRateIn < 6400
-    || sampleRateIn > 48000
-     )
-  {
-    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-    goto bail;
-  }
-
-  if ( sampleRateOut > 96000 )
-  {
-    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-    goto bail;
-  }
-
-  /* Set QMF mode flags */
-  if (self->flags & SBRDEC_LOW_POWER)
-    qmfFlags |= QMF_FLAG_LP;
-
-  if (self->coreCodec == AOT_ER_AAC_ELD) {
-    if (self->flags & SBRDEC_LD_MPS_QMF) {
-      qmfFlags |=  QMF_FLAG_MPSLDFB;
-    } else {
-      qmfFlags |=  QMF_FLAG_CLDFB;
-    }
-  }
-
-  /* Set downsampling factor for synthesis filter bank */
-  if (sampleRateOut == 0)
-  {
-    /* no single rate mode */
-      sampleRateOut = sampleRateIn<<1; /* In case of implicit signalling, assume dual rate SBR */
-  }
-
-  if ( sampleRateIn == sampleRateOut ) {
-    synDownsampleFac = 2;
-  } else {
-    synDownsampleFac = 1;
-  }
-
-  self->synDownsampleFac = synDownsampleFac;
-  self->sampleRateOut = sampleRateOut;
-
-  {
-    int i;
-
-    for (i = 0; i < (1)+1; i++)
-    {
-      hSbrHeader = &(self->sbrHeader[elementIndex][i]);
-
-      /* init a default header such that we can at least do upsampling later */
-      sbrError = initHeaderData(
-              hSbrHeader,
-              sampleRateIn,
-              sampleRateOut,
-              samplesPerFrame,
-              self->flags
-              );
-    }
-  }
-
-  if (sbrError != SBRDEC_OK) {
-    goto bail;
-  }
-
-  /* Init SBR channels going to be assigned to a SBR element */
-  {
-    int ch;
-
-    for (ch=0; ch<self->pSbrElement[elementIndex]->nChannels; ch++)
-    {
-      /* and create sbrDec */
-      sbrError = createSbrDec (self->pSbrElement[elementIndex]->pSbrChannel[ch],
-                          hSbrHeader,
-                         &self->pSbrElement[elementIndex]->transposerSettings,
-                          synDownsampleFac,
-                          qmfFlags,
-                          self->flags,
-                          overlap,
-                          ch );
-
-      if (sbrError != SBRDEC_OK) {
-        goto bail;
-      }
-    }
-  }
-
-  //FDKmemclear(sbr_OverlapBuffer, sizeof(sbr_OverlapBuffer));
-
-  if (self->numSbrElements == 1) {
-    switch ( self->coreCodec ) {
-    case AOT_AAC_LC:
-    case AOT_SBR:
-    case AOT_PS:
-    case AOT_ER_AAC_SCAL:
-    case AOT_DRM_AAC:
-    case AOT_DRM_SURROUND:
-      if (CreatePsDec ( &self->hParametricStereoDec, samplesPerFrame )) {
-        sbrError = SBRDEC_CREATE_ERROR;
-        goto bail;
-      }
-      break;
-    default:
-      break;
-    }
-  }
-
-  /* Init frame delay slot handling */
-  self->pSbrElement[elementIndex]->useFrameSlot = 0;
-  for (i = 0; i < ((1)+1); i++) {
-    self->pSbrElement[elementIndex]->useHeaderSlot[i] = i;
-  }
-
-bail:
-
-  return sbrError;
-}
-
-
-SBR_ERROR sbrDecoder_Open ( HANDLE_SBRDECODER  * pSelf )
-{
-  HANDLE_SBRDECODER    self = NULL;
-  SBR_ERROR sbrError = SBRDEC_OK;
-
-  /* Get memory for this instance */
-  self = GetRam_SbrDecoder();
-  if (self == NULL) {
-    sbrError = SBRDEC_MEM_ALLOC_FAILED;
-    goto bail;
-  }
-
-  self->workBuffer1 = GetRam_SbrDecWorkBuffer1();
-  self->workBuffer2 = GetRam_SbrDecWorkBuffer2();
-
-  if (  self->workBuffer1 == NULL
-     || self->workBuffer2 == NULL )
-  {
-    sbrError = SBRDEC_MEM_ALLOC_FAILED;
-    goto bail;
-  }
-
-  /*
-  Already zero because of calloc
-  self->numSbrElements = 0;
-  self->numSbrChannels = 0;
-  self->codecFrameSize = 0;
-  */
-
-  self->numDelayFrames = (1);  /* set to the max value by default */
-
-  *pSelf = self;
-
-bail:
-  return sbrError;
-}
-
-/**
- * \brief determine if the given core codec AOT can be processed or not.
- * \param coreCodec core codec audio object type.
- * \return 1 if SBR can be processed, 0 if SBR cannot be processed/applied.
- */
-static
-int sbrDecoder_isCoreCodecValid(AUDIO_OBJECT_TYPE coreCodec)
-{
-  switch (coreCodec) {
-    case AOT_AAC_LC:
-    case AOT_SBR:
-    case AOT_PS:
-    case AOT_ER_AAC_SCAL:
-    case AOT_ER_AAC_ELD:
-      return 1;
-    default:
-      return 0;
-  }
-}
-
-static
-void sbrDecoder_DestroyElement (
-        HANDLE_SBRDECODER       self,
-        const int               elementIndex
-        )
-{
-  if (self->pSbrElement[elementIndex] != NULL) {
-    int ch;
-
-    for (ch=0; ch<SBRDEC_MAX_CH_PER_ELEMENT; ch++) {
-      if (self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) {
-        deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] );
-        FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] );
-        self->numSbrChannels -= 1;
-      }
-    }
-    FreeRam_SbrDecElement( &self->pSbrElement[elementIndex] );
-    self->numSbrElements -= 1;
-  }
-}
-
-
-SBR_ERROR sbrDecoder_InitElement (
-        HANDLE_SBRDECODER       self,
-        const int               sampleRateIn,
-        const int               sampleRateOut,
-        const int               samplesPerFrame,
-        const AUDIO_OBJECT_TYPE coreCodec,
-        const MP4_ELEMENT_ID    elementID,
-        const int               elementIndex
-        )
-{
-  SBR_ERROR sbrError = SBRDEC_OK;
-  int chCnt=0;
-  int nSbrElementsStart = self->numSbrElements;
-
-  /* Check core codec AOT */
-  if (! sbrDecoder_isCoreCodecValid(coreCodec) || elementIndex >= (4)) {
-    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-    goto bail;
-  }
-
-  if ( elementID != ID_SCE && elementID != ID_CPE && elementID != ID_LFE )
-  {
-    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
-    goto bail;
-  }
-
-  if (  self->sampleRateIn == sampleRateIn
-     && self->codecFrameSize == samplesPerFrame
-     && self->coreCodec == coreCodec
-     && self->pSbrElement[elementIndex] != NULL
-     && self->pSbrElement[elementIndex]->elementID == elementID
-     )
-  {
-     /* Nothing to do */
-     return SBRDEC_OK;
-  }
-
-  self->sampleRateIn = sampleRateIn;
-  self->codecFrameSize = samplesPerFrame;
-  self->coreCodec = coreCodec;
-
-  self->flags = 0;
-  self->flags |= (coreCodec == AOT_ER_AAC_ELD) ? SBRDEC_ELD_GRID : 0;
-
-  /* Init SBR elements */
-  {
-    int elChannels, ch;
-
-    if (self->pSbrElement[elementIndex] == NULL) {
-      self->pSbrElement[elementIndex] = GetRam_SbrDecElement(elementIndex);
-      if (self->pSbrElement[elementIndex] == NULL) {
-        sbrError = SBRDEC_MEM_ALLOC_FAILED;
-        goto bail;
-      }
-      self->numSbrElements ++;
-    } else {
-      self->numSbrChannels -= self->pSbrElement[elementIndex]->nChannels;
-    }
-
-    /* Save element ID for sanity checks and to have a fallback for concealment. */
-    self->pSbrElement[elementIndex]->elementID = elementID;
-
-    /* Determine amount of channels for this element */
-    switch (elementID) {
-      case ID_NONE:
-      case ID_CPE: elChannels=2;
-        break;
-      case ID_LFE:
-      case ID_SCE: elChannels=1;
-        break;
-      default: elChannels=0;
-        break;
-    }
-
-    /* Handle case of Parametric Stereo */
-    if ( elementIndex == 0 && elementID == ID_SCE ) {
-      switch (coreCodec) {
-        case AOT_AAC_LC:
-        case AOT_SBR:
-        case AOT_PS:
-        case AOT_ER_AAC_SCAL:
-        case AOT_DRM_AAC:
-        case AOT_DRM_SURROUND:
-          elChannels = 2;
-          break;
-        default:
-          break;
-      }
-    }
-
-    self->pSbrElement[elementIndex]->nChannels = elChannels;
-
-    for (ch=0; ch<elChannels; ch++)
-    {
-      if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
-        self->pSbrElement[elementIndex]->pSbrChannel[ch] = GetRam_SbrDecChannel(chCnt);
-        if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
-          sbrError = SBRDEC_MEM_ALLOC_FAILED;
-          goto bail;
-        }
-      }
-      self->numSbrChannels ++;
-
-      sbrDecoder_drcInitChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.sbrDrcChannel );
-
-      /* Add reference pointer to workbuffers. */
-      self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer1 = self->workBuffer1;
-      self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer2 = self->workBuffer2;
-      chCnt++;
-    }
-    if (elChannels == 1 && self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) {
-      deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] );
-      FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] );
-    }
-  }
-
-  /* clear error flags for all delay slots */
-  FDKmemclear(self->pSbrElement[elementIndex]->frameErrorFlag, ((1)+1)*sizeof(UCHAR));
-
-  /* Initialize this instance */
-  sbrError = sbrDecoder_ResetElement(
-          self,
-          sampleRateIn,
-          sampleRateOut,
-          samplesPerFrame,
-          elementID,
-          elementIndex,
-          (coreCodec == AOT_ER_AAC_ELD) ? 0 : (6)
-          );
-
-
-
-bail:
-  if (sbrError != SBRDEC_OK) {
-    if (nSbrElementsStart < self->numSbrElements) {
-      /* Free the memory allocated for this element */
-      sbrDecoder_DestroyElement( self, elementIndex );
-    } else if (self->pSbrElement[elementIndex] != NULL) {
-      /* Set error flag to trigger concealment */
-      self->pSbrElement[elementIndex]->frameErrorFlag[self->pSbrElement[elementIndex]->useFrameSlot] = 1;
-    }
-  }
-
-  return sbrError;
-}
-
-/**
- * \brief Apply decoded SBR header for one element.
- * \param self SBR decoder instance handle
- * \param hSbrHeader SBR header handle to be processed.
- * \param hSbrChannel pointer array to the SBR element channels corresponding to the SBR header.
- * \param headerStatus header status value returned from SBR header parser.
- * \param numElementChannels amount of channels for the SBR element whos header is to be processed.
- */
-static
-SBR_ERROR sbrDecoder_HeaderUpdate(
-        HANDLE_SBRDECODER self,
-        HANDLE_SBR_HEADER_DATA hSbrHeader,
-        SBR_HEADER_STATUS headerStatus,
-        HANDLE_SBR_CHANNEL hSbrChannel[],
-        const int numElementChannels
-        )
-{
-  SBR_ERROR errorStatus = SBRDEC_OK;
-
-  /*
-    change of control data, reset decoder
-  */
-  errorStatus = resetFreqBandTables(hSbrHeader, self->flags);
-
-  if (errorStatus == SBRDEC_OK) {
-    if (hSbrHeader->syncState == UPSAMPLING && headerStatus != HEADER_RESET)
-    {
-      /* As the default header would limit the frequency range,
-         lowSubband and highSubband must be patched. */
-      hSbrHeader->freqBandData.lowSubband = hSbrHeader->numberOfAnalysisBands;
-      hSbrHeader->freqBandData.highSubband = hSbrHeader->numberOfAnalysisBands;
-    }
-
-    /* Trigger a reset before processing this slot */
-    hSbrHeader->status |= SBRDEC_HDR_STAT_RESET;
-  }
-
-  return errorStatus;
-}
-
-INT sbrDecoder_Header (
-        HANDLE_SBRDECODER       self,
-        HANDLE_FDK_BITSTREAM    hBs,
-        const INT sampleRateIn,
-        const INT sampleRateOut,
-        const INT samplesPerFrame,
-        const AUDIO_OBJECT_TYPE coreCodec,
-        const MP4_ELEMENT_ID    elementID,
-        const INT               elementIndex
-        )
-{
-  SBR_HEADER_STATUS headerStatus;
-  HANDLE_SBR_HEADER_DATA hSbrHeader;
-  SBR_ERROR sbrError = SBRDEC_OK;
-  int headerIndex;
-
-  if ( self == NULL || elementIndex > (4) )
-  {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  if (! sbrDecoder_isCoreCodecValid(coreCodec)) {
-    return SBRDEC_UNSUPPORTED_CONFIG;
-  }
-
-  sbrError = sbrDecoder_InitElement(
-          self,
-          sampleRateIn,
-          sampleRateOut,
-          samplesPerFrame,
-          coreCodec,
-          elementID,
-          elementIndex
-          );
-
-  if (sbrError != SBRDEC_OK) {
-    goto bail;
-  }
-
-  headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
-                              self->pSbrElement[elementIndex]->useHeaderSlot);
-  hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
-
-  headerStatus = sbrGetHeaderData ( hSbrHeader,
-                                    hBs,
-                                    self->flags,
-                                    0);
-
-
-  {
-    SBR_DECODER_ELEMENT *pSbrElement;
-
-    pSbrElement = self->pSbrElement[elementIndex];
-
-    /* Sanity check */
-    if (pSbrElement != NULL) {
-      if ( (elementID == ID_CPE && pSbrElement->nChannels != 2)
-        || (elementID != ID_CPE && pSbrElement->nChannels != 1) )
-      {
-        return SBRDEC_UNSUPPORTED_CONFIG;
-      }
-      if ( headerStatus == HEADER_RESET ) {
-
-        sbrError = sbrDecoder_HeaderUpdate(
-              self,
-              hSbrHeader,
-              headerStatus,
-              pSbrElement->pSbrChannel,
-              pSbrElement->nChannels
-              );
-
-        if (sbrError == SBRDEC_OK) {
-          hSbrHeader->syncState = SBR_HEADER;
-          hSbrHeader->status   |= SBRDEC_HDR_STAT_UPDATE;
-        }
-        /* else {
-          Since we already have overwritten the old SBR header the only way out is UPSAMPLING!
-          This will be prepared in the next step.
-        } */
-      }
-    }
-  }
-bail:
-  return sbrError;
-}
-
-
-SBR_ERROR sbrDecoder_SetParam (HANDLE_SBRDECODER   self,
-                               const SBRDEC_PARAM  param,
-                               const INT           value )
-{
-  SBR_ERROR errorStatus = SBRDEC_OK;
-
-  /* configure the subsystems */
-  switch (param)
-  {
-  case SBR_SYSTEM_BITSTREAM_DELAY:
-    if (value < 0 || value > (1)) {
-      errorStatus = SBRDEC_SET_PARAM_FAIL;
-      break;
-    }
-    if (self == NULL) {
-      errorStatus = SBRDEC_NOT_INITIALIZED;
-    } else {
-      self->numDelayFrames = (UCHAR)value;
-    }
-    break;
-  case SBR_QMF_MODE:
-    if (self == NULL) {
-      errorStatus = SBRDEC_NOT_INITIALIZED;
-    } else {
-      if (value == 1) {
-        self->flags |= SBRDEC_LOW_POWER;
-      } else {
-        self->flags &= ~SBRDEC_LOW_POWER;
-      }
-    }
-    break;
-  case SBR_LD_QMF_TIME_ALIGN:
-    if (self == NULL) {
-      errorStatus = SBRDEC_NOT_INITIALIZED;
-    } else {
-      if (value == 1) {
-        self->flags |= SBRDEC_LD_MPS_QMF;
-      } else {
-        self->flags &= ~SBRDEC_LD_MPS_QMF;
-      }
-    }
-    break;
-  case SBR_BS_INTERRUPTION:
-    {
-      int elementIndex;
-
-      if (self == NULL) {
-        errorStatus = SBRDEC_NOT_INITIALIZED;
-        break;
-      }
-
-      /* Loop over SBR elements */
-      for (elementIndex = 0; elementIndex < self->numSbrElements; elementIndex++)
-      {
-        HANDLE_SBR_HEADER_DATA hSbrHeader;
-        int headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
-                                        self->pSbrElement[elementIndex]->useHeaderSlot);
-
-        hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
-
-        /* Set sync state UPSAMPLING for the corresponding slot.
-           This switches off bitstream parsing until a new header arrives. */
-        hSbrHeader->syncState = UPSAMPLING;
-        hSbrHeader->status   |= SBRDEC_HDR_STAT_UPDATE;
-      }
-    }
-    break;
-  default:
-    errorStatus = SBRDEC_SET_PARAM_FAIL;
-    break;
-  }  /* switch(param) */
-
-  return (errorStatus);
-}
-
-static
-SBRDEC_DRC_CHANNEL * sbrDecoder_drcGetChannel( const HANDLE_SBRDECODER self, const INT channel )
-{
-  SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
-  int elementIndex, elChanIdx=0, numCh=0;
-
-  for (elementIndex = 0; (elementIndex < (4)) && (numCh <= channel); elementIndex++)
-  {
-    SBR_DECODER_ELEMENT *pSbrElement = self->pSbrElement[elementIndex];
-    int c, elChannels;
-
-    elChanIdx = 0;
-    if (pSbrElement == NULL) break;
-
-    /* Determine amount of channels for this element */
-    switch (pSbrElement->elementID) {
-      case ID_CPE: elChannels = 2;
-        break;
-      case ID_LFE:
-      case ID_SCE: elChannels = 1;
-        break;
-      case ID_NONE:
-      default: elChannels = 0;
-        break;
-    }
-
-    /* Limit with actual allocated element channels */
-    elChannels = FDKmin(elChannels, pSbrElement->nChannels);
-
-    for (c = 0; (c < elChannels) && (numCh <= channel); c++) {
-      if (pSbrElement->pSbrChannel[elChanIdx] != NULL) {
-        numCh++;
-        elChanIdx++;
-      }
-    }
-  }
-  elementIndex -= 1;
-  elChanIdx -= 1;
-
-  if (elChanIdx < 0 || elementIndex < 0) {
-    return NULL;
-  }
-
-  if ( self->pSbrElement[elementIndex] != NULL ) {
-    if ( self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx] != NULL )
-    {
-      pSbrDrcChannelData = &self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx]->SbrDec.sbrDrcChannel;
-    }
-  }
-
-  return (pSbrDrcChannelData);
-}
-
-SBR_ERROR sbrDecoder_drcFeedChannel ( HANDLE_SBRDECODER  self,
-                                      INT                ch,
-                                      UINT               numBands,
-                                      FIXP_DBL          *pNextFact_mag,
-                                      INT                nextFact_exp,
-                                      SHORT              drcInterpolationScheme,
-                                      UCHAR              winSequence,
-                                      USHORT            *pBandTop )
-{
-  SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
-  int band, isValidData = 0;
-
-  if (self == NULL) {
-    return SBRDEC_NOT_INITIALIZED;
-  }
-  if (ch > (6) || pNextFact_mag == NULL) {
-    return SBRDEC_SET_PARAM_FAIL;
-  }
-
-  /* Search for gain values different to 1.0f */
-  for (band = 0; band < numBands; band += 1) {
-    if ( !((pNextFact_mag[band] == FL2FXCONST_DBL(0.5))  && (nextFact_exp == 1))
-      && !((pNextFact_mag[band] == (FIXP_DBL)MAXVAL_DBL) && (nextFact_exp == 0)) ) {
-      isValidData = 1;
-      break;
-    }
-  }
-
-  /* Find the right SBR channel */
-  pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch );
-
-  if ( pSbrDrcChannelData != NULL ) {
-    if ( pSbrDrcChannelData->enable || isValidData )
-  { /* Activate processing only with real and valid data */
-    int i;
-
-    pSbrDrcChannelData->enable   = 1;
-    pSbrDrcChannelData->numBandsNext = numBands;
-
-    pSbrDrcChannelData->winSequenceNext            = winSequence;
-    pSbrDrcChannelData->drcInterpolationSchemeNext = drcInterpolationScheme;
-    pSbrDrcChannelData->nextFact_exp               = nextFact_exp;
-
-    for (i = 0; i < (int)numBands; i++) {
-      pSbrDrcChannelData->bandTopNext[i]  = pBandTop[i];
-      pSbrDrcChannelData->nextFact_mag[i] = pNextFact_mag[i];
-    }
-  }
-  }
-
-  return SBRDEC_OK;
-}
-
-
-void sbrDecoder_drcDisable ( HANDLE_SBRDECODER  self,
-                             INT                ch )
-{
-  SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
-
-  if ( (self == NULL)
-    || (ch > (6))
-    || (self->numSbrElements == 0)
-    || (self->numSbrChannels == 0) ) {
-    return;
-  }
-
-  /* Find the right SBR channel */
-  pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch );
-
-  if ( pSbrDrcChannelData != NULL ) {
-    sbrDecoder_drcInitChannel( pSbrDrcChannelData );
-  }
-}
-
-
-
-SBR_ERROR sbrDecoder_Parse(
-        HANDLE_SBRDECODER self,
-        HANDLE_FDK_BITSTREAM  hBs,
-        int *count,
-        int  bsPayLen,
-        int  crcFlag,
-        MP4_ELEMENT_ID prevElement,
-        int elementIndex,
-        int fGlobalIndependencyFlag
-        )
-{
-  SBR_DECODER_ELEMENT   *hSbrElement;
-  HANDLE_SBR_HEADER_DATA hSbrHeader;
-  HANDLE_SBR_CHANNEL    *pSbrChannel;
-
-  SBR_FRAME_DATA *hFrameDataLeft;
-  SBR_FRAME_DATA *hFrameDataRight;
-
-  SBR_ERROR errorStatus = SBRDEC_OK;
-  SBR_SYNC_STATE initialSyncState;
-  SBR_HEADER_STATUS headerStatus = HEADER_NOT_PRESENT;
-
-  INT  startPos;
-  INT  CRCLen = 0;
-
-  int  stereo;
-  int  fDoDecodeSbrData = 1;
-
-  int lastSlot, lastHdrSlot = 0, thisHdrSlot;
-
-  /* Remember start position of  SBR element */
-  startPos = FDKgetValidBits(hBs);
-
-  /* SBR sanity checks */
-  if ( self == NULL || self->pSbrElement[elementIndex] == NULL ) {
-    errorStatus = SBRDEC_NOT_INITIALIZED;
-    goto bail;
-  } 
-
-  hSbrElement = self->pSbrElement[elementIndex];
-
-  lastSlot    = (hSbrElement->useFrameSlot > 0) ? hSbrElement->useFrameSlot-1 : self->numDelayFrames;
-  lastHdrSlot =  hSbrElement->useHeaderSlot[lastSlot];
-  thisHdrSlot =  getHeaderSlot( hSbrElement->useFrameSlot, hSbrElement->useHeaderSlot );  /* Get a free header slot not used by frames not processed yet. */
-
-  /* Assign the free slot to store a new header if there is one. */
-  hSbrHeader = &self->sbrHeader[elementIndex][thisHdrSlot];
-
-  pSbrChannel = hSbrElement->pSbrChannel;
-  stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
-
-  hFrameDataLeft  = &self->pSbrElement[elementIndex]->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
-  hFrameDataRight = &self->pSbrElement[elementIndex]->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
-
-  initialSyncState = hSbrHeader->syncState;
-
-  /* reset PS flag; will be set after PS was found */
-  self->flags &= ~SBRDEC_PS_DECODED;
-
-  if (hSbrHeader->status & SBRDEC_HDR_STAT_UPDATE) {
-    /* Got a new header from extern (e.g. from an ASC) */
-    headerStatus = HEADER_OK;
-    hSbrHeader->status &= ~SBRDEC_HDR_STAT_UPDATE;
-  }
-  else if (thisHdrSlot != lastHdrSlot) {
-    /* Copy the last header into this slot otherwise the
-       header compare will trigger more HEADER_RESETs than needed. */
-    copySbrHeader( hSbrHeader, &self->sbrHeader[elementIndex][lastHdrSlot] );
-  }
-
-  /*
-     Check if bit stream data is valid and matches the element context
-  */
-  if ( ((prevElement != ID_SCE) && (prevElement != ID_CPE)) || prevElement != hSbrElement->elementID) {
-    /* In case of LFE we also land here, since there is no LFE SBR element (do upsampling only) */
-    fDoDecodeSbrData = 0;
-  }
-
-  if (fDoDecodeSbrData)
-  {
-    if ((INT)FDKgetValidBits(hBs) <= 0) {
-      fDoDecodeSbrData = 0;
-    }
-  }
-
-  /*
-     SBR CRC-check
-  */
-  if (fDoDecodeSbrData)
-  {
-    if (crcFlag == 1) {
-      switch (self->coreCodec) {
-      case AOT_ER_AAC_ELD:
-        FDKpushFor (hBs, 10);
-        /* check sbrcrc later: we don't know the payload length now */
-        break;
-      default:
-        CRCLen = bsPayLen - 10;                     /* change: 0 => i */
-        if (CRCLen < 0) {
-          fDoDecodeSbrData = 0;
-        } else {
-          fDoDecodeSbrData = SbrCrcCheck (hBs, CRCLen);
-        }
-        break;
-      }
-    }
-  } /* if (fDoDecodeSbrData) */
-
-  /*
-     Read in the header data and issue a reset if change occured
-  */
-  if (fDoDecodeSbrData)
-  {
-    int sbrHeaderPresent;
-
-    {
-      sbrHeaderPresent = FDKreadBit(hBs);
-    }
-
-    if ( sbrHeaderPresent ) {
-      headerStatus = sbrGetHeaderData (hSbrHeader,
-                                       hBs,
-                                       self->flags,
-                                       1);
-    }
-
-    if (headerStatus == HEADER_RESET)
-    {
-      errorStatus = sbrDecoder_HeaderUpdate(
-            self,
-            hSbrHeader,
-            headerStatus,
-            pSbrChannel,
-            hSbrElement->nChannels 
-            );
-
-      if (errorStatus == SBRDEC_OK) {
-        hSbrHeader->syncState = SBR_HEADER;
-      } else {
-        hSbrHeader->syncState = SBR_NOT_INITIALIZED;
-      }
-    }
-
-    if (errorStatus != SBRDEC_OK) {
-      fDoDecodeSbrData = 0;
-    }
-  } /* if (fDoDecodeSbrData) */
-
-  /*
-    Print debugging output only if state has changed
-  */
-
-  /* read frame data */
-  if ((hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) {
-    int sbrFrameOk;
-    /* read the SBR element data */
-    if (stereo) {
-      sbrFrameOk = sbrGetChannelPairElement(hSbrHeader,
-                                            hFrameDataLeft,
-                                            hFrameDataRight,
-                                            hBs,
-                                            self->flags,
-                                            self->pSbrElement[elementIndex]->transposerSettings.overlap);
-    }
-    else {
-      if (self->hParametricStereoDec != NULL) {
-        /* update slot index for PS bitstream parsing */
-        self->hParametricStereoDec->bsLastSlot = self->hParametricStereoDec->bsReadSlot;
-        self->hParametricStereoDec->bsReadSlot = hSbrElement->useFrameSlot;
-      }
-      sbrFrameOk = sbrGetSingleChannelElement(hSbrHeader,
-                                              hFrameDataLeft,
-                                              hBs,
-                                              self->hParametricStereoDec,
-                                              self->flags,
-                                              self->pSbrElement[elementIndex]->transposerSettings.overlap);
-    }
-    if (!sbrFrameOk) {
-      fDoDecodeSbrData = 0;
-    }
-    else {
-      INT valBits;
-
-      if (bsPayLen > 0) {
-        valBits = bsPayLen - ((INT)startPos - (INT)FDKgetValidBits(hBs));
-      } else {
-        valBits = (INT)FDKgetValidBits(hBs);
-      }
-
-      if ( crcFlag == 1 ) {
-        switch (self->coreCodec) {
-        case AOT_ER_AAC_ELD:
-          {
-            /* late crc check for eld */
-            INT payloadbits = (INT)startPos - (INT)FDKgetValidBits(hBs) - startPos;
-            INT crcLen      = payloadbits - 10;
-            FDKpushBack(hBs, payloadbits);
-            fDoDecodeSbrData      = SbrCrcCheck (hBs, crcLen);
-            FDKpushFor(hBs, crcLen);
-          }
-          break;
-        default:
-          break;
-        }
-      }
-
-      /* sanity check of remaining bits */
-      if (valBits < 0) {
-        fDoDecodeSbrData = 0;
-      } else {
-        switch (self->coreCodec) {
-        case AOT_SBR:
-        case AOT_PS:
-        case AOT_AAC_LC:
-          {
-            /* This sanity check is only meaningful with General Audio bitstreams */
-            int alignBits = valBits & 0x7;
-
-            if (valBits > alignBits) {
-              fDoDecodeSbrData = 0;
-            }
-          }
-          break;
-        default:
-          /* No sanity check available */
-          break;
-        }
-      }
-    }
-  }
-
-  if (!fDoDecodeSbrData) {
-    /* Set error flag for this slot to trigger concealment */
-    self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 1;
-    errorStatus = SBRDEC_PARSE_ERROR;
-  } else {
-    /* Everything seems to be ok so clear the error flag */
-    self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 0;
-  }
-
-  if (!stereo) {
-    /* Turn coupling off explicitely to avoid access to absent right frame data
-       that might occur with corrupt bitstreams. */
-    hFrameDataLeft->coupling = COUPLING_OFF;
-  }
-
-bail:
-  if (errorStatus == SBRDEC_OK) {
-    if (headerStatus == HEADER_NOT_PRESENT) {
-      /* Use the old header for this frame */
-      hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = lastHdrSlot;
-    } else {
-      /* Use the new header for this frame */
-      hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = thisHdrSlot;
-    }
-
-    /* Move frame pointer to the next slot which is up to be decoded/applied next */
-    hSbrElement->useFrameSlot = (hSbrElement->useFrameSlot+1) % (self->numDelayFrames+1);
-  }
-
-  *count -= startPos - FDKgetValidBits(hBs);
-
-  return errorStatus;
-}
-
-
-/**
- * \brief Render one SBR element into time domain signal.
- * \param self SBR decoder handle
- * \param timeData pointer to output buffer
- * \param interleaved flag indicating interleaved channel output
- * \param channelMapping pointer to UCHAR array where next 2 channel offsets are stored. 
- * \param elementIndex enumerating index of the SBR element to render.
- * \param numInChannels number of channels from core coder (reading stride).
- * \param numOutChannels pointer to a location to return number of output channels.
- * \param psPossible flag indicating if PS is possible or not.
- * \return SBRDEC_OK if successfull, else error code
- */
-static SBR_ERROR
-sbrDecoder_DecodeElement (
-        HANDLE_SBRDECODER    self,
-        INT_PCM             *timeData,
-        const int            interleaved,
-        const UCHAR         *channelMapping,
-        const int            elementIndex,
-        const int            numInChannels,
-        int                 *numOutChannels,
-        const int            psPossible
-        )
-{
-  SBR_DECODER_ELEMENT *hSbrElement = self->pSbrElement[elementIndex];
-  HANDLE_SBR_CHANNEL    *pSbrChannel = self->pSbrElement[elementIndex]->pSbrChannel;
-  HANDLE_SBR_HEADER_DATA hSbrHeader = &self->sbrHeader[elementIndex][hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot]];
-  HANDLE_PS_DEC h_ps_d = self->hParametricStereoDec;
-
-  /* get memory for frame data from scratch */
-  SBR_FRAME_DATA *hFrameDataLeft  = &hSbrElement->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
-  SBR_FRAME_DATA *hFrameDataRight = &hSbrElement->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
-
-  SBR_ERROR errorStatus = SBRDEC_OK;
-
-
-  INT  strideIn, strideOut, offset0, offset1;
-  INT  codecFrameSize = self->codecFrameSize;
-
-  int  stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
-  int  numElementChannels = hSbrElement->nChannels; /* Number of channels of the current SBR element */
-
-  /* Update the header error flag */
-  hSbrHeader->frameErrorFlag = hSbrElement->frameErrorFlag[hSbrElement->useFrameSlot];
-
-  /*
-     Prepare filterbank for upsampling if no valid bit stream data is available.
-   */
-  if ( hSbrHeader->syncState == SBR_NOT_INITIALIZED )
-  {
-    errorStatus = initHeaderData(
-            hSbrHeader,
-            self->sampleRateIn,
-            self->sampleRateOut,
-            codecFrameSize,
-            self->flags
-            );
-
-    if (errorStatus != SBRDEC_OK) {
-      return errorStatus;
-    }
-
-    hSbrHeader->syncState = UPSAMPLING;
-
-    errorStatus = sbrDecoder_HeaderUpdate(
-            self,
-            hSbrHeader,
-            HEADER_NOT_PRESENT,
-            pSbrChannel,
-            hSbrElement->nChannels
-            );
-
-    if (errorStatus != SBRDEC_OK) {
-      hSbrHeader->syncState = SBR_NOT_INITIALIZED;
-      return errorStatus;
-    }
-  }
-
-  /* reset */
-  if (hSbrHeader->status & SBRDEC_HDR_STAT_RESET) {
-    int ch;
-    for (ch = 0 ; ch < numElementChannels; ch++) {
-      SBR_ERROR errorStatusTmp = SBRDEC_OK;
-
-      errorStatusTmp = resetSbrDec (
-             &pSbrChannel[ch]->SbrDec,
-              hSbrHeader,
-             &pSbrChannel[ch]->prevFrameData,
-              self->flags & SBRDEC_LOW_POWER,
-              self->synDownsampleFac
-              );
-
-      if (errorStatusTmp != SBRDEC_OK) {
-        errorStatus = errorStatusTmp;
-      }
-    }
-    hSbrHeader->status &= ~SBRDEC_HDR_STAT_RESET;
-  }
-
-  /* decoding */
-  if ( (hSbrHeader->syncState == SBR_ACTIVE)
-    || ((hSbrHeader->syncState == SBR_HEADER) && (hSbrHeader->frameErrorFlag == 0)) )
-  {
-    errorStatus = SBRDEC_OK;
-
-    decodeSbrData (hSbrHeader,
-                   hFrameDataLeft,
-                  &pSbrChannel[0]->prevFrameData,
-                   (stereo) ? hFrameDataRight : NULL,
-                   (stereo) ? &pSbrChannel[1]->prevFrameData : NULL);
-
-
-    /* Now we have a full parameter set and can do parameter
-       based concealment instead of plain upsampling. */
-    hSbrHeader->syncState = SBR_ACTIVE;
-  }
-
-  /* decode PS data if available */
-  if (h_ps_d != NULL && psPossible) {
-    int applyPs = 1;
-
-    /* define which frame delay line slot to process */
-    h_ps_d->processSlot = hSbrElement->useFrameSlot;
-
-    applyPs = DecodePs(h_ps_d, hSbrHeader->frameErrorFlag);
-    self->flags |= (applyPs) ? SBRDEC_PS_DECODED : 0;
-  }
-
-  /* Set strides for reading and writing */
-  if (interleaved) {
-    strideIn = numInChannels;
-    if ( psPossible )
-      strideOut = (numInChannels < 2) ? 2 : numInChannels;
-    else
-      strideOut = numInChannels;
-    offset0 = channelMapping[0];
-    offset1 = channelMapping[1];
-  } else {
-    strideIn  = 1;
-    strideOut = 1;
-    offset0 = channelMapping[0]*2*codecFrameSize;
-    offset1 = channelMapping[1]*2*codecFrameSize;
-  }
-
-  /* use same buffers for left and right channel and apply PS per timeslot */
-  /* Process left channel */
-//FDKprintf("self->codecFrameSize %d\t%d\n",self->codecFrameSize,self->sampleRateIn);
-  sbr_dec (&pSbrChannel[0]->SbrDec,
-            timeData + offset0,
-            timeData + offset0,
-           &pSbrChannel[1]->SbrDec,
-            timeData + offset1,
-            strideIn,
-            strideOut,
-            hSbrHeader,
-            hFrameDataLeft,
-           &pSbrChannel[0]->prevFrameData,
-            (hSbrHeader->syncState == SBR_ACTIVE),
-            h_ps_d,
-            self->flags
-          );
-
-  if (stereo) {
-    /* Process right channel */
-    sbr_dec (&pSbrChannel[1]->SbrDec,
-              timeData + offset1,
-              timeData + offset1,
-              NULL,
-              NULL,
-              strideIn,
-              strideOut,
-              hSbrHeader,
-              hFrameDataRight,
-             &pSbrChannel[1]->prevFrameData,
-              (hSbrHeader->syncState == SBR_ACTIVE),
-              NULL,
-              self->flags
-            );
-  }
-
-  if (h_ps_d != NULL) {
-    /* save PS status for next run */
-    h_ps_d->psDecodedPrv = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0 ;
-  }
-
-  if ( psPossible 
-    )
-  {
-    FDK_ASSERT(strideOut > 1);
-    if ( !(self->flags & SBRDEC_PS_DECODED) ) {
-      /* A decoder which is able to decode PS has to produce a stereo output even if no PS data is availble. */
-      /* So copy left channel to right channel.                                                              */
-      if (interleaved) {
-        INT_PCM *ptr;
-        INT i;
-        FDK_ASSERT(strideOut == 2);
-
-        ptr = timeData;
-        for (i = codecFrameSize; i--; ) 
-        {
-          INT_PCM tmp; /* This temporal variable is required because some compilers can't do *ptr++ = *ptr++ correctly. */
-          tmp = *ptr++; *ptr++ = tmp;
-          tmp = *ptr++; *ptr++ = tmp;
-        }
-      } else {
-        FDKmemcpy( timeData+2*codecFrameSize, timeData, 2*codecFrameSize*sizeof(INT_PCM) );
-      }
-    }
-    *numOutChannels = 2;  /* Output minimum two channels when PS is enabled. */
-  }
-
-  return errorStatus;
-}
-
-
-SBR_ERROR sbrDecoder_Apply ( HANDLE_SBRDECODER   self,
-                             INT_PCM            *timeData,
-                             int                *numChannels,
-                             int                *sampleRate,
-                             const UCHAR         channelMapping[(6)],
-                             const int           interleaved,
-                             const int           coreDecodedOk,
-                             UCHAR              *psDecoded )
-{
-  SBR_ERROR errorStatus = SBRDEC_OK;
-
-  int   psPossible = 0;
-  int   sbrElementNum;
-  int   numCoreChannels = *numChannels;
-  int   numSbrChannels  = 0;
-
-  psPossible = *psDecoded;
-
-  if (self->numSbrElements < 1) {
-    /* exit immediately to avoid access violations */
-    return SBRDEC_CREATE_ERROR;
-  }
-
-  /* Sanity check of allocated SBR elements. */
-  for (sbrElementNum=0; sbrElementNum<self->numSbrElements; sbrElementNum++) {
-    if (self->pSbrElement[sbrElementNum] == NULL) {
-      return SBRDEC_CREATE_ERROR;
-    }
-  }
-
-  if (self->numSbrElements != 1 || self->pSbrElement[0]->elementID != ID_SCE) {
-    psPossible = 0;
-  }
-
-
-  /* In case of non-interleaved time domain data and upsampling, make room for bigger SBR output. */
-  if (self->synDownsampleFac == 1 && interleaved == 0) {
-    int c, outputFrameSize;
-
-    outputFrameSize =
-            self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_channels
-            * self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_col;
-
-    for (c=numCoreChannels-1; c>0; c--) {
-      FDKmemmove(timeData + c*outputFrameSize, timeData + c*self->codecFrameSize , self->codecFrameSize*sizeof(INT_PCM));
-    }
-  }
-
-
-  /* Make sure that even if no SBR data was found/parsed *psDecoded is returned 1 if psPossible was 0. */
-  if (psPossible == 0) {
-    self->flags &= ~SBRDEC_PS_DECODED;
-  }
-
-  /* Loop over SBR elements */
-  for (sbrElementNum = 0; sbrElementNum<self->numSbrElements; sbrElementNum++)
-  {
-    int numElementChan;
-
-    if (psPossible && self->pSbrElement[sbrElementNum]->pSbrChannel[1] == NULL) {
-      errorStatus = SBRDEC_UNSUPPORTED_CONFIG;
-      goto bail;
-    }
-
-    numElementChan = (self->pSbrElement[sbrElementNum]->elementID == ID_CPE) ? 2 : 1;
-
-    /* If core signal is bad then force upsampling */
-    if ( ! coreDecodedOk ) {
-      self->pSbrElement[sbrElementNum]->frameErrorFlag[self->pSbrElement[sbrElementNum]->useFrameSlot] = 1;
-    }
-
-    errorStatus = sbrDecoder_DecodeElement (
-                                 self,
-                                 timeData,
-                                 interleaved,
-                                 channelMapping,
-                                 sbrElementNum,
-                                 numCoreChannels,
-                                &numElementChan,
-                                 psPossible
-                               );
-
-    if (errorStatus != SBRDEC_OK) {
-      goto bail;
-    }
-
-    numSbrChannels += numElementChan;
-    channelMapping += numElementChan;
-
-    if (numSbrChannels >= numCoreChannels) {
-      break;
-    }
-  }
-
-  /* Update numChannels and samplerate */
-  *numChannels = numSbrChannels;
-  *sampleRate = self->sampleRateOut;
-  *psDecoded = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0;
-
-
-
-bail:
-
-  return errorStatus;
-}
-
-
-SBR_ERROR sbrDecoder_Close ( HANDLE_SBRDECODER *pSelf )
-{
-  HANDLE_SBRDECODER self = *pSelf;
-  int i;
-
-  if (self != NULL)
-  {
-    if (self->hParametricStereoDec != NULL) {
-      DeletePsDec ( &self->hParametricStereoDec );
-    }
-
-    if (self->workBuffer1 != NULL) {
-      FreeRam_SbrDecWorkBuffer1(&self->workBuffer1);
-    }
-    if (self->workBuffer2 != NULL) {
-      FreeRam_SbrDecWorkBuffer2(&self->workBuffer2);
-    }
-
-    for (i = 0; i < (4); i++) {
-      sbrDecoder_DestroyElement( self, i );
-    }
-
-    FreeRam_SbrDecoder(pSelf);
-  }
-
-  return SBRDEC_OK;
-}
-
-
-INT sbrDecoder_GetLibInfo( LIB_INFO *info )
-{
-  int i;
-
-  if (info == NULL) {
-    return -1;
-  }
-
-  /* search for next free tab */
-  for (i = 0; i < FDK_MODULE_LAST; i++) {
-    if (info[i].module_id == FDK_NONE)
-      break;
-  }
-  if (i == FDK_MODULE_LAST)
-    return -1;
-  info += i;
-
-  info->module_id = FDK_SBRDEC;
-  info->version = LIB_VERSION(SBRDECODER_LIB_VL0, SBRDECODER_LIB_VL1, SBRDECODER_LIB_VL2);
-  LIB_VERSION_STRING(info);
-  info->build_date = (char *)SBRDECODER_LIB_BUILD_DATE;
-  info->build_time = (char *)SBRDECODER_LIB_BUILD_TIME;
-  info->title      = (char *)SBRDECODER_LIB_TITLE;
-
-  /* Set flags */
-  info->flags = 0
-    | CAPF_SBR_HQ
-    | CAPF_SBR_LP
-    | CAPF_SBR_PS_MPEG
-    | CAPF_SBR_CONCEALMENT
-    | CAPF_SBR_DRC
-      ;
-  /* End of flags */
-
-  return 0;
-}
-
diff --git a/libSBRdec/src/transcendent.h b/libSBRdec/src/transcendent.h
deleted file mode 100644
index ad88bc9..0000000
--- a/libSBRdec/src/transcendent.h
+++ /dev/null
@@ -1,355 +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  FDK Fixed Point Arithmetic Library Interface  
-*/
-
-#ifndef __TRANSCENDENT_H
-#define __TRANSCENDENT_H
-
-#include "sbrdecoder.h"
-#include "sbr_rom.h"
-
-/************************************************************************/
-/*!
-  \brief   Get number of octaves between frequencies a and b
-
-  The Result is scaled with 1/8.
-  The valid range for a and b is 1 to LOG_DUALIS_TABLE_SIZE.
-
-  \return   ld(a/b) / 8
-*/
-/************************************************************************/
-static inline FIXP_SGL FDK_getNumOctavesDiv8(INT a, /*!< lower band */
-                                             INT b) /*!< upper band */
-{
-  return ( (SHORT)((LONG)(CalcLdInt(b) - CalcLdInt(a))>>(FRACT_BITS-3)) );
-}
-
-
-/************************************************************************/
-/*!
-  \brief   Add two values given by mantissa and exponent.
-
-  Mantissas are in fract format with values between 0 and 1. <br>
-  The base for exponents is 2.  Example:  \f$  a = a\_m * 2^{a\_e}  \f$<br>
-*/
-/************************************************************************/
-inline void FDK_add_MantExp(FIXP_SGL a_m, /*!< Mantissa of 1st operand a */
-                     SCHAR     a_e,       /*!< Exponent of 1st operand a */
-                     FIXP_SGL  b_m,       /*!< Mantissa of 2nd operand b */
-                     SCHAR     b_e,       /*!< Exponent of 2nd operand b */
-                     FIXP_SGL *ptrSum_m,  /*!< Mantissa of result */
-                     SCHAR    *ptrSum_e)  /*!< Exponent of result */
-{
-  FIXP_DBL accu;
-  int   shift;
-  int   shiftAbs;
-
-  FIXP_DBL shiftedMantissa;
-  FIXP_DBL otherMantissa;
-
-  /* Equalize exponents of the summands.
-     For the smaller summand, the exponent is adapted and
-     for compensation, the mantissa is shifted right. */
-
-  shift = (int)(a_e - b_e);
-
-  shiftAbs = (shift>0)? shift : -shift;
-  shiftAbs = (shiftAbs < DFRACT_BITS-1)? shiftAbs : DFRACT_BITS-1;
-  shiftedMantissa = (shift>0)? (FX_SGL2FX_DBL(b_m) >> shiftAbs) : (FX_SGL2FX_DBL(a_m) >> shiftAbs);
-  otherMantissa = (shift>0)? FX_SGL2FX_DBL(a_m) : FX_SGL2FX_DBL(b_m);
-  *ptrSum_e = (shift>0)? a_e : b_e;
-
-  accu = (shiftedMantissa >> 1) + (otherMantissa >> 1);
-  /* shift by 1 bit to avoid overflow */
-
-  if ( (accu >= (FL2FXCONST_DBL(0.5f) - (FIXP_DBL)1)) || (accu <= FL2FXCONST_DBL(-0.5f)) )
-    *ptrSum_e += 1;
-  else
-    accu = (shiftedMantissa + otherMantissa);
-
-  *ptrSum_m = FX_DBL2FX_SGL(accu);
-
-}
-
-inline void FDK_add_MantExp(FIXP_DBL a,   /*!< Mantissa of 1st operand a */
-                     SCHAR     a_e,       /*!< Exponent of 1st operand a */
-                     FIXP_DBL  b,         /*!< Mantissa of 2nd operand b */
-                     SCHAR     b_e,       /*!< Exponent of 2nd operand b */
-                     FIXP_DBL *ptrSum,    /*!< Mantissa of result */
-                     SCHAR    *ptrSum_e)  /*!< Exponent of result */
-{
-  FIXP_DBL accu;
-  int   shift;
-  int   shiftAbs;
-
-  FIXP_DBL shiftedMantissa;
-  FIXP_DBL otherMantissa;
-
-  /* Equalize exponents of the summands.
-     For the smaller summand, the exponent is adapted and
-     for compensation, the mantissa is shifted right. */
-
-  shift = (int)(a_e - b_e);
-
-  shiftAbs = (shift>0)? shift : -shift;
-  shiftAbs = (shiftAbs < DFRACT_BITS-1)? shiftAbs : DFRACT_BITS-1;
-  shiftedMantissa = (shift>0)? (b >> shiftAbs) : (a >> shiftAbs);
-  otherMantissa = (shift>0)? a : b;
-  *ptrSum_e = (shift>0)? a_e : b_e;
-
-  accu = (shiftedMantissa >> 1) + (otherMantissa >> 1);
-  /* shift by 1 bit to avoid overflow */
-
-  if ( (accu >= (FL2FXCONST_DBL(0.5f) - (FIXP_DBL)1)) || (accu <= FL2FXCONST_DBL(-0.5f)) )
-    *ptrSum_e += 1;
-  else
-    accu = (shiftedMantissa + otherMantissa);
-
-  *ptrSum = accu;
-
-}
-
-/************************************************************************/
-/*!
-  \brief   Divide two values given by mantissa and exponent.
-
-  Mantissas are in fract format with values between 0 and 1. <br>
-  The base for exponents is 2.  Example:  \f$  a = a\_m * 2^{a\_e}  \f$<br>
-
-  For performance reasons, the division is based on a table lookup
-  which limits accuracy.
-*/
-/************************************************************************/
-static inline void FDK_divide_MantExp(FIXP_SGL a_m,           /*!< Mantissa of dividend a */
-                                      SCHAR     a_e,          /*!< Exponent of dividend a */
-                                      FIXP_SGL  b_m,          /*!< Mantissa of divisor b */
-                                      SCHAR     b_e,          /*!< Exponent of divisor b */
-                                      FIXP_SGL *ptrResult_m,  /*!< Mantissa of quotient a/b */
-                                      SCHAR    *ptrResult_e)  /*!< Exponent of quotient a/b */
-
-{
-  int preShift, postShift, index, shift;
-  FIXP_DBL ratio_m;
-  FIXP_SGL  bInv_m = FL2FXCONST_SGL(0.0f);
-
-  preShift = CntLeadingZeros(FX_SGL2FX_DBL(b_m));
-
-  /*
-    Shift b into the range from 0..INV_TABLE_SIZE-1,
-
-    E.g. 10 bits must be skipped for INV_TABLE_BITS 8:
-    - leave 8 bits as index for table
-    - skip sign bit,
-    - skip first bit of mantissa, because this is always the same (>0.5)
-
-    We are dealing with energies, so we need not care
-    about negative numbers
-  */
-
-  /*
-    The first interval has half width so the lowest bit of the index is
-    needed for a doubled resolution.
-  */
-  shift = (FRACT_BITS - 2 - INV_TABLE_BITS - preShift);
-
-  index = (shift<0)? (LONG)b_m << (-shift) : (LONG)b_m >> shift;
-
-
-  /* The index has INV_TABLE_BITS +1 valid bits here. Clear the other bits. */
-  index &= (1 << (INV_TABLE_BITS+1)) - 1;
-
-    /* Remove offset of half an interval */
-  index--;
-
-    /* Now the lowest bit is shifted out */
-  index = index >> 1;
-
-    /* Fetch inversed mantissa from table: */
-  bInv_m = (index<0)? bInv_m : FDK_sbrDecoder_invTable[index];
-
-    /* Multiply a with the inverse of b: */
-  ratio_m = (index<0)? FX_SGL2FX_DBL(a_m >> 1) : fMultDiv2(bInv_m,a_m);
-
-  postShift = CntLeadingZeros(ratio_m)-1;
-
-  *ptrResult_m = FX_DBL2FX_SGL(ratio_m << postShift);
-  *ptrResult_e = a_e - b_e + 1 + preShift - postShift;
-}
-
-static inline void FDK_divide_MantExp(FIXP_DBL a_m,           /*!< Mantissa of dividend a */
-                                      SCHAR     a_e,          /*!< Exponent of dividend a */
-                                      FIXP_DBL  b_m,          /*!< Mantissa of divisor b */
-                                      SCHAR     b_e,          /*!< Exponent of divisor b */
-                                      FIXP_DBL *ptrResult_m,  /*!< Mantissa of quotient a/b */
-                                      SCHAR    *ptrResult_e)  /*!< Exponent of quotient a/b */
-
-{
-  int preShift, postShift, index, shift;
-  FIXP_DBL ratio_m;
-  FIXP_SGL  bInv_m = FL2FXCONST_SGL(0.0f);
-
-  preShift = CntLeadingZeros(b_m);
-
-  /*
-    Shift b into the range from 0..INV_TABLE_SIZE-1,
-
-    E.g. 10 bits must be skipped for INV_TABLE_BITS 8:
-    - leave 8 bits as index for table
-    - skip sign bit,
-    - skip first bit of mantissa, because this is always the same (>0.5)
-
-    We are dealing with energies, so we need not care
-    about negative numbers
-  */
-
-  /*
-    The first interval has half width so the lowest bit of the index is
-    needed for a doubled resolution.
-  */
-  shift = (DFRACT_BITS - 2 - INV_TABLE_BITS - preShift);
-
-  index = (shift<0)? (LONG)b_m << (-shift) : (LONG)b_m >> shift;
-
-
-  /* The index has INV_TABLE_BITS +1 valid bits here. Clear the other bits. */
-  index &= (1 << (INV_TABLE_BITS+1)) - 1;
-
-    /* Remove offset of half an interval */
-  index--;
-
-    /* Now the lowest bit is shifted out */
-  index = index >> 1;
-
-    /* Fetch inversed mantissa from table: */
-  bInv_m = (index<0)? bInv_m : FDK_sbrDecoder_invTable[index];
-
-    /* Multiply a with the inverse of b: */
-  ratio_m = (index<0)? (a_m >> 1) : fMultDiv2(bInv_m,a_m);
-
-  postShift = CntLeadingZeros(ratio_m)-1;
-
-  *ptrResult_m = ratio_m << postShift;
-  *ptrResult_e = a_e - b_e + 1 + preShift - postShift;
-}
-
-/*!
-  \brief   Calculate the squareroot of a number given by mantissa and exponent
-
-  Mantissa is in fract format with values between 0 and 1. <br>
-  The base for the exponent is 2.  Example:  \f$  a = a\_m * 2^{a\_e}  \f$<br>
-  The operand is addressed via pointers and will be overwritten with the result.
-
-  For performance reasons, the square root is based on a table lookup
-  which limits accuracy.
-*/
-static inline void FDK_sqrt_MantExp(FIXP_DBL *mantissa,    /*!< Pointer to mantissa */
-                                    SCHAR    *exponent,
-                                    const SCHAR *destScale)
-{
-  FIXP_DBL input_m = *mantissa;
-  int   input_e = (int) *exponent;
-  FIXP_DBL result = FL2FXCONST_DBL(0.0f);
-  int    result_e = -FRACT_BITS;
-
-  /* Call lookup square root, which does internally normalization. */
-  result   = sqrtFixp_lookup(input_m, &input_e);
-  result_e = input_e;
-
-  /* Write result */
-  if (exponent==destScale) {
-    *mantissa = result;
-    *exponent = result_e;
-  } else {
-    int shift = result_e - *destScale;
-    *mantissa = (shift>=0) ? result << (INT)fixMin(DFRACT_BITS-1,shift)
-                           : result >> (INT)fixMin(DFRACT_BITS-1,-shift);
-    *exponent = *destScale;
-  }
-}
-
-
-#endif