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; }
/* * 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; }
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; }