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, 401 insertions, 364 deletions

diff --git a/libAACenc/src/block_switch.cpp b/libAACenc/src/block_switch.cpp
index 7b3e275..c132253 100644
--- a/libAACenc/src/block_switch.cpp
+++ b/libAACenc/src/block_switch.cpp
@@ -1,74 +1,85 @@
-
-/* -----------------------------------------------------------------------------------------------------------
+/* -----------------------------------------------------------------------------
 Software License for The Fraunhofer FDK AAC Codec Library for Android
 
-© Copyright  1995 - 2013 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,460 +90,488 @@ Am Wolfsmantel 33
 
 www.iis.fraunhofer.de/amm
 amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
+----------------------------------------------------------------------------- */
 
-/*****************************  MPEG-4 AAC Encoder  **************************
+/**************************** AAC encoder library ******************************
 
    Author(s):   M. Werner, Tobias Chalupka
+
    Description: Block switching
 
-******************************************************************************/
+*******************************************************************************/
 
 /****************** Includes *****************************/
 
 #include "block_switch.h"
 #include "genericStds.h"
 
-
 #define LOWOV_WINDOW _LOWOV_WINDOW
 
 /**************** internal function prototypes ***********/
 
-static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx);
+static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[],
+                                          const INT blSwWndIdx);
 
 static void FDKaacEnc_CalcWindowEnergy(
-        BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl,
-        INT                      windowLen,
-        const INT_PCM           *pTimeSignal
-        );
+    BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen,
+    const INT_PCM *pTimeSignal);
 
 /****************** Constants *****************************/
-/*                                                LONG         START        SHORT         STOP         LOWOV                  */
-static const INT blockType2windowShape[2][5] = { {SINE_WINDOW, KBD_WINDOW,  WRONG_WINDOW, SINE_WINDOW, KBD_WINDOW},     /* LD */
-                                                 {KBD_WINDOW,  SINE_WINDOW, SINE_WINDOW,  KBD_WINDOW,  WRONG_WINDOW} }; /* LC */
+/*                                                LONG         START
+ * SHORT         STOP         LOWOV                  */
+static const INT blockType2windowShape[2][5] = {
+    {SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW, SINE_WINDOW, KBD_WINDOW},  /* LD */
+    {KBD_WINDOW, SINE_WINDOW, SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW}}; /* LC */
 
 /* IIR high pass coeffs */
 
 #ifndef SINETABLE_16BIT
 
-static const FIXP_DBL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]=
-{
-  FL2FXCONST_DBL(-0.5095),FL2FXCONST_DBL(0.7548)
-};
+static const FIXP_DBL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN] = {
+    FL2FXCONST_DBL(-0.5095), FL2FXCONST_DBL(0.7548)};
 
-static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f);                   /* factor for accumulating filtered window energies */
+static const FIXP_DBL accWindowNrgFac =
+    FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
 static const FIXP_DBL oneMinusAccWindowNrgFac = FL2FXCONST_DBL(0.7f);
-/* static const float attackRatio = 10.0; */                                    /* lower ratio limit for attacks */
-static const FIXP_DBL invAttackRatio = FL2FXCONST_DBL(0.1f);                    /* inverted lower ratio limit for attacks */
+/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
+static const FIXP_DBL invAttackRatio =
+    FL2FXCONST_DBL(0.1f); /* inverted lower ratio limit for attacks */
 
-/* The next constants are scaled, because they are used for comparison with scaled values*/
+/* The next constants are scaled, because they are used for comparison with
+ * scaled values*/
 /* minimum energy for attacks */
-static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
+static const FIXP_DBL minAttackNrg =
+    (FL2FXCONST_DBL(1e+6f * NORM_PCM_ENERGY) >>
+     BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
 
 #else
 
-static const FIXP_SGL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]=
-{
-  FL2FXCONST_SGL(-0.5095),FL2FXCONST_SGL(0.7548)
-};
+static const FIXP_SGL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN] = {
+    FL2FXCONST_SGL(-0.5095), FL2FXCONST_SGL(0.7548)};
 
-static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f);                   /* factor for accumulating filtered window energies */
+static const FIXP_DBL accWindowNrgFac =
+    FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
 static const FIXP_SGL oneMinusAccWindowNrgFac = FL2FXCONST_SGL(0.7f);
-/* static const float attackRatio = 10.0; */                                    /* lower ratio limit for attacks */
-static const FIXP_SGL invAttackRatio = FL2FXCONST_SGL(0.1f);                    /* inverted lower ratio limit for attacks */
+/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
+static const FIXP_SGL invAttackRatio =
+    FL2FXCONST_SGL(0.1f); /* inverted lower ratio limit for attacks */
 /* minimum energy for attacks */
-static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
+static const FIXP_DBL minAttackNrg =
+    (FL2FXCONST_DBL(1e+6f * NORM_PCM_ENERGY) >>
+     BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
 
 #endif
 
 /**************** internal function prototypes ***********/
 
 /****************** Routines ****************************/
-void FDKaacEnc_InitBlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay)
-{
-  FDKmemclear (blockSwitchingControl, sizeof(BLOCK_SWITCHING_CONTROL));
+void FDKaacEnc_InitBlockSwitching(
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay) {
+  FDKmemclear(blockSwitchingControl, sizeof(BLOCK_SWITCHING_CONTROL));
 
-  if (isLowDelay)
-  {
+  if (isLowDelay) {
     blockSwitchingControl->nBlockSwitchWindows = 4;
-    blockSwitchingControl->allowShortFrames    = 0;
-    blockSwitchingControl->allowLookAhead      = 0;
-  }
-  else
-  {
+    blockSwitchingControl->allowShortFrames = 0;
+    blockSwitchingControl->allowLookAhead = 0;
+  } else {
     blockSwitchingControl->nBlockSwitchWindows = 8;
-    blockSwitchingControl->allowShortFrames    = 1;
-    blockSwitchingControl->allowLookAhead      = 1;
+    blockSwitchingControl->allowShortFrames = 1;
+    blockSwitchingControl->allowLookAhead = 1;
   }
 
-  blockSwitchingControl->noOfGroups            = MAX_NO_OF_GROUPS;
+  blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
 
   /* Initialize startvalue for blocktype */
-  blockSwitchingControl->lastWindowSequence    = LONG_WINDOW;
-  blockSwitchingControl->windowShape           = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence];
-
+  blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
+  blockSwitchingControl->windowShape =
+      blockType2windowShape[blockSwitchingControl->allowShortFrames]
+                           [blockSwitchingControl->lastWindowSequence];
 }
 
-static const INT suggestedGroupingTable[TRANS_FAC][MAX_NO_OF_GROUPS] =
-{
-    /* Attack in Window 0 */ {1,  3,  3,  1},
-    /* Attack in Window 1 */ {1,  1,  3,  3},
-    /* Attack in Window 2 */ {2,  1,  3,  2},
-    /* Attack in Window 3 */ {3,  1,  3,  1},
-    /* Attack in Window 4 */ {3,  1,  1,  3},
-    /* Attack in Window 5 */ {3,  2,  1,  2},
-    /* Attack in Window 6 */ {3,  3,  1,  1},
-    /* Attack in Window 7 */ {3,  3,  1,  1}
-};
-
-/* change block type depending on current blocktype and whether there's an attack */
+static const INT suggestedGroupingTable[TRANS_FAC][MAX_NO_OF_GROUPS] = {
+    /* Attack in Window 0 */ {1, 3, 3, 1},
+    /* Attack in Window 1 */ {1, 1, 3, 3},
+    /* Attack in Window 2 */ {2, 1, 3, 2},
+    /* Attack in Window 3 */ {3, 1, 3, 1},
+    /* Attack in Window 4 */ {3, 1, 1, 3},
+    /* Attack in Window 5 */ {3, 2, 1, 2},
+    /* Attack in Window 6 */ {3, 3, 1, 1},
+    /* Attack in Window 7 */ {3, 3, 1, 1}};
+
+/* change block type depending on current blocktype and whether there's an
+ * attack */
 /* assume no look-ahead */
-static const INT chgWndSq[2][N_BLOCKTYPES] =
-{
-  /*             LONG WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW,  LOWOV_WINDOW, WRONG_WINDOW */
-  /*no attack*/ {LONG_WINDOW,  STOP_WINDOW,  WRONG_WINDOW, LONG_WINDOW,  STOP_WINDOW , WRONG_WINDOW },
-  /*attack   */ {START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW }
-};
-
-/* change block type depending on current blocktype and whether there's an attack */
+static const INT chgWndSq[2][N_BLOCKTYPES] = {
+    /*             LONG WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW,
+       LOWOV_WINDOW, WRONG_WINDOW */
+    /*no attack*/ {LONG_WINDOW, STOP_WINDOW, WRONG_WINDOW, LONG_WINDOW,
+                   STOP_WINDOW, WRONG_WINDOW},
+    /*attack   */ {START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, START_WINDOW,
+                   LOWOV_WINDOW, WRONG_WINDOW}};
+
+/* change block type depending on current blocktype and whether there's an
+ * attack */
 /* assume look-ahead */
-static const INT chgWndSqLkAhd[2][2][N_BLOCKTYPES] =
-{
-  /*attack         LONG WINDOW    START_WINDOW   SHORT_WINDOW   STOP_WINDOW   LOWOV_WINDOW, WRONG_WINDOW */  /* last attack */
-  /*no attack*/ { {LONG_WINDOW,   SHORT_WINDOW,  STOP_WINDOW,   LONG_WINDOW,  WRONG_WINDOW, WRONG_WINDOW},   /* no attack   */
-  /*attack   */   {START_WINDOW,  SHORT_WINDOW,  SHORT_WINDOW,  START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} }, /* no attack   */
-  /*no attack*/ { {LONG_WINDOW,   SHORT_WINDOW,  SHORT_WINDOW,  LONG_WINDOW,  WRONG_WINDOW, WRONG_WINDOW},   /* attack      */
-  /*attack   */   {START_WINDOW,  SHORT_WINDOW,  SHORT_WINDOW,  START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} }  /* attack      */
+static const INT chgWndSqLkAhd[2][2][N_BLOCKTYPES] = {
+    /*attack         LONG WINDOW    START_WINDOW   SHORT_WINDOW   STOP_WINDOW   LOWOV_WINDOW, WRONG_WINDOW */ /* last attack */
+    /*no attack*/ {
+        {LONG_WINDOW, SHORT_WINDOW, STOP_WINDOW, LONG_WINDOW, WRONG_WINDOW,
+         WRONG_WINDOW}, /* no attack   */
+        /*attack   */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW,
+                       WRONG_WINDOW, WRONG_WINDOW}}, /* no attack   */
+    /*no attack*/ {{LONG_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LONG_WINDOW,
+                    WRONG_WINDOW, WRONG_WINDOW}, /* attack      */
+                   /*attack   */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW,
+                                  START_WINDOW, WRONG_WINDOW,
+                                  WRONG_WINDOW}} /* attack      */
 };
 
-int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, const INT granuleLength, const int isLFE, const INT_PCM *pTimeSignal)
-{
-    UINT i;
-    FIXP_DBL enM1, enMax;
-
-    UINT nBlockSwitchWindows = blockSwitchingControl->nBlockSwitchWindows;
-
-    /* for LFE : only LONG window allowed */
-    if (isLFE) {
-
-      /* case LFE: */
-      /* only long blocks, always use sine windows (MPEG2 AAC, MPEG4 AAC) */
-      blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
-      blockSwitchingControl->windowShape    = SINE_WINDOW;
-      blockSwitchingControl->noOfGroups     = 1;
-      blockSwitchingControl->groupLen[0]    = 1;
-
-      return(0);
-    };
-
-    /* Save current attack index as last attack index */
-    blockSwitchingControl->lastattack = blockSwitchingControl->attack;
-    blockSwitchingControl->lastAttackIndex = blockSwitchingControl->attackIndex;
-
-    /* Save current window energy as last window energy */
-    FDKmemcpy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->windowNrg[1], sizeof(blockSwitchingControl->windowNrg[0]));
-    FDKmemcpy(blockSwitchingControl->windowNrgF[0], blockSwitchingControl->windowNrgF[1], sizeof(blockSwitchingControl->windowNrgF[0]));
-
-    if (blockSwitchingControl->allowShortFrames)
-    {
-      /* Calculate suggested grouping info for the last frame */
-
-      /* Reset grouping info */
-      FDKmemclear (blockSwitchingControl->groupLen, sizeof(blockSwitchingControl->groupLen));
-
-      /* Set grouping info */
-      blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
-
-      FDKmemcpy(blockSwitchingControl->groupLen, suggestedGroupingTable[blockSwitchingControl->lastAttackIndex], sizeof(blockSwitchingControl->groupLen));
-
-      if (blockSwitchingControl->attack == TRUE)
-          blockSwitchingControl->maxWindowNrg = FDKaacEnc_GetWindowEnergy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->lastAttackIndex);
-      else
-          blockSwitchingControl->maxWindowNrg = FL2FXCONST_DBL(0.0);
-
-    }
-
-
-    /* Calculate unfiltered and filtered energies in subwindows and combine to segments */
-    FDKaacEnc_CalcWindowEnergy(blockSwitchingControl, granuleLength>>(nBlockSwitchWindows==4? 2:3 ), pTimeSignal);
-
-    /* now calculate if there is an attack */
-
-    /* reset attack */
-    blockSwitchingControl->attack = FALSE;
+int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl,
+                             const INT granuleLength, const int isLFE,
+                             const INT_PCM *pTimeSignal) {
+  UINT i;
+  FIXP_DBL enM1, enMax;
+
+  UINT nBlockSwitchWindows = blockSwitchingControl->nBlockSwitchWindows;
+
+  /* for LFE : only LONG window allowed */
+  if (isLFE) {
+    /* case LFE: */
+    /* only long blocks, always use sine windows (MPEG2 AAC, MPEG4 AAC) */
+    blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
+    blockSwitchingControl->windowShape = SINE_WINDOW;
+    blockSwitchingControl->noOfGroups = 1;
+    blockSwitchingControl->groupLen[0] = 1;
+
+    return (0);
+  };
+
+  /* Save current attack index as last attack index */
+  blockSwitchingControl->lastattack = blockSwitchingControl->attack;
+  blockSwitchingControl->lastAttackIndex = blockSwitchingControl->attackIndex;
+
+  /* Save current window energy as last window energy */
+  FDKmemcpy(blockSwitchingControl->windowNrg[0],
+            blockSwitchingControl->windowNrg[1],
+            sizeof(blockSwitchingControl->windowNrg[0]));
+  FDKmemcpy(blockSwitchingControl->windowNrgF[0],
+            blockSwitchingControl->windowNrgF[1],
+            sizeof(blockSwitchingControl->windowNrgF[0]));
+
+  if (blockSwitchingControl->allowShortFrames) {
+    /* Calculate suggested grouping info for the last frame */
+
+    /* Reset grouping info */
+    FDKmemclear(blockSwitchingControl->groupLen,
+                sizeof(blockSwitchingControl->groupLen));
+
+    /* Set grouping info */
+    blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
+
+    FDKmemcpy(blockSwitchingControl->groupLen,
+              suggestedGroupingTable[blockSwitchingControl->lastAttackIndex],
+              sizeof(blockSwitchingControl->groupLen));
+
+    if (blockSwitchingControl->attack == TRUE)
+      blockSwitchingControl->maxWindowNrg =
+          FDKaacEnc_GetWindowEnergy(blockSwitchingControl->windowNrg[0],
+                                    blockSwitchingControl->lastAttackIndex);
+    else
+      blockSwitchingControl->maxWindowNrg = FL2FXCONST_DBL(0.0);
+  }
 
-    /* look for attack */
-    enMax = FL2FXCONST_DBL(0.0f);
-    enM1 = blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1];
+  /* Calculate unfiltered and filtered energies in subwindows and combine to
+   * segments */
+  FDKaacEnc_CalcWindowEnergy(
+      blockSwitchingControl,
+      granuleLength >> (nBlockSwitchWindows == 4 ? 2 : 3), pTimeSignal);
 
-    for (i=0; i<nBlockSwitchWindows; i++) {
-        FIXP_DBL tmp = fMultDiv2(oneMinusAccWindowNrgFac, blockSwitchingControl->accWindowNrg);
-        blockSwitchingControl->accWindowNrg = fMultAdd(tmp, accWindowNrgFac, enM1) ;
+  /* now calculate if there is an attack */
 
-        if (fMult(blockSwitchingControl->windowNrgF[1][i],invAttackRatio) > blockSwitchingControl->accWindowNrg ) {
-            blockSwitchingControl->attack = TRUE;
-            blockSwitchingControl->attackIndex = i;
-        }
-        enM1 = blockSwitchingControl->windowNrgF[1][i];
-        enMax = fixMax(enMax, enM1);
-    }
+  /* reset attack */
+  blockSwitchingControl->attack = FALSE;
 
+  /* look for attack */
+  enMax = FL2FXCONST_DBL(0.0f);
+  enM1 = blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows - 1];
 
-    if (enMax < minAttackNrg) blockSwitchingControl->attack = FALSE;
+  for (i = 0; i < nBlockSwitchWindows; i++) {
+    FIXP_DBL tmp =
+        fMultDiv2(oneMinusAccWindowNrgFac, blockSwitchingControl->accWindowNrg);
+    blockSwitchingControl->accWindowNrg = fMultAdd(tmp, accWindowNrgFac, enM1);
 
-    /* Check if attack spreads over frame border */
-    if((blockSwitchingControl->attack == FALSE) && (blockSwitchingControl->lastattack == TRUE)) {
-        /* if attack is in last window repeat SHORT_WINDOW */
-        if ( ((blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1]>>4) > fMult((FIXP_DBL)(10<<(DFRACT_BITS-1-4)), blockSwitchingControl->windowNrgF[1][1]))
-           && (blockSwitchingControl->lastAttackIndex == (INT)nBlockSwitchWindows-1)
-        )
-        {
-            blockSwitchingControl->attack = TRUE;
-            blockSwitchingControl->attackIndex = 0;
-        }
+    if (fMult(blockSwitchingControl->windowNrgF[1][i], invAttackRatio) >
+        blockSwitchingControl->accWindowNrg) {
+      blockSwitchingControl->attack = TRUE;
+      blockSwitchingControl->attackIndex = i;
     }
+    enM1 = blockSwitchingControl->windowNrgF[1][i];
+    enMax = fixMax(enMax, enM1);
+  }
 
-
-    if(blockSwitchingControl->allowLookAhead)
-    {
-
-
-      blockSwitchingControl->lastWindowSequence =
-        chgWndSqLkAhd[blockSwitchingControl->lastattack][blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence];
-    }
-    else
-    {
-      /* Low Delay */
-      blockSwitchingControl->lastWindowSequence =
-        chgWndSq[blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence];
+  if (enMax < minAttackNrg) blockSwitchingControl->attack = FALSE;
+
+  /* Check if attack spreads over frame border */
+  if ((blockSwitchingControl->attack == FALSE) &&
+      (blockSwitchingControl->lastattack == TRUE)) {
+    /* if attack is in last window repeat SHORT_WINDOW */
+    if (((blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows - 1] >> 4) >
+         fMult((FIXP_DBL)(10 << (DFRACT_BITS - 1 - 4)),
+               blockSwitchingControl->windowNrgF[1][1])) &&
+        (blockSwitchingControl->lastAttackIndex ==
+         (INT)nBlockSwitchWindows - 1)) {
+      blockSwitchingControl->attack = TRUE;
+      blockSwitchingControl->attackIndex = 0;
     }
+  }
 
+  if (blockSwitchingControl->allowLookAhead) {
+    blockSwitchingControl->lastWindowSequence =
+        chgWndSqLkAhd[blockSwitchingControl->lastattack]
+                     [blockSwitchingControl->attack]
+                     [blockSwitchingControl->lastWindowSequence];
+  } else {
+    /* Low Delay */
+    blockSwitchingControl->lastWindowSequence =
+        chgWndSq[blockSwitchingControl->attack]
+                [blockSwitchingControl->lastWindowSequence];
+  }
 
-    /* update window shape */
-    blockSwitchingControl->windowShape = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence];
+  /* update window shape */
+  blockSwitchingControl->windowShape =
+      blockType2windowShape[blockSwitchingControl->allowShortFrames]
+                           [blockSwitchingControl->lastWindowSequence];
 
-    return(0);
+  return (0);
 }
 
-
-
-static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx)
-{
-/* For coherency, change FDKaacEnc_GetWindowEnergy() to calcluate the energy for a block switching analysis windows,
-   not for a short block. The same is done FDKaacEnc_CalcWindowEnergy(). The result of FDKaacEnc_GetWindowEnergy()
-   is used for a comparision of the max energy of left/right channel. */
+static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[],
+                                          const INT blSwWndIdx) {
+  /* For coherency, change FDKaacEnc_GetWindowEnergy() to calcluate the energy
+     for a block switching analysis windows, not for a short block. The same is
+     done FDKaacEnc_CalcWindowEnergy(). The result of
+     FDKaacEnc_GetWindowEnergy() is used for a comparision of the max energy of
+     left/right channel. */
 
   return in[blSwWndIdx];
-
 }
 
-static void FDKaacEnc_CalcWindowEnergy(BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen, const INT_PCM *pTimeSignal)
-{
-    INT  i;
-    UINT w;
-
-    FIXP_SGL hiPassCoeff0 = hiPassCoeff[0];
-    FIXP_SGL hiPassCoeff1 = hiPassCoeff[1];
+static void FDKaacEnc_CalcWindowEnergy(
+    BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen,
+    const INT_PCM *pTimeSignal) {
+  INT i;
+  UINT w;
 
-    /* sum up scalarproduct of timesignal as windowed Energies */
-    for (w=0; w < blockSwitchingControl->nBlockSwitchWindows; w++) {
+#ifndef SINETABLE_16BIT
+  const FIXP_DBL hiPassCoeff0 = hiPassCoeff[0];
+  const FIXP_DBL hiPassCoeff1 = hiPassCoeff[1];
+#else
+  const FIXP_SGL hiPassCoeff0 = hiPassCoeff[0];
+  const FIXP_SGL hiPassCoeff1 = hiPassCoeff[1];
+#endif
 
-        FIXP_DBL temp_windowNrg  = FL2FXCONST_DBL(0.0f);
-        FIXP_DBL temp_windowNrgF = FL2FXCONST_DBL(0.0f);
-        FIXP_DBL temp_iirState0  = blockSwitchingControl->iirStates[0];
-        FIXP_DBL temp_iirState1  = blockSwitchingControl->iirStates[1];
+  FIXP_DBL temp_iirState0 = blockSwitchingControl->iirStates[0];
+  FIXP_DBL temp_iirState1 = blockSwitchingControl->iirStates[1];
 
-        /* windowNrg = sum(timesample^2) */
-        for(i=0;i<windowLen;i++)
-        {
+  /* sum up scalarproduct of timesignal as windowed Energies */
+  for (w = 0; w < blockSwitchingControl->nBlockSwitchWindows; w++) {
+    ULONG temp_windowNrg = 0x0;
+    ULONG temp_windowNrgF = 0x0;
 
-            FIXP_DBL tempUnfiltered, tempFiltred, t1, t2;
-            /* tempUnfiltered is scaled with 1 to prevent overflows during calculation of tempFiltred */
+    /* windowNrg = sum(timesample^2) */
+    for (i = 0; i < windowLen; i++) {
+      FIXP_DBL tempUnfiltered, t1, t2;
+      /* tempUnfiltered is scaled with 1 to prevent overflows during calculation
+       * of tempFiltred */
 #if SAMPLE_BITS == DFRACT_BITS
-            tempUnfiltered = (FIXP_DBL) *pTimeSignal++ >> 1;
+      tempUnfiltered = (FIXP_DBL)*pTimeSignal++ >> 1;
 #else
-            tempUnfiltered = (FIXP_DBL) *pTimeSignal++ << (DFRACT_BITS-SAMPLE_BITS-1);
+      tempUnfiltered = (FIXP_DBL)*pTimeSignal++
+                       << (DFRACT_BITS - SAMPLE_BITS - 1);
 #endif
-            t1 = fMultDiv2(hiPassCoeff1, tempUnfiltered-temp_iirState0);
-            t2 = fMultDiv2(hiPassCoeff0, temp_iirState1);
-            tempFiltred = (t1 - t2) << 1;
-
-            temp_iirState0 = tempUnfiltered;
-            temp_iirState1 = tempFiltred;
-
-            /* subtract 2 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT)
-             * because tempUnfiltered was already scaled with 1 (is 2 after squaring)
-             * subtract 1 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT)
-             * because of fMultDiv2 is doing a scaling by one */
-            temp_windowNrg += fPow2Div2(tempUnfiltered) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
-            temp_windowNrgF += fPow2Div2(tempFiltred) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
-        }
-        blockSwitchingControl->windowNrg[1][w]  = temp_windowNrg;
-        blockSwitchingControl->windowNrgF[1][w] = temp_windowNrgF;
-        blockSwitchingControl->iirStates[0]     = temp_iirState0;
-        blockSwitchingControl->iirStates[1]     = temp_iirState1;
+      t1 = fMultDiv2(hiPassCoeff1, tempUnfiltered - temp_iirState0);
+      t2 = fMultDiv2(hiPassCoeff0, temp_iirState1);
+      temp_iirState0 = tempUnfiltered;
+      temp_iirState1 = (t1 - t2) << 1;
+
+      temp_windowNrg += (LONG)fPow2Div2(temp_iirState0) >>
+                        (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
+      temp_windowNrgF += (LONG)fPow2Div2(temp_iirState1) >>
+                         (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
     }
+    blockSwitchingControl->windowNrg[1][w] =
+        (LONG)fMin(temp_windowNrg, (UINT)MAXVAL_DBL);
+    blockSwitchingControl->windowNrgF[1][w] =
+        (LONG)fMin(temp_windowNrgF, (UINT)MAXVAL_DBL);
+  }
+  blockSwitchingControl->iirStates[0] = temp_iirState0;
+  blockSwitchingControl->iirStates[1] = temp_iirState1;
 }
 
-
-static const UCHAR synchronizedBlockTypeTable[5][5] =
-{
-  /*                  LONG_WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW   LOWOV_WINDOW*/
-  /* LONG_WINDOW  */ {LONG_WINDOW,  START_WINDOW, SHORT_WINDOW, STOP_WINDOW,  LOWOV_WINDOW},
-  /* START_WINDOW */ {START_WINDOW, START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LOWOV_WINDOW},
-  /* SHORT_WINDOW */ {SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, WRONG_WINDOW},
-  /* STOP_WINDOW  */ {STOP_WINDOW,  SHORT_WINDOW, SHORT_WINDOW, STOP_WINDOW,  LOWOV_WINDOW},
-  /* LOWOV_WINDOW */ {LOWOV_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, LOWOV_WINDOW, LOWOV_WINDOW},
+static const UCHAR synchronizedBlockTypeTable[5][5] = {
+    /*                  LONG_WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW
+       LOWOV_WINDOW*/
+    /* LONG_WINDOW  */ {LONG_WINDOW, START_WINDOW, SHORT_WINDOW, STOP_WINDOW,
+                        LOWOV_WINDOW},
+    /* START_WINDOW */
+    {START_WINDOW, START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LOWOV_WINDOW},
+    /* SHORT_WINDOW */
+    {SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, WRONG_WINDOW},
+    /* STOP_WINDOW  */
+    {STOP_WINDOW, SHORT_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW},
+    /* LOWOV_WINDOW */
+    {LOWOV_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, LOWOV_WINDOW, LOWOV_WINDOW},
 };
 
-int FDKaacEnc_SyncBlockSwitching (
-      BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft,
-      BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight,
-      const INT nChannels,
-      const INT commonWindow )
-{
+int FDKaacEnc_SyncBlockSwitching(
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft,
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight, const INT nChannels,
+    const INT commonWindow) {
   UCHAR patchType = LONG_WINDOW;
 
-  if( nChannels == 2 && commonWindow == TRUE)
-  {
+  if (nChannels == 2 && commonWindow == TRUE) {
     /* could be better with a channel loop (need a handle to psy_data) */
     /* get suggested Block Types and synchronize */
-    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlLeft->lastWindowSequence];
-    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlRight->lastWindowSequence];
+    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlLeft
+                                                          ->lastWindowSequence];
+    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlRight
+                                                          ->lastWindowSequence];
 
-    /* sanity check (no change from low overlap window to short winow and vice versa) */
-    if (patchType == WRONG_WINDOW)
-      return -1; /* mixed up AAC-LC and AAC-LD */
+    /* sanity check (no change from low overlap window to short winow and vice
+     * versa) */
+    if (patchType == WRONG_WINDOW) return -1; /* mixed up AAC-LC and AAC-LD */
 
     /* Set synchronized Blocktype */
-    blockSwitchingControlLeft->lastWindowSequence  = patchType;
+    blockSwitchingControlLeft->lastWindowSequence = patchType;
     blockSwitchingControlRight->lastWindowSequence = patchType;
 
     /* update window shape */
-    blockSwitchingControlLeft->windowShape  = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlLeft->lastWindowSequence];
-    blockSwitchingControlRight->windowShape = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlRight->lastWindowSequence];
+    blockSwitchingControlLeft->windowShape =
+        blockType2windowShape[blockSwitchingControlLeft->allowShortFrames]
+                             [blockSwitchingControlLeft->lastWindowSequence];
+    blockSwitchingControlRight->windowShape =
+        blockType2windowShape[blockSwitchingControlLeft->allowShortFrames]
+                             [blockSwitchingControlRight->lastWindowSequence];
   }
 
-  if (blockSwitchingControlLeft->allowShortFrames)
-  {
+  if (blockSwitchingControlLeft->allowShortFrames) {
     int i;
 
-    if( nChannels == 2 )
-    {
-      if (commonWindow == TRUE)
-      {
+    if (nChannels == 2) {
+      if (commonWindow == TRUE) {
         /* Synchronize grouping info */
-        int windowSequenceLeftOld  = blockSwitchingControlLeft->lastWindowSequence;
-        int windowSequenceRightOld = blockSwitchingControlRight->lastWindowSequence;
+        int windowSequenceLeftOld =
+            blockSwitchingControlLeft->lastWindowSequence;
+        int windowSequenceRightOld =
+            blockSwitchingControlRight->lastWindowSequence;
 
         /* Long Blocks */
-        if(patchType != SHORT_WINDOW) {
+        if (patchType != SHORT_WINDOW) {
           /* Set grouping info */
-          blockSwitchingControlLeft->noOfGroups   = 1;
-          blockSwitchingControlRight->noOfGroups  = 1;
-          blockSwitchingControlLeft->groupLen[0]  = 1;
+          blockSwitchingControlLeft->noOfGroups = 1;
+          blockSwitchingControlRight->noOfGroups = 1;
+          blockSwitchingControlLeft->groupLen[0] = 1;
           blockSwitchingControlRight->groupLen[0] = 1;
 
-          for (i = 1; i < MAX_NO_OF_GROUPS; i++)
-          {
-            blockSwitchingControlLeft->groupLen[i]  = 0;
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
+            blockSwitchingControlLeft->groupLen[i] = 0;
             blockSwitchingControlRight->groupLen[i] = 0;
           }
         }
 
         /* Short Blocks */
         else {
-          /* in case all two channels were detected as short-blocks before syncing, use the grouping of channel with higher maxWindowNrg */
-          if( (windowSequenceLeftOld  == SHORT_WINDOW) &&
-	            (windowSequenceRightOld == SHORT_WINDOW) )
-          {
-            if(blockSwitchingControlLeft->maxWindowNrg > blockSwitchingControlRight->maxWindowNrg) {
-	            /* Left Channel wins */
-	            blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups;
-	            for (i = 0; i < MAX_NO_OF_GROUPS; i++){
-	              blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i];
-	            }
+          /* in case all two channels were detected as short-blocks before
+           * syncing, use the grouping of channel with higher maxWindowNrg */
+          if ((windowSequenceLeftOld == SHORT_WINDOW) &&
+              (windowSequenceRightOld == SHORT_WINDOW)) {
+            if (blockSwitchingControlLeft->maxWindowNrg >
+                blockSwitchingControlRight->maxWindowNrg) {
+              /* Left Channel wins */
+              blockSwitchingControlRight->noOfGroups =
+                  blockSwitchingControlLeft->noOfGroups;
+              for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+                blockSwitchingControlRight->groupLen[i] =
+                    blockSwitchingControlLeft->groupLen[i];
+              }
+            } else {
+              /* Right Channel wins */
+              blockSwitchingControlLeft->noOfGroups =
+                  blockSwitchingControlRight->noOfGroups;
+              for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+                blockSwitchingControlLeft->groupLen[i] =
+                    blockSwitchingControlRight->groupLen[i];
+              }
             }
-            else {
-	            /* Right Channel wins */
-	            blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups;
-	            for (i = 0; i < MAX_NO_OF_GROUPS; i++){
-	              blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i];
-	            }
-            }
-          }
-          else if ( (windowSequenceLeftOld  == SHORT_WINDOW) &&
-                    (windowSequenceRightOld != SHORT_WINDOW) )
-          {
+          } else if ((windowSequenceLeftOld == SHORT_WINDOW) &&
+                     (windowSequenceRightOld != SHORT_WINDOW)) {
             /* else use grouping of short-block channel */
-            blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups;
-            for (i = 0; i < MAX_NO_OF_GROUPS; i++){
-              blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i];
+            blockSwitchingControlRight->noOfGroups =
+                blockSwitchingControlLeft->noOfGroups;
+            for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+              blockSwitchingControlRight->groupLen[i] =
+                  blockSwitchingControlLeft->groupLen[i];
             }
-          }
-          else if ( (windowSequenceRightOld == SHORT_WINDOW) &&
-		                (windowSequenceLeftOld  != SHORT_WINDOW) )
-          {
-            blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups;
-            for (i = 0; i < MAX_NO_OF_GROUPS; i++){
-              blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i];
+          } else if ((windowSequenceRightOld == SHORT_WINDOW) &&
+                     (windowSequenceLeftOld != SHORT_WINDOW)) {
+            blockSwitchingControlLeft->noOfGroups =
+                blockSwitchingControlRight->noOfGroups;
+            for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+              blockSwitchingControlLeft->groupLen[i] =
+                  blockSwitchingControlRight->groupLen[i];
             }
           } else {
             /* syncing a start and stop window ... */
-            blockSwitchingControlLeft->noOfGroups  = blockSwitchingControlRight->noOfGroups  = 2;
-            blockSwitchingControlLeft->groupLen[0] = blockSwitchingControlRight->groupLen[0] = 4;
-            blockSwitchingControlLeft->groupLen[1] = blockSwitchingControlRight->groupLen[1] = 4;
+            blockSwitchingControlLeft->noOfGroups =
+                blockSwitchingControlRight->noOfGroups = 2;
+            blockSwitchingControlLeft->groupLen[0] =
+                blockSwitchingControlRight->groupLen[0] = 4;
+            blockSwitchingControlLeft->groupLen[1] =
+                blockSwitchingControlRight->groupLen[1] = 4;
           }
         } /* Short Blocks */
-      }
-      else {
+      } else {
         /* stereo, no common window */
-        if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){
-          blockSwitchingControlLeft->noOfGroups  = 1;
+        if (blockSwitchingControlLeft->lastWindowSequence != SHORT_WINDOW) {
+          blockSwitchingControlLeft->noOfGroups = 1;
           blockSwitchingControlLeft->groupLen[0] = 1;
-          for (i = 1; i < MAX_NO_OF_GROUPS; i++)
-          {
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
             blockSwitchingControlLeft->groupLen[i] = 0;
           }
         }
-        if (blockSwitchingControlRight->lastWindowSequence!=SHORT_WINDOW){
-          blockSwitchingControlRight->noOfGroups  = 1;
+        if (blockSwitchingControlRight->lastWindowSequence != SHORT_WINDOW) {
+          blockSwitchingControlRight->noOfGroups = 1;
           blockSwitchingControlRight->groupLen[0] = 1;
-          for (i = 1; i < MAX_NO_OF_GROUPS; i++)
-          {
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
             blockSwitchingControlRight->groupLen[i] = 0;
           }
         }
       } /* common window */
     } else {
       /* Mono */
-      if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){
-        blockSwitchingControlLeft->noOfGroups  = 1;
+      if (blockSwitchingControlLeft->lastWindowSequence != SHORT_WINDOW) {
+        blockSwitchingControlLeft->noOfGroups = 1;
         blockSwitchingControlLeft->groupLen[0] = 1;
 
-        for (i = 1; i < MAX_NO_OF_GROUPS; i++)
-        {
+        for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
           blockSwitchingControlLeft->groupLen[i] = 0;
         }
       }
     }
   } /* allowShortFrames */
 
-
   /* Translate LOWOV_WINDOW block type to a meaningful window shape. */
-  if ( ! blockSwitchingControlLeft->allowShortFrames ) {
-    if ( blockSwitchingControlLeft->lastWindowSequence != LONG_WINDOW
-      && blockSwitchingControlLeft->lastWindowSequence != STOP_WINDOW )
-    {
+  if (!blockSwitchingControlLeft->allowShortFrames) {
+    if (blockSwitchingControlLeft->lastWindowSequence != LONG_WINDOW &&
+        blockSwitchingControlLeft->lastWindowSequence != STOP_WINDOW) {
       blockSwitchingControlLeft->lastWindowSequence = LONG_WINDOW;
       blockSwitchingControlLeft->windowShape = LOL_WINDOW;
     }
   }
   if (nChannels == 2) {
-    if ( ! blockSwitchingControlRight->allowShortFrames ) {
-      if ( blockSwitchingControlRight->lastWindowSequence != LONG_WINDOW
-        && blockSwitchingControlRight->lastWindowSequence != STOP_WINDOW )
-      {
+    if (!blockSwitchingControlRight->allowShortFrames) {
+      if (blockSwitchingControlRight->lastWindowSequence != LONG_WINDOW &&
+          blockSwitchingControlRight->lastWindowSequence != STOP_WINDOW) {
         blockSwitchingControlRight->lastWindowSequence = LONG_WINDOW;
         blockSwitchingControlRight->windowShape = LOL_WINDOW;
       }
@@ -541,5 +580,3 @@ int FDKaacEnc_SyncBlockSwitching (
 
   return 0;
 }
-
-