545 files changed, 230976 insertions, 0 deletions
diff --git a/audio_codec/libfaad/helixaac/noiseless.c b/audio_codec/libfaad/helixaac/noiseless.c new file mode 100644 index 0000000..e519e9d --- a/dev/null +++ b/audio_codec/libfaad/helixaac/noiseless.c @@ -0,0 +1,513 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Source last modified: $Id: noiseless.c,v 1.1 2005/02/26 01:47:35 jrecker Exp $ + * + * Portions Copyright (c) 1995-2005 RealNetworks, Inc. All Rights Reserved. + * + * The contents of this file, and the files included with this file, + * are subject to the current version of the RealNetworks Public + * Source License (the "RPSL") available at + * http://www.helixcommunity.org/content/rpsl unless you have licensed + * the file under the current version of the RealNetworks Community + * Source License (the "RCSL") available at + * http://www.helixcommunity.org/content/rcsl, in which case the RCSL + * will apply. You may also obtain the license terms directly from + * RealNetworks. You may not use this file except in compliance with + * the RPSL or, if you have a valid RCSL with RealNetworks applicable + * to this file, the RCSL. Please see the applicable RPSL or RCSL for + * the rights, obligations and limitations governing use of the + * contents of the file. + * + * This file is part of the Helix DNA Technology. RealNetworks is the + * developer of the Original Code and owns the copyrights in the + * portions it created. + * + * This file, and the files included with this file, is distributed + * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY + * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS + * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET + * ENJOYMENT OR NON-INFRINGEMENT. + * + * Technology Compatibility Kit Test Suite(s) Location: + * http://www.helixcommunity.org/content/tck + * + * Contributor(s): + * + * ***** END LICENSE BLOCK ***** */ + +/************************************************************************************** + * Fixed-point HE-AAC decoder + * Jon Recker (jrecker@real.com) + * February 2005 + * + * noiseless.c - decode channel info, scalefactors, quantized coefficients, + * scalefactor band codebook, and TNS coefficients from bitstream + **************************************************************************************/ + +#include "coder.h" +#include <stdio.h> + + +/************************************************************************************** + * Function: DecodeICSInfo + * + * Description: decode individual channel stream info + * + * Inputs: BitStreamInfo struct pointing to start of ICS info + * (14496-3, table 4.4.6) + * sample rate index + * + * Outputs: updated icsInfo struct + * + * Return: none + **************************************************************************************/ +void DecodeICSInfo(BitStreamInfo *bsi, ICSInfo *icsInfo, int sampRateIdx) +{ + int sfb, g, mask; + + icsInfo->icsResBit = GetBits(bsi, 1); + icsInfo->winSequence = GetBits(bsi, 2); + icsInfo->winShape = GetBits(bsi, 1); + if (icsInfo->winSequence == 2) { + /* short block */ + icsInfo->maxSFB = GetBits(bsi, 4); + icsInfo->sfGroup = GetBits(bsi, 7); + icsInfo->numWinGroup = 1; + icsInfo->winGroupLen[0] = 1; + mask = 0x40; /* start with bit 6 */ + for (g = 0; g < 7; g++) { + if (icsInfo->sfGroup & mask) { + icsInfo->winGroupLen[icsInfo->numWinGroup - 1]++; + } else { + icsInfo->numWinGroup++; + icsInfo->winGroupLen[icsInfo->numWinGroup - 1] = 1; + } + mask >>= 1; + } + } else { + /* long block */ + icsInfo->maxSFB = GetBits(bsi, 6); + icsInfo->predictorDataPresent = GetBits(bsi, 1); + if (icsInfo->predictorDataPresent) { + icsInfo->predictorReset = GetBits(bsi, 1); + if (icsInfo->predictorReset) { + icsInfo->predictorResetGroupNum = GetBits(bsi, 5); + } + for (sfb = 0; sfb < MIN(icsInfo->maxSFB, predSFBMax[sampRateIdx]); sfb++) { + icsInfo->predictionUsed[sfb] = GetBits(bsi, 1); + } + } + icsInfo->numWinGroup = 1; + icsInfo->winGroupLen[0] = 1; + } +} + +/************************************************************************************** + * Function: DecodeSectionData + * + * Description: decode section data (scale factor band groupings and + * associated Huffman codebooks) + * + * Inputs: BitStreamInfo struct pointing to start of ICS info + * (14496-3, table 4.4.25) + * window sequence (short or long blocks) + * number of window groups (1 for long blocks, 1-8 for short blocks) + * max coded scalefactor band + * + * Outputs: index of Huffman codebook for each scalefactor band in each section + * + * Return: none + * + * Notes: sectCB, sectEnd, sfbCodeBook, ordered by window groups for short blocks + **************************************************************************************/ +static int DecodeSectionData(BitStreamInfo *bsi, int winSequence, int numWinGrp, int maxSFB, unsigned char *sfbCodeBook) +{ + int g, cb, sfb; + int sectLen, sectLenBits, sectLenIncr, sectEscapeVal; + + sectLenBits = (winSequence == 2 ? 3 : 5); + sectEscapeVal = (1 << sectLenBits) - 1; + + for (g = 0; g < numWinGrp; g++) { + sfb = 0; + while (sfb < maxSFB) { + cb = GetBits(bsi, 4); /* next section codebook */ + sectLen = 0; + do { + sectLenIncr = GetBits(bsi, sectLenBits); + sectLen += sectLenIncr; + } while (sectLenIncr == sectEscapeVal); + + sfb += sectLen; + while (sectLen--) { + *sfbCodeBook++ = (unsigned char)cb; + } + } + ASSERT(sfb == maxSFB, ERR_AAC_HUFFMAN_DECODING); + } + return ERR_AAC_NONE; +} + +/************************************************************************************** + * Function: DecodeOneScaleFactor + * + * Description: decode one scalefactor using scalefactor Huffman codebook + * + * Inputs: BitStreamInfo struct pointing to start of next coded scalefactor + * + * Outputs: updated BitstreamInfo struct + * + * Return: one decoded scalefactor, including index_offset of -60 + **************************************************************************************/ +static int DecodeOneScaleFactor(BitStreamInfo *bsi) +{ + int nBits, val; + unsigned int bitBuf; + + /* decode next scalefactor from bitstream */ + bitBuf = GetBitsNoAdvance(bsi, huffTabScaleFactInfo.maxBits) << (32 - huffTabScaleFactInfo.maxBits); + nBits = DecodeHuffmanScalar(huffTabScaleFact, &huffTabScaleFactInfo, bitBuf, &val); + AdvanceBitstream(bsi, nBits); + + return val; +} + +/************************************************************************************** + * Function: DecodeScaleFactors + * + * Description: decode scalefactors, PNS energy, and intensity stereo weights + * + * Inputs: BitStreamInfo struct pointing to start of ICS info + * (14496-3, table 4.4.26) + * number of window groups (1 for long blocks, 1-8 for short blocks) + * max coded scalefactor band + * global gain (starting value for differential scalefactor coding) + * index of Huffman codebook for each scalefactor band in each section + * + * Outputs: decoded scalefactor for each section + * + * Return: none + * + * Notes: sfbCodeBook, scaleFactors ordered by window groups for short blocks + * for section with codebook 13, scaleFactors buffer has decoded PNS + * energy instead of regular scalefactor + * for section with codebook 14 or 15, scaleFactors buffer has intensity + * stereo weight instead of regular scalefactor + **************************************************************************************/ +static void DecodeScaleFactors(BitStreamInfo *bsi, int numWinGrp, int maxSFB, int globalGain, + unsigned char *sfbCodeBook, short *scaleFactors) +{ + int g, sfbCB, nrg, npf, val, sf, is; + + /* starting values for differential coding */ + sf = globalGain; + is = 0; + nrg = globalGain - 90 - 256; + npf = 1; + + for (g = 0; g < numWinGrp * maxSFB; g++) { + sfbCB = *sfbCodeBook++; + + if (sfbCB == 14 || sfbCB == 15) { + /* intensity stereo - differential coding */ + val = DecodeOneScaleFactor(bsi); + is += val; + *scaleFactors++ = (short)is; + } else if (sfbCB == 13) { + /* PNS - first energy is directly coded, rest are Huffman coded (npf = noise_pcm_flag) */ + if (npf) { + val = GetBits(bsi, 9); + npf = 0; + } else { + val = DecodeOneScaleFactor(bsi); + } + nrg += val; + *scaleFactors++ = (short)nrg; + } else if (sfbCB >= 1 && sfbCB <= 11) { + /* regular (non-zero) region - differential coding */ + val = DecodeOneScaleFactor(bsi); + sf += val; + *scaleFactors++ = (short)sf; + } else { + /* inactive scalefactor band if codebook 0 */ + *scaleFactors++ = 0; + } + } +} + +/************************************************************************************** + * Function: DecodePulseInfo + * + * Description: decode pulse information + * + * Inputs: BitStreamInfo struct pointing to start of pulse info + * (14496-3, table 4.4.7) + * + * Outputs: updated PulseInfo struct + * + * Return: none + **************************************************************************************/ +static void DecodePulseInfo(BitStreamInfo *bsi, PulseInfo *pi) +{ + int i; + + pi->numPulse = GetBits(bsi, 2) + 1; /* add 1 here */ + pi->startSFB = GetBits(bsi, 6); + for (i = 0; i < pi->numPulse; i++) { + pi->offset[i] = GetBits(bsi, 5); + pi->amp[i] = GetBits(bsi, 4); + } +} + +/************************************************************************************** + * Function: DecodeTNSInfo + * + * Description: decode TNS filter information + * + * Inputs: BitStreamInfo struct pointing to start of TNS info + * (14496-3, table 4.4.27) + * window sequence (short or long blocks) + * + * Outputs: updated TNSInfo struct + * buffer of decoded (signed) TNS filter coefficients + * + * Return: none + **************************************************************************************/ +static void DecodeTNSInfo(BitStreamInfo *bsi, int winSequence, TNSInfo *ti, signed char *tnsCoef) +{ + int i, w, f, coefBits, compress; + signed char c, s, n; + signed char sgnMask[3] = { 0x02, 0x04, 0x08}; + signed char negMask[3] = {~0x03, ~0x07, ~0x0f}; + unsigned char *filtLength, *filtOrder, *filtDir; + + filtLength = ti->length; + filtOrder = ti->order; + filtDir = ti->dir; + + if (winSequence == 2) { + /* short blocks */ + for (w = 0; w < NWINDOWS_SHORT; w++) { + ti->numFilt[w] = GetBits(bsi, 1); + if (ti->numFilt[w]) { + ti->coefRes[w] = GetBits(bsi, 1) + 3; + *filtLength = GetBits(bsi, 4); + *filtOrder = GetBits(bsi, 3); + if (*filtOrder) { + *filtDir++ = GetBits(bsi, 1); + compress = GetBits(bsi, 1); + coefBits = (int)ti->coefRes[w] - compress; /* 2, 3, or 4 */ + s = sgnMask[coefBits - 2]; + n = negMask[coefBits - 2]; + for (i = 0; i < *filtOrder; i++) { + c = GetBits(bsi, coefBits); + if (c & s) { + c |= n; + } + *tnsCoef++ = c; + } + } + filtLength++; + filtOrder++; + } + } + } else { + /* long blocks */ + ti->numFilt[0] = GetBits(bsi, 2); + if (ti->numFilt[0]) { + ti->coefRes[0] = GetBits(bsi, 1) + 3; + } + for (f = 0; f < ti->numFilt[0]; f++) { + *filtLength = GetBits(bsi, 6); + *filtOrder = GetBits(bsi, 5); + if (*filtOrder) { + *filtDir++ = GetBits(bsi, 1); + compress = GetBits(bsi, 1); + coefBits = (int)ti->coefRes[0] - compress; /* 2, 3, or 4 */ + s = sgnMask[coefBits - 2]; + n = negMask[coefBits - 2]; + for (i = 0; i < *filtOrder; i++) { + c = GetBits(bsi, coefBits); + if (c & s) { + c |= n; + } + *tnsCoef++ = c; + } + } + filtLength++; + filtOrder++; + } + } +} + +/* bitstream field lengths for gain control data: + * gainBits[winSequence][0] = maxWindow (how many gain windows there are) + * gainBits[winSequence][1] = locBitsZero (bits for alocCode if window == 0) + * gainBits[winSequence][2] = locBits (bits for alocCode if window != 0) + */ +static const unsigned char gainBits[4][3] = { + {1, 5, 5}, /* long */ + {2, 4, 2}, /* start */ + {8, 2, 2}, /* short */ + {2, 4, 5}, /* stop */ +}; + +/************************************************************************************** + * Function: DecodeGainControlInfo + * + * Description: decode gain control information (SSR profile only) + * + * Inputs: BitStreamInfo struct pointing to start of gain control info + * (14496-3, table 4.4.12) + * window sequence (short or long blocks) + * + * Outputs: updated GainControlInfo struct + * + * Return: none + **************************************************************************************/ +static void DecodeGainControlInfo(BitStreamInfo *bsi, int winSequence, GainControlInfo *gi) +{ + int bd, wd, ad; + int locBits, locBitsZero, maxWin; + + gi->maxBand = GetBits(bsi, 2); + maxWin = (int)gainBits[winSequence][0]; + locBitsZero = (int)gainBits[winSequence][1]; + locBits = (int)gainBits[winSequence][2]; + + for (bd = 1; bd <= gi->maxBand; bd++) { + for (wd = 0; wd < maxWin; wd++) { + gi->adjNum[bd][wd] = GetBits(bsi, 3); + for (ad = 0; ad < gi->adjNum[bd][wd]; ad++) { + gi->alevCode[bd][wd][ad] = GetBits(bsi, 4); + gi->alocCode[bd][wd][ad] = GetBits(bsi, (wd == 0 ? locBitsZero : locBits)); + } + } + } +} + +/************************************************************************************** + * Function: DecodeICS + * + * Description: decode individual channel stream + * + * Inputs: platform specific info struct + * BitStreamInfo struct pointing to start of individual channel stream + * (14496-3, table 4.4.24) + * index of current channel + * + * Outputs: updated section data, scale factor data, pulse data, TNS data, + * and gain control data + * + * Return: none + **************************************************************************************/ +static int DecodeICS(PSInfoBase *psi, BitStreamInfo *bsi, int ch) +{ + int globalGain; + ICSInfo *icsInfo; + PulseInfo *pi; + TNSInfo *ti; + GainControlInfo *gi; + int err = ERR_AAC_NONE; + + icsInfo = (ch == 1 && psi->commonWin == 1) ? &(psi->icsInfo[0]) : &(psi->icsInfo[ch]); + + globalGain = GetBits(bsi, 8); + if (!psi->commonWin) { + DecodeICSInfo(bsi, icsInfo, psi->sampRateIdx); + } + + err = DecodeSectionData(bsi, icsInfo->winSequence, icsInfo->numWinGroup, icsInfo->maxSFB, psi->sfbCodeBook[ch]); + if (err) { + return err; + } + DecodeScaleFactors(bsi, icsInfo->numWinGroup, icsInfo->maxSFB, globalGain, psi->sfbCodeBook[ch], psi->scaleFactors[ch]); + + pi = &psi->pulseInfo[ch]; + pi->pulseDataPresent = GetBits(bsi, 1); + if (pi->pulseDataPresent) { + DecodePulseInfo(bsi, pi); + } + + ti = &psi->tnsInfo[ch]; + ti->tnsDataPresent = GetBits(bsi, 1); + if (ti->tnsDataPresent) { + DecodeTNSInfo(bsi, icsInfo->winSequence, ti, ti->coef); + } + + gi = &psi->gainControlInfo[ch]; + gi->gainControlDataPresent = GetBits(bsi, 1); + if (gi->gainControlDataPresent) { + /* disable SSR, as we can decode out this part */ + return ERR_AAC_SSR_GAIN_NOT_ADDED; + DecodeGainControlInfo(bsi, icsInfo->winSequence, gi); + } + return err; +} + +/************************************************************************************** + * Function: DecodeNoiselessData + * + * Description: decode noiseless data (side info and transform coefficients) + * + * Inputs: valid AACDecInfo struct + * double pointer to buffer pointing to start of individual channel stream + * (14496-3, table 4.4.24) + * pointer to bit offset + * pointer to number of valid bits remaining in buf + * index of current channel + * + * Outputs: updated global gain, section data, scale factor data, pulse data, + * TNS data, gain control data, and spectral data + * + * Return: 0 if successful, error code (< 0) if error + **************************************************************************************/ +int DecodeNoiselessData(AACDecInfo *aacDecInfo, unsigned char **buf, int *bitOffset, int *bitsAvail, int ch) +{ + int bitsUsed; + BitStreamInfo bsi; + PSInfoBase *psi; + ICSInfo *icsInfo; + int err = 0; + /* validate pointers */ + if (!aacDecInfo || !aacDecInfo->psInfoBase) { + return ERR_AAC_NULL_POINTER; + } + psi = (PSInfoBase *)(aacDecInfo->psInfoBase); + icsInfo = (ch == 1 && psi->commonWin == 1) ? &(psi->icsInfo[0]) : &(psi->icsInfo[ch]); + + if (AACDataSource == 1) { + SetBitstreamPointer(&bsi, (*bitsAvail + 7) >> 3, *buf); + GetBits(&bsi, *bitOffset); + } else { + if (((*bitsAvail + 7) >> 3) < 0) { + return ERR_AAC_INDATA_UNDERFLOW; + } + } + + err = DecodeICS(psi, &bsi, ch); + if (err) { + return err; + } + if (icsInfo->winSequence == 2) { + err = DecodeSpectrumShort(psi, &bsi, ch); + } else { + err = DecodeSpectrumLong(psi, &bsi, ch); + } + if (err) { + return err; + } + if (AACDataSource == 1) { + bitsUsed = CalcBitsUsed(&bsi, *buf, *bitOffset); + *buf += ((bitsUsed + *bitOffset) >> 3); + *bitOffset = ((bitsUsed + *bitOffset) & 0x07); + *bitsAvail -= bitsUsed; + if (*bitsAvail < 0) { + return ERR_AAC_INDATA_UNDERFLOW; + } + } + aacDecInfo->sbDeinterleaveReqd[ch] = 0; + aacDecInfo->tnsUsed |= psi->tnsInfo[ch].tnsDataPresent; /* set flag if TNS used for any channel */ + + return ERR_AAC_NONE; +} |