blob: 11df761117a5fcc69f63e7304d7152d7f3e87a58 [file] [log] [blame]
/* -----------------------------------------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android
© Copyright 1995 - 2012 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
All rights reserved.
1. INTRODUCTION
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
of the MPEG specifications.
Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
individually for the purpose of encoding or decoding bit streams in products that are compliant with
the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
software may already be covered under those patent licenses when it is used for those licensed purposes only.
Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
applications information and documentation.
2. COPYRIGHT LICENSE
Redistribution and use in source and binary forms, with or without modification, are permitted without
payment of copyright license fees provided that you satisfy the following conditions:
You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
your modifications thereto in source code form.
You must retain the complete text of this software license in the documentation and/or other materials
provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
modifications thereto to recipients of copies in binary form.
The name of Fraunhofer may not be used to endorse or promote products derived from this library without
prior written permission.
You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
software or your modifications thereto.
Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
and the date of any change. For modified versions of the FDK AAC Codec, the term
"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
3. NO PATENT LICENSE
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
respect to this software.
You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
by appropriate patent licenses.
4. DISCLAIMER
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
or business interruption, however caused and on any theory of liability, whether in contract, strict
liability, or tort (including negligence), arising in any way out of the use of this software, even if
advised of the possibility of such damage.
5. CONTACT INFORMATION
Fraunhofer Institute for Integrated Circuits IIS
Attention: Audio and Multimedia Departments - FDK AAC LL
Am Wolfsmantel 33
91058 Erlangen, Germany
www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
----------------------------------------------------------------------------------------------------------- */
/*!
\file
\brief Envelope calculation
The envelope adjustor compares the energies present in the transposed
highband to the reference energies conveyed with the bitstream.
The highband is amplified (sometimes) or attenuated (mostly) to the
desired level.
The spectral shape of the reference energies can be changed several times per
frame if necessary. Each set of energy values corresponding to a certain range
in time will be called an <em>envelope</em> here.
The bitstream supports several frequency scales and two resolutions. Normally,
one or more QMF-subbands are grouped to one SBR-band. An envelope contains
reference energies for each SBR-band.
In addition to the energy envelopes, noise envelopes are transmitted that
define the ratio of energy which is generated by adding noise instead of
transposing the lowband. The noise envelopes are given in a coarser time
and frequency resolution.
If a signal contains strong tonal components, synthetic sines can be
generated in individual SBR bands.
An overlap buffer of 6 QMF-timeslots is used to allow a more
flexible alignment of the envelopes in time that is not restricted to the
core codec's frame borders.
Therefore the envelope adjustor has access to the spectral data of the
current frame as well as the last 6 QMF-timeslots of the previous frame.
However, in average only the data of 1 frame is being processed as
the adjustor is called once per frame.
Depending on the frequency range set in the bitstream, only QMF-subbands between
<em>lowSubband</em> and <em>highSubband</em> are adjusted.
Scaling of spectral data to maximize SNR (see #QMF_SCALE_FACTOR) as well as a special Mantissa-Exponent format
( see calculateSbrEnvelope() ) are being used. The main entry point for this modules is calculateSbrEnvelope().
\sa sbr_scale.h, #QMF_SCALE_FACTOR, calculateSbrEnvelope(), \ref documentationOverview
*/
#include "env_calc.h"
#include "sbrdec_freq_sca.h"
#include "env_extr.h"
#include "transcendent.h"
#include "sbr_ram.h"
#include "sbr_rom.h"
#include "genericStds.h" /* need FDKpow() for debug outputs */
#if defined(__arm__)
#include "arm/env_calc_arm.cpp"
#endif
typedef struct
{
FIXP_DBL nrgRef[MAX_FREQ_COEFFS];
FIXP_DBL nrgEst[MAX_FREQ_COEFFS];
FIXP_DBL nrgGain[MAX_FREQ_COEFFS];
FIXP_DBL noiseLevel[MAX_FREQ_COEFFS];
FIXP_DBL nrgSine[MAX_FREQ_COEFFS];
SCHAR nrgRef_e[MAX_FREQ_COEFFS];
SCHAR nrgEst_e[MAX_FREQ_COEFFS];
SCHAR nrgGain_e[MAX_FREQ_COEFFS];
SCHAR noiseLevel_e[MAX_FREQ_COEFFS];
SCHAR nrgSine_e[MAX_FREQ_COEFFS];
}
ENV_CALC_NRGS;
/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer,
SCHAR *filtBuffer_e,
FIXP_DBL *NrgGain,
SCHAR *NrgGain_e,
int subbands);
/*static*/ void calcNrgPerSubband(FIXP_DBL **analysBufferReal,
FIXP_DBL **analysBufferImag,
int lowSubband, int highSubband,
int start_pos, int next_pos,
SCHAR frameExp,
FIXP_DBL *nrgEst,
SCHAR *nrgEst_e );
/*static*/ void calcNrgPerSfb(FIXP_DBL **analysBufferReal,
FIXP_DBL **analysBufferImag,
int nSfb,
UCHAR *freqBandTable,
int start_pos, int next_pos,
SCHAR input_e,
FIXP_DBL *nrg_est,
SCHAR *nrg_est_e );
/*static*/ void calcSubbandGain(FIXP_DBL nrgRef, SCHAR nrgRef_e, ENV_CALC_NRGS* nrgs, int c,
FIXP_DBL tmpNoise, SCHAR tmpNoise_e,
UCHAR sinePresentFlag,
UCHAR sineMapped,
int noNoiseFlag);
/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
int lowSubband,
int highSubband,
FIXP_DBL *sumRef_m,
SCHAR *sumRef_e,
FIXP_DBL *ptrAvgGain_m,
SCHAR *ptrAvgGain_e);
/*static*/ void adjustTimeSlotLC(FIXP_DBL *ptrReal,
ENV_CALC_NRGS* nrgs,
UCHAR *ptrHarmIndex,
int lowSubbands,
int noSubbands,
int scale_change,
int noNoiseFlag,
int *ptrPhaseIndex,
int fCldfb);
/*static*/ void adjustTimeSlotHQ(FIXP_DBL *ptrReal,
FIXP_DBL *ptrImag,
HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
ENV_CALC_NRGS* nrgs,
int lowSubbands,
int noSubbands,
int scale_change,
FIXP_SGL smooth_ratio,
int noNoiseFlag,
int filtBufferNoiseShift);
/*!
\brief Map sine flags from bitstream to QMF bands
The bitstream carries only 1 sine flag per band and frame.
This function maps every sine flag from the bitstream to a specific QMF subband
and to a specific envelope where the sine shall start.
The result is stored in the vector sineMapped which contains one entry per
QMF subband. The value of an entry specifies the envelope where a sine
shall start. A value of #MAX_ENVELOPES indicates that no sine is present
in the subband.
The missing harmonics flags from the previous frame (harmFlagsPrev) determine
if a sine starts at the beginning of the frame or at the transient position.
Additionally, the flags in harmFlagsPrev are being updated by this function
for the next frame.
*/
/*static*/ void mapSineFlags(UCHAR *freqBandTable, /*!< Band borders (there's only 1 flag per band) */
int nSfb, /*!< Number of bands in the table */
UCHAR *addHarmonics, /*!< vector with 1 flag per sfb */
int *harmFlagsPrev, /*!< Packed 'addHarmonics' */
int tranEnv, /*!< Transient position */
SCHAR *sineMapped) /*!< Resulting vector of sine start positions for each QMF band */
{
int i;
int lowSubband2 = freqBandTable[0]<<1;
int bitcount = 0;
int oldflags = *harmFlagsPrev;
int newflags = 0;
/*
Format of harmFlagsPrev:
first word = flags for highest 16 sfb bands in use
second word = flags for next lower 16 sfb bands (if present)
third word = flags for lowest 16 sfb bands (if present)
Up to MAX_FREQ_COEFFS sfb bands can be flagged for a sign.
The lowest bit of the first word corresponds to the _highest_ sfb band in use.
This is ensures that each flag is mapped to the same QMF band even after a
change of the crossover-frequency.
*/
/* Reset the output vector first */
FDKmemset(sineMapped, MAX_ENVELOPES,MAX_FREQ_COEFFS); /* MAX_ENVELOPES means 'no sine' */
freqBandTable += nSfb;
addHarmonics += nSfb-1;
for (i=nSfb; i!=0; i--) {
int ui = *freqBandTable--; /* Upper limit of the current scale factor band. */
int li = *freqBandTable; /* Lower limit of the current scale factor band. */
if ( *addHarmonics-- ) { /* There is a sine in this band */
unsigned int mask = 1 << bitcount;
newflags |= mask; /* Set flag */
/*
If there was a sine in the last frame, let it continue from the first envelope on
else start at the transient position.
*/
sineMapped[(ui+li-lowSubband2) >> 1] = ( oldflags & mask ) ? 0 : tranEnv;
}
if ((++bitcount == 16) || i==1) {
bitcount = 0;
*harmFlagsPrev++ = newflags;
oldflags = *harmFlagsPrev; /* Fetch 16 of the old flags */
newflags = 0;
}
}
}
/*!
\brief Reduce gain-adjustment induced aliasing for real valued filterbank.
*/
/*static*/ void
aliasingReduction(FIXP_DBL* degreeAlias, /*!< estimated aliasing for each QMF channel */
ENV_CALC_NRGS* nrgs,
int* useAliasReduction, /*!< synthetic sine engergy for each subband, used as flag */
int noSubbands) /*!< number of QMF channels to process */
{
FIXP_DBL* nrgGain = nrgs->nrgGain; /*!< subband gains to be modified */
SCHAR* nrgGain_e = nrgs->nrgGain_e; /*!< subband gains to be modified (exponents) */
FIXP_DBL* nrgEst = nrgs->nrgEst; /*!< subband energy before amplification */
SCHAR* nrgEst_e = nrgs->nrgEst_e; /*!< subband energy before amplification (exponents) */
int grouping = 0, index = 0, noGroups, k;
int groupVector[MAX_FREQ_COEFFS];
/* Calculate grouping*/
for (k = 0; k < noSubbands-1; k++ ){
if ( (degreeAlias[k + 1] != FL2FXCONST_DBL(0.0f)) && useAliasReduction[k] ) {
if(grouping==0){
groupVector[index++] = k;
grouping = 1;
}
else{
if(groupVector[index-1] + 3 == k){
groupVector[index++] = k + 1;
grouping = 0;
}
}
}
else{
if(grouping){
if(useAliasReduction[k])
groupVector[index++] = k + 1;
else
groupVector[index++] = k;
grouping = 0;
}
}
}
if(grouping){
groupVector[index++] = noSubbands;
}
noGroups = index >> 1;
/*Calculate new gain*/
for (int group = 0; group < noGroups; group ++) {
FIXP_DBL nrgOrig = FL2FXCONST_DBL(0.0f); /* Original signal energy in current group of bands */
SCHAR nrgOrig_e = 0;
FIXP_DBL nrgAmp = FL2FXCONST_DBL(0.0f); /* Amplified signal energy in group (using current gains) */
SCHAR nrgAmp_e = 0;
FIXP_DBL nrgMod = FL2FXCONST_DBL(0.0f); /* Signal energy in group when applying modified gains */
SCHAR nrgMod_e = 0;
FIXP_DBL groupGain; /* Total energy gain in group */
SCHAR groupGain_e;
FIXP_DBL compensation; /* Compensation factor for the energy change when applying modified gains */
SCHAR compensation_e;
int startGroup = groupVector[2*group];
int stopGroup = groupVector[2*group+1];
/* Calculate total energy in group before and after amplification with current gains: */
for(k = startGroup; k < stopGroup; k++){
/* Get original band energy */
FIXP_DBL tmp = nrgEst[k];
SCHAR tmp_e = nrgEst_e[k];
FDK_add_MantExp(tmp, tmp_e, nrgOrig, nrgOrig_e, &nrgOrig, &nrgOrig_e);
/* Multiply band energy with current gain */
tmp = fMult(tmp,nrgGain[k]);
tmp_e = tmp_e + nrgGain_e[k];
FDK_add_MantExp(tmp, tmp_e, nrgAmp, nrgAmp_e, &nrgAmp, &nrgAmp_e);
}
/* Calculate total energy gain in group */
FDK_divide_MantExp(nrgAmp, nrgAmp_e,
nrgOrig, nrgOrig_e,
&groupGain, &groupGain_e);
for(k = startGroup; k < stopGroup; k++){
FIXP_DBL tmp;
SCHAR tmp_e;
FIXP_DBL alpha = degreeAlias[k];
if (k < noSubbands - 1) {
if (degreeAlias[k + 1] > alpha)
alpha = degreeAlias[k + 1];
}
/* Modify gain depending on the degree of aliasing */
FDK_add_MantExp( fMult(alpha,groupGain), groupGain_e,
fMult(/*FL2FXCONST_DBL(1.0f)*/ (FIXP_DBL)MAXVAL_DBL - alpha,nrgGain[k]), nrgGain_e[k],
&nrgGain[k], &nrgGain_e[k] );
/* Apply modified gain to original energy */
tmp = fMult(nrgGain[k],nrgEst[k]);
tmp_e = nrgGain_e[k] + nrgEst_e[k];
/* Accumulate energy with modified gains applied */
FDK_add_MantExp( tmp, tmp_e,
nrgMod, nrgMod_e,
&nrgMod, &nrgMod_e );
}
/* Calculate compensation factor to retain the energy of the amplified signal */
FDK_divide_MantExp(nrgAmp, nrgAmp_e,
nrgMod, nrgMod_e,
&compensation, &compensation_e);
/* Apply compensation factor to all gains of the group */
for(k = startGroup; k < stopGroup; k++){
nrgGain[k] = fMult(nrgGain[k],compensation);
nrgGain_e[k] = nrgGain_e[k] + compensation_e;
}
}
}
/* Convert headroom bits to exponent */
#define SCALE2EXP(s) (15-(s))
#define EXP2SCALE(e) (15-(e))
/*!
\brief Apply spectral envelope to subband samples
This function is called from sbr_dec.cpp in each frame.
To enhance accuracy and due to the usage of tables for squareroots and
inverse, some calculations are performed with the operands being split
into mantissa and exponent. The variable names in the source code carry
the suffixes <em>_m</em> and <em>_e</em> respectively. The control data
in #hFrameData containts envelope data which is represented by this format but
stored in single words. (See requantizeEnvelopeData() for details). This data
is unpacked within calculateSbrEnvelope() to follow the described suffix convention.
The actual value (comparable to the corresponding float-variable in the
research-implementation) of a mantissa/exponent-pair can be calculated as
\f$ value = value\_m * 2^{value\_e} \f$
All energies and noise levels decoded from the bitstream suit for an
original signal magnitude of \f$\pm 32768 \f$ rather than \f$ \pm 1\f$. Therefore,
the scale factor <em>hb_scale</em> passed into this function will be converted
to an 'input exponent' (#input_e), which fits the internal representation.
Before the actual processing, an exponent #adj_e for resulting adjusted
samples is derived from the maximum reference energy.
Then, for each envelope, the following steps are performed:
\li Calculate energy in the signal to be adjusted. Depending on the the value of
#interpolFreq (interpolation mode), this is either done seperately
for each QMF-subband or for each SBR-band.
The resulting energies are stored in #nrgEst_m[#MAX_FREQ_COEFFS] (mantissas)
and #nrgEst_e[#MAX_FREQ_COEFFS] (exponents).
\li Calculate gain and noise level for each subband:<br>
\f$ gain = \sqrt{ \frac{nrgRef}{nrgEst} \cdot (1 - noiseRatio) }
\hspace{2cm}
noise = \sqrt{ nrgRef \cdot noiseRatio }
\f$<br>
where <em>noiseRatio</em> and <em>nrgRef</em> are extracted from the
bitstream and <em>nrgEst</em> is the subband energy before adjustment.
The resulting gains are stored in #nrgGain_m[#MAX_FREQ_COEFFS]
(mantissas) and #nrgGain_e[#MAX_FREQ_COEFFS] (exponents), the noise levels
are stored in #noiseLevel_m[#MAX_FREQ_COEFFS] and #noiseLevel_e[#MAX_FREQ_COEFFS]
(exponents).
The sine levels are stored in #nrgSine_m[#MAX_FREQ_COEFFS]
and #nrgSine_e[#MAX_FREQ_COEFFS].
\li Noise limiting: The gain for each subband is limited both absolutely
and relatively compared to the total gain over all subbands.
\li Boost gain: Calculate and apply boost factor for each limiter band
in order to compensate for the energy loss imposed by the limiting.
\li Apply gains and add noise: The gains and noise levels are applied
to all timeslots of the current envelope. A short FIR-filter (length 4
QMF-timeslots) can be used to smooth the sudden change at the envelope borders.
Each complex subband sample of the current timeslot is multiplied by the
smoothed gain, then random noise with the calculated level is added.
\note
To reduce the stack size, some of the local arrays could be located within
the time output buffer. Of the 512 samples temporarily available there,
about half the size is already used by #SBR_FRAME_DATA. A pointer to the
remaining free memory could be supplied by an additional argument to calculateSbrEnvelope()
in sbr_dec:
\par
\code
calculateSbrEnvelope (&hSbrDec->sbrScaleFactor,
&hSbrDec->SbrCalculateEnvelope,
hHeaderData,
hFrameData,
QmfBufferReal,
QmfBufferImag,
timeOutPtr + sizeof(SBR_FRAME_DATA)/sizeof(Float) + 1);
\endcode
\par
Within calculateSbrEnvelope(), some pointers could be defined instead of the arrays
#nrgRef_m, #nrgRef_e, #nrgEst_m, #nrgEst_e, #noiseLevel_m:
\par
\code
fract* nrgRef_m = timeOutPtr;
SCHAR* nrgRef_e = nrgRef_m + MAX_FREQ_COEFFS;
fract* nrgEst_m = nrgRef_e + MAX_FREQ_COEFFS;
SCHAR* nrgEst_e = nrgEst_m + MAX_FREQ_COEFFS;
fract* noiseLevel_m = nrgEst_e + MAX_FREQ_COEFFS;
\endcode
<br>
*/
void
calculateSbrEnvelope (QMF_SCALE_FACTOR *sbrScaleFactor, /*!< Scaling factors */
HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env, /*!< Handle to struct filled by the create-function */
HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
HANDLE_SBR_FRAME_DATA hFrameData, /*!< Control data of current frame */
FIXP_DBL **analysBufferReal, /*!< Real part of subband samples to be processed */
FIXP_DBL **analysBufferImag, /*!< Imag part of subband samples to be processed */
const int useLP,
FIXP_DBL *degreeAlias, /*!< Estimated aliasing for each QMF channel */
const UINT flags,
const int frameErrorFlag
)
{
int c, i, j, envNoise = 0;
UCHAR* borders = hFrameData->frameInfo.borders;
FIXP_SGL *noiseLevels = hFrameData->sbrNoiseFloorLevel;
HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
int lowSubband = hFreq->lowSubband;
int highSubband = hFreq->highSubband;
int noSubbands = highSubband - lowSubband;
int noNoiseBands = hFreq->nNfb;
int no_cols = hHeaderData->numberTimeSlots * hHeaderData->timeStep;
UCHAR first_start = borders[0] * hHeaderData->timeStep;
SCHAR sineMapped[MAX_FREQ_COEFFS];
SCHAR ov_adj_e = SCALE2EXP(sbrScaleFactor->ov_hb_scale);
SCHAR adj_e = 0;
SCHAR output_e;
SCHAR final_e = 0;
SCHAR maxGainLimit_e = (frameErrorFlag) ? MAX_GAIN_CONCEAL_EXP : MAX_GAIN_EXP;
int useAliasReduction[64];
UCHAR smooth_length = 0;
FIXP_SGL * pIenv = hFrameData->iEnvelope;
/*
Extract sine flags for all QMF bands
*/
mapSineFlags(hFreq->freqBandTable[1],
hFreq->nSfb[1],
hFrameData->addHarmonics,
h_sbr_cal_env->harmFlagsPrev,
hFrameData->frameInfo.tranEnv,
sineMapped);
/*
Scan for maximum in bufferd noise levels.
This is needed in case that we had strong noise in the previous frame
which is smoothed into the current frame.
The resulting exponent is used as start value for the maximum search
in reference energies
*/
if (!useLP)
adj_e = h_sbr_cal_env->filtBufferNoise_e - getScalefactor(h_sbr_cal_env->filtBufferNoise, noSubbands);
/*
Scan for maximum reference energy to be able
to select appropriate values for adj_e and final_e.
*/
for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
INT maxSfbNrg_e = -FRACT_BITS+NRG_EXP_OFFSET; /* start value for maximum search */
/* Fetch frequency resolution for current envelope: */
for (j=hFreq->nSfb[hFrameData->frameInfo.freqRes[i]]; j!=0; j--) {
maxSfbNrg_e = fixMax(maxSfbNrg_e,(INT)((LONG)(*pIenv++) & MASK_E));
}
maxSfbNrg_e -= NRG_EXP_OFFSET;
/* Energy -> magnitude (sqrt halfens exponent) */
maxSfbNrg_e = (maxSfbNrg_e+1) >> 1; /* +1 to go safe (round to next higher int) */
/* Some safety margin is needed for 2 reasons:
- The signal energy is not equally spread over all subband samples in
a specific sfb of an envelope (Nrg could be too high by a factor of
envWidth * sfbWidth)
- Smoothing can smear high gains of the previous envelope into the current
*/
maxSfbNrg_e += 6;
if (borders[i] < hHeaderData->numberTimeSlots)
/* This envelope affects timeslots that belong to the output frame */
adj_e = (maxSfbNrg_e > adj_e) ? maxSfbNrg_e : adj_e;
if (borders[i+1] > hHeaderData->numberTimeSlots)
/* This envelope affects timeslots after the output frame */
final_e = (maxSfbNrg_e > final_e) ? maxSfbNrg_e : final_e;
}
/*
Calculate adjustment factors and apply them for every envelope.
*/
pIenv = hFrameData->iEnvelope;
for (i = 0; i < hFrameData->frameInfo.nEnvelopes; i++) {
int k, noNoiseFlag;
SCHAR noise_e, input_e = SCALE2EXP(sbrScaleFactor->hb_scale);
C_ALLOC_SCRATCH_START(pNrgs, ENV_CALC_NRGS, 1);
/*
Helper variables.
*/
UCHAR start_pos = hHeaderData->timeStep * borders[i]; /* Start-position in time (subband sample) for current envelope. */
UCHAR stop_pos = hHeaderData->timeStep * borders[i+1]; /* Stop-position in time (subband sample) for current envelope. */
UCHAR freq_res = hFrameData->frameInfo.freqRes[i]; /* Frequency resolution for current envelope. */
/* Always do fully initialize the temporary energy table. This prevents negative energies and extreme gain factors in
cases where the number of limiter bands exceeds the number of subbands. The latter can be caused by undetected bit
errors and is tested by some streams from the certification set. */
FDKmemclear(pNrgs, sizeof(ENV_CALC_NRGS));
/* If the start-pos of the current envelope equals the stop pos of the current
noise envelope, increase the pointer (i.e. choose the next noise-floor).*/
if (borders[i] == hFrameData->frameInfo.bordersNoise[envNoise+1]){
noiseLevels += noNoiseBands; /* The noise floor data is stored in a row [noiseFloor1 noiseFloor2...].*/
envNoise++;
}
if(i==hFrameData->frameInfo.tranEnv || i==h_sbr_cal_env->prevTranEnv) /* attack */
{
noNoiseFlag = 1;
if (!useLP)
smooth_length = 0; /* No smoothing on attacks! */
}
else {
noNoiseFlag = 0;
if (!useLP)
smooth_length = (1 - hHeaderData->bs_data.smoothingLength) << 2; /* can become either 0 or 4 */
}
/*
Energy estimation in transposed highband.
*/
if (hHeaderData->bs_data.interpolFreq)
calcNrgPerSubband(analysBufferReal,
(useLP) ? NULL : analysBufferImag,
lowSubband, highSubband,
start_pos, stop_pos,
input_e,
pNrgs->nrgEst,
pNrgs->nrgEst_e);
else
calcNrgPerSfb(analysBufferReal,
(useLP) ? NULL : analysBufferImag,
hFreq->nSfb[freq_res],
hFreq->freqBandTable[freq_res],
start_pos, stop_pos,
input_e,
pNrgs->nrgEst,
pNrgs->nrgEst_e);
/*
Calculate subband gains
*/
{
UCHAR * table = hFreq->freqBandTable[freq_res];
UCHAR * pUiNoise = &hFreq->freqBandTableNoise[1]; /*! Upper limit of the current noise floor band. */
FIXP_SGL * pNoiseLevels = noiseLevels;
FIXP_DBL tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
SCHAR tmpNoise_e = (UCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
int cc = 0;
c = 0;
for (j = 0; j < hFreq->nSfb[freq_res]; j++) {
FIXP_DBL refNrg = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pIenv) & MASK_M));
SCHAR refNrg_e = (SCHAR)((LONG)(*pIenv) & MASK_E) - NRG_EXP_OFFSET;
UCHAR sinePresentFlag = 0;
int li = table[j];
int ui = table[j+1];
for (k=li; k<ui; k++) {
sinePresentFlag |= (i >= sineMapped[cc]);
cc++;
}
for (k=li; k<ui; k++) {
if (k >= *pUiNoise) {
tmpNoise = FX_SGL2FX_DBL((FIXP_SGL)((LONG)(*pNoiseLevels) & MASK_M));
tmpNoise_e = (SCHAR)((LONG)(*pNoiseLevels++) & MASK_E) - NOISE_EXP_OFFSET;
pUiNoise++;
}
FDK_ASSERT(k >= lowSubband);
if (useLP)
useAliasReduction[k-lowSubband] = !sinePresentFlag;
pNrgs->nrgSine[c] = FL2FXCONST_DBL(0.0f);
pNrgs->nrgSine_e[c] = 0;
calcSubbandGain(refNrg, refNrg_e, pNrgs, c,
tmpNoise, tmpNoise_e,
sinePresentFlag, i >= sineMapped[c],
noNoiseFlag);
pNrgs->nrgRef[c] = refNrg;
pNrgs->nrgRef_e[c] = refNrg_e;
c++;
}
pIenv++;
}
}
/*
Noise limiting
*/
for (c = 0; c < hFreq->noLimiterBands; c++) {
FIXP_DBL sumRef, boostGain, maxGain;
FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
SCHAR sumRef_e, boostGain_e, maxGain_e, accu_e = 0;
calcAvgGain(pNrgs,
hFreq->limiterBandTable[c], hFreq->limiterBandTable[c+1],
&sumRef, &sumRef_e,
&maxGain, &maxGain_e);
/* Multiply maxGain with limiterGain: */
maxGain = fMult(maxGain, FDK_sbrDecoder_sbr_limGains_m[hHeaderData->bs_data.limiterGains]);
maxGain_e += FDK_sbrDecoder_sbr_limGains_e[hHeaderData->bs_data.limiterGains];
/* Scale mantissa of MaxGain into range between 0.5 and 1: */
if (maxGain == FL2FXCONST_DBL(0.0f))
maxGain_e = -FRACT_BITS;
else {
SCHAR charTemp = CountLeadingBits(maxGain);
maxGain_e -= charTemp;
maxGain <<= (int)charTemp;
}
if (maxGain_e >= maxGainLimit_e) { /* upper limit (e.g. 96 dB) */
maxGain = FL2FXCONST_DBL(0.5f);
maxGain_e = maxGainLimit_e;
}
/* Every subband gain is compared to the scaled "average gain"
and limited if necessary: */
for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c+1]; k++) {
if ( (pNrgs->nrgGain_e[k] > maxGain_e) || (pNrgs->nrgGain_e[k] == maxGain_e && pNrgs->nrgGain[k]>maxGain) ) {
FIXP_DBL noiseAmp;
SCHAR noiseAmp_e;
FDK_divide_MantExp(maxGain, maxGain_e, pNrgs->nrgGain[k], pNrgs->nrgGain_e[k], &noiseAmp, &noiseAmp_e);
pNrgs->noiseLevel[k] = fMult(pNrgs->noiseLevel[k],noiseAmp);
pNrgs->noiseLevel_e[k] += noiseAmp_e;
pNrgs->nrgGain[k] = maxGain;
pNrgs->nrgGain_e[k] = maxGain_e;
}
}
/* -- Boost gain
Calculate and apply boost factor for each limiter band:
1. Check how much energy would be present when using the limited gain
2. Calculate boost factor by comparison with reference energy
3. Apply boost factor to compensate for the energy loss due to limiting
*/
for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
/* 1.a Add energy of adjusted signal (using preliminary gain) */
FIXP_DBL tmp = fMult(pNrgs->nrgGain[k],pNrgs->nrgEst[k]);
SCHAR tmp_e = pNrgs->nrgGain_e[k] + pNrgs->nrgEst_e[k];
FDK_add_MantExp(tmp, tmp_e, accu, accu_e, &accu, &accu_e);
/* 1.b Add sine energy (if present) */
if(pNrgs->nrgSine[k] != FL2FXCONST_DBL(0.0f)) {
FDK_add_MantExp(pNrgs->nrgSine[k], pNrgs->nrgSine_e[k], accu, accu_e, &accu, &accu_e);
}
else {
/* 1.c Add noise energy (if present) */
if(noNoiseFlag == 0) {
FDK_add_MantExp(pNrgs->noiseLevel[k], pNrgs->noiseLevel_e[k], accu, accu_e, &accu, &accu_e);
}
}
}
/* 2.a Calculate ratio of wanted energy and accumulated energy */
if (accu == (FIXP_DBL)0) { /* If divisor is 0, limit quotient to +4 dB */
boostGain = FL2FXCONST_DBL(0.6279716f);
boostGain_e = 2;
} else {
INT div_e;
boostGain = fDivNorm(sumRef, accu, &div_e);
boostGain_e = sumRef_e - accu_e + div_e;
}
/* 2.b Result too high? --> Limit the boost factor to +4 dB */
if((boostGain_e > 3) ||
(boostGain_e == 2 && boostGain > FL2FXCONST_DBL(0.6279716f)) ||
(boostGain_e == 3 && boostGain > FL2FXCONST_DBL(0.3139858f)) )
{
boostGain = FL2FXCONST_DBL(0.6279716f);
boostGain_e = 2;
}
/* 3. Multiply all signal components with the boost factor */
for (k = hFreq->limiterBandTable[c]; k < hFreq->limiterBandTable[c + 1]; k++) {
pNrgs->nrgGain[k] = fMultDiv2(pNrgs->nrgGain[k],boostGain);
pNrgs->nrgGain_e[k] = pNrgs->nrgGain_e[k] + boostGain_e + 1;
pNrgs->nrgSine[k] = fMultDiv2(pNrgs->nrgSine[k],boostGain);
pNrgs->nrgSine_e[k] = pNrgs->nrgSine_e[k] + boostGain_e + 1;
pNrgs->noiseLevel[k] = fMultDiv2(pNrgs->noiseLevel[k],boostGain);
pNrgs->noiseLevel_e[k] = pNrgs->noiseLevel_e[k] + boostGain_e + 1;
}
}
/* End of noise limiting */
if (useLP)
aliasingReduction(degreeAlias+lowSubband,
pNrgs,
useAliasReduction,
noSubbands);
/* For the timeslots within the range for the output frame,
use the same scale for the noise levels.
Drawback: If the envelope exceeds the frame border, the noise levels
will have to be rescaled later to fit final_e of
the gain-values.
*/
noise_e = (start_pos < no_cols) ? adj_e : final_e;
/*
Convert energies to amplitude levels
*/
for (k=0; k<noSubbands; k++) {
FDK_sqrt_MantExp(&pNrgs->nrgSine[k], &pNrgs->nrgSine_e[k], &noise_e);
FDK_sqrt_MantExp(&pNrgs->nrgGain[k], &pNrgs->nrgGain_e[k], &pNrgs->nrgGain_e[k]);
FDK_sqrt_MantExp(&pNrgs->noiseLevel[k], &pNrgs->noiseLevel_e[k], &noise_e);
}
/*
Apply calculated gains and adaptive noise
*/
/* assembleHfSignals() */
{
int scale_change, sc_change;
FIXP_SGL smooth_ratio;
int filtBufferNoiseShift=0;
/* Initialize smoothing buffers with the first valid values */
if (h_sbr_cal_env->startUp)
{
if (!useLP) {
h_sbr_cal_env->filtBufferNoise_e = noise_e;
FDKmemcpy(h_sbr_cal_env->filtBuffer_e, pNrgs->nrgGain_e, noSubbands*sizeof(SCHAR));
FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
FDKmemcpy(h_sbr_cal_env->filtBuffer, pNrgs->nrgGain, noSubbands*sizeof(FIXP_DBL));
}
h_sbr_cal_env->startUp = 0;
}
if (!useLP) {
equalizeFiltBufferExp(h_sbr_cal_env->filtBuffer, /* buffered */
h_sbr_cal_env->filtBuffer_e, /* buffered */
pNrgs->nrgGain, /* current */
pNrgs->nrgGain_e, /* current */
noSubbands);
/* Adapt exponent of buffered noise levels to the current exponent
so they can easily be smoothed */
if((h_sbr_cal_env->filtBufferNoise_e - noise_e)>=0) {
int shift = fixMin(DFRACT_BITS-1,(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
for (k=0; k<noSubbands; k++)
h_sbr_cal_env->filtBufferNoise[k] <<= shift;
}
else {
int shift = fixMin(DFRACT_BITS-1,-(int)(h_sbr_cal_env->filtBufferNoise_e - noise_e));
for (k=0; k<noSubbands; k++)
h_sbr_cal_env->filtBufferNoise[k] >>= shift;
}
h_sbr_cal_env->filtBufferNoise_e = noise_e;
}
/* find best scaling! */
scale_change = -(DFRACT_BITS-1);
for(k=0;k<noSubbands;k++) {
scale_change = fixMax(scale_change,(int)pNrgs->nrgGain_e[k]);
}
sc_change = (start_pos<no_cols)? adj_e - input_e : final_e - input_e;
if ((scale_change-sc_change+1)<0)
scale_change-=(scale_change-sc_change+1);
scale_change = (scale_change-sc_change)+1;
for(k=0;k<noSubbands;k++) {
int sc = scale_change-pNrgs->nrgGain_e[k] + (sc_change-1);
pNrgs->nrgGain[k] >>= sc;
pNrgs->nrgGain_e[k] += sc;
}
if (!useLP) {
for(k=0;k<noSubbands;k++) {
int sc = scale_change-h_sbr_cal_env->filtBuffer_e[k] + (sc_change-1);
h_sbr_cal_env->filtBuffer[k] >>= sc;
}
}
for (j = start_pos; j < stop_pos; j++)
{
/* This timeslot is located within the first part of the processing buffer
and will be fed into the QMF-synthesis for the current frame.
adj_e - input_e
This timeslot will not yet be fed into the QMF so we do not care
about the adj_e.
sc_change = final_e - input_e
*/
if ( (j==no_cols) && (start_pos<no_cols) )
{
int shift = (int) (noise_e - final_e);
if (!useLP)
filtBufferNoiseShift = shift; /* shifting of h_sbr_cal_env->filtBufferNoise[k] will be applied in function adjustTimeSlotHQ() */
if (shift>=0) {
shift = fixMin(DFRACT_BITS-1,shift);
for (k=0; k<noSubbands; k++) {
pNrgs->nrgSine[k] <<= shift;
pNrgs->noiseLevel[k] <<= shift;
/*
if (!useLP)
h_sbr_cal_env->filtBufferNoise[k] <<= shift;
*/
}
}
else {
shift = fixMin(DFRACT_BITS-1,-shift);
for (k=0; k<noSubbands; k++) {
pNrgs->nrgSine[k] >>= shift;
pNrgs->noiseLevel[k] >>= shift;
/*
if (!useLP)
h_sbr_cal_env->filtBufferNoise[k] >>= shift;
*/
}
}
/* update noise scaling */
noise_e = final_e;
if (!useLP)
h_sbr_cal_env->filtBufferNoise_e = noise_e; /* scaling value unused! */
/* update gain buffer*/
sc_change -= (final_e - input_e);
if (sc_change<0) {
for(k=0;k<noSubbands;k++) {
pNrgs->nrgGain[k] >>= -sc_change;
pNrgs->nrgGain_e[k] += -sc_change;
}
if (!useLP) {
for(k=0;k<noSubbands;k++) {
h_sbr_cal_env->filtBuffer[k] >>= -sc_change;
}
}
} else {
scale_change+=sc_change;
}
} // if
if (!useLP) {
/* Prevent the smoothing filter from running on constant levels */
if (j-start_pos < smooth_length)
smooth_ratio = FDK_sbrDecoder_sbr_smoothFilter[j-start_pos];
else
smooth_ratio = FL2FXCONST_SGL(0.0f);
adjustTimeSlotHQ(&analysBufferReal[j][lowSubband],
&analysBufferImag[j][lowSubband],
h_sbr_cal_env,
pNrgs,
lowSubband,
noSubbands,
scale_change,
smooth_ratio,
noNoiseFlag,
filtBufferNoiseShift);
}
else
{
adjustTimeSlotLC(&analysBufferReal[j][lowSubband],
pNrgs,
&h_sbr_cal_env->harmIndex,
lowSubband,
noSubbands,
scale_change,
noNoiseFlag,
&h_sbr_cal_env->phaseIndex,
(flags & SBRDEC_ELD_GRID));
}
} // for
if (!useLP) {
/* Update time-smoothing-buffers for gains and noise levels
The gains and the noise values of the current envelope are copied into the buffer.
This has to be done at the end of each envelope as the values are required for
a smooth transition to the next envelope. */
FDKmemcpy(h_sbr_cal_env->filtBuffer, pNrgs->nrgGain, noSubbands*sizeof(FIXP_DBL));
FDKmemcpy(h_sbr_cal_env->filtBuffer_e, pNrgs->nrgGain_e, noSubbands*sizeof(SCHAR));
FDKmemcpy(h_sbr_cal_env->filtBufferNoise, pNrgs->noiseLevel, noSubbands*sizeof(FIXP_DBL));
}
}
C_ALLOC_SCRATCH_END(pNrgs, ENV_CALC_NRGS, 1);
}
/* Rescale output samples */
{
FIXP_DBL maxVal;
int ov_reserve, reserve;
/* Determine headroom in old adjusted samples */
maxVal = maxSubbandSample( analysBufferReal,
(useLP) ? NULL : analysBufferImag,
lowSubband,
highSubband,
0,
first_start);
ov_reserve = fNorm(maxVal);
/* Determine headroom in new adjusted samples */
maxVal = maxSubbandSample( analysBufferReal,
(useLP) ? NULL : analysBufferImag,
lowSubband,
highSubband,
first_start,
no_cols);
reserve = fNorm(maxVal);
/* Determine common output exponent */
if (ov_adj_e - ov_reserve > adj_e - reserve ) /* set output_e to the maximum */
output_e = ov_adj_e - ov_reserve;
else
output_e = adj_e - reserve;
/* Rescale old samples */
rescaleSubbandSamples( analysBufferReal,
(useLP) ? NULL : analysBufferImag,
lowSubband, highSubband,
0, first_start,
ov_adj_e - output_e);
/* Rescale new samples */
rescaleSubbandSamples( analysBufferReal,
(useLP) ? NULL : analysBufferImag,
lowSubband, highSubband,
first_start, no_cols,
adj_e - output_e);
}
/* Update hb_scale */
sbrScaleFactor->hb_scale = EXP2SCALE(output_e);
/* Save the current final exponent for the next frame: */
sbrScaleFactor->ov_hb_scale = EXP2SCALE(final_e);
/* We need to remeber to the next frame that the transient
will occur in the first envelope (if tranEnv == nEnvelopes). */
if(hFrameData->frameInfo.tranEnv == hFrameData->frameInfo.nEnvelopes)
h_sbr_cal_env->prevTranEnv = 0;
else
h_sbr_cal_env->prevTranEnv = -1;
}
/*!
\brief Create envelope instance
Must be called once for each channel before calculateSbrEnvelope() can be used.
\return errorCode, 0 if successful
*/
SBR_ERROR
createSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs, /*!< pointer to envelope instance */
HANDLE_SBR_HEADER_DATA hHeaderData, /*!< static SBR control data, initialized with defaults */
const int chan, /*!< Channel for which to assign buffers */
const UINT flags)
{
SBR_ERROR err = SBRDEC_OK;
int i;
/* Clear previous missing harmonics flags */
for (i=0; i<(MAX_FREQ_COEFFS+15)>>4; i++) {
hs->harmFlagsPrev[i] = 0;
}
hs->harmIndex = 0;
/*
Setup pointers for time smoothing.
The buffer itself will be initialized later triggered by the startUp-flag.
*/
hs->prevTranEnv = -1;
/* initialization */
resetSbrEnvelopeCalc(hs);
if (chan==0) { /* do this only once */
err = resetFreqBandTables(hHeaderData, flags);
}
return err;
}
/*!
\brief Create envelope instance
Must be called once for each channel before calculateSbrEnvelope() can be used.
\return errorCode, 0 if successful
*/
int
deleteSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hs)
{
return 0;
}
/*!
\brief Reset envelope instance
This function must be called for each channel on a change of configuration.
Note that resetFreqBandTables should also be called in this case.
\return errorCode, 0 if successful
*/
void
resetSbrEnvelopeCalc (HANDLE_SBR_CALCULATE_ENVELOPE hCalEnv) /*!< pointer to envelope instance */
{
hCalEnv->phaseIndex = 0;
/* Noise exponent needs to be reset because the output exponent for the next frame depends on it */
hCalEnv->filtBufferNoise_e = 0;
hCalEnv->startUp = 1;
}
/*!
\brief Equalize exponents of the buffered gain values and the new ones
After equalization of exponents, the FIR-filter addition for smoothing
can be performed.
This function is called once for each envelope before adjusting.
*/
/*static*/ void equalizeFiltBufferExp(FIXP_DBL *filtBuffer, /*!< bufferd gains */
SCHAR *filtBuffer_e, /*!< exponents of bufferd gains */
FIXP_DBL *nrgGain, /*!< gains for current envelope */
SCHAR *nrgGain_e, /*!< exponents of gains for current envelope */
int subbands) /*!< Number of QMF subbands */
{
int band;
int diff;
for (band=0; band<subbands; band++){
diff = (int) (nrgGain_e[band] - filtBuffer_e[band]);
if (diff>0) {
filtBuffer[band] >>= diff; /* Compensate for the scale change by shifting the mantissa. */
filtBuffer_e[band] += diff; /* New gain is bigger, use its exponent */
}
else if (diff<0) {
/* The buffered gains seem to be larger, but maybe there
are some unused bits left in the mantissa */
int reserve = CntLeadingZeros(fixp_abs(filtBuffer[band]))-1;
if ((-diff) <= reserve) {
/* There is enough space in the buffered mantissa so
that we can take the new exponent as common.
*/
filtBuffer[band] <<= (-diff);
filtBuffer_e[band] += diff; /* becomes equal to *ptrNewExp */
}
else {
filtBuffer[band] <<= reserve; /* Shift the mantissa as far as possible: */
filtBuffer_e[band] -= reserve; /* Compensate in the exponent: */
/* For the remaining difference, change the new gain value */
diff = fixMin(-(reserve + diff),DFRACT_BITS-1);
nrgGain[band] >>= diff;
nrgGain_e[band] += diff;
}
}
}
}
/*!
\brief Shift left the mantissas of all subband samples
in the giventime and frequency range by the specified number of bits.
This function is used to rescale the audio data in the overlap buffer
which has already been envelope adjusted with the last frame.
*/
void rescaleSubbandSamples(FIXP_DBL ** re, /*!< Real part of input and output subband samples */
FIXP_DBL ** im, /*!< Imaginary part of input and output subband samples */
int lowSubband, /*!< Begin of frequency range to process */
int highSubband, /*!< End of frequency range to process */
int start_pos, /*!< Begin of time rage (QMF-timeslot) */
int next_pos, /*!< End of time rage (QMF-timeslot) */
int shift) /*!< number of bits to shift */
{
int width = highSubband-lowSubband;
if ( (width > 0) && (shift!=0) ) {
if (im!=NULL) {
for (int l=start_pos; l<next_pos; l++) {
scaleValues(&re[l][lowSubband], width, shift);
scaleValues(&im[l][lowSubband], width, shift);
}
} else
{
for (int l=start_pos; l<next_pos; l++) {
scaleValues(&re[l][lowSubband], width, shift);
}
}
}
}
/*!
\brief Determine headroom for shifting
Determine by how much the spectrum can be shifted left
for better accuracy in later processing.
\return Number of free bits in the biggest spectral value
*/
FIXP_DBL maxSubbandSample( FIXP_DBL ** re, /*!< Real part of input and output subband samples */
FIXP_DBL ** im, /*!< Real part of input and output subband samples */
int lowSubband, /*!< Begin of frequency range to process */
int highSubband, /*!< Number of QMF bands to process */
int start_pos, /*!< Begin of time rage (QMF-timeslot) */
int next_pos /*!< End of time rage (QMF-timeslot) */
)
{
FIXP_DBL maxVal = FL2FX_DBL(0.0f);
unsigned int width = highSubband - lowSubband;
FDK_ASSERT(width <= (64));
if ( width > 0 ) {
if (im!=NULL)
{
for (int l=start_pos; l<next_pos; l++)
{
#ifdef FUNCTION_FDK_get_maxval
maxVal = FDK_get_maxval(maxVal, &re[l][lowSubband], &im[l][lowSubband], width);
#else
int k=width;
FIXP_DBL *reTmp = &re[l][lowSubband];
FIXP_DBL *imTmp = &im[l][lowSubband];
do{
FIXP_DBL tmp1 = *(reTmp++);
FIXP_DBL tmp2 = *(imTmp++);
maxVal |= (FIXP_DBL)((LONG)(tmp1)^((LONG)tmp1>>(DFRACT_BITS-1)));
maxVal |= (FIXP_DBL)((LONG)(tmp2)^((LONG)tmp2>>(DFRACT_BITS-1)));
} while(--k!=0);
#endif
}
} else
{
for (int l=start_pos; l<next_pos; l++) {
int k=width;
FIXP_DBL *reTmp = &re[l][lowSubband];
do{
FIXP_DBL tmp = *(reTmp++);
maxVal |= (FIXP_DBL)((LONG)(tmp)^((LONG)tmp>>(DFRACT_BITS-1)));
}while(--k!=0);
}
}
}
return(maxVal);
}
#define SHIFT_BEFORE_SQUARE (3) /* (7/2) */
/*!<
If the accumulator does not provide enough overflow bits or
does not provide a high dynamic range, the below energy calculation
requires an additional shift operation for each sample.
On the other hand, doing the shift allows using a single-precision
multiplication for the square (at least 16bit x 16bit).
For even values of OVRFLW_BITS (0, 2, 4, 6), saturated arithmetic
is required for the energy accumulation.
Theoretically, the sample-squares can sum up to a value of 76,
requiring 7 overflow bits. However since such situations are *very*
rare, accu can be limited to 64.
In case native saturated arithmetic is not available, overflows
can be prevented by replacing the above #define by
#define SHIFT_BEFORE_SQUARE ((8 - OVRFLW_BITS) / 2)
which will result in slightly reduced accuracy.
*/
/*!
\brief Estimates the mean energy of each filter-bank channel for the
duration of the current envelope
This function is used when interpolFreq is true.
*/
/*static*/ void calcNrgPerSubband(FIXP_DBL **analysBufferReal, /*!< Real part of subband samples */
FIXP_DBL **analysBufferImag, /*!< Imaginary part of subband samples */
int lowSubband, /*!< Begin of the SBR frequency range */
int highSubband, /*!< High end of the SBR frequency range */
int start_pos, /*!< First QMF-slot of current envelope */
int next_pos, /*!< Last QMF-slot of current envelope + 1 */
SCHAR frameExp, /*!< Common exponent for all input samples */
FIXP_DBL *nrgEst, /*!< resulting Energy (0..1) */
SCHAR *nrgEst_e ) /*!< Exponent of resulting Energy */
{
FIXP_SGL invWidth;
SCHAR preShift;
SCHAR shift;
FIXP_DBL sum;
int k,l;
/* Divide by width of envelope later: */
invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
/* The common exponent needs to be doubled because all mantissas are squared: */
frameExp = frameExp << 1;
for (k=lowSubband; k<highSubband; k++) {
FIXP_DBL bufferReal[(((1024)/(32))+(6))];
FIXP_DBL bufferImag[(((1024)/(32))+(6))];
FIXP_DBL maxVal = FL2FX_DBL(0.0f);
if (analysBufferImag!=NULL)
{
for (l=start_pos;l<next_pos;l++)
{
bufferImag[l] = analysBufferImag[l][k];
maxVal |= (FIXP_DBL)((LONG)(bufferImag[l])^((LONG)bufferImag[l]>>(DFRACT_BITS-1)));
bufferReal[l] = analysBufferReal[l][k];
maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
}
}
else
{
for (l=start_pos;l<next_pos;l++)
{
bufferReal[l] = analysBufferReal[l][k];
maxVal |= (FIXP_DBL)((LONG)(bufferReal[l])^((LONG)bufferReal[l]>>(DFRACT_BITS-1)));
}
}
if (maxVal!=FL2FXCONST_DBL(0.f)) {
/* If the accu does not provide enough overflow bits, we cannot
shift the samples up to the limit.
Instead, keep up to 3 free bits in each sample, i.e. up to
6 bits after calculation of square.
Please note the comment on saturated arithmetic above!
*/
FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
preShift = CntLeadingZeros(maxVal)-1;
preShift -= SHIFT_BEFORE_SQUARE;
if (preShift>=0) {
if (analysBufferImag!=NULL) {
for (l=start_pos; l<next_pos; l++) {
FIXP_DBL temp1 = bufferReal[l] << (int)preShift;
FIXP_DBL temp2 = bufferImag[l] << (int)preShift;
accu = fPow2AddDiv2(accu, temp1);
accu = fPow2AddDiv2(accu, temp2);
}
} else
{
for (l=start_pos; l<next_pos; l++) {
FIXP_DBL temp = bufferReal[l] << (int)preShift;
accu = fPow2AddDiv2(accu, temp);
}
}
}
else { /* if negative shift value */
int negpreShift = -preShift;
if (analysBufferImag!=NULL) {
for (l=start_pos; l<next_pos; l++) {
FIXP_DBL temp1 = bufferReal[l] >> (int)negpreShift;
FIXP_DBL temp2 = bufferImag[l] >> (int)negpreShift;
accu = fPow2AddDiv2(accu, temp1);
accu = fPow2AddDiv2(accu, temp2);
}
} else
{
for (l=start_pos; l<next_pos; l++) {
FIXP_DBL temp = bufferReal[l] >> (int)negpreShift;
accu = fPow2AddDiv2(accu, temp);
}
}
}
accu <<= 1;
/* Convert double precision to Mantissa/Exponent: */
shift = fNorm(accu);
sum = accu << (int)shift;
/* Divide by width of envelope and apply frame scale: */
*nrgEst++ = fMult(sum, invWidth);
shift += 2 * preShift;
if (analysBufferImag!=NULL)
*nrgEst_e++ = frameExp - shift;
else
*nrgEst_e++ = frameExp - shift + 1; /* +1 due to missing imag. part */
} /* maxVal!=0 */
else {
/* Prevent a zero-mantissa-number from being misinterpreted
due to its exponent. */
*nrgEst++ = FL2FXCONST_DBL(0.0f);
*nrgEst_e++ = 0;
}
}
}
/*!
\brief Estimates the mean energy of each Scale factor band for the
duration of the current envelope.
This function is used when interpolFreq is false.
*/
/*static*/ void calcNrgPerSfb(FIXP_DBL **analysBufferReal, /*!< Real part of subband samples */
FIXP_DBL **analysBufferImag, /*!< Imaginary part of subband samples */
int nSfb, /*!< Number of scale factor bands */
UCHAR *freqBandTable, /*!< First Subband for each Sfb */
int start_pos, /*!< First QMF-slot of current envelope */
int next_pos, /*!< Last QMF-slot of current envelope + 1 */
SCHAR input_e, /*!< Common exponent for all input samples */
FIXP_DBL *nrgEst, /*!< resulting Energy (0..1) */
SCHAR *nrgEst_e ) /*!< Exponent of resulting Energy */
{
FIXP_SGL invWidth;
FIXP_DBL temp;
SCHAR preShift;
SCHAR shift, sum_e;
FIXP_DBL sum;
int j,k,l,li,ui;
FIXP_DBL sumAll, sumLine; /* Single precision would be sufficient,
but overflow bits are required for accumulation */
/* Divide by width of envelope later: */
invWidth = FX_DBL2FX_SGL(GetInvInt(next_pos - start_pos));
/* The common exponent needs to be doubled because all mantissas are squared: */
input_e = input_e << 1;
for(j=0; j<nSfb; j++) {
li = freqBandTable[j];
ui = freqBandTable[j+1];
FIXP_DBL maxVal = maxSubbandSample( analysBufferReal,
analysBufferImag,
li,
ui,
start_pos,
next_pos );
if (maxVal!=FL2FXCONST_DBL(0.f)) {
preShift = CntLeadingZeros(maxVal)-1;
/* If the accu does not provide enough overflow bits, we cannot
shift the samples up to the limit.
Instead, keep up to 3 free bits in each sample, i.e. up to
6 bits after calculation of square.
Please note the comment on saturated arithmetic above!
*/
preShift -= SHIFT_BEFORE_SQUARE;
sumAll = FL2FXCONST_DBL(0.0f);
for (k=li; k<ui; k++) {
sumLine = FL2FXCONST_DBL(0.0f);
if (analysBufferImag!=NULL) {
if (preShift>=0) {
for (l=start_pos; l<next_pos; l++) {
temp = analysBufferReal[l][k] << (int)preShift;
sumLine += fPow2Div2(temp);
temp = analysBufferImag[l][k] << (int)preShift;
sumLine += fPow2Div2(temp);
}
} else {
for (l=start_pos; l<next_pos; l++) {
temp = analysBufferReal[l][k] >> -(int)preShift;
sumLine += fPow2Div2(temp);
temp = analysBufferImag[l][k] >> -(int)preShift;
sumLine += fPow2Div2(temp);
}
}
} else
{
if (preShift>=0) {
for (l=start_pos; l<next_pos; l++) {
temp = analysBufferReal[l][k] << (int)preShift;
sumLine += fPow2Div2(temp);
}
} else {
for (l=start_pos; l<next_pos; l++) {
temp = analysBufferReal[l][k] >> -(int)preShift;
sumLine += fPow2Div2(temp);
}
}
}
/* The number of QMF-channels per SBR bands may be up to 15.
Shift right to avoid overflows in sum over all channels. */
sumLine = sumLine >> (4-1);
sumAll += sumLine;
}
/* Convert double precision to Mantissa/Exponent: */
shift = fNorm(sumAll);
sum = sumAll << (int)shift;
/* Divide by width of envelope: */
sum = fMult(sum,invWidth);
/* Divide by width of Sfb: */
sum = fMult(sum, FX_DBL2FX_SGL(GetInvInt(ui-li)));
/* Set all Subband energies in the Sfb to the average energy: */
if (analysBufferImag!=NULL)
sum_e = input_e + 4 - shift; /* -4 to compensate right-shift */
else
sum_e = input_e + 4 + 1 - shift; /* -4 to compensate right-shift; +1 due to missing imag. part */
sum_e -= 2 * preShift;
} /* maxVal!=0 */
else {
/* Prevent a zero-mantissa-number from being misinterpreted
due to its exponent. */
sum = FL2FXCONST_DBL(0.0f);
sum_e = 0;
}
for (k=li; k<ui; k++)
{
*nrgEst++ = sum;
*nrgEst_e++ = sum_e;
}
}
}
/*!
\brief Calculate gain, noise, and additional sine level for one subband.
The resulting energy gain is given by mantissa and exponent.
*/
/*static*/ void calcSubbandGain(FIXP_DBL nrgRef, /*!< Reference Energy according to envelope data */
SCHAR nrgRef_e, /*!< Reference Energy according to envelope data (exponent) */
ENV_CALC_NRGS* nrgs,
int i,
FIXP_DBL tmpNoise, /*!< Relative noise level */
SCHAR tmpNoise_e, /*!< Relative noise level (exponent) */
UCHAR sinePresentFlag, /*!< Indicates if sine is present on band */
UCHAR sineMapped, /*!< Indicates if sine must be added */
int noNoiseFlag) /*!< Flag to suppress noise addition */
{
FIXP_DBL nrgEst = nrgs->nrgEst[i]; /*!< Energy in transposed signal */
SCHAR nrgEst_e = nrgs->nrgEst_e[i]; /*!< Energy in transposed signal (exponent) */
FIXP_DBL *ptrNrgGain = &nrgs->nrgGain[i]; /*!< Resulting energy gain */
SCHAR *ptrNrgGain_e = &nrgs->nrgGain_e[i]; /*!< Resulting energy gain (exponent) */
FIXP_DBL *ptrNoiseLevel = &nrgs->noiseLevel[i]; /*!< Resulting absolute noise energy */
SCHAR *ptrNoiseLevel_e = &nrgs->noiseLevel_e[i]; /*!< Resulting absolute noise energy (exponent) */
FIXP_DBL *ptrNrgSine = &nrgs->nrgSine[i]; /*!< Additional sine energy */
SCHAR *ptrNrgSine_e = &nrgs->nrgSine_e[i]; /*!< Additional sine energy (exponent) */
FIXP_DBL a, b, c;
SCHAR a_e, b_e, c_e;
/*
This addition of 1 prevents divisions by zero in the reference code.
For very small energies in nrgEst, it prevents the gains from becoming
very high which could cause some trouble due to the smoothing.
*/
b_e = (int)(nrgEst_e - 1);
if (b_e>=0) {
nrgEst = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (nrgEst >> 1);
nrgEst_e += 1; /* shift by 1 bit to avoid overflow */
} else {
nrgEst = (nrgEst >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
nrgEst_e = 2; /* shift by 1 bit to avoid overflow */
}
/* A = NrgRef * TmpNoise */
a = fMult(nrgRef,tmpNoise);
a_e = nrgRef_e + tmpNoise_e;
/* B = 1 + TmpNoise */
b_e = (int)(tmpNoise_e - 1);
if (b_e>=0) {
b = (FL2FXCONST_DBL(0.5f) >> (INT)fixMin(b_e+1,DFRACT_BITS-1)) + (tmpNoise >> 1);
b_e = tmpNoise_e + 1; /* shift by 1 bit to avoid overflow */
} else {
b = (tmpNoise >> (INT)(fixMin(-b_e+1,DFRACT_BITS-1))) + (FL2FXCONST_DBL(0.5f) >> 1);
b_e = 2; /* shift by 1 bit to avoid overflow */
}
/* noiseLevel = A / B = (NrgRef * TmpNoise) / (1 + TmpNoise) */
FDK_divide_MantExp( a, a_e,
b, b_e,
ptrNoiseLevel, ptrNoiseLevel_e);
if (sinePresentFlag) {
/* C = (1 + TmpNoise) * NrgEst */
c = fMult(b,nrgEst);
c_e = b_e + nrgEst_e;
/* gain = A / C = (NrgRef * TmpNoise) / (1 + TmpNoise) * NrgEst */
FDK_divide_MantExp( a, a_e,
c, c_e,
ptrNrgGain, ptrNrgGain_e);
if (sineMapped) {
/* sineLevel = nrgRef/ (1 + TmpNoise) */
FDK_divide_MantExp( nrgRef, nrgRef_e,
b, b_e,
ptrNrgSine, ptrNrgSine_e);
}
}
else {
if (noNoiseFlag) {
/* B = NrgEst */
b = nrgEst;
b_e = nrgEst_e;
}
else {
/* B = NrgEst * (1 + TmpNoise) */
b = fMult(b,nrgEst);
b_e = b_e + nrgEst_e;
}
/* gain = nrgRef / B */
FDK_divide_MantExp( nrgRef, nrgRef_e,
b, b_e,
ptrNrgGain, ptrNrgGain_e);
}
}
/*!
\brief Calculate "average gain" for the specified subband range.
This is rather a gain of the average magnitude than the average
of gains!
The result is used as a relative limit for all gains within the
current "limiter band" (a certain frequency range).
*/
/*static*/ void calcAvgGain(ENV_CALC_NRGS* nrgs,
int lowSubband, /*!< Begin of the limiter band */
int highSubband, /*!< High end of the limiter band */
FIXP_DBL *ptrSumRef,
SCHAR *ptrSumRef_e,
FIXP_DBL *ptrAvgGain, /*!< Resulting overall gain (mantissa) */
SCHAR *ptrAvgGain_e) /*!< Resulting overall gain (exponent) */
{
FIXP_DBL *nrgRef = nrgs->nrgRef; /*!< Reference Energy according to envelope data */
SCHAR *nrgRef_e = nrgs->nrgRef_e; /*!< Reference Energy according to envelope data (exponent) */
FIXP_DBL *nrgEst = nrgs->nrgEst; /*!< Energy in transposed signal */
SCHAR *nrgEst_e = nrgs->nrgEst_e; /*!< Energy in transposed signal (exponent) */
FIXP_DBL sumRef = 1;
FIXP_DBL sumEst = 1;
SCHAR sumRef_e = -FRACT_BITS;
SCHAR sumEst_e = -FRACT_BITS;
int k;
for (k=lowSubband; k<highSubband; k++){
/* Add nrgRef[k] to sumRef: */
FDK_add_MantExp( sumRef, sumRef_e,
nrgRef[k], nrgRef_e[k],
&sumRef, &sumRef_e );
/* Add nrgEst[k] to sumEst: */
FDK_add_MantExp( sumEst, sumEst_e,
nrgEst[k], nrgEst_e[k],
&sumEst, &sumEst_e );
}
FDK_divide_MantExp(sumRef, sumRef_e,
sumEst, sumEst_e,
ptrAvgGain, ptrAvgGain_e);
*ptrSumRef = sumRef;
*ptrSumRef_e = sumRef_e;
}
/*!
\brief Amplify one timeslot of the signal with the calculated gains
and add the noisefloor.
*/
/*static*/ void adjustTimeSlotLC(FIXP_DBL *ptrReal, /*!< Subband samples to be adjusted, real part */
ENV_CALC_NRGS* nrgs,
UCHAR *ptrHarmIndex, /*!< Harmonic index */
int lowSubband, /*!< Lowest QMF-channel in the currently used SBR range. */
int noSubbands, /*!< Number of QMF subbands */
int scale_change, /*!< Number of bits to shift adjusted samples */
int noNoiseFlag, /*!< Flag to suppress noise addition */
int *ptrPhaseIndex, /*!< Start index to random number array */
int fCldfb) /*!< CLDFB 80 flag */
{
FIXP_DBL *pGain = nrgs->nrgGain; /*!< Gains of current envelope */
FIXP_DBL *pNoiseLevel = nrgs->noiseLevel; /*!< Noise levels of current envelope */
FIXP_DBL *pSineLevel = nrgs->nrgSine; /*!< Sine levels */
int k;
int index = *ptrPhaseIndex;
UCHAR harmIndex = *ptrHarmIndex;
UCHAR freqInvFlag = (lowSubband & 1);
FIXP_DBL signalReal, sineLevel, sineLevelNext, sineLevelPrev;
int tone_count = 0;
int sineSign = 1;
#define C1 ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.00815f))
#define C1_CLDFB ((FIXP_SGL)FL2FXCONST_SGL(2.f*0.16773f))
/*
First pass for k=0 pulled out of the loop:
*/
index = (index + 1) & (SBR_NF_NO_RANDOM_VAL - 1);
/*
The next multiplication constitutes the actual envelope adjustment
of the signal and should be carried out with full accuracy
(supplying #FRACT_BITS valid bits).
*/
signalReal = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
sineLevel = *pSineLevel++;
sineLevelNext = (noSubbands > 1) ? pSineLevel[0] : FL2FXCONST_DBL(0.0f);
if (sineLevel!=FL2FXCONST_DBL(0.0f)) tone_count++;
else if (!noNoiseFlag)
/* Add noisefloor to the amplified signal */
signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
if (fCldfb) {
if (!(harmIndex&0x1)) {
/* harmIndex 0,2 */
signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
*ptrReal++ = signalReal;
}
else {
/* harmIndex 1,3 in combination with freqInvFlag */
int shift = (int) (scale_change+1);
shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
FIXP_DBL tmp1 = scaleValue( fMultDiv2(C1_CLDFB, sineLevel), -shift );
FIXP_DBL tmp2 = fMultDiv2(C1_CLDFB, sineLevelNext);
/* save switch and compare operations and reduce to XOR statement */
if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
*(ptrReal-1) += tmp1;
signalReal -= tmp2;
} else {
*(ptrReal-1) -= tmp1;
signalReal += tmp2;
}
*ptrReal++ = signalReal;
freqInvFlag = !freqInvFlag;
}
} else
{
if (!(harmIndex&0x1)) {
/* harmIndex 0,2 */
signalReal += (harmIndex&0x2) ? -sineLevel : sineLevel;
*ptrReal++ = signalReal;
}
else {
/* harmIndex 1,3 in combination with freqInvFlag */
int shift = (int) (scale_change+1);
shift = (shift>=0) ? fixMin(DFRACT_BITS-1,shift) : fixMax(-(DFRACT_BITS-1),shift);
FIXP_DBL tmp1 = (shift>=0) ? ( fMultDiv2(C1, sineLevel) >> shift )
: ( fMultDiv2(C1, sineLevel) << (-shift) );
FIXP_DBL tmp2 = fMultDiv2(C1, sineLevelNext);
/* save switch and compare operations and reduce to XOR statement */
if ( ((harmIndex>>1)&0x1)^freqInvFlag) {
*(ptrReal-1) += tmp1;
signalReal -= tmp2;
} else {
*(ptrReal-1) -= tmp1;
signalReal += tmp2;
}
*ptrReal++ = signalReal;
freqInvFlag = !freqInvFlag;
}
}
pNoiseLevel++;
if ( noSubbands > 2 ) {
if (!(harmIndex&0x1)) {
/* harmIndex 0,2 */
if(!harmIndex)
{
sineSign = 0;
}
for (k=noSubbands-2; k!=0; k--) {
FIXP_DBL sinelevel = *pSineLevel++;
index++;
if (((signalReal = (sineSign ? -sinelevel : sinelevel)) == FL2FXCONST_DBL(0.0f)) && !noNoiseFlag)
{
/* Add noisefloor to the amplified signal */
index &= (SBR_NF_NO_RANDOM_VAL - 1);
signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
}
/* The next multiplication constitutes the actual envelope adjustment of the signal. */
signalReal += fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
pNoiseLevel++;
*ptrReal++ = signalReal;
} /* for ... */
}
else {
/* harmIndex 1,3 in combination with freqInvFlag */
if (harmIndex==1) freqInvFlag = !freqInvFlag;
for (k=noSubbands-2; k!=0; k--) {
index++;
/* The next multiplication constitutes the actual envelope adjustment of the signal. */
signalReal = fMultDiv2(*ptrReal,*pGain++) << ((int)scale_change);
if (*pSineLevel++!=FL2FXCONST_DBL(0.0f)) tone_count++;
else if (!noNoiseFlag) {
/* Add noisefloor to the amplified signal */
index &= (SBR_NF_NO_RANDOM_VAL - 1);
signalReal += (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
}
pNoiseLevel++;
if (tone_count <= 16) {
FIXP_DBL addSine = fMultDiv2((pSineLevel[-2] - pSineLevel[0]), C1);
signalReal += (freqInvFlag) ? (-addSine) : (addSine);
}
*ptrReal++ = signalReal;
freqInvFlag = !freqInvFlag;
} /* for ... */
}
}
if (noSubbands > -1) {
index++;
/* The next multiplication constitutes the actual envelope adjustment of the signal. */
signalReal = fMultDiv2(*ptrReal,*pGain) << ((int)scale_change);
sineLevelPrev = fMultDiv2(pSineLevel[-1],FL2FX_SGL(0.0163f));
sineLevel = pSineLevel[0];
if (pSineLevel[0]!=FL2FXCONST_DBL(0.0f)) tone_count++;
else if (!noNoiseFlag) {
/* Add noisefloor to the amplified signal */
index &= (SBR_NF_NO_RANDOM_VAL - 1);
signalReal = signalReal + (fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], pNoiseLevel[0])<<4);
}
if (!(harmIndex&0x1)) {
/* harmIndex 0,2 */
*ptrReal = signalReal + ( (sineSign) ? -sineLevel : sineLevel);
}
else {
/* harmIndex 1,3 in combination with freqInvFlag */
if(tone_count <= 16){
if (freqInvFlag) {
*ptrReal++ = signalReal - sineLevelPrev;
if (noSubbands + lowSubband < 63)
*ptrReal = *ptrReal + fMultDiv2(C1, sineLevel);
}
else {
*ptrReal++ = signalReal + sineLevelPrev;
if (noSubbands + lowSubband < 63)
*ptrReal = *ptrReal - fMultDiv2(C1, sineLevel);
}
}
else *ptrReal = signalReal;
}
}
*ptrHarmIndex = (harmIndex + 1) & 3;
*ptrPhaseIndex = index & (SBR_NF_NO_RANDOM_VAL - 1);
}
void adjustTimeSlotHQ(FIXP_DBL *RESTRICT ptrReal, /*!< Subband samples to be adjusted, real part */
FIXP_DBL *RESTRICT ptrImag, /*!< Subband samples to be adjusted, imag part */
HANDLE_SBR_CALCULATE_ENVELOPE h_sbr_cal_env,
ENV_CALC_NRGS* nrgs,
int lowSubband, /*!< Lowest QMF-channel in the currently used SBR range. */
int noSubbands, /*!< Number of QMF subbands */
int scale_change, /*!< Number of bits to shift adjusted samples */
FIXP_SGL smooth_ratio, /*!< Impact of last envelope */
int noNoiseFlag, /*!< Start index to random number array */
int filtBufferNoiseShift) /*!< Shift factor of filtBufferNoise */
{
FIXP_DBL *RESTRICT gain = nrgs->nrgGain; /*!< Gains of current envelope */
FIXP_DBL *RESTRICT noiseLevel = nrgs->noiseLevel; /*!< Noise levels of current envelope */
FIXP_DBL *RESTRICT pSineLevel = nrgs->nrgSine; /*!< Sine levels */
FIXP_DBL *RESTRICT filtBuffer = h_sbr_cal_env->filtBuffer; /*!< Gains of last envelope */
FIXP_DBL *RESTRICT filtBufferNoise = h_sbr_cal_env->filtBufferNoise; /*!< Noise levels of last envelope */
UCHAR *RESTRICT ptrHarmIndex =&h_sbr_cal_env->harmIndex; /*!< Harmonic index */
int *RESTRICT ptrPhaseIndex =&h_sbr_cal_env->phaseIndex; /*!< Start index to random number array */
int k;
FIXP_DBL signalReal, signalImag;
FIXP_DBL noiseReal, noiseImag;
FIXP_DBL smoothedGain, smoothedNoise;
FIXP_SGL direct_ratio = /*FL2FXCONST_SGL(1.0f) */ (FIXP_SGL)MAXVAL_SGL - smooth_ratio;
int index = *ptrPhaseIndex;
UCHAR harmIndex = *ptrHarmIndex;
register int freqInvFlag = (lowSubband & 1);
FIXP_DBL sineLevel;
int shift;
*ptrPhaseIndex = (index+noSubbands) & (SBR_NF_NO_RANDOM_VAL - 1);
*ptrHarmIndex = (harmIndex + 1) & 3;
/*
Possible optimization:
smooth_ratio and harmIndex stay constant during the loop.
It might be faster to include a separate loop in each path.
the check for smooth_ratio is now outside the loop and the workload
of the whole function decreased by about 20 %
*/
filtBufferNoiseShift += 1; /* due to later use of fMultDiv2 instead of fMult */
if (filtBufferNoiseShift<0)
shift = fixMin(DFRACT_BITS-1,-filtBufferNoiseShift);
else
shift = fixMin(DFRACT_BITS-1, filtBufferNoiseShift);
if (smooth_ratio > FL2FXCONST_SGL(0.0f)) {
for (k=0; k<noSubbands; k++) {
/*
Smoothing: The old envelope has been bufferd and a certain ratio
of the old gains and noise levels is used.
*/
smoothedGain = fMult(smooth_ratio,filtBuffer[k]) +
fMult(direct_ratio,gain[k]);
if (filtBufferNoiseShift<0) {
smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])>>shift) +
fMult(direct_ratio,noiseLevel[k]);
}
else {
smoothedNoise = (fMultDiv2(smooth_ratio,filtBufferNoise[k])<<shift) +
fMult(direct_ratio,noiseLevel[k]);
}
/*
The next 2 multiplications constitute the actual envelope adjustment
of the signal and should be carried out with full accuracy
(supplying #DFRACT_BITS valid bits).
*/
signalReal = fMultDiv2(*ptrReal,smoothedGain)<<((int)scale_change);
signalImag = fMultDiv2(*ptrImag,smoothedGain)<<((int)scale_change);
index++;
if (pSineLevel[k] != FL2FXCONST_DBL(0.0f)) {
sineLevel = pSineLevel[k];
switch(harmIndex) {
case 0:
*ptrReal++ = (signalReal + sineLevel);
*ptrImag++ = (signalImag);
break;
case 2:
*ptrReal++ = (signalReal - sineLevel);
*ptrImag++ = (signalImag);
break;
case 1:
*ptrReal++ = (signalReal);
if (freqInvFlag)
*ptrImag++ = (signalImag - sineLevel);
else
*ptrImag++ = (signalImag + sineLevel);
break;
case 3:
*ptrReal++ = signalReal;
if (freqInvFlag)
*ptrImag++ = (signalImag + sineLevel);
else
*ptrImag++ = (signalImag - sineLevel);
break;
}
}
else {
if (noNoiseFlag) {
/* Just the amplified signal is saved */
*ptrReal++ = (signalReal);
*ptrImag++ = (signalImag);
}
else {
/* Add noisefloor to the amplified signal */
index &= (SBR_NF_NO_RANDOM_VAL - 1);
noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise)<<4;
noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise)<<4;
*ptrReal++ = (signalReal + noiseReal);
*ptrImag++ = (signalImag + noiseImag);
}
}
freqInvFlag ^= 1;
}
}
else
{
for (k=0; k<noSubbands; k++)
{
smoothedGain = gain[k];
signalReal = fMultDiv2(*ptrReal, smoothedGain) << scale_change;
signalImag = fMultDiv2(*ptrImag, smoothedGain) << scale_change;
index++;
if ((sineLevel = pSineLevel[k]) != FL2FXCONST_DBL(0.0f))
{
switch (harmIndex)
{
case 0:
signalReal += sineLevel;
break;
case 1:
if (freqInvFlag)
signalImag -= sineLevel;
else
signalImag += sineLevel;
break;
case 2:
signalReal -= sineLevel;
break;
case 3:
if (freqInvFlag)
signalImag += sineLevel;
else
signalImag -= sineLevel;
break;
}
}
else
{
if (noNoiseFlag == 0)
{
/* Add noisefloor to the amplified signal */
smoothedNoise = noiseLevel[k];
index &= (SBR_NF_NO_RANDOM_VAL - 1);
noiseReal = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][0], smoothedNoise);
noiseImag = fMultDiv2(FDK_sbrDecoder_sbr_randomPhase[index][1], smoothedNoise);
signalReal += noiseReal<<4;
signalImag += noiseImag<<4;
}
}
*ptrReal++ = signalReal;
*ptrImag++ = signalImag;
freqInvFlag ^= 1;
}
}
}
/*!
\brief Reset limiter bands.
Build frequency band table for the gain limiter dependent on
the previously generated transposer patch areas.
\return SBRDEC_OK if ok, SBRDEC_UNSUPPORTED_CONFIG on error
*/
SBR_ERROR
ResetLimiterBands ( UCHAR *limiterBandTable, /*!< Resulting band borders in QMF channels */
UCHAR *noLimiterBands, /*!< Resulting number of limiter band */
UCHAR *freqBandTable, /*!< Table with possible band borders */
int noFreqBands, /*!< Number of bands in freqBandTable */
const PATCH_PARAM *patchParam, /*!< Transposer patch parameters */
int noPatches, /*!< Number of transposer patches */
int limiterBands) /*!< Selected 'band density' from bitstream */
{
int i, k, isPatchBorder[2], loLimIndex, hiLimIndex, tempNoLim, nBands;
UCHAR workLimiterBandTable[MAX_FREQ_COEFFS / 2 + MAX_NUM_PATCHES + 1];
int patchBorders[MAX_NUM_PATCHES + 1];
int kx, k2;
FIXP_DBL temp;
int lowSubband = freqBandTable[0];
int highSubband = freqBandTable[noFreqBands];
/* 1 limiter band. */
if(limiterBands == 0) {
limiterBandTable[0] = 0;
limiterBandTable[1] = highSubband - lowSubband;
nBands = 1;
} else {
for (i = 0; i < noPatches; i++) {
patchBorders[i] = patchParam[i].guardStartBand - lowSubband;
}
patchBorders[i] = highSubband - lowSubband;
/* 1.2, 2, or 3 limiter bands/octave plus bandborders at patchborders. */
for (k = 0; k <= noFreqBands; k++) {
workLimiterBandTable[k] = freqBandTable[k] - lowSubband;
}
for (k = 1; k < noPatches; k++) {
workLimiterBandTable[noFreqBands + k] = patchBorders[k];
}
tempNoLim = nBands = noFreqBands + noPatches - 1;
shellsort(workLimiterBandTable, tempNoLim + 1);
loLimIndex = 0;
hiLimIndex = 1;
while (hiLimIndex <= tempNoLim) {
k2 = workLimiterBandTable[hiLimIndex] + lowSubband;
kx = workLimiterBandTable[loLimIndex] + lowSubband;
temp = FX_SGL2FX_DBL(FDK_getNumOctavesDiv8(kx,k2)); /* Number of octaves */
temp = fMult(temp, FDK_sbrDecoder_sbr_limiterBandsPerOctaveDiv4[limiterBands]);
if (temp < FL2FXCONST_DBL (0.49f)>>5) {
if (workLimiterBandTable[hiLimIndex] == workLimiterBandTable[loLimIndex]) {
workLimiterBandTable[hiLimIndex] = highSubband;
nBands--;
hiLimIndex++;
continue;
}
isPatchBorder[0] = isPatchBorder[1] = 0;
for (k = 0; k <= noPatches; k++) {
if (workLimiterBandTable[hiLimIndex] == patchBorders[k]) {
isPatchBorder[1] = 1;
break;
}
}
if (!isPatchBorder[1]) {
workLimiterBandTable[hiLimIndex] = highSubband;
nBands--;
hiLimIndex++;
continue;
}
for (k = 0; k <= noPatches; k++) {
if (workLimiterBandTable[loLimIndex] == patchBorders[k]) {
isPatchBorder[0] = 1;
break;
}
}
if (!isPatchBorder[0]) {
workLimiterBandTable[loLimIndex] = highSubband;
nBands--;
}
}
loLimIndex = hiLimIndex;
hiLimIndex++;
}
shellsort(workLimiterBandTable, tempNoLim + 1);
/* Test if algorithm exceeded maximum allowed limiterbands */
if( nBands > MAX_NUM_LIMITERS || nBands <= 0) {
return SBRDEC_UNSUPPORTED_CONFIG;
}
/* Copy limiterbands from working buffer into final destination */
for (k = 0; k <= nBands; k++) {
limiterBandTable[k] = workLimiterBandTable[k];
}
}
*noLimiterBands = nBands;
return SBRDEC_OK;
}