/*!
\brief SBR decoder processing
\return SBRDEC_OK if successfull, else error code
*/
SBR_ERROR
applySBR (SBRDECODER self,
SBRBITSTREAM * Bitstr,
float *timeData,
float *workBufferCore,
int *numChannels,
int SbrFrameOK,
int bDownSample,
int bBitstreamDownMix
)
{
unsigned char i;
unsigned char dualMono = 0;
int stereo = 0;
int CRCLen = 0;
int crcEnable = 0;
int readHeader = 0;
int err = 0;
SBR_CHANNEL *SbrChannel = &self->SbrChannel[0];
BIT_BUFFER bitBuf;
HANDLE_SBR_HEADER_DATA_DEC hHeaderData = &self->sbr_header;
SBR_HEADER_STATUS headerStatus = HEADER_NOT_INITIALIZED;
int codecFrameSize = hHeaderData->codecFrameSize;
SBR_SYNC_STATE initialSyncState = hHeaderData->syncState;
HANDLE_SBR_CONCEAL_DATA hConcealData = &self->SbrConcealData;
float * pWorkBuffer1 = &timeData[2*codecFrameSize];
SBR_FRAME_DATA *hFrameDataLeft = (SBR_FRAME_DATA*) pWorkBuffer1;
SBR_FRAME_DATA *hFrameDataRight = (SBR_FRAME_DATA*) self->InterimResult;
assert( sizeof(SBR_FRAME_DATA) <= MAX_FRAME_SIZE*sizeof(float));
self->SbrChannel->SbrDec.workBuffer2 = workBufferCore;
FLC_sub_start("applySBR");
INDIRECT(5); MOVE(9); PTR_INIT(6); /* counting previous operations */
PTR_INIT(1); FUNC(3);
DelaySbrBitstr(hConcealData, Bitstr, &SbrFrameOK);
INDIRECT(1); BRANCH(1);
if (Bitstr->NrElements) {
PTR_INIT(6); /* Bitstr->sbrElement[]
SbrChannel[]
hHeaderData
hFrameDataLeft
hFrameDataRight
bitBuf
*/
INDIRECT(1); LOOP(1);
for (i=0; i<Bitstr->NrElements; i++) {
/* Save last error flag */
MOVE(1);
hHeaderData->prevFrameErrorFlag = hHeaderData->frameErrorFlag;
ADD(1); BRANCH(1);
if (Bitstr->NrElements == 2) {
MOVE(1);
dualMono = 1;
}
else {
BRANCH(2);
switch (Bitstr->sbrElement[i].ElementID) {
case SBR_ID_SCE:
MOVE(1);
stereo = 0;
break;
case SBR_ID_CPE:
MOVE(1);
stereo = 1;
break;
default:
MOVE(1);
SbrFrameOK = 0;
}
}
MULT(1); FUNC(3);
initBitBuffer (&bitBuf,
Bitstr->sbrElement[i].Data,
Bitstr->sbrElement[i].Payload * 8) ;
FUNC(2);
getbits (&bitBuf, LEN_NIBBLE);
BRANCH(1);
if (SbrFrameOK) {
ADD(1); BRANCH(1);
if (Bitstr->sbrElement[i].ExtensionType == SBR_EXTENSION_CRC) {
MOVE(1);
crcEnable = 1;
ADD(2); MULT(1);
CRCLen = 8*(Bitstr->sbrElement[i].Payload-1)+4 - SI_SBR_CRC_BITS;
BRANCH(1);
if (CRCLen < 0) {
MOVE(2);
crcEnable = 0;
SbrFrameOK = 0;
}
}
BRANCH(1);
if (crcEnable)
{
FUNC(2);
SbrFrameOK = SbrCrcCheck (&bitBuf,
CRCLen);
}
FUNC(2);
readHeader = getbits (&bitBuf, 1);
BRANCH(1);
if (SbrFrameOK){
int lr;
FUNC(1);
if (readHeader) {
FUNC(3);
headerStatus = sbrGetHeaderData (hHeaderData,
&bitBuf,
(SBR_ELEMENT_ID)Bitstr->sbrElement[i].ElementID);
ADD(1); BRANCH(1);
if (headerStatus == HEADER_NOT_INITIALIZED) {
FLC_sub_end();
return SBRDEC_NOT_INITIALIZED;
}
ADD(1); BRANCH(1);
if (headerStatus == HEADER_RESET) {
FUNC(1);
err = resetFreqBandTables(hHeaderData);
PTR_INIT(1); /* SbrChannel[] */
LOOP(1);
for (lr = 0 ; lr < MAXNRSBRCHANNELS; lr++) {
INDIRECT(1); PTR_INIT(1); FUNC(1);
resetSbrEnvelopeCalc (&(SbrChannel[lr].SbrDec.SbrCalculateEnvelope));
}
PTR_INIT(1); /* SbrChannel[] */
LOOP(1);
for (lr = 0 ; lr < MAXNRQMFCHANNELS; lr++) {
#ifdef NON_BE_BUGFIX
PTR_INIT(1); FUNC(5);
#else
PTR_INIT(1); FUNC(4);
#endif
err |= resetSbrQMF (&(SbrChannel[lr].SbrDec),
hHeaderData,
lr,
#ifdef NON_BE_BUGFIX
*numChannels,
#endif
SbrChannel[lr].hPrevFrameData);
}
BRANCH(1);
if (err==0) {
MOVE(1);
hHeaderData->syncState = SBR_ACTIVE;
}
}
} // if (readHeader)
ADD(1); LOGIC(1); BRANCH(1);
if (err || hHeaderData->syncState == SBR_NOT_INITIALIZED) {
ADD(1); LOGIC(1); BRANCH(1);
if (err && hHeaderData->syncState == SBR_NOT_INITIALIZED) {
FLC_sub_end();
return SBRDEC_NOT_INITIALIZED;
}
SHIFT(1); FUNC(3);
initHeaderData( hHeaderData,
hHeaderData->outSampleRate >> 1,
codecFrameSize);
FUNC(1);
err = resetFreqBandTables(hHeaderData);
MOVE(2);
hHeaderData->FreqBandData.lowSubband = NO_ANALYSIS_CHANNELS;
hHeaderData->FreqBandData.highSubband = NO_ANALYSIS_CHANNELS;
PTR_INIT(1); /* SbrChannel[lr] */
LOOP(1);
for (lr = 0 ; lr < MAXNRSBRCHANNELS; lr++) {
INDIRECT(1); PTR_INIT(1); FUNC(1);
resetSbrEnvelopeCalc (&(SbrChannel[lr].SbrDec.SbrCalculateEnvelope));
}
PTR_INIT(1); /* SbrChannel[lr] */
LOOP(1);
for (lr = 0 ; lr < MAXNRQMFCHANNELS; lr++) {
#ifdef NON_BE_BUGFIX
PTR_INIT(1); FUNC(5);
#else
PTR_INIT(1); FUNC(4);
#endif
err |= resetSbrQMF (&(SbrChannel[lr].SbrDec),
hHeaderData,
lr,
#ifdef NON_BE_BUGFIX
*numChannels,
#endif
SbrChannel[lr].hPrevFrameData);
}
MOVE(1);
hHeaderData->syncState = UPSAMPLING;
}
ADD(1); BRANCH(1);
if (hHeaderData->syncState == SBR_ACTIVE) {
BRANCH(1);
if (dualMono) {
BRANCH(1);
if (i == 0) {
BRANCH(1); MOVE(1);
hFrameDataLeft->xposCtrl = max(0, SbrChannel[i].hPrevFrameData->xposCtrl);
FUNC(4);
SbrFrameOK = sbrGetSingleChannelElement(hHeaderData,
hFrameDataLeft,
NULL,
&bitBuf);
}
else {
BRANCH(1); MOVE(1);
hFrameDataRight->xposCtrl = max(0, SbrChannel[i].hPrevFrameData->xposCtrl);
FUNC(4);
SbrFrameOK = sbrGetSingleChannelElement(hHeaderData,
hFrameDataRight,
NULL,
&bitBuf);
}
}
else {
BRANCH(1); MOVE(1);
hFrameDataLeft->xposCtrl = max(0, SbrChannel[i].hPrevFrameData->xposCtrl);
BRANCH(1);
if (stereo) {
BRANCH(1); MOVE(1);
hFrameDataRight->xposCtrl = max(0, SbrChannel[i+1].hPrevFrameData->xposCtrl);
FUNC(4);
SbrFrameOK = sbrGetChannelPairElement(hHeaderData,
hFrameDataLeft,
hFrameDataRight,
&bitBuf);
}
else
{
BRANCH(1);
if (bBitstreamDownMix)
{
MOVE(1);
self->ParametricStereoDec.bForceMono = 1;
}
else
{
MOVE(1);
self->ParametricStereoDec.bForceMono = 0;
}
FUNC(4);
SbrFrameOK = sbrGetSingleChannelElement(hHeaderData,
hFrameDataLeft,
&self->ParametricStereoDec,
&bitBuf);
}
}
{
int payloadbits = GetNrBitsRead (&bitBuf);
int fillbits = (8 - (payloadbits & 7)) & 7;
FUNC(1); ADD(1); LOGIC(2); /* counting previous operations */
ADD(2); MULT(1); BRANCH(1);
if ((payloadbits + fillbits) != 8 * Bitstr->sbrElement[i].Payload)
{
MOVE(1);
SbrFrameOK = 0;
}
}
}
}
}
ADD(1); LOGIC(1); BRANCH(1);
if (!SbrFrameOK || headerStatus == CONCEALMENT) {
MOVE(1);
hHeaderData->frameErrorFlag = 1;
}
}
SBR_ERROR sbrDecoder_Parse(
HANDLE_SBRDECODER self,
HANDLE_FDK_BITSTREAM hBs,
int *count,
int bsPayLen,
int crcFlag,
MP4_ELEMENT_ID prevElement,
int elementIndex,
int fGlobalIndependencyFlag
)
{
SBR_DECODER_ELEMENT *hSbrElement;
HANDLE_SBR_HEADER_DATA hSbrHeader;
HANDLE_SBR_CHANNEL *pSbrChannel;
SBR_FRAME_DATA *hFrameDataLeft;
SBR_FRAME_DATA *hFrameDataRight;
SBR_ERROR errorStatus = SBRDEC_OK;
SBR_SYNC_STATE initialSyncState;
SBR_HEADER_STATUS headerStatus = HEADER_NOT_PRESENT;
INT startPos;
INT CRCLen = 0;
int stereo;
int fDoDecodeSbrData = 1;
int lastSlot, lastHdrSlot = 0, thisHdrSlot;
/* Remember start position of SBR element */
startPos = FDKgetValidBits(hBs);
/* SBR sanity checks */
if ( self == NULL || self->pSbrElement[elementIndex] == NULL ) {
errorStatus = SBRDEC_NOT_INITIALIZED;
goto bail;
}
hSbrElement = self->pSbrElement[elementIndex];
lastSlot = (hSbrElement->useFrameSlot > 0) ? hSbrElement->useFrameSlot-1 : self->numDelayFrames;
lastHdrSlot = hSbrElement->useHeaderSlot[lastSlot];
thisHdrSlot = getHeaderSlot( hSbrElement->useFrameSlot, hSbrElement->useHeaderSlot ); /* Get a free header slot not used by frames not processed yet. */
/* Assign the free slot to store a new header if there is one. */
hSbrHeader = &self->sbrHeader[elementIndex][thisHdrSlot];
pSbrChannel = hSbrElement->pSbrChannel;
stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
hFrameDataLeft = &self->pSbrElement[elementIndex]->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
hFrameDataRight = &self->pSbrElement[elementIndex]->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
initialSyncState = hSbrHeader->syncState;
/* reset PS flag; will be set after PS was found */
self->flags &= ~SBRDEC_PS_DECODED;
if (hSbrHeader->status & SBRDEC_HDR_STAT_UPDATE) {
/* Got a new header from extern (e.g. from an ASC) */
headerStatus = HEADER_OK;
hSbrHeader->status &= ~SBRDEC_HDR_STAT_UPDATE;
}
else if (thisHdrSlot != lastHdrSlot) {
/* Copy the last header into this slot otherwise the
header compare will trigger more HEADER_RESETs than needed. */
copySbrHeader( hSbrHeader, &self->sbrHeader[elementIndex][lastHdrSlot] );
}
/*
Check if bit stream data is valid and matches the element context
*/
if ( ((prevElement != ID_SCE) && (prevElement != ID_CPE)) || prevElement != hSbrElement->elementID) {
/* In case of LFE we also land here, since there is no LFE SBR element (do upsampling only) */
fDoDecodeSbrData = 0;
}
if (fDoDecodeSbrData)
{
if ((INT)FDKgetValidBits(hBs) <= 0) {
fDoDecodeSbrData = 0;
}
}
/*
SBR CRC-check
*/
if (fDoDecodeSbrData)
{
if (crcFlag == 1) {
switch (self->coreCodec) {
case AOT_ER_AAC_ELD:
FDKpushFor (hBs, 10);
/* check sbrcrc later: we don't know the payload length now */
break;
default:
CRCLen = bsPayLen - 10; /* change: 0 => i */
if (CRCLen < 0) {
fDoDecodeSbrData = 0;
} else {
fDoDecodeSbrData = SbrCrcCheck (hBs, CRCLen);
}
break;
}
}
} /* if (fDoDecodeSbrData) */
/*
Read in the header data and issue a reset if change occured
*/
if (fDoDecodeSbrData)
{
int sbrHeaderPresent;
{
sbrHeaderPresent = FDKreadBit(hBs);
}
if ( sbrHeaderPresent ) {
headerStatus = sbrGetHeaderData (hSbrHeader,
hBs,
self->flags,
1);
}
if (headerStatus == HEADER_RESET)
{
errorStatus = sbrDecoder_HeaderUpdate(
self,
hSbrHeader,
headerStatus,
pSbrChannel,
hSbrElement->nChannels
);
if (errorStatus == SBRDEC_OK) {
hSbrHeader->syncState = SBR_HEADER;
} else {
hSbrHeader->syncState = SBR_NOT_INITIALIZED;
}
}
if (errorStatus != SBRDEC_OK) {
fDoDecodeSbrData = 0;
}
} /* if (fDoDecodeSbrData) */
/*
Print debugging output only if state has changed
*/
/* read frame data */
if ((hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) {
int sbrFrameOk;
/* read the SBR element data */
if (stereo) {
sbrFrameOk = sbrGetChannelPairElement(hSbrHeader,
hFrameDataLeft,
hFrameDataRight,
hBs,
self->flags,
self->pSbrElement[elementIndex]->transposerSettings.overlap);
}
else {
if (self->hParametricStereoDec != NULL) {
/* update slot index for PS bitstream parsing */
self->hParametricStereoDec->bsLastSlot = self->hParametricStereoDec->bsReadSlot;
self->hParametricStereoDec->bsReadSlot = hSbrElement->useFrameSlot;
}
sbrFrameOk = sbrGetSingleChannelElement(hSbrHeader,
hFrameDataLeft,
hBs,
self->hParametricStereoDec,
self->flags,
self->pSbrElement[elementIndex]->transposerSettings.overlap);
}
if (!sbrFrameOk) {
fDoDecodeSbrData = 0;
}
else {
INT valBits;
if (bsPayLen > 0) {
valBits = bsPayLen - ((INT)startPos - (INT)FDKgetValidBits(hBs));
} else {
valBits = (INT)FDKgetValidBits(hBs);
}
if ( crcFlag == 1 ) {
switch (self->coreCodec) {
case AOT_ER_AAC_ELD:
{
/* late crc check for eld */
INT payloadbits = (INT)startPos - (INT)FDKgetValidBits(hBs) - startPos;
INT crcLen = payloadbits - 10;
FDKpushBack(hBs, payloadbits);
fDoDecodeSbrData = SbrCrcCheck (hBs, crcLen);
FDKpushFor(hBs, crcLen);
}
break;
default:
break;
}
}
/* sanity check of remaining bits */
if (valBits < 0) {
fDoDecodeSbrData = 0;
} else {
switch (self->coreCodec) {
case AOT_SBR:
case AOT_PS:
case AOT_AAC_LC:
{
/* This sanity check is only meaningful with General Audio bitstreams */
int alignBits = valBits & 0x7;
if (valBits > alignBits) {
fDoDecodeSbrData = 0;
}
}
break;
default:
/* No sanity check available */
break;
}
}
}
} else {
/* The returned bit count will not be the actual payload size since we did not
parse the frame data. Return an error so that the caller can react respectively. */
errorStatus = SBRDEC_PARSE_ERROR;
}
if (!fDoDecodeSbrData) {
/* Set error flag for this slot to trigger concealment */
self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 1;
errorStatus = SBRDEC_PARSE_ERROR;
} else {
/* Everything seems to be ok so clear the error flag */
self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 0;
}
if (!stereo) {
/* Turn coupling off explicitely to avoid access to absent right frame data
that might occur with corrupt bitstreams. */
hFrameDataLeft->coupling = COUPLING_OFF;
}
bail:
if (errorStatus == SBRDEC_OK) {
if (headerStatus == HEADER_NOT_PRESENT) {
/* Use the old header for this frame */
hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = lastHdrSlot;
} else {
/* Use the new header for this frame */
hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = thisHdrSlot;
}
/* Move frame pointer to the next slot which is up to be decoded/applied next */
hSbrElement->useFrameSlot = (hSbrElement->useFrameSlot+1) % (self->numDelayFrames+1);
}
*count -= startPos - FDKgetValidBits(hBs);
return errorStatus;
}