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, 392 insertions, 376 deletions

diff --git a/libSBRdec/src/env_dec.cpp b/libSBRdec/src/env_dec.cpp
index c65c169..88c92cd 100644
--- a/libSBRdec/src/env_dec.cpp
+++ b/libSBRdec/src/env_dec.cpp
@@ -1,74 +1,85 @@
-
-/* -----------------------------------------------------------------------------------------------------------
+/* -----------------------------------------------------------------------------
 Software License for The Fraunhofer FDK AAC Codec Library for Android
 
-© Copyright  1995 - 2015 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
+© 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.
+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:
+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 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
+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.
+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.
+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."
+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.
+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.
+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.
+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
 
@@ -79,13 +90,21 @@ Am Wolfsmantel 33
 
 www.iis.fraunhofer.de/amm
 amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
+----------------------------------------------------------------------------- */
+
+/**************************** SBR decoder library ******************************
+
+   Author(s):
+
+   Description:
+
+*******************************************************************************/
 
 /*!
   \file
-  \brief  envelope decoding  
-  This module provides envelope decoding and error concealment algorithms. The main
-  entry point is decodeSbrData().
+  \brief  envelope decoding
+  This module provides envelope decoding and error concealment algorithms. The
+  main entry point is decodeSbrData().
 
   \sa decodeSbrData(),\ref documentationOverview
 */
@@ -97,43 +116,41 @@ amm-info@iis.fraunhofer.de
 
 #include "genericStds.h"
 
-
-static void decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
-                            HANDLE_SBR_FRAME_DATA h_sbr_data,
-                            HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
-                            HANDLE_SBR_PREV_FRAME_DATA h_prev_data_otherChannel);
-static void sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                    HANDLE_SBR_FRAME_DATA h_data_left,
-                                    HANDLE_SBR_FRAME_DATA h_data_right);
-static void requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                    int ampResolution);
-static void deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                              HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                              HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static void decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                    HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static void timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
-                                         HANDLE_SBR_FRAME_DATA h_sbr_data,
-                                         HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-static int checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,
-                              HANDLE_SBR_FRAME_DATA h_sbr_data,
-                              HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
-
-
-
-#define SBR_ENERGY_PAN_OFFSET   (12 << ENV_EXP_FRACT)
-#define SBR_MAX_ENERGY          (35 << ENV_EXP_FRACT)
-
-#define DECAY                   ( 1 << ENV_EXP_FRACT)
+static void decodeEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
+                           HANDLE_SBR_FRAME_DATA h_sbr_data,
+                           HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
+                           HANDLE_SBR_PREV_FRAME_DATA h_prev_data_otherChannel);
+static void sbr_envelope_unmapping(HANDLE_SBR_HEADER_DATA hHeaderData,
+                                   HANDLE_SBR_FRAME_DATA h_data_left,
+                                   HANDLE_SBR_FRAME_DATA h_data_right);
+static void requantizeEnvelopeData(HANDLE_SBR_FRAME_DATA h_sbr_data,
+                                   int ampResolution);
+static void deltaToLinearPcmEnvelopeDecoding(
+    HANDLE_SBR_HEADER_DATA hHeaderData, HANDLE_SBR_FRAME_DATA h_sbr_data,
+    HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
+static void decodeNoiseFloorlevels(HANDLE_SBR_HEADER_DATA hHeaderData,
+                                   HANDLE_SBR_FRAME_DATA h_sbr_data,
+                                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
+static void timeCompensateFirstEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
+                                        HANDLE_SBR_FRAME_DATA h_sbr_data,
+                                        HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
+static int checkEnvelopeData(HANDLE_SBR_HEADER_DATA hHeaderData,
+                             HANDLE_SBR_FRAME_DATA h_sbr_data,
+                             HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
+
+#define SBR_ENERGY_PAN_OFFSET (12 << ENV_EXP_FRACT)
+#define SBR_MAX_ENERGY (35 << ENV_EXP_FRACT)
+
+#define DECAY (1 << ENV_EXP_FRACT)
 
 #if ENV_EXP_FRACT
-#define DECAY_COUPLING          ( 1 << (ENV_EXP_FRACT-1) ) /*!< corresponds to a value of 0.5 */
+#define DECAY_COUPLING \
+  (1 << (ENV_EXP_FRACT - 1)) /*!< corresponds to a value of 0.5 */
 #else
-#define DECAY_COUPLING            1  /*!< If the energy data is not shifted, use 1 instead of 0.5 */
+#define DECAY_COUPLING \
+  1 /*!< If the energy data is not shifted, use 1 instead of 0.5 */
 #endif
 
-
 /*!
   \brief  Convert table index
 */
@@ -141,29 +158,23 @@ static int indexLow2High(int offset, /*!< mapping factor */
                          int index,  /*!< index to scalefactor band */
                          int res)    /*!< frequency resolution */
 {
-  if(res == 0)
-  {
-    if (offset >= 0)
-    {
-        if (index < offset)
-          return(index);
-        else
-          return(2*index - offset);
-    }
-    else
-    {
-        offset = -offset;
-        if (index < offset)
-          return(2*index+index);
-        else
-          return(2*index + offset);
+  if (res == 0) {
+    if (offset >= 0) {
+      if (index < offset)
+        return (index);
+      else
+        return (2 * index - offset);
+    } else {
+      offset = -offset;
+      if (index < offset)
+        return (2 * index + index);
+      else
+        return (2 * index + offset);
     }
-  }
-  else
-    return(index);
+  } else
+    return (index);
 }
 
-
 /*!
   \brief  Update previous envelope value for delta-coding
 
@@ -173,115 +184,119 @@ static int indexLow2High(int offset, /*!< mapping factor */
   low frequency resolution, the energy value will be mapped to the
   corresponding high-res bands.
 */
-static void mapLowResEnergyVal(FIXP_SGL currVal,  /*!< current energy value */
-                               FIXP_SGL* prevData,/*!< pointer to previous data vector */
-                               int offset,      /*!< mapping factor */
-                               int index,       /*!< index to scalefactor band */
-                               int res)         /*!< frequeny resolution */
+static void mapLowResEnergyVal(
+    FIXP_SGL currVal,   /*!< current energy value */
+    FIXP_SGL *prevData, /*!< pointer to previous data vector */
+    int offset,         /*!< mapping factor */
+    int index,          /*!< index to scalefactor band */
+    int res)            /*!< frequeny resolution */
 {
-  if(res == 0)
-  {
-    if (offset >= 0)
-    {
-        if(index < offset)
-            prevData[index] = currVal;
-        else
-        {
-            prevData[2*index - offset] = currVal;
-            prevData[2*index+1 - offset] = currVal;
-        }
-    }
-    else
-    {
-        offset = -offset;
-        if (index < offset)
-        {
-            prevData[3*index] = currVal;
-            prevData[3*index+1] = currVal;
-            prevData[3*index+2] = currVal;
-        }
-        else
-        {
-            prevData[2*index + offset] = currVal;
-            prevData[2*index + 1 + offset] = currVal;
-        }
+  if (res == 0) {
+    if (offset >= 0) {
+      if (index < offset)
+        prevData[index] = currVal;
+      else {
+        prevData[2 * index - offset] = currVal;
+        prevData[2 * index + 1 - offset] = currVal;
+      }
+    } else {
+      offset = -offset;
+      if (index < offset) {
+        prevData[3 * index] = currVal;
+        prevData[3 * index + 1] = currVal;
+        prevData[3 * index + 2] = currVal;
+      } else {
+        prevData[2 * index + offset] = currVal;
+        prevData[2 * index + 1 + offset] = currVal;
+      }
     }
-  }
-  else
+  } else
     prevData[index] = currVal;
 }
 
-
-
 /*!
   \brief    Convert raw envelope and noisefloor data to energy levels
 
-  This function is being called by sbrDecoder_ParseElement() and provides two important algorithms:
+  This function is being called by sbrDecoder_ParseElement() and provides two
+  important algorithms:
 
-  First the function decodes envelopes and noise floor levels as described in requantizeEnvelopeData()
-  and sbr_envelope_unmapping(). The function also implements concealment algorithms in case there are errors
-  within the sbr data. For both operations fractional arithmetic is used.
-  Therefore you might encounter different output values on your target
-  system compared to the reference implementation.
+  First the function decodes envelopes and noise floor levels as described in
+  requantizeEnvelopeData() and sbr_envelope_unmapping(). The function also
+  implements concealment algorithms in case there are errors within the sbr
+  data. For both operations fractional arithmetic is used. Therefore you might
+  encounter different output values on your target system compared to the
+  reference implementation.
 */
-void
-decodeSbrData (HANDLE_SBR_HEADER_DATA hHeaderData,          /*!< Static control data */
-               HANDLE_SBR_FRAME_DATA h_data_left,           /*!< pointer to left channel frame data */
-               HANDLE_SBR_PREV_FRAME_DATA h_prev_data_left, /*!< pointer to left channel previous frame data */
-               HANDLE_SBR_FRAME_DATA h_data_right,          /*!< pointer to right channel frame data */
-               HANDLE_SBR_PREV_FRAME_DATA h_prev_data_right)/*!< pointer to right channel previous frame data */
+void decodeSbrData(
+    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA
+        h_data_left, /*!< pointer to left channel frame data */
+    HANDLE_SBR_PREV_FRAME_DATA
+        h_prev_data_left, /*!< pointer to left channel previous frame data */
+    HANDLE_SBR_FRAME_DATA
+        h_data_right, /*!< pointer to right channel frame data */
+    HANDLE_SBR_PREV_FRAME_DATA
+        h_prev_data_right) /*!< pointer to right channel previous frame data */
 {
   FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
   int errLeft;
 
-  /* Save previous energy values to be able to reuse them later for concealment. */
-  FDKmemcpy (tempSfbNrgPrev, h_prev_data_left->sfb_nrg_prev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
+  /* Save previous energy values to be able to reuse them later for concealment.
+   */
+  FDKmemcpy(tempSfbNrgPrev, h_prev_data_left->sfb_nrg_prev,
+            MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
 
-  decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
-  decodeNoiseFloorlevels (hHeaderData, h_data_left, h_prev_data_left);
+  if (hHeaderData->frameErrorFlag || hHeaderData->bs_info.pvc_mode == 0) {
+    decodeEnvelope(hHeaderData, h_data_left, h_prev_data_left,
+                   h_prev_data_right);
+  } else {
+    FDK_ASSERT(h_data_right == NULL);
+  }
+  decodeNoiseFloorlevels(hHeaderData, h_data_left, h_prev_data_left);
 
-  if(h_data_right != NULL) {
+  if (h_data_right != NULL) {
     errLeft = hHeaderData->frameErrorFlag;
-    decodeEnvelope (hHeaderData, h_data_right, h_prev_data_right, h_prev_data_left);
-    decodeNoiseFloorlevels (hHeaderData, h_data_right, h_prev_data_right);
+    decodeEnvelope(hHeaderData, h_data_right, h_prev_data_right,
+                   h_prev_data_left);
+    decodeNoiseFloorlevels(hHeaderData, h_data_right, h_prev_data_right);
 
     if (!errLeft && hHeaderData->frameErrorFlag) {
-      /* If an error occurs in the right channel where the left channel seemed ok,
-         we apply concealment also on the left channel. This ensures that the coupling
-         modes of both channels match and that we have the same number of envelopes in
-         coupling mode.
-         However, as the left channel has already been processed before, the resulting
-         energy levels are not the same as if the left channel had been concealed
-         during the first call of decodeEnvelope().
+      /* If an error occurs in the right channel where the left channel seemed
+         ok, we apply concealment also on the left channel. This ensures that
+         the coupling modes of both channels match and that we have the same
+         number of envelopes in coupling mode. However, as the left channel has
+         already been processed before, the resulting energy levels are not the
+         same as if the left channel had been concealed during the first call of
+         decodeEnvelope().
       */
-      /* Restore previous energy values for concealment, because the values have been
-         overwritten by the first call of decodeEnvelope(). */
-      FDKmemcpy (h_prev_data_left->sfb_nrg_prev, tempSfbNrgPrev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
+      /* Restore previous energy values for concealment, because the values have
+         been overwritten by the first call of decodeEnvelope(). */
+      FDKmemcpy(h_prev_data_left->sfb_nrg_prev, tempSfbNrgPrev,
+                MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
       /* Do concealment */
-      decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
+      decodeEnvelope(hHeaderData, h_data_left, h_prev_data_left,
+                     h_prev_data_right);
     }
 
     if (h_data_left->coupling) {
-      sbr_envelope_unmapping (hHeaderData, h_data_left, h_data_right);
+      sbr_envelope_unmapping(hHeaderData, h_data_left, h_data_right);
     }
   }
 
   /* Display the data for debugging: */
 }
 
-
 /*!
   \brief   Convert from coupled channels to independent L/R data
 */
-static void
-sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
-                        HANDLE_SBR_FRAME_DATA h_data_left,  /*!< pointer to left channel */
-                        HANDLE_SBR_FRAME_DATA h_data_right) /*!< pointer to right channel */
+static void sbr_envelope_unmapping(
+    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_data_left,  /*!< pointer to left channel */
+    HANDLE_SBR_FRAME_DATA h_data_right) /*!< pointer to right channel */
 {
   int i;
   FIXP_SGL tempL_m, tempR_m, tempRplus1_m, newL_m, newR_m;
-  SCHAR   tempL_e, tempR_e, tempRplus1_e, newL_e, newR_e;
-
+  SCHAR tempL_e, tempR_e, tempRplus1_e, newL_e, newR_e;
 
   /* 1. Unmap (already dequantized) coupled envelope energies */
 
@@ -289,51 +304,53 @@ sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control
     tempR_m = (FIXP_SGL)((LONG)h_data_right->iEnvelope[i] & MASK_M);
     tempR_e = (SCHAR)((LONG)h_data_right->iEnvelope[i] & MASK_E);
 
-    tempR_e -= (18 + NRG_EXP_OFFSET);  /* -18 = ld(UNMAPPING_SCALE / h_data_right->nChannels) */
+    tempR_e -= (18 + NRG_EXP_OFFSET); /* -18 = ld(UNMAPPING_SCALE /
+                                         h_data_right->nChannels) */
     tempL_m = (FIXP_SGL)((LONG)h_data_left->iEnvelope[i] & MASK_M);
     tempL_e = (SCHAR)((LONG)h_data_left->iEnvelope[i] & MASK_E);
 
     tempL_e -= NRG_EXP_OFFSET;
 
     /* Calculate tempRight+1 */
-    FDK_add_MantExp( tempR_m, tempR_e,
-                     FL2FXCONST_SGL(0.5f), 1,  /* 1.0 */
-                     &tempRplus1_m, &tempRplus1_e);
+    FDK_add_MantExp(tempR_m, tempR_e, FL2FXCONST_SGL(0.5f), 1, /* 1.0 */
+                    &tempRplus1_m, &tempRplus1_e);
 
-    FDK_divide_MantExp( tempL_m, tempL_e+1,  /*  2 * tempLeft */
-                       tempRplus1_m, tempRplus1_e,
-                       &newR_m, &newR_e );
+    FDK_divide_MantExp(tempL_m, tempL_e + 1, /*  2 * tempLeft */
+                       tempRplus1_m, tempRplus1_e, &newR_m, &newR_e);
 
     if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
       newR_m >>= 1;
       newR_e += 1;
     }
 
-    newL_m = FX_DBL2FX_SGL(fMult(tempR_m,newR_m));
+    newL_m = FX_DBL2FX_SGL(fMult(tempR_m, newR_m));
     newL_e = tempR_e + newR_e;
 
-    h_data_right->iEnvelope[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
-                                  (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NRG_EXP_OFFSET) & MASK_E);
-    h_data_left->iEnvelope[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
-                                  (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NRG_EXP_OFFSET) & MASK_E);
+    h_data_right->iEnvelope[i] =
+        ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
+        (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NRG_EXP_OFFSET) & MASK_E);
+    h_data_left->iEnvelope[i] =
+        ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
+        (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NRG_EXP_OFFSET) & MASK_E);
   }
 
   /* 2. Dequantize and unmap coupled noise floor levels */
 
-  for (i = 0; i < hHeaderData->freqBandData.nNfb * h_data_left->frameInfo.nNoiseEnvelopes; i++) {
-
+  for (i = 0; i < hHeaderData->freqBandData.nNfb *
+                      h_data_left->frameInfo.nNoiseEnvelopes;
+       i++) {
     tempL_e = (SCHAR)(6 - (LONG)h_data_left->sbrNoiseFloorLevel[i]);
-    tempR_e = (SCHAR)((LONG)h_data_right->sbrNoiseFloorLevel[i] - 12) /*SBR_ENERGY_PAN_OFFSET*/;
+    tempR_e = (SCHAR)((LONG)h_data_right->sbrNoiseFloorLevel[i] -
+                      12) /*SBR_ENERGY_PAN_OFFSET*/;
 
     /* Calculate tempR+1 */
-    FDK_add_MantExp( FL2FXCONST_SGL(0.5f), 1+tempR_e, /* tempR */
-                     FL2FXCONST_SGL(0.5f), 1,         /*  1.0  */
-                     &tempRplus1_m, &tempRplus1_e);
+    FDK_add_MantExp(FL2FXCONST_SGL(0.5f), 1 + tempR_e, /* tempR */
+                    FL2FXCONST_SGL(0.5f), 1,           /*  1.0  */
+                    &tempRplus1_m, &tempRplus1_e);
 
     /* Calculate 2*tempLeft/(tempR+1) */
-    FDK_divide_MantExp( FL2FXCONST_SGL(0.5f), tempL_e+2,  /*  2 * tempLeft */
-                       tempRplus1_m, tempRplus1_e,
-                       &newR_m, &newR_e );
+    FDK_divide_MantExp(FL2FXCONST_SGL(0.5f), tempL_e + 2, /*  2 * tempLeft */
+                       tempRplus1_m, tempRplus1_e, &newR_m, &newR_e);
 
     /* if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
       newR_m >>= 1;
@@ -343,14 +360,15 @@ sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control
     /* L = tempR * R */
     newL_m = newR_m;
     newL_e = newR_e + tempR_e;
-    h_data_right->sbrNoiseFloorLevel[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
-                                           (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NOISE_EXP_OFFSET) & MASK_E);
-    h_data_left->sbrNoiseFloorLevel[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
-                                           (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NOISE_EXP_OFFSET) & MASK_E);
+    h_data_right->sbrNoiseFloorLevel[i] =
+        ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
+        (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NOISE_EXP_OFFSET) & MASK_E);
+    h_data_left->sbrNoiseFloorLevel[i] =
+        ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
+        (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NOISE_EXP_OFFSET) & MASK_E);
   }
 }
 
-
 /*!
   \brief    Simple alternative to the real SBR concealment
 
@@ -359,24 +377,23 @@ sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control
   The delta-coded energies are set to negative values, resulting in a fade-down.
   In case of coupling, the balance-channel will move towards the center.
 */
-static void
-leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                   HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
-                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
-                   )
-{
-  FIXP_SGL target;  /* targeted level for sfb_nrg_prev during fade-down */
-  FIXP_SGL step;    /* speed of fade */
+static void leanSbrConcealment(
+    HANDLE_SBR_HEADER_DATA hHeaderData,    /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,      /*!< pointer to current data */
+    HANDLE_SBR_PREV_FRAME_DATA h_prev_data /*!< pointer to data of last frame */
+) {
+  FIXP_SGL target; /* targeted level for sfb_nrg_prev during fade-down */
+  FIXP_SGL step;   /* speed of fade */
   int i;
 
-  int currentStartPos = FDKmax(0, h_prev_data->stopPos - hHeaderData->numberTimeSlots);
+  int currentStartPos =
+      fMax(0, h_prev_data->stopPos - hHeaderData->numberTimeSlots);
   int currentStopPos = hHeaderData->numberTimeSlots;
 
-
   /* Use some settings of the previous frame */
   h_sbr_data->ampResolutionCurrentFrame = h_prev_data->ampRes;
   h_sbr_data->coupling = h_prev_data->coupling;
-  for(i=0;i<MAX_INVF_BANDS;i++)
+  for (i = 0; i < MAX_INVF_BANDS; i++)
     h_sbr_data->sbr_invf_mode[i] = h_prev_data->sbr_invf_mode[i];
 
   /* Generate concealing control data */
@@ -385,7 +402,7 @@ leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control d
   h_sbr_data->frameInfo.borders[0] = currentStartPos;
   h_sbr_data->frameInfo.borders[1] = currentStopPos;
   h_sbr_data->frameInfo.freqRes[0] = 1;
-  h_sbr_data->frameInfo.tranEnv = -1;  /* no transient */
+  h_sbr_data->frameInfo.tranEnv = -1; /* no transient */
   h_sbr_data->frameInfo.nNoiseEnvelopes = 1;
   h_sbr_data->frameInfo.bordersNoise[0] = currentStartPos;
   h_sbr_data->frameInfo.bordersNoise[1] = currentStopPos;
@@ -399,17 +416,16 @@ leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control d
   if (h_sbr_data->coupling == COUPLING_BAL) {
     target = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
     step = (FIXP_SGL)DECAY_COUPLING;
-  }
-  else {
+  } else {
     target = FL2FXCONST_SGL(0.0f);
-    step   = (FIXP_SGL)DECAY;
+    step = (FIXP_SGL)DECAY;
   }
   if (hHeaderData->bs_info.ampResolution == 0) {
     target <<= 1;
-    step   <<= 1;
+    step <<= 1;
   }
 
-  for (i=0; i < h_sbr_data->nScaleFactors; i++) {
+  for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
     if (h_prev_data->sfb_nrg_prev[i] > target)
       h_sbr_data->iEnvelope[i] = -step;
     else
@@ -419,123 +435,125 @@ leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control d
   /* Noisefloor levels are always cleared ... */
 
   h_sbr_data->domain_vec_noise[0] = 1;
-  for (i=0; i < hHeaderData->freqBandData.nNfb; i++)
+  for (i = 0; i < hHeaderData->freqBandData.nNfb; i++)
     h_sbr_data->sbrNoiseFloorLevel[i] = FL2FXCONST_SGL(0.0f);
 
   /* ... and so are the sines */
-  FDKmemclear(h_sbr_data->addHarmonics, MAX_FREQ_COEFFS);
+  FDKmemclear(h_sbr_data->addHarmonics,
+              sizeof(ULONG) * ADD_HARMONICS_FLAGS_SIZE);
 }
 
-
 /*!
   \brief   Build reference energies and noise levels from bitstream elements
 */
-static void
-decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
-                HANDLE_SBR_PREV_FRAME_DATA h_prev_data, /*!< pointer to data of last frame */
-                HANDLE_SBR_PREV_FRAME_DATA otherChannel /*!< other channel's last frame data */
-                )
-{
+static void decodeEnvelope(
+    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,   /*!< pointer to current data */
+    HANDLE_SBR_PREV_FRAME_DATA
+        h_prev_data, /*!< pointer to data of last frame */
+    HANDLE_SBR_PREV_FRAME_DATA
+        otherChannel /*!< other channel's last frame data */
+) {
   int i;
   int fFrameError = hHeaderData->frameErrorFlag;
   FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
 
   if (!fFrameError) {
     /*
-      To avoid distortions after bad frames, set the error flag if delta coding in time occurs.
-      However, SBR can take a little longer to come up again.
+      To avoid distortions after bad frames, set the error flag if delta coding
+      in time occurs. However, SBR can take a little longer to come up again.
     */
-    if ( h_prev_data->frameErrorFlag ) {
+    if (h_prev_data->frameErrorFlag) {
       if (h_sbr_data->domain_vec[0] != 0) {
         fFrameError = 1;
       }
     } else {
-      /* Check that the previous stop position and the current start position match.
-         (Could be done in checkFrameInfo(), but the previous frame data is not available there) */
-      if ( h_sbr_data->frameInfo.borders[0] != h_prev_data->stopPos - hHeaderData->numberTimeSlots ) {
-        /* Both the previous as well as the current frame are flagged to be ok, but they do not match! */
+      /* Check that the previous stop position and the current start position
+         match. (Could be done in checkFrameInfo(), but the previous frame data
+         is not available there) */
+      if (h_sbr_data->frameInfo.borders[0] !=
+          h_prev_data->stopPos - hHeaderData->numberTimeSlots) {
+        /* Both the previous as well as the current frame are flagged to be ok,
+         * but they do not match! */
         if (h_sbr_data->domain_vec[0] == 1) {
-          /* Prefer concealment over delta-time coding between the mismatching frames */
+          /* Prefer concealment over delta-time coding between the mismatching
+           * frames */
           fFrameError = 1;
-        }
-        else {
-          /* Close the gap in time by triggering timeCompensateFirstEnvelope() */
+        } else {
+          /* Close the gap in time by triggering timeCompensateFirstEnvelope()
+           */
           fFrameError = 1;
         }
       }
     }
   }
 
+  if (fFrameError) /* Error is detected */
+  {
+    leanSbrConcealment(hHeaderData, h_sbr_data, h_prev_data);
 
-  if (fFrameError)       /* Error is detected */
-    {
-      leanSbrConcealment(hHeaderData,
-                         h_sbr_data,
-                         h_prev_data);
-
-      /* decode the envelope data to linear PCM */
-      deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
-    }
-  else                          /*Do a temporary dummy decoding and check that the envelope values are within limits */
-    {
-      if (h_prev_data->frameErrorFlag) {
-        timeCompensateFirstEnvelope (hHeaderData, h_sbr_data, h_prev_data);
-        if (h_sbr_data->coupling != h_prev_data->coupling) {
-          /*
-            Coupling mode has changed during concealment.
-             The stored energy levels need to be converted.
-           */
-          for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
-            /* Former Level-Channel will be used for both channels */
-            if (h_prev_data->coupling == COUPLING_BAL)
-              h_prev_data->sfb_nrg_prev[i] = otherChannel->sfb_nrg_prev[i];
-            /* Former L/R will be combined as the new Level-Channel */
-            else if (h_sbr_data->coupling == COUPLING_LEVEL)
-              h_prev_data->sfb_nrg_prev[i] = (h_prev_data->sfb_nrg_prev[i] + otherChannel->sfb_nrg_prev[i]) >> 1;
-            else if (h_sbr_data->coupling == COUPLING_BAL)
-              h_prev_data->sfb_nrg_prev[i] = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
-          }
+    /* decode the envelope data to linear PCM */
+    deltaToLinearPcmEnvelopeDecoding(hHeaderData, h_sbr_data, h_prev_data);
+  } else /*Do a temporary dummy decoding and check that the envelope values are
+            within limits */
+  {
+    if (h_prev_data->frameErrorFlag) {
+      timeCompensateFirstEnvelope(hHeaderData, h_sbr_data, h_prev_data);
+      if (h_sbr_data->coupling != h_prev_data->coupling) {
+        /*
+          Coupling mode has changed during concealment.
+           The stored energy levels need to be converted.
+         */
+        for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
+          /* Former Level-Channel will be used for both channels */
+          if (h_prev_data->coupling == COUPLING_BAL)
+            h_prev_data->sfb_nrg_prev[i] = otherChannel->sfb_nrg_prev[i];
+          /* Former L/R will be combined as the new Level-Channel */
+          else if (h_sbr_data->coupling == COUPLING_LEVEL)
+            h_prev_data->sfb_nrg_prev[i] = (h_prev_data->sfb_nrg_prev[i] +
+                                            otherChannel->sfb_nrg_prev[i]) >>
+                                           1;
+          else if (h_sbr_data->coupling == COUPLING_BAL)
+            h_prev_data->sfb_nrg_prev[i] = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
         }
       }
-      FDKmemcpy (tempSfbNrgPrev, h_prev_data->sfb_nrg_prev,
-              MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
+    }
+    FDKmemcpy(tempSfbNrgPrev, h_prev_data->sfb_nrg_prev,
+              MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
 
-      deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
+    deltaToLinearPcmEnvelopeDecoding(hHeaderData, h_sbr_data, h_prev_data);
 
-      fFrameError = checkEnvelopeData (hHeaderData, h_sbr_data, h_prev_data);
+    fFrameError = checkEnvelopeData(hHeaderData, h_sbr_data, h_prev_data);
 
-      if (fFrameError)
-        {
-          hHeaderData->frameErrorFlag = 1;
-          FDKmemcpy (h_prev_data->sfb_nrg_prev, tempSfbNrgPrev,
-                  MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
-          decodeEnvelope (hHeaderData, h_sbr_data, h_prev_data, otherChannel);
-          return;
-        }
+    if (fFrameError) {
+      hHeaderData->frameErrorFlag = 1;
+      FDKmemcpy(h_prev_data->sfb_nrg_prev, tempSfbNrgPrev,
+                MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
+      decodeEnvelope(hHeaderData, h_sbr_data, h_prev_data, otherChannel);
+      return;
     }
+  }
 
-  requantizeEnvelopeData (h_sbr_data, h_sbr_data->ampResolutionCurrentFrame);
+  requantizeEnvelopeData(h_sbr_data, h_sbr_data->ampResolutionCurrentFrame);
 
   hHeaderData->frameErrorFlag = fFrameError;
 }
 
-
 /*!
   \brief   Verify that envelope energies are within the allowed range
   \return  0 if all is fine, 1 if an envelope value was too high
 */
-static int
-checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                   HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
-                   )
-{
+static int checkEnvelopeData(
+    HANDLE_SBR_HEADER_DATA hHeaderData,    /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,      /*!< pointer to current data */
+    HANDLE_SBR_PREV_FRAME_DATA h_prev_data /*!< pointer to data of last frame */
+) {
   FIXP_SGL *iEnvelope = h_sbr_data->iEnvelope;
   FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
-  int    i = 0, errorFlag = 0;
-  FIXP_SGL sbr_max_energy =
-    (h_sbr_data->ampResolutionCurrentFrame == 1) ? SBR_MAX_ENERGY : (SBR_MAX_ENERGY << 1);
+  int i = 0, errorFlag = 0;
+  FIXP_SGL sbr_max_energy = (h_sbr_data->ampResolutionCurrentFrame == 1)
+                                ? SBR_MAX_ENERGY
+                                : (SBR_MAX_ENERGY << 1);
 
   /*
     Range check for current energies
@@ -561,7 +579,6 @@ checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control d
   return (errorFlag);
 }
 
-
 /*!
   \brief   Verify that the noise levels are within the allowed range
 
@@ -569,49 +586,55 @@ checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control d
   When the noise-levels are being decoded, it is already too late for
   concealment. Therefore the noise levels are simply limited here.
 */
-static void
-limitNoiseLevels(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                 HANDLE_SBR_FRAME_DATA h_sbr_data)       /*!< pointer to current data */
+static void limitNoiseLevels(
+    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data)   /*!< pointer to current data */
 {
   int i;
   int nNfb = hHeaderData->freqBandData.nNfb;
 
-  /*
-    Set range limits. The exact values depend on the coupling mode.
-    However this limitation is primarily intended to avoid unlimited
-    accumulation of the delta-coded noise levels.
-  */
-  #define lowerLimit   ((FIXP_SGL)0)     /* lowerLimit actually refers to the _highest_ noise energy */
-  #define upperLimit   ((FIXP_SGL)35)    /* upperLimit actually refers to the _lowest_ noise energy */
+/*
+  Set range limits. The exact values depend on the coupling mode.
+  However this limitation is primarily intended to avoid unlimited
+  accumulation of the delta-coded noise levels.
+*/
+#define lowerLimit \
+  ((FIXP_SGL)0) /* lowerLimit actually refers to the _highest_ noise energy */
+#define upperLimit \
+  ((FIXP_SGL)35) /* upperLimit actually refers to the _lowest_ noise energy */
 
   /*
     Range check for current noise levels
   */
   for (i = 0; i < h_sbr_data->frameInfo.nNoiseEnvelopes * nNfb; i++) {
-    h_sbr_data->sbrNoiseFloorLevel[i] = fixMin(h_sbr_data->sbrNoiseFloorLevel[i], upperLimit);
-    h_sbr_data->sbrNoiseFloorLevel[i] = fixMax(h_sbr_data->sbrNoiseFloorLevel[i], lowerLimit);
+    h_sbr_data->sbrNoiseFloorLevel[i] =
+        fixMin(h_sbr_data->sbrNoiseFloorLevel[i], upperLimit);
+    h_sbr_data->sbrNoiseFloorLevel[i] =
+        fixMax(h_sbr_data->sbrNoiseFloorLevel[i], lowerLimit);
   }
 }
 
-
 /*!
   \brief   Compensate for the wrong timing that might occur after a frame error.
 */
-static void
-timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
-                             HANDLE_SBR_FRAME_DATA h_sbr_data,   /*!< pointer to actual data */
-                             HANDLE_SBR_PREV_FRAME_DATA h_prev_data)  /*!< pointer to data of last frame */
+static void timeCompensateFirstEnvelope(
+    HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,   /*!< pointer to actual data */
+    HANDLE_SBR_PREV_FRAME_DATA
+        h_prev_data) /*!< pointer to data of last frame */
 {
   int i, nScalefactors;
   FRAME_INFO *pFrameInfo = &h_sbr_data->frameInfo;
   UCHAR *nSfb = hHeaderData->freqBandData.nSfb;
-  int estimatedStartPos = h_prev_data->stopPos - hHeaderData->numberTimeSlots;
+  int estimatedStartPos =
+      fMax(0, h_prev_data->stopPos - hHeaderData->numberTimeSlots);
   int refLen, newLen, shift;
-  FIXP_SGL  deltaExp;
+  FIXP_SGL deltaExp;
 
   /* Original length of first envelope according to bitstream */
   refLen = pFrameInfo->borders[1] - pFrameInfo->borders[0];
-  /* Corrected length of first envelope (concealing can make the first envelope longer) */
+  /* Corrected length of first envelope (concealing can make the first envelope
+   * longer) */
   newLen = pFrameInfo->borders[1] - estimatedStartPos;
 
   if (newLen <= 0) {
@@ -625,7 +648,8 @@ timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static con
   deltaExp = FDK_getNumOctavesDiv8(newLen, refLen);
 
   /* Shift by -3 to rescale ld-table, ampRes-1 to enable coarser steps */
-  shift = (FRACT_BITS - 1 - ENV_EXP_FRACT - 1 + h_sbr_data->ampResolutionCurrentFrame - 3);
+  shift = (FRACT_BITS - 1 - ENV_EXP_FRACT - 1 +
+           h_sbr_data->ampResolutionCurrentFrame - 3);
   deltaExp = deltaExp >> shift;
   pFrameInfo->borders[0] = estimatedStartPos;
   pFrameInfo->bordersNoise[0] = estimatedStartPos;
@@ -638,8 +662,6 @@ timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static con
   }
 }
 
-
-
 /*!
   \brief   Convert each envelope value from logarithmic to linear domain
 
@@ -660,9 +682,8 @@ timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static con
 
   The data is then used in calculateSbrEnvelope().
 */
-static void
-requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
-{
+static void requantizeEnvelopeData(HANDLE_SBR_FRAME_DATA h_sbr_data,
+                                   int ampResolution) {
   int i;
   FIXP_SGL mantissa;
   int ampShift = 1 - ampResolution;
@@ -672,16 +693,15 @@ requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
      the initialization of this array has to be adapted!
   */
 #if ENV_EXP_FRACT
-  static const FIXP_SGL pow2[ENV_EXP_FRACT] =
-  {
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 1))), /* 0.7071 */
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 2))), /* 0.5946 */
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 3))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 4))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 5))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 6))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 7))),
-    FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 8)))  /* 0.5013 */
+  static const FIXP_SGL pow2[ENV_EXP_FRACT] = {
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 1))), /* 0.7071 */
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 2))), /* 0.5946 */
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 3))),
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 4))),
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 5))),
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 6))),
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 7))),
+      FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 8))) /* 0.5013 */
   };
 
   int bit, mask;
@@ -698,13 +718,13 @@ requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
     /* Amplify mantissa according to the fractional part of the
        exponent (result will be between 0.500000 and 0.999999)
     */
-    mask = 1;  /* begin with lowest bit of exponent */
+    mask = 1; /* begin with lowest bit of exponent */
 
-    for ( bit=ENV_EXP_FRACT-1; bit>=0; bit-- ) {
+    for (bit = ENV_EXP_FRACT - 1; bit >= 0; bit--) {
       if (exponent & mask) {
         /* The current bit of the exponent is set,
            multiply mantissa with the corresponding factor: */
-        mantissa = (FIXP_SGL)( (mantissa * pow2[bit]) << 1);
+        mantissa = (FIXP_SGL)((mantissa * pow2[bit]) << 1);
       }
       /* Advance to next bit */
       mask = mask << 1;
@@ -714,40 +734,43 @@ requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
     exponent = exponent >> ENV_EXP_FRACT;
 
 #else
-    /* In case of the high amplitude resolution, 1 bit of the exponent gets lost by the shift.
-       This will be compensated by a mantissa of 0.5*sqrt(2) instead of 0.5 if that bit is 1. */
-    mantissa = (exponent & ampShift) ? FL2FXCONST_SGL(0.707106781186548f) : FL2FXCONST_SGL(0.5f);
+    /* In case of the high amplitude resolution, 1 bit of the exponent gets lost
+       by the shift. This will be compensated by a mantissa of 0.5*sqrt(2)
+       instead of 0.5 if that bit is 1. */
+    mantissa = (exponent & ampShift) ? FL2FXCONST_SGL(0.707106781186548f)
+                                     : FL2FXCONST_SGL(0.5f);
     exponent = exponent >> ampShift;
 #endif
 
     /*
-      Mantissa was set to 0.5 (instead of 1.0, therefore increase exponent by 1).
-      Multiply by L=nChannels=64 by increasing exponent by another 6.
+      Mantissa was set to 0.5 (instead of 1.0, therefore increase exponent by
+      1). Multiply by L=nChannels=64 by increasing exponent by another 6.
       => Increase exponent by 7
     */
     exponent += 7 + NRG_EXP_OFFSET;
 
     /* Combine mantissa and exponent and write back the result */
-    h_sbr_data->iEnvelope[i] = (FIXP_SGL)(((LONG)mantissa & MASK_M) | (exponent & MASK_E));
-
+    h_sbr_data->iEnvelope[i] =
+        ((FIXP_SGL)((SHORT)(FIXP_SGL)mantissa & MASK_M)) +
+        (FIXP_SGL)((SHORT)(FIXP_SGL)exponent & MASK_E);
   }
 }
 
-
 /*!
   \brief   Build new reference energies from old ones and delta coded data
 */
-static void
-deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                                  HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                                  HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
+static void deltaToLinearPcmEnvelopeDecoding(
+    HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
+    HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
 {
   int i, domain, no_of_bands, band, freqRes;
 
   FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
   FIXP_SGL *ptr_nrg = h_sbr_data->iEnvelope;
 
-  int offset = 2 * hHeaderData->freqBandData.nSfb[0] - hHeaderData->freqBandData.nSfb[1];
+  int offset =
+      2 * hHeaderData->freqBandData.nSfb[0] - hHeaderData->freqBandData.nSfb[1];
 
   for (i = 0; i < h_sbr_data->frameInfo.nEnvelopes; i++) {
     domain = h_sbr_data->domain_vec[i];
@@ -759,22 +782,18 @@ deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< S
 
     FDK_ASSERT(no_of_bands < (64));
 
-    if (domain == 0)
-    {
+    if (domain == 0) {
       mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, 0, freqRes);
       ptr_nrg++;
-      for (band = 1; band < no_of_bands; band++)
-      {
-        *ptr_nrg = *ptr_nrg + *(ptr_nrg-1);
+      for (band = 1; band < no_of_bands; band++) {
+        *ptr_nrg = *ptr_nrg + *(ptr_nrg - 1);
         mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
         ptr_nrg++;
       }
-    }
-    else
-    {
-      for (band = 0; band < no_of_bands; band++)
-      {
-        *ptr_nrg = *ptr_nrg + sfb_nrg_prev[indexLow2High(offset, band, freqRes)];
+    } else {
+      for (band = 0; band < no_of_bands; band++) {
+        *ptr_nrg =
+            *ptr_nrg + sfb_nrg_prev[indexLow2High(offset, band, freqRes)];
         mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
         ptr_nrg++;
       }
@@ -782,14 +801,13 @@ deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< S
   }
 }
 
-
 /*!
   \brief   Build new noise levels from old ones and delta coded data
 */
-static void
-decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
-                        HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
-                        HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
+static void decodeNoiseFloorlevels(
+    HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
+    HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
+    HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
 {
   int i;
   int nNfb = hHeaderData->freqBandData.nNfb;
@@ -803,8 +821,7 @@ decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static cont
       noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
       h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
     }
-  }
-  else {
+  } else {
     for (i = 0; i < nNfb; i++) {
       h_sbr_data->sbrNoiseFloorLevel[i] += h_prev_data->prevNoiseLevel[i];
     }
@@ -816,14 +833,14 @@ decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static cont
   if (nNoiseFloorEnvelopes > 1) {
     if (h_sbr_data->domain_vec_noise[1] == 0) {
       FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[nNfb];
-      for (i = nNfb + 1; i < 2*nNfb; i++) {
+      for (i = nNfb + 1; i < 2 * nNfb; i++) {
         noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
         h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
       }
-    }
-    else {
+    } else {
       for (i = 0; i < nNfb; i++) {
-        h_sbr_data->sbrNoiseFloorLevel[i + nNfb] += h_sbr_data->sbrNoiseFloorLevel[i];
+        h_sbr_data->sbrNoiseFloorLevel[i + nNfb] +=
+            h_sbr_data->sbrNoiseFloorLevel[i];
       }
     }
   }
@@ -832,21 +849,20 @@ decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static cont
 
   /* Update prevNoiseLevel with the last noise envelope */
   for (i = 0; i < nNfb; i++)
-    h_prev_data->prevNoiseLevel[i] = h_sbr_data->sbrNoiseFloorLevel[i + nNfb*(nNoiseFloorEnvelopes-1)];
-
+    h_prev_data->prevNoiseLevel[i] =
+        h_sbr_data->sbrNoiseFloorLevel[i + nNfb * (nNoiseFloorEnvelopes - 1)];
 
   /* Requantize the noise floor levels in COUPLING_OFF-mode */
   if (!h_sbr_data->coupling) {
     int nf_e;
 
-    for (i = 0; i < nNoiseFloorEnvelopes*nNfb; i++) {
+    for (i = 0; i < nNoiseFloorEnvelopes * nNfb; i++) {
       nf_e = 6 - (LONG)h_sbr_data->sbrNoiseFloorLevel[i] + 1 + NOISE_EXP_OFFSET;
       /* +1 to compensate for a mantissa of 0.5 instead of 1.0 */
 
       h_sbr_data->sbrNoiseFloorLevel[i] =
-        (FIXP_SGL)( ((LONG)FL2FXCONST_SGL(0.5f)) +  /* mantissa */
-                  (nf_e & MASK_E) ); /* exponent */
-
+          (FIXP_SGL)(((LONG)FL2FXCONST_SGL(0.5f)) + /* mantissa */
+                     (nf_e & MASK_E));              /* exponent */
     }
   }
 }