aboutsummaryrefslogtreecommitdiffstats
path: root/libSBRdec/src/env_calc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libSBRdec/src/env_calc.cpp')
-rw-r--r--libSBRdec/src/env_calc.cpp2229
1 files changed, 2229 insertions, 0 deletions
diff --git a/libSBRdec/src/env_calc.cpp b/libSBRdec/src/env_calc.cpp
new file mode 100644
index 0000000..11df761
--- /dev/null
+++ b/libSBRdec/src/env_calc.cpp
@@ -0,0 +1,2229 @@
+
+/* -----------------------------------------------------------------------------------------------------------
+Software License for The Fraunhofer FDK AAC Codec Library for Android
+
+© Copyright 1995 - 2012 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
+----------------------------------------------------------------------------------------------------------- */
+
+/*!
+ \file
+ \brief Envelope calculation
+
+ The envelope adjustor compares the energies present in the transposed
+ highband to the reference energies conveyed with the bitstream.
+ The highband is amplified (sometimes) or attenuated (mostly) to the
+ desired level.
+
+ The spectral shape of the reference energies can be changed several times per
+ frame if necessary. Each set of energy values corresponding to a certain range
+ in time will be called an <em>envelope</em> here.
+ The bitstream supports several frequency scales and two resolutions. Normally,
+ one or more QMF-subbands are grouped to one SBR-band. An envelope contains
+ reference energies for each SBR-band.
+ In addition to the energy envelopes, noise envelopes are transmitted that
+ define the ratio of energy which is generated by adding noise instead of
+ transposing the lowband. The noise envelopes are given in a coarser time
+ and frequency resolution.
+ If a signal contains strong tonal components, synthetic sines can be
+ generated in individual SBR bands.
+
+ An overlap buffer of 6 QMF-timeslots is used to allow a more
+ flexible alignment of the envelopes in time that is not restricted to the
+ core codec's frame borders.
+ Therefore the envelope adjustor has access to the spectral data of the
+ current frame as well as the last 6 QMF-timeslots of the previous frame.
+ However, in average only the data of 1 frame is being processed as
+ the adjustor is called once per frame.
+
+ Depending on the frequency range set in the bitstream, only QMF-subbands between
+ <em>lowSubband</em> and <em>highSubband</em> are adjusted.
+
+ Scaling of spectral data to maximize SNR (see #QMF_SCALE_FACTOR) as well as a special Mantissa-Exponent format
+ ( see calculateSbrEnvelope() ) are being used. The main entry point for this modules is calculateSbrEnvelope().
+
+ \sa sbr_scale.h, #QMF_SCALE_FACTOR, calculateSbrEnvelope(), \ref documentationOverview
+*/
+
+
+#include "env_calc.h"
+
+#include "sbrdec_freq_sca.h"
+#include "env_extr.h"
+#include "transcendent.h"
+#include "sbr_ram.h"
+#include "sbr_rom.h"
+
+#include "genericStds.h" /* need FDKpow() for debug outputs */
+
+#if defined(__arm__)
+#include "arm/env_calc_arm.cpp"
+#endif
+
+typedef struct
+{
+ FIXP_DBL nrgRef[MAX_FREQ_COEFFS];
+ FIXP_DBL nrgEst[MAX_FREQ_COEFFS];
+ FIXP_DBL nrgGain[MAX_FREQ_COEFFS];
+ FIXP_DBL noiseLevel[MAX_FREQ_COEFFS];
+ FIXP_DBL nrgSine[MAX_FREQ_COEFFS];
+
+ SCHAR nrgRef_e[MAX_FREQ_COEFFS];
+ SCHAR nrgEst_e[MAX_FREQ_COEFFS];
+ SCHAR nrgGain_e[MAX_FREQ_COEFFS];
+ SCHAR noiseLevel_e[MAX_FREQ_COEFFS];
+ SCHAR nrgSine_e[MAX_FREQ_COEFFS];
+}
+ENV_CALC_NRGS;
+
+/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer,
+ SCHAR *filtBuffer_e,
+ FIXP_DBL *NrgGain,
+ SCHAR *NrgGain_e,
+ int subbands);
+
+/*static*/ void calcNrgPerSubband(FIXP_DBL **analysBufferReal,
+ FIXP_DBL **analysBufferImag,
+ int lowSubband, int highSubband,
+ int start_pos, int next_pos,
+ SCHAR frameExp,
+ FIXP_DBL *nrgEst,
+ SCHAR *nrgEst_e );
+
+/*static*/ void calcNrgPerSfb(FIXP_DBL **analysBufferReal,
+ FIXP_DBL **analysBufferImag,
+ int nSfb,
+ UCHAR *freqBandTable,
+ int start_pos, int next_pos,
+ SCHAR input_e,
+ FIXP_DBL *nrg_est,
+ SCHAR *nrg_est_e );
+
+/*static*/ void calcSubbandGain(FIXP_DBL nrgRef, SCHAR nrgRef_e, ENV_CALC_NRGS* nrgs, int c,
+ FIXP_DBL tmpNoise, SCHAR tmpNoise_e,
+ UCHAR sinePresentFlag,
+ UCHAR sineMapped,
+ int noNoiseFlag);
+
+/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
+ int lowSubband,
+ int highSubband,
+ FIXP_DBL *sumRef_m,
+ SCHAR *sumRef_e,
+ FIXP_DBL *ptrAvgGain_m,
+ SCHAR *ptrAvgGain_e);
+
+/*static*/ void adjustTimeSlotLC(FIXP_DBL *ptrReal,
+ ENV_CALC_NRGS* nrgs,
+ UCHAR *ptrHarmIndex,
+ int lowSubbands,
+ int noSubbands,
+ int scale_change,
+ int noNoiseFlag,
+ int *ptrPhaseIndex,
+ int fCldfb);
+/*static*/ void adjustTimeSlotHQ(FIXP_DBL *ptrReal,
+ FIXP_DBL *ptrImag,
+ HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
+ ENV_CALC_NRGS* nrgs,
+ int lowSubbands,
+ int noSubbands,
+ int scale_change,
+ FIXP_SGL smooth_ratio,
+ int noNoiseFlag,
+ int filtBufferNoiseShift);
+
+
+/*!
+ \brief Map sine flags from bitstream to QMF bands
+
+ The bitstream carries only 1 sine flag per band and frame.
+ This function maps every sine flag from the bitstream to a specific QMF subband
+ and to a specific envelope where the sine shall start.
+ The result is stored in the vector sineMapped which contains one entry per
+ QMF subband. The value of an entry specifies the envelope where a sine
+ shall start. A value of #MAX_ENVELOPES indicates that no sine is present
+ in the subband.
+ The missing harmonics flags from the previous frame (harmFlagsPrev) determine
+ if a sine starts at the beginning of the frame or at the transient position.
+ Additionally, the flags in harmFlagsPrev are being updated by this function
+ for the next frame.
+*/
+/*static*/ void mapSineFlags(UCHAR *freqBandTable, /*!< Band borders (there's only 1 flag per band) */
+ int nSfb, /*!< Number of bands in the table */
+ UCHAR *addHarmonics, /*!< vector with 1 flag per sfb */
+ int *harmFlagsPrev, /*!< Packed 'addHarmonics' */
+ int tranEnv, /*!< Transient position */
+ SCHAR *sineMapped) /*!< Resulting vector of sine start positions for each QMF band */
+
+{
+ int i;
+ int lowSubband2 = freqBandTable[0]<<1;
+ int bitcount = 0;
+ int oldflags = *harmFlagsPrev;
+ int newflags = 0;
+
+ /*
+ Format of harmFlagsPrev:
+
+ first word = flags for highest 16 sfb bands in use
+ second word = flags for next lower 16 sfb bands (if present)
+ third word = flags for lowest 16 sfb bands (if present)
+
+ Up to MAX_FREQ_COEFFS sfb bands can be flagged for a sign.
+ The lowest bit of the first word corresponds to the _highest_ sfb band in use.
+ This is ensures that each flag is mapped to the same QMF band even after a
+ change of the crossover-frequency.
+ */
+
+
+ /* Reset the output vector first */
+ FDKmemset(sineMapped, MAX_ENVELOPES,MAX_FREQ_COEFFS); /* MAX_ENVELOPES means 'no sine' */
+
+ freqBandTable += nSfb;
+ addHarmonics += nSfb-1;
+
+ for (i=nSfb; i!=0; i--) {
+ int ui = *freqBandTable--; /* Upper limit of the current scale factor band. */
+ int li = *freqBandTable; /* Lower limit of the current scale factor band. */
+
+ if ( *addHarmonics-- ) { /* There is a sine in this band */
+
+ unsigned int mask = 1 << bitcount;
+ newflags |= mask; /* Set flag */
+
+ /*
+ If there was a sine in the last frame, let it continue from the first envelope on
+ else start at the transient position.
+ */
+ sineMapped[(ui+li-lowSubband2) >> 1] = ( oldflags & mask ) ? 0 : tranEnv;
+ }
+
+ if ((++bitcount == 16) || i==1) {
+ bitcount = 0;
+ *harmFlagsPrev++ = newflags;
+ oldflags = *harmFlagsPrev; /* Fetch 16 of the old flags */
+ newflags = 0;
+ }
+ }
+}
+
+
+/*!
+ \brief Reduce gain-adjustment induced aliasing for real valued filterbank.
+*/
+/*static*/ void
+aliasingReduction(FIXP_DBL* degreeAlias, /*!< estimated aliasing for each QMF channel */
+ ENV_CALC_NRGS* nrgs,
+ int* useAliasReduction, /*!< synthetic sine engergy for each subband, used as flag */
+ int noSubbands) /*!< number of QMF channels to process */
+{
+ FIXP_DBL* nrgGain = nrgs->nrgGain; /*!< subband gains to be modified */
+ SCHAR* nrgGain_e = nrgs->nrgGain_e; /*!< subband gains to be modified (exponents) */
+ FIXP_DBL* nrgEst = nrgs->nrgEst; /*!< subband energy before amplification */
+ SCHAR* nrgEst_e = nrgs->nrgEst_e; /*!< subband energy before amplification (exponents) */
+ int grouping = 0, index = 0, noGroups, k;
+ int groupVector[MAX_FREQ_COEFFS];
+
+ /* Calculate grouping*/
+ for (k = 0; k < noSubbands-1; k++ ){
+ if ( (degreeAlias[k + 1] != FL2FXCONST_DBL(0.0f)) && useAliasReduction[k] ) {
+ if(grouping==0){
+ groupVector[index++] = k;
+ grouping = 1;
+ }
+ else{
+ if(groupVector[index-1] + 3 == k){
+ groupVector[index++] = k + 1;
+ grouping = 0;
+ }
+ }
+ }
+ else{
+ if(grouping){
+ if(useAliasReduction[k])
+ groupVector[index++] = k + 1;
+ else
+ groupVector[index++] = k;
+ grouping = 0;
+ }
+ }
+ }
+
+ if(grouping){
+ groupVector[index++] = noSubbands;
+ }
+ noGroups = index >> 1;
+
+
+ /*Calculate new gain*/
+ for (int group = 0; group < noGroups; group ++) {
+ FIXP_DBL nrgOrig = FL2FXCONST_DBL(0.0f); /* Original signal energy in current group of bands */
+ SCHAR nrgOrig_e = 0;
+ FIXP_DBL nrgAmp = FL2FXCONST_DBL(0.0f); /* Amplified signal energy in group (using current gains) */
+ SCHAR nrgAmp_e = 0;
+ FIXP_DBL nrgMod = FL2FXCONST_DBL(0.0f); /* Signal energy in group when applying modified gains */
+ SCHAR nrgMod_e = 0;
+ FIXP_DBL groupGain; /* Total energy gain in group */
+ SCHAR groupGain_e;
+ FIXP_DBL compensation; /* Compensation factor for the energy change when applying modified gains */
+ SCHAR compensation_e;
+
+ int startGroup = groupVector[2*group];
+ int stopGroup = groupVector[2*group+1];
+
+ /* Calculate total energy in group before and after amplification with current gains: */
+ for(k = startGroup; k < stopGroup; k++){
+ /* Get original band energy */
+ FIXP_DBL tmp = nrgEst[k];
+ SCHAR tmp_e = nrgEst_e[k];
+
+ FDK_add_MantExp(tmp, tmp_e, nrgOrig, nrgOrig_e, &nrgOrig, &nrgOrig_e);
+
+ /* Multiply band energy with current gain */
+ tmp = fMult(tmp,nrgGain[k]);
+ tmp_e = tmp_e + nrgGain_e[k];
+
+ FDK_add_MantExp(tmp, tmp_e, nrgAmp, nrgAmp_e, &nrgAmp, &nrgAmp_e);
+ }
+
+ /* Calculate total energy gain in group */
+ FDK_divide_MantExp(nrgAmp, nrgAmp_e,
+ nrgOrig, nrgOrig_e,
+ &groupGain, &groupGain_e);
+
+ for(k = startGroup; k < stopGroup; k++){
+ FIXP_DBL tmp;
+ SCHAR tmp_e;
+
+ FIXP_DBL alpha = degreeAlias[k];
+ if (k < noSubbands - 1) {
+ if (degreeAlias[k + 1] > alpha)
+ alpha = degreeAlias[k + 1];
+ }
+
+ /* Modify gain depending on the degree of aliasing */
+ FDK_add_MantExp( fMult(alpha,groupGain), groupGain_e,
+ fMult(/*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - alpha,nrgGain[k]), nrgGain_e[k],
+ &nrgGain[k], &nrgGain_e[k] );
+
+ /* Apply modified gain to original energy */
+ tmp = fMult(nrgGain[k],nrgEst[k]);
+ tmp_e = nrgGain_e[k] + nrgEst_e[k];
+
+ /* Accumulate energy with modified gains applied */
+ FDK_add_MantExp( tmp, tmp_e,
+ nrgMod, nrgMod_e,
+ &nrgMod, &nrgMod_e );
+ }
+
+ /* Calculate compensation factor to retain the energy of the amplified signal */
+ FDK_divide_MantExp(nrgAmp, nrgAmp_e,
+ nrgMod, nrgMod_e,
+ &compensation, &compensation_e);
+
+ /* Apply compensation factor to all gains of the group */
+ for(k = startGroup; k < stopGroup; k++){
+ nrgGain[k] = fMult(nrgGain[k],compensation);
+ nrgGain_e[k] = nrgGain_e[k] + compensation_e;
+ }
+ }
+}
+
+
+ /* Convert headroom bits to exponent */
+#define SCALE2EXP(s) (15-(s))
+#define EXP2SCALE(e) (15-(e))
+
+/*!
+ \brief Apply spectral envelope to subband samples
+
+ This function is called from sbr_dec.cpp in each frame.
+
+ To enhance accuracy and due to the usage of tables for squareroots and
+ inverse, some calculations are performed with the operands being split
+ into mantissa and exponent. The variable names in the source code carry
+ the suffixes <em>_m</em> and <em>_e</em> respectively. The control data
+ in #hFrameData containts envelope data which is represented by this format but
+ stored in single words. (See requantizeEnvelopeData() for details). This data
+ is unpacked within calculateSbrEnvelope() to follow the described suffix convention.
+
+ The actual value (comparable to the corresponding float-variable in the
+ research-implementation) of a mantissa/exponent-pair can be calculated as
+
+ \f$ value = value\_m * 2^{value\_e} \f$
+
+ All energies and noise levels decoded from the bitstream suit for an
+ original signal magnitude of \f$\pm 32768 \f$ rather than \f$ \pm 1\f$. Therefore,
+ the scale factor <em>hb_scale</em> passed into this function will be converted
+ to an 'input exponent' (#input_e), which fits the internal representation.
+
+ Before the actual processing, an exponent #adj_e for resulting adjusted
+ samples is derived from the maximum reference energy.
+
+ Then, for each envelope, the following steps are performed:
+
+ \li Calculate energy in the signal to be adjusted. Depending on the the value of
+ #interpolFreq (interpolation mode), this is either done seperately
+ for each QMF-subband or for each SBR-band.
+ The resulting energies are stored in #nrgEst_m[#MAX_FREQ_COEFFS] (mantissas)
+ and #nrgEst_e[#MAX_FREQ_COEFFS] (exponents).
+ \li Calculate gain and noise level for each subband:<br>
+ \f$ gain = \sqrt{ \frac{nrgRef}{nrgEst} \cdot (1 - noiseRatio) }
+ \hspace{2cm}
+ noise = \sqrt{ nrgRef \cdot noiseRatio }
+ \f$<br>
+ where <em>noiseRatio</em> and <em>nrgRef</em> are extracted from the
+ bitstream and <em>nrgEst</em> is the subband energy before adjustment.
+ The resulting gains are stored in #nrgGain_m[#MAX_FREQ_COEFFS]
+ (mantissas) and #nrgGain_e[#MAX_FREQ_COEFFS] (exponents), the noise levels
+ are stored in #noiseLevel_m[#MAX_FREQ_COEFFS] and #noiseLevel_e[#MAX_FREQ_COEFFS]
+ (exponents).
+ The sine levels are stored in #nrgSine_m[#MAX_FREQ_COEFFS]
+ and #nrgSine_e[#MAX_FREQ_COEFFS].
+ \li Noise limiting: The gain for each subband is limited both absolutely
+ and relatively compared to the total gain over all subbands.
+ \li Boost gain: Calculate and apply boost factor for each limiter band
+ in order to compensate for the energy loss imposed by the limiting.
+ \li Apply gains and add noise: The gains and noise levels are applied
+ to all timeslots of the current envelope. A short FIR-filter (length 4
+ QMF-timeslots) can be used to smooth the sudden change at the envelope borders.
+ Each complex subband sample of the current timeslot is multiplied by the
+ smoothed gain, then random noise with the calculated level is added.
+
+ \note
+ To reduce the stack size, some of the local arrays could be located within
+ the time output buffer. Of the 512 samples temporarily available there,
+ about half the size is already used by #SBR_FRAME_DATA. A pointer to the
+ remaining free memory could be supplied by an additional argument to calculateSbrEnvelope()
+ in sbr_dec:
+
+ \par
+ \code
+ calculateSbrEnvelope (&hSbrDec->sbrScaleFactor,
+ &hSbrDec->SbrCalculateEnvelope,
+ hHeaderData,
+ hFrameData,
+ QmfBufferReal,
+ QmfBufferImag,
+ timeOutPtr + sizeof(SBR_FRAME_DATA)/sizeof(Float) + 1);
+ \endcode
+
+ \par
+ Within calculateSbrEnvelope(), some pointers could be defined instead of the arrays
+ #nrgRef_m, #nrgRef_e, #nrgEst_m, #nrgEst_e, #noiseLevel_m:
+
+ \par
+ \code
+ fract* nrgRef_m = timeOutPtr;
+ SCHAR* nrgRef_e = nrgRef_m + MAX_FREQ_COEFFS;
+ fract* nrgEst_m = nrgRef_e + MAX_FREQ_COEFFS;
+ SCHAR* nrgEst_e = nrgEst_m + MAX_FREQ_COEFFS;
+ fract* noiseLevel_m = nrgEst_e + MAX_FREQ_COEFFS;
+ \endcode
+
+ <br>
+*/
+void
+calculateSbrEnvelope (QMF_SCALE_FACTOR *sbrScaleFactor, /*!< Scaling factors */
+ HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env, /*!< Handle to struct filled by the create-function */
+ HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+ HANDLE_SBR_FRAME_DATA hFrameData, /*!< Control data of current frame */
+ FIXP_DBL **analysBufferReal, /*!< Real part of subband samples to be processed */
+ FIXP_DBL **analysBufferImag, /*!< Imag part of subband samples to be processed */
+ const int useLP,
+ FIXP_DBL *degreeAlias, /*!< Estimated aliasing for each QMF channel */
+ const UINT flags,
+ const int frameErrorFlag
+ )
+{
+ int c, i, j, envNoise = 0;
+ UCHAR* borders = hFrameData->frameInfo.borders;
+
+ FIXP_SGL *noiseLevels = hFrameData->sbrNoiseFloorLevel;
+ HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
+
+ int lowSubband = hFreq->lowSubband;
+ int highSubband = hFreq->highSubband;
+ int noSubbands = highSubband - lowSubband;
+
+ int noNoiseBands = hFreq->nNfb;
+ int no_cols = hHeaderData->numberTimeSlots * hHeaderData->timeStep;
+ UCHAR first_start = borders[0] * hHeaderData->timeStep;
+
+ SCHAR sineMapped[MAX_FREQ_COEFFS];
+ SCHAR ov_adj_e = SCALE2EXP(sbrScaleFactor->ov_hb_scale);
+ SCHAR adj_e = 0;
+ SCHAR output_e;
+ SCHAR final_e = 0;
+
+ SCHAR maxGainLimit_e = (frameErrorFlag) ? MAX_GAIN_CONCEAL_EXP : MAX_GAIN_EXP;
+
+ int useAliasReduction[64];
+ UCHAR smooth_length = 0;
+
+ FIXP_SGL * pIenv = hFrameData->iEnvelope;
+
+ /*
+ Extract sine flags for all QMF bands
+ */
+ mapSineFlags(hFreq->freqBandTable[1],
+ hFreq->nSfb[1],
+ hFrameData->addHarmonics,
+ h_sbr_cal_env->harmFlagsPrev,
+ hFrameData->frameInfo.tranEnv,
+ sineMapped);
+
+
+ /*
+ Scan for maximum in bufferd noise levels.
+ This is needed in case that we had strong noise in the previous frame
+ which is smoothed into the current frame.
+ The resulting exponent is used as start value for the maximum search
+ in reference energies
+ */
+ if (!useLP)
+ adj_e = h_sbr_cal_env->filtBufferNoise_e - getScalefactor(h_sbr_cal_env->filtBufferNoise, noSubbands);
+
+ /*
+ Scan for maximum reference energy to be able
+ to select appropriate values for adj_e and final_e.
+ */
+
+ for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
+ INT maxSfbNrg_e = -FRACT_BITS+NRG_EXP_OFFSET; /* start value for maximum search */
+
+ /* Fetch frequency resolution for current envelope: */
+ for (j=hFreq->nSfb[hFrameData->frameInfo.freqRes[i]]; j!=0; j--) {
+ maxSfbNrg_e = fixMax(maxSfbNrg_e,(INT)((LONG)(*pIenv++) & MASK_E));
+ }
+ maxSfbNrg_e -= NRG_EXP_OFFSET;
+
+ /* Energy -> magnitude (sqrt halfens exponent) */
+ maxSfbNrg_e = (maxSfbNrg_e+1) >> 1; /* +1 to go safe (round to next higher int) */
+
+ /* Some safety margin is needed for 2 reasons:
+ - The signal energy is not equally spread over all subband samples in
+ a specific sfb of an envelope (Nrg could be too high by a factor of
+ envWidth * sfbWidth)
+ - Smoothing can smear high gains of the previous envelope into the current
+ */
+ maxSfbNrg_e += 6;
+
+ if (borders[i] < hHeaderData->numberTimeSlots)
+ /* This envelope affects timeslots that belong to the output frame */
+ adj_e = (maxSfbNrg_e > adj_e) ? maxSfbNrg_e : adj_e;
+
+ if (borders[i+1] > hHeaderData->numberTimeSlots)
+ /* This envelope affects timeslots after the output frame */
+ final_e = (maxSfbNrg_e > final_e) ? maxSfbNrg_e : final_e;
+
+ }
+
+ /*
+ Calculate adjustment factors and apply them for every envelope.
+ */
+ pIenv = hFrameData->iEnvelope;
+
+ for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
+
+ int k, noNoiseFlag;
+ SCHAR noise_e, input_e = SCALE2EXP(sbrScaleFactor->hb_scale);
+ C_ALLOC_SCRATCH_START(pNrgs, ENV_CALC_NRGS, 1);
+
+ /*
+ Helper variables.
+ */
+ UCHAR start_pos = hHeaderData->timeStep * borders[i]; /* Start-position in time (subband sample) for current envelope. */
+ UCHAR stop_pos = hHeaderData->timeStep * borders[i+1]; /* Stop-position in time (subband sample) for current envelope. */
+ UCHAR freq_res = hFrameData->frameInfo.freqRes[i]; /* Frequency resolution for current envelope. */
+
+
+ /* Always do fully initialize the temporary energy table. This prevents negative energies and extreme gain factors in
+ cases where the number of limiter bands exceeds the number of subbands. The latter can be caused by undetected bit
+ errors and is tested by some streams from the certification set. */
+ FDKmemclear(pNrgs, sizeof(ENV_CALC_NRGS));
+
+ /* If the start-pos of the current envelope equals the stop pos of the current
+ noise envelope, increase the pointer (i.e. choose the next noise-floor).*/
+ if (borders[i] == hFrameData->frameInfo.bordersNoise[envNoise+1]){
+ noiseLevels += noNoiseBands; /* The noise floor data is stored in a row [noiseFloor1 noiseFloor2...].*/
+ envNoise++;
+ }
+
+ if(i==hFrameData->frameInfo.tranEnv || i==h_sbr_cal_env->prevTranEnv) /* attack */
+ {
+ noNoiseFlag = 1;
+ if (!useLP)
+ smooth_length = 0; /* No smoothing on attacks! */
+ }
+ else {
+ noNoiseFlag = 0;
+ if (!useLP)
+ smooth_length = (1 - hHeaderData->bs_data.smoothingLength) << 2; /* can become either 0 or 4 */
+ }
+
+
+ /*
+ Energy estimation in transposed highband.
+ */
+ if (hHeaderData->bs_data.interpolFreq)
+ calcNrgPerSubband(analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ lowSubband, highSubband,
+ start_pos, stop_pos,
+ input_e,
+ pNrgs->nrgEst,
+ pNrgs->nrgEst_e);
+ else
+ calcNrgPerSfb(analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ hFreq->nSfb[freq_res],
+ hFreq->freqBandTable[freq_res],
+ start_pos, stop_pos,
+ input_e,
+ pNrgs->nrgEst,
+ pNrgs->nrgEst_e);
+
+ /*
+ Calculate subband gains
+ */
+ {
+ UCHAR * table = hFreq->freqBandTable[freq_res];
+ UCHAR * pUiNoise = &hFreq->freqBandTableNoise[1]; /*! Upper limit of the current noise floor band. */
+
+ FIXP_SGL * pNoiseLevels = noiseLevels;
+
+ FIXP_DBL tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
+ SCHAR tmpNoise_e = (UCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
+
+ int cc = 0;
+ c = 0;
+ for (j = 0; j < hFreq->nSfb[freq_res]; j++) {
+
+ FIXP_DBL refNrg = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pIenv) & MASK_M));
+ SCHAR refNrg_e = (SCHAR)((LONG)(*pIenv) & MASK_E) - NRG_EXP_OFFSET;
+
+ UCHAR sinePresentFlag = 0;
+ int li = table[j];
+ int ui = table[j+1];
+
+ for (k=li; k<ui; k++) {
+ sinePresentFlag |= (i >= sineMapped[cc]);
+ cc++;
+ }
+
+ for (k=li; k<ui; k++) {
+ if (k >= *pUiNoise) {
+ tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
+ tmpNoise_e = (SCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
+
+ pUiNoise++;
+ }
+
+ FDK_ASSERT(k >= lowSubband);
+
+ if (useLP)
+ useAliasReduction[k-lowSubband] = !sinePresentFlag;
+
+ pNrgs->nrgSine[c] = FL2FXCONST_DBL(0.0f);
+ pNrgs->nrgSine_e[c] = 0;
+
+ calcSubbandGain(refNrg, refNrg_e, pNrgs, c,
+ tmpNoise, tmpNoise_e,
+ sinePresentFlag, i >= sineMapped[c],
+ noNoiseFlag);
+
+ pNrgs->nrgRef[c] = refNrg;
+ pNrgs->nrgRef_e[c] = refNrg_e;
+
+ c++;
+ }
+ pIenv++;
+ }
+ }
+
+ /*
+ Noise limiting
+ */
+
+ for (c = 0; c < hFreq->noLimiterBands; c++) {
+
+ FIXP_DBL sumRef, boostGain, maxGain;
+ FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
+ SCHAR sumRef_e, boostGain_e, maxGain_e, accu_e = 0;
+
+ calcAvgGain(pNrgs,
+ hFreq->limiterBandTable[c], hFreq->limiterBandTable[c+1],
+ &sumRef, &sumRef_e,
+ &maxGain, &maxGain_e);
+
+ /* Multiply maxGain with limiterGain: */
+ maxGain = fMult(maxGain, FDK_sbrDecoder_sbr_limGains_m[hHeaderData->bs_data.limiterGains]);
+ maxGain_e += FDK_sbrDecoder_sbr_limGains_e[hHeaderData->bs_data.limiterGains];
+
+ /* Scale mantissa of MaxGain into range between 0.5 and 1: */
+ if (maxGain == FL2FXCONST_DBL(0.0f))
+ maxGain_e = -FRACT_BITS;
+ else {
+ SCHAR charTemp = CountLeadingBits(maxGain);
+ maxGain_e -= charTemp;
+ maxGain <<= (int)charTemp;
+ }
+
+ if (maxGain_e >= maxGainLimit_e) { /* upper limit (e.g. 96 dB) */
+ maxGain = FL2FXCONST_DBL(0.5f);
+ maxGain_e = maxGainLimit_e;
+ }
+
+
+ /* Every subband gain is compared to the scaled "average gain"
+ and limited if necessary: */
+ for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c+1]; k++) {
+ if ( (pNrgs->nrgGain_e[k] > maxGain_e) || (pNrgs->nrgGain_e[k] == maxGain_e && pNrgs->nrgGain[k]>maxGain) ) {
+
+ FIXP_DBL noiseAmp;
+ SCHAR noiseAmp_e;
+
+ FDK_divide_MantExp(maxGain, maxGain_e, pNrgs->nrgGain[k], pNrgs->nrgGain_e[k], &noiseAmp, &noiseAmp_e);
+ pNrgs->noiseLevel[k] = fMult(pNrgs->noiseLevel[k],noiseAmp);
+ pNrgs->noiseLevel_e[k] += noiseAmp_e;
+ pNrgs->nrgGain[k] = maxGain;
+ pNrgs->nrgGain_e[k] = maxGain_e;
+ }
+ }
+
+ /* -- Boost gain
+ Calculate and apply boost factor for each limiter band:
+ 1. Check how much energy would be present when using the limited gain
+ 2. Calculate boost factor by comparison with reference energy
+ 3. Apply boost factor to compensate for the energy loss due to limiting
+ */
+ for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
+
+ /* 1.a Add energy of adjusted signal (using preliminary gain) */
+ FIXP_DBL tmp = fMult(pNrgs->nrgGain[k],pNrgs->nrgEst[k]);
+ SCHAR tmp_e = pNrgs->nrgGain_e[k] + pNrgs->nrgEst_e[k];
+ FDK_add_MantExp(tmp, tmp_e, accu, accu_e, &accu, &accu_e);
+
+ /* 1.b Add sine energy (if present) */
+ if(pNrgs->nrgSine[k] != FL2FXCONST_DBL(0.0f)) {
+ FDK_add_MantExp(pNrgs->nrgSine[k], pNrgs->nrgSine_e[k], accu, accu_e, &accu, &accu_e);
+ }
+ else {
+ /* 1.c Add noise energy (if present) */
+ if(noNoiseFlag == 0) {
+ FDK_add_MantExp(pNrgs->noiseLevel[k], pNrgs->noiseLevel_e[k], accu, accu_e, &accu, &accu_e);
+ }
+ }
+ }
+
+ /* 2.a Calculate ratio of wanted energy and accumulated energy */
+ if (accu == (FIXP_DBL)0) { /* If divisor is 0, limit quotient to +4 dB */
+ boostGain = FL2FXCONST_DBL(0.6279716f);
+ boostGain_e = 2;
+ } else {
+ INT div_e;
+ boostGain = fDivNorm(sumRef, accu, &div_e);
+ boostGain_e = sumRef_e - accu_e + div_e;
+ }
+
+
+ /* 2.b Result too high? --> Limit the boost factor to +4 dB */
+ if((boostGain_e > 3) ||
+ (boostGain_e == 2 && boostGain > FL2FXCONST_DBL(0.6279716f)) ||
+ (boostGain_e == 3 && boostGain > FL2FXCONST_DBL(0.3139858f)) )
+ {
+ boostGain = FL2FXCONST_DBL(0.6279716f);
+ boostGain_e = 2;
+ }
+ /* 3. Multiply all signal components with the boost factor */
+ for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
+ pNrgs->nrgGain[k] = fMultDiv2(pNrgs->nrgGain[k],boostGain);
+ pNrgs->nrgGain_e[k] = pNrgs->nrgGain_e[k] + boostGain_e + 1;
+
+ pNrgs->nrgSine[k] = fMultDiv2(pNrgs->nrgSine[k],boostGain);
+ pNrgs->nrgSine_e[k] = pNrgs->nrgSine_e[k] + boostGain_e + 1;
+
+ pNrgs->noiseLevel[k] = fMultDiv2(pNrgs->noiseLevel[k],boostGain);
+ pNrgs->noiseLevel_e[k] = pNrgs->noiseLevel_e[k] + boostGain_e + 1;
+ }
+ }
+ /* End of noise limiting */
+
+ if (useLP)
+ aliasingReduction(degreeAlias+lowSubband,
+ pNrgs,
+ useAliasReduction,
+ noSubbands);
+
+ /* For the timeslots within the range for the output frame,
+ use the same scale for the noise levels.
+ Drawback: If the envelope exceeds the frame border, the noise levels
+ will have to be rescaled later to fit final_e of
+ the gain-values.
+ */
+ noise_e = (start_pos < no_cols) ? adj_e : final_e;
+
+ /*
+ Convert energies to amplitude levels
+ */
+ for (k=0; k<noSubbands; k++) {
+ FDK_sqrt_MantExp(&pNrgs->nrgSine[k], &pNrgs->nrgSine_e[k], &noise_e);
+ FDK_sqrt_MantExp(&pNrgs->nrgGain[k], &pNrgs->nrgGain_e[k], &pNrgs->nrgGain_e[k]);
+ FDK_sqrt_MantExp(&pNrgs->noiseLevel[k], &pNrgs->noiseLevel_e[k], &noise_e);
+ }
+
+
+
+ /*
+ Apply calculated gains and adaptive noise
+ */
+
+ /* assembleHfSignals() */
+ {
+ int scale_change, sc_change;
+ FIXP_SGL smooth_ratio;
+ int filtBufferNoiseShift=0;
+
+ /* Initialize smoothing buffers with the first valid values */
+ if (h_sbr_cal_env->startUp)
+ {
+ if (!useLP) {
+ h_sbr_cal_env->filtBufferNoise_e = noise_e;
+
+ FDKmemcpy(h_sbr_cal_env->filtBuffer_e, pNrgs->nrgGain_e, noSubbands*sizeof(SCHAR));
+ FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
+ FDKmemcpy(h_sbr_cal_env->filtBuffer, pNrgs->nrgGain, noSubbands*sizeof(FIXP_DBL));
+
+ }
+ h_sbr_cal_env->startUp = 0;
+ }
+
+ if (!useLP) {
+
+ equalizeFiltBufferExp(h_sbr_cal_env->filtBuffer, /* buffered */
+ h_sbr_cal_env->filtBuffer_e, /* buffered */
+ pNrgs->nrgGain, /* current */
+ pNrgs->nrgGain_e, /* current */
+ noSubbands);
+
+ /* Adapt exponent of buffered noise levels to the current exponent
+ so they can easily be smoothed */
+ if((h_sbr_cal_env->filtBufferNoise_e - noise_e)>=0) {
+ int shift = fixMin(DFRACT_BITS-1,(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
+ for (k=0; k<noSubbands; k++)
+ h_sbr_cal_env->filtBufferNoise[k] <<= shift;
+ }
+ else {
+ int shift = fixMin(DFRACT_BITS-1,-(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
+ for (k=0; k<noSubbands; k++)
+ h_sbr_cal_env->filtBufferNoise[k] >>= shift;
+ }
+
+ h_sbr_cal_env->filtBufferNoise_e = noise_e;
+ }
+
+ /* find best scaling! */
+ scale_change = -(DFRACT_BITS-1);
+ for(k=0;k<noSubbands;k++) {
+ scale_change = fixMax(scale_change,(int)pNrgs->nrgGain_e[k]);
+ }
+ sc_change = (start_pos<no_cols)? adj_e - input_e : final_e - input_e;
+
+ if ((scale_change-sc_change+1)<0)
+ scale_change-=(scale_change-sc_change+1);
+
+ scale_change = (scale_change-sc_change)+1;
+
+ for(k=0;k<noSubbands;k++) {
+ int sc = scale_change-pNrgs->nrgGain_e[k] + (sc_change-1);
+ pNrgs->nrgGain[k] >>= sc;
+ pNrgs->nrgGain_e[k] += sc;
+ }
+
+ if (!useLP) {
+ for(k=0;k<noSubbands;k++) {
+ int sc = scale_change-h_sbr_cal_env->filtBuffer_e[k] + (sc_change-1);
+ h_sbr_cal_env->filtBuffer[k] >>= sc;
+ }
+ }
+
+ for (j = start_pos; j < stop_pos; j++)
+ {
+ /* This timeslot is located within the first part of the processing buffer
+ and will be fed into the QMF-synthesis for the current frame.
+ adj_e - input_e
+ This timeslot will not yet be fed into the QMF so we do not care
+ about the adj_e.
+ sc_change = final_e - input_e
+ */
+ if ( (j==no_cols) && (start_pos<no_cols) )
+ {
+ int shift = (int) (noise_e - final_e);
+ if (!useLP)
+ filtBufferNoiseShift = shift; /* shifting of h_sbr_cal_env->filtBufferNoise[k] will be applied in function adjustTimeSlotHQ() */
+ if (shift>=0) {
+ shift = fixMin(DFRACT_BITS-1,shift);
+ for (k=0; k<noSubbands; k++) {
+ pNrgs->nrgSine[k] <<= shift;
+ pNrgs->noiseLevel[k] <<= shift;
+ /*
+ if (!useLP)
+ h_sbr_cal_env->filtBufferNoise[k] <<= shift;
+ */
+ }
+ }
+ else {
+ shift = fixMin(DFRACT_BITS-1,-shift);
+ for (k=0; k<noSubbands; k++) {
+ pNrgs->nrgSine[k] >>= shift;
+ pNrgs->noiseLevel[k] >>= shift;
+ /*
+ if (!useLP)
+ h_sbr_cal_env->filtBufferNoise[k] >>= shift;
+ */
+ }
+ }
+
+ /* update noise scaling */
+ noise_e = final_e;
+ if (!useLP)
+ h_sbr_cal_env->filtBufferNoise_e = noise_e; /* scaling value unused! */
+
+ /* update gain buffer*/
+ sc_change -= (final_e - input_e);
+
+ if (sc_change<0) {
+ for(k=0;k<noSubbands;k++) {
+ pNrgs->nrgGain[k] >>= -sc_change;
+ pNrgs->nrgGain_e[k] += -sc_change;
+ }
+ if (!useLP) {
+ for(k=0;k<noSubbands;k++) {
+ h_sbr_cal_env->filtBuffer[k] >>= -sc_change;
+ }
+ }
+ } else {
+ scale_change+=sc_change;
+ }
+
+ } // if
+
+ if (!useLP) {
+
+ /* Prevent the smoothing filter from running on constant levels */
+ if (j-start_pos < smooth_length)
+ smooth_ratio = FDK_sbrDecoder_sbr_smoothFilter[j-start_pos];
+
+ else
+ smooth_ratio = FL2FXCONST_SGL(0.0f);
+
+ adjustTimeSlotHQ(&analysBufferReal[j][lowSubband],
+ &analysBufferImag[j][lowSubband],
+ h_sbr_cal_env,
+ pNrgs,
+ lowSubband,
+ noSubbands,
+ scale_change,
+ smooth_ratio,
+ noNoiseFlag,
+ filtBufferNoiseShift);
+ }
+ else
+ {
+ adjustTimeSlotLC(&analysBufferReal[j][lowSubband],
+ pNrgs,
+ &h_sbr_cal_env->harmIndex,
+ lowSubband,
+ noSubbands,
+ scale_change,
+ noNoiseFlag,
+ &h_sbr_cal_env->phaseIndex,
+ (flags & SBRDEC_ELD_GRID));
+ }
+ } // for
+
+ if (!useLP) {
+ /* Update time-smoothing-buffers for gains and noise levels
+ The gains and the noise values of the current envelope are copied into the buffer.
+ This has to be done at the end of each envelope as the values are required for
+ a smooth transition to the next envelope. */
+ FDKmemcpy(h_sbr_cal_env->filtBuffer, pNrgs->nrgGain, noSubbands*sizeof(FIXP_DBL));
+ FDKmemcpy(h_sbr_cal_env->filtBuffer_e, pNrgs->nrgGain_e, noSubbands*sizeof(SCHAR));
+ FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
+ }
+
+ }
+ C_ALLOC_SCRATCH_END(pNrgs, ENV_CALC_NRGS, 1);
+ }
+
+ /* Rescale output samples */
+ {
+ FIXP_DBL maxVal;
+ int ov_reserve, reserve;
+
+ /* Determine headroom in old adjusted samples */
+ maxVal = maxSubbandSample( analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ lowSubband,
+ highSubband,
+ 0,
+ first_start);
+
+ ov_reserve = fNorm(maxVal);
+
+ /* Determine headroom in new adjusted samples */
+ maxVal = maxSubbandSample( analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ lowSubband,
+ highSubband,
+ first_start,
+ no_cols);
+
+ reserve = fNorm(maxVal);
+
+ /* Determine common output exponent */
+ if (ov_adj_e - ov_reserve > adj_e - reserve ) /* set output_e to the maximum */
+ output_e = ov_adj_e - ov_reserve;
+ else
+ output_e = adj_e - reserve;
+
+ /* Rescale old samples */
+ rescaleSubbandSamples( analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ lowSubband, highSubband,
+ 0, first_start,
+ ov_adj_e - output_e);
+
+ /* Rescale new samples */
+ rescaleSubbandSamples( analysBufferReal,
+ (useLP) ? NULL : analysBufferImag,
+ lowSubband, highSubband,
+ first_start, no_cols,
+ adj_e - output_e);
+ }
+
+ /* Update hb_scale */
+ sbrScaleFactor->hb_scale = EXP2SCALE(output_e);
+
+ /* Save the current final exponent for the next frame: */
+ sbrScaleFactor->ov_hb_scale = EXP2SCALE(final_e);
+
+
+ /* We need to remeber to the next frame that the transient
+ will occur in the first envelope (if tranEnv == nEnvelopes). */
+ if(hFrameData->frameInfo.tranEnv == hFrameData->frameInfo.nEnvelopes)
+ h_sbr_cal_env->prevTranEnv = 0;
+ else
+ h_sbr_cal_env->prevTranEnv = -1;
+
+}
+
+
+/*!
+ \brief Create envelope instance
+
+ Must be called once for each channel before calculateSbrEnvelope() can be used.
+
+ \return errorCode, 0 if successful
+*/
+SBR_ERROR
+createSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs, /*!< pointer to envelope instance */
+ HANDLE_SBR_HEADER_DATA hHeaderData, /*!< static SBR control data, initialized with defaults */
+ const int chan, /*!< Channel for which to assign buffers */
+ const UINT flags)
+{
+ SBR_ERROR err = SBRDEC_OK;
+ int i;
+
+ /* Clear previous missing harmonics flags */
+ for (i=0; i<(MAX_FREQ_COEFFS+15)>>4; i++) {
+ hs->harmFlagsPrev[i] = 0;
+ }
+ hs->harmIndex = 0;
+
+ /*
+ Setup pointers for time smoothing.
+ The buffer itself will be initialized later triggered by the startUp-flag.
+ */
+ hs->prevTranEnv = -1;
+
+
+ /* initialization */
+ resetSbrEnvelopeCalc(hs);
+
+ if (chan==0) { /* do this only once */
+ err = resetFreqBandTables(hHeaderData, flags);
+ }
+
+ return err;
+}
+
+/*!
+ \brief Create envelope instance
+
+ Must be called once for each channel before calculateSbrEnvelope() can be used.
+
+ \return errorCode, 0 if successful
+*/
+int
+deleteSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs)
+{
+ return 0;
+}
+
+
+/*!
+ \brief Reset envelope instance
+
+ This function must be called for each channel on a change of configuration.
+ Note that resetFreqBandTables should also be called in this case.
+
+ \return errorCode, 0 if successful
+*/
+void
+resetSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hCalEnv) /*!< pointer to envelope instance */
+{
+ hCalEnv->phaseIndex = 0;
+
+ /* Noise exponent needs to be reset because the output exponent for the next frame depends on it */
+ hCalEnv->filtBufferNoise_e = 0;
+
+ hCalEnv->startUp = 1;
+}
+
+
+/*!
+ \brief Equalize exponents of the buffered gain values and the new ones
+
+ After equalization of exponents, the FIR-filter addition for smoothing
+ can be performed.
+ This function is called once for each envelope before adjusting.
+*/
+/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer, /*!< bufferd gains */
+ SCHAR *filtBuffer_e, /*!< exponents of bufferd gains */
+ FIXP_DBL *nrgGain, /*!< gains for current envelope */
+ SCHAR *nrgGain_e, /*!< exponents of gains for current envelope */
+ int subbands) /*!< Number of QMF subbands */
+{
+ int band;
+ int diff;
+
+ for (band=0; band<subbands; band++){
+ diff = (int) (nrgGain_e[band] - filtBuffer_e[band]);
+ if (diff>0) {
+ filtBuffer[band] >>= diff; /* Compensate for the scale change by shifting the mantissa. */
+ filtBuffer_e[band] += diff; /* New gain is bigger, use its exponent */
+ }
+ else if (diff<0) {
+ /* The buffered gains seem to be larger, but maybe there
+ are some unused bits left in the mantissa */
+
+ int reserve = CntLeadingZeros(fixp_abs(filtBuffer[band]))-1;
+
+ if ((-diff) <= reserve) {
+ /* There is enough space in the buffered mantissa so
+ that we can take the new exponent as common.
+ */
+ filtBuffer[band] <<= (-diff);
+ filtBuffer_e[band] += diff; /* becomes equal to *ptrNewExp */
+ }
+ else {
+ filtBuffer[band] <<= reserve; /* Shift the mantissa as far as possible: */
+ filtBuffer_e[band] -= reserve; /* Compensate in the exponent: */
+
+ /* For the remaining difference, change the new gain value */
+ diff = fixMin(-(reserve + diff),DFRACT_BITS-1);
+ nrgGain[band] >>= diff;
+ nrgGain_e[band] += diff;
+ }
+ }
+ }
+}
+
+/*!
+ \brief Shift left the mantissas of all subband samples
+ in the giventime and frequency range by the specified number of bits.
+
+ This function is used to rescale the audio data in the overlap buffer
+ which has already been envelope adjusted with the last frame.
+*/
+void rescaleSubbandSamples(FIXP_DBL ** re, /*!< Real part of input and output subband samples */
+ FIXP_DBL ** im, /*!< Imaginary part of input and output subband samples */
+ int lowSubband, /*!< Begin of frequency range to process */
+ int highSubband, /*!< End of frequency range to process */
+ int start_pos, /*!< Begin of time rage (QMF-timeslot) */
+ int next_pos, /*!< End of time rage (QMF-timeslot) */
+ int shift) /*!< number of bits to shift */
+{
+ int width = highSubband-lowSubband;
+
+ if ( (width > 0) && (shift!=0) ) {
+ if (im!=NULL) {
+ for (int l=start_pos; l<next_pos; l++) {
+ scaleValues(&re[l][lowSubband], width, shift);
+ scaleValues(&im[l][lowSubband], width, shift);
+ }
+ } else
+ {
+ for (int l=start_pos; l<next_pos; l++) {
+ scaleValues(&re[l][lowSubband], width, shift);
+ }
+ }
+ }
+}
+
+
+/*!
+ \brief Determine headroom for shifting
+
+ Determine by how much the spectrum can be shifted left
+ for better accuracy in later processing.
+
+ \return Number of free bits in the biggest spectral value
+*/
+
+FIXP_DBL maxSubbandSample( FIXP_DBL ** re, /*!< Real part of input and output subband samples */
+ FIXP_DBL ** im, /*!< Real part of input and output subband samples */
+ int lowSubband, /*!< Begin of frequency range to process */
+ int highSubband, /*!< Number of QMF bands to process */
+ int start_pos, /*!< Begin of time rage (QMF-timeslot) */
+ int next_pos /*!< End of time rage (QMF-timeslot) */
+ )
+{
+ FIXP_DBL maxVal = FL2FX_DBL(0.0f);
+ unsigned int width = highSubband - lowSubband;
+
+ FDK_ASSERT(width <= (64));
+
+ if ( width > 0 ) {
+ if (im!=NULL)
+ {
+ for (int l=start_pos; l<next_pos; l++)
+ {
+#ifdef FUNCTION_FDK_get_maxval
+ maxVal = FDK_get_maxval(maxVal, &re[l][lowSubband], &im[l][lowSubband], width);
+#else
+ int k=width;
+ FIXP_DBL *reTmp = &re[l][lowSubband];
+ FIXP_DBL *imTmp = &im[l][lowSubband];
+ do{
+ FIXP_DBL tmp1 = *(reTmp++);
+ FIXP_DBL tmp2 = *(imTmp++);
+ maxVal |= (FIXP_DBL)((LONG)(tmp1)^((LONG)tmp1>>(DFRACT_BITS-1)));
+ maxVal |= (FIXP_DBL)((LONG)(tmp2)^((LONG)tmp2>>(DFRACT_BITS-1)));
+ } while(--k!=0);
+#endif
+ }
+ } else
+ {
+ for (int l=start_pos; l<next_pos; l++) {
+ int k=width;
+ FIXP_DBL *reTmp = &re[l][lowSubband];
+ do{
+ FIXP_DBL tmp = *(reTmp++);
+ maxVal |= (FIXP_DBL)((LONG)(tmp)^((LONG)tmp>>(DFRACT_BITS-1)));
+ }while(--k!=0);
+ }
+ }
+ }
+
+ return(maxVal);
+}
+
+#define SHIFT_BEFORE_SQUARE (3) /* (7/2) */
+/*!<
+ If the accumulator does not provide enough overflow bits or
+ does not provide a high dynamic range, the below energy calculation
+ requires an additional shift operation for each sample.
+ On the other hand, doing the shift allows using a single-precision
+ multiplication for the square (at least 16bit x 16bit).
+ For even values of OVRFLW_BITS (0, 2, 4, 6), saturated arithmetic
+ is required for the energy accumulation.
+ Theoretically, the sample-squares can sum up to a value of 76,
+ requiring 7 overflow bits. However since such situations are *very*
+ rare, accu can be limited to 64.
+ In case native saturated arithmetic is not available, overflows
+ can be prevented by replacing the above #define by
+ #define SHIFT_BEFORE_SQUARE ((8 - OVRFLW_BITS) / 2)
+ which will result in slightly reduced accuracy.
+*/
+
+/*!
+ \brief Estimates the mean energy of each filter-bank channel for the
+ duration of the current envelope
+
+ This function is used when interpolFreq is true.
+*/
+/*static*/ void calcNrgPerSubband(FIXP_DBL **analysBufferReal, /*!< Real part of subband samples */
+ FIXP_DBL **analysBufferImag, /*!< Imaginary part of subband samples */
+ int lowSubband, /*!< Begin of the SBR frequency range */
+ int highSubband, /*!< High end of the SBR frequency range */
+ int start_pos, /*!< First QMF-slot of current envelope */
+ int next_pos, /*!< Last QMF-slot of current envelope + 1 */
+ SCHAR frameExp, /*!< Common exponent for all input samples */
+ FIXP_DBL *nrgEst, /*!< resulting Energy (0..1) */
+ SCHAR *nrgEst_e ) /*!< Exponent of resulting Energy */
+{
+ FIXP_SGL invWidth;
+ SCHAR preShift;
+ SCHAR shift;
+ FIXP_DBL sum;
+ int k,l;
+
+ /* Divide by width of envelope later: */
+ invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
+ /* The common exponent needs to be doubled because all mantissas are squared: */
+ frameExp = frameExp << 1;
+
+ for (k=lowSubband; k<highSubband; k++) {
+ FIXP_DBL bufferReal[(((1024)/(32))+(6))];
+ FIXP_DBL bufferImag[(((1024)/(32))+(6))];
+ FIXP_DBL maxVal = FL2FX_DBL(0.0f);
+
+ if (analysBufferImag!=NULL)
+ {
+ for (l=start_pos;l<next_pos;l++)
+ {
+ bufferImag[l] = analysBufferImag[l][k];
+ maxVal |= (FIXP_DBL)((LONG)(bufferImag[l])^((LONG)bufferImag[l]>>(DFRACT_BITS-1)));
+ bufferReal[l] = analysBufferReal[l][k];
+ maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
+ }
+ }
+ else
+ {
+ for (l=start_pos;l<next_pos;l++)
+ {
+ bufferReal[l] = analysBufferReal[l][k];
+ maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
+ }
+ }
+
+ if (maxVal!=FL2FXCONST_DBL(0.f)) {
+
+
+ /* If the accu does not provide enough overflow bits, we cannot
+ shift the samples up to the limit.
+ Instead, keep up to 3 free bits in each sample, i.e. up to
+ 6 bits after calculation of square.
+ Please note the comment on saturated arithmetic above!
+ */
+ FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
+ preShift = CntLeadingZeros(maxVal)-1;
+ preShift -= SHIFT_BEFORE_SQUARE;
+
+ if (preShift>=0) {
+ if (analysBufferImag!=NULL) {
+ for (l=start_pos; l<next_pos; l++) {
+ FIXP_DBL temp1 = bufferReal[l] << (int)preShift;
+ FIXP_DBL temp2 = bufferImag[l] << (int)preShift;
+ accu = fPow2AddDiv2(accu, temp1);
+ accu = fPow2AddDiv2(accu, temp2);
+ }
+ } else
+ {
+ for (l=start_pos; l<next_pos; l++) {
+ FIXP_DBL temp = bufferReal[l] << (int)preShift;
+ accu = fPow2AddDiv2(accu, temp);
+ }
+ }
+ }
+ else { /* if negative shift value */
+ int negpreShift = -preShift;
+ if (analysBufferImag!=NULL) {
+ for (l=start_pos; l<next_pos; l++) {
+ FIXP_DBL temp1 = bufferReal[l] >> (int)negpreShift;
+ FIXP_DBL temp2 = bufferImag[l] >> (int)negpreShift;
+ accu = fPow2AddDiv2(accu, temp1);
+ accu = fPow2AddDiv2(accu, temp2);
+ }
+ } else
+ {
+ for (l=start_pos; l<next_pos; l++) {
+ FIXP_DBL temp = bufferReal[l] >> (int)negpreShift;
+ accu = fPow2AddDiv2(accu, temp);
+ }
+ }
+ }
+ accu <<= 1;
+
+ /* Convert double precision to Mantissa/Exponent: */
+ shift = fNorm(accu);
+ sum = accu << (int)shift;
+
+ /* Divide by width of envelope and apply frame scale: */
+ *nrgEst++ = fMult(sum, invWidth);
+ shift += 2 * preShift;
+ if (analysBufferImag!=NULL)
+ *nrgEst_e++ = frameExp - shift;
+ else
+ *nrgEst_e++ = frameExp - shift + 1; /* +1 due to missing imag. part */
+ } /* maxVal!=0 */
+ else {
+
+ /* Prevent a zero-mantissa-number from being misinterpreted
+ due to its exponent. */
+ *nrgEst++ = FL2FXCONST_DBL(0.0f);
+ *nrgEst_e++ = 0;
+ }
+ }
+}
+
+/*!
+ \brief Estimates the mean energy of each Scale factor band for the
+ duration of the current envelope.
+
+ This function is used when interpolFreq is false.
+*/
+/*static*/ void calcNrgPerSfb(FIXP_DBL **analysBufferReal, /*!< Real part of subband samples */
+ FIXP_DBL **analysBufferImag, /*!< Imaginary part of subband samples */
+ int nSfb, /*!< Number of scale factor bands */
+ UCHAR *freqBandTable, /*!< First Subband for each Sfb */
+ int start_pos, /*!< First QMF-slot of current envelope */
+ int next_pos, /*!< Last QMF-slot of current envelope + 1 */
+ SCHAR input_e, /*!< Common exponent for all input samples */
+ FIXP_DBL *nrgEst, /*!< resulting Energy (0..1) */
+ SCHAR *nrgEst_e ) /*!< Exponent of resulting Energy */
+{
+ FIXP_SGL invWidth;
+ FIXP_DBL temp;
+ SCHAR preShift;
+ SCHAR shift, sum_e;
+ FIXP_DBL sum;
+
+ int j,k,l,li,ui;
+ FIXP_DBL sumAll, sumLine; /* Single precision would be sufficient,
+ but overflow bits are required for accumulation */
+
+ /* Divide by width of envelope later: */
+ invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
+ /* The common exponent needs to be doubled because all mantissas are squared: */
+ input_e = input_e << 1;
+
+ for(j=0; j<nSfb; j++) {
+ li = freqBandTable[j];
+ ui = freqBandTable[j+1];
+
+ FIXP_DBL maxVal = maxSubbandSample( analysBufferReal,
+ analysBufferImag,
+ li,
+ ui,
+ start_pos,
+ next_pos );
+
+ if (maxVal!=FL2FXCONST_DBL(0.f)) {
+
+ preShift = CntLeadingZeros(maxVal)-1;
+
+ /* If the accu does not provide enough overflow bits, we cannot
+ shift the samples up to the limit.
+ Instead, keep up to 3 free bits in each sample, i.e. up to
+ 6 bits after calculation of square.
+ Please note the comment on saturated arithmetic above!
+ */
+ preShift -= SHIFT_BEFORE_SQUARE;
+
+ sumAll = FL2FXCONST_DBL(0.0f);
+
+
+ for (k=li; k<ui; k++) {
+
+ sumLine = FL2FXCONST_DBL(0.0f);
+
+ if (analysBufferImag!=NULL) {
+ if (preShift>=0) {
+ for (l=start_pos; l<next_pos; l++) {
+ temp = analysBufferReal[l][k] << (int)preShift;
+ sumLine += fPow2Div2(temp);
+ temp = analysBufferImag[l][k] << (int)preShift;
+ sumLine += fPow2Div2(temp);
+
+ }
+ } else {
+ for (l=start_pos; l<next_pos; l++) {
+ temp = analysBufferReal[l][k] >> -(int)preShift;
+ sumLine += fPow2Div2(temp);
+ temp = analysBufferImag[l][k] >> -(int)preShift;
+ sumLine += fPow2Div2(temp);
+ }
+ }
+ } else
+ {
+ if (preShift>=0) {
+ for (l=start_pos; l<next_pos; l++) {
+ temp = analysBufferReal[l][k] << (int)preShift;
+ sumLine += fPow2Div2(temp);
+ }
+ } else {
+ for (l=start_pos; l<next_pos; l++) {
+ temp = analysBufferReal[l][k] >> -(int)preShift;
+ sumLine += fPow2Div2(temp);
+ }
+ }
+ }
+
+ /* The number of QMF-channels per SBR bands may be up to 15.
+ Shift right to avoid overflows in sum over all channels. */
+ sumLine = sumLine >> (4-1);
+ sumAll += sumLine;
+ }
+
+ /* Convert double precision to Mantissa/Exponent: */
+ shift = fNorm(sumAll);
+ sum = sumAll << (int)shift;
+
+ /* Divide by width of envelope: */
+ sum = fMult(sum,invWidth);
+
+ /* Divide by width of Sfb: */
+ sum = fMult(sum, FX_DBL2FX_SGL(GetInvInt(ui-li)));
+
+ /* Set all Subband energies in the Sfb to the average energy: */
+ if (analysBufferImag!=NULL)
+ sum_e = input_e + 4 - shift; /* -4 to compensate right-shift */
+ else
+ sum_e = input_e + 4 + 1 - shift; /* -4 to compensate right-shift; +1 due to missing imag. part */
+
+ sum_e -= 2 * preShift;
+ } /* maxVal!=0 */
+ else {
+
+ /* Prevent a zero-mantissa-number from being misinterpreted
+ due to its exponent. */
+ sum = FL2FXCONST_DBL(0.0f);
+ sum_e = 0;
+ }
+
+ for (k=li; k<ui; k++)
+ {
+ *nrgEst++ = sum;
+ *nrgEst_e++ = sum_e;
+ }
+ }
+}
+
+
+/*!
+ \brief Calculate gain, noise, and additional sine level for one subband.
+
+ The resulting energy gain is given by mantissa and exponent.
+*/
+/*static*/ void calcSubbandGain(FIXP_DBL nrgRef, /*!< Reference Energy according to envelope data */
+ SCHAR nrgRef_e, /*!< Reference Energy according to envelope data (exponent) */
+ ENV_CALC_NRGS* nrgs,
+ int i,
+ FIXP_DBL tmpNoise, /*!< Relative noise level */
+ SCHAR tmpNoise_e, /*!< Relative noise level (exponent) */
+ UCHAR sinePresentFlag, /*!< Indicates if sine is present on band */
+ UCHAR sineMapped, /*!< Indicates if sine must be added */
+ int noNoiseFlag) /*!< Flag to suppress noise addition */
+{
+ FIXP_DBL nrgEst = nrgs->nrgEst[i]; /*!< Energy in transposed signal */
+ SCHAR nrgEst_e = nrgs->nrgEst_e[i]; /*!< Energy in transposed signal (exponent) */
+ FIXP_DBL *ptrNrgGain = &nrgs->nrgGain[i]; /*!< Resulting energy gain */
+ SCHAR *ptrNrgGain_e = &nrgs->nrgGain_e[i]; /*!< Resulting energy gain (exponent) */
+ FIXP_DBL *ptrNoiseLevel = &nrgs->noiseLevel[i]; /*!< Resulting absolute noise energy */
+ SCHAR *ptrNoiseLevel_e = &nrgs->noiseLevel_e[i]; /*!< Resulting absolute noise energy (exponent) */
+ FIXP_DBL *ptrNrgSine = &nrgs->nrgSine[i]; /*!< Additional sine energy */
+ SCHAR *ptrNrgSine_e = &nrgs->nrgSine_e[i]; /*!< Additional sine energy (exponent) */
+
+ FIXP_DBL a, b, c;
+ SCHAR a_e, b_e, c_e;
+
+ /*
+ This addition of 1 prevents divisions by zero in the reference code.
+ For very small energies in nrgEst, it prevents the gains from becoming
+ very high which could cause some trouble due to the smoothing.
+ */
+ b_e = (int)(nrgEst_e - 1);
+ if (b_e>=0) {
+ nrgEst = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (nrgEst >> 1);
+ nrgEst_e += 1; /* shift by 1 bit to avoid overflow */
+
+ } else {
+ nrgEst = (nrgEst >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
+ nrgEst_e = 2; /* shift by 1 bit to avoid overflow */
+ }
+
+ /* A = NrgRef * TmpNoise */
+ a = fMult(nrgRef,tmpNoise);
+ a_e = nrgRef_e + tmpNoise_e;
+
+ /* B = 1 + TmpNoise */
+ b_e = (int)(tmpNoise_e - 1);
+ if (b_e>=0) {
+ b = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (tmpNoise >> 1);
+ b_e = tmpNoise_e + 1; /* shift by 1 bit to avoid overflow */
+ } else {
+ b = (tmpNoise >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
+ b_e = 2; /* shift by 1 bit to avoid overflow */
+ }
+
+ /* noiseLevel = A / B = (NrgRef * TmpNoise) / (1 + TmpNoise) */
+ FDK_divide_MantExp( a, a_e,
+ b, b_e,
+ ptrNoiseLevel, ptrNoiseLevel_e);
+
+ if (sinePresentFlag) {
+
+ /* C = (1 + TmpNoise) * NrgEst */
+ c = fMult(b,nrgEst);
+ c_e = b_e + nrgEst_e;
+
+ /* gain = A / C = (NrgRef * TmpNoise) / (1 + TmpNoise) * NrgEst */
+ FDK_divide_MantExp( a, a_e,
+ c, c_e,
+ ptrNrgGain, ptrNrgGain_e);
+
+ if (sineMapped) {
+
+ /* sineLevel = nrgRef/ (1 + TmpNoise) */
+ FDK_divide_MantExp( nrgRef, nrgRef_e,
+ b, b_e,
+ ptrNrgSine, ptrNrgSine_e);
+ }
+ }
+ else {
+ if (noNoiseFlag) {
+ /* B = NrgEst */
+ b = nrgEst;
+ b_e = nrgEst_e;
+ }
+ else {
+ /* B = NrgEst * (1 + TmpNoise) */
+ b = fMult(b,nrgEst);
+ b_e = b_e + nrgEst_e;
+ }
+
+
+ /* gain = nrgRef / B */
+ FDK_divide_MantExp( nrgRef, nrgRef_e,
+ b, b_e,
+ ptrNrgGain, ptrNrgGain_e);
+ }
+}
+
+
+/*!
+ \brief Calculate "average gain" for the specified subband range.
+
+ This is rather a gain of the average magnitude than the average
+ of gains!
+ The result is used as a relative limit for all gains within the
+ current "limiter band" (a certain frequency range).
+*/
+/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
+ int lowSubband, /*!< Begin of the limiter band */
+ int highSubband, /*!< High end of the limiter band */
+ FIXP_DBL *ptrSumRef,
+ SCHAR *ptrSumRef_e,
+ FIXP_DBL *ptrAvgGain, /*!< Resulting overall gain (mantissa) */
+ SCHAR *ptrAvgGain_e) /*!< Resulting overall gain (exponent) */
+{
+ FIXP_DBL *nrgRef = nrgs->nrgRef; /*!< Reference Energy according to envelope data */
+ SCHAR *nrgRef_e = nrgs->nrgRef_e; /*!< Reference Energy according to envelope data (exponent) */
+ FIXP_DBL *nrgEst = nrgs->nrgEst; /*!< Energy in transposed signal */
+ SCHAR *nrgEst_e = nrgs->nrgEst_e; /*!< Energy in transposed signal (exponent) */
+
+ FIXP_DBL sumRef = 1;
+ FIXP_DBL sumEst = 1;
+ SCHAR sumRef_e = -FRACT_BITS;
+ SCHAR sumEst_e = -FRACT_BITS;
+ int k;
+
+ for (k=lowSubband; k<highSubband; k++){
+ /* Add nrgRef[k] to sumRef: */
+ FDK_add_MantExp( sumRef, sumRef_e,
+ nrgRef[k], nrgRef_e[k],
+ &sumRef, &sumRef_e );
+
+ /* Add nrgEst[k] to sumEst: */
+ FDK_add_MantExp( sumEst, sumEst_e,
+ nrgEst[k], nrgEst_e[k],
+ &sumEst, &sumEst_e );
+ }
+
+ FDK_divide_MantExp(sumRef, sumRef_e,
+ sumEst, sumEst_e,
+ ptrAvgGain, ptrAvgGain_e);
+
+ *ptrSumRef = sumRef;
+ *ptrSumRef_e = sumRef_e;
+}
+
+
+/*!
+ \brief Amplify one timeslot of the signal with the calculated gains
+ and add the noisefloor.
+*/
+
+/*static*/ void adjustTimeSlotLC(FIXP_DBL *ptrReal, /*!< Subband samples to be adjusted, real part */
+ ENV_CALC_NRGS* nrgs,
+ UCHAR *ptrHarmIndex, /*!< Harmonic index */
+ int lowSubband, /*!< Lowest QMF-channel in the currently used SBR range. */
+ int noSubbands, /*!< Number of QMF subbands */
+ int scale_change, /*!< Number of bits to shift adjusted samples */
+ int noNoiseFlag, /*!< Flag to suppress noise addition */
+ int *ptrPhaseIndex, /*!< Start index to random number array */
+ int fCldfb) /*!< CLDFB 80 flag */
+{
+ FIXP_DBL *pGain = nrgs->nrgGain; /*!< Gains of current envelope */
+ FIXP_DBL *pNoiseLevel = nrgs->noiseLevel; /*!< Noise levels of current envelope */
+ FIXP_DBL *pSineLevel = nrgs->nrgSine; /*!< Sine levels */
+
+ int k;
+ int index = *ptrPhaseIndex;
+ UCHAR harmIndex = *ptrHarmIndex;
+ UCHAR freqInvFlag = (lowSubband & 1);
+ FIXP_DBL signalReal, sineLevel, sineLevelNext, sineLevelPrev;
+ int tone_count = 0;
+ int sineSign = 1;
+
+ #define C1 ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.00815f))
+ #define C1_CLDFB ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.16773f))
+
+ /*
+ First pass for k=0 pulled out of the loop:
+ */
+
+ index = (index + 1) & (SBR_NF_NO_RANDOM_VAL - 1);
+
+ /*
+ The next multiplication constitutes the actual envelope adjustment
+ of the signal and should be carried out with full accuracy
+ (supplying #FRACT_BITS valid bits).
+ */
+ signalReal = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
+ sineLevel = *pSineLevel++;
+ sineLevelNext = (noSubbands > 1) ? pSineLevel[0] : FL2FXCONST_DBL(0.0f);
+
+ if (sineLevel!=FL2FXCONST_DBL(0.0f)) tone_count++;
+
+ else if (!noNoiseFlag)
+ /* Add noisefloor to the amplified signal */
+ signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
+
+ if (fCldfb) {
+
+ if (!(harmIndex&0x1)) {
+ /* harmIndex 0,2 */
+ signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
+ *ptrReal++ = signalReal;
+ }
+ else {
+ /* harmIndex 1,3 in combination with freqInvFlag */
+ int shift = (int) (scale_change+1);
+ shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
+
+ FIXP_DBL tmp1 = scaleValue( fMultDiv2(C1_CLDFB, sineLevel), -shift );
+
+ FIXP_DBL tmp2 = fMultDiv2(C1_CLDFB, sineLevelNext);
+
+
+ /* save switch and compare operations and reduce to XOR statement */
+ if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
+ *(ptrReal-1) += tmp1;
+ signalReal -= tmp2;
+ } else {
+ *(ptrReal-1) -= tmp1;
+ signalReal += tmp2;
+ }
+ *ptrReal++ = signalReal;
+ freqInvFlag = !freqInvFlag;
+ }
+
+ } else
+ {
+ if (!(harmIndex&0x1)) {
+ /* harmIndex 0,2 */
+ signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
+ *ptrReal++ = signalReal;
+ }
+ else {
+ /* harmIndex 1,3 in combination with freqInvFlag */
+ int shift = (int) (scale_change+1);
+ shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
+
+ FIXP_DBL tmp1 = (shift>=0) ? ( fMultDiv2(C1, sineLevel) >> shift )
+ : ( fMultDiv2(C1, sineLevel) << (-shift) );
+ FIXP_DBL tmp2 = fMultDiv2(C1, sineLevelNext);
+
+
+ /* save switch and compare operations and reduce to XOR statement */
+ if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
+ *(ptrReal-1) += tmp1;
+ signalReal -= tmp2;
+ } else {
+ *(ptrReal-1) -= tmp1;
+ signalReal += tmp2;
+ }
+ *ptrReal++ = signalReal;
+ freqInvFlag = !freqInvFlag;
+ }
+ }
+
+ pNoiseLevel++;
+
+ if ( noSubbands > 2 ) {
+ if (!(harmIndex&0x1)) {
+ /* harmIndex 0,2 */
+ if(!harmIndex)
+ {
+ sineSign = 0;
+ }
+
+ for (k=noSubbands-2; k!=0; k--) {
+ FIXP_DBL sinelevel = *pSineLevel++;
+ index++;
+ if (((signalReal = (sineSign ? -sinelevel : sinelevel)) == FL2FXCONST_DBL(0.0f)) && !noNoiseFlag)
+ {
+ /* Add noisefloor to the amplified signal */
+ index &= (SBR_NF_NO_RANDOM_VAL - 1);
+ signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
+ }
+
+ /* The next multiplication constitutes the actual envelope adjustment of the signal. */
+ signalReal += fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
+
+ pNoiseLevel++;
+ *ptrReal++ = signalReal;
+ } /* for ... */
+ }
+ else {
+ /* harmIndex 1,3 in combination with freqInvFlag */
+ if (harmIndex==1) freqInvFlag = !freqInvFlag;
+
+ for (k=noSubbands-2; k!=0; k--) {
+ index++;
+ /* The next multiplication constitutes the actual envelope adjustment of the signal. */
+ signalReal = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
+
+ if (*pSineLevel++!=FL2FXCONST_DBL(0.0f)) tone_count++;
+ else if (!noNoiseFlag) {
+ /* Add noisefloor to the amplified signal */
+ index &= (SBR_NF_NO_RANDOM_VAL - 1);
+ signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
+ }
+
+ pNoiseLevel++;
+
+ if (tone_count <= 16) {
+ FIXP_DBL addSine = fMultDiv2((pSineLevel[-2] - pSineLevel[0]), C1);
+ signalReal += (freqInvFlag) ? (-addSine) : (addSine);
+ }
+
+ *ptrReal++ = signalReal;
+ freqInvFlag = !freqInvFlag;
+ } /* for ... */
+ }
+ }
+
+ if (noSubbands > -1) {
+ index++;
+ /* The next multiplication constitutes the actual envelope adjustment of the signal. */
+ signalReal = fMultDiv2(*ptrReal,*pGain) << ((int)scale_change);
+ sineLevelPrev = fMultDiv2(pSineLevel[-1],FL2FX_SGL(0.0163f));
+ sineLevel = pSineLevel[0];
+
+ if (pSineLevel[0]!=FL2FXCONST_DBL(0.0f)) tone_count++;
+ else if (!noNoiseFlag) {
+ /* Add noisefloor to the amplified signal */
+ index &= (SBR_NF_NO_RANDOM_VAL - 1);
+ signalReal = signalReal + (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
+ }
+
+ if (!(harmIndex&0x1)) {
+ /* harmIndex 0,2 */
+ *ptrReal = signalReal + ( (sineSign) ? -sineLevel : sineLevel);
+ }
+ else {
+ /* harmIndex 1,3 in combination with freqInvFlag */
+ if(tone_count <= 16){
+ if (freqInvFlag) {
+ *ptrReal++ = signalReal - sineLevelPrev;
+ if (noSubbands + lowSubband < 63)
+ *ptrReal = *ptrReal + fMultDiv2(C1, sineLevel);
+ }
+ else {
+ *ptrReal++ = signalReal + sineLevelPrev;
+ if (noSubbands + lowSubband < 63)
+ *ptrReal = *ptrReal - fMultDiv2(C1, sineLevel);
+ }
+ }
+ else *ptrReal = signalReal;
+ }
+ }
+ *ptrHarmIndex = (harmIndex + 1) & 3;
+ *ptrPhaseIndex = index & (SBR_NF_NO_RANDOM_VAL - 1);
+}
+void adjustTimeSlotHQ(FIXP_DBL *RESTRICT ptrReal, /*!< Subband samples to be adjusted, real part */
+ FIXP_DBL *RESTRICT ptrImag, /*!< Subband samples to be adjusted, imag part */
+ HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
+ ENV_CALC_NRGS* nrgs,
+ int lowSubband, /*!< Lowest QMF-channel in the currently used SBR range. */
+ int noSubbands, /*!< Number of QMF subbands */
+ int scale_change, /*!< Number of bits to shift adjusted samples */
+ FIXP_SGL smooth_ratio, /*!< Impact of last envelope */
+ int noNoiseFlag, /*!< Start index to random number array */
+ int filtBufferNoiseShift) /*!< Shift factor of filtBufferNoise */
+{
+
+ FIXP_DBL *RESTRICT gain = nrgs->nrgGain; /*!< Gains of current envelope */
+ FIXP_DBL *RESTRICT noiseLevel = nrgs->noiseLevel; /*!< Noise levels of current envelope */
+ FIXP_DBL *RESTRICT pSineLevel = nrgs->nrgSine; /*!< Sine levels */
+
+ FIXP_DBL *RESTRICT filtBuffer = h_sbr_cal_env->filtBuffer; /*!< Gains of last envelope */
+ FIXP_DBL *RESTRICT filtBufferNoise = h_sbr_cal_env->filtBufferNoise; /*!< Noise levels of last envelope */
+ UCHAR *RESTRICT ptrHarmIndex =&h_sbr_cal_env->harmIndex; /*!< Harmonic index */
+ int *RESTRICT ptrPhaseIndex =&h_sbr_cal_env->phaseIndex; /*!< Start index to random number array */
+
+ int k;
+ FIXP_DBL signalReal, signalImag;
+ FIXP_DBL noiseReal, noiseImag;
+ FIXP_DBL smoothedGain, smoothedNoise;
+ FIXP_SGL direct_ratio = /*FL2FXCONST_SGL(1.0f) */ (FIXP_SGL)MAXVAL_SGL - smooth_ratio;
+ int index = *ptrPhaseIndex;
+ UCHAR harmIndex = *ptrHarmIndex;
+ register int freqInvFlag = (lowSubband & 1);
+ FIXP_DBL sineLevel;
+ int shift;
+
+ *ptrPhaseIndex = (index+noSubbands) & (SBR_NF_NO_RANDOM_VAL - 1);
+ *ptrHarmIndex = (harmIndex + 1) & 3;
+
+ /*
+ Possible optimization:
+ smooth_ratio and harmIndex stay constant during the loop.
+ It might be faster to include a separate loop in each path.
+
+ the check for smooth_ratio is now outside the loop and the workload
+ of the whole function decreased by about 20 %
+ */
+
+ filtBufferNoiseShift += 1; /* due to later use of fMultDiv2 instead of fMult */
+ if (filtBufferNoiseShift<0)
+ shift = fixMin(DFRACT_BITS-1,-filtBufferNoiseShift);
+ else
+ shift = fixMin(DFRACT_BITS-1, filtBufferNoiseShift);
+
+ if (smooth_ratio > FL2FXCONST_SGL(0.0f)) {
+
+ for (k=0; k<noSubbands; k++) {
+ /*
+ Smoothing: The old envelope has been bufferd and a certain ratio
+ of the old gains and noise levels is used.
+ */
+
+ smoothedGain = fMult(smooth_ratio,filtBuffer[k]) +
+ fMult(direct_ratio,gain[k]);
+
+ if (filtBufferNoiseShift<0) {
+ smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])>>shift) +
+ fMult(direct_ratio,noiseLevel[k]);
+ }
+ else {
+ smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])<<shift) +
+ fMult(direct_ratio,noiseLevel[k]);
+ }
+
+ /*
+ The next 2 multiplications constitute the actual envelope adjustment
+ of the signal and should be carried out with full accuracy
+ (supplying #DFRACT_BITS valid bits).
+ */
+ signalReal = fMultDiv2(*ptrReal,smoothedGain)<<((int)scale_change);
+ signalImag = fMultDiv2(*ptrImag,smoothedGain)<<((int)scale_change);
+
+ index++;
+
+ if (pSineLevel[k] != FL2FXCONST_DBL(0.0f)) {
+ sineLevel = pSineLevel[k];
+
+ switch(harmIndex) {
+ case 0:
+ *ptrReal++ = (signalReal + sineLevel);
+ *ptrImag++ = (signalImag);
+ break;
+ case 2:
+ *ptrReal++ = (signalReal - sineLevel);
+ *ptrImag++ = (signalImag);
+ break;
+ case 1:
+ *ptrReal++ = (signalReal);
+ if (freqInvFlag)
+ *ptrImag++ = (signalImag - sineLevel);
+ else
+ *ptrImag++ = (signalImag + sineLevel);
+ break;
+ case 3:
+ *ptrReal++ = signalReal;
+ if (freqInvFlag)
+ *ptrImag++ = (signalImag + sineLevel);
+ else
+ *ptrImag++ = (signalImag - sineLevel);
+ break;
+ }
+ }
+ else {
+ if (noNoiseFlag) {
+ /* Just the amplified signal is saved */
+ *ptrReal++ = (signalReal);
+ *ptrImag++ = (signalImag);
+ }
+ else {
+ /* Add noisefloor to the amplified signal */
+ index &= (SBR_NF_NO_RANDOM_VAL - 1);
+ noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise)<<4;
+ noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise)<<4;
+ *ptrReal++ = (signalReal + noiseReal);
+ *ptrImag++ = (signalImag + noiseImag);
+ }
+ }
+ freqInvFlag ^= 1;
+ }
+
+ }
+ else
+ {
+ for (k=0; k<noSubbands; k++)
+ {
+ smoothedGain = gain[k];
+ signalReal = fMultDiv2(*ptrReal, smoothedGain) << scale_change;
+ signalImag = fMultDiv2(*ptrImag, smoothedGain) << scale_change;
+
+ index++;
+
+ if ((sineLevel = pSineLevel[k]) != FL2FXCONST_DBL(0.0f))
+ {
+ switch (harmIndex)
+ {
+ case 0:
+ signalReal += sineLevel;
+ break;
+ case 1:
+ if (freqInvFlag)
+ signalImag -= sineLevel;
+ else
+ signalImag += sineLevel;
+ break;
+ case 2:
+ signalReal -= sineLevel;
+ break;
+ case 3:
+ if (freqInvFlag)
+ signalImag += sineLevel;
+ else
+ signalImag -= sineLevel;
+ break;
+ }
+ }
+ else
+ {
+ if (noNoiseFlag == 0)
+ {
+ /* Add noisefloor to the amplified signal */
+ smoothedNoise = noiseLevel[k];
+ index &= (SBR_NF_NO_RANDOM_VAL - 1);
+ noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise);
+ noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise);
+ signalReal += noiseReal<<4;
+ signalImag += noiseImag<<4;
+ }
+ }
+ *ptrReal++ = signalReal;
+ *ptrImag++ = signalImag;
+
+ freqInvFlag ^= 1;
+ }
+ }
+}
+
+
+/*!
+ \brief Reset limiter bands.
+
+ Build frequency band table for the gain limiter dependent on
+ the previously generated transposer patch areas.
+
+ \return SBRDEC_OK if ok, SBRDEC_UNSUPPORTED_CONFIG on error
+*/
+SBR_ERROR
+ResetLimiterBands ( UCHAR *limiterBandTable, /*!< Resulting band borders in QMF channels */
+ UCHAR *noLimiterBands, /*!< Resulting number of limiter band */
+ UCHAR *freqBandTable, /*!< Table with possible band borders */
+ int noFreqBands, /*!< Number of bands in freqBandTable */
+ const PATCH_PARAM *patchParam, /*!< Transposer patch parameters */
+ int noPatches, /*!< Number of transposer patches */
+ int limiterBands) /*!< Selected 'band density' from bitstream */
+{
+ int i, k, isPatchBorder[2], loLimIndex, hiLimIndex, tempNoLim, nBands;
+ UCHAR workLimiterBandTable[MAX_FREQ_COEFFS / 2 + MAX_NUM_PATCHES + 1];
+ int patchBorders[MAX_NUM_PATCHES + 1];
+ int kx, k2;
+ FIXP_DBL temp;
+
+ int lowSubband = freqBandTable[0];
+ int highSubband = freqBandTable[noFreqBands];
+
+ /* 1 limiter band. */
+ if(limiterBands == 0) {
+ limiterBandTable[0] = 0;
+ limiterBandTable[1] = highSubband - lowSubband;
+ nBands = 1;
+ } else {
+ for (i = 0; i < noPatches; i++) {
+ patchBorders[i] = patchParam[i].guardStartBand - lowSubband;
+ }
+ patchBorders[i] = highSubband - lowSubband;
+
+ /* 1.2, 2, or 3 limiter bands/octave plus bandborders at patchborders. */
+ for (k = 0; k <= noFreqBands; k++) {
+ workLimiterBandTable[k] = freqBandTable[k] - lowSubband;
+ }
+ for (k = 1; k < noPatches; k++) {
+ workLimiterBandTable[noFreqBands + k] = patchBorders[k];
+ }
+
+ tempNoLim = nBands = noFreqBands + noPatches - 1;
+ shellsort(workLimiterBandTable, tempNoLim + 1);
+
+ loLimIndex = 0;
+ hiLimIndex = 1;
+
+
+ while (hiLimIndex <= tempNoLim) {
+ k2 = workLimiterBandTable[hiLimIndex] + lowSubband;
+ kx = workLimiterBandTable[loLimIndex] + lowSubband;
+
+ temp = FX_SGL2FX_DBL(FDK_getNumOctavesDiv8(kx,k2)); /* Number of octaves */
+ temp = fMult(temp, FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4[limiterBands]);
+
+ if (temp < FL2FXCONST_DBL (0.49f)>>5) {
+ if (workLimiterBandTable[hiLimIndex] == workLimiterBandTable[loLimIndex]) {
+ workLimiterBandTable[hiLimIndex] = highSubband;
+ nBands--;
+ hiLimIndex++;
+ continue;
+ }
+ isPatchBorder[0] = isPatchBorder[1] = 0;
+ for (k = 0; k <= noPatches; k++) {
+ if (workLimiterBandTable[hiLimIndex] == patchBorders[k]) {
+ isPatchBorder[1] = 1;
+ break;
+ }
+ }
+ if (!isPatchBorder[1]) {
+ workLimiterBandTable[hiLimIndex] = highSubband;
+ nBands--;
+ hiLimIndex++;
+ continue;
+ }
+ for (k = 0; k <= noPatches; k++) {
+ if (workLimiterBandTable[loLimIndex] == patchBorders[k]) {
+ isPatchBorder[0] = 1;
+ break;
+ }
+ }
+ if (!isPatchBorder[0]) {
+ workLimiterBandTable[loLimIndex] = highSubband;
+ nBands--;
+ }
+ }
+ loLimIndex = hiLimIndex;
+ hiLimIndex++;
+
+ }
+ shellsort(workLimiterBandTable, tempNoLim + 1);
+
+ /* Test if algorithm exceeded maximum allowed limiterbands */
+ if( nBands > MAX_NUM_LIMITERS || nBands <= 0) {
+ return SBRDEC_UNSUPPORTED_CONFIG;
+ }
+
+ /* Copy limiterbands from working buffer into final destination */
+ for (k = 0; k <= nBands; k++) {
+ limiterBandTable[k] = workLimiterBandTable[k];
+ }
+ }
+ *noLimiterBands = nBands;
+
+ return SBRDEC_OK;
+}
+