mirror of https://github.com/mstorsjo/fdk-aac.git
1093 lines
41 KiB
C++
1093 lines
41 KiB
C++
/* -----------------------------------------------------------------------------
|
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
|
|
© Copyright 1995 - 2018 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
|
|
----------------------------------------------------------------------------- */
|
|
|
|
/**************************** SBR encoder library ******************************
|
|
|
|
Author(s): Tobias Chalupka
|
|
|
|
Description: SBR encoder transient detector
|
|
|
|
*******************************************************************************/
|
|
|
|
#include "tran_det.h"
|
|
|
|
#include "fram_gen.h"
|
|
#include "sbrenc_ram.h"
|
|
#include "sbr_misc.h"
|
|
|
|
#include "genericStds.h"
|
|
|
|
#define NORM_QMF_ENERGY 9.31322574615479E-10 /* 2^-30 */
|
|
|
|
/* static FIXP_DBL ABS_THRES = fixMax( FL2FXCONST_DBL(1.28e5 *
|
|
* NORM_QMF_ENERGY), (FIXP_DBL)1) Minimum threshold for detecting changes */
|
|
#define ABS_THRES ((FIXP_DBL)16)
|
|
|
|
/*******************************************************************************
|
|
Functionname: spectralChange
|
|
*******************************************************************************
|
|
\brief Calculates a measure for the spectral change within the frame
|
|
|
|
The function says how good it would be to split the frame at the given border
|
|
position into 2 envelopes.
|
|
|
|
The return value delta_sum is scaled with the factor 1/64
|
|
|
|
\return calculated value
|
|
*******************************************************************************/
|
|
#define NRG_SHIFT 3 /* for energy summation */
|
|
|
|
static FIXP_DBL spectralChange(
|
|
FIXP_DBL Energies[NUMBER_TIME_SLOTS_2304][MAX_FREQ_COEFFS],
|
|
INT *scaleEnergies, FIXP_DBL EnergyTotal, INT nSfb, INT start, INT border,
|
|
INT YBufferWriteOffset, INT stop, INT *result_e) {
|
|
INT i, j;
|
|
INT len1, len2;
|
|
SCHAR energies_e_diff[NUMBER_TIME_SLOTS_2304], energies_e, energyTotal_e = 19,
|
|
energies_e_add;
|
|
SCHAR prevEnergies_e_diff, newEnergies_e_diff;
|
|
FIXP_DBL tmp0, tmp1;
|
|
FIXP_DBL delta, delta_sum;
|
|
INT accu_e, tmp_e;
|
|
|
|
delta_sum = FL2FXCONST_DBL(0.0f);
|
|
*result_e = 0;
|
|
|
|
len1 = border - start;
|
|
len2 = stop - border;
|
|
|
|
/* prefer borders near the middle of the frame */
|
|
FIXP_DBL pos_weight;
|
|
pos_weight = FL2FXCONST_DBL(0.5f) - (len1 * GetInvInt(len1 + len2));
|
|
pos_weight = /*FL2FXCONST_DBL(1.0)*/ (FIXP_DBL)MAXVAL_DBL -
|
|
(fMult(pos_weight, pos_weight) << 2);
|
|
|
|
/*** Calc scaling for energies ***/
|
|
FDK_ASSERT(scaleEnergies[0] >= 0);
|
|
FDK_ASSERT(scaleEnergies[1] >= 0);
|
|
|
|
energies_e = 19 - fMin(scaleEnergies[0], scaleEnergies[1]);
|
|
|
|
/* limit shift for energy accumulation, energies_e can be -10 min. */
|
|
if (energies_e < -10) {
|
|
energies_e_add = -10 - energies_e;
|
|
energies_e = -10;
|
|
} else if (energies_e > 17) {
|
|
energies_e_add = energies_e - 17;
|
|
energies_e = 17;
|
|
} else {
|
|
energies_e_add = 0;
|
|
}
|
|
|
|
/* compensate scaling differences between scaleEnergies[0] and
|
|
* scaleEnergies[1] */
|
|
prevEnergies_e_diff = scaleEnergies[0] -
|
|
fMin(scaleEnergies[0], scaleEnergies[1]) +
|
|
energies_e_add + NRG_SHIFT;
|
|
newEnergies_e_diff = scaleEnergies[1] -
|
|
fMin(scaleEnergies[0], scaleEnergies[1]) +
|
|
energies_e_add + NRG_SHIFT;
|
|
|
|
prevEnergies_e_diff = fMin(prevEnergies_e_diff, DFRACT_BITS - 1);
|
|
newEnergies_e_diff = fMin(newEnergies_e_diff, DFRACT_BITS - 1);
|
|
|
|
for (i = start; i < YBufferWriteOffset; i++) {
|
|
energies_e_diff[i] = prevEnergies_e_diff;
|
|
}
|
|
for (i = YBufferWriteOffset; i < stop; i++) {
|
|
energies_e_diff[i] = newEnergies_e_diff;
|
|
}
|
|
|
|
/* Sum up energies of all QMF-timeslots for both halfs */
|
|
FDK_ASSERT(len1 <= 8); /* otherwise an overflow is possible */
|
|
FDK_ASSERT(len2 <= 8); /* otherwise an overflow is possible */
|
|
|
|
for (j = 0; j < nSfb; j++) {
|
|
FIXP_DBL accu1 = FL2FXCONST_DBL(0.f);
|
|
FIXP_DBL accu2 = FL2FXCONST_DBL(0.f);
|
|
accu_e = energies_e + 3;
|
|
|
|
/* Sum up energies in first half */
|
|
for (i = start; i < border; i++) {
|
|
accu1 += scaleValue(Energies[i][j], -energies_e_diff[i]);
|
|
}
|
|
|
|
/* Sum up energies in second half */
|
|
for (i = border; i < stop; i++) {
|
|
accu2 += scaleValue(Energies[i][j], -energies_e_diff[i]);
|
|
}
|
|
|
|
/* Ensure certain energy to prevent division by zero and to prevent
|
|
* splitting for very low levels */
|
|
accu1 = fMax(accu1, (FIXP_DBL)len1);
|
|
accu2 = fMax(accu2, (FIXP_DBL)len2);
|
|
|
|
/* Energy change in current band */
|
|
#define LN2 FL2FXCONST_DBL(0.6931471806f) /* ln(2) */
|
|
tmp0 = fLog2(accu2, accu_e) - fLog2(accu1, accu_e);
|
|
tmp1 = fLog2((FIXP_DBL)len1, 31) - fLog2((FIXP_DBL)len2, 31);
|
|
delta = fMult(LN2, (tmp0 + tmp1));
|
|
delta = (FIXP_DBL)fAbs(delta);
|
|
|
|
/* Weighting with amplitude ratio of this band */
|
|
accu_e++; /* scale at least one bit due to (accu1+accu2) */
|
|
accu1 >>= 1;
|
|
accu2 >>= 1;
|
|
|
|
if (accu_e & 1) {
|
|
accu_e++; /* for a defined square result exponent, the exponent has to be
|
|
even */
|
|
accu1 >>= 1;
|
|
accu2 >>= 1;
|
|
}
|
|
|
|
delta_sum += fMult(sqrtFixp(accu1 + accu2), delta);
|
|
*result_e = ((accu_e >> 1) + LD_DATA_SHIFT);
|
|
}
|
|
|
|
if (energyTotal_e & 1) {
|
|
energyTotal_e += 1; /* for a defined square result exponent, the exponent
|
|
has to be even */
|
|
EnergyTotal >>= 1;
|
|
}
|
|
|
|
delta_sum = fMult(delta_sum, invSqrtNorm2(EnergyTotal, &tmp_e));
|
|
*result_e = *result_e + (tmp_e - (energyTotal_e >> 1));
|
|
|
|
return fMult(delta_sum, pos_weight);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
Functionname: addLowbandEnergies
|
|
*******************************************************************************
|
|
\brief Calculates total lowband energy
|
|
|
|
The input values Energies[0] (low-band) are scaled by the factor
|
|
2^(14-*scaleEnergies[0])
|
|
The input values Energies[1] (high-band) are scaled by the factor
|
|
2^(14-*scaleEnergies[1])
|
|
|
|
\return total energy in the lowband, scaled by the factor 2^19
|
|
*******************************************************************************/
|
|
static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, int *scaleEnergies,
|
|
int YBufferWriteOffset, int nrgSzShift,
|
|
int tran_off, UCHAR *freqBandTable,
|
|
int slots) {
|
|
INT nrgTotal_e;
|
|
FIXP_DBL nrgTotal_m;
|
|
FIXP_DBL accu1 = FL2FXCONST_DBL(0.0f);
|
|
FIXP_DBL accu2 = FL2FXCONST_DBL(0.0f);
|
|
int tran_offdiv2 = tran_off >> nrgSzShift;
|
|
const int sc1 =
|
|
DFRACT_BITS -
|
|
fNormz((FIXP_DBL)fMax(
|
|
1, (freqBandTable[0] * (YBufferWriteOffset - tran_offdiv2) - 1)));
|
|
const int sc2 =
|
|
DFRACT_BITS -
|
|
fNormz((FIXP_DBL)fMax(
|
|
1, (freqBandTable[0] *
|
|
(tran_offdiv2 + (slots >> nrgSzShift) - YBufferWriteOffset) -
|
|
1)));
|
|
int ts, k;
|
|
|
|
/* Sum up lowband energy from one frame at offset tran_off */
|
|
/* freqBandTable[LORES] has MAX_FREQ_COEFFS/2 +1 coeefs max. */
|
|
for (ts = tran_offdiv2; ts < YBufferWriteOffset; ts++) {
|
|
for (k = 0; k < freqBandTable[0]; k++) {
|
|
accu1 += Energies[ts][k] >> sc1;
|
|
}
|
|
}
|
|
for (; ts < tran_offdiv2 + (slots >> nrgSzShift); ts++) {
|
|
for (k = 0; k < freqBandTable[0]; k++) {
|
|
accu2 += Energies[ts][k] >> sc2;
|
|
}
|
|
}
|
|
|
|
nrgTotal_m = fAddNorm(accu1, (sc1 - 5) - scaleEnergies[0], accu2,
|
|
(sc2 - 5) - scaleEnergies[1], &nrgTotal_e);
|
|
nrgTotal_m = scaleValueSaturate(nrgTotal_m, nrgTotal_e);
|
|
|
|
return (nrgTotal_m);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
Functionname: addHighbandEnergies
|
|
*******************************************************************************
|
|
\brief Add highband energies
|
|
|
|
Highband energies are mapped to an array with smaller dimension:
|
|
Its time resolution is only 1 SBR-timeslot and its frequency resolution
|
|
is 1 SBR-band. Therefore the data to be fed into the spectralChange
|
|
function is reduced.
|
|
|
|
The values EnergiesM are scaled by the factor (2^19-scaleEnergies[0]) for
|
|
slots<YBufferWriteOffset and by the factor (2^19-scaleEnergies[1]) for
|
|
slots>=YBufferWriteOffset.
|
|
|
|
\return total energy in the highband, scaled by factor 2^19
|
|
*******************************************************************************/
|
|
|
|
static FIXP_DBL addHighbandEnergies(
|
|
FIXP_DBL **RESTRICT Energies, /*!< input */
|
|
INT *scaleEnergies, INT YBufferWriteOffset,
|
|
FIXP_DBL EnergiesM[NUMBER_TIME_SLOTS_2304]
|
|
[MAX_FREQ_COEFFS], /*!< Combined output */
|
|
UCHAR *RESTRICT freqBandTable, INT nSfb, INT sbrSlots, INT timeStep) {
|
|
INT i, j, k, slotIn, slotOut, scale[2];
|
|
INT li, ui;
|
|
FIXP_DBL nrgTotal;
|
|
FIXP_DBL accu = FL2FXCONST_DBL(0.0f);
|
|
|
|
/* Combine QMF-timeslots to SBR-timeslots,
|
|
combine QMF-bands to SBR-bands,
|
|
combine Left and Right channel */
|
|
for (slotOut = 0; slotOut < sbrSlots; slotOut++) {
|
|
/* Note: Below slotIn = slotOut and not slotIn = timeStep*slotOut
|
|
because the Energies[] time resolution is always the SBR slot resolution
|
|
regardless of the timeStep. */
|
|
slotIn = slotOut;
|
|
|
|
for (j = 0; j < nSfb; j++) {
|
|
accu = FL2FXCONST_DBL(0.0f);
|
|
|
|
li = freqBandTable[j];
|
|
ui = freqBandTable[j + 1];
|
|
|
|
for (k = li; k < ui; k++) {
|
|
for (i = 0; i < timeStep; i++) {
|
|
accu += Energies[slotIn][k] >> 5;
|
|
}
|
|
}
|
|
EnergiesM[slotOut][j] = accu;
|
|
}
|
|
}
|
|
|
|
/* scale energies down before add up */
|
|
scale[0] = fixMin(8, scaleEnergies[0]);
|
|
scale[1] = fixMin(8, scaleEnergies[1]);
|
|
|
|
if ((scaleEnergies[0] - scale[0]) > (DFRACT_BITS - 1) ||
|
|
(scaleEnergies[1] - scale[1]) > (DFRACT_BITS - 1))
|
|
nrgTotal = FL2FXCONST_DBL(0.0f);
|
|
else {
|
|
/* Now add all energies */
|
|
accu = FL2FXCONST_DBL(0.0f);
|
|
|
|
for (slotOut = 0; slotOut < YBufferWriteOffset; slotOut++) {
|
|
for (j = 0; j < nSfb; j++) {
|
|
accu += (EnergiesM[slotOut][j] >> scale[0]);
|
|
}
|
|
}
|
|
nrgTotal = accu >> (scaleEnergies[0] - scale[0]);
|
|
|
|
for (slotOut = YBufferWriteOffset; slotOut < sbrSlots; slotOut++) {
|
|
for (j = 0; j < nSfb; j++) {
|
|
accu += (EnergiesM[slotOut][j] >> scale[0]);
|
|
}
|
|
}
|
|
nrgTotal = fAddSaturate(nrgTotal, accu >> (scaleEnergies[1] - scale[1]));
|
|
}
|
|
|
|
return (nrgTotal);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
Functionname: FDKsbrEnc_frameSplitter
|
|
*******************************************************************************
|
|
\brief Decides if a FIXFIX-frame shall be splitted into 2 envelopes
|
|
|
|
If no transient has been detected before, the frame can still be splitted
|
|
into 2 envelopes.
|
|
*******************************************************************************/
|
|
void FDKsbrEnc_frameSplitter(
|
|
FIXP_DBL **Energies, INT *scaleEnergies,
|
|
HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientDetector, UCHAR *freqBandTable,
|
|
UCHAR *tran_vector, int YBufferWriteOffset, int YBufferSzShift, int nSfb,
|
|
int timeStep, int no_cols, FIXP_DBL *tonality) {
|
|
if (tran_vector[1] == 0) /* no transient was detected */
|
|
{
|
|
FIXP_DBL delta;
|
|
INT delta_e;
|
|
FIXP_DBL(*EnergiesM)[MAX_FREQ_COEFFS];
|
|
FIXP_DBL EnergyTotal, newLowbandEnergy, newHighbandEnergy;
|
|
INT border;
|
|
INT sbrSlots = fMultI(GetInvInt(timeStep), no_cols);
|
|
C_ALLOC_SCRATCH_START(_EnergiesM, FIXP_DBL,
|
|
NUMBER_TIME_SLOTS_2304 * MAX_FREQ_COEFFS)
|
|
|
|
FDK_ASSERT(sbrSlots * timeStep == no_cols);
|
|
|
|
EnergiesM = (FIXP_DBL(*)[MAX_FREQ_COEFFS])_EnergiesM;
|
|
|
|
/*
|
|
Get Lowband-energy over a range of 2 frames (Look half a frame back and
|
|
ahead).
|
|
*/
|
|
newLowbandEnergy = addLowbandEnergies(
|
|
Energies, scaleEnergies, YBufferWriteOffset, YBufferSzShift,
|
|
h_sbrTransientDetector->tran_off, freqBandTable, no_cols);
|
|
|
|
newHighbandEnergy =
|
|
addHighbandEnergies(Energies, scaleEnergies, YBufferWriteOffset,
|
|
EnergiesM, freqBandTable, nSfb, sbrSlots, timeStep);
|
|
|
|
{
|
|
/* prevLowBandEnergy: Corresponds to 1 frame, starting with half a frame
|
|
look-behind newLowbandEnergy: Corresponds to 1 frame, starting in the
|
|
middle of the current frame */
|
|
EnergyTotal = (newLowbandEnergy >> 1) +
|
|
(h_sbrTransientDetector->prevLowBandEnergy >>
|
|
1); /* mean of new and prev LB NRG */
|
|
EnergyTotal =
|
|
fAddSaturate(EnergyTotal, newHighbandEnergy); /* Add HB NRG */
|
|
/* The below border should specify the same position as the middle border
|
|
of a FIXFIX-frame with 2 envelopes. */
|
|
border = (sbrSlots + 1) >> 1;
|
|
|
|
if ((INT)EnergyTotal & 0xffffffe0 &&
|
|
(scaleEnergies[0] < 32 || scaleEnergies[1] < 32)) /* i.e. > 31 */ {
|
|
delta = spectralChange(EnergiesM, scaleEnergies, EnergyTotal, nSfb, 0,
|
|
border, YBufferWriteOffset, sbrSlots, &delta_e);
|
|
} else {
|
|
delta = FL2FXCONST_DBL(0.0f);
|
|
delta_e = 0;
|
|
|
|
/* set tonality to 0 when energy is very low, since the amplitude
|
|
resolution should then be low as well */
|
|
*tonality = FL2FXCONST_DBL(0.0f);
|
|
}
|
|
|
|
if (fIsLessThan(h_sbrTransientDetector->split_thr_m,
|
|
h_sbrTransientDetector->split_thr_e, delta, delta_e)) {
|
|
tran_vector[0] = 1; /* Set flag for splitting */
|
|
} else {
|
|
tran_vector[0] = 0;
|
|
}
|
|
}
|
|
|
|
/* Update prevLowBandEnergy */
|
|
h_sbrTransientDetector->prevLowBandEnergy = newLowbandEnergy;
|
|
h_sbrTransientDetector->prevHighBandEnergy = newHighbandEnergy;
|
|
C_ALLOC_SCRATCH_END(_EnergiesM, FIXP_DBL,
|
|
NUMBER_TIME_SLOTS_2304 * MAX_FREQ_COEFFS)
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Calculate transient energy threshold for each QMF band
|
|
*/
|
|
static void calculateThresholds(FIXP_DBL **RESTRICT Energies,
|
|
INT *RESTRICT scaleEnergies,
|
|
FIXP_DBL *RESTRICT thresholds,
|
|
int YBufferWriteOffset, int YBufferSzShift,
|
|
int noCols, int noRows, int tran_off) {
|
|
FIXP_DBL mean_val, std_val, temp;
|
|
FIXP_DBL i_noCols;
|
|
FIXP_DBL i_noCols1;
|
|
FIXP_DBL accu, accu0, accu1;
|
|
int scaleFactor0, scaleFactor1, commonScale;
|
|
int i, j;
|
|
|
|
i_noCols = GetInvInt(noCols + tran_off) << YBufferSzShift;
|
|
i_noCols1 = GetInvInt(noCols + tran_off - 1) << YBufferSzShift;
|
|
|
|
/* calc minimum scale of energies of previous and current frame */
|
|
commonScale = fixMin(scaleEnergies[0], scaleEnergies[1]);
|
|
|
|
/* calc scalefactors to adapt energies to common scale */
|
|
scaleFactor0 = fixMin((scaleEnergies[0] - commonScale), (DFRACT_BITS - 1));
|
|
scaleFactor1 = fixMin((scaleEnergies[1] - commonScale), (DFRACT_BITS - 1));
|
|
|
|
FDK_ASSERT((scaleFactor0 >= 0) && (scaleFactor1 >= 0));
|
|
|
|
/* calculate standard deviation in every subband */
|
|
for (i = 0; i < noRows; i++) {
|
|
int startEnergy = (tran_off >> YBufferSzShift);
|
|
int endEnergy = ((noCols >> YBufferSzShift) + tran_off);
|
|
int shift;
|
|
|
|
/* calculate mean value over decimated energy values (downsampled by 2). */
|
|
accu0 = accu1 = FL2FXCONST_DBL(0.0f);
|
|
|
|
for (j = startEnergy; j < YBufferWriteOffset; j++)
|
|
accu0 = fMultAddDiv2(accu0, Energies[j][i], i_noCols);
|
|
for (; j < endEnergy; j++)
|
|
accu1 = fMultAddDiv2(accu1, Energies[j][i], i_noCols);
|
|
|
|
mean_val = ((accu0 << 1) >> scaleFactor0) +
|
|
((accu1 << 1) >> scaleFactor1); /* average */
|
|
shift = fixMax(
|
|
0, CountLeadingBits(mean_val) -
|
|
6); /* -6 to keep room for accumulating upto N = 24 values */
|
|
|
|
/* calculate standard deviation */
|
|
accu = FL2FXCONST_DBL(0.0f);
|
|
|
|
/* summe { ((mean_val-nrg)^2) * i_noCols1 } */
|
|
for (j = startEnergy; j < YBufferWriteOffset; j++) {
|
|
temp = ((FIXP_DBL)mean_val - ((FIXP_DBL)Energies[j][i] >> scaleFactor0))
|
|
<< shift;
|
|
temp = fPow2Div2(temp);
|
|
accu = fMultAddDiv2(accu, temp, i_noCols1);
|
|
}
|
|
for (; j < endEnergy; j++) {
|
|
temp = ((FIXP_DBL)mean_val - ((FIXP_DBL)Energies[j][i] >> scaleFactor1))
|
|
<< shift;
|
|
temp = fPow2Div2(temp);
|
|
accu = fMultAddDiv2(accu, temp, i_noCols1);
|
|
}
|
|
accu <<= 2;
|
|
std_val = sqrtFixp(accu) >> shift; /* standard deviation */
|
|
|
|
/*
|
|
Take new threshold as average of calculated standard deviation ratio
|
|
and old threshold if greater than absolute threshold
|
|
*/
|
|
temp = (commonScale <= (DFRACT_BITS - 1))
|
|
? fMult(FL2FXCONST_DBL(0.66f), thresholds[i]) +
|
|
(fMult(FL2FXCONST_DBL(0.34f), std_val) >> commonScale)
|
|
: (FIXP_DBL)0;
|
|
|
|
thresholds[i] = fixMax(ABS_THRES, temp);
|
|
|
|
FDK_ASSERT(commonScale >= 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Calculate transient levels for each QMF time slot.
|
|
*/
|
|
static void extractTransientCandidates(
|
|
FIXP_DBL **RESTRICT Energies, INT *RESTRICT scaleEnergies,
|
|
FIXP_DBL *RESTRICT thresholds, FIXP_DBL *RESTRICT transients,
|
|
int YBufferWriteOffset, int YBufferSzShift, int noCols, int start_band,
|
|
int stop_band, int tran_off, int addPrevSamples) {
|
|
FIXP_DBL i_thres;
|
|
C_ALLOC_SCRATCH_START(EnergiesTemp, FIXP_DBL, 2 * 32)
|
|
int tmpScaleEnergies0, tmpScaleEnergies1;
|
|
int endCond;
|
|
int startEnerg, endEnerg;
|
|
int i, j, jIndex, jpBM;
|
|
|
|
tmpScaleEnergies0 = scaleEnergies[0];
|
|
tmpScaleEnergies1 = scaleEnergies[1];
|
|
|
|
/* Scale value for first energies, upto YBufferWriteOffset */
|
|
tmpScaleEnergies0 = fixMin(tmpScaleEnergies0, MAX_SHIFT_DBL);
|
|
/* Scale value for first energies, from YBufferWriteOffset upwards */
|
|
tmpScaleEnergies1 = fixMin(tmpScaleEnergies1, MAX_SHIFT_DBL);
|
|
|
|
FDK_ASSERT((tmpScaleEnergies0 >= 0) && (tmpScaleEnergies1 >= 0));
|
|
|
|
/* Keep addPrevSamples extra previous transient candidates. */
|
|
FDKmemmove(transients, transients + noCols - addPrevSamples,
|
|
(tran_off + addPrevSamples) * sizeof(FIXP_DBL));
|
|
FDKmemclear(transients + tran_off + addPrevSamples,
|
|
noCols * sizeof(FIXP_DBL));
|
|
|
|
endCond = noCols; /* Amount of new transient values to be calculated. */
|
|
startEnerg = (tran_off - 3) >> YBufferSzShift; /* >>YBufferSzShift because of
|
|
amount of energy values. -3
|
|
because of neighbors being
|
|
watched. */
|
|
endEnerg =
|
|
((noCols + (YBufferWriteOffset << YBufferSzShift)) - 1) >>
|
|
YBufferSzShift; /* YBufferSzShift shifts because of half energy values. */
|
|
|
|
/* Compute differential values with two different weightings in every subband
|
|
*/
|
|
for (i = start_band; i < stop_band; i++) {
|
|
FIXP_DBL thres = thresholds[i];
|
|
|
|
if ((LONG)thresholds[i] >= 256)
|
|
i_thres = (LONG)((LONG)MAXVAL_DBL / ((((LONG)thresholds[i])) + 1))
|
|
<< (32 - 24);
|
|
else
|
|
i_thres = (LONG)MAXVAL_DBL;
|
|
|
|
/* Copy one timeslot and de-scale and de-squish */
|
|
if (YBufferSzShift == 1) {
|
|
for (j = startEnerg; j < YBufferWriteOffset; j++) {
|
|
FIXP_DBL tmp = Energies[j][i];
|
|
EnergiesTemp[(j << 1) + 1] = EnergiesTemp[j << 1] =
|
|
tmp >> tmpScaleEnergies0;
|
|
}
|
|
for (; j <= endEnerg; j++) {
|
|
FIXP_DBL tmp = Energies[j][i];
|
|
EnergiesTemp[(j << 1) + 1] = EnergiesTemp[j << 1] =
|
|
tmp >> tmpScaleEnergies1;
|
|
}
|
|
} else {
|
|
for (j = startEnerg; j < YBufferWriteOffset; j++) {
|
|
FIXP_DBL tmp = Energies[j][i];
|
|
EnergiesTemp[j] = tmp >> tmpScaleEnergies0;
|
|
}
|
|
for (; j <= endEnerg; j++) {
|
|
FIXP_DBL tmp = Energies[j][i];
|
|
EnergiesTemp[j] = tmp >> tmpScaleEnergies1;
|
|
}
|
|
}
|
|
|
|
/* Detect peaks in energy values. */
|
|
|
|
jIndex = tran_off;
|
|
jpBM = jIndex + addPrevSamples;
|
|
|
|
for (j = endCond; j--; jIndex++, jpBM++) {
|
|
FIXP_DBL delta, tran;
|
|
int d;
|
|
|
|
delta = (FIXP_DBL)0;
|
|
tran = (FIXP_DBL)0;
|
|
|
|
for (d = 1; d < 4; d++) {
|
|
delta += EnergiesTemp[jIndex + d]; /* R */
|
|
delta -= EnergiesTemp[jIndex - d]; /* L */
|
|
delta -= thres;
|
|
|
|
if (delta > (FIXP_DBL)0) {
|
|
tran = fMultAddDiv2(tran, i_thres, delta);
|
|
}
|
|
}
|
|
transients[jpBM] += (tran << 1);
|
|
}
|
|
}
|
|
C_ALLOC_SCRATCH_END(EnergiesTemp, FIXP_DBL, 2 * 32)
|
|
}
|
|
|
|
void FDKsbrEnc_transientDetect(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTran,
|
|
FIXP_DBL **Energies, INT *scaleEnergies,
|
|
UCHAR *transient_info, int YBufferWriteOffset,
|
|
int YBufferSzShift, int timeStep,
|
|
int frameMiddleBorder) {
|
|
int no_cols = h_sbrTran->no_cols;
|
|
int qmfStartSample;
|
|
int addPrevSamples;
|
|
int timeStepShift = 0;
|
|
int i, cond;
|
|
|
|
/* Where to start looking for transients in the transient candidate buffer */
|
|
qmfStartSample = timeStep * frameMiddleBorder;
|
|
/* We need to look one value backwards in the transients, so we might need one
|
|
* more previous value. */
|
|
addPrevSamples = (qmfStartSample > 0) ? 0 : 1;
|
|
|
|
switch (timeStep) {
|
|
case 1:
|
|
timeStepShift = 0;
|
|
break;
|
|
case 2:
|
|
timeStepShift = 1;
|
|
break;
|
|
case 4:
|
|
timeStepShift = 2;
|
|
break;
|
|
}
|
|
|
|
calculateThresholds(Energies, scaleEnergies, h_sbrTran->thresholds,
|
|
YBufferWriteOffset, YBufferSzShift, h_sbrTran->no_cols,
|
|
h_sbrTran->no_rows, h_sbrTran->tran_off);
|
|
|
|
extractTransientCandidates(
|
|
Energies, scaleEnergies, h_sbrTran->thresholds, h_sbrTran->transients,
|
|
YBufferWriteOffset, YBufferSzShift, h_sbrTran->no_cols, 0,
|
|
h_sbrTran->no_rows, h_sbrTran->tran_off, addPrevSamples);
|
|
|
|
transient_info[0] = 0;
|
|
transient_info[1] = 0;
|
|
transient_info[2] = 0;
|
|
|
|
/* Offset by the amount of additional previous transient candidates being
|
|
* kept. */
|
|
qmfStartSample += addPrevSamples;
|
|
|
|
/* Check for transients in second granule (pick the last value of subsequent
|
|
* values) */
|
|
for (i = qmfStartSample; i < qmfStartSample + no_cols; i++) {
|
|
cond = (h_sbrTran->transients[i] <
|
|
fMult(FL2FXCONST_DBL(0.9f), h_sbrTran->transients[i - 1])) &&
|
|
(h_sbrTran->transients[i - 1] > h_sbrTran->tran_thr);
|
|
|
|
if (cond) {
|
|
transient_info[0] = (i - qmfStartSample) >> timeStepShift;
|
|
transient_info[1] = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (h_sbrTran->frameShift != 0) {
|
|
/* transient prediction for LDSBR */
|
|
/* Check for transients in first <frameShift> qmf-slots of second frame */
|
|
for (i = qmfStartSample + no_cols;
|
|
i < qmfStartSample + no_cols + h_sbrTran->frameShift; i++) {
|
|
cond = (h_sbrTran->transients[i] <
|
|
fMult(FL2FXCONST_DBL(0.9f), h_sbrTran->transients[i - 1])) &&
|
|
(h_sbrTran->transients[i - 1] > h_sbrTran->tran_thr);
|
|
|
|
if (cond) {
|
|
int pos = (int)((i - qmfStartSample - no_cols) >> timeStepShift);
|
|
if ((pos < 3) && (transient_info[1] == 0)) {
|
|
transient_info[2] = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int FDKsbrEnc_InitSbrTransientDetector(
|
|
HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientDetector,
|
|
UINT sbrSyntaxFlags, /* SBR syntax flags derived from AOT. */
|
|
INT frameSize, INT sampleFreq, sbrConfigurationPtr params, int tran_fc,
|
|
int no_cols, int no_rows, int YBufferWriteOffset, int YBufferSzShift,
|
|
int frameShift, int tran_off) {
|
|
INT totalBitrate =
|
|
params->codecSettings.standardBitrate * params->codecSettings.nChannels;
|
|
INT codecBitrate = params->codecSettings.bitRate;
|
|
FIXP_DBL bitrateFactor_m, framedur_fix;
|
|
INT bitrateFactor_e, tmp_e;
|
|
|
|
FDKmemclear(h_sbrTransientDetector, sizeof(SBR_TRANSIENT_DETECTOR));
|
|
|
|
h_sbrTransientDetector->frameShift = frameShift;
|
|
h_sbrTransientDetector->tran_off = tran_off;
|
|
|
|
if (codecBitrate) {
|
|
bitrateFactor_m = fDivNorm((FIXP_DBL)totalBitrate,
|
|
(FIXP_DBL)(codecBitrate << 2), &bitrateFactor_e);
|
|
bitrateFactor_e += 2;
|
|
} else {
|
|
bitrateFactor_m = FL2FXCONST_DBL(1.0 / 4.0);
|
|
bitrateFactor_e = 2;
|
|
}
|
|
|
|
framedur_fix = fDivNorm(frameSize, sampleFreq);
|
|
|
|
/* The longer the frames, the more often should the FIXFIX-
|
|
case transmit 2 envelopes instead of 1.
|
|
Frame durations below 10 ms produce the highest threshold
|
|
so that practically always only 1 env is transmitted. */
|
|
FIXP_DBL tmp = framedur_fix - FL2FXCONST_DBL(0.010);
|
|
|
|
tmp = fixMax(tmp, FL2FXCONST_DBL(0.0001));
|
|
tmp = fDivNorm(FL2FXCONST_DBL(0.000075), fPow2(tmp), &tmp_e);
|
|
|
|
bitrateFactor_e = (tmp_e + bitrateFactor_e);
|
|
|
|
if (sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
|
|
bitrateFactor_e--; /* divide by 2 */
|
|
}
|
|
|
|
FDK_ASSERT(no_cols <= 32);
|
|
FDK_ASSERT(no_rows <= 64);
|
|
|
|
h_sbrTransientDetector->no_cols = no_cols;
|
|
h_sbrTransientDetector->tran_thr =
|
|
(FIXP_DBL)((params->tran_thr << (32 - 24 - 1)) / no_rows);
|
|
h_sbrTransientDetector->tran_fc = tran_fc;
|
|
h_sbrTransientDetector->split_thr_m = fMult(tmp, bitrateFactor_m);
|
|
h_sbrTransientDetector->split_thr_e = bitrateFactor_e;
|
|
h_sbrTransientDetector->no_rows = no_rows;
|
|
h_sbrTransientDetector->mode = params->tran_det_mode;
|
|
h_sbrTransientDetector->prevLowBandEnergy = FL2FXCONST_DBL(0.0f);
|
|
|
|
return (0);
|
|
}
|
|
|
|
#define ENERGY_SCALING_SIZE 32
|
|
|
|
INT FDKsbrEnc_InitSbrFastTransientDetector(
|
|
HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector,
|
|
const INT time_slots_per_frame, const INT bandwidth_qmf_slot,
|
|
const INT no_qmf_channels, const INT sbr_qmf_1st_band) {
|
|
int i;
|
|
int buff_size;
|
|
FIXP_DBL myExp;
|
|
FIXP_DBL myExpSlot;
|
|
|
|
h_sbrFastTransientDetector->lookahead = TRAN_DET_LOOKAHEAD;
|
|
h_sbrFastTransientDetector->nTimeSlots = time_slots_per_frame;
|
|
|
|
buff_size = h_sbrFastTransientDetector->nTimeSlots +
|
|
h_sbrFastTransientDetector->lookahead;
|
|
|
|
for (i = 0; i < buff_size; i++) {
|
|
h_sbrFastTransientDetector->delta_energy[i] = FL2FXCONST_DBL(0.0f);
|
|
h_sbrFastTransientDetector->energy_timeSlots[i] = FL2FXCONST_DBL(0.0f);
|
|
h_sbrFastTransientDetector->lowpass_energy[i] = FL2FXCONST_DBL(0.0f);
|
|
h_sbrFastTransientDetector->transientCandidates[i] = 0;
|
|
}
|
|
|
|
FDK_ASSERT(bandwidth_qmf_slot > 0.f);
|
|
h_sbrFastTransientDetector->stopBand =
|
|
fMin(TRAN_DET_STOP_FREQ / bandwidth_qmf_slot, no_qmf_channels);
|
|
h_sbrFastTransientDetector->startBand =
|
|
fMin(sbr_qmf_1st_band,
|
|
h_sbrFastTransientDetector->stopBand - TRAN_DET_MIN_QMFBANDS);
|
|
|
|
FDK_ASSERT(h_sbrFastTransientDetector->startBand < no_qmf_channels);
|
|
FDK_ASSERT(h_sbrFastTransientDetector->startBand <
|
|
h_sbrFastTransientDetector->stopBand);
|
|
FDK_ASSERT(h_sbrFastTransientDetector->startBand > 1);
|
|
FDK_ASSERT(h_sbrFastTransientDetector->stopBand > 1);
|
|
|
|
/* the energy weighting and adding up has a headroom of 6 Bits,
|
|
so up to 64 bands can be added without potential overflow. */
|
|
FDK_ASSERT(h_sbrFastTransientDetector->stopBand -
|
|
h_sbrFastTransientDetector->startBand <=
|
|
64);
|
|
|
|
/* QMF_HP_dB_SLOPE_FIX says that we want a 20 dB per 16 kHz HP filter.
|
|
The following lines map this to the QMF bandwidth. */
|
|
#define EXP_E 7 /* 64 (=64) multiplications max, max. allowed sum is 0.5 */
|
|
myExp = fMultNorm(QMF_HP_dBd_SLOPE_FIX, 0, (FIXP_DBL)bandwidth_qmf_slot,
|
|
DFRACT_BITS - 1, EXP_E);
|
|
myExpSlot = myExp;
|
|
|
|
for (i = 0; i < 64; i++) {
|
|
/* Calculate dBf over all qmf bands:
|
|
dBf = (10^(0.002266f/10*bw(slot)))^(band) =
|
|
= 2^(log2(10)*0.002266f/10*bw(slot)*band) =
|
|
= 2^(0.00075275f*bw(slot)*band) */
|
|
|
|
FIXP_DBL dBf_m; /* dBf mantissa */
|
|
INT dBf_e; /* dBf exponent */
|
|
INT tmp;
|
|
|
|
INT dBf_int; /* dBf integer part */
|
|
FIXP_DBL dBf_fract; /* dBf fractional part */
|
|
|
|
/* myExp*(i+1) = myExp_int - myExp_fract
|
|
myExp*(i+1) is split up here for better accuracy of CalcInvLdData(),
|
|
for its result can be split up into an integer and a fractional part */
|
|
|
|
/* Round up to next integer */
|
|
FIXP_DBL myExp_int =
|
|
(myExpSlot & (FIXP_DBL)0xfe000000) + (FIXP_DBL)0x02000000;
|
|
|
|
/* This is the fractional part that needs to be substracted */
|
|
FIXP_DBL myExp_fract = myExp_int - myExpSlot;
|
|
|
|
/* Calc integer part */
|
|
dBf_int = CalcInvLdData(myExp_int);
|
|
/* The result needs to be re-scaled. The ld(myExp_int) had been scaled by
|
|
EXP_E, the CalcInvLdData expects the operand to be scaled by
|
|
LD_DATA_SHIFT. Therefore, the correctly scaled result is
|
|
dBf_int^(2^(EXP_E-LD_DATA_SHIFT)), which is dBf_int^2 */
|
|
|
|
if (dBf_int <=
|
|
46340) { /* compare with maximum allowed value for signed integer
|
|
multiplication, 46340 =
|
|
(INT)floor(sqrt((double)(((UINT)1<<(DFRACT_BITS-1))-1))) */
|
|
dBf_int *= dBf_int;
|
|
|
|
/* Calc fractional part */
|
|
dBf_fract = CalcInvLdData(-myExp_fract);
|
|
/* The result needs to be re-scaled. The ld(myExp_fract) had been scaled
|
|
by EXP_E, the CalcInvLdData expects the operand to be scaled by
|
|
LD_DATA_SHIFT. Therefore, the correctly scaled result is
|
|
dBf_fract^(2^(EXP_E-LD_DATA_SHIFT)), which is dBf_fract^2 */
|
|
dBf_fract = fMultNorm(dBf_fract, dBf_fract, &tmp);
|
|
|
|
/* Get worst case scaling of multiplication result */
|
|
dBf_e = (DFRACT_BITS - 1 - tmp) - CountLeadingBits(dBf_int);
|
|
|
|
/* Now multiply integer with fractional part of the result, thus resulting
|
|
in the overall accurate fractional result */
|
|
dBf_m = fMultNorm(dBf_int, DFRACT_BITS - 1, dBf_fract, tmp, dBf_e);
|
|
|
|
myExpSlot += myExp;
|
|
} else {
|
|
dBf_m = (FIXP_DBL)0;
|
|
dBf_e = 0;
|
|
}
|
|
|
|
/* Keep the results */
|
|
h_sbrFastTransientDetector->dBf_m[i] = dBf_m;
|
|
h_sbrFastTransientDetector->dBf_e[i] = dBf_e;
|
|
}
|
|
|
|
/* Make sure that dBf is greater than 1.0 (because it should be a highpass) */
|
|
/* ... */
|
|
|
|
return 0;
|
|
}
|
|
|
|
void FDKsbrEnc_fastTransientDetect(
|
|
const HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector,
|
|
const FIXP_DBL *const *Energies, const int *const scaleEnergies,
|
|
const INT YBufferWriteOffset, UCHAR *const tran_vector) {
|
|
int timeSlot, band;
|
|
|
|
FIXP_DBL max_delta_energy; /* helper to store maximum energy ratio */
|
|
int max_delta_energy_scale; /* helper to store scale of maximum energy ratio
|
|
*/
|
|
int ind_max = 0; /* helper to store index of maximum energy ratio */
|
|
int isTransientInFrame = 0;
|
|
|
|
const int nTimeSlots = h_sbrFastTransientDetector->nTimeSlots;
|
|
const int lookahead = h_sbrFastTransientDetector->lookahead;
|
|
const int startBand = h_sbrFastTransientDetector->startBand;
|
|
const int stopBand = h_sbrFastTransientDetector->stopBand;
|
|
|
|
int *transientCandidates = h_sbrFastTransientDetector->transientCandidates;
|
|
|
|
FIXP_DBL *energy_timeSlots = h_sbrFastTransientDetector->energy_timeSlots;
|
|
int *energy_timeSlots_scale =
|
|
h_sbrFastTransientDetector->energy_timeSlots_scale;
|
|
|
|
FIXP_DBL *delta_energy = h_sbrFastTransientDetector->delta_energy;
|
|
int *delta_energy_scale = h_sbrFastTransientDetector->delta_energy_scale;
|
|
|
|
const FIXP_DBL thr = TRAN_DET_THRSHLD;
|
|
const INT thr_scale = TRAN_DET_THRSHLD_SCALE;
|
|
|
|
/*reset transient info*/
|
|
tran_vector[2] = 0;
|
|
|
|
/* reset transient candidates */
|
|
FDKmemclear(transientCandidates + lookahead, nTimeSlots * sizeof(int));
|
|
|
|
for (timeSlot = lookahead; timeSlot < nTimeSlots + lookahead; timeSlot++) {
|
|
int i, norm;
|
|
FIXP_DBL tmpE = FL2FXCONST_DBL(0.0f);
|
|
int headroomEnSlot = DFRACT_BITS - 1;
|
|
|
|
FIXP_DBL smallNRG = FL2FXCONST_DBL(1e-2f);
|
|
FIXP_DBL denominator;
|
|
INT denominator_scale;
|
|
|
|
/* determine minimum headroom of energy values for this timeslot */
|
|
for (band = startBand; band < stopBand; band++) {
|
|
int tmp_headroom = fNormz(Energies[timeSlot][band]) - 1;
|
|
if (tmp_headroom < headroomEnSlot) {
|
|
headroomEnSlot = tmp_headroom;
|
|
}
|
|
}
|
|
|
|
for (i = 0, band = startBand; band < stopBand; band++, i++) {
|
|
/* energy is weighted by weightingfactor stored in dBf_m array */
|
|
/* dBf_m index runs from 0 to stopBand-startband */
|
|
/* energy shifted by calculated headroom for maximum precision */
|
|
FIXP_DBL weightedEnergy =
|
|
fMult(Energies[timeSlot][band] << headroomEnSlot,
|
|
h_sbrFastTransientDetector->dBf_m[i]);
|
|
|
|
/* energy is added up */
|
|
/* shift by 6 to have a headroom for maximum 64 additions */
|
|
/* shift by dBf_e to handle weighting factor dependent scale factors */
|
|
tmpE +=
|
|
weightedEnergy >> (6 + (10 - h_sbrFastTransientDetector->dBf_e[i]));
|
|
}
|
|
|
|
/* store calculated energy for timeslot */
|
|
energy_timeSlots[timeSlot] = tmpE;
|
|
|
|
/* calculate overall scale factor for energy of this timeslot */
|
|
/* = original scale factor of energies
|
|
* (-scaleEnergies[0]+2*QMF_SCALE_OFFSET or
|
|
* -scaleEnergies[1]+2*QMF_SCALE_OFFSET */
|
|
/* depending on YBufferWriteOffset) */
|
|
/* + weighting factor scale (10) */
|
|
/* + adding up scale factor ( 6) */
|
|
/* - headroom of energy value (headroomEnSlot) */
|
|
if (timeSlot < YBufferWriteOffset) {
|
|
energy_timeSlots_scale[timeSlot] =
|
|
(-scaleEnergies[0] + 2 * QMF_SCALE_OFFSET) + (10 + 6) -
|
|
headroomEnSlot;
|
|
} else {
|
|
energy_timeSlots_scale[timeSlot] =
|
|
(-scaleEnergies[1] + 2 * QMF_SCALE_OFFSET) + (10 + 6) -
|
|
headroomEnSlot;
|
|
}
|
|
|
|
/* Add a small energy to the denominator, thus making the transient
|
|
detection energy-dependent. Loud transients are being detected,
|
|
silent ones not. */
|
|
|
|
/* make sure that smallNRG does not overflow */
|
|
if (-energy_timeSlots_scale[timeSlot - 1] + 1 > 5) {
|
|
denominator = smallNRG;
|
|
denominator_scale = 0;
|
|
} else {
|
|
/* Leave an additional headroom of 1 bit for this addition. */
|
|
smallNRG =
|
|
scaleValue(smallNRG, -(energy_timeSlots_scale[timeSlot - 1] + 1));
|
|
denominator = (energy_timeSlots[timeSlot - 1] >> 1) + smallNRG;
|
|
denominator_scale = energy_timeSlots_scale[timeSlot - 1] + 1;
|
|
}
|
|
|
|
delta_energy[timeSlot] =
|
|
fDivNorm(energy_timeSlots[timeSlot], denominator, &norm);
|
|
delta_energy_scale[timeSlot] =
|
|
energy_timeSlots_scale[timeSlot] - denominator_scale + norm;
|
|
}
|
|
|
|
/*get transient candidates*/
|
|
/* For every timeslot, check if delta(E) exceeds the threshold. If it did,
|
|
it could potentially be marked as a transient candidate. However, the 2
|
|
slots before the current one must not be transients with an energy higher
|
|
than 1.4*E(current). If both aren't transients or if the energy of the
|
|
current timesolot is more than 1.4 times higher than the energy in the
|
|
last or the one before the last slot, it is marked as a transient.*/
|
|
|
|
FDK_ASSERT(lookahead >= 2);
|
|
for (timeSlot = lookahead; timeSlot < nTimeSlots + lookahead; timeSlot++) {
|
|
FIXP_DBL energy_cur_slot_weighted =
|
|
fMult(energy_timeSlots[timeSlot], FL2FXCONST_DBL(1.0f / 1.4f));
|
|
if (!fIsLessThan(delta_energy[timeSlot], delta_energy_scale[timeSlot], thr,
|
|
thr_scale) &&
|
|
(((transientCandidates[timeSlot - 2] == 0) &&
|
|
(transientCandidates[timeSlot - 1] == 0)) ||
|
|
!fIsLessThan(energy_cur_slot_weighted,
|
|
energy_timeSlots_scale[timeSlot],
|
|
energy_timeSlots[timeSlot - 1],
|
|
energy_timeSlots_scale[timeSlot - 1]) ||
|
|
!fIsLessThan(energy_cur_slot_weighted,
|
|
energy_timeSlots_scale[timeSlot],
|
|
energy_timeSlots[timeSlot - 2],
|
|
energy_timeSlots_scale[timeSlot - 2]))) {
|
|
/* in case of strong transients, subsequent
|
|
* qmf slots might be recognized as transients. */
|
|
transientCandidates[timeSlot] = 1;
|
|
}
|
|
}
|
|
|
|
/*get transient with max energy*/
|
|
max_delta_energy = FL2FXCONST_DBL(0.0f);
|
|
max_delta_energy_scale = 0;
|
|
ind_max = 0;
|
|
isTransientInFrame = 0;
|
|
for (timeSlot = 0; timeSlot < nTimeSlots; timeSlot++) {
|
|
int scale = fMax(delta_energy_scale[timeSlot], max_delta_energy_scale);
|
|
if (transientCandidates[timeSlot] &&
|
|
((delta_energy[timeSlot] >> (scale - delta_energy_scale[timeSlot])) >
|
|
(max_delta_energy >> (scale - max_delta_energy_scale)))) {
|
|
max_delta_energy = delta_energy[timeSlot];
|
|
max_delta_energy_scale = scale;
|
|
ind_max = timeSlot;
|
|
isTransientInFrame = 1;
|
|
}
|
|
}
|
|
|
|
/*from all transient candidates take the one with the biggest energy*/
|
|
if (isTransientInFrame) {
|
|
tran_vector[0] = ind_max;
|
|
tran_vector[1] = 1;
|
|
} else {
|
|
/*reset transient info*/
|
|
tran_vector[0] = tran_vector[1] = 0;
|
|
}
|
|
|
|
/*check for transients in lookahead*/
|
|
for (timeSlot = nTimeSlots; timeSlot < nTimeSlots + lookahead; timeSlot++) {
|
|
if (transientCandidates[timeSlot]) {
|
|
tran_vector[2] = 1;
|
|
}
|
|
}
|
|
|
|
/*update buffers*/
|
|
for (timeSlot = 0; timeSlot < lookahead; timeSlot++) {
|
|
transientCandidates[timeSlot] = transientCandidates[nTimeSlots + timeSlot];
|
|
|
|
/* fixpoint stuff */
|
|
energy_timeSlots[timeSlot] = energy_timeSlots[nTimeSlots + timeSlot];
|
|
energy_timeSlots_scale[timeSlot] =
|
|
energy_timeSlots_scale[nTimeSlots + timeSlot];
|
|
|
|
delta_energy[timeSlot] = delta_energy[nTimeSlots + timeSlot];
|
|
delta_energy_scale[timeSlot] = delta_energy_scale[nTimeSlots + timeSlot];
|
|
}
|
|
}
|