Remove FDK-AAC

1 files changed, 0 insertions, 1038 deletions

diff --git a/libAACenc/src/metadata_compressor.cpp b/libAACenc/src/metadata_compressor.cpp
deleted file mode 100644
index 876de57..0000000
--- a/libAACenc/src/metadata_compressor.cpp
+++ /dev/null
@@ -1,1038 +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 FDK AAC Encoder lib  ******************
-
-   Author(s): M. Neusinger
-   Description: Compressor for AAC Metadata Generator
-
-******************************************************************************/
-
-
-#include "metadata_compressor.h"
-#include "channel_map.h"
-
-
-#define LOG2                                    0.69314718056f  /* natural logarithm of 2 */
-#define ILOG2                                   1.442695041f    /* 1/LOG2 */
-#define FIXP_ILOG2_DIV2                         (FL2FXCONST_DBL(ILOG2/2))
-
-/*----------------- defines ----------------------*/
-
-#define MAX_DRC_CHANNELS        (8)          /*!< Max number of audio input channels. */
-#define DOWNMIX_SHIFT           (3)          /*!< Max 8 channel. */
-#define WEIGHTING_FILTER_SHIFT  (2)          /*!< Scaling used in weighting filter. */
-
-#define METADATA_INT_BITS      10
-#define METADATA_LINT_BITS     20
-#define METADATA_INT_SCALE     (INT64(1)<<(METADATA_INT_BITS))
-#define METADATA_FRACT_BITS    (DFRACT_BITS-1-METADATA_INT_BITS)
-#define METADATA_FRACT_SCALE   (INT64(1)<<(METADATA_FRACT_BITS))
-
-/**
- *  Enum for channel assignment.
- */
-enum {
-    L   = 0,
-    R   = 1,
-    C   = 2,
-    LFE = 3,
-    LS  = 4,
-    RS  = 5,
-    S   = 6,
-    LS2 = 7,
-    RS2 = 8
-};
-
-/*--------------- structure definitions --------------------*/
-
-/**
- *  Structure holds weighting filter filter states.
- */
-struct WEIGHTING_STATES {
-    FIXP_DBL x1;
-    FIXP_DBL x2;
-    FIXP_DBL y1;
-    FIXP_DBL y2;
-};
-
-/**
- *  Dynamic Range Control compressor structure.
- */
-struct DRC_COMP {
-
-    FIXP_DBL     maxBoostThr[2];             /*!< Max boost threshold. */
-    FIXP_DBL     boostThr[2];                /*!< Boost threshold. */
-    FIXP_DBL     earlyCutThr[2];             /*!< Early cut threshold. */
-    FIXP_DBL     cutThr[2];                  /*!< Cut threshold. */
-    FIXP_DBL     maxCutThr[2];               /*!< Max cut threshold. */
-
-    FIXP_DBL     boostFac[2];                /*!< Precalculated factor for boost compression. */
-    FIXP_DBL     earlyCutFac[2];             /*!< Precalculated factor for early cut compression. */
-    FIXP_DBL     cutFac[2];                  /*!< Precalculated factor for cut compression. */
-
-    FIXP_DBL     maxBoost[2];                /*!< Maximum boost. */
-    FIXP_DBL     maxCut[2];                  /*!< Maximum cut. */
-    FIXP_DBL     maxEarlyCut[2];             /*!< Maximum early cut. */
-
-    FIXP_DBL     fastAttack[2];              /*!< Fast attack coefficient. */
-    FIXP_DBL     fastDecay[2];               /*!< Fast release coefficient. */
-    FIXP_DBL     slowAttack[2];              /*!< Slow attack coefficient. */
-    FIXP_DBL     slowDecay[2];               /*!< Slow release coefficient. */
-    UINT         holdOff[2];                 /*!< Hold time in blocks. */
-
-    FIXP_DBL     attackThr[2];               /*!< Slow/fast attack threshold. */
-    FIXP_DBL     decayThr[2];                /*!< Slow/fast release threshold. */
-
-    DRC_PROFILE  profile[2];                 /*!< DRC profile. */
-    INT          blockLength;                /*!< Block length in samples. */
-    UINT         sampleRate;                 /*!< Sample rate. */
-    CHANNEL_MODE chanConfig;                 /*!< Channel configuration. */
-
-    UCHAR        useWeighting;               /*!< Use weighting filter. */
-
-    UINT         channels;                   /*!< Number of channels. */
-    UINT         fullChannels;               /*!< Number of full range channels. */
-    INT          channelIdx[9];              /*!< Offsets of interleaved channel samples (L, R, C, LFE, Ls, Rs, S, Ls2, Rs2). */
-
-    FIXP_DBL     smoothLevel[2];             /*!< level smoothing states */
-    FIXP_DBL     smoothGain[2];              /*!< gain smoothing states */
-    UINT         holdCnt[2];                 /*!< hold counter */
-
-    FIXP_DBL     limGain[2];                 /*!< limiter gain */
-    FIXP_DBL     limDecay;                   /*!< limiter decay (linear) */
-    FIXP_DBL     prevPeak[2];                /*!< max peak of previous block (stereo/mono)*/
-
-    WEIGHTING_STATES filter[MAX_DRC_CHANNELS]; /*!< array holds weighting filter states */
-
-};
-
-/*---------------- constants -----------------------*/
-
-/**
- *  Profile tables.
- */
-static const FIXP_DBL tabMaxBoostThr[] = {
-    (FIXP_DBL)(-43<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-53<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-55<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-65<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-50<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-40<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabBoostThr[] = {
-    (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-41<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-41<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-31<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabEarlyCutThr[] = {
-    (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-20<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabCutThr[]      = {
-    (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-11<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(-10<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabMaxCutThr[]   = {
-    (FIXP_DBL)(4<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(9<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(4<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(9<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(4<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(4<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabBoostRatio[] = {
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/5.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/5.f) - 1.f) )
-};
-static const FIXP_DBL tabEarlyCutRatio[] = {
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/1.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/2.f) - 1.f) )
-};
-static const FIXP_DBL tabCutRatio[]      = {
-    FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/ 2.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
-    FL2FXCONST_DBL( ((1.f/20.f) - 1.f) )
-};
-static const FIXP_DBL tabMaxBoost[] = {
-    (FIXP_DBL)( 6<<METADATA_FRACT_BITS),
-    (FIXP_DBL)( 6<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(12<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(12<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabMaxCut[]   = {
-    (FIXP_DBL)(24<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(24<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(24<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(24<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(24<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabFastAttack[] = {
-    FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL( (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabFastDecay[]  = {
-    FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL( (200.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL(   (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabSlowAttack[] = {
-    FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL(  (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabSlowDecay[]  = {
-    FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL((10000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL( (1000.f/1000.f)/METADATA_INT_SCALE),
-    FL2FXCONST_DBL(    (0.f/1000.f)/METADATA_INT_SCALE)
-};
-
-static const INT tabHoldOff[]    = { 10, 10, 10, 10, 10, 0 };
-
-static const FIXP_DBL tabAttackThr[] = {
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(15<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(10<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(0<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabDecayThr[]  = {
-    (FIXP_DBL)(20<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(20<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(20<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(20<<METADATA_FRACT_BITS),
-    (FIXP_DBL)(10<<METADATA_FRACT_BITS),
-    (FIXP_DBL)( 0<<METADATA_FRACT_BITS)
-};
-
-/**
- *  Weighting filter coefficients (biquad bandpass).
- */
-static const FIXP_DBL b0 = FL2FXCONST_DBL(0.53050662f);                                      /* b1 = 0, b2 = -b0 */
-static const FIXP_DBL a1 = FL2FXCONST_DBL(-0.95237983f), a2 = FL2FXCONST_DBL(-0.02248836f);  /* a0 = 1 */
-
-
-/*------------- function definitions ----------------*/
-
-/**
- * \brief  Calculate scaling factor for denoted processing block.
- *
- * \param blockLength   Length of processing block.
- *
- * \return    shiftFactor
- */
-static UINT getShiftFactor(
-        const UINT                length
-        )
-{
-    UINT ldN;
-    for(ldN=1;(((UINT)1)<<ldN) < length;ldN++);
-
-    return ldN;
-}
-
-/**
- * \brief  Sum up fixpoint values with best possible accuracy.
- *
- * \param value1        First input value.
- * \param q1            Scaling factor of first input value.
- * \param pValue2       Pointer to second input value, will be modified on return.
- * \param pQ2           Pointer to second scaling factor, will be modified on return.
- *
- * \return    void
- */
-static void fixpAdd(
-        const FIXP_DBL                  value1,
-        const int                       q1,
-        FIXP_DBL *const                 pValue2,
-        int *const                      pQ2
-        )
-{
-  const int headroom1 = fNormz(fixp_abs(value1))-1;
-  const int headroom2 = fNormz(fixp_abs(*pValue2))-1;
-  int resultScale = fixMax(q1-headroom1, (*pQ2)-headroom2);
-
-  if ( (value1!=FL2FXCONST_DBL(0.f)) && (*pValue2!=FL2FXCONST_DBL(0.f)) ) {
-    resultScale++;
-  }
-
-  *pValue2 = scaleValue(value1, q1-resultScale) + scaleValue(*pValue2, (*pQ2)-resultScale);
-  *pQ2 = (*pValue2!=(FIXP_DBL)0) ? resultScale : DFRACT_BITS-1;
-}
-
-/**
- * \brief  Function for converting time constant to filter coefficient.
- *
- * \param t             Time constant.
- * \param sampleRate    Sampling rate in Hz.
- * \param blockLength   Length of processing block in samples per channel.
- *
- * \return    result = 1.0 - exp(-1.0/((t) * (f)))
- */
-static FIXP_DBL tc2Coeff(
-        const FIXP_DBL            t,
-        const INT                 sampleRate,
-        const INT                 blockLength
-        )
-{
-   FIXP_DBL sampleRateFract;
-   FIXP_DBL blockLengthFract;
-   FIXP_DBL f, product;
-   FIXP_DBL exponent, result;
-   INT e_res;
-
-   /* f = sampleRate/blockLength */
-   sampleRateFract = (FIXP_DBL)(sampleRate<<(DFRACT_BITS-1-METADATA_LINT_BITS));
-   blockLengthFract = (FIXP_DBL)(blockLength<<(DFRACT_BITS-1-METADATA_LINT_BITS));
-   f = fDivNorm(sampleRateFract, blockLengthFract, &e_res);
-   f = scaleValue(f, e_res-METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
-   /* product = t*f */
-   product = fMultNorm(t, f, &e_res);
-   product = scaleValue(product, e_res+METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
-   /* exponent = (-1.0/((t) * (f))) */
-   exponent = fDivNorm(METADATA_FRACT_SCALE, product, &e_res);
-   exponent = scaleValue(exponent, e_res-METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
-   /* exponent * ld(e) */
-   exponent = fMult(exponent,FIXP_ILOG2_DIV2)<<1; /* e^(x) = 2^(x*ld(e)) */
-
-   /* exp(-1.0/((t) * (f))) */
-   result = f2Pow(-exponent, DFRACT_BITS-1-METADATA_FRACT_BITS, &e_res);
-
-   /* result = 1.0 - exp(-1.0/((t) * (f))) */
-   result = (FIXP_DBL)MAXVAL_DBL - scaleValue(result, e_res);
-
-   return result;
-}
-
-INT FDK_DRC_Generator_Open(
-        HDRC_COMP                      *phDrcComp
-        )
-{
-    INT err = 0;
-    HDRC_COMP hDcComp = NULL;
-
-    if (phDrcComp == NULL) {
-      err = -1;
-      goto bail;
-    }
-
-    /* allocate memory */
-    hDcComp = (HDRC_COMP)FDKcalloc(1, sizeof(DRC_COMP));
-
-    if (hDcComp == NULL) {
-      err = -1;
-      goto bail;
-    }
-
-    FDKmemclear(hDcComp, sizeof(DRC_COMP));
-
-    /* Return drc compressor instance */
-    *phDrcComp = hDcComp;
-    return err;
-bail:
-    FDK_DRC_Generator_Close(&hDcComp);
-    return err;
-}
-
-INT FDK_DRC_Generator_Close(
-        HDRC_COMP                      *phDrcComp
-        )
-{
-    if (phDrcComp == NULL) {
-      return -1;
-    }
-    if (*phDrcComp != NULL) {
-      FDKfree(*phDrcComp);
-      *phDrcComp = NULL;
-    }
-    return 0;
-}
-
-
-INT FDK_DRC_Generator_Initialize(
-        HDRC_COMP                       drcComp,
-        const DRC_PROFILE               profileLine,
-        const DRC_PROFILE               profileRF,
-        const INT                       blockLength,
-        const UINT                      sampleRate,
-        const CHANNEL_MODE              channelMode,
-        const CHANNEL_ORDER             channelOrder,
-        const UCHAR                     useWeighting
-        )
-{
-    int i;
-    CHANNEL_MAPPING channelMapping;
-
-    drcComp->limDecay = FL2FXCONST_DBL( ((0.006f / 256) * blockLength) / METADATA_INT_SCALE );
-
-    /* Save parameters. */
-    drcComp->blockLength = blockLength;
-    drcComp->sampleRate  = sampleRate;
-    drcComp->chanConfig = channelMode;
-    drcComp->useWeighting = useWeighting;
-
-    if (FDK_DRC_Generator_setDrcProfile(drcComp, profileLine, profileRF)!=0) { /* expects initialized blockLength and sampleRate */
-      return (-1);
-    }
-
-    /* Set number of channels and channel offsets. */
-    if (FDKaacEnc_InitChannelMapping(channelMode, channelOrder, &channelMapping)!=AAC_ENC_OK) {
-      return (-2);
-    }
-
-    for (i = 0; i < 9; i++) drcComp->channelIdx[i] = -1;
-
-    switch (channelMode) {
-    case MODE_1: /* mono */
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0];
-        break;
-    case MODE_2: /* stereo */
-        drcComp->channelIdx[L]   = channelMapping.elInfo[0].ChannelIndex[0];
-        drcComp->channelIdx[R]   = channelMapping.elInfo[0].ChannelIndex[1];
-        break;
-    case MODE_1_2: /* 3ch */
-        drcComp->channelIdx[L]   = channelMapping.elInfo[1].ChannelIndex[0];
-        drcComp->channelIdx[R]   = channelMapping.elInfo[1].ChannelIndex[1];
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0];
-        break;
-    case MODE_1_2_1: /* 4ch */
-        drcComp->channelIdx[L]   = channelMapping.elInfo[1].ChannelIndex[0];
-        drcComp->channelIdx[R]   = channelMapping.elInfo[1].ChannelIndex[1];
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0];
-        drcComp->channelIdx[S]   = channelMapping.elInfo[2].ChannelIndex[0];
-        break;
-    case MODE_1_2_2: /* 5ch */
-        drcComp->channelIdx[L]   = channelMapping.elInfo[1].ChannelIndex[0];
-        drcComp->channelIdx[R]   = channelMapping.elInfo[1].ChannelIndex[1];
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0];
-        drcComp->channelIdx[LS]  = channelMapping.elInfo[2].ChannelIndex[0];
-        drcComp->channelIdx[RS]  = channelMapping.elInfo[2].ChannelIndex[1];
-        break;
-    case MODE_1_2_2_1:  /* 5.1 ch */
-        drcComp->channelIdx[L]   = channelMapping.elInfo[1].ChannelIndex[0];
-        drcComp->channelIdx[R]   = channelMapping.elInfo[1].ChannelIndex[1];
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0];
-        drcComp->channelIdx[LFE] = channelMapping.elInfo[3].ChannelIndex[0];
-        drcComp->channelIdx[LS]  = channelMapping.elInfo[2].ChannelIndex[0];
-        drcComp->channelIdx[RS]  = channelMapping.elInfo[2].ChannelIndex[1];
-        break;
-    case MODE_1_2_2_2_1: /* 7.1 ch */
-    case MODE_7_1_FRONT_CENTER:
-        drcComp->channelIdx[L]   = channelMapping.elInfo[2].ChannelIndex[0]; /* l */
-        drcComp->channelIdx[R]   = channelMapping.elInfo[2].ChannelIndex[1]; /* r */
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0]; /* c */
-        drcComp->channelIdx[LFE] = channelMapping.elInfo[4].ChannelIndex[0]; /* lfe */
-        drcComp->channelIdx[LS]  = channelMapping.elInfo[3].ChannelIndex[0]; /* ls */
-        drcComp->channelIdx[RS]  = channelMapping.elInfo[3].ChannelIndex[1]; /* rs */
-        drcComp->channelIdx[LS2] = channelMapping.elInfo[1].ChannelIndex[0]; /* lc */
-        drcComp->channelIdx[RS2] = channelMapping.elInfo[1].ChannelIndex[1]; /* rc */
-        break;
-    case MODE_7_1_REAR_SURROUND:
-        drcComp->channelIdx[L]   = channelMapping.elInfo[1].ChannelIndex[0]; /* l */
-        drcComp->channelIdx[R]   = channelMapping.elInfo[1].ChannelIndex[1]; /* r */
-        drcComp->channelIdx[C]   = channelMapping.elInfo[0].ChannelIndex[0]; /* c */
-        drcComp->channelIdx[LFE] = channelMapping.elInfo[4].ChannelIndex[0]; /* lfe */
-        drcComp->channelIdx[LS]  = channelMapping.elInfo[3].ChannelIndex[0]; /* lrear */
-        drcComp->channelIdx[RS]  = channelMapping.elInfo[3].ChannelIndex[1]; /* rrear */
-        drcComp->channelIdx[LS2] = channelMapping.elInfo[2].ChannelIndex[0]; /* ls */
-        drcComp->channelIdx[RS2] = channelMapping.elInfo[2].ChannelIndex[1]; /* rs */
-        break;
-    case MODE_1_1:
-    case MODE_1_1_1_1:
-    case MODE_1_1_1_1_1_1:
-    case MODE_1_1_1_1_1_1_1_1:
-    case MODE_1_1_1_1_1_1_1_1_1_1_1_1:
-    case MODE_2_2:
-    case MODE_2_2_2:
-    case MODE_2_2_2_2:
-    case MODE_2_2_2_2_2_2:
-    default:
-        return (-1);
-    }
-
-    drcComp->fullChannels = channelMapping.nChannelsEff;
-    drcComp->channels     = channelMapping.nChannels;
-
-    /* Init states. */
-    drcComp->smoothLevel[0] = drcComp->smoothLevel[1] = (FIXP_DBL)(-135<<METADATA_FRACT_BITS);
-
-    FDKmemclear(drcComp->smoothGain, sizeof(drcComp->smoothGain));
-    FDKmemclear(drcComp->holdCnt, sizeof(drcComp->holdCnt));
-    FDKmemclear(drcComp->limGain, sizeof(drcComp->limGain));
-    FDKmemclear(drcComp->prevPeak, sizeof(drcComp->prevPeak));
-    FDKmemclear(drcComp->filter, sizeof(drcComp->filter));
-
-    return (0);
-}
-
-
-INT FDK_DRC_Generator_setDrcProfile(
-        HDRC_COMP                       drcComp,
-        const DRC_PROFILE               profileLine,
-        const DRC_PROFILE               profileRF
-        )
-{
-    int profileIdx, i;
-
-    drcComp->profile[0] = profileLine;
-    drcComp->profile[1] = profileRF;
-
-    for (i = 0; i < 2; i++) {
-        /* get profile index */
-        switch (drcComp->profile[i]) {
-            case DRC_NONE:
-            case DRC_FILMSTANDARD:  profileIdx = 0; break;
-            case DRC_FILMLIGHT:     profileIdx = 1; break;
-            case DRC_MUSICSTANDARD: profileIdx = 2; break;
-            case DRC_MUSICLIGHT:    profileIdx = 3; break;
-            case DRC_SPEECH:        profileIdx = 4; break;
-            case DRC_DELAY_TEST:    profileIdx = 5; break;
-            default: return (-1);
-        }
-
-        /* get parameters for selected profile */
-        if (profileIdx >= 0) {
-            drcComp->maxBoostThr[i] = tabMaxBoostThr[profileIdx];
-            drcComp->boostThr[i]    = tabBoostThr[profileIdx];
-            drcComp->earlyCutThr[i] = tabEarlyCutThr[profileIdx];
-            drcComp->cutThr[i]      = tabCutThr[profileIdx];
-            drcComp->maxCutThr[i]   = tabMaxCutThr[profileIdx];
-
-            drcComp->boostFac[i]    = tabBoostRatio[profileIdx];
-            drcComp->earlyCutFac[i] = tabEarlyCutRatio[profileIdx];
-            drcComp->cutFac[i]      = tabCutRatio[profileIdx];
-
-            drcComp->maxBoost[i]    = tabMaxBoost[profileIdx];
-            drcComp->maxCut[i]      = tabMaxCut[profileIdx];
-            drcComp->maxEarlyCut[i] = - fMult((drcComp->cutThr[i] - drcComp->earlyCutThr[i]), drcComp->earlyCutFac[i]); /* no scaling after mult needed, earlyCutFac is in FIXP_DBL */
-
-            drcComp->fastAttack[i]  = tc2Coeff(tabFastAttack[profileIdx], drcComp->sampleRate, drcComp->blockLength);
-            drcComp->fastDecay[i]   = tc2Coeff(tabFastDecay[profileIdx], drcComp->sampleRate, drcComp->blockLength);
-            drcComp->slowAttack[i]  = tc2Coeff(tabSlowAttack[profileIdx], drcComp->sampleRate, drcComp->blockLength);
-            drcComp->slowDecay[i]   = tc2Coeff(tabSlowDecay[profileIdx], drcComp->sampleRate, drcComp->blockLength);
-            drcComp->holdOff[i]     = tabHoldOff[profileIdx] * 256 / drcComp->blockLength;
-
-            drcComp->attackThr[i]   = tabAttackThr[profileIdx];
-            drcComp->decayThr[i]    = tabDecayThr[profileIdx];
-        }
-
-        drcComp->smoothGain[i] = FL2FXCONST_DBL(0.f);
-    }
-    return (0);
-}
-
-
-INT FDK_DRC_Generator_Calc(
-        HDRC_COMP                       drcComp,
-        const INT_PCM * const           inSamples,
-        const INT                       dialnorm,
-        const INT                       drc_TargetRefLevel,
-        const INT                       comp_TargetRefLevel,
-        FIXP_DBL                        clev,
-        FIXP_DBL                        slev,
-        INT * const                     pDynrng,
-        INT * const                     pCompr
-        )
-{
-    int i, c;
-    FIXP_DBL peak[2];
-
-
-    /**************************************************************************
-    * compressor
-    **************************************************************************/
-      if ((drcComp->profile[0] != DRC_NONE) || (drcComp->profile[1] != DRC_NONE)) {
-        /* Calc loudness level */
-        FIXP_DBL level_b = FL2FXCONST_DBL(0.f);
-        int      level_e = DFRACT_BITS-1;
-
-        /* Increase energy time resolution with shorter processing blocks. 32 is an empiric value. */
-        const int granuleLength = fixMin(32, drcComp->blockLength);
-
-        if (drcComp->useWeighting) {
-            FIXP_DBL x1, x2, y, y1, y2;
-            /* sum of filter coefficients about 2.5 -> squared value is 6.25
-               WEIGHTING_FILTER_SHIFT is 2 -> scaling about 16, therefore reduce granuleShift by 1.
-             */
-            const int granuleShift = getShiftFactor(granuleLength)-1;
-
-            for (c = 0; c < (int)drcComp->channels; c++) {
-                const INT_PCM* pSamples = &inSamples[c];
-
-                if (c == drcComp->channelIdx[LFE]) {
-                  continue;  /* skip LFE */
-                }
-
-                /* get filter states */
-                x1 = drcComp->filter[c].x1;
-                x2 = drcComp->filter[c].x2;
-                y1 = drcComp->filter[c].y1;
-                y2 = drcComp->filter[c].y2;
-
-                i = 0;
-
-                do {
-
-                  int offset = i;
-                  FIXP_DBL accu = FL2FXCONST_DBL(0.f);
-
-                  for (i=offset; i < fixMin(offset+granuleLength,drcComp->blockLength); i++) {
-                    /* apply weighting filter */
-                    FIXP_DBL x = FX_PCM2FX_DBL((FIXP_PCM)pSamples[i*drcComp->channels]) >> WEIGHTING_FILTER_SHIFT;
-
-                    /* y = b0 * (x - x2) - a1 * y1 - a2 * y2; */
-                    y = fMult(b0,x-x2) - fMult(a1,y1) - fMult(a2,y2);
-
-                    x2 = x1;
-                    x1 = x;
-                    y2 = y1;
-                    y1 = y;
-
-                    accu += fPow2Div2(y)>>(granuleShift-1);     /* partial energy */
-                  } /* i */
-
-                  fixpAdd(accu, granuleShift+2*WEIGHTING_FILTER_SHIFT, &level_b, &level_e); /* sup up partial energies */
-
-                } while ( i < drcComp->blockLength );
-
-
-                /* save filter states */
-                drcComp->filter[c].x1 = x1;
-                drcComp->filter[c].x2 = x2;
-                drcComp->filter[c].y1 = y1;
-                drcComp->filter[c].y2 = y2;
-            } /* c */
-        } /* weighting */
-        else {
-            const int granuleShift = getShiftFactor(granuleLength);
-
-            for (c = 0; c < (int)drcComp->channels; c++) {
-                const INT_PCM* pSamples = &inSamples[c];
-
-                if ((int)c == drcComp->channelIdx[LFE]) {
-                  continue;  /* skip LFE */
-                }
-
-                i = 0;
-
-                do {
-                  int offset = i;
-                  FIXP_DBL accu = FL2FXCONST_DBL(0.f);
-
-                  for (i=offset; i < fixMin(offset+granuleLength,drcComp->blockLength); i++) {
-                    /* partial energy */
-                    accu += fPow2Div2((FIXP_PCM)pSamples[i*drcComp->channels])>>(granuleShift-1);
-                  } /* i */
-
-                  fixpAdd(accu, granuleShift, &level_b, &level_e); /* sup up partial energies */
-
-                } while ( i < drcComp->blockLength );
-            }
-        } /* weighting */
-
-        /*
-         * Convert to dBFS, apply dialnorm
-         */
-        /* level scaling */
-
-        /* descaled level in ld64 representation */
-        FIXP_DBL ldLevel = CalcLdData(level_b) + (FIXP_DBL)((level_e-12)<<(DFRACT_BITS-1-LD_DATA_SHIFT)) - CalcLdData((FIXP_DBL)(drcComp->blockLength<<(DFRACT_BITS-1-12)));
-
-        /* if (level < 1e-10) level = 1e-10f; */
-        ldLevel = FDKmax(ldLevel, FL2FXCONST_DBL(-0.51905126482615036685473741085772f));
-
-        /* level = 10 * log(level)/log(10) + 3;
-         *       = 10*log(2)/log(10) * ld(level) + 3;
-         *       = 10 * 0.30102999566398119521373889472449 * ld(level) + 3
-         *       = 10 * (0.30102999566398119521373889472449 * ld(level) + 0.3)
-         *       = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 64
-         *
-         *    additional scaling with METADATA_FRACT_BITS:
-         *       = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 64 * 2^(METADATA_FRACT_BITS)
-         *       = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 2^(METADATA_FRACT_BITS+LD_DATA_SHIFT)
-         *       = 10*2^(METADATA_FRACT_BITS+LD_DATA_SHIFT) * ( 0.30102999566398119521373889472449 * ld64(level) + 0.3/64 )
-         * */
-        FIXP_DBL level = fMult((FIXP_DBL)(10<<(METADATA_FRACT_BITS+LD_DATA_SHIFT)), fMult( FL2FXCONST_DBL(0.30102999566398119521373889472449f), ldLevel) + (FIXP_DBL)(FL2FXCONST_DBL(0.3f)>>LD_DATA_SHIFT) );
-
-        /* level -= dialnorm + 31 */   /* this is fixed to Dolby-ReferenceLevel as compressor profiles are defined relative to this */
-        level -= ((FIXP_DBL)(dialnorm<<(METADATA_FRACT_BITS-16))  + (FIXP_DBL)(31<<METADATA_FRACT_BITS));
-
-        for (i = 0; i < 2; i++) {
-            if (drcComp->profile[i] == DRC_NONE) {
-                /* no compression */
-                drcComp->smoothGain[i] = FL2FXCONST_DBL(0.f);
-            }
-            else {
-                FIXP_DBL gain, alpha, lvl2smthlvl;
-
-                /* calc static gain */
-                if (level <= drcComp->maxBoostThr[i]) {
-                    /* max boost */
-                    gain = drcComp->maxBoost[i];
-                }
-                else if (level < drcComp->boostThr[i]) {
-                    /* boost range */
-                    gain = fMult((level - drcComp->boostThr[i]),drcComp->boostFac[i]);
-                }
-                else if (level <= drcComp->earlyCutThr[i]) {
-                    /* null band */
-                    gain = FL2FXCONST_DBL(0.f);
-                }
-                else if (level <= drcComp->cutThr[i]) {
-                    /* early cut range */
-                    gain = fMult((level - drcComp->earlyCutThr[i]), drcComp->earlyCutFac[i]);
-                }
-                else if (level < drcComp->maxCutThr[i]) {
-                    /* cut range */
-                    gain = fMult((level - drcComp->cutThr[i]), drcComp->cutFac[i]) - drcComp->maxEarlyCut[i];
-                }
-                else {
-                    /* max cut */
-                    gain = -drcComp->maxCut[i];
-                }
-
-                /* choose time constant */
-                lvl2smthlvl = level - drcComp->smoothLevel[i];
-                if (gain < drcComp->smoothGain[i]) {
-                    /* attack */
-                    if (lvl2smthlvl > drcComp->attackThr[i]) {
-                        /* fast attack */
-                        alpha = drcComp->fastAttack[i];
-                    }
-                    else {
-                        /* slow attack */
-                        alpha = drcComp->slowAttack[i];
-                    }
-                }
-                else {
-                    /* release */
-                    if (lvl2smthlvl < -drcComp->decayThr[i]) {
-                        /* fast release */
-                        alpha = drcComp->fastDecay[i];
-                    }
-                    else {
-                        /* slow release */
-                        alpha = drcComp->slowDecay[i];
-                    }
-                }
-
-                /* smooth gain & level */
-                if ((gain < drcComp->smoothGain[i]) || (drcComp->holdCnt[i] == 0)) { /* hold gain unless we have an attack or hold period is over */
-                    FIXP_DBL accu;
-
-                    /* drcComp->smoothLevel[i] = (1-alpha) * drcComp->smoothLevel[i] + alpha * level; */
-                    accu =  fMult(((FIXP_DBL)MAXVAL_DBL-alpha), drcComp->smoothLevel[i]);
-                    accu += fMult(alpha,level);
-                    drcComp->smoothLevel[i] = accu;
-
-                    /* drcComp->smoothGain[i]  = (1-alpha) * drcComp->smoothGain[i] + alpha * gain; */
-                    accu =  fMult(((FIXP_DBL)MAXVAL_DBL-alpha), drcComp->smoothGain[i]);
-                    accu += fMult(alpha,gain);
-                    drcComp->smoothGain[i] = accu;
-                }
-
-                /* hold counter */
-                if (drcComp->holdCnt[i]) {
-                  drcComp->holdCnt[i]--;
-                }
-                if (gain < drcComp->smoothGain[i]) {
-                  drcComp->holdCnt[i] = drcComp->holdOff[i];
-                }
-            } /* profile != DRC_NONE */
-        } /* for i=1..2 */
-      } else {
-        /* no compression */
-        drcComp->smoothGain[0] = FL2FXCONST_DBL(0.f);
-        drcComp->smoothGain[1] = FL2FXCONST_DBL(0.f);
-      }
-
-    /**************************************************************************
-    * limiter
-    **************************************************************************/
-
-    /* find peak level */
-    peak[0] = peak[1] = FL2FXCONST_DBL(0.f);
-    for (i = 0; i < drcComp->blockLength; i++) {
-        FIXP_DBL tmp;
-        const INT_PCM* pSamples = &inSamples[i*drcComp->channels];
-        INT_PCM maxSample = 0;
-
-        /* single channels */
-        for (c = 0; c < (int)drcComp->channels; c++) {
-            maxSample = FDKmax(maxSample, fAbs(pSamples[c]));
-        }
-        peak[0] = fixMax(peak[0], FX_PCM2FX_DBL(maxSample)>>DOWNMIX_SHIFT);
-
-        /* Lt/Rt downmix */
-        if (drcComp->fullChannels > 2) {
-            /* Lt */
-            tmp = FL2FXCONST_DBL(0.f);
-
-            if (drcComp->channelIdx[LS] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1);          /* Ls */
-            if (drcComp->channelIdx[LS2] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1);        /* Ls2 */
-            if (drcComp->channelIdx[RS] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1);          /* Rs */
-            if (drcComp->channelIdx[RS2] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1);        /* Rs2 */
-            if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp);                                     /* 7.1ch */
-            if (drcComp->channelIdx[S] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]])>>(DOWNMIX_SHIFT-1);            /* S */
-            if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1);            /* C */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT);                                                                   /* L */
-
-            peak[0] = fixMax(peak[0], fixp_abs(tmp));
-
-            /* Rt */
-            tmp = FL2FXCONST_DBL(0.f);
-            if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1);          /* Ls */
-            if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1);        /* Ls2 */
-            if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1);          /* Rs */
-            if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1);        /* Rs2 */
-            if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp);                                     /* 7.1ch */
-            if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]])>>(DOWNMIX_SHIFT-1);            /* S */
-            if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1);            /* C */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT);                                                                   /* R */
-
-            peak[0] = fixMax(peak[0], fixp_abs(tmp));
-        }
-
-        /* Lo/Ro downmix */
-        if (drcComp->fullChannels > 2) {
-            /* Lo */
-            tmp = FL2FXCONST_DBL(0.f);
-            if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1);                            /* Ls */
-            if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1);                          /* Ls2 */
-            if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp);                                     /* 7.1ch */
-            if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
-            if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1);                              /* C */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT);                                                                   /* L */
-
-            peak[0] = fixMax(peak[0], fixp_abs(tmp));
-
-            /* Ro */
-            tmp = FL2FXCONST_DBL(0.f);
-            if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1);                            /* Rs */
-            if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1);                          /* Rs2 */
-            if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp);                                     /* 7.1ch */
-            if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
-            if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1);                              /* C */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT);                                                                   /* R */
-
-            peak[0] = fixMax(peak[0], fixp_abs(tmp));
-        }
-
-        peak[1] = fixMax(peak[0], peak[1]);
-
-        /* Mono Downmix - for comp_val only */
-        if (drcComp->fullChannels > 1) {
-            tmp = FL2FXCONST_DBL(0.f);
-            if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1);                            /* Ls */
-            if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1);                          /* Ls2 */
-            if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1);                            /* Rs */
-            if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1);                          /* Rs2 */
-            if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp);                                     /* 7.1ch */
-            /*if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp *=0.707f;*/                                                             /* 7.1ch */
-            if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
-            if (drcComp->channelIdx[C] >= 0) tmp += fMult(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1);                                  /* C (2*clev) */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT);                                                                   /* L */
-            tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT);                                                                   /* R */
-
-            peak[1] = fixMax(peak[1], fixp_abs(tmp));
-        }
-    }
-
-    for (i=0; i<2; i++) {
-      FIXP_DBL tmp = drcComp->prevPeak[i];
-      drcComp->prevPeak[i] = peak[i];
-      peak[i] = fixMax(peak[i], tmp);
-
-      /*
-       * Convert to dBFS, apply dialnorm
-       */
-      /* descaled peak in ld64 representation */
-      FIXP_DBL ld_peak = CalcLdData(peak[i]) + (FIXP_DBL)((LONG)DOWNMIX_SHIFT<<(DFRACT_BITS-1-LD_DATA_SHIFT));
-
-      /* if (peak < 1e-6) level = 1e-6f; */
-      ld_peak = FDKmax(ld_peak, FL2FXCONST_DBL(-0.31143075889569022011284244651463f));
-
-      /* peak[i] = 20 * log(peak[i])/log(10) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
-       * peak[i] = 20 * log(2)/log(10) * ld(peak[i]) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
-       * peak[i] = 10 * 2*0.30102999566398119521373889472449 * ld(peak[i]) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
-       *
-       *    additional scaling with METADATA_FRACT_BITS:
-       * peak[i] = (10 * 2*0.30102999566398119521373889472449 * ld64(peak[i]) * 64 + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS))*2^(-METADATA_FRACT_BITS)
-       * peak[i] = 10*2^(METADATA_FRACT_BITS+LD_DATA_SHIFT) * 2*0.30102999566398119521373889472449 * ld64(peak[i])
-       *         + 0.2f*2^(-METADATA_FRACT_BITS) + drcComp->smoothGain[i]
-       */
-      peak[i] = fMult((FIXP_DBL)(10<<(METADATA_FRACT_BITS+LD_DATA_SHIFT)), fMult( FL2FX_DBL(2*0.30102999566398119521373889472449f), ld_peak));
-      peak[i] += (FL2FX_DBL(0.5f)>>METADATA_INT_BITS);           /* add a little bit headroom */
-      peak[i] +=  drcComp->smoothGain[i];
-    }
-
-    /* peak -= dialnorm + 31; */  /* this is Dolby style only */
-    peak[0] -= (FIXP_DBL)((dialnorm-drc_TargetRefLevel)<<(METADATA_FRACT_BITS-16)); /* peak[0] -= dialnorm - drc_TargetRefLevel */
-
-    /* peak += 11; */   /* this is Dolby style only */      /* RF mode output is 11dB higher */
-    /*peak += comp_TargetRefLevel - drc_TargetRefLevel;*/
-    peak[1] -= (FIXP_DBL)((dialnorm-comp_TargetRefLevel)<<(METADATA_FRACT_BITS-16)); /* peak[1] -= dialnorm - comp_TargetRefLevel */
-
-    /* limiter gain */
-    drcComp->limGain[0] += drcComp->limDecay;               /* linear limiter release */
-    drcComp->limGain[0] = fixMin(drcComp->limGain[0], -peak[0]);
-
-    drcComp->limGain[1] += 2*drcComp->limDecay;             /* linear limiter release */
-    drcComp->limGain[1] = fixMin(drcComp->limGain[1], -peak[1]);
-
-    /*************************************************************************/
-
-    /* apply limiting, return DRC gains*/
-    {
-        FIXP_DBL tmp;
-
-        tmp = drcComp->smoothGain[0];
-        if (drcComp->limGain[0] < FL2FXCONST_DBL(0.f)) {
-          tmp += drcComp->limGain[0];
-        }
-        *pDynrng = (LONG) scaleValue(tmp, -(METADATA_FRACT_BITS-16));
-
-        tmp = drcComp->smoothGain[1];
-        if (drcComp->limGain[1] < FL2FXCONST_DBL(0.f)) {
-          tmp += drcComp->limGain[1];
-        }
-        *pCompr  = (LONG) scaleValue(tmp, -(METADATA_FRACT_BITS-16));
-    }
-
-    return 0;
-}
-
-
-DRC_PROFILE FDK_DRC_Generator_getDrcProfile(const HDRC_COMP drcComp)
-{
-    return drcComp->profile[0];
-}
-
-DRC_PROFILE FDK_DRC_Generator_getCompProfile(const HDRC_COMP drcComp)
-{
-    return drcComp->profile[1];
-}
-
-