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

diff --git a/fdk-aac/libMpegTPEnc/src/tpenc_lib.cpp b/fdk-aac/libMpegTPEnc/src/tpenc_lib.cpp
new file mode 100644
index 0000000..316c6e0
--- /dev/null
+++ b/fdk-aac/libMpegTPEnc/src/tpenc_lib.cpp
@@ -0,0 +1,713 @@
+/* -----------------------------------------------------------------------------
+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 encoder library *********************
+
+   Author(s):   Manuel Jander
+
+   Description: MPEG Transport encode
+
+*******************************************************************************/
+
+#include "tpenc_lib.h"
+
+/* library info */
+#include "tp_version.h"
+
+#define MODULE_NAME "transportEnc"
+
+#include "tpenc_asc.h"
+
+#include "tpenc_adts.h"
+
+#include "tpenc_adif.h"
+
+#include "tpenc_dab.h"
+
+#include "tpenc_latm.h"
+
+typedef struct {
+  int curSubFrame;
+  int nSubFrames;
+  int prevBits;
+} RAWPACKETS_INFO;
+
+struct TRANSPORTENC {
+  CODER_CONFIG config;
+  TRANSPORT_TYPE transportFmt; /*!< MPEG4 transport type. */
+
+  FDK_BITSTREAM bitStream;
+  UCHAR *bsBuffer;
+  INT bsBufferSize;
+
+  INT pceFrameCounter; /*!< Indicates frame period when PCE must be written in
+                          raw_data_block. -1 means not to write a PCE in
+                          raw_dat_block. */
+  union {
+    STRUCT_ADTS adts;
+
+    ADIF_INFO adif;
+
+    STRUCT_DAB dab;
+
+    LATM_STREAM latm;
+
+    RAWPACKETS_INFO raw;
+
+  } writer;
+
+  CSTpCallBacks callbacks;
+};
+
+typedef struct _TRANSPORTENC_STRUCT TRANSPORTENC_STRUCT;
+
+/*
+ * MEMORY Declaration
+ */
+
+C_ALLOC_MEM(Ram_TransportEncoder, struct TRANSPORTENC, 1)
+
+TRANSPORTENC_ERROR transportEnc_Open(HANDLE_TRANSPORTENC *phTpEnc) {
+  HANDLE_TRANSPORTENC hTpEnc;
+
+  if (phTpEnc == NULL) {
+    return TRANSPORTENC_INVALID_PARAMETER;
+  }
+
+  hTpEnc = GetRam_TransportEncoder(0);
+
+  if (hTpEnc == NULL) {
+    return TRANSPORTENC_NO_MEM;
+  }
+
+  *phTpEnc = hTpEnc;
+  return TRANSPORTENC_OK;
+}
+
+/**
+ * \brief  Get frame period of PCE in raw_data_block.
+ *
+ * - Write PCE only if necessary. PCE can be part of the ASC if chConfig==0
+ * whererfore no additonal PCE will be written in raw_data_block.
+ * - A matrixMixdown coefficient can only be written if chConfig is 5.0 or 5.1.
+ * - The PCE repetition rate in raw_data_block can be controlled via
+ * headerPeriod parameter.
+ *
+ * \param channelMode           Encoder Channel Mode.
+ * \param channelConfigZero     No standard channel configuration.
+ * \param transportFmt          Format of the transport to be written.
+ * \param headerPeriod          Chosen PCE frame repetition rate.
+ * \param matrixMixdownA        Indicates if a valid Matrix Mixdown coefficient
+ * is available.
+ *
+ * \return  PCE frame repetition rate. -1 means no PCE present in
+ * raw_data_block.
+ */
+static INT getPceRepetitionRate(const CHANNEL_MODE channelMode,
+                                const int channelConfigZero,
+                                const TRANSPORT_TYPE transportFmt,
+                                const int headerPeriod,
+                                const int matrixMixdownA) {
+  INT pceFrameCounter = -1; /* variable to be returned */
+
+  if (headerPeriod > 0) {
+    switch (getChannelConfig(channelMode, channelConfigZero)) {
+      case 0:
+        switch (transportFmt) {
+          case TT_MP4_ADTS:
+          case TT_MP4_LATM_MCP0:
+          case TT_MP4_RAW:
+            pceFrameCounter = headerPeriod;
+            break;
+          case TT_MP4_ADIF: /* ADIF header comprises PCE */
+            if ((channelMode == MODE_1_2_2) || (channelMode == MODE_1_2_2_1)) {
+              pceFrameCounter = headerPeriod; /* repeating pce only meaningful
+                                                 for potential matrix mixdown */
+              break;
+            }
+            FDK_FALLTHROUGH;
+          case TT_MP4_LOAS:      /* PCE in ASC if chChonfig==0 */
+          case TT_MP4_LATM_MCP1: /* PCE in ASC if chChonfig==0 */
+          case TT_DABPLUS:
+          default:
+            pceFrameCounter = -1; /* no PCE in raw_data_block */
+        }
+        break;
+      case 5: /* MODE_1_2_2 */
+      case 6: /* MODE_1_2_2_1 */
+        /* matrixMixdownCoefficient can only be written if 5.0 and 5.1 config
+         * present. */
+        if (matrixMixdownA != 0) {
+          switch (transportFmt) {
+            case TT_MP4_ADIF: /* ADIF header comprises PCE */
+            case TT_MP4_ADTS:
+            case TT_MP4_LOAS:      /* no PCE in ASC because chConfig!=0 */
+            case TT_MP4_LATM_MCP1: /* no PCE in ASC because chConfig!=0 */
+            case TT_MP4_LATM_MCP0:
+            case TT_MP4_RAW:
+              pceFrameCounter = headerPeriod;
+              break;
+            case TT_DABPLUS:
+            default:
+              pceFrameCounter = -1; /* no PCE in raw_data_block */
+          }                         /* switch transportFmt */
+        }                           /* if matrixMixdownA!=0 */
+        break;
+      default:
+        pceFrameCounter = -1; /* no PCE in raw_data_block */
+    }                         /* switch getChannelConfig() */
+  }                           /* if headerPeriod>0  */
+  else {
+    pceFrameCounter = -1; /* no PCE in raw_data_block */
+  }
+
+  return pceFrameCounter;
+}
+
+TRANSPORTENC_ERROR transportEnc_Init(HANDLE_TRANSPORTENC hTpEnc,
+                                     UCHAR *bsBuffer, INT bsBufferSize,
+                                     TRANSPORT_TYPE transportFmt,
+                                     CODER_CONFIG *cconfig, UINT flags) {
+  /* Copy configuration structure */
+  FDKmemcpy(&hTpEnc->config, cconfig, sizeof(CODER_CONFIG));
+
+  /* Init transportEnc struct. */
+  hTpEnc->transportFmt = transportFmt;
+
+  hTpEnc->bsBuffer = bsBuffer;
+  hTpEnc->bsBufferSize = bsBufferSize;
+
+  FDKinitBitStream(&hTpEnc->bitStream, hTpEnc->bsBuffer, hTpEnc->bsBufferSize,
+                   0, BS_WRITER);
+
+  switch (transportFmt) {
+    case TT_MP4_ADIF:
+      /* Sanity checks */
+      if ((hTpEnc->config.aot != AOT_AAC_LC) ||
+          (hTpEnc->config.samplesPerFrame != 1024)) {
+        return TRANSPORTENC_INVALID_PARAMETER;
+      }
+      hTpEnc->writer.adif.headerWritten = 0;
+      hTpEnc->writer.adif.samplingRate = hTpEnc->config.samplingRate;
+      hTpEnc->writer.adif.bitRate = hTpEnc->config.bitRate;
+      hTpEnc->writer.adif.profile = ((int)hTpEnc->config.aot) - 1;
+      hTpEnc->writer.adif.cm = hTpEnc->config.channelMode;
+      hTpEnc->writer.adif.bVariableRate = 0;
+      hTpEnc->writer.adif.instanceTag = 0;
+      hTpEnc->writer.adif.matrixMixdownA = hTpEnc->config.matrixMixdownA;
+      hTpEnc->writer.adif.pseudoSurroundEnable =
+          (hTpEnc->config.flags & CC_PSEUDO_SURROUND) ? 1 : 0;
+      break;
+
+    case TT_MP4_ADTS:
+      /* Sanity checks */
+      if ((hTpEnc->config.aot != AOT_AAC_LC) ||
+          (hTpEnc->config.samplesPerFrame != 1024)) {
+        return TRANSPORTENC_INVALID_PARAMETER;
+      }
+      if (adtsWrite_Init(&hTpEnc->writer.adts, &hTpEnc->config) != 0) {
+        return TRANSPORTENC_INVALID_PARAMETER;
+      }
+      break;
+
+  case TT_DABPLUS:
+    /* Sanity checks */
+    if ( ( hTpEnc->config.aot != AOT_AAC_LC)
+       ||(hTpEnc->config.samplesPerFrame != 960) )
+    {
+      return TRANSPORTENC_INVALID_PARAMETER;
+    }
+    if ( dabWrite_Init(&hTpEnc->writer.dab, &hTpEnc->config) != 0) {
+      return TRANSPORTENC_INVALID_PARAMETER;
+    }
+    break;
+
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1: {
+      TRANSPORTENC_ERROR error;
+
+      error = transportEnc_Latm_Init(&hTpEnc->writer.latm, &hTpEnc->bitStream,
+                                     &hTpEnc->config, flags & TP_FLAG_LATM_AMV,
+                                     transportFmt, &hTpEnc->callbacks);
+      if (error != TRANSPORTENC_OK) {
+        return error;
+      }
+    } break;
+
+    case TT_MP4_RAW:
+      hTpEnc->writer.raw.curSubFrame = 0;
+      hTpEnc->writer.raw.nSubFrames = hTpEnc->config.nSubFrames;
+      break;
+
+    default:
+      return TRANSPORTENC_INVALID_PARAMETER;
+  }
+
+  /* pceFrameCounter indicates if PCE must be written in raw_data_block. */
+  hTpEnc->pceFrameCounter = getPceRepetitionRate(
+      hTpEnc->config.channelMode, hTpEnc->config.channelConfigZero,
+      transportFmt, hTpEnc->config.headerPeriod, hTpEnc->config.matrixMixdownA);
+
+  return TRANSPORTENC_OK;
+}
+
+TRANSPORTENC_ERROR transportEnc_AddOtherDataBits(HANDLE_TRANSPORTENC hTpEnc,
+                                                 const int nBits) {
+  TRANSPORTENC_ERROR tpErr = TRANSPORTENC_OK;
+
+  switch (hTpEnc->transportFmt) {
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+    case TT_MP4_LOAS:
+      tpErr = transportEnc_LatmAddOtherDataBits(&hTpEnc->writer.latm, nBits);
+      break;
+    case TT_MP4_ADTS:
+    case TT_MP4_ADIF:
+    case TT_MP4_RAW:
+    default:
+      tpErr = TRANSPORTENC_UNKOWN_ERROR;
+  }
+
+  return tpErr;
+}
+
+HANDLE_FDK_BITSTREAM transportEnc_GetBitstream(HANDLE_TRANSPORTENC hTp) {
+  return &hTp->bitStream;
+}
+
+int transportEnc_RegisterSbrCallback(HANDLE_TRANSPORTENC hTpEnc,
+                                     const cbSbr_t cbSbr, void *user_data) {
+  if (hTpEnc == NULL) {
+    return -1;
+  }
+  hTpEnc->callbacks.cbSbr = cbSbr;
+  hTpEnc->callbacks.cbSbrData = user_data;
+  return 0;
+}
+int transportEnc_RegisterUsacCallback(HANDLE_TRANSPORTENC hTpEnc,
+                                      const cbUsac_t cbUsac, void *user_data) {
+  if (hTpEnc == NULL) {
+    return -1;
+  }
+  hTpEnc->callbacks.cbUsac = cbUsac;
+  hTpEnc->callbacks.cbUsacData = user_data;
+  return 0;
+}
+
+int transportEnc_RegisterSscCallback(HANDLE_TRANSPORTENC hTpEnc,
+                                     const cbSsc_t cbSsc, void *user_data) {
+  if (hTpEnc == NULL) {
+    return -1;
+  }
+  hTpEnc->callbacks.cbSsc = cbSsc;
+  hTpEnc->callbacks.cbSscData = user_data;
+  return 0;
+}
+
+TRANSPORTENC_ERROR transportEnc_WriteAccessUnit(HANDLE_TRANSPORTENC hTp,
+                                                INT frameUsedBits,
+                                                int bufferFullness, int ncc) {
+  TRANSPORTENC_ERROR err = TRANSPORTENC_OK;
+
+  if (!hTp) {
+    return TRANSPORTENC_INVALID_PARAMETER;
+  }
+  HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream;
+
+  /* In case of writing PCE in raw_data_block frameUsedBits must be adapted. */
+  if (hTp->pceFrameCounter >= hTp->config.headerPeriod) {
+    frameUsedBits += transportEnc_GetPCEBits(
+        hTp->config.channelMode, hTp->config.matrixMixdownA,
+        3); /* Consider 3 bits ID signalling in alignment */
+  }
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADIF:
+      FDKinitBitStream(&hTp->bitStream, hTp->bsBuffer, hTp->bsBufferSize, 0,
+                       BS_WRITER);
+      if (0 != adifWrite_EncodeHeader(&hTp->writer.adif, hBs, bufferFullness)) {
+        err = TRANSPORTENC_INVALID_CONFIG;
+      }
+      break;
+    case TT_MP4_ADTS:
+      bufferFullness /= ncc; /* Number of Considered Channels */
+      bufferFullness /= 32;
+      bufferFullness = FDKmin(0x7FF, bufferFullness); /* Signal variable rate */
+      adtsWrite_EncodeHeader(&hTp->writer.adts, &hTp->bitStream, bufferFullness,
+                             frameUsedBits);
+      break;
+    case TT_DABPLUS:
+      bufferFullness /= ncc;                          /* Number of Considered Channels */
+      bufferFullness /= 32;
+      bufferFullness = FDKmin(0x7FF, bufferFullness); /* Signal variable rate */
+      dabWrite_EncodeHeader(
+             &hTp->writer.dab,
+             &hTp->bitStream,
+              bufferFullness,
+              frameUsedBits
+              );
+      break;
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      bufferFullness /= ncc; /* Number of Considered Channels */
+      bufferFullness /= 32;
+      bufferFullness = FDKmin(0xFF, bufferFullness); /* Signal variable rate */
+      transportEnc_LatmWrite(&hTp->writer.latm, hBs, frameUsedBits,
+                             bufferFullness, &hTp->callbacks);
+      break;
+    case TT_MP4_RAW:
+      if (hTp->writer.raw.curSubFrame >= hTp->writer.raw.nSubFrames) {
+        hTp->writer.raw.curSubFrame = 0;
+        FDKinitBitStream(&hTp->bitStream, hTp->bsBuffer, hTp->bsBufferSize, 0,
+                         BS_WRITER);
+      }
+      hTp->writer.raw.prevBits = FDKgetValidBits(hBs);
+      break;
+    default:
+      err = TRANSPORTENC_UNSUPPORTED_FORMAT;
+      break;
+  }
+
+  /* Write PCE in raw_data_block if required */
+  if (hTp->pceFrameCounter >= hTp->config.headerPeriod) {
+    INT crcIndex = 0;
+    /* Align inside PCE with repsect to the first bit of the raw_data_block() */
+    UINT alignAnchor = FDKgetValidBits(&hTp->bitStream);
+
+    /* Write PCE element ID bits */
+    FDKwriteBits(&hTp->bitStream, ID_PCE, 3);
+
+    if ((hTp->transportFmt == TT_MP4_ADTS) &&
+        !hTp->writer.adts.protection_absent) {
+      crcIndex = adtsWrite_CrcStartReg(&hTp->writer.adts, &hTp->bitStream, 0);
+    }
+
+    /* Write PCE as first raw_data_block element */
+    transportEnc_writePCE(
+        &hTp->bitStream, hTp->config.channelMode, hTp->config.samplingRate, 0,
+        1, hTp->config.matrixMixdownA,
+        (hTp->config.flags & CC_PSEUDO_SURROUND) ? 1 : 0, alignAnchor);
+
+    if ((hTp->transportFmt == TT_MP4_ADTS) &&
+        !hTp->writer.adts.protection_absent) {
+      adtsWrite_CrcEndReg(&hTp->writer.adts, &hTp->bitStream, crcIndex);
+    }
+    hTp->pceFrameCounter = 0; /* reset pce frame counter */
+  }
+
+  if (hTp->pceFrameCounter != -1) {
+    hTp->pceFrameCounter++; /* Update pceFrameCounter only if PCE writing is
+                               active. */
+  }
+
+  return err;
+}
+
+TRANSPORTENC_ERROR transportEnc_EndAccessUnit(HANDLE_TRANSPORTENC hTp,
+                                              int *bits) {
+  switch (hTp->transportFmt) {
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+    case TT_MP4_LOAS:
+      transportEnc_LatmAdjustSubframeBits(&hTp->writer.latm, bits);
+      break;
+    case TT_MP4_ADTS:
+      adtsWrite_EndRawDataBlock(&hTp->writer.adts, &hTp->bitStream, bits);
+      break;
+    case TT_DABPLUS:
+      dabWrite_EndRawDataBlock(&hTp->writer.dab, &hTp->bitStream, bits);
+      break;
+    case TT_MP4_ADIF:
+      /* Substract ADIF header from AU bits, not to be considered. */
+      *bits -= adifWrite_GetHeaderBits(&hTp->writer.adif);
+      hTp->writer.adif.headerWritten = 1;
+      break;
+    case TT_MP4_RAW:
+      *bits -= hTp->writer.raw.prevBits;
+      break;
+    default:
+      break;
+  }
+
+  return TRANSPORTENC_OK;
+}
+
+TRANSPORTENC_ERROR transportEnc_GetFrame(HANDLE_TRANSPORTENC hTpEnc,
+                                         int *nbytes) {
+  TRANSPORTENC_ERROR tpErr = TRANSPORTENC_OK;
+  HANDLE_FDK_BITSTREAM hBs = &hTpEnc->bitStream;
+
+  switch (hTpEnc->transportFmt) {
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+    case TT_MP4_LOAS:
+      *nbytes = hTpEnc->bsBufferSize;
+      tpErr = transportEnc_LatmGetFrame(&hTpEnc->writer.latm, hBs, nbytes);
+      break;
+    case TT_MP4_ADTS:
+      if (hTpEnc->writer.adts.currentBlock >=
+          hTpEnc->writer.adts.num_raw_blocks + 1) {
+        *nbytes = (FDKgetValidBits(hBs) + 7) >> 3;
+        hTpEnc->writer.adts.currentBlock = 0;
+      } else {
+        *nbytes = 0;
+      }
+      break;
+    case TT_DABPLUS:
+      if (hTpEnc->writer.dab.currentBlock >= hTpEnc->writer.dab.num_raw_blocks+1) {
+        *nbytes = (FDKgetValidBits(hBs) + 7)>>3;
+        hTpEnc->writer.dab.currentBlock = 0;
+      } else {
+        *nbytes = 0;
+      }
+      break;
+    case TT_MP4_ADIF:
+      FDK_ASSERT((INT)FDKgetValidBits(hBs) >= 0);
+      *nbytes = (FDKgetValidBits(hBs) + 7) >> 3;
+      break;
+    case TT_MP4_RAW:
+      FDKsyncCache(hBs);
+      hTpEnc->writer.raw.curSubFrame++;
+      *nbytes = ((FDKgetValidBits(hBs) - hTpEnc->writer.raw.prevBits) + 7) >> 3;
+      break;
+    default:
+      break;
+  }
+
+  return tpErr;
+}
+
+INT transportEnc_GetStaticBits(HANDLE_TRANSPORTENC hTp, int auBits) {
+  INT nbits = 0, nPceBits = 0;
+
+  /* Write PCE within raw_data_block in transport lib. */
+  if (hTp->pceFrameCounter >= hTp->config.headerPeriod) {
+    nPceBits = transportEnc_GetPCEBits(
+        hTp->config.channelMode, hTp->config.matrixMixdownA,
+        3);             /* Consider 3 bits ID signalling in alignment */
+    auBits += nPceBits; /* Adapt required raw_data_block bit consumtpion for AU
+                           length information e.g. in LATM/LOAS configuration.
+                         */
+  }
+
+  switch (hTp->transportFmt) {
+    case TT_MP4_ADIF:
+    case TT_MP4_RAW:
+      nbits = 0; /* Do not consider the ADIF header into the total bitrate */
+      break;
+    case TT_MP4_ADTS:
+      nbits = adtsWrite_GetHeaderBits(&hTp->writer.adts);
+      break;
+    case TT_DABPLUS:
+      nbits = dabWrite_CountTotalBitDemandHeader(&hTp->writer.dab, auBits);
+      break;
+    case TT_MP4_LOAS:
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+      nbits =
+          transportEnc_LatmCountTotalBitDemandHeader(&hTp->writer.latm, auBits);
+      break;
+    default:
+      nbits = 0;
+      break;
+  }
+
+  /* PCE is written in the transport library therefore the bit consumption is
+   * part of the transport static bits. */
+  nbits += nPceBits;
+
+  return nbits;
+}
+
+void transportEnc_Close(HANDLE_TRANSPORTENC *phTp) {
+  if (phTp != NULL) {
+    if (*phTp != NULL) {
+      FreeRam_TransportEncoder(phTp);
+    }
+  }
+}
+
+int transportEnc_CrcStartReg(HANDLE_TRANSPORTENC hTpEnc, int mBits) {
+  int crcReg = 0;
+
+  switch (hTpEnc->transportFmt) {
+    case TT_MP4_ADTS:
+      crcReg = adtsWrite_CrcStartReg(&hTpEnc->writer.adts, &hTpEnc->bitStream,
+                                     mBits);
+      break;
+    case TT_DABPLUS:
+      crcReg = dabWrite_CrcStartReg(&hTpEnc->writer.dab, &hTpEnc->bitStream, mBits);
+      break;
+    default:
+      break;
+  }
+
+  return crcReg;
+}
+
+void transportEnc_CrcEndReg(HANDLE_TRANSPORTENC hTpEnc, int reg) {
+  switch (hTpEnc->transportFmt) {
+    case TT_MP4_ADTS:
+      adtsWrite_CrcEndReg(&hTpEnc->writer.adts, &hTpEnc->bitStream, reg);
+      break;
+    case TT_DABPLUS:
+      dabWrite_CrcEndReg(&hTpEnc->writer.dab, &hTpEnc->bitStream, reg);
+      break;
+    default:
+      break;
+  }
+}
+
+TRANSPORTENC_ERROR transportEnc_GetConf(HANDLE_TRANSPORTENC hTpEnc,
+                                        CODER_CONFIG *cc,
+                                        FDK_BITSTREAM *dataBuffer,
+                                        UINT *confType) {
+  TRANSPORTENC_ERROR tpErr = TRANSPORTENC_OK;
+  HANDLE_LATM_STREAM hLatmConfig = &hTpEnc->writer.latm;
+
+  *confType = 0; /* set confType variable to default */
+
+  /* write StreamMuxConfig or AudioSpecificConfig depending on format used */
+  switch (hTpEnc->transportFmt) {
+    case TT_MP4_LATM_MCP0:
+    case TT_MP4_LATM_MCP1:
+    case TT_MP4_LOAS:
+      tpErr =
+          CreateStreamMuxConfig(hLatmConfig, dataBuffer, 0, &hTpEnc->callbacks);
+      *confType = 1; /* config is SMC */
+      break;
+    default:
+      if (transportEnc_writeASC(dataBuffer, cc, &hTpEnc->callbacks) != 0) {
+        tpErr = TRANSPORTENC_UNKOWN_ERROR;
+      }
+  }
+
+  return tpErr;
+}
+
+TRANSPORTENC_ERROR transportEnc_GetLibInfo(LIB_INFO *info) {
+  int i;
+
+  if (info == NULL) {
+    return TRANSPORTENC_INVALID_PARAMETER;
+  }
+  /* 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 TRANSPORTENC_UNKOWN_ERROR;
+  }
+  info += i;
+
+  info->module_id = FDK_TPENC;
+  info->version = LIB_VERSION(TP_LIB_VL0, TP_LIB_VL1, TP_LIB_VL2);
+  LIB_VERSION_STRING(info);
+#ifdef __ANDROID__
+  info->build_date = "";
+  info->build_time = "";
+#else
+  info->build_date = __DATE__;
+  info->build_time = __TIME__;
+#endif
+  info->title = TP_LIB_TITLE;
+
+  /* Set flags */
+  info->flags =
+      0 | CAPF_ADIF | CAPF_ADTS | CAPF_LATM | CAPF_LOAS | CAPF_RAWPACKETS | CAPF_DAB_AAC;
+
+  return TRANSPORTENC_OK;
+}