Merge GStreamer into next

1 files changed, 602 insertions, 0 deletions

diff --git a/fdk-aac/libSBRenc/src/code_env.cpp b/fdk-aac/libSBRenc/src/code_env.cpp
new file mode 100644
index 0000000..fb0f6a4
--- /dev/null
+++ b/fdk-aac/libSBRenc/src/code_env.cpp
@@ -0,0 +1,602 @@
+/* -----------------------------------------------------------------------------
+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):
+
+   Description:
+
+*******************************************************************************/
+
+#include "code_env.h"
+#include "sbrenc_rom.h"
+
+/*****************************************************************************
+
+ functionname: FDKsbrEnc_InitSbrHuffmanTables
+ description:  initializes Huffman Tables dependent on chosen amp_res
+ returns:      error handle
+ input:
+ output:
+
+*****************************************************************************/
+INT FDKsbrEnc_InitSbrHuffmanTables(HANDLE_SBR_ENV_DATA sbrEnvData,
+                                   HANDLE_SBR_CODE_ENVELOPE henv,
+                                   HANDLE_SBR_CODE_ENVELOPE hnoise,
+                                   AMP_RES amp_res) {
+  if ((!henv) || (!hnoise) || (!sbrEnvData)) return (1); /* not init. */
+
+  sbrEnvData->init_sbr_amp_res = amp_res;
+
+  switch (amp_res) {
+    case SBR_AMP_RES_3_0:
+      /*envelope data*/
+
+      /*Level/Pan - coding */
+      sbrEnvData->hufftableLevelTimeC = v_Huff_envelopeLevelC11T;
+      sbrEnvData->hufftableLevelTimeL = v_Huff_envelopeLevelL11T;
+      sbrEnvData->hufftableBalanceTimeC = bookSbrEnvBalanceC11T;
+      sbrEnvData->hufftableBalanceTimeL = bookSbrEnvBalanceL11T;
+
+      sbrEnvData->hufftableLevelFreqC = v_Huff_envelopeLevelC11F;
+      sbrEnvData->hufftableLevelFreqL = v_Huff_envelopeLevelL11F;
+      sbrEnvData->hufftableBalanceFreqC = bookSbrEnvBalanceC11F;
+      sbrEnvData->hufftableBalanceFreqL = bookSbrEnvBalanceL11F;
+
+      /*Right/Left - coding */
+      sbrEnvData->hufftableTimeC = v_Huff_envelopeLevelC11T;
+      sbrEnvData->hufftableTimeL = v_Huff_envelopeLevelL11T;
+      sbrEnvData->hufftableFreqC = v_Huff_envelopeLevelC11F;
+      sbrEnvData->hufftableFreqL = v_Huff_envelopeLevelL11F;
+
+      sbrEnvData->codeBookScfLavBalance = CODE_BOOK_SCF_LAV_BALANCE11;
+      sbrEnvData->codeBookScfLav = CODE_BOOK_SCF_LAV11;
+
+      sbrEnvData->si_sbr_start_env_bits = SI_SBR_START_ENV_BITS_AMP_RES_3_0;
+      sbrEnvData->si_sbr_start_env_bits_balance =
+          SI_SBR_START_ENV_BITS_BALANCE_AMP_RES_3_0;
+      break;
+
+    case SBR_AMP_RES_1_5:
+      /*envelope data*/
+
+      /*Level/Pan - coding */
+      sbrEnvData->hufftableLevelTimeC = v_Huff_envelopeLevelC10T;
+      sbrEnvData->hufftableLevelTimeL = v_Huff_envelopeLevelL10T;
+      sbrEnvData->hufftableBalanceTimeC = bookSbrEnvBalanceC10T;
+      sbrEnvData->hufftableBalanceTimeL = bookSbrEnvBalanceL10T;
+
+      sbrEnvData->hufftableLevelFreqC = v_Huff_envelopeLevelC10F;
+      sbrEnvData->hufftableLevelFreqL = v_Huff_envelopeLevelL10F;
+      sbrEnvData->hufftableBalanceFreqC = bookSbrEnvBalanceC10F;
+      sbrEnvData->hufftableBalanceFreqL = bookSbrEnvBalanceL10F;
+
+      /*Right/Left - coding */
+      sbrEnvData->hufftableTimeC = v_Huff_envelopeLevelC10T;
+      sbrEnvData->hufftableTimeL = v_Huff_envelopeLevelL10T;
+      sbrEnvData->hufftableFreqC = v_Huff_envelopeLevelC10F;
+      sbrEnvData->hufftableFreqL = v_Huff_envelopeLevelL10F;
+
+      sbrEnvData->codeBookScfLavBalance = CODE_BOOK_SCF_LAV_BALANCE10;
+      sbrEnvData->codeBookScfLav = CODE_BOOK_SCF_LAV10;
+
+      sbrEnvData->si_sbr_start_env_bits = SI_SBR_START_ENV_BITS_AMP_RES_1_5;
+      sbrEnvData->si_sbr_start_env_bits_balance =
+          SI_SBR_START_ENV_BITS_BALANCE_AMP_RES_1_5;
+      break;
+
+    default:
+      return (1); /* undefined amp_res mode */
+  }
+
+  /* these are common to both amp_res values */
+  /*Noise data*/
+
+  /*Level/Pan - coding */
+  sbrEnvData->hufftableNoiseLevelTimeC = v_Huff_NoiseLevelC11T;
+  sbrEnvData->hufftableNoiseLevelTimeL = v_Huff_NoiseLevelL11T;
+  sbrEnvData->hufftableNoiseBalanceTimeC = bookSbrNoiseBalanceC11T;
+  sbrEnvData->hufftableNoiseBalanceTimeL = bookSbrNoiseBalanceL11T;
+
+  sbrEnvData->hufftableNoiseLevelFreqC = v_Huff_envelopeLevelC11F;
+  sbrEnvData->hufftableNoiseLevelFreqL = v_Huff_envelopeLevelL11F;
+  sbrEnvData->hufftableNoiseBalanceFreqC = bookSbrEnvBalanceC11F;
+  sbrEnvData->hufftableNoiseBalanceFreqL = bookSbrEnvBalanceL11F;
+
+  /*Right/Left - coding */
+  sbrEnvData->hufftableNoiseTimeC = v_Huff_NoiseLevelC11T;
+  sbrEnvData->hufftableNoiseTimeL = v_Huff_NoiseLevelL11T;
+  sbrEnvData->hufftableNoiseFreqC = v_Huff_envelopeLevelC11F;
+  sbrEnvData->hufftableNoiseFreqL = v_Huff_envelopeLevelL11F;
+
+  sbrEnvData->si_sbr_start_noise_bits = SI_SBR_START_NOISE_BITS_AMP_RES_3_0;
+  sbrEnvData->si_sbr_start_noise_bits_balance =
+      SI_SBR_START_NOISE_BITS_BALANCE_AMP_RES_3_0;
+
+  /* init envelope tables and codebooks */
+  henv->codeBookScfLavBalanceTime = sbrEnvData->codeBookScfLavBalance;
+  henv->codeBookScfLavBalanceFreq = sbrEnvData->codeBookScfLavBalance;
+  henv->codeBookScfLavLevelTime = sbrEnvData->codeBookScfLav;
+  henv->codeBookScfLavLevelFreq = sbrEnvData->codeBookScfLav;
+  henv->codeBookScfLavTime = sbrEnvData->codeBookScfLav;
+  henv->codeBookScfLavFreq = sbrEnvData->codeBookScfLav;
+
+  henv->hufftableLevelTimeL = sbrEnvData->hufftableLevelTimeL;
+  henv->hufftableBalanceTimeL = sbrEnvData->hufftableBalanceTimeL;
+  henv->hufftableTimeL = sbrEnvData->hufftableTimeL;
+  henv->hufftableLevelFreqL = sbrEnvData->hufftableLevelFreqL;
+  henv->hufftableBalanceFreqL = sbrEnvData->hufftableBalanceFreqL;
+  henv->hufftableFreqL = sbrEnvData->hufftableFreqL;
+
+  henv->codeBookScfLavFreq = sbrEnvData->codeBookScfLav;
+  henv->codeBookScfLavTime = sbrEnvData->codeBookScfLav;
+
+  henv->start_bits = sbrEnvData->si_sbr_start_env_bits;
+  henv->start_bits_balance = sbrEnvData->si_sbr_start_env_bits_balance;
+
+  /* init noise tables and codebooks */
+
+  hnoise->codeBookScfLavBalanceTime = CODE_BOOK_SCF_LAV_BALANCE11;
+  hnoise->codeBookScfLavBalanceFreq = CODE_BOOK_SCF_LAV_BALANCE11;
+  hnoise->codeBookScfLavLevelTime = CODE_BOOK_SCF_LAV11;
+  hnoise->codeBookScfLavLevelFreq = CODE_BOOK_SCF_LAV11;
+  hnoise->codeBookScfLavTime = CODE_BOOK_SCF_LAV11;
+  hnoise->codeBookScfLavFreq = CODE_BOOK_SCF_LAV11;
+
+  hnoise->hufftableLevelTimeL = sbrEnvData->hufftableNoiseLevelTimeL;
+  hnoise->hufftableBalanceTimeL = sbrEnvData->hufftableNoiseBalanceTimeL;
+  hnoise->hufftableTimeL = sbrEnvData->hufftableNoiseTimeL;
+  hnoise->hufftableLevelFreqL = sbrEnvData->hufftableNoiseLevelFreqL;
+  hnoise->hufftableBalanceFreqL = sbrEnvData->hufftableNoiseBalanceFreqL;
+  hnoise->hufftableFreqL = sbrEnvData->hufftableNoiseFreqL;
+
+  hnoise->start_bits = sbrEnvData->si_sbr_start_noise_bits;
+  hnoise->start_bits_balance = sbrEnvData->si_sbr_start_noise_bits_balance;
+
+  /* No delta coding in time from the previous frame due to 1.5dB FIx-FIX rule
+   */
+  henv->upDate = 0;
+  hnoise->upDate = 0;
+  return (0);
+}
+
+/*******************************************************************************
+ Functionname:  indexLow2High
+ *******************************************************************************
+
+ Description:   Nice small patch-functions in order to cope with non-factor-2
+                ratios between high-res and low-res
+
+ Arguments:     INT offset, INT index, FREQ_RES res
+
+ Return:        INT
+
+*******************************************************************************/
+static INT indexLow2High(INT offset, INT index, FREQ_RES res) {
+  if (res == FREQ_RES_LOW) {
+    if (offset >= 0) {
+      if (index < offset)
+        return (index);
+      else
+        return (2 * index - offset);
+    } else {
+      offset = -offset;
+      if (index < offset)
+        return (2 * index + index);
+      else
+        return (2 * index + offset);
+    }
+  } else
+    return (index);
+}
+
+/*******************************************************************************
+ Functionname:  mapLowResEnergyVal
+ *******************************************************************************
+
+ Description:
+
+ Arguments:     INT currVal,INT* prevData, INT offset, INT index, FREQ_RES res
+
+ Return:        none
+
+*******************************************************************************/
+static void mapLowResEnergyVal(SCHAR currVal, SCHAR *prevData, INT offset,
+                               INT index, FREQ_RES res) {
+  if (res == FREQ_RES_LOW) {
+    if (offset >= 0) {
+      if (index < offset)
+        prevData[index] = currVal;
+      else {
+        prevData[2 * index - offset] = currVal;
+        prevData[2 * index + 1 - offset] = currVal;
+      }
+    } else {
+      offset = -offset;
+      if (index < offset) {
+        prevData[3 * index] = currVal;
+        prevData[3 * index + 1] = currVal;
+        prevData[3 * index + 2] = currVal;
+      } else {
+        prevData[2 * index + offset] = currVal;
+        prevData[2 * index + 1 + offset] = currVal;
+      }
+    }
+  } else
+    prevData[index] = currVal;
+}
+
+/*******************************************************************************
+ Functionname:  computeBits
+ *******************************************************************************
+
+ Description:
+
+ Arguments:     INT delta,
+                INT codeBookScfLavLevel,
+                INT codeBookScfLavBalance,
+                const UCHAR * hufftableLevel,
+                const UCHAR * hufftableBalance, INT coupling, INT channel)
+
+ Return:        INT
+
+*******************************************************************************/
+static INT computeBits(SCHAR *delta, INT codeBookScfLavLevel,
+                       INT codeBookScfLavBalance, const UCHAR *hufftableLevel,
+                       const UCHAR *hufftableBalance, INT coupling,
+                       INT channel) {
+  INT index;
+  INT delta_bits = 0;
+
+  if (coupling) {
+    if (channel == 1) {
+      if (*delta < 0)
+        index = fixMax(*delta, -codeBookScfLavBalance);
+      else
+        index = fixMin(*delta, codeBookScfLavBalance);
+
+      if (index != *delta) {
+        *delta = index;
+        return (10000);
+      }
+
+      delta_bits = hufftableBalance[index + codeBookScfLavBalance];
+    } else {
+      if (*delta < 0)
+        index = fixMax(*delta, -codeBookScfLavLevel);
+      else
+        index = fixMin(*delta, codeBookScfLavLevel);
+
+      if (index != *delta) {
+        *delta = index;
+        return (10000);
+      }
+      delta_bits = hufftableLevel[index + codeBookScfLavLevel];
+    }
+  } else {
+    if (*delta < 0)
+      index = fixMax(*delta, -codeBookScfLavLevel);
+    else
+      index = fixMin(*delta, codeBookScfLavLevel);
+
+    if (index != *delta) {
+      *delta = index;
+      return (10000);
+    }
+    delta_bits = hufftableLevel[index + codeBookScfLavLevel];
+  }
+
+  return (delta_bits);
+}
+
+/*******************************************************************************
+ Functionname:  FDKsbrEnc_codeEnvelope
+ *******************************************************************************
+
+ Description:
+
+ Arguments:     INT *sfb_nrg,
+                const FREQ_RES *freq_res,
+                SBR_CODE_ENVELOPE * h_sbrCodeEnvelope,
+                INT *directionVec, INT scalable, INT nEnvelopes, INT channel,
+                INT headerActive)
+
+ Return:        none
+                h_sbrCodeEnvelope->sfb_nrg_prev is modified !
+                sfb_nrg is modified
+                h_sbrCodeEnvelope->update is modfied !
+                *directionVec is modified
+
+*******************************************************************************/
+void FDKsbrEnc_codeEnvelope(SCHAR *sfb_nrg, const FREQ_RES *freq_res,
+                            SBR_CODE_ENVELOPE *h_sbrCodeEnvelope,
+                            INT *directionVec, INT coupling, INT nEnvelopes,
+                            INT channel, INT headerActive) {
+  INT i, no_of_bands, band;
+  FIXP_DBL tmp1, tmp2, tmp3, dF_edge_1stEnv;
+  SCHAR *ptr_nrg;
+
+  INT codeBookScfLavLevelTime;
+  INT codeBookScfLavLevelFreq;
+  INT codeBookScfLavBalanceTime;
+  INT codeBookScfLavBalanceFreq;
+  const UCHAR *hufftableLevelTimeL;
+  const UCHAR *hufftableBalanceTimeL;
+  const UCHAR *hufftableLevelFreqL;
+  const UCHAR *hufftableBalanceFreqL;
+
+  INT offset = h_sbrCodeEnvelope->offset;
+  INT envDataTableCompFactor;
+
+  INT delta_F_bits = 0, delta_T_bits = 0;
+  INT use_dT;
+
+  SCHAR delta_F[MAX_FREQ_COEFFS];
+  SCHAR delta_T[MAX_FREQ_COEFFS];
+  SCHAR last_nrg, curr_nrg;
+
+  tmp1 = FL2FXCONST_DBL(0.5f) >> (DFRACT_BITS - 16 - 1);
+  tmp2 = h_sbrCodeEnvelope->dF_edge_1stEnv >> (DFRACT_BITS - 16);
+  tmp3 = (FIXP_DBL)fMult(h_sbrCodeEnvelope->dF_edge_incr,
+                         ((FIXP_DBL)h_sbrCodeEnvelope->dF_edge_incr_fac) << 15);
+
+  dF_edge_1stEnv = tmp1 + tmp2 + tmp3;
+
+  if (coupling) {
+    codeBookScfLavLevelTime = h_sbrCodeEnvelope->codeBookScfLavLevelTime;
+    codeBookScfLavLevelFreq = h_sbrCodeEnvelope->codeBookScfLavLevelFreq;
+    codeBookScfLavBalanceTime = h_sbrCodeEnvelope->codeBookScfLavBalanceTime;
+    codeBookScfLavBalanceFreq = h_sbrCodeEnvelope->codeBookScfLavBalanceFreq;
+    hufftableLevelTimeL = h_sbrCodeEnvelope->hufftableLevelTimeL;
+    hufftableBalanceTimeL = h_sbrCodeEnvelope->hufftableBalanceTimeL;
+    hufftableLevelFreqL = h_sbrCodeEnvelope->hufftableLevelFreqL;
+    hufftableBalanceFreqL = h_sbrCodeEnvelope->hufftableBalanceFreqL;
+  } else {
+    codeBookScfLavLevelTime = h_sbrCodeEnvelope->codeBookScfLavTime;
+    codeBookScfLavLevelFreq = h_sbrCodeEnvelope->codeBookScfLavFreq;
+    codeBookScfLavBalanceTime = h_sbrCodeEnvelope->codeBookScfLavTime;
+    codeBookScfLavBalanceFreq = h_sbrCodeEnvelope->codeBookScfLavFreq;
+    hufftableLevelTimeL = h_sbrCodeEnvelope->hufftableTimeL;
+    hufftableBalanceTimeL = h_sbrCodeEnvelope->hufftableTimeL;
+    hufftableLevelFreqL = h_sbrCodeEnvelope->hufftableFreqL;
+    hufftableBalanceFreqL = h_sbrCodeEnvelope->hufftableFreqL;
+  }
+
+  if (coupling == 1 && channel == 1)
+    envDataTableCompFactor =
+        1; /*should be one when the new huffman-tables are ready*/
+  else
+    envDataTableCompFactor = 0;
+
+  if (h_sbrCodeEnvelope->deltaTAcrossFrames == 0) h_sbrCodeEnvelope->upDate = 0;
+
+  /* no delta coding in time in case of a header */
+  if (headerActive) h_sbrCodeEnvelope->upDate = 0;
+
+  for (i = 0; i < nEnvelopes; i++) {
+    if (freq_res[i] == FREQ_RES_HIGH)
+      no_of_bands = h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH];
+    else
+      no_of_bands = h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW];
+
+    ptr_nrg = sfb_nrg;
+    curr_nrg = *ptr_nrg;
+
+    delta_F[0] = curr_nrg >> envDataTableCompFactor;
+
+    if (coupling && channel == 1)
+      delta_F_bits = h_sbrCodeEnvelope->start_bits_balance;
+    else
+      delta_F_bits = h_sbrCodeEnvelope->start_bits;
+
+    if (h_sbrCodeEnvelope->upDate != 0) {
+      delta_T[0] = (curr_nrg - h_sbrCodeEnvelope->sfb_nrg_prev[0]) >>
+                   envDataTableCompFactor;
+
+      delta_T_bits = computeBits(&delta_T[0], codeBookScfLavLevelTime,
+                                 codeBookScfLavBalanceTime, hufftableLevelTimeL,
+                                 hufftableBalanceTimeL, coupling, channel);
+    }
+
+    mapLowResEnergyVal(curr_nrg, h_sbrCodeEnvelope->sfb_nrg_prev, offset, 0,
+                       freq_res[i]);
+
+    /* ensure that nrg difference is not higher than codeBookScfLavXXXFreq */
+    if (coupling && channel == 1) {
+      for (band = no_of_bands - 1; band > 0; band--) {
+        if (ptr_nrg[band] - ptr_nrg[band - 1] > codeBookScfLavBalanceFreq) {
+          ptr_nrg[band - 1] = ptr_nrg[band] - codeBookScfLavBalanceFreq;
+        }
+      }
+      for (band = 1; band < no_of_bands; band++) {
+        if (ptr_nrg[band - 1] - ptr_nrg[band] > codeBookScfLavBalanceFreq) {
+          ptr_nrg[band] = ptr_nrg[band - 1] - codeBookScfLavBalanceFreq;
+        }
+      }
+    } else {
+      for (band = no_of_bands - 1; band > 0; band--) {
+        if (ptr_nrg[band] - ptr_nrg[band - 1] > codeBookScfLavLevelFreq) {
+          ptr_nrg[band - 1] = ptr_nrg[band] - codeBookScfLavLevelFreq;
+        }
+      }
+      for (band = 1; band < no_of_bands; band++) {
+        if (ptr_nrg[band - 1] - ptr_nrg[band] > codeBookScfLavLevelFreq) {
+          ptr_nrg[band] = ptr_nrg[band - 1] - codeBookScfLavLevelFreq;
+        }
+      }
+    }
+
+    /* Coding loop*/
+    for (band = 1; band < no_of_bands; band++) {
+      last_nrg = (*ptr_nrg);
+      ptr_nrg++;
+      curr_nrg = (*ptr_nrg);
+
+      delta_F[band] = (curr_nrg - last_nrg) >> envDataTableCompFactor;
+
+      delta_F_bits += computeBits(
+          &delta_F[band], codeBookScfLavLevelFreq, codeBookScfLavBalanceFreq,
+          hufftableLevelFreqL, hufftableBalanceFreqL, coupling, channel);
+
+      if (h_sbrCodeEnvelope->upDate != 0) {
+        delta_T[band] =
+            curr_nrg -
+            h_sbrCodeEnvelope
+                ->sfb_nrg_prev[indexLow2High(offset, band, freq_res[i])];
+        delta_T[band] = delta_T[band] >> envDataTableCompFactor;
+      }
+
+      mapLowResEnergyVal(curr_nrg, h_sbrCodeEnvelope->sfb_nrg_prev, offset,
+                         band, freq_res[i]);
+
+      if (h_sbrCodeEnvelope->upDate != 0) {
+        delta_T_bits += computeBits(
+            &delta_T[band], codeBookScfLavLevelTime, codeBookScfLavBalanceTime,
+            hufftableLevelTimeL, hufftableBalanceTimeL, coupling, channel);
+      }
+    }
+
+    /* Replace sfb_nrg with deltacoded samples and set flag */
+    if (i == 0) {
+      INT tmp_bits;
+      tmp_bits = (((delta_T_bits * dF_edge_1stEnv) >> (DFRACT_BITS - 18)) +
+                  (FIXP_DBL)1) >>
+                 1;
+      use_dT = (h_sbrCodeEnvelope->upDate != 0 && (delta_F_bits > tmp_bits));
+    } else
+      use_dT = (delta_T_bits < delta_F_bits && h_sbrCodeEnvelope->upDate != 0);
+
+    if (use_dT) {
+      directionVec[i] = TIME;
+      FDKmemcpy(sfb_nrg, delta_T, no_of_bands * sizeof(SCHAR));
+    } else {
+      h_sbrCodeEnvelope->upDate = 0;
+      directionVec[i] = FREQ;
+      FDKmemcpy(sfb_nrg, delta_F, no_of_bands * sizeof(SCHAR));
+    }
+    sfb_nrg += no_of_bands;
+    h_sbrCodeEnvelope->upDate = 1;
+  }
+}
+
+/*******************************************************************************
+ Functionname:  FDKsbrEnc_InitSbrCodeEnvelope
+ *******************************************************************************
+
+ Description:
+
+ Arguments:
+
+ Return:
+
+*******************************************************************************/
+INT FDKsbrEnc_InitSbrCodeEnvelope(HANDLE_SBR_CODE_ENVELOPE h_sbrCodeEnvelope,
+                                  INT *nSfb, INT deltaTAcrossFrames,
+                                  FIXP_DBL dF_edge_1stEnv,
+                                  FIXP_DBL dF_edge_incr) {
+  FDKmemclear(h_sbrCodeEnvelope, sizeof(SBR_CODE_ENVELOPE));
+
+  h_sbrCodeEnvelope->deltaTAcrossFrames = deltaTAcrossFrames;
+  h_sbrCodeEnvelope->dF_edge_1stEnv = dF_edge_1stEnv;
+  h_sbrCodeEnvelope->dF_edge_incr = dF_edge_incr;
+  h_sbrCodeEnvelope->dF_edge_incr_fac = 0;
+  h_sbrCodeEnvelope->upDate = 0;
+  h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW] = nSfb[FREQ_RES_LOW];
+  h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH] = nSfb[FREQ_RES_HIGH];
+  h_sbrCodeEnvelope->offset = 2 * h_sbrCodeEnvelope->nSfb[FREQ_RES_LOW] -
+                              h_sbrCodeEnvelope->nSfb[FREQ_RES_HIGH];
+
+  return (0);
+}