xref: /external/aac/libSBRdec/src/lpp_tran.cpp

/* -----------------------------------------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android

� Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
  All rights reserved.

 1.    INTRODUCTION
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
This FDK AAC Codec software is intended to be used on a wide variety of Android devices.

AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
of the MPEG specifications.

Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
individually for the purpose of encoding or decoding bit streams in products that are compliant with
the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
software may already be covered under those patent licenses when it is used for those licensed purposes only.

Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
applications information and documentation.

2.    COPYRIGHT LICENSE

Redistribution and use in source and binary forms, with or without modification, are permitted without
payment of copyright license fees provided that you satisfy the following conditions:

You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
your modifications thereto in source code form.

You must retain the complete text of this software license in the documentation and/or other materials
provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
modifications thereto to recipients of copies in binary form.

The name of Fraunhofer may not be used to endorse or promote products derived from this library without
prior written permission.

You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
software or your modifications thereto.

Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
and the date of any change. For modified versions of the FDK AAC Codec, the term
"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."

3.    NO PATENT LICENSE

NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
respect to this software.

You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
by appropriate patent licenses.

4.    DISCLAIMER

This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
or business interruption, however caused and on any theory of liability, whether in contract, strict
liability, or tort (including negligence), arising in any way out of the use of this software, even if
advised of the possibility of such damage.

5.    CONTACT INFORMATION

Fraunhofer Institute for Integrated Circuits IIS
Attention: Audio and Multimedia Departments - FDK AAC LL
Am Wolfsmantel 33
91058 Erlangen, Germany

www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
----------------------------------------------------------------------------------------------------------- */

/*!
  \file
  \brief  Low Power Profile Transposer,
  This module provides the transposer. The main entry point is lppTransposer(). The function generates
  high frequency content by copying data from the low band (provided by core codec) into the high band.
  This process is also referred to as "patching". The function also implements spectral whitening by means of
  inverse filtering based on LPC coefficients.

  Together with the QMF filterbank the transposer can be tested using a supplied test program. See main_audio.cpp for details.
  This module does use fractional arithmetic and the accuracy of the computations has an impact on the overall sound quality.
  The module also needs to take into account the different scaling of spectral data.

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

#include "lpp_tran.h"

#include "sbr_ram.h"
#include "sbr_rom.h"

#include "genericStds.h"
#include "autocorr2nd.h"



#if defined(__arm__)
#include "arm/lpp_tran_arm.cpp"
#endif



#define LPC_SCALE_FACTOR  2


/*!
 *
 * \brief Get bandwidth expansion factor from filtering level
 *
 * Returns a filter parameter (bandwidth expansion factor) depending on
 * the desired filtering level signalled in the bitstream.
 * When switching the filtering level from LOW to OFF, an additional
 * level is being inserted to achieve a smooth transition.
 */

#ifndef FUNCTION_mapInvfMode
static FIXP_DBL
mapInvfMode (INVF_MODE mode,
             INVF_MODE prevMode,
             WHITENING_FACTORS whFactors)
{
  switch (mode) {
  case INVF_LOW_LEVEL:
    if(prevMode == INVF_OFF)
      return whFactors.transitionLevel;
    else
      return whFactors.lowLevel;

  case INVF_MID_LEVEL:
    return whFactors.midLevel;

  case INVF_HIGH_LEVEL:
    return whFactors.highLevel;

  default:
    if(prevMode == INVF_LOW_LEVEL)
      return whFactors.transitionLevel;
    else
      return whFactors.off;
  }
}
#endif /* #ifndef FUNCTION_mapInvfMode */

/*!
 *
 * \brief Perform inverse filtering level emphasis
 *
 * Retrieve bandwidth expansion factor and apply smoothing for each filter band
 *
 */

#ifndef FUNCTION_inverseFilteringLevelEmphasis
static void
inverseFilteringLevelEmphasis(HANDLE_SBR_LPP_TRANS hLppTrans,/*!< Handle of lpp transposer  */
                              UCHAR nInvfBands,              /*!< Number of bands for inverse filtering */
                              INVF_MODE *sbr_invf_mode,      /*!< Current inverse filtering modes */
                              INVF_MODE *sbr_invf_mode_prev, /*!< Previous inverse filtering modes */
                              FIXP_DBL * bwVector            /*!< Resulting filtering levels */
                              )
{
  for(int i = 0; i < nInvfBands; i++) {
    FIXP_DBL accu;
    FIXP_DBL bwTmp = mapInvfMode (sbr_invf_mode[i],
                                  sbr_invf_mode_prev[i],
                                  hLppTrans->pSettings->whFactors);

    if(bwTmp < hLppTrans->bwVectorOld[i]) {
      accu = fMultDiv2(FL2FXCONST_DBL(0.75f),bwTmp) +
             fMultDiv2(FL2FXCONST_DBL(0.25f),hLppTrans->bwVectorOld[i]);
    }
    else {
      accu = fMultDiv2(FL2FXCONST_DBL(0.90625f),bwTmp) +
             fMultDiv2(FL2FXCONST_DBL(0.09375f),hLppTrans->bwVectorOld[i]);
    }

    if (accu <  FL2FXCONST_DBL(0.015625f)>>1)
      bwVector[i] = FL2FXCONST_DBL(0.0f);
    else
      bwVector[i] = fixMin(accu<<1,FL2FXCONST_DBL(0.99609375f));
  }
}
#endif /* #ifndef FUNCTION_inverseFilteringLevelEmphasis */

/* Resulting autocorrelation determinant exponent */
#define ACDET_EXP (2*(DFRACT_BITS+sbrScaleFactor->lb_scale+10-ac.det_scale))
#define AC_EXP (-sbrScaleFactor->lb_scale+LPC_SCALE_FACTOR)
#define ALPHA_EXP (-sbrScaleFactor->lb_scale+LPC_SCALE_FACTOR+1)
/* Resulting transposed QMF values exponent 16 bit normalized samplebits assumed. */
#define QMFOUT_EXP ((SAMPLE_BITS-15)-sbrScaleFactor->lb_scale)

/*!
 *
 * \brief Perform transposition by patching of subband samples.
 * This function serves as the main entry point into the module. The function determines the areas for the
 * patching process (these are the source range as well as the target range) and implements spectral whitening
 * by means of inverse filtering. The function autoCorrelation2nd() is an auxiliary function for calculating the
 * LPC coefficients for the filtering.  The actual calculation of the LPC coefficients and the implementation
 * of the filtering are done as part of lppTransposer().
 *
 * Note that the filtering is done on all available QMF subsamples, whereas the patching is only done on those QMF
 * subsamples that will be used in the next QMF synthesis. The filtering is also implemented before the patching
 * includes further dependencies on parameters from the SBR data.
 *
 */

void lppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,    /*!< Handle of lpp transposer  */
                    QMF_SCALE_FACTOR  *sbrScaleFactor, /*!< Scaling factors */
                    FIXP_DBL **qmfBufferReal,          /*!< Pointer to pointer to real part of subband samples (source) */

                    FIXP_DBL *degreeAlias,             /*!< Vector for results of aliasing estimation */
                    FIXP_DBL **qmfBufferImag,          /*!< Pointer to pointer to imaginary part of subband samples (source) */
                    const int useLP,
                    const int timeStep,                /*!< Time step of envelope */
                    const int firstSlotOffs,           /*!< Start position in time */
                    const int lastSlotOffs,            /*!< Number of overlap-slots into next frame */
                    const int nInvfBands,              /*!< Number of bands for inverse filtering */
                    INVF_MODE *sbr_invf_mode,          /*!< Current inverse filtering modes */
                    INVF_MODE *sbr_invf_mode_prev      /*!< Previous inverse filtering modes */
                    )
{
  INT    bwIndex[MAX_NUM_PATCHES];
  FIXP_DBL  bwVector[MAX_NUM_PATCHES];       /*!< pole moving factors */

  int    i;
  int    loBand, start, stop;
  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;
  PATCH_PARAM *patchParam = pSettings->patchParam;
  int    patch;

  FIXP_SGL  alphar[LPC_ORDER], a0r, a1r;
  FIXP_SGL  alphai[LPC_ORDER], a0i=0, a1i=0;
  FIXP_SGL  bw = FL2FXCONST_SGL(0.0f);

  int    autoCorrLength;

  FIXP_DBL k1, k1_below=0, k1_below2=0;

  ACORR_COEFS ac;
  int    startSample;
  int    stopSample;
  int    stopSampleClear;

  int comLowBandScale;
  int ovLowBandShift;
  int lowBandShift;
/*  int ovHighBandShift;*/
  int targetStopBand;


  alphai[0] = FL2FXCONST_SGL(0.0f);
  alphai[1] = FL2FXCONST_SGL(0.0f);


  startSample = firstSlotOffs * timeStep;
  stopSample  = pSettings->nCols + lastSlotOffs * timeStep;


  inverseFilteringLevelEmphasis(hLppTrans, nInvfBands, sbr_invf_mode, sbr_invf_mode_prev, bwVector);

  stopSampleClear = stopSample;

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

  /* Set upper subbands to zero:
     This is required in case that the patches do not cover the complete highband
     (because the last patch would be too short).
     Possible optimization: Clearing bands up to usb would be sufficient here. */
  targetStopBand = patchParam[pSettings->noOfPatches-1].targetStartBand
                 + patchParam[pSettings->noOfPatches-1].numBandsInPatch;

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

  if (!useLP) {
    for (i = startSample; i < stopSampleClear; i++) {
      FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);
      FDKmemclear(&qmfBufferImag[i][targetStopBand], memSize);
    }
  } else
  for (i = startSample; i < stopSampleClear; i++) {
    FDKmemclear(&qmfBufferReal[i][targetStopBand], memSize);
  }

  /* init bwIndex for each patch */
  FDKmemclear(bwIndex, pSettings->noOfPatches*sizeof(INT));

  /*
    Calc common low band scale factor
  */
  comLowBandScale = fixMin(sbrScaleFactor->ov_lb_scale,sbrScaleFactor->lb_scale);

  ovLowBandShift =  sbrScaleFactor->ov_lb_scale - comLowBandScale;
  lowBandShift   =  sbrScaleFactor->lb_scale - comLowBandScale;
  /*  ovHighBandShift = firstSlotOffs == 0 ? ovLowBandShift:0;*/

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

  if (!useLP) {
    start = pSettings->lbStartPatching;
    stop = pSettings->lbStopPatching;
  } else
  {
    start = fixMax(1, pSettings->lbStartPatching - 2);
    stop = patchParam[0].targetStartBand;
  }


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

    FIXP_DBL  lowBandReal[(((1024)/(32))+(6))+LPC_ORDER];
    FIXP_DBL *plowBandReal = lowBandReal;
    FIXP_DBL **pqmfBufferReal = qmfBufferReal;
    FIXP_DBL  lowBandImag[(((1024)/(32))+(6))+LPC_ORDER];
    FIXP_DBL *plowBandImag = lowBandImag;
    FIXP_DBL **pqmfBufferImag = qmfBufferImag;
    int resetLPCCoeffs=0;
    int dynamicScale = DFRACT_BITS-1-LPC_SCALE_FACTOR;
    int acDetScale = 0; /* scaling of autocorrelation determinant */

    for(i=0;i<LPC_ORDER;i++){
      *plowBandReal++ = hLppTrans->lpcFilterStatesReal[i][loBand];
      if (!useLP)
        *plowBandImag++ = hLppTrans->lpcFilterStatesImag[i][loBand];
    }

    /*
      Take old slope length qmf slot source values out of (overlap)qmf buffer
    */
    if (!useLP) {
      for(i=0;i<pSettings->nCols+pSettings->overlap;i++){
        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
        *plowBandImag++ = (*pqmfBufferImag++)[loBand];
      }
    } else
    {
      /* pSettings->overlap is always even */
      FDK_ASSERT((pSettings->overlap & 1) == 0);

      for(i=0;i<((pSettings->overlap+pSettings->nCols)>>1);i++) {
        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
      }
      if (pSettings->nCols & 1) {
        *plowBandReal++ = (*pqmfBufferReal++)[loBand];
      }
    }

    /*
      Determine dynamic scaling value.
     */
    dynamicScale = fixMin(dynamicScale, getScalefactor(lowBandReal, LPC_ORDER+pSettings->overlap) + ovLowBandShift);
    dynamicScale = fixMin(dynamicScale, getScalefactor(&lowBandReal[LPC_ORDER+pSettings->overlap], pSettings->nCols) + lowBandShift);
    if (!useLP) {
      dynamicScale = fixMin(dynamicScale, getScalefactor(lowBandImag, LPC_ORDER+pSettings->overlap) + ovLowBandShift);
      dynamicScale = fixMin(dynamicScale, getScalefactor(&lowBandImag[LPC_ORDER+pSettings->overlap], pSettings->nCols) + lowBandShift);
    }
    dynamicScale = fixMax(0, dynamicScale-1); /* one additional bit headroom to prevent -1.0 */

    /*
      Scale temporal QMF buffer.
     */
    scaleValues(&lowBandReal[0], LPC_ORDER+pSettings->overlap, dynamicScale-ovLowBandShift);
    scaleValues(&lowBandReal[LPC_ORDER+pSettings->overlap], pSettings->nCols, dynamicScale-lowBandShift);

    if (!useLP) {
      scaleValues(&lowBandImag[0], LPC_ORDER+pSettings->overlap, dynamicScale-ovLowBandShift);
      scaleValues(&lowBandImag[LPC_ORDER+pSettings->overlap], pSettings->nCols, dynamicScale-lowBandShift);
    }


      if (!useLP) {
        acDetScale += autoCorr2nd_cplx(&ac, lowBandReal+LPC_ORDER, lowBandImag+LPC_ORDER, autoCorrLength);
      }
      else
      {
        acDetScale += autoCorr2nd_real(&ac, lowBandReal+LPC_ORDER, autoCorrLength);
      }

      /* Examine dynamic of determinant in autocorrelation. */
      acDetScale += 2*(comLowBandScale + dynamicScale);
      acDetScale *= 2;              /* two times reflection coefficent scaling */
      acDetScale += ac.det_scale;   /* ac scaling of determinant */

      /* In case of determinant < 10^-38, resetLPCCoeffs=1 has to be enforced. */
      if (acDetScale>126 ) {
        resetLPCCoeffs = 1;
      }


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

    if (ac.det != FL2FXCONST_DBL(0.0f)) {
      FIXP_DBL tmp,absTmp,absDet;

      absDet = fixp_abs(ac.det);

      if (!useLP) {
        tmp = ( fMultDiv2(ac.r01r,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) -
              ( (fMultDiv2(ac.r01i,ac.r12i) + fMultDiv2(ac.r02r,ac.r11r)) >> (LPC_SCALE_FACTOR-1) );
      } else
      {
        tmp = ( fMultDiv2(ac.r01r,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) -
              ( fMultDiv2(ac.r02r,ac.r11r) >> (LPC_SCALE_FACTOR-1) );
      }
      absTmp = fixp_abs(tmp);

      /*
        Quick check: is first filter coeff >= 1(4)
       */
      {
        INT scale;
        FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);
        scale = scale+ac.det_scale;

        if ( (scale > 0) && (result >= (FIXP_DBL)MAXVAL_DBL>>scale) ) {
          resetLPCCoeffs = 1;
        }
        else {
          alphar[1] = FX_DBL2FX_SGL(scaleValue(result,scale));
          if((tmp<FL2FX_DBL(0.0f)) ^ (ac.det<FL2FX_DBL(0.0f))) {
            alphar[1] = -alphar[1];
          }
        }
      }

      if (!useLP)
      {
        tmp =  ( fMultDiv2(ac.r01i,ac.r12r) >> (LPC_SCALE_FACTOR-1) ) +
               ( (fMultDiv2(ac.r01r,ac.r12i) - (FIXP_DBL)fMultDiv2(ac.r02i,ac.r11r)) >> (LPC_SCALE_FACTOR-1) ) ;

        absTmp = fixp_abs(tmp);

        /*
        Quick check: is second filter coeff >= 1(4)
        */
        {
          INT scale;
          FIXP_DBL result = fDivNorm(absTmp, absDet, &scale);
          scale = scale+ac.det_scale;

          if ( (scale > 0) && (result >= /*FL2FXCONST_DBL(1.f)*/ (FIXP_DBL)MAXVAL_DBL>>scale) ) {
            resetLPCCoeffs = 1;
          }
          else {
            alphai[1] = FX_DBL2FX_SGL(scaleValue(result,scale));
            if((tmp<FL2FX_DBL(0.0f)) ^ (ac.det<FL2FX_DBL(0.0f))) {
              alphai[1] = -alphai[1];
            }
          }
        }
      }
    }

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

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

      /* ac.r11r is always >=0 */
      FIXP_DBL tmp,absTmp;

      if (!useLP) {
        tmp = (ac.r01r>>(LPC_SCALE_FACTOR+1)) +
              (fMultDiv2(alphar[1],ac.r12r) + fMultDiv2(alphai[1],ac.r12i));
      } else
      {
        if(ac.r01r>=FL2FXCONST_DBL(0.0f))
          tmp = (ac.r01r>>(LPC_SCALE_FACTOR+1)) + fMultDiv2(alphar[1],ac.r12r);
        else
          tmp = -((-ac.r01r)>>(LPC_SCALE_FACTOR+1)) + fMultDiv2(alphar[1],ac.r12r);
      }

      absTmp = fixp_abs(tmp);

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

      if (absTmp >= (ac.r11r>>1)) {
        resetLPCCoeffs=1;
      }
      else {
        INT scale;
        FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);
        alphar[0] =  FX_DBL2FX_SGL(scaleValue(result,scale+1));

        if((tmp>FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))
          alphar[0] = -alphar[0];
      }

      if (!useLP)
      {
        tmp = (ac.r01i>>(LPC_SCALE_FACTOR+1)) +
              (fMultDiv2(alphai[1],ac.r12r) - fMultDiv2(alphar[1],ac.r12i));

        absTmp = fixp_abs(tmp);

        /*
        Quick check: is second filter coeff >= 1(4)
        */
        if (absTmp >= (ac.r11r>>1)) {
          resetLPCCoeffs=1;
        }
        else {
          INT scale;
          FIXP_DBL result = fDivNorm(absTmp, fixp_abs(ac.r11r), &scale);
          alphai[0] = FX_DBL2FX_SGL(scaleValue(result,scale+1));
          if((tmp>FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))
            alphai[0] = -alphai[0];
        }
      }
    }


    if (!useLP)
    {
      /* Now check the quadratic criteria */
      if( (fMultDiv2(alphar[0],alphar[0]) + fMultDiv2(alphai[0],alphai[0])) >= FL2FXCONST_DBL(0.5f) )
        resetLPCCoeffs=1;
      if( (fMultDiv2(alphar[1],alphar[1]) + fMultDiv2(alphai[1],alphai[1])) >= FL2FXCONST_DBL(0.5f) )
        resetLPCCoeffs=1;
    }

    if(resetLPCCoeffs){
      alphar[0] = FL2FXCONST_SGL(0.0f);
      alphar[1] = FL2FXCONST_SGL(0.0f);
      if (!useLP)
      {
        alphai[0] = FL2FXCONST_SGL(0.0f);
        alphai[1] = FL2FXCONST_SGL(0.0f);
      }
    }

    if (useLP)
    {

      /* Aliasing detection */
      if(ac.r11r==FL2FXCONST_DBL(0.0f)) {
        k1 = FL2FXCONST_DBL(0.0f);
      }
      else {
        if ( fixp_abs(ac.r01r) >= fixp_abs(ac.r11r) ) {
          if ( fMultDiv2(ac.r01r,ac.r11r) < FL2FX_DBL(0.0f)) {
            k1 = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_SGL(1.0f)*/;
          }else {
            /* Since this value is squared later, it must not ever become -1.0f. */
            k1 = (FIXP_DBL)(MINVAL_DBL+1) /*FL2FXCONST_SGL(-1.0f)*/;
          }
        }
        else {
          INT scale;
          FIXP_DBL result = fDivNorm(fixp_abs(ac.r01r), fixp_abs(ac.r11r), &scale);
          k1 = scaleValue(result,scale);

          if(!((ac.r01r<FL2FX_DBL(0.0f)) ^ (ac.r11r<FL2FX_DBL(0.0f)))) {
            k1 = -k1;
          }
        }
      }
      if(loBand > 1){
        /* Check if the gain should be locked */
        FIXP_DBL deg = /*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - fPow2(k1_below);
        degreeAlias[loBand] = FL2FXCONST_DBL(0.0f);
        if (((loBand & 1) == 0) && (k1 < FL2FXCONST_DBL(0.0f))){
          if (k1_below < FL2FXCONST_DBL(0.0f)) {         /* 2-Ch Aliasing Detection */
            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;
            if ( k1_below2 > FL2FXCONST_DBL(0.0f) ) {    /* 3-Ch Aliasing Detection */
              degreeAlias[loBand-1] = deg;
            }
          }
          else if ( k1_below2 > FL2FXCONST_DBL(0.0f) ) { /* 3-Ch Aliasing Detection */
            degreeAlias[loBand]   = deg;
          }
        }
        if (((loBand & 1) == 1) && (k1 > FL2FXCONST_DBL(0.0f))){
          if (k1_below > FL2FXCONST_DBL(0.0f)) {         /* 2-CH Aliasing Detection */
            degreeAlias[loBand] = (FIXP_DBL)MAXVAL_DBL /*FL2FXCONST_DBL(1.0f)*/;
            if ( k1_below2 < FL2FXCONST_DBL(0.0f) ) {    /* 3-CH Aliasing Detection */
              degreeAlias[loBand-1] = deg;
            }
          }
          else if ( k1_below2 < FL2FXCONST_DBL(0.0f) ) { /* 3-CH Aliasing Detection */
            degreeAlias[loBand]   = deg;
          }
        }
      }
      /* remember k1 values of the 2 QMF channels below the current channel */
      k1_below2 = k1_below;
      k1_below = k1;
    }

    patch = 0;

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

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

      if ( loBand < patchParam[patch].sourceStartBand
           || loBand >= patchParam[patch].sourceStopBand
           //|| hiBand >= hLppTrans->pSettings->noChannels
           ) {
        /* Lowband not in current patch - proceed */
        patch++;
        continue;
      }

      FDK_ASSERT( hiBand < (64) );

      /* bwIndex[patch] is already initialized with value from previous band inside this patch */
      while (hiBand >= pSettings->bwBorders[bwIndex[patch]])
        bwIndex[patch]++;


      /*
        Filter Step 2: add the left slope with the current filter to the buffer
                       pure source values are already in there
      */
      bw = FX_DBL2FX_SGL(bwVector[bwIndex[patch]]);

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


      if (!useLP)
        a0i = FX_DBL2FX_SGL(fMult(bw,alphai[0]));
      bw =  FX_DBL2FX_SGL(fPow2(bw));
      a1r = FX_DBL2FX_SGL(fMult(bw,alphar[1]));
      if (!useLP)
        a1i = FX_DBL2FX_SGL(fMult(bw,alphai[1]));



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

      if ( bw <= FL2FXCONST_SGL(0.0f) ) {
        if (!useLP) {
          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
          for(i = startSample; i < stopSample; i++ ) {
            qmfBufferReal[i][hiBand] = lowBandReal[LPC_ORDER+i]>>descale;
            qmfBufferImag[i][hiBand] = lowBandImag[LPC_ORDER+i]>>descale;
          }
        } else
        {
          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
          for(i = startSample; i < stopSample; i++ ) {
            qmfBufferReal[i][hiBand] = lowBandReal[LPC_ORDER+i]>>descale;
          }
        }
      }
      else {  /* bw <= 0 */

        if (!useLP) {
          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));
#ifdef FUNCTION_LPPTRANSPOSER_func1
          lppTransposer_func1(lowBandReal+LPC_ORDER+startSample,lowBandImag+LPC_ORDER+startSample,
                              qmfBufferReal+startSample,qmfBufferImag+startSample,
                              stopSample-startSample, (int) hiBand,
                              dynamicScale,descale,
                              a0r, a0i, a1r, a1i);
#else
          for(i = startSample; i < stopSample; i++ ) {
            FIXP_DBL accu1, accu2;

            accu1 = (fMultDiv2(a0r,lowBandReal[LPC_ORDER+i-1]) - fMultDiv2(a0i,lowBandImag[LPC_ORDER+i-1]) +
                     fMultDiv2(a1r,lowBandReal[LPC_ORDER+i-2]) - fMultDiv2(a1i,lowBandImag[LPC_ORDER+i-2]))>>dynamicScale;
            accu2 = (fMultDiv2(a0i,lowBandReal[LPC_ORDER+i-1]) + fMultDiv2(a0r,lowBandImag[LPC_ORDER+i-1]) +
                     fMultDiv2(a1i,lowBandReal[LPC_ORDER+i-2]) + fMultDiv2(a1r,lowBandImag[LPC_ORDER+i-2]))>>dynamicScale;

            qmfBufferReal[i][hiBand] = (lowBandReal[LPC_ORDER+i]>>descale) + (accu1<<1);
            qmfBufferImag[i][hiBand] = (lowBandImag[LPC_ORDER+i]>>descale) + (accu2<<1);
          }
#endif
        } else
        {
          int descale = fixMin(DFRACT_BITS-1, (LPC_SCALE_FACTOR+dynamicScale));

          FDK_ASSERT(dynamicScale >= 0);
          for(i = startSample; i < stopSample; i++ ) {
            FIXP_DBL accu1;

            accu1 = (fMultDiv2(a0r,lowBandReal[LPC_ORDER+i-1]) + fMultDiv2(a1r,lowBandReal[LPC_ORDER+i-2]))>>dynamicScale;

            qmfBufferReal[i][hiBand] = (lowBandReal[LPC_ORDER+i]>>descale) + (accu1<<1);
          }
        }
      } /* bw <= 0 */

      patch++;

    }  /* inner loop over patches */

     /*
     * store the unmodified filter coefficients if there is
     * an overlapping envelope
     *****************************************************************/


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

  if (useLP)
  {
    for ( loBand = pSettings->lbStartPatching; loBand <  pSettings->lbStopPatching; loBand++ ) {
      patch = 0;
      while ( patch < pSettings->noOfPatches ) {

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

        if ( loBand < patchParam[patch].sourceStartBand
          || loBand >= patchParam[patch].sourceStopBand
          || hiBand >= (64)              /* Highband out of range (biterror) */
          ) {
          /* Lowband not in current patch or highband out of range (might be caused by biterrors)- proceed */
          patch++;
          continue;
        }

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

        patch++;
      }
    }/* end  for loop */
  }

 for (i = 0; i < nInvfBands; i++ ) {
   hLppTrans->bwVectorOld[i] = bwVector[i];
 }

  /*
    set high band scale factor
  */
  sbrScaleFactor->hb_scale = comLowBandScale-(LPC_SCALE_FACTOR);

}

/*!
 *
 * \brief Initialize one low power transposer instance
 *
 *
 */
SBR_ERROR
createLppTransposer (HANDLE_SBR_LPP_TRANS hs, /*!< Handle of low power transposer  */
                     TRANSPOSER_SETTINGS *pSettings, /*!< Pointer to settings */
                     const int  highBandStartSb, /*!< ? */
                     UCHAR *v_k_master,         /*!< Master table */
                     const int numMaster,       /*!< Valid entries in master table */
                     const int usb,             /*!< Highband area stop subband */
                     const int timeSlots,       /*!< Number of time slots */
                     const int nCols,           /*!< Number of colums (codec qmf bank) */
                     UCHAR *noiseBandTable,     /*!< Mapping of SBR noise bands to QMF bands */
                     const int  noNoiseBands,   /*!< Number of noise bands */
                     UINT   fs,                 /*!< Sample Frequency */
                     const int chan,            /*!< Channel number */
                     const int overlap
                     )
{
  /* FB inverse filtering settings */
  hs->pSettings = pSettings;

  pSettings->nCols = nCols;
  pSettings->overlap = overlap;

  switch (timeSlots) {

  case 15:
  case 16:
    break;

  default:
    return SBRDEC_UNSUPPORTED_CONFIG; /* Unimplemented */
  }

  if (chan==0) {
    /* Init common data only once */
    hs->pSettings->nCols = nCols;

    return resetLppTransposer (hs,
                               highBandStartSb,
                               v_k_master,
                               numMaster,
                               noiseBandTable,
                               noNoiseBands,
                               usb,
                               fs);
  }
  return SBRDEC_OK;
}


static int findClosestEntry(UCHAR goalSb, UCHAR *v_k_master, UCHAR numMaster, UCHAR direction)
{
  int index;

  if( goalSb <= v_k_master[0] )
    return v_k_master[0];

  if( goalSb >= v_k_master[numMaster] )
    return v_k_master[numMaster];

  if(direction) {
    index = 0;
    while( v_k_master[index] < goalSb ) {
      index++;
    }
  } else {
    index = numMaster;
    while( v_k_master[index] > goalSb ) {
      index--;
    }
  }

  return v_k_master[index];
}


/*!
 *
 * \brief Reset memory for one lpp transposer instance
 *
 * \return SBRDEC_OK on success, SBRDEC_UNSUPPORTED_CONFIG on error
 */
SBR_ERROR
resetLppTransposer (HANDLE_SBR_LPP_TRANS hLppTrans,  /*!< Handle of lpp transposer  */
                    UCHAR  highBandStartSb,          /*!< High band area: start subband */
                    UCHAR *v_k_master,               /*!< Master table */
                    UCHAR  numMaster,                /*!< Valid entries in master table */
                    UCHAR *noiseBandTable,           /*!< Mapping of SBR noise bands to QMF bands */
                    UCHAR  noNoiseBands,             /*!< Number of noise bands */
                    UCHAR  usb,                      /*!< High band area: stop subband */
                    UINT   fs                        /*!< SBR output sampling frequency */
                    )
{
  TRANSPOSER_SETTINGS *pSettings = hLppTrans->pSettings;
  PATCH_PARAM  *patchParam = pSettings->patchParam;

  int i, patch;
  int targetStopBand;
  int sourceStartBand;
  int patchDistance;
  int numBandsInPatch;

  int lsb = v_k_master[0];                 /* Start subband expressed in "non-critical" sampling terms*/
  int xoverOffset = highBandStartSb - lsb; /* Calculate distance in QMF bands between k0 and kx */
  int startFreqHz;

  int desiredBorder;

  usb = fixMin(usb, v_k_master[numMaster]); /* Avoid endless loops (compare with float code). */

  /*
   * Plausibility check
   */

  if ( lsb - SHIFT_START_SB < 4 ) {
    return SBRDEC_UNSUPPORTED_CONFIG;
  }


  /*
   * Initialize the patching parameter
   */
  /* ISO/IEC 14496-3 (Figure 4.48): goalSb = round( 2.048e6 / fs ) */
  desiredBorder    = (((2048000*2) / fs) + 1) >> 1;

  desiredBorder = findClosestEntry(desiredBorder, v_k_master, numMaster, 1); /* Adapt region to master-table */

  /* First patch */
  sourceStartBand = SHIFT_START_SB + xoverOffset;
  targetStopBand = lsb + xoverOffset; /* upperBand */

  /* Even (odd) numbered channel must be patched to even (odd) numbered channel */
  patch = 0;
  while(targetStopBand < usb) {

    /* Too many patches?
       Allow MAX_NUM_PATCHES+1 patches here.
       we need to check later again, since patch might be the highest patch
       AND contain less than 3 bands => actual number of patches will be reduced by 1.
    */
    if (patch > MAX_NUM_PATCHES) {
      return SBRDEC_UNSUPPORTED_CONFIG;
    }

    patchParam[patch].guardStartBand = targetStopBand;
    patchParam[patch].targetStartBand = targetStopBand;

    numBandsInPatch = desiredBorder - targetStopBand;                   /* Get the desired range of the patch */

    if ( numBandsInPatch >= lsb - sourceStartBand ) {
      /* Desired number bands are not available -> patch whole source range */
      patchDistance   = targetStopBand - sourceStartBand;        /* Get the targetOffset */
      patchDistance   = patchDistance & ~1;                      /* Rounding off odd numbers and make all even */
      numBandsInPatch = lsb - (targetStopBand - patchDistance);  /* Update number of bands to be patched */
      numBandsInPatch = findClosestEntry(targetStopBand + numBandsInPatch, v_k_master, numMaster, 0) -
                        targetStopBand;  /* Adapt region to master-table */
    }

    /* Desired number bands are available -> get the minimal even patching distance */
    patchDistance   = numBandsInPatch + targetStopBand - lsb;  /* Get minimal distance */
    patchDistance   = (patchDistance + 1) & ~1;                /* Rounding up odd numbers and make all even */

    if (numBandsInPatch > 0) {
      patchParam[patch].sourceStartBand = targetStopBand - patchDistance;
      patchParam[patch].targetBandOffs  = patchDistance;
      patchParam[patch].numBandsInPatch = numBandsInPatch;
      patchParam[patch].sourceStopBand  = patchParam[patch].sourceStartBand + numBandsInPatch;

      targetStopBand += patchParam[patch].numBandsInPatch;
      patch++;
    }

    /* All patches but first */
    sourceStartBand = SHIFT_START_SB;

    /* Check if we are close to desiredBorder */
    if( desiredBorder - targetStopBand < 3)  /* MPEG doc */
    {
      desiredBorder = usb;
    }

  }

  patch--;

  /* If highest patch contains less than three subband: skip it */
  if ( (patch>0) && (patchParam[patch].numBandsInPatch < 3) ) {
    patch--;
    targetStopBand = patchParam[patch].targetStartBand + patchParam[patch].numBandsInPatch;
  }

  /* now check if we don't have one too many */
  if (patch >= MAX_NUM_PATCHES) {
    return SBRDEC_UNSUPPORTED_CONFIG;
  }

  pSettings->noOfPatches = patch + 1;

  /* Check lowest and highest source subband */
  pSettings->lbStartPatching = targetStopBand;
  pSettings->lbStopPatching  = 0;
  for ( patch = 0; patch < pSettings->noOfPatches; patch++ ) {
    pSettings->lbStartPatching = fixMin( pSettings->lbStartPatching, patchParam[patch].sourceStartBand );
    pSettings->lbStopPatching  = fixMax( pSettings->lbStopPatching, patchParam[patch].sourceStopBand );
  }

  for(i = 0 ; i < noNoiseBands; i++){
    pSettings->bwBorders[i] = noiseBandTable[i+1];
  }

  /*
   * Choose whitening factors
   */

  startFreqHz = ( (lsb + xoverOffset)*fs ) >> 7;  /* Shift does a division by 2*(64) */

  for( i = 1; i < NUM_WHFACTOR_TABLE_ENTRIES; i++ )
  {
    if( startFreqHz < FDK_sbrDecoder_sbr_whFactorsIndex[i])
      break;
  }
  i--;

  pSettings->whFactors.off = FDK_sbrDecoder_sbr_whFactorsTable[i][0];
  pSettings->whFactors.transitionLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][1];
  pSettings->whFactors.lowLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][2];
  pSettings->whFactors.midLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][3];
  pSettings->whFactors.highLevel = FDK_sbrDecoder_sbr_whFactorsTable[i][4];

  return SBRDEC_OK;
}