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; }
/*! \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; } }
INT sbrDecoder_Header ( HANDLE_SBRDECODER self, HANDLE_FDK_BITSTREAM hBs, const INT sampleRateIn, const INT sampleRateOut, const INT samplesPerFrame, const AUDIO_OBJECT_TYPE coreCodec, const MP4_ELEMENT_ID elementID, const INT elementIndex ) { SBR_HEADER_STATUS headerStatus; HANDLE_SBR_HEADER_DATA hSbrHeader; SBR_ERROR sbrError = SBRDEC_OK; int headerIndex; if ( self == NULL || elementIndex > (8) ) { return SBRDEC_UNSUPPORTED_CONFIG; } if (! sbrDecoder_isCoreCodecValid(coreCodec)) { return SBRDEC_UNSUPPORTED_CONFIG; } sbrError = sbrDecoder_InitElement( self, sampleRateIn, sampleRateOut, samplesPerFrame, coreCodec, elementID, elementIndex ); if (sbrError != SBRDEC_OK) { goto bail; } headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot, self->pSbrElement[elementIndex]->useHeaderSlot); hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]); headerStatus = sbrGetHeaderData ( hSbrHeader, hBs, self->flags, 0); { SBR_DECODER_ELEMENT *pSbrElement; pSbrElement = self->pSbrElement[elementIndex]; /* Sanity check */ if (pSbrElement != NULL) { if ( (elementID == ID_CPE && pSbrElement->nChannels != 2) || (elementID != ID_CPE && pSbrElement->nChannels != 1) ) { return SBRDEC_UNSUPPORTED_CONFIG; } if ( headerStatus == HEADER_RESET ) { sbrError = sbrDecoder_HeaderUpdate( self, hSbrHeader, headerStatus, pSbrElement->pSbrChannel, pSbrElement->nChannels ); if (sbrError == SBRDEC_OK) { hSbrHeader->syncState = SBR_HEADER; hSbrHeader->status |= SBRDEC_HDR_STAT_UPDATE; } /* else { Since we already have overwritten the old SBR header the only way out is UPSAMPLING! This will be prepared in the next step. } */ } } } bail: return sbrError; }