aboutsummaryrefslogtreecommitdiffstats
path: root/fdk-aac/libSACdec/src/sac_reshapeBBEnv.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fdk-aac/libSACdec/src/sac_reshapeBBEnv.cpp')
-rw-r--r--fdk-aac/libSACdec/src/sac_reshapeBBEnv.cpp680
1 files changed, 680 insertions, 0 deletions
diff --git a/fdk-aac/libSACdec/src/sac_reshapeBBEnv.cpp b/fdk-aac/libSACdec/src/sac_reshapeBBEnv.cpp
new file mode 100644
index 0000000..87c0ac6
--- /dev/null
+++ b/fdk-aac/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);
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-21 09:36:06 +0000