/* -----------------------------------------------------------------------------
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):   Andreas Ehret, Tobias Chalupka

   Description: SBR encoder top level processing.

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

#include "sbr_encoder.h"

#include "sbrenc_ram.h"
#include "sbrenc_rom.h"
#include "sbrenc_freq_sca.h"
#include "env_bit.h"
#include "cmondata.h"
#include "sbr_misc.h"
#include "sbr.h"
#include "qmf.h"

#include "ps_main.h"

#define SBRENCODER_LIB_VL0 4
#define SBRENCODER_LIB_VL1 0
#define SBRENCODER_LIB_VL2 0

/***************************************************************************/
/*
 * SBR Delay balancing definitions.
 */

/*
      input buffer (1ch)

      |------------ 1537   -------------|-----|---------- 2048 -------------|
           (core2sbr delay     )          ds     (read, core and ds area)
*/

#define SFB(dwnsmp) \
  (32 << (dwnsmp -  \
          1)) /* SBR Frequency bands: 64 for dual-rate, 32 for single-rate */
#define STS(fl)                                                              \
  (((fl) == 1024) ? 32                                                       \
                  : 30) /* SBR Time Slots: 32 for core frame length 1024, 30 \
                           for core frame length 960 */

#define DELAY_QMF_ANA(dwnsmp) \
  ((320 << ((dwnsmp)-1)) - (32 << ((dwnsmp)-1))) /* Full bandwidth */
#define DELAY_HYB_ANA (10 * 64) /* + 0.5 */      /*  */
#define DELAY_HYB_SYN (6 * 64 - 32)              /*  */
#define DELAY_QMF_POSTPROC(dwnsmp) \
  (32 * (dwnsmp))                               /* QMF postprocessing delay */
#define DELAY_DEC_QMF(dwnsmp) (6 * SFB(dwnsmp)) /* Decoder QMF overlap */
#define DELAY_QMF_SYN(dwnsmp) \
  (1 << (dwnsmp -             \
         1)) /* QMF_NO_POLY/2=2.5, rounded down to 2, half for single-rate */
#define DELAY_QMF_DS (32) /* QMF synthesis for downsampled time signal */

/* Delay in QMF paths */
#define DELAY_SBR(fl, dwnsmp) \
  (DELAY_QMF_ANA(dwnsmp) + (SFB(dwnsmp) * STS(fl) - 1) + DELAY_QMF_SYN(dwnsmp))
#define DELAY_PS(fl, dwnsmp)                                       \
  (DELAY_QMF_ANA(dwnsmp) + DELAY_HYB_ANA + DELAY_DEC_QMF(dwnsmp) + \
   (SFB(dwnsmp) * STS(fl) - 1) + DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp))
#define DELAY_ELDSBR(fl, dwnsmp) \
  ((((fl) / 2) * (dwnsmp)) - 1 + DELAY_QMF_POSTPROC(dwnsmp))
#define DELAY_ELDv2SBR(fl, dwnsmp)                                        \
  ((((fl) / 2) * (dwnsmp)) - 1 + 80 * (dwnsmp)) /* 80 is the delay caused \
                                                   by the sum of the CLD  \
                                                   analysis and the MPSLD \
                                                   synthesis filterbank */

/* Delay in core path (core and downsampler not taken into account) */
#define DELAY_COREPATH_SBR(fl, dwnsmp) \
  ((DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + DELAY_QMF_SYN(dwnsmp)))
#define DELAY_COREPATH_ELDSBR(fl, dwnsmp) ((DELAY_QMF_POSTPROC(dwnsmp)))
#define DELAY_COREPATH_ELDv2SBR(fl, dwnsmp) (128 * (dwnsmp)) /* 4 slots */
#define DELAY_COREPATH_PS(fl, dwnsmp)                                        \
  ((DELAY_QMF_ANA(dwnsmp) + DELAY_QMF_DS +                                   \
    /*(DELAY_AAC(fl)*2) + */ DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + \
    DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp))) /* 2048 - 463*2 */

/* Delay differences between SBR- and downsampled path for SBR and SBR+PS */
#define DELAY_AAC2SBR(fl, dwnsmp) \
  ((DELAY_COREPATH_SBR(fl, dwnsmp)) - DELAY_SBR((fl), (dwnsmp)))
#define DELAY_ELD2SBR(fl, dwnsmp) \
  ((DELAY_COREPATH_ELDSBR(fl, dwnsmp)) - DELAY_ELDSBR(fl, dwnsmp))
#define DELAY_AAC2PS(fl, dwnsmp) \
  ((DELAY_COREPATH_PS(fl, dwnsmp)) - DELAY_PS(fl, dwnsmp)) /* 2048 - 463*2 */

/* Assumption: The sample delay resulting of of DELAY_AAC2PS is always smaller
 * than the sample delay implied by DELAY_AAC2SBR */
#define MAX_DS_FILTER_DELAY \
  (5) /* the additional max downsampler filter delay (source fs) */
#define MAX_SAMPLE_DELAY                                                 \
  (DELAY_AAC2SBR(1024, 2) + MAX_DS_FILTER_DELAY) /* maximum delay: frame \
                                                    length of 1024 and   \
                                                    dual-rate sbr */

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

/*************** Delay parameters for sbrEncoder_Init_delay() **************/
typedef struct {
  int dsDelay;        /* the delay of the (time-domain) downsampler itself */
  int delay;          /* overall delay / samples  */
  int sbrDecDelay;    /* SBR decoder's delay */
  int corePathOffset; /* core path offset / samples; added by
                         sbrEncoder_Init_delay() */
  int sbrPathOffset;  /* SBR path offset / samples; added by
                         sbrEncoder_Init_delay() */
  int bitstrDelay; /* bitstream delay / frames; added by sbrEncoder_Init_delay()
                    */
  int delayInput2Core; /* delay of the input to the core / samples */
} DELAY_PARAM;
/***************************************************************************/

#define INVALID_TABLE_IDX -1

/***************************************************************************/
/*!

  \brief  Selects the SBR tuning settings to use dependent on number of
          channels, bitrate, sample rate and core coder

  \return Index to the appropriate table

****************************************************************************/
#define DISTANCE_CEIL_VALUE 5000000
static INT getSbrTuningTableIndex(
    UINT bitrate,     /*! the total bitrate in bits/sec */
    UINT numChannels, /*! the number of channels for the core coder */
    UINT sampleRate,  /*! the sampling rate of the core coder */
    AUDIO_OBJECT_TYPE core, UINT *pBitRateClosest) {
  int i, bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1,
         found = 0;
  UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE;

#define isForThisCore(i)                                                     \
  ((sbrTuningTable[i].coreCoder == CODEC_AACLD && core == AOT_ER_AAC_ELD) || \
   (sbrTuningTable[i].coreCoder == CODEC_AAC && core != AOT_ER_AAC_ELD))

  for (i = 0; i < sbrTuningTableSize; i++) {
    if (isForThisCore(i)) /* tuning table is for this core codec */
    {
      if (numChannels == sbrTuningTable[i].numChannels &&
          sampleRate == sbrTuningTable[i].sampleRate) {
        found = 1;
        if ((bitrate >= sbrTuningTable[i].bitrateFrom) &&
            (bitrate < sbrTuningTable[i].bitrateTo)) {
          return i;
        } else {
          if (sbrTuningTable[i].bitrateFrom > bitrate) {
            if (sbrTuningTable[i].bitrateFrom < bitRateClosestLower) {
              bitRateClosestLower = sbrTuningTable[i].bitrateFrom;
              bitRateClosestLowerIndex = i;
            }
          }
          if (sbrTuningTable[i].bitrateTo <= bitrate) {
            if (sbrTuningTable[i].bitrateTo > bitRateClosestUpper) {
              bitRateClosestUpper = sbrTuningTable[i].bitrateTo - 1;
              bitRateClosestUpperIndex = i;
            }
          }
        }
      }
    }
  }

  if (bitRateClosestUpperIndex >= 0) {
    return bitRateClosestUpperIndex;
  }

  if (pBitRateClosest != NULL) {
    /* If there was at least one matching tuning entry pick the least distance
     * bit rate */
    if (found) {
      int distanceUpper = DISTANCE_CEIL_VALUE,
          distanceLower = DISTANCE_CEIL_VALUE;
      if (bitRateClosestLowerIndex >= 0) {
        distanceLower =
            sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate;
      }
      if (bitRateClosestUpperIndex >= 0) {
        distanceUpper =
            bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo;
      }
      if (distanceUpper < distanceLower) {
        *pBitRateClosest = bitRateClosestUpper;
      } else {
        *pBitRateClosest = bitRateClosestLower;
      }
    } else {
      *pBitRateClosest = 0;
    }
  }

  return INVALID_TABLE_IDX;
}

/***************************************************************************/
/*!

  \brief  Selects the PS tuning settings to use dependent on bitrate
  and core coder

  \return Index to the appropriate table

****************************************************************************/
static INT getPsTuningTableIndex(UINT bitrate, UINT *pBitRateClosest) {
  INT i, paramSets = sizeof(psTuningTable) / sizeof(psTuningTable[0]);
  int bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1;
  UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE;

  for (i = 0; i < paramSets; i++) {
    if ((bitrate >= psTuningTable[i].bitrateFrom) &&
        (bitrate < psTuningTable[i].bitrateTo)) {
      return i;
    } else {
      if (psTuningTable[i].bitrateFrom > bitrate) {
        if (psTuningTable[i].bitrateFrom < bitRateClosestLower) {
          bitRateClosestLower = psTuningTable[i].bitrateFrom;
          bitRateClosestLowerIndex = i;
        }
      }
      if (psTuningTable[i].bitrateTo <= bitrate) {
        if (psTuningTable[i].bitrateTo > bitRateClosestUpper) {
          bitRateClosestUpper = psTuningTable[i].bitrateTo - 1;
          bitRateClosestUpperIndex = i;
        }
      }
    }
  }

  if (bitRateClosestUpperIndex >= 0) {
    return bitRateClosestUpperIndex;
  }

  if (pBitRateClosest != NULL) {
    int distanceUpper = DISTANCE_CEIL_VALUE,
        distanceLower = DISTANCE_CEIL_VALUE;
    if (bitRateClosestLowerIndex >= 0) {
      distanceLower =
          sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate;
    }
    if (bitRateClosestUpperIndex >= 0) {
      distanceUpper =
          bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo;
    }
    if (distanceUpper < distanceLower) {
      *pBitRateClosest = bitRateClosestUpper;
    } else {
      *pBitRateClosest = bitRateClosestLower;
    }
  }

  return INVALID_TABLE_IDX;
}

/***************************************************************************/
/*!

  \brief  In case of downsampled SBR we may need to lower the stop freq
          of a tuning setting to fit into the lower half of the
          spectrum ( which is sampleRate/4 )

  \return the adapted stop frequency index (-1 -> error)

  \ingroup SbrEncCfg

****************************************************************************/
static INT FDKsbrEnc_GetDownsampledStopFreq(const INT sampleRateCore,
                                            const INT startFreq, INT stopFreq,
                                            const INT downSampleFactor) {
  INT maxStopFreqRaw = sampleRateCore / 2;
  INT startBand, stopBand;
  HANDLE_ERROR_INFO err;

  while (stopFreq > 0 && FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) >
                             maxStopFreqRaw) {
    stopFreq--;
  }

  if (FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) > maxStopFreqRaw)
    return -1;

  err = FDKsbrEnc_FindStartAndStopBand(
      sampleRateCore << (downSampleFactor - 1), sampleRateCore,
      32 << (downSampleFactor - 1), startFreq, stopFreq, &startBand, &stopBand);
  if (err) return -1;

  return stopFreq;
}

/***************************************************************************/
/*!

  \brief  tells us, if for the given coreCoder, bitrate, number of channels
          and input sampling rate an SBR setting is available. If yes, it
          tells us also the core sampling rate we would need to run with

  \return a flag indicating success: yes (1) or no (0)

****************************************************************************/
static UINT FDKsbrEnc_IsSbrSettingAvail(
    UINT bitrate,           /*! the total bitrate in bits/sec */
    UINT vbrMode,           /*! the vbr paramter, 0 means constant bitrate */
    UINT numOutputChannels, /*! the number of channels for the core coder */
    UINT sampleRateInput,   /*! the input sample rate [in Hz] */
    UINT sampleRateCore,    /*! the core's sampling rate */
    AUDIO_OBJECT_TYPE core) {
  INT idx = INVALID_TABLE_IDX;

  if (sampleRateInput < 16000) return 0;

  if (bitrate == 0) {
    /* map vbr quality to bitrate */
    if (vbrMode < 30)
      bitrate = 24000;
    else if (vbrMode < 40)
      bitrate = 28000;
    else if (vbrMode < 60)
      bitrate = 32000;
    else if (vbrMode < 75)
      bitrate = 40000;
    else
      bitrate = 48000;
    bitrate *= numOutputChannels;
  }

  idx = getSbrTuningTableIndex(bitrate, numOutputChannels, sampleRateCore, core,
                               NULL);

  return (idx == INVALID_TABLE_IDX ? 0 : 1);
}

/***************************************************************************/
/*!

  \brief  Adjusts the SBR settings according to the chosen core coder
          settings which are accessible via config->codecSettings

  \return A flag indicating success: yes (1) or no (0)

****************************************************************************/
static UINT FDKsbrEnc_AdjustSbrSettings(
    const sbrConfigurationPtr config, /*! output, modified */
    UINT bitRate,                     /*! the total bitrate in bits/sec */
    UINT numChannels,                 /*! the core coder number of channels */
    UINT sampleRateCore,              /*! the core coder sampling rate in Hz */
    UINT sampleRateSbr,               /*! the sbr coder sampling rate in Hz */
    UINT transFac,                    /*! the short block to long block ratio */
    UINT standardBitrate, /*! the standard bitrate per channel in bits/sec */
    UINT vbrMode, /*! the vbr paramter, 0 poor quality .. 100 high quality*/
    UINT useSpeechConfig,   /*!< adapt tuning parameters for speech ? */
    UINT lcsMode,           /*! the low complexity stereo mode */
    UINT bParametricStereo, /*!< use parametric stereo */
    AUDIO_OBJECT_TYPE core) /* Core audio codec object type */
{
  INT idx = INVALID_TABLE_IDX;
  /* set the core codec settings */
  config->codecSettings.bitRate = bitRate;
  config->codecSettings.nChannels = numChannels;
  config->codecSettings.sampleFreq = sampleRateCore;
  config->codecSettings.transFac = transFac;
  config->codecSettings.standardBitrate = standardBitrate;

  if (bitRate < 28000) {
    config->threshold_AmpRes_FF_m = (FIXP_DBL)MAXVAL_DBL;
    config->threshold_AmpRes_FF_e = 7;
  } else if (bitRate >= 28000 && bitRate <= 48000) {
    /* The float threshold is 75
       0.524288f is fractional part of RELAXATION, the quotaMatrix and therefore
       tonality are scaled by this 2/3 is because the original implementation
       divides the tonality values by 3, here it's divided by 2 128 compensates
       the necessary shiftfactor of 7 */
    config->threshold_AmpRes_FF_m =
        FL2FXCONST_DBL(75.0f * 0.524288f / (2.0f / 3.0f) / 128.0f);
    config->threshold_AmpRes_FF_e = 7;
  } else if (bitRate > 48000) {
    config->threshold_AmpRes_FF_m = FL2FXCONST_DBL(0);
    config->threshold_AmpRes_FF_e = 0;
  }

  if (bitRate == 0) {
    /* map vbr quality to bitrate */
    if (vbrMode < 30)
      bitRate = 24000;
    else if (vbrMode < 40)
      bitRate = 28000;
    else if (vbrMode < 60)
      bitRate = 32000;
    else if (vbrMode < 75)
      bitRate = 40000;
    else
      bitRate = 48000;
    bitRate *= numChannels;
    /* fix to enable mono vbrMode<40 @ 44.1 of 48kHz */
    if (numChannels == 1) {
      if (sampleRateSbr == 44100 || sampleRateSbr == 48000) {
        if (vbrMode < 40) bitRate = 32000;
      }
    }
  }

  idx =
      getSbrTuningTableIndex(bitRate, numChannels, sampleRateCore, core, NULL);

  if (idx != INVALID_TABLE_IDX) {
    config->startFreq = sbrTuningTable[idx].startFreq;
    config->stopFreq = sbrTuningTable[idx].stopFreq;
    if (useSpeechConfig) {
      config->startFreq = sbrTuningTable[idx].startFreqSpeech;
      config->stopFreq = sbrTuningTable[idx].stopFreqSpeech;
    }

    /* Adapt stop frequency in case of downsampled SBR - only 32 bands then */
    if (1 == config->downSampleFactor) {
      INT dsStopFreq = FDKsbrEnc_GetDownsampledStopFreq(
          sampleRateCore, config->startFreq, config->stopFreq,
          config->downSampleFactor);
      if (dsStopFreq < 0) {
        return 0;
      }

      config->stopFreq = dsStopFreq;
    }

    config->sbr_noise_bands = sbrTuningTable[idx].numNoiseBands;
    if (core == AOT_ER_AAC_ELD) config->init_amp_res_FF = SBR_AMP_RES_1_5;
    config->noiseFloorOffset = sbrTuningTable[idx].noiseFloorOffset;

    config->ana_max_level = sbrTuningTable[idx].noiseMaxLevel;
    config->stereoMode = sbrTuningTable[idx].stereoMode;
    config->freqScale = sbrTuningTable[idx].freqScale;

    if (numChannels == 1) {
      /* stereo case */
      switch (core) {
        case AOT_AAC_LC:
          if (bitRate <= (useSpeechConfig ? 24000U : 20000U)) {
            config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for
                                                          non-split frames */
            config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for split
                                                          frames */
          }
          break;
        case AOT_ER_AAC_ELD:
          if (bitRate < 36000)
            config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for split
                                                          frames */
          if (bitRate < 26000) {
            config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for
                                                          non-split frames */
            config->fResTransIsLow =
                1; /* for transient frames, set low frequency resolution */
          }
          break;
        default:
          break;
      }
    } else {
      /* stereo case */
      switch (core) {
        case AOT_AAC_LC:
          if (bitRate <= 28000) {
            config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for
                                                          non-split frames */
            config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for split
                                                          frames */
          }
          break;
        case AOT_ER_AAC_ELD:
          if (bitRate < 72000) {
            config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for split
                                                          frames */
          }
          if (bitRate < 52000) {
            config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
                                                          resolution for
                                                          non-split frames */
            config->fResTransIsLow =
                1; /* for transient frames, set low frequency resolution */
          }
          break;
        default:
          break;
      }
      if (bitRate <= 28000) {
        /*
          additionally restrict frequency resolution in FIXFIX frames
          to further reduce SBR payload size */
        config->freq_res_fixfix[0] = FREQ_RES_LOW;
        config->freq_res_fixfix[1] = FREQ_RES_LOW;
      }
    }

    /* adjust usage of parametric coding dependent on bitrate and speech config
     * flag */
    if (useSpeechConfig) config->parametricCoding = 0;

    if (core == AOT_ER_AAC_ELD) {
      if (bitRate < 28000) config->init_amp_res_FF = SBR_AMP_RES_3_0;
      config->SendHeaderDataTime = -1;
    }

    if (numChannels == 1) {
      if (bitRate < 16000) {
        config->parametricCoding = 0;
      }
    } else {
      if (bitRate < 20000) {
        config->parametricCoding = 0;
      }
    }

    config->useSpeechConfig = useSpeechConfig;

    /* PS settings */
    config->bParametricStereo = bParametricStereo;

    return 1;
  } else {
    return 0;
  }
}

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

 functionname: FDKsbrEnc_InitializeSbrDefaults
 description:  initializes the SBR configuration
 returns:      error status
 input:        - core codec type,
               - factor of SBR to core frame length,
               - core frame length
 output:       initialized SBR configuration

*****************************************************************************/
static UINT FDKsbrEnc_InitializeSbrDefaults(sbrConfigurationPtr config,
                                            INT downSampleFactor,
                                            UINT codecGranuleLen,
                                            const INT isLowDelay) {
  if ((downSampleFactor < 1 || downSampleFactor > 2) ||
      (codecGranuleLen * downSampleFactor > 64 * 32))
    return (0); /* error */

  config->SendHeaderDataTime = 1000;
  config->useWaveCoding = 0;
  config->crcSbr = 0;
  config->dynBwSupported = 1;
  if (isLowDelay)
    config->tran_thr = 6000;
  else
    config->tran_thr = 13000;

  config->parametricCoding = 1;

  config->sbrFrameSize = codecGranuleLen * downSampleFactor;
  config->downSampleFactor = downSampleFactor;

  /* sbr default parameters */
  config->sbr_data_extra = 0;
  config->amp_res = SBR_AMP_RES_3_0;
  config->tran_fc = 0;
  config->tran_det_mode = 1;
  config->spread = 1;
  config->stat = 0;
  config->e = 1;
  config->deltaTAcrossFrames = 1;
  config->dF_edge_1stEnv = FL2FXCONST_DBL(0.3f);
  config->dF_edge_incr = FL2FXCONST_DBL(0.3f);

  config->sbr_invf_mode = INVF_SWITCHED;
  config->sbr_xpos_mode = XPOS_LC;
  config->sbr_xpos_ctrl = SBR_XPOS_CTRL_DEFAULT;
  config->sbr_xpos_level = 0;
  config->useSaPan = 0;
  config->dynBwEnabled = 0;

  /* the following parameters are overwritten by the
     FDKsbrEnc_AdjustSbrSettings() function since they are included in the
     tuning table */
  config->stereoMode = SBR_SWITCH_LRC;
  config->ana_max_level = 6;
  config->noiseFloorOffset = 0;
  config->startFreq = 5; /*  5.9 respectively  6.0 kHz at fs = 44.1/48 kHz */
  config->stopFreq = 9;  /* 16.2 respectively 16.8 kHz at fs = 44.1/48 kHz */
  config->freq_res_fixfix[0] = FREQ_RES_HIGH; /* non-split case */
  config->freq_res_fixfix[1] = FREQ_RES_HIGH; /* split case */
  config->fResTransIsLow = 0; /* for transient frames, set variable frequency
                                 resolution according to freqResTable */

  /* header_extra_1 */
  config->freqScale = SBR_FREQ_SCALE_DEFAULT;
  config->alterScale = SBR_ALTER_SCALE_DEFAULT;
  config->sbr_noise_bands = SBR_NOISE_BANDS_DEFAULT;

  /* header_extra_2 */
  config->sbr_limiter_bands = SBR_LIMITER_BANDS_DEFAULT;
  config->sbr_limiter_gains = SBR_LIMITER_GAINS_DEFAULT;
  config->sbr_interpol_freq = SBR_INTERPOL_FREQ_DEFAULT;
  config->sbr_smoothing_length = SBR_SMOOTHING_LENGTH_DEFAULT;

  return 1;
}

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

 functionname: DeleteEnvChannel
 description:  frees memory of one SBR channel
 returns:      -
 input:        handle of channel
 output:       released handle

*****************************************************************************/
static void deleteEnvChannel(HANDLE_ENV_CHANNEL hEnvCut) {
  if (hEnvCut) {
    FDKsbrEnc_DeleteTonCorrParamExtr(&hEnvCut->TonCorr);

    FDKsbrEnc_deleteExtractSbrEnvelope(&hEnvCut->sbrExtractEnvelope);
  }
}

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

 functionname: sbrEncoder_ChannelClose
 description:  close the channel coding handle
 returns:
 input:        phSbrChannel
 output:

*****************************************************************************/
static void sbrEncoder_ChannelClose(HANDLE_SBR_CHANNEL hSbrChannel) {
  if (hSbrChannel != NULL) {
    deleteEnvChannel(&hSbrChannel->hEnvChannel);
  }
}

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

 functionname: sbrEncoder_ElementClose
 description:  close the channel coding handle
 returns:
 input:        phSbrChannel
 output:

*****************************************************************************/
static void sbrEncoder_ElementClose(HANDLE_SBR_ELEMENT *phSbrElement) {
  HANDLE_SBR_ELEMENT hSbrElement = *phSbrElement;

  if (hSbrElement != NULL) {
    if (hSbrElement->sbrConfigData.v_k_master)
      FreeRam_Sbr_v_k_master(&hSbrElement->sbrConfigData.v_k_master);
    if (hSbrElement->sbrConfigData.freqBandTable[LO])
      FreeRam_Sbr_freqBandTableLO(
          &hSbrElement->sbrConfigData.freqBandTable[LO]);
    if (hSbrElement->sbrConfigData.freqBandTable[HI])
      FreeRam_Sbr_freqBandTableHI(
          &hSbrElement->sbrConfigData.freqBandTable[HI]);

    FreeRam_SbrElement(phSbrElement);
  }
  return;
}

void sbrEncoder_Close(HANDLE_SBR_ENCODER *phSbrEncoder) {
  HANDLE_SBR_ENCODER hSbrEncoder = *phSbrEncoder;

  if (hSbrEncoder != NULL) {
    int el, ch;

    for (el = 0; el < (8); el++) {
      if (hSbrEncoder->sbrElement[el] != NULL) {
        sbrEncoder_ElementClose(&hSbrEncoder->sbrElement[el]);
      }
    }

    /* Close sbr Channels */
    for (ch = 0; ch < (8); ch++) {
      if (hSbrEncoder->pSbrChannel[ch]) {
        sbrEncoder_ChannelClose(hSbrEncoder->pSbrChannel[ch]);
        FreeRam_SbrChannel(&hSbrEncoder->pSbrChannel[ch]);
      }

      if (hSbrEncoder->QmfAnalysis[ch].FilterStates)
        FreeRam_Sbr_QmfStatesAnalysis(
            (FIXP_QAS **)&hSbrEncoder->QmfAnalysis[ch].FilterStates);
    }

    if (hSbrEncoder->hParametricStereo)
      PSEnc_Destroy(&hSbrEncoder->hParametricStereo);
    if (hSbrEncoder->qmfSynthesisPS.FilterStates)
      FreeRam_PsQmfStatesSynthesis(
          (FIXP_DBL **)&hSbrEncoder->qmfSynthesisPS.FilterStates);

    /* Release Overlay */
    if (hSbrEncoder->pSBRdynamic_RAM)
      FreeRam_SbrDynamic_RAM((FIXP_DBL **)&hSbrEncoder->pSBRdynamic_RAM);

    FreeRam_SbrEncoder(phSbrEncoder);
  }
}

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

 functionname: updateFreqBandTable
 description:  updates vk_master
 returns:      -
 input:        config handle
 output:       error info

*****************************************************************************/
static INT updateFreqBandTable(HANDLE_SBR_CONFIG_DATA sbrConfigData,
                               HANDLE_SBR_HEADER_DATA sbrHeaderData,
                               const INT downSampleFactor) {
  INT k0, k2;

  if (FDKsbrEnc_FindStartAndStopBand(
          sbrConfigData->sampleFreq,
          sbrConfigData->sampleFreq >> (downSampleFactor - 1),
          sbrConfigData->noQmfBands, sbrHeaderData->sbr_start_frequency,
          sbrHeaderData->sbr_stop_frequency, &k0, &k2))
    return (1);

  if (FDKsbrEnc_UpdateFreqScale(
          sbrConfigData->v_k_master, &sbrConfigData->num_Master, k0, k2,
          sbrHeaderData->freqScale, sbrHeaderData->alterScale))
    return (1);

  sbrHeaderData->sbr_xover_band = 0;

  if (FDKsbrEnc_UpdateHiRes(sbrConfigData->freqBandTable[HI],
                            &sbrConfigData->nSfb[HI], sbrConfigData->v_k_master,
                            sbrConfigData->num_Master,
                            &sbrHeaderData->sbr_xover_band))
    return (1);

  FDKsbrEnc_UpdateLoRes(
      sbrConfigData->freqBandTable[LO], &sbrConfigData->nSfb[LO],
      sbrConfigData->freqBandTable[HI], sbrConfigData->nSfb[HI]);

  sbrConfigData->xOverFreq =
      (sbrConfigData->freqBandTable[LOW_RES][0] * sbrConfigData->sampleFreq /
           sbrConfigData->noQmfBands +
       1) >>
      1;

  return (0);
}

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

 functionname: resetEnvChannel
 description:  resets parameters and allocates memory
 returns:      error status
 input:
 output:       hEnv

*****************************************************************************/
static INT resetEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,
                           HANDLE_SBR_HEADER_DATA sbrHeaderData,
                           HANDLE_ENV_CHANNEL hEnv) {
  /* note !!! hEnv->encEnvData.noOfnoisebands will be updated later in function
   * FDKsbrEnc_extractSbrEnvelope !!!*/
  hEnv->TonCorr.sbrNoiseFloorEstimate.noiseBands =
      sbrHeaderData->sbr_noise_bands;

  if (FDKsbrEnc_ResetTonCorrParamExtr(
          &hEnv->TonCorr, sbrConfigData->xposCtrlSwitch,
          sbrConfigData->freqBandTable[HI][0], sbrConfigData->v_k_master,
          sbrConfigData->num_Master, sbrConfigData->sampleFreq,
          sbrConfigData->freqBandTable, sbrConfigData->nSfb,
          sbrConfigData->noQmfBands))
    return (1);

  hEnv->sbrCodeNoiseFloor.nSfb[LO] =
      hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
  hEnv->sbrCodeNoiseFloor.nSfb[HI] =
      hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;

  hEnv->sbrCodeEnvelope.nSfb[LO] = sbrConfigData->nSfb[LO];
  hEnv->sbrCodeEnvelope.nSfb[HI] = sbrConfigData->nSfb[HI];

  hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];

  hEnv->sbrCodeEnvelope.upDate = 0;
  hEnv->sbrCodeNoiseFloor.upDate = 0;

  return (0);
}

/* ****************************** FDKsbrEnc_SbrGetXOverFreq
 * ******************************/
/**
 * @fn
 * @brief       calculates the closest possible crossover frequency
 * @return      the crossover frequency SBR accepts
 *
 */
static INT FDKsbrEnc_SbrGetXOverFreq(
    HANDLE_SBR_ELEMENT hEnv, /*!< handle to SBR encoder instance */
    INT xoverFreq) /*!< from core coder suggested crossover frequency */
{
  INT band;
  INT lastDiff, newDiff;
  INT cutoffSb;

  UCHAR *RESTRICT pVKMaster = hEnv->sbrConfigData.v_k_master;

  /* Check if there is a matching cutoff frequency in the master table */
  cutoffSb = (4 * xoverFreq * hEnv->sbrConfigData.noQmfBands /
                  hEnv->sbrConfigData.sampleFreq +
              1) >>
             1;
  lastDiff = cutoffSb;
  for (band = 0; band < hEnv->sbrConfigData.num_Master; band++) {
    newDiff = fixp_abs((INT)pVKMaster[band] - cutoffSb);

    if (newDiff >= lastDiff) {
      band--;
      break;
    }

    lastDiff = newDiff;
  }

  return ((pVKMaster[band] * hEnv->sbrConfigData.sampleFreq /
               hEnv->sbrConfigData.noQmfBands +
           1) >>
          1);
}

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

 functionname: FDKsbrEnc_EnvEncodeFrame
 description: performs the sbr envelope calculation for one element
 returns:
 input:
 output:

*****************************************************************************/
INT FDKsbrEnc_EnvEncodeFrame(
    HANDLE_SBR_ENCODER hEnvEncoder, int iElement,
    INT_PCM *samples,    /*!< time samples, always deinterleaved */
    UINT samplesBufSize, /*!< time buffer channel stride */
    UINT *sbrDataBits,   /*!< Size of SBR payload  */
    UCHAR *sbrData,      /*!< SBR payload  */
    int clearOutput      /*!< Do not consider any input signal */
) {
  HANDLE_SBR_ELEMENT hSbrElement = NULL;
  FDK_CRCINFO crcInfo;
  INT crcReg;
  INT ch;
  INT band;
  INT cutoffSb;
  INT newXOver;

  if (hEnvEncoder == NULL) return -1;

  hSbrElement = hEnvEncoder->sbrElement[iElement];

  if (hSbrElement == NULL) return -1;

  /* header bitstream handling */
  HANDLE_SBR_BITSTREAM_DATA sbrBitstreamData = &hSbrElement->sbrBitstreamData;

  INT psHeaderActive = 0;
  sbrBitstreamData->HeaderActive = 0;

  /* Anticipate PS header because of internal PS bitstream delay in order to be
   * in sync with SBR header. */
  if (sbrBitstreamData->CountSendHeaderData ==
      (sbrBitstreamData->NrSendHeaderData - 1)) {
    psHeaderActive = 1;
  }

  /* Signal SBR header to be written into bitstream */
  if (sbrBitstreamData->CountSendHeaderData == 0) {
    sbrBitstreamData->HeaderActive = 1;
  }

  /* Increment header interval counter */
  if (sbrBitstreamData->NrSendHeaderData == 0) {
    sbrBitstreamData->CountSendHeaderData = 1;
  } else {
    if (sbrBitstreamData->CountSendHeaderData >= 0) {
      sbrBitstreamData->CountSendHeaderData++;
      sbrBitstreamData->CountSendHeaderData %=
          sbrBitstreamData->NrSendHeaderData;
    }
  }

  if (hSbrElement->CmonData.dynBwEnabled) {
    INT i;
    for (i = 4; i > 0; i--)
      hSbrElement->dynXOverFreqDelay[i] = hSbrElement->dynXOverFreqDelay[i - 1];

    hSbrElement->dynXOverFreqDelay[0] = hSbrElement->CmonData.dynXOverFreqEnc;
    if (hSbrElement->dynXOverFreqDelay[1] > hSbrElement->dynXOverFreqDelay[2])
      newXOver = hSbrElement->dynXOverFreqDelay[2];
    else
      newXOver = hSbrElement->dynXOverFreqDelay[1];

    /* has the crossover frequency changed? */
    if (hSbrElement->sbrConfigData.dynXOverFreq != newXOver) {
      /* get corresponding master band */
      cutoffSb = ((4 * newXOver * hSbrElement->sbrConfigData.noQmfBands /
                   hSbrElement->sbrConfigData.sampleFreq) +
                  1) >>
                 1;

      for (band = 0; band < hSbrElement->sbrConfigData.num_Master; band++) {
        if (cutoffSb == hSbrElement->sbrConfigData.v_k_master[band]) break;
      }
      FDK_ASSERT(band < hSbrElement->sbrConfigData.num_Master);

      hSbrElement->sbrConfigData.dynXOverFreq = newXOver;
      hSbrElement->sbrHeaderData.sbr_xover_band = band;
      hSbrElement->sbrBitstreamData.HeaderActive = 1;
      psHeaderActive = 1; /* ps header is one frame delayed */

      /*
        update vk_master table
      */
      if (updateFreqBandTable(&hSbrElement->sbrConfigData,
                              &hSbrElement->sbrHeaderData,
                              hEnvEncoder->downSampleFactor))
        return (1);

      /* reset SBR channels */
      INT nEnvCh = hSbrElement->sbrConfigData.nChannels;
      for (ch = 0; ch < nEnvCh; ch++) {
        if (resetEnvChannel(&hSbrElement->sbrConfigData,
                            &hSbrElement->sbrHeaderData,
                            &hSbrElement->sbrChannel[ch]->hEnvChannel))
          return (1);
      }
    }
  }

  /*
    allocate space for dummy header and crc
  */
  crcReg = FDKsbrEnc_InitSbrBitstream(
      &hSbrElement->CmonData,
      hSbrElement->payloadDelayLine[hEnvEncoder->nBitstrDelay],
      MAX_PAYLOAD_SIZE * sizeof(UCHAR), &crcInfo,
      hSbrElement->sbrConfigData.sbrSyntaxFlags);

  /* Temporal Envelope Data */
  SBR_FRAME_TEMP_DATA _fData;
  SBR_FRAME_TEMP_DATA *fData = &_fData;
  SBR_ENV_TEMP_DATA eData[MAX_NUM_CHANNELS];

  /* Init Temporal Envelope Data */
  {
    int i;

    FDKmemclear(&eData[0], sizeof(SBR_ENV_TEMP_DATA));
    FDKmemclear(&eData[1], sizeof(SBR_ENV_TEMP_DATA));
    FDKmemclear(fData, sizeof(SBR_FRAME_TEMP_DATA));

    for (i = 0; i < MAX_NUM_NOISE_VALUES; i++) fData->res[i] = FREQ_RES_HIGH;
  }

  if (!clearOutput) {
    /*
     * Transform audio data into QMF domain
     */
    for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) {
      HANDLE_ENV_CHANNEL h_envChan = &hSbrElement->sbrChannel[ch]->hEnvChannel;
      HANDLE_SBR_EXTRACT_ENVELOPE sbrExtrEnv = &h_envChan->sbrExtractEnvelope;

      if (hSbrElement->elInfo.fParametricStereo == 0) {
        QMF_SCALE_FACTOR tmpScale;
        FIXP_DBL **pQmfReal, **pQmfImag;
        C_AALLOC_SCRATCH_START(qmfWorkBuffer, FIXP_DBL, 64 * 2)

        /* Obtain pointers to QMF buffers. */
        pQmfReal = sbrExtrEnv->rBuffer;
        pQmfImag = sbrExtrEnv->iBuffer;

        qmfAnalysisFiltering(
            hSbrElement->hQmfAnalysis[ch], pQmfReal, pQmfImag, &tmpScale,
            samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize, 0,
            1, qmfWorkBuffer);

        h_envChan->qmfScale = tmpScale.lb_scale + 7;

        C_AALLOC_SCRATCH_END(qmfWorkBuffer, FIXP_DBL, 64 * 2)

      } /* fParametricStereo == 0 */

      /*
        Parametric Stereo processing
      */
      if (hSbrElement->elInfo.fParametricStereo) {
        INT error = noError;

        /* Limit Parametric Stereo to one instance */
        FDK_ASSERT(ch == 0);

        if (error == noError) {
          /* parametric stereo processing:
             - input:
               o left and right time domain samples
             - processing:
               o stereo qmf analysis
               o stereo hybrid analysis
               o ps parameter extraction
               o downmix + hybrid synthesis
             - output:
               o downmixed qmf data is written to sbrExtrEnv->rBuffer and
             sbrExtrEnv->iBuffer
          */
          SCHAR qmfScale;
          INT_PCM *pSamples[2] = {
              samples + hSbrElement->elInfo.ChannelIndex[0] * samplesBufSize,
              samples + hSbrElement->elInfo.ChannelIndex[1] * samplesBufSize};
          error = FDKsbrEnc_PSEnc_ParametricStereoProcessing(
              hEnvEncoder->hParametricStereo, pSamples, samplesBufSize,
              hSbrElement->hQmfAnalysis, sbrExtrEnv->rBuffer,
              sbrExtrEnv->iBuffer,
              samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize,
              &hEnvEncoder->qmfSynthesisPS, &qmfScale, psHeaderActive);
          h_envChan->qmfScale = (int)qmfScale;
        }

      } /* if (hEnvEncoder->hParametricStereo) */

      /*

         Extract Envelope relevant things from QMF data

      */
      FDKsbrEnc_extractSbrEnvelope1(&hSbrElement->sbrConfigData,
                                    &hSbrElement->sbrHeaderData,
                                    &hSbrElement->sbrBitstreamData, h_envChan,
                                    &hSbrElement->CmonData, &eData[ch], fData);

    } /* hEnvEncoder->sbrConfigData.nChannels */
  }

  /*
     Process Envelope relevant things and calculate envelope data and write
     payload
  */
  FDKsbrEnc_extractSbrEnvelope2(
      &hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData,
      (hSbrElement->elInfo.fParametricStereo) ? hEnvEncoder->hParametricStereo
                                              : NULL,
      &hSbrElement->sbrBitstreamData, &hSbrElement->sbrChannel[0]->hEnvChannel,
      (hSbrElement->sbrConfigData.stereoMode != SBR_MONO)
          ? &hSbrElement->sbrChannel[1]->hEnvChannel
          : NULL,
      &hSbrElement->CmonData, eData, fData, clearOutput);

  hSbrElement->sbrBitstreamData.rightBorderFIX = 0;

  /*
    format payload, calculate crc
  */
  FDKsbrEnc_AssembleSbrBitstream(&hSbrElement->CmonData, &crcInfo, crcReg,
                                 hSbrElement->sbrConfigData.sbrSyntaxFlags);

  /*
    save new payload, set to zero length if greater than MAX_PAYLOAD_SIZE
  */
  hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] =
      FDKgetValidBits(&hSbrElement->CmonData.sbrBitbuf);

  if (hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] >
      (MAX_PAYLOAD_SIZE << 3))
    hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] = 0;

  /* While filling the Delay lines, sbrData is NULL */
  if (sbrData) {
    *sbrDataBits = hSbrElement->payloadDelayLineSize[0];
    FDKmemcpy(sbrData, hSbrElement->payloadDelayLine[0],
              (hSbrElement->payloadDelayLineSize[0] + 7) >> 3);
  }

  /* delay header active flag */
  if (hSbrElement->sbrBitstreamData.HeaderActive == 1) {
    hSbrElement->sbrBitstreamData.HeaderActiveDelay =
        1 + hEnvEncoder->nBitstrDelay;
  } else {
    if (hSbrElement->sbrBitstreamData.HeaderActiveDelay > 0) {
      hSbrElement->sbrBitstreamData.HeaderActiveDelay--;
    }
  }

  return (0);
}

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

 functionname: FDKsbrEnc_Downsample
 description: performs downsampling and delay compensation of the core path
 returns:
 input:
 output:

*****************************************************************************/
INT FDKsbrEnc_Downsample(
    HANDLE_SBR_ENCODER hSbrEncoder,
    INT_PCM *samples,    /*!< time samples, always deinterleaved */
    UINT samplesBufSize, /*!< time buffer size per channel */
    UINT numChannels,    /*!< number of channels */
    UINT *sbrDataBits,   /*!< Size of SBR payload  */
    UCHAR *sbrData,      /*!< SBR payload  */
    int clearOutput      /*!< Do not consider any input signal */
) {
  HANDLE_SBR_ELEMENT hSbrElement = NULL;
  INT nOutSamples;
  int el;
  if (hSbrEncoder->downSampleFactor > 1) {
    /* Do downsampling */

    /* Loop over elements (LFE is handled later) */
    for (el = 0; el < hSbrEncoder->noElements; el++) {
      hSbrElement = hSbrEncoder->sbrElement[el];
      if (hSbrEncoder->sbrElement[el] != NULL) {
        if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) {
          int ch;
          int nChannels = hSbrElement->sbrConfigData.nChannels;

          for (ch = 0; ch < nChannels; ch++) {
            FDKaacEnc_Downsample(
                &hSbrElement->sbrChannel[ch]->downSampler,
                samples +
                    hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize +
                    hSbrEncoder->bufferOffset / numChannels,
                hSbrElement->sbrConfigData.frameSize,
                samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize,
                &nOutSamples);
          }
        }
      }
    }

    /* Handle LFE (if existing) */
    if (hSbrEncoder->lfeChIdx != -1) { /* lfe downsampler */
      FDKaacEnc_Downsample(&hSbrEncoder->lfeDownSampler,
                           samples + hSbrEncoder->lfeChIdx * samplesBufSize +
                               hSbrEncoder->bufferOffset / numChannels,
                           hSbrEncoder->frameSize,
                           samples + hSbrEncoder->lfeChIdx * samplesBufSize,
                           &nOutSamples);
    }
  } else {
    /* No downsampling. Still, some buffer shifting for correct delay */
    int samples2Copy = hSbrEncoder->frameSize;
    if (hSbrEncoder->bufferOffset / (int)numChannels < samples2Copy) {
      for (int c = 0; c < (int)numChannels; c++) {
        /* Do memmove while taking care of overlapping memory areas. (memcpy
           does not necessarily take care) Distinguish between oeverlapping and
           non overlapping version due to reasons of complexity. */
        FDKmemmove(samples + c * samplesBufSize,
                   samples + c * samplesBufSize +
                       hSbrEncoder->bufferOffset / numChannels,
                   samples2Copy * sizeof(INT_PCM));
      }
    } else {
      for (int c = 0; c < (int)numChannels; c++) {
        /* Simple memcpy since the memory areas are not overlapping */
        FDKmemcpy(samples + c * samplesBufSize,
                  samples + c * samplesBufSize +
                      hSbrEncoder->bufferOffset / numChannels,
                  samples2Copy * sizeof(INT_PCM));
      }
    }
  }

  return 0;
}

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

 functionname: createEnvChannel
 description:  initializes parameters and allocates memory
 returns:      error status
 input:
 output:       hEnv

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

static INT createEnvChannel(HANDLE_ENV_CHANNEL hEnv, INT channel,
                            UCHAR *dynamic_RAM) {
  FDKmemclear(hEnv, sizeof(struct ENV_CHANNEL));

  if (FDKsbrEnc_CreateTonCorrParamExtr(&hEnv->TonCorr, channel)) {
    return (1);
  }

  if (FDKsbrEnc_CreateExtractSbrEnvelope(&hEnv->sbrExtractEnvelope, channel,
                                         /*chan*/ 0, dynamic_RAM)) {
    return (1);
  }

  return 0;
}

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

 functionname: initEnvChannel
 description:  initializes parameters
 returns:      error status
 input:
 output:

*****************************************************************************/
static INT initEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,
                          HANDLE_SBR_HEADER_DATA sbrHeaderData,
                          HANDLE_ENV_CHANNEL hEnv, sbrConfigurationPtr params,
                          ULONG statesInitFlag, INT chanInEl,
                          UCHAR *dynamic_RAM) {
  int frameShift, tran_off = 0;
  INT e;
  INT tran_fc;
  INT timeSlots, timeStep, startIndex;
  INT noiseBands[2] = {3, 3};

  e = 1 << params->e;

  FDK_ASSERT(params->e >= 0);

  hEnv->encEnvData.freq_res_fixfix[0] = params->freq_res_fixfix[0];
  hEnv->encEnvData.freq_res_fixfix[1] = params->freq_res_fixfix[1];
  hEnv->encEnvData.fResTransIsLow = params->fResTransIsLow;

  hEnv->fLevelProtect = 0;

  hEnv->encEnvData.ldGrid =
      (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) ? 1 : 0;

  hEnv->encEnvData.sbr_xpos_mode = (XPOS_MODE)params->sbr_xpos_mode;

  if (hEnv->encEnvData.sbr_xpos_mode == XPOS_SWITCHED) {
    /*
       no other type than XPOS_MDCT or XPOS_SPEECH allowed,
       but enable switching
    */
    sbrConfigData->switchTransposers = TRUE;
    hEnv->encEnvData.sbr_xpos_mode = XPOS_MDCT;
  } else {
    sbrConfigData->switchTransposers = FALSE;
  }

  hEnv->encEnvData.sbr_xpos_ctrl = params->sbr_xpos_ctrl;

  /* extended data */
  if (params->parametricCoding) {
    hEnv->encEnvData.extended_data = 1;
  } else {
    hEnv->encEnvData.extended_data = 0;
  }

  hEnv->encEnvData.extension_size = 0;

  startIndex = QMF_FILTER_PROTOTYPE_SIZE - sbrConfigData->noQmfBands;

  switch (params->sbrFrameSize) {
    case 2304:
      timeSlots = 18;
      break;
    case 2048:
    case 1024:
    case 512:
      timeSlots = 16;
      break;
    case 1920:
    case 960:
    case 480:
      timeSlots = 15;
      break;
    case 1152:
      timeSlots = 9;
      break;
    default:
      return (1); /* Illegal frame size */
  }

  timeStep = sbrConfigData->noQmfSlots / timeSlots;

  if (FDKsbrEnc_InitTonCorrParamExtr(
          params->sbrFrameSize, &hEnv->TonCorr, sbrConfigData, timeSlots,
          params->sbr_xpos_ctrl, params->ana_max_level,
          sbrHeaderData->sbr_noise_bands, params->noiseFloorOffset,
          params->useSpeechConfig))
    return (1);

  hEnv->encEnvData.noOfnoisebands =
      hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;

  noiseBands[0] = hEnv->encEnvData.noOfnoisebands;
  noiseBands[1] = hEnv->encEnvData.noOfnoisebands;

  hEnv->encEnvData.sbr_invf_mode = (INVF_MODE)params->sbr_invf_mode;

  if (hEnv->encEnvData.sbr_invf_mode == INVF_SWITCHED) {
    hEnv->encEnvData.sbr_invf_mode = INVF_MID_LEVEL;
    hEnv->TonCorr.switchInverseFilt = TRUE;
  } else {
    hEnv->TonCorr.switchInverseFilt = FALSE;
  }

  tran_fc = params->tran_fc;

  if (tran_fc == 0) {
    tran_fc = fixMin(
        5000, FDKsbrEnc_getSbrStartFreqRAW(sbrHeaderData->sbr_start_frequency,
                                           params->codecSettings.sampleFreq));
  }

  tran_fc =
      (tran_fc * 4 * sbrConfigData->noQmfBands / sbrConfigData->sampleFreq +
       1) >>
      1;

  if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
    frameShift = LD_PRETRAN_OFF;
    tran_off = LD_PRETRAN_OFF + FRAME_MIDDLE_SLOT_512LD * timeStep;
  } else {
    frameShift = 0;
    switch (timeSlots) {
      /* The factor of 2 is by definition. */
      case NUMBER_TIME_SLOTS_2048:
        tran_off = 8 + FRAME_MIDDLE_SLOT_2048 * timeStep;
        break;
      case NUMBER_TIME_SLOTS_1920:
        tran_off = 7 + FRAME_MIDDLE_SLOT_1920 * timeStep;
        break;
      default:
        return 1;
    }
  }
  if (FDKsbrEnc_InitExtractSbrEnvelope(
          &hEnv->sbrExtractEnvelope, sbrConfigData->noQmfSlots,
          sbrConfigData->noQmfBands, startIndex, timeSlots, timeStep, tran_off,
          statesInitFlag, chanInEl, dynamic_RAM, sbrConfigData->sbrSyntaxFlags))
    return (1);

  if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeEnvelope, sbrConfigData->nSfb,
                                    params->deltaTAcrossFrames,
                                    params->dF_edge_1stEnv,
                                    params->dF_edge_incr))
    return (1);

  if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeNoiseFloor, noiseBands,
                                    params->deltaTAcrossFrames, 0, 0))
    return (1);

  sbrConfigData->initAmpResFF = params->init_amp_res_FF;

  if (FDKsbrEnc_InitSbrHuffmanTables(&hEnv->encEnvData, &hEnv->sbrCodeEnvelope,
                                     &hEnv->sbrCodeNoiseFloor,
                                     sbrHeaderData->sbr_amp_res))
    return (1);

  FDKsbrEnc_initFrameInfoGenerator(
      &hEnv->SbrEnvFrame, params->spread, e, params->stat, timeSlots,
      hEnv->encEnvData.freq_res_fixfix, hEnv->encEnvData.fResTransIsLow,
      hEnv->encEnvData.ldGrid);

  if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY)

  {
    INT bandwidth_qmf_slot =
        (sbrConfigData->sampleFreq >> 1) / (sbrConfigData->noQmfBands);
    if (FDKsbrEnc_InitSbrFastTransientDetector(
            &hEnv->sbrFastTransientDetector, sbrConfigData->noQmfSlots,
            bandwidth_qmf_slot, sbrConfigData->noQmfBands,
            sbrConfigData->freqBandTable[0][0]))
      return (1);
  }

  /* The transient detector has to be initialized also if the fast transient
     detector was active, because the values from the transient detector
     structure are used. */
  if (FDKsbrEnc_InitSbrTransientDetector(
          &hEnv->sbrTransientDetector, sbrConfigData->sbrSyntaxFlags,
          sbrConfigData->frameSize, sbrConfigData->sampleFreq, params, tran_fc,
          sbrConfigData->noQmfSlots, sbrConfigData->noQmfBands,
          hEnv->sbrExtractEnvelope.YBufferWriteOffset,
          hEnv->sbrExtractEnvelope.YBufferSzShift, frameShift, tran_off))
    return (1);

  sbrConfigData->xposCtrlSwitch = params->sbr_xpos_ctrl;

  hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];
  hEnv->encEnvData.addHarmonicFlag = 0;

  return (0);
}

INT sbrEncoder_Open(HANDLE_SBR_ENCODER *phSbrEncoder, INT nElements,
                    INT nChannels, INT supportPS) {
  INT i;
  INT errorStatus = 1;
  HANDLE_SBR_ENCODER hSbrEncoder = NULL;

  if (phSbrEncoder == NULL) {
    goto bail;
  }

  hSbrEncoder = GetRam_SbrEncoder();
  if (hSbrEncoder == NULL) {
    goto bail;
  }
  FDKmemclear(hSbrEncoder, sizeof(SBR_ENCODER));

  if (NULL ==
      (hSbrEncoder->pSBRdynamic_RAM = (UCHAR *)GetRam_SbrDynamic_RAM())) {
    goto bail;
  }
  hSbrEncoder->dynamicRam = hSbrEncoder->pSBRdynamic_RAM;

  /* Create SBR elements */
  for (i = 0; i < nElements; i++) {
    hSbrEncoder->sbrElement[i] = GetRam_SbrElement(i);
    if (hSbrEncoder->sbrElement[i] == NULL) {
      goto bail;
    }
    FDKmemclear(hSbrEncoder->sbrElement[i], sizeof(SBR_ELEMENT));
    hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] =
        GetRam_Sbr_freqBandTableLO(i);
    hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] =
        GetRam_Sbr_freqBandTableHI(i);
    hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master =
        GetRam_Sbr_v_k_master(i);
    if ((hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] == NULL) ||
        (hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] == NULL) ||
        (hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master == NULL)) {
      goto bail;
    }
  }

  /* Create SBR channels */
  for (i = 0; i < nChannels; i++) {
    hSbrEncoder->pSbrChannel[i] = GetRam_SbrChannel(i);
    if (hSbrEncoder->pSbrChannel[i] == NULL) {
      goto bail;
    }

    if (createEnvChannel(&hSbrEncoder->pSbrChannel[i]->hEnvChannel, i,
                         hSbrEncoder->dynamicRam)) {
      goto bail;
    }
  }

  /* Create QMF States */
  for (i = 0; i < fixMax(nChannels, (supportPS) ? 2 : 0); i++) {
    hSbrEncoder->QmfAnalysis[i].FilterStates = GetRam_Sbr_QmfStatesAnalysis(i);
    if (hSbrEncoder->QmfAnalysis[i].FilterStates == NULL) {
      goto bail;
    }
  }

  /* Create Parametric Stereo handle */
  if (supportPS) {
    if (PSEnc_Create(&hSbrEncoder->hParametricStereo)) {
      goto bail;
    }

    hSbrEncoder->qmfSynthesisPS.FilterStates = GetRam_PsQmfStatesSynthesis();
    if (hSbrEncoder->qmfSynthesisPS.FilterStates == NULL) {
      goto bail;
    }
  } /* supportPS */

  *phSbrEncoder = hSbrEncoder;

  errorStatus = 0;
  return errorStatus;

bail:
  /* Close SBR encoder instance */
  sbrEncoder_Close(&hSbrEncoder);
  return errorStatus;
}

static INT FDKsbrEnc_Reallocate(HANDLE_SBR_ENCODER hSbrEncoder,
                                SBR_ELEMENT_INFO elInfo[(8)],
                                const INT noElements) {
  INT totalCh = 0;
  INT totalQmf = 0;
  INT coreEl;
  INT el = -1;

  hSbrEncoder->lfeChIdx = -1; /* default value, until lfe found */

  for (coreEl = 0; coreEl < noElements; coreEl++) {
    /* SBR only handles SCE and CPE's */
    if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
      el++;
    } else {
      if (elInfo[coreEl].elType == ID_LFE) {
        hSbrEncoder->lfeChIdx = elInfo[coreEl].ChannelIndex[0];
      }
      continue;
    }

    SBR_ELEMENT_INFO *pelInfo = &elInfo[coreEl];
    HANDLE_SBR_ELEMENT hSbrElement = hSbrEncoder->sbrElement[el];

    int ch;
    for (ch = 0; ch < pelInfo->nChannelsInEl; ch++) {
      hSbrElement->sbrChannel[ch] = hSbrEncoder->pSbrChannel[totalCh];
      totalCh++;
    }
    /* analysis QMF */
    for (ch = 0;
         ch < ((pelInfo->fParametricStereo) ? 2 : pelInfo->nChannelsInEl);
         ch++) {
      hSbrElement->elInfo.ChannelIndex[ch] = pelInfo->ChannelIndex[ch];
      hSbrElement->hQmfAnalysis[ch] = &hSbrEncoder->QmfAnalysis[totalQmf++];
    }

    /* Copy Element info */
    hSbrElement->elInfo.elType = pelInfo->elType;
    hSbrElement->elInfo.instanceTag = pelInfo->instanceTag;
    hSbrElement->elInfo.nChannelsInEl = pelInfo->nChannelsInEl;
    hSbrElement->elInfo.fParametricStereo = pelInfo->fParametricStereo;
    hSbrElement->elInfo.fDualMono = pelInfo->fDualMono;
  } /* coreEl */

  return 0;
}

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

 functionname: FDKsbrEnc_bsBufInit
 description:  initializes bitstream buffer
 returns:      initialized bitstream buffer in env encoder
 input:
 output:       hEnv

*****************************************************************************/
static INT FDKsbrEnc_bsBufInit(HANDLE_SBR_ELEMENT hSbrElement,
                               int nBitstrDelay) {
  UCHAR *bitstreamBuffer;

  /* initialize the bitstream buffer */
  bitstreamBuffer = hSbrElement->payloadDelayLine[nBitstrDelay];
  FDKinitBitStream(&hSbrElement->CmonData.sbrBitbuf, bitstreamBuffer,
                   MAX_PAYLOAD_SIZE * sizeof(UCHAR), 0, BS_WRITER);

  return (0);
}

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

 functionname: FDKsbrEnc_EnvInit
 description:  initializes parameters
 returns:      error status
 input:
 output:       hEnv

*****************************************************************************/
static INT FDKsbrEnc_EnvInit(HANDLE_SBR_ELEMENT hSbrElement,
                             sbrConfigurationPtr params, INT *coreBandWith,
                             AUDIO_OBJECT_TYPE aot, int nElement,
                             const int headerPeriod, ULONG statesInitFlag,
                             const SBRENC_DS_TYPE downsamplingMethod,
                             UCHAR *dynamic_RAM) {
  int ch, i;

  if ((params->codecSettings.nChannels < 1) ||
      (params->codecSettings.nChannels > MAX_NUM_CHANNELS)) {
    return (1);
  }

  /* init and set syntax flags */
  hSbrElement->sbrConfigData.sbrSyntaxFlags = 0;

  switch (aot) {
    case AOT_ER_AAC_ELD:
      hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_LOW_DELAY;
      break;
    default:
      break;
  }
  if (params->crcSbr) {
    hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_CRC;
  }

  hSbrElement->sbrConfigData.noQmfBands = 64 >> (2 - params->downSampleFactor);
  switch (hSbrElement->sbrConfigData.noQmfBands) {
    case 64:
      hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6;
      break;
    case 32:
      hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 5;
      break;
    default:
      hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6;
      return (2);
  }

  /*
    now initialize sbrConfigData, sbrHeaderData and sbrBitstreamData,
  */
  hSbrElement->sbrConfigData.nChannels = params->codecSettings.nChannels;

  if (params->codecSettings.nChannels == 2) {
    if ((hSbrElement->elInfo.elType == ID_CPE) &&
        ((hSbrElement->elInfo.fDualMono == 1))) {
      hSbrElement->sbrConfigData.stereoMode = SBR_LEFT_RIGHT;
    } else {
      hSbrElement->sbrConfigData.stereoMode = params->stereoMode;
    }
  } else {
    hSbrElement->sbrConfigData.stereoMode = SBR_MONO;
  }

  hSbrElement->sbrConfigData.frameSize = params->sbrFrameSize;

  hSbrElement->sbrConfigData.sampleFreq =
      params->downSampleFactor * params->codecSettings.sampleFreq;

  hSbrElement->sbrBitstreamData.CountSendHeaderData = 0;
  if (params->SendHeaderDataTime > 0) {
    if (headerPeriod == -1) {
      hSbrElement->sbrBitstreamData.NrSendHeaderData = (INT)(
          params->SendHeaderDataTime * hSbrElement->sbrConfigData.sampleFreq /
          (1000 * hSbrElement->sbrConfigData.frameSize));
      hSbrElement->sbrBitstreamData.NrSendHeaderData =
          fixMax(hSbrElement->sbrBitstreamData.NrSendHeaderData, 1);
    } else {
      /* assure header period at least once per second */
      hSbrElement->sbrBitstreamData.NrSendHeaderData = fixMin(
          fixMax(headerPeriod, 1), (hSbrElement->sbrConfigData.sampleFreq /
                                    hSbrElement->sbrConfigData.frameSize));
    }
  } else {
    hSbrElement->sbrBitstreamData.NrSendHeaderData = 0;
  }

  hSbrElement->sbrHeaderData.sbr_data_extra = params->sbr_data_extra;
  hSbrElement->sbrBitstreamData.HeaderActive = 0;
  hSbrElement->sbrBitstreamData.rightBorderFIX = 0;
  hSbrElement->sbrHeaderData.sbr_start_frequency = params->startFreq;
  hSbrElement->sbrHeaderData.sbr_stop_frequency = params->stopFreq;
  hSbrElement->sbrHeaderData.sbr_xover_band = 0;
  hSbrElement->sbrHeaderData.sbr_lc_stereo_mode = 0;

  /* data_extra */
  if (params->sbr_xpos_ctrl != SBR_XPOS_CTRL_DEFAULT)
    hSbrElement->sbrHeaderData.sbr_data_extra = 1;

  hSbrElement->sbrHeaderData.sbr_amp_res = (AMP_RES)params->amp_res;

  /* header_extra_1 */
  hSbrElement->sbrHeaderData.freqScale = params->freqScale;
  hSbrElement->sbrHeaderData.alterScale = params->alterScale;
  hSbrElement->sbrHeaderData.sbr_noise_bands = params->sbr_noise_bands;
  hSbrElement->sbrHeaderData.header_extra_1 = 0;

  if ((params->freqScale != SBR_FREQ_SCALE_DEFAULT) ||
      (params->alterScale != SBR_ALTER_SCALE_DEFAULT) ||
      (params->sbr_noise_bands != SBR_NOISE_BANDS_DEFAULT)) {
    hSbrElement->sbrHeaderData.header_extra_1 = 1;
  }

  /* header_extra_2 */
  hSbrElement->sbrHeaderData.sbr_limiter_bands = params->sbr_limiter_bands;
  hSbrElement->sbrHeaderData.sbr_limiter_gains = params->sbr_limiter_gains;

  if ((hSbrElement->sbrConfigData.sampleFreq > 48000) &&
      (hSbrElement->sbrHeaderData.sbr_start_frequency >= 9)) {
    hSbrElement->sbrHeaderData.sbr_limiter_gains = SBR_LIMITER_GAINS_INFINITE;
  }

  hSbrElement->sbrHeaderData.sbr_interpol_freq = params->sbr_interpol_freq;
  hSbrElement->sbrHeaderData.sbr_smoothing_length =
      params->sbr_smoothing_length;
  hSbrElement->sbrHeaderData.header_extra_2 = 0;

  if ((params->sbr_limiter_bands != SBR_LIMITER_BANDS_DEFAULT) ||
      (params->sbr_limiter_gains != SBR_LIMITER_GAINS_DEFAULT) ||
      (params->sbr_interpol_freq != SBR_INTERPOL_FREQ_DEFAULT) ||
      (params->sbr_smoothing_length != SBR_SMOOTHING_LENGTH_DEFAULT)) {
    hSbrElement->sbrHeaderData.header_extra_2 = 1;
  }

  /* other switches */
  hSbrElement->sbrConfigData.useWaveCoding = params->useWaveCoding;
  hSbrElement->sbrConfigData.useParametricCoding = params->parametricCoding;
  hSbrElement->sbrConfigData.thresholdAmpResFF_m =
      params->threshold_AmpRes_FF_m;
  hSbrElement->sbrConfigData.thresholdAmpResFF_e =
      params->threshold_AmpRes_FF_e;

  /* init freq band table */
  if (updateFreqBandTable(&hSbrElement->sbrConfigData,
                          &hSbrElement->sbrHeaderData,
                          params->downSampleFactor)) {
    return (1);
  }

  /* now create envelope ext and QMF for each available channel */
  for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) {
    if (initEnvChannel(&hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData,
                       &hSbrElement->sbrChannel[ch]->hEnvChannel, params,
                       statesInitFlag, ch, dynamic_RAM)) {
      return (1);
    }

  } /* nChannels */

  /* reset and intialize analysis qmf */
  for (ch = 0; ch < ((hSbrElement->elInfo.fParametricStereo)
                         ? 2
                         : hSbrElement->sbrConfigData.nChannels);
       ch++) {
    int err;
    UINT qmfFlags =
        (hSbrElement->sbrConfigData.sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY)
            ? QMF_FLAG_CLDFB
            : 0;
    if (statesInitFlag)
      qmfFlags &= ~QMF_FLAG_KEEP_STATES;
    else
      qmfFlags |= QMF_FLAG_KEEP_STATES;

    err = qmfInitAnalysisFilterBank(
        hSbrElement->hQmfAnalysis[ch],
        (FIXP_QAS *)hSbrElement->hQmfAnalysis[ch]->FilterStates,
        hSbrElement->sbrConfigData.noQmfSlots,
        hSbrElement->sbrConfigData.noQmfBands,
        hSbrElement->sbrConfigData.noQmfBands,
        hSbrElement->sbrConfigData.noQmfBands, qmfFlags);
    if (0 != err) {
      return err;
    }
  }

  /*  */
  hSbrElement->CmonData.xOverFreq = hSbrElement->sbrConfigData.xOverFreq;
  hSbrElement->CmonData.dynBwEnabled =
      (params->dynBwSupported && params->dynBwEnabled);
  hSbrElement->CmonData.dynXOverFreqEnc =
      FDKsbrEnc_SbrGetXOverFreq(hSbrElement, hSbrElement->CmonData.xOverFreq);
  for (i = 0; i < 5; i++)
    hSbrElement->dynXOverFreqDelay[i] = hSbrElement->CmonData.dynXOverFreqEnc;
  hSbrElement->CmonData.sbrNumChannels = hSbrElement->sbrConfigData.nChannels;
  hSbrElement->sbrConfigData.dynXOverFreq = hSbrElement->CmonData.xOverFreq;

  /* Update Bandwith to be passed to the core encoder */
  *coreBandWith = hSbrElement->CmonData.xOverFreq;

  return (0);
}

INT sbrEncoder_GetInBufferSize(int noChannels) {
  INT temp;

  temp = (2048);
  temp += 1024 + MAX_SAMPLE_DELAY;
  temp *= noChannels;
  temp *= sizeof(INT_PCM);
  return temp;
}

/*
 * Encode Dummy SBR payload frames to fill the delay lines.
 */
static INT FDKsbrEnc_DelayCompensation(HANDLE_SBR_ENCODER hEnvEnc,
                                       INT_PCM *timeBuffer,
                                       UINT timeBufferBufSize) {
  int n, el;

  for (n = hEnvEnc->nBitstrDelay; n > 0; n--) {
    for (el = 0; el < hEnvEnc->noElements; el++) {
      if (FDKsbrEnc_EnvEncodeFrame(
              hEnvEnc, el,
              timeBuffer + hEnvEnc->downsampledOffset / hEnvEnc->nChannels,
              timeBufferBufSize, NULL, NULL, 1))
        return -1;
    }
    sbrEncoder_UpdateBuffers(hEnvEnc, timeBuffer, timeBufferBufSize);
  }
  return 0;
}

UINT sbrEncoder_LimitBitRate(UINT bitRate, UINT numChannels,
                             UINT coreSampleRate, AUDIO_OBJECT_TYPE aot) {
  UINT newBitRate = bitRate;
  INT index;

  FDK_ASSERT(numChannels > 0 && numChannels <= 2);
  if (aot == AOT_PS) {
    if (numChannels == 1) {
      index = getPsTuningTableIndex(bitRate, &newBitRate);
      if (index == INVALID_TABLE_IDX) {
        bitRate = newBitRate;
      }
    } else {
      return 0;
    }
  }
  index = getSbrTuningTableIndex(bitRate, numChannels, coreSampleRate, aot,
                                 &newBitRate);
  if (index != INVALID_TABLE_IDX) {
    newBitRate = bitRate;
  }

  return newBitRate;
}

UINT sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot) {
  UINT isPossible = (AOT_PS == aot) ? 0 : 1;
  return isPossible;
}

/*****************************************************************************/
/*                                                                           */
/*functionname: sbrEncoder_Init_delay                                        */
/*description:  Determine Delay balancing and new encoder delay              */
/*                                                                           */
/*returns:      - error status                                               */
/*input:        - frame length of the core (i.e. e.g. AAC)                   */
/*              - number of channels                                         */
/*              - downsample factor (1 for downsampled, 2 for dual-rate SBR) */
/*              - low delay presence                                         */
/*              - ps presence                                                */
/*              - downsampling method: QMF-, time domain or no downsampling  */
/*              - various delay values (see DELAY_PARAM struct description)  */
/*                                                                           */
/*Example: Delay balancing for a HE-AACv1 encoder (time-domain downsampling) */
/*========================================================================== */
/*                                                                           */
/*    +--------+            +--------+ +--------+ +--------+ +--------+      */
/*    |core    |            |ds 2:1  | |AAC     | |QMF     | |QMF     |      */
/*  +-+path    +------------+        +-+core    +-+analysis+-+overlap +-+    */
/*  | |offset  |            |        | |        | |32 bands| |        | |    */
/*  | +--------+            +--------+ +--------+ +--------+ +--------+ |    */
/*  |                              core path                    +-------++   */
/*  |                                                           |QMF     |   */
/*->+                                                           +synth.  +-> */
/*  |                                                           |64 bands|   */
/*  |                                                           +-------++   */
/*  | +--------+ +--------+ +--------+ +--------+                       |    */
/*  | |SBR path| |QMF     | |subband | |bs delay|                       |    */
/*  +-+offset  +-+analysis+-+sample  +-+(full   +-----------------------+    */
/*    |        | |64 bands| |buffer  | | frames)|                            */
/*    +--------+ +--------+ +--------+ +--------+                            */
/*                                 SBR path                                  */
/*                                                                           */
/*****************************************************************************/
static INT sbrEncoder_Init_delay(
    const int coreFrameLength,               /* input */
    const int numChannels,                   /* input */
    const int downSampleFactor,              /* input */
    const int lowDelay,                      /* input */
    const int usePs,                         /* input */
    const int is212,                         /* input */
    const SBRENC_DS_TYPE downsamplingMethod, /* input */
    DELAY_PARAM *hDelayParam                 /* input/output */
) {
  int delayCorePath = 0;   /* delay in core path */
  int delaySbrPath = 0;    /* delay difference in QMF aka SBR path */
  int delayInput2Core = 0; /* delay from the input to the core */
  int delaySbrDec = 0;     /* delay of the decoder's SBR module */

  int delayCore = hDelayParam->delay; /* delay of the core */

  /* Added delay by the SBR delay initialization */
  int corePathOffset = 0; /* core path */
  int sbrPathOffset = 0;  /* sbr path */
  int bitstreamDelay = 0; /* sbr path, framewise */

  int flCore = coreFrameLength; /* core frame length */

  int returnValue = 0; /* return value - 0 means: no error */

  /* 1) Calculate actual delay  for core and SBR path */
  if (is212) {
    delayCorePath = DELAY_COREPATH_ELDv2SBR(flCore, downSampleFactor);
    delaySbrPath = DELAY_ELDv2SBR(flCore, downSampleFactor);
    delaySbrDec = ((flCore) / 2) * (downSampleFactor);
  } else if (lowDelay) {
    delayCorePath = DELAY_COREPATH_ELDSBR(flCore, downSampleFactor);
    delaySbrPath = DELAY_ELDSBR(flCore, downSampleFactor);
    delaySbrDec = DELAY_QMF_POSTPROC(downSampleFactor);
  } else if (usePs) {
    delayCorePath = DELAY_COREPATH_PS(flCore, downSampleFactor);
    delaySbrPath = DELAY_PS(flCore, downSampleFactor);
    delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor);
  } else {
    delayCorePath = DELAY_COREPATH_SBR(flCore, downSampleFactor);
    delaySbrPath = DELAY_SBR(flCore, downSampleFactor);
    delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor);
  }
  delayCorePath += delayCore * downSampleFactor;
  delayCorePath +=
      (downsamplingMethod == SBRENC_DS_TIME) ? hDelayParam->dsDelay : 0;

  /* 2) Manage coupling of paths */
  if (downsamplingMethod == SBRENC_DS_QMF && delayCorePath > delaySbrPath) {
    /* In case of QMF downsampling, both paths are coupled, i.e. the SBR path
       offset would be added to both the SBR path and to the core path
       as well, thus making it impossible to achieve delay balancing.
       To overcome that problem, a framewise delay is added to the SBR path
       first, until the overall delay of the core path is shorter than
       the delay of the SBR path. When this is achieved, the missing delay
       difference can be added as downsampled offset to the core path.
    */
    while (delayCorePath > delaySbrPath) {
      /* Add one frame delay to SBR path */
      delaySbrPath += flCore * downSampleFactor;
      bitstreamDelay += 1;
    }
  }

  /* 3) Calculate necessary additional delay to balance the paths */
  if (delayCorePath > delaySbrPath) {
    /* Delay QMF input */
    while (delayCorePath > delaySbrPath + (int)flCore * (int)downSampleFactor) {
      /* Do bitstream frame-wise delay balancing if there are
         more than SBR framelength samples delay difference */
      delaySbrPath += flCore * downSampleFactor;
      bitstreamDelay += 1;
    }
    /* Multiply input offset by input channels */
    corePathOffset = 0;
    sbrPathOffset = (delayCorePath - delaySbrPath) * numChannels;
  } else {
    /* Delay AAC data */
    /* Multiply downsampled offset by AAC core channels. Divide by 2 because of
       half samplerate of downsampled data. */
    corePathOffset = ((delaySbrPath - delayCorePath) * numChannels) >>
                     (downSampleFactor - 1);
    sbrPathOffset = 0;
  }

  /* 4) Calculate delay from input to core */
  if (usePs) {
    delayInput2Core =
        (DELAY_QMF_ANA(downSampleFactor) + DELAY_QMF_DS + DELAY_HYB_SYN) +
        (downSampleFactor * corePathOffset) + 1;
  } else if (downsamplingMethod == SBRENC_DS_TIME) {
    delayInput2Core = corePathOffset + hDelayParam->dsDelay;
  } else {
    delayInput2Core = corePathOffset;
  }

  /* 6) Set output parameters */
  hDelayParam->delay = FDKmax(delayCorePath, delaySbrPath); /* overall delay */
  hDelayParam->sbrDecDelay = delaySbrDec;         /* SBR decoder delay */
  hDelayParam->delayInput2Core = delayInput2Core; /* delay input - core */
  hDelayParam->bitstrDelay = bitstreamDelay;    /* bitstream delay, in frames */
  hDelayParam->corePathOffset = corePathOffset; /* offset added to core path */
  hDelayParam->sbrPathOffset = sbrPathOffset;   /* offset added to SBR path */

  return returnValue;
}

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

 functionname: sbrEncoder_Init
 description:  initializes the SBR encoder
 returns:      error status

*****************************************************************************/
INT sbrEncoder_Init(HANDLE_SBR_ENCODER hSbrEncoder,
                    SBR_ELEMENT_INFO elInfo[(8)], int noElements,
                    INT_PCM *inputBuffer, UINT inputBufferBufSize,
                    INT *coreBandwidth, INT *inputBufferOffset,
                    INT *numChannels, const UINT syntaxFlags,
                    INT *coreSampleRate, UINT *downSampleFactor,
                    INT *frameLength, AUDIO_OBJECT_TYPE aot, int *delay,
                    int transformFactor, const int headerPeriod,
                    ULONG statesInitFlag) {
  HANDLE_ERROR_INFO errorInfo = noError;
  sbrConfiguration sbrConfig[(8)];
  INT error = 0;
  INT lowestBandwidth;
  /* Save input parameters */
  INT inputSampleRate = *coreSampleRate;
  int coreFrameLength = *frameLength;
  int inputBandWidth = *coreBandwidth;
  int inputChannels = *numChannels;

  SBRENC_DS_TYPE downsamplingMethod = SBRENC_DS_NONE;
  int highestSbrStartFreq, highestSbrStopFreq;
  int lowDelay = 0;
  int usePs = 0;
  int is212 = 0;

  DELAY_PARAM delayParam;

  /* check whether SBR setting is available for the current encoder
   * configuration (bitrate, samplerate) */
  if (!sbrEncoder_IsSingleRatePossible(aot)) {
    *downSampleFactor = 2;
  }

  if (aot == AOT_PS) {
    usePs = 1;
  }
  if (aot == AOT_ER_AAC_ELD) {
    lowDelay = 1;
  } else if (aot == AOT_ER_AAC_LD) {
    error = 1;
    goto bail;
  }

  /* Parametric Stereo */
  if (usePs) {
    if (*numChannels == 2 && noElements == 1) {
      /* Override Element type in case of Parametric stereo */
      elInfo[0].elType = ID_SCE;
      elInfo[0].fParametricStereo = 1;
      elInfo[0].nChannelsInEl = 1;
      /* core encoder gets downmixed mono signal */
      *numChannels = 1;
    } else {
      error = 1;
      goto bail;
    }
  } /* usePs */

  /* set the core's sample rate */
  switch (*downSampleFactor) {
    case 1:
      *coreSampleRate = inputSampleRate;
      downsamplingMethod = SBRENC_DS_NONE;
      break;
    case 2:
      *coreSampleRate = inputSampleRate >> 1;
      downsamplingMethod = usePs ? SBRENC_DS_QMF : SBRENC_DS_TIME;
      break;
    default:
      *coreSampleRate = inputSampleRate >> 1;
      return 0; /* return error */
  }

  /* check whether SBR setting is available for the current encoder
   * configuration (bitrate, coreSampleRate) */
  {
    int el, coreEl;

    /* Check if every element config is feasible */
    for (coreEl = 0; coreEl < noElements; coreEl++) {
      /* SBR only handles SCE and CPE's */
      if (elInfo[coreEl].elType != ID_SCE && elInfo[coreEl].elType != ID_CPE) {
        continue;
      }
      /* check if desired configuration is available */
      if (!FDKsbrEnc_IsSbrSettingAvail(elInfo[coreEl].bitRate, 0,
                                       elInfo[coreEl].nChannelsInEl,
                                       inputSampleRate, *coreSampleRate, aot)) {
        error = 1;
        goto bail;
      }
    }

    hSbrEncoder->nChannels = *numChannels;
    hSbrEncoder->frameSize = coreFrameLength * *downSampleFactor;
    hSbrEncoder->downsamplingMethod = downsamplingMethod;
    hSbrEncoder->downSampleFactor = *downSampleFactor;
    hSbrEncoder->estimateBitrate = 0;
    hSbrEncoder->inputDataDelay = 0;
    is212 = ((aot == AOT_ER_AAC_ELD) && (syntaxFlags & AC_LD_MPS)) ? 1 : 0;

    /* Open SBR elements */
    el = -1;
    highestSbrStartFreq = highestSbrStopFreq = 0;
    lowestBandwidth = 99999;

    /* Loop through each core encoder element and get a matching SBR element
     * config */
    for (coreEl = 0; coreEl < noElements; coreEl++) {
      /* SBR only handles SCE and CPE's */
      if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
        el++;
      } else {
        continue;
      }

      /* Set parametric Stereo Flag. */
      if (usePs) {
        elInfo[coreEl].fParametricStereo = 1;
      } else {
        elInfo[coreEl].fParametricStereo = 0;
      }

      /*
       * Init sbrConfig structure
       */
      if (!FDKsbrEnc_InitializeSbrDefaults(&sbrConfig[el], *downSampleFactor,
                                           coreFrameLength, IS_LOWDELAY(aot))) {
        error = 1;
        goto bail;
      }

      /*
       * Modify sbrConfig structure according to Element parameters
       */
      if (!FDKsbrEnc_AdjustSbrSettings(
              &sbrConfig[el], elInfo[coreEl].bitRate,
              elInfo[coreEl].nChannelsInEl, *coreSampleRate, inputSampleRate,
              transformFactor, 24000, 0, 0, /* useSpeechConfig */
              0,                            /* lcsMode */
              usePs,                        /* bParametricStereo */
              aot)) {
        error = 1;
        goto bail;
      }

      /* Find common frequency border for all SBR elements */
      highestSbrStartFreq =
          fixMax(highestSbrStartFreq, sbrConfig[el].startFreq);
      highestSbrStopFreq = fixMax(highestSbrStopFreq, sbrConfig[el].stopFreq);

    } /* first element loop */

    /* Set element count (can be less than core encoder element count) */
    hSbrEncoder->noElements = el + 1;

    FDKsbrEnc_Reallocate(hSbrEncoder, elInfo, noElements);

    for (el = 0; el < hSbrEncoder->noElements; el++) {
      int bandwidth = *coreBandwidth;

      /* Use lowest common bandwidth */
      sbrConfig[el].startFreq = highestSbrStartFreq;
      sbrConfig[el].stopFreq = highestSbrStopFreq;

      /* initialize SBR element, and get core bandwidth */
      error = FDKsbrEnc_EnvInit(hSbrEncoder->sbrElement[el], &sbrConfig[el],
                                &bandwidth, aot, el, headerPeriod,
                                statesInitFlag, hSbrEncoder->downsamplingMethod,
                                hSbrEncoder->dynamicRam);

      if (error != 0) {
        error = 2;
        goto bail;
      }

      /* Get lowest core encoder bandwidth to be returned later. */
      lowestBandwidth = fixMin(lowestBandwidth, bandwidth);

    } /* second element loop */

    /* Initialize a downsampler for each channel in each SBR element */
    if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) {
      for (el = 0; el < hSbrEncoder->noElements; el++) {
        HANDLE_SBR_ELEMENT hSbrEl = hSbrEncoder->sbrElement[el];
        INT Wc, ch;

        Wc = 500; /* Cutoff frequency with full bandwidth */

        for (ch = 0; ch < hSbrEl->elInfo.nChannelsInEl; ch++) {
          FDKaacEnc_InitDownsampler(&hSbrEl->sbrChannel[ch]->downSampler, Wc,
                                    *downSampleFactor);
          FDK_ASSERT(hSbrEl->sbrChannel[ch]->downSampler.delay <=
                     MAX_DS_FILTER_DELAY);
        }
      } /* third element loop */

      /* lfe */
      FDKaacEnc_InitDownsampler(&hSbrEncoder->lfeDownSampler, 0,
                                *downSampleFactor);
    }

    /* Get delay information */
    delayParam.dsDelay =
        hSbrEncoder->sbrElement[0]->sbrChannel[0]->downSampler.delay;
    delayParam.delay = *delay;

    error = sbrEncoder_Init_delay(coreFrameLength, *numChannels,
                                  *downSampleFactor, lowDelay, usePs, is212,
                                  downsamplingMethod, &delayParam);

    if (error != 0) {
      error = 3;
      goto bail;
    }

    hSbrEncoder->nBitstrDelay = delayParam.bitstrDelay;
    hSbrEncoder->sbrDecDelay = delayParam.sbrDecDelay;
    hSbrEncoder->inputDataDelay = delayParam.delayInput2Core;

    /* Assign core encoder Bandwidth */
    *coreBandwidth = lowestBandwidth;

    /* Estimate sbr bitrate, 2.5 kBit/s per sbr channel */
    hSbrEncoder->estimateBitrate += 2500 * (*numChannels);

    /* Initialize bitstream buffer for each element */
    for (el = 0; el < hSbrEncoder->noElements; el++) {
      FDKsbrEnc_bsBufInit(hSbrEncoder->sbrElement[el], delayParam.bitstrDelay);
    }

    /* initialize parametric stereo */
    if (usePs) {
      PSENC_CONFIG psEncConfig;
      FDK_ASSERT(hSbrEncoder->noElements == 1);
      INT psTuningTableIdx = getPsTuningTableIndex(elInfo[0].bitRate, NULL);

      psEncConfig.frameSize = coreFrameLength;  // sbrConfig.sbrFrameSize;
      psEncConfig.qmfFilterMode = 0;
      psEncConfig.sbrPsDelay = 0;

      /* tuning parameters */
      if (psTuningTableIdx != INVALID_TABLE_IDX) {
        psEncConfig.nStereoBands = psTuningTable[psTuningTableIdx].nStereoBands;
        psEncConfig.maxEnvelopes = psTuningTable[psTuningTableIdx].nEnvelopes;
        psEncConfig.iidQuantErrorThreshold =
            (FIXP_DBL)psTuningTable[psTuningTableIdx].iidQuantErrorThreshold;

        /* calculation is not quite linear, increased number of envelopes causes
         * more bits */
        /* assume avg. 50 bits per frame for 10 stereo bands / 1 envelope
         * configuration */
        hSbrEncoder->estimateBitrate +=
            ((((*coreSampleRate) * 5 * psEncConfig.nStereoBands *
               psEncConfig.maxEnvelopes) /
              hSbrEncoder->frameSize));

      } else {
        error = ERROR(CDI, "Invalid ps tuning table index.");
        goto bail;
      }

      qmfInitSynthesisFilterBank(
          &hSbrEncoder->qmfSynthesisPS,
          (FIXP_DBL *)hSbrEncoder->qmfSynthesisPS.FilterStates,
          hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
          hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
          hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
          hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
          (statesInitFlag) ? 0 : QMF_FLAG_KEEP_STATES);

      if (errorInfo == noError) {
        /* update delay */
        psEncConfig.sbrPsDelay =
            FDKsbrEnc_GetEnvEstDelay(&hSbrEncoder->sbrElement[0]
                                          ->sbrChannel[0]
                                          ->hEnvChannel.sbrExtractEnvelope);

        errorInfo =
            PSEnc_Init(hSbrEncoder->hParametricStereo, &psEncConfig,
                       hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
                       hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands,
                       hSbrEncoder->dynamicRam);
      }
    }

    hSbrEncoder->downsampledOffset = delayParam.corePathOffset;
    hSbrEncoder->bufferOffset = delayParam.sbrPathOffset;
    *delay = delayParam.delay;

    { hSbrEncoder->downmixSize = coreFrameLength * (*numChannels); }

    /* Delay Compensation: fill bitstream delay buffer with zero input signal */
    if (hSbrEncoder->nBitstrDelay > 0) {
      error = FDKsbrEnc_DelayCompensation(hSbrEncoder, inputBuffer,
                                          inputBufferBufSize);
      if (error != 0) goto bail;
    }

    /* Set Output frame length */
    *frameLength = coreFrameLength * *downSampleFactor;
    /* Input buffer offset */
    *inputBufferOffset =
        fixMax(delayParam.sbrPathOffset, delayParam.corePathOffset);
  }

  return error;

bail:
  /* Restore input settings */
  *coreSampleRate = inputSampleRate;
  *frameLength = coreFrameLength;
  *numChannels = inputChannels;
  *coreBandwidth = inputBandWidth;

  return error;
}

INT sbrEncoder_EncodeFrame(HANDLE_SBR_ENCODER hSbrEncoder, INT_PCM *samples,
                           UINT samplesBufSize, UINT sbrDataBits[(8)],
                           UCHAR sbrData[(8)][MAX_PAYLOAD_SIZE]) {
  INT error;
  int el;

  for (el = 0; el < hSbrEncoder->noElements; el++) {
    if (hSbrEncoder->sbrElement[el] != NULL) {
      error = FDKsbrEnc_EnvEncodeFrame(
          hSbrEncoder, el,
          samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels,
          samplesBufSize, &sbrDataBits[el], sbrData[el], 0);
      if (error) return error;
    }
  }

  error = FDKsbrEnc_Downsample(
      hSbrEncoder,
      samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels,
      samplesBufSize, hSbrEncoder->nChannels, &sbrDataBits[el], sbrData[el], 0);
  if (error) return error;

  return 0;
}

INT sbrEncoder_UpdateBuffers(HANDLE_SBR_ENCODER hSbrEncoder,
                             INT_PCM *timeBuffer, UINT timeBufferBufSize) {
  if (hSbrEncoder->downsampledOffset > 0) {
    int c;
    int nd = hSbrEncoder->downmixSize / hSbrEncoder->nChannels;

    for (c = 0; c < hSbrEncoder->nChannels; c++) {
      /* Move delayed downsampled data */
      FDKmemcpy(timeBuffer + timeBufferBufSize * c,
                timeBuffer + timeBufferBufSize * c + nd,
                sizeof(INT_PCM) *
                    (hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels));
    }
  } else {
    int c;

    for (c = 0; c < hSbrEncoder->nChannels; c++) {
      /* Move delayed input data */
      FDKmemcpy(
          timeBuffer + timeBufferBufSize * c,
          timeBuffer + timeBufferBufSize * c + hSbrEncoder->frameSize,
          sizeof(INT_PCM) * hSbrEncoder->bufferOffset / hSbrEncoder->nChannels);
    }
  }
  if (hSbrEncoder->nBitstrDelay > 0) {
    int el;

    for (el = 0; el < hSbrEncoder->noElements; el++) {
      FDKmemmove(
          hSbrEncoder->sbrElement[el]->payloadDelayLine[0],
          hSbrEncoder->sbrElement[el]->payloadDelayLine[1],
          sizeof(UCHAR) * (hSbrEncoder->nBitstrDelay * MAX_PAYLOAD_SIZE));

      FDKmemmove(&hSbrEncoder->sbrElement[el]->payloadDelayLineSize[0],
                 &hSbrEncoder->sbrElement[el]->payloadDelayLineSize[1],
                 sizeof(UINT) * (hSbrEncoder->nBitstrDelay));
    }
  }
  return 0;
}

INT sbrEncoder_SendHeader(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT error = -1;
  if (hSbrEncoder) {
    int el;
    for (el = 0; el < hSbrEncoder->noElements; el++) {
      if ((hSbrEncoder->noElements == 1) &&
          (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) {
        hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData =
            hSbrEncoder->sbrElement[el]->sbrBitstreamData.NrSendHeaderData - 1;
      } else {
        hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData = 0;
      }
    }
    error = 0;
  }
  return error;
}

INT sbrEncoder_ContainsHeader(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT sbrHeader = 1;
  if (hSbrEncoder) {
    int el;
    for (el = 0; el < hSbrEncoder->noElements; el++) {
      sbrHeader &=
          (hSbrEncoder->sbrElement[el]->sbrBitstreamData.HeaderActiveDelay == 1)
              ? 1
              : 0;
    }
  }
  return sbrHeader;
}

INT sbrEncoder_GetHeaderDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT delay = -1;

  if (hSbrEncoder) {
    if ((hSbrEncoder->noElements == 1) &&
        (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) {
      delay = hSbrEncoder->nBitstrDelay + 1;
    } else {
      delay = hSbrEncoder->nBitstrDelay;
    }
  }
  return delay;
}
INT sbrEncoder_GetBsDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT delay = -1;

  if (hSbrEncoder) {
    delay = hSbrEncoder->nBitstrDelay;
  }
  return delay;
}

INT sbrEncoder_SAPPrepare(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT error = -1;
  if (hSbrEncoder) {
    int el;
    for (el = 0; el < hSbrEncoder->noElements; el++) {
      hSbrEncoder->sbrElement[el]->sbrBitstreamData.rightBorderFIX = 1;
    }
    error = 0;
  }
  return error;
}

INT sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT estimateBitrate = 0;

  if (hSbrEncoder) {
    estimateBitrate += hSbrEncoder->estimateBitrate;
  }

  return estimateBitrate;
}

INT sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT delay = -1;

  if (hSbrEncoder) {
    delay = hSbrEncoder->inputDataDelay;
  }
  return delay;
}

INT sbrEncoder_GetSbrDecDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
  INT delay = -1;

  if (hSbrEncoder) {
    delay = hSbrEncoder->sbrDecDelay;
  }
  return delay;
}

INT sbrEncoder_GetLibInfo(LIB_INFO *info) {
  int i;

  if (info == NULL) {
    return -1;
  }
  /* search for next free tab */
  for (i = 0; i < FDK_MODULE_LAST; i++) {
    if (info[i].module_id == FDK_NONE) break;
  }
  if (i == FDK_MODULE_LAST) {
    return -1;
  }
  info += i;

  info->module_id = FDK_SBRENC;
  info->version =
      LIB_VERSION(SBRENCODER_LIB_VL0, SBRENCODER_LIB_VL1, SBRENCODER_LIB_VL2);
  LIB_VERSION_STRING(info);
#ifdef __ANDROID__
  info->build_date = "";
  info->build_time = "";
#else
  info->build_date = __DATE__;
  info->build_time = __TIME__;
#endif
  info->title = "SBR Encoder";

  /* Set flags */
  info->flags = 0 | CAPF_SBR_HQ | CAPF_SBR_PS_MPEG;
  /* End of flags */

  return 0;
}
