aboutsummaryrefslogtreecommitdiffstats
path: root/libSBRenc/src/nf_est.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libSBRenc/src/nf_est.cpp')
-rw-r--r--libSBRenc/src/nf_est.cpp575
1 files changed, 575 insertions, 0 deletions
diff --git a/libSBRenc/src/nf_est.cpp b/libSBRenc/src/nf_est.cpp
new file mode 100644
index 0000000..62bcc79
--- /dev/null
+++ b/libSBRenc/src/nf_est.cpp
@@ -0,0 +1,575 @@
+
+/* -----------------------------------------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------------------------------------- */
+
+#include "nf_est.h"
+
+#include "sbr_misc.h"
+
+#include "genericStds.h"
+
+/* smoothFilter[4] = {0.05857864376269f, 0.2f, 0.34142135623731f, 0.4f}; */
+static const FIXP_DBL smoothFilter[4] = { 0x077f813d, 0x19999995, 0x2bb3b1f5, 0x33333335 };
+
+/* static const INT smoothFilterLength = 4; */
+
+static const FIXP_DBL QuantOffset = (INT)0xfc000000; /* ld64(0.25) */
+
+#ifndef min
+#define min(a,b) ( a < b ? a:b)
+#endif
+
+#ifndef max
+#define max(a,b) ( a > b ? a:b)
+#endif
+
+#define NOISE_FLOOR_OFFSET_SCALING (3)
+
+
+
+/**************************************************************************/
+/*!
+ \brief The function applies smoothing to the noise levels.
+
+
+
+ \return none
+
+*/
+/**************************************************************************/
+static void
+smoothingOfNoiseLevels(FIXP_DBL *NoiseLevels, /*!< pointer to noise-floor levels.*/
+ INT nEnvelopes, /*!< Number of noise floor envelopes.*/
+ INT noNoiseBands, /*!< Number of noise bands for every noise floor envelope. */
+ FIXP_DBL prevNoiseLevels[NF_SMOOTHING_LENGTH][MAX_NUM_NOISE_VALUES],/*!< Previous noise floor envelopes. */
+ const FIXP_DBL *smoothFilter, /*!< filter used for smoothing the noise floor levels. */
+ INT transientFlag) /*!< flag indicating if a transient is present*/
+
+{
+ INT i,band,env;
+ FIXP_DBL accu;
+
+ for(env = 0; env < nEnvelopes; env++){
+ if(transientFlag){
+ for (i = 0; i < NF_SMOOTHING_LENGTH; i++){
+ FDKmemcpy(prevNoiseLevels[i],NoiseLevels+env*noNoiseBands,noNoiseBands*sizeof(FIXP_DBL));
+ }
+ }
+ else {
+ for (i = 1; i < NF_SMOOTHING_LENGTH; i++){
+ FDKmemcpy(prevNoiseLevels[i - 1],prevNoiseLevels[i],noNoiseBands*sizeof(FIXP_DBL));
+ }
+ FDKmemcpy(prevNoiseLevels[NF_SMOOTHING_LENGTH - 1],NoiseLevels+env*noNoiseBands,noNoiseBands*sizeof(FIXP_DBL));
+ }
+
+ for (band = 0; band < noNoiseBands; band++){
+ accu = FL2FXCONST_DBL(0.0f);
+ for (i = 0; i < NF_SMOOTHING_LENGTH; i++){
+ accu += fMultDiv2(smoothFilter[i], prevNoiseLevels[i][band]);
+ }
+ FDK_ASSERT( (band + env*noNoiseBands) < MAX_NUM_NOISE_VALUES);
+ NoiseLevels[band+ env*noNoiseBands] = accu<<1;
+ }
+ }
+}
+
+/**************************************************************************/
+/*!
+ \brief Does the noise floor level estiamtion.
+
+ The noiseLevel samples are scaled by the factor 0.25
+
+ \return none
+
+*/
+/**************************************************************************/
+static void
+qmfBasedNoiseFloorDetection(FIXP_DBL *noiseLevel, /*!< Pointer to vector to store the noise levels in.*/
+ FIXP_DBL ** quotaMatrixOrig, /*!< Matrix holding the quota values of the original. */
+ SCHAR *indexVector, /*!< Index vector to obtain the patched data. */
+ INT startIndex, /*!< Start index. */
+ INT stopIndex, /*!< Stop index. */
+ INT startChannel, /*!< Start channel of the current noise floor band.*/
+ INT stopChannel, /*!< Stop channel of the current noise floor band. */
+ FIXP_DBL ana_max_level, /*!< Maximum level of the adaptive noise.*/
+ FIXP_DBL noiseFloorOffset, /*!< Noise floor offset. */
+ INT missingHarmonicFlag, /*!< Flag indicating if a strong tonal component is missing.*/
+ FIXP_DBL weightFac, /*!< Weightening factor for the difference between orig and sbr. */
+ INVF_MODE diffThres, /*!< Threshold value to control the inverse filtering decision.*/
+ INVF_MODE inverseFilteringLevel) /*!< Inverse filtering level of the current band.*/
+{
+ INT scale, l, k;
+ FIXP_DBL meanOrig=FL2FXCONST_DBL(0.0f), meanSbr=FL2FXCONST_DBL(0.0f), diff;
+ FIXP_DBL invIndex = GetInvInt(stopIndex-startIndex);
+ FIXP_DBL invChannel = GetInvInt(stopChannel-startChannel);
+ FIXP_DBL accu;
+
+ /*
+ Calculate the mean value, over the current time segment, for the original, the HFR
+ and the difference, over all channels in the current frequency range.
+ */
+
+ if(missingHarmonicFlag == 1){
+ for(l = startChannel; l < stopChannel;l++){
+ /* tonalityOrig */
+ accu = FL2FXCONST_DBL(0.0f);
+ for(k = startIndex ; k < stopIndex; k++){
+ accu += fMultDiv2(quotaMatrixOrig[k][l], invIndex);
+ }
+ meanOrig = fixMax(meanOrig,(accu<<1));
+
+ /* tonalitySbr */
+ accu = FL2FXCONST_DBL(0.0f);
+ for(k = startIndex ; k < stopIndex; k++){
+ accu += fMultDiv2(quotaMatrixOrig[k][indexVector[l]], invIndex);
+ }
+ meanSbr = fixMax(meanSbr,(accu<<1));
+
+ }
+ }
+ else{
+ for(l = startChannel; l < stopChannel;l++){
+ /* tonalityOrig */
+ accu = FL2FXCONST_DBL(0.0f);
+ for(k = startIndex ; k < stopIndex; k++){
+ accu += fMultDiv2(quotaMatrixOrig[k][l], invIndex);
+ }
+ meanOrig += fMult((accu<<1), invChannel);
+
+ /* tonalitySbr */
+ accu = FL2FXCONST_DBL(0.0f);
+ for(k = startIndex ; k < stopIndex; k++){
+ accu += fMultDiv2(quotaMatrixOrig[k][indexVector[l]], invIndex);
+ }
+ meanSbr += fMult((accu<<1), invChannel);
+ }
+ }
+
+ /* Small fix to avoid noise during silent passages.*/
+ if( meanOrig <= FL2FXCONST_DBL(0.000976562f*RELAXATION_FLOAT) &&
+ meanSbr <= FL2FXCONST_DBL(0.000976562f*RELAXATION_FLOAT) )
+ {
+ meanOrig = FL2FXCONST_DBL(101.5936673f*RELAXATION_FLOAT);
+ meanSbr = FL2FXCONST_DBL(101.5936673f*RELAXATION_FLOAT);
+ }
+
+ meanOrig = fixMax(meanOrig,RELAXATION);
+ meanSbr = fixMax(meanSbr,RELAXATION);
+
+ if (missingHarmonicFlag == 1 ||
+ inverseFilteringLevel == INVF_MID_LEVEL ||
+ inverseFilteringLevel == INVF_LOW_LEVEL ||
+ inverseFilteringLevel == INVF_OFF ||
+ inverseFilteringLevel <= diffThres)
+ {
+ diff = RELAXATION;
+ }
+ else {
+ accu = fDivNorm(meanSbr, meanOrig, &scale);
+
+ diff = fixMax( RELAXATION,
+ fMult(RELAXATION_FRACT,fMult(weightFac,accu)) >>( RELAXATION_SHIFT-scale ) ) ;
+ }
+
+ /*
+ * noise Level is now a positive value, i.e.
+ * the more harmonic the signal is the higher noise level,
+ * this makes no sense so we change the sign.
+ *********************************************************/
+ accu = fDivNorm(diff, meanOrig, &scale);
+ scale -= 2;
+
+ if ( (scale>0) && (accu > ((FIXP_DBL)MAXVAL_DBL)>>scale) ) {
+ *noiseLevel = (FIXP_DBL)MAXVAL_DBL;
+ }
+ else {
+ *noiseLevel = scaleValue(accu, scale);
+ }
+
+ /*
+ * Add a noise floor offset to compensate for bias in the detector
+ *****************************************************************/
+ if(!missingHarmonicFlag)
+ *noiseLevel = fMult(*noiseLevel, noiseFloorOffset)<<(NOISE_FLOOR_OFFSET_SCALING);
+
+ /*
+ * check to see that we don't exceed the maximum allowed level
+ **************************************************************/
+ *noiseLevel = fixMin(*noiseLevel, ana_max_level); /* ana_max_level is scaled with factor 0.25 */
+}
+
+/**************************************************************************/
+/*!
+ \brief Does the noise floor level estiamtion.
+ The function calls the Noisefloor estimation function
+ for the time segments decided based upon the transient
+ information. The block is always divided into one or two segments.
+
+
+ \return none
+
+*/
+/**************************************************************************/
+void
+FDKsbrEnc_sbrNoiseFloorEstimateQmf(HANDLE_SBR_NOISE_FLOOR_ESTIMATE h_sbrNoiseFloorEstimate, /*!< Handle to SBR_NOISE_FLOOR_ESTIMATE struct */
+ const SBR_FRAME_INFO *frame_info, /*!< Time frequency grid of the current frame. */
+ FIXP_DBL *noiseLevels, /*!< Pointer to vector to store the noise levels in.*/
+ FIXP_DBL **quotaMatrixOrig, /*!< Matrix holding the quota values of the original. */
+ SCHAR *indexVector, /*!< Index vector to obtain the patched data. */
+ INT missingHarmonicsFlag, /*!< Flag indicating if a strong tonal component will be missing. */
+ INT startIndex, /*!< Start index. */
+ int numberOfEstimatesPerFrame, /*!< The number of tonality estimates per frame. */
+ int transientFrame, /*!< A flag indicating if a transient is present. */
+ INVF_MODE* pInvFiltLevels, /*!< Pointer to the vector holding the inverse filtering levels. */
+ UINT sbrSyntaxFlags
+ )
+
+{
+
+ INT nNoiseEnvelopes, startPos[2], stopPos[2], env, band;
+
+ INT noNoiseBands = h_sbrNoiseFloorEstimate->noNoiseBands;
+ INT *freqBandTable = h_sbrNoiseFloorEstimate->freqBandTableQmf;
+
+ nNoiseEnvelopes = frame_info->nNoiseEnvelopes;
+
+ if (sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
+ nNoiseEnvelopes = 1;
+ startPos[0] = startIndex;
+ stopPos[0] = startIndex + min(numberOfEstimatesPerFrame,2);
+ } else
+ if(nNoiseEnvelopes == 1){
+ startPos[0] = startIndex;
+ stopPos[0] = startIndex + 2;
+ }
+ else{
+ startPos[0] = startIndex;
+ stopPos[0] = startIndex + 1;
+ startPos[1] = startIndex + 1;
+ stopPos[1] = startIndex + 2;
+ }
+
+ /*
+ * Estimate the noise floor.
+ **************************************/
+ for(env = 0; env < nNoiseEnvelopes; env++){
+ for(band = 0; band < noNoiseBands; band++){
+ FDK_ASSERT( (band + env*noNoiseBands) < MAX_NUM_NOISE_VALUES);
+ qmfBasedNoiseFloorDetection(&noiseLevels[band + env*noNoiseBands],
+ quotaMatrixOrig,
+ indexVector,
+ startPos[env],
+ stopPos[env],
+ freqBandTable[band],
+ freqBandTable[band+1],
+ h_sbrNoiseFloorEstimate->ana_max_level,
+ h_sbrNoiseFloorEstimate->noiseFloorOffset[band],
+ missingHarmonicsFlag,
+ h_sbrNoiseFloorEstimate->weightFac,
+ h_sbrNoiseFloorEstimate->diffThres,
+ pInvFiltLevels[band]);
+ }
+ }
+
+
+ /*
+ * Smoothing of the values.
+ **************************/
+ smoothingOfNoiseLevels(noiseLevels,
+ nNoiseEnvelopes,
+ h_sbrNoiseFloorEstimate->noNoiseBands,
+ h_sbrNoiseFloorEstimate->prevNoiseLevels,
+ h_sbrNoiseFloorEstimate->smoothFilter,
+ transientFrame);
+
+
+ /* quantisation*/
+ for(env = 0; env < nNoiseEnvelopes; env++){
+ for(band = 0; band < noNoiseBands; band++){
+ FDK_ASSERT( (band + env*noNoiseBands) < MAX_NUM_NOISE_VALUES);
+ noiseLevels[band + env*noNoiseBands] =
+ (FIXP_DBL)NOISE_FLOOR_OFFSET_64 - (FIXP_DBL)CalcLdData(noiseLevels[band + env*noNoiseBands]+(FIXP_DBL)1) + QuantOffset;
+ }
+ }
+}
+
+/**************************************************************************/
+/*!
+ \brief
+
+
+ \return errorCode, noError if successful
+
+*/
+/**************************************************************************/
+static INT
+downSampleLoRes(INT *v_result, /*!< */
+ INT num_result, /*!< */
+ const UCHAR *freqBandTableRef,/*!< */
+ INT num_Ref) /*!< */
+{
+ INT step;
+ INT i,j;
+ INT org_length,result_length;
+ INT v_index[MAX_FREQ_COEFFS/2];
+
+ /* init */
+ org_length=num_Ref;
+ result_length=num_result;
+
+ v_index[0]=0; /* Always use left border */
+ i=0;
+ while(org_length > 0) /* Create downsample vector */
+ {
+ i++;
+ step=org_length/result_length; /* floor; */
+ org_length=org_length - step;
+ result_length--;
+ v_index[i]=v_index[i-1]+step;
+ }
+
+ if(i != num_result ) /* Should never happen */
+ return (1);/* error downsampling */
+
+ for(j=0;j<=i;j++) /* Use downsample vector to index LoResolution vector. */
+ {
+ v_result[j]=freqBandTableRef[v_index[j]];
+ }
+
+ return (0);
+}
+
+/**************************************************************************/
+/*!
+ \brief Initialize an instance of the noise floor level estimation module.
+
+
+ \return errorCode, noError if successful
+
+*/
+/**************************************************************************/
+INT
+FDKsbrEnc_InitSbrNoiseFloorEstimate (HANDLE_SBR_NOISE_FLOOR_ESTIMATE h_sbrNoiseFloorEstimate, /*!< Handle to SBR_NOISE_FLOOR_ESTIMATE struct */
+ INT ana_max_level, /*!< Maximum level of the adaptive noise. */
+ const UCHAR *freqBandTable, /*!< Frequany band table. */
+ INT nSfb, /*!< Number of frequency bands. */
+ INT noiseBands, /*!< Number of noise bands per octave. */
+ INT noiseFloorOffset, /*!< Noise floor offset. */
+ INT timeSlots, /*!< Number of time slots in a frame. */
+ UINT useSpeechConfig /*!< Flag: adapt tuning parameters according to speech */
+ )
+{
+ INT i, qexp, qtmp;
+ FIXP_DBL tmp, exp;
+
+ FDKmemclear(h_sbrNoiseFloorEstimate,sizeof(SBR_NOISE_FLOOR_ESTIMATE));
+
+ h_sbrNoiseFloorEstimate->smoothFilter = smoothFilter;
+ if (useSpeechConfig) {
+ h_sbrNoiseFloorEstimate->weightFac = (FIXP_DBL)MAXVAL_DBL;
+ h_sbrNoiseFloorEstimate->diffThres = INVF_LOW_LEVEL;
+ }
+ else {
+ h_sbrNoiseFloorEstimate->weightFac = FL2FXCONST_DBL(0.25f);
+ h_sbrNoiseFloorEstimate->diffThres = INVF_MID_LEVEL;
+ }
+
+ h_sbrNoiseFloorEstimate->timeSlots = timeSlots;
+ h_sbrNoiseFloorEstimate->noiseBands = noiseBands;
+
+ /* h_sbrNoiseFloorEstimate->ana_max_level is scaled by 0.25 */
+ switch(ana_max_level)
+ {
+ case 6:
+ h_sbrNoiseFloorEstimate->ana_max_level = (FIXP_DBL)MAXVAL_DBL;
+ break;
+ case 3:
+ h_sbrNoiseFloorEstimate->ana_max_level = FL2FXCONST_DBL(0.5);
+ break;
+ case -3:
+ h_sbrNoiseFloorEstimate->ana_max_level = FL2FXCONST_DBL(0.125);
+ break;
+ default:
+ /* Should not enter here */
+ h_sbrNoiseFloorEstimate->ana_max_level = (FIXP_DBL)MAXVAL_DBL;
+ break;
+ }
+
+ /*
+ calculate number of noise bands and allocate
+ */
+ if(FDKsbrEnc_resetSbrNoiseFloorEstimate(h_sbrNoiseFloorEstimate,freqBandTable,nSfb))
+ return(1);
+
+ if(noiseFloorOffset == 0) {
+ tmp = ((FIXP_DBL)MAXVAL_DBL)>>NOISE_FLOOR_OFFSET_SCALING;
+ }
+ else {
+ FDK_ASSERT(noiseFloorOffset<=8); /* because of NOISE_FLOOR_OFFSET_SCALING */
+
+ /* Assumes the noise floor offset in tuning table are in q31 */
+ /* Currently the table contains only 0 for noise floor offset */
+ /* Change the qformat here when non-zero values would be filled */
+ exp = fDivNorm((FIXP_DBL)noiseFloorOffset, 3, &qexp);
+ tmp = fPow(2, DFRACT_BITS-1, exp, qexp, &qtmp);
+ tmp = scaleValue(tmp, qtmp-NOISE_FLOOR_OFFSET_SCALING);
+ }
+
+ for(i=0;i<h_sbrNoiseFloorEstimate->noNoiseBands;i++) {
+ h_sbrNoiseFloorEstimate->noiseFloorOffset[i] = tmp;
+ }
+
+ return (0);
+}
+
+/**************************************************************************/
+/*!
+ \brief Resets the current instance of the noise floor estiamtion
+ module.
+
+
+ \return errorCode, noError if successful
+
+*/
+/**************************************************************************/
+INT
+FDKsbrEnc_resetSbrNoiseFloorEstimate (HANDLE_SBR_NOISE_FLOOR_ESTIMATE h_sbrNoiseFloorEstimate, /*!< Handle to SBR_NOISE_FLOOR_ESTIMATE struct */
+ const UCHAR *freqBandTable, /*!< Frequany band table. */
+ INT nSfb) /*!< Number of bands in the frequency band table. */
+{
+ INT k2,kx;
+
+ /*
+ * Calculate number of noise bands
+ ***********************************/
+ k2=freqBandTable[nSfb];
+ kx=freqBandTable[0];
+ if(h_sbrNoiseFloorEstimate->noiseBands == 0){
+ h_sbrNoiseFloorEstimate->noNoiseBands = 1;
+ }
+ else{
+ /*
+ * Calculate number of noise bands 1,2 or 3 bands/octave
+ ********************************************************/
+ FIXP_DBL tmp, ratio, lg2;
+ INT ratio_e, qlg2;
+
+ ratio = fDivNorm(k2, kx, &ratio_e);
+ lg2 = fLog2(ratio, ratio_e, &qlg2);
+ tmp = fMult((FIXP_DBL)(h_sbrNoiseFloorEstimate->noiseBands<<24), lg2);
+ tmp = scaleValue(tmp, qlg2-23);
+
+ h_sbrNoiseFloorEstimate->noNoiseBands = (INT)((tmp + (FIXP_DBL)1) >> 1);
+
+ if (h_sbrNoiseFloorEstimate->noNoiseBands > MAX_NUM_NOISE_COEFFS)
+ h_sbrNoiseFloorEstimate->noNoiseBands = MAX_NUM_NOISE_COEFFS;
+
+ if( h_sbrNoiseFloorEstimate->noNoiseBands==0)
+ h_sbrNoiseFloorEstimate->noNoiseBands=1;
+ }
+
+
+ return(downSampleLoRes(h_sbrNoiseFloorEstimate->freqBandTableQmf,
+ h_sbrNoiseFloorEstimate->noNoiseBands,
+ freqBandTable,nSfb));
+}
+
+/**************************************************************************/
+/*!
+ \brief Deletes the current instancce of the noise floor level
+ estimation module.
+
+
+ \return none
+
+*/
+/**************************************************************************/
+void
+FDKsbrEnc_deleteSbrNoiseFloorEstimate (HANDLE_SBR_NOISE_FLOOR_ESTIMATE h_sbrNoiseFloorEstimate) /*!< Handle to SBR_NOISE_FLOOR_ESTIMATE struct */
+{
+
+ if (h_sbrNoiseFloorEstimate) {
+ /*
+ nothing to do
+ */
+ }
+}