AAC_DECODER_ERROR CBlock_ReadScaleFactorData(
CAacDecoderChannelInfo *pAacDecoderChannelInfo,
HANDLE_FDK_BITSTREAM bs,
UINT flags
)
{
int temp;
int band;
int group;
int position = 0; /* accu for intensity delta coding */
int factor = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain; /* accu for scale factor delta coding */
UCHAR *pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
SHORT *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
const CodeBookDescription *hcb =&AACcodeBookDescriptionTable[BOOKSCL];
int ScaleFactorBandsTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); group++)
{
for (band=0; band < ScaleFactorBandsTransmitted; band++)
{
switch (pCodeBook[group*16+band]) {
case ZERO_HCB: /* zero book */
pScaleFactor[group*16+band] = 0;
break;
default: /* decode scale factor */
{
temp = CBlock_DecodeHuffmanWord(bs,hcb);
factor += temp - 60; /* MIDFAC 1.5 dB */
}
pScaleFactor[group*16+band] = factor - 100;
break;
case INTENSITY_HCB: /* intensity steering */
case INTENSITY_HCB2:
temp = CBlock_DecodeHuffmanWord(bs,hcb);
position += temp - 60;
pScaleFactor[group*16+band] = position - 100;
break;
case NOISE_HCB: /* PNS */
if (flags & (AC_MPS_RES|AC_USAC|AC_RSVD50)) {
return AAC_DEC_PARSE_ERROR;
}
CPns_Read( &pAacDecoderChannelInfo->data.aac.PnsData, bs, hcb, pAacDecoderChannelInfo->pDynData->aScaleFactor, pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain, band, group);
break;
}
}
}
return AAC_DEC_OK;
}
/*!
\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;
}
/*
* 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;
}
int CShortBlock_ReadSpectralData(HANDLE_BIT_BUF bs,
CAacDecoderChannelInfo *pAacDecoderChannelInfo)
{
int i,index,step;
int window,group,groupwin,groupoffset,band;
int scfExp,scfMod;
int *QuantizedCoef;
char *pCodeBook = pAacDecoderChannelInfo->pCodeBook;
short *pScaleFactor = pAacDecoderChannelInfo->pScaleFactor;
float *pSpectralCoefficient = pAacDecoderChannelInfo->pSpectralCoefficient;
const short *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->IcsInfo);
const CodeBookDescription *hcb;
COUNT_sub_start("CShortBlock_ReadSpectralData");
QuantizedCoef = (int*)pSpectralCoefficient;
PTR_INIT(5); INDIRECT(4); FUNC(1); /* counting previous operations */
LOOP(1);
for (window=0; window < MaximumWindows; window++)
{
PTR_INIT(1); /* pointer for QuantizedCoef[] */
LOOP(1);
for (index=0; index < MaximumBinsShort; index++) {
MOVE(1);
QuantizedCoef[window*MaximumBinsShort+index] = 0;
}
}
MOVE(1);
groupoffset = 0;
INDIRECT(1); FUNC(1); LOOP(1);
for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++)
{
PTR_INIT(1); /* pointer for pCodeBook[] */
INDIRECT(1); FUNC(1); LOOP(1);
for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++)
{
PTR_INIT(1);
hcb = &HuffmanCodeBooks[pCodeBook[group*MaximumScaleFactorBandsShort+band]];
INDIRECT(1); FUNC(1); LOOP(1);
for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group); groupwin++)
{
ADD(1);
window = groupoffset + groupwin;
ADD(4); LOGIC(3); BRANCH(1);
if ( (pCodeBook[group*MaximumScaleFactorBandsShort+band] == ZERO_HCB)
||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == INTENSITY_HCB)
||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == INTENSITY_HCB2)
||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == NOISE_HCB))
continue;
MOVE(1);
step = 0 ;
PTR_INIT(2); /* pointer for BandOffsets[],
QuantizedCoef[] */
LOOP(1);
for (index=BandOffsets[band]; index < BandOffsets[band+1]; index+=step)
{
INDIRECT(1); FUNC(2); PTR_INIT(1); FUNC(3);
step = CBlock_UnpackIndex(CBlock_DecodeHuffmanWord(bs,hcb->CodeBook),&QuantizedCoef[window*MaximumBinsShort+index],hcb);
INDIRECT(1); BRANCH(1);
if (hcb->Offset == 0)
{
PTR_INIT(1); /* pointer for QuantizedCoef[] */
LOOP(1);
for (i=0; i < step; i++)
{
BRANCH(1);
if (QuantizedCoef[window*MaximumBinsShort+index+i])
{
FUNC(2);
if (GetBits(bs,1)) /* sign bit */
{
MULT(1); STORE(1);
QuantizedCoef [window*MaximumBinsShort+index+i] = -QuantizedCoef [window*MaximumBinsShort+index+i];
}
}
}
}
ADD(1); BRANCH(1);
if (pCodeBook[group*MaximumScaleFactorBandsShort+band] == ESCBOOK)
{
FUNC(2); STORE(1);
QuantizedCoef[window*MaximumBinsShort+index] = CBlock_GetEscape(bs,QuantizedCoef[window*MaximumBinsShort+index]);
FUNC(2); STORE(1);
QuantizedCoef[window*MaximumBinsShort+index+1] = CBlock_GetEscape(bs,QuantizedCoef[window*MaximumBinsShort+index+1]);
FUNC(1); FUNC(1); ADD(2); LOGIC(1); BRANCH(1);
if (abs(QuantizedCoef[window*MaximumBinsShort+index]) > MAX_QUANTIZED_VALUE || abs(QuantizedCoef[window*MaximumBinsShort+index+1]) > MAX_QUANTIZED_VALUE) {
COUNT_sub_end();
return (AAC_DEC_DECODE_FRAME_ERROR);
}
}
}
}
}
INDIRECT(1); ADD(1);
groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group);
}
INDIRECT(1); FUNC(1); LOOP(1);
for (window=0, group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++)
{
INDIRECT(1); FUNC(1); LOOP(1);
for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group); groupwin++, window++)
{
MOVE(1);
index = 0;
PTR_INIT(2); /* pointer for BandOffsets[],
pScaleFactor */
INDIRECT(1); FUNC(1); LOOP(1) ;
/* quantize & apply scalefactors */
for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++)
{
/* scalefactor exponents and scalefactor mantissa for current band */
SHIFT(1);
scfExp = pScaleFactor[group*MaximumScaleFactorBandsShort+band] >> 2;
LOGIC(1);
scfMod = pScaleFactor[group*MaximumScaleFactorBandsShort+band] & 3;
PTR_INIT(2); /* pointer for QuantizedCoef[],
pSpectralCoefficient */
LOOP(1);
for (index=BandOffsets[band]; index < BandOffsets[band+1] ;index++)
{
ADD(1); FUNC(3); STORE(1);
pSpectralCoefficient[window*MaximumBinsShort+index] = CBlock_Quantize(QuantizedCoef[window*MaximumBinsShort+index],scfMod,scfExp-6);
}
}
PTR_INIT(1); /* pointer for pSpectralCoefficient */
LOOP(1);
for (; index < MaximumBinsShort; index++) {
MOVE(1);
pSpectralCoefficient[window*MaximumBinsShort+index] = 0.0;
}
}
}
COUNT_sub_end();
return (AAC_DEC_OK);
}
void CShortBlock_ReadScaleFactorData(HANDLE_BIT_BUF bs,
CAacDecoderChannelInfo *pAacDecoderChannelInfo,
unsigned char global_gain)
{
int temp;
int band;
int group;
int position = 0;
int factor = global_gain;
char *pCodeBook = pAacDecoderChannelInfo->pCodeBook;
short *pScaleFactor = pAacDecoderChannelInfo->pScaleFactor;
const CodeBookDescription *hcb = &HuffmanCodeBooks[BOOKSCL];
COUNT_sub_start("CShortBlock_ReadScaleFactorData");
INDIRECT(3); PTR_INIT(3); MOVE(2); /* counting previous operations */
INDIRECT(1); PTR_INIT(1); FUNC(1); LOOP(1);
for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++)
{
PTR_INIT(2); /* pCodeBook[]
pScaleFactor[]
*/
for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++)
{
BRANCH(2);
switch (pCodeBook[group*MaximumScaleFactorBandsShort+band])
{
case ZERO_HCB: /* zero book */
MOVE(1);
pScaleFactor[group*MaximumScaleFactorBandsShort+band] = 0;
break;
default: /* decode scale factor */
INDIRECT(1); FUNC(2);
temp = CBlock_DecodeHuffmanWord(bs,hcb->CodeBook);
ADD(2);
factor += temp - 60; /* MIDFAC 1.5 dB */
ADD(1); STORE(1);
pScaleFactor[group*MaximumScaleFactorBandsShort+band] = factor - 100;
break;
case INTENSITY_HCB: /* intensity steering */
case INTENSITY_HCB2:
INDIRECT(1); FUNC(2);
temp = CBlock_DecodeHuffmanWord(bs,hcb->CodeBook);
ADD(2);
position += temp - 60;
ADD(1); STORE(1);
pScaleFactor[group*MaximumScaleFactorBandsShort+band] = position - 100;
break;
case NOISE_HCB: /* PNS */
FUNC(5);
CPns_Read(pAacDecoderChannelInfo, bs, hcb, global_gain, band, group);
break;
}
}
}
COUNT_sub_end();
}
int CJointStereo_Read(HANDLE_FDK_BITSTREAM bs,
CJointStereoData *pJointStereoData,
const int windowGroups,
const int scaleFactorBandsTransmitted,
const int max_sfb_ste_clear,
CJointStereoPersistentData *pJointStereoPersistentData,
CCplxPredictionData *cplxPredictionData,
int cplxPredictionActiv, int scaleFactorBandsTotal,
int windowSequence, const UINT flags) {
int group, band;
pJointStereoData->MsMaskPresent = (UCHAR)FDKreadBits(bs, 2);
FDKmemclear(pJointStereoData->MsUsed,
scaleFactorBandsTransmitted * sizeof(UCHAR));
pJointStereoData->cplx_pred_flag = 0;
if (cplxPredictionActiv) {
cplxPredictionData->pred_dir = 0;
cplxPredictionData->complex_coef = 0;
cplxPredictionData->use_prev_frame = 0;
cplxPredictionData->igf_pred_dir = 0;
}
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;
case 3:
/* M/S coding is disabled, complex stereo prediction is enabled */
if (flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) {
if (cplxPredictionActiv) { /* 'if (stereoConfigIndex == 0)' */
pJointStereoData->cplx_pred_flag = 1;
/* cplx_pred_data() cp. ISO/IEC FDIS 23003-3:2011(E) Table 26 */
int cplx_pred_all = 0; /* local use only */
cplx_pred_all = FDKreadBits(bs, 1);
if (cplx_pred_all) {
for (group = 0; group < windowGroups; group++) {
UCHAR groupmask = ((UCHAR)1 << group);
for (band = 0; band < scaleFactorBandsTransmitted; band++) {
pJointStereoData->MsUsed[band] |= groupmask;
}
}
} else {
for (group = 0; group < windowGroups; group++) {
for (band = 0; band < scaleFactorBandsTransmitted;
band += SFB_PER_PRED_BAND) {
pJointStereoData->MsUsed[band] |= (FDKreadBits(bs, 1) << group);
if ((band + 1) < scaleFactorBandsTotal) {
pJointStereoData->MsUsed[band + 1] |=
(pJointStereoData->MsUsed[band] & ((UCHAR)1 << group));
}
}
}
}
} else {
return -1;
}
}
break;
}
if (cplxPredictionActiv) {
/* If all sfb are MS-ed then no complex prediction */
if (pJointStereoData->MsMaskPresent == 3) {
if (pJointStereoData->cplx_pred_flag) {
int delta_code_time = 0;
/* set pointer to Huffman codebooks */
const CodeBookDescription *hcb = &AACcodeBookDescriptionTable[BOOKSCL];
/* set predictors to zero in case of a transition from long to short
* window sequences and vice versa */
if (((windowSequence == BLOCK_SHORT) &&
(pJointStereoPersistentData->winSeqPrev != BLOCK_SHORT)) ||
((pJointStereoPersistentData->winSeqPrev == BLOCK_SHORT) &&
(windowSequence != BLOCK_SHORT))) {
FDKmemclear(pJointStereoPersistentData->alpha_q_re_prev,
JointStereoMaximumGroups * JointStereoMaximumBands *
sizeof(SHORT));
FDKmemclear(pJointStereoPersistentData->alpha_q_im_prev,
JointStereoMaximumGroups * JointStereoMaximumBands *
sizeof(SHORT));
}
{
FDKmemclear(cplxPredictionData->alpha_q_re,
JointStereoMaximumGroups * JointStereoMaximumBands *
sizeof(SHORT));
FDKmemclear(cplxPredictionData->alpha_q_im,
JointStereoMaximumGroups * JointStereoMaximumBands *
sizeof(SHORT));
}
/* 0 = mid->side prediction, 1 = side->mid prediction */
cplxPredictionData->pred_dir = FDKreadBits(bs, 1);
cplxPredictionData->complex_coef = FDKreadBits(bs, 1);
if (cplxPredictionData->complex_coef) {
if (flags & AC_INDEP) {
cplxPredictionData->use_prev_frame = 0;
} else {
cplxPredictionData->use_prev_frame = FDKreadBits(bs, 1);
}
}
if (flags & AC_INDEP) {
delta_code_time = 0;
} else {
delta_code_time = FDKreadBits(bs, 1);
}
{
int last_alpha_q_re = 0, last_alpha_q_im = 0;
for (group = 0; group < windowGroups; group++) {
for (band = 0; band < scaleFactorBandsTransmitted;
band += SFB_PER_PRED_BAND) {
if (delta_code_time == 1) {
if (group > 0) {
last_alpha_q_re =
cplxPredictionData->alpha_q_re[group - 1][band];
last_alpha_q_im =
cplxPredictionData->alpha_q_im[group - 1][band];
} else if ((windowSequence == BLOCK_SHORT) &&
(pJointStereoPersistentData->winSeqPrev ==
BLOCK_SHORT)) {
/* Included for error-robustness */
if (pJointStereoPersistentData->winGroupsPrev == 0) return -1;
last_alpha_q_re =
pJointStereoPersistentData->alpha_q_re_prev
[pJointStereoPersistentData->winGroupsPrev - 1][band];
last_alpha_q_im =
pJointStereoPersistentData->alpha_q_im_prev
[pJointStereoPersistentData->winGroupsPrev - 1][band];
} else {
last_alpha_q_re =
pJointStereoPersistentData->alpha_q_re_prev[group][band];
last_alpha_q_im =
pJointStereoPersistentData->alpha_q_im_prev[group][band];
}
} else {
if (band > 0) {
last_alpha_q_re =
cplxPredictionData->alpha_q_re[group][band - 1];
last_alpha_q_im =
cplxPredictionData->alpha_q_im[group][band - 1];
} else {
last_alpha_q_re = 0;
last_alpha_q_im = 0;
}
} /* if (delta_code_time == 1) */
if (pJointStereoData->MsUsed[band] & ((UCHAR)1 << group)) {
int dpcm_alpha_re, dpcm_alpha_im;
dpcm_alpha_re = CBlock_DecodeHuffmanWord(bs, hcb);
dpcm_alpha_re -= 60;
dpcm_alpha_re *= -1;
cplxPredictionData->alpha_q_re[group][band] =
dpcm_alpha_re + last_alpha_q_re;
if (cplxPredictionData->complex_coef) {
dpcm_alpha_im = CBlock_DecodeHuffmanWord(bs, hcb);
dpcm_alpha_im -= 60;
dpcm_alpha_im *= -1;
cplxPredictionData->alpha_q_im[group][band] =
dpcm_alpha_im + last_alpha_q_im;
} else {
cplxPredictionData->alpha_q_im[group][band] = 0;
}
} else {
cplxPredictionData->alpha_q_re[group][band] = 0;
cplxPredictionData->alpha_q_im[group][band] = 0;
} /* if (pJointStereoData->MsUsed[band] & ((UCHAR)1 << group)) */
if ((band + 1) <
scaleFactorBandsTransmitted) { /* <= this should be the
correct way (cp.
ISO_IEC_FDIS_23003-0(E) */
/* 7.7.2.3.2 Decoding of prediction coefficients) */
cplxPredictionData->alpha_q_re[group][band + 1] =
cplxPredictionData->alpha_q_re[group][band];
cplxPredictionData->alpha_q_im[group][band + 1] =
cplxPredictionData->alpha_q_im[group][band];
} /* if ((band+1)<scaleFactorBandsTotal) */
pJointStereoPersistentData->alpha_q_re_prev[group][band] =
cplxPredictionData->alpha_q_re[group][band];
pJointStereoPersistentData->alpha_q_im_prev[group][band] =
cplxPredictionData->alpha_q_im[group][band];
}
for (band = scaleFactorBandsTransmitted; band < max_sfb_ste_clear;
band++) {
cplxPredictionData->alpha_q_re[group][band] = 0;
cplxPredictionData->alpha_q_im[group][band] = 0;
pJointStereoPersistentData->alpha_q_re_prev[group][band] = 0;
pJointStereoPersistentData->alpha_q_im_prev[group][band] = 0;
}
}
}
}
} else {
for (group = 0; group < windowGroups; group++) {
for (band = 0; band < max_sfb_ste_clear; band++) {
pJointStereoPersistentData->alpha_q_re_prev[group][band] = 0;
pJointStereoPersistentData->alpha_q_im_prev[group][band] = 0;
}
}
}
pJointStereoPersistentData->winGroupsPrev = windowGroups;
}
return 0;
}
