| /* ----------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten |
| Forschung e.V. All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software |
| that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding |
| scheme for digital audio. This FDK AAC Codec software is intended to be used on |
| a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient |
| general perceptual audio codecs. AAC-ELD is considered the best-performing |
| full-bandwidth communications codec by independent studies and is widely |
| deployed. AAC has been standardized by ISO and IEC as part of the MPEG |
| specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including |
| those of Fraunhofer) may be obtained through Via Licensing |
| (www.vialicensing.com) or through the respective patent owners individually for |
| the purpose of encoding or decoding bit streams in products that are compliant |
| with the ISO/IEC MPEG audio standards. Please note that most manufacturers of |
| Android devices already license these patent claims through Via Licensing or |
| directly from the patent owners, and therefore FDK AAC Codec software may |
| already be covered under those patent licenses when it is used for those |
| licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions |
| with enhanced sound quality, are also available from Fraunhofer. Users are |
| encouraged to check the Fraunhofer website for additional applications |
| information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted without payment of copyright license fees provided that you |
| satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of |
| the FDK AAC Codec or your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation |
| and/or other materials provided with redistributions of the FDK AAC Codec or |
| your modifications thereto in binary form. You must make available free of |
| charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived |
| from this library without prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute |
| the FDK AAC Codec software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating |
| that you changed the software and the date of any change. For modified versions |
| of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" |
| must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK |
| AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without |
| limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. |
| Fraunhofer provides no warranty of patent non-infringement with respect to this |
| software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for |
| purposes that are authorized by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright |
| holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, |
| including but not limited to the implied warranties of merchantability and |
| fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, |
| or consequential damages, including but not limited to procurement of substitute |
| goods or services; loss of use, data, or profits, or business interruption, |
| however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of |
| this software, even if advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------- */ |
| |
| /*********************** MPEG surround decoder library ************************* |
| |
| Author(s): |
| |
| Description: SAC Dec subband processing |
| |
| *******************************************************************************/ |
| |
| #include "sac_stp.h" |
| #include "sac_calcM1andM2.h" |
| #include "sac_bitdec.h" |
| #include "FDK_matrixCalloc.h" |
| #include "sac_rom.h" |
| |
| #define BP_GF_START 6 |
| #define BP_GF_SIZE 25 |
| #define HP_SIZE 9 |
| #define STP_UPDATE_ENERGY_RATE 32 |
| |
| #define SF_WET 5 |
| #define SF_DRY \ |
| 3 /* SF_DRY == 2 would produce good conformance test results as well */ |
| #define SF_PRODUCT_BP_GF 13 |
| #define SF_PRODUCT_BP_GF_GF 26 |
| #define SF_SCALE 2 |
| |
| #define SF_SCALE_LD64 FL2FXCONST_DBL(0.03125) /* LD64((1<<SF_SCALE))*/ |
| #define STP_LPF_COEFF1__FDK FL2FXCONST_DBL(0.950f) /* 0.95 */ |
| #define ONE_MINUS_STP_LPF_COEFF1__FDK FL2FXCONST_DBL(0.05f) /* 1.0 - 0.95 */ |
| #define STP_LPF_COEFF2__FDK FL2FXCONST_DBL(0.450f) /* 0.45 */ |
| #define ONE_MINUS_STP_LPF_COEFF2__FDK \ |
| FL2FXCONST_DBL(1.0f - 0.450f) /* 1.0 - 0.45 */ |
| #define STP_SCALE_LIMIT__FDK \ |
| FL2FXCONST_DBL(2.82f / (float)(1 << SF_SCALE)) /* scaled by SF_SCALE */ |
| #define ONE_DIV_STP_SCALE_LIMIT__FDK \ |
| FL2FXCONST_DBL(1.0f / 2.82f / (float)(1 << SF_SCALE)) /* scaled by SF_SCALE \ |
| */ |
| #define ABS_THR__FDK \ |
| FL2FXCONST_DBL(ABS_THR / \ |
| ((float)(1 << (22 + 22 - 26)))) /* scaled by 18 bits */ |
| #define ABS_THR2__FDK \ |
| FL2FXCONST_DBL(ABS_THR * 32.0f * 32.0f / \ |
| ((float)(1 << (22 + 22 - 26)))) /* scaled by 10 bits */ |
| #define STP_SCALE_LIMIT_HI \ |
| FL2FXCONST_DBL(3.02222222222 / (1 << SF_SCALE)) /* see 4. below */ |
| #define STP_SCALE_LIMIT_LO \ |
| FL2FXCONST_DBL(0.28289992119 / (1 << SF_SCALE)) /* see 4. below */ |
| #define STP_SCALE_LIMIT_HI_LD64 \ |
| FL2FXCONST_DBL(0.04986280452) /* see 4. below \ |
| */ |
| #define STP_SCALE_LIMIT_LO_LD64 \ |
| FL2FXCONST_DBL(0.05692613500) /* see 4. below \ |
| */ |
| |
| /* Scale factor calculation for the diffuse signal needs adapted thresholds |
| for STP_SCALE_LIMIT and 1/STP_SCALE_LIMIT: |
| |
| 1. scale = sqrt(DryNrg/WetNrg) |
| |
| 2. Damping of scale factor |
| scale2 = 0.1 + 0.9 * scale |
| |
| 3. Limiting of scale factor |
| STP_SCALE_LIMIT >= scale2 >= 1/STP_SCALE_LIMIT |
| => STP_SCALE_LIMIT >= (0.1 + 0.9 * scale) >= 1/STP_SCALE_LIMIT |
| => (STP_SCALE_LIMIT-0.1)/0.9 >= scale >= |
| (1/STP_SCALE_LIMIT-0.1)/0.9 |
| |
| 3. Limiting of scale factor before sqrt calculation |
| ((STP_SCALE_LIMIT-0.1)/0.9)^2 >= (scale^2) >= |
| ((1/STP_SCALE_LIMIT-0.1)/0.9)^2 (STP_SCALE_LIMIT_HI)^2 >= (scale^2) >= |
| (STP_SCALE_LIMIT_LO)^2 |
| |
| 4. Thresholds for limiting of scale factor |
| STP_SCALE_LIMIT_HI = ((2.82-0.1)/0.9) |
| STP_SCALE_LIMIT_LO = (((1.0/2.82)-0.1)/0.9) |
| STP_SCALE_LIMIT_HI_LD64 = LD64(STP_SCALE_LIMIT_HI*STP_SCALE_LIMIT_HI) |
| STP_SCALE_LIMIT_LO_LD64 = LD64(STP_SCALE_LIMIT_LO*STP_SCALE_LIMIT_LO) |
| */ |
| |
| #define DRY_ENER_WEIGHT(DryEner) DryEner = DryEner >> dry_scale_dmx |
| |
| #define WET_ENER_WEIGHT(WetEner) WetEner = WetEner << wet_scale_dmx |
| |
| #define DRY_ENER_SUM_REAL(DryEner, dmxReal, n) \ |
| DryEner += \ |
| fMultDiv2(fPow2Div2(dmxReal << SF_DRY), pBP[n]) >> ((2 * SF_DRY) - 2) |
| |
| #define DRY_ENER_SUM_CPLX(DryEner, dmxReal, dmxImag, n) \ |
| DryEner += fMultDiv2( \ |
| fPow2Div2(dmxReal << SF_DRY) + fPow2Div2(dmxImag << SF_DRY), pBP[n]) |
| |
| #define CALC_WET_SCALE(dryIdx, wetIdx) \ |
| if ((DryEnerLD64[dryIdx] - STP_SCALE_LIMIT_HI_LD64) > WetEnerLD64[wetIdx]) { \ |
| scale[wetIdx] = STP_SCALE_LIMIT_HI; \ |
| } else if (DryEnerLD64[dryIdx] < \ |
| (WetEnerLD64[wetIdx] - STP_SCALE_LIMIT_LO_LD64)) { \ |
| scale[wetIdx] = STP_SCALE_LIMIT_LO; \ |
| } else { \ |
| tmp = ((DryEnerLD64[dryIdx] - WetEnerLD64[wetIdx]) >> 1) - SF_SCALE_LD64; \ |
| scale[wetIdx] = CalcInvLdData(tmp); \ |
| } |
| |
| struct STP_DEC { |
| FIXP_DBL runDryEner[MAX_INPUT_CHANNELS]; |
| FIXP_DBL runWetEner[MAX_OUTPUT_CHANNELS]; |
| FIXP_DBL oldDryEnerLD64[MAX_INPUT_CHANNELS]; |
| FIXP_DBL oldWetEnerLD64[MAX_OUTPUT_CHANNELS]; |
| FIXP_DBL prev_tp_scale[MAX_OUTPUT_CHANNELS]; |
| const FIXP_CFG *BP; |
| const FIXP_CFG *BP_GF; |
| int update_old_ener; |
| }; |
| |
| inline void combineSignalReal(FIXP_DBL *hybOutputRealDry, |
| FIXP_DBL *hybOutputRealWet, int bands) { |
| int n; |
| |
| for (n = bands - 1; n >= 0; n--) { |
| *hybOutputRealDry = *hybOutputRealDry + *hybOutputRealWet; |
| hybOutputRealDry++, hybOutputRealWet++; |
| } |
| } |
| |
| inline void combineSignalRealScale1(FIXP_DBL *hybOutputRealDry, |
| FIXP_DBL *hybOutputRealWet, FIXP_DBL scaleX, |
| int bands) { |
| int n; |
| |
| for (n = bands - 1; n >= 0; n--) { |
| *hybOutputRealDry = |
| *hybOutputRealDry + |
| (fMultDiv2(*hybOutputRealWet, scaleX) << (SF_SCALE + 1)); |
| hybOutputRealDry++, hybOutputRealWet++; |
| } |
| } |
| |
| inline void combineSignalCplx(FIXP_DBL *hybOutputRealDry, |
| FIXP_DBL *hybOutputImagDry, |
| FIXP_DBL *hybOutputRealWet, |
| FIXP_DBL *hybOutputImagWet, int bands) { |
| int n; |
| |
| for (n = bands - 1; n >= 0; n--) { |
| *hybOutputRealDry = *hybOutputRealDry + *hybOutputRealWet; |
| *hybOutputImagDry = *hybOutputImagDry + *hybOutputImagWet; |
| hybOutputRealDry++, hybOutputRealWet++; |
| hybOutputImagDry++, hybOutputImagWet++; |
| } |
| } |
| |
| inline void combineSignalCplxScale1(FIXP_DBL *hybOutputRealDry, |
| FIXP_DBL *hybOutputImagDry, |
| FIXP_DBL *hybOutputRealWet, |
| FIXP_DBL *hybOutputImagWet, |
| const FIXP_CFG *pBP, FIXP_DBL scaleX, |
| int bands) { |
| int n; |
| FIXP_DBL scaleY; |
| for (n = bands - 1; n >= 0; n--) { |
| scaleY = fMultDiv2(scaleX, *pBP); |
| *hybOutputRealDry = |
| *hybOutputRealDry + |
| (fMultDiv2(*hybOutputRealWet, scaleY) << (SF_SCALE + 2)); |
| *hybOutputImagDry = |
| *hybOutputImagDry + |
| (fMultDiv2(*hybOutputImagWet, scaleY) << (SF_SCALE + 2)); |
| hybOutputRealDry++, hybOutputRealWet++; |
| hybOutputImagDry++, hybOutputImagWet++; |
| pBP++; |
| } |
| } |
| |
| inline void combineSignalCplxScale2(FIXP_DBL *hybOutputRealDry, |
| FIXP_DBL *hybOutputImagDry, |
| FIXP_DBL *hybOutputRealWet, |
| FIXP_DBL *hybOutputImagWet, FIXP_DBL scaleX, |
| int bands) { |
| int n; |
| |
| for (n = bands - 1; n >= 0; n--) { |
| *hybOutputRealDry = |
| *hybOutputRealDry + |
| (fMultDiv2(*hybOutputRealWet, scaleX) << (SF_SCALE + 1)); |
| *hybOutputImagDry = |
| *hybOutputImagDry + |
| (fMultDiv2(*hybOutputImagWet, scaleX) << (SF_SCALE + 1)); |
| hybOutputRealDry++, hybOutputRealWet++; |
| hybOutputImagDry++, hybOutputImagWet++; |
| } |
| } |
| |
| /******************************************************************************* |
| Functionname: subbandTPCreate |
| ******************************************************************************/ |
| SACDEC_ERROR subbandTPCreate(HANDLE_STP_DEC *hStpDec) { |
| HANDLE_STP_DEC self = NULL; |
| FDK_ALLOCATE_MEMORY_1D(self, 1, struct STP_DEC) |
| if (hStpDec != NULL) { |
| *hStpDec = self; |
| } |
| |
| return MPS_OK; |
| bail: |
| return MPS_OUTOFMEMORY; |
| } |
| |
| SACDEC_ERROR subbandTPInit(HANDLE_STP_DEC self) { |
| SACDEC_ERROR err = MPS_OK; |
| int ch; |
| |
| for (ch = 0; ch < MAX_OUTPUT_CHANNELS; ch++) { |
| self->prev_tp_scale[ch] = FL2FXCONST_DBL(1.0f / (1 << SF_SCALE)); |
| self->oldWetEnerLD64[ch] = |
| FL2FXCONST_DBL(0.34375f); /* 32768.0*32768.0/2^(44-26-10) */ |
| } |
| for (ch = 0; ch < MAX_INPUT_CHANNELS; ch++) { |
| self->oldDryEnerLD64[ch] = |
| FL2FXCONST_DBL(0.1875f); /* 32768.0*32768.0/2^(44-26) */ |
| } |
| |
| self->BP = BP__FDK; |
| self->BP_GF = BP_GF__FDK; |
| |
| self->update_old_ener = 0; |
| |
| return err; |
| } |
| |
| /******************************************************************************* |
| Functionname: subbandTPDestroy |
| ******************************************************************************/ |
| void subbandTPDestroy(HANDLE_STP_DEC *hStpDec) { |
| if (hStpDec != NULL) { |
| FDK_FREE_MEMORY_1D(*hStpDec); |
| } |
| } |
| |
| /******************************************************************************* |
| Functionname: subbandTPApply |
| ******************************************************************************/ |
| SACDEC_ERROR subbandTPApply(spatialDec *self, const SPATIAL_BS_FRAME *frame) { |
| FIXP_DBL *qmfOutputRealDry[MAX_OUTPUT_CHANNELS]; |
| FIXP_DBL *qmfOutputImagDry[MAX_OUTPUT_CHANNELS]; |
| FIXP_DBL *qmfOutputRealWet[MAX_OUTPUT_CHANNELS]; |
| FIXP_DBL *qmfOutputImagWet[MAX_OUTPUT_CHANNELS]; |
| |
| FIXP_DBL DryEner[MAX_INPUT_CHANNELS]; |
| FIXP_DBL scale[MAX_OUTPUT_CHANNELS]; |
| |
| FIXP_DBL DryEnerLD64[MAX_INPUT_CHANNELS]; |
| FIXP_DBL WetEnerLD64[MAX_OUTPUT_CHANNELS]; |
| |
| FIXP_DBL DryEner0 = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL WetEnerX, damp, tmp; |
| FIXP_DBL dmxReal0, dmxImag0; |
| int skipChannels[MAX_OUTPUT_CHANNELS]; |
| int n, ch, cplxBands, cplxHybBands; |
| int dry_scale_dmx, wet_scale_dmx; |
| int i_LF, i_RF; |
| HANDLE_STP_DEC hStpDec; |
| const FIXP_CFG *pBP; |
| |
| int nrgScale = (2 * self->clipProtectGainSF__FDK); |
| |
| hStpDec = self->hStpDec; |
| |
| /* set scalefactor and loop counter */ |
| FDK_ASSERT(SF_DRY >= 1); |
| { |
| cplxBands = BP_GF_SIZE; |
| cplxHybBands = self->hybridBands; |
| dry_scale_dmx = (2 * SF_DRY) - 2; |
| wet_scale_dmx = 2; |
| } |
| |
| /* setup pointer for forming the direct downmix signal */ |
| for (ch = 0; ch < self->numOutputChannels; ch++) { |
| qmfOutputRealDry[ch] = &self->hybOutputRealDry__FDK[ch][7]; |
| qmfOutputRealWet[ch] = &self->hybOutputRealWet__FDK[ch][7]; |
| qmfOutputImagDry[ch] = &self->hybOutputImagDry__FDK[ch][7]; |
| qmfOutputImagWet[ch] = &self->hybOutputImagWet__FDK[ch][7]; |
| } |
| |
| /* clear skipping flag for all output channels */ |
| FDKmemset(skipChannels, 0, self->numOutputChannels * sizeof(int)); |
| |
| /* set scale values to zero */ |
| FDKmemset(scale, 0, self->numOutputChannels * sizeof(FIXP_DBL)); |
| |
| /* update normalisation energy with latest smoothed energy */ |
| if (hStpDec->update_old_ener == STP_UPDATE_ENERGY_RATE) { |
| hStpDec->update_old_ener = 1; |
| for (ch = 0; ch < self->numInputChannels; ch++) { |
| hStpDec->oldDryEnerLD64[ch] = |
| CalcLdData(hStpDec->runDryEner[ch] + ABS_THR__FDK); |
| } |
| for (ch = 0; ch < self->numOutputChannels; ch++) { |
| hStpDec->oldWetEnerLD64[ch] = |
| CalcLdData(hStpDec->runWetEner[ch] + ABS_THR2__FDK); |
| } |
| } else { |
| hStpDec->update_old_ener++; |
| } |
| |
| /* get channel configuration */ |
| switch (self->treeConfig) { |
| case TREE_212: |
| i_LF = 0; |
| i_RF = 1; |
| break; |
| default: |
| return MPS_WRONG_TREECONFIG; |
| } |
| |
| /* form the 'direct' downmix signal */ |
| pBP = hStpDec->BP_GF - BP_GF_START; |
| switch (self->treeConfig) { |
| case TREE_212: |
| for (n = BP_GF_START; n < cplxBands; n++) { |
| dmxReal0 = qmfOutputRealDry[i_LF][n] + qmfOutputRealDry[i_RF][n]; |
| dmxImag0 = qmfOutputImagDry[i_LF][n] + qmfOutputImagDry[i_RF][n]; |
| DRY_ENER_SUM_CPLX(DryEner0, dmxReal0, dmxImag0, n); |
| } |
| DRY_ENER_WEIGHT(DryEner0); |
| break; |
| default:; |
| } |
| DryEner[0] = DryEner0; |
| |
| /* normalise the 'direct' signals */ |
| for (ch = 0; ch < self->numInputChannels; ch++) { |
| DryEner[ch] = DryEner[ch] << (nrgScale); |
| hStpDec->runDryEner[ch] = |
| fMult(STP_LPF_COEFF1__FDK, hStpDec->runDryEner[ch]) + |
| fMult(ONE_MINUS_STP_LPF_COEFF1__FDK, DryEner[ch]); |
| if (DryEner[ch] != FL2FXCONST_DBL(0.0f)) { |
| DryEnerLD64[ch] = |
| fixMax((CalcLdData(DryEner[ch]) - hStpDec->oldDryEnerLD64[ch]), |
| FL2FXCONST_DBL(-0.484375f)); |
| } else { |
| DryEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f); |
| } |
| } |
| if (self->treeConfig == TREE_212) { |
| for (; ch < MAX_INPUT_CHANNELS; ch++) { |
| DryEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f); |
| } |
| } |
| |
| /* normalise the 'diffuse' signals */ |
| pBP = hStpDec->BP_GF - BP_GF_START; |
| for (ch = 0; ch < self->numOutputChannels; ch++) { |
| if (skipChannels[ch]) { |
| continue; |
| } |
| |
| WetEnerX = FL2FXCONST_DBL(0.0f); |
| for (n = BP_GF_START; n < cplxBands; n++) { |
| tmp = fPow2Div2(qmfOutputRealWet[ch][n] << SF_WET); |
| tmp += fPow2Div2(qmfOutputImagWet[ch][n] << SF_WET); |
| WetEnerX += fMultDiv2(tmp, pBP[n]); |
| } |
| WET_ENER_WEIGHT(WetEnerX); |
| |
| WetEnerX = WetEnerX << (nrgScale); |
| hStpDec->runWetEner[ch] = |
| fMult(STP_LPF_COEFF1__FDK, hStpDec->runWetEner[ch]) + |
| fMult(ONE_MINUS_STP_LPF_COEFF1__FDK, WetEnerX); |
| |
| if (WetEnerX == FL2FXCONST_DBL(0.0f)) { |
| WetEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f); |
| } else { |
| WetEnerLD64[ch] = |
| fixMax((CalcLdData(WetEnerX) - hStpDec->oldWetEnerLD64[ch]), |
| FL2FXCONST_DBL(-0.484375f)); |
| } |
| } |
| |
| /* compute scale factor for the 'diffuse' signals */ |
| switch (self->treeConfig) { |
| case TREE_212: |
| if (DryEner[0] != FL2FXCONST_DBL(0.0f)) { |
| CALC_WET_SCALE(0, i_LF); |
| CALC_WET_SCALE(0, i_RF); |
| } |
| break; |
| default:; |
| } |
| |
| damp = FL2FXCONST_DBL(0.1f / (1 << SF_SCALE)); |
| for (ch = 0; ch < self->numOutputChannels; ch++) { |
| /* damp the scaling factor */ |
| scale[ch] = damp + fMult(FL2FXCONST_DBL(0.9f), scale[ch]); |
| |
| /* limiting the scale factor */ |
| if (scale[ch] > STP_SCALE_LIMIT__FDK) { |
| scale[ch] = STP_SCALE_LIMIT__FDK; |
| } |
| if (scale[ch] < ONE_DIV_STP_SCALE_LIMIT__FDK) { |
| scale[ch] = ONE_DIV_STP_SCALE_LIMIT__FDK; |
| } |
| |
| /* low pass filter the scaling factor */ |
| scale[ch] = |
| fMult(STP_LPF_COEFF2__FDK, scale[ch]) + |
| fMult(ONE_MINUS_STP_LPF_COEFF2__FDK, hStpDec->prev_tp_scale[ch]); |
| hStpDec->prev_tp_scale[ch] = scale[ch]; |
| } |
| |
| /* combine 'direct' and scaled 'diffuse' signal */ |
| FDK_ASSERT((HP_SIZE - 3 + 10 - 1) == PC_NUM_HYB_BANDS); |
| const SCHAR *channlIndex = row2channelSTP[self->treeConfig]; |
| |
| for (ch = 0; ch < self->numOutputChannels; ch++) { |
| int no_scaling; |
| |
| no_scaling = !frame->tempShapeEnableChannelSTP[channlIndex[ch]]; |
| if (no_scaling) { |
| combineSignalCplx( |
| &self->hybOutputRealDry__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputImagDry__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputRealWet__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputImagWet__FDK[ch][self->tp_hybBandBorder], |
| cplxHybBands - self->tp_hybBandBorder); |
| |
| } else { |
| FIXP_DBL scaleX; |
| scaleX = scale[ch]; |
| pBP = hStpDec->BP - self->tp_hybBandBorder; |
| /* Band[HP_SIZE-3+10-1] needs not to be processed in |
| combineSignalCplxScale1(), because pB[HP_SIZE-3+10-1] would be 1.0 */ |
| combineSignalCplxScale1( |
| &self->hybOutputRealDry__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputImagDry__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputRealWet__FDK[ch][self->tp_hybBandBorder], |
| &self->hybOutputImagWet__FDK[ch][self->tp_hybBandBorder], |
| &pBP[self->tp_hybBandBorder], scaleX, |
| (HP_SIZE - 3 + 10 - 1) - self->tp_hybBandBorder); |
| |
| { |
| combineSignalCplxScale2( |
| &self->hybOutputRealDry__FDK[ch][HP_SIZE - 3 + 10 - 1], |
| &self->hybOutputImagDry__FDK[ch][HP_SIZE - 3 + 10 - 1], |
| &self->hybOutputRealWet__FDK[ch][HP_SIZE - 3 + 10 - 1], |
| &self->hybOutputImagWet__FDK[ch][HP_SIZE - 3 + 10 - 1], scaleX, |
| cplxHybBands - (HP_SIZE - 3 + 10 - 1)); |
| } |
| } |
| } |
| |
| return (SACDEC_ERROR)MPS_OK; |
| ; |
| } |
