/* -----------------------------------------------------------------------------

Software License for The Fraunhofer FDK AAC Codec Library for Android

© Copyright  1995 - 2018 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

----------------------------------------------------------------------------- */

/**************************** AAC encoder library ******************************

   Author(s):   M. Werner

   Description: Scale factor estimation

*******************************************************************************/

#include "sf_estim.h"

#include "aacEnc_rom.h"

#include "quantize.h"

#include "bit_cnt.h"

#ifdef __arm__

#endif

#define UPCOUNT_LIMIT 1

#define AS_PE_FAC_SHIFT 7

#define DIST_FAC_SHIFT 3

#define AS_PE_FAC_FLOAT (float)(1 << AS_PE_FAC_SHIFT)

static const INT MAX_SCF_DELTA = 60;

static const FIXP_DBL PE_C1 = FL2FXCONST_DBL(

    3.0f / AS_PE_FAC_FLOAT); /* (log(8.0)/log(2)) >> AS_PE_FAC_SHIFT */

static const FIXP_DBL PE_C2 = FL2FXCONST_DBL(

    1.3219281f / AS_PE_FAC_FLOAT); /* (log(2.5)/log(2)) >> AS_PE_FAC_SHIFT */

static const FIXP_DBL PE_C3 = FL2FXCONST_DBL(0.5593573f); /* 1-C2/C1 */

/*

  Function; FDKaacEnc_FDKaacEnc_CalcFormFactorChannel

  Description: Calculates the formfactor

  sf: scale factor of the mdct spectrum

  sfbFormFactorLdData is scaled with the factor 1/(((2^sf)^0.5) *

  (2^FORM_FAC_SHIFT))

*/

static void FDKaacEnc_FDKaacEnc_CalcFormFactorChannel(

    FIXP_DBL *RESTRICT sfbFormFactorLdData,

    PSY_OUT_CHANNEL *RESTRICT psyOutChan) {

  INT j, sfb, sfbGrp;

  FIXP_DBL formFactor;

  int tmp0 = psyOutChan->sfbCnt;

  int tmp1 = psyOutChan->maxSfbPerGroup;

  int step = psyOutChan->sfbPerGroup;

  for (sfbGrp = 0; sfbGrp < tmp0; sfbGrp += step) {

    for (sfb = 0; sfb < tmp1; sfb++) {

      formFactor = FL2FXCONST_DBL(0.0f);

      /* calc sum of sqrt(spec) */

      for (j = psyOutChan->sfbOffsets[sfbGrp + sfb];

           j < psyOutChan->sfbOffsets[sfbGrp + sfb + 1]; j++) {

        formFactor +=

            sqrtFixp(fixp_abs(psyOutChan->mdctSpectrum[j])) >> FORM_FAC_SHIFT;

      }

      sfbFormFactorLdData[sfbGrp + sfb] = CalcLdData(formFactor);

    }

    /* set sfbFormFactor for sfbs with zero spec to zero. Just for debugging. */

    for (; sfb < psyOutChan->sfbPerGroup; sfb++) {

      sfbFormFactorLdData[sfbGrp + sfb] = FL2FXCONST_DBL(-1.0f);

    }

  }

}

/*

  Function: FDKaacEnc_CalcFormFactor

  Description: Calls FDKaacEnc_FDKaacEnc_CalcFormFactorChannel() for each

  channel

*/

void FDKaacEnc_CalcFormFactor(QC_OUT_CHANNEL *qcOutChannel[(2)],

                              PSY_OUT_CHANNEL *psyOutChannel[(2)],

                              const INT nChannels) {

  INT j;

  for (j = 0; j < nChannels; j++) {

    FDKaacEnc_FDKaacEnc_CalcFormFactorChannel(

        qcOutChannel[j]->sfbFormFactorLdData, psyOutChannel[j]);

  }

}

/*

  Function: FDKaacEnc_calcSfbRelevantLines

  Description: Calculates sfbNRelevantLines

  sfbNRelevantLines is scaled with the factor 1/((2^FORM_FAC_SHIFT) * 2.0)

*/

static void FDKaacEnc_calcSfbRelevantLines(

    const FIXP_DBL *const sfbFormFactorLdData,

    const FIXP_DBL *const sfbEnergyLdData,

    const FIXP_DBL *const sfbThresholdLdData, const INT *const sfbOffsets,

    const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup,

    FIXP_DBL *sfbNRelevantLines) {

  INT sfbOffs, sfb;

  FIXP_DBL sfbWidthLdData;

  FIXP_DBL asPeFacLdData =

      FL2FXCONST_DBL(0.109375); /* AS_PE_FAC_SHIFT*ld64(2) */

  FIXP_DBL accu;

  /* sfbNRelevantLines[i] = 2^( (sfbFormFactorLdData[i] - 0.25 *

   * (sfbEnergyLdData[i] - ld64(sfbWidth[i]/(2^7)) - AS_PE_FAC_SHIFT*ld64(2)) *

   * 64); */

  FDKmemclear(sfbNRelevantLines, sfbCnt * sizeof(FIXP_DBL));

  for (sfbOffs = 0; sfbOffs < sfbCnt; sfbOffs += sfbPerGroup) {

    for (sfb = 0; sfb < maxSfbPerGroup; sfb++) {

      /* calc sum of sqrt(spec) */

      if ((FIXP_DBL)sfbEnergyLdData[sfbOffs + sfb] >

          (FIXP_DBL)sfbThresholdLdData[sfbOffs + sfb]) {

        INT sfbWidth =

            sfbOffsets[sfbOffs + sfb + 1] - sfbOffsets[sfbOffs + sfb];

        /* avgFormFactorLdData =

         * sqrtFixp(sqrtFixp(sfbEnergyLdData[sfbOffs+sfb]/sfbWidth)); */

        /* sfbNRelevantLines[sfbOffs+sfb] = sfbFormFactor[sfbOffs+sfb] /

         * avgFormFactorLdData; */

        sfbWidthLdData =

            (FIXP_DBL)(sfbWidth << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT));

        sfbWidthLdData = CalcLdData(sfbWidthLdData);

        accu = sfbEnergyLdData[sfbOffs + sfb] - sfbWidthLdData - asPeFacLdData;

        accu = sfbFormFactorLdData[sfbOffs + sfb] - (accu >> 2);

        sfbNRelevantLines[sfbOffs + sfb] = CalcInvLdData(accu) >> 1;

      }

    }

  }

}

/*

  Function: FDKaacEnc_countSingleScfBits

  Description:

  scfBitsFract is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))

*/

static FIXP_DBL FDKaacEnc_countSingleScfBits(INT scf, INT scfLeft,

                                             INT scfRight) {

  FIXP_DBL scfBitsFract;

  scfBitsFract = (FIXP_DBL)(FDKaacEnc_bitCountScalefactorDelta(scfLeft - scf) +

                            FDKaacEnc_bitCountScalefactorDelta(scf - scfRight));

  scfBitsFract = scfBitsFract << (DFRACT_BITS - 1 - (2 * AS_PE_FAC_SHIFT));

  return scfBitsFract; /* output scaled by 1/(2^(2*AS_PE_FAC)) */

}

/*

  Function: FDKaacEnc_calcSingleSpecPe

  specPe is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))

*/

static FIXP_DBL FDKaacEnc_calcSingleSpecPe(INT scf, FIXP_DBL sfbConstPePart,

                                           FIXP_DBL nLines) {

  FIXP_DBL specPe = FL2FXCONST_DBL(0.0f);

  FIXP_DBL ldRatio;

  FIXP_DBL scfFract;

  scfFract = (FIXP_DBL)(scf << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT));

  ldRatio = sfbConstPePart - fMult(FL2FXCONST_DBL(0.375f), scfFract);

  if (ldRatio >= PE_C1) {

    specPe = fMult(FL2FXCONST_DBL(0.7f), fMult(nLines, ldRatio));

  } else {

    specPe = fMult(FL2FXCONST_DBL(0.7f),

                   fMult(nLines, (PE_C2 + fMult(PE_C3, ldRatio))));

  }

  return specPe; /* output scaled by 1/(2^(2*AS_PE_FAC)) */

}

/*

  Function: FDKaacEnc_countScfBitsDiff

  scfBitsDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))

*/

static FIXP_DBL FDKaacEnc_countScfBitsDiff(INT *scfOld, INT *scfNew, INT sfbCnt,

                                           INT startSfb, INT stopSfb) {

  FIXP_DBL scfBitsFract;

  INT scfBitsDiff = 0;

  INT sfb = 0, sfbLast;

  INT sfbPrev, sfbNext;

  /* search for first relevant sfb */

  sfbLast = startSfb;

  while ((sfbLast < stopSfb) && (scfOld[sfbLast] == FDK_INT_MIN)) sfbLast++;

  /* search for previous relevant sfb and count diff */

  sfbPrev = startSfb - 1;

  while ((sfbPrev >= 0) && (scfOld[sfbPrev] == FDK_INT_MIN)) sfbPrev--;

  if (sfbPrev >= 0)

    scfBitsDiff +=

        FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbPrev] - scfNew[sfbLast]) -

        FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbPrev] - scfOld[sfbLast]);

  /* now loop through all sfbs and count diffs of relevant sfbs */

  for (sfb = sfbLast + 1; sfb < stopSfb; sfb++) {

    if (scfOld[sfb] != FDK_INT_MIN) {

      scfBitsDiff +=

          FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast] - scfNew[sfb]) -

          FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast] - scfOld[sfb]);

      sfbLast = sfb;

    }

  }

  /* search for next relevant sfb and count diff */

  sfbNext = stopSfb;

  while ((sfbNext < sfbCnt) && (scfOld[sfbNext] == FDK_INT_MIN)) sfbNext++;

  if (sfbNext < sfbCnt)

    scfBitsDiff +=

        FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast] - scfNew[sfbNext]) -

        FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast] - scfOld[sfbNext]);

  scfBitsFract =

      (FIXP_DBL)(scfBitsDiff << (DFRACT_BITS - 1 - (2 * AS_PE_FAC_SHIFT)));

  return scfBitsFract;

}

/*

  Function: FDKaacEnc_calcSpecPeDiff

  specPeDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))

*/

static FIXP_DBL FDKaacEnc_calcSpecPeDiff(

    PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, INT *scfOld,

    INT *scfNew, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData,

    FIXP_DBL *sfbNRelevantLines, INT startSfb, INT stopSfb) {

  FIXP_DBL specPeDiff = FL2FXCONST_DBL(0.0f);

  FIXP_DBL scfFract = FL2FXCONST_DBL(0.0f);

  INT sfb;

  /* loop through all sfbs and count pe difference */

  for (sfb = startSfb; sfb < stopSfb; sfb++) {

    if (scfOld[sfb] != FDK_INT_MIN) {

      FIXP_DBL ldRatioOld, ldRatioNew, pOld, pNew;

      /* sfbConstPePart[sfb] = (float)log(psyOutChan->sfbEnergy[sfb] * 6.75f /

       * sfbFormFactor[sfb]) * LOG2_1; */

      /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for

       * log2 */

      /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */

      if (sfbConstPePart[sfb] == (FIXP_DBL)FDK_INT_MIN)

        sfbConstPePart[sfb] =

            ((psyOutChan->sfbEnergyLdData[sfb] - sfbFormFactorLdData[sfb] -

              FL2FXCONST_DBL(0.09375f)) >>

             1) +

            FL2FXCONST_DBL(0.02152255861f);

      scfFract = (FIXP_DBL)(scfOld[sfb] << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT));

      ldRatioOld =

          sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f), scfFract);

      scfFract = (FIXP_DBL)(scfNew[sfb] << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT));

      ldRatioNew =

          sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f), scfFract);

      if (ldRatioOld >= PE_C1)

        pOld = ldRatioOld;

      else

        pOld = PE_C2 + fMult(PE_C3, ldRatioOld);

      if (ldRatioNew >= PE_C1)

        pNew = ldRatioNew;

      else

        pNew = PE_C2 + fMult(PE_C3, ldRatioNew);

      specPeDiff += fMult(FL2FXCONST_DBL(0.7f),

                          fMult(sfbNRelevantLines[sfb], (pNew - pOld)));

    }

  }

  return specPeDiff;

}

/*

  Function: FDKaacEnc_improveScf

  Description: Calculate the distortion by quantization and inverse quantization

  of the spectrum with various scalefactors. The scalefactor which provides the

  best results will be used.

*/

static INT FDKaacEnc_improveScf(const FIXP_DBL *spec, SHORT *quantSpec,

                                SHORT *quantSpecTmp, INT sfbWidth,

                                FIXP_DBL threshLdData, INT scf, INT minScf,

                                FIXP_DBL *distLdData, INT *minScfCalculated,

                                INT dZoneQuantEnable) {

  FIXP_DBL sfbDistLdData;

  INT scfBest = scf;

  INT k;

  FIXP_DBL distFactorLdData = FL2FXCONST_DBL(-0.0050301265); /* ld64(1/1.25) */

  /* calc real distortion */

  sfbDistLdData =

      FDKaacEnc_calcSfbDist(spec, quantSpec, sfbWidth, scf, dZoneQuantEnable);

  *minScfCalculated = scf;

  /* nmr > 1.25 -> try to improve nmr */

  if (sfbDistLdData > (threshLdData - distFactorLdData)) {

    INT scfEstimated = scf;

    FIXP_DBL sfbDistBestLdData = sfbDistLdData;

    INT cnt;

    /* improve by bigger scf ? */

    cnt = 0;

    while ((sfbDistLdData > (threshLdData - distFactorLdData)) &&

           (cnt++ < UPCOUNT_LIMIT)) {

      scf++;

      sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf,

                                            dZoneQuantEnable);

      if (sfbDistLdData < sfbDistBestLdData) {

        scfBest = scf;

        sfbDistBestLdData = sfbDistLdData;

        for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k];

      }

    }

    /* improve by smaller scf ? */

    cnt = 0;

    scf = scfEstimated;

    sfbDistLdData = sfbDistBestLdData;

    while ((sfbDistLdData > (threshLdData - distFactorLdData)) && (cnt++ < 1) &&

           (scf > minScf)) {

      scf--;

      sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf,

                                            dZoneQuantEnable);

      if (sfbDistLdData < sfbDistBestLdData) {

        scfBest = scf;

        sfbDistBestLdData = sfbDistLdData;

        for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k];

      }

      *minScfCalculated = scf;

    }

    *distLdData = sfbDistBestLdData;

  } else { /* nmr <= 1.25 -> try to find bigger scf to use less bits */

    FIXP_DBL sfbDistBestLdData = sfbDistLdData;

    FIXP_DBL sfbDistAllowedLdData =

        fixMin(sfbDistLdData - distFactorLdData, threshLdData);

    int cnt;

    for (cnt = 0; cnt < UPCOUNT_LIMIT; cnt++) {

      scf++;

      sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf,

                                            dZoneQuantEnable);

      if (sfbDistLdData < sfbDistAllowedLdData) {

        *minScfCalculated = scfBest + 1;

        scfBest = scf;

        sfbDistBestLdData = sfbDistLdData;

        for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k];

      }

    }

    *distLdData = sfbDistBestLdData;

  }

  /* return best scalefactor */

  return scfBest;

}

/*

  Function: FDKaacEnc_assimilateSingleScf

*/

static void FDKaacEnc_assimilateSingleScf(

    const PSY_OUT_CHANNEL *psyOutChan, const QC_OUT_CHANNEL *qcOutChannel,

    SHORT *quantSpec, SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf,

    const INT *minScf, FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart,

    const FIXP_DBL *sfbFormFactorLdData, const FIXP_DBL *sfbNRelevantLines,

    INT *minScfCalculated, INT restartOnSuccess) {

  INT sfbLast, sfbAct, sfbNext;

  INT scfAct, *scfLast, *scfNext, scfMin, scfMax;

  INT sfbWidth, sfbOffs;

  FIXP_DBL enLdData;

  FIXP_DBL sfbPeOld, sfbPeNew;

  FIXP_DBL sfbDistNew;

  INT i, k;

  INT success = 0;

  FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);

  FIXP_DBL deltaPeNew, deltaPeTmp;

  INT prevScfLast[MAX_GROUPED_SFB], prevScfNext[MAX_GROUPED_SFB];

  FIXP_DBL deltaPeLast[MAX_GROUPED_SFB];

  INT updateMinScfCalculated;

  for (i = 0; i < psyOutChan->sfbCnt; i++) {

    prevScfLast[i] = FDK_INT_MAX;

    prevScfNext[i] = FDK_INT_MAX;

    deltaPeLast[i] = (FIXP_DBL)FDK_INT_MAX;

  }

  sfbLast = -1;

  sfbAct = -1;

  sfbNext = -1;

  scfLast = 0;

  scfNext = 0;

  scfMin = FDK_INT_MAX;

  scfMax = FDK_INT_MAX;

  do {

    /* search for new relevant sfb */

    sfbNext++;

    while ((sfbNext < psyOutChan->sfbCnt) && (scf[sfbNext] == FDK_INT_MIN))

      sfbNext++;

    if ((sfbLast >= 0) && (sfbAct >= 0) && (sfbNext < psyOutChan->sfbCnt)) {

      /* relevant scfs to the left and to the right */

      scfAct = scf[sfbAct];

      scfLast = scf + sfbLast;

      scfNext = scf + sfbNext;

      scfMin = fixMin(*scfLast, *scfNext);

      scfMax = fixMax(*scfLast, *scfNext);

    } else if ((sfbLast == -1) && (sfbAct >= 0) &&

               (sfbNext < psyOutChan->sfbCnt)) {

      /* first relevant scf */

      scfAct = scf[sfbAct];

      scfLast = &scfAct;

      scfNext = scf + sfbNext;

      scfMin = *scfNext;

      scfMax = *scfNext;

    } else if ((sfbLast >= 0) && (sfbAct >= 0) &&

               (sfbNext == psyOutChan->sfbCnt)) {

      /* last relevant scf */

      scfAct = scf[sfbAct];

      scfLast = scf + sfbLast;

      scfNext = &scfAct;

      scfMin = *scfLast;

      scfMax = *scfLast;

    }

    if (sfbAct >= 0) scfMin = fixMax(scfMin, minScf[sfbAct]);

    if ((sfbAct >= 0) && (sfbLast >= 0 || sfbNext < psyOutChan->sfbCnt) &&

        (scfAct > scfMin) && (scfAct <= scfMin + MAX_SCF_DELTA) &&

        (scfAct >= scfMax - MAX_SCF_DELTA) &&

        (scfAct <=

         fixMin(scfMin, fixMin(*scfLast, *scfNext)) + MAX_SCF_DELTA) &&

        (*scfLast != prevScfLast[sfbAct] || *scfNext != prevScfNext[sfbAct] ||

         deltaPe < deltaPeLast[sfbAct])) {

      /* bigger than neighbouring scf found, try to use smaller scf */

      success = 0;

      sfbWidth =

          psyOutChan->sfbOffsets[sfbAct + 1] - psyOutChan->sfbOffsets[sfbAct];

      sfbOffs = psyOutChan->sfbOffsets[sfbAct];

      /* estimate required bits for actual scf */

      enLdData = qcOutChannel->sfbEnergyLdData[sfbAct];

      /* sfbConstPePart[sfbAct] = (float)log(6.75f*en/sfbFormFactor[sfbAct]) *

       * LOG2_1; */

      /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for

       * log2 */

      /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */

      if (sfbConstPePart[sfbAct] == (FIXP_DBL)FDK_INT_MIN) {

        sfbConstPePart[sfbAct] = ((enLdData - sfbFormFactorLdData[sfbAct] -

                                   FL2FXCONST_DBL(0.09375f)) >>

                                  1) +

                                 FL2FXCONST_DBL(0.02152255861f);

      }

      sfbPeOld = FDKaacEnc_calcSingleSpecPe(scfAct, sfbConstPePart[sfbAct],

                                            sfbNRelevantLines[sfbAct]) +

                 FDKaacEnc_countSingleScfBits(scfAct, *scfLast, *scfNext);

      deltaPeNew = deltaPe;

      updateMinScfCalculated = 1;

      do {

        /* estimate required bits for smaller scf */

        scfAct--;

        /* check only if the same check was not done before */

        if (scfAct < minScfCalculated[sfbAct] &&

            scfAct >= scfMax - MAX_SCF_DELTA) {

          /* estimate required bits for new scf */

          sfbPeNew = FDKaacEnc_calcSingleSpecPe(scfAct, sfbConstPePart[sfbAct],

                                                sfbNRelevantLines[sfbAct]) +

                     FDKaacEnc_countSingleScfBits(scfAct, *scfLast, *scfNext);

          /* use new scf if no increase in pe and

             quantization error is smaller */

          deltaPeTmp = deltaPe + sfbPeNew - sfbPeOld;

          /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */

          if (deltaPeTmp < FL2FXCONST_DBL(0.0006103515625f)) {

            /* distortion of new scf */

            sfbDistNew = FDKaacEnc_calcSfbDist(

                qcOutChannel->mdctSpectrum + sfbOffs, quantSpecTmp + sfbOffs,

                sfbWidth, scfAct, dZoneQuantEnable);

            if (sfbDistNew < sfbDist[sfbAct]) {

              /* success, replace scf by new one */

              scf[sfbAct] = scfAct;

              sfbDist[sfbAct] = sfbDistNew;

              for (k = 0; k < sfbWidth; k++)

                quantSpec[sfbOffs + k] = quantSpecTmp[sfbOffs + k];

              deltaPeNew = deltaPeTmp;

              success = 1;

            }

            /* mark as already checked */

            if (updateMinScfCalculated) minScfCalculated[sfbAct] = scfAct;

          } else {

            /* from this scf value on not all new values have been checked */

            updateMinScfCalculated = 0;

          }

        }

      } while (scfAct > scfMin);

      deltaPe = deltaPeNew;

      /* save parameters to avoid multiple computations of the same sfb */

      prevScfLast[sfbAct] = *scfLast;

      prevScfNext[sfbAct] = *scfNext;

      deltaPeLast[sfbAct] = deltaPe;

    }

    if (success && restartOnSuccess) {

      /* start again at first sfb */

      sfbLast = -1;

      sfbAct = -1;

      sfbNext = -1;

      scfLast = 0;

      scfNext = 0;

      scfMin = FDK_INT_MAX;

      scfMax = FDK_INT_MAX;

      success = 0;

    } else {

      /* shift sfbs for next band */

      sfbLast = sfbAct;

      sfbAct = sfbNext;

    }

  } while (sfbNext < psyOutChan->sfbCnt);

}

/*

  Function: FDKaacEnc_assimilateMultipleScf

*/

static void FDKaacEnc_assimilateMultipleScf(

    PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, SHORT *quantSpec,

    SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf, const INT *minScf,

    FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData,

    FIXP_DBL *sfbNRelevantLines) {

  INT sfb, startSfb, stopSfb;

  INT scfTmp[MAX_GROUPED_SFB], scfMin, scfMax, scfAct;

  INT possibleRegionFound;

  INT sfbWidth, sfbOffs, i, k;

  FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], distOldSum, distNewSum;

  INT deltaScfBits;

  FIXP_DBL deltaSpecPe;

  FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);

  FIXP_DBL deltaPeNew;

  INT sfbCnt = psyOutChan->sfbCnt;

  /* calc min and max scalfactors */

  scfMin = FDK_INT_MAX;

  scfMax = FDK_INT_MIN;

  for (sfb = 0; sfb < sfbCnt; sfb++) {

    if (scf[sfb] != FDK_INT_MIN) {

      scfMin = fixMin(scfMin, scf[sfb]);

      scfMax = fixMax(scfMax, scf[sfb]);

    }

  }

  if (scfMax != FDK_INT_MIN && scfMax <= scfMin + MAX_SCF_DELTA) {

    scfAct = scfMax;

    do {

      /* try smaller scf */

      scfAct--;

      for (i = 0; i < MAX_GROUPED_SFB; i++) scfTmp[i] = scf[i];

      stopSfb = 0;

      do {

        /* search for region where all scfs are bigger than scfAct */

        sfb = stopSfb;

        while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN || scf[sfb] <= scfAct))

          sfb++;

        startSfb = sfb;

        sfb++;

        while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN || scf[sfb] > scfAct))

          sfb++;

        stopSfb = sfb;

        /* check if in all sfb of a valid region scfAct >= minScf[sfb] */

        possibleRegionFound = 0;

        if (startSfb < sfbCnt) {

          possibleRegionFound = 1;

          for (sfb = startSfb; sfb < stopSfb; sfb++) {

            if (scf[sfb] != FDK_INT_MIN)

              if (scfAct < minScf[sfb]) {

                possibleRegionFound = 0;

                break;

              }

          }

        }

        if (possibleRegionFound) { /* region found */

          /* replace scfs in region by scfAct */

          for (sfb = startSfb; sfb < stopSfb; sfb++) {

            if (scfTmp[sfb] != FDK_INT_MIN) scfTmp[sfb] = scfAct;

          }

          /* estimate change in bit demand for new scfs */

          deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt,

                                                    startSfb, stopSfb);

          deltaSpecPe = FDKaacEnc_calcSpecPeDiff(

              psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart,

              sfbFormFactorLdData, sfbNRelevantLines, startSfb, stopSfb);

          deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe;

          /* new bit demand small enough ? */

          /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */

          if (deltaPeNew < FL2FXCONST_DBL(0.0006103515625f)) {

            /* quantize and calc sum of new distortion */

            distOldSum = distNewSum = FL2FXCONST_DBL(0.0f);

            for (sfb = startSfb; sfb < stopSfb; sfb++) {

              if (scfTmp[sfb] != FDK_INT_MIN) {

                distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT;

                sfbWidth = psyOutChan->sfbOffsets[sfb + 1] -

                           psyOutChan->sfbOffsets[sfb];

                sfbOffs = psyOutChan->sfbOffsets[sfb];

                sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(

                    qcOutChannel->mdctSpectrum + sfbOffs,

                    quantSpecTmp + sfbOffs, sfbWidth, scfAct, dZoneQuantEnable);

                if (sfbDistNew[sfb] > qcOutChannel->sfbThresholdLdData[sfb]) {

                  /* no improvement, skip further dist. calculations */

                  distNewSum = distOldSum << 1;

                  break;

                }

                distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT;

              }

            }

            /* distortion smaller ? -> use new scalefactors */

            if (distNewSum < distOldSum) {

              deltaPe = deltaPeNew;

              for (sfb = startSfb; sfb < stopSfb; sfb++) {

                if (scf[sfb] != FDK_INT_MIN) {

                  sfbWidth = psyOutChan->sfbOffsets[sfb + 1] -

                             psyOutChan->sfbOffsets[sfb];

                  sfbOffs = psyOutChan->sfbOffsets[sfb];

                  scf[sfb] = scfAct;

                  sfbDist[sfb] = sfbDistNew[sfb];

                  for (k = 0; k < sfbWidth; k++)

                    quantSpec[sfbOffs + k] = quantSpecTmp[sfbOffs + k];

                }

              }

            }

          }

        }

      } while (stopSfb <= sfbCnt);

    } while (scfAct > scfMin);

  }

}

/*

  Function: FDKaacEnc_FDKaacEnc_assimilateMultipleScf2

*/

static void FDKaacEnc_FDKaacEnc_assimilateMultipleScf2(

    PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, SHORT *quantSpec,

    SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf, const INT *minScf,

    FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData,

    FIXP_DBL *sfbNRelevantLines) {

  INT sfb, startSfb, stopSfb;

  INT scfTmp[MAX_GROUPED_SFB], scfAct, scfNew;

  INT scfPrev, scfNext, scfPrevNextMin, scfPrevNextMax, scfLo, scfHi;

  INT scfMin, scfMax;

  INT *sfbOffs = psyOutChan->sfbOffsets;

  FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], sfbDistMax[MAX_GROUPED_SFB];

  FIXP_DBL distOldSum, distNewSum;

  INT deltaScfBits;

  FIXP_DBL deltaSpecPe;

  FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);

  FIXP_DBL deltaPeNew = FL2FXCONST_DBL(0.0f);

  INT sfbCnt = psyOutChan->sfbCnt;

  INT bSuccess, bCheckScf;

  INT i, k;

  /* calc min and max scalfactors */

  scfMin = FDK_INT_MAX;

  scfMax = FDK_INT_MIN;

  for (sfb = 0; sfb < sfbCnt; sfb++) {

    if (scf[sfb] != FDK_INT_MIN) {

      scfMin = fixMin(scfMin, scf[sfb]);

      scfMax = fixMax(scfMax, scf[sfb]);

    }

  }

  stopSfb = 0;

  scfAct = FDK_INT_MIN;

  do {

    /* search for region with same scf values scfAct */

    scfPrev = scfAct;

    sfb = stopSfb;

    while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN)) sfb++;

    startSfb = sfb;

    scfAct = scf[startSfb];

    sfb++;

    while (sfb < sfbCnt &&

           ((scf[sfb] == FDK_INT_MIN) || (scf[sfb] == scf[startSfb])))

      sfb++;

    stopSfb = sfb;

    if (stopSfb < sfbCnt)

      scfNext = scf[stopSfb];

    else

      scfNext = scfAct;

    if (scfPrev == FDK_INT_MIN) scfPrev = scfAct;

    scfPrevNextMax = fixMax(scfPrev, scfNext);

    scfPrevNextMin = fixMin(scfPrev, scfNext);

    /* try to reduce bits by checking scf values in the range

       scf[startSfb]...scfHi */

    scfHi = fixMax(scfPrevNextMax, scfAct);

    /* try to find a better solution by reducing the scf difference to

       the nearest possible lower scf */

    if (scfPrevNextMax >= scfAct)

      scfLo = fixMin(scfAct, scfPrevNextMin);

    else

      scfLo = scfPrevNextMax;

    if (startSfb < sfbCnt &&

        scfHi - scfLo <= MAX_SCF_DELTA) { /* region found */

      /* 1. try to save bits by coarser quantization */

      if (scfHi > scf[startSfb]) {

        /* calculate the allowed distortion */

        for (sfb = startSfb; sfb < stopSfb; sfb++) {

          if (scf[sfb] != FDK_INT_MIN) {

            /* sfbDistMax[sfb] =

             * (float)pow(qcOutChannel->sfbThreshold[sfb]*sfbDist[sfb]*sfbDist[sfb],1.0f/3.0f);

             */

            /* sfbDistMax[sfb] =

             * fixMax(sfbDistMax[sfb],qcOutChannel->sfbEnergy[sfb]*FL2FXCONST_DBL(1.e-3f));

             */

            /* -0.15571537944 = ld64(1.e-3f)*/

            sfbDistMax[sfb] = fMult(FL2FXCONST_DBL(1.0f / 3.0f),

                                    qcOutChannel->sfbThresholdLdData[sfb]) +

                              fMult(FL2FXCONST_DBL(1.0f / 3.0f), sfbDist[sfb]) +

                              fMult(FL2FXCONST_DBL(1.0f / 3.0f), sfbDist[sfb]);

            sfbDistMax[sfb] =

                fixMax(sfbDistMax[sfb], qcOutChannel->sfbEnergyLdData[sfb] -

                                            FL2FXCONST_DBL(0.15571537944));

            sfbDistMax[sfb] =

                fixMin(sfbDistMax[sfb], qcOutChannel->sfbThresholdLdData[sfb]);

          }

        }

        /* loop over all possible scf values for this region */

        bCheckScf = 1;

        for (scfNew = scf[startSfb] + 1; scfNew <= scfHi; scfNew++) {

          for (k = 0; k < MAX_GROUPED_SFB; k++) scfTmp[k] = scf[k];

          /* replace scfs in region by scfNew */

          for (sfb = startSfb; sfb < stopSfb; sfb++) {

            if (scfTmp[sfb] != FDK_INT_MIN) scfTmp[sfb] = scfNew;

          }

          /* estimate change in bit demand for new scfs */

          deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt,

                                                    startSfb, stopSfb);

          deltaSpecPe = FDKaacEnc_calcSpecPeDiff(

              psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart,

              sfbFormFactorLdData, sfbNRelevantLines, startSfb, stopSfb);

          deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe;

          /* new bit demand small enough ? */

          if (deltaPeNew < FL2FXCONST_DBL(0.0f)) {

            bSuccess = 1;

            /* quantize and calc sum of new distortion */

            for (sfb = startSfb; sfb < stopSfb; sfb++) {

              if (scfTmp[sfb] != FDK_INT_MIN) {

                sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(

                    qcOutChannel->mdctSpectrum + sfbOffs[sfb],

                    quantSpecTmp + sfbOffs[sfb],

                    sfbOffs[sfb + 1] - sfbOffs[sfb], scfNew, dZoneQuantEnable);

                if (sfbDistNew[sfb] > sfbDistMax[sfb]) {

                  /* no improvement, skip further dist. calculations */

                  bSuccess = 0;

                  if (sfbDistNew[sfb] == qcOutChannel->sfbEnergyLdData[sfb]) {

                    /* if whole sfb is already quantized to 0, further

                       checks with even coarser quant. are useless*/

                    bCheckScf = 0;

                  }

                  break;

                }

              }

            }