diff options
Diffstat (limited to 'libSBRdec/src/env_calc.cpp')
| -rw-r--r-- | libSBRdec/src/env_calc.cpp | 2317 |
1 files changed, 0 insertions, 2317 deletions
diff --git a/libSBRdec/src/env_calc.cpp b/libSBRdec/src/env_calc.cpp deleted file mode 100644 index 73bd7ba..0000000 --- a/libSBRdec/src/env_calc.cpp +++ /dev/null @@ -1,2317 +0,0 @@ - -/* ----------------------------------------------------------------------------------------------------------- -Software License for The Fraunhofer FDK AAC Codec Library for Android - -© Copyright 1995 - 2015 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 adjustTimeSlot_EldGrid(FIXP_DBL *ptrReal, - ENV_CALC_NRGS* nrgs, - UCHAR *ptrHarmIndex, - int lowSubbands, - int noSubbands, - int scale_change, - int noNoiseFlag, - int *ptrPhaseIndex, - int scale_diff_low); - -static void adjustTimeSlotLC(FIXP_DBL *ptrReal, - ENV_CALC_NRGS* nrgs, - UCHAR *ptrHarmIndex, - int lowSubbands, - int noSubbands, - int scale_change, - int noNoiseFlag, - int *ptrPhaseIndex); -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 - { - if (flags & SBRDEC_ELD_GRID) { - adjustTimeSlot_EldGrid(&analysBufferReal[j][lowSubband], - pNrgs, - &h_sbr_cal_env->harmIndex, - lowSubband, - noSubbands, - scale_change, - noNoiseFlag, - &h_sbr_cal_env->phaseIndex, - EXP2SCALE(adj_e) - sbrScaleFactor->lb_scale); - } else - { - adjustTimeSlotLC(&analysBufferReal[j][lowSubband], - pNrgs, - &h_sbr_cal_env->harmIndex, - lowSubband, - noSubbands, - scale_change, - noNoiseFlag, - &h_sbr_cal_env->phaseIndex); - } - } - } // 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; -} - -static void adjustTimeSlot_EldGrid( - 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 scale_diff_low) /*!< */ -{ - int k; - FIXP_DBL signalReal, sbNoise; - int tone_count = 0; - - 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 phaseIndex = *ptrPhaseIndex; - UCHAR harmIndex = *ptrHarmIndex; - - static const INT harmonicPhase [2][4] = { - { 1, 0, -1, 0}, - { 0, 1, 0, -1} - }; - - static const FIXP_DBL harmonicPhaseX [2][4] = { - { FL2FXCONST_DBL(2.0*1.245183154539139e-001), FL2FXCONST_DBL(2.0*-1.123767859325028e-001), FL2FXCONST_DBL(2.0*-1.245183154539139e-001), FL2FXCONST_DBL(2.0* 1.123767859325028e-001) }, - { FL2FXCONST_DBL(2.0*1.245183154539139e-001), FL2FXCONST_DBL(2.0* 1.123767859325028e-001), FL2FXCONST_DBL(2.0*-1.245183154539139e-001), FL2FXCONST_DBL(2.0*-1.123767859325028e-001) } - }; - - for (k=0; k < noSubbands; k++) { - - phaseIndex = (phaseIndex + 1) & (SBR_NF_NO_RANDOM_VAL - 1); - - if( (pSineLevel[0] != FL2FXCONST_DBL(0.0f)) || (noNoiseFlag == 1) ){ - sbNoise = FL2FXCONST_DBL(0.0f); - } else { - sbNoise = pNoiseLevel[0]; - } - - signalReal = fMultDiv2(*ptrReal,*pGain) << ((int)scale_change); - - signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[phaseIndex][0], sbNoise)<<4); - - signalReal += pSineLevel[0] * harmonicPhase[0][harmIndex]; - - *ptrReal = signalReal; - - if (k == 0) { - *(ptrReal-1) += scaleValue(fMultDiv2(harmonicPhaseX[lowSubband&1][harmIndex], pSineLevel[0]), -scale_diff_low) ; - if (k < noSubbands - 1) { - *(ptrReal) += fMultDiv2(pSineLevel[1], harmonicPhaseX[(lowSubband+1)&1][harmIndex]); - } - } - if (k > 0 && k < noSubbands - 1 && tone_count < 16) { - *(ptrReal) += fMultDiv2(pSineLevel[- 1], harmonicPhaseX [(lowSubband+k)&1] [harmIndex]); - *(ptrReal) += fMultDiv2(pSineLevel[+ 1], harmonicPhaseX [(lowSubband+k+1)&1][harmIndex]); - } - if (k == noSubbands - 1 && tone_count < 16) { - if (k > 0) { - *(ptrReal) += fMultDiv2(pSineLevel[- 1], harmonicPhaseX [(lowSubband+k)&1][harmIndex]); - } - if (k + lowSubband + 1< 63) { - *(ptrReal+1) += fMultDiv2(pSineLevel[0], harmonicPhaseX[(lowSubband+k+1)&1][harmIndex]); - } - } - - if(pSineLevel[0] != FL2FXCONST_DBL(0.0f)){ - tone_count++; - } - ptrReal++; - pNoiseLevel++; - pGain++; - pSineLevel++; - } - - *ptrHarmIndex = (harmIndex + 1) & 3; - *ptrPhaseIndex = phaseIndex & (SBR_NF_NO_RANDOM_VAL - 1); -} - -/*! - \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 */ -{ - 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 (!(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); -} -static 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; - 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; - - 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) { - FIXP_DBL div_m, oct_m, temp; - INT div_e = 0, oct_e = 0, temp_e = 0; - - k2 = workLimiterBandTable[hiLimIndex] + lowSubband; - kx = workLimiterBandTable[loLimIndex] + lowSubband; - - div_m = fDivNorm(k2, kx, &div_e); - - /* calculate number of octaves */ - oct_m = fLog2(div_m, div_e, &oct_e); - - /* multiply with limiterbands per octave */ - /* values 1, 1.2, 2, 3 -> scale factor of 2 */ - temp = fMultNorm(oct_m, FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4_DBL[limiterBands], &temp_e); - - /* overall scale factor of temp ist addition of scalefactors from log2 calculation, - limiter bands scalefactor (2) and limiter bands multiplication */ - temp_e += oct_e + 2; - - /* div can be a maximum of 64 (k2 = 64 and kx = 1) - -> oct can be a maximum of 6 - -> temp can be a maximum of 18 (as limiterBandsPerOctoave is a maximum factor of 3) - -> we need a scale factor of 5 for comparisson - */ - if (temp >> (5 - temp_e) < 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; -} - |