/* -----------------------------------------------------------------------------
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
|
Forschung e.V. All rights reserved.
|
|
1. INTRODUCTION
|
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
|
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
|
scheme for digital audio. This FDK AAC Codec software is intended to be used on
|
a wide variety of Android devices.
|
|
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
|
general perceptual audio codecs. AAC-ELD is considered the best-performing
|
full-bandwidth communications codec by independent studies and is widely
|
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
|
specifications.
|
|
Patent licenses for necessary patent claims for the FDK AAC Codec (including
|
those of Fraunhofer) may be obtained through Via Licensing
|
(www.vialicensing.com) or through the respective patent owners individually for
|
the purpose of encoding or decoding bit streams in products that are compliant
|
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
|
Android devices already license these patent claims through Via Licensing or
|
directly from the patent owners, and therefore FDK AAC Codec software may
|
already be covered under those patent licenses when it is used for those
|
licensed purposes only.
|
|
Commercially-licensed AAC software libraries, including floating-point versions
|
with enhanced sound quality, are also available from Fraunhofer. Users are
|
encouraged to check the Fraunhofer website for additional applications
|
information and documentation.
|
|
2. COPYRIGHT LICENSE
|
|
Redistribution and use in source and binary forms, with or without modification,
|
are permitted without payment of copyright license fees provided that you
|
satisfy the following conditions:
|
|
You must retain the complete text of this software license in redistributions of
|
the FDK AAC Codec or your modifications thereto in source code form.
|
|
You must retain the complete text of this software license in the documentation
|
and/or other materials provided with redistributions of the FDK AAC Codec or
|
your modifications thereto in binary form. You must make available free of
|
charge copies of the complete source code of the FDK AAC Codec and your
|
modifications thereto to recipients of copies in binary form.
|
|
The name of Fraunhofer may not be used to endorse or promote products derived
|
from this library without prior written permission.
|
|
You may not charge copyright license fees for anyone to use, copy or distribute
|
the FDK AAC Codec software or your modifications thereto.
|
|
Your modified versions of the FDK AAC Codec must carry prominent notices stating
|
that you changed the software and the date of any change. For modified versions
|
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
|
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
|
AAC Codec Library for Android."
|
|
3. NO PATENT LICENSE
|
|
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
|
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
|
Fraunhofer provides no warranty of patent non-infringement with respect to this
|
software.
|
|
You may use this FDK AAC Codec software or modifications thereto only for
|
purposes that are authorized by appropriate patent licenses.
|
|
4. DISCLAIMER
|
|
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
|
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
|
including but not limited to the implied warranties of merchantability and
|
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
|
or consequential damages, including but not limited to procurement of substitute
|
goods or services; loss of use, data, or profits, or business interruption,
|
however caused and on any theory of liability, whether in contract, strict
|
liability, or tort (including negligence), arising in any way out of the use of
|
this software, even if advised of the possibility of such damage.
|
|
5. CONTACT INFORMATION
|
|
Fraunhofer Institute for Integrated Circuits IIS
|
Attention: Audio and Multimedia Departments - FDK AAC LL
|
Am Wolfsmantel 33
|
91058 Erlangen, Germany
|
|
www.iis.fraunhofer.de/amm
|
amm-info@iis.fraunhofer.de
|
----------------------------------------------------------------------------- */
|
|
/******************* MPEG transport format decoder library *********************
|
|
Author(s): Daniel Homm
|
|
Description:
|
|
*******************************************************************************/
|
|
#include "tpdec_latm.h"
|
|
#include "FDK_bitstream.h"
|
|
#define TPDEC_TRACKINDEX(p, l) (1 * (p) + (l))
|
|
static UINT CLatmDemux_GetValue(HANDLE_FDK_BITSTREAM bs) {
|
UCHAR bytesForValue = 0, tmp = 0;
|
int value = 0;
|
|
bytesForValue = (UCHAR)FDKreadBits(bs, 2);
|
|
for (UINT i = 0; i <= bytesForValue; i++) {
|
value <<= 8;
|
tmp = (UCHAR)FDKreadBits(bs, 8);
|
value += tmp;
|
}
|
|
return value;
|
}
|
|
static TRANSPORTDEC_ERROR CLatmDemux_ReadAudioMuxElement(
|
HANDLE_FDK_BITSTREAM bs, CLatmDemux *pLatmDemux, int m_muxConfigPresent,
|
CSTpCallBacks *pTpDecCallbacks, CSAudioSpecificConfig *pAsc,
|
int *pfConfigFound) {
|
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
|
|
if (m_muxConfigPresent) {
|
pLatmDemux->m_useSameStreamMux = FDKreadBits(bs, 1);
|
|
if (!pLatmDemux->m_useSameStreamMux) {
|
int i;
|
UCHAR configChanged = 0;
|
UCHAR configMode = 0;
|
|
FDK_BITSTREAM bsAnchor;
|
|
FDK_BITSTREAM bsAnchorDummyParse;
|
|
if (!pLatmDemux->applyAsc) {
|
bsAnchorDummyParse = *bs;
|
pLatmDemux->newCfgHasAudioPreRoll = 0;
|
/* do dummy-parsing of ASC to determine if there is an audioPreRoll */
|
configMode |= AC_CM_DET_CFG_CHANGE;
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = CLatmDemux_ReadStreamMuxConfig(
|
bs, pLatmDemux, pTpDecCallbacks, pAsc, pfConfigFound,
|
configMode, configChanged))) {
|
goto bail;
|
}
|
|
/* Allow flushing only when audioPreroll functionality is enabled in
|
* current and new config otherwise the new config can be applied
|
* immediately. */
|
if (pAsc->m_sc.m_usacConfig.element[0]
|
.extElement.usacExtElementHasAudioPreRoll &&
|
pLatmDemux->newCfgHasAudioPreRoll) {
|
pLatmDemux->newCfgHasAudioPreRoll = 0;
|
/* with audioPreRoll we must flush before applying new cfg */
|
pLatmDemux->applyAsc = 0;
|
} else {
|
*bs = bsAnchorDummyParse;
|
pLatmDemux->applyAsc = 1; /* apply new config immediate */
|
}
|
}
|
|
if (pLatmDemux->applyAsc) {
|
for (i = 0; i < 2; i++) {
|
configMode = 0;
|
|
if (i == 0) {
|
configMode |= AC_CM_DET_CFG_CHANGE;
|
bsAnchor = *bs;
|
} else {
|
configMode |= AC_CM_ALLOC_MEM;
|
*bs = bsAnchor;
|
}
|
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = CLatmDemux_ReadStreamMuxConfig(
|
bs, pLatmDemux, pTpDecCallbacks, pAsc, pfConfigFound,
|
configMode, configChanged))) {
|
goto bail;
|
}
|
|
if (ErrorStatus == TRANSPORTDEC_OK) {
|
if ((i == 0) && (pAsc->AacConfigChanged || pAsc->SbrConfigChanged ||
|
pAsc->SacConfigChanged)) {
|
int errC;
|
|
configChanged = 1;
|
errC = pTpDecCallbacks->cbFreeMem(pTpDecCallbacks->cbFreeMemData,
|
pAsc);
|
if (errC != 0) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/* If there was no configuration read, its not possible to parse
|
* PayloadLengthInfo below. */
|
if (!*pfConfigFound) {
|
ErrorStatus = TRANSPORTDEC_SYNC_ERROR;
|
goto bail;
|
}
|
|
if (pLatmDemux->m_AudioMuxVersionA == 0) {
|
/* Do only once per call, because parsing and decoding is done in-line. */
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = CLatmDemux_ReadPayloadLengthInfo(bs, pLatmDemux))) {
|
*pfConfigFound = 0;
|
goto bail;
|
}
|
} else {
|
/* audioMuxVersionA > 0 is reserved for future extensions */
|
ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
|
*pfConfigFound = 0;
|
goto bail;
|
}
|
|
bail:
|
if (ErrorStatus != TRANSPORTDEC_OK) {
|
pLatmDemux->applyAsc = 1;
|
}
|
|
return (ErrorStatus);
|
}
|
|
TRANSPORTDEC_ERROR CLatmDemux_Read(HANDLE_FDK_BITSTREAM bs,
|
CLatmDemux *pLatmDemux, TRANSPORT_TYPE tt,
|
CSTpCallBacks *pTpDecCallbacks,
|
CSAudioSpecificConfig *pAsc,
|
int *pfConfigFound,
|
const INT ignoreBufferFullness) {
|
UINT cntBits;
|
UINT cmpBufferFullness;
|
UINT audioMuxLengthBytesLast = 0;
|
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
|
|
cntBits = FDKgetValidBits(bs);
|
|
if ((INT)cntBits < MIN_LATM_HEADERLENGTH) {
|
return TRANSPORTDEC_NOT_ENOUGH_BITS;
|
}
|
|
if (TRANSPORTDEC_OK != (ErrorStatus = CLatmDemux_ReadAudioMuxElement(
|
bs, pLatmDemux, (tt != TT_MP4_LATM_MCP0),
|
pTpDecCallbacks, pAsc, pfConfigFound)))
|
return (ErrorStatus);
|
|
if (!ignoreBufferFullness) {
|
cmpBufferFullness =
|
24 + audioMuxLengthBytesLast * 8 +
|
pLatmDemux->m_linfo[0][0].m_bufferFullness *
|
pAsc[TPDEC_TRACKINDEX(0, 0)].m_channelConfiguration * 32;
|
|
/* evaluate buffer fullness */
|
|
if (pLatmDemux->m_linfo[0][0].m_bufferFullness != 0xFF) {
|
if (!pLatmDemux->BufferFullnessAchieved) {
|
if (cntBits < cmpBufferFullness) {
|
/* condition for start of decoding is not fulfilled */
|
|
/* the current frame will not be decoded */
|
return TRANSPORTDEC_NOT_ENOUGH_BITS;
|
} else {
|
pLatmDemux->BufferFullnessAchieved = 1;
|
}
|
}
|
}
|
}
|
|
return (ErrorStatus);
|
}
|
|
TRANSPORTDEC_ERROR CLatmDemux_ReadStreamMuxConfig(
|
HANDLE_FDK_BITSTREAM bs, CLatmDemux *pLatmDemux,
|
CSTpCallBacks *pTpDecCallbacks, CSAudioSpecificConfig *pAsc,
|
int *pfConfigFound, UCHAR configMode, UCHAR configChanged) {
|
CSAudioSpecificConfig ascDummy; /* the actual config is needed for flushing,
|
after that new config can be parsed */
|
CSAudioSpecificConfig *pAscDummy;
|
pAscDummy = &ascDummy;
|
pLatmDemux->usacExplicitCfgChanged = 0;
|
LATM_LAYER_INFO *p_linfo = NULL;
|
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
|
UCHAR updateConfig[1 * 1] = {0};
|
|
pLatmDemux->m_AudioMuxVersion = FDKreadBits(bs, 1);
|
|
if (pLatmDemux->m_AudioMuxVersion == 0) {
|
pLatmDemux->m_AudioMuxVersionA = 0;
|
} else {
|
pLatmDemux->m_AudioMuxVersionA = FDKreadBits(bs, 1);
|
}
|
|
if (pLatmDemux->m_AudioMuxVersionA == 0) {
|
if (pLatmDemux->m_AudioMuxVersion == 1) {
|
pLatmDemux->m_taraBufferFullness = CLatmDemux_GetValue(bs);
|
}
|
pLatmDemux->m_allStreamsSameTimeFraming = FDKreadBits(bs, 1);
|
pLatmDemux->m_noSubFrames = FDKreadBits(bs, 6) + 1;
|
pLatmDemux->m_numProgram = FDKreadBits(bs, 4) + 1;
|
|
if (pLatmDemux->m_numProgram > LATM_MAX_PROG) {
|
ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
|
goto bail;
|
}
|
|
int idCnt = 0;
|
for (UINT prog = 0; prog < pLatmDemux->m_numProgram; prog++) {
|
pLatmDemux->m_numLayer[prog] = FDKreadBits(bs, 3) + 1;
|
if (pLatmDemux->m_numLayer[prog] > LATM_MAX_LAYER) {
|
ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
|
goto bail;
|
}
|
|
for (UINT lay = 0; lay < pLatmDemux->m_numLayer[prog]; lay++) {
|
int useSameConfig;
|
p_linfo = &pLatmDemux->m_linfo[prog][lay];
|
|
p_linfo->m_streamID = idCnt++;
|
p_linfo->m_frameLengthInBits = 0;
|
|
if ((prog == 0) && (lay == 0)) {
|
useSameConfig = 0;
|
} else {
|
useSameConfig = FDKreadBits(bs, 1);
|
}
|
|
if (useSameConfig) {
|
if (lay > 0) {
|
FDKmemcpy(&pAsc[TPDEC_TRACKINDEX(prog, lay)],
|
&pAsc[TPDEC_TRACKINDEX(prog, lay - 1)],
|
sizeof(CSAudioSpecificConfig));
|
} else {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
} else {
|
UINT usacConfigLengthPrev = 0;
|
UCHAR usacConfigPrev[TP_USAC_MAX_CONFIG_LEN];
|
|
if (!(pLatmDemux->applyAsc) &&
|
(pAsc[TPDEC_TRACKINDEX(prog, lay)].m_aot == AOT_USAC)) {
|
usacConfigLengthPrev =
|
(UINT)(pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfigBits +
|
7) >>
|
3; /* store previous USAC config length */
|
if (usacConfigLengthPrev > TP_USAC_MAX_CONFIG_LEN) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
FDKmemclear(usacConfigPrev, TP_USAC_MAX_CONFIG_LEN);
|
FDKmemcpy(
|
usacConfigPrev,
|
&pAsc[TPDEC_TRACKINDEX(prog, lay)].m_sc.m_usacConfig.UsacConfig,
|
usacConfigLengthPrev); /* store previous USAC config */
|
}
|
if (pLatmDemux->m_AudioMuxVersion == 1) {
|
FDK_BITSTREAM tmpBs;
|
UINT ascLen = 0;
|
ascLen = CLatmDemux_GetValue(bs);
|
/* The ascLen could be wrong, so check if validBits<=bufBits*/
|
if (ascLen > FDKgetValidBits(bs)) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
FDKsyncCache(bs);
|
tmpBs = *bs;
|
tmpBs.hBitBuf.ValidBits = ascLen;
|
|
/* Read ASC */
|
if (pLatmDemux->applyAsc) {
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = AudioSpecificConfig_Parse(
|
&pAsc[TPDEC_TRACKINDEX(prog, lay)], &tmpBs, 1,
|
pTpDecCallbacks, configMode, configChanged,
|
AOT_NULL_OBJECT)))
|
goto bail;
|
} else {
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = AudioSpecificConfig_Parse(
|
pAscDummy, &tmpBs, 1, pTpDecCallbacks, configMode,
|
configChanged, AOT_NULL_OBJECT)))
|
goto bail;
|
}
|
|
/* The field p_linfo->m_ascLen could be wrong, so check if */
|
if (0 > (INT)FDKgetValidBits(&tmpBs)) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
FDKpushFor(bs, ascLen); /* position bitstream after ASC */
|
} else {
|
/* Read ASC */
|
if (pLatmDemux->applyAsc) {
|
if (TRANSPORTDEC_OK != (ErrorStatus = AudioSpecificConfig_Parse(
|
&pAsc[TPDEC_TRACKINDEX(prog, lay)],
|
bs, 0, pTpDecCallbacks, configMode,
|
configChanged, AOT_NULL_OBJECT)))
|
goto bail;
|
} else {
|
if (TRANSPORTDEC_OK !=
|
(ErrorStatus = AudioSpecificConfig_Parse(
|
pAscDummy, bs, 0, pTpDecCallbacks, configMode,
|
configChanged, AOT_NULL_OBJECT)))
|
goto bail;
|
}
|
}
|
if (!pLatmDemux->applyAsc) {
|
updateConfig[TPDEC_TRACKINDEX(prog, lay)] = 0;
|
} else {
|
updateConfig[TPDEC_TRACKINDEX(prog, lay)] = 1;
|
}
|
|
if (!pLatmDemux->applyAsc) {
|
if (pAscDummy[TPDEC_TRACKINDEX(prog, lay)].m_aot ==
|
AOT_USAC) { /* flush in case SMC has changed */
|
const UINT usacConfigLength =
|
(UINT)(pAscDummy->m_sc.m_usacConfig.UsacConfigBits + 7) >> 3;
|
if (usacConfigLength > TP_USAC_MAX_CONFIG_LEN) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
if (usacConfigLength != usacConfigLengthPrev) {
|
FDKmemclear(&pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfig,
|
TP_USAC_MAX_CONFIG_LEN);
|
FDKmemcpy(&pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfig,
|
&pAscDummy->m_sc.m_usacConfig.UsacConfig,
|
usacConfigLength); /* store new USAC config */
|
pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfigBits =
|
pAscDummy->m_sc.m_usacConfig.UsacConfigBits;
|
pLatmDemux->usacExplicitCfgChanged = 1;
|
} else {
|
if (FDKmemcmp(usacConfigPrev,
|
pAscDummy->m_sc.m_usacConfig.UsacConfig,
|
usacConfigLengthPrev)) {
|
FDKmemclear(&pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfig,
|
TP_USAC_MAX_CONFIG_LEN);
|
FDKmemcpy(&pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfig,
|
&pAscDummy->m_sc.m_usacConfig.UsacConfig,
|
usacConfigLength); /* store new USAC config */
|
pAsc[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.UsacConfigBits =
|
pAscDummy->m_sc.m_usacConfig.UsacConfigBits;
|
pLatmDemux->usacExplicitCfgChanged = 1;
|
}
|
}
|
|
if (pAscDummy[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.m_usacNumElements) {
|
if (pAscDummy[TPDEC_TRACKINDEX(prog, lay)]
|
.m_sc.m_usacConfig.element[0]
|
.extElement.usacExtElementHasAudioPreRoll) {
|
pLatmDemux->newCfgHasAudioPreRoll =
|
1; /* if dummy parsed cfg has audioPreRoll we first flush
|
before applying new cfg */
|
}
|
}
|
}
|
}
|
}
|
|
p_linfo->m_frameLengthType = FDKreadBits(bs, 3);
|
switch (p_linfo->m_frameLengthType) {
|
case 0:
|
p_linfo->m_bufferFullness = FDKreadBits(bs, 8);
|
|
if (!pLatmDemux->m_allStreamsSameTimeFraming) {
|
if ((lay > 0) &&
|
(pAsc[TPDEC_TRACKINDEX(prog, lay)].m_aot == AOT_AAC_SCAL ||
|
pAsc[TPDEC_TRACKINDEX(prog, lay)].m_aot ==
|
AOT_ER_AAC_SCAL) &&
|
(pAsc[TPDEC_TRACKINDEX(prog, lay - 1)].m_aot == AOT_CELP ||
|
pAsc[TPDEC_TRACKINDEX(prog, lay - 1)].m_aot ==
|
AOT_ER_CELP)) { /* The layer maybe
|
ignored later so
|
read it anyway: */
|
/* coreFrameOffset = */ FDKreadBits(bs, 6);
|
}
|
}
|
break;
|
case 1:
|
p_linfo->m_frameLengthInBits = FDKreadBits(bs, 9);
|
break;
|
case 3:
|
case 4:
|
case 5:
|
/* CELP */
|
case 6:
|
case 7:
|
/* HVXC */
|
default:
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
} /* switch framelengthtype*/
|
|
} /* layer loop */
|
} /* prog loop */
|
|
pLatmDemux->m_otherDataPresent = FDKreadBits(bs, 1);
|
pLatmDemux->m_otherDataLength = 0;
|
|
if (pLatmDemux->m_otherDataPresent) {
|
if (pLatmDemux->m_AudioMuxVersion == 1) {
|
pLatmDemux->m_otherDataLength = CLatmDemux_GetValue(bs);
|
} else {
|
int otherDataLenEsc = 0;
|
do {
|
pLatmDemux->m_otherDataLength <<= 8; // *= 256
|
otherDataLenEsc = FDKreadBits(bs, 1);
|
pLatmDemux->m_otherDataLength += FDKreadBits(bs, 8);
|
} while (otherDataLenEsc);
|
}
|
if (pLatmDemux->m_audioMuxLengthBytes <
|
(pLatmDemux->m_otherDataLength >> 3)) {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
|
goto bail;
|
}
|
}
|
|
pLatmDemux->m_crcCheckPresent = FDKreadBits(bs, 1);
|
|
if (pLatmDemux->m_crcCheckPresent) {
|
FDKreadBits(bs, 8);
|
}
|
|
} else {
|
/* audioMuxVersionA > 0 is reserved for future extensions */
|
ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT;
|
}
|
|
/* Configure source decoder: */
|
if (ErrorStatus == TRANSPORTDEC_OK) {
|
UINT prog;
|
for (prog = 0; prog < pLatmDemux->m_numProgram; prog++) {
|
UINT lay;
|
for (lay = 0; lay < pLatmDemux->m_numLayer[prog]; lay++) {
|
if (updateConfig[TPDEC_TRACKINDEX(prog, lay)] != 0) {
|
int cbError;
|
cbError = pTpDecCallbacks->cbUpdateConfig(
|
pTpDecCallbacks->cbUpdateConfigData,
|
&pAsc[TPDEC_TRACKINDEX(prog, lay)],
|
pAsc[TPDEC_TRACKINDEX(prog, lay)].configMode,
|
&pAsc[TPDEC_TRACKINDEX(prog, lay)].AacConfigChanged);
|
if (cbError == TRANSPORTDEC_NEED_TO_RESTART) {
|
*pfConfigFound = 0;
|
ErrorStatus = TRANSPORTDEC_NEED_TO_RESTART;
|
goto bail;
|
}
|
if (cbError != 0) {
|
*pfConfigFound = 0;
|
if (lay == 0) {
|
ErrorStatus = TRANSPORTDEC_SYNC_ERROR;
|
goto bail;
|
}
|
} else {
|
*pfConfigFound = 1;
|
}
|
} else {
|
*pfConfigFound = 1;
|
}
|
}
|
}
|
}
|
|
bail:
|
if (ErrorStatus != TRANSPORTDEC_OK) {
|
UCHAR applyAsc = pLatmDemux->applyAsc;
|
FDKmemclear(pLatmDemux, sizeof(CLatmDemux)); /* reset structure */
|
pLatmDemux->applyAsc = applyAsc;
|
} else {
|
/* no error and config parsing is finished */
|
if (configMode == AC_CM_ALLOC_MEM) pLatmDemux->applyAsc = 0;
|
}
|
|
return (ErrorStatus);
|
}
|
|
TRANSPORTDEC_ERROR CLatmDemux_ReadPayloadLengthInfo(HANDLE_FDK_BITSTREAM bs,
|
CLatmDemux *pLatmDemux) {
|
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
|
int totalPayloadBits = 0;
|
|
if (pLatmDemux->m_allStreamsSameTimeFraming == 1) {
|
FDK_ASSERT(pLatmDemux->m_numProgram <= LATM_MAX_PROG);
|
for (UINT prog = 0; prog < pLatmDemux->m_numProgram; prog++) {
|
FDK_ASSERT(pLatmDemux->m_numLayer[prog] <= LATM_MAX_LAYER);
|
for (UINT lay = 0; lay < pLatmDemux->m_numLayer[prog]; lay++) {
|
LATM_LAYER_INFO *p_linfo = &pLatmDemux->m_linfo[prog][lay];
|
|
switch (p_linfo->m_frameLengthType) {
|
case 0:
|
p_linfo->m_frameLengthInBits = CLatmDemux_ReadAuChunkLengthInfo(bs);
|
totalPayloadBits += p_linfo->m_frameLengthInBits;
|
break;
|
case 3:
|
case 5:
|
case 7:
|
default:
|
return TRANSPORTDEC_PARSE_ERROR; // AAC_DEC_LATM_INVALIDFRAMELENGTHTYPE;
|
}
|
}
|
}
|
} else {
|
ErrorStatus = TRANSPORTDEC_PARSE_ERROR; // AAC_DEC_LATM_TIMEFRAMING;
|
}
|
if (pLatmDemux->m_audioMuxLengthBytes > (UINT)0 &&
|
totalPayloadBits > (int)pLatmDemux->m_audioMuxLengthBytes * 8) {
|
return TRANSPORTDEC_PARSE_ERROR;
|
}
|
|
return (ErrorStatus);
|
}
|
|
int CLatmDemux_ReadAuChunkLengthInfo(HANDLE_FDK_BITSTREAM bs) {
|
UCHAR endFlag;
|
int len = 0;
|
|
do {
|
UCHAR tmp = (UCHAR)FDKreadBits(bs, 8);
|
endFlag = (tmp < 255);
|
|
len += tmp;
|
|
} while (endFlag == 0);
|
|
len <<= 3; /* convert from bytes to bits */
|
|
return len;
|
}
|
|
UINT CLatmDemux_GetFrameLengthInBits(CLatmDemux *pLatmDemux, const UINT prog,
|
const UINT layer) {
|
UINT nFrameLenBits = 0;
|
if (prog < pLatmDemux->m_numProgram) {
|
if (layer < pLatmDemux->m_numLayer[prog]) {
|
nFrameLenBits = pLatmDemux->m_linfo[prog][layer].m_frameLengthInBits;
|
}
|
}
|
return nFrameLenBits;
|
}
|
|
UINT CLatmDemux_GetOtherDataPresentFlag(CLatmDemux *pLatmDemux) {
|
return pLatmDemux->m_otherDataPresent ? 1 : 0;
|
}
|
|
UINT CLatmDemux_GetOtherDataLength(CLatmDemux *pLatmDemux) {
|
return pLatmDemux->m_otherDataLength;
|
}
|
|
UINT CLatmDemux_GetNrOfSubFrames(CLatmDemux *pLatmDemux) {
|
return pLatmDemux->m_noSubFrames;
|
}
|
|
UINT CLatmDemux_GetNrOfLayers(CLatmDemux *pLatmDemux, const UINT prog) {
|
UINT numLayer = 0;
|
if (prog < pLatmDemux->m_numProgram) {
|
numLayer = pLatmDemux->m_numLayer[prog];
|
}
|
return numLayer;
|
}
|
