Upgrade to FDKv2

Bug: 71430241
Test: CTS DecoderTest and DecoderTestAacDrc

original-Change-Id: Iaa20f749b8a04d553b20247cfe1a8930ebbabe30

Apply clang-format also on header files.

original-Change-Id: I14de1ef16bbc79ec0283e745f98356a10efeb2e4

Fixes for MPEG-D DRC

original-Change-Id: If1de2d74bbbac84b3f67de3b88b83f6a23b8a15c

Catch unsupported tw_mdct at an early stage

original-Change-Id: Ied9dd00d754162a0e3ca1ae3e6b854315d818afe

Fixing PVC transition frames

original-Change-Id: Ib75725abe39252806c32d71176308f2c03547a4e

Move qmf bands sanity check

original-Change-Id: Iab540c3013c174d9490d2ae100a4576f51d8dbc4

Initialize scaling variable

original-Change-Id: I3c4087101b70e998c71c1689b122b0d7762e0f9e

Add 16 qmf band configuration to getSlotNrgHQ()

original-Change-Id: I49a5d30f703a1b126ff163df9656db2540df21f1

Always apply byte alignment at the end of the AudioMuxElement

original-Change-Id: I42d560287506d65d4c3de8bfe3eb9a4ebeb4efc7

Setup SBR element only if no parse error exists

original-Change-Id: I1915b73704bc80ab882b9173d6bec59cbd073676

Additional array index check in HCR

original-Change-Id: I18cc6e501ea683b5009f1bbee26de8ddd04d8267

Fix fade-in index selection in concealment module

original-Change-Id: Ibf802ed6ed8c05e9257e1f3b6d0ac1162e9b81c1

Enable explicit backward compatible parser for AAC_LD

original-Change-Id: I27e9c678dcb5d40ed760a6d1e06609563d02482d

Skip spatial specific config in explicit backward compatible ASC

original-Change-Id: Iff7cc365561319e886090cedf30533f562ea4d6e

Update flags description in decoder API

original-Change-Id: I9a5b4f8da76bb652f5580cbd3ba9760425c43830

Add QMF domain reset function

original-Change-Id: I4f89a8a2c0277d18103380134e4ed86996e9d8d6

DRC upgrade v2.1.0

original-Change-Id: I5731c0540139dab220094cd978ef42099fc45b74

Fix integer overflow in sqrtFixp_lookup()

original-Change-Id: I429a6f0d19aa2cc957e0f181066f0ca73968c914

Fix integer overflow in invSqrtNorm2()

original-Change-Id: I84de5cbf9fb3adeb611db203fe492fabf4eb6155

Fix integer overflow in GenerateRandomVector()

original-Change-Id: I3118a641008bd9484d479e5b0b1ee2b5d7d44d74

Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I29d503c247c5c8282349b79df940416a512fb9d5

Fix integer overflow in FDKsbrEnc_codeEnvelope()

original-Change-Id: I6b34b61ebb9d525b0c651ed08de2befc1f801449

Follow-up on: Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I6f8f578cc7089e5eb7c7b93e580b72ca35ad689a

Fix integer overflow in get_pk_v2()

original-Change-Id: I63375bed40d45867f6eeaa72b20b1f33e815938c

Fix integer overflow in Syn_filt_zero()

original-Change-Id: Ie0c02fdfbe03988f9d3b20d10cd9fe4c002d1279

Fix integer overflow in CFac_CalcFacSignal()

original-Change-Id: Id2d767c40066c591b51768e978eb8af3b803f0c5

Fix integer overflow in FDKaacEnc_FDKaacEnc_calcPeNoAH()

original-Change-Id: Idcbd0f4a51ae2550ed106aa6f3d678d1f9724841

Fix integer overflow in sbrDecoder_calculateGainVec()

original-Change-Id: I7081bcbe29c5cede9821b38d93de07c7add2d507

Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4a95ddc18de150102352d4a1845f06094764c881

Fix integer overflow in Pred_Lt4()

original-Change-Id: I4dbd012b2de7d07c3e70a47b92e3bfae8dbc750a

Fix integer overflow in FDKsbrEnc_InitSbrFastTransientDetector()

original-Change-Id: I788cbec1a4a00f44c2f3a72ad7a4afa219807d04

Fix unsigned integer overflow in FDKaacEnc_WriteBitstream()

original-Change-Id: I68fc75166e7d2cd5cd45b18dbe3d8c2a92f1822a

Fix unsigned integer overflow in FDK_MetadataEnc_Init()

original-Change-Id: Ie8d025f9bcdb2442c704bd196e61065c03c10af4

Fix overflow in pseudo random number generators

original-Change-Id: I3e2551ee01356297ca14e3788436ede80bd5513c

Fix unsigned integer overflow in sbrDecoder_Parse()

original-Change-Id: I3f231b2f437e9c37db4d5b964164686710eee971

Fix unsigned integer overflow in longsub()

original-Change-Id: I73c2bc50415cac26f1f5a29e125bbe75f9180a6e

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: Ifce2db4b1454b46fa5f887e9d383f1cc43b291e4

Fix overflow at CLpdChannelStream_Read()

original-Change-Id: Idb9d822ce3a4272e4794b643644f5434e2d4bf3f

Fix unsigned integer overflow in Hcr_State_BODY_SIGN_ESC__ESC_WORD()

original-Change-Id: I1ccf77c0015684b85534c5eb97162740a870b71c

Fix unsigned integer overflow in UsacConfig_Parse()

original-Change-Id: Ie6d27f84b6ae7eef092ecbff4447941c77864d9f

Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I713f28e883eea3d70b6fa56a7b8f8c22bcf66ca0

Fix unsigned integer overflow in aacDecoder_drcReadCompression()

original-Change-Id: Ia34dfeb88c4705c558bce34314f584965cafcf7a

Fix unsigned integer overflow in CDataStreamElement_Read()

original-Change-Id: Iae896cc1d11f0a893d21be6aa90bd3e60a2c25f0

Fix unsigned integer overflow in transportDec_AdjustEndOfAccessUnit()

original-Change-Id: I64cf29a153ee784bb4a16fdc088baabebc0007dc

Fix unsigned integer overflow in transportDec_GetAuBitsRemaining()

original-Change-Id: I975b3420faa9c16a041874ba0db82e92035962e4

Fix unsigned integer overflow in extractExtendedData()

original-Change-Id: I2a59eb09e2053cfb58dfb75fcecfad6b85a80a8f

Fix signed integer overflow in CAacDecoder_ExtPayloadParse()

original-Change-Id: I4ad5ca4e3b83b5d964f1c2f8c5e7b17c477c7929

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: I29a39df77d45c52a0c9c5c83c1ba81f8d0f25090

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I8fb194ffc073a3432a380845be71036a272d388f

Fix signed integer overflow in _interpolateDrcGain()

original-Change-Id: I879ec9ab14005069a7c47faf80e8bc6e03d22e60

Fix unsigned integer overflow in FDKreadBits()

original-Change-Id: I1f47a6a8037ff70375aa8844947d5681bb4287ad

Fix unsigned integer overflow in FDKbyteAlign()

original-Change-Id: Id5f3a11a0c9e50fc6f76ed6c572dbd4e9f2af766

Fix unsigned integer overflow in FDK_get32()

original-Change-Id: I9d33b8e97e3d38cbb80629cb859266ca0acdce96

Fix unsigned integer overflow in FDK_pushBack()

original-Change-Id: Ic87f899bc8c6acf7a377a8ca7f3ba74c3a1e1c19

Fix unsigned integer overflow in FDK_pushForward()

original-Change-Id: I3b754382f6776a34be1602e66694ede8e0b8effc

Fix unsigned integer overflow in ReadPsData()

original-Change-Id: I25361664ba8139e32bbbef2ca8c106a606ce9c37

Fix signed integer overflow in E_UTIL_residu()

original-Change-Id: I8c3abd1f437ee869caa8fb5903ce7d3d641b6aad

REVERT: Follow-up on: Integer overflow in CLpc_SynthesisLattice().

original-Change-Id: I3d340099acb0414795c8dfbe6362bc0a8f045f9b

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4aedb8b3a187064e9f4d985175aa55bb99cc7590

Follow-up on: Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I2aa2e13916213bf52a67e8b0518e7bf7e57fb37d

Fix integer overflow in acelp

original-Change-Id: Ie6390c136d84055f8b728aefbe4ebef6e029dc77

Fix unsigned integer overflow in aacDecoder_UpdateBitStreamCounters()

original-Change-Id: I391ffd97ddb0b2c184cba76139bfb356a3b4d2e2

Adjust concealment default settings

original-Change-Id: I6a95db935a327c47df348030bcceafcb29f54b21

Saturate estimatedStartPos

original-Change-Id: I27be2085e0ae83ec9501409f65e003f6bcba1ab6

Negative shift exponent in _interpolateDrcGain()

original-Change-Id: I18edb26b26d002aafd5e633d4914960f7a359c29

Negative shift exponent in calculateICC()

original-Change-Id: I3dcd2ae98d2eb70ee0d59750863cbb2a6f4f8aba

Too large shift exponent in FDK_put()

original-Change-Id: Ib7d9aaa434d2d8de4a13b720ca0464b31ca9b671

Too large shift exponent in CalcInvLdData()

original-Change-Id: I43e6e78d4cd12daeb1dcd5d82d1798bdc2550262

Member access within null pointer of type SBR_CHANNEL

original-Change-Id: Idc5e4ea8997810376d2f36bbdf628923b135b097

Member access within null pointer of type CpePersistentData

original-Change-Id: Ib6c91cb0d37882768e5baf63324e429589de0d9d

Member access within null pointer FDKaacEnc_psyMain()

original-Change-Id: I7729b7f4479970531d9dc823abff63ca52e01997

Member access within null pointer FDKaacEnc_GetPnsParam()

original-Change-Id: I9aa3b9f3456ae2e0f7483dbd5b3dde95fc62da39

Member access within null pointer FDKsbrEnc_EnvEncodeFrame()

original-Change-Id: I67936f90ea714e90b3e81bc0dd1472cc713eb23a

Add HCR sanity check

original-Change-Id: I6c1d9732ebcf6af12f50b7641400752f74be39f7

Fix memory issue for HBE edge case with 8:3 SBR

original-Change-Id: I11ea58a61e69fbe8bf75034b640baee3011e63e9

Additional SBR parametrization sanity check for ELD

original-Change-Id: Ie26026fbfe174c2c7b3691f6218b5ce63e322140

Add MPEG-D DRC channel layout check

original-Change-Id: Iea70a74f171b227cce636a9eac4ba662777a2f72

Additional out-of-bounds checks in MPEG-D DRC

original-Change-Id: Ife4a8c3452c6fde8a0a09e941154a39a769777d4

Change-Id: Ic63cb2f628720f54fe9b572b0cb528e2599c624e

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);
+    }
+  }
+}