summaryrefslogtreecommitdiffstats
path: root/fdk-aac/libSBRenc/src/code_env.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fdk-aac/libSBRenc/src/code_env.cpp')
-rw-r--r--fdk-aac/libSBRenc/src/code_env.cpp602
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);
+}