static int huffspec(faacDecHandle hDecoder, Info *info, int nsect, byte *sect,
int *factors, Float *coef)
{
Hcb *hcb;
Huffman *hcw;
int i, j, k, table, step, stop, bottom, top;
int *bands, *bandp;
int *quant, *qp;
int *tmp_spec;
int *quantPtr;
int *tmp_specPtr;
quant = AllocMemory(LN2*sizeof(int));
tmp_spec = AllocMemory(LN2*sizeof(int));
quantPtr = quant;
tmp_specPtr = tmp_spec;
#ifndef _WIN32
SetMemory(quant, 0, LN2*sizeof(int));
#endif
bands = info->bk_sfb_top;
bottom = 0;
k = 0;
bandp = bands;
for(i = nsect; i; i--) {
table = sect[0];
top = sect[1];
sect += 2;
if( (table == 0) || (table == NOISE_HCB) ||
(table == INTENSITY_HCB) || (table == INTENSITY_HCB2) ) {
bandp = bands+top;
k = bandp[-1];
bottom = top;
continue;
}
if(table < BY4BOOKS+1) {
step = 4;
} else {
step = 2;
}
hcb = &book[table];
hcw = hcb->hcw;
qp = quant+k;
for(j = bottom; j < top; j++) {
stop = *bandp++;
while(k < stop) {
decode_huff_cw(hDecoder, hcw, qp, hcb);
if (!hcb->signed_cb)
get_sign_bits(hDecoder, qp, step);
if(table == ESCBOOK){
qp[0] = getescape(hDecoder, qp[0]);
qp[1] = getescape(hDecoder, qp[1]);
}
qp += step;
k += step;
}
}
bottom = top;
}
/* pulse coding reconstruction */
if ((info->islong) && (hDecoder->pulse_info.pulse_data_present))
pulse_nc(hDecoder, quant, &hDecoder->pulse_info);
if (!info->islong) {
deinterleave (quant,tmp_spec,
(short)info->num_groups,
info->group_len,
info->sfb_per_sbk,
info->sfb_width_128);
for (i = LN2/16 - 1; i >= 0; --i)
{
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
*quantPtr++ = *tmp_specPtr++; *quantPtr++ = *tmp_specPtr++;
}
}
/* inverse quantization */
for (i=0; i<info->bins_per_bk; i++) {
coef[i] = esc_iquant(hDecoder, quant[i]);
}
/* rescaling */
{
int sbk, nsbk, sfb, nsfb, fac, top;
Float *fp, scale;
i = 0;
fp = coef;
nsbk = info->nsbk;
for (sbk=0; sbk<nsbk; sbk++) {
nsfb = info->sfb_per_sbk[sbk];
k=0;
for (sfb=0; sfb<nsfb; sfb++) {
top = info->sbk_sfb_top[sbk][sfb];
fac = factors[i++]-SF_OFFSET;
if (fac >= 0 && fac < TEXP) {
scale = hDecoder->exptable[fac];
}
else {
if (fac == -SF_OFFSET) {
scale = 0;
}
else {
scale = (float)pow(2.0, 0.25*fac);
}
}
for ( ; k<top; k++) {
*fp++ *= scale;
}
}
}
}
if (quant) FreeMemory(quant);
if (tmp_spec) FreeMemory(tmp_spec);
return 1;
}
/*!
\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));
}
