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

Software License for The Fraunhofer FDK AAC Codec Library for Android

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

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

/**************************** SBR decoder library ******************************

   Author(s):

   Description:

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

/*!

  \file

  \brief  Low Power Profile Transposer

  This module provides the transposer. The main entry point is lppTransposer().

  The function generates high frequency content by copying data from the low

  band (provided by core codec) into the high band. This process is also

  referred to as "patching". The function also implements spectral whitening by

  means of inverse filtering based on LPC coefficients.

  Together with the QMF filterbank the transposer can be tested using a supplied

  test program. See main_audio.cpp for details. This module does use fractional

  arithmetic and the accuracy of the computations has an impact on the overall

  sound quality. The module also needs to take into account the different

  scaling of spectral data.

  \sa lppTransposer(), main_audio.cpp, sbr_scale.h, \ref documentationOverview

*/

#if __has_include(<android/ndk-version.h>)

#include <android/ndk-version.h>

#endif

#if defined __ANDROID__ && !defined __ANDROID_NDK__

#include "log/log.h"

#endif

#include "lpp_tran.h"

#include "sbr_ram.h"

#include "sbr_rom.h"

#include "genericStds.h"

#include "autocorr2nd.h"

#include "HFgen_preFlat.h"

#define LPC_SCALE_FACTOR 2

/*!

 *

 * \brief Get bandwidth expansion factor from filtering level

 *

 * Returns a filter parameter (bandwidth expansion factor) depending on

 * the desired filtering level signalled in the bitstream.

 * When switching the filtering level from LOW to OFF, an additional

 * level is being inserted to achieve a smooth transition.

 */

static FIXP_DBL mapInvfMode(INVF_MODE mode, INVF_MODE prevMode,

                            WHITENING_FACTORS whFactors) {

  switch (mode) {

    case INVF_LOW_LEVEL:

      if (prevMode == INVF_OFF)

        return whFactors.transitionLevel;

      else

        return whFactors.lowLevel;

    case INVF_MID_LEVEL:

      return whFactors.midLevel;

    case INVF_HIGH_LEVEL:

      return whFactors.highLevel;

    default:

      if (prevMode == INVF_LOW_LEVEL)

        return whFactors.transitionLevel;

      else

        return whFactors.off;

  }

}

/*!

 *

 * \brief Perform inverse filtering level emphasis

 *

 * Retrieve bandwidth expansion factor and apply smoothing for each filter band

 *

 */

static void inverseFilteringLevelEmphasis(

    HANDLE_SBR_LPP_TRANS hLppTrans, /*!< Handle of lpp transposer  */

    UCHAR nInvfBands,              /*!< Number of bands for inverse filtering */

    INVF_MODE *sbr_invf_mode,      /*!< Current inverse filtering modes */

    INVF_MODE *sbr_invf_mode_prev, /*!< Previous inverse filtering modes */

    FIXP_DBL *bwVector             /*!< Resulting filtering levels */

) {

  for (int i = 0; i < nInvfBands; i++) {

    FIXP_DBL accu;

    FIXP_DBL bwTmp = mapInvfMode(sbr_invf_mode[i], sbr_invf_mode_prev[i],

                                 hLppTrans->pSettings->whFactors);

    if (bwTmp < hLppTrans->bwVectorOld[i]) {

      accu = fMultDiv2(FL2FXCONST_DBL(0.75f), bwTmp) +

             fMultDiv2(FL2FXCONST_DBL(0.25f), hLppTrans->bwVectorOld[i]);

    } else {

      accu = fMultDiv2(FL2FXCONST_DBL(0.90625f), bwTmp) +

             fMultDiv2(FL2FXCONST_DBL(0.09375f), hLppTrans->bwVectorOld[i]);

    }

    if (accu<FL2FXCONST_DBL(0.015625f)>> 1) {

      bwVector[i] = FL2FXCONST_DBL(0.0f);

    } else {

      bwVector[i] = fixMin(accu << 1, FL2FXCONST_DBL(0.99609375f));

    }

  }

}

/* Resulting autocorrelation determinant exponent */

#define ACDET_EXP \

  (2 * (DFRACT_BITS + sbrScaleFactor->lb_scale + 10 - ac.det_scale))

#define AC_EXP (-sbrScaleFactor->lb_scale + LPC_SCALE_FACTOR)

#define ALPHA_EXP (-sbrScaleFactor->lb_scale + LPC_SCALE_FACTOR + 1)

/* Resulting transposed QMF values exponent 16 bit normalized samplebits

 * assumed. */

#define QMFOUT_EXP ((SAMPLE_BITS - 15) - sbrScaleFactor->lb_scale)

static inline void calc_qmfBufferReal(FIXP_DBL **qmfBufferReal,

                                      const FIXP_DBL *const lowBandReal,

                                      const int startSample,

                                      const int stopSample, const UCHAR hiBand,

                                      const int dynamicScale,

                                      const FIXP_SGL a0r, const FIXP_SGL a1r) {

  const int dynscale = fixMax(0, dynamicScale - 1) + 1;

  const int rescale = -fixMin(0, dynamicScale - 1) + 1;

  const int descale =

      fixMin(DFRACT_BITS - 1, LPC_SCALE_FACTOR + dynamicScale + rescale);

  for (int i = 0; i < stopSample - startSample; i++) {

    FIXP_DBL accu;

    accu = fMultDiv2(a1r, lowBandReal[i]) + fMultDiv2(a0r, lowBandReal[i + 1]);

    accu = (lowBandReal[i + 2] >> descale) + (accu >> dynscale);

    qmfBufferReal[i + startSample][hiBand] =

        SATURATE_LEFT_SHIFT(accu, rescale, DFRACT_BITS);

  }

}

/*!

 *

 * \brief Perform transposition by patching of subband samples.

 * This function serves as the main entry point into the module. The function

 * determines the areas for the patching process (these are the source range as

 * well as the target range) and implements spectral whitening by means of

 * inverse filtering. The function autoCorrelation2nd() is an auxiliary function

 * for calculating the LPC coefficients for the filtering.  The actual

 * calculation of the LPC coefficients and the implementation of the filtering

 * are done as part of lppTransposer().

 *

 * Note that the filtering is done on all available QMF subsamples, whereas the

 * patching is only done on those QMF subsamples that will be used in the next

 * QMF synthesis. The filtering is also implemented before the patching includes

 * further dependencies on parameters from the SBR data.

 *

 */

void lppTransposer(

    HANDLE_SBR_LPP_TRANS hLppTrans,   /*!< Handle of lpp transposer  */

    QMF_SCALE_FACTOR *sbrScaleFactor, /*!< Scaling factors */

    FIXP_DBL **qmfBufferReal, /*!< Pointer to pointer to real part of subband

                                 samples (source) */

    FIXP_DBL *degreeAlias,    /*!< Vector for results of aliasing estimation */

    FIXP_DBL **qmfBufferImag, /*!< Pointer to pointer to imaginary part of

                                 subband samples (source) */

    const int useLP, const int fPreWhitening, const int v_k_master0,

    const int timeStep,       /*!< Time step of envelope */

    const int firstSlotOffs,  /*!< Start position in time */

    const int lastSlotOffs,   /*!< Number of overlap-slots into next frame */

    const int nInvfBands,     /*!< Number of bands for inverse filtering */

    INVF_MODE *sbr_invf_mode, /*!< Current inverse filtering modes */

    INVF_MODE *sbr_invf_mode_prev /*!< Previous inverse filtering modes */

) {

  INT bwIndex[MAX_NUM_PATCHES];

  FIXP_DBL bwVector[MAX_NUM_PATCHES]; /*!< pole moving factors */

  FIXP_DBL preWhiteningGains[(64) / 2];

  int preWhiteningGains_exp[(64) / 2];

  int i;

  int loBand, start, stop;

  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;

  PATCH_PARAM *patchParam = pSettings->patchParam;

  int patch;

  FIXP_SGL alphar[LPC_ORDER], a0r, a1r;

  FIXP_SGL alphai[LPC_ORDER], a0i = 0, a1i = 0;

  FIXP_SGL bw = FL2FXCONST_SGL(0.0f);

  int autoCorrLength;

  FIXP_DBL k1, k1_below = 0, k1_below2 = 0;

  ACORR_COEFS ac;

  int startSample;

  int stopSample;

  int stopSampleClear;

  int comLowBandScale;

  int ovLowBandShift;

  int lowBandShift;

  /*  int ovHighBandShift;*/

  alphai[0] = FL2FXCONST_SGL(0.0f);

  alphai[1] = FL2FXCONST_SGL(0.0f);

  startSample = firstSlotOffs * timeStep;

  stopSample = pSettings->nCols + lastSlotOffs * timeStep;

  FDK_ASSERT((lastSlotOffs * timeStep) <= pSettings->overlap);

  inverseFilteringLevelEmphasis(hLppTrans, nInvfBands, sbr_invf_mode,

                                sbr_invf_mode_prev, bwVector);

  stopSampleClear = stopSample;

  autoCorrLength = pSettings->nCols + pSettings->overlap;

  if (pSettings->noOfPatches > 0) {

    /* Set upper subbands to zero:

       This is required in case that the patches do not cover the complete

       highband (because the last patch would be too short). Possible

       optimization: Clearing bands up to usb would be sufficient here. */

    int targetStopBand =

        patchParam[pSettings->noOfPatches - 1].targetStartBand +

        patchParam[pSettings->noOfPatches - 1].numBandsInPatch;

    int memSize = ((64) - targetStopBand) * sizeof(FIXP_DBL);

    if (!useLP) {

      for (i = startSample; i < stopSampleClear; i++) {

        FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);

        FDKmemclear(&qmfBufferImag[i][targetStopBand], memSize);

      }

    } else {

      for (i = startSample; i < stopSampleClear; i++) {

        FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);

      }

    }

  }

#if defined __ANDROID__ && !defined __ANDROID_NDK__

  else {

    // Safetynet logging

    android_errorWriteLog(0x534e4554, "112160868");

  }

#endif

  /* init bwIndex for each patch */

  FDKmemclear(bwIndex, sizeof(bwIndex));

  /*

    Calc common low band scale factor

  */

  comLowBandScale =

      fixMin(sbrScaleFactor->ov_lb_scale, sbrScaleFactor->lb_scale);

  ovLowBandShift = sbrScaleFactor->ov_lb_scale - comLowBandScale;

  lowBandShift = sbrScaleFactor->lb_scale - comLowBandScale;

  /*  ovHighBandShift = firstSlotOffs == 0 ? ovLowBandShift:0;*/

  if (fPreWhitening) {

    sbrDecoder_calculateGainVec(

        qmfBufferReal, qmfBufferImag,

        DFRACT_BITS - 1 - 16 -

            sbrScaleFactor->ov_lb_scale, /* convert scale to exponent */

        DFRACT_BITS - 1 - 16 -

            sbrScaleFactor->lb_scale, /* convert scale to exponent */

        pSettings->overlap, preWhiteningGains, preWhiteningGains_exp,

        v_k_master0, startSample, stopSample);

  }

  /* outer loop over bands to do analysis only once for each band */

  if (!useLP) {

    start = pSettings->lbStartPatching;

    stop = pSettings->lbStopPatching;

  } else {

    start = fixMax(1, pSettings->lbStartPatching - 2);

    stop = patchParam[0].targetStartBand;

  }

  for (loBand = start; loBand < stop; loBand++) {

    FIXP_DBL lowBandReal[(((1024) / (32) * (4) / 2) + (3 * (4))) + LPC_ORDER];

    FIXP_DBL *plowBandReal = lowBandReal;

    FIXP_DBL **pqmfBufferReal =

        qmfBufferReal + firstSlotOffs * timeStep /* + pSettings->overlap */;

    FIXP_DBL lowBandImag[(((1024) / (32) * (4) / 2) + (3 * (4))) + LPC_ORDER];

    FIXP_DBL *plowBandImag = lowBandImag;

    FIXP_DBL **pqmfBufferImag =

        qmfBufferImag + firstSlotOffs * timeStep /* + pSettings->overlap */;

    int resetLPCCoeffs = 0;

    int dynamicScale = DFRACT_BITS - 1 - LPC_SCALE_FACTOR;

    int acDetScale = 0; /* scaling of autocorrelation determinant */

    for (i = 0;

         i < LPC_ORDER + firstSlotOffs * timeStep /*+pSettings->overlap*/;

         i++) {

      *plowBandReal++ = hLppTrans->lpcFilterStatesRealLegSBR[i][loBand];

      if (!useLP)

        *plowBandImag++ = hLppTrans->lpcFilterStatesImagLegSBR[i][loBand];

    }

    /*

      Take old slope length qmf slot source values out of (overlap)qmf buffer

    */

    if (!useLP) {

      for (i = 0;

           i < pSettings->nCols + pSettings->overlap - firstSlotOffs * timeStep;

           i++) {

        *plowBandReal++ = (*pqmfBufferReal++)[loBand];

        *plowBandImag++ = (*pqmfBufferImag++)[loBand];

      }

    } else {

      /* pSettings->overlap is always even */

      FDK_ASSERT((pSettings->overlap & 1) == 0);

      for (i = 0; i < ((pSettings->nCols + pSettings->overlap -

                        firstSlotOffs * timeStep) >>

                       1);

           i++) {

        *plowBandReal++ = (*pqmfBufferReal++)[loBand];

        *plowBandReal++ = (*pqmfBufferReal++)[loBand];

      }

      if (pSettings->nCols & 1) {

        *plowBandReal++ = (*pqmfBufferReal++)[loBand];

      }

    }

    /*

      Determine dynamic scaling value.

     */

    dynamicScale =

        fixMin(dynamicScale,

               getScalefactor(lowBandReal, LPC_ORDER + pSettings->overlap) +

                   ovLowBandShift);

    dynamicScale =

        fixMin(dynamicScale,

               getScalefactor(&lowBandReal[LPC_ORDER + pSettings->overlap],

                              pSettings->nCols) +

                   lowBandShift);

    if (!useLP) {

      dynamicScale =

          fixMin(dynamicScale,

                 getScalefactor(lowBandImag, LPC_ORDER + pSettings->overlap) +

                     ovLowBandShift);

      dynamicScale =

          fixMin(dynamicScale,

                 getScalefactor(&lowBandImag[LPC_ORDER + pSettings->overlap],

                                pSettings->nCols) +

                     lowBandShift);

    }

    if (dynamicScale == 0) {

      /* In this special case the available headroom bits as well as

         ovLowBandShift and lowBandShift are zero. The spectrum is limited to

         prevent -1.0, so negative values for dynamicScale can be avoided. */

      for (i = 0; i < (LPC_ORDER + pSettings->overlap + pSettings->nCols);

           i++) {

        lowBandReal[i] = fixMax(lowBandReal[i], (FIXP_DBL)0x80000001);

      }

      if (!useLP) {

        for (i = 0; i < (LPC_ORDER + pSettings->overlap + pSettings->nCols);

             i++) {

          lowBandImag[i] = fixMax(lowBandImag[i], (FIXP_DBL)0x80000001);

        }

      }

    } else {

      dynamicScale =

          fixMax(0, dynamicScale -

                        1); /* one additional bit headroom to prevent -1.0 */

    }

    /*

      Scale temporal QMF buffer.

     */

    scaleValues(&lowBandReal[0], LPC_ORDER + pSettings->overlap,

                dynamicScale - ovLowBandShift);

    scaleValues(&lowBandReal[LPC_ORDER + pSettings->overlap], pSettings->nCols,

                dynamicScale - lowBandShift);

    if (!useLP) {

      scaleValues(&lowBandImag[0], LPC_ORDER + pSettings->overlap,

                  dynamicScale - ovLowBandShift);

      scaleValues(&lowBandImag[LPC_ORDER + pSettings->overlap],

                  pSettings->nCols, dynamicScale - lowBandShift);

    }

    if (!useLP) {

      acDetScale += autoCorr2nd_cplx(&ac, lowBandReal + LPC_ORDER,

                                     lowBandImag + LPC_ORDER, autoCorrLength);

    } else {

      acDetScale +=

          autoCorr2nd_real(&ac, lowBandReal + LPC_ORDER, autoCorrLength);

    }

    /* Examine dynamic of determinant in autocorrelation. */

    acDetScale += 2 * (comLowBandScale + dynamicScale);

    acDetScale *= 2;            /* two times reflection coefficent scaling */

    acDetScale += ac.det_scale; /* ac scaling of determinant */

    /* In case of determinant < 10^-38, resetLPCCoeffs=1 has to be enforced. */

    if (acDetScale > 126) {

      resetLPCCoeffs = 1;

    }

    alphar[1] = FL2FXCONST_SGL(0.0f);

    if (!useLP) alphai[1] = FL2FXCONST_SGL(0.0f);

    if (ac.det != FL2FXCONST_DBL(0.0f)) {

      FIXP_DBL tmp, absTmp, absDet;

      absDet = fixp_abs(ac.det);

      if (!useLP) {

        tmp = (fMultDiv2(ac.r01r, ac.r12r) >> (LPC_SCALE_FACTOR - 1)) -

              ((fMultDiv2(ac.r01i, ac.r12i) + fMultDiv2(ac.r02r, ac.r11r)) >>

               (LPC_SCALE_FACTOR - 1));

      } else {

        tmp = (fMultDiv2(ac.r01r, ac.r12r) >> (LPC_SCALE_FACTOR - 1)) -

              (fMultDiv2(ac.r02r, ac.r11r) >> (LPC_SCALE_FACTOR - 1));

      }

      absTmp = fixp_abs(tmp);

      /*

        Quick check: is first filter coeff >= 1(4)

       */

      {

        INT scale;

        FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);

        scale = scale + ac.det_scale;

        if ((scale > 0) && (result >= (FIXP_DBL)MAXVAL_DBL >> scale)) {

          resetLPCCoeffs = 1;

        } else {

          alphar[1] = FX_DBL2FX_SGL(scaleValueSaturate(result, scale));

          if ((tmp < FL2FX_DBL(0.0f)) ^ (ac.det < FL2FX_DBL(0.0f))) {

            alphar[1] = -alphar[1];

          }

        }

      }

      if (!useLP) {

        tmp = (fMultDiv2(ac.r01i, ac.r12r) >> (LPC_SCALE_FACTOR - 1)) +

              ((fMultDiv2(ac.r01r, ac.r12i) -

                (FIXP_DBL)fMultDiv2(ac.r02i, ac.r11r)) >>

               (LPC_SCALE_FACTOR - 1));

        absTmp = fixp_abs(tmp);

        /*

        Quick check: is second filter coeff >= 1(4)

        */

        {

          INT scale;

          FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);

          scale = scale + ac.det_scale;

          if ((scale > 0) &&

              (result >= /*FL2FXCONST_DBL(1.f)*/ (FIXP_DBL)MAXVAL_DBL >>

               scale)) {

            resetLPCCoeffs = 1;

          } else {

            alphai[1] = FX_DBL2FX_SGL(scaleValueSaturate(result, scale));

            if ((tmp < FL2FX_DBL(0.0f)) ^ (ac.det < FL2FX_DBL(0.0f))) {

              alphai[1] = -alphai[1];

            }

          }

        }

      }

    }

    alphar[0] = FL2FXCONST_SGL(0.0f);

    if (!useLP) alphai[0] = FL2FXCONST_SGL(0.0f);

    if (ac.r11r != FL2FXCONST_DBL(0.0f)) {

      /* ac.r11r is always >=0 */

      FIXP_DBL tmp, absTmp;

      if (!useLP) {

        tmp = (ac.r01r >> (LPC_SCALE_FACTOR + 1)) +

              (fMultDiv2(alphar[1], ac.r12r) + fMultDiv2(alphai[1], ac.r12i));

      } else {

        if (ac.r01r >= FL2FXCONST_DBL(0.0f))

          tmp = (ac.r01r >> (LPC_SCALE_FACTOR + 1)) +

                fMultDiv2(alphar[1], ac.r12r);

        else

          tmp = -((-ac.r01r) >> (LPC_SCALE_FACTOR + 1)) +

                fMultDiv2(alphar[1], ac.r12r);

      }

      absTmp = fixp_abs(tmp);

      /*

        Quick check: is first filter coeff >= 1(4)

      */

      if (absTmp >= (ac.r11r >> 1)) {

        resetLPCCoeffs = 1;

      } else {

        INT scale;

        FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);

        alphar[0] = FX_DBL2FX_SGL(scaleValueSaturate(result, scale + 1));

        if ((tmp > FL2FX_DBL(0.0f)) ^ (ac.r11r < FL2FX_DBL(0.0f)))

          alphar[0] = -alphar[0];

      }

      if (!useLP) {

        tmp = (ac.r01i >> (LPC_SCALE_FACTOR + 1)) +

              (fMultDiv2(alphai[1], ac.r12r) - fMultDiv2(alphar[1], ac.r12i));

        absTmp = fixp_abs(tmp);

        /*

        Quick check: is second filter coeff >= 1(4)

        */

        if (absTmp >= (ac.r11r >> 1)) {

          resetLPCCoeffs = 1;

        } else {

          INT scale;

          FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);

          alphai[0] = FX_DBL2FX_SGL(scaleValueSaturate(result, scale + 1));

          if ((tmp > FL2FX_DBL(0.0f)) ^ (ac.r11r < FL2FX_DBL(0.0f)))

            alphai[0] = -alphai[0];

        }

      }

    }

    if (!useLP) {

      /* Now check the quadratic criteria */

      if ((fMultDiv2(alphar[0], alphar[0]) + fMultDiv2(alphai[0], alphai[0])) >=

          FL2FXCONST_DBL(0.5f))

        resetLPCCoeffs = 1;

      if ((fMultDiv2(alphar[1], alphar[1]) + fMultDiv2(alphai[1], alphai[1])) >=

          FL2FXCONST_DBL(0.5f))

        resetLPCCoeffs = 1;

    }

    if (resetLPCCoeffs) {

      alphar[0] = FL2FXCONST_SGL(0.0f);

      alphar[1] = FL2FXCONST_SGL(0.0f);

      if (!useLP) {

        alphai[0] = FL2FXCONST_SGL(0.0f);

        alphai[1] = FL2FXCONST_SGL(0.0f);

      }

    }

    if (useLP) {

      /* Aliasing detection */

      if (ac.r11r == FL2FXCONST_DBL(0.0f)) {

        k1 = FL2FXCONST_DBL(0.0f);

      } else {

        if (fixp_abs(ac.r01r) >= fixp_abs(ac.r11r)) {

          if (fMultDiv2(ac.r01r, ac.r11r) < FL2FX_DBL(0.0f)) {

            k1 = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_SGL(1.0f)*/;

          } else {

            /* Since this value is squared later, it must not ever become -1.0f.

             */

            k1 = (FIXP_DBL)(MINVAL_DBL + 1) /*FL2FXCONST_SGL(-1.0f)*/;

          }

        } else {

          INT scale;

          FIXP_DBL result =

              fDivNorm(fixp_abs(ac.r01r), fixp_abs(ac.r11r), &scale);

          k1 = scaleValueSaturate(result, scale);

          if (!((ac.r01r < FL2FX_DBL(0.0f)) ^ (ac.r11r < FL2FX_DBL(0.0f)))) {

            k1 = -k1;

          }

        }

      }

      if ((loBand > 1) && (loBand < v_k_master0)) {

        /* Check if the gain should be locked */

        FIXP_DBL deg =

            /*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - fPow2(k1_below);

        degreeAlias[loBand] = FL2FXCONST_DBL(0.0f);

        if (((loBand & 1) == 0) && (k1 < FL2FXCONST_DBL(0.0f))) {

          if (k1_below < FL2FXCONST_DBL(0.0f)) { /* 2-Ch Aliasing Detection */

            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;

            if (k1_below2 >

                FL2FXCONST_DBL(0.0f)) { /* 3-Ch Aliasing Detection */

              degreeAlias[loBand - 1] = deg;

            }

          } else if (k1_below2 >

                     FL2FXCONST_DBL(0.0f)) { /* 3-Ch Aliasing Detection */

            degreeAlias[loBand] = deg;

          }

        }

        if (((loBand & 1) == 1) && (k1 > FL2FXCONST_DBL(0.0f))) {

          if (k1_below > FL2FXCONST_DBL(0.0f)) { /* 2-CH Aliasing Detection */

            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;

            if (k1_below2 <

                FL2FXCONST_DBL(0.0f)) { /* 3-CH Aliasing Detection */

              degreeAlias[loBand - 1] = deg;

            }

          } else if (k1_below2 <

                     FL2FXCONST_DBL(0.0f)) { /* 3-CH Aliasing Detection */

            degreeAlias[loBand] = deg;

          }

        }

      }

      /* remember k1 values of the 2 QMF channels below the current channel */

      k1_below2 = k1_below;

      k1_below = k1;

    }

    patch = 0;

    while (patch < pSettings->noOfPatches) { /* inner loop over every patch */

      int hiBand = loBand + patchParam[patch].targetBandOffs;

      if (loBand < patchParam[patch].sourceStartBand ||

          loBand >= patchParam[patch].sourceStopBand

          //|| hiBand >= hLppTrans->pSettings->noChannels

      ) {

        /* Lowband not in current patch - proceed */

        patch++;

        continue;

      }

      FDK_ASSERT(hiBand < (64));

      /* bwIndex[patch] is already initialized with value from previous band

       * inside this patch */

      while (hiBand >= pSettings->bwBorders[bwIndex[patch]] &&

             bwIndex[patch] < MAX_NUM_PATCHES - 1) {

        bwIndex[patch]++;

      }

      /*

        Filter Step 2: add the left slope with the current filter to the buffer

                       pure source values are already in there

      */

      bw = FX_DBL2FX_SGL(bwVector[bwIndex[patch]]);

      a0r = FX_DBL2FX_SGL(

          fMult(bw, alphar[0])); /* Apply current bandwidth expansion factor */

      if (!useLP) a0i = FX_DBL2FX_SGL(fMult(bw, alphai[0]));

      bw = FX_DBL2FX_SGL(fPow2(bw));

      a1r = FX_DBL2FX_SGL(fMult(bw, alphar[1]));

      if (!useLP) a1i = FX_DBL2FX_SGL(fMult(bw, alphai[1]));

      /*

        Filter Step 3: insert the middle part which won't be windowed

      */

      if (bw <= FL2FXCONST_SGL(0.0f)) {

        if (!useLP) {

          int descale =

              fixMin(DFRACT_BITS - 1, (LPC_SCALE_FACTOR + dynamicScale));

          for (i = startSample; i < stopSample; i++) {

            FIXP_DBL accu1, accu2;

            accu1 = lowBandReal[LPC_ORDER + i] >> descale;

            accu2 = lowBandImag[LPC_ORDER + i] >> descale;

            if (fPreWhitening) {

              accu1 = scaleValueSaturate(

                  fMultDiv2(accu1, preWhiteningGains[loBand]),

                  preWhiteningGains_exp[loBand] + 1);

              accu2 = scaleValueSaturate(

                  fMultDiv2(accu2, preWhiteningGains[loBand]),

                  preWhiteningGains_exp[loBand] + 1);

            }

            qmfBufferReal[i][hiBand] = accu1;

            qmfBufferImag[i][hiBand] = accu2;

          }

        } else {

          int descale =

              fixMin(DFRACT_BITS - 1, (LPC_SCALE_FACTOR + dynamicScale));

          for (i = startSample; i < stopSample; i++) {

            qmfBufferReal[i][hiBand] = lowBandReal[LPC_ORDER + i] >> descale;

          }

        }

      } else { /* bw <= 0 */

        if (!useLP) {

          const int dynscale = fixMax(0, dynamicScale - 2) + 1;

          const int rescale = -fixMin(0, dynamicScale - 2) + 1;

          const int descale = fixMin(DFRACT_BITS - 1,

                                     LPC_SCALE_FACTOR + dynamicScale + rescale);

          for (i = startSample; i < stopSample; i++) {

            FIXP_DBL accu1, accu2;

            accu1 = ((fMultDiv2(a0r, lowBandReal[LPC_ORDER + i - 1]) -

                      fMultDiv2(a0i, lowBandImag[LPC_ORDER + i - 1])) >>

                     1) +

                    ((fMultDiv2(a1r, lowBandReal[LPC_ORDER + i - 2]) -

                      fMultDiv2(a1i, lowBandImag[LPC_ORDER + i - 2])) >>

                     1);

            accu2 = ((fMultDiv2(a0i, lowBandReal[LPC_ORDER + i - 1]) +

                      fMultDiv2(a0r, lowBandImag[LPC_ORDER + i - 1])) >>

                     1) +

                    ((fMultDiv2(a1i, lowBandReal[LPC_ORDER + i - 2]) +

                      fMultDiv2(a1r, lowBandImag[LPC_ORDER + i - 2])) >>

                     1);

            accu1 =

                (lowBandReal[LPC_ORDER + i] >> descale) + (accu1 >> dynscale);

            accu2 =

                (lowBandImag[LPC_ORDER + i] >> descale) + (accu2 >> dynscale);

            if (fPreWhitening) {

              qmfBufferReal[i][hiBand] = scaleValueSaturate(

                  fMultDiv2(accu1, preWhiteningGains[loBand]),

                  preWhiteningGains_exp[loBand] + 1 + rescale);

              qmfBufferImag[i][hiBand] = scaleValueSaturate(

                  fMultDiv2(accu2, preWhiteningGains[loBand]),

                  preWhiteningGains_exp[loBand] + 1 + rescale);

            } else {

              qmfBufferReal[i][hiBand] =

                  SATURATE_LEFT_SHIFT(accu1, rescale, DFRACT_BITS);

              qmfBufferImag[i][hiBand] =

                  SATURATE_LEFT_SHIFT(accu2, rescale, DFRACT_BITS);

            }

          }

        } else {

          FDK_ASSERT(dynamicScale >= 0);

          calc_qmfBufferReal(

              qmfBufferReal, &(lowBandReal[LPC_ORDER + startSample - 2]),

              startSample, stopSample, hiBand, dynamicScale, a0r, a1r);

        }

      } /* bw <= 0 */

      patch++;

    } /* inner loop over patches */

    /*

     * store the unmodified filter coefficients if there is

     * an overlapping envelope

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

  } /* outer loop over bands (loBand) */

  if (useLP) {

    for (loBand = pSettings->lbStartPatching;

         loBand < pSettings->lbStopPatching; loBand++) {

      patch = 0;

      while (patch < pSettings->noOfPatches) {

        UCHAR hiBand = loBand + patchParam[patch].targetBandOffs;

        if (loBand < patchParam[patch].sourceStartBand ||

            loBand >= patchParam[patch].sourceStopBand ||

            hiBand >= (64) /* Highband out of range (biterror) */

        ) {

          /* Lowband not in current patch or highband out of range (might be

           * caused by biterrors)- proceed */

          patch++;

          continue;

        }

        if (hiBand != patchParam[patch].targetStartBand)

          degreeAlias[hiBand] = degreeAlias[loBand];

        patch++;

      }

    } /* end  for loop */

  }

  for (i = 0; i < nInvfBands; i++) {

    hLppTrans->bwVectorOld[i] = bwVector[i];

  }

  /*

    set high band scale factor

  */

  sbrScaleFactor->hb_scale = comLowBandScale - (LPC_SCALE_FACTOR);

}

void lppTransposerHBE(

    HANDLE_SBR_LPP_TRANS hLppTrans, /*!< Handle of lpp transposer  */

    HANDLE_HBE_TRANSPOSER hQmfTransposer,

    QMF_SCALE_FACTOR *sbrScaleFactor, /*!< Scaling factors */

    FIXP_DBL **qmfBufferReal, /*!< Pointer to pointer to real part of subband

                                 samples (source) */

    FIXP_DBL **qmfBufferImag, /*!< Pointer to pointer to imaginary part of

                                 subband samples (source) */

    const int timeStep,       /*!< Time step of envelope */

    const int firstSlotOffs,  /*!< Start position in time */

    const int lastSlotOffs,   /*!< Number of overlap-slots into next frame */

    const int nInvfBands,     /*!< Number of bands for inverse filtering */

    INVF_MODE *sbr_invf_mode, /*!< Current inverse filtering modes */

    INVF_MODE *sbr_invf_mode_prev /*!< Previous inverse filtering modes */

) {

  INT bwIndex;

  FIXP_DBL bwVector[MAX_NUM_PATCHES_HBE]; /*!< pole moving factors */

  int i;

  int loBand, start, stop;

  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;

  PATCH_PARAM *patchParam = pSettings->patchParam;

  FIXP_SGL alphar[LPC_ORDER], a0r, a1r;

  FIXP_SGL alphai[LPC_ORDER], a0i = 0, a1i = 0;

  FIXP_SGL bw = FL2FXCONST_SGL(0.0f);

  int autoCorrLength;