aboutsummaryrefslogtreecommitdiffstats
path: root/fdk-aac/libMpegTPDec/src/tpdec_lib.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fdk-aac/libMpegTPDec/src/tpdec_lib.cpp')
-rw-r--r--fdk-aac/libMpegTPDec/src/tpdec_lib.cpp1820
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;
+}