/*!
\brief crc
*/
static int
getCrc (HANDLE_FDK_BITSTREAM hBs, ULONG NrBits)
{
int i;
CRC_BUFFER CrcBuf;
CrcBuf.crcState = SBR_CRC_START;
CrcBuf.crcPoly = SBR_CRC_POLY;
CrcBuf.crcMask = SBR_CRC_MASK;
int CrcStep = NrBits>>MAXCRCSTEP_LD;
int CrcNrBitsRest = (NrBits - CrcStep * MAXCRCSTEP);
ULONG bValue;
for (i = 0; i < CrcStep; i++) {
bValue = FDKreadBits (hBs, MAXCRCSTEP);
calcCRC (&CrcBuf, bValue, MAXCRCSTEP);
}
bValue = FDKreadBits (hBs, CrcNrBitsRest);
calcCRC (&CrcBuf, bValue, CrcNrBitsRest);
return (CrcBuf.crcState & SBR_CRC_RANGE);
}
/*---------------------------------------------------------------------------------------------
description: This function returns a bit from the bitstream according to
read direction. It is called very often, therefore it makes sense to inline it
(runtime).
-----------------------------------------------------------------------------------------------
input: - handle to FDK bitstream
- reference value marking start of bitfield
- pLeftStartOfSegment
- pRightStartOfSegment
- readDirection
-----------------------------------------------------------------------------------------------
return: - bit from bitstream
--------------------------------------------------------------------------------------------
*/
UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
INT *pLeftStartOfSegment,
INT *pRightStartOfSegment, UCHAR readDirection) {
UINT bit;
INT readBitOffset;
if (readDirection == FROM_LEFT_TO_RIGHT) {
readBitOffset = (INT)FDKgetValidBits(bs) - bsAnchor + *pLeftStartOfSegment;
if (readBitOffset) {
FDKpushBiDirectional(bs, readBitOffset);
}
bit = FDKreadBits(bs, 1);
*pLeftStartOfSegment += 1;
} else {
readBitOffset = (INT)FDKgetValidBits(bs) - bsAnchor + *pRightStartOfSegment;
if (readBitOffset) {
FDKpushBiDirectional(bs, readBitOffset);
}
/* to be replaced with a brother function of FDKreadBits() */
bit = FDKreadBits(bs, 1);
FDKpushBack(bs, 2);
*pRightStartOfSegment -= 1;
}
return (bit);
}
UCHAR rvlcReadBitFromBitstream (HANDLE_FDK_BITSTREAM bs,
USHORT *pPosition,
UCHAR readDirection)
{
UINT bit;
INT readBitOffset = *pPosition-FDKgetBitCnt(bs);
if( readBitOffset ) {
FDKpushBiDirectional(bs, readBitOffset);
}
if (readDirection == FWD) {
bit = FDKreadBits(bs, 1);
*pPosition += 1;
} else {
/* to be replaced with a brother function of FDKreadBits() */
bit = FDKreadBits(bs, 1);
FDKpushBack(bs, 2);
*pPosition -= 1;
}
return (bit);
}
static
TRANSPORTDEC_ERROR AudioSpecificConfig_ExtensionParse(CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs, CSTpCallBacks *cb)
{
TP_ASC_EXTENSION_ID lastAscExt, ascExtId = ASCEXT_UNKOWN;
INT bitsAvailable = (INT)FDKgetValidBits(bs);
while (bitsAvailable >= 11)
{
lastAscExt = ascExtId;
ascExtId = (TP_ASC_EXTENSION_ID)FDKreadBits(bs, 11);
bitsAvailable -= 11;
switch (ascExtId) {
case ASCEXT_SBR: /* 0x2b7 */
if ( (self->m_extensionAudioObjectType != AOT_SBR) && (bitsAvailable >= 5) ) {
self->m_extensionAudioObjectType = getAOT(bs);
if ( (self->m_extensionAudioObjectType == AOT_SBR)
|| (self->m_extensionAudioObjectType == AOT_ER_BSAC) )
{ /* Get SBR extension configuration */
self->m_sbrPresentFlag = FDKreadBits(bs, 1);
bitsAvailable -= 1;
if ( self->m_sbrPresentFlag == 1 ) {
self->m_extensionSamplingFrequency = getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
if ((INT)self->m_extensionSamplingFrequency <= 0) {
return TRANSPORTDEC_PARSE_ERROR;
}
}
if ( self->m_extensionAudioObjectType == AOT_ER_BSAC ) {
self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
bitsAvailable -= 4;
}
}
/* Update counter because of variable length fields (AOT and sampling rate) */
bitsAvailable = (INT)FDKgetValidBits(bs);
}
break;
case ASCEXT_PS: /* 0x548 */
if ( (lastAscExt == ASCEXT_SBR)
&& (self->m_extensionAudioObjectType == AOT_SBR)
&& (bitsAvailable > 0) )
{ /* Get PS extension configuration */
self->m_psPresentFlag = FDKreadBits(bs, 1);
bitsAvailable -= 1;
}
break;
default:
/* Just ignore anything. */
return TRANSPORTDEC_OK;
}
}
return TRANSPORTDEC_OK;
}
/*
* Read the extension for height info.
* return 0 if successfull or -1 if the CRC failed.
*/
static
int CProgramConfig_ReadHeightExt(
CProgramConfig *pPce,
HANDLE_FDK_BITSTREAM bs,
int * const bytesAvailable,
const UINT alignmentAnchor
)
{
int err = 0;
FDK_CRCINFO crcInfo; /* CRC state info */
INT crcReg;
FDKcrcInit(&crcInfo, 0x07, 0xFF, 8);
crcReg = FDKcrcStartReg(&crcInfo, bs, 0);
UINT startAnchor = FDKgetValidBits(bs);
FDK_ASSERT(pPce != NULL);
FDK_ASSERT(bs != NULL);
FDK_ASSERT(bytesAvailable != NULL);
if ( (startAnchor >= 24) && (*bytesAvailable >= 3)
&& (FDKreadBits(bs,8) == PCE_HEIGHT_EXT_SYNC) )
{
int i;
for (i=0; i < pPce->NumFrontChannelElements; i++)
{
pPce->FrontElementHeightInfo[i] = (UCHAR) FDKreadBits(bs,2);
}
for (i=0; i < pPce->NumSideChannelElements; i++)
{
pPce->SideElementHeightInfo[i] = (UCHAR) FDKreadBits(bs,2);
}
for (i=0; i < pPce->NumBackChannelElements; i++)
{
pPce->BackElementHeightInfo[i] = (UCHAR) FDKreadBits(bs,2);
}
FDKbyteAlign(bs, alignmentAnchor);
FDKcrcEndReg(&crcInfo, bs, crcReg);
if ((USHORT)FDKreadBits(bs,8) != FDKcrcGetCRC(&crcInfo)) {
/* CRC failed */
err = -1;
}
}
else {
/* No valid extension data found -> restore the initial bitbuffer state */
FDKpushBack(bs, startAnchor - FDKgetValidBits(bs));
}
/* Always report the bytes read. */
*bytesAvailable -= (startAnchor - FDKgetValidBits(bs)) >> 3;
return (err);
}
static AUDIO_OBJECT_TYPE getAOT(HANDLE_FDK_BITSTREAM bs)
{
int tmp = 0;
tmp = FDKreadBits(bs,5);
if (tmp == AOT_ESCAPE) {
int tmp2 = FDKreadBits(bs,6);
tmp = 32 + tmp2;
}
return (AUDIO_OBJECT_TYPE)tmp;
}
/*!
\brief Read PNS information
The function reads the PNS information from the bitstream
*/
void CPns_Read (CPnsData *pPnsData,
HANDLE_FDK_BITSTREAM bs,
const CodeBookDescription *hcb,
SHORT *pScaleFactor,
UCHAR global_gain,
int band,
int group /* = 0 */)
{
int delta ;
UINT pns_band = group*16+band;
if (pPnsData->PnsActive) {
/* Next PNS band case */
delta = CBlock_DecodeHuffmanWord (bs, hcb) - 60;
} else {
/* First PNS band case */
int noiseStartValue = FDKreadBits(bs,9);
delta = noiseStartValue - 256 ;
pPnsData->PnsActive = 1;
pPnsData->CurrentEnergy = global_gain - NOISE_OFFSET;
}
pPnsData->CurrentEnergy += delta ;
pScaleFactor[pns_band] = pPnsData->CurrentEnergy;
pPnsData->pnsUsed[pns_band] = 1;
}
/*!
\brief crc interface
\return 1: CRC OK, 0: CRC check failure
*/
int SbrCrcCheck(HANDLE_FDK_BITSTREAM hBs, /*!< handle to bit-buffer */
LONG NrBits) /*!< max. CRC length */
{
int crcResult = 1;
ULONG NrCrcBits;
ULONG crcCheckResult;
LONG NrBitsAvailable;
ULONG crcCheckSum;
crcCheckSum = FDKreadBits(hBs, 10);
NrBitsAvailable = FDKgetValidBits(hBs);
if (NrBitsAvailable <= 0) {
return 0;
}
NrCrcBits = fixMin((INT)NrBits, (INT)NrBitsAvailable);
crcCheckResult = getCrc(hBs, NrCrcBits);
FDKpushBack(hBs, (NrBitsAvailable - FDKgetValidBits(hBs)));
if (crcCheckResult != crcCheckSum) {
crcResult = 0;
}
return (crcResult);
}
int CLpd_FAC_Read(HANDLE_FDK_BITSTREAM hBs, FIXP_DBL *pFac, SCHAR *pFacScale,
int length, int use_gain, int frame) {
FIXP_DBL fac_gain;
int fac_gain_e = 0;
if (use_gain) {
CLpd_DecodeGain(&fac_gain, &fac_gain_e, FDKreadBits(hBs, 7));
}
if (CLpc_DecodeAVQ(hBs, pFac, 1, 1, length) != 0) {
return -1;
}
{
int scale;
scale = getScalefactor(pFac, length);
scaleValues(pFac, length, scale);
pFacScale[frame] = DFRACT_BITS - 1 - scale;
}
if (use_gain) {
int i;
pFacScale[frame] += fac_gain_e;
for (i = 0; i < length; i++) {
pFac[i] = fMult(pFac[i], fac_gain);
}
}
return 0;
}
static INT getSampleRate(HANDLE_FDK_BITSTREAM bs, UCHAR *index, int nBits)
{
INT sampleRate;
int idx;
idx = FDKreadBits(bs, nBits);
if( idx == (1<<nBits)-1 ) {
if(FDKgetValidBits(bs) < 24) {
return 0;
}
sampleRate = FDKreadBits(bs,24);
} else {
sampleRate = SamplingRateTable[idx];
}
*index = idx;
return sampleRate;
}
/*!
\brief Read escape sequence of codeword
The function reads the escape sequence from the bitstream,
if the absolute value of the quantized coefficient has the
value 16.
\return quantized coefficient
*/
LONG CBlock_GetEscape(HANDLE_FDK_BITSTREAM bs, /*!< pointer to bitstream */
const LONG q) /*!< quantized coefficient */
{
LONG i, off, neg ;
if (q < 0)
{
if (q != -16) return q;
neg = 1;
}
else
{
if (q != +16) return q;
neg = 0;
}
for (i=4; ; i++)
{
if (FDKreadBits(bs,1) == 0)
break;
}
if (i > 16)
{
if (i - 16 > CACHE_BITS) { /* cannot read more than "CACHE_BITS" bits at once in the function FDKreadBits() */
return (MAX_QUANTIZED_VALUE + 1); /* returning invalid value that will be captured later */
}
off = FDKreadBits(bs,i-16) << 16;
off |= FDKreadBits(bs,16);
}
else
{
off = FDKreadBits(bs,i);
}
i = off + (1 << i);
if (neg) i = -i;
return i;
}
INT CPulseData_Read(
HANDLE_FDK_BITSTREAM bs,
CPulseData *const PulseData,
const SHORT *sfb_startlines,
const void *pIcsInfo,
const SHORT frame_length
)
{
int i, k=0;
const UINT MaxSfBands = GetScaleFactorBandsTransmitted((CIcsInfo*)pIcsInfo);
/* reset pulse data flag */
PulseData->PulseDataPresent = 0;
if ((PulseData->PulseDataPresent = (UCHAR) FDKreadBit(bs)) != 0) {
if (!IsLongBlock((CIcsInfo*)pIcsInfo)) {
return AAC_DEC_DECODE_FRAME_ERROR;
}
PulseData->NumberPulse = (UCHAR) FDKreadBits(bs,2);
PulseData->PulseStartBand = (UCHAR) FDKreadBits(bs,6);
if (PulseData->PulseStartBand >= MaxSfBands) {
return AAC_DEC_DECODE_FRAME_ERROR;
}
k = sfb_startlines[PulseData->PulseStartBand];
for (i=0; i<=PulseData->NumberPulse; i++) {
PulseData->PulseOffset[i] = (UCHAR) FDKreadBits(bs,5);
PulseData->PulseAmp[i] = (UCHAR) FDKreadBits(bs,4);
k += PulseData->PulseOffset[i];
}
if (k >= frame_length) {
return AAC_DEC_DECODE_FRAME_ERROR;
}
}
return 0;
}
int CJointStereo_Read(
HANDLE_FDK_BITSTREAM bs,
CJointStereoData *pJointStereoData,
const int windowGroups,
const int scaleFactorBandsTransmitted,
const UINT flags
)
{
int group,band;
pJointStereoData->MsMaskPresent = (UCHAR) FDKreadBits(bs,2);
FDKmemclear(pJointStereoData->MsUsed, scaleFactorBandsTransmitted*sizeof(UCHAR));
switch (pJointStereoData->MsMaskPresent)
{
case 0 : /* no M/S */
/* all flags are already cleared */
break ;
case 1 : /* read ms_used */
for (group=0; group<windowGroups; group++)
{
for (band=0; band<scaleFactorBandsTransmitted; band++)
{
pJointStereoData->MsUsed[band] |= (FDKreadBits(bs,1) << group);
}
}
break ;
case 2 : /* full spectrum M/S */
for (band=0; band<scaleFactorBandsTransmitted; band++)
{
pJointStereoData->MsUsed[band] = 255 ; /* set all flags to 1 */
}
break ;
}
return 0;
}
/*!
\brief Decodes one huffman code word
Reads bits from the bitstream until a valid codeword is found.
The table entries are interpreted either as index to the next entry
or - if negative - as the codeword.
\return decoded value
\author
****************************************************************************/
int
DecodeHuffmanCW (Huffman h, /*!< pointer to huffman codebook table */
HANDLE_FDK_BITSTREAM hBs) /*!< Handle to Bitbuffer */
{
SCHAR index = 0;
int value, bit;
while (index >= 0) {
bit = FDKreadBits (hBs, 1);
index = h[index][bit];
}
value = index+64; /* Add offset */
return value;
}
/*!
\brief huffman decoding by codebook table
\return index of huffman codebook table
****************************************************************************/
static SCHAR
decode_huff_cw (Huffman h, /*!< pointer to huffman codebook table */
HANDLE_FDK_BITSTREAM hBitBuf, /*!< Handle to Bitbuffer */
int *length) /*!< length of huffman codeword (or NULL) */
{
UCHAR bit = 0;
SCHAR index = 0;
UCHAR bitCount = 0;
while (index >= 0) {
bit = FDKreadBits (hBitBuf, 1);
bitCount++;
index = h[index][bit];
}
if (length) {
*length = bitCount;
}
return( index+64 ); /* Add offset */
}
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) )
{
HANDLE_FDK_BITSTREAM hBs = &pTp->bitStream[0];
int bitDiff;
/* Calculate possible offset to CRC value. */
bitDiff = pTp->parser.adts.rawDataBlockDist[pTp->parser.adts.bs.num_raw_blocks-pTp->numberOfRawDataBlocks]<<3;
bitDiff -= pTp->globalFramePos - FDKgetValidBits(hBs) + 16;
FDKpushBiDirectional(hBs, bitDiff);
pTp->parser.adts.crcReadValue = FDKreadBits(hBs, 16);
}
return adtsRead_CrcCheck(&pTp->parser.adts);
default:
return TRANSPORTDEC_OK;
}
}
AAC_DECODER_ERROR IcsReadMaxSfb (
HANDLE_FDK_BITSTREAM bs,
CIcsInfo *pIcsInfo,
const SamplingRateInfo *pSamplingRateInfo
)
{
AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
int nbits;
if (IsLongBlock(pIcsInfo)) {
nbits = 6;
pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
} else {
nbits = 4;
pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Short;
}
pIcsInfo->MaxSfBands = (UCHAR) FDKreadBits(bs, nbits);
if (pIcsInfo->MaxSfBands > pIcsInfo->TotalSfBands){
ErrorStatus = AAC_DEC_PARSE_ERROR;
}
return ErrorStatus;
}
TRANSPORTDEC_ERROR adifRead_DecodeHeader(
CAdifHeader *pAdifHeader,
CProgramConfig *pPce,
HANDLE_FDK_BITSTREAM bs
)
{
int i;
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
UINT startAnchor = FDKgetValidBits(bs);
if ((INT)startAnchor < MIN_ADIF_HEADERLENGTH) {
return (TRANSPORTDEC_NOT_ENOUGH_BITS);
}
if (FDKreadBits(bs,8) != 'A') {
return (TRANSPORTDEC_SYNC_ERROR);
}
if (FDKreadBits(bs,8) != 'D') {
return (TRANSPORTDEC_SYNC_ERROR);
}
if (FDKreadBits(bs,8) != 'I') {
return (TRANSPORTDEC_SYNC_ERROR);
}
if (FDKreadBits(bs,8) != 'F') {
return (TRANSPORTDEC_SYNC_ERROR);
}
if ( (pAdifHeader->CopyrightIdPresent = FDKreadBits(bs,1)) != 0 )
FDKpushBiDirectional(bs,72); /* CopyrightId */
pAdifHeader->OriginalCopy = FDKreadBits(bs,1);
pAdifHeader->Home = FDKreadBits(bs,1);
pAdifHeader->BitstreamType = FDKreadBits(bs,1);
/* pAdifHeader->BitRate = FDKreadBits(bs, 23); */
pAdifHeader->BitRate = FDKreadBits(bs,16);
pAdifHeader->BitRate <<= 7;
pAdifHeader->BitRate |= FDKreadBits(bs,7);
pAdifHeader->NumProgramConfigElements = FDKreadBits(bs,4) + 1;
if (pAdifHeader->BitstreamType == 0) {
FDKpushBiDirectional(bs,20); /* adif_buffer_fullness */
}
/* Parse all PCEs but keep only one */
for (i=0; i < pAdifHeader->NumProgramConfigElements; i++)
{
CProgramConfig_Read(pPce, bs, startAnchor);
}
FDKbyteAlign(bs, startAnchor);
return (ErrorStatus);
}
/*!
\brief Reads parametric stereo data from bitstream
\return
****************************************************************************/
unsigned int
ReadPsData (HANDLE_PS_DEC h_ps_d, /*!< handle to struct PS_DEC */
HANDLE_FDK_BITSTREAM hBitBuf, /*!< handle to struct BIT_BUF */
int nBitsLeft /*!< max number of bits available */
)
{
MPEG_PS_BS_DATA *pBsData;
UCHAR gr, env;
SCHAR dtFlag;
INT startbits;
Huffman CurrentTable;
SCHAR bEnableHeader;
if (!h_ps_d)
return 0;
pBsData = &h_ps_d->bsData[h_ps_d->bsReadSlot].mpeg;
if (h_ps_d->bsReadSlot != h_ps_d->bsLastSlot) {
/* Copy last header data */
FDKmemcpy(pBsData, &h_ps_d->bsData[h_ps_d->bsLastSlot].mpeg, sizeof(MPEG_PS_BS_DATA));
}
startbits = (INT) FDKgetValidBits(hBitBuf);
bEnableHeader = (SCHAR) FDKreadBits (hBitBuf, 1);
/* Read header */
if (bEnableHeader) {
pBsData->bPsHeaderValid = 1;
pBsData->bEnableIid = (UCHAR) FDKreadBits (hBitBuf, 1);
if (pBsData->bEnableIid) {
pBsData->modeIid = (UCHAR) FDKreadBits (hBitBuf, 3);
}
pBsData->bEnableIcc = (UCHAR) FDKreadBits (hBitBuf, 1);
if (pBsData->bEnableIcc) {
pBsData->modeIcc = (UCHAR) FDKreadBits (hBitBuf, 3);
}
pBsData->bEnableExt = (UCHAR) FDKreadBits (hBitBuf, 1);
}
pBsData->bFrameClass = (UCHAR) FDKreadBits (hBitBuf, 1);
if (pBsData->bFrameClass == 0) {
/* FIX_BORDERS NoEnv=0,1,2,4 */
pBsData->noEnv = FDK_sbrDecoder_aFixNoEnvDecode[(UCHAR) FDKreadBits (hBitBuf, 2)];
/* all additional handling of env borders is now in DecodePs() */
}
else {
/* VAR_BORDERS NoEnv=1,2,3,4 */
pBsData->noEnv = 1+(UCHAR) FDKreadBits (hBitBuf, 2);
for (env=1; env<pBsData->noEnv+1; env++)
pBsData->aEnvStartStop[env] = ((UCHAR) FDKreadBits (hBitBuf, 5)) + 1;
/* all additional handling of env borders is now in DecodePs() */
}
/* verify that IID & ICC modes (quant grid, freq res) are supported */
if ((pBsData->modeIid > 5) || (pBsData->modeIcc > 5)) {
/* no useful PS data could be read from bitstream */
h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_none;
/* discard all remaining bits */
nBitsLeft -= startbits - FDKgetValidBits(hBitBuf);
while (nBitsLeft) {
int i = nBitsLeft;
if (i>8) {
i = 8;
}
FDKreadBits (hBitBuf, i);
nBitsLeft -= i;
}
return (startbits - FDKgetValidBits(hBitBuf));
}
if (pBsData->modeIid > 2){
pBsData->freqResIid = pBsData->modeIid-3;
pBsData->bFineIidQ = 1;
}
else{
pBsData->freqResIid = pBsData->modeIid;
pBsData->bFineIidQ = 0;
}
if (pBsData->modeIcc > 2){
pBsData->freqResIcc = pBsData->modeIcc-3;
}
else{
pBsData->freqResIcc = pBsData->modeIcc;
}
/* Extract IID data */
if (pBsData->bEnableIid) {
for (env=0; env<pBsData->noEnv; env++) {
dtFlag = (SCHAR)FDKreadBits (hBitBuf, 1);
if (!dtFlag)
{
if (pBsData->bFineIidQ)
CurrentTable = (Huffman)&aBookPsIidFineFreqDecode;
else
CurrentTable = (Huffman)&aBookPsIidFreqDecode;
}
else
{
if (pBsData->bFineIidQ)
CurrentTable = (Huffman)&aBookPsIidFineTimeDecode;
else
CurrentTable = (Huffman)&aBookPsIidTimeDecode;
}
for (gr = 0; gr < FDK_sbrDecoder_aNoIidBins[pBsData->freqResIid]; gr++)
pBsData->aaIidIndex[env][gr] = decode_huff_cw(CurrentTable,hBitBuf,NULL);
pBsData->abIidDtFlag[env] = dtFlag;
}
}
/* Extract ICC data */
if (pBsData->bEnableIcc) {
for (env=0; env<pBsData->noEnv; env++) {
dtFlag = (SCHAR)FDKreadBits (hBitBuf, 1);
if (!dtFlag)
CurrentTable = (Huffman)&aBookPsIccFreqDecode;
else
CurrentTable = (Huffman)&aBookPsIccTimeDecode;
for (gr = 0; gr < FDK_sbrDecoder_aNoIccBins[pBsData->freqResIcc]; gr++)
pBsData->aaIccIndex[env][gr] = decode_huff_cw(CurrentTable,hBitBuf,NULL);
pBsData->abIccDtFlag[env] = dtFlag;
}
}
if (pBsData->bEnableExt) {
/*!
Decoders that support only the baseline version of the PS tool are allowed
to ignore the IPD/OPD data, but according header data has to be parsed.
ISO/IEC 14496-3 Subpart 8 Annex 4
*/
int cnt = FDKreadBits(hBitBuf, PS_EXTENSION_SIZE_BITS);
if (cnt == (1<<PS_EXTENSION_SIZE_BITS)-1) {
cnt += FDKreadBits(hBitBuf, PS_EXTENSION_ESC_COUNT_BITS);
}
while (cnt--)
FDKreadBits(hBitBuf, 8);
}
/* new PS data was read from bitstream */
h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_mpeg;
return (startbits - FDKgetValidBits(hBitBuf));
}
void CProgramConfig_Read(
CProgramConfig *pPce,
HANDLE_FDK_BITSTREAM bs,
UINT alignmentAnchor
)
{
int i, err = 0;
int commentBytes;
pPce->NumEffectiveChannels = 0;
pPce->NumChannels = 0;
pPce->ElementInstanceTag = (UCHAR) FDKreadBits(bs,4);
pPce->Profile = (UCHAR) FDKreadBits(bs,2);
pPce->SamplingFrequencyIndex = (UCHAR) FDKreadBits(bs,4);
pPce->NumFrontChannelElements = (UCHAR) FDKreadBits(bs,4);
pPce->NumSideChannelElements = (UCHAR) FDKreadBits(bs,4);
pPce->NumBackChannelElements = (UCHAR) FDKreadBits(bs,4);
pPce->NumLfeChannelElements = (UCHAR) FDKreadBits(bs,2);
pPce->NumAssocDataElements = (UCHAR) FDKreadBits(bs,3);
pPce->NumValidCcElements = (UCHAR) FDKreadBits(bs,4);
if ((pPce->MonoMixdownPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
{
pPce->MonoMixdownElementNumber = (UCHAR) FDKreadBits(bs,4);
}
if ((pPce->StereoMixdownPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
{
pPce->StereoMixdownElementNumber = (UCHAR) FDKreadBits(bs,4);
}
if ((pPce->MatrixMixdownIndexPresent = (UCHAR) FDKreadBits(bs,1)) != 0)
{
pPce->MatrixMixdownIndex = (UCHAR) FDKreadBits(bs,2);
pPce->PseudoSurroundEnable = (UCHAR) FDKreadBits(bs,1);
}
for (i=0; i < pPce->NumFrontChannelElements; i++)
{
pPce->FrontElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
pPce->FrontElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
pPce->NumChannels += pPce->FrontElementIsCpe[i] ? 2 : 1;
}
for (i=0; i < pPce->NumSideChannelElements; i++)
{
pPce->SideElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
pPce->SideElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
pPce->NumChannels += pPce->SideElementIsCpe[i] ? 2 : 1;
}
for (i=0; i < pPce->NumBackChannelElements; i++)
{
pPce->BackElementIsCpe[i] = (UCHAR) FDKreadBits(bs,1);
pPce->BackElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
pPce->NumChannels += pPce->BackElementIsCpe[i] ? 2 : 1;
}
pPce->NumEffectiveChannels = pPce->NumChannels;
for (i=0; i < pPce->NumLfeChannelElements; i++)
{
pPce->LfeElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
pPce->NumChannels += 1;
}
for (i=0; i < pPce->NumAssocDataElements; i++)
{
pPce->AssocDataElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
}
for (i=0; i < pPce->NumValidCcElements; i++)
{
pPce->CcElementIsIndSw[i] = (UCHAR) FDKreadBits(bs,1);
pPce->ValidCcElementTagSelect[i] = (UCHAR) FDKreadBits(bs,4);
}
FDKbyteAlign(bs, alignmentAnchor);
pPce->CommentFieldBytes = (UCHAR) FDKreadBits(bs,8);
commentBytes = pPce->CommentFieldBytes;
/* Search for height info extension and read it if available */
err = CProgramConfig_ReadHeightExt( pPce, bs, &commentBytes, alignmentAnchor );
for (i=0; i < commentBytes; i++)
{
UCHAR text;
text = (UCHAR)FDKreadBits(bs,8);
if (i < PC_COMMENTLENGTH)
{
pPce->Comment[i] = text;
}
}
pPce->isValid = (err) ? 0 : 1;
}
/*
* Arbitrary order bitstream parser
*/
AAC_DECODER_ERROR CChannelElement_Read(
HANDLE_FDK_BITSTREAM hBs, CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
const AUDIO_OBJECT_TYPE aot, SamplingRateInfo *pSamplingRateInfo,
const UINT flags, const UINT elFlags, const UINT frame_length,
const UCHAR numberOfChannels, const SCHAR epConfig,
HANDLE_TRANSPORTDEC pTpDec) {
AAC_DECODER_ERROR error = AAC_DEC_OK;
const element_list_t *list;
int i, ch, decision_bit;
int crcReg1 = -1, crcReg2 = -1;
int cplxPred;
int ind_sw_cce_flag = 0, num_gain_element_lists = 0;
FDK_ASSERT((numberOfChannels == 1) || (numberOfChannels == 2));
/* Get channel element sequence table */
list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0, elFlags);
if (list == NULL) {
error = AAC_DEC_UNSUPPORTED_FORMAT;
goto bail;
}
CTns_Reset(&pAacDecoderChannelInfo[0]->pDynData->TnsData);
/* Set common window to 0 by default. If signalized in the bit stream it will
* be overwritten later explicitely */
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
if (flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) {
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active = 0;
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr = 0;
}
if (numberOfChannels == 2) {
CTns_Reset(&pAacDecoderChannelInfo[1]->pDynData->TnsData);
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
}
cplxPred = 0;
if (pAacDecoderStaticChannelInfo != NULL) {
if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
pAacDecoderChannelInfo[0]->pComData->jointStereoData.cplx_pred_flag = 0;
cplxPred = 1;
}
}
if (0 || (flags & (AC_ELD | AC_SCALABLE))) {
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 1;
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
}
/* Iterate through sequence table */
i = 0;
ch = 0;
decision_bit = 0;
do {
switch (list->id[i]) {
case element_instance_tag:
pAacDecoderChannelInfo[0]->ElementInstanceTag = FDKreadBits(hBs, 4);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->ElementInstanceTag =
pAacDecoderChannelInfo[0]->ElementInstanceTag;
}
break;
case common_window:
decision_bit =
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow =
FDKreadBits(hBs, 1);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
break;
case ics_info:
/* store last window sequence (utilized in complex stereo prediction)
* before reading new channel-info */
if (cplxPred) {
if (pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData.winSeqPrev =
pAacDecoderChannelInfo[0]->icsInfo.WindowSequence;
pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData.winShapePrev =
pAacDecoderChannelInfo[0]->icsInfo.WindowShape;
}
}
/* Read individual channel info */
error = IcsRead(hBs, &pAacDecoderChannelInfo[ch]->icsInfo,
pSamplingRateInfo, flags);
if (elFlags & AC_EL_LFE &&
GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) !=
BLOCK_LONG) {
error = AAC_DEC_PARSE_ERROR;
break;
}
if (numberOfChannels == 2 &&
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
pAacDecoderChannelInfo[1]->icsInfo =
pAacDecoderChannelInfo[0]->icsInfo;
}
break;
case common_max_sfb:
if (FDKreadBit(hBs) == 0) {
error = IcsReadMaxSfb(hBs, &pAacDecoderChannelInfo[1]->icsInfo,
pSamplingRateInfo);
}
break;
case ltp_data_present:
if (FDKreadBits(hBs, 1) != 0) {
error = AAC_DEC_UNSUPPORTED_PREDICTION;
}
break;
case ms:
INT max_sfb_ste;
INT max_sfb_ste_clear;
max_sfb_ste = GetScaleMaxFactorBandsTransmitted(
&pAacDecoderChannelInfo[0]->icsInfo,
&pAacDecoderChannelInfo[1]->icsInfo);
max_sfb_ste_clear = 64;
pAacDecoderChannelInfo[0]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
pAacDecoderChannelInfo[1]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
if (flags & (AC_USAC | AC_RSV603DA) &&
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow ==
0) {
Clean_Complex_Prediction_coefficients(
&pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData,
GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo), 0, 64);
}
if (CJointStereo_Read(
hBs, &pAacDecoderChannelInfo[0]->pComData->jointStereoData,
GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo),
max_sfb_ste, max_sfb_ste_clear,
/* jointStereoPersistentData and cplxPredictionData are only
available/allocated if cplxPred is active. */
((cplxPred == 0) || (pAacDecoderStaticChannelInfo == NULL))
? NULL
: &pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData,
((cplxPred == 0) || (pAacDecoderChannelInfo[0] == NULL))
? NULL
: pAacDecoderChannelInfo[0]
->pComStaticData->cplxPredictionData,
cplxPred,
GetScaleFactorBandsTotal(&pAacDecoderChannelInfo[0]->icsInfo),
GetWindowSequence(&pAacDecoderChannelInfo[0]->icsInfo),
flags)) {
error = AAC_DEC_PARSE_ERROR;
}
break;
case global_gain:
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.GlobalGain =
(UCHAR)FDKreadBits(hBs, 8);
break;
case section_data:
error = CBlock_ReadSectionData(hBs, pAacDecoderChannelInfo[ch],
pSamplingRateInfo, flags);
break;
case scale_factor_data_usac:
pAacDecoderChannelInfo[ch]->currAliasingSymmetry = 0;
/* Set active sfb codebook indexes to HCB_ESC to make them "active" */
CChannel_CodebookTableInit(
pAacDecoderChannelInfo[ch]); /* equals ReadSectionData(self,
bs) in float soft. block.c
line: ~599 */
/* Note: The missing "break" is intentional here, since we need to call
* CBlock_ReadScaleFactorData(). */
case scale_factor_data:
if (flags & AC_ER_RVLC) {
/* read RVLC data from bitstream (error sens. cat. 1) */
CRvlc_Read(pAacDecoderChannelInfo[ch], hBs);
} else {
error = CBlock_ReadScaleFactorData(pAacDecoderChannelInfo[ch], hBs,
flags);
}
break;
case pulse:
if (CPulseData_Read(
hBs,
&pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.PulseData,
pSamplingRateInfo->ScaleFactorBands_Long, /* pulse data is only
allowed to be
present in long
blocks! */
(void *)&pAacDecoderChannelInfo[ch]->icsInfo,
frame_length) != 0) {
error = AAC_DEC_DECODE_FRAME_ERROR;
}
break;
case tns_data_present:
CTns_ReadDataPresentFlag(
hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData);
if (elFlags & AC_EL_LFE &&
pAacDecoderChannelInfo[ch]->pDynData->TnsData.DataPresent) {
error = AAC_DEC_PARSE_ERROR;
}
break;
case tns_data:
/* tns_data_present is checked inside CTns_Read(). */
error = CTns_Read(hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData,
&pAacDecoderChannelInfo[ch]->icsInfo, flags);
break;
case gain_control_data:
break;
case gain_control_data_present:
if (FDKreadBits(hBs, 1)) {
error = AAC_DEC_UNSUPPORTED_GAIN_CONTROL_DATA;
}
break;
case tw_data:
break;
case common_tw:
break;
case tns_data_present_usac:
if (pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active) {
CTns_ReadDataPresentUsac(
hBs, &pAacDecoderChannelInfo[0]->pDynData->TnsData,
&pAacDecoderChannelInfo[1]->pDynData->TnsData,
&pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr,
&pAacDecoderChannelInfo[0]->icsInfo, flags, elFlags,
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow);
} else {
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr =
(UCHAR)1;
}
break;
case core_mode:
decision_bit = FDKreadBits(hBs, 1);
pAacDecoderChannelInfo[ch]->data.usac.core_mode = decision_bit;
if ((ch == 1) && (pAacDecoderChannelInfo[0]->data.usac.core_mode !=
pAacDecoderChannelInfo[1]->data.usac.core_mode)) {
/* StereoCoreToolInfo(core_mode[ch] ) */
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
}
break;
case tns_active:
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active =
FDKreadBit(hBs);
break;
case noise:
if (elFlags & AC_EL_USAC_NOISE) {
pAacDecoderChannelInfo[ch]
->pDynData->specificTo.usac.fd_noise_level_and_offset =
FDKreadBits(hBs, 3 + 5); /* Noise level */
}
break;
case lpd_channel_stream:
{
error = CLpdChannelStream_Read(/* = lpd_channel_stream() */
hBs, pAacDecoderChannelInfo[ch],
pAacDecoderStaticChannelInfo[ch],
pSamplingRateInfo, flags);
}
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_LPD;
break;
case fac_data: {
int fFacDatPresent = FDKreadBit(hBs);
/* Wee need a valid fac_data[0] even if no FAC data is present (as
* temporal buffer) */
pAacDecoderChannelInfo[ch]->data.usac.fac_data[0] =
pAacDecoderChannelInfo[ch]->data.usac.fac_data0;
if (fFacDatPresent) {
if (elFlags & AC_EL_LFE) {
error = AAC_DEC_PARSE_ERROR;
break;
}
/* FAC data present, this frame is FD, so the last mode had to be
* ACELP. */
if (pAacDecoderStaticChannelInfo[ch]->last_core_mode != LPD ||
pAacDecoderStaticChannelInfo[ch]->last_lpd_mode != 0) {
pAacDecoderChannelInfo[ch]->data.usac.core_mode_last = LPD;
pAacDecoderChannelInfo[ch]->data.usac.lpd_mode_last = 0;
/* We can't change the past! So look to the future and go ahead! */
}
CLpd_FAC_Read(hBs, pAacDecoderChannelInfo[ch]->data.usac.fac_data[0],
pAacDecoderChannelInfo[ch]->data.usac.fac_data_e,
CLpd_FAC_getLength(
IsLongBlock(&pAacDecoderChannelInfo[ch]->icsInfo),
pAacDecoderChannelInfo[ch]->granuleLength),
1, 0);
} else {
if (pAacDecoderStaticChannelInfo[ch]->last_core_mode == LPD &&
pAacDecoderStaticChannelInfo[ch]->last_lpd_mode == 0) {
/* ACELP to FD transitons without FAC are possible. That is why we
zero it out (i.e FAC will not be considered in the subsequent
calculations */
FDKmemclear(pAacDecoderChannelInfo[ch]->data.usac.fac_data0,
LFAC * sizeof(FIXP_DBL));
}
}
} break;
case esc2_rvlc:
if (flags & AC_ER_RVLC) {
CRvlc_Decode(pAacDecoderChannelInfo[ch],
pAacDecoderStaticChannelInfo[ch], hBs);
}
break;
case esc1_hcr:
if (flags & AC_ER_HCR) {
CHcr_Read(hBs, pAacDecoderChannelInfo[ch],
numberOfChannels == 2 ? ID_CPE : ID_SCE);
}
break;
case spectral_data:
error = CBlock_ReadSpectralData(hBs, pAacDecoderChannelInfo[ch],
pSamplingRateInfo, flags);
if (flags & AC_ELD) {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_ELDFB;
} else {
if (flags & AC_HDAAC) {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_INTIMDCT;
} else {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
}
}
break;
case ac_spectral_data:
error = CBlock_ReadAcSpectralData(
hBs, pAacDecoderChannelInfo[ch], pAacDecoderStaticChannelInfo[ch],
pSamplingRateInfo, frame_length, flags);
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
break;
case coupled_elements: {
int num_coupled_elements, c;
ind_sw_cce_flag = FDKreadBit(hBs);
num_coupled_elements = FDKreadBits(hBs, 3);
for (c = 0; c < (num_coupled_elements + 1); c++) {
int cc_target_is_cpe;
num_gain_element_lists++;
cc_target_is_cpe = FDKreadBit(hBs); /* cc_target_is_cpe[c] */
FDKreadBits(hBs, 4); /* cc_target_tag_select[c] */
if (cc_target_is_cpe) {
int cc_l, cc_r;
cc_l = FDKreadBit(hBs); /* cc_l[c] */
cc_r = FDKreadBit(hBs); /* cc_r[c] */
if (cc_l && cc_r) {
num_gain_element_lists++;
}
}
}
FDKreadBit(hBs); /* cc_domain */
FDKreadBit(hBs); /* gain_element_sign */
FDKreadBits(hBs, 2); /* gain_element_scale */
} break;
case gain_element_lists: {
const CodeBookDescription *hcb;
UCHAR *pCodeBook;
int c;
hcb = &AACcodeBookDescriptionTable[BOOKSCL];
pCodeBook = pAacDecoderChannelInfo[ch]->pDynData->aCodeBook;
for (c = 1; c < num_gain_element_lists; c++) {
int cge;
if (ind_sw_cce_flag) {
cge = 1;
} else {
cge = FDKreadBits(hBs, 1); /* common_gain_element_present[c] */
}
if (cge) {
/* Huffman */
CBlock_DecodeHuffmanWord(
hBs, hcb); /* hcod_sf[common_gain_element[c]] 1..19 */
} else {
int g, sfb;
for (g = 0;
g < GetWindowGroups(&pAacDecoderChannelInfo[ch]->icsInfo);
g++) {
for (sfb = 0; sfb < GetScaleFactorBandsTransmitted(
&pAacDecoderChannelInfo[ch]->icsInfo);
sfb++) {
if (pCodeBook[sfb] != ZERO_HCB) {
/* Huffman */
CBlock_DecodeHuffmanWord(
hBs,
hcb); /* hcod_sf[dpcm_gain_element[c][g][sfb]] 1..19 */
}
}
}
}
}
} break;
/* CRC handling */
case adtscrc_start_reg1:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 192);
}
break;
case adtscrc_start_reg2:
if (pTpDec != NULL) {
crcReg2 = transportDec_CrcStartReg(pTpDec, 128);
}
break;
case adtscrc_end_reg1:
case drmcrc_end_reg:
if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg1);
crcReg1 = -1;
}
break;
case adtscrc_end_reg2:
if (crcReg1 != -1) {
error = AAC_DEC_DECODE_FRAME_ERROR;
} else if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg2);
crcReg2 = -1;
}
break;
case drmcrc_start_reg:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 0);
}
break;
/* Non data cases */
case next_channel:
ch = (ch + 1) % numberOfChannels;
break;
case link_sequence:
list = list->next[decision_bit];
i = -1;
break;
default:
error = AAC_DEC_UNSUPPORTED_FORMAT;
break;
}
if (error != AAC_DEC_OK) {
goto bail;
}
i++;
} while (list->id[i] != end_of_sequence);
for (ch = 0; ch < numberOfChannels; ch++) {
if (pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_IMDCT ||
pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_ELDFB) {
/* Shows which bands are empty. */
UCHAR *band_is_noise =
pAacDecoderChannelInfo[ch]->pDynData->band_is_noise;
FDKmemset(band_is_noise, (UCHAR)1, sizeof(UCHAR) * (8 * 16));
error = CBlock_InverseQuantizeSpectralData(
pAacDecoderChannelInfo[ch], pSamplingRateInfo, band_is_noise, 1);
if (error != AAC_DEC_OK) {
return error;
}
if (elFlags & AC_EL_USAC_NOISE) {
CBlock_ApplyNoise(pAacDecoderChannelInfo[ch], pSamplingRateInfo,
&pAacDecoderStaticChannelInfo[ch]->nfRandomSeed,
band_is_noise);
} /* if (elFlags & AC_EL_USAC_NOISE) */
}
}
bail:
if (crcReg1 != -1 || crcReg2 != -1) {
if (error == AAC_DEC_OK) {
error = AAC_DEC_DECODE_FRAME_ERROR;
}
if (crcReg1 != -1) {
transportDec_CrcEndReg(pTpDec, crcReg1);
}
if (crcReg2 != -1) {
transportDec_CrcEndReg(pTpDec, crcReg2);
}
}
return error;
}
TRANSPORTDEC_ERROR AudioSpecificConfig_Parse(
CSAudioSpecificConfig *self,
HANDLE_FDK_BITSTREAM bs,
int fExplicitBackwardCompatible,
CSTpCallBacks *cb
)
{
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
UINT ascStartAnchor = FDKgetValidBits(bs);
int frameLengthFlag = -1;
AudioSpecificConfig_Init(self);
self->m_aot = getAOT(bs);
self->m_samplingFrequency = getSampleRate(bs, &self->m_samplingFrequencyIndex, 4);
if (self->m_samplingFrequency <= 0) {
return TRANSPORTDEC_PARSE_ERROR;
}
self->m_channelConfiguration = FDKreadBits(bs,4);
/* SBR extension ( explicit non-backwards compatible mode ) */
self->m_sbrPresentFlag = 0;
self->m_psPresentFlag = 0;
if ( self->m_aot == AOT_SBR || self->m_aot == AOT_PS ) {
self->m_extensionAudioObjectType = AOT_SBR;
self->m_sbrPresentFlag = 1;
if ( self->m_aot == AOT_PS ) {
self->m_psPresentFlag = 1;
}
self->m_extensionSamplingFrequency = getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
self->m_aot = getAOT(bs);
} else {
self->m_extensionAudioObjectType = AOT_NULL_OBJECT;
}
/* Parse whatever specific configs */
switch (self->m_aot)
{
#ifdef TP_GA_ENABLE
case AOT_AAC_LC:
case AOT_ER_AAC_LC:
case AOT_ER_AAC_LD:
case AOT_ER_AAC_SCAL:
case AOT_ER_BSAC:
if ((ErrorStatus = GaSpecificConfig_Parse(&self->m_sc.m_gaSpecificConfig, self, bs, ascStartAnchor)) != TRANSPORTDEC_OK ) {
return (ErrorStatus);
}
frameLengthFlag = self->m_sc.m_gaSpecificConfig.m_frameLengthFlag;
break;
#endif /* TP_GA_ENABLE */
case AOT_MPEGS:
if (cb->cbSsc != NULL) {
cb->cbSsc(
cb->cbSscData,
bs,
self->m_aot,
self->m_samplingFrequency,
1,
0 /* don't know the length */
);
} else {
return TRANSPORTDEC_UNSUPPORTED_FORMAT;
}
break;
#ifdef TP_ELD_ENABLE
case AOT_ER_AAC_ELD:
if ((ErrorStatus = EldSpecificConfig_Parse(self, bs, cb)) != TRANSPORTDEC_OK ) {
return (ErrorStatus);
}
frameLengthFlag = self->m_sc.m_eldSpecificConfig.m_frameLengthFlag;
self->m_sbrPresentFlag = self->m_sc.m_eldSpecificConfig.m_sbrPresentFlag;
self->m_extensionSamplingFrequency = (self->m_sc.m_eldSpecificConfig.m_sbrSamplingRate+1) * self->m_samplingFrequency;
break;
#endif /* TP_ELD_ENABLE */
default:
return TRANSPORTDEC_UNSUPPORTED_FORMAT;
break;
}
/* Frame length */
switch (self->m_aot)
{
#if defined(TP_GA_ENABLE) || defined(TP_USAC_ENABLE)
case AOT_AAC_LC:
case AOT_ER_AAC_LC:
case AOT_ER_AAC_SCAL:
case AOT_ER_BSAC:
/*case AOT_USAC:*/
if (!frameLengthFlag)
self->m_samplesPerFrame = 1024;
else
self->m_samplesPerFrame = 960;
break;
#endif /* TP_GA_ENABLE */
#if defined(TP_GA_ENABLE)
case AOT_ER_AAC_LD:
if (!frameLengthFlag)
self->m_samplesPerFrame = 512;
else
self->m_samplesPerFrame = 480;
break;
#endif /* defined(TP_GA_ENABLE) */
default:
break;
}
switch (self->m_aot)
{
case AOT_ER_AAC_LC:
case AOT_ER_AAC_LD:
case AOT_ER_AAC_ELD:
case AOT_ER_AAC_SCAL:
case AOT_ER_CELP:
case AOT_ER_HVXC:
case AOT_ER_BSAC:
self->m_epConfig = FDKreadBits(bs,2);
if (self->m_epConfig > 1) {
return TRANSPORTDEC_UNSUPPORTED_FORMAT; // EPCONFIG;
}
break;
default:
break;
}
if (fExplicitBackwardCompatible) {
ErrorStatus = AudioSpecificConfig_ExtensionParse(self, bs, cb);
}
return (ErrorStatus);
}
AAC_DECODER_ERROR IcsRead(HANDLE_FDK_BITSTREAM bs,
CIcsInfo *pIcsInfo,
const SamplingRateInfo* pSamplingRateInfo,
const UINT flags)
{
AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
pIcsInfo->Valid = 0;
if (flags & AC_ELD){
pIcsInfo->WindowSequence = OnlyLongSequence;
pIcsInfo->WindowShape = 0;
}
else {
if ( !(flags & (AC_USAC|AC_RSVD50)) ) {
FDKreadBits(bs,1);
}
pIcsInfo->WindowSequence = (UCHAR) FDKreadBits(bs,2);
pIcsInfo->WindowShape = (UCHAR) FDKreadBits(bs,1);
if (flags & AC_LD) {
if (pIcsInfo->WindowShape) {
pIcsInfo->WindowShape = 2; /* select low overlap instead of KBD */
}
}
}
/* Sanity check */
if ( (flags & (AC_ELD|AC_LD)) && pIcsInfo->WindowSequence != OnlyLongSequence) {
pIcsInfo->WindowSequence = OnlyLongSequence;
ErrorStatus = AAC_DEC_PARSE_ERROR;
goto bail;
}
ErrorStatus = IcsReadMaxSfb(bs, pIcsInfo, pSamplingRateInfo);
if (ErrorStatus != AAC_DEC_OK) {
goto bail;
}
if (IsLongBlock(pIcsInfo))
{
if ( !(flags & (AC_ELD|AC_SCALABLE|AC_BSAC|AC_USAC|AC_RSVD50)) ) /* If not ELD nor Scalable nor BSAC nor USAC syntax then ... */
{
if ((UCHAR)FDKreadBits(bs,1) != 0 ) /* UCHAR PredictorDataPresent */
{
ErrorStatus = AAC_DEC_UNSUPPORTED_PREDICTION;
goto bail;
}
}
pIcsInfo->WindowGroups = 1;
pIcsInfo->WindowGroupLength[0] = 1;
}
else
{
INT i;
UINT mask;
pIcsInfo->ScaleFactorGrouping = (UCHAR) FDKreadBits(bs,7);
pIcsInfo->WindowGroups = 0 ;
for (i=0; i < (8-1); i++)
{
mask = 1 << (6 - i);
pIcsInfo->WindowGroupLength[i] = 1;
if (pIcsInfo->ScaleFactorGrouping & mask)
{
pIcsInfo->WindowGroupLength[pIcsInfo->WindowGroups]++;
}
else
{
pIcsInfo->WindowGroups++;
}
}
/* loop runs to i < 7 only */
pIcsInfo->WindowGroupLength[8-1] = 1;
pIcsInfo->WindowGroups++;
}
bail:
if (ErrorStatus == AAC_DEC_OK)
pIcsInfo->Valid = 1;
return ErrorStatus;
}
static
TRANSPORTDEC_ERROR EldSpecificConfig_Parse(
CSAudioSpecificConfig *asc,
HANDLE_FDK_BITSTREAM hBs,
CSTpCallBacks *cb
)
{
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
CSEldSpecificConfig *esc = &asc->m_sc.m_eldSpecificConfig;
ASC_ELD_EXT_TYPE eldExtType;
int eldExtLen, len, cnt;
FDKmemclear(esc, sizeof(CSEldSpecificConfig));
esc->m_frameLengthFlag = FDKreadBits(hBs, 1 );
if (esc->m_frameLengthFlag) {
asc->m_samplesPerFrame = 480;
} else {
asc->m_samplesPerFrame = 512;
}
asc->m_vcb11Flag = FDKreadBits(hBs, 1 );
asc->m_rvlcFlag = FDKreadBits(hBs, 1 );
asc->m_hcrFlag = FDKreadBits(hBs, 1 );
esc->m_sbrPresentFlag = FDKreadBits(hBs, 1 );
if (esc->m_sbrPresentFlag == 1) {
esc->m_sbrSamplingRate = FDKreadBits(hBs, 1 ); /* 0: single rate, 1: dual rate */
esc->m_sbrCrcFlag = FDKreadBits(hBs, 1 );
asc->m_extensionSamplingFrequency = asc->m_samplingFrequency << esc->m_sbrSamplingRate;
if (cb->cbSbr != NULL){
if ( 0 != ld_sbr_header(asc, hBs, cb) ) {
return TRANSPORTDEC_PARSE_ERROR;
}
} else {
return TRANSPORTDEC_UNSUPPORTED_FORMAT;
}
}
esc->m_useLdQmfTimeAlign = 0;
/* new ELD syntax */
/* parse ExtTypeConfigData */
while ((eldExtType = (ASC_ELD_EXT_TYPE)FDKreadBits(hBs, 4 )) != ELDEXT_TERM) {
eldExtLen = len = FDKreadBits(hBs, 4 );
if ( len == 0xf ) {
len = FDKreadBits(hBs, 8 );
eldExtLen += len;
if ( len == 0xff ) {
len = FDKreadBits(hBs, 16 );
eldExtLen += len;
}
}
switch (eldExtType) {
default:
for(cnt=0; cnt<eldExtLen; cnt++) {
FDKreadBits(hBs, 8 );
}
break;
/* add future eld extension configs here */
}
}
bail:
return (ErrorStatus);
}
static
TRANSPORTDEC_ERROR GaSpecificConfig_Parse( CSGaSpecificConfig *self,
CSAudioSpecificConfig *asc,
HANDLE_FDK_BITSTREAM bs,
UINT ascStartAnchor )
{
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
self->m_frameLengthFlag = FDKreadBits(bs,1);
self->m_dependsOnCoreCoder = FDKreadBits(bs,1);
if( self->m_dependsOnCoreCoder )
self->m_coreCoderDelay = FDKreadBits(bs,14);
self->m_extensionFlag = FDKreadBits(bs,1);
if( asc->m_channelConfiguration == 0 ) {
CProgramConfig_Read(&asc->m_progrConfigElement, bs, ascStartAnchor);
}
if ((asc->m_aot == AOT_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_SCAL)) {
self->m_layer = FDKreadBits(bs,3);
}
if (self->m_extensionFlag) {
if (asc->m_aot == AOT_ER_BSAC) {
self->m_numOfSubFrame = FDKreadBits(bs,5);
self->m_layerLength = FDKreadBits(bs,11);
}
if ((asc->m_aot == AOT_ER_AAC_LC) || (asc->m_aot == AOT_ER_AAC_LTP) ||
(asc->m_aot == AOT_ER_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_LD))
{
asc->m_vcb11Flag = FDKreadBits(bs,1); /* aacSectionDataResilienceFlag */
asc->m_rvlcFlag = FDKreadBits(bs,1); /* aacScalefactorDataResilienceFlag */
asc->m_hcrFlag = FDKreadBits(bs,1); /* aacSpectralDataResilienceFlag */
}
self->m_extensionFlag3 = FDKreadBits(bs,1);
}
return (ErrorStatus);
}
void
FDKsbrEnc_AssembleSbrBitstream( HANDLE_COMMON_DATA hCmonData,
HANDLE_FDK_CRCINFO hCrcInfo,
INT crcRegion,
UINT sbrSyntaxFlags)
{
USHORT crcReg = SBR_CRCINIT;
INT numCrcBits,i;
/* check if SBR is present */
if ( hCmonData==NULL )
return;
hCmonData->sbrFillBits = 0; /* Fill bits are written only for GA streams */
if ( sbrSyntaxFlags & SBR_SYNTAX_DRM_CRC )
{
/*
* Calculate and write DRM CRC
*/
FDKcrcEndReg( hCrcInfo, &hCmonData->sbrBitbuf, crcRegion );
FDKwriteBits( &hCmonData->tmpWriteBitbuf, FDKcrcGetCRC(hCrcInfo)^0xFF, SI_SBR_DRM_CRC_BITS );
}
else
{
if ( !(sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) )
{
/* Do alignment here, because its defined as part of the sbr_extension_data */
int sbrLoad = hCmonData->sbrHdrBits + hCmonData->sbrDataBits;
if ( sbrSyntaxFlags & SBR_SYNTAX_CRC ) {
sbrLoad += SI_SBR_CRC_BITS;
}
sbrLoad += 4; /* Do byte Align with 4 bit offset. ISO/IEC 14496-3:2005(E) page 39. */
hCmonData->sbrFillBits = (8 - (sbrLoad % 8)) % 8;
/*
append fill bits
*/
FDKwriteBits(&hCmonData->sbrBitbuf, 0, hCmonData->sbrFillBits );
FDK_ASSERT(FDKgetValidBits(&hCmonData->sbrBitbuf) % 8 == 4);
}
/*
calculate crc
*/
if ( sbrSyntaxFlags & SBR_SYNTAX_CRC ) {
FDK_BITSTREAM tmpCRCBuf = hCmonData->sbrBitbuf;
FDKresetBitbuffer( &tmpCRCBuf, BS_READER );
numCrcBits = hCmonData->sbrHdrBits + hCmonData->sbrDataBits + hCmonData->sbrFillBits;
for(i=0;i<numCrcBits;i++){
INT bit;
bit = FDKreadBits(&tmpCRCBuf,1);
crcAdvance(SBR_CRC_POLY,SBR_CRC_MASK,&crcReg,bit,1);
}
crcReg &= (SBR_CRC_RANGE);
/*
* Write CRC data.
*/
FDKwriteBits (&hCmonData->tmpWriteBitbuf, crcReg, SI_SBR_CRC_BITS);
}
}
FDKsyncCache(&hCmonData->tmpWriteBitbuf);
}
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 = 0, startPos, startPosFirstFrame = -1;
INT numRawDataBlocksFirstFrame = 0, numRawDataBlocksPrevious, globalFramePosFirstFrame = 0, rawDataBlockLengthFirstFrame = 0;
INT ignoreBufferFullness = hTp->flags & (TPDEC_IGNORE_BUFFERFULLNESS|TPDEC_SYNCOK);
/* 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) {
/* Return sync error, because this happens only in case of severly damaged bit streams.
Returning TRANSPORTDEC_NOT_ENOUGH_BITS here is very dangerous. */
/* numberOfRawDataBlocks must be always reset in case of sync errors. */
hTp->numberOfRawDataBlocks = 0;
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) */
startPos = FDKgetValidBits(hBs);
if (err == TRANSPORTDEC_OK )
{
switch (hTp->transportFmt) {
case TT_MP4_ADTS:
if (hTp->numberOfRawDataBlocks <= 0)
{
int errC;
/* 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]);
if (errC != 0) {
err = TRANSPORTDEC_SYNC_ERROR;
} else {
hTp->numberOfRawDataBlocks = hTp->parser.adts.bs.num_raw_blocks+1;
/* CAUTION: The PCE (if available) is declared to be a part of the header! */
hTp->globalFramePos = FDKgetValidBits(hBs) + hTp->parser.adts.bs.num_pce_bits;
}
}
}
else {
/* Reset CRC because the next bits are the beginning of a raw_data_block() */
FDKcrcReset(&hTp->parser.adts.crcInfo);
hTp->globalFramePos = FDKgetValidBits(hBs);
}
if (err == TRANSPORTDEC_OK) {
hTp->numberOfRawDataBlocks--;
rawDataBlockLength = adtsRead_GetRawDataBlockLength(&hTp->parser.adts, (hTp->parser.adts.bs.num_raw_blocks-hTp->numberOfRawDataBlocks));
syncLayerFrameBits = (hTp->parser.adts.bs.frame_length<<3) - (startPos - FDKgetValidBits(hBs)) - syncLength;
if (syncLayerFrameBits <= 0) {
err = TRANSPORTDEC_SYNC_ERROR;
}
} else {
hTp->numberOfRawDataBlocks = 0;
}
break;
case TT_MP4_LOAS:
if (hTp->numberOfRawDataBlocks <= 0)
{
syncLayerFrameBits = FDKreadBits(hBs, 13);
hTp->parser.latm.m_audioMuxLengthBytes = syncLayerFrameBits;
syncLayerFrameBits <<= 3;
}
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,
ignoreBufferFullness);
if (err != TRANSPORTDEC_OK) {
if (err != TRANSPORTDEC_NOT_ENOUGH_BITS) {
err = TRANSPORTDEC_SYNC_ERROR;
}
} else {
hTp->numberOfRawDataBlocks = CLatmDemux_GetNrOfSubFrames(&hTp->parser.latm);
syncLayerFrameBits -= startPos - FDKgetValidBits(hBs) - (13);
}
} else {
err = CLatmDemux_ReadPayloadLengthInfo(hBs, &hTp->parser.latm);
if (err != TRANSPORTDEC_OK) {
err = TRANSPORTDEC_SYNC_ERROR;
}
}
if (err == TRANSPORTDEC_OK) {
rawDataBlockLength = CLatmDemux_GetFrameLengthInBits(&hTp->parser.latm);
hTp->numberOfRawDataBlocks--;
} else {
hTp->numberOfRawDataBlocks = 0;
}
break;
default:
{
syncLayerFrameBits = 0;
}
break;
}
}
headerBits += startPos - (INT)FDKgetValidBits(hBs);
bitsAvail -= headerBits;
checkLengthBits = syncLayerFrameBits;
/* Check if the whole frame would fit the bitstream buffer */
if (err == TRANSPORTDEC_OK) {
if ( (checkLengthBits+headerBits) > ((TRANSPORTDEC_INBUF_SIZE<<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) {
break;
}
if (err == TRANSPORTDEC_SYNC_ERROR) {
int bits;
/* Enforce re-sync of transport headers. */
hTp->numberOfRawDataBlocks = 0;
/* Ensure that the bit amount lands and 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);
bitsAvail += 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)) {
break;
}
}
if (err == TRANSPORTDEC_OK) {
FDKpushFor(hBs, rawDataBlockLength);
bitsAvail -= rawDataBlockLength;
numFramesTraversed++;
/* Ignore error here itentionally. */
transportDec_AdjustEndOfAccessUnit(hTp);
}
}
} 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_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);
if (err != TRANSPORTDEC_OK) {
hTp->numberOfRawDataBlocks = numRawDataBlocksPrevious;
headerBits = headerBitsPrevious;
}
err = TRANSPORTDEC_OK;
}
bail:
hTp->auLength[0] = rawDataBlockLength;
if (err == TRANSPORTDEC_OK) {
hTp->flags |= TPDEC_SYNCOK;
}
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;
}
TRANSPORTDEC_ERROR DrmRawSdcAudioConfig_Parse(
CSAudioSpecificConfig *self,
HANDLE_FDK_BITSTREAM bs
)
{
TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
AudioSpecificConfig_Init(self);
if ((INT)FDKgetValidBits(bs) < 20) {
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
goto bail;
}
else {
/* DRM - Audio information data entity - type 9
- Short Id 2 bits
- Stream Id 2 bits
- audio coding 2 bits
- SBR flag 1 bit
- audio mode 2 bits
- audio sampling rate 3 bits
- text flag 1 bit
- enhancement flag 1 bit
- coder field 5 bits
- rfa 1 bit */
int audioCoding, audioMode, cSamplingFreq, coderField, sfIdx, sbrFlag;
/* Read the SDC field */
FDKreadBits(bs,4); /* Short and Stream Id */
audioCoding = FDKreadBits(bs, 2);
sbrFlag = FDKreadBits(bs, 1);
audioMode = FDKreadBits(bs, 2);
cSamplingFreq = FDKreadBits(bs, 3); /* audio sampling rate */
FDKreadBits(bs, 2); /* Text and enhancement flag */
coderField = FDKreadBits(bs, 5);
FDKreadBits(bs, 1); /* rfa */
/* Evaluate configuration and fill the ASC */
switch (cSamplingFreq) {
case 0: /* 8 kHz */
sfIdx = 11;
break;
case 1: /* 12 kHz */
sfIdx = 9;
break;
case 2: /* 16 kHz */
sfIdx = 8;
break;
case 3: /* 24 kHz */
sfIdx = 6;
break;
case 5: /* 48 kHz */
sfIdx = 3;
break;
case 4: /* reserved */
case 6: /* reserved */
case 7: /* reserved */
default:
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
goto bail;
}
self->m_samplingFrequencyIndex = sfIdx;
self->m_samplingFrequency = SamplingRateTable[sfIdx];
if ( sbrFlag ) {
UINT i;
int tmp = -1;
self->m_sbrPresentFlag = 1;
self->m_extensionAudioObjectType = AOT_SBR;
self->m_extensionSamplingFrequency = self->m_samplingFrequency << 1;
for (i=0; i<(sizeof(SamplingRateTable)/sizeof(SamplingRateTable[0])); i++){
if (SamplingRateTable[i] == self->m_extensionSamplingFrequency){
tmp = i;
break;
}
}
self->m_extensionSamplingFrequencyIndex = tmp;
}
switch (audioCoding) {
case 0: /* AAC */
self->m_aot = AOT_DRM_AAC ; /* Set pseudo AOT for Drm AAC */
switch (audioMode) {
case 1: /* parametric stereo */
self->m_psPresentFlag = 1;
case 0: /* mono */
self->m_channelConfiguration = 1;
break;
case 2: /* stereo */
self->m_channelConfiguration = 2;
break;
default:
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
goto bail;
}
self->m_vcb11Flag = 1;
self->m_hcrFlag = 1;
self->m_samplesPerFrame = 960;
self->m_epConfig = 1;
break;
case 1: /* CELP */
self->m_aot = AOT_ER_CELP;
self->m_channelConfiguration = 1;
break;
case 2: /* HVXC */
self->m_aot = AOT_ER_HVXC;
self->m_channelConfiguration = 1;
break;
case 3: /* reserved */
default:
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
self->m_aot = AOT_NONE;
break;
}
if (self->m_psPresentFlag && !self->m_sbrPresentFlag) {
ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
goto bail;
}
}
bail:
return (ErrorStatus);
}
AAC_DECODER_ERROR CChannelElement_Read(HANDLE_FDK_BITSTREAM hBs,
CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
const AUDIO_OBJECT_TYPE aot,
const SamplingRateInfo *pSamplingRateInfo,
const UINT flags,
const UINT frame_length,
const UCHAR numberOfChannels,
const SCHAR epConfig,
HANDLE_TRANSPORTDEC pTpDec
)
{
AAC_DECODER_ERROR error = AAC_DEC_OK;
const element_list_t *list;
int i, ch, decision_bit;
int crcReg1 = -1, crcReg2 = -1;
FDK_ASSERT( (numberOfChannels == 1) || (numberOfChannels == 2) );
/* Get channel element sequence table */
list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0);
if (list == NULL) {
error = AAC_DEC_UNSUPPORTED_FORMAT;
goto bail;
}
CTns_Reset(&pAacDecoderChannelInfo[0]->pDynData->TnsData);
if (numberOfChannels == 2) {
CTns_Reset(&pAacDecoderChannelInfo[1]->pDynData->TnsData);
}
if (flags & (AC_ELD|AC_SCALABLE)) {
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 1;
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
}
/* Iterate through sequence table */
i = 0;
ch = 0;
decision_bit = 0;
do {
switch (list->id[i]) {
case element_instance_tag:
pAacDecoderChannelInfo[0]->ElementInstanceTag = FDKreadBits(hBs, 4);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->ElementInstanceTag = pAacDecoderChannelInfo[0]->ElementInstanceTag;
}
break;
case common_window:
decision_bit = pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow = FDKreadBits(hBs, 1);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
break;
case ics_info:
/* Read individual channel info */
error = IcsRead( hBs,
&pAacDecoderChannelInfo[ch]->icsInfo,
pSamplingRateInfo,
flags );
if (numberOfChannels == 2 && pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
pAacDecoderChannelInfo[1]->icsInfo = pAacDecoderChannelInfo[0]->icsInfo;
}
break;
case ltp_data_present:
if (FDKreadBits(hBs, 1) != 0) {
error = AAC_DEC_UNSUPPORTED_PREDICTION;
}
break;
case ms:
if ( CJointStereo_Read(
hBs,
&pAacDecoderChannelInfo[0]->pComData->jointStereoData,
GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo),
GetScaleMaxFactorBandsTransmitted(&pAacDecoderChannelInfo[0]->icsInfo,
&pAacDecoderChannelInfo[1]->icsInfo),
flags) )
{
error = AAC_DEC_PARSE_ERROR;
}
break;
case global_gain:
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.GlobalGain = (UCHAR) FDKreadBits(hBs,8);
break;
case section_data:
error = CBlock_ReadSectionData( hBs,
pAacDecoderChannelInfo[ch],
pSamplingRateInfo,
flags );
break;
case scale_factor_data:
if (flags & AC_ER_RVLC) {
/* read RVLC data from bitstream (error sens. cat. 1) */
CRvlc_Read(pAacDecoderChannelInfo[ch], hBs);
}
else
{
error = CBlock_ReadScaleFactorData(pAacDecoderChannelInfo[ch], hBs, flags);
}
break;
case pulse:
if ( CPulseData_Read( hBs,
&pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.PulseData,
pSamplingRateInfo->ScaleFactorBands_Long, /* pulse data is only allowed to be present in long blocks! */
(void*)&pAacDecoderChannelInfo[ch]->icsInfo,
frame_length
) != 0 )
{
error = AAC_DEC_DECODE_FRAME_ERROR;
}
break;
case tns_data_present:
CTns_ReadDataPresentFlag(hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData);
break;
case tns_data:
/* tns_data_present is checked inside CTns_Read(). */
error = CTns_Read(hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData, &pAacDecoderChannelInfo[ch]->icsInfo, flags);
break;
case gain_control_data:
break;
case gain_control_data_present:
if (FDKreadBits(hBs, 1)) {
error = AAC_DEC_UNSUPPORTED_GAIN_CONTROL_DATA;
}
break;
case esc2_rvlc:
if (flags & AC_ER_RVLC) {
CRvlc_Decode(
pAacDecoderChannelInfo[ch],
pAacDecoderStaticChannelInfo[ch],
hBs
);
}
break;
case esc1_hcr:
if (flags & AC_ER_HCR) {
CHcr_Read(hBs, pAacDecoderChannelInfo[ch] );
}
break;
case spectral_data:
error = CBlock_ReadSpectralData( hBs,
pAacDecoderChannelInfo[ch],
pSamplingRateInfo,
flags );
if (flags & AC_ELD) {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_ELDFB;
} else {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
}
break;
/* CRC handling */
case adtscrc_start_reg1:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 192);
}
break;
case adtscrc_start_reg2:
if (pTpDec != NULL) {
crcReg2 = transportDec_CrcStartReg(pTpDec, 128);
}
break;
case adtscrc_end_reg1:
case drmcrc_end_reg:
if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg1);
}
break;
case adtscrc_end_reg2:
if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg2);
}
break;
case drmcrc_start_reg:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 0);
}
break;
/* Non data cases */
case next_channel:
ch = (ch + 1) % numberOfChannels;
break;
case link_sequence:
list = list->next[decision_bit];
i=-1;
break;
default:
error = AAC_DEC_UNSUPPORTED_FORMAT;
break;
}
if (error != AAC_DEC_OK) {
goto bail;
}
i++;
} while (list->id[i] != end_of_sequence);
bail:
return error;
}
AAC_DECODER_ERROR CBlock_ReadSectionData(HANDLE_FDK_BITSTREAM bs,
CAacDecoderChannelInfo *pAacDecoderChannelInfo,
const SamplingRateInfo *pSamplingRateInfo,
const UINT flags)
{
int top, band;
int sect_len, sect_len_incr;
int group;
UCHAR sect_cb;
UCHAR *pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
/* HCR input (long) */
SHORT *pNumLinesInSec = pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr;
int numLinesInSecIdx = 0;
UCHAR *pHcrCodeBook = pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr;
const SHORT *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo);
pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection = 0;
AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
FDKmemclear(pCodeBook, sizeof(UCHAR)*(8*16));
const int nbits = (IsLongBlock(&pAacDecoderChannelInfo->icsInfo) == 1) ? 5 : 3;
int sect_esc_val = (1 << nbits) - 1 ;
UCHAR ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
for (group=0; group<GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
{
for (band=0; band < ScaleFactorBandsTransmitted; )
{
sect_len = 0;
if ( flags & AC_ER_VCB11 ) {
sect_cb = (UCHAR) FDKreadBits(bs,5);
}
else
sect_cb = (UCHAR) FDKreadBits(bs,4);
if ( ((flags & AC_ER_VCB11) == 0) || ( sect_cb < 11 ) || ((sect_cb > 11) && (sect_cb < 16)) ) {
sect_len_incr = FDKreadBits(bs, nbits);
while (sect_len_incr == sect_esc_val)
{
sect_len += sect_esc_val;
sect_len_incr = FDKreadBits(bs, nbits);
}
}
else {
sect_len_incr = 1;
}
sect_len += sect_len_incr;
top = band + sect_len;
if (flags & AC_ER_HCR) {
/* HCR input (long) -- collecting sideinfo (for HCR-_long_ only) */
if (numLinesInSecIdx >= MAX_SFB_HCR) {
return AAC_DEC_PARSE_ERROR;
}
pNumLinesInSec[numLinesInSecIdx] = BandOffsets[top] - BandOffsets[band];
numLinesInSecIdx++;
if (sect_cb == BOOKSCL)
{
return AAC_DEC_INVALID_CODE_BOOK;
} else {
*pHcrCodeBook++ = sect_cb;
}
pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection++;
}
/* Check spectral line limits */
if (IsLongBlock( &(pAacDecoderChannelInfo->icsInfo) ))
{
if (top > 64) {
return AAC_DEC_DECODE_FRAME_ERROR;
}
} else { /* short block */
if (top + group*16 > (8 * 16)) {
return AAC_DEC_DECODE_FRAME_ERROR;
}
}
/* Check if decoded codebook index is feasible */
if ( (sect_cb == BOOKSCL)
|| ( (sect_cb == INTENSITY_HCB || sect_cb == INTENSITY_HCB2) && pAacDecoderChannelInfo->pDynData->RawDataInfo.CommonWindow == 0)
)
{
return AAC_DEC_INVALID_CODE_BOOK;
}
/* Store codebook index */
for (; band < top; band++)
{
pCodeBook[group*16+band] = sect_cb;
}
}
}
return ErrorStatus;
}
