mirror of
https://github.com/sle118/squeezelite-esp32.git
synced 2025-12-09 13:07:03 +03:00
big merge
This commit is contained in:
Philippe G
484
components/spotify/cspot/bell/libhelix-aac/noiseless.c
Normal file
484
components/spotify/cspot/bell/libhelix-aac/noiseless.c
Normal file
@@ -0,0 +1,484 @@
|
||||
/* ***** 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;
|
||||
}
|
||||
Reference in New Issue
Block a user