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, 378 insertions, 452 deletions

diff --git a/libSBRenc/src/ps_bitenc.cpp b/libSBRenc/src/ps_bitenc.cpp
index 420ea15..e30af2a 100644
--- a/libSBRenc/src/ps_bitenc.cpp
+++ b/libSBRenc/src/ps_bitenc.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,37 +90,35 @@ Am Wolfsmantel 33
 
 www.iis.fraunhofer.de/amm
 amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************  MPEG Audio Encoder  ***************************
+----------------------------------------------------------------------------- */
 
-   Initial author:       N. Rettelbach
-   contents/description: Parametric Stereo bitstream encoder
+/**************************** SBR encoder library ******************************
 
-******************************************************************************/
+   Author(s):   N. Rettelbach
 
-#include "ps_main.h"
+   Description: Parametric Stereo bitstream encoder
 
+*******************************************************************************/
 
-#include "ps_const.h"
 #include "ps_bitenc.h"
 
-static
-inline UCHAR FDKsbrEnc_WriteBits_ps(HANDLE_FDK_BITSTREAM hBitStream, UINT value,
-                                    const UINT numberOfBits)
-{
+#include "ps_main.h"
+
+static inline UCHAR FDKsbrEnc_WriteBits_ps(HANDLE_FDK_BITSTREAM hBitStream,
+                                           UINT value,
+                                           const UINT numberOfBits) {
   /* hBitStream == NULL happens here intentionally */
-  if(hBitStream!=NULL){
+  if (hBitStream != NULL) {
     FDKwriteBits(hBitStream, value, numberOfBits);
   }
   return numberOfBits;
 }
 
-#define SI_SBR_EXTENSION_SIZE_BITS              4
-#define SI_SBR_EXTENSION_ESC_COUNT_BITS         8
-#define SI_SBR_EXTENSION_ID_BITS                2
-#define EXTENSION_ID_PS_CODING                  2
-#define PS_EXT_ID_V0                            0
+#define SI_SBR_EXTENSION_SIZE_BITS 4
+#define SI_SBR_EXTENSION_ESC_COUNT_BITS 8
+#define SI_SBR_EXTENSION_ID_BITS 2
+#define EXTENSION_ID_PS_CODING 2
+#define PS_EXT_ID_V0 0
 
 static const INT iidDeltaCoarse_Offset = 14;
 static const INT iidDeltaCoarse_MaxVal = 28;
@@ -117,499 +126,425 @@ static const INT iidDeltaFine_Offset = 30;
 static const INT iidDeltaFine_MaxVal = 60;
 
 /* PS Stereo Huffmantable: iidDeltaFreqCoarse */
-static const UINT iidDeltaFreqCoarse_Length[] =
-{
-  17,    17,    17,    17,    16,  15,    13,    10,     9,     7,
-   6,     5,     4,     3,     1,   3,     4,     5,     6,     6,
-   8,    11,    13,    14,    14,  15,    17,    18,    18
-};
-static const UINT iidDeltaFreqCoarse_Code[]  =
-{
-  0x0001fffb,  0x0001fffc,  0x0001fffd,  0x0001fffa,  0x0000fffc,  0x00007ffc,  0x00001ffd,  0x000003fe,  0x000001fe,  0x0000007e,
-  0x0000003c,  0x0000001d,  0x0000000d,  0x00000005,  0000000000,  0x00000004,  0x0000000c,  0x0000001c,  0x0000003d,  0x0000003e,
-  0x000000fe,  0x000007fe,  0x00001ffc,  0x00003ffc,  0x00003ffd,  0x00007ffd,  0x0001fffe,  0x0003fffe,  0x0003ffff
-};
+static const UINT iidDeltaFreqCoarse_Length[] = {
+    17, 17, 17, 17, 16, 15, 13, 10, 9,  7,  6,  5,  4,  3, 1,
+    3,  4,  5,  6,  6,  8,  11, 13, 14, 14, 15, 17, 18, 18};
+static const UINT iidDeltaFreqCoarse_Code[] = {
+    0x0001fffb, 0x0001fffc, 0x0001fffd, 0x0001fffa, 0x0000fffc, 0x00007ffc,
+    0x00001ffd, 0x000003fe, 0x000001fe, 0x0000007e, 0x0000003c, 0x0000001d,
+    0x0000000d, 0x00000005, 0000000000, 0x00000004, 0x0000000c, 0x0000001c,
+    0x0000003d, 0x0000003e, 0x000000fe, 0x000007fe, 0x00001ffc, 0x00003ffc,
+    0x00003ffd, 0x00007ffd, 0x0001fffe, 0x0003fffe, 0x0003ffff};
 
 /* PS Stereo Huffmantable: iidDeltaFreqFine */
-static const UINT iidDeltaFreqFine_Length[] =
-{
-  18,    18,    18,    18,    18,  18,    18,    18,    18,    17,
-  18,    17,    17,    16,    16,  15,    14,    14,    13,    12,
-  12,    11,    10,    10,     8,   7,     6,     5,     4,     3,
-   1,     3,     4,     5,     6,   7,     8,     9,    10,    11,
-  11,    12,    13,    14,    14,  15,    16,    16,    17,    17,
-  18,    17,    18,    18,    18,  18,    18,    18,    18,    18,
-  18
-};
-static const UINT iidDeltaFreqFine_Code[] =
-{
-  0x0001feb4,  0x0001feb5,  0x0001fd76,  0x0001fd77,  0x0001fd74,  0x0001fd75,  0x0001fe8a,  0x0001fe8b,  0x0001fe88,  0x0000fe80,
-  0x0001feb6,  0x0000fe82,  0x0000feb8,  0x00007f42,  0x00007fae,  0x00003faf,  0x00001fd1,  0x00001fe9,  0x00000fe9,  0x000007ea,
-  0x000007fb,  0x000003fb,  0x000001fb,  0x000001ff,  0x0000007c,  0x0000003c,  0x0000001c,  0x0000000c,  0000000000,  0x00000001,
-  0x00000001,  0x00000002,  0x00000001,  0x0000000d,  0x0000001d,  0x0000003d,  0x0000007d,  0x000000fc,  0x000001fc,  0x000003fc,
-  0x000003f4,  0x000007eb,  0x00000fea,  0x00001fea,  0x00001fd6,  0x00003fd0,  0x00007faf,  0x00007f43,  0x0000feb9,  0x0000fe83,
-  0x0001feb7,  0x0000fe81,  0x0001fe89,  0x0001fe8e,  0x0001fe8f,  0x0001fe8c,  0x0001fe8d,  0x0001feb2,  0x0001feb3,  0x0001feb0,
-  0x0001feb1
-};
+static const UINT iidDeltaFreqFine_Length[] = {
+    18, 18, 18, 18, 18, 18, 18, 18, 18, 17, 18, 17, 17, 16, 16, 15,
+    14, 14, 13, 12, 12, 11, 10, 10, 8,  7,  6,  5,  4,  3,  1,  3,
+    4,  5,  6,  7,  8,  9,  10, 11, 11, 12, 13, 14, 14, 15, 16, 16,
+    17, 17, 18, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18};
+static const UINT iidDeltaFreqFine_Code[] = {
+    0x0001feb4, 0x0001feb5, 0x0001fd76, 0x0001fd77, 0x0001fd74, 0x0001fd75,
+    0x0001fe8a, 0x0001fe8b, 0x0001fe88, 0x0000fe80, 0x0001feb6, 0x0000fe82,
+    0x0000feb8, 0x00007f42, 0x00007fae, 0x00003faf, 0x00001fd1, 0x00001fe9,
+    0x00000fe9, 0x000007ea, 0x000007fb, 0x000003fb, 0x000001fb, 0x000001ff,
+    0x0000007c, 0x0000003c, 0x0000001c, 0x0000000c, 0000000000, 0x00000001,
+    0x00000001, 0x00000002, 0x00000001, 0x0000000d, 0x0000001d, 0x0000003d,
+    0x0000007d, 0x000000fc, 0x000001fc, 0x000003fc, 0x000003f4, 0x000007eb,
+    0x00000fea, 0x00001fea, 0x00001fd6, 0x00003fd0, 0x00007faf, 0x00007f43,
+    0x0000feb9, 0x0000fe83, 0x0001feb7, 0x0000fe81, 0x0001fe89, 0x0001fe8e,
+    0x0001fe8f, 0x0001fe8c, 0x0001fe8d, 0x0001feb2, 0x0001feb3, 0x0001feb0,
+    0x0001feb1};
 
 /* PS Stereo Huffmantable: iidDeltaTimeCoarse */
-static const UINT iidDeltaTimeCoarse_Length[] =
-{
-  19,    19,    19,    20,    20,  20,    17,    15,    12,    10,
-   8,     6,     4,     2,     1,   3,     5,     7,     9,    11,
-  13,    14,    17,    19,    20,  20,    20,    20,    20
-};
-static const UINT iidDeltaTimeCoarse_Code[] =
-{
-  0x0007fff9,  0x0007fffa,  0x0007fffb,  0x000ffff8,  0x000ffff9,  0x000ffffa,  0x0001fffd,  0x00007ffe,  0x00000ffe,  0x000003fe,
-  0x000000fe,  0x0000003e,  0x0000000e,  0x00000002,  0000000000,  0x00000006,  0x0000001e,  0x0000007e,  0x000001fe,  0x000007fe,
-  0x00001ffe,  0x00003ffe,  0x0001fffc,  0x0007fff8,  0x000ffffb,  0x000ffffc,  0x000ffffd,  0x000ffffe,  0x000fffff
-};
+static const UINT iidDeltaTimeCoarse_Length[] = {
+    19, 19, 19, 20, 20, 20, 17, 15, 12, 10, 8,  6,  4,  2, 1,
+    3,  5,  7,  9,  11, 13, 14, 17, 19, 20, 20, 20, 20, 20};
+static const UINT iidDeltaTimeCoarse_Code[] = {
+    0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9, 0x000ffffa,
+    0x0001fffd, 0x00007ffe, 0x00000ffe, 0x000003fe, 0x000000fe, 0x0000003e,
+    0x0000000e, 0x00000002, 0000000000, 0x00000006, 0x0000001e, 0x0000007e,
+    0x000001fe, 0x000007fe, 0x00001ffe, 0x00003ffe, 0x0001fffc, 0x0007fff8,
+    0x000ffffb, 0x000ffffc, 0x000ffffd, 0x000ffffe, 0x000fffff};
 
 /* PS Stereo Huffmantable: iidDeltaTimeFine */
-static const UINT iidDeltaTimeFine_Length[] =
-{
-  16,    16,    16,    16,    16,  16,    16,    16,    16,    15,
-  15,    15,    15,    15,    15,  14,    14,    13,    13,    13,
-  12,    12,    11,    10,     9,   9,     7,     6,     5,     3,
-   1,     2,     5,     6,     7,   8,     9,    10,    11,    11,
-  12,    12,    13,    13,    14,  14,    15,    15,    15,    15,
-  16,    16,    16,    16,    16,  16,    16,    16,    16,    16,
-  16
-};
-static const UINT iidDeltaTimeFine_Code[] =
-{
-  0x00004ed4,  0x00004ed5,  0x00004ece,  0x00004ecf,  0x00004ecc,  0x00004ed6,  0x00004ed8,  0x00004f46,  0x00004f60,  0x00002718,
-  0x00002719,  0x00002764,  0x00002765,  0x0000276d,  0x000027b1,  0x000013b7,  0x000013d6,  0x000009c7,  0x000009e9,  0x000009ed,
-  0x000004ee,  0x000004f7,  0x00000278,  0x00000139,  0x0000009a,  0x0000009f,  0x00000020,  0x00000011,  0x0000000a,  0x00000003,
-  0x00000001,  0000000000,  0x0000000b,  0x00000012,  0x00000021,  0x0000004c,  0x0000009b,  0x0000013a,  0x00000279,  0x00000270,
-  0x000004ef,  0x000004e2,  0x000009ea,  0x000009d8,  0x000013d7,  0x000013d0,  0x000027b2,  0x000027a2,  0x0000271a,  0x0000271b,
-  0x00004f66,  0x00004f67,  0x00004f61,  0x00004f47,  0x00004ed9,  0x00004ed7,  0x00004ecd,  0x00004ed2,  0x00004ed3,  0x00004ed0,
-  0x00004ed1
-};
-
-static const INT iccDelta_Offset =  7;
+static const UINT iidDeltaTimeFine_Length[] = {
+    16, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 14,
+    14, 13, 13, 13, 12, 12, 11, 10, 9,  9,  7,  6,  5,  3,  1,  2,
+    5,  6,  7,  8,  9,  10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15,
+    15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16};
+static const UINT iidDeltaTimeFine_Code[] = {
+    0x00004ed4, 0x00004ed5, 0x00004ece, 0x00004ecf, 0x00004ecc, 0x00004ed6,
+    0x00004ed8, 0x00004f46, 0x00004f60, 0x00002718, 0x00002719, 0x00002764,
+    0x00002765, 0x0000276d, 0x000027b1, 0x000013b7, 0x000013d6, 0x000009c7,
+    0x000009e9, 0x000009ed, 0x000004ee, 0x000004f7, 0x00000278, 0x00000139,
+    0x0000009a, 0x0000009f, 0x00000020, 0x00000011, 0x0000000a, 0x00000003,
+    0x00000001, 0000000000, 0x0000000b, 0x00000012, 0x00000021, 0x0000004c,
+    0x0000009b, 0x0000013a, 0x00000279, 0x00000270, 0x000004ef, 0x000004e2,
+    0x000009ea, 0x000009d8, 0x000013d7, 0x000013d0, 0x000027b2, 0x000027a2,
+    0x0000271a, 0x0000271b, 0x00004f66, 0x00004f67, 0x00004f61, 0x00004f47,
+    0x00004ed9, 0x00004ed7, 0x00004ecd, 0x00004ed2, 0x00004ed3, 0x00004ed0,
+    0x00004ed1};
+
+static const INT iccDelta_Offset = 7;
 static const INT iccDelta_MaxVal = 14;
 /* PS Stereo Huffmantable: iccDeltaFreq */
-static const UINT iccDeltaFreq_Length[] =
-{
-  14,    14,    12,    10,     7,   5,     3,     1,     2,     4,
-   6,     8,     9,    11,    13
-};
-static const UINT iccDeltaFreq_Code[] =
-{
-  0x00003fff,  0x00003ffe,  0x00000ffe,  0x000003fe,  0x0000007e,  0x0000001e,  0x00000006,  0000000000,  0x00000002,  0x0000000e,
-  0x0000003e,  0x000000fe,  0x000001fe,  0x000007fe,  0x00001ffe
-};
+static const UINT iccDeltaFreq_Length[] = {14, 14, 12, 10, 7, 5,  3, 1,
+                                           2,  4,  6,  8,  9, 11, 13};
+static const UINT iccDeltaFreq_Code[] = {
+    0x00003fff, 0x00003ffe, 0x00000ffe, 0x000003fe, 0x0000007e,
+    0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
+    0x0000003e, 0x000000fe, 0x000001fe, 0x000007fe, 0x00001ffe};
 
 /* PS Stereo Huffmantable: iccDeltaTime */
-static const UINT iccDeltaTime_Length[] =
-{
-  14,    13,    11,     9,     7,   5,     3,     1,     2,     4,
-   6,     8,    10,    12,    14
-};
-static const UINT iccDeltaTime_Code[] =
-{
-  0x00003ffe,  0x00001ffe,  0x000007fe,  0x000001fe,  0x0000007e,  0x0000001e,  0x00000006,  0000000000,  0x00000002,  0x0000000e,
-  0x0000003e,  0x000000fe,  0x000003fe,  0x00000ffe,  0x00003fff
-};
-
-
+static const UINT iccDeltaTime_Length[] = {14, 13, 11, 9, 7,  5,  3, 1,
+                                           2,  4,  6,  8, 10, 12, 14};
+static const UINT iccDeltaTime_Code[] = {
+    0x00003ffe, 0x00001ffe, 0x000007fe, 0x000001fe, 0x0000007e,
+    0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
+    0x0000003e, 0x000000fe, 0x000003fe, 0x00000ffe, 0x00003fff};
 
 static const INT ipdDelta_Offset = 0;
 static const INT ipdDelta_MaxVal = 7;
 /* PS Stereo Huffmantable: ipdDeltaFreq */
-static const UINT ipdDeltaFreq_Length[] =
-{
-   1,     3,     4,     4,     4,   4,     4,     4
-};
-static const UINT ipdDeltaFreq_Code[] =
-{
-  0x00000001,  0000000000,  0x00000006,  0x00000004,  0x00000002,  0x00000003,  0x00000005,  0x00000007
-};
+static const UINT ipdDeltaFreq_Length[] = {1, 3, 4, 4, 4, 4, 4, 4};
+static const UINT ipdDeltaFreq_Code[] = {0x00000001, 0000000000, 0x00000006,
+                                         0x00000004, 0x00000002, 0x00000003,
+                                         0x00000005, 0x00000007};
 
 /* PS Stereo Huffmantable: ipdDeltaTime */
-static const UINT ipdDeltaTime_Length[] =
-{
-   1,     3,     4,     5,     5,   4,     4,     3
-};
-static const UINT ipdDeltaTime_Code[] =
-{
-  0x00000001,  0x00000002,  0x00000002,  0x00000003,  0x00000002,  0000000000,  0x00000003,  0x00000003
-};
-
+static const UINT ipdDeltaTime_Length[] = {1, 3, 4, 5, 5, 4, 4, 3};
+static const UINT ipdDeltaTime_Code[] = {0x00000001, 0x00000002, 0x00000002,
+                                         0x00000003, 0x00000002, 0000000000,
+                                         0x00000003, 0x00000003};
 
 static const INT opdDelta_Offset = 0;
 static const INT opdDelta_MaxVal = 7;
 /* PS Stereo Huffmantable: opdDeltaFreq */
-static const UINT opdDeltaFreq_Length[] =
-{
-   1,     3,     4,     4,     5,   5,     4,     3
-};
-static const UINT opdDeltaFreq_Code[] =
-{
-  0x00000001,  0x00000001,  0x00000006,  0x00000004,  0x0000000f,  0x0000000e,  0x00000005,  0000000000,
+static const UINT opdDeltaFreq_Length[] = {1, 3, 4, 4, 5, 5, 4, 3};
+static const UINT opdDeltaFreq_Code[] = {
+    0x00000001, 0x00000001, 0x00000006, 0x00000004,
+    0x0000000f, 0x0000000e, 0x00000005, 0000000000,
 };
 
 /* PS Stereo Huffmantable: opdDeltaTime */
-static const UINT opdDeltaTime_Length[] =
-{
-   1,     3,     4,     5,     5,   4,     4,     3
-};
-static const UINT opdDeltaTime_Code[] =
-{
-  0x00000001,  0x00000002,  0x00000001,  0x00000007,  0x00000006,  0000000000,  0x00000002,  0x00000003
-};
+static const UINT opdDeltaTime_Length[] = {1, 3, 4, 5, 5, 4, 4, 3};
+static const UINT opdDeltaTime_Code[] = {0x00000001, 0x00000002, 0x00000001,
+                                         0x00000007, 0x00000006, 0000000000,
+                                         0x00000002, 0x00000003};
 
-static INT getNoBands(const INT mode)
-{
+static INT getNoBands(const INT mode) {
   INT noBands = 0;
 
   switch (mode) {
-    case 0: case 3: /* coarse */
+    case 0:
+    case 3: /* coarse */
       noBands = PS_BANDS_COARSE;
       break;
-    case 1: case 4: /* mid */
+    case 1:
+    case 4: /* mid */
       noBands = PS_BANDS_MID;
       break;
-    case 2: case 5: /* fine not supported */
-    default:        /* coarse as default */
+    case 2:
+    case 5:  /* fine not supported */
+    default: /* coarse as default */
       noBands = PS_BANDS_COARSE;
   }
 
   return noBands;
 }
 
-static INT getIIDRes(INT iidMode)
-{
-  if(iidMode<3)
+static INT getIIDRes(INT iidMode) {
+  if (iidMode < 3)
     return PS_IID_RES_COARSE;
   else
     return PS_IID_RES_FINE;
 }
 
-static INT
-encodeDeltaFreq(HANDLE_FDK_BITSTREAM hBitBuf,
-                const INT          *val,
-                const INT           nBands,
-                const UINT *codeTable,
-                const UINT *lengthTable,
-                const INT           tableOffset,
-                const INT           maxVal,
-                INT                *error)
-{
+static INT encodeDeltaFreq(HANDLE_FDK_BITSTREAM hBitBuf, const INT *val,
+                           const INT nBands, const UINT *codeTable,
+                           const UINT *lengthTable, const INT tableOffset,
+                           const INT maxVal, INT *error) {
   INT bitCnt = 0;
   INT lastVal = 0;
   INT band;
 
-  for(band=0;band<nBands;band++) {
+  for (band = 0; band < nBands; band++) {
     INT delta = (val[band] - lastVal) + tableOffset;
     lastVal = val[band];
-    if( (delta>maxVal) || (delta<0) ) {
+    if ((delta > maxVal) || (delta < 0)) {
       *error = 1;
-      delta = delta>0?maxVal:0;
+      delta = delta > 0 ? maxVal : 0;
     }
-    bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
+    bitCnt +=
+        FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
   }
 
   return bitCnt;
 }
 
-static INT
-encodeDeltaTime(HANDLE_FDK_BITSTREAM hBitBuf,
-                const INT          *val,
-                const INT          *valLast,
-                const INT           nBands,
-                const UINT *codeTable,
-                const UINT *lengthTable,
-                const INT           tableOffset,
-                const INT           maxVal,
-                INT                *error)
-{
+static INT encodeDeltaTime(HANDLE_FDK_BITSTREAM hBitBuf, const INT *val,
+                           const INT *valLast, const INT nBands,
+                           const UINT *codeTable, const UINT *lengthTable,
+                           const INT tableOffset, const INT maxVal,
+                           INT *error) {
   INT bitCnt = 0;
   INT band;
 
-  for(band=0;band<nBands;band++) {
+  for (band = 0; band < nBands; band++) {
     INT delta = (val[band] - valLast[band]) + tableOffset;
-    if( (delta>maxVal) || (delta<0) ) {
+    if ((delta > maxVal) || (delta < 0)) {
       *error = 1;
-      delta = delta>0?maxVal:0;
+      delta = delta > 0 ? maxVal : 0;
     }
-    bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
+    bitCnt +=
+        FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
   }
 
   return bitCnt;
 }
 
-INT FDKsbrEnc_EncodeIid(HANDLE_FDK_BITSTREAM     hBitBuf,
-              const INT               *iidVal,
-              const INT               *iidValLast,
-              const INT                nBands,
-              const PS_IID_RESOLUTION  res,
-              const PS_DELTA           mode,
-              INT                     *error)
-{
+INT FDKsbrEnc_EncodeIid(HANDLE_FDK_BITSTREAM hBitBuf, const INT *iidVal,
+                        const INT *iidValLast, const INT nBands,
+                        const PS_IID_RESOLUTION res, const PS_DELTA mode,
+                        INT *error) {
   const UINT *codeTable;
   const UINT *lengthTable;
   INT bitCnt = 0;
 
   bitCnt = 0;
 
-  switch(mode) {
-  case PS_DELTA_FREQ:
-    switch(res) {
-    case PS_IID_RES_COARSE:
-      codeTable   = iidDeltaFreqCoarse_Code;
-      lengthTable = iidDeltaFreqCoarse_Length;
-      bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
-                                lengthTable, iidDeltaCoarse_Offset,
-                                iidDeltaCoarse_MaxVal, error);
-    break;
-    case PS_IID_RES_FINE:
-      codeTable   = iidDeltaFreqFine_Code;
-      lengthTable = iidDeltaFreqFine_Length;
-      bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
-                                lengthTable, iidDeltaFine_Offset,
-                                iidDeltaFine_MaxVal, error);
-    break;
-    default:
-      *error = 1;
-    }
-    break;
-
-  case PS_DELTA_TIME:
-    switch(res) {
-    case PS_IID_RES_COARSE:
-      codeTable   = iidDeltaTimeCoarse_Code;
-      lengthTable = iidDeltaTimeCoarse_Length;
-      bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands, codeTable,
-                                lengthTable, iidDeltaCoarse_Offset,
-                                iidDeltaCoarse_MaxVal, error);
-    break;
-    case PS_IID_RES_FINE:
-      codeTable   = iidDeltaTimeFine_Code;
-      lengthTable = iidDeltaTimeFine_Length;
-      bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands, codeTable,
-                                lengthTable, iidDeltaFine_Offset,
-                                iidDeltaFine_MaxVal, error);
-    break;
+  switch (mode) {
+    case PS_DELTA_FREQ:
+      switch (res) {
+        case PS_IID_RES_COARSE:
+          codeTable = iidDeltaFreqCoarse_Code;
+          lengthTable = iidDeltaFreqCoarse_Length;
+          bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
+                                    lengthTable, iidDeltaCoarse_Offset,
+                                    iidDeltaCoarse_MaxVal, error);
+          break;
+        case PS_IID_RES_FINE:
+          codeTable = iidDeltaFreqFine_Code;
+          lengthTable = iidDeltaFreqFine_Length;
+          bitCnt +=
+              encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable, lengthTable,
+                              iidDeltaFine_Offset, iidDeltaFine_MaxVal, error);
+          break;
+        default:
+          *error = 1;
+      }
+      break;
+
+    case PS_DELTA_TIME:
+      switch (res) {
+        case PS_IID_RES_COARSE:
+          codeTable = iidDeltaTimeCoarse_Code;
+          lengthTable = iidDeltaTimeCoarse_Length;
+          bitCnt += encodeDeltaTime(
+              hBitBuf, iidVal, iidValLast, nBands, codeTable, lengthTable,
+              iidDeltaCoarse_Offset, iidDeltaCoarse_MaxVal, error);
+          break;
+        case PS_IID_RES_FINE:
+          codeTable = iidDeltaTimeFine_Code;
+          lengthTable = iidDeltaTimeFine_Length;
+          bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands,
+                                    codeTable, lengthTable, iidDeltaFine_Offset,
+                                    iidDeltaFine_MaxVal, error);
+          break;
+        default:
+          *error = 1;
+      }
+      break;
+
     default:
       *error = 1;
-    }
-    break;
-
-  default:
-    *error = 1;
   }
 
   return bitCnt;
 }
 
-
-INT FDKsbrEnc_EncodeIcc(HANDLE_FDK_BITSTREAM hBitBuf,
-              const INT      *iccVal,
-              const INT      *iccValLast,
-              const INT       nBands,
-              const PS_DELTA  mode,
-              INT            *error)
-{
+INT FDKsbrEnc_EncodeIcc(HANDLE_FDK_BITSTREAM hBitBuf, const INT *iccVal,
+                        const INT *iccValLast, const INT nBands,
+                        const PS_DELTA mode, INT *error) {
   const UINT *codeTable;
   const UINT *lengthTable;
   INT bitCnt = 0;
 
-  switch(mode) {
-  case PS_DELTA_FREQ:
-    codeTable   = iccDeltaFreq_Code;
-    lengthTable = iccDeltaFreq_Length;
-    bitCnt += encodeDeltaFreq(hBitBuf, iccVal, nBands, codeTable,
-                              lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
-    break;
+  switch (mode) {
+    case PS_DELTA_FREQ:
+      codeTable = iccDeltaFreq_Code;
+      lengthTable = iccDeltaFreq_Length;
+      bitCnt += encodeDeltaFreq(hBitBuf, iccVal, nBands, codeTable, lengthTable,
+                                iccDelta_Offset, iccDelta_MaxVal, error);
+      break;
 
-  case PS_DELTA_TIME:
-    codeTable   = iccDeltaTime_Code;
-    lengthTable = iccDeltaTime_Length;
+    case PS_DELTA_TIME:
+      codeTable = iccDeltaTime_Code;
+      lengthTable = iccDeltaTime_Length;
 
-    bitCnt += encodeDeltaTime(hBitBuf, iccVal, iccValLast, nBands, codeTable,
-                              lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
-    break;
+      bitCnt +=
+          encodeDeltaTime(hBitBuf, iccVal, iccValLast, nBands, codeTable,
+                          lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
+      break;
 
-  default:
-    *error = 1;
+    default:
+      *error = 1;
   }
 
   return bitCnt;
 }
 
-INT FDKsbrEnc_EncodeIpd(HANDLE_FDK_BITSTREAM hBitBuf,
-              const INT      *ipdVal,
-              const INT      *ipdValLast,
-              const INT       nBands,
-              const PS_DELTA  mode,
-              INT            *error)
-{
+INT FDKsbrEnc_EncodeIpd(HANDLE_FDK_BITSTREAM hBitBuf, const INT *ipdVal,
+                        const INT *ipdValLast, const INT nBands,
+                        const PS_DELTA mode, INT *error) {
   const UINT *codeTable;
   const UINT *lengthTable;
   INT bitCnt = 0;
 
-  switch(mode) {
-  case PS_DELTA_FREQ:
-    codeTable   = ipdDeltaFreq_Code;
-    lengthTable = ipdDeltaFreq_Length;
-    bitCnt += encodeDeltaFreq(hBitBuf, ipdVal, nBands, codeTable,
-                              lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
-    break;
+  switch (mode) {
+    case PS_DELTA_FREQ:
+      codeTable = ipdDeltaFreq_Code;
+      lengthTable = ipdDeltaFreq_Length;
+      bitCnt += encodeDeltaFreq(hBitBuf, ipdVal, nBands, codeTable, lengthTable,
+                                ipdDelta_Offset, ipdDelta_MaxVal, error);
+      break;
 
-  case PS_DELTA_TIME:
-    codeTable   = ipdDeltaTime_Code;
-    lengthTable = ipdDeltaTime_Length;
+    case PS_DELTA_TIME:
+      codeTable = ipdDeltaTime_Code;
+      lengthTable = ipdDeltaTime_Length;
 
-    bitCnt += encodeDeltaTime(hBitBuf, ipdVal, ipdValLast, nBands, codeTable,
-                              lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
-    break;
+      bitCnt +=
+          encodeDeltaTime(hBitBuf, ipdVal, ipdValLast, nBands, codeTable,
+                          lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
+      break;
 
-  default:
-    *error = 1;
+    default:
+      *error = 1;
   }
 
   return bitCnt;
 }
 
-INT FDKsbrEnc_EncodeOpd(HANDLE_FDK_BITSTREAM hBitBuf,
-              const INT      *opdVal,
-              const INT      *opdValLast,
-              const INT       nBands,
-              const PS_DELTA  mode,
-              INT            *error)
-{
+INT FDKsbrEnc_EncodeOpd(HANDLE_FDK_BITSTREAM hBitBuf, const INT *opdVal,
+                        const INT *opdValLast, const INT nBands,
+                        const PS_DELTA mode, INT *error) {
   const UINT *codeTable;
   const UINT *lengthTable;
   INT bitCnt = 0;
 
-  switch(mode) {
-  case PS_DELTA_FREQ:
-    codeTable   = opdDeltaFreq_Code;
-    lengthTable = opdDeltaFreq_Length;
-    bitCnt += encodeDeltaFreq(hBitBuf, opdVal, nBands, codeTable,
-                              lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
-    break;
+  switch (mode) {
+    case PS_DELTA_FREQ:
+      codeTable = opdDeltaFreq_Code;
+      lengthTable = opdDeltaFreq_Length;
+      bitCnt += encodeDeltaFreq(hBitBuf, opdVal, nBands, codeTable, lengthTable,
+                                opdDelta_Offset, opdDelta_MaxVal, error);
+      break;
 
-  case PS_DELTA_TIME:
-    codeTable   = opdDeltaTime_Code;
-    lengthTable = opdDeltaTime_Length;
+    case PS_DELTA_TIME:
+      codeTable = opdDeltaTime_Code;
+      lengthTable = opdDeltaTime_Length;
 
-    bitCnt += encodeDeltaTime(hBitBuf, opdVal, opdValLast, nBands, codeTable,
-                              lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
-    break;
+      bitCnt +=
+          encodeDeltaTime(hBitBuf, opdVal, opdValLast, nBands, codeTable,
+                          lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
+      break;
 
-  default:
-    *error = 1;
+    default:
+      *error = 1;
   }
 
   return bitCnt;
 }
 
-static INT encodeIpdOpd(HANDLE_PS_OUT        psOut,
-                        HANDLE_FDK_BITSTREAM hBitBuf )
-{
+static INT encodeIpdOpd(HANDLE_PS_OUT psOut, HANDLE_FDK_BITSTREAM hBitBuf) {
   INT bitCnt = 0;
-  INT error  = 0;
+  INT error = 0;
   INT env;
 
   FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableIpdOpd, 1);
 
-  if(psOut->enableIpdOpd==1) {
+  if (psOut->enableIpdOpd == 1) {
     INT *ipdLast = psOut->ipdLast;
     INT *opdLast = psOut->opdLast;
 
-    for(env=0; env<psOut->nEnvelopes; env++) {
-      bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaIPD[env], 1);
-      bitCnt += FDKsbrEnc_EncodeIpd( hBitBuf,
-                           psOut->ipd[env],
-                           ipdLast,
-                           getNoBands(psOut->iidMode),
-                           psOut->deltaIPD[env],
-                           &error);
-
-      bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaOPD[env], 1);
-      bitCnt += FDKsbrEnc_EncodeOpd( hBitBuf,
-                           psOut->opd[env],
-                           opdLast,
-                           getNoBands(psOut->iidMode),
-                           psOut->deltaOPD[env],
-                           &error );
+    for (env = 0; env < psOut->nEnvelopes; env++) {
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaIPD[env], 1);
+      bitCnt += FDKsbrEnc_EncodeIpd(hBitBuf, psOut->ipd[env], ipdLast,
+                                    getNoBands(psOut->iidMode),
+                                    psOut->deltaIPD[env], &error);
+
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaOPD[env], 1);
+      bitCnt += FDKsbrEnc_EncodeOpd(hBitBuf, psOut->opd[env], opdLast,
+                                    getNoBands(psOut->iidMode),
+                                    psOut->deltaOPD[env], &error);
     }
     /* reserved bit */
-    bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, 0, 1);
+    bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, 1);
   }
 
-
   return bitCnt;
 }
 
-static INT getEnvIdx(const INT nEnvelopes, const INT frameClass)
-{
+static INT getEnvIdx(const INT nEnvelopes, const INT frameClass) {
   INT envIdx = 0;
 
-  switch(nEnvelopes) {
-  case 0:
-    envIdx = 0;
-    break;
-
-  case 1:
-    if (frameClass==0)
-      envIdx = 1;
-    else
+  switch (nEnvelopes) {
+    case 0:
       envIdx = 0;
-    break;
+      break;
 
-  case 2:
-    if (frameClass==0)
-      envIdx = 2;
-    else
-      envIdx = 1;
-    break;
+    case 1:
+      if (frameClass == 0)
+        envIdx = 1;
+      else
+        envIdx = 0;
+      break;
+
+    case 2:
+      if (frameClass == 0)
+        envIdx = 2;
+      else
+        envIdx = 1;
+      break;
 
-  case 3:
-    envIdx = 2;
-    break;
+    case 3:
+      envIdx = 2;
+      break;
 
-  case 4:
-    envIdx = 3;
-    break;
+    case 4:
+      envIdx = 3;
+      break;
 
-  default:
-    /* unsupported number of envelopes */
-    envIdx = 0;
+    default:
+      /* unsupported number of envelopes */
+      envIdx = 0;
   }
 
   return envIdx;
 }
 
-
-static INT encodePSExtension(const HANDLE_PS_OUT   psOut,
-                             HANDLE_FDK_BITSTREAM  hBitBuf )
-{
+static INT encodePSExtension(const HANDLE_PS_OUT psOut,
+                             HANDLE_FDK_BITSTREAM hBitBuf) {
   INT bitCnt = 0;
 
-  if(psOut->enableIpdOpd==1) {
+  if (psOut->enableIpdOpd == 1) {
     INT ipdOpdBits = 0;
-    INT extSize = (2 + encodeIpdOpd(psOut,NULL)+7)>>3;
+    INT extSize = (2 + encodeIpdOpd(psOut, NULL) + 7) >> 3;
 
-    if(extSize<15) {
-      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf,  extSize, 4);
-    }
-    else {
-      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf,          15 , 4);
-      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, (extSize-15), 8);
+    if (extSize < 15) {
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, extSize, 4);
+    } else {
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, 15, 4);
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, (extSize - 15), 8);
     }
 
     /* write ipd opd data */
     ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, PS_EXT_ID_V0, 2);
-    ipdOpdBits += encodeIpdOpd(psOut, hBitBuf );
+    ipdOpdBits += encodeIpdOpd(psOut, hBitBuf);
 
     /* byte align the ipd opd data  */
-    if(ipdOpdBits%8)
-      ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, (8-(ipdOpdBits%8)) );
+    if (ipdOpdBits % 8)
+      ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, (8 - (ipdOpdBits % 8)));
 
     bitCnt += ipdOpdBits;
   }
@@ -617,77 +552,69 @@ static INT encodePSExtension(const HANDLE_PS_OUT   psOut,
   return (bitCnt);
 }
 
-INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT   psOut,
-                               HANDLE_FDK_BITSTREAM  hBitBuf )
-{
+INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT psOut,
+                               HANDLE_FDK_BITSTREAM hBitBuf) {
   INT psExtEnable = 0;
   INT bitCnt = 0;
   INT error = 0;
   INT env;
 
-  if(psOut != NULL){
-
+  if (psOut != NULL) {
     /* PS HEADER */
-    bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enablePSHeader, 1);
+    bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enablePSHeader, 1);
 
-    if(psOut->enablePSHeader) {
-
-      bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enableIID, 1);
-      if(psOut->enableIID) {
-        bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->iidMode, 3);
+    if (psOut->enablePSHeader) {
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableIID, 1);
+      if (psOut->enableIID) {
+        bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->iidMode, 3);
       }
-      bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enableICC, 1);
-      if(psOut->enableICC) {
-        bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->iccMode, 3);
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableICC, 1);
+      if (psOut->enableICC) {
+        bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->iccMode, 3);
       }
-      if(psOut->enableIpdOpd) {
+      if (psOut->enableIpdOpd) {
         psExtEnable = 1;
       }
-      bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psExtEnable, 1);
+      bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psExtEnable, 1);
     }
 
     /* Frame class, number of envelopes */
-    bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->frameClass, 1);
-    bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, getEnvIdx(psOut->nEnvelopes, psOut->frameClass), 2);
+    bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->frameClass, 1);
+    bitCnt += FDKsbrEnc_WriteBits_ps(
+        hBitBuf, getEnvIdx(psOut->nEnvelopes, psOut->frameClass), 2);
 
-    if(psOut->frameClass==1) {
-      for(env=0; env<psOut->nEnvelopes; env++) {
-        bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->frameBorder[env], 5);
+    if (psOut->frameClass == 1) {
+      for (env = 0; env < psOut->nEnvelopes; env++) {
+        bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->frameBorder[env], 5);
       }
     }
 
-    if(psOut->enableIID==1) {
+    if (psOut->enableIID == 1) {
       INT *iidLast = psOut->iidLast;
-      for(env=0; env<psOut->nEnvelopes; env++) {
-        bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaIID[env], 1);
-        bitCnt += FDKsbrEnc_EncodeIid( hBitBuf,
-                             psOut->iid[env],
-                             iidLast,
-                             getNoBands(psOut->iidMode),
-                             (PS_IID_RESOLUTION)getIIDRes(psOut->iidMode),
-                             psOut->deltaIID[env],
-                             &error );
+      for (env = 0; env < psOut->nEnvelopes; env++) {
+        bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaIID[env], 1);
+        bitCnt += FDKsbrEnc_EncodeIid(
+            hBitBuf, psOut->iid[env], iidLast, getNoBands(psOut->iidMode),
+            (PS_IID_RESOLUTION)getIIDRes(psOut->iidMode), psOut->deltaIID[env],
+            &error);
 
         iidLast = psOut->iid[env];
       }
     }
 
-    if(psOut->enableICC==1) {
+    if (psOut->enableICC == 1) {
       INT *iccLast = psOut->iccLast;
-      for(env=0; env<psOut->nEnvelopes; env++) {
-        bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaICC[env], 1);
-        bitCnt += FDKsbrEnc_EncodeIcc( hBitBuf,
-                             psOut->icc[env],
-                             iccLast,
-                             getNoBands(psOut->iccMode),
-                             psOut->deltaICC[env],
-                             &error);
+      for (env = 0; env < psOut->nEnvelopes; env++) {
+        bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaICC[env], 1);
+        bitCnt += FDKsbrEnc_EncodeIcc(hBitBuf, psOut->icc[env], iccLast,
+                                      getNoBands(psOut->iccMode),
+                                      psOut->deltaICC[env], &error);
 
         iccLast = psOut->icc[env];
       }
     }
 
-    if(psExtEnable!=0) {
+    if (psExtEnable != 0) {
       bitCnt += encodePSExtension(psOut, hBitBuf);
     }
 
@@ -695,4 +622,3 @@ INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT   psOut,
 
   return bitCnt;
 }
-