/*!
\brief FDKaacEnc_ScaleUpSpectrum
Scales up spectrum lines in a given frequency section
\param scaled spectrum
\param original spectrum
\param frequency line to start scaling
\param frequency line to enc scaling
\return scale factor
****************************************************************************/
static inline INT FDKaacEnc_ScaleUpSpectrum(
FIXP_DBL *dest,
const FIXP_DBL *src,
const INT startLine,
const INT stopLine
)
{
INT i, scale;
FIXP_DBL maxVal = FL2FXCONST_DBL(0.f);
/* Get highest value in given spectrum */
for (i=startLine; i<stopLine; i++) {
maxVal = fixMax(maxVal,fixp_abs(src[i]));
}
scale = CountLeadingBits(maxVal);
/* Scale spectrum according to highest value */
for (i=startLine; i<stopLine; i++) {
dest[i] = src[i]<<scale;
}
return scale;
}
/*****************************************************************************
functionname: writeEnvelopeData
description: writes bits corresponding to the envelope
returns: number of bits written
input:
output:
*****************************************************************************/
static INT writeEnvelopeData(HANDLE_SBR_ENV_DATA sbrEnvData,
HANDLE_FDK_BITSTREAM hBitStream, INT coupling) {
INT payloadBits = 0, j, i, delta;
for (j = 0; j < sbrEnvData->noOfEnvelopes;
j++) { /* loop over all envelopes */
if (sbrEnvData->domain_vec[j] == FREQ) {
if (coupling && sbrEnvData->balance) {
payloadBits += FDKwriteBits(hBitStream, sbrEnvData->ienvelope[j][0],
sbrEnvData->si_sbr_start_env_bits_balance);
} else {
payloadBits += FDKwriteBits(hBitStream, sbrEnvData->ienvelope[j][0],
sbrEnvData->si_sbr_start_env_bits);
}
}
for (i = 1 - sbrEnvData->domain_vec[j]; i < sbrEnvData->noScfBands[j];
i++) {
delta = sbrEnvData->ienvelope[j][i];
if (coupling && sbrEnvData->balance) {
FDK_ASSERT(fixp_abs(delta) <= sbrEnvData->codeBookScfLavBalance);
} else {
FDK_ASSERT(fixp_abs(delta) <= sbrEnvData->codeBookScfLav);
}
if (coupling) {
if (sbrEnvData->balance) {
if (sbrEnvData->domain_vec[j]) {
/* coupling && balance && TIME */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData
->hufftableBalanceTimeC[delta +
sbrEnvData->codeBookScfLavBalance],
sbrEnvData
->hufftableBalanceTimeL[delta +
sbrEnvData->codeBookScfLavBalance]);
} else {
/* coupling && balance && FREQ */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData
->hufftableBalanceFreqC[delta +
sbrEnvData->codeBookScfLavBalance],
sbrEnvData
->hufftableBalanceFreqL[delta +
sbrEnvData->codeBookScfLavBalance]);
}
} else {
if (sbrEnvData->domain_vec[j]) {
/* coupling && !balance && TIME */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData
->hufftableLevelTimeC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData
->hufftableLevelTimeL[delta + sbrEnvData->codeBookScfLav]);
} else {
/* coupling && !balance && FREQ */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData
->hufftableLevelFreqC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData
->hufftableLevelFreqL[delta + sbrEnvData->codeBookScfLav]);
}
}
} else {
if (sbrEnvData->domain_vec[j]) {
/* !coupling && TIME */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData->hufftableTimeC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableTimeL[delta + sbrEnvData->codeBookScfLav]);
} else {
/* !coupling && FREQ */
payloadBits += FDKwriteBits(
hBitStream,
sbrEnvData->hufftableFreqC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableFreqL[delta + sbrEnvData->codeBookScfLav]);
}
}
}
}
return payloadBits;
}
static void CTns_Filter (FIXP_DBL *spec, int size, int inc, FIXP_TCC coeff [], int order)
{
// - Simple all-pole filter of order "order" defined by
// y(n) = x(n) - a(2)*y(n-1) - ... - a(order+1)*y(n-order)
//
// - The state variables of the filter are initialized to zero every time
//
// - The output data is written over the input data ("in-place operation")
//
// - An input vector of "size" samples is processed and the index increment
// to the next data sample is given by "inc"
int i,j,N;
FIXP_DBL *pSpec;
FIXP_DBL maxVal=FL2FXCONST_DBL(0.0);
INT s;
FDK_ASSERT(order <= TNS_MAXIMUM_ORDER);
C_ALLOC_SCRATCH_START(state, FIXP_DBL, TNS_MAXIMUM_ORDER);
FDKmemclear(state, order*sizeof(FIXP_DBL));
for (i=0; i<size; i++) {
maxVal = fixMax(maxVal,fixp_abs(spec[i]));
}
if ( maxVal > FL2FXCONST_DBL(0.03125*0.70710678118) )
s = fixMax(CntLeadingZeros(maxVal)-6,0);
else
s = fixMax(CntLeadingZeros(maxVal)-5,0);
s = fixMin(s,2);
s = s-1;
if (inc == -1)
pSpec = &spec[size - 1];
else
pSpec = &spec[0];
FIXP_TCC *pCoeff;
#define FIRST_PART_FLTR \
FIXP_DBL x, *pState = state; \
pCoeff = coeff; \
\
if (s < 0) \
x = (pSpec [0]>>1) + fMultDiv2 (*pCoeff++, pState [0]) ; \
else \
x = (pSpec [0]<<s) + fMultDiv2 (*pCoeff++, pState [0]) ;
#define INNER_FLTR_INLINE \
x = fMultAddDiv2 (x, *pCoeff, pState [1]); \
pState [0] = pState [1] - (fMultDiv2 (*pCoeff++, x) <<2) ; \
pState++;
#define LAST_PART_FLTR \
if (s < 0) \
*pSpec = x << 1; \
else \
*pSpec = x >> s; \
*pState =(-x) << 1; \
pSpec += inc ;
if (order>8)
{
N = (order-1)&7;
for (i = size ; i != 0 ; i--)
{
FIRST_PART_FLTR
for (j = N; j > 0 ; j--) { INNER_FLTR_INLINE }
INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE
INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE
LAST_PART_FLTR
}
} else if (order>4) {
