Include patched FDK-AAC in the repository

The initial idea was to get the DAB+ patch into upstream, but since
that follows the android source releases, there is no place for a custom
DAB+ patch there.

So instead of having to maintain a patched fdk-aac that has to have the
same .so version as the distribution package on which it is installed,
we prefer having a separate fdk-aac-dab library to avoid collision.

At that point, there's no reason to keep fdk-aac in a separate
repository, as odr-audioenc is the only tool that needs DAB+ encoding
support. Including it here simplifies installation, and makes it
consistent with toolame-dab, also shipped in this repository.

DAB+ decoding support (needed by ODR-SourceCompanion, dablin, etisnoop,
welle.io and others) can be done using upstream FDK-AAC.

1 files changed, 826 insertions, 0 deletions

diff --git a/fdk-aac/libSACenc/src/sacenc_bitstream.cpp b/fdk-aac/libSACenc/src/sacenc_bitstream.cpp
new file mode 100644
index 0000000..dacfc27
--- /dev/null
+++ b/fdk-aac/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;
+}