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, 826 insertions, 0 deletions

diff --git a/libSACenc/src/sacenc_bitstream.cpp b/libSACenc/src/sacenc_bitstream.cpp
new file mode 100644
index 0000000..dacfc27
--- /dev/null
+++ b/libSACenc/src/sacenc_bitstream.cpp
@@ -0,0 +1,826 @@
+/* -----------------------------------------------------------------------------
+Software License for The Fraunhofer FDK AAC Codec Library for Android
+
+© Copyright  1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
+Forschung e.V. All rights reserved.
+
+ 1.    INTRODUCTION
+The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
+that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
+scheme for digital audio. This FDK AAC Codec software is intended to be used on
+a wide variety of Android devices.
+
+AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
+general perceptual audio codecs. AAC-ELD is considered the best-performing
+full-bandwidth communications codec by independent studies and is widely
+deployed. AAC has been standardized by ISO and IEC as part of the MPEG
+specifications.
+
+Patent licenses for necessary patent claims for the FDK AAC Codec (including
+those of Fraunhofer) may be obtained through Via Licensing
+(www.vialicensing.com) or through the respective patent owners individually for
+the purpose of encoding or decoding bit streams in products that are compliant
+with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
+Android devices already license these patent claims through Via Licensing or
+directly from the patent owners, and therefore FDK AAC Codec software may
+already be covered under those patent licenses when it is used for those
+licensed purposes only.
+
+Commercially-licensed AAC software libraries, including floating-point versions
+with enhanced sound quality, are also available from Fraunhofer. Users are
+encouraged to check the Fraunhofer website for additional applications
+information and documentation.
+
+2.    COPYRIGHT LICENSE
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted without payment of copyright license fees provided that you
+satisfy the following conditions:
+
+You must retain the complete text of this software license in redistributions of
+the FDK AAC Codec or your modifications thereto in source code form.
+
+You must retain the complete text of this software license in the documentation
+and/or other materials provided with redistributions of the FDK AAC Codec or
+your modifications thereto in binary form. You must make available free of
+charge copies of the complete source code of the FDK AAC Codec and your
+modifications thereto to recipients of copies in binary form.
+
+The name of Fraunhofer may not be used to endorse or promote products derived
+from this library without prior written permission.
+
+You may not charge copyright license fees for anyone to use, copy or distribute
+the FDK AAC Codec software or your modifications thereto.
+
+Your modified versions of the FDK AAC Codec must carry prominent notices stating
+that you changed the software and the date of any change. For modified versions
+of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
+must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
+AAC Codec Library for Android."
+
+3.    NO PATENT LICENSE
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
+limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
+Fraunhofer provides no warranty of patent non-infringement with respect to this
+software.
+
+You may use this FDK AAC Codec software or modifications thereto only for
+purposes that are authorized by appropriate patent licenses.
+
+4.    DISCLAIMER
+
+This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
+holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+including but not limited to the implied warranties of merchantability and
+fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
+or consequential damages, including but not limited to procurement of substitute
+goods or services; loss of use, data, or profits, or business interruption,
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence), arising in any way out of the use of
+this software, even if advised of the possibility of such damage.
+
+5.    CONTACT INFORMATION
+
+Fraunhofer Institute for Integrated Circuits IIS
+Attention: Audio and Multimedia Departments - FDK AAC LL
+Am Wolfsmantel 33
+91058 Erlangen, Germany
+
+www.iis.fraunhofer.de/amm
+amm-info@iis.fraunhofer.de
+----------------------------------------------------------------------------- */
+
+/*********************** MPEG surround encoder library *************************
+
+   Author(s):
+
+   Description: Encoder Library Interface
+                Bitstream Writer
+
+*******************************************************************************/
+
+/* Includes ******************************************************************/
+#include "sacenc_bitstream.h"
+#include "sacenc_const.h"
+
+#include "genericStds.h"
+#include "common_fix.h"
+
+#include "FDK_matrixCalloc.h"
+#include "sacenc_nlc_enc.h"
+
+/* Defines *******************************************************************/
+#define MAX_FREQ_RES_INDEX 8
+#define MAX_SAMPLING_FREQUENCY_INDEX 13
+#define SAMPLING_FREQUENCY_INDEX_ESCAPE 15
+
+/* Data Types ****************************************************************/
+typedef struct {
+  SCHAR cld_old[SACENC_MAX_NUM_BOXES][MAX_NUM_BINS];
+  SCHAR icc_old[SACENC_MAX_NUM_BOXES][MAX_NUM_BINS];
+  UCHAR quantCoarseCldPrev[SACENC_MAX_NUM_BOXES][MAX_NUM_PARAMS];
+  UCHAR quantCoarseIccPrev[SACENC_MAX_NUM_BOXES][MAX_NUM_PARAMS];
+
+} PREV_OTTDATA;
+
+typedef struct {
+  PREV_OTTDATA prevOttData;
+
+} STATIC_SPATIALFRAME;
+
+typedef struct BSF_INSTANCE {
+  SPATIALSPECIFICCONFIG spatialSpecificConfig;
+  SPATIALFRAME frame;
+  STATIC_SPATIALFRAME prevFrameData;
+
+} BSF_INSTANCE;
+
+/* Constants *****************************************************************/
+static const INT SampleRateTable[MAX_SAMPLING_FREQUENCY_INDEX] = {
+    96000, 88200, 64000, 48000, 44100, 32000, 24000,
+    22050, 16000, 12000, 11025, 8000,  7350};
+
+static const UCHAR FreqResBinTable_LD[MAX_FREQ_RES_INDEX] = {0, 23, 15, 12,
+                                                             9, 7,  5,  4};
+static const UCHAR FreqResStrideTable_LD[] = {1, 2, 5, 23};
+
+/* Function / Class Declarations *********************************************/
+
+/* Function / Class Definition ***********************************************/
+static FDK_SACENC_ERROR DuplicateLosslessData(
+    const INT startBox, const INT stopBox,
+    const LOSSLESSDATA *const hLosslessDataFrom, const INT setFrom,
+    LOSSLESSDATA *const hLosslessDataTo, const INT setTo) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((NULL == hLosslessDataFrom) || (NULL == hLosslessDataTo)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    int i;
+
+    for (i = startBox; i < stopBox; i++) {
+      hLosslessDataTo->bsXXXDataMode[i][setTo] =
+          hLosslessDataFrom->bsXXXDataMode[i][setFrom];
+      hLosslessDataTo->bsDataPair[i][setTo] =
+          hLosslessDataFrom->bsDataPair[i][setFrom];
+      hLosslessDataTo->bsQuantCoarseXXX[i][setTo] =
+          hLosslessDataFrom->bsQuantCoarseXXX[i][setFrom];
+      hLosslessDataTo->bsFreqResStrideXXX[i][setTo] =
+          hLosslessDataFrom->bsFreqResStrideXXX[i][setFrom];
+    }
+  }
+  return error;
+}
+
+FDK_SACENC_ERROR fdk_sacenc_duplicateParameterSet(
+    const SPATIALFRAME *const hFrom, const INT setFrom, SPATIALFRAME *const hTo,
+    const INT setTo) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((NULL == hFrom) || (NULL == hTo)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    int box;
+    /* Only Copy Parameter Set selective stuff */
+
+    /* OTT-Data */
+    for (box = 0; box < SACENC_MAX_NUM_BOXES; box++) {
+      FDKmemcpy(hTo->ottData.cld[box][setTo], hFrom->ottData.cld[box][setFrom],
+                sizeof(hFrom->ottData.cld[0][0]));
+      FDKmemcpy(hTo->ottData.icc[box][setTo], hFrom->ottData.icc[box][setFrom],
+                sizeof(hFrom->ottData.icc[0][0]));
+    }
+
+    /* LOSSLESSDATA */
+    DuplicateLosslessData(0, SACENC_MAX_NUM_BOXES, &hFrom->CLDLosslessData,
+                          setFrom, &hTo->CLDLosslessData, setTo);
+    DuplicateLosslessData(0, SACENC_MAX_NUM_BOXES, &hFrom->ICCLosslessData,
+                          setFrom, &hTo->ICCLosslessData, setTo);
+
+  } /* valid handle */
+
+  return error;
+}
+
+/* set frame defaults */
+static void clearFrame(SPATIALFRAME *const pFrame) {
+  FDKmemclear(pFrame, sizeof(SPATIALFRAME));
+
+  pFrame->bsIndependencyFlag = 1;
+  pFrame->framingInfo.numParamSets = 1;
+}
+
+static void fine2coarse(SCHAR *const data, const DATA_TYPE dataType,
+                        const INT startBand, const INT numBands) {
+  int i;
+  if (dataType == t_CLD) {
+    for (i = startBand; i < startBand + numBands; i++) {
+      data[i] /= 2;
+    }
+  } else {
+    for (i = startBand; i < startBand + numBands; i++) {
+      data[i] >>= 1;
+    }
+  }
+}
+
+static void coarse2fine(SCHAR *const data, const DATA_TYPE dataType,
+                        const INT startBand, const INT numBands) {
+  int i;
+
+  for (i = startBand; i < startBand + numBands; i++) {
+    data[i] <<= 1;
+  }
+
+  if (dataType == t_CLD) {
+    for (i = startBand; i < startBand + numBands; i++) {
+      if (data[i] == -14) {
+        data[i] = -15;
+      } else if (data[i] == 14) {
+        data[i] = 15;
+      }
+    }
+  } /* (dataType == t_CLD) */
+}
+
+static UCHAR getBsFreqResStride(const INT index) {
+  const UCHAR *pFreqResStrideTable = NULL;
+  int freqResStrideTableSize = 0;
+
+  pFreqResStrideTable = FreqResStrideTable_LD;
+  freqResStrideTableSize =
+      sizeof(FreqResStrideTable_LD) / sizeof(*FreqResStrideTable_LD);
+
+  return (((NULL != pFreqResStrideTable) && (index >= 0) &&
+           (index < freqResStrideTableSize))
+              ? pFreqResStrideTable[index]
+              : 1);
+}
+
+/* write data to bitstream */
+static void ecData(HANDLE_FDK_BITSTREAM bitstream,
+                   SCHAR data[MAX_NUM_PARAMS][MAX_NUM_BINS],
+                   SCHAR oldData[MAX_NUM_BINS],
+                   UCHAR quantCoarseXXXprev[MAX_NUM_PARAMS],
+                   LOSSLESSDATA *const losslessData, const DATA_TYPE dataType,
+                   const INT paramIdx, const INT numParamSets,
+                   const INT independencyFlag, const INT startBand,
+                   const INT stopBand, const INT defaultValue) {
+  int ps, pb, strOffset, pbStride, dataBands, i;
+  int aStrides[MAX_NUM_BINS + 1] = {0};
+  SHORT cmpIdxData[2][MAX_NUM_BINS] = {{0}};
+  SHORT cmpOldData[MAX_NUM_BINS] = {0};
+
+  /* bsXXXDataMode */
+  if (independencyFlag || (losslessData->bsQuantCoarseXXX[paramIdx][0] !=
+                           quantCoarseXXXprev[paramIdx])) {
+    losslessData->bsXXXDataMode[paramIdx][0] = FINECOARSE;
+  } else {
+    losslessData->bsXXXDataMode[paramIdx][0] = KEEP;
+    for (i = startBand; i < stopBand; i++) {
+      if (data[0][i] != oldData[i]) {
+        losslessData->bsXXXDataMode[paramIdx][0] = FINECOARSE;
+        break;
+      }
+    }
+  }
+
+  FDKwriteBits(bitstream, losslessData->bsXXXDataMode[paramIdx][0], 2);
+
+  for (ps = 1; ps < numParamSets; ps++) {
+    if (losslessData->bsQuantCoarseXXX[paramIdx][ps] !=
+        losslessData->bsQuantCoarseXXX[paramIdx][ps - 1]) {
+      losslessData->bsXXXDataMode[paramIdx][ps] = FINECOARSE;
+    } else {
+      losslessData->bsXXXDataMode[paramIdx][ps] = KEEP;
+      for (i = startBand; i < stopBand; i++) {
+        if (data[ps][i] != data[ps - 1][i]) {
+          losslessData->bsXXXDataMode[paramIdx][ps] = FINECOARSE;
+          break;
+        }
+      }
+    }
+
+    FDKwriteBits(bitstream, losslessData->bsXXXDataMode[paramIdx][ps], 2);
+  } /* for ps */
+
+  /* Create data pairs if possible */
+  for (ps = 0; ps < (numParamSets - 1); ps++) {
+    if (losslessData->bsXXXDataMode[paramIdx][ps] == FINECOARSE) {
+      /* Check if next parameter set is FINCOARSE */
+      if (losslessData->bsXXXDataMode[paramIdx][ps + 1] == FINECOARSE) {
+        /* We have to check if ps and ps+1 use the same bsXXXQuantMode */
+        /* and also have the same stride */
+        if ((losslessData->bsQuantCoarseXXX[paramIdx][ps + 1] ==
+             losslessData->bsQuantCoarseXXX[paramIdx][ps]) &&
+            (losslessData->bsFreqResStrideXXX[paramIdx][ps + 1] ==
+             losslessData->bsFreqResStrideXXX[paramIdx][ps])) {
+          losslessData->bsDataPair[paramIdx][ps] = 1;
+          losslessData->bsDataPair[paramIdx][ps + 1] = 1;
+
+          /* We have a data pair -> Jump to the ps after next ps*/
+          ps++;
+          continue;
+        }
+      }
+      /* dataMode of next ps is not FINECOARSE or does not use the same
+       * bsXXXQuantMode/stride */
+      /* -> no dataPair possible */
+      losslessData->bsDataPair[paramIdx][ps] = 0;
+
+      /* Initialize ps after next ps to Zero (only important for the last
+       * parameter set) */
+      losslessData->bsDataPair[paramIdx][ps + 1] = 0;
+    } else {
+      /* No FINECOARSE -> no data pair possible */
+      losslessData->bsDataPair[paramIdx][ps] = 0;
+
+      /* Initialize ps after next ps to Zero (only important for the last
+       * parameter set) */
+      losslessData->bsDataPair[paramIdx][ps + 1] = 0;
+    }
+  } /* for ps */
+
+  for (ps = 0; ps < numParamSets; ps++) {
+    if (losslessData->bsXXXDataMode[paramIdx][ps] == DEFAULT) {
+      /* Prepare old data */
+      for (i = startBand; i < stopBand; i++) {
+        oldData[i] = defaultValue;
+      }
+      quantCoarseXXXprev[paramIdx] = 0; /* Default data are always fine */
+    }
+
+    if (losslessData->bsXXXDataMode[paramIdx][ps] == FINECOARSE) {
+      FDKwriteBits(bitstream, losslessData->bsDataPair[paramIdx][ps], 1);
+      FDKwriteBits(bitstream, losslessData->bsQuantCoarseXXX[paramIdx][ps], 1);
+      FDKwriteBits(bitstream, losslessData->bsFreqResStrideXXX[paramIdx][ps],
+                   2);
+
+      if (losslessData->bsQuantCoarseXXX[paramIdx][ps] !=
+          quantCoarseXXXprev[paramIdx]) {
+        if (quantCoarseXXXprev[paramIdx]) {
+          coarse2fine(oldData, dataType, startBand, stopBand - startBand);
+        } else {
+          fine2coarse(oldData, dataType, startBand, stopBand - startBand);
+        }
+      }
+
+      /* Handle strides */
+      pbStride =
+          getBsFreqResStride(losslessData->bsFreqResStrideXXX[paramIdx][ps]);
+      dataBands = (stopBand - startBand - 1) / pbStride + 1;
+
+      aStrides[0] = startBand;
+      for (pb = 1; pb <= dataBands; pb++) {
+        aStrides[pb] = aStrides[pb - 1] + pbStride;
+      }
+
+      strOffset = 0;
+      while (aStrides[dataBands] > stopBand) {
+        if (strOffset < dataBands) {
+          strOffset++;
+        }
+        for (i = strOffset; i <= dataBands; i++) {
+          aStrides[i]--;
+        }
+      } /* while */
+
+      for (pb = 0; pb < dataBands; pb++) {
+        cmpOldData[startBand + pb] = oldData[aStrides[pb]];
+        cmpIdxData[0][startBand + pb] = data[ps][aStrides[pb]];
+
+        if (losslessData->bsDataPair[paramIdx][ps]) {
+          cmpIdxData[1][startBand + pb] = data[ps + 1][aStrides[pb]];
+        }
+      } /* for pb*/
+
+      /* Finally encode */
+      if (losslessData->bsDataPair[paramIdx][ps]) {
+        fdk_sacenc_ecDataPairEnc(bitstream, cmpIdxData, cmpOldData, dataType, 0,
+                                 startBand, dataBands,
+                                 losslessData->bsQuantCoarseXXX[paramIdx][ps],
+                                 independencyFlag && (ps == 0));
+      } else {
+        fdk_sacenc_ecDataSingleEnc(bitstream, cmpIdxData, cmpOldData, dataType,
+                                   0, startBand, dataBands,
+                                   losslessData->bsQuantCoarseXXX[paramIdx][ps],
+                                   independencyFlag && (ps == 0));
+      }
+
+      /* Overwrite old data */
+      for (i = startBand; i < stopBand; i++) {
+        if (losslessData->bsDataPair[paramIdx][ps]) {
+          oldData[i] = data[ps + 1][i];
+        } else {
+          oldData[i] = data[ps][i];
+        }
+      }
+
+      quantCoarseXXXprev[paramIdx] =
+          losslessData->bsQuantCoarseXXX[paramIdx][ps];
+
+      /* Jump forward if we have encoded a data pair */
+      if (losslessData->bsDataPair[paramIdx][ps]) {
+        ps++;
+      }
+
+    } /* if (losslessData->bsXXXDataMode[paramIdx][ps] == FINECOARSE ) */
+  }   /* for ps */
+}
+
+/****************************************************************************/
+/* Bitstream formatter interface functions                                  */
+/****************************************************************************/
+static FDK_SACENC_ERROR getBsFreqResIndex(const INT numBands,
+                                          INT *const pbsFreqResIndex) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if (NULL == pbsFreqResIndex) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    const UCHAR *pFreqResBinTable = FreqResBinTable_LD;
+    int i;
+    *pbsFreqResIndex = -1;
+
+    for (i = 0; i < MAX_FREQ_RES_INDEX; i++) {
+      if (numBands == pFreqResBinTable[i]) {
+        *pbsFreqResIndex = i;
+        break;
+      }
+    }
+    if (*pbsFreqResIndex < 0 || *pbsFreqResIndex >= MAX_FREQ_RES_INDEX) {
+      error = SACENC_INVALID_CONFIG;
+    }
+  }
+  return error;
+}
+
+static FDK_SACENC_ERROR getSamplingFrequencyIndex(
+    const INT bsSamplingFrequency, INT *const pbsSamplingFrequencyIndex) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if (NULL == pbsSamplingFrequencyIndex) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    int i;
+    *pbsSamplingFrequencyIndex = SAMPLING_FREQUENCY_INDEX_ESCAPE;
+
+    for (i = 0; i < MAX_SAMPLING_FREQUENCY_INDEX; i++) {
+      if (bsSamplingFrequency == SampleRateTable[i]) { /*spatial sampling rate*/
+        *pbsSamplingFrequencyIndex = i;
+        break;
+      }
+    }
+  }
+  return error;
+}
+
+/* destroy encoder instance */
+FDK_SACENC_ERROR fdk_sacenc_destroySpatialBitstreamEncoder(
+    HANDLE_BSF_INSTANCE *selfPtr) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((selfPtr == NULL) || (*selfPtr == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    if (*selfPtr != NULL) {
+      FDK_FREE_MEMORY_1D(*selfPtr);
+    }
+  }
+  return error;
+}
+
+/* create encoder instance */
+FDK_SACENC_ERROR fdk_sacenc_createSpatialBitstreamEncoder(
+    HANDLE_BSF_INSTANCE *selfPtr) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if (NULL == selfPtr) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    /* allocate encoder struct */
+    FDK_ALLOCATE_MEMORY_1D(*selfPtr, 1, BSF_INSTANCE);
+  }
+  return error;
+
+bail:
+  fdk_sacenc_destroySpatialBitstreamEncoder(selfPtr);
+  return ((SACENC_OK == error) ? SACENC_MEMORY_ERROR : error);
+}
+
+/* init encoder instance */
+FDK_SACENC_ERROR fdk_sacenc_initSpatialBitstreamEncoder(
+    HANDLE_BSF_INSTANCE selfPtr) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if (selfPtr == NULL) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    /* init/clear */
+    clearFrame(&selfPtr->frame);
+
+  } /* valid handle */
+  return error;
+}
+
+/* get SpatialSpecificConfig struct */
+SPATIALSPECIFICCONFIG *fdk_sacenc_getSpatialSpecificConfig(
+    HANDLE_BSF_INSTANCE selfPtr) {
+  return ((selfPtr == NULL) ? NULL : &(selfPtr->spatialSpecificConfig));
+}
+
+/* write SpatialSpecificConfig to stream */
+FDK_SACENC_ERROR fdk_sacenc_writeSpatialSpecificConfig(
+    SPATIALSPECIFICCONFIG *const spatialSpecificConfig,
+    UCHAR *const pOutputBuffer, const INT outputBufferSize,
+    INT *const pnOutputBits) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+  INT bsSamplingFrequencyIndex = 0;
+  INT bsFreqRes = 0;
+
+  if ((spatialSpecificConfig == NULL) || (pOutputBuffer == NULL) ||
+      (pnOutputBits == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    FDK_BITSTREAM bitstream;
+
+    /* Find FreqRes */
+    if (SACENC_OK != (error = getBsFreqResIndex(spatialSpecificConfig->numBands,
+                                                &bsFreqRes)))
+      goto bail;
+
+    /* Find SamplingFrequencyIndex */
+    if (SACENC_OK != (error = getSamplingFrequencyIndex(
+                          spatialSpecificConfig->bsSamplingFrequency,
+                          &bsSamplingFrequencyIndex)))
+      goto bail;
+
+    /* bind extern buffer to bitstream handle */
+    FDKinitBitStream(&bitstream, pOutputBuffer, outputBufferSize, 0, BS_WRITER);
+
+    /****************************************************************************/
+    /* write to bitstream */
+
+    FDKwriteBits(&bitstream, bsSamplingFrequencyIndex, 4);
+
+    if (bsSamplingFrequencyIndex == 15) {
+      FDKwriteBits(&bitstream, spatialSpecificConfig->bsSamplingFrequency, 24);
+    }
+
+    FDKwriteBits(&bitstream, spatialSpecificConfig->bsFrameLength, 5);
+
+    FDKwriteBits(&bitstream, bsFreqRes, 3);
+    FDKwriteBits(&bitstream, spatialSpecificConfig->bsTreeConfig, 4);
+    FDKwriteBits(&bitstream, spatialSpecificConfig->bsQuantMode, 2);
+
+    FDKwriteBits(&bitstream, 0, 1); /* bsArbitraryDownmix */
+
+    FDKwriteBits(&bitstream, spatialSpecificConfig->bsFixedGainDMX, 3);
+
+    FDKwriteBits(&bitstream, TEMPSHAPE_OFF, 2);
+    FDKwriteBits(&bitstream, spatialSpecificConfig->bsDecorrConfig, 2);
+
+    FDKbyteAlign(&bitstream, 0); /* byte alignment */
+
+    /* return number of valid bits in bitstream */
+    if ((*pnOutputBits = FDKgetValidBits(&bitstream)) >
+        (outputBufferSize * 8)) {
+      error = SACENC_INVALID_CONFIG;
+      goto bail;
+    }
+
+    /* terminate buffer with alignment */
+    FDKbyteAlign(&bitstream, 0);
+
+  } /* valid handle */
+
+bail:
+  return error;
+}
+
+/* get SpatialFrame struct */
+SPATIALFRAME *fdk_sacenc_getSpatialFrame(HANDLE_BSF_INSTANCE selfPtr,
+                                         const SPATIALFRAME_TYPE frameType) {
+  int idx = -1;
+
+  switch (frameType) {
+    case READ_SPATIALFRAME:
+    case WRITE_SPATIALFRAME:
+      idx = 0;
+      break;
+    default:
+      idx = -1; /* invalid configuration */
+  }             /* switch frameType */
+
+  return (((selfPtr == NULL) || (idx == -1)) ? NULL : &selfPtr->frame);
+}
+
+static FDK_SACENC_ERROR writeFramingInfo(HANDLE_FDK_BITSTREAM hBitstream,
+                                         const FRAMINGINFO *const pFramingInfo,
+                                         const INT frameLength) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((hBitstream == NULL) || (pFramingInfo == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    FDKwriteBits(hBitstream, pFramingInfo->bsFramingType, 1);
+    FDKwriteBits(hBitstream, pFramingInfo->numParamSets - 1, 1);
+
+    if (pFramingInfo->bsFramingType) {
+      int ps = 0;
+      int numParamSets = pFramingInfo->numParamSets;
+
+      {
+        for (ps = 0; ps < numParamSets; ps++) {
+          int bitsParamSlot = 0;
+          while ((1 << bitsParamSlot) < (frameLength + 1)) bitsParamSlot++;
+          if (bitsParamSlot > 0)
+            FDKwriteBits(hBitstream, pFramingInfo->bsParamSlots[ps],
+                         bitsParamSlot);
+        }
+      }
+    } /* pFramingInfo->bsFramingType */
+  }   /* valid handle */
+
+  return error;
+}
+
+static FDK_SACENC_ERROR writeSmgData(HANDLE_FDK_BITSTREAM hBitstream,
+                                     const SMGDATA *const pSmgData,
+                                     const INT numParamSets,
+                                     const INT dataBands) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((hBitstream == NULL) || (pSmgData == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    int i, j;
+
+    for (i = 0; i < numParamSets; i++) {
+      FDKwriteBits(hBitstream, pSmgData->bsSmoothMode[i], 2);
+
+      if (pSmgData->bsSmoothMode[i] >= 2) {
+        FDKwriteBits(hBitstream, pSmgData->bsSmoothTime[i], 2);
+      }
+      if (pSmgData->bsSmoothMode[i] == 3) {
+        const int stride = getBsFreqResStride(pSmgData->bsFreqResStride[i]);
+        FDKwriteBits(hBitstream, pSmgData->bsFreqResStride[i], 2);
+        for (j = 0; j < dataBands; j += stride) {
+          FDKwriteBits(hBitstream, pSmgData->bsSmgData[i][j], 1);
+        }
+      }
+    } /* for i */
+  }   /* valid handle */
+
+  return error;
+}
+
+static FDK_SACENC_ERROR writeOttData(
+    HANDLE_FDK_BITSTREAM hBitstream, PREV_OTTDATA *const pPrevOttData,
+    OTTDATA *const pOttData, const OTTCONFIG ottConfig[SACENC_MAX_NUM_BOXES],
+    LOSSLESSDATA *const pCLDLosslessData, LOSSLESSDATA *const pICCLosslessData,
+    const INT numOttBoxes, const INT numBands, const INT numParamSets,
+    const INT bsIndependencyFlag) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((hBitstream == NULL) || (pPrevOttData == NULL) || (pOttData == NULL) ||
+      (ottConfig == NULL) || (pCLDLosslessData == NULL) ||
+      (pICCLosslessData == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    int i;
+    for (i = 0; i < numOttBoxes; i++) {
+      ecData(hBitstream, pOttData->cld[i], pPrevOttData->cld_old[i],
+             pPrevOttData->quantCoarseCldPrev[i], pCLDLosslessData, t_CLD, i,
+             numParamSets, bsIndependencyFlag, 0, ottConfig[i].bsOttBands, 15);
+    }
+    {
+      for (i = 0; i < numOttBoxes; i++) {
+        {
+          ecData(hBitstream, pOttData->icc[i], pPrevOttData->icc_old[i],
+                 pPrevOttData->quantCoarseIccPrev[i], pICCLosslessData, t_ICC,
+                 i, numParamSets, bsIndependencyFlag, 0, numBands, 0);
+        }
+      } /* for i */
+    }
+  } /* valid handle */
+
+  return error;
+}
+
+/* write extension frame data to stream */
+static FDK_SACENC_ERROR WriteSpatialExtensionFrame(
+    HANDLE_FDK_BITSTREAM bitstream, HANDLE_BSF_INSTANCE self) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((bitstream == NULL) || (self == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    FDKbyteAlign(bitstream, 0);
+  } /* valid handle */
+
+  return error;
+}
+
+/* write frame data to stream */
+FDK_SACENC_ERROR fdk_sacenc_writeSpatialFrame(UCHAR *const pOutputBuffer,
+                                              const INT outputBufferSize,
+                                              INT *const pnOutputBits,
+                                              HANDLE_BSF_INSTANCE selfPtr) {
+  FDK_SACENC_ERROR error = SACENC_OK;
+
+  if ((pOutputBuffer == NULL) || (pnOutputBits == NULL) || (selfPtr == NULL)) {
+    error = SACENC_INVALID_HANDLE;
+  } else {
+    SPATIALFRAME *frame = NULL;
+    SPATIALSPECIFICCONFIG *config = NULL;
+    FDK_BITSTREAM bitstream;
+
+    int i, j, numParamSets, numOttBoxes;
+
+    if ((NULL ==
+         (frame = fdk_sacenc_getSpatialFrame(selfPtr, READ_SPATIALFRAME))) ||
+        (NULL == (config = &(selfPtr->spatialSpecificConfig)))) {
+      error = SACENC_INVALID_HANDLE;
+      goto bail;
+    }
+
+    numOttBoxes = selfPtr->spatialSpecificConfig.treeDescription.numOttBoxes;
+
+    numParamSets = frame->framingInfo.numParamSets;
+
+    if (frame->bUseBBCues) {
+      for (i = 0; i < SACENC_MAX_NUM_BOXES; i++) {
+        /* If a transient was detected, force only the second ps broad band */
+        if (numParamSets == 1) {
+          frame->CLDLosslessData.bsFreqResStrideXXX[i][0] = 3;
+          frame->ICCLosslessData.bsFreqResStrideXXX[i][0] = 3;
+        } else {
+          for (j = 1; j < MAX_NUM_PARAMS; j++) {
+            frame->CLDLosslessData.bsFreqResStrideXXX[i][j] = 3;
+            frame->ICCLosslessData.bsFreqResStrideXXX[i][j] = 3;
+          }
+        }
+      }
+    } /* frame->bUseBBCues */
+
+    /* bind extern buffer to bitstream handle */
+    FDKinitBitStream(&bitstream, pOutputBuffer, outputBufferSize, 0, BS_WRITER);
+
+    if (SACENC_OK != (error = writeFramingInfo(
+                          &bitstream, &(frame->framingInfo),
+                          selfPtr->spatialSpecificConfig.bsFrameLength))) {
+      goto bail;
+    }
+
+    /* write bsIndependencyFlag */
+    FDKwriteBits(&bitstream, frame->bsIndependencyFlag, 1);
+
+    /* write spatial data to bitstream */
+    if (SACENC_OK !=
+        (error = writeOttData(&bitstream, &selfPtr->prevFrameData.prevOttData,
+                              &frame->ottData, config->ottConfig,
+                              &frame->CLDLosslessData, &frame->ICCLosslessData,
+                              numOttBoxes, config->numBands, numParamSets,
+                              frame->bsIndependencyFlag))) {
+      goto bail;
+    }
+    if (SACENC_OK != (error = writeSmgData(&bitstream, &frame->smgData,
+                                           numParamSets, config->numBands))) {
+      goto bail;
+    }
+
+    /* byte alignment */
+    FDKbyteAlign(&bitstream, 0);
+
+    /* Write SpatialExtensionFrame */
+    if (SACENC_OK !=
+        (error = WriteSpatialExtensionFrame(&bitstream, selfPtr))) {
+      goto bail;
+    }
+
+    if (NULL ==
+        (frame = fdk_sacenc_getSpatialFrame(selfPtr, WRITE_SPATIALFRAME))) {
+      error = SACENC_INVALID_HANDLE;
+      goto bail;
+    }
+
+    clearFrame(frame);
+
+    /* return number of valid bits in bitstream */
+    if ((*pnOutputBits = FDKgetValidBits(&bitstream)) >
+        (outputBufferSize * 8)) {
+      error = SACENC_INVALID_CONFIG;
+      goto bail;
+    }
+
+    /* terminate buffer with alignment */
+    FDKbyteAlign(&bitstream, 0);
+
+  } /* valid handle */
+
+bail:
+  return error;
+}