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

diff --git a/fdk-aac/libMpegTPDec/src/tpdec_lib.cpp b/fdk-aac/libMpegTPDec/src/tpdec_lib.cpp
new file mode 100644
index 0000000..1976cb9
--- /dev/null
+++ b/fdk-aac/libMpegTPDec/src/tpdec_lib.cpp
@@ -0,0 +1,1820 @@
+/* -----------------------------------------------------------------------------
+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):   Manuel Jander
+
+   Description: MPEG Transport decoder
+
+*******************************************************************************/
+
+#include "tpdec_lib.h"
+
+/* library version */
+#include "tp_version.h"
+
+#include "tp_data.h"
+
+#include "tpdec_adts.h"
+
+#include "tpdec_adif.h"
+
+#include "tpdec_latm.h"
+
+#include "tpdec_drm.h"
+
+#include "FDK_crc.h"
+
+#define MODULE_NAME "transportDec"
+
+typedef union {
+  STRUCT_ADTS adts;
+
+  CAdifHeader adif;
+
+  CLatmDemux latm;
+
+  STRUCT_DRM drm;
+
+} transportdec_parser_t;
+
+#define MHAS_CONFIG_PRESENT 0x001
+#define MHAS_UI_PRESENT 0x002
+
+struct TRANSPORTDEC {
+  TRANSPORT_TYPE transportFmt; /*!< MPEG4 transportDec type. */
+
+  CSTpCallBacks callbacks; /*!< Struct holding callback and its data */
+
+  FDK_BITSTREAM bitStream[1]; /* Bitstream reader */
+  UCHAR *bsBuffer;            /* Internal bitstreamd data buffer */
+
+  transportdec_parser_t parser; /* Format specific parser structs. */
+
+  CSAudioSpecificConfig asc[(1 * 1) + 1]; /* Audio specific config from the last
+                                             config found. One additional
+                                             CSAudioSpecificConfig is used
+                                             temporarily for parsing. */
+  CCtrlCFGChange ctrlCFGChange[(1 * 1)];  /* Controls config change */
+
+  UINT globalFramePos;      /* Global transport frame reference bit position. */
+  UINT accessUnitAnchor[1]; /* Current access unit start bit position. */
+  INT auLength[1];          /* Length of current access unit. */
+  INT numberOfRawDataBlocks; /* Current number of raw data blocks contained
+                                remaining from the current transport frame. */
+  UINT avgBitRate; /* Average bit rate used for frame loss estimation. */
+  UINT lastValidBufferFullness; /* Last valid buffer fullness value for frame
+                                   loss estimation */
+  INT remainder; /* Reminder in division during lost access unit estimation. */
+  INT missingAccessUnits; /* Estimated missing access units. */
+  UINT burstPeriod;       /* Data burst period in mili seconds. */
+  UINT holdOffFrames;     /* Amount of frames that were already hold off due to
+                             buffer fullness condition not being met. */
+  UINT flags;             /* Flags. */
+  INT targetLayout;       /* CICP target layout. */
+  UINT *pLoudnessInfoSetPosition; /* Reference and start position (bits) and
+                                     length (bytes) of loudnessInfoSet within
+                                     rsv603daConfig.  */
+};
+
+/* Flag bitmasks for "flags" member of struct TRANSPORTDEC */
+#define TPDEC_SYNCOK 1
+#define TPDEC_MINIMIZE_DELAY 2
+#define TPDEC_IGNORE_BUFFERFULLNESS 4
+#define TPDEC_EARLY_CONFIG 8
+#define TPDEC_LOST_FRAMES_PENDING 16
+#define TPDEC_CONFIG_FOUND 32
+#define TPDEC_USE_ELEM_SKIPPING 64
+
+/* force config/content change */
+#define TPDEC_FORCE_CONFIG_CHANGE 1
+#define TPDEC_FORCE_CONTENT_CHANGE 2
+
+/* skip packet */
+#define TPDEC_SKIP_PACKET 1
+
+C_ALLOC_MEM(Ram_TransportDecoder, struct TRANSPORTDEC, 1)
+C_ALLOC_MEM(Ram_TransportDecoderBuffer, UCHAR, (8192 * 4))
+
+HANDLE_TRANSPORTDEC transportDec_Open(const TRANSPORT_TYPE transportFmt,
+                                      const UINT flags, const UINT nrOfLayers) {
+  HANDLE_TRANSPORTDEC hInput;
+
+  hInput = GetRam_TransportDecoder(0);
+  if (hInput == NULL) {
+    return NULL;
+  }
+
+  /* Init transportDec struct. */
+  hInput->transportFmt = transportFmt;
+
+  switch (transportFmt) {
+    case TT_MP4_ADIF:
+      break;
+
+    case TT_MP4_ADTS:
+      if (flags & TP_FLAG_MPEG4)
+        hInput->parser.adts.decoderCanDoMpeg4 = 1;
+      else
+        hInput->parser.adts.decoderCanDoMpeg4 = 0;
+      adtsRead_CrcInit(&hInput->parser.adts);
+      hInput->parser.adts.BufferFullnesStartFlag = 1;
+      hInput->numberOfRawDataBlocks = 0;
+      break;
+
+    case TT_DRM:
+      drmRead_CrcInit(&hInput->parser.drm);
+      break;
+
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      hInput->parser.latm.usacExplicitCfgChanged = 0;
+      hInput->parser.latm.applyAsc = 1;
+      break;
+    case TT_MP4_LOAS:
+      hInput->parser.latm.usacExplicitCfgChanged = 0;
+      hInput->parser.latm.applyAsc = 1;
+      break;
+    case TT_MP4_RAW:
+      break;
+
+    default:
+      FreeRam_TransportDecoder(&hInput);
+      hInput = NULL;
+      break;
+  }
+
+  if (hInput != NULL) {
+    /* Create bitstream */
+    {
+      hInput->bsBuffer = GetRam_TransportDecoderBuffer(0);
+      if (hInput->bsBuffer == NULL) {
+        transportDec_Close(&hInput);
+        return NULL;
+      }
+      if (nrOfLayers > 1) {
+        transportDec_Close(&hInput);
+        return NULL;
+      }
+      for (UINT i = 0; i < nrOfLayers; i++) {
+        FDKinitBitStream(&hInput->bitStream[i], hInput->bsBuffer, (8192 * 4), 0,
+                         BS_READER);
+      }
+    }
+    hInput->burstPeriod = 0;
+  }
+
+  return hInput;
+}
+
+TRANSPORTDEC_ERROR transportDec_OutOfBandConfig(HANDLE_TRANSPORTDEC hTp,
+                                                UCHAR *conf, const UINT length,
+                                                UINT layer) {
+  int i;
+
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+  FDK_BITSTREAM bs;
+  HANDLE_FDK_BITSTREAM hBs = &bs;
+
+  int fConfigFound = 0;
+
+  UCHAR configChanged = 0;
+  UCHAR configMode = AC_CM_DET_CFG_CHANGE;
+
+  UCHAR tmpConf[1024];
+  if (length > 1024) {
+    return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+  }
+  FDKmemcpy(tmpConf, conf, length);
+  FDKinitBitStream(hBs, tmpConf, 1024, length << 3, BS_READER);
+
+  for (i = 0; i < 2; i++) {
+    if (i > 0) {
+      FDKpushBack(hBs, (INT)length * 8 - (INT)FDKgetValidBits(hBs));
+      configMode = AC_CM_ALLOC_MEM;
+    }
+
+    /* config transport decoder */
+    switch (hTp->transportFmt) {
+      case TT_MP4_LATM_MCP0:
+      case TT_MP4_LATM_MCP1:
+      case TT_MP4_LOAS: {
+        if (layer != 0) {
+          return TRANSPORTDEC_INVALID_PARAMETER;
+        }
+        CLatmDemux *pLatmDemux = &hTp->parser.latm;
+        err = CLatmDemux_ReadStreamMuxConfig(hBs, pLatmDemux, &hTp->callbacks,
+                                             hTp->asc, &fConfigFound,
+                                             configMode, configChanged);
+        if (err != TRANSPORTDEC_OK) {
+          return err;
+        }
+      } break;
+      default:
+        fConfigFound = 1;
+        err = AudioSpecificConfig_Parse(&hTp->asc[(1 * 1)], hBs, 1,
+                                        &hTp->callbacks, configMode,
+                                        configChanged, AOT_NULL_OBJECT);
+        if (err == TRANSPORTDEC_OK) {
+          int errC;
+
+          hTp->asc[layer] = hTp->asc[(1 * 1)];
+          errC = hTp->callbacks.cbUpdateConfig(
+              hTp->callbacks.cbUpdateConfigData, &hTp->asc[layer],
+              hTp->asc[layer].configMode, &hTp->asc[layer].AacConfigChanged);
+          if (errC != 0) {
+            err = TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+        break;
+      case TT_DRM:
+        fConfigFound = 1;
+        err = DrmRawSdcAudioConfig_Parse(&hTp->asc[layer], hBs, &hTp->callbacks,
+                                         configMode, configChanged);
+        if (err == TRANSPORTDEC_OK) {
+          int errC;
+
+          errC = hTp->callbacks.cbUpdateConfig(
+              hTp->callbacks.cbUpdateConfigData, &hTp->asc[layer],
+              hTp->asc[layer].configMode, &hTp->asc[layer].AacConfigChanged);
+          if (errC != 0) {
+            err = TRANSPORTDEC_PARSE_ERROR;
+          }
+        }
+        break;
+    }
+
+    if (err == TRANSPORTDEC_OK) {
+      if ((i == 0) && (hTp->asc[layer].AacConfigChanged ||
+                       hTp->asc[layer].SbrConfigChanged ||
+                       hTp->asc[layer].SacConfigChanged)) {
+        int errC;
+
+        configChanged = 1;
+        errC = hTp->callbacks.cbFreeMem(hTp->callbacks.cbFreeMemData,
+                                        &hTp->asc[layer]);
+        if (errC != 0) {
+          err = TRANSPORTDEC_PARSE_ERROR;
+        }
+      }
+    }
+  }
+
+  if (err == TRANSPORTDEC_OK && fConfigFound) {
+    hTp->flags |= TPDEC_CONFIG_FOUND;
+  }
+
+  return err;
+}
+
+TRANSPORTDEC_ERROR transportDec_InBandConfig(HANDLE_TRANSPORTDEC hTp,
+                                             UCHAR *newConfig,
+                                             const UINT newConfigLength,
+                                             const UCHAR buildUpStatus,
+                                             UCHAR *configChanged, UINT layer,
+                                             UCHAR *implicitExplicitCfgDiff) {
+  int errC;
+  FDK_BITSTREAM bs;
+  HANDLE_FDK_BITSTREAM hBs = &bs;
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+  int fConfigFound = 0;
+  UCHAR configMode = AC_CM_ALLOC_MEM;
+  *implicitExplicitCfgDiff = 0;
+
+  FDK_ASSERT(hTp->asc->m_aot == AOT_USAC);
+
+  FDKinitBitStream(hBs, newConfig, TP_USAC_MAX_CONFIG_LEN, newConfigLength << 3,
+                   BS_READER);
+
+  if ((hTp->ctrlCFGChange[layer].flushStatus == TPDEC_FLUSH_OFF) &&
+      (hTp->ctrlCFGChange[layer].buildUpStatus !=
+       TPDEC_RSV60_BUILD_UP_IDLE_IN_BAND)) {
+    if (hTp->asc->m_aot == AOT_USAC) {
+      if ((UINT)(hTp->asc->m_sc.m_usacConfig.UsacConfigBits + 7) >> 3 ==
+          newConfigLength) {
+        if (0 == FDKmemcmp(newConfig, hTp->asc->m_sc.m_usacConfig.UsacConfig,
+                           newConfigLength)) {
+          if (hTp->parser.latm.usacExplicitCfgChanged) { /* configChange from
+                                                            LOAS/LATM parser */
+            hTp->parser.latm.usacExplicitCfgChanged = 0;
+            hTp->ctrlCFGChange[layer].flushCnt = 0;
+            hTp->ctrlCFGChange[layer].flushStatus =
+                TPDEC_USAC_DASH_IPF_FLUSH_ON;
+            hTp->ctrlCFGChange[layer].buildUpCnt = 0;
+            hTp->ctrlCFGChange[layer].buildUpStatus = TPDEC_BUILD_UP_OFF;
+          } else {
+            *configChanged = 0;
+            return err;
+          }
+        } else {
+          *implicitExplicitCfgDiff = 1;
+        }
+      } else {
+        *implicitExplicitCfgDiff = 1;
+      }
+      /* ISO/IEC 23003-3:2012/FDAM 3:2016(E) Annex F.2: explicit and implicit
+       * config shall be identical. */
+      if (*implicitExplicitCfgDiff) {
+        switch (hTp->transportFmt) {
+          case TT_MP4_LATM_MCP0:
+          case TT_MP4_LATM_MCP1:
+          case TT_MP4_LOAS:
+            /* reset decoder to initial state to achieve definite behavior after
+             * error in config */
+            hTp->callbacks.cbFreeMem(hTp->callbacks.cbFreeMemData,
+                                     &hTp->asc[layer]);
+            hTp->parser.latm.usacExplicitCfgChanged = 0;
+            hTp->parser.latm.applyAsc = 1;
+            err = TRANSPORTDEC_PARSE_ERROR;
+            goto bail;
+          default:
+            break;
+        }
+      }
+    }
+  }
+
+  {
+    if ((hTp->ctrlCFGChange[layer].flushStatus == TPDEC_FLUSH_OFF) &&
+        (hTp->ctrlCFGChange[layer].buildUpStatus !=
+         TPDEC_RSV60_BUILD_UP_IDLE_IN_BAND)) {
+      hTp->ctrlCFGChange[layer].flushCnt = 0;
+      hTp->ctrlCFGChange[layer].buildUpCnt = 0;
+      hTp->ctrlCFGChange[layer].buildUpStatus = TPDEC_BUILD_UP_OFF;
+      if (hTp->asc->m_aot == AOT_USAC) {
+        hTp->ctrlCFGChange[layer].flushStatus = TPDEC_USAC_DASH_IPF_FLUSH_ON;
+      }
+    }
+
+    if ((hTp->ctrlCFGChange[layer].flushStatus ==
+         TPDEC_RSV60_DASH_IPF_ATSC_FLUSH_ON) ||
+        (hTp->ctrlCFGChange[layer].flushStatus ==
+         TPDEC_USAC_DASH_IPF_FLUSH_ON)) {
+      SCHAR counter = 0;
+      if (hTp->asc->m_aot == AOT_USAC) {
+        counter = TPDEC_USAC_NUM_CONFIG_CHANGE_FRAMES;
+      }
+      if (hTp->ctrlCFGChange[layer].flushCnt >= counter) {
+        hTp->ctrlCFGChange[layer].flushCnt = 0;
+        hTp->ctrlCFGChange[layer].flushStatus = TPDEC_FLUSH_OFF;
+        hTp->ctrlCFGChange[layer].forceCfgChange = 0;
+        if (hTp->asc->m_aot == AOT_USAC) {
+          hTp->ctrlCFGChange[layer].buildUpCnt =
+              TPDEC_USAC_NUM_CONFIG_CHANGE_FRAMES - 1;
+          hTp->ctrlCFGChange[layer].buildUpStatus = TPDEC_USAC_BUILD_UP_ON;
+        }
+      }
+
+      /* Activate flush mode. After that continue with build up mode in core */
+      if (hTp->callbacks.cbCtrlCFGChange(hTp->callbacks.cbCtrlCFGChangeData,
+                                         &hTp->ctrlCFGChange[layer]) != 0) {
+        err = TRANSPORTDEC_PARSE_ERROR;
+      }
+
+      if ((hTp->ctrlCFGChange[layer].flushStatus ==
+           TPDEC_RSV60_DASH_IPF_ATSC_FLUSH_ON) ||
+          (hTp->ctrlCFGChange[layer].flushStatus ==
+           TPDEC_USAC_DASH_IPF_FLUSH_ON)) {
+        hTp->ctrlCFGChange[layer].flushCnt++;
+        return err;
+      }
+    }
+
+    if (hTp->asc->m_aot == AOT_USAC) {
+      fConfigFound = 1;
+
+      if (err == TRANSPORTDEC_OK) {
+        *configChanged = 0;
+        configMode = AC_CM_DET_CFG_CHANGE;
+
+        for (int i = 0; i < 2; i++) {
+          if (i > 0) {
+            FDKpushBack(hBs, newConfigLength * 8 - FDKgetValidBits(hBs));
+            configMode = AC_CM_ALLOC_MEM;
+          }
+          /* config transport decoder */
+          err = AudioSpecificConfig_Parse(
+              &hTp->asc[(1 * 1)], hBs, 0, &hTp->callbacks, configMode,
+              *configChanged, hTp->asc[layer].m_aot);
+          if (err == TRANSPORTDEC_OK) {
+            hTp->asc[layer] = hTp->asc[(1 * 1)];
+            errC = hTp->callbacks.cbUpdateConfig(
+                hTp->callbacks.cbUpdateConfigData, &hTp->asc[layer],
+                hTp->asc[layer].configMode, &hTp->asc[layer].AacConfigChanged);
+            if (errC != 0) {
+              err = TRANSPORTDEC_PARSE_ERROR;
+            }
+          }
+
+          if (err == TRANSPORTDEC_OK) {
+            if ((i == 0) && (hTp->asc[layer].AacConfigChanged ||
+                             hTp->asc[layer].SbrConfigChanged ||
+                             hTp->asc[layer].SacConfigChanged)) {
+              *configChanged = 1;
+              errC = hTp->callbacks.cbFreeMem(hTp->callbacks.cbFreeMemData,
+                                              &hTp->asc[layer]);
+              if (errC != 0) {
+                err = TRANSPORTDEC_PARSE_ERROR;
+              }
+            }
+          }
+
+          /* if an error is detected terminate config parsing to avoid that an
+           * invalid config is accepted in the second pass */
+          if (err != TRANSPORTDEC_OK) {
+            break;
+          }
+        }
+      }
+    }
+
+  bail:
+    /* save new config */
+    if (err == TRANSPORTDEC_OK) {
+      if (hTp->asc->m_aot == AOT_USAC) {
+        hTp->asc->m_sc.m_usacConfig.UsacConfigBits = newConfigLength << 3;
+        FDKmemcpy(hTp->asc->m_sc.m_usacConfig.UsacConfig, newConfig,
+                  newConfigLength);
+        /* in case of USAC reset transportDecoder variables here because
+         * otherwise without IPF they are not reset */
+        hTp->ctrlCFGChange[layer].flushCnt = 0;
+        hTp->ctrlCFGChange[layer].flushStatus = TPDEC_FLUSH_OFF;
+        hTp->ctrlCFGChange[layer].buildUpCnt = 0;
+        hTp->ctrlCFGChange[layer].buildUpStatus = TPDEC_BUILD_UP_OFF;
+      }
+    } else {
+      hTp->numberOfRawDataBlocks = 0;
+
+      /* If parsing error while config found, clear ctrlCFGChange-struct */
+      hTp->ctrlCFGChange[layer].flushCnt = 0;
+      hTp->ctrlCFGChange[layer].flushStatus = TPDEC_FLUSH_OFF;
+      hTp->ctrlCFGChange[layer].buildUpCnt = 0;
+      hTp->ctrlCFGChange[layer].buildUpStatus = TPDEC_BUILD_UP_OFF;
+      hTp->ctrlCFGChange[layer].cfgChanged = 0;
+      hTp->ctrlCFGChange[layer].contentChanged = 0;
+      hTp->ctrlCFGChange[layer].forceCfgChange = 0;
+
+      hTp->callbacks.cbCtrlCFGChange(hTp->callbacks.cbCtrlCFGChangeData,
+                                     &hTp->ctrlCFGChange[layer]);
+    }
+  }
+
+  if (err == TRANSPORTDEC_OK && fConfigFound) {
+    hTp->flags |= TPDEC_CONFIG_FOUND;
+  }
+
+  return err;
+}
+
+int transportDec_RegisterAscCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                     const cbUpdateConfig_t cbUpdateConfig,
+                                     void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbUpdateConfig = cbUpdateConfig;
+  hTpDec->callbacks.cbUpdateConfigData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterFreeMemCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                         const cbFreeMem_t cbFreeMem,
+                                         void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbFreeMem = cbFreeMem;
+  hTpDec->callbacks.cbFreeMemData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterCtrlCFGChangeCallback(
+    HANDLE_TRANSPORTDEC hTpDec, const cbCtrlCFGChange_t cbCtrlCFGChange,
+    void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbCtrlCFGChange = cbCtrlCFGChange;
+  hTpDec->callbacks.cbCtrlCFGChangeData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterSscCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                     const cbSsc_t cbSsc, void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbSsc = cbSsc;
+  hTpDec->callbacks.cbSscData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterSbrCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                     const cbSbr_t cbSbr, void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbSbr = cbSbr;
+  hTpDec->callbacks.cbSbrData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterUsacCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                      const cbUsac_t cbUsac, void *user_data) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+  hTpDec->callbacks.cbUsac = cbUsac;
+  hTpDec->callbacks.cbUsacData = user_data;
+  return 0;
+}
+
+int transportDec_RegisterUniDrcConfigCallback(HANDLE_TRANSPORTDEC hTpDec,
+                                              const cbUniDrc_t cbUniDrc,
+                                              void *user_data,
+                                              UINT *pLoudnessInfoSetPosition) {
+  if (hTpDec == NULL) {
+    return -1;
+  }
+
+  hTpDec->callbacks.cbUniDrc = cbUniDrc;
+  hTpDec->callbacks.cbUniDrcData = user_data;
+
+  hTpDec->pLoudnessInfoSetPosition = pLoudnessInfoSetPosition;
+  return 0;
+}
+
+TRANSPORTDEC_ERROR transportDec_FillData(const HANDLE_TRANSPORTDEC hTp,
+                                         UCHAR *pBuffer, const UINT bufferSize,
+                                         UINT *pBytesValid, const INT layer) {
+  HANDLE_FDK_BITSTREAM hBs;
+
+  if ((hTp == NULL) || (layer >= 1)) {
+    return TRANSPORTDEC_INVALID_PARAMETER;
+  }
+
+  /* set bitbuffer shortcut */
+  hBs = &hTp->bitStream[layer];
+
+  if (TT_IS_PACKET(hTp->transportFmt)) {
+    if (hTp->numberOfRawDataBlocks == 0) {
+      FDKresetBitbuffer(hBs);
+      FDKfeedBuffer(hBs, pBuffer, bufferSize, pBytesValid);
+      if (*pBytesValid != 0) {
+        return TRANSPORTDEC_TOO_MANY_BITS;
+      }
+    }
+  } else {
+    /* ... else feed bitbuffer with new stream data (append). */
+
+    if (*pBytesValid == 0) {
+      /* nothing to do */
+      return TRANSPORTDEC_OK;
+    }
+
+    if (hTp->numberOfRawDataBlocks <= 0) {
+      FDKfeedBuffer(hBs, pBuffer, bufferSize, pBytesValid);
+    }
+  }
+
+  return TRANSPORTDEC_OK;
+}
+
+HANDLE_FDK_BITSTREAM transportDec_GetBitstream(const HANDLE_TRANSPORTDEC hTp,
+                                               const UINT layer) {
+  return &hTp->bitStream[layer];
+}
+
+TRANSPORT_TYPE transportDec_GetFormat(const HANDLE_TRANSPORTDEC hTp) {
+  return hTp->transportFmt;
+}
+
+INT transportDec_GetBufferFullness(const HANDLE_TRANSPORTDEC hTp) {
+  INT bufferFullness = -1;
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADTS:
+      if (hTp->parser.adts.bs.adts_fullness != 0x7ff) {
+        bufferFullness = hTp->parser.adts.bs.frame_length * 8 +
+                         hTp->parser.adts.bs.adts_fullness * 32 *
+                             getNumberOfEffectiveChannels(
+                                 hTp->parser.adts.bs.channel_config);
+      }
+      break;
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      if (hTp->parser.latm.m_linfo[0][0].m_bufferFullness != 0xff) {
+        bufferFullness = hTp->parser.latm.m_linfo[0][0].m_bufferFullness;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return bufferFullness;
+}
+
+/**
+ * \brief adjust bit stream position and the end of an access unit.
+ * \param hTp transport decoder handle.
+ * \return error code.
+ */
+static TRANSPORTDEC_ERROR transportDec_AdjustEndOfAccessUnit(
+    HANDLE_TRANSPORTDEC hTp) {
+  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADIF:
+      /* Do byte align at the end of raw_data_block() because UsacFrame() is not
+       * byte aligned. */
+      FDKbyteAlign(hBs, hTp->accessUnitAnchor[0]);
+      break;
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      if (hTp->numberOfRawDataBlocks == 0) {
+        /* Do byte align at the end of AudioMuxElement. */
+        FDKbyteAlign(hBs, hTp->globalFramePos);
+
+        /* Check global frame length */
+        if (hTp->transportFmt == TT_MP4_LOAS &&
+            hTp->parser.latm.m_audioMuxLengthBytes > 0) {
+          int loasOffset;
+
+          loasOffset = ((INT)hTp->parser.latm.m_audioMuxLengthBytes * 8 +
+                        (INT)FDKgetValidBits(hBs)) -
+                       (INT)hTp->globalFramePos;
+          if (loasOffset != 0) {
+            FDKpushBiDirectional(hBs, loasOffset);
+            /* For ELD and other payloads there is an unknown amount of padding,
+               so ignore unread bits, but throw an error only if too many bits
+               where read. */
+            if (loasOffset < 0) {
+              err = TRANSPORTDEC_PARSE_ERROR;
+            }
+          }
+        }
+      }
+      break;
+
+    case TT_MP4_ADTS:
+      if (hTp->parser.adts.bs.protection_absent == 0) {
+        int offset;
+
+        /* Calculate offset to end of AU */
+        offset = hTp->parser.adts
+                     .rawDataBlockDist[hTp->parser.adts.bs.num_raw_blocks -
+                                       hTp->numberOfRawDataBlocks]
+                 << 3;
+        /* CAUTION: The PCE (if available) is declared to be a part of the
+         * header! */
+        offset -= (INT)hTp->accessUnitAnchor[0] - (INT)FDKgetValidBits(hBs) +
+                  16 + hTp->parser.adts.bs.num_pce_bits;
+        FDKpushBiDirectional(hBs, offset);
+      }
+      if (hTp->parser.adts.bs.num_raw_blocks > 0 &&
+          hTp->parser.adts.bs.protection_absent == 0) {
+        /* Note this CRC read currently happens twice because of
+         * transportDec_CrcCheck() */
+        hTp->parser.adts.crcReadValue = FDKreadBits(hBs, 16);
+      }
+      if (hTp->numberOfRawDataBlocks == 0) {
+        /* Check global frame length */
+        if (hTp->parser.adts.bs.protection_absent == 0) {
+          int offset;
+
+          offset = (hTp->parser.adts.bs.frame_length * 8 - ADTS_SYNCLENGTH +
+                    (INT)FDKgetValidBits(hBs)) -
+                   (INT)hTp->globalFramePos;
+          if (offset != 0) {
+            FDKpushBiDirectional(hBs, offset);
+          }
+        }
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  return err;
+}
+
+/**
+ * \brief Determine additional buffer fullness contraint due to burst data
+ * reception. The parameter TPDEC_PARAM_BURSTPERIOD must have been set as a
+ * precondition.
+ * \param hTp transport decoder handle.
+ * \param bufferFullness the buffer fullness value of the first frame to be
+ * decoded.
+ * \param bitsAvail the amount of available bits at the end of the first frame
+ * to be decoded.
+ * \return error code
+ */
+static TRANSPORTDEC_ERROR additionalHoldOffNeeded(HANDLE_TRANSPORTDEC hTp,
+                                                  INT bufferFullness,
+                                                  INT bitsAvail) {
+  INT checkLengthBits, avgBitsPerFrame;
+  INT maxAU; /* maximum number of frames per Master Frame */
+  INT samplesPerFrame = hTp->asc->m_samplesPerFrame;
+  INT samplingFrequency = (INT)hTp->asc->m_samplingFrequency;
+
+  if ((hTp->avgBitRate == 0) || (hTp->burstPeriod == 0)) {
+    return TRANSPORTDEC_OK;
+  }
+  if ((samplesPerFrame == 0) || (samplingFrequency == 0)) {
+    return TRANSPORTDEC_NOT_ENOUGH_BITS;
+  }
+
+  /* One Master Frame is sent every hTp->burstPeriod ms */
+  maxAU = hTp->burstPeriod * samplingFrequency + (samplesPerFrame * 1000 - 1);
+  maxAU = maxAU / (samplesPerFrame * 1000);
+  /* Subtract number of frames which were already held off. */
+  maxAU -= hTp->holdOffFrames;
+
+  avgBitsPerFrame = hTp->avgBitRate * samplesPerFrame + (samplingFrequency - 1);
+  avgBitsPerFrame = avgBitsPerFrame / samplingFrequency;
+
+  /* Consider worst case of bufferFullness quantization. */
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADIF:
+    case TT_MP4_ADTS:
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      bufferFullness += 31;
+      break;
+    default: /* added to avoid compiler warning */
+      break; /* added to avoid compiler warning */
+  }
+
+  checkLengthBits = bufferFullness + (maxAU - 1) * avgBitsPerFrame;
+
+  /* Check if buffer is big enough to fullfill buffer fullness condition */
+  if ((checkLengthBits /*+headerBits*/) > (((8192 * 4) << 3) - 7)) {
+    return TRANSPORTDEC_SYNC_ERROR;
+  }
+
+  if (bitsAvail < checkLengthBits) {
+    return TRANSPORTDEC_NOT_ENOUGH_BITS;
+  } else {
+    return TRANSPORTDEC_OK;
+  }
+}
+
+static TRANSPORTDEC_ERROR transportDec_readHeader(
+    HANDLE_TRANSPORTDEC hTp, HANDLE_FDK_BITSTREAM hBs, int syncLength,
+    int ignoreBufferFullness, int *pRawDataBlockLength,
+    int *pfTraverseMoreFrames, int *pSyncLayerFrameBits, int *pfConfigFound,
+    int *pHeaderBits) {
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+  int rawDataBlockLength = *pRawDataBlockLength;
+  int fTraverseMoreFrames =
+      (pfTraverseMoreFrames != NULL) ? *pfTraverseMoreFrames : 0;
+  int syncLayerFrameBits =
+      (pSyncLayerFrameBits != NULL) ? *pSyncLayerFrameBits : 0;
+  int fConfigFound = (pfConfigFound != NULL) ? *pfConfigFound : 0;
+  int startPos;
+
+  startPos = (INT)FDKgetValidBits(hBs);
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADTS:
+      if (hTp->numberOfRawDataBlocks <= 0) {
+        int i, errC;
+
+        hTp->globalFramePos = FDKgetValidBits(hBs);
+
+        UCHAR configChanged = 0;
+        UCHAR configMode = AC_CM_DET_CFG_CHANGE;
+
+        for (i = 0; i < 2; i++) {
+          if (i > 0) {
+            FDKpushBack(hBs,
+                        (INT)hTp->globalFramePos - (INT)FDKgetValidBits(hBs));
+            configMode = AC_CM_ALLOC_MEM;
+          }
+
+          /* Parse ADTS header */
+          err = adtsRead_DecodeHeader(&hTp->parser.adts, &hTp->asc[0], hBs,
+                                      ignoreBufferFullness);
+          if (err != TRANSPORTDEC_OK) {
+            if (err != TRANSPORTDEC_NOT_ENOUGH_BITS) {
+              err = TRANSPORTDEC_SYNC_ERROR;
+            }
+          } else {
+            errC = hTp->callbacks.cbUpdateConfig(
+                hTp->callbacks.cbUpdateConfigData, &hTp->asc[0], configMode,
+                &configChanged);
+            if (errC != 0) {
+              if (errC == TRANSPORTDEC_NEED_TO_RESTART) {
+                err = TRANSPORTDEC_NEED_TO_RESTART;
+                goto bail;
+              } else {
+                err = TRANSPORTDEC_SYNC_ERROR;
+              }
+            } else {
+              fConfigFound = 1;
+              hTp->numberOfRawDataBlocks =
+                  hTp->parser.adts.bs.num_raw_blocks + 1;
+            }
+          }
+
+          if (err == TRANSPORTDEC_OK) {
+            if ((i == 0) && configChanged) {
+              errC = hTp->callbacks.cbFreeMem(hTp->callbacks.cbFreeMemData,
+                                              &hTp->asc[0]);
+              if (errC != 0) {
+                err = TRANSPORTDEC_PARSE_ERROR;
+              }
+            }
+          }
+        }
+      } else {
+        /* Reset CRC because the next bits are the beginning of a
+         * raw_data_block() */
+        FDKcrcReset(&hTp->parser.adts.crcInfo);
+        hTp->parser.adts.bs.num_pce_bits = 0;
+      }
+      if (err == TRANSPORTDEC_OK) {
+        hTp->numberOfRawDataBlocks--;
+        rawDataBlockLength = adtsRead_GetRawDataBlockLength(
+            &hTp->parser.adts,
+            (hTp->parser.adts.bs.num_raw_blocks - hTp->numberOfRawDataBlocks));
+        if (rawDataBlockLength <= 0) {
+          /* No further frame traversal possible. */
+          fTraverseMoreFrames = 0;
+        }
+        syncLayerFrameBits = (hTp->parser.adts.bs.frame_length << 3) -
+                             (startPos - (INT)FDKgetValidBits(hBs)) -
+                             syncLength;
+        if (syncLayerFrameBits <= 0) {
+          err = TRANSPORTDEC_SYNC_ERROR;
+        }
+      } else {
+        hTp->numberOfRawDataBlocks = 0;
+      }
+      break;
+    case TT_MP4_LOAS:
+      if (hTp->numberOfRawDataBlocks <= 0) {
+        syncLayerFrameBits = (INT)FDKreadBits(hBs, 13);
+        hTp->parser.latm.m_audioMuxLengthBytes = syncLayerFrameBits;
+        syncLayerFrameBits <<= 3;
+      }
+      FDK_FALLTHROUGH;
+    case TT_MP4_LATM_MCP1:
+    case TT_MP4_LATM_MCP0:
+      if (hTp->numberOfRawDataBlocks <= 0) {
+        hTp->globalFramePos = FDKgetValidBits(hBs);
+
+        err = CLatmDemux_Read(hBs, &hTp->parser.latm, hTp->transportFmt,
+                              &hTp->callbacks, hTp->asc, &fConfigFound,
+                              ignoreBufferFullness);
+
+        if (err != TRANSPORTDEC_OK) {
+          if ((err != TRANSPORTDEC_NOT_ENOUGH_BITS) &&
+              !TPDEC_IS_FATAL_ERROR(err)) {
+            err = TRANSPORTDEC_SYNC_ERROR;
+          }
+        } else {
+          hTp->numberOfRawDataBlocks =
+              CLatmDemux_GetNrOfSubFrames(&hTp->parser.latm);
+          if (hTp->transportFmt == TT_MP4_LOAS) {
+            syncLayerFrameBits -= startPos - (INT)FDKgetValidBits(hBs) - (13);
+          }
+        }
+      } else {
+        err = CLatmDemux_ReadPayloadLengthInfo(hBs, &hTp->parser.latm);
+        if (err != TRANSPORTDEC_OK) {
+          err = TRANSPORTDEC_SYNC_ERROR;
+        }
+      }
+      if (err == TRANSPORTDEC_OK) {
+        int layer;
+        rawDataBlockLength = 0;
+        for (layer = 0;
+             layer < (int)CLatmDemux_GetNrOfLayers(&hTp->parser.latm, 0);
+             layer += 1) {
+          rawDataBlockLength +=
+              CLatmDemux_GetFrameLengthInBits(&hTp->parser.latm, 0, layer);
+        }
+        hTp->numberOfRawDataBlocks--;
+      } else {
+        hTp->numberOfRawDataBlocks = 0;
+      }
+      break;
+    default: { syncLayerFrameBits = 0; } break;
+  }
+
+bail:
+
+  *pRawDataBlockLength = rawDataBlockLength;
+
+  if (pHeaderBits != NULL) {
+    *pHeaderBits += startPos - (INT)FDKgetValidBits(hBs);
+  }
+
+  for (int i = 0; i < (1 * 1); i++) {
+    /* If parsing error while config found, clear ctrlCFGChange-struct */
+    if (hTp->ctrlCFGChange[i].cfgChanged && err != TRANSPORTDEC_OK) {
+      hTp->numberOfRawDataBlocks = 0;
+      hTp->ctrlCFGChange[i].flushCnt = 0;
+      hTp->ctrlCFGChange[i].flushStatus = TPDEC_FLUSH_OFF;
+      hTp->ctrlCFGChange[i].buildUpCnt = 0;
+      hTp->ctrlCFGChange[i].buildUpStatus = TPDEC_BUILD_UP_OFF;
+      hTp->ctrlCFGChange[i].cfgChanged = 0;
+      hTp->ctrlCFGChange[i].contentChanged = 0;
+      hTp->ctrlCFGChange[i].forceCfgChange = 0;
+
+      hTp->callbacks.cbCtrlCFGChange(hTp->callbacks.cbCtrlCFGChangeData,
+                                     &hTp->ctrlCFGChange[i]);
+    }
+  }
+
+  if (pfConfigFound != NULL) {
+    *pfConfigFound = fConfigFound;
+  }
+
+  if (pfTraverseMoreFrames != NULL) {
+    *pfTraverseMoreFrames = fTraverseMoreFrames;
+  }
+  if (pSyncLayerFrameBits != NULL) {
+    *pSyncLayerFrameBits = syncLayerFrameBits;
+  }
+
+  return err;
+}
+
+/* How many bits to advance for synchronization search. */
+#define TPDEC_SYNCSKIP 8
+
+static TRANSPORTDEC_ERROR synchronization(HANDLE_TRANSPORTDEC hTp,
+                                          INT *pHeaderBits) {
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK, errFirstFrame = TRANSPORTDEC_OK;
+  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
+
+  INT syncLayerFrameBits = 0; /* Length of sync layer frame (i.e. LOAS) */
+  INT rawDataBlockLength = 0, rawDataBlockLengthPrevious;
+  INT totalBits;
+  INT headerBits = 0, headerBitsFirstFrame = 0, headerBitsPrevious;
+  INT numFramesTraversed = 0, fTraverseMoreFrames,
+      fConfigFound = (hTp->flags & TPDEC_CONFIG_FOUND), startPosFirstFrame = -1;
+  INT numRawDataBlocksFirstFrame = 0, numRawDataBlocksPrevious,
+      globalFramePosFirstFrame = 0, rawDataBlockLengthFirstFrame = 0;
+  INT ignoreBufferFullness =
+      hTp->flags &
+      (TPDEC_LOST_FRAMES_PENDING | TPDEC_IGNORE_BUFFERFULLNESS | TPDEC_SYNCOK);
+  UINT endTpFrameBitsPrevious = 0;
+
+  /* Synch parameters */
+  INT syncLength; /* Length of sync word in bits */
+  UINT syncWord;  /* Sync word to be found */
+  UINT syncMask;  /* Mask for sync word (for adding one bit, so comprising one
+                     bit less) */
+  C_ALLOC_SCRATCH_START(contextFirstFrame, transportdec_parser_t, 1);
+
+  totalBits = (INT)FDKgetValidBits(hBs);
+
+  if (totalBits <= 0) {
+    err = TRANSPORTDEC_NOT_ENOUGH_BITS;
+    goto bail;
+  }
+
+  fTraverseMoreFrames =
+      (hTp->flags & (TPDEC_MINIMIZE_DELAY | TPDEC_EARLY_CONFIG)) &&
+      !(hTp->flags & TPDEC_SYNCOK);
+
+  /* Set transport specific sync parameters */
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADTS:
+      syncWord = ADTS_SYNCWORD;
+      syncLength = ADTS_SYNCLENGTH;
+      break;
+    case TT_MP4_LOAS:
+      syncWord = 0x2B7;
+      syncLength = 11;
+      break;
+    default:
+      syncWord = 0;
+      syncLength = 0;
+      break;
+  }
+
+  syncMask = (1 << syncLength) - 1;
+
+  do {
+    INT bitsAvail = 0;   /* Bits available in bitstream buffer    */
+    INT checkLengthBits; /* Helper to check remaining bits and buffer boundaries
+                          */
+    UINT synch;          /* Current sync word read from bitstream */
+
+    headerBitsPrevious = headerBits;
+
+    bitsAvail = (INT)FDKgetValidBits(hBs);
+
+    if (hTp->numberOfRawDataBlocks == 0) {
+      /* search synchword */
+
+      FDK_ASSERT((bitsAvail % TPDEC_SYNCSKIP) == 0);
+
+      if ((bitsAvail - syncLength) < TPDEC_SYNCSKIP) {
+        err = TRANSPORTDEC_NOT_ENOUGH_BITS;
+        headerBits = 0;
+      } else {
+        synch = FDKreadBits(hBs, syncLength);
+
+        if (!(hTp->flags & TPDEC_SYNCOK)) {
+          for (; (bitsAvail - syncLength) >= TPDEC_SYNCSKIP;
+               bitsAvail -= TPDEC_SYNCSKIP) {
+            if (synch == syncWord) {
+              break;
+            }
+            synch = ((synch << TPDEC_SYNCSKIP) & syncMask) |
+                    FDKreadBits(hBs, TPDEC_SYNCSKIP);
+          }
+        }
+        if (synch != syncWord) {
+          /* No correct syncword found. */
+          err = TRANSPORTDEC_SYNC_ERROR;
+        } else {
+          err = TRANSPORTDEC_OK;
+        }
+        headerBits = syncLength;
+      }
+    } else {
+      headerBits = 0;
+    }
+
+    /* Save previous raw data block data */
+    rawDataBlockLengthPrevious = rawDataBlockLength;
+    numRawDataBlocksPrevious = hTp->numberOfRawDataBlocks;
+
+    /* Parse transport header (raw data block granularity) */
+
+    if (err == TRANSPORTDEC_OK) {
+      err = transportDec_readHeader(hTp, hBs, syncLength, ignoreBufferFullness,
+                                    &rawDataBlockLength, &fTraverseMoreFrames,
+                                    &syncLayerFrameBits, &fConfigFound,
+                                    &headerBits);
+      if (TPDEC_IS_FATAL_ERROR(err)) {
+        /* Rewind - TPDEC_SYNCSKIP, in order to look for a synch one bit ahead
+         * next time. Ensure that the bit amount lands at a multiple of
+         * TPDEC_SYNCSKIP. */
+        FDKpushBiDirectional(
+            hBs, -headerBits + TPDEC_SYNCSKIP + (bitsAvail % TPDEC_SYNCSKIP));
+
+        goto bail;
+      }
+    }
+
+    bitsAvail -= headerBits;
+
+    checkLengthBits = syncLayerFrameBits;
+
+    /* Check if the whole frame would fit the bitstream buffer */
+    if (err == TRANSPORTDEC_OK) {
+      if ((checkLengthBits + headerBits) > (((8192 * 4) << 3) - 7)) {
+        /* We assume that the size of the transport bit buffer has been
+           chosen to meet all system requirements, thus this condition
+           is considered a synchronisation error. */
+        err = TRANSPORTDEC_SYNC_ERROR;
+      } else {
+        if (bitsAvail < checkLengthBits) {
+          err = TRANSPORTDEC_NOT_ENOUGH_BITS;
+        }
+      }
+    }
+
+    if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
+      /* Enforce reading of new data */
+      hTp->numberOfRawDataBlocks = 0;
+      break;
+    }
+
+    if (err == TRANSPORTDEC_SYNC_ERROR) {
+      int bits;
+
+      /* Enforce re-sync of transport headers. */
+      hTp->numberOfRawDataBlocks = 0;
+
+      /* Ensure that the bit amount lands at a multiple of TPDEC_SYNCSKIP */
+      bits = (bitsAvail + headerBits) % TPDEC_SYNCSKIP;
+      /* Rewind - TPDEC_SYNCSKIP, in order to look for a synch one bit ahead
+       * next time. */
+      FDKpushBiDirectional(hBs, -(headerBits - TPDEC_SYNCSKIP) + bits);
+      headerBits = 0;
+    }
+
+    /* Frame traversal */
+    if (fTraverseMoreFrames) {
+      /* Save parser context for early config discovery "rewind all frames" */
+      if ((hTp->flags & TPDEC_EARLY_CONFIG) &&
+          !(hTp->flags & TPDEC_MINIMIZE_DELAY)) {
+        /* ignore buffer fullness if just traversing additional frames for ECD
+         */
+        ignoreBufferFullness = 1;
+
+        /* Save context in order to return later */
+        if (err == TRANSPORTDEC_OK && startPosFirstFrame == -1) {
+          startPosFirstFrame = FDKgetValidBits(hBs);
+          numRawDataBlocksFirstFrame = hTp->numberOfRawDataBlocks;
+          globalFramePosFirstFrame = hTp->globalFramePos;
+          rawDataBlockLengthFirstFrame = rawDataBlockLength;
+          headerBitsFirstFrame = headerBits;
+          errFirstFrame = err;
+          FDKmemcpy(contextFirstFrame, &hTp->parser,
+                    sizeof(transportdec_parser_t));
+        }
+
+        /* Break when config was found or it is not possible anymore to find a
+         * config */
+        if (startPosFirstFrame != -1 &&
+            (fConfigFound || err != TRANSPORTDEC_OK)) {
+          /* In case of ECD and sync error, do not rewind anywhere. */
+          if (err == TRANSPORTDEC_SYNC_ERROR) {
+            startPosFirstFrame = -1;
+            fConfigFound = 0;
+            numFramesTraversed = 0;
+          }
+          break;
+        }
+      }
+
+      if (err == TRANSPORTDEC_OK) {
+        FDKpushFor(hBs, rawDataBlockLength);
+        numFramesTraversed++;
+        endTpFrameBitsPrevious = (INT)FDKgetValidBits(hBs);
+        /* Ignore error here itentionally. */
+        transportDec_AdjustEndOfAccessUnit(hTp);
+        endTpFrameBitsPrevious -= FDKgetValidBits(hBs);
+      }
+    }
+  } while (fTraverseMoreFrames ||
+           (err == TRANSPORTDEC_SYNC_ERROR && !(hTp->flags & TPDEC_SYNCOK)));
+
+  /* Restore context in case of ECD frame traversal */
+  if (startPosFirstFrame != -1 && (fConfigFound || err != TRANSPORTDEC_OK)) {
+    FDKpushBiDirectional(hBs, FDKgetValidBits(hBs) - startPosFirstFrame);
+    FDKmemcpy(&hTp->parser, contextFirstFrame, sizeof(transportdec_parser_t));
+    hTp->numberOfRawDataBlocks = numRawDataBlocksFirstFrame;
+    hTp->globalFramePos = globalFramePosFirstFrame;
+    rawDataBlockLength = rawDataBlockLengthFirstFrame;
+    headerBits = headerBitsFirstFrame;
+    err = errFirstFrame;
+    numFramesTraversed = 0;
+  }
+
+  /* Additional burst data mode buffer fullness check. */
+  if (!(hTp->flags & (TPDEC_LOST_FRAMES_PENDING | TPDEC_IGNORE_BUFFERFULLNESS |
+                      TPDEC_SYNCOK)) &&
+      err == TRANSPORTDEC_OK) {
+    err = additionalHoldOffNeeded(hTp, transportDec_GetBufferFullness(hTp),
+                                  FDKgetValidBits(hBs) - syncLayerFrameBits);
+    if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
+      hTp->holdOffFrames++;
+    }
+  }
+
+  /* Rewind for retry because of not enough bits */
+  if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
+    FDKpushBack(hBs, headerBits);
+    headerBits = 0;
+  } else {
+    /* reset hold off frame counter */
+    hTp->holdOffFrames = 0;
+  }
+
+  /* Return to last good frame in case of frame traversal but not ECD. */
+  if (numFramesTraversed > 0) {
+    FDKpushBack(hBs, rawDataBlockLengthPrevious + endTpFrameBitsPrevious);
+    if (err != TRANSPORTDEC_OK) {
+      hTp->numberOfRawDataBlocks = numRawDataBlocksPrevious;
+      headerBits = headerBitsPrevious;
+      rawDataBlockLength = rawDataBlockLengthPrevious;
+    }
+    err = TRANSPORTDEC_OK;
+  }
+
+bail:
+  hTp->auLength[0] = rawDataBlockLength;
+
+  /* Detect pointless TRANSPORTDEC_NOT_ENOUGH_BITS error case, where the bit
+     buffer is already full, or no new burst packet fits. Recover by advancing
+     the bit buffer. */
+  if ((totalBits > 0) && (TRANSPORTDEC_NOT_ENOUGH_BITS == err) &&
+      (FDKgetValidBits(hBs) >=
+       (((8192 * 4) * 8 - ((hTp->avgBitRate * hTp->burstPeriod) / 1000)) -
+        7))) {
+    FDKpushFor(hBs, TPDEC_SYNCSKIP);
+    err = TRANSPORTDEC_SYNC_ERROR;
+  }
+
+  if (err == TRANSPORTDEC_OK) {
+    hTp->flags |= TPDEC_SYNCOK;
+  }
+
+  if (fConfigFound) {
+    hTp->flags |= TPDEC_CONFIG_FOUND;
+  }
+
+  if (pHeaderBits != NULL) {
+    *pHeaderBits = headerBits;
+  }
+
+  if (err == TRANSPORTDEC_SYNC_ERROR) {
+    hTp->flags &= ~TPDEC_SYNCOK;
+  }
+
+  C_ALLOC_SCRATCH_END(contextFirstFrame, transportdec_parser_t, 1);
+
+  return err;
+}
+
+/**
+ * \brief Synchronize to stream and estimate the amount of missing access units
+ * due to a current synchronization error in case of constant average bit rate.
+ */
+static TRANSPORTDEC_ERROR transportDec_readStream(HANDLE_TRANSPORTDEC hTp,
+                                                  const UINT layer) {
+  TRANSPORTDEC_ERROR error = TRANSPORTDEC_OK;
+  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[layer];
+
+  INT headerBits;
+  INT bitDistance, bfDelta;
+
+  /* Obtain distance to next synch word */
+  bitDistance = (INT)FDKgetValidBits(hBs);
+  error = synchronization(hTp, &headerBits);
+  bitDistance -= (INT)FDKgetValidBits(hBs);
+
+  FDK_ASSERT(bitDistance >= 0);
+
+  INT nAU = -1;
+
+  if (error == TRANSPORTDEC_SYNC_ERROR ||
+      (hTp->flags & TPDEC_LOST_FRAMES_PENDING)) {
+    /* Check if estimating lost access units is feasible. */
+    if (hTp->avgBitRate > 0 && hTp->asc[0].m_samplesPerFrame > 0 &&
+        hTp->asc[0].m_samplingFrequency > 0) {
+      if (error == TRANSPORTDEC_OK) {
+        int aj;
+
+        aj = transportDec_GetBufferFullness(hTp);
+        if (aj > 0) {
+          bfDelta = aj;
+        } else {
+          bfDelta = 0;
+        }
+        /* sync was ok: last of a series of bad access units. */
+        hTp->flags &= ~TPDEC_LOST_FRAMES_PENDING;
+        /* Add up bitDistance until end of the current frame. Later we substract
+           this frame from the grand total, since this current successfully
+           synchronized frame should not be skipped of course; but it must be
+           accounted into the bufferfulness math. */
+        bitDistance += hTp->auLength[0];
+      } else {
+        if (!(hTp->flags & TPDEC_LOST_FRAMES_PENDING)) {
+          /* sync not ok: one of many bad access units. */
+          hTp->flags |= TPDEC_LOST_FRAMES_PENDING;
+          bfDelta = -(INT)hTp->lastValidBufferFullness;
+        } else {
+          bfDelta = 0;
+        }
+      }
+
+      {
+        int num, denom;
+
+        /* Obtain estimate of number of lost frames */
+        num = (INT)hTp->asc[0].m_samplingFrequency * (bfDelta + bitDistance) +
+              hTp->remainder;
+        denom = hTp->avgBitRate * hTp->asc[0].m_samplesPerFrame;
+        if (num > 0) {
+          nAU = num / denom;
+          hTp->remainder = num % denom;
+        } else {
+          hTp->remainder = num;
+        }
+
+        if (error == TRANSPORTDEC_OK) {
+          /* Final adjustment of remainder, taken -1 into account because
+             current frame should not be skipped, thus substract -1 or do
+             nothing instead of +1-1 accordingly. */
+          if ((denom - hTp->remainder) >= hTp->remainder) {
+            nAU--;
+          }
+
+          if (nAU < 0) {
+            /* There was one frame too much concealed, so unfortunately we will
+             * have to skip one good frame. */
+            transportDec_EndAccessUnit(hTp);
+            error = synchronization(hTp, &headerBits);
+            nAU = -1;
+          }
+          hTp->remainder = 0;
+          /* Enforce last missed frames to be concealed. */
+          if (nAU > 0) {
+            FDKpushBack(hBs, headerBits);
+          }
+        }
+      }
+    }
+  }
+
+  /* Be sure that lost frames are handled correctly. This is necessary due to
+     some sync error sequences where later it turns out that there is not enough
+     data, but the bits upto the sync word are discarded, thus causing a value
+     of nAU > 0 */
+  if (nAU > 0) {
+    error = TRANSPORTDEC_SYNC_ERROR;
+  }
+
+  hTp->missingAccessUnits = nAU;
+
+  return error;
+}
+
+/* returns error code */
+TRANSPORTDEC_ERROR transportDec_ReadAccessUnit(const HANDLE_TRANSPORTDEC hTp,
+                                               const UINT layer) {
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+  HANDLE_FDK_BITSTREAM hBs;
+
+  if (!hTp) {
+    return TRANSPORTDEC_INVALID_PARAMETER;
+  }
+
+  hBs = &hTp->bitStream[layer];
+
+  if ((INT)FDKgetValidBits(hBs) <= 0) {
+    /* This is only relevant for RAW and ADIF cases.
+     * For streaming formats err will get overwritten. */
+    err = TRANSPORTDEC_NOT_ENOUGH_BITS;
+    hTp->numberOfRawDataBlocks = 0;
+  }
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADIF:
+      /* Read header if not already done */
+      if (!(hTp->flags & TPDEC_CONFIG_FOUND)) {
+        int i;
+        CProgramConfig *pce;
+        INT bsStart = FDKgetValidBits(hBs);
+        UCHAR configChanged = 0;
+        UCHAR configMode = AC_CM_DET_CFG_CHANGE;
+
+        for (i = 0; i < 2; i++) {
+          if (i > 0) {
+            FDKpushBack(hBs, bsStart - FDKgetValidBits(hBs));
+            configMode = AC_CM_ALLOC_MEM;
+          }
+
+          AudioSpecificConfig_Init(&hTp->asc[0]);
+          pce = &hTp->asc[0].m_progrConfigElement;
+          err = adifRead_DecodeHeader(&hTp->parser.adif, pce, hBs);
+          if (err) goto bail;
+
+          /* Map adif header to ASC */
+          hTp->asc[0].m_aot = (AUDIO_OBJECT_TYPE)(pce->Profile + 1);
+          hTp->asc[0].m_samplingFrequencyIndex = pce->SamplingFrequencyIndex;
+          hTp->asc[0].m_samplingFrequency =
+              SamplingRateTable[pce->SamplingFrequencyIndex];
+          hTp->asc[0].m_channelConfiguration = 0;
+          hTp->asc[0].m_samplesPerFrame = 1024;
+          hTp->avgBitRate = hTp->parser.adif.BitRate;
+
+          /* Call callback to decoder. */
+          {
+            int errC;
+
+            errC = hTp->callbacks.cbUpdateConfig(
+                hTp->callbacks.cbUpdateConfigData, &hTp->asc[0], configMode,
+                &configChanged);
+            if (errC == 0) {
+              hTp->flags |= TPDEC_CONFIG_FOUND;
+            } else {
+              err = TRANSPORTDEC_PARSE_ERROR;
+              goto bail;
+            }
+          }
+
+          if (err == TRANSPORTDEC_OK) {
+            if ((i == 0) && configChanged) {
+              int errC;
+              errC = hTp->callbacks.cbFreeMem(hTp->callbacks.cbFreeMemData,
+                                              &hTp->asc[0]);
+              if (errC != 0) {
+                err = TRANSPORTDEC_PARSE_ERROR;
+              }
+            }
+          }
+        }
+      }
+      hTp->auLength[layer] = -1; /* Access Unit data length is unknown. */
+      break;
+
+    case TT_MP4_RAW:
+    case TT_DRM:
+      /* One Access Unit was filled into buffer.
+         So get the length out of the buffer. */
+      hTp->auLength[layer] = FDKgetValidBits(hBs);
+      hTp->flags |= TPDEC_SYNCOK;
+      break;
+
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      if (err == TRANSPORTDEC_OK) {
+        int fConfigFound = hTp->flags & TPDEC_CONFIG_FOUND;
+        err = transportDec_readHeader(hTp, hBs, 0, 1, &hTp->auLength[layer],
+                                      NULL, NULL, &fConfigFound, NULL);
+        if (fConfigFound) {
+          hTp->flags |= TPDEC_CONFIG_FOUND;
+        }
+      }
+      break;
+
+    case TT_MP4_ADTS:
+    case TT_MP4_LOAS:
+      err = transportDec_readStream(hTp, layer);
+      break;
+
+    default:
+      err = TRANSPORTDEC_UNSUPPORTED_FORMAT;
+      break;
+  }
+
+  if (err == TRANSPORTDEC_OK) {
+    hTp->accessUnitAnchor[layer] = FDKgetValidBits(hBs);
+  } else {
+    hTp->accessUnitAnchor[layer] = 0;
+  }
+
+bail:
+  return err;
+}
+
+TRANSPORTDEC_ERROR transportDec_GetAsc(const HANDLE_TRANSPORTDEC hTp,
+                                       const UINT layer,
+                                       CSAudioSpecificConfig *asc) {
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+  if (hTp != NULL) {
+    *asc = hTp->asc[layer];
+    err = TRANSPORTDEC_OK;
+  } else {
+    err = TRANSPORTDEC_INVALID_PARAMETER;
+  }
+  return err;
+}
+
+INT transportDec_GetAuBitsRemaining(const HANDLE_TRANSPORTDEC hTp,
+                                    const UINT layer) {
+  INT bits;
+
+  if (hTp->accessUnitAnchor[layer] > 0 && hTp->auLength[layer] > 0) {
+    bits = (INT)FDKgetValidBits(&hTp->bitStream[layer]);
+    if (bits >= 0) {
+      bits = hTp->auLength[layer] - ((INT)hTp->accessUnitAnchor[layer] - bits);
+    }
+  } else {
+    bits = FDKgetValidBits(&hTp->bitStream[layer]);
+  }
+
+  return bits;
+}
+
+INT transportDec_GetAuBitsTotal(const HANDLE_TRANSPORTDEC hTp,
+                                const UINT layer) {
+  return hTp->auLength[layer];
+}
+
+TRANSPORTDEC_ERROR transportDec_GetMissingAccessUnitCount(
+    INT *pNAccessUnits, HANDLE_TRANSPORTDEC hTp) {
+  *pNAccessUnits = hTp->missingAccessUnits;
+
+  return TRANSPORTDEC_OK;
+}
+
+/* Inform the transportDec layer that reading of access unit has finished. */
+TRANSPORTDEC_ERROR transportDec_EndAccessUnit(HANDLE_TRANSPORTDEC hTp) {
+  TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1: {
+      HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
+      if (hTp->numberOfRawDataBlocks == 0) {
+        /* Read other data if available. */
+        if (CLatmDemux_GetOtherDataPresentFlag(&hTp->parser.latm)) {
+          int otherDataLen = CLatmDemux_GetOtherDataLength(&hTp->parser.latm);
+
+          if ((INT)FDKgetValidBits(hBs) >= otherDataLen) {
+            FDKpushFor(hBs, otherDataLen);
+          } else {
+            /* Do byte align at the end of AudioMuxElement. */
+            if (hTp->numberOfRawDataBlocks == 0) {
+              FDKbyteAlign(hBs, hTp->globalFramePos);
+            }
+            return TRANSPORTDEC_NOT_ENOUGH_BITS;
+          }
+        }
+      } else {
+        /* If bit buffer has not more bits but hTp->numberOfRawDataBlocks > 0
+           then too many bits were read and obviously no more RawDataBlocks can
+           be read. Set numberOfRawDataBlocks to zero to attempt a new sync
+           attempt. */
+        if ((INT)FDKgetValidBits(hBs) <= 0) {
+          hTp->numberOfRawDataBlocks = 0;
+        }
+      }
+    } break;
+    default:
+      break;
+  }
+
+  err = transportDec_AdjustEndOfAccessUnit(hTp);
+
+  switch (hTp->transportFmt) {
+    default:
+      break;
+  }
+
+  return err;
+}
+
+TRANSPORTDEC_ERROR transportDec_SetParam(const HANDLE_TRANSPORTDEC hTp,
+                                         const TPDEC_PARAM param,
+                                         const INT value) {
+  TRANSPORTDEC_ERROR error = TRANSPORTDEC_OK;
+
+  if (hTp == NULL) {
+    return TRANSPORTDEC_INVALID_PARAMETER;
+  }
+
+  switch (param) {
+    case TPDEC_PARAM_MINIMIZE_DELAY:
+      if (value) {
+        hTp->flags |= TPDEC_MINIMIZE_DELAY;
+      } else {
+        hTp->flags &= ~TPDEC_MINIMIZE_DELAY;
+      }
+      break;
+    case TPDEC_PARAM_EARLY_CONFIG:
+      if (value) {
+        hTp->flags |= TPDEC_EARLY_CONFIG;
+      } else {
+        hTp->flags &= ~TPDEC_EARLY_CONFIG;
+      }
+      break;
+    case TPDEC_PARAM_IGNORE_BUFFERFULLNESS:
+      if (value) {
+        hTp->flags |= TPDEC_IGNORE_BUFFERFULLNESS;
+      } else {
+        hTp->flags &= ~TPDEC_IGNORE_BUFFERFULLNESS;
+      }
+      break;
+    case TPDEC_PARAM_SET_BITRATE:
+      hTp->avgBitRate = value;
+      break;
+    case TPDEC_PARAM_BURST_PERIOD:
+      hTp->burstPeriod = value;
+      break;
+    case TPDEC_PARAM_RESET: {
+      int i;
+
+      for (i = 0; i < (1 * 1); i++) {
+        FDKresetBitbuffer(&hTp->bitStream[i]);
+        hTp->auLength[i] = 0;
+        hTp->accessUnitAnchor[i] = 0;
+      }
+      hTp->flags &= ~(TPDEC_SYNCOK | TPDEC_LOST_FRAMES_PENDING);
+      if (hTp->transportFmt != TT_MP4_ADIF) {
+        hTp->flags &= ~TPDEC_CONFIG_FOUND;
+      }
+      hTp->remainder = 0;
+      hTp->avgBitRate = 0;
+      hTp->missingAccessUnits = 0;
+      hTp->numberOfRawDataBlocks = 0;
+      hTp->globalFramePos = 0;
+      hTp->holdOffFrames = 0;
+    } break;
+    case TPDEC_PARAM_TARGETLAYOUT:
+      hTp->targetLayout = value;
+      break;
+    case TPDEC_PARAM_FORCE_CONFIG_CHANGE:
+      hTp->ctrlCFGChange[value].forceCfgChange = TPDEC_FORCE_CONFIG_CHANGE;
+      break;
+    case TPDEC_PARAM_USE_ELEM_SKIPPING:
+      if (value) {
+        hTp->flags |= TPDEC_USE_ELEM_SKIPPING;
+      } else {
+        hTp->flags &= ~TPDEC_USE_ELEM_SKIPPING;
+      }
+      break;
+  }
+
+  return error;
+}
+
+UINT transportDec_GetNrOfSubFrames(HANDLE_TRANSPORTDEC hTp) {
+  UINT nSubFrames = 0;
+
+  if (hTp == NULL) return 0;
+
+  if (hTp->transportFmt == TT_MP4_LATM_MCP1 ||
+      hTp->transportFmt == TT_MP4_LATM_MCP0 || hTp->transportFmt == TT_MP4_LOAS)
+    nSubFrames = CLatmDemux_GetNrOfSubFrames(&hTp->parser.latm);
+  else if (hTp->transportFmt == TT_MP4_ADTS)
+    nSubFrames = hTp->parser.adts.bs.num_raw_blocks;
+
+  return nSubFrames;
+}
+
+void transportDec_Close(HANDLE_TRANSPORTDEC *phTp) {
+  if (phTp != NULL) {
+    if (*phTp != NULL) {
+      FreeRam_TransportDecoderBuffer(&(*phTp)->bsBuffer);
+      FreeRam_TransportDecoder(phTp);
+    }
+  }
+}
+
+TRANSPORTDEC_ERROR transportDec_GetLibInfo(LIB_INFO *info) {
+  int i;
+
+  if (info == NULL) {
+    return TRANSPORTDEC_UNKOWN_ERROR;
+  }
+
+  /* search for next free tab */
+  for (i = 0; i < FDK_MODULE_LAST; i++) {
+    if (info[i].module_id == FDK_NONE) break;
+  }
+  if (i == FDK_MODULE_LAST) return TRANSPORTDEC_UNKOWN_ERROR;
+  info += i;
+
+  info->module_id = FDK_TPDEC;
+#ifdef __ANDROID__
+  info->build_date = "";
+  info->build_time = "";
+#else
+  info->build_date = __DATE__;
+  info->build_time = __TIME__;
+#endif
+  info->title = TP_LIB_TITLE;
+  info->version = LIB_VERSION(TP_LIB_VL0, TP_LIB_VL1, TP_LIB_VL2);
+  LIB_VERSION_STRING(info);
+  info->flags = 0 | CAPF_ADIF | CAPF_ADTS | CAPF_LATM | CAPF_LOAS |
+                CAPF_RAWPACKETS | CAPF_DRM;
+
+  return TRANSPORTDEC_OK; /* FDKERR_NOERROR; */
+}
+
+int transportDec_CrcStartReg(HANDLE_TRANSPORTDEC pTp, INT mBits) {
+  switch (pTp->transportFmt) {
+    case TT_MP4_ADTS:
+      return adtsRead_CrcStartReg(&pTp->parser.adts, &pTp->bitStream[0], mBits);
+    case TT_DRM:
+      return drmRead_CrcStartReg(&pTp->parser.drm, &pTp->bitStream[0], mBits);
+    default:
+      return -1;
+  }
+}
+
+void transportDec_CrcEndReg(HANDLE_TRANSPORTDEC pTp, INT reg) {
+  switch (pTp->transportFmt) {
+    case TT_MP4_ADTS:
+      adtsRead_CrcEndReg(&pTp->parser.adts, &pTp->bitStream[0], reg);
+      break;
+    case TT_DRM:
+      drmRead_CrcEndReg(&pTp->parser.drm, &pTp->bitStream[0], reg);
+      break;
+    default:
+      break;
+  }
+}
+
+TRANSPORTDEC_ERROR transportDec_CrcCheck(HANDLE_TRANSPORTDEC pTp) {
+  switch (pTp->transportFmt) {
+    case TT_MP4_ADTS:
+      if ((pTp->parser.adts.bs.num_raw_blocks > 0) &&
+          (pTp->parser.adts.bs.protection_absent == 0)) {
+        transportDec_AdjustEndOfAccessUnit(pTp);
+      }
+      return adtsRead_CrcCheck(&pTp->parser.adts);
+    case TT_DRM:
+      return drmRead_CrcCheck(&pTp->parser.drm);
+    default:
+      return TRANSPORTDEC_OK;
+  }
+}
+
+TRANSPORTDEC_ERROR transportDec_DrmRawSdcAudioConfig_Check(UCHAR *conf,
+                                                           const UINT length) {
+  CSAudioSpecificConfig asc;
+  FDK_BITSTREAM bs;
+  HANDLE_FDK_BITSTREAM hBs = &bs;
+
+  FDKinitBitStream(hBs, conf, BUFSIZE_DUMMY_VALUE, length << 3, BS_READER);
+
+  TRANSPORTDEC_ERROR err =
+      DrmRawSdcAudioConfig_Parse(&asc, hBs, NULL, (UCHAR)AC_CM_ALLOC_MEM, 0);
+
+  return err;
+}