Include patched FDK-AAC in the repository

The initial idea was to get the DAB+ patch into upstream, but since
that follows the android source releases, there is no place for a custom
DAB+ patch there.

So instead of having to maintain a patched fdk-aac that has to have the
same .so version as the distribution package on which it is installed,
we prefer having a separate fdk-aac-dab library to avoid collision.

At that point, there's no reason to keep fdk-aac in a separate
repository, as odr-audioenc is the only tool that needs DAB+ encoding
support. Including it here simplifies installation, and makes it
consistent with toolame-dab, also shipped in this repository.

DAB+ decoding support (needed by ODR-SourceCompanion, dablin, etisnoop,
welle.io and others) can be done using upstream FDK-AAC.

1 files changed, 1292 insertions, 0 deletions

diff --git a/fdk-aac/libAACenc/src/sf_estim.cpp b/fdk-aac/libAACenc/src/sf_estim.cpp
new file mode 100644
index 0000000..17a8ae2
--- /dev/null
+++ b/fdk-aac/libAACenc/src/sf_estim.cpp
@@ -0,0 +1,1292 @@
+/* -----------------------------------------------------------------------------
+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;
+                }
+              }
+            }
+            if (bCheckScf == 0) /* further calculations useless ? */
+              break;
+            /* distortion small enough ? -> use new scalefactors */
+            if (bSuccess) {
+              deltaPe = deltaPeNew;
+              for (sfb = startSfb; sfb < stopSfb; sfb++) {
+                if (scf[sfb] != FDK_INT_MIN) {
+                  scf[sfb] = scfNew;
+                  sfbDist[sfb] = sfbDistNew[sfb];
+
+                  for (k = 0; k < sfbOffs[sfb + 1] - sfbOffs[sfb]; k++)
+                    quantSpec[sfbOffs[sfb] + k] =
+                        quantSpecTmp[sfbOffs[sfb] + k];
+                }
+              }
+            }
+          }
+        }
+      }
+
+      /* 2. only if coarser quantization was not successful, try to find
+         a better solution by finer quantization and reducing bits for
+         scalefactor coding */
+      if (scfAct == scf[startSfb] && scfLo < scfAct &&
+          scfMax - scfMin <= MAX_SCF_DELTA) {
+        int bminScfViolation = 0;
+
+        for (k = 0; k < MAX_GROUPED_SFB; k++) scfTmp[k] = scf[k];
+
+        scfNew = scfLo;
+
+        /* replace scfs in region by scfNew and
+           check if in all sfb scfNew >= minScf[sfb] */
+        for (sfb = startSfb; sfb < stopSfb; sfb++) {
+          if (scfTmp[sfb] != FDK_INT_MIN) {
+            scfTmp[sfb] = scfNew;
+            if (scfNew < minScf[sfb]) bminScfViolation = 1;
+          }
+        }
+
+        if (!bminScfViolation) {
+          /* 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 (!bminScfViolation && deltaPeNew < FL2FXCONST_DBL(0.0f)) {
+          /* 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;
+
+              sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(
+                  qcOutChannel->mdctSpectrum + sfbOffs[sfb],
+                  quantSpecTmp + sfbOffs[sfb], sfbOffs[sfb + 1] - sfbOffs[sfb],
+                  scfNew, 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 < fMult(FL2FXCONST_DBL(0.8f), distOldSum)) {
+            deltaPe = deltaPeNew;
+            for (sfb = startSfb; sfb < stopSfb; sfb++) {
+              if (scf[sfb] != FDK_INT_MIN) {
+                scf[sfb] = scfNew;
+                sfbDist[sfb] = sfbDistNew[sfb];
+
+                for (k = 0; k < sfbOffs[sfb + 1] - sfbOffs[sfb]; k++)
+                  quantSpec[sfbOffs[sfb] + k] = quantSpecTmp[sfbOffs[sfb] + k];
+              }
+            }
+          }
+        }
+      }
+
+      /* 3. try to find a better solution (save bits) by only reducing the
+         scalefactor without new quantization */
+      if (scfMax - scfMin <=
+          MAX_SCF_DELTA - 3) { /* 3 bec. scf is reduced 3 times,
+                                  see for loop below */
+
+        for (k = 0; k < sfbCnt; k++) scfTmp[k] = scf[k];
+
+        for (i = 0; i < 3; i++) {
+          scfNew = scfTmp[startSfb] - 1;
+          /* 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);
+          deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits;
+          /* new bit demand small enough ? */
+          if (deltaPeNew <= FL2FXCONST_DBL(0.0f)) {
+            bSuccess = 1;
+            distOldSum = distNewSum = FL2FXCONST_DBL(0.0f);
+            for (sfb = startSfb; sfb < stopSfb; sfb++) {
+              if (scfTmp[sfb] != FDK_INT_MIN) {
+                FIXP_DBL sfbEnQ;
+                /* calc the energy and distortion of the quantized spectrum for
+                   a smaller scf */
+                FDKaacEnc_calcSfbQuantEnergyAndDist(
+                    qcOutChannel->mdctSpectrum + sfbOffs[sfb],
+                    quantSpec + sfbOffs[sfb], sfbOffs[sfb + 1] - sfbOffs[sfb],
+                    scfNew, &sfbEnQ, &sfbDistNew[sfb]);
+
+                distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT;
+                distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT;
+
+                /*  0.00259488556167 = ld64(1.122f) */
+                /* -0.00778722686652 = ld64(0.7079f) */
+                if ((sfbDistNew[sfb] >
+                     (sfbDist[sfb] + FL2FXCONST_DBL(0.00259488556167f))) ||
+                    (sfbEnQ < (qcOutChannel->sfbEnergyLdData[sfb] -
+                               FL2FXCONST_DBL(0.00778722686652f)))) {
+                  bSuccess = 0;
+                  break;
+                }
+              }
+            }
+            /* distortion smaller ? -> use new scalefactors */
+            if (distNewSum < distOldSum && bSuccess) {
+              deltaPe = deltaPeNew;
+              for (sfb = startSfb; sfb < stopSfb; sfb++) {
+                if (scf[sfb] != FDK_INT_MIN) {
+                  scf[sfb] = scfNew;
+                  sfbDist[sfb] = sfbDistNew[sfb];
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  } while (stopSfb <= sfbCnt);
+}
+
+static void FDKaacEnc_EstimateScaleFactorsChannel(
+    QC_OUT_CHANNEL *qcOutChannel, PSY_OUT_CHANNEL *psyOutChannel,
+    INT *RESTRICT scf, INT *RESTRICT globalGain,
+    FIXP_DBL *RESTRICT sfbFormFactorLdData, const INT invQuant,
+    SHORT *RESTRICT quantSpec, const INT dZoneQuantEnable) {
+  INT i, j, sfb, sfbOffs;
+  INT scfInt;
+  INT maxSf;
+  INT minSf;
+  FIXP_DBL threshLdData;
+  FIXP_DBL energyLdData;
+  FIXP_DBL energyPartLdData;
+  FIXP_DBL thresholdPartLdData;
+  FIXP_DBL scfFract;
+  FIXP_DBL maxSpec;
+  INT minScfCalculated[MAX_GROUPED_SFB];
+  FIXP_DBL sfbDistLdData[MAX_GROUPED_SFB];
+  C_ALLOC_SCRATCH_START(quantSpecTmp, SHORT, (1024))
+  INT minSfMaxQuant[MAX_GROUPED_SFB];
+
+  FIXP_DBL threshConstLdData =
+      FL2FXCONST_DBL(0.04304511722f); /* log10(6.75)/log10(2.0)/64.0 */
+  FIXP_DBL convConst = FL2FXCONST_DBL(0.30102999566f); /* log10(2.0) */
+  FIXP_DBL c1Const =
+      FL2FXCONST_DBL(-0.27083183594f); /* C1 = -69.33295 => C1/2^8 */
+
+  if (invQuant > 0) {
+    FDKmemclear(quantSpec, (1024) * sizeof(SHORT));
+  }
+
+  /* scfs without energy or with thresh>energy are marked with FDK_INT_MIN */
+  for (i = 0; i < psyOutChannel->sfbCnt; i++) {
+    scf[i] = FDK_INT_MIN;
+  }
+
+  for (i = 0; i < MAX_GROUPED_SFB; i++) {
+    minSfMaxQuant[i] = FDK_INT_MIN;
+  }
+
+  for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+       sfbOffs += psyOutChannel->sfbPerGroup) {
+    for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+      threshLdData = qcOutChannel->sfbThresholdLdData[sfbOffs + sfb];
+      energyLdData = qcOutChannel->sfbEnergyLdData[sfbOffs + sfb];
+
+      sfbDistLdData[sfbOffs + sfb] = energyLdData;
+
+      if (energyLdData > threshLdData) {
+        FIXP_DBL tmp;
+
+        /* energyPart = (float)log10(sfbFormFactor[sfbOffs+sfb]); */
+        /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */
+        energyPartLdData =
+            sfbFormFactorLdData[sfbOffs + sfb] + FL2FXCONST_DBL(0.09375f);
+
+        /* influence of allowed distortion */
+        /* thresholdPart = (float)log10(6.75*thresh+FLT_MIN); */
+        thresholdPartLdData = threshConstLdData + threshLdData;
+
+        /* scf calc */
+        /* scfFloat = 8.8585f * (thresholdPart - energyPart); */
+        scfFract = thresholdPartLdData - energyPartLdData;
+        /* conversion from log2 to log10 */
+        scfFract = fMult(convConst, scfFract);
+        /* (8.8585f * scfFract)/8 = 8/8 * scfFract + 0.8585 * scfFract/8 */
+        scfFract = scfFract + fMult(FL2FXCONST_DBL(0.8585f), scfFract >> 3);
+
+        /* integer scalefactor */
+        /* scfInt = (int)floor(scfFloat); */
+        scfInt =
+            (INT)(scfFract >>
+                  ((DFRACT_BITS - 1) - 3 -
+                   LD_DATA_SHIFT)); /* 3 bits => scfFract/8.0; 6 bits => ld64 */
+
+        /* maximum of spectrum */
+        maxSpec = FL2FXCONST_DBL(0.0f);
+
+        /* Unroll by 4, allow dual memory access */
+        DWORD_ALIGNED(qcOutChannel->mdctSpectrum);
+        for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb];
+             j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j += 4) {
+          maxSpec = fMax(maxSpec,
+                         fMax(fMax(fAbs(qcOutChannel->mdctSpectrum[j + 0]),
+                                   fAbs(qcOutChannel->mdctSpectrum[j + 1])),
+                              fMax(fAbs(qcOutChannel->mdctSpectrum[j + 2]),
+                                   fAbs(qcOutChannel->mdctSpectrum[j + 3]))));
+        }
+        /* lower scf limit to avoid quantized values bigger than MAX_QUANT */
+        /* C1 = -69.33295f, C2 = 5.77078f = 4/log(2) */
+        /* minSfMaxQuant[sfbOffs+sfb] = (int)ceil(C1 + C2*log(maxSpec)); */
+        /* C1/2^8 + 4/log(2.0)*log(maxSpec)/2^8  => C1/2^8 +
+         * log(maxSpec)/log(2.0)*4/2^8 => C1/2^8 + log(maxSpec)/log(2.0)/64.0 */
+
+        // minSfMaxQuant[sfbOffs+sfb] = ((INT) ((c1Const + CalcLdData(maxSpec))
+        // >> ((DFRACT_BITS-1)-8))) + 1;
+        tmp = CalcLdData(maxSpec);
+        if (c1Const > FL2FXCONST_DBL(-1.f) - tmp) {
+          minSfMaxQuant[sfbOffs + sfb] =
+              ((INT)((c1Const + tmp) >> ((DFRACT_BITS - 1) - 8))) + 1;
+        } else {
+          minSfMaxQuant[sfbOffs + sfb] =
+              ((INT)(FL2FXCONST_DBL(-1.f) >> ((DFRACT_BITS - 1) - 8))) + 1;
+        }
+
+        scfInt = fixMax(scfInt, minSfMaxQuant[sfbOffs + sfb]);
+
+        /* find better scalefactor with analysis by synthesis */
+        if (invQuant > 0) {
+          scfInt = FDKaacEnc_improveScf(
+              qcOutChannel->mdctSpectrum +
+                  psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              quantSpec + psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              quantSpecTmp + psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              psyOutChannel->sfbOffsets[sfbOffs + sfb + 1] -
+                  psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              threshLdData, scfInt, minSfMaxQuant[sfbOffs + sfb],
+              &sfbDistLdData[sfbOffs + sfb], &minScfCalculated[sfbOffs + sfb],
+              dZoneQuantEnable);
+        }
+        scf[sfbOffs + sfb] = scfInt;
+      }
+    }
+  }
+
+  if (invQuant > 0) {
+    /* try to decrease scf differences */
+    FIXP_DBL sfbConstPePart[MAX_GROUPED_SFB];
+    FIXP_DBL sfbNRelevantLines[MAX_GROUPED_SFB];
+
+    for (i = 0; i < psyOutChannel->sfbCnt; i++)
+      sfbConstPePart[i] = (FIXP_DBL)FDK_INT_MIN;
+
+    FDKaacEnc_calcSfbRelevantLines(
+        sfbFormFactorLdData, qcOutChannel->sfbEnergyLdData,
+        qcOutChannel->sfbThresholdLdData, psyOutChannel->sfbOffsets,
+        psyOutChannel->sfbCnt, psyOutChannel->sfbPerGroup,
+        psyOutChannel->maxSfbPerGroup, sfbNRelevantLines);
+
+    FDKaacEnc_assimilateSingleScf(
+        psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, dZoneQuantEnable,
+        scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart, sfbFormFactorLdData,
+        sfbNRelevantLines, minScfCalculated, 1);
+
+    if (invQuant > 1) {
+      FDKaacEnc_assimilateMultipleScf(
+          psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp,
+          dZoneQuantEnable, scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart,
+          sfbFormFactorLdData, sfbNRelevantLines);
+
+      FDKaacEnc_FDKaacEnc_assimilateMultipleScf2(
+          psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp,
+          dZoneQuantEnable, scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart,
+          sfbFormFactorLdData, sfbNRelevantLines);
+    }
+  }
+
+  /* get min scalefac */
+  minSf = FDK_INT_MAX;
+  for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+       sfbOffs += psyOutChannel->sfbPerGroup) {
+    for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+      if (scf[sfbOffs + sfb] != FDK_INT_MIN)
+        minSf = fixMin(minSf, scf[sfbOffs + sfb]);
+    }
+  }
+
+  /* limit scf delta */
+  for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+       sfbOffs += psyOutChannel->sfbPerGroup) {
+    for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+      if ((scf[sfbOffs + sfb] != FDK_INT_MIN) &&
+          (minSf + MAX_SCF_DELTA) < scf[sfbOffs + sfb]) {
+        scf[sfbOffs + sfb] = minSf + MAX_SCF_DELTA;
+        if (invQuant > 0) { /* changed bands need to be quantized again */
+          sfbDistLdData[sfbOffs + sfb] = FDKaacEnc_calcSfbDist(
+              qcOutChannel->mdctSpectrum +
+                  psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              quantSpec + psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              psyOutChannel->sfbOffsets[sfbOffs + sfb + 1] -
+                  psyOutChannel->sfbOffsets[sfbOffs + sfb],
+              scf[sfbOffs + sfb], dZoneQuantEnable);
+        }
+      }
+    }
+  }
+
+  /* get max scalefac for global gain */
+  maxSf = FDK_INT_MIN;
+  for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+       sfbOffs += psyOutChannel->sfbPerGroup) {
+    for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+      maxSf = fixMax(maxSf, scf[sfbOffs + sfb]);
+    }
+  }
+
+  /* calc loop scalefactors, if spec is not all zero (i.e. maxSf == -99) */
+  if (maxSf > FDK_INT_MIN) {
+    *globalGain = maxSf;
+    for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+         sfbOffs += psyOutChannel->sfbPerGroup) {
+      for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+        if (scf[sfbOffs + sfb] == FDK_INT_MIN) {
+          scf[sfbOffs + sfb] = 0;
+          /* set band explicitely to zero */
+          for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb];
+               j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j++) {
+            qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f);
+          }
+        } else {
+          scf[sfbOffs + sfb] = maxSf - scf[sfbOffs + sfb];
+        }
+      }
+    }
+  } else {
+    *globalGain = 0;
+    /* set spectrum explicitely to zero */
+    for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt;
+         sfbOffs += psyOutChannel->sfbPerGroup) {
+      for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
+        scf[sfbOffs + sfb] = 0;
+        /* set band explicitely to zero */
+        for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb];
+             j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j++) {
+          qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f);
+        }
+      }
+    }
+  }
+
+  /* free quantSpecTmp from scratch */
+  C_ALLOC_SCRATCH_END(quantSpecTmp, SHORT, (1024))
+}
+
+void FDKaacEnc_EstimateScaleFactors(PSY_OUT_CHANNEL *psyOutChannel[],
+                                    QC_OUT_CHANNEL *qcOutChannel[],
+                                    const INT invQuant,
+                                    const INT dZoneQuantEnable,
+                                    const INT nChannels) {
+  int ch;
+
+  for (ch = 0; ch < nChannels; ch++) {
+    FDKaacEnc_EstimateScaleFactorsChannel(
+        qcOutChannel[ch], psyOutChannel[ch], qcOutChannel[ch]->scf,
+        &qcOutChannel[ch]->globalGain, qcOutChannel[ch]->sfbFormFactorLdData,
+        invQuant, qcOutChannel[ch]->quantSpec, dZoneQuantEnable);
+  }
+}