545 files changed, 230976 insertions, 0 deletions

diff --git a/audio_codec/libraac/noiseless.c b/audio_codec/libraac/noiseless.c
new file mode 100644
index 0000000..f782f39
--- a/dev/null
+++ b/audio_codec/libraac/noiseless.c
@@ -0,0 +1,503 @@
+/* ***** 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 <core/dsp.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 void 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);
+    }
+}
+
+/**************************************************************************************
+ * 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 void DecodeICS(PSInfoBase *psi, BitStreamInfo *bsi, int ch)
+{
+    int globalGain;
+    ICSInfo *icsInfo;
+    PulseInfo *pi;
+    TNSInfo *ti;
+    GainControlInfo *gi;
+
+    icsInfo = (ch == 1 && psi->commonWin == 1) ? &(psi->icsInfo[0]) : &(psi->icsInfo[ch]);
+
+    globalGain = GetBits(bsi, 8);
+    if (!psi->commonWin) {
+        DecodeICSInfo(bsi, icsInfo, psi->sampRateIdx);
+    }
+
+    DecodeSectionData(bsi, icsInfo->winSequence, icsInfo->numWinGroup, icsInfo->maxSFB, psi->sfbCodeBook[ch]);
+
+    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) {
+        DecodeGainControlInfo(bsi, icsInfo->winSequence, gi);
+    }
+}
+
+/**************************************************************************************
+ * 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;
+
+    /* 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;
+        }
+    }
+
+    DecodeICS(psi, &bsi, ch);
+
+    if (icsInfo->winSequence == 2) {
+        DecodeSpectrumShort(psi, &bsi, ch);
+    } else {
+        DecodeSpectrumLong(psi, &bsi, ch);
+    }
+
+    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;
+}