/* -----------------------------------------------------------------------------
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 decoder library ******************************

   Author(s):

   Description:

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

/*!
  \file
  \brief  Envelope extraction
  The functions provided by this module are mostly called by applySBR(). After
  it is determined that there is valid SBR data, sbrGetHeaderData() might be
  called if the current SBR data contains an \ref SBR_HEADER_ELEMENT as opposed
  to a \ref SBR_STANDARD_ELEMENT. This function may return various error codes
  as defined in #SBR_HEADER_STATUS . Most importantly it returns HEADER_RESET
  when decoder settings need to be recalculated according to the SBR
  specifications. In that case applySBR() will initiatite the required
  re-configuration.

  The header data is stored in a #SBR_HEADER_DATA structure.

  The actual SBR data for the current frame is decoded into SBR_FRAME_DATA
  stuctures by sbrGetChannelPairElement() [for stereo streams] and
  sbrGetSingleChannelElement() [for mono streams]. There is no fractional
  arithmetic involved.

  Once the information is extracted, the data needs to be further prepared
  before the actual decoding process. This is done in decodeSbrData().

  \sa Description of buffer management in applySBR(). \ref documentationOverview

  <h1>About the SBR data format:</h1>

  Each frame includes SBR data (side chain information), and can be either the
  \ref SBR_HEADER_ELEMENT or the \ref SBR_STANDARD_ELEMENT. Parts of the data
  can be protected by a CRC checksum.

  \anchor SBR_HEADER_ELEMENT <h2>The SBR_HEADER_ELEMENT</h2>

  The SBR_HEADER_ELEMENT can be transmitted with every frame, however, it
  typically is send every second or so. It contains fundamental information such
  as SBR sampling frequency and frequency range as well as control signals that
  do not require frequent changes. It also includes the \ref
  SBR_STANDARD_ELEMENT.

  Depending on the changes between the information in a current
  SBR_HEADER_ELEMENT and the previous SBR_HEADER_ELEMENT, the SBR decoder might
  need to be reset and reconfigured (e.g. new tables need to be calculated).

  \anchor SBR_STANDARD_ELEMENT <h2>The SBR_STANDARD_ELEMENT</h2>

  This data can be subdivided into "side info" and "raw data", where side info
  is defined as signals needed to decode the raw data and some decoder tuning
  signals. Raw data is referred to as PCM and Huffman coded envelope and noise
  floor estimates. The side info also includes information about the
  time-frequency grid for the current frame.

  \sa \ref documentationOverview
*/

#include "env_extr.h"

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

#include "psbitdec.h"

#define DRM_PARAMETRIC_STEREO 0
#define EXTENSION_ID_PS_CODING 2

static int extractPvcFrameInfo(
    HANDLE_FDK_BITSTREAM hBs,           /*!< bitbuffer handle */
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< pointer to memory where the
                                           frame-info will be stored */
    HANDLE_SBR_PREV_FRAME_DATA h_prev_frame_data, /*!< pointer to memory where
                                                     the previous frame-info
                                                     will be stored */
    UCHAR pvc_mode_last,                          /**< PVC mode of last frame */
    const UINT flags);
static int extractFrameInfo(HANDLE_FDK_BITSTREAM hBs,
                            HANDLE_SBR_HEADER_DATA hHeaderData,
                            HANDLE_SBR_FRAME_DATA h_frame_data,
                            const UINT nrOfChannels, const UINT flags);

static int sbrGetPvcEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
                             HANDLE_SBR_FRAME_DATA h_frame_data,
                             HANDLE_FDK_BITSTREAM hBs, const UINT flags,
                             const UINT pvcMode);
static int sbrGetEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
                          HANDLE_SBR_FRAME_DATA h_frame_data,
                          HANDLE_FDK_BITSTREAM hBs, const UINT flags);

static void sbrGetDirectionControlData(HANDLE_SBR_FRAME_DATA hFrameData,
                                       HANDLE_FDK_BITSTREAM hBs,
                                       const UINT flags, const int bs_pvc_mode);

static void sbrGetNoiseFloorData(HANDLE_SBR_HEADER_DATA hHeaderData,
                                 HANDLE_SBR_FRAME_DATA h_frame_data,
                                 HANDLE_FDK_BITSTREAM hBs);

static int checkFrameInfo(FRAME_INFO *pFrameInfo, int numberOfTimeSlots,
                          int overlap, int timeStep);

/* Mapping to std samplerate table according to 14496-3 (4.6.18.2.6) */
typedef struct SR_MAPPING {
  UINT fsRangeLo; /* If fsRangeLo(n+1)>fs>=fsRangeLo(n), it will be mapped to...
                   */
  UINT fsMapped;  /* fsMapped. */
} SR_MAPPING;

static const SR_MAPPING stdSampleRatesMapping[] = {
    {0, 8000},      {9391, 11025},  {11502, 12000}, {13856, 16000},
    {18783, 22050}, {23004, 24000}, {27713, 32000}, {37566, 44100},
    {46009, 48000}, {55426, 64000}, {75132, 88200}, {92017, 96000}};
static const SR_MAPPING stdSampleRatesMappingUsac[] = {
    {0, 16000},     {18783, 22050}, {23004, 24000}, {27713, 32000},
    {35777, 40000}, {42000, 44100}, {46009, 48000}, {55426, 64000},
    {75132, 88200}, {92017, 96000}};

UINT sbrdec_mapToStdSampleRate(UINT fs,
                               UINT isUsac) /*!< Output sampling frequency */
{
  UINT fsMapped = fs, tableSize = 0;
  const SR_MAPPING *mappingTable;
  int i;

  if (!isUsac) {
    mappingTable = stdSampleRatesMapping;
    tableSize = sizeof(stdSampleRatesMapping) / sizeof(SR_MAPPING);
  } else {
    mappingTable = stdSampleRatesMappingUsac;
    tableSize = sizeof(stdSampleRatesMappingUsac) / sizeof(SR_MAPPING);
  }

  for (i = tableSize - 1; i >= 0; i--) {
    if (fs >= mappingTable[i].fsRangeLo) {
      fsMapped = mappingTable[i].fsMapped;
      break;
    }
  }

  return (fsMapped);
}

SBR_ERROR
initHeaderData(HANDLE_SBR_HEADER_DATA hHeaderData, const int sampleRateIn,
               const int sampleRateOut, const INT downscaleFactor,
               const int samplesPerFrame, const UINT flags,
               const int setDefaultHdr) {
  HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
  SBR_ERROR sbrError = SBRDEC_OK;
  int numAnalysisBands;
  int sampleRateProc;

  if (!(flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50))) {
    sampleRateProc =
        sbrdec_mapToStdSampleRate(sampleRateOut * downscaleFactor, 0);
  } else {
    sampleRateProc = sampleRateOut * downscaleFactor;
  }

  if (sampleRateIn == sampleRateOut) {
    hHeaderData->sbrProcSmplRate = sampleRateProc << 1;
    numAnalysisBands = 32;
  } else {
    hHeaderData->sbrProcSmplRate = sampleRateProc;
    if ((sampleRateOut >> 1) == sampleRateIn) {
      /* 1:2 */
      numAnalysisBands = 32;
    } else if ((sampleRateOut >> 2) == sampleRateIn) {
      /* 1:4 */
      numAnalysisBands = 16;
    } else if ((sampleRateOut * 3) >> 3 == (sampleRateIn * 8) >> 3) {
      /* 3:8, 3/4 core frame length */
      numAnalysisBands = 24;
    } else {
      sbrError = SBRDEC_UNSUPPORTED_CONFIG;
      goto bail;
    }
  }
  numAnalysisBands /= downscaleFactor;

  if (setDefaultHdr) {
    /* Fill in default values first */
    hHeaderData->syncState = SBR_NOT_INITIALIZED;
    hHeaderData->status = 0;
    hHeaderData->frameErrorFlag = 0;

    hHeaderData->bs_info.ampResolution = 1;
    hHeaderData->bs_info.xover_band = 0;
    hHeaderData->bs_info.sbr_preprocessing = 0;
    hHeaderData->bs_info.pvc_mode = 0;

    hHeaderData->bs_data.startFreq = 5;
    hHeaderData->bs_data.stopFreq = 0;
    hHeaderData->bs_data.freqScale =
        0; /* previously 2; for ELD reduced delay bitstreams
           /samplerates initializing of the sbr decoder instance fails if
           freqScale is set to 2 because no master table can be generated; in
           ELD reduced delay bitstreams this value is always 0; gets overwritten
           when header is read */
    hHeaderData->bs_data.alterScale = 1;
    hHeaderData->bs_data.noise_bands = 2;
    hHeaderData->bs_data.limiterBands = 2;
    hHeaderData->bs_data.limiterGains = 2;
    hHeaderData->bs_data.interpolFreq = 1;
    hHeaderData->bs_data.smoothingLength = 1;

    /* Patch some entries */
    if (sampleRateOut * downscaleFactor >= 96000) {
      hHeaderData->bs_data.startFreq =
          4; /*   having read these frequency values from bit stream before. */
      hHeaderData->bs_data.stopFreq = 3;
    } else if (sampleRateOut * downscaleFactor >
               24000) { /* Trigger an error if SBR is going to be processed
                           without     */
      hHeaderData->bs_data.startFreq =
          7; /*   having read these frequency values from bit stream before. */
      hHeaderData->bs_data.stopFreq = 3;
    }
  }

  if ((sampleRateOut >> 2) == sampleRateIn) {
    hHeaderData->timeStep = 4;
  } else {
    hHeaderData->timeStep = (flags & SBRDEC_ELD_GRID) ? 1 : 2;
  }

  /* Setup pointers to frequency band tables */
  hFreq->freqBandTable[0] = hFreq->freqBandTableLo;
  hFreq->freqBandTable[1] = hFreq->freqBandTableHi;

  /* One SBR timeslot corresponds to the amount of samples equal to the amount
   * of analysis bands, divided by the timestep. */
  hHeaderData->numberTimeSlots =
      (samplesPerFrame / numAnalysisBands) >> (hHeaderData->timeStep - 1);
  if (hHeaderData->numberTimeSlots > (16)) {
    sbrError = SBRDEC_UNSUPPORTED_CONFIG;
  }

  hHeaderData->numberOfAnalysisBands = numAnalysisBands;
  if ((sampleRateOut >> 2) == sampleRateIn) {
    hHeaderData->numberTimeSlots <<= 1;
  }

bail:
  return sbrError;
}

/*!
  \brief   Initialize the SBR_PREV_FRAME_DATA struct
*/
void initSbrPrevFrameData(
    HANDLE_SBR_PREV_FRAME_DATA
        h_prev_data, /*!< handle to struct SBR_PREV_FRAME_DATA */
    int timeSlots)   /*!< Framelength in SBR-timeslots */
{
  int i;

  /* Set previous energy and noise levels to 0 for the case
     that decoding starts in the middle of a bitstream */
  for (i = 0; i < MAX_FREQ_COEFFS; i++)
    h_prev_data->sfb_nrg_prev[i] = (FIXP_DBL)0;
  for (i = 0; i < MAX_NOISE_COEFFS; i++)
    h_prev_data->prevNoiseLevel[i] = (FIXP_DBL)0;
  for (i = 0; i < MAX_INVF_BANDS; i++) h_prev_data->sbr_invf_mode[i] = INVF_OFF;

  h_prev_data->stopPos = timeSlots;
  h_prev_data->coupling = COUPLING_OFF;
  h_prev_data->ampRes = 0;

  FDKmemclear(&h_prev_data->prevFrameInfo, sizeof(h_prev_data->prevFrameInfo));
}

/*!
  \brief   Read header data from bitstream

  \return  error status - 0 if ok
*/
SBR_HEADER_STATUS
sbrGetHeaderData(HANDLE_SBR_HEADER_DATA hHeaderData, HANDLE_FDK_BITSTREAM hBs,
                 const UINT flags, const int fIsSbrData,
                 const UCHAR configMode) {
  SBR_HEADER_DATA_BS *pBsData;
  SBR_HEADER_DATA_BS lastHeader;
  SBR_HEADER_DATA_BS_INFO lastInfo;
  int headerExtra1 = 0, headerExtra2 = 0;

  /* Read and discard new header in config change detection mode */
  if (configMode & AC_CM_DET_CFG_CHANGE) {
    if (!(flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC))) {
      /* ampResolution */
      FDKreadBits(hBs, 1);
    }
    /* startFreq, stopFreq */
    FDKpushFor(hBs, 8);
    if (!(flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC))) {
      /* xover_band */
      FDKreadBits(hBs, 3);
      /* reserved bits */
      FDKreadBits(hBs, 2);
    }
    headerExtra1 = FDKreadBit(hBs);
    headerExtra2 = FDKreadBit(hBs);
    FDKpushFor(hBs, 5 * headerExtra1 + 6 * headerExtra2);

    return HEADER_OK;
  }

  /* Copy SBR bit stream header to temporary header */
  lastHeader = hHeaderData->bs_data;
  lastInfo = hHeaderData->bs_info;

  /* Read new header from bitstream */
  if ((flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC)) && !fIsSbrData) {
    pBsData = &hHeaderData->bs_dflt;
  } else {
    pBsData = &hHeaderData->bs_data;
  }

  if (!(flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC))) {
    hHeaderData->bs_info.ampResolution = FDKreadBits(hBs, 1);
  }

  pBsData->startFreq = FDKreadBits(hBs, 4);
  pBsData->stopFreq = FDKreadBits(hBs, 4);

  if (!(flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC))) {
    hHeaderData->bs_info.xover_band = FDKreadBits(hBs, 3);
    FDKreadBits(hBs, 2);
  }

  headerExtra1 = FDKreadBits(hBs, 1);
  headerExtra2 = FDKreadBits(hBs, 1);

  /* Handle extra header information */
  if (headerExtra1) {
    pBsData->freqScale = FDKreadBits(hBs, 2);
    pBsData->alterScale = FDKreadBits(hBs, 1);
    pBsData->noise_bands = FDKreadBits(hBs, 2);
  } else {
    pBsData->freqScale = 2;
    pBsData->alterScale = 1;
    pBsData->noise_bands = 2;
  }

  if (headerExtra2) {
    pBsData->limiterBands = FDKreadBits(hBs, 2);
    pBsData->limiterGains = FDKreadBits(hBs, 2);
    pBsData->interpolFreq = FDKreadBits(hBs, 1);
    pBsData->smoothingLength = FDKreadBits(hBs, 1);
  } else {
    pBsData->limiterBands = 2;
    pBsData->limiterGains = 2;
    pBsData->interpolFreq = 1;
    pBsData->smoothingLength = 1;
  }

  /* Look for new settings. IEC 14496-3, 4.6.18.3.1 */
  if (hHeaderData->syncState < SBR_HEADER ||
      lastHeader.startFreq != pBsData->startFreq ||
      lastHeader.stopFreq != pBsData->stopFreq ||
      lastHeader.freqScale != pBsData->freqScale ||
      lastHeader.alterScale != pBsData->alterScale ||
      lastHeader.noise_bands != pBsData->noise_bands ||
      lastInfo.xover_band != hHeaderData->bs_info.xover_band) {
    return HEADER_RESET; /* New settings */
  }

  return HEADER_OK;
}

/*!
  \brief   Get missing harmonics parameters (only used for AAC+SBR)

  \return  error status - 0 if ok
*/
int sbrGetSyntheticCodedData(HANDLE_SBR_HEADER_DATA hHeaderData,
                             HANDLE_SBR_FRAME_DATA hFrameData,
                             HANDLE_FDK_BITSTREAM hBs, const UINT flags) {
  int i, bitsRead = 0;

  int add_harmonic_flag = FDKreadBits(hBs, 1);
  bitsRead++;

  if (add_harmonic_flag) {
    int nSfb = hHeaderData->freqBandData.nSfb[1];
    for (i = 0; i < ADD_HARMONICS_FLAGS_SIZE; i++) {
      /* read maximum 32 bits and align them to the MSB */
      int readBits = fMin(32, nSfb);
      nSfb -= readBits;
      if (readBits > 0) {
        hFrameData->addHarmonics[i] = FDKreadBits(hBs, readBits)
                                      << (32 - readBits);
      } else {
        hFrameData->addHarmonics[i] = 0;
      }

      bitsRead += readBits;
    }
    /* bs_pvc_mode = 0 for Rsvd50 */
    if (flags & SBRDEC_SYNTAX_USAC) {
      if (hHeaderData->bs_info.pvc_mode) {
        int bs_sinusoidal_position = 31;
        if (FDKreadBit(hBs) /* bs_sinusoidal_position_flag */) {
          bs_sinusoidal_position = FDKreadBits(hBs, 5);
        }
        hFrameData->sinusoidal_position = bs_sinusoidal_position;
      }
    }
  } else {
    for (i = 0; i < ADD_HARMONICS_FLAGS_SIZE; i++)
      hFrameData->addHarmonics[i] = 0;
  }

  return (bitsRead);
}

/*!
  \brief      Reads extension data from the bitstream

  The bitstream format allows up to 4 kinds of extended data element.
  Extended data may contain several elements, each identified by a 2-bit-ID.
  So far, no extended data elements are defined hence the first 2 parameters
  are unused. The data should be skipped in order to update the number
  of read bits for the consistency check in applySBR().
*/
static int extractExtendedData(
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< handle to SBR header */
    HANDLE_FDK_BITSTREAM hBs            /*!< Handle to the bit buffer */
    ,
    HANDLE_PS_DEC hParametricStereoDec /*!< Parametric Stereo Decoder */
) {
  INT nBitsLeft;
  int extended_data;
  int i, frameOk = 1;

  extended_data = FDKreadBits(hBs, 1);

  if (extended_data) {
    int cnt;
    int bPsRead = 0;

    cnt = FDKreadBits(hBs, 4);
    if (cnt == (1 << 4) - 1) cnt += FDKreadBits(hBs, 8);

    nBitsLeft = 8 * cnt;

    /* sanity check for cnt */
    if (nBitsLeft > (INT)FDKgetValidBits(hBs)) {
      /* limit nBitsLeft */
      nBitsLeft = (INT)FDKgetValidBits(hBs);
      /* set frame error */
      frameOk = 0;
    }

    while (nBitsLeft > 7) {
      int extension_id = FDKreadBits(hBs, 2);
      nBitsLeft -= 2;

      switch (extension_id) {
        case EXTENSION_ID_PS_CODING:

          /* Read PS data from bitstream */

          if (hParametricStereoDec != NULL) {
            if (bPsRead &&
                !hParametricStereoDec->bsData[hParametricStereoDec->bsReadSlot]
                     .mpeg.bPsHeaderValid) {
              cnt = nBitsLeft >> 3; /* number of remaining bytes */
              for (i = 0; i < cnt; i++) FDKreadBits(hBs, 8);
              nBitsLeft -= cnt * 8;
            } else {
              nBitsLeft -=
                  (INT)ReadPsData(hParametricStereoDec, hBs, nBitsLeft);
              bPsRead = 1;
            }
          }

          /* parametric stereo detected, could set channelMode accordingly here
           */
          /*                                                                     */
          /* "The usage of this parametric stereo extension to HE-AAC is */
          /* signalled implicitly in the bitstream. Hence, if an sbr_extension()
           */
          /* with bs_extension_id==EXTENSION_ID_PS is found in the SBR part of
           */
          /* the bitstream, a decoder supporting the combination of SBR and PS
           */
          /* shall operate the PS tool to generate a stereo output signal." */
          /* source: ISO/IEC 14496-3:2001/FDAM 2:2004(E) */

          break;

        default:
          cnt = nBitsLeft >> 3; /* number of remaining bytes */
          for (i = 0; i < cnt; i++) FDKreadBits(hBs, 8);
          nBitsLeft -= cnt * 8;
          break;
      }
    }

    if (nBitsLeft < 0) {
      frameOk = 0;
      goto bail;
    } else {
      /* Read fill bits for byte alignment */
      FDKreadBits(hBs, nBitsLeft);
    }
  }

bail:
  return (frameOk);
}

/*!
  \brief      Read bitstream elements of a SBR channel element
  \return     SbrFrameOK
*/
int sbrGetChannelElement(HANDLE_SBR_HEADER_DATA hHeaderData,
                         HANDLE_SBR_FRAME_DATA hFrameDataLeft,
                         HANDLE_SBR_FRAME_DATA hFrameDataRight,
                         HANDLE_SBR_PREV_FRAME_DATA hFrameDataLeftPrev,
                         UCHAR pvc_mode_last, HANDLE_FDK_BITSTREAM hBs,
                         HANDLE_PS_DEC hParametricStereoDec, const UINT flags,
                         const int overlap) {
  int i, bs_coupling = COUPLING_OFF;
  const int nCh = (hFrameDataRight == NULL) ? 1 : 2;

  if (!(flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50))) {
    /* Reserved bits */
    if (FDKreadBits(hBs, 1)) { /* bs_data_extra */
      FDKreadBits(hBs, 4);
      if ((flags & SBRDEC_SYNTAX_SCAL) || (nCh == 2)) {
        FDKreadBits(hBs, 4);
      }
    }
  }

  if (nCh == 2) {
    /* Read coupling flag */
    bs_coupling = FDKreadBits(hBs, 1);
    if (bs_coupling) {
      hFrameDataLeft->coupling = COUPLING_LEVEL;
      hFrameDataRight->coupling = COUPLING_BAL;
    } else {
      hFrameDataLeft->coupling = COUPLING_OFF;
      hFrameDataRight->coupling = COUPLING_OFF;
    }
  } else {
    if (flags & SBRDEC_SYNTAX_SCAL) {
      FDKreadBits(hBs, 1); /* bs_coupling */
    }
    hFrameDataLeft->coupling = COUPLING_OFF;
  }

  if (flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50)) {
    if (flags & SBRDEC_USAC_HARMONICSBR) {
      hFrameDataLeft->sbrPatchingMode = FDKreadBit(hBs);
      if (hFrameDataLeft->sbrPatchingMode == 0) {
        hFrameDataLeft->sbrOversamplingFlag = FDKreadBit(hBs);
        if (FDKreadBit(hBs)) { /* sbrPitchInBinsFlag */
          hFrameDataLeft->sbrPitchInBins = FDKreadBits(hBs, 7);
        } else {
          hFrameDataLeft->sbrPitchInBins = 0;
        }
      } else {
        hFrameDataLeft->sbrOversamplingFlag = 0;
        hFrameDataLeft->sbrPitchInBins = 0;
      }

      if (nCh == 2) {
        if (bs_coupling) {
          hFrameDataRight->sbrPatchingMode = hFrameDataLeft->sbrPatchingMode;
          hFrameDataRight->sbrOversamplingFlag =
              hFrameDataLeft->sbrOversamplingFlag;
          hFrameDataRight->sbrPitchInBins = hFrameDataLeft->sbrPitchInBins;
        } else {
          hFrameDataRight->sbrPatchingMode = FDKreadBit(hBs);
          if (hFrameDataRight->sbrPatchingMode == 0) {
            hFrameDataRight->sbrOversamplingFlag = FDKreadBit(hBs);
            if (FDKreadBit(hBs)) { /* sbrPitchInBinsFlag */
              hFrameDataRight->sbrPitchInBins = FDKreadBits(hBs, 7);
            } else {
              hFrameDataRight->sbrPitchInBins = 0;
            }
          } else {
            hFrameDataRight->sbrOversamplingFlag = 0;
            hFrameDataRight->sbrPitchInBins = 0;
          }
        }
      }
    } else {
      if (nCh == 2) {
        hFrameDataRight->sbrPatchingMode = 1;
        hFrameDataRight->sbrOversamplingFlag = 0;
        hFrameDataRight->sbrPitchInBins = 0;
      }

      hFrameDataLeft->sbrPatchingMode = 1;
      hFrameDataLeft->sbrOversamplingFlag = 0;
      hFrameDataLeft->sbrPitchInBins = 0;
    }
  } else {
    if (nCh == 2) {
      hFrameDataRight->sbrPatchingMode = 1;
      hFrameDataRight->sbrOversamplingFlag = 0;
      hFrameDataRight->sbrPitchInBins = 0;
    }

    hFrameDataLeft->sbrPatchingMode = 1;
    hFrameDataLeft->sbrOversamplingFlag = 0;
    hFrameDataLeft->sbrPitchInBins = 0;
  }

  /*
    sbr_grid(): Grid control
  */
  if (hHeaderData->bs_info.pvc_mode) {
    FDK_ASSERT(nCh == 1); /* PVC not possible for CPE */
    if (!extractPvcFrameInfo(hBs, hHeaderData, hFrameDataLeft,
                             hFrameDataLeftPrev, pvc_mode_last, flags))
      return 0;

    if (!checkFrameInfo(&hFrameDataLeft->frameInfo,
                        hHeaderData->numberTimeSlots, overlap,
                        hHeaderData->timeStep))
      return 0;
  } else {
    if (!extractFrameInfo(hBs, hHeaderData, hFrameDataLeft, 1, flags)) return 0;

    if (!checkFrameInfo(&hFrameDataLeft->frameInfo,
                        hHeaderData->numberTimeSlots, overlap,
                        hHeaderData->timeStep))
      return 0;
  }
  if (nCh == 2) {
    if (hFrameDataLeft->coupling) {
      FDKmemcpy(&hFrameDataRight->frameInfo, &hFrameDataLeft->frameInfo,
                sizeof(FRAME_INFO));
      hFrameDataRight->ampResolutionCurrentFrame =
          hFrameDataLeft->ampResolutionCurrentFrame;
    } else {
      if (!extractFrameInfo(hBs, hHeaderData, hFrameDataRight, 2, flags))
        return 0;

      if (!checkFrameInfo(&hFrameDataRight->frameInfo,
                          hHeaderData->numberTimeSlots, overlap,
                          hHeaderData->timeStep))
        return 0;
    }
  }

  /*
    sbr_dtdf(): Fetch domain vectors (time or frequency direction for
    delta-coding)
  */
  sbrGetDirectionControlData(hFrameDataLeft, hBs, flags,
                             hHeaderData->bs_info.pvc_mode);
  if (nCh == 2) {
    sbrGetDirectionControlData(hFrameDataRight, hBs, flags, 0);
  }

  /* sbr_invf() */
  for (i = 0; i < hHeaderData->freqBandData.nInvfBands; i++) {
    hFrameDataLeft->sbr_invf_mode[i] = (INVF_MODE)FDKreadBits(hBs, 2);
  }
  if (nCh == 2) {
    if (hFrameDataLeft->coupling) {
      for (i = 0; i < hHeaderData->freqBandData.nInvfBands; i++) {
        hFrameDataRight->sbr_invf_mode[i] = hFrameDataLeft->sbr_invf_mode[i];
      }
    } else {
      for (i = 0; i < hHeaderData->freqBandData.nInvfBands; i++) {
        hFrameDataRight->sbr_invf_mode[i] = (INVF_MODE)FDKreadBits(hBs, 2);
      }
    }
  }

  if (nCh == 1) {
    if (hHeaderData->bs_info.pvc_mode) {
      if (!sbrGetPvcEnvelope(hHeaderData, hFrameDataLeft, hBs, flags,
                             hHeaderData->bs_info.pvc_mode))
        return 0;
    } else if (!sbrGetEnvelope(hHeaderData, hFrameDataLeft, hBs, flags))
      return 0;

    sbrGetNoiseFloorData(hHeaderData, hFrameDataLeft, hBs);
  } else if (hFrameDataLeft->coupling) {
    if (!sbrGetEnvelope(hHeaderData, hFrameDataLeft, hBs, flags)) {
      return 0;
    }

    sbrGetNoiseFloorData(hHeaderData, hFrameDataLeft, hBs);

    if (!sbrGetEnvelope(hHeaderData, hFrameDataRight, hBs, flags)) {
      return 0;
    }
    sbrGetNoiseFloorData(hHeaderData, hFrameDataRight, hBs);
  } else { /* nCh == 2 && no coupling */

    if (!sbrGetEnvelope(hHeaderData, hFrameDataLeft, hBs, flags)) return 0;

    if (!sbrGetEnvelope(hHeaderData, hFrameDataRight, hBs, flags)) return 0;

    sbrGetNoiseFloorData(hHeaderData, hFrameDataLeft, hBs);

    sbrGetNoiseFloorData(hHeaderData, hFrameDataRight, hBs);
  }

  sbrGetSyntheticCodedData(hHeaderData, hFrameDataLeft, hBs, flags);
  if (nCh == 2) {
    sbrGetSyntheticCodedData(hHeaderData, hFrameDataRight, hBs, flags);
  }

  if (!(flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50))) {
    if (!extractExtendedData(hHeaderData, hBs, hParametricStereoDec)) {
      return 0;
    }
  }

  return 1;
}

/*!
  \brief   Read direction control data from bitstream
*/
void sbrGetDirectionControlData(
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
    HANDLE_FDK_BITSTREAM hBs,           /*!< handle to struct BIT_BUF */
    const UINT flags, const int bs_pvc_mode)

{
  int i;
  int indepFlag = 0;

  if (flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50)) {
    indepFlag = flags & SBRDEC_USAC_INDEP;
  }

  if (bs_pvc_mode == 0) {
    i = 0;
    if (indepFlag) {
      h_frame_data->domain_vec[i++] = 0;
    }
    for (; i < h_frame_data->frameInfo.nEnvelopes; i++) {
      h_frame_data->domain_vec[i] = FDKreadBits(hBs, 1);
    }
  }

  i = 0;
  if (indepFlag) {
    h_frame_data->domain_vec_noise[i++] = 0;
  }
  for (; i < h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
    h_frame_data->domain_vec_noise[i] = FDKreadBits(hBs, 1);
  }
}

/*!
  \brief   Read noise-floor-level data from bitstream
*/
void sbrGetNoiseFloorData(
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
    HANDLE_FDK_BITSTREAM hBs)           /*!< handle to struct BIT_BUF */
{
  int i, j;
  int delta;
  COUPLING_MODE coupling;
  int noNoiseBands = hHeaderData->freqBandData.nNfb;

  Huffman hcb_noiseF;
  Huffman hcb_noise;
  int envDataTableCompFactor;

  coupling = h_frame_data->coupling;

  /*
    Select huffman codebook depending on coupling mode
  */
  if (coupling == COUPLING_BAL) {
    hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseBalance11T;
    hcb_noiseF =
        (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F; /* "sbr_huffBook_NoiseBalance11F"
                                                              */
    envDataTableCompFactor = 1;
  } else {
    hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseLevel11T;
    hcb_noiseF =
        (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F; /* "sbr_huffBook_NoiseLevel11F"
                                                            */
    envDataTableCompFactor = 0;
  }

  /*
    Read raw noise-envelope data
  */
  for (i = 0; i < h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
    if (h_frame_data->domain_vec_noise[i] == 0) {
      if (coupling == COUPLING_BAL) {
        h_frame_data->sbrNoiseFloorLevel[i * noNoiseBands] =
            (FIXP_SGL)(((int)FDKreadBits(hBs, 5)) << envDataTableCompFactor);
      } else {
        h_frame_data->sbrNoiseFloorLevel[i * noNoiseBands] =
            (FIXP_SGL)(int)FDKreadBits(hBs, 5);
      }

      for (j = 1; j < noNoiseBands; j++) {
        delta = DecodeHuffmanCW(hcb_noiseF, hBs);
        h_frame_data->sbrNoiseFloorLevel[i * noNoiseBands + j] =
            (FIXP_SGL)(delta << envDataTableCompFactor);
      }
    } else {
      for (j = 0; j < noNoiseBands; j++) {
        delta = DecodeHuffmanCW(hcb_noise, hBs);
        h_frame_data->sbrNoiseFloorLevel[i * noNoiseBands + j] =
            (FIXP_SGL)(delta << envDataTableCompFactor);
      }
    }
  }
}

/* ns = mapNsMode2ns[pvcMode-1][nsMode] */
static const UCHAR mapNsMode2ns[2][2] = {
    {16, 4}, /* pvcMode = 1 */
    {12, 3}  /* pvcMode = 2 */
};

static int sbrGetPvcEnvelope(
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
    HANDLE_FDK_BITSTREAM hBs,           /*!< handle to struct BIT_BUF */
    const UINT flags, const UINT pvcMode) {
  int divMode, nsMode;
  int indepFlag = flags & SBRDEC_USAC_INDEP;
  UCHAR *pvcID = h_frame_data->pvcID;

  divMode = FDKreadBits(hBs, PVC_DIVMODE_BITS);
  nsMode = FDKreadBit(hBs);
  FDK_ASSERT((pvcMode == 1) || (pvcMode == 2));
  h_frame_data->ns = mapNsMode2ns[pvcMode - 1][nsMode];

  if (divMode <= 3) {
    int i, k = 1, sum_length = 0, reuse_pcvID;

    /* special treatment for first time slot k=0 */
    indepFlag ? (reuse_pcvID = 0) : (reuse_pcvID = FDKreadBit(hBs));
    if (reuse_pcvID) {
      pvcID[0] = hHeaderData->pvcIDprev;
    } else {
      pvcID[0] = FDKreadBits(hBs, PVC_PVCID_BITS);
    }

    /* other time slots k>0 */
    for (i = 0; i < divMode; i++) {
      int length, numBits = 4;

      if (sum_length >= 13) {
        numBits = 1;
      } else if (sum_length >= 11) {
        numBits = 2;
      } else if (sum_length >= 7) {
        numBits = 3;
      }

      length = FDKreadBits(hBs, numBits);
      sum_length += length + 1;
      if (sum_length >= PVC_NTIMESLOT) {
        return 0; /* parse error */
      }
      for (; length--; k++) {
        pvcID[k] = pvcID[k - 1];
      }
      pvcID[k++] = FDKreadBits(hBs, PVC_PVCID_BITS);
    }
    for (; k < 16; k++) {
      pvcID[k] = pvcID[k - 1];
    }
  } else { /* divMode >= 4 */
    int num_grid_info, fixed_length, grid_info, j, k = 0;

    divMode -= 4;
    num_grid_info = 2 << divMode;
    fixed_length = 8 >> divMode;
    FDK_ASSERT(num_grid_info * fixed_length == PVC_NTIMESLOT);

    /* special treatment for first time slot k=0 */
    indepFlag ? (grid_info = 1) : (grid_info = FDKreadBit(hBs));
    if (grid_info) {
      pvcID[k++] = FDKreadBits(hBs, PVC_PVCID_BITS);
    } else {
      pvcID[k++] = hHeaderData->pvcIDprev;
    }
    j = fixed_length - 1;
    for (; j--; k++) {
      pvcID[k] = pvcID[k - 1];
    }
    num_grid_info--;

    /* other time slots k>0 */
    for (; num_grid_info--;) {
      j = fixed_length;
      grid_info = FDKreadBit(hBs);
      if (grid_info) {
        pvcID[k++] = FDKreadBits(hBs, PVC_PVCID_BITS);
        j--;
      }
      for (; j--; k++) {
        pvcID[k] = pvcID[k - 1];
      }
    }
  }

  hHeaderData->pvcIDprev = pvcID[PVC_NTIMESLOT - 1];

  /* usage of PVC excludes inter-TES tool */
  h_frame_data->iTESactive = (UCHAR)0;

  return 1;
}
/*!
  \brief   Read envelope data from bitstream
*/
static int sbrGetEnvelope(
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
    HANDLE_FDK_BITSTREAM hBs,           /*!< handle to struct BIT_BUF */
    const UINT flags) {
  int i, j;
  UCHAR no_band[MAX_ENVELOPES];
  int delta = 0;
  int offset = 0;
  COUPLING_MODE coupling = h_frame_data->coupling;
  int ampRes = hHeaderData->bs_info.ampResolution;
  int nEnvelopes = h_frame_data->frameInfo.nEnvelopes;
  int envDataTableCompFactor;
  int start_bits, start_bits_balance;
  Huffman hcb_t, hcb_f;

  h_frame_data->nScaleFactors = 0;

  if ((h_frame_data->frameInfo.frameClass == 0) && (nEnvelopes == 1)) {
    if (flags & SBRDEC_ELD_GRID)
      ampRes = h_frame_data->ampResolutionCurrentFrame;
    else
      ampRes = 0;
  }
  h_frame_data->ampResolutionCurrentFrame = ampRes;

  /*
    Set number of bits for first value depending on amplitude resolution
  */
  if (ampRes == 1) {
    start_bits = 6;
    start_bits_balance = 5;
  } else {
    start_bits = 7;
    start_bits_balance = 6;
  }

  /*
    Calculate number of values for each envelope and alltogether
  */
  for (i = 0; i < nEnvelopes; i++) {
    no_band[i] =
        hHeaderData->freqBandData.nSfb[h_frame_data->frameInfo.freqRes[i]];
    h_frame_data->nScaleFactors += no_band[i];
  }
  if (h_frame_data->nScaleFactors > MAX_NUM_ENVELOPE_VALUES) return 0;

  /*
    Select Huffman codebook depending on coupling mode and amplitude resolution
  */
  if (coupling == COUPLING_BAL) {
    envDataTableCompFactor = 1;
    if (ampRes == 0) {
      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10T;
      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10F;
    } else {
      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11T;
      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F;
    }
  } else {
    envDataTableCompFactor = 0;
    if (ampRes == 0) {
      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10T;
      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10F;
    } else {
      hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11T;
      hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F;
    }
  }

  h_frame_data->iTESactive = (UCHAR)0; /* disable inter-TES by default */
  /*
    Now read raw envelope data
  */
  for (j = 0, offset = 0; j < nEnvelopes; j++) {
    if (h_frame_data->domain_vec[j] == 0) {
      if (coupling == COUPLING_BAL) {
        h_frame_data->iEnvelope[offset] =
            (FIXP_SGL)(((int)FDKreadBits(hBs, start_bits_balance))
                       << envDataTableCompFactor);
      } else {
        h_frame_data->iEnvelope[offset] =
            (FIXP_SGL)(int)FDKreadBits(hBs, start_bits);
      }
    }

    for (i = (1 - h_frame_data->domain_vec[j]); i < no_band[j]; i++) {
      if (h_frame_data->domain_vec[j] == 0) {
        delta = DecodeHuffmanCW(hcb_f, hBs);
      } else {
        delta = DecodeHuffmanCW(hcb_t, hBs);
      }

      h_frame_data->iEnvelope[offset + i] =
          (FIXP_SGL)(delta << envDataTableCompFactor);
    }
    if ((flags & SBRDEC_SYNTAX_USAC) && (flags & SBRDEC_USAC_ITES)) {
      int bs_temp_shape = FDKreadBit(hBs);
      FDK_ASSERT(j < 8);
      h_frame_data->iTESactive |= (UCHAR)(bs_temp_shape << j);
      if (bs_temp_shape) {
        h_frame_data->interTempShapeMode[j] =
            FDKread2Bits(hBs); /* bs_inter_temp_shape_mode */
      } else {
        h_frame_data->interTempShapeMode[j] = 0;
      }
    }
    offset += no_band[j];
  }

#if ENV_EXP_FRACT
  /* Convert from int to scaled fract (ENV_EXP_FRACT bits for the fractional
   * part) */
  for (i = 0; i < h_frame_data->nScaleFactors; i++) {
    h_frame_data->iEnvelope[i] <<= ENV_EXP_FRACT;
  }
#endif

  return 1;
}

/***************************************************************************/
/*!
  \brief    Generates frame info for FIXFIXonly frame class used for low delay
 version

  \return   zero for error, one for correct.
 ****************************************************************************/
static int generateFixFixOnly(FRAME_INFO *hSbrFrameInfo, int tranPosInternal,
                              int numberTimeSlots, const UINT flags) {
  int nEnv, i, tranIdx;
  const int *pTable;

  switch (numberTimeSlots) {
    case 8:
      pTable = FDK_sbrDecoder_envelopeTable_8[tranPosInternal];
      break;
    case 15:
      pTable = FDK_sbrDecoder_envelopeTable_15[tranPosInternal];
      break;
    case 16:
      pTable = FDK_sbrDecoder_envelopeTable_16[tranPosInternal];
      break;
    default:
      return 0;
  }

  /* look number of envelopes in table */
  nEnv = pTable[0];
  /* look up envelope distribution in table */
  for (i = 1; i < nEnv; i++) hSbrFrameInfo->borders[i] = pTable[i + 2];
  /* open and close frame border */
  hSbrFrameInfo->borders[0] = 0;
  hSbrFrameInfo->borders[nEnv] = numberTimeSlots;
  hSbrFrameInfo->nEnvelopes = nEnv;

  /* transient idx */
  tranIdx = hSbrFrameInfo->tranEnv = pTable[1];

  /* add noise floors */
  hSbrFrameInfo->bordersNoise[0] = 0;
  hSbrFrameInfo->bordersNoise[1] =
      hSbrFrameInfo->borders[tranIdx ? tranIdx : 1];
  hSbrFrameInfo->bordersNoise[2] = numberTimeSlots;
  /* nEnv is always > 1, so nNoiseEnvelopes is always 2 (IEC 14496-3 4.6.19.3.2)
   */
  hSbrFrameInfo->nNoiseEnvelopes = 2;

  return 1;
}

/*!
  \brief  Extracts LowDelaySBR control data from the bitstream.

  \return zero for bitstream error, one for correct.
*/
static int extractLowDelayGrid(
    HANDLE_FDK_BITSTREAM hBitBuf, /*!< bitbuffer handle */
    HANDLE_SBR_HEADER_DATA hHeaderData,
    HANDLE_SBR_FRAME_DATA
        h_frame_data, /*!< contains the FRAME_INFO struct to be filled */
    int timeSlots, const UINT flags) {
  FRAME_INFO *pFrameInfo = &h_frame_data->frameInfo;
  INT numberTimeSlots = hHeaderData->numberTimeSlots;
  INT temp = 0, k;

  /* FIXFIXonly framing case */
  h_frame_data->frameInfo.frameClass = 0;

  /* get the transient position from the bitstream */
  switch (timeSlots) {
    case 8:
      /* 3bit transient position (temp={0;..;7}) */
      temp = FDKreadBits(hBitBuf, 3);
      break;

    case 16:
    case 15:
      /* 4bit transient position (temp={0;..;15}) */
      temp = FDKreadBits(hBitBuf, 4);
      break;

    default:
      return 0;
  }

  /* For "case 15" only*/
  if (temp >= timeSlots) {
    return 0;
  }

  /* calculate borders according to the transient position */
  if (!generateFixFixOnly(pFrameInfo, temp, numberTimeSlots, flags)) {
    return 0;
  }

  /* decode freq res: */
  for (k = 0; k < pFrameInfo->nEnvelopes; k++) {
    pFrameInfo->freqRes[k] =
        (UCHAR)FDKreadBits(hBitBuf, 1); /* f = F [1 bits] */
  }

  return 1;
}

/*!
  \brief   Extract the PVC frame information (structure FRAME_INFO) from the
  bitstream \return  Zero for bitstream error, one for correct.
*/
int extractPvcFrameInfo(
    HANDLE_FDK_BITSTREAM hBs,           /*!< bitbuffer handle */
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< pointer to memory where the
                                           frame-info will be stored */
    HANDLE_SBR_PREV_FRAME_DATA h_prev_frame_data, /*!< pointer to memory where
                                                     the previous frame-info
                                                     will be stored */
    UCHAR pvc_mode_last,                          /**< PVC mode of last frame */
    const UINT flags) {
  FRAME_INFO *pFrameInfo = &h_frame_data->frameInfo;
  FRAME_INFO *pPrevFrameInfo = &h_prev_frame_data->prevFrameInfo;
  int bs_var_len_hf, bs_noise_position;
  bs_noise_position = FDKreadBits(hBs, 4); /* SBR_PVC_NOISEPOSITION_BITS 4 */
  bs_var_len_hf = FDKreadBit(hBs);
  pFrameInfo->noisePosition = bs_noise_position;
  pFrameInfo->tranEnv = -1;

  /* Init for bs_noise_position == 0 in case a parse error is found below. */
  pFrameInfo->nEnvelopes = 1;
  pFrameInfo->nNoiseEnvelopes = 1;
  pFrameInfo->freqRes[0] = 0;

  if (bs_var_len_hf) { /* 1 or 3 Bits */
    pFrameInfo->varLength = FDKreadBits(hBs, 2) + 1;
    if (pFrameInfo->varLength > 3) {
      pFrameInfo->varLength =
          0;    /* assume bs_var_len_hf == 0 in case of error */
      return 0; /* reserved value -> parse error */
    }
  } else {
    pFrameInfo->varLength = 0;
  }

  if (bs_noise_position) {
    pFrameInfo->nEnvelopes = 2;
    pFrameInfo->nNoiseEnvelopes = 2;
    FDKmemclear(pFrameInfo->freqRes, sizeof(pFrameInfo->freqRes));
  }

  /* frame border calculation */
  if (hHeaderData->bs_info.pvc_mode > 0) {
    /* See "7.5.1.4 HF adjustment of SBR envelope scalefactors" for reference.
     */

    FDK_ASSERT((pFrameInfo->nEnvelopes == 1) || (pFrameInfo->nEnvelopes == 2));

    /* left timeborder-offset: use the timeborder of prev SBR frame */
    if (pPrevFrameInfo->nEnvelopes > 0) {
      pFrameInfo->borders[0] =
          pPrevFrameInfo->borders[pPrevFrameInfo->nEnvelopes] - PVC_NTIMESLOT;
      FDK_ASSERT(pFrameInfo->borders[0] <= 3);
    } else {
      pFrameInfo->borders[0] = 0;
    }

    /* right timeborder-offset: */
    pFrameInfo->borders[pFrameInfo->nEnvelopes] = 16 + pFrameInfo->varLength;

    if (pFrameInfo->nEnvelopes == 2) {
      pFrameInfo->borders[1] = pFrameInfo->noisePosition;
    }

    /* Calculation of PVC time borders t_EPVC */
    if (pvc_mode_last == 0) {
      /* there was a legacy SBR frame before this frame => use bs_var_len' for
       * first PVC timeslot */
      pFrameInfo->pvcBorders[0] = pFrameInfo->borders[0];
    } else {
      pFrameInfo->pvcBorders[0] = 0;
    }
    if (pFrameInfo->nEnvelopes == 2) {
      pFrameInfo->pvcBorders[1] = pFrameInfo->borders[1];
    }
    pFrameInfo->pvcBorders[pFrameInfo->nEnvelopes] = 16;

    /* calculation of SBR noise-floor time-border vector: */
    for (INT i = 0; i <= pFrameInfo->nNoiseEnvelopes; i++) {
      pFrameInfo->bordersNoise[i] = pFrameInfo->borders[i];
    }

    pFrameInfo->tranEnv = -1; /* tranEnv not used */
  }
  return 1;
}

/*!
  \brief   Extract the frame information (structure FRAME_INFO) from the
  bitstream \return  Zero for bitstream error, one for correct.
*/
int extractFrameInfo(
    HANDLE_FDK_BITSTREAM hBs,           /*!< bitbuffer handle */
    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    HANDLE_SBR_FRAME_DATA h_frame_data, /*!< pointer to memory where the
                                           frame-info will be stored */
    const UINT nrOfChannels, const UINT flags) {
  FRAME_INFO *pFrameInfo = &h_frame_data->frameInfo;
  int numberTimeSlots = hHeaderData->numberTimeSlots;
  int pointer_bits = 0, nEnv = 0, b = 0, border, i, n = 0, k, p, aL, aR, nL, nR,
      temp = 0, staticFreqRes;
  UCHAR frameClass;

  if (flags & SBRDEC_ELD_GRID) {
    /* CODEC_AACLD (LD+SBR) only uses the normal 0 Grid for non-transient Frames
     * and the LowDelayGrid for transient Frames */
    frameClass = FDKreadBits(hBs, 1); /* frameClass = [1 bit] */
    if (frameClass == 1) {
      /* if frameClass == 1, extract LowDelaySbrGrid, otherwise extract normal
       * SBR-Grid for FIXIFX */
      /* extract the AACLD-Sbr-Grid */
      pFrameInfo->frameClass = frameClass;
      int err = 1;
      err = extractLowDelayGrid(hBs, hHeaderData, h_frame_data, numberTimeSlots,
                                flags);
      return err;
    }
  } else {
    frameClass = FDKreadBits(hBs, 2); /* frameClass = C [2 bits] */
  }

  switch (frameClass) {
    case 0:
      temp = FDKreadBits(hBs, 2); /* E [2 bits ] */
      nEnv = (int)(1 << temp);    /* E -> e */

      if ((flags & SBRDEC_ELD_GRID) && (nEnv == 1))
        h_frame_data->ampResolutionCurrentFrame =
            FDKreadBits(hBs, 1); /* new ELD Syntax 07-11-09 */

      staticFreqRes = FDKreadBits(hBs, 1);

      if (flags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50)) {
        if (nEnv > MAX_ENVELOPES_USAC) return 0;
      } else

        b = nEnv + 1;
      switch (nEnv) {
        case 1:
          switch (numberTimeSlots) {
            case 15:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_15,
                        sizeof(FRAME_INFO));
              break;
            case 16:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_16,
                        sizeof(FRAME_INFO));
              break;
            default:
              FDK_ASSERT(0);
          }
          break;
        case 2:
          switch (numberTimeSlots) {
            case 15:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_15,
                        sizeof(FRAME_INFO));
              break;
            case 16:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_16,
                        sizeof(FRAME_INFO));
              break;
            default:
              FDK_ASSERT(0);
          }
          break;
        case 4:
          switch (numberTimeSlots) {
            case 15:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_15,
                        sizeof(FRAME_INFO));
              break;
            case 16:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_16,
                        sizeof(FRAME_INFO));
              break;
            default:
              FDK_ASSERT(0);
          }
          break;
        case 8:
#if (MAX_ENVELOPES >= 8)
          switch (numberTimeSlots) {
            case 15:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_15,
                        sizeof(FRAME_INFO));
              break;
            case 16:
              FDKmemcpy(pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_16,
                        sizeof(FRAME_INFO));
              break;
            default:
              FDK_ASSERT(0);
          }
          break;
#else
          return 0;
#endif
      }
      /* Apply correct freqRes (High is default) */
      if (!staticFreqRes) {
        for (i = 0; i < nEnv; i++) pFrameInfo->freqRes[i] = 0;
      }

      break;
    case 1:
    case 2:
      temp = FDKreadBits(hBs, 2); /* A [2 bits] */

      n = FDKreadBits(hBs, 2); /* n = N [2 bits] */

      nEnv = n + 1; /* # envelopes */
      b = nEnv + 1; /* # borders   */

      break;
  }

  switch (frameClass) {
    case 1:
      /* Decode borders: */
      pFrameInfo->borders[0] = 0;      /* first border          */
      border = temp + numberTimeSlots; /* A -> aR               */
      i = b - 1;                       /* frame info index for last border */
      pFrameInfo->borders[i] = border; /* last border                      */

      for (k = 0; k < n; k++) {
        temp = FDKreadBits(hBs, 2); /* R [2 bits] */
        border -= (2 * temp + 2);   /* R -> r                */
        pFrameInfo->borders[--i] = border;
      }

      /* Decode pointer: */
      pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n + 1));
      p = FDKreadBits(hBs, pointer_bits); /* p = P [pointer_bits bits] */

      if (p > n + 1) return 0;

      pFrameInfo->tranEnv = p ? n + 2 - p : -1;

      /* Decode freq res: */
      for (k = n; k >= 0; k--) {
        pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
      }

      /* Calculate noise floor middle border: */
      if (p == 0 || p == 1)
        pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
      else
        pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];

      break;

    case 2:
      /* Decode borders: */
      border = temp;                   /* A -> aL */
      pFrameInfo->borders[0] = border; /* first border */

      for (k = 1; k <= n; k++) {
        temp = FDKreadBits(hBs, 2); /* R [2 bits] */
        border += (2 * temp + 2);   /* R -> r                */
        pFrameInfo->borders[k] = border;
      }
      pFrameInfo->borders[k] = numberTimeSlots; /* last border */

      /* Decode pointer: */
      pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n + 1));
      p = FDKreadBits(hBs, pointer_bits); /* p = P [pointer_bits bits] */
      if (p > n + 1) return 0;

      if (p == 0 || p == 1)
        pFrameInfo->tranEnv = -1;
      else
        pFrameInfo->tranEnv = p - 1;

      /* Decode freq res: */
      for (k = 0; k <= n; k++) {
        pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
      }

      /* Calculate noise floor middle border: */
      switch (p) {
        case 0:
          pFrameInfo->bordersNoise[1] = pFrameInfo->borders[1];
          break;
        case 1:
          pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
          break;
        default:
          pFrameInfo->bordersNoise[1] =
              pFrameInfo->borders[pFrameInfo->tranEnv];
          break;
      }

      break;

    case 3:
      /* v_ctrlSignal = [frameClass,aL,aR,nL,nR,v_rL,v_rR,p,v_fLR]; */

      aL = FDKreadBits(hBs, 2); /* AL [2 bits], AL -> aL */

      aR = FDKreadBits(hBs, 2) + numberTimeSlots; /* AR [2 bits], AR -> aR */

      nL = FDKreadBits(hBs, 2); /* nL = NL [2 bits] */

      nR = FDKreadBits(hBs, 2); /* nR = NR [2 bits] */

      /*-------------------------------------------------------------------------
        Calculate help variables
        --------------------------------------------------------------------------*/

      /* general: */
      nEnv = nL + nR + 1; /* # envelopes */
      if (nEnv > MAX_ENVELOPES) return 0;
      b = nEnv + 1; /* # borders   */

      /*-------------------------------------------------------------------------
        Decode envelopes
        --------------------------------------------------------------------------*/

      /* L-borders:   */
      border = aL; /* first border */
      pFrameInfo->borders[0] = border;

      for (k = 1; k <= nL; k++) {
        temp = FDKreadBits(hBs, 2); /* R [2 bits] */
        border += (2 * temp + 2);   /* R -> r                */
        pFrameInfo->borders[k] = border;
      }

      /* R-borders:  */
      border = aR; /* last border */
      i = nEnv;

      pFrameInfo->borders[i] = border;

      for (k = 0; k < nR; k++) {
        temp = FDKreadBits(hBs, 2); /* R [2 bits] */
        border -= (2 * temp + 2);   /* R -> r                */
        pFrameInfo->borders[--i] = border;
      }

      /* decode pointer: */
      pointer_bits =
          DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(nL + nR + 1));
      p = FDKreadBits(hBs, pointer_bits); /* p = P [pointer_bits bits] */

      if (p > nL + nR + 1) return 0;

      pFrameInfo->tranEnv = p ? b - p : -1;

      /* decode freq res: */
      for (k = 0; k < nEnv; k++) {
        pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
      }

      /*-------------------------------------------------------------------------
        Decode noise floors
        --------------------------------------------------------------------------*/
      pFrameInfo->bordersNoise[0] = aL;

      if (nEnv == 1) {
        /* 1 noise floor envelope: */
        pFrameInfo->bordersNoise[1] = aR;
      } else {
        /* 2 noise floor envelopes */
        if (p == 0 || p == 1)
          pFrameInfo->bordersNoise[1] = pFrameInfo->borders[nEnv - 1];
        else
          pFrameInfo->bordersNoise[1] =
              pFrameInfo->borders[pFrameInfo->tranEnv];
        pFrameInfo->bordersNoise[2] = aR;
      }
      break;
  }

  /*
    Store number of envelopes, noise floor envelopes and frame class
  */
  pFrameInfo->nEnvelopes = nEnv;

  if (nEnv == 1)
    pFrameInfo->nNoiseEnvelopes = 1;
  else
    pFrameInfo->nNoiseEnvelopes = 2;

  pFrameInfo->frameClass = frameClass;

  if (pFrameInfo->frameClass == 2 || pFrameInfo->frameClass == 1) {
    /* calculate noise floor first and last borders: */
    pFrameInfo->bordersNoise[0] = pFrameInfo->borders[0];
    pFrameInfo->bordersNoise[pFrameInfo->nNoiseEnvelopes] =
        pFrameInfo->borders[nEnv];
  }

  return 1;
}

/*!
  \brief   Check if the frameInfo vector has reasonable values.
  \return  Zero for error, one for correct
*/
static int checkFrameInfo(
    FRAME_INFO *pFrameInfo, /*!< pointer to frameInfo */
    int numberOfTimeSlots,  /*!< QMF time slots per frame */
    int overlap,            /*!< Amount of overlap QMF time slots */
    int timeStep)           /*!< QMF slots to SBR slots step factor */
{
  int maxPos, i, j;
  int startPos;
  int stopPos;
  int tranEnv;
  int startPosNoise;
  int stopPosNoise;
  int nEnvelopes = pFrameInfo->nEnvelopes;
  int nNoiseEnvelopes = pFrameInfo->nNoiseEnvelopes;

  if (nEnvelopes < 1 || nEnvelopes > MAX_ENVELOPES) return 0;

  if (nNoiseEnvelopes > MAX_NOISE_ENVELOPES) return 0;

  startPos = pFrameInfo->borders[0];
  stopPos = pFrameInfo->borders[nEnvelopes];
  tranEnv = pFrameInfo->tranEnv;
  startPosNoise = pFrameInfo->bordersNoise[0];
  stopPosNoise = pFrameInfo->bordersNoise[nNoiseEnvelopes];

  if (overlap < 0 || overlap > (3 * (4))) {
    return 0;
  }
  if (timeStep < 1 || timeStep > (4)) {
    return 0;
  }
  maxPos = numberOfTimeSlots + (overlap / timeStep);

  /* Check that the start and stop positions of the frame are reasonable values.
   */
  if ((startPos < 0) || (startPos >= stopPos)) return 0;
  if (startPos > maxPos - numberOfTimeSlots) /* First env. must start in or
                                                directly after the overlap
                                                buffer */
    return 0;
  if (stopPos < numberOfTimeSlots) /* One complete frame must be ready for
                                      output after processing */
    return 0;
  if (stopPos > maxPos) return 0;

  /* Check that the  start border for every envelope is strictly later in time
   */
  for (i = 0; i < nEnvelopes; i++) {
    if (pFrameInfo->borders[i] >= pFrameInfo->borders[i + 1]) return 0;
  }

  /* Check that the envelope to be shortened is actually among the envelopes */
  if (tranEnv > nEnvelopes) return 0;

  /* Check the noise borders */
  if (nEnvelopes == 1 && nNoiseEnvelopes > 1) return 0;

  if (startPos != startPosNoise || stopPos != stopPosNoise) return 0;

  /* Check that the  start border for every noise-envelope is strictly later in
   * time*/
  for (i = 0; i < nNoiseEnvelopes; i++) {
    if (pFrameInfo->bordersNoise[i] >= pFrameInfo->bordersNoise[i + 1])
      return 0;
  }

  /* Check that every noise border is the same as an envelope border*/
  for (i = 0; i < nNoiseEnvelopes; i++) {
    startPosNoise = pFrameInfo->bordersNoise[i];

    for (j = 0; j < nEnvelopes; j++) {
      if (pFrameInfo->borders[j] == startPosNoise) break;
    }
    if (j == nEnvelopes) return 0;
  }

  return 1;
}