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

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

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

/**************************** SBR encoder library ******************************

   Author(s):   Tobias Chalupka

   Description: SBR encoder transient detector

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

#include "tran_det.h"

#include "fram_gen.h"

#include "sbrenc_ram.h"

#include "sbr_misc.h"

#include "genericStds.h"

#define NORM_QMF_ENERGY 9.31322574615479E-10 /* 2^-30 */

/* static FIXP_DBL ABS_THRES = fixMax( FL2FXCONST_DBL(1.28e5 *

 * NORM_QMF_ENERGY), (FIXP_DBL)1)  Minimum threshold for detecting changes */

#define ABS_THRES ((FIXP_DBL)16)

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

 Functionname:  spectralChange

 *******************************************************************************

 \brief   Calculates a measure for the spectral change within the frame

 The function says how good it would be to split the frame at the given border

 position into 2 envelopes.

 The return value delta_sum is scaled with the factor 1/64

 \return  calculated value

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

#define NRG_SHIFT 3 /* for energy summation */

static FIXP_DBL spectralChange(

    FIXP_DBL Energies[NUMBER_TIME_SLOTS_2304][MAX_FREQ_COEFFS],

    INT *scaleEnergies, FIXP_DBL EnergyTotal, INT nSfb, INT start, INT border,

    INT YBufferWriteOffset, INT stop, INT *result_e) {

  INT i, j;

  INT len1, len2;

  SCHAR energies_e_diff[NUMBER_TIME_SLOTS_2304], energies_e, energyTotal_e = 19,

                                                             energies_e_add;

  SCHAR prevEnergies_e_diff, newEnergies_e_diff;

  FIXP_DBL tmp0, tmp1;

  FIXP_DBL delta, delta_sum;

  INT accu_e, tmp_e;

  delta_sum = FL2FXCONST_DBL(0.0f);

  *result_e = 0;

  len1 = border - start;

  len2 = stop - border;

  /* prefer borders near the middle of the frame */

  FIXP_DBL pos_weight;

  pos_weight = FL2FXCONST_DBL(0.5f) - (len1 * GetInvInt(len1 + len2));

  pos_weight = /*FL2FXCONST_DBL(1.0)*/ (FIXP_DBL)MAXVAL_DBL -

               (fMult(pos_weight, pos_weight) << 2);

  /*** Calc scaling for energies ***/

  FDK_ASSERT(scaleEnergies[0] >= 0);

  FDK_ASSERT(scaleEnergies[1] >= 0);

  energies_e = 19 - fMin(scaleEnergies[0], scaleEnergies[1]);

  /* limit shift for energy accumulation, energies_e can be -10 min. */

  if (energies_e < -10) {

    energies_e_add = -10 - energies_e;

    energies_e = -10;

  } else if (energies_e > 17) {

    energies_e_add = energies_e - 17;

    energies_e = 17;

  } else {

    energies_e_add = 0;

  }

  /* compensate scaling differences between scaleEnergies[0] and

   * scaleEnergies[1]  */

  prevEnergies_e_diff = scaleEnergies[0] -

                        fMin(scaleEnergies[0], scaleEnergies[1]) +

                        energies_e_add + NRG_SHIFT;

  newEnergies_e_diff = scaleEnergies[1] -

                       fMin(scaleEnergies[0], scaleEnergies[1]) +

                       energies_e_add + NRG_SHIFT;

  prevEnergies_e_diff = fMin(prevEnergies_e_diff, DFRACT_BITS - 1);

  newEnergies_e_diff = fMin(newEnergies_e_diff, DFRACT_BITS - 1);

  for (i = start; i < YBufferWriteOffset; i++) {

    energies_e_diff[i] = prevEnergies_e_diff;

  }

  for (i = YBufferWriteOffset; i < stop; i++) {

    energies_e_diff[i] = newEnergies_e_diff;

  }

  /* Sum up energies of all QMF-timeslots for both halfs */

  FDK_ASSERT(len1 <= 8); /* otherwise an overflow is possible */

  FDK_ASSERT(len2 <= 8); /* otherwise an overflow is possible */

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

    FIXP_DBL accu1 = FL2FXCONST_DBL(0.f);

    FIXP_DBL accu2 = FL2FXCONST_DBL(0.f);

    accu_e = energies_e + 3;

    /* Sum up energies in first half */

    for (i = start; i < border; i++) {

      accu1 += scaleValue(Energies[i][j], -energies_e_diff[i]);

    }

    /* Sum up energies in second half */

    for (i = border; i < stop; i++) {

      accu2 += scaleValue(Energies[i][j], -energies_e_diff[i]);

    }

    /* Ensure certain energy to prevent division by zero and to prevent

     * splitting for very low levels */

    accu1 = fMax(accu1, (FIXP_DBL)len1);

    accu2 = fMax(accu2, (FIXP_DBL)len2);

/* Energy change in current band */

#define LN2 FL2FXCONST_DBL(0.6931471806f) /* ln(2) */

    tmp0 = fLog2(accu2, accu_e) - fLog2(accu1, accu_e);

    tmp1 = fLog2((FIXP_DBL)len1, 31) - fLog2((FIXP_DBL)len2, 31);

    delta = fMult(LN2, (tmp0 + tmp1));

    delta = (FIXP_DBL)fAbs(delta);

    /* Weighting with amplitude ratio of this band */

    accu_e++; /* scale at least one bit due to (accu1+accu2) */

    accu1 >>= 1;

    accu2 >>= 1;

    if (accu_e & 1) {

      accu_e++; /* for a defined square result exponent, the exponent has to be

                   even */

      accu1 >>= 1;

      accu2 >>= 1;

    }

    delta_sum += fMult(sqrtFixp(accu1 + accu2), delta);

    *result_e = ((accu_e >> 1) + LD_DATA_SHIFT);

  }

  if (energyTotal_e & 1) {

    energyTotal_e += 1; /* for a defined square result exponent, the exponent

                           has to be even */

    EnergyTotal >>= 1;

  }

  delta_sum = fMult(delta_sum, invSqrtNorm2(EnergyTotal, &tmp_e));

  *result_e = *result_e + (tmp_e - (energyTotal_e >> 1));

  return fMult(delta_sum, pos_weight);

}

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

 Functionname:  addLowbandEnergies

 *******************************************************************************

 \brief   Calculates total lowband energy

 The input values Energies[0] (low-band) are scaled by the factor

 2^(14-*scaleEnergies[0])

 The input values Energies[1] (high-band) are scaled by the factor

 2^(14-*scaleEnergies[1])

 \return  total energy in the lowband, scaled by the factor 2^19

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

static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, int *scaleEnergies,

                                   int YBufferWriteOffset, int nrgSzShift,

                                   int tran_off, UCHAR *freqBandTable,

                                   int slots) {

  INT nrgTotal_e;

  FIXP_DBL nrgTotal_m;

  FIXP_DBL accu1 = FL2FXCONST_DBL(0.0f);

  FIXP_DBL accu2 = FL2FXCONST_DBL(0.0f);

  int tran_offdiv2 = tran_off >> nrgSzShift;

  const int sc1 =

      DFRACT_BITS -

      fNormz((FIXP_DBL)fMax(

          1, (freqBandTable[0] * (YBufferWriteOffset - tran_offdiv2) - 1)));

  const int sc2 =

      DFRACT_BITS -

      fNormz((FIXP_DBL)fMax(

          1, (freqBandTable[0] *

                  (tran_offdiv2 + (slots >> nrgSzShift) - YBufferWriteOffset) -

              1)));

  int ts, k;

  /* Sum up lowband energy from one frame at offset tran_off */

  /* freqBandTable[LORES] has MAX_FREQ_COEFFS/2 +1 coeefs max. */

  for (ts = tran_offdiv2; ts < YBufferWriteOffset; ts++) {

    for (k = 0; k < freqBandTable[0]; k++) {

      accu1 += Energies[ts][k] >> sc1;

    }

  }

  for (; ts < tran_offdiv2 + (slots >> nrgSzShift); ts++) {

    for (k = 0; k < freqBandTable[0]; k++) {

      accu2 += Energies[ts][k] >> sc2;

    }

  }

  nrgTotal_m = fAddNorm(accu1, (sc1 - 5) - scaleEnergies[0], accu2,

                        (sc2 - 5) - scaleEnergies[1], &nrgTotal_e);

  nrgTotal_m = scaleValueSaturate(nrgTotal_m, nrgTotal_e);

  return (nrgTotal_m);

}

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

 Functionname:  addHighbandEnergies

 *******************************************************************************

 \brief   Add highband energies

 Highband energies are mapped to an array with smaller dimension:

 Its time resolution is only 1 SBR-timeslot and its frequency resolution

 is 1 SBR-band. Therefore the data to be fed into the spectralChange

 function is reduced.

 The values EnergiesM are scaled by the factor (2^19-scaleEnergies[0]) for

 slots<YBufferWriteOffset and by the factor (2^19-scaleEnergies[1]) for

 slots>=YBufferWriteOffset.

 \return  total energy in the highband, scaled by factor 2^19

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

static FIXP_DBL addHighbandEnergies(

    FIXP_DBL **RESTRICT Energies, /*!< input */

    INT *scaleEnergies, INT YBufferWriteOffset,

    FIXP_DBL EnergiesM[NUMBER_TIME_SLOTS_2304]

                      [MAX_FREQ_COEFFS], /*!< Combined output */

    UCHAR *RESTRICT freqBandTable, INT nSfb, INT sbrSlots, INT timeStep) {

  INT i, j, k, slotIn, slotOut, scale[2];

  INT li, ui;

  FIXP_DBL nrgTotal;

  FIXP_DBL accu = FL2FXCONST_DBL(0.0f);

  /* Combine QMF-timeslots to SBR-timeslots,

     combine QMF-bands to SBR-bands,

     combine Left and Right channel */

  for (slotOut = 0; slotOut < sbrSlots; slotOut++) {

    /* Note: Below slotIn = slotOut and not slotIn = timeStep*slotOut

       because the Energies[] time resolution is always the SBR slot resolution

       regardless of the timeStep. */

    slotIn = slotOut;

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

      accu = FL2FXCONST_DBL(0.0f);

      li = freqBandTable[j];

      ui = freqBandTable[j + 1];

      for (k = li; k < ui; k++) {

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

          accu += Energies[slotIn][k] >> 5;

        }

      }

      EnergiesM[slotOut][j] = accu;

    }

  }

  /* scale energies down before add up */

  scale[0] = fixMin(8, scaleEnergies[0]);

  scale[1] = fixMin(8, scaleEnergies[1]);

  if ((scaleEnergies[0] - scale[0]) > (DFRACT_BITS - 1) ||

      (scaleEnergies[1] - scale[1]) > (DFRACT_BITS - 1))

    nrgTotal = FL2FXCONST_DBL(0.0f);

  else {

    /* Now add all energies */

    accu = FL2FXCONST_DBL(0.0f);

    for (slotOut = 0; slotOut < YBufferWriteOffset; slotOut++) {

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

        accu += (EnergiesM[slotOut][j] >> scale[0]);

      }

    }

    nrgTotal = accu >> (scaleEnergies[0] - scale[0]);

    for (slotOut = YBufferWriteOffset; slotOut < sbrSlots; slotOut++) {

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

        accu += (EnergiesM[slotOut][j] >> scale[0]);

      }

    }

    nrgTotal = fAddSaturate(nrgTotal, accu >> (scaleEnergies[1] - scale[1]));

  }

  return (nrgTotal);

}

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

 Functionname:  FDKsbrEnc_frameSplitter

 *******************************************************************************

 \brief   Decides if a FIXFIX-frame shall be splitted into 2 envelopes

 If no transient has been detected before, the frame can still be splitted

 into 2 envelopes.

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

void FDKsbrEnc_frameSplitter(

    FIXP_DBL **Energies, INT *scaleEnergies,

    HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientDetector, UCHAR *freqBandTable,

    UCHAR *tran_vector, int YBufferWriteOffset, int YBufferSzShift, int nSfb,

    int timeStep, int no_cols, FIXP_DBL *tonality) {

  if (tran_vector[1] == 0) /* no transient was detected */

  {

    FIXP_DBL delta;

    INT delta_e;

    FIXP_DBL(*EnergiesM)[MAX_FREQ_COEFFS];

    FIXP_DBL EnergyTotal, newLowbandEnergy, newHighbandEnergy;

    INT border;

    INT sbrSlots = fMultI(GetInvInt(timeStep), no_cols);

    C_ALLOC_SCRATCH_START(_EnergiesM, FIXP_DBL,

                          NUMBER_TIME_SLOTS_2304 * MAX_FREQ_COEFFS)

    FDK_ASSERT(sbrSlots * timeStep == no_cols);

    EnergiesM = (FIXP_DBL(*)[MAX_FREQ_COEFFS])_EnergiesM;

    /*

      Get Lowband-energy over a range of 2 frames (Look half a frame back and

      ahead).

    */

    newLowbandEnergy = addLowbandEnergies(

        Energies, scaleEnergies, YBufferWriteOffset, YBufferSzShift,

        h_sbrTransientDetector->tran_off, freqBandTable, no_cols);

    newHighbandEnergy =

        addHighbandEnergies(Energies, scaleEnergies, YBufferWriteOffset,

                            EnergiesM, freqBandTable, nSfb, sbrSlots, timeStep);

    {

      /* prevLowBandEnergy: Corresponds to 1 frame, starting with half a frame

         look-behind newLowbandEnergy:  Corresponds to 1 frame, starting in the

         middle of the current frame */

      EnergyTotal = (newLowbandEnergy >> 1) +

                    (h_sbrTransientDetector->prevLowBandEnergy >>

                     1); /* mean of new and prev LB NRG */

      EnergyTotal =

          fAddSaturate(EnergyTotal, newHighbandEnergy); /* Add HB NRG */

      /* The below border should specify the same position as the middle border

         of a FIXFIX-frame with 2 envelopes. */

      border = (sbrSlots + 1) >> 1;

      if ((INT)EnergyTotal & 0xffffffe0 &&

          (scaleEnergies[0] < 32 || scaleEnergies[1] < 32)) /* i.e. > 31 */ {

        delta = spectralChange(EnergiesM, scaleEnergies, EnergyTotal, nSfb, 0,

                               border, YBufferWriteOffset, sbrSlots, &delta_e);

      } else {

        delta = FL2FXCONST_DBL(0.0f);

        delta_e = 0;

        /* set tonality to 0 when energy is very low, since the amplitude

           resolution should then be low as well                          */

        *tonality = FL2FXCONST_DBL(0.0f);

      }

      if (fIsLessThan(h_sbrTransientDetector->split_thr_m,

                      h_sbrTransientDetector->split_thr_e, delta, delta_e)) {

        tran_vector[0] = 1; /* Set flag for splitting */

      } else {

        tran_vector[0] = 0;

      }

    }

    /* Update prevLowBandEnergy */

    h_sbrTransientDetector->prevLowBandEnergy = newLowbandEnergy;

    h_sbrTransientDetector->prevHighBandEnergy = newHighbandEnergy;

    C_ALLOC_SCRATCH_END(_EnergiesM, FIXP_DBL,

                        NUMBER_TIME_SLOTS_2304 * MAX_FREQ_COEFFS)

  }

}

/*

 * Calculate transient energy threshold for each QMF band

 */

static void calculateThresholds(FIXP_DBL **RESTRICT Energies,

                                INT *RESTRICT scaleEnergies,

                                FIXP_DBL *RESTRICT thresholds,

                                int YBufferWriteOffset, int YBufferSzShift,

                                int noCols, int noRows, int tran_off) {

  FIXP_DBL mean_val, std_val, temp;

  FIXP_DBL i_noCols;

  FIXP_DBL i_noCols1;

  FIXP_DBL accu, accu0, accu1;

  int scaleFactor0, scaleFactor1, commonScale;

  int i, j;

  i_noCols = GetInvInt(noCols + tran_off) << YBufferSzShift;

  i_noCols1 = GetInvInt(noCols + tran_off - 1) << YBufferSzShift;

  /* calc minimum scale of energies of previous and current frame */

  commonScale = fixMin(scaleEnergies[0], scaleEnergies[1]);

  /* calc scalefactors to adapt energies to common scale */

  scaleFactor0 = fixMin((scaleEnergies[0] - commonScale), (DFRACT_BITS - 1));

  scaleFactor1 = fixMin((scaleEnergies[1] - commonScale), (DFRACT_BITS - 1));

  FDK_ASSERT((scaleFactor0 >= 0) && (scaleFactor1 >= 0));

  /* calculate standard deviation in every subband */

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

    int startEnergy = (tran_off >> YBufferSzShift);

    int endEnergy = ((noCols >> YBufferSzShift) + tran_off);

    int shift;

    /* calculate mean value over decimated energy values (downsampled by 2). */

    accu0 = accu1 = FL2FXCONST_DBL(0.0f);

    for (j = startEnergy; j < YBufferWriteOffset; j++)

      accu0 = fMultAddDiv2(accu0, Energies[j][i], i_noCols);

    for (; j < endEnergy; j++)

      accu1 = fMultAddDiv2(accu1, Energies[j][i], i_noCols);

    mean_val = ((accu0 << 1) >> scaleFactor0) +

               ((accu1 << 1) >> scaleFactor1); /* average */

    shift = fixMax(

        0, CountLeadingBits(mean_val) -

               6); /* -6 to keep room for accumulating upto N = 24 values */

    /* calculate standard deviation */

    accu = FL2FXCONST_DBL(0.0f);

    /* summe { ((mean_val-nrg)^2) * i_noCols1 } */

    for (j = startEnergy; j < YBufferWriteOffset; j++) {

      temp = ((FIXP_DBL)mean_val - ((FIXP_DBL)Energies[j][i] >> scaleFactor0))

             << shift;

      temp = fPow2Div2(temp);

      accu = fMultAddDiv2(accu, temp, i_noCols1);

    }

    for (; j < endEnergy; j++) {

      temp = ((FIXP_DBL)mean_val - ((FIXP_DBL)Energies[j][i] >> scaleFactor1))

             << shift;

      temp = fPow2Div2(temp);

      accu = fMultAddDiv2(accu, temp, i_noCols1);

    }

    accu <<= 2;

    std_val = sqrtFixp(accu) >> shift; /* standard deviation */

    /*

    Take new threshold as average of calculated standard deviation ratio

    and old threshold if greater than absolute threshold

    */

    temp = (commonScale <= (DFRACT_BITS - 1))

               ? fMult(FL2FXCONST_DBL(0.66f), thresholds[i]) +

                     (fMult(FL2FXCONST_DBL(0.34f), std_val) >> commonScale)

               : (FIXP_DBL)0;

    thresholds[i] = fixMax(ABS_THRES, temp);

    FDK_ASSERT(commonScale >= 0);

  }

}

/*

 * Calculate transient levels for each QMF time slot.

 */

static void extractTransientCandidates(

    FIXP_DBL **RESTRICT Energies, INT *RESTRICT scaleEnergies,

    FIXP_DBL *RESTRICT thresholds, FIXP_DBL *RESTRICT transients,

    int YBufferWriteOffset, int YBufferSzShift, int noCols, int start_band,

    int stop_band, int tran_off, int addPrevSamples) {

  FIXP_DBL i_thres;

  C_ALLOC_SCRATCH_START(EnergiesTemp, FIXP_DBL, 2 * 32)

  int tmpScaleEnergies0, tmpScaleEnergies1;

  int endCond;

  int startEnerg, endEnerg;

  int i, j, jIndex, jpBM;

  tmpScaleEnergies0 = scaleEnergies[0];

  tmpScaleEnergies1 = scaleEnergies[1];

  /* Scale value for first energies, upto YBufferWriteOffset */

  tmpScaleEnergies0 = fixMin(tmpScaleEnergies0, MAX_SHIFT_DBL);

  /* Scale value for first energies, from YBufferWriteOffset upwards */

  tmpScaleEnergies1 = fixMin(tmpScaleEnergies1, MAX_SHIFT_DBL);

  FDK_ASSERT((tmpScaleEnergies0 >= 0) && (tmpScaleEnergies1 >= 0));

  /* Keep addPrevSamples extra previous transient candidates. */

  FDKmemmove(transients, transients + noCols - addPrevSamples,

             (tran_off + addPrevSamples) * sizeof(FIXP_DBL));

  FDKmemclear(transients + tran_off + addPrevSamples,

              noCols * sizeof(FIXP_DBL));

  endCond = noCols; /* Amount of new transient values to be calculated. */

  startEnerg = (tran_off - 3) >> YBufferSzShift; /* >>YBufferSzShift because of

                                                    amount of energy values. -3

                                                    because of neighbors being

                                                    watched. */

  endEnerg =

      ((noCols + (YBufferWriteOffset << YBufferSzShift)) - 1) >>

      YBufferSzShift; /* YBufferSzShift shifts because of half energy values. */

  /* Compute differential values with two different weightings in every subband

   */

  for (i = start_band; i < stop_band; i++) {

    FIXP_DBL thres = thresholds[i];

    if ((LONG)thresholds[i] >= 256)

      i_thres = (LONG)((LONG)MAXVAL_DBL / ((((LONG)thresholds[i])) + 1))

                << (32 - 24);

    else

      i_thres = (LONG)MAXVAL_DBL;

    /* Copy one timeslot and de-scale and de-squish */

    if (YBufferSzShift == 1) {

      for (j = startEnerg; j < YBufferWriteOffset; j++) {

        FIXP_DBL tmp = Energies[j][i];

        EnergiesTemp[(j << 1) + 1] = EnergiesTemp[j << 1] =

            tmp >> tmpScaleEnergies0;

      }

      for (; j <= endEnerg; j++) {

        FIXP_DBL tmp = Energies[j][i];

        EnergiesTemp[(j << 1) + 1] = EnergiesTemp[j << 1] =

            tmp >> tmpScaleEnergies1;

      }

    } else {

      for (j = startEnerg; j < YBufferWriteOffset; j++) {

        FIXP_DBL tmp = Energies[j][i];

        EnergiesTemp[j] = tmp >> tmpScaleEnergies0;

      }

      for (; j <= endEnerg; j++) {

        FIXP_DBL tmp = Energies[j][i];

        EnergiesTemp[j] = tmp >> tmpScaleEnergies1;

      }

    }

    /* Detect peaks in energy values. */

    jIndex = tran_off;

    jpBM = jIndex + addPrevSamples;

    for (j = endCond; j--; jIndex++, jpBM++) {

      FIXP_DBL delta, tran;

      int d;

      delta = (FIXP_DBL)0;

      tran = (FIXP_DBL)0;

      for (d = 1; d < 4; d++) {

        delta += EnergiesTemp[jIndex + d]; /* R */

        delta -= EnergiesTemp[jIndex - d]; /* L */

        delta -= thres;

        if (delta > (FIXP_DBL)0) {

          tran = fMultAddDiv2(tran, i_thres, delta);

        }

      }

      transients[jpBM] += (tran << 1);

    }

  }

  C_ALLOC_SCRATCH_END(EnergiesTemp, FIXP_DBL, 2 * 32)

}

void FDKsbrEnc_transientDetect(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTran,

                               FIXP_DBL **Energies, INT *scaleEnergies,

                               UCHAR *transient_info, int YBufferWriteOffset,

                               int YBufferSzShift, int timeStep,

                               int frameMiddleBorder) {

  int no_cols = h_sbrTran->no_cols;

  int qmfStartSample;

  int addPrevSamples;

  int timeStepShift = 0;

  int i, cond;

  /* Where to start looking for transients in the transient candidate buffer */

  qmfStartSample = timeStep * frameMiddleBorder;

  /* We need to look one value backwards in the transients, so we might need one

   * more previous value. */

  addPrevSamples = (qmfStartSample > 0) ? 0 : 1;

  switch (timeStep) {

    case 1:

      timeStepShift = 0;

      break;

    case 2:

      timeStepShift = 1;

      break;

    case 4:

      timeStepShift = 2;

      break;

  }

  calculateThresholds(Energies, scaleEnergies, h_sbrTran->thresholds,

                      YBufferWriteOffset, YBufferSzShift, h_sbrTran->no_cols,

                      h_sbrTran->no_rows, h_sbrTran->tran_off);

  extractTransientCandidates(

      Energies, scaleEnergies, h_sbrTran->thresholds, h_sbrTran->transients,

      YBufferWriteOffset, YBufferSzShift, h_sbrTran->no_cols, 0,

      h_sbrTran->no_rows, h_sbrTran->tran_off, addPrevSamples);

  transient_info[0] = 0;

  transient_info[1] = 0;

  transient_info[2] = 0;

  /* Offset by the amount of additional previous transient candidates being

   * kept. */

  qmfStartSample += addPrevSamples;

  /* Check for transients in second granule (pick the last value of subsequent

   * values)  */

  for (i = qmfStartSample; i < qmfStartSample + no_cols; i++) {

    cond = (h_sbrTran->transients[i] <

            fMult(FL2FXCONST_DBL(0.9f), h_sbrTran->transients[i - 1])) &&

           (h_sbrTran->transients[i - 1] > h_sbrTran->tran_thr);

    if (cond) {

      transient_info[0] = (i - qmfStartSample) >> timeStepShift;

      transient_info[1] = 1;

      break;

    }

  }

  if (h_sbrTran->frameShift != 0) {

    /* transient prediction for LDSBR */

    /* Check for transients in first <frameShift> qmf-slots of second frame */

    for (i = qmfStartSample + no_cols;

         i < qmfStartSample + no_cols + h_sbrTran->frameShift; i++) {

      cond = (h_sbrTran->transients[i] <

              fMult(FL2FXCONST_DBL(0.9f), h_sbrTran->transients[i - 1])) &&

             (h_sbrTran->transients[i - 1] > h_sbrTran->tran_thr);

      if (cond) {

        int pos = (int)((i - qmfStartSample - no_cols) >> timeStepShift);

        if ((pos < 3) && (transient_info[1] == 0)) {

          transient_info[2] = 1;

        }

        break;

      }

    }

  }

}

int FDKsbrEnc_InitSbrTransientDetector(

    HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientDetector,

    UINT sbrSyntaxFlags, /* SBR syntax flags derived from AOT. */

    INT frameSize, INT sampleFreq, sbrConfigurationPtr params, int tran_fc,

    int no_cols, int no_rows, int YBufferWriteOffset, int YBufferSzShift,

    int frameShift, int tran_off) {

  INT totalBitrate =

      params->codecSettings.standardBitrate * params->codecSettings.nChannels;

  INT codecBitrate = params->codecSettings.bitRate;

  FIXP_DBL bitrateFactor_m, framedur_fix;

  INT bitrateFactor_e, tmp_e;

  FDKmemclear(h_sbrTransientDetector, sizeof(SBR_TRANSIENT_DETECTOR));

  h_sbrTransientDetector->frameShift = frameShift;

  h_sbrTransientDetector->tran_off = tran_off;

  if (codecBitrate) {

    bitrateFactor_m = fDivNorm((FIXP_DBL)totalBitrate,

                               (FIXP_DBL)(codecBitrate << 2), &bitrateFactor_e);

    bitrateFactor_e += 2;

  } else {

    bitrateFactor_m = FL2FXCONST_DBL(1.0 / 4.0);

    bitrateFactor_e = 2;

  }

  framedur_fix = fDivNorm(frameSize, sampleFreq);

  /* The longer the frames, the more often should the FIXFIX-

  case transmit 2 envelopes instead of 1.

  Frame durations below 10 ms produce the highest threshold

  so that practically always only 1 env is transmitted. */

  FIXP_DBL tmp = framedur_fix - FL2FXCONST_DBL(0.010);

  tmp = fixMax(tmp, FL2FXCONST_DBL(0.0001));

  tmp = fDivNorm(FL2FXCONST_DBL(0.000075), fPow2(tmp), &tmp_e);

  bitrateFactor_e = (tmp_e + bitrateFactor_e);

  if (sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {

    bitrateFactor_e--; /* divide by 2 */

  }

  FDK_ASSERT(no_cols <= 32);

  FDK_ASSERT(no_rows <= 64);

  h_sbrTransientDetector->no_cols = no_cols;

  h_sbrTransientDetector->tran_thr =

      (FIXP_DBL)((params->tran_thr << (32 - 24 - 1)) / no_rows);

  h_sbrTransientDetector->tran_fc = tran_fc;

  h_sbrTransientDetector->split_thr_m = fMult(tmp, bitrateFactor_m);

  h_sbrTransientDetector->split_thr_e = bitrateFactor_e;

  h_sbrTransientDetector->no_rows = no_rows;

  h_sbrTransientDetector->mode = params->tran_det_mode;

  h_sbrTransientDetector->prevLowBandEnergy = FL2FXCONST_DBL(0.0f);

  return (0);

}

#define ENERGY_SCALING_SIZE 32

INT FDKsbrEnc_InitSbrFastTransientDetector(

    HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector,

    const INT time_slots_per_frame, const INT bandwidth_qmf_slot,

    const INT no_qmf_channels, const INT sbr_qmf_1st_band) {

  int i;

  int buff_size;

  FIXP_DBL myExp;

  FIXP_DBL myExpSlot;

  h_sbrFastTransientDetector->lookahead = TRAN_DET_LOOKAHEAD;

  h_sbrFastTransientDetector->nTimeSlots = time_slots_per_frame;

  buff_size = h_sbrFastTransientDetector->nTimeSlots +

              h_sbrFastTransientDetector->lookahead;

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

    h_sbrFastTransientDetector->delta_energy[i] = FL2FXCONST_DBL(0.0f);

    h_sbrFastTransientDetector->energy_timeSlots[i] = FL2FXCONST_DBL(0.0f);

    h_sbrFastTransientDetector->lowpass_energy[i] = FL2FXCONST_DBL(0.0f);

    h_sbrFastTransientDetector->transientCandidates[i] = 0;

  }

  FDK_ASSERT(bandwidth_qmf_slot > 0.f);

  h_sbrFastTransientDetector->stopBand =

      fMin(TRAN_DET_STOP_FREQ / bandwidth_qmf_slot, no_qmf_channels);

  h_sbrFastTransientDetector->startBand =

      fMin(sbr_qmf_1st_band,

           h_sbrFastTransientDetector->stopBand - TRAN_DET_MIN_QMFBANDS);

  FDK_ASSERT(h_sbrFastTransientDetector->startBand < no_qmf_channels);

  FDK_ASSERT(h_sbrFastTransientDetector->startBand <

             h_sbrFastTransientDetector->stopBand);

  FDK_ASSERT(h_sbrFastTransientDetector->startBand > 1);

  FDK_ASSERT(h_sbrFastTransientDetector->stopBand > 1);

  /* the energy weighting and adding up has a headroom of 6 Bits,

     so up to 64 bands can be added without potential overflow. */

  FDK_ASSERT(h_sbrFastTransientDetector->stopBand -

                 h_sbrFastTransientDetector->startBand <=

             64);

/* QMF_HP_dB_SLOPE_FIX says that we want a 20 dB per 16 kHz HP filter.

   The following lines map this to the QMF bandwidth. */

#define EXP_E 7 /* 64 (=64) multiplications max, max. allowed sum is 0.5 */

  myExp = fMultNorm(QMF_HP_dBd_SLOPE_FIX, 0, (FIXP_DBL)bandwidth_qmf_slot,

                    DFRACT_BITS - 1, EXP_E);

  myExpSlot = myExp;

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

    /* Calculate dBf over all qmf bands:

       dBf = (10^(0.002266f/10*bw(slot)))^(band) =

           = 2^(log2(10)*0.002266f/10*bw(slot)*band) =

           = 2^(0.00075275f*bw(slot)*band)                                   */

    FIXP_DBL dBf_m; /* dBf mantissa        */

    INT dBf_e;      /* dBf exponent        */

    INT tmp;

    INT dBf_int;        /* dBf integer part    */

    FIXP_DBL dBf_fract; /* dBf fractional part */

    /* myExp*(i+1) = myExp_int - myExp_fract

       myExp*(i+1) is split up here for better accuracy of CalcInvLdData(),

       for its result can be split up into an integer and a fractional part */

    /* Round up to next integer */

    FIXP_DBL myExp_int =

        (myExpSlot & (FIXP_DBL)0xfe000000) + (FIXP_DBL)0x02000000;

    /* This is the fractional part that needs to be substracted */

    FIXP_DBL myExp_fract = myExp_int - myExpSlot;

    /* Calc integer part */

    dBf_int = CalcInvLdData(myExp_int);

    /* The result needs to be re-scaled. The ld(myExp_int) had been scaled by

       EXP_E, the CalcInvLdData expects the operand to be scaled by

       LD_DATA_SHIFT. Therefore, the correctly scaled result is

       dBf_int^(2^(EXP_E-LD_DATA_SHIFT)), which is dBf_int^2 */

    if (dBf_int <=

        46340) { /* compare with maximum allowed value for signed integer

                    multiplication, 46340 =

                    (INT)floor(sqrt((double)(((UINT)1<<(DFRACT_BITS-1))-1))) */

      dBf_int *= dBf_int;

      /* Calc fractional part */

      dBf_fract = CalcInvLdData(-myExp_fract);

      /* The result needs to be re-scaled. The ld(myExp_fract) had been scaled

         by EXP_E, the CalcInvLdData expects the operand to be scaled by

         LD_DATA_SHIFT. Therefore, the correctly scaled result is

         dBf_fract^(2^(EXP_E-LD_DATA_SHIFT)), which is dBf_fract^2 */

      dBf_fract = fMultNorm(dBf_fract, dBf_fract, &tmp);

      /* Get worst case scaling of multiplication result */

      dBf_e = (DFRACT_BITS - 1 - tmp) - CountLeadingBits(dBf_int);

      /* Now multiply integer with fractional part of the result, thus resulting

         in the overall accurate fractional result */

      dBf_m = fMultNorm(dBf_int, DFRACT_BITS - 1, dBf_fract, tmp, dBf_e);

      myExpSlot += myExp;

    } else {

      dBf_m = (FIXP_DBL)0;

      dBf_e = 0;

    }

    /* Keep the results */

    h_sbrFastTransientDetector->dBf_m[i] = dBf_m;

    h_sbrFastTransientDetector->dBf_e[i] = dBf_e;

  }

  /* Make sure that dBf is greater than 1.0 (because it should be a highpass) */

  /* ... */

  return 0;

}

void FDKsbrEnc_fastTransientDetect(

    const HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector,

    const FIXP_DBL *const *Energies, const int *const scaleEnergies,

    const INT YBufferWriteOffset, UCHAR *const tran_vector) {

  int timeSlot, band;

  FIXP_DBL max_delta_energy; /* helper to store maximum energy ratio          */

  int max_delta_energy_scale; /* helper to store scale of maximum energy ratio

                               */

  int ind_max = 0; /* helper to store index of maximum energy ratio */

  int isTransientInFrame = 0;

  const int nTimeSlots = h_sbrFastTransientDetector->nTimeSlots;

  const int lookahead = h_sbrFastTransientDetector->lookahead;

  const int startBand = h_sbrFastTransientDetector->startBand;

  const int stopBand = h_sbrFastTransientDetector->stopBand;