diff options
Diffstat (limited to 'libSACdec/src/sac_reshapeBBEnv.cpp')
| -rw-r--r-- | libSACdec/src/sac_reshapeBBEnv.cpp | 680 |
1 files changed, 680 insertions, 0 deletions
diff --git a/libSACdec/src/sac_reshapeBBEnv.cpp b/libSACdec/src/sac_reshapeBBEnv.cpp new file mode 100644 index 0000000..87c0ac6 --- /dev/null +++ b/libSACdec/src/sac_reshapeBBEnv.cpp @@ -0,0 +1,680 @@ +/* ----------------------------------------------------------------------------- +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 guided envelope shaping + +*******************************************************************************/ + +#include "sac_reshapeBBEnv.h" + +#include "sac_dec.h" +#include "sac_bitdec.h" +#include "sac_calcM1andM2.h" +#include "sac_reshapeBBEnv.h" +#include "sac_rom.h" + +#define INP_DRY_WET 0 +#define INP_DMX 1 + +#define SF_SHAPE 1 +#define SF_DIV32 6 +#define SF_FACTOR_SLOT 5 + +#define START_BB_ENV 0 /* 10 */ +#define END_BB_ENV 9 /* 18 */ + +#define SF_ALPHA1 8 +#define SF_BETA1 4 + +void initBBEnv(spatialDec *self, int initStatesFlag) { + INT ch, k; + + for (ch = 0; ch < self->numOutputChannels; ch++) { + k = row2channelGES[self->treeConfig][ch]; + self->row2channelDmxGES[ch] = k; + if (k == -1) continue; + + switch (self->treeConfig) { + case TREE_212: + self->row2channelDmxGES[ch] = 0; + break; + default:; + } + } + + if (initStatesFlag) { + for (k = 0; k < 2 * MAX_OUTPUT_CHANNELS + MAX_INPUT_CHANNELS; k++) { + self->reshapeBBEnvState->normNrgPrev__FDK[k] = + FL2FXCONST_DBL(0.5f); /* 32768.f*32768.f */ + self->reshapeBBEnvState->normNrgPrevSF[k] = DFRACT_BITS - 1; + self->reshapeBBEnvState->partNrgPrevSF[k] = 0; + self->reshapeBBEnvState->partNrgPrev2SF[k] = 0; + self->reshapeBBEnvState->frameNrgPrevSF[k] = 0; + } + } + + self->reshapeBBEnvState->alpha__FDK = + FL2FXCONST_DBL(0.99637845575f); /* FDKexp(-64 / (0.4f * 44100)) */ + self->reshapeBBEnvState->beta__FDK = + FL2FXCONST_DBL(0.96436909488f); /* FDKexp(-64 / (0.04f * 44100)) */ +} + +static inline void getSlotNrgHQ(FIXP_DBL *RESTRICT pReal, + FIXP_DBL *RESTRICT pImag, + FIXP_DBL *RESTRICT slotNrg, INT maxValSF, + INT hybBands) { + INT qs; + FIXP_DBL nrg; + + /* qs = 12, 13, 14 */ + slotNrg[0] = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[1] = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[2] = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 15 */ + slotNrg[3] = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 16, 17 */ + nrg = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[4] = nrg + ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 18, 19, 20 */ + nrg = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + nrg += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[5] = nrg + ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 21, 22 */ + nrg = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[6] = nrg + ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 23, 24 */ + if (hybBands > 23) { + slotNrg[6] += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[6] += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 25, 26, 29, 28, 29 */ + nrg = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + nrg += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + nrg += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + nrg += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + slotNrg[7] = nrg + ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + /* qs = 30 ... min(41,hybBands-1) */ + nrg = ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + for (qs = 31; qs < hybBands; qs++) { + nrg += ((fPow2Div2((*pReal++) << maxValSF) + + fPow2Div2((*pImag++) << maxValSF)) >> + (SF_FACTOR_SLOT - 1)); + } + slotNrg[8] = nrg; + } else { + slotNrg[7] = (FIXP_DBL)0; + slotNrg[8] = (FIXP_DBL)0; + } +} + +static inline INT getMaxValDmx(FIXP_DBL *RESTRICT pReal, + FIXP_DBL *RESTRICT pImag, INT cplxBands, + INT hybBands) { + INT qs, clz; + FIXP_DBL maxVal = FL2FXCONST_DBL(0.0f); + + for (qs = 12; qs < cplxBands; qs++) { + maxVal |= fAbs(pReal[qs]); + maxVal |= fAbs(pImag[qs]); + } + for (; qs < hybBands; qs++) { + maxVal |= fAbs(pReal[qs]); + } + + clz = fixMax(0, CntLeadingZeros(maxVal) - 1); + + return (clz); +} + +static inline INT getMaxValDryWet(FIXP_DBL *RESTRICT pReal, + FIXP_DBL *RESTRICT pImag, + FIXP_DBL *RESTRICT pHybOutputRealDry, + FIXP_DBL *RESTRICT pHybOutputImagDry, + FIXP_DBL *RESTRICT pHybOutputRealWet, + FIXP_DBL *RESTRICT pHybOutputImagWet, + INT cplxBands, INT hybBands) { + INT qs, clz; + FIXP_DBL maxVal = FL2FXCONST_DBL(0.0f); + + for (qs = 12; qs < cplxBands; qs++) { + pReal[qs] = pHybOutputRealDry[qs] + pHybOutputRealWet[qs]; + maxVal |= fAbs(pReal[qs]); + pImag[qs] = pHybOutputImagDry[qs] + pHybOutputImagWet[qs]; + maxVal |= fAbs(pImag[qs]); + } + for (; qs < hybBands; qs++) { + pReal[qs] = pHybOutputRealDry[qs] + pHybOutputRealWet[qs]; + maxVal |= fAbs(pReal[qs]); + } + + clz = fixMax(0, CntLeadingZeros(maxVal) - 1); + + return (clz); +} + +static inline void slotAmp(FIXP_DBL *RESTRICT slotAmp_dry, + FIXP_DBL *RESTRICT slotAmp_wet, + FIXP_DBL *RESTRICT pHybOutputRealDry, + FIXP_DBL *RESTRICT pHybOutputImagDry, + FIXP_DBL *RESTRICT pHybOutputRealWet, + FIXP_DBL *RESTRICT pHybOutputImagWet, INT cplxBands, + INT hybBands) { + INT qs; + FIXP_DBL dry, wet; + + dry = wet = FL2FXCONST_DBL(0.0f); + for (qs = 0; qs < cplxBands; qs++) { + dry = fAddSaturate(dry, fPow2Div2(pHybOutputRealDry[qs]) + + fPow2Div2(pHybOutputImagDry[qs])); + wet = fAddSaturate(wet, fPow2Div2(pHybOutputRealWet[qs]) + + fPow2Div2(pHybOutputImagWet[qs])); + } + for (; qs < hybBands; qs++) { + dry = fAddSaturate(dry, fPow2Div2(pHybOutputRealDry[qs])); + wet = fAddSaturate(wet, fPow2Div2(pHybOutputRealWet[qs])); + } + *slotAmp_dry = dry; + *slotAmp_wet = wet; +} + +#if defined(__aarch64__) +__attribute__((noinline)) +#endif +static void +shapeBBEnv(FIXP_DBL *pHybOutputRealDry, FIXP_DBL *pHybOutputImagDry, + FIXP_DBL dryFac, INT scale, INT cplxBands, INT hybBands) { + INT qs; + + if (scale == 0) { + for (qs = 0; qs < cplxBands; qs++) { + pHybOutputRealDry[qs] = fMultDiv2(pHybOutputRealDry[qs], dryFac); + pHybOutputImagDry[qs] = fMultDiv2(pHybOutputImagDry[qs], dryFac); + } + for (; qs < hybBands; qs++) { + pHybOutputRealDry[qs] = fMultDiv2(pHybOutputRealDry[qs], dryFac); + } + } else { + for (qs = 0; qs < cplxBands; qs++) { + pHybOutputRealDry[qs] = fMultDiv2(pHybOutputRealDry[qs], dryFac) << scale; + pHybOutputImagDry[qs] = fMultDiv2(pHybOutputImagDry[qs], dryFac) << scale; + } + for (; qs < hybBands; qs++) { + pHybOutputRealDry[qs] = fMultDiv2(pHybOutputRealDry[qs], dryFac) << scale; + } + } +} + +static void extractBBEnv(spatialDec *self, INT inp, INT start, INT channels, + FIXP_DBL *pEnv, const SPATIAL_BS_FRAME *frame) { + INT ch, pb, prevChOffs; + INT clz, scale, scale_min, envSF; + INT scaleCur, scalePrev, commonScale; + INT slotNrgSF, partNrgSF, frameNrgSF; + INT *pPartNrgPrevSF, *pFrameNrgPrevSF; + INT *pNormNrgPrevSF, *pPartNrgPrev2SF; + + FIXP_DBL maxVal, env, frameNrg, normNrg; + FIXP_DBL *pReal, *pImag; + FIXP_DBL *partNrg, *partNrgPrev; + + C_ALLOC_SCRATCH_START(pScratchBuffer, FIXP_DBL, + (2 * 42 + MAX_PARAMETER_BANDS)); + C_ALLOC_SCRATCH_START(resPb, FIXP_DBL, (END_BB_ENV - START_BB_ENV)); + C_ALLOC_SCRATCH_START(resPbSF, INT, (END_BB_ENV - START_BB_ENV)); + + FIXP_DBL *slotNrg = pScratchBuffer + (2 * 42); + + RESHAPE_BBENV_STATE *pBBEnvState = self->reshapeBBEnvState; + + FIXP_DBL alpha = pBBEnvState->alpha__FDK; + /*FIXP_DBL alpha1 = (FL2FXCONST_DBL(1.0f) - alpha) << SF_ALPHA1;*/ + FIXP_DBL alpha1 = ((FIXP_DBL)MAXVAL_DBL - alpha) << SF_ALPHA1; + FIXP_DBL beta = pBBEnvState->beta__FDK; + /*FIXP_DBL beta1 = (FL2FXCONST_DBL(1.0f) - beta) << SF_BETA1;*/ + FIXP_DBL beta1 = ((FIXP_DBL)MAXVAL_DBL - beta) << SF_BETA1; + + INT shapeActiv = 1; + INT hybBands = fixMin(42, self->hybridBands); + INT staticScale = self->staticDecScale; + INT cplxBands; + cplxBands = fixMin(42, self->hybridBands); + + for (ch = start; ch < channels; ch++) { + if (inp == INP_DRY_WET) { + INT ch2 = row2channelGES[self->treeConfig][ch]; + if (ch2 == -1) { + continue; + } else { + if (frame->tempShapeEnableChannelGES[ch2]) { + shapeActiv = 1; + } else { + shapeActiv = 0; + } + } + prevChOffs = ch; + pReal = pScratchBuffer; + pImag = pScratchBuffer + 42; + clz = getMaxValDryWet( + pReal, pImag, self->hybOutputRealDry__FDK[ch], + self->hybOutputImagDry__FDK[ch], self->hybOutputRealWet__FDK[ch], + self->hybOutputImagWet__FDK[ch], cplxBands, hybBands); + } else { + prevChOffs = ch + self->numOutputChannels; + pReal = self->hybInputReal__FDK[ch]; + pImag = self->hybInputImag__FDK[ch]; + clz = getMaxValDmx(pReal, pImag, cplxBands, hybBands); + } + + partNrg = partNrgPrev = pBBEnvState->partNrgPrev__FDK[prevChOffs]; + pPartNrgPrevSF = &pBBEnvState->partNrgPrevSF[prevChOffs]; + pFrameNrgPrevSF = &pBBEnvState->frameNrgPrevSF[prevChOffs]; + pNormNrgPrevSF = &pBBEnvState->normNrgPrevSF[prevChOffs]; + pPartNrgPrev2SF = &pBBEnvState->partNrgPrev2SF[prevChOffs]; + + /* calculate slot energy */ + { + getSlotNrgHQ(&pReal[12], &pImag[12], slotNrg, clz, + fixMin(42, self->hybridBands)); /* scale slotNrg: + 2*(staticScale-clz) + + SF_FACTOR_SLOT */ + } + + slotNrgSF = 2 * (staticScale - clz) + SF_FACTOR_SLOT; + frameNrgSF = 2 * (staticScale - clz) + SF_FACTOR_SLOT; + + partNrgSF = fixMax(slotNrgSF - SF_ALPHA1 + 1, + pPartNrgPrevSF[0] - pPartNrgPrev2SF[0] + 1); + scalePrev = fixMax(fixMin(partNrgSF - pPartNrgPrevSF[0], DFRACT_BITS - 1), + -(DFRACT_BITS - 1)); + scaleCur = + fixMax(fixMin(partNrgSF - slotNrgSF + SF_ALPHA1, DFRACT_BITS - 1), + -(DFRACT_BITS - 1)); + + maxVal = FL2FXCONST_DBL(0.0f); + frameNrg = FL2FXCONST_DBL(0.0f); + if ((scaleCur < 0) && (scalePrev < 0)) { + scaleCur = -scaleCur; + scalePrev = -scalePrev; + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + partNrg[pb] = ((fMultDiv2(alpha1, slotNrg[pb]) << scaleCur) + + (fMultDiv2(alpha, partNrgPrev[pb]) << scalePrev)) + << 1; + maxVal |= partNrg[pb]; + frameNrg += slotNrg[pb] >> 3; + } + } else if ((scaleCur >= 0) && (scalePrev >= 0)) { + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + partNrg[pb] = ((fMultDiv2(alpha1, slotNrg[pb]) >> scaleCur) + + (fMultDiv2(alpha, partNrgPrev[pb]) >> scalePrev)) + << 1; + maxVal |= partNrg[pb]; + frameNrg += slotNrg[pb] >> 3; + } + } else if ((scaleCur < 0) && (scalePrev >= 0)) { + scaleCur = -scaleCur; + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + partNrg[pb] = ((fMultDiv2(alpha1, slotNrg[pb]) << scaleCur) + + (fMultDiv2(alpha, partNrgPrev[pb]) >> scalePrev)) + << 1; + maxVal |= partNrg[pb]; + frameNrg += slotNrg[pb] >> 3; + } + } else { /* if ( (scaleCur >= 0) && (scalePrev < 0) ) */ + scalePrev = -scalePrev; + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + partNrg[pb] = ((fMultDiv2(alpha1, slotNrg[pb]) >> scaleCur) + + (fMultDiv2(alpha, partNrgPrev[pb]) << scalePrev)) + << 1; + maxVal |= partNrg[pb]; + frameNrg += slotNrg[pb] >> 3; + } + } + + /* frameNrg /= (END_BB_ENV - START_BB_ENV); 0.88888888888f = + * (1/(END_BB_ENV-START_BB_ENV)<<3; shift with 3 is compensated in loop + * above */ + frameNrg = fMult(frameNrg, FL2FXCONST_DBL(0.88888888888f)); + + /* store scalefactor and headroom for part nrg prev */ + pPartNrgPrevSF[0] = partNrgSF; + pPartNrgPrev2SF[0] = fixMax(0, CntLeadingZeros(maxVal) - 1); + + commonScale = fixMax(frameNrgSF - SF_ALPHA1 + 1, pFrameNrgPrevSF[0] + 1); + scalePrev = fixMin(commonScale - pFrameNrgPrevSF[0], DFRACT_BITS - 1); + scaleCur = fixMin(commonScale - frameNrgSF + SF_ALPHA1, DFRACT_BITS - 1); + frameNrgSF = commonScale; + + frameNrg = ((fMultDiv2(alpha1, frameNrg) >> scaleCur) + + (fMultDiv2(alpha, pBBEnvState->frameNrgPrev__FDK[prevChOffs]) >> + scalePrev)) + << 1; + + clz = fixMax(0, CntLeadingZeros(frameNrg) - 1); + pBBEnvState->frameNrgPrev__FDK[prevChOffs] = frameNrg << clz; + pFrameNrgPrevSF[0] = frameNrgSF - clz; + + env = FL2FXCONST_DBL(0.0f); + scale = clz + partNrgSF - frameNrgSF; + scale_min = DFRACT_BITS - 1; + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + if ((partNrg[pb] | slotNrg[pb]) != FL2FXCONST_DBL(0.0f)) { + INT s; + INT sc = 0; + INT sn = fixMax(0, CntLeadingZeros(slotNrg[pb]) - 1); + FIXP_DBL inv_sqrt = invSqrtNorm2(partNrg[pb], &sc); + FIXP_DBL res = fMult(slotNrg[pb] << sn, fPow2(inv_sqrt)); + + s = fixMax(0, CntLeadingZeros(res) - 1); + res = res << s; + + sc = scale - (2 * sc - sn - s); + scale_min = fixMin(scale_min, sc); + + resPb[pb] = res; + resPbSF[pb] = sc; + } else { + resPb[pb] = (FIXP_DBL)0; + resPbSF[pb] = 0; + } + } + + scale_min = 4 - scale_min; + + for (pb = START_BB_ENV; pb < END_BB_ENV; pb++) { + INT sc = fixMax(fixMin(resPbSF[pb] + scale_min, DFRACT_BITS - 1), + -(DFRACT_BITS - 1)); + + if (sc < 0) { + env += resPb[pb] << (-sc); + } else { + env += resPb[pb] >> (sc); + } + } + + env = fMultDiv2(env, pBBEnvState->frameNrgPrev__FDK[prevChOffs]); + envSF = slotNrgSF + scale_min + 1; + + commonScale = fixMax(envSF - SF_BETA1 + 1, pNormNrgPrevSF[0] + 1); + scalePrev = fixMin(commonScale - pNormNrgPrevSF[0], DFRACT_BITS - 1); + scaleCur = fixMin(commonScale - envSF + SF_BETA1, DFRACT_BITS - 1); + + normNrg = ((fMultDiv2(beta1, env) >> scaleCur) + + (fMultDiv2(beta, pBBEnvState->normNrgPrev__FDK[prevChOffs]) >> + scalePrev)) + << 1; + + clz = fixMax(0, CntLeadingZeros(normNrg) - 1); + pBBEnvState->normNrgPrev__FDK[prevChOffs] = normNrg << clz; + pNormNrgPrevSF[0] = commonScale - clz; + + if (shapeActiv) { + if ((env | normNrg) != FL2FXCONST_DBL(0.0f)) { + INT sc, se, sn; + se = fixMax(0, CntLeadingZeros(env) - 1); + sc = commonScale + SF_DIV32 - envSF + se; + env = fMult(sqrtFixp((env << se) >> (sc & 0x1)), + invSqrtNorm2(normNrg, &sn)); + + sc = fixMin((sc >> 1) - sn, DFRACT_BITS - 1); + if (sc < 0) { + env <<= (-sc); + } else { + env >>= (sc); + } + } + /* env is scaled by SF_DIV32/2 bits */ + } + pEnv[ch] = env; + } + + C_ALLOC_SCRATCH_END(resPbSF, INT, (END_BB_ENV - START_BB_ENV)); + C_ALLOC_SCRATCH_END(resPb, FIXP_DBL, (END_BB_ENV - START_BB_ENV)); + C_ALLOC_SCRATCH_END(pScratchBuffer, FIXP_DBL, (2 * 42 + MAX_PARAMETER_BANDS)); +} + +void SpatialDecReshapeBBEnv(spatialDec *self, const SPATIAL_BS_FRAME *frame, + INT ts) { + INT ch, scale; + INT dryFacSF, slotAmpSF; + FIXP_DBL tmp, dryFac, envShape; + FIXP_DBL slotAmp_dry, slotAmp_wet, slotAmp_ratio; + FIXP_DBL envDry[MAX_OUTPUT_CHANNELS], envDmx[2]; + + INT cplxBands; + INT hybBands = self->hybridBands - 6; + + cplxBands = self->hybridBands - 6; + + /* extract downmix envelope(s) */ + switch (self->treeConfig) { + default: + extractBBEnv(self, INP_DMX, 0, fMin(self->numInputChannels, 2), envDmx, + frame); + } + + /* extract dry and wet envelopes */ + extractBBEnv(self, INP_DRY_WET, 0, self->numOutputChannels, envDry, frame); + + for (ch = 0; ch < self->numOutputChannels; ch++) { + INT ch2; + + ch2 = row2channelGES[self->treeConfig][ch]; + + if (ch2 == -1) continue; + + if (frame->tempShapeEnableChannelGES[ch2]) { + INT sc; + + /* reshape dry and wet signals according to transmitted envelope */ + + /* De-quantize GES data */ + FDK_ASSERT((frame->bsEnvShapeData[ch2][ts] >= 0) && + (frame->bsEnvShapeData[ch2][ts] <= 4)); + FDK_ASSERT((self->envQuantMode == 0) || (self->envQuantMode == 1)); + envShape = + FX_CFG2FX_DBL(envShapeDataTable__FDK[frame->bsEnvShapeData[ch2][ts]] + [self->envQuantMode]); + + /* get downmix channel */ + ch2 = self->row2channelDmxGES[ch]; + + /* multiply ratio with dmx envelope; tmp is scaled by SF_DIV32/2+SF_SHAPE + * bits */ + if (ch2 == 2) { + tmp = fMultDiv2(envShape, envDmx[0]) + fMultDiv2(envShape, envDmx[1]); + } else { + tmp = fMult(envShape, envDmx[ch2]); + } + + /* weighting factors */ + dryFacSF = slotAmpSF = 0; + dryFac = slotAmp_ratio = FL2FXCONST_DBL(0.0f); + + /* dryFac will be scaled by dryFacSF bits */ + if (envDry[ch] != FL2FXCONST_DBL(0.0f)) { + envDry[ch] = invSqrtNorm2(envDry[ch], &dryFacSF); + dryFac = fMultDiv2(tmp, fPow2Div2(envDry[ch])) << 2; + dryFacSF = SF_SHAPE + 2 * dryFacSF; + } + + /* calculate slotAmp_dry and slotAmp_wet */ + slotAmp(&slotAmp_dry, &slotAmp_wet, &self->hybOutputRealDry__FDK[ch][6], + &self->hybOutputImagDry__FDK[ch][6], + &self->hybOutputRealWet__FDK[ch][6], + &self->hybOutputImagWet__FDK[ch][6], cplxBands, hybBands); + + /* slotAmp_ratio will be scaled by slotAmpSF bits */ + if (slotAmp_dry != FL2FXCONST_DBL(0.0f)) { + sc = fixMax(0, CntLeadingZeros(slotAmp_wet) - 1); + sc = sc - (sc & 1); + + slotAmp_wet = sqrtFixp(slotAmp_wet << sc); + slotAmp_dry = invSqrtNorm2(slotAmp_dry, &slotAmpSF); + + slotAmp_ratio = fMult(slotAmp_wet, slotAmp_dry); + slotAmpSF = slotAmpSF - (sc >> 1); + } + + /* calculate common scale factor */ + scale = + fixMax(3, fixMax(dryFacSF, slotAmpSF)); /* scale is at least with 3 + bits to avoid overflows + when calculating dryFac */ + dryFac = dryFac >> (scale - dryFacSF); + slotAmp_ratio = slotAmp_ratio >> (scale - slotAmpSF); + + /* limit dryFac */ + dryFac = fixMax( + FL2FXCONST_DBL(0.25f) >> (INT)fixMin(2 * scale, DFRACT_BITS - 1), + fMult(dryFac, slotAmp_ratio) - (slotAmp_ratio >> scale) + + (dryFac >> scale)); + dryFac = fixMin( + FL2FXCONST_DBL(0.50f) >> (INT)fixMin(2 * scale - 3, DFRACT_BITS - 1), + dryFac); /* reduce shift bits by 3, because upper + limit 4.0 is scaled with 3 bits */ + scale = 2 * scale + 1; + + /* improve precision for dryFac */ + sc = fixMax(0, CntLeadingZeros(dryFac) - 1); + dryFac = dryFac << (INT)fixMin(scale, sc); + scale = scale - fixMin(scale, sc); + + /* shaping */ + shapeBBEnv(&self->hybOutputRealDry__FDK[ch][6], + &self->hybOutputImagDry__FDK[ch][6], dryFac, scale, cplxBands, + hybBands); + } + } +} |