mirror of
https://github.com/sle118/squeezelite-esp32.git
synced 2025-12-09 04:57:06 +03:00
485 lines
16 KiB
C
485 lines
16 KiB
C
/* ***** 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 "profile.h"
|
|
|
|
//#define PROFILE_START(x)
|
|
//#define PROFILE_END()
|
|
|
|
/**************************************************************************************
|
|
* 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
|
|
**************************************************************************************/
|
|
/* __attribute__ ((section (".data"))) */ 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
|
|
**************************************************************************************/
|
|
/* __attribute__ ((section (".data"))) */ 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);
|
|
//PROFILE_START("DecodeHuffmanScalar");
|
|
nBits = DecodeHuffmanScalar(huffTabScaleFact, &huffTabScaleFactInfo, bitBuf, &val);
|
|
AdvanceBitstream(bsi, nBits);
|
|
//PROFILE_END();
|
|
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
|
|
**************************************************************************************/
|
|
/* __attribute__ ((section (".data"))) */ 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
|
|
**************************************************************************************/
|
|
/* __attribute__ ((section (".data"))) */ 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 const signed char sgnMask[3] = {0x02, 0x04, 0x08};
|
|
static const signed char negMask[3] = {~0x03, ~0x07, ~0x0f};
|
|
|
|
static void DecodeTNSInfo(BitStreamInfo *bsi, int winSequence, TNSInfo *ti, signed char *tnsCoef)
|
|
{
|
|
int i, w, f, coefBits, compress;
|
|
signed char c, s, n;
|
|
|
|
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]);
|
|
|
|
SetBitstreamPointer(&bsi, (*bitsAvail+7) >> 3, *buf);
|
|
GetBits(&bsi, *bitOffset);
|
|
|
|
DecodeICS(psi, &bsi, ch);
|
|
|
|
if (icsInfo->winSequence == 2)
|
|
DecodeSpectrumShort(psi, &bsi, ch);
|
|
else
|
|
DecodeSpectrumLong(psi, &bsi, ch);
|
|
|
|
bitsUsed = CalcBitsUsed(&bsi, *buf, *bitOffset);
|
|
*buf += ((bitsUsed + *bitOffset) >> 3);
|
|
*bitOffset = ((bitsUsed + *bitOffset) & 0x07);
|
|
*bitsAvail -= bitsUsed;
|
|
|
|
aacDecInfo->sbDeinterleaveReqd[ch] = 0;
|
|
aacDecInfo->tnsUsed |= psi->tnsInfo[ch].tnsDataPresent; /* set flag if TNS used for any channel */
|
|
|
|
return ERR_AAC_NONE;
|
|
}
|