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

diff --git a/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp b/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp
new file mode 100644
index 0000000..28bc22d
--- /dev/null
+++ b/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp
@@ -0,0 +1,2592 @@
+/* -----------------------------------------------------------------------------
+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 transport format decoder library *********************
+
+   Author(s):   Daniel Homm
+
+   Description:
+
+*******************************************************************************/
+
+#include "tpdec_lib.h"
+#include "tp_data.h"
+
+#include "FDK_crc.h"
+
+#include "common_fix.h"
+
+/**
+ * The following arrays provide the IDs of the consecutive elements for each
+ * channel configuration. Every channel_configuration has to be finalized with
+ * ID_NONE.
+ */
+static const MP4_ELEMENT_ID channel_configuration_0[] = {ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_1[] = {ID_SCE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_2[] = {ID_CPE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_3[] = {ID_SCE, ID_CPE,
+                                                         ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_4[] = {ID_SCE, ID_CPE, ID_SCE,
+                                                         ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_5[] = {ID_SCE, ID_CPE, ID_CPE,
+                                                         ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_6[] = {ID_SCE, ID_CPE, ID_CPE,
+                                                         ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_7[] = {
+    ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_8[] = {
+    ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_9[] = {
+    ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_10[] = {
+    ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_11[] = {
+    ID_SCE, ID_CPE, ID_CPE, ID_SCE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_12[] = {
+    ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_13[] = {
+    ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_CPE, ID_SCE, ID_LFE, ID_LFE, ID_SCE,
+    ID_CPE, ID_CPE, ID_SCE, ID_CPE, ID_SCE, ID_SCE, ID_CPE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_14[] = {
+    ID_SCE, ID_CPE, ID_CPE, ID_LFE, ID_CPE, ID_NONE};
+
+static const MP4_ELEMENT_ID *channel_configuration_array[] = {
+    channel_configuration_0,  channel_configuration_1,
+    channel_configuration_2,  channel_configuration_3,
+    channel_configuration_4,  channel_configuration_5,
+    channel_configuration_6,  channel_configuration_7,
+    channel_configuration_8,  channel_configuration_9,
+    channel_configuration_10, channel_configuration_11,
+    channel_configuration_12, channel_configuration_13,
+    channel_configuration_14};
+
+#define TP_USAC_MAX_CHANNEL_CONFIGURATION_INDEX (13)
+#define SC_CHANNEL_CONFIG_TAB_SIZE (TP_USAC_MAX_CHANNEL_CONFIGURATION_INDEX + 1)
+
+/* channel config structure used for sanity check */
+typedef struct {
+  SCHAR nCh;  /* number of channels */
+  SCHAR nSCE; /* number of SCE's */
+  SCHAR nCPE; /* number of CPE's */
+  SCHAR nLFE; /* number of LFE's */
+} SC_CHANNEL_CONFIG;
+
+static const SC_CHANNEL_CONFIG sc_chan_config_tab[SC_CHANNEL_CONFIG_TAB_SIZE] =
+    {
+        /* nCh, nSCE, nCPE, nLFE,     cci */
+        {0, 0, 0, 0}, /*  0 */
+        {1, 1, 0, 0}, /*  1 */
+        {2, 0, 1, 0}, /*  2 */
+        {3, 1, 1, 0}, /*  3 */
+        {4, 2, 1, 0}, /*  4 */
+        {5, 1, 2, 0}, /*  5 */
+        {6, 1, 2, 1}, /*  6 */
+        {8, 1, 3, 1}, /*  7 */
+        {2, 2, 0, 0}, /*  8 */
+        {3, 1, 1, 0}, /*  9 */
+        {4, 0, 2, 0}, /* 10 */
+        {7, 2, 2, 1}, /* 11 */
+        {8, 1, 3, 1}, /* 12 */
+        {24, 6, 8, 2} /* 13 */
+};
+
+void CProgramConfig_Reset(CProgramConfig *pPce) { pPce->elCounter = 0; }
+
+void CProgramConfig_Init(CProgramConfig *pPce) {
+  FDKmemclear(pPce, sizeof(CProgramConfig));
+  pPce->SamplingFrequencyIndex = 0xf;
+}
+
+int CProgramConfig_IsValid(const CProgramConfig *pPce) {
+  return ((pPce->isValid) ? 1 : 0);
+}
+
+#define PCE_HEIGHT_EXT_SYNC (0xAC)
+
+/*
+ * Read the extension for height info.
+ * return 0 if successfull,
+ *       -1 if the CRC failed,
+ *       -2 if invalid HeightInfo.
+ */
+static int CProgramConfig_ReadHeightExt(CProgramConfig *pPce,
+                                        HANDLE_FDK_BITSTREAM bs,
+                                        int *const bytesAvailable,
+                                        const UINT alignmentAnchor) {
+  int err = 0;
+  FDK_CRCINFO crcInfo; /* CRC state info */
+  INT crcReg;
+  FDKcrcInit(&crcInfo, 0x07, 0xFF, 8);
+  crcReg = FDKcrcStartReg(&crcInfo, bs, 0);
+  UINT startAnchor = FDKgetValidBits(bs);
+
+  FDK_ASSERT(pPce != NULL);
+  FDK_ASSERT(bs != NULL);
+  FDK_ASSERT(bytesAvailable != NULL);
+
+  if ((startAnchor >= 24) && (*bytesAvailable >= 3) &&
+      (FDKreadBits(bs, 8) == PCE_HEIGHT_EXT_SYNC)) {
+    int i;
+
+    for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+      if ((pPce->FrontElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+          PC_NUM_HEIGHT_LAYER) {
+        err = -2; /* height information is out of the valid range */
+      }
+    }
+    for (i = 0; i < pPce->NumSideChannelElements; i++) {
+      if ((pPce->SideElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+          PC_NUM_HEIGHT_LAYER) {
+        err = -2; /* height information is out of the valid range */
+      }
+    }
+    for (i = 0; i < pPce->NumBackChannelElements; i++) {
+      if ((pPce->BackElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+          PC_NUM_HEIGHT_LAYER) {
+        err = -2; /* height information is out of the valid range */
+      }
+    }
+    FDKbyteAlign(bs, alignmentAnchor);
+
+    FDKcrcEndReg(&crcInfo, bs, crcReg);
+    if ((USHORT)FDKreadBits(bs, 8) != FDKcrcGetCRC(&crcInfo)) {
+      /* CRC failed */
+      err = -1;
+    }
+    if (err != 0) {
+      /* Reset whole height information in case an error occured during parsing.
+         The return value ensures that pPce->isValid is set to 0 and implicit
+         channel mapping is used. */
+      FDKmemclear(pPce->FrontElementHeightInfo,
+                  sizeof(pPce->FrontElementHeightInfo));
+      FDKmemclear(pPce->SideElementHeightInfo,
+                  sizeof(pPce->SideElementHeightInfo));
+      FDKmemclear(pPce->BackElementHeightInfo,
+                  sizeof(pPce->BackElementHeightInfo));
+    }
+  } else {
+    /* No valid extension data found -> restore the initial bitbuffer state */
+    FDKpushBack(bs, (INT)startAnchor - (INT)FDKgetValidBits(bs));
+  }
+
+  /* Always report the bytes read. */
+  *bytesAvailable -= ((INT)startAnchor - (INT)FDKgetValidBits(bs)) >> 3;
+
+  return (err);
+}
+
+void CProgramConfig_Read(CProgramConfig *pPce, HANDLE_FDK_BITSTREAM bs,
+                         UINT alignmentAnchor) {
+  int i, err = 0;
+  int commentBytes;
+
+  pPce->NumEffectiveChannels = 0;
+  pPce->NumChannels = 0;
+  pPce->ElementInstanceTag = (UCHAR)FDKreadBits(bs, 4);
+  pPce->Profile = (UCHAR)FDKreadBits(bs, 2);
+  pPce->SamplingFrequencyIndex = (UCHAR)FDKreadBits(bs, 4);
+  pPce->NumFrontChannelElements = (UCHAR)FDKreadBits(bs, 4);
+  pPce->NumSideChannelElements = (UCHAR)FDKreadBits(bs, 4);
+  pPce->NumBackChannelElements = (UCHAR)FDKreadBits(bs, 4);
+  pPce->NumLfeChannelElements = (UCHAR)FDKreadBits(bs, 2);
+  pPce->NumAssocDataElements = (UCHAR)FDKreadBits(bs, 3);
+  pPce->NumValidCcElements = (UCHAR)FDKreadBits(bs, 4);
+
+  if ((pPce->MonoMixdownPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+    pPce->MonoMixdownElementNumber = (UCHAR)FDKreadBits(bs, 4);
+  }
+
+  if ((pPce->StereoMixdownPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+    pPce->StereoMixdownElementNumber = (UCHAR)FDKreadBits(bs, 4);
+  }
+
+  if ((pPce->MatrixMixdownIndexPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+    pPce->MatrixMixdownIndex = (UCHAR)FDKreadBits(bs, 2);
+    pPce->PseudoSurroundEnable = (UCHAR)FDKreadBits(bs, 1);
+  }
+
+  for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+    pPce->FrontElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+    pPce->FrontElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+    pPce->NumChannels += pPce->FrontElementIsCpe[i] ? 2 : 1;
+  }
+
+  for (i = 0; i < pPce->NumSideChannelElements; i++) {
+    pPce->SideElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+    pPce->SideElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+    pPce->NumChannels += pPce->SideElementIsCpe[i] ? 2 : 1;
+  }
+
+  for (i = 0; i < pPce->NumBackChannelElements; i++) {
+    pPce->BackElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+    pPce->BackElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+    pPce->NumChannels += pPce->BackElementIsCpe[i] ? 2 : 1;
+  }
+
+  pPce->NumEffectiveChannels = pPce->NumChannels;
+
+  for (i = 0; i < pPce->NumLfeChannelElements; i++) {
+    pPce->LfeElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+    pPce->NumChannels += 1;
+  }
+
+  for (i = 0; i < pPce->NumAssocDataElements; i++) {
+    pPce->AssocDataElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+  }
+
+  for (i = 0; i < pPce->NumValidCcElements; i++) {
+    pPce->CcElementIsIndSw[i] = (UCHAR)FDKreadBits(bs, 1);
+    pPce->ValidCcElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+  }
+
+  FDKbyteAlign(bs, alignmentAnchor);
+
+  pPce->CommentFieldBytes = (UCHAR)FDKreadBits(bs, 8);
+  commentBytes = pPce->CommentFieldBytes;
+
+  /* Search for height info extension and read it if available */
+  err = CProgramConfig_ReadHeightExt(pPce, bs, &commentBytes, alignmentAnchor);
+
+  for (i = 0; i < commentBytes; i++) {
+    UCHAR text;
+
+    text = (UCHAR)FDKreadBits(bs, 8);
+
+    if (i < PC_COMMENTLENGTH) {
+      pPce->Comment[i] = text;
+    }
+  }
+
+  pPce->isValid = (err) ? 0 : 1;
+}
+
+/*
+ * Compare two program configurations.
+ * Returns the result of the comparison:
+ *  -1 - completely different
+ *   0 - completely equal
+ *   1 - different but same channel configuration
+ *   2 - different channel configuration but same number of channels
+ */
+int CProgramConfig_Compare(const CProgramConfig *const pPce1,
+                           const CProgramConfig *const pPce2) {
+  int result = 0; /* Innocent until proven false. */
+
+  if (FDKmemcmp(pPce1, pPce2, sizeof(CProgramConfig)) !=
+      0) { /* Configurations are not completely equal.
+              So look into details and analyse the channel configurations: */
+    result = -1;
+
+    if (pPce1->NumChannels ==
+        pPce2->NumChannels) { /* Now the logic changes. We first assume to have
+                                 the same channel configuration and then prove
+                                 if this assumption is true. */
+      result = 1;
+
+      /* Front channels */
+      if (pPce1->NumFrontChannelElements != pPce2->NumFrontChannelElements) {
+        result = 2; /* different number of front channel elements */
+      } else {
+        int el, numCh1 = 0, numCh2 = 0;
+        for (el = 0; el < pPce1->NumFrontChannelElements; el += 1) {
+          if (pPce1->FrontElementHeightInfo[el] !=
+              pPce2->FrontElementHeightInfo[el]) {
+            result = 2; /* different height info */
+            break;
+          }
+          numCh1 += pPce1->FrontElementIsCpe[el] ? 2 : 1;
+          numCh2 += pPce2->FrontElementIsCpe[el] ? 2 : 1;
+        }
+        if (numCh1 != numCh2) {
+          result = 2; /* different number of front channels */
+        }
+      }
+      /* Side channels */
+      if (pPce1->NumSideChannelElements != pPce2->NumSideChannelElements) {
+        result = 2; /* different number of side channel elements */
+      } else {
+        int el, numCh1 = 0, numCh2 = 0;
+        for (el = 0; el < pPce1->NumSideChannelElements; el += 1) {
+          if (pPce1->SideElementHeightInfo[el] !=
+              pPce2->SideElementHeightInfo[el]) {
+            result = 2; /* different height info */
+            break;
+          }
+          numCh1 += pPce1->SideElementIsCpe[el] ? 2 : 1;
+          numCh2 += pPce2->SideElementIsCpe[el] ? 2 : 1;
+        }
+        if (numCh1 != numCh2) {
+          result = 2; /* different number of side channels */
+        }
+      }
+      /* Back channels */
+      if (pPce1->NumBackChannelElements != pPce2->NumBackChannelElements) {
+        result = 2; /* different number of back channel elements */
+      } else {
+        int el, numCh1 = 0, numCh2 = 0;
+        for (el = 0; el < pPce1->NumBackChannelElements; el += 1) {
+          if (pPce1->BackElementHeightInfo[el] !=
+              pPce2->BackElementHeightInfo[el]) {
+            result = 2; /* different height info */
+            break;
+          }
+          numCh1 += pPce1->BackElementIsCpe[el] ? 2 : 1;
+          numCh2 += pPce2->BackElementIsCpe[el] ? 2 : 1;
+        }
+        if (numCh1 != numCh2) {
+          result = 2; /* different number of back channels */
+        }
+      }
+      /* LFE channels */
+      if (pPce1->NumLfeChannelElements != pPce2->NumLfeChannelElements) {
+        result = 2; /* different number of lfe channels */
+      }
+      /* LFEs are always SCEs so we don't need to count the channels. */
+    }
+  }
+
+  return result;
+}
+
+void CProgramConfig_GetDefault(CProgramConfig *pPce, const UINT channelConfig) {
+  FDK_ASSERT(pPce != NULL);
+
+  /* Init PCE */
+  CProgramConfig_Init(pPce);
+  pPce->Profile =
+      1; /* Set AAC LC because it is the only supported object type. */
+
+  switch (channelConfig) {
+    /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+    case 32: /* 7.1 side channel configuration as defined in FDK_audio.h */
+      pPce->NumFrontChannelElements = 2;
+      pPce->FrontElementIsCpe[0] = 0;
+      pPce->FrontElementIsCpe[1] = 1;
+      pPce->NumSideChannelElements = 1;
+      pPce->SideElementIsCpe[0] = 1;
+      pPce->NumBackChannelElements = 1;
+      pPce->BackElementIsCpe[0] = 1;
+      pPce->NumLfeChannelElements = 1;
+      pPce->NumChannels = 8;
+      pPce->NumEffectiveChannels = 7;
+      pPce->isValid = 1;
+      break;
+    /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+    case 12: /* 3/0/4.1ch surround back */
+      pPce->BackElementIsCpe[1] = 1;
+      pPce->NumChannels += 1;
+      pPce->NumEffectiveChannels += 1;
+      FDK_FALLTHROUGH;
+    case 11: /* 3/0/3.1ch */
+      pPce->NumFrontChannelElements += 2;
+      pPce->FrontElementIsCpe[0] = 0;
+      pPce->FrontElementIsCpe[1] = 1;
+      pPce->NumBackChannelElements += 2;
+      pPce->BackElementIsCpe[0] = 1;
+      pPce->BackElementIsCpe[1] += 0;
+      pPce->NumLfeChannelElements += 1;
+      pPce->NumChannels += 7;
+      pPce->NumEffectiveChannels += 6;
+      pPce->isValid = 1;
+      break;
+    /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+    case 14:                               /* 2/0/0-3/0/2-0.1ch front height */
+      pPce->FrontElementHeightInfo[2] = 1; /* Top speaker */
+      FDK_FALLTHROUGH;
+    case 7: /* 5/0/2.1ch front */
+      pPce->NumFrontChannelElements += 1;
+      pPce->FrontElementIsCpe[2] = 1;
+      pPce->NumChannels += 2;
+      pPce->NumEffectiveChannels += 2;
+      FDK_FALLTHROUGH;
+    case 6: /* 3/0/2.1ch */
+      pPce->NumLfeChannelElements += 1;
+      pPce->NumChannels += 1;
+      FDK_FALLTHROUGH;
+    case 5: /* 3/0/2.0ch */
+    case 4: /* 3/0/1.0ch */
+      pPce->NumBackChannelElements += 1;
+      pPce->BackElementIsCpe[0] = (channelConfig > 4) ? 1 : 0;
+      pPce->NumChannels += (channelConfig > 4) ? 2 : 1;
+      pPce->NumEffectiveChannels += (channelConfig > 4) ? 2 : 1;
+      FDK_FALLTHROUGH;
+    case 3: /* 3/0/0.0ch */
+      pPce->NumFrontChannelElements += 1;
+      pPce->FrontElementIsCpe[1] = 1;
+      pPce->NumChannels += 2;
+      pPce->NumEffectiveChannels += 2;
+      FDK_FALLTHROUGH;
+    case 1: /* 1/0/0.0ch */
+      pPce->NumFrontChannelElements += 1;
+      pPce->FrontElementIsCpe[0] = 0;
+      pPce->NumChannels += 1;
+      pPce->NumEffectiveChannels += 1;
+      pPce->isValid = 1;
+      break;
+    /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+    case 2: /* 2/0/0.ch */
+      pPce->NumFrontChannelElements = 1;
+      pPce->FrontElementIsCpe[0] = 1;
+      pPce->NumChannels += 2;
+      pPce->NumEffectiveChannels += 2;
+      pPce->isValid = 1;
+      break;
+    /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+    default:
+      pPce->isValid = 0; /* To be explicit! */
+      break;
+  }
+
+  if (pPce->isValid) {
+    /* Create valid element instance tags */
+    int el, elTagSce = 0, elTagCpe = 0;
+
+    for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+      pPce->FrontElementTagSelect[el] =
+          (pPce->FrontElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+    }
+    for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+      pPce->SideElementTagSelect[el] =
+          (pPce->SideElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+    }
+    for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+      pPce->BackElementTagSelect[el] =
+          (pPce->BackElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+    }
+    elTagSce = 0;
+    for (el = 0; el < pPce->NumLfeChannelElements; el += 1) {
+      pPce->LfeElementTagSelect[el] = elTagSce++;
+    }
+  }
+}
+
+/**
+ * \brief get implicit audio channel type for given channelConfig and MPEG
+ * ordered channel index
+ * \param channelConfig MPEG channelConfiguration from 1 upto 14
+ * \param index MPEG channel order index
+ * \return audio channel type.
+ */
+static void getImplicitAudioChannelTypeAndIndex(AUDIO_CHANNEL_TYPE *chType,
+                                                UCHAR *chIndex,
+                                                UINT channelConfig,
+                                                UINT index) {
+  if (index < 3) {
+    *chType = ACT_FRONT;
+    *chIndex = index;
+  } else {
+    switch (channelConfig) {
+      case 4: /* SCE, CPE, SCE */
+      case 5: /* SCE, CPE, CPE */
+      case 6: /* SCE, CPE, CPE, LFE */
+        switch (index) {
+          case 3:
+          case 4:
+            *chType = ACT_BACK;
+            *chIndex = index - 3;
+            break;
+          case 5:
+            *chType = ACT_LFE;
+            *chIndex = 0;
+            break;
+        }
+        break;
+      case 7: /* SCE,CPE,CPE,CPE,LFE */
+        switch (index) {
+          case 3:
+          case 4:
+            *chType = ACT_FRONT;
+            *chIndex = index;
+            break;
+          case 5:
+          case 6:
+            *chType = ACT_BACK;
+            *chIndex = index - 5;
+            break;
+          case 7:
+            *chType = ACT_LFE;
+            *chIndex = 0;
+            break;
+        }
+        break;
+      case 11: /* SCE,CPE,CPE,SCE,LFE */
+        if (index < 6) {
+          *chType = ACT_BACK;
+          *chIndex = index - 3;
+        } else {
+          *chType = ACT_LFE;
+          *chIndex = 0;
+        }
+        break;
+      case 12: /* SCE,CPE,CPE,CPE,LFE */
+        if (index < 7) {
+          *chType = ACT_BACK;
+          *chIndex = index - 3;
+        } else {
+          *chType = ACT_LFE;
+          *chIndex = 0;
+        }
+        break;
+      case 14: /* SCE,CPE,CPE,LFE,CPE */
+        switch (index) {
+          case 3:
+          case 4:
+            *chType = ACT_BACK;
+            *chIndex = index - 3;
+            break;
+          case 5:
+            *chType = ACT_LFE;
+            *chIndex = 0;
+            break;
+          case 6:
+          case 7:
+            *chType = ACT_FRONT_TOP;
+            *chIndex = index - 6; /* handle the top layer independently */
+            break;
+        }
+        break;
+      default:
+        *chType = ACT_NONE;
+        break;
+    }
+  }
+}
+
+int CProgramConfig_LookupElement(CProgramConfig *pPce, UINT channelConfig,
+                                 const UINT tag, const UINT channelIdx,
+                                 UCHAR chMapping[], AUDIO_CHANNEL_TYPE chType[],
+                                 UCHAR chIndex[], const UINT chDescrLen,
+                                 UCHAR *elMapping, MP4_ELEMENT_ID elList[],
+                                 MP4_ELEMENT_ID elType) {
+  if (channelConfig > 0) {
+    /* Constant channel mapping must have
+       been set during initialization. */
+    if (IS_CHANNEL_ELEMENT(elType)) {
+      *elMapping = pPce->elCounter;
+      if (elList[pPce->elCounter] != elType &&
+          !IS_USAC_CHANNEL_ELEMENT(elType)) {
+        /* Not in the list */
+        if ((channelConfig == 2) &&
+            (elType == ID_SCE)) { /* This scenario occurs with HE-AAC v2 streams
+                                     of buggy encoders. In other decoder
+                                     implementations decoding of this kind of
+                                     streams is desired. */
+          channelConfig = 1;
+        } else if ((elList[pPce->elCounter] == ID_LFE) &&
+                   (elType ==
+                    ID_SCE)) { /* Decode bitstreams which wrongly use ID_SCE
+                                  instead of ID_LFE element type. */
+          ;
+        } else {
+          return 0;
+        }
+      }
+      /* Assume all front channels */
+      getImplicitAudioChannelTypeAndIndex(
+          &chType[channelIdx], &chIndex[channelIdx], channelConfig, channelIdx);
+      if (elType == ID_CPE || elType == ID_USAC_CPE) {
+        chType[channelIdx + 1] = chType[channelIdx];
+        chIndex[channelIdx + 1] = chIndex[channelIdx] + 1;
+      }
+      pPce->elCounter++;
+    }
+    /* Accept all non-channel elements, too. */
+    return 1;
+  } else {
+    if ((!pPce->isValid) || (pPce->NumChannels > chDescrLen)) {
+      /* Implicit channel mapping. */
+      if (IS_USAC_CHANNEL_ELEMENT(elType)) {
+        *elMapping = pPce->elCounter++;
+      } else if (IS_MP4_CHANNEL_ELEMENT(elType)) {
+        /* Store all channel element IDs */
+        elList[pPce->elCounter] = elType;
+        *elMapping = pPce->elCounter++;
+      }
+    } else {
+      /* Accept the additional channel(s), only if the tag is in the lists */
+      int isCpe = 0, i;
+      /* Element counter */
+      int ec[PC_NUM_HEIGHT_LAYER] = {0};
+      /* Channel counters */
+      int cc[PC_NUM_HEIGHT_LAYER] = {0};
+      int fc[PC_NUM_HEIGHT_LAYER] = {0}; /* front channel counter */
+      int sc[PC_NUM_HEIGHT_LAYER] = {0}; /* side channel counter */
+      int bc[PC_NUM_HEIGHT_LAYER] = {0}; /* back channel counter */
+      int lc = 0;                        /* lfe channel counter */
+
+      /* General MPEG (PCE) composition rules:
+         - Over all:
+             <normal height channels><top height channels><bottom height
+         channels>
+         - Within each height layer:
+             <front channels><side channels><back channels>
+         - Exception:
+             The LFE channels have no height info and thus they are arranged at
+         the very end of the normal height layer channels.
+       */
+
+      switch (elType) {
+        case ID_CPE:
+          isCpe = 1;
+          FDK_FALLTHROUGH;
+        case ID_SCE:
+          /* search in front channels */
+          for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+            int heightLayer = pPce->FrontElementHeightInfo[i];
+            if (isCpe == pPce->FrontElementIsCpe[i] &&
+                pPce->FrontElementTagSelect[i] == tag) {
+              int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+              AUDIO_CHANNEL_TYPE aChType =
+                  (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_FRONT);
+              for (h = heightLayer - 1; h >= 0; h -= 1) {
+                int el;
+                /* Count front channels/elements */
+                for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+                  if (pPce->FrontElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count side channels/elements */
+                for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+                  if (pPce->SideElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count back channels/elements */
+                for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+                  if (pPce->BackElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                if (h == 0) { /* normal height */
+                  elIdx += pPce->NumLfeChannelElements;
+                  chIdx += pPce->NumLfeChannelElements;
+                }
+              }
+              chMapping[chIdx] = channelIdx;
+              chType[chIdx] = aChType;
+              chIndex[chIdx] = fc[heightLayer];
+              if (isCpe) {
+                chMapping[chIdx + 1] = channelIdx + 1;
+                chType[chIdx + 1] = aChType;
+                chIndex[chIdx + 1] = fc[heightLayer] + 1;
+              }
+              *elMapping = elIdx;
+              return 1;
+            }
+            ec[heightLayer] += 1;
+            if (pPce->FrontElementIsCpe[i]) {
+              cc[heightLayer] += 2;
+              fc[heightLayer] += 2;
+            } else {
+              cc[heightLayer] += 1;
+              fc[heightLayer] += 1;
+            }
+          }
+          /* search in side channels */
+          for (i = 0; i < pPce->NumSideChannelElements; i++) {
+            int heightLayer = pPce->SideElementHeightInfo[i];
+            if (isCpe == pPce->SideElementIsCpe[i] &&
+                pPce->SideElementTagSelect[i] == tag) {
+              int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+              AUDIO_CHANNEL_TYPE aChType =
+                  (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_SIDE);
+              for (h = heightLayer - 1; h >= 0; h -= 1) {
+                int el;
+                /* Count front channels/elements */
+                for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+                  if (pPce->FrontElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count side channels/elements */
+                for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+                  if (pPce->SideElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count back channels/elements */
+                for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+                  if (pPce->BackElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                if (h ==
+                    0) { /* LFE channels belong to the normal height layer */
+                  elIdx += pPce->NumLfeChannelElements;
+                  chIdx += pPce->NumLfeChannelElements;
+                }
+              }
+              chMapping[chIdx] = channelIdx;
+              chType[chIdx] = aChType;
+              chIndex[chIdx] = sc[heightLayer];
+              if (isCpe) {
+                chMapping[chIdx + 1] = channelIdx + 1;
+                chType[chIdx + 1] = aChType;
+                chIndex[chIdx + 1] = sc[heightLayer] + 1;
+              }
+              *elMapping = elIdx;
+              return 1;
+            }
+            ec[heightLayer] += 1;
+            if (pPce->SideElementIsCpe[i]) {
+              cc[heightLayer] += 2;
+              sc[heightLayer] += 2;
+            } else {
+              cc[heightLayer] += 1;
+              sc[heightLayer] += 1;
+            }
+          }
+          /* search in back channels */
+          for (i = 0; i < pPce->NumBackChannelElements; i++) {
+            int heightLayer = pPce->BackElementHeightInfo[i];
+            if (isCpe == pPce->BackElementIsCpe[i] &&
+                pPce->BackElementTagSelect[i] == tag) {
+              int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+              AUDIO_CHANNEL_TYPE aChType =
+                  (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_BACK);
+              for (h = heightLayer - 1; h >= 0; h -= 1) {
+                int el;
+                /* Count front channels/elements */
+                for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+                  if (pPce->FrontElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count side channels/elements */
+                for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+                  if (pPce->SideElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                /* Count back channels/elements */
+                for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+                  if (pPce->BackElementHeightInfo[el] == h) {
+                    elIdx += 1;
+                    chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+                  }
+                }
+                if (h == 0) { /* normal height */
+                  elIdx += pPce->NumLfeChannelElements;
+                  chIdx += pPce->NumLfeChannelElements;
+                }
+              }
+              chMapping[chIdx] = channelIdx;
+              chType[chIdx] = aChType;
+              chIndex[chIdx] = bc[heightLayer];
+              if (isCpe) {
+                chMapping[chIdx + 1] = channelIdx + 1;
+                chType[chIdx + 1] = aChType;
+                chIndex[chIdx + 1] = bc[heightLayer] + 1;
+              }
+              *elMapping = elIdx;
+              return 1;
+            }
+            ec[heightLayer] += 1;
+            if (pPce->BackElementIsCpe[i]) {
+              cc[heightLayer] += 2;
+              bc[heightLayer] += 2;
+            } else {
+              cc[heightLayer] += 1;
+              bc[heightLayer] += 1;
+            }
+          }
+          break;
+
+        case ID_LFE: { /* Unfortunately we have to go through all normal height
+                          layer elements to get the position of the LFE
+                          channels. Start with counting the front
+                          channels/elements at normal height */
+          for (i = 0; i < pPce->NumFrontChannelElements; i += 1) {
+            int heightLayer = pPce->FrontElementHeightInfo[i];
+            ec[heightLayer] += 1;
+            cc[heightLayer] += (pPce->FrontElementIsCpe[i]) ? 2 : 1;
+          }
+          /* Count side channels/elements at normal height */
+          for (i = 0; i < pPce->NumSideChannelElements; i += 1) {
+            int heightLayer = pPce->SideElementHeightInfo[i];
+            ec[heightLayer] += 1;
+            cc[heightLayer] += (pPce->SideElementIsCpe[i]) ? 2 : 1;
+          }
+          /* Count back channels/elements at normal height */
+          for (i = 0; i < pPce->NumBackChannelElements; i += 1) {
+            int heightLayer = pPce->BackElementHeightInfo[i];
+            ec[heightLayer] += 1;
+            cc[heightLayer] += (pPce->BackElementIsCpe[i]) ? 2 : 1;
+          }
+
+          /* search in lfe channels */
+          for (i = 0; i < pPce->NumLfeChannelElements; i++) {
+            int elIdx =
+                ec[0]; /* LFE channels belong to the normal height layer */
+            int chIdx = cc[0];
+            if (pPce->LfeElementTagSelect[i] == tag) {
+              chMapping[chIdx] = channelIdx;
+              *elMapping = elIdx;
+              chType[chIdx] = ACT_LFE;
+              chIndex[chIdx] = lc;
+              return 1;
+            }
+            ec[0] += 1;
+            cc[0] += 1;
+            lc += 1;
+          }
+        } break;
+
+        /* Non audio elements */
+        case ID_CCE:
+          /* search in cce channels */
+          for (i = 0; i < pPce->NumValidCcElements; i++) {
+            if (pPce->ValidCcElementTagSelect[i] == tag) {
+              return 1;
+            }
+          }
+          break;
+        case ID_DSE:
+          /* search associated data elements */
+          for (i = 0; i < pPce->NumAssocDataElements; i++) {
+            if (pPce->AssocDataElementTagSelect[i] == tag) {
+              return 1;
+            }
+          }
+          break;
+        default:
+          return 0;
+      }
+      return 0; /* not found in any list */
+    }
+  }
+
+  return 1;
+}
+
+#define SPEAKER_PLANE_NORMAL 0
+#define SPEAKER_PLANE_TOP 1
+#define SPEAKER_PLANE_BOTTOM 2
+
+void CProgramConfig_GetChannelDescription(const UINT chConfig,
+                                          const CProgramConfig *pPce,
+                                          AUDIO_CHANNEL_TYPE chType[],
+                                          UCHAR chIndex[]) {
+  FDK_ASSERT(chType != NULL);
+  FDK_ASSERT(chIndex != NULL);
+
+  if ((chConfig == 0) && (pPce != NULL)) {
+    if (pPce->isValid) {
+      int spkPlane, chIdx = 0;
+      for (spkPlane = SPEAKER_PLANE_NORMAL; spkPlane <= SPEAKER_PLANE_BOTTOM;
+           spkPlane += 1) {
+        int elIdx, grpChIdx = 0;
+        for (elIdx = 0; elIdx < pPce->NumFrontChannelElements; elIdx += 1) {
+          if (pPce->FrontElementHeightInfo[elIdx] == spkPlane) {
+            chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_FRONT);
+            chIndex[chIdx++] = grpChIdx++;
+            if (pPce->FrontElementIsCpe[elIdx]) {
+              chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_FRONT);
+              chIndex[chIdx++] = grpChIdx++;
+            }
+          }
+        }
+        grpChIdx = 0;
+        for (elIdx = 0; elIdx < pPce->NumSideChannelElements; elIdx += 1) {
+          if (pPce->SideElementHeightInfo[elIdx] == spkPlane) {
+            chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_SIDE);
+            chIndex[chIdx++] = grpChIdx++;
+            if (pPce->SideElementIsCpe[elIdx]) {
+              chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_SIDE);
+              chIndex[chIdx++] = grpChIdx++;
+            }
+          }
+        }
+        grpChIdx = 0;
+        for (elIdx = 0; elIdx < pPce->NumBackChannelElements; elIdx += 1) {
+          if (pPce->BackElementHeightInfo[elIdx] == spkPlane) {
+            chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_BACK);
+            chIndex[chIdx++] = grpChIdx++;
+            if (pPce->BackElementIsCpe[elIdx]) {
+              chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_BACK);
+              chIndex[chIdx++] = grpChIdx++;
+            }
+          }
+        }
+        grpChIdx = 0;
+        if (spkPlane == SPEAKER_PLANE_NORMAL) {
+          for (elIdx = 0; elIdx < pPce->NumLfeChannelElements; elIdx += 1) {
+            chType[chIdx] = ACT_LFE;
+            chIndex[chIdx++] = grpChIdx++;
+          }
+        }
+      }
+    }
+  } else {
+    int chIdx;
+    for (chIdx = 0; chIdx < getNumberOfTotalChannels(chConfig); chIdx += 1) {
+      getImplicitAudioChannelTypeAndIndex(&chType[chIdx], &chIndex[chIdx],
+                                          chConfig, chIdx);
+    }
+  }
+}
+
+int CProgramConfig_GetPceChMap(const CProgramConfig *pPce, UCHAR pceChMap[],
+                               const UINT pceChMapLen) {
+  const UCHAR *nElements = &pPce->NumFrontChannelElements;
+  const UCHAR *elHeight[3], *elIsCpe[3];
+  unsigned chIdx, plane, grp, offset, totCh[3], numCh[3][4];
+
+  FDK_ASSERT(pPce != NULL);
+  FDK_ASSERT(pceChMap != NULL);
+
+  /* Init counter: */
+  FDKmemclear(totCh, 3 * sizeof(unsigned));
+  FDKmemclear(numCh, 3 * 4 * sizeof(unsigned));
+
+  /* Analyse PCE: */
+  elHeight[0] = pPce->FrontElementHeightInfo;
+  elIsCpe[0] = pPce->FrontElementIsCpe;
+  elHeight[1] = pPce->SideElementHeightInfo;
+  elIsCpe[1] = pPce->SideElementIsCpe;
+  elHeight[2] = pPce->BackElementHeightInfo;
+  elIsCpe[2] = pPce->BackElementIsCpe;
+
+  for (plane = 0; plane <= SPEAKER_PLANE_BOTTOM; plane += 1) {
+    for (grp = 0; grp < 3; grp += 1) { /* front, side, back */
+      unsigned el;
+      for (el = 0; el < nElements[grp]; el += 1) {
+        if (elHeight[grp][el] == plane) {
+          unsigned elCh = elIsCpe[grp][el] ? 2 : 1;
+          numCh[plane][grp] += elCh;
+          totCh[plane] += elCh;
+        }
+      }
+    }
+    if (plane == SPEAKER_PLANE_NORMAL) {
+      unsigned elCh = pPce->NumLfeChannelElements;
+      numCh[plane][grp] += elCh;
+      totCh[plane] += elCh;
+    }
+  }
+  /* Sanity checks: */
+  chIdx = totCh[SPEAKER_PLANE_NORMAL] + totCh[SPEAKER_PLANE_TOP] +
+          totCh[SPEAKER_PLANE_BOTTOM];
+  if (chIdx > pceChMapLen) {
+    return -1;
+  }
+
+  /* Create map: */
+  offset = grp = 0;
+  unsigned grpThresh = numCh[SPEAKER_PLANE_NORMAL][grp];
+  for (chIdx = 0; chIdx < totCh[SPEAKER_PLANE_NORMAL]; chIdx += 1) {
+    while ((chIdx >= grpThresh) && (grp < 3)) {
+      offset += numCh[1][grp] + numCh[2][grp];
+      grp += 1;
+      grpThresh += numCh[SPEAKER_PLANE_NORMAL][grp];
+    }
+    pceChMap[chIdx] = chIdx + offset;
+  }
+  offset = 0;
+  for (grp = 0; grp < 4; grp += 1) { /* front, side, back and lfe */
+    offset += numCh[SPEAKER_PLANE_NORMAL][grp];
+    for (plane = SPEAKER_PLANE_TOP; plane <= SPEAKER_PLANE_BOTTOM; plane += 1) {
+      unsigned mapCh;
+      for (mapCh = 0; mapCh < numCh[plane][grp]; mapCh += 1) {
+        pceChMap[chIdx++] = offset;
+        offset += 1;
+      }
+    }
+  }
+  return 0;
+}
+
+int CProgramConfig_GetElementTable(const CProgramConfig *pPce,
+                                   MP4_ELEMENT_ID elList[],
+                                   const INT elListSize, UCHAR *pChMapIdx) {
+  int i, el = 0;
+
+  FDK_ASSERT(elList != NULL);
+  FDK_ASSERT(pChMapIdx != NULL);
+  FDK_ASSERT(pPce != NULL);
+
+  *pChMapIdx = 0;
+
+  if ((elListSize <
+       pPce->NumFrontChannelElements + pPce->NumSideChannelElements +
+           pPce->NumBackChannelElements + pPce->NumLfeChannelElements) ||
+      (pPce->NumChannels == 0)) {
+    return 0;
+  }
+
+  for (i = 0; i < pPce->NumFrontChannelElements; i += 1) {
+    elList[el++] = (pPce->FrontElementIsCpe[i]) ? ID_CPE : ID_SCE;
+  }
+
+  for (i = 0; i < pPce->NumSideChannelElements; i += 1) {
+    elList[el++] = (pPce->SideElementIsCpe[i]) ? ID_CPE : ID_SCE;
+  }
+
+  for (i = 0; i < pPce->NumBackChannelElements; i += 1) {
+    elList[el++] = (pPce->BackElementIsCpe[i]) ? ID_CPE : ID_SCE;
+  }
+
+  for (i = 0; i < pPce->NumLfeChannelElements; i += 1) {
+    elList[el++] = ID_LFE;
+  }
+
+  /* Find an corresponding channel configuration if possible */
+  switch (pPce->NumChannels) {
+    case 1:
+    case 2:
+      /* One and two channels have no alternatives. */
+      *pChMapIdx = pPce->NumChannels;
+      break;
+    case 3:
+    case 4:
+    case 5:
+    case 6: { /* Test if the number of channels can be used as channel config:
+               */
+      C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+      /* Create a PCE for the config to test ... */
+      CProgramConfig_GetDefault(tmpPce, pPce->NumChannels);
+      /* ... and compare it with the given one. */
+      *pChMapIdx = (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE))
+                       ? pPce->NumChannels
+                       : 0;
+      /* If compare result is 0 or 1 we can be sure that it is channel
+       * config 11. */
+      C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+    } break;
+    case 7: {
+      C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+      /* Create a PCE for the config to test ... */
+      CProgramConfig_GetDefault(tmpPce, 11);
+      /* ... and compare it with the given one. */
+      *pChMapIdx = (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE)) ? 11 : 0;
+      /* If compare result is 0 or 1 we can be sure that it is channel
+       * config 11. */
+      C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+    } break;
+    case 8: { /* Try the four possible 7.1ch configurations. One after the
+                 other. */
+      UCHAR testCfg[4] = {32, 14, 12, 7};
+      C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+      for (i = 0; i < 4; i += 1) {
+        /* Create a PCE for the config to test ... */
+        CProgramConfig_GetDefault(tmpPce, testCfg[i]);
+        /* ... and compare it with the given one. */
+        if (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE)) {
+          /* If the compare result is 0 or 1 than the two channel configurations
+           * match. */
+          /* Explicit mapping of 7.1 side channel configuration to 7.1 rear
+           * channel mapping. */
+          *pChMapIdx = (testCfg[i] == 32) ? 12 : testCfg[i];
+        }
+      }
+      C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+    } break;
+    default:
+      /* The PCE does not match any predefined channel configuration. */
+      *pChMapIdx = 0;
+      break;
+  }
+
+  return el;
+}
+
+static AUDIO_OBJECT_TYPE getAOT(HANDLE_FDK_BITSTREAM bs) {
+  int tmp = 0;
+
+  tmp = FDKreadBits(bs, 5);
+  if (tmp == AOT_ESCAPE) {
+    int tmp2 = FDKreadBits(bs, 6);
+    tmp = 32 + tmp2;
+  }
+
+  return (AUDIO_OBJECT_TYPE)tmp;
+}
+
+static INT getSampleRate(HANDLE_FDK_BITSTREAM bs, UCHAR *index, int nBits) {
+  INT sampleRate;
+  int idx;
+
+  idx = FDKreadBits(bs, nBits);
+  if (idx == (1 << nBits) - 1) {
+    if (FDKgetValidBits(bs) < 24) {
+      return 0;
+    }
+    sampleRate = FDKreadBits(bs, 24);
+  } else {
+    sampleRate = SamplingRateTable[idx];
+  }
+
+  *index = idx;
+
+  return sampleRate;
+}
+
+static TRANSPORTDEC_ERROR GaSpecificConfig_Parse(CSGaSpecificConfig *self,
+                                                 CSAudioSpecificConfig *asc,
+                                                 HANDLE_FDK_BITSTREAM bs,
+                                                 UINT ascStartAnchor) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+  self->m_frameLengthFlag = FDKreadBits(bs, 1);
+
+  self->m_dependsOnCoreCoder = FDKreadBits(bs, 1);
+
+  if (self->m_dependsOnCoreCoder) self->m_coreCoderDelay = FDKreadBits(bs, 14);
+
+  self->m_extensionFlag = FDKreadBits(bs, 1);
+
+  if (asc->m_channelConfiguration == 0) {
+    CProgramConfig_Read(&asc->m_progrConfigElement, bs, ascStartAnchor);
+  }
+
+  if ((asc->m_aot == AOT_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_SCAL)) {
+    self->m_layer = FDKreadBits(bs, 3);
+  }
+
+  if (self->m_extensionFlag) {
+    if (asc->m_aot == AOT_ER_BSAC) {
+      self->m_numOfSubFrame = FDKreadBits(bs, 5);
+      self->m_layerLength = FDKreadBits(bs, 11);
+    }
+
+    if ((asc->m_aot == AOT_ER_AAC_LC) || (asc->m_aot == AOT_ER_AAC_LTP) ||
+        (asc->m_aot == AOT_ER_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_LD)) {
+      asc->m_vcb11Flag = FDKreadBits(bs, 1); /* aacSectionDataResilienceFlag */
+      asc->m_rvlcFlag =
+          FDKreadBits(bs, 1); /* aacScalefactorDataResilienceFlag */
+      asc->m_hcrFlag = FDKreadBits(bs, 1); /* aacSpectralDataResilienceFlag */
+    }
+
+    self->m_extensionFlag3 = FDKreadBits(bs, 1);
+  }
+  return (ErrorStatus);
+}
+
+static INT skipSbrHeader(HANDLE_FDK_BITSTREAM hBs, int isUsac) {
+  /* Dummy parse SbrDfltHeader() */
+  INT dflt_header_extra1, dflt_header_extra2, bitsToSkip = 0;
+
+  if (!isUsac) {
+    bitsToSkip = 6;
+    FDKpushFor(hBs, 6); /* amp res 1, xover freq 3, reserved 2 */
+  }
+  bitsToSkip += 8;
+  FDKpushFor(hBs, 8); /* start / stop freq */
+  bitsToSkip += 2;
+  dflt_header_extra1 = FDKreadBit(hBs);
+  dflt_header_extra2 = FDKreadBit(hBs);
+  bitsToSkip += 5 * dflt_header_extra1 + 6 * dflt_header_extra2;
+  FDKpushFor(hBs, 5 * dflt_header_extra1 + 6 * dflt_header_extra2);
+
+  return bitsToSkip;
+}
+
+static INT ld_sbr_header(CSAudioSpecificConfig *asc, const INT dsFactor,
+                         HANDLE_FDK_BITSTREAM hBs, CSTpCallBacks *cb) {
+  const int channelConfiguration = asc->m_channelConfiguration;
+  int i = 0, j = 0;
+  INT error = 0;
+  MP4_ELEMENT_ID element = ID_NONE;
+
+  /* check whether the channelConfiguration is defined in
+   * channel_configuration_array */
+  if (channelConfiguration < 0 ||
+      channelConfiguration > (INT)(sizeof(channel_configuration_array) /
+                                       sizeof(MP4_ELEMENT_ID **) -
+                                   1)) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  /* read elements of the passed channel_configuration until there is ID_NONE */
+  while ((element = channel_configuration_array[channelConfiguration][j]) !=
+         ID_NONE) {
+    /* Setup LFE element for upsampling too. This is essential especially for
+     * channel configs where the LFE element is not at the last position for
+     * example in channel config 13 or 14. It leads to memory leaks if the setup
+     * of the LFE element would be done later in the core. */
+    if (element == ID_SCE || element == ID_CPE || element == ID_LFE) {
+      error |= cb->cbSbr(
+          cb->cbSbrData, hBs, asc->m_samplingFrequency / dsFactor,
+          asc->m_extensionSamplingFrequency / dsFactor,
+          asc->m_samplesPerFrame / dsFactor, AOT_ER_AAC_ELD, element, i++, 0, 0,
+          asc->configMode, &asc->SbrConfigChanged, dsFactor);
+      if (error != TRANSPORTDEC_OK) {
+        goto bail;
+      }
+    }
+    j++;
+  }
+bail:
+  return error;
+}
+
+static TRANSPORTDEC_ERROR EldSpecificConfig_Parse(CSAudioSpecificConfig *asc,
+                                                  HANDLE_FDK_BITSTREAM hBs,
+                                                  CSTpCallBacks *cb) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+  CSEldSpecificConfig *esc = &asc->m_sc.m_eldSpecificConfig;
+  ASC_ELD_EXT_TYPE eldExtType;
+  int eldExtLen, len, cnt, ldSbrLen = 0, eldExtLenSum, numSbrHeader = 0,
+                           sbrIndex;
+
+  unsigned char downscale_fill_nibble;
+
+  FDKmemclear(esc, sizeof(CSEldSpecificConfig));
+
+  esc->m_frameLengthFlag = FDKreadBits(hBs, 1);
+  if (esc->m_frameLengthFlag) {
+    asc->m_samplesPerFrame = 480;
+  } else {
+    asc->m_samplesPerFrame = 512;
+  }
+
+  asc->m_vcb11Flag = FDKreadBits(hBs, 1);
+  asc->m_rvlcFlag = FDKreadBits(hBs, 1);
+  asc->m_hcrFlag = FDKreadBits(hBs, 1);
+
+  esc->m_sbrPresentFlag = FDKreadBits(hBs, 1);
+
+  if (esc->m_sbrPresentFlag == 1) {
+    esc->m_sbrSamplingRate =
+        FDKreadBits(hBs, 1); /* 0: single rate, 1: dual rate */
+    esc->m_sbrCrcFlag = FDKreadBits(hBs, 1);
+
+    asc->m_extensionSamplingFrequency = asc->m_samplingFrequency
+                                        << esc->m_sbrSamplingRate;
+
+    if (cb->cbSbr != NULL) {
+      /* ELD reduced delay mode: LD-SBR initialization has to know the downscale
+         information. Postpone LD-SBR initialization and read ELD extension
+         information first. */
+      switch (asc->m_channelConfiguration) {
+        case 1:
+        case 2:
+          numSbrHeader = 1;
+          break;
+        case 3:
+          numSbrHeader = 2;
+          break;
+        case 4:
+        case 5:
+        case 6:
+          numSbrHeader = 3;
+          break;
+        case 7:
+        case 11:
+        case 12:
+        case 14:
+          numSbrHeader = 4;
+          break;
+        default:
+          numSbrHeader = 0;
+          break;
+      }
+      for (sbrIndex = 0; sbrIndex < numSbrHeader; sbrIndex++) {
+        ldSbrLen += skipSbrHeader(hBs, 0);
+      }
+    } else {
+      return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+    }
+  }
+  esc->m_useLdQmfTimeAlign = 0;
+
+  /* new ELD syntax */
+  eldExtLenSum = FDKgetValidBits(hBs);
+  esc->m_downscaledSamplingFrequency = asc->m_samplingFrequency;
+  /* parse ExtTypeConfigData */
+  while (
+      ((eldExtType = (ASC_ELD_EXT_TYPE)FDKreadBits(hBs, 4)) != ELDEXT_TERM) &&
+      ((INT)FDKgetValidBits(hBs) >= 0)) {
+    eldExtLen = len = FDKreadBits(hBs, 4);
+    if (len == 0xf) {
+      len = FDKreadBits(hBs, 8);
+      eldExtLen += len;
+
+      if (len == 0xff) {
+        len = FDKreadBits(hBs, 16);
+        eldExtLen += len;
+      }
+    }
+
+    switch (eldExtType) {
+      case ELDEXT_LDSAC:
+        esc->m_useLdQmfTimeAlign = 1;
+        if (cb->cbSsc != NULL) {
+          ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbSsc(
+              cb->cbSscData, hBs, asc->m_aot,
+              asc->m_samplingFrequency << esc->m_sbrSamplingRate,
+              asc->m_samplesPerFrame << esc->m_sbrSamplingRate,
+              1,  /* stereoConfigIndex */
+              -1, /* nTimeSlots: read from bitstream */
+              eldExtLen, asc->configMode, &asc->SacConfigChanged);
+          if (ErrorStatus != TRANSPORTDEC_OK) {
+            return TRANSPORTDEC_PARSE_ERROR;
+          }
+          if (esc->m_downscaledSamplingFrequency != asc->m_samplingFrequency) {
+            return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* ELDv2 w/ ELD downscaled
+                                                       mode not allowed */
+          }
+          break;
+        }
+
+        FDK_FALLTHROUGH;
+      default:
+        for (cnt = 0; cnt < eldExtLen; cnt++) {
+          FDKreadBits(hBs, 8);
+        }
+        break;
+
+      case ELDEXT_DOWNSCALEINFO:
+        UCHAR tmpDownscaleFreqIdx;
+        esc->m_downscaledSamplingFrequency =
+            getSampleRate(hBs, &tmpDownscaleFreqIdx, 4);
+        if (esc->m_downscaledSamplingFrequency == 0) {
+          return TRANSPORTDEC_PARSE_ERROR;
+        }
+        downscale_fill_nibble = FDKreadBits(hBs, 4);
+        if (downscale_fill_nibble != 0x0) {
+          return TRANSPORTDEC_PARSE_ERROR;
+        }
+        if (esc->m_useLdQmfTimeAlign == 1) {
+          return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* ELDv2 w/ ELD downscaled
+                                                     mode not allowed */
+        }
+        break;
+    }
+  }
+
+  if ((INT)FDKgetValidBits(hBs) < 0) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  if (esc->m_sbrPresentFlag == 1 && numSbrHeader != 0) {
+    INT dsFactor = 1; /* Downscale factor must be 1 or even for SBR */
+    if (esc->m_downscaledSamplingFrequency != 0) {
+      if (asc->m_samplingFrequency % esc->m_downscaledSamplingFrequency != 0) {
+        return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+      }
+      dsFactor = asc->m_samplingFrequency / esc->m_downscaledSamplingFrequency;
+      if (dsFactor != 1 && (dsFactor)&1) {
+        return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* SBR needs an even downscale
+                                                   factor */
+      }
+      if (dsFactor != 1 && dsFactor != 2 && dsFactor != 4) {
+        dsFactor = 1; /* don't apply dsf for not yet supported even dsfs */
+      }
+      if ((INT)asc->m_samplesPerFrame % dsFactor != 0) {
+        return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* frameSize/dsf must be an
+                                                   integer number */
+      }
+    }
+    eldExtLenSum = eldExtLenSum - FDKgetValidBits(hBs);
+    FDKpushBack(hBs, eldExtLenSum + ldSbrLen);
+    if (0 != ld_sbr_header(asc, dsFactor, hBs, cb)) {
+      return TRANSPORTDEC_PARSE_ERROR;
+    }
+    FDKpushFor(hBs, eldExtLenSum);
+  }
+  return (ErrorStatus);
+}
+
+/*
+Subroutine to store config in UCHAR buffer. Bit stream position does not change.
+*/
+static UINT StoreConfigAsBitstream(
+    HANDLE_FDK_BITSTREAM hBs, const INT configSize_bits, /* If < 0 (> 0) config
+                                                            to read is before
+                                                            (after) current bit
+                                                            stream position. */
+    UCHAR *configTargetBuffer, const USHORT configTargetBufferSize_bytes) {
+  FDK_BITSTREAM usacConf;
+  UINT const nBits = fAbs(configSize_bits);
+  UINT j, tmp;
+
+  if (nBits > 8 * (UINT)configTargetBufferSize_bytes) {
+    return 1;
+  }
+  FDKmemclear(configTargetBuffer, configTargetBufferSize_bytes);
+
+  FDKinitBitStream(&usacConf, configTargetBuffer, configTargetBufferSize_bytes,
+                   nBits, BS_WRITER);
+  if (configSize_bits < 0) {
+    FDKpushBack(hBs, nBits);
+  }
+  for (j = nBits; j > 31; j -= 32) {
+    tmp = FDKreadBits(hBs, 32);
+    FDKwriteBits(&usacConf, tmp, 32);
+  }
+  if (j > 0) {
+    tmp = FDKreadBits(hBs, j);
+    FDKwriteBits(&usacConf, tmp, j);
+  }
+  FDKsyncCache(&usacConf);
+  if (configSize_bits > 0) {
+    FDKpushBack(hBs, nBits);
+  }
+
+  return 0;
+}
+
+/* maps coreSbrFrameLengthIndex to coreCoderFrameLength */
+static const USHORT usacFrameLength[8] = {768, 1024, 2048, 2048, 4096, 0, 0, 0};
+/* maps coreSbrFrameLengthIndex to sbrRatioIndex */
+static const UCHAR sbrRatioIndex[8] = {0, 0, 2, 3, 1, 0, 0, 0};
+
+/*
+  subroutine for parsing extension element configuration:
+  UsacExtElementConfig() q.v. ISO/IEC FDIS 23003-3:2011(E) Table 14
+  rsv603daExtElementConfig() q.v. ISO/IEC DIS 23008-3 Table 13
+*/
+static TRANSPORTDEC_ERROR extElementConfig(CSUsacExtElementConfig *extElement,
+                                           HANDLE_FDK_BITSTREAM hBs,
+                                           const CSTpCallBacks *cb,
+                                           const UCHAR numSignalsInGroup,
+                                           const UINT coreFrameLength,
+                                           const int subStreamIndex,
+                                           const AUDIO_OBJECT_TYPE aot) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+  USAC_EXT_ELEMENT_TYPE usacExtElementType =
+      (USAC_EXT_ELEMENT_TYPE)escapedValue(hBs, 4, 8, 16);
+
+  /* recurve extension elements which are invalid for USAC */
+  if (aot == AOT_USAC) {
+    switch (usacExtElementType) {
+      case ID_EXT_ELE_FILL:
+      case ID_EXT_ELE_MPEGS:
+      case ID_EXT_ELE_SAOC:
+      case ID_EXT_ELE_AUDIOPREROLL:
+      case ID_EXT_ELE_UNI_DRC:
+        break;
+      default:
+        usacExtElementType = ID_EXT_ELE_UNKNOWN;
+        break;
+    }
+  }
+
+  extElement->usacExtElementType = usacExtElementType;
+  int usacExtElementConfigLength = escapedValue(hBs, 4, 8, 16);
+  extElement->usacExtElementConfigLength = (USHORT)usacExtElementConfigLength;
+  INT bsAnchor;
+
+  if (FDKreadBit(hBs)) /* usacExtElementDefaultLengthPresent */
+    extElement->usacExtElementDefaultLength = escapedValue(hBs, 8, 16, 0) + 1;
+  else
+    extElement->usacExtElementDefaultLength = 0;
+
+  extElement->usacExtElementPayloadFrag = FDKreadBit(hBs);
+
+  bsAnchor = (INT)FDKgetValidBits(hBs);
+
+  switch (usacExtElementType) {
+    case ID_EXT_ELE_UNKNOWN:
+    case ID_EXT_ELE_FILL:
+      break;
+    case ID_EXT_ELE_AUDIOPREROLL:
+      /* No configuration element */
+      extElement->usacExtElementHasAudioPreRoll = 1;
+      break;
+    case ID_EXT_ELE_UNI_DRC: {
+      if (cb->cbUniDrc != NULL) {
+        ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbUniDrc(
+            cb->cbUniDrcData, hBs, usacExtElementConfigLength,
+            0, /* uniDrcConfig */
+            subStreamIndex, 0, aot);
+        if (ErrorStatus != TRANSPORTDEC_OK) {
+          return ErrorStatus;
+        }
+      }
+    } break;
+    default:
+      break;
+  }
+
+  /* Adjust bit stream position. This is required because of byte alignment and
+   * unhandled extensions. */
+  {
+    INT left_bits = (usacExtElementConfigLength << 3) -
+                    (bsAnchor - (INT)FDKgetValidBits(hBs));
+    if (left_bits >= 0) {
+      FDKpushFor(hBs, left_bits);
+    } else {
+      /* parsed too many bits */
+      ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+    }
+  }
+
+  return ErrorStatus;
+}
+
+/*
+  subroutine for parsing the USAC / RSVD60 configuration extension:
+  UsacConfigExtension() q.v. ISO/IEC FDIS 23003-3:2011(E) Table 15
+  rsv603daConfigExtension() q.v. ISO/IEC DIS 23008-3 Table 14
+*/
+static TRANSPORTDEC_ERROR configExtension(CSUsacConfig *usc,
+                                          HANDLE_FDK_BITSTREAM hBs,
+                                          const CSTpCallBacks *cb) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+  int numConfigExtensions;
+  CONFIG_EXT_ID usacConfigExtType;
+  int usacConfigExtLength;
+
+  numConfigExtensions = (int)escapedValue(hBs, 2, 4, 8) + 1;
+  for (int confExtIdx = 0; confExtIdx < numConfigExtensions; confExtIdx++) {
+    INT nbits;
+    int loudnessInfoSetConfigExtensionPosition = FDKgetValidBits(hBs);
+    usacConfigExtType = (CONFIG_EXT_ID)escapedValue(hBs, 4, 8, 16);
+    usacConfigExtLength = (int)escapedValue(hBs, 4, 8, 16);
+
+    /* Start bit position of config extension */
+    nbits = (INT)FDKgetValidBits(hBs);
+
+    /* Return an error in case the bitbuffer fill level is too low. */
+    if (nbits < usacConfigExtLength * 8) {
+      return TRANSPORTDEC_PARSE_ERROR;
+    }
+
+    switch (usacConfigExtType) {
+      case ID_CONFIG_EXT_FILL:
+        for (int i = 0; i < usacConfigExtLength; i++) {
+          if (FDKreadBits(hBs, 8) != 0xa5) {
+            return TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+        break;
+      case ID_CONFIG_EXT_LOUDNESS_INFO: {
+        if (cb->cbUniDrc != NULL) {
+          ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbUniDrc(
+              cb->cbUniDrcData, hBs, usacConfigExtLength,
+              1, /* loudnessInfoSet */
+              0, loudnessInfoSetConfigExtensionPosition, AOT_USAC);
+          if (ErrorStatus != TRANSPORTDEC_OK) {
+            return ErrorStatus;
+          }
+        }
+      } break;
+      default:
+        break;
+    }
+
+    /* Skip remaining bits. If too many bits were parsed, assume error. */
+    usacConfigExtLength =
+        8 * usacConfigExtLength - (nbits - (INT)FDKgetValidBits(hBs));
+    if (usacConfigExtLength < 0) {
+      return TRANSPORTDEC_PARSE_ERROR;
+    }
+    FDKpushFor(hBs, usacConfigExtLength);
+  }
+
+  return ErrorStatus;
+}
+
+/* This function unifies decoder config parsing of USAC and RSV60:
+   rsv603daDecoderConfig() ISO/IEC DIS 23008-3   Table 8
+   UsacDecoderConfig()     ISO/IEC FDIS 23003-3  Table 6
+  */
+static TRANSPORTDEC_ERROR UsacRsv60DecoderConfig_Parse(
+    CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM hBs,
+    const CSTpCallBacks *cb) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+  CSUsacConfig *usc = &asc->m_sc.m_usacConfig;
+  int i, numberOfElements;
+  int channelElementIdx =
+      0; /* index for elements which contain audio channels (sce, cpe, lfe) */
+  SC_CHANNEL_CONFIG sc_chan_config = {0, 0, 0, 0};
+
+  numberOfElements = (int)escapedValue(hBs, 4, 8, 16) + 1;
+  usc->m_usacNumElements = numberOfElements;
+  if (numberOfElements > TP_USAC_MAX_ELEMENTS) {
+    return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+  }
+  usc->m_nUsacChannels = 0;
+  usc->m_channelConfigurationIndex = asc->m_channelConfiguration;
+
+  if (asc->m_aot == AOT_USAC) {
+    sc_chan_config = sc_chan_config_tab[usc->m_channelConfigurationIndex];
+
+    if (sc_chan_config.nCh > (SCHAR)TP_USAC_MAX_SPEAKERS) {
+      return TRANSPORTDEC_PARSE_ERROR;
+    }
+  }
+
+  for (i = 0; i < numberOfElements; i++) {
+    MP4_ELEMENT_ID usacElementType = (MP4_ELEMENT_ID)(
+        FDKreadBits(hBs, 2) | USAC_ID_BIT); /* set USAC_ID_BIT to map
+                                               usacElementType to
+                                               MP4_ELEMENT_ID enum */
+    usc->element[i].usacElementType = usacElementType;
+
+    /* sanity check: update element counter */
+    if (asc->m_aot == AOT_USAC) {
+      switch (usacElementType) {
+        case ID_USAC_SCE:
+          sc_chan_config.nSCE--;
+          break;
+        case ID_USAC_CPE:
+          sc_chan_config.nCPE--;
+          break;
+        case ID_USAC_LFE:
+          sc_chan_config.nLFE--;
+          break;
+        default:
+          break;
+      }
+      if (usc->m_channelConfigurationIndex) {
+        /* sanity check: no element counter may be smaller zero */
+        if (sc_chan_config.nCPE < 0 || sc_chan_config.nSCE < 0 ||
+            sc_chan_config.nLFE < 0) {
+          return TRANSPORTDEC_PARSE_ERROR;
+        }
+      }
+    }
+
+    switch (usacElementType) {
+      case ID_USAC_SCE:
+        /* UsacCoreConfig() ISO/IEC FDIS 23003-3  Table 10 */
+        if (FDKreadBit(hBs)) { /* tw_mdct */
+          return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+        }
+        usc->element[i].m_noiseFilling = FDKreadBits(hBs, 1);
+        /* end of UsacCoreConfig() */
+        if (usc->m_sbrRatioIndex > 0) {
+          if (cb->cbSbr == NULL) {
+            return TRANSPORTDEC_UNKOWN_ERROR;
+          }
+          /* SbrConfig() ISO/IEC FDIS 23003-3  Table 11 */
+          usc->element[i].m_harmonicSBR = FDKreadBit(hBs);
+          usc->element[i].m_interTes = FDKreadBit(hBs);
+          usc->element[i].m_pvc = FDKreadBit(hBs);
+          if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+                        asc->m_extensionSamplingFrequency,
+                        asc->m_samplesPerFrame, asc->m_aot, ID_SCE,
+                        channelElementIdx, usc->element[i].m_harmonicSBR,
+                        usc->element[i].m_stereoConfigIndex, asc->configMode,
+                        &asc->SbrConfigChanged, 1)) {
+            return TRANSPORTDEC_PARSE_ERROR;
+          }
+          /* end of SbrConfig() */
+        }
+        usc->m_nUsacChannels += 1;
+        channelElementIdx++;
+        break;
+
+      case ID_USAC_CPE:
+        /* UsacCoreConfig() ISO/IEC FDIS 23003-3  Table 10 */
+        if (FDKreadBit(hBs)) { /* tw_mdct */
+          return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+        }
+        usc->element[i].m_noiseFilling = FDKreadBits(hBs, 1);
+        /* end of UsacCoreConfig() */
+        if (usc->m_sbrRatioIndex > 0) {
+          if (cb->cbSbr == NULL) return TRANSPORTDEC_UNKOWN_ERROR;
+          /* SbrConfig() ISO/IEC FDIS 23003-3 */
+          usc->element[i].m_harmonicSBR = FDKreadBit(hBs);
+          usc->element[i].m_interTes = FDKreadBit(hBs);
+          usc->element[i].m_pvc = FDKreadBit(hBs);
+          {
+            INT bitsToSkip = skipSbrHeader(hBs, 1);
+            /* read stereoConfigIndex */
+            usc->element[i].m_stereoConfigIndex = FDKreadBits(hBs, 2);
+            /* rewind */
+            FDKpushBack(hBs, bitsToSkip + 2);
+          }
+          {
+            MP4_ELEMENT_ID el_type =
+                (usc->element[i].m_stereoConfigIndex == 1 ||
+                 usc->element[i].m_stereoConfigIndex == 2)
+                    ? ID_SCE
+                    : ID_CPE;
+            if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+                          asc->m_extensionSamplingFrequency,
+                          asc->m_samplesPerFrame, asc->m_aot, el_type,
+                          channelElementIdx, usc->element[i].m_harmonicSBR,
+                          usc->element[i].m_stereoConfigIndex, asc->configMode,
+                          &asc->SbrConfigChanged, 1)) {
+              return TRANSPORTDEC_PARSE_ERROR;
+            }
+          }
+          /* end of SbrConfig() */
+
+          usc->element[i].m_stereoConfigIndex =
+              FDKreadBits(hBs, 2); /* Needed in RM5 syntax */
+
+          if (usc->element[i].m_stereoConfigIndex > 0) {
+            if (cb->cbSsc != NULL) {
+              int samplesPerFrame = asc->m_samplesPerFrame;
+
+              if (usc->m_sbrRatioIndex == 1) samplesPerFrame <<= 2;
+              if (usc->m_sbrRatioIndex == 2)
+                samplesPerFrame = (samplesPerFrame * 8) / 3;
+              if (usc->m_sbrRatioIndex == 3) samplesPerFrame <<= 1;
+
+              /* Mps212Config() ISO/IEC FDIS 23003-3 */
+              if (cb->cbSsc(cb->cbSscData, hBs, asc->m_aot,
+                            asc->m_extensionSamplingFrequency, samplesPerFrame,
+                            usc->element[i].m_stereoConfigIndex,
+                            usc->m_coreSbrFrameLengthIndex,
+                            0, /* don't know the length */
+                            asc->configMode, &asc->SacConfigChanged)) {
+                return TRANSPORTDEC_PARSE_ERROR;
+              }
+              /* end of Mps212Config() */
+            } else {
+              return TRANSPORTDEC_UNKOWN_ERROR;
+            }
+          }
+        } else {
+          usc->element[i].m_stereoConfigIndex = 0;
+        }
+        usc->m_nUsacChannels += 2;
+
+        channelElementIdx++;
+        break;
+
+      case ID_USAC_LFE:
+        usc->element[i].m_noiseFilling = 0;
+        usc->m_nUsacChannels += 1;
+        if (usc->m_sbrRatioIndex > 0) {
+          /* Use SBR for upsampling */
+          if (cb->cbSbr == NULL) return ErrorStatus = TRANSPORTDEC_UNKOWN_ERROR;
+          usc->element[i].m_harmonicSBR = (UCHAR)0;
+          usc->element[i].m_interTes = (UCHAR)0;
+          usc->element[i].m_pvc = (UCHAR)0;
+          if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+                        asc->m_extensionSamplingFrequency,
+                        asc->m_samplesPerFrame, asc->m_aot, ID_LFE,
+                        channelElementIdx, usc->element[i].m_harmonicSBR,
+                        usc->element[i].m_stereoConfigIndex, asc->configMode,
+                        &asc->SbrConfigChanged, 1)) {
+            return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+        channelElementIdx++;
+        break;
+
+      case ID_USAC_EXT:
+        ErrorStatus = extElementConfig(&usc->element[i].extElement, hBs, cb, 0,
+                                       asc->m_samplesPerFrame, 0, asc->m_aot);
+
+        if (ErrorStatus) {
+          return ErrorStatus;
+        }
+        break;
+
+      default:
+        /* non USAC-element encountered */
+        return TRANSPORTDEC_PARSE_ERROR;
+    }
+  }
+
+  if (asc->m_aot == AOT_USAC) {
+    if (usc->m_channelConfigurationIndex) {
+      /* sanity check: all element counter must be zero */
+      if (sc_chan_config.nCPE | sc_chan_config.nSCE | sc_chan_config.nLFE) {
+        return TRANSPORTDEC_PARSE_ERROR;
+      }
+    } else {
+      /* sanity check: number of audio channels shall be equal to or smaller
+       * than the accumulated sum of all channels */
+      if ((INT)(-2 * sc_chan_config.nCPE - sc_chan_config.nSCE -
+                sc_chan_config.nLFE) < (INT)usc->numAudioChannels) {
+        return TRANSPORTDEC_PARSE_ERROR;
+      }
+    }
+  }
+
+  return ErrorStatus;
+}
+
+/* Mapping of coreSbrFrameLengthIndex defined by Table 70 in ISO/IEC 23003-3 */
+static TRANSPORTDEC_ERROR UsacConfig_SetCoreSbrFrameLengthIndex(
+    CSAudioSpecificConfig *asc, int coreSbrFrameLengthIndex) {
+  int sbrRatioIndex_val;
+
+  if (coreSbrFrameLengthIndex > 4) {
+    return TRANSPORTDEC_PARSE_ERROR; /* reserved values */
+  }
+  asc->m_sc.m_usacConfig.m_coreSbrFrameLengthIndex = coreSbrFrameLengthIndex;
+  asc->m_samplesPerFrame = usacFrameLength[coreSbrFrameLengthIndex];
+  sbrRatioIndex_val = sbrRatioIndex[coreSbrFrameLengthIndex];
+  asc->m_sc.m_usacConfig.m_sbrRatioIndex = sbrRatioIndex_val;
+
+  if (sbrRatioIndex_val > 0) {
+    asc->m_sbrPresentFlag = 1;
+    asc->m_extensionSamplingFrequency = asc->m_samplingFrequency;
+    asc->m_extensionSamplingFrequencyIndex = asc->m_samplingFrequencyIndex;
+    switch (sbrRatioIndex_val) {
+      case 1: /* sbrRatio = 4:1 */
+        asc->m_samplingFrequency >>= 2;
+        asc->m_samplesPerFrame >>= 2;
+        break;
+      case 2: /* sbrRatio = 8:3 */
+        asc->m_samplingFrequency = (asc->m_samplingFrequency * 3) / 8;
+        asc->m_samplesPerFrame = (asc->m_samplesPerFrame * 3) / 8;
+        break;
+      case 3: /* sbrRatio = 2:1 */
+        asc->m_samplingFrequency >>= 1;
+        asc->m_samplesPerFrame >>= 1;
+        break;
+      default:
+        return TRANSPORTDEC_PARSE_ERROR;
+    }
+    asc->m_samplingFrequencyIndex =
+        getSamplingRateIndex(asc->m_samplingFrequency, 4);
+  }
+
+  return TRANSPORTDEC_OK;
+}
+
+static TRANSPORTDEC_ERROR UsacConfig_Parse(CSAudioSpecificConfig *asc,
+                                           HANDLE_FDK_BITSTREAM hBs,
+                                           CSTpCallBacks *cb) {
+  int usacSamplingFrequency, channelConfigurationIndex, coreSbrFrameLengthIndex;
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+  /* Start bit position of usacConfig */
+  INT nbits = (INT)FDKgetValidBits(hBs);
+
+  usacSamplingFrequency = getSampleRate(hBs, &asc->m_samplingFrequencyIndex, 5);
+  asc->m_samplingFrequency = (UINT)usacSamplingFrequency;
+
+  coreSbrFrameLengthIndex = FDKreadBits(hBs, 3);
+  if (UsacConfig_SetCoreSbrFrameLengthIndex(asc, coreSbrFrameLengthIndex) !=
+      TRANSPORTDEC_OK) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  channelConfigurationIndex = FDKreadBits(hBs, 5);
+  if (channelConfigurationIndex > 2) {
+    return TRANSPORTDEC_PARSE_ERROR; /* only channelConfigurationIndex = [1,2]
+                                        are supported */
+  }
+
+  if (channelConfigurationIndex == 0) {
+    return TRANSPORTDEC_PARSE_ERROR; /* only channelConfigurationIndex = [1,2]
+                                        are supported */
+  }
+  asc->m_channelConfiguration = channelConfigurationIndex;
+
+  err = UsacRsv60DecoderConfig_Parse(asc, hBs, cb);
+  if (err != TRANSPORTDEC_OK) {
+    return err;
+  }
+
+  if (FDKreadBits(hBs, 1)) { /* usacConfigExtensionPresent */
+    err = configExtension(&asc->m_sc.m_usacConfig, hBs, cb);
+    if (err != TRANSPORTDEC_OK) {
+      return err;
+    }
+  }
+
+  /* sanity check whether number of channels signaled in UsacDecoderConfig()
+     matches the number of channels required by channelConfigurationIndex */
+  if ((channelConfigurationIndex > 0) &&
+      (sc_chan_config_tab[channelConfigurationIndex].nCh !=
+       asc->m_sc.m_usacConfig.m_nUsacChannels)) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  /* Copy UsacConfig() to asc->m_sc.m_usacConfig.UsacConfig[] buffer. */
+  INT configSize_bits = (INT)FDKgetValidBits(hBs) - nbits;
+  StoreConfigAsBitstream(hBs, configSize_bits,
+                         asc->m_sc.m_usacConfig.UsacConfig,
+                         TP_USAC_MAX_CONFIG_LEN);
+  asc->m_sc.m_usacConfig.UsacConfigBits = fAbs(configSize_bits);
+
+  return err;
+}
+
+static TRANSPORTDEC_ERROR AudioSpecificConfig_ExtensionParse(
+    CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs, CSTpCallBacks *cb) {
+  TP_ASC_EXTENSION_ID lastAscExt, ascExtId = ASCEXT_UNKOWN;
+  INT bitsAvailable = (INT)FDKgetValidBits(bs);
+
+  while (bitsAvailable >= 11) {
+    lastAscExt = ascExtId;
+    ascExtId = (TP_ASC_EXTENSION_ID)FDKreadBits(bs, 11);
+    bitsAvailable -= 11;
+
+    switch (ascExtId) {
+      case ASCEXT_SBR: /* 0x2b7 */
+        if ((self->m_extensionAudioObjectType != AOT_SBR) &&
+            (bitsAvailable >= 5)) {
+          self->m_extensionAudioObjectType = getAOT(bs);
+
+          if ((self->m_extensionAudioObjectType == AOT_SBR) ||
+              (self->m_extensionAudioObjectType ==
+               AOT_ER_BSAC)) { /* Get SBR extension configuration */
+            self->m_sbrPresentFlag = FDKreadBits(bs, 1);
+            if (self->m_aot == AOT_USAC && self->m_sbrPresentFlag > 0 &&
+                self->m_sc.m_usacConfig.m_sbrRatioIndex == 0) {
+              return TRANSPORTDEC_PARSE_ERROR;
+            }
+
+            if (self->m_sbrPresentFlag == 1) {
+              self->m_extensionSamplingFrequency = getSampleRate(
+                  bs, &self->m_extensionSamplingFrequencyIndex, 4);
+
+              if ((INT)self->m_extensionSamplingFrequency <= 0) {
+                return TRANSPORTDEC_PARSE_ERROR;
+              }
+            }
+            if (self->m_extensionAudioObjectType == AOT_ER_BSAC) {
+              self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
+            }
+          }
+          /* Update counter because of variable length fields (AOT and sampling
+           * rate) */
+          bitsAvailable = (INT)FDKgetValidBits(bs);
+        }
+        break;
+      case ASCEXT_PS: /* 0x548 */
+        if ((lastAscExt == ASCEXT_SBR) &&
+            (self->m_extensionAudioObjectType == AOT_SBR) &&
+            (bitsAvailable > 0)) { /* Get PS extension configuration */
+          self->m_psPresentFlag = FDKreadBits(bs, 1);
+          bitsAvailable -= 1;
+        }
+        break;
+      case ASCEXT_MPS: /* 0x76a */
+        if (self->m_extensionAudioObjectType == AOT_MPEGS) break;
+        FDK_FALLTHROUGH;
+      case ASCEXT_LDMPS: /* 0x7cc */
+        if ((ascExtId == ASCEXT_LDMPS) &&
+            (self->m_extensionAudioObjectType == AOT_LD_MPEGS))
+          break;
+        if (bitsAvailable >= 1) {
+          bitsAvailable -= 1;
+          if (FDKreadBits(bs, 1)) { /* self->m_mpsPresentFlag */
+            int sscLen = FDKreadBits(bs, 8);
+            bitsAvailable -= 8;
+            if (sscLen == 0xFF) {
+              sscLen += FDKreadBits(bs, 16);
+              bitsAvailable -= 16;
+            }
+            FDKpushFor(bs, sscLen); /* Skip SSC to be able to read the next
+                                       extension if there is one. */
+
+            bitsAvailable -= sscLen * 8;
+          }
+        }
+        break;
+      case ASCEXT_SAOC:
+        if ((ascExtId == ASCEXT_SAOC) &&
+            (self->m_extensionAudioObjectType == AOT_SAOC))
+          break;
+        if (FDKreadBits(bs, 1)) { /* saocPresent */
+          int saocscLen = FDKreadBits(bs, 8);
+          bitsAvailable -= 8;
+          if (saocscLen == 0xFF) {
+            saocscLen += FDKreadBits(bs, 16);
+            bitsAvailable -= 16;
+          }
+          FDKpushFor(bs, saocscLen);
+          bitsAvailable -= saocscLen * 8;
+        }
+        break;
+      default:
+        /* Just ignore anything. */
+        return TRANSPORTDEC_OK;
+    }
+  }
+
+  return TRANSPORTDEC_OK;
+}
+
+/*
+ * API Functions
+ */
+
+void AudioSpecificConfig_Init(CSAudioSpecificConfig *asc) {
+  FDKmemclear(asc, sizeof(CSAudioSpecificConfig));
+
+  /* Init all values that should not be zero. */
+  asc->m_aot = AOT_NONE;
+  asc->m_samplingFrequencyIndex = 0xf;
+  asc->m_epConfig = -1;
+  asc->m_extensionAudioObjectType = AOT_NULL_OBJECT;
+  CProgramConfig_Init(&asc->m_progrConfigElement);
+}
+
+TRANSPORTDEC_ERROR AudioSpecificConfig_Parse(
+    CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs,
+    int fExplicitBackwardCompatible, CSTpCallBacks *cb, UCHAR configMode,
+    UCHAR configChanged, AUDIO_OBJECT_TYPE m_aot) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+  UINT ascStartAnchor = FDKgetValidBits(bs);
+  int frameLengthFlag = -1;
+
+  AudioSpecificConfig_Init(self);
+
+  self->configMode = configMode;
+  self->AacConfigChanged = configChanged;
+  self->SbrConfigChanged = configChanged;
+  self->SacConfigChanged = configChanged;
+
+  if (m_aot != AOT_NULL_OBJECT) {
+    self->m_aot = m_aot;
+  } else {
+    self->m_aot = getAOT(bs);
+    self->m_samplingFrequency =
+        getSampleRate(bs, &self->m_samplingFrequencyIndex, 4);
+    if (self->m_samplingFrequency <= 0 ||
+        (self->m_samplingFrequency > 96000 && self->m_aot != 39) ||
+        self->m_samplingFrequency > 4 * 96000) {
+      return TRANSPORTDEC_PARSE_ERROR;
+    }
+
+    self->m_channelConfiguration = FDKreadBits(bs, 4);
+
+    /* SBR extension ( explicit non-backwards compatible mode ) */
+    self->m_sbrPresentFlag = 0;
+    self->m_psPresentFlag = 0;
+
+    if (self->m_aot == AOT_SBR || self->m_aot == AOT_PS) {
+      self->m_extensionAudioObjectType = AOT_SBR;
+
+      self->m_sbrPresentFlag = 1;
+      if (self->m_aot == AOT_PS) {
+        self->m_psPresentFlag = 1;
+      }
+
+      self->m_extensionSamplingFrequency =
+          getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
+      self->m_aot = getAOT(bs);
+
+      switch (self->m_aot) {
+        case AOT_AAC_LC:
+          break;
+        case AOT_ER_BSAC:
+          break;
+        default:
+          return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+      }
+
+      if (self->m_aot == AOT_ER_BSAC) {
+        self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
+      }
+    } else {
+      self->m_extensionAudioObjectType = AOT_NULL_OBJECT;
+    }
+  }
+
+  /* Parse whatever specific configs */
+  switch (self->m_aot) {
+    case AOT_AAC_LC:
+    case AOT_AAC_SCAL:
+    case AOT_ER_AAC_LC:
+    case AOT_ER_AAC_LD:
+    case AOT_ER_AAC_SCAL:
+    case AOT_ER_BSAC:
+      if ((ErrorStatus = GaSpecificConfig_Parse(&self->m_sc.m_gaSpecificConfig,
+                                                self, bs, ascStartAnchor)) !=
+          TRANSPORTDEC_OK) {
+        return (ErrorStatus);
+      }
+      frameLengthFlag = self->m_sc.m_gaSpecificConfig.m_frameLengthFlag;
+      break;
+    case AOT_MPEGS:
+      if (cb->cbSsc != NULL) {
+        if (cb->cbSsc(cb->cbSscData, bs, self->m_aot, self->m_samplingFrequency,
+                      self->m_samplesPerFrame, 1,
+                      -1, /* nTimeSlots: read from bitstream */
+                      0,  /* don't know the length */
+                      self->configMode, &self->SacConfigChanged)) {
+          return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+        }
+      } else {
+        return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+      }
+      break;
+    case AOT_ER_AAC_ELD:
+      if ((ErrorStatus = EldSpecificConfig_Parse(self, bs, cb)) !=
+          TRANSPORTDEC_OK) {
+        return (ErrorStatus);
+      }
+      frameLengthFlag = self->m_sc.m_eldSpecificConfig.m_frameLengthFlag;
+      self->m_sbrPresentFlag = self->m_sc.m_eldSpecificConfig.m_sbrPresentFlag;
+      self->m_extensionSamplingFrequency =
+          (self->m_sc.m_eldSpecificConfig.m_sbrSamplingRate + 1) *
+          self->m_samplingFrequency;
+      break;
+    case AOT_USAC:
+      if ((ErrorStatus = UsacConfig_Parse(self, bs, cb)) != TRANSPORTDEC_OK) {
+        return (ErrorStatus);
+      }
+      break;
+
+    default:
+      return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+  }
+
+  /* Frame length */
+  switch (self->m_aot) {
+    case AOT_AAC_LC:
+    case AOT_AAC_SCAL:
+    case AOT_ER_AAC_LC:
+    case AOT_ER_AAC_SCAL:
+    case AOT_ER_BSAC:
+      /*case AOT_USAC:*/
+      if (!frameLengthFlag)
+        self->m_samplesPerFrame = 1024;
+      else
+        self->m_samplesPerFrame = 960;
+      break;
+    case AOT_ER_AAC_LD:
+      if (!frameLengthFlag)
+        self->m_samplesPerFrame = 512;
+      else
+        self->m_samplesPerFrame = 480;
+      break;
+    default:
+      break;
+  }
+
+  switch (self->m_aot) {
+    case AOT_ER_AAC_LC:
+    case AOT_ER_AAC_LD:
+    case AOT_ER_AAC_ELD:
+    case AOT_ER_AAC_SCAL:
+    case AOT_ER_CELP:
+    case AOT_ER_HVXC:
+    case AOT_ER_BSAC:
+      self->m_epConfig = FDKreadBits(bs, 2);
+
+      if (self->m_epConfig > 1) {
+        return TRANSPORTDEC_UNSUPPORTED_FORMAT;  // EPCONFIG;
+      }
+      break;
+    default:
+      break;
+  }
+
+  if (fExplicitBackwardCompatible &&
+      (self->m_aot == AOT_AAC_LC || self->m_aot == AOT_ER_AAC_LD ||
+       self->m_aot == AOT_ER_BSAC)) {
+    ErrorStatus = AudioSpecificConfig_ExtensionParse(self, bs, cb);
+  }
+
+  /* Copy config() to asc->config[] buffer. */
+  if ((ErrorStatus == TRANSPORTDEC_OK) && (self->m_aot == AOT_USAC)) {
+    INT configSize_bits = (INT)FDKgetValidBits(bs) - (INT)ascStartAnchor;
+    StoreConfigAsBitstream(bs, configSize_bits, self->config,
+                           TP_USAC_MAX_CONFIG_LEN);
+    self->configBits = fAbs(configSize_bits);
+  }
+
+  return (ErrorStatus);
+}
+
+static TRANSPORTDEC_ERROR Drm_xHEAACDecoderConfig(
+    CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM hBs, int audioMode,
+    CSTpCallBacks *cb /* use cb == NULL to signal config check only mode */
+) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+  CSUsacConfig *usc = &asc->m_sc.m_usacConfig;
+  int elemIdx = 0;
+
+  usc->element[elemIdx].m_stereoConfigIndex = 0;
+
+  usc->m_usacNumElements = 1; /* Currently all extension elements are skipped
+                                 -> only one SCE or CPE. */
+
+  switch (audioMode) {
+    case 0: /* mono: ID_USAC_SCE */
+      usc->element[elemIdx].usacElementType = ID_USAC_SCE;
+      usc->m_nUsacChannels = 1;
+      usc->element[elemIdx].m_noiseFilling = FDKreadBits(hBs, 1);
+      if (usc->m_sbrRatioIndex > 0) {
+        if (cb == NULL) {
+          return ErrorStatus;
+        }
+        if (cb->cbSbr != NULL) {
+          usc->element[elemIdx].m_harmonicSBR = FDKreadBit(hBs);
+          usc->element[elemIdx].m_interTes = FDKreadBit(hBs);
+          usc->element[elemIdx].m_pvc = FDKreadBit(hBs);
+          if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+                        asc->m_extensionSamplingFrequency,
+                        asc->m_samplesPerFrame, asc->m_aot, ID_SCE, elemIdx,
+                        usc->element[elemIdx].m_harmonicSBR,
+                        usc->element[elemIdx].m_stereoConfigIndex,
+                        asc->configMode, &asc->SbrConfigChanged, 1)) {
+            return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+      }
+      break;
+    case 2: /* stereo: ID_USAC_CPE */
+      usc->element[elemIdx].usacElementType = ID_USAC_CPE;
+      usc->m_nUsacChannels = 2;
+      usc->element[elemIdx].m_noiseFilling = FDKreadBits(hBs, 1);
+      if (usc->m_sbrRatioIndex > 0) {
+        usc->element[elemIdx].m_harmonicSBR = FDKreadBit(hBs);
+        usc->element[elemIdx].m_interTes = FDKreadBit(hBs);
+        usc->element[elemIdx].m_pvc = FDKreadBit(hBs);
+        {
+          INT bitsToSkip = skipSbrHeader(hBs, 1);
+          /* read stereoConfigIndex */
+          usc->element[elemIdx].m_stereoConfigIndex = FDKreadBits(hBs, 2);
+          /* rewind */
+          FDKpushBack(hBs, bitsToSkip + 2);
+        }
+        /*
+        The application of the following tools is mutually exclusive per audio
+        stream configuration (see clause 5.3.2, xHE-AAC codec configuration):
+        - MPS212 parametric stereo tool with residual coding
+        (stereoConfigIndex>1); and
+        - QMF based Harmonic Transposer (harmonicSBR==1).
+        */
+        if ((usc->element[elemIdx].m_stereoConfigIndex > 1) &&
+            usc->element[elemIdx].m_harmonicSBR) {
+          return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+        }
+        /*
+        The 4:1 sbrRatio (sbrRatioIndex==1 in [11]) may only be employed:
+        - in mono operation; or
+        - in stereo operation if parametric stereo (MPS212) without residual
+        coding is applied, i.e. if stereoConfigIndex==1 (see clause 5.3.2,
+        xHE-AAC codec configuration).
+        */
+        if ((usc->m_sbrRatioIndex == 1) &&
+            (usc->element[elemIdx].m_stereoConfigIndex != 1)) {
+          return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+        }
+        if (cb == NULL) {
+          return ErrorStatus;
+        }
+        {
+          MP4_ELEMENT_ID el_type =
+              (usc->element[elemIdx].m_stereoConfigIndex == 1 ||
+               usc->element[elemIdx].m_stereoConfigIndex == 2)
+                  ? ID_SCE
+                  : ID_CPE;
+          if (cb->cbSbr == NULL) return ErrorStatus = TRANSPORTDEC_UNKOWN_ERROR;
+          if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+                        asc->m_extensionSamplingFrequency,
+                        asc->m_samplesPerFrame, asc->m_aot, el_type, elemIdx,
+                        usc->element[elemIdx].m_harmonicSBR,
+                        usc->element[elemIdx].m_stereoConfigIndex,
+                        asc->configMode, &asc->SbrConfigChanged, 1)) {
+            return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+        /*usc->element[elemIdx].m_stereoConfigIndex =*/FDKreadBits(hBs, 2);
+        if (usc->element[elemIdx].m_stereoConfigIndex > 0) {
+          if (cb->cbSsc != NULL) {
+            int samplesPerFrame = asc->m_samplesPerFrame;
+
+            if (usc->m_sbrRatioIndex == 1) samplesPerFrame <<= 2;
+            if (usc->m_sbrRatioIndex == 2)
+              samplesPerFrame = (samplesPerFrame * 8) / 3;
+            if (usc->m_sbrRatioIndex == 3) samplesPerFrame <<= 1;
+
+            ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbSsc(
+                cb->cbSscData, hBs,
+                AOT_DRM_USAC, /* syntax differs from MPEG Mps212Config() */
+                asc->m_extensionSamplingFrequency, samplesPerFrame,
+                usc->element[elemIdx].m_stereoConfigIndex,
+                usc->m_coreSbrFrameLengthIndex, 0, /* don't know the length */
+                asc->configMode, &asc->SacConfigChanged);
+          } else {
+            /* ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT; */
+          }
+        }
+      }
+      break;
+    default:
+      return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  return ErrorStatus;
+}
+
+TRANSPORTDEC_ERROR Drm_xHEAACStaticConfig(
+    CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM bs, int audioMode,
+    CSTpCallBacks *cb /* use cb == NULL to signal config check only mode */
+) {
+  int coreSbrFrameLengthIndexDrm = FDKreadBits(bs, 2);
+  if (UsacConfig_SetCoreSbrFrameLengthIndex(
+          asc, coreSbrFrameLengthIndexDrm + 1) != TRANSPORTDEC_OK) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  asc->m_channelConfiguration = (audioMode) ? 2 : 1;
+
+  if (Drm_xHEAACDecoderConfig(asc, bs, audioMode, cb) != TRANSPORTDEC_OK) {
+    return TRANSPORTDEC_PARSE_ERROR;
+  }
+
+  return TRANSPORTDEC_OK;
+}
+
+/* Mapping of DRM audio sampling rate field to MPEG usacSamplingFrequencyIndex
+ */
+const UCHAR mapSr2MPEGIdx[8] = {
+    0x1b, /*  9.6 kHz */
+    0x09, /* 12.0 kHz */
+    0x08, /* 16.0 kHz */
+    0x17, /* 19.2 kHz */
+    0x06, /* 24.0 kHz */
+    0x05, /* 32.0 kHz */
+    0x12, /* 38.4 kHz */
+    0x03  /* 48.0 kHz */
+};
+
+TRANSPORTDEC_ERROR DrmRawSdcAudioConfig_Parse(
+    CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs,
+    CSTpCallBacks *cb, /* use cb == NULL to signal config check only mode */
+    UCHAR configMode, UCHAR configChanged) {
+  TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+  AudioSpecificConfig_Init(self);
+
+  if ((INT)FDKgetValidBits(bs) < 16) {
+    ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+    goto bail;
+  } else {
+    /* DRM - Audio information data entity - type 9
+       - Short Id            2 bits (not part of the config buffer)
+       - Stream Id           2 bits (not part of the config buffer)
+       - audio coding        2 bits
+       - SBR flag            1 bit
+       - audio mode          2 bits
+       - audio sampling rate 3 bits
+       - text flag           1 bit
+       - enhancement flag    1 bit
+       - coder field         5 bits
+       - rfa                 1 bit  */
+
+    int audioCoding, audioMode, cSamplingFreq, coderField, sfIdx, sbrFlag;
+
+    self->configMode = configMode;
+    self->AacConfigChanged = configChanged;
+    self->SbrConfigChanged = configChanged;
+    self->SacConfigChanged = configChanged;
+
+    /* Read the SDC field */
+    audioCoding = FDKreadBits(bs, 2);
+    sbrFlag = FDKreadBits(bs, 1);
+    audioMode = FDKreadBits(bs, 2);
+    cSamplingFreq = FDKreadBits(bs, 3); /* audio sampling rate */
+
+    FDKreadBits(bs, 2); /* Text and enhancement flag */
+    coderField = FDKreadBits(bs, 5);
+    FDKreadBits(bs, 1); /* rfa */
+
+    /* Evaluate configuration and fill the ASC */
+    if (audioCoding == 3) {
+      sfIdx = (int)mapSr2MPEGIdx[cSamplingFreq];
+      sbrFlag = 0; /* rfa */
+    } else {
+      switch (cSamplingFreq) {
+        case 0: /*  8 kHz */
+          sfIdx = 11;
+          break;
+        case 1: /* 12 kHz */
+          sfIdx = 9;
+          break;
+        case 2: /* 16 kHz */
+          sfIdx = 8;
+          break;
+        case 3: /* 24 kHz */
+          sfIdx = 6;
+          break;
+        case 5: /* 48 kHz */
+          sfIdx = 3;
+          break;
+        case 4: /* reserved */
+        case 6: /* reserved */
+        case 7: /* reserved */
+        default:
+          ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+          goto bail;
+      }
+    }
+
+    self->m_samplingFrequencyIndex = sfIdx;
+    self->m_samplingFrequency = SamplingRateTable[sfIdx];
+
+    if (sbrFlag) {
+      UINT i;
+      int tmp = -1;
+      self->m_sbrPresentFlag = 1;
+      self->m_extensionAudioObjectType = AOT_SBR;
+      self->m_extensionSamplingFrequency = self->m_samplingFrequency << 1;
+      for (i = 0;
+           i < (sizeof(SamplingRateTable) / sizeof(SamplingRateTable[0]));
+           i++) {
+        if (SamplingRateTable[i] == self->m_extensionSamplingFrequency) {
+          tmp = i;
+          break;
+        }
+      }
+      self->m_extensionSamplingFrequencyIndex = tmp;
+    }
+
+    switch (audioCoding) {
+      case 0: /* AAC */
+        if ((coderField >> 2) && (audioMode != 1)) {
+          self->m_aot = AOT_DRM_SURROUND; /* Set pseudo AOT for Drm Surround */
+        } else {
+          self->m_aot = AOT_DRM_AAC; /* Set pseudo AOT for Drm AAC */
+        }
+        switch (audioMode) {
+          case 1: /* parametric stereo */
+            self->m_psPresentFlag = 1;
+            FDK_FALLTHROUGH;
+          case 0: /* mono */
+            self->m_channelConfiguration = 1;
+            break;
+          case 2: /* stereo */
+            self->m_channelConfiguration = 2;
+            break;
+          default:
+            ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+            goto bail;
+        }
+        self->m_vcb11Flag = 1;
+        self->m_hcrFlag = 1;
+        self->m_samplesPerFrame = 960;
+        self->m_epConfig = 1;
+        break;
+      case 1: /* CELP */
+        self->m_aot = AOT_ER_CELP;
+        self->m_channelConfiguration = 1;
+        break;
+      case 2: /* HVXC */
+        self->m_aot = AOT_ER_HVXC;
+        self->m_channelConfiguration = 1;
+        break;
+      case 3: /* xHE-AAC */
+      {
+        /* payload is MPEG conform -> no pseudo DRM AOT needed */
+        self->m_aot = AOT_USAC;
+      }
+        switch (audioMode) {
+          case 0: /* mono */
+          case 2: /* stereo */
+            /* codec specific config 8n bits */
+            ErrorStatus = Drm_xHEAACStaticConfig(self, bs, audioMode, cb);
+            break;
+          default:
+            ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+            goto bail;
+        }
+        break;
+      default:
+        ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+        self->m_aot = AOT_NONE;
+        break;
+    }
+
+    if (self->m_psPresentFlag && !self->m_sbrPresentFlag) {
+      ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+      goto bail;
+    }
+  }
+
+bail:
+  return (ErrorStatus);
+}