summaryrefslogtreecommitdiffstats
path: root/libAACdec/src/conceal.cpp
diff options
context:
space:
mode:
authorDave Burke <daveburke@google.com>2012-04-17 09:51:45 -0700
committerDave Burke <daveburke@google.com>2012-04-17 23:04:43 -0700
commit9bf37cc9712506b2483650c82d3c41152337ef7e (patch)
tree77db44e2bae06e3d144b255628be2b7a55c581d3 /libAACdec/src/conceal.cpp
parenta37315fe10ee143d6d0b28c19d41a476a23e63ea (diff)
downloadODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.gz
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.bz2
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.zip
Fraunhofer AAC codec.
License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5
Diffstat (limited to 'libAACdec/src/conceal.cpp')
-rw-r--r--libAACdec/src/conceal.cpp1763
1 files changed, 1763 insertions, 0 deletions
diff --git a/libAACdec/src/conceal.cpp b/libAACdec/src/conceal.cpp
new file mode 100644
index 0000000..9fb2ed3
--- /dev/null
+++ b/libAACdec/src/conceal.cpp
@@ -0,0 +1,1763 @@
+/***************************** MPEG-4 AAC Decoder **************************
+
+ (C) Copyright Fraunhofer IIS (2004)
+ All Rights Reserved
+
+ Please be advised that this software and/or program delivery is
+ Confidential Information of Fraunhofer and subject to and covered by the
+
+ Fraunhofer IIS Software Evaluation Agreement
+ between Google Inc. and Fraunhofer
+ effective and in full force since March 1, 2012.
+
+ You may use this software and/or program only under the terms and
+ conditions described in the above mentioned Fraunhofer IIS Software
+ Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+ $Id$
+ Author(s): Josef Hoepfl
+ Description: independent channel concealment
+
+ This software and/or program is protected by copyright law and international
+ treaties. Any reproduction or distribution of this software and/or program,
+ or any portion of it, may result in severe civil and criminal penalties, and
+ will be prosecuted to the maximum extent possible under law.
+
+******************************************************************************/
+
+/*!
+ \page concealment AAC core concealment
+
+ This AAC core implementation includes a concealment function, which can be enabled
+ using the several defines during compilation.
+
+ There are various tests inside the core, starting with simple CRC tests and ending in
+ a variety of plausibility checks. If such a check indicates an invalid bitstream, then
+ concealment is applied.
+
+ Concealment is also applied when the calling main program indicates a distorted or missing
+ data frame using the frameOK flag. This is used for error detection on the transport layer.
+ (See below)
+
+ There are three concealment-modes:
+
+ 1) Muting: The spectral data is simply set to zero in case of an detected error.
+
+ 2) Noise substitution: In case of an detected error, concealment copies the last frame and adds
+ attenuates the spectral data. For this mode you have to set the #CONCEAL_NOISE define.
+ Noise substitution adds no additional delay.
+
+ 3) Interpolation: The interpolation routine swaps the spectral data from the previous and the
+ current frame just before the final frequency to time conversion. In case a single frame is
+ corrupted, concealmant interpolates between the last good and the first good frame to create
+ the spectral data for the missing frame. If multiple frames are corrupted, concealment
+ implements first a fade out based on slightly modified spectral values from the last good
+ frame. As soon as good frames are available, concealmant fades in the new spectral data.
+ For this mode you have to set the #CONCEAL_INTER define. Note that in this case, you also
+ need to set #SBR_BS_DELAY_ENABLE, which basically adds approriate delay in the SBR decoder.
+ Note that the Interpolating-Concealment increases the delay of your decoder by one frame
+ and that it does require additional resources such as memory and computational complexity.
+
+ <h2>How concealment can be used with errors on the transport layer</h2>
+
+ Many errors can or have to be detected on the transport layer. For example in IP based systems
+ packet loss can occur. The transport protocol used should indicate such packet loss by inserting
+ an empty frame with frameOK=0.
+*/
+
+#include "conceal.h"
+
+#include "aac_rom.h"
+#include "genericStds.h"
+
+
+/* PNS (of block) */
+#include "aacdec_pns.h"
+#include "block.h"
+
+#include "FDK_tools_rom.h"
+
+#define CONCEAL_DFLT_COMF_NOISE_LEVEL ( 46 ) /* ~= -70 dB */
+
+
+/* default settings */
+#define CONCEAL_DFLT_FADEOUT_FRAMES ( 5 )
+#define CONCEAL_DFLT_FADEIN_FRAMES ( 5 )
+#define CONCEAL_DFLT_MUTE_RELEASE_FRAMES ( 3 )
+
+#define CONCEAL_DFLT_FADE_FACTOR ( 0.707106781186548f ) /* 1/sqrt(2) */
+
+/* some often used constants: */
+#define FIXP_ZERO FL2FXCONST_DBL(0.0f)
+#define FIXP_ONE FL2FXCONST_DBL(1.0f)
+#define FIXP_FL_CORRECTION FL2FXCONST_DBL(0.53333333333333333f)
+
+/* For parameter conversion */
+#define CONCEAL_PARAMETER_BITS ( 8 )
+#define CONCEAL_MAX_QUANT_FACTOR ( (1<<CONCEAL_PARAMETER_BITS)-1 )
+/*#define CONCEAL_MIN_ATTENUATION_FACTOR_025 ( FL2FXCONST_DBL(0.971627951577106174) )*/ /* -0.25 dB */
+#define CONCEAL_MIN_ATTENUATION_FACTOR_025_LD FL2FXCONST_DBL(-0.041524101186092029596853445212299)
+/*#define CONCEAL_MIN_ATTENUATION_FACTOR_050 ( FL2FXCONST_DBL(0.944060876285923380) )*/ /* -0.50 dB */
+#define CONCEAL_MIN_ATTENUATION_FACTOR_050_LD FL2FXCONST_DBL(-0.083048202372184059253597008145293)
+
+typedef enum {
+ CConcealment_NoExpand,
+ CConcealment_Expand,
+ CConcealment_Compress
+}
+CConcealmentExpandType;
+
+static const FIXP_SGL facMod4Table[4] = {
+ FL2FXCONST_SGL(0.500000000f), /* FIXP_SGL(0x4000), 2^-(1-0,00) */
+ FL2FXCONST_SGL(0.594603558f), /* FIXP_SGL(0x4c1b), 2^-(1-0,25) */
+ FL2FXCONST_SGL(0.707106781f), /* FIXP_SGL(0x5a82), 2^-(1-0,50) */
+ FL2FXCONST_SGL(0.840896415f) /* FIXP_SGL(0x6ba2) 2^-(1-0,75) */
+};
+
+
+
+
+static void
+ CConcealment_CalcBandEnergy (
+ FIXP_DBL *spectrum,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int blockType,
+ CConcealmentExpandType ex,
+ int *sfbEnergy
+ );
+
+static void
+ CConcealment_InterpolateBuffer (
+ FIXP_DBL *spectrum,
+ SHORT *pSpecScalePrev,
+ SHORT *pSpecScaleAct,
+ SHORT *pSpecScaleOut,
+ int *enPrv,
+ int *enAct,
+ int sfbCnt,
+ const SHORT *pSfbOffset
+ );
+
+static int
+ CConcealment_ApplyInter (
+ CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int samplesPerFrame,
+ const int improveTonal,
+ const int frameOk
+ );
+
+
+
+static int
+ CConcealment_ApplyNoise (
+ CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int samplesPerFrame,
+ const UINT flags
+ );
+
+static void
+ CConcealment_UpdateState (
+ CConcealmentInfo *pConcealmentInfo,
+ int frameOk
+ );
+
+static void
+ CConcealment_ApplyRandomSign (
+ int iRandomPhase,
+ FIXP_DBL *spec,
+ int samplesPerFrame
+ );
+
+
+static int CConcealment_GetWinSeq(int prevWinSeq)
+{
+ int newWinSeq = OnlyLongSequence;
+
+ /* Try to have only long blocks */
+ if ( prevWinSeq == LongStartSequence
+ || prevWinSeq == EightShortSequence )
+ {
+ newWinSeq = LongStopSequence;
+ }
+
+ return (newWinSeq);
+}
+
+
+/*!
+ \brief Init common concealment information data
+
+ \pConcealCommonData Pointer to the concealment common data structure.
+
+ \return none
+*/
+void
+ CConcealment_InitCommonData (CConcealParams *pConcealCommonData)
+{
+ if (pConcealCommonData != NULL)
+ {
+ int i;
+
+ /* Set default error concealment technique */
+ pConcealCommonData->method = ConcealMethodInter;
+
+ pConcealCommonData->numFadeOutFrames = CONCEAL_DFLT_FADEOUT_FRAMES;
+ pConcealCommonData->numFadeInFrames = CONCEAL_DFLT_FADEIN_FRAMES;
+ pConcealCommonData->numMuteReleaseFrames = CONCEAL_DFLT_MUTE_RELEASE_FRAMES;
+
+ pConcealCommonData->comfortNoiseLevel = CONCEAL_DFLT_COMF_NOISE_LEVEL;
+
+ /* Init fade factors (symetric) */
+ pConcealCommonData->fadeOutFactor[0] = FL2FXCONST_SGL( CONCEAL_DFLT_FADE_FACTOR );
+ pConcealCommonData->fadeInFactor[0] = pConcealCommonData->fadeOutFactor[0];
+
+ for (i = 1; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) {
+ pConcealCommonData->fadeOutFactor[i] = FX_DBL2FX_SGL(fMult(pConcealCommonData->fadeOutFactor[i-1],FL2FXCONST_SGL(CONCEAL_DFLT_FADE_FACTOR)));
+ pConcealCommonData->fadeInFactor[i] = pConcealCommonData->fadeOutFactor[i];
+ }
+ }
+}
+
+
+
+/*!
+ \brief Get current concealment method.
+
+ \pConcealCommonData Pointer to common concealment data (for all channels)
+
+ \return Concealment method.
+*/
+CConcealmentMethod
+ CConcealment_GetMethod( CConcealParams *pConcealCommonData )
+{
+ CConcealmentMethod method = ConcealMethodNone;
+
+ if (pConcealCommonData != NULL) {
+ method = pConcealCommonData->method;
+ }
+
+ return (method);
+}
+
+
+/*!
+ \brief Init concealment information for each channel
+
+ The function initializes the concealment information. Two methods can be chosen:
+ 0 = interpolation method (adds delay)
+ 1 = noise substitution (no delay, low complexity)
+
+ \return none
+*/
+void
+ CConcealment_InitChannelData (
+ CConcealmentInfo *pConcealChannelInfo,
+ CConcealParams *pConcealCommonData,
+ int samplesPerFrame )
+{
+ int i;
+
+ pConcealChannelInfo->pConcealParams = pConcealCommonData;
+
+ FDKmemclear(pConcealChannelInfo->spectralCoefficient, 1024 * sizeof(FIXP_CNCL));
+
+ for (i = 0; i < 8; i++) {
+ pConcealChannelInfo->specScale[i] = 0;
+ }
+
+ pConcealChannelInfo->iRandomPhase = 0;
+
+ pConcealChannelInfo->windowSequence = 0;
+ pConcealChannelInfo->windowShape = 0;
+
+ pConcealChannelInfo->prevFrameOk[0] = 1;
+ pConcealChannelInfo->prevFrameOk[1] = 1;
+
+ pConcealChannelInfo->cntFadeFrames = 0;
+ pConcealChannelInfo->cntValidFrames = 0;
+
+ pConcealChannelInfo->concealState = ConcealState_Ok;
+
+}
+
+
+/*!
+ \brief Set error concealment parameters
+
+ \concealParams
+ \method
+ \fadeOutSlope
+ \fadeInSlope
+ \muteRelease
+ \comfNoiseLevel
+
+ \return none
+*/
+AAC_DECODER_ERROR
+ CConcealment_SetParams (
+ CConcealParams *concealParams,
+ int method,
+ int fadeOutSlope,
+ int fadeInSlope,
+ int muteRelease,
+ int comfNoiseLevel )
+{
+ /* set concealment technique */
+ if (method != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ switch ((CConcealmentMethod)method)
+ {
+ case ConcealMethodMute:
+ case ConcealMethodNoise:
+ case ConcealMethodInter:
+ /* Be sure to enable delay adjustment of SBR decoder! */
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ /* set param */
+ concealParams->method = (CConcealmentMethod)method;
+ }
+ break;
+
+ default:
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+
+ /* set number of frames for fade-out slope */
+ if (fadeOutSlope != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ if ( (fadeOutSlope < CONCEAL_MAX_NUM_FADE_FACTORS)
+ && (fadeOutSlope >= 0) )
+ {
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ /* set param */
+ concealParams->numFadeOutFrames = fadeOutSlope;
+ }
+ } else {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+
+ /* set number of frames for fade-in slope */
+ if (fadeInSlope != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ if ( (fadeInSlope < CONCEAL_MAX_NUM_FADE_FACTORS)
+ && (fadeInSlope >= 1) )
+ {
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ /* set param */
+ concealParams->numFadeInFrames = fadeInSlope;
+ }
+ } else {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+
+ /* set number of error-free frames after which the muting will be released */
+ if (muteRelease != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ if ( (muteRelease < (CONCEAL_MAX_NUM_FADE_FACTORS<<1))
+ && (muteRelease >= 0) )
+ {
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ /* set param */
+ concealParams->numMuteReleaseFrames = muteRelease;
+ }
+ } else {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+
+ /* set confort noise level which will be inserted while in state 'muting' */
+ if (comfNoiseLevel != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ if ( (comfNoiseLevel < 0)
+ || (comfNoiseLevel > 127) ) {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ concealParams->comfortNoiseLevel = comfNoiseLevel;
+ }
+ }
+
+ return (AAC_DEC_OK);
+}
+
+
+/*!
+ \brief Set fade-out/in attenuation factor vectors
+
+ \concealParams
+ \fadeOutAttenuationVector
+ \fadeInAttenuationVector
+
+ \return 0 if OK all other values indicate errors
+*/
+AAC_DECODER_ERROR
+ CConcealment_SetAttenuation (
+ CConcealParams *concealParams,
+ SHORT *fadeOutAttenuationVector,
+ SHORT *fadeInAttenuationVector )
+{
+ if ( (fadeOutAttenuationVector == NULL)
+ && (fadeInAttenuationVector == NULL) ) {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+
+ /* Fade-out factors */
+ if (fadeOutAttenuationVector != NULL)
+ {
+ int i;
+
+ /* check quantized factors first */
+ for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) {
+ if ((fadeOutAttenuationVector[i] < 0) || (fadeOutAttenuationVector[i] > CONCEAL_MAX_QUANT_FACTOR)) {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ }
+
+ /* now dequantize factors */
+ for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++)
+ {
+ concealParams->fadeOutFactor[i] =
+ FX_DBL2FX_SGL( fLdPow( CONCEAL_MIN_ATTENUATION_FACTOR_025_LD,
+ 0,
+ (FIXP_DBL)((INT)(FL2FXCONST_DBL(1.0/2.0)>>(CONCEAL_PARAMETER_BITS-1)) * (INT)fadeOutAttenuationVector[i]),
+ CONCEAL_PARAMETER_BITS
+ )
+ );
+ }
+ }
+
+ /* Fade-in factors */
+ if (fadeInAttenuationVector != NULL)
+ {
+ int i;
+
+ /* check quantized factors first */
+ for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) {
+ if ((fadeInAttenuationVector[i] < 0) || (fadeInAttenuationVector[i] > CONCEAL_MAX_QUANT_FACTOR)) {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ }
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ }
+
+ /* now dequantize factors */
+ for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++)
+ {
+ concealParams->fadeInFactor[i] =
+ FX_DBL2FX_SGL( fLdPow( CONCEAL_MIN_ATTENUATION_FACTOR_025_LD,
+ 0,
+ (FIXP_DBL)((INT)(FIXP_ONE>>CONCEAL_PARAMETER_BITS) * (INT)fadeInAttenuationVector[i]),
+ CONCEAL_PARAMETER_BITS
+ )
+ );
+ }
+ }
+
+ return (AAC_DEC_OK);
+}
+
+
+/*!
+ \brief Get state of concealment module.
+
+ \pConcealChannelInfo
+
+ \return Concealment state.
+*/
+CConcealmentState
+ CConcealment_GetState (
+ CConcealmentInfo *pConcealChannelInfo
+ )
+{
+ CConcealmentState state = ConcealState_Ok;
+
+ if (pConcealChannelInfo != NULL) {
+ state = pConcealChannelInfo->concealState;
+ }
+
+ return (state);
+}
+
+
+static void CConcealment_fakePnsData (
+ CPnsData *pPnsData,
+ CIcsInfo *pIcsInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ SHORT *pSpecScale,
+ SHORT *pScaleFactor,
+ const int level )
+{
+ CPnsInterChannelData *pInterChannelData = pPnsData->pPnsInterChannelData;
+
+ int pnsBand, band, group, win;
+ //int delta = 0;
+ int windowsPerFrame = GetWindowsPerFrame(pIcsInfo);
+ int refLevel = (windowsPerFrame > 1) ? 82 : 91;
+
+ FDK_ASSERT(level >= 0 && level <= 127);
+
+ for (win = 0; win < windowsPerFrame; win++) {
+ pSpecScale[win] = 31;
+ }
+
+ /* fake ICS info if necessary */
+ if (!IsValid(pIcsInfo)) {
+ pIcsInfo->WindowGroups = 1;
+ if (IsLongBlock(pIcsInfo)) {
+ pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
+ pIcsInfo->WindowGroupLength[0] = 1;
+ }
+ else {
+ pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Short;
+ pIcsInfo->WindowGroupLength[0] = 8;
+ }
+ pIcsInfo->MaxSfBands = pIcsInfo->TotalSfBands;
+ }
+
+ /* global activate PNS */
+ pPnsData->PnsActive = 1;
+ /* set energy level */
+ pPnsData->CurrentEnergy = fixMax( 0, refLevel - level );
+
+ /*
+ value: | Avg. RMS power | Avg. RMS power |
+ | specScale = 22 | specScale = 31 |
+ -------+----------------+----------------+
+ 5 | | -99.0 dB
+ 15 | | -90.0 dB
+ 25 | | -89.7 dB
+ 35 | | -85.3 dB
+ ... | ... | ...
+ 45 | -69.9 dB | -70.0 dB
+ 50 | -62.2 dB |
+ 55 | -55.6 dB | -54.6 dB
+ 60 | -47.0 dB |
+ 65 | -39.5 dB | -39.5 dB
+ 70 | -31.9 dB |
+ 75 | -24.4 dB | -24.4 dB
+ 80 | -16.9 dB |
+ 85 | -9.4 dB (c) | -9.4 dB
+ 90 | -3.9 dB (c) |
+ 95 | | -2.1 dB
+ 100 | | -1.6 dB
+ 105 | | -1.4 dB
+ */
+
+ for (group=0; group < GetWindowGroups(pIcsInfo); group++)
+ {
+ for (band=0; band < GetScaleFactorBandsTransmitted(pIcsInfo); band++)
+ {
+ pnsBand = group * 16 + band;
+
+ if (pnsBand >= NO_OFBANDS) {
+ return;
+ }
+ //pPnsData->CurrentEnergy += delta ;
+ pScaleFactor[pnsBand] = pPnsData->CurrentEnergy;
+ pInterChannelData->correlated[pnsBand] = 0;
+ pPnsData->pnsUsed[pnsBand] = 1;
+ }
+ }
+}
+
+
+/*!
+ \brief Store data for concealment techniques applied later
+
+ Interface function to store data for different concealment strategies
+
+ \return none
+ */
+void
+ CConcealment_Store (
+ CConcealmentInfo *hConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo )
+{
+ if ( !(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD
+ ) )
+ {
+ FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+
+ SHORT tSpecScale[8];
+ UCHAR tWindowShape, tWindowSequence;
+
+ /* store old window infos for swapping */
+ tWindowSequence = hConcealmentInfo->windowSequence;
+ tWindowShape = hConcealmentInfo->windowShape;
+
+ /* store old scale factors for swapping */
+ FDKmemcpy(tSpecScale, hConcealmentInfo->specScale, 8*sizeof(SHORT));
+
+ /* store new window infos */
+ hConcealmentInfo->windowSequence = GetWindowSequence(pIcsInfo);
+ hConcealmentInfo->windowShape = GetWindowShape(pIcsInfo);
+ hConcealmentInfo->lastWinGrpLen = *(GetWindowGroupLengthTable(pIcsInfo)+GetWindowGroups(pIcsInfo)-1);
+
+ /* store new scale factors */
+ FDKmemcpy(hConcealmentInfo->specScale, pSpecScale, 8*sizeof(SHORT));
+
+ if (CConcealment_GetDelay(hConcealmentInfo->pConcealParams) == 0)
+ {
+ /* store new spectral bins */
+#if (CNCL_FRACT_BITS == DFRACT_BITS)
+ FDKmemcpy(hConcealmentInfo->spectralCoefficient, pSpectralCoefficient, 1024 * sizeof(FIXP_CNCL));
+#else
+ FIXP_CNCL *RESTRICT pCncl = &hConcealmentInfo->spectralCoefficient[1024-1];
+ FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024-1];
+ int i;
+
+ for (i = 1024; i != 0; i--) {
+ *pCncl-- = FX_DBL2FX_CNCL(*pSpec--);
+ }
+#endif
+ }
+ else
+ {
+ FIXP_CNCL *RESTRICT pCncl = &hConcealmentInfo->spectralCoefficient[1024-1];
+ FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024-1];
+ int i;
+
+ /* swap spectral data */
+ for (i = 1024; i != 0; i--) {
+ FIXP_DBL tSpec = *pSpec;
+ *pSpec-- = FX_CNCL2FX_DBL(*pCncl);
+ *pCncl-- = FX_DBL2FX_CNCL( tSpec);
+ }
+
+ /* complete swapping of window infos */
+ pIcsInfo->WindowSequence = tWindowSequence;
+ pIcsInfo->WindowShape = tWindowShape;
+
+ /* complete swapping of scale factors */
+ FDKmemcpy(pSpecScale, tSpecScale, 8*sizeof(SHORT));
+ }
+ }
+
+}
+
+
+/*!
+ \brief Apply concealment
+
+ Interface function to different concealment strategies
+
+ \return none
+ */
+int
+ CConcealment_Apply (
+ CConcealmentInfo *hConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int samplesPerFrame,
+ const UCHAR lastLpdMode,
+ const int frameOk,
+ const UINT flags)
+{
+ int appliedProcessing = 0;
+
+ if ( (frameOk == 0)
+ && (pAacDecoderChannelInfo->renderMode != (AACDEC_RENDER_MODE)hConcealmentInfo->lastRenderMode) ) {
+ /* restore the last render mode to stay in the same domain which allows to do a proper concealment */
+ pAacDecoderChannelInfo->renderMode = (AACDEC_RENDER_MODE)hConcealmentInfo->lastRenderMode;
+ } else {
+ /* otherwise store the current mode */
+ hConcealmentInfo->lastRenderMode = (SCHAR)pAacDecoderChannelInfo->renderMode;
+ }
+
+ if ( frameOk )
+ {
+ /* Rescue current data for concealment in future frames */
+ CConcealment_Store ( hConcealmentInfo,
+ pAacDecoderChannelInfo,
+ pAacDecoderStaticChannelInfo );
+ /* Reset index to random sign vector to make sign calculation frame agnostic
+ (only depends on number of subsequently concealed spectral blocks) */
+ hConcealmentInfo->iRandomPhase = 0;
+ }
+
+ /* hand current frame status to the state machine */
+ CConcealment_UpdateState( hConcealmentInfo,
+ frameOk );
+
+ if ( !frameOk )
+ {
+ /* Create data for signal rendering according to the selected concealment method and decoder operating mode. */
+
+
+ if ( !(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD
+ )
+ )
+ {
+ switch (hConcealmentInfo->pConcealParams->method)
+ {
+ default:
+ case ConcealMethodMute:
+ /* Mute spectral data in case of errors */
+ FDKmemclear(pAacDecoderChannelInfo->pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL));
+ /* Set last window shape */
+ pAacDecoderChannelInfo->icsInfo.WindowShape = hConcealmentInfo->windowShape;
+ appliedProcessing = 1;
+ break;
+
+ case ConcealMethodNoise:
+ /* Noise substitution error concealment technique */
+ appliedProcessing =
+ CConcealment_ApplyNoise (hConcealmentInfo,
+ pAacDecoderChannelInfo,
+ pAacDecoderStaticChannelInfo,
+ pSamplingRateInfo,
+ samplesPerFrame,
+ flags);
+ break;
+
+ case ConcealMethodInter:
+ /* Energy interpolation concealment based on 3GPP */
+ appliedProcessing =
+ CConcealment_ApplyInter (hConcealmentInfo,
+ pAacDecoderChannelInfo,
+ pSamplingRateInfo,
+ samplesPerFrame,
+ 0, /* don't use tonal improvement */
+ 0);
+ break;
+
+ }
+ }
+ }
+ /* update history */
+ hConcealmentInfo->prevFrameOk[0] = hConcealmentInfo->prevFrameOk[1];
+ hConcealmentInfo->prevFrameOk[1] = frameOk;
+
+ return appliedProcessing;
+}
+
+/*!
+\brief Apply concealment noise substitution
+
+ In case of frame lost this function produces a noisy frame with respect to the
+ energies values of past frame.
+
+\return none
+ */
+static int
+ CConcealment_ApplyNoise (CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int samplesPerFrame,
+ const UINT flags)
+{
+ CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams;
+
+ FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+
+ int appliedProcessing = 0;
+
+ FDK_ASSERT((samplesPerFrame>=480) && (samplesPerFrame<=1024));
+ FDK_ASSERT((samplesPerFrame&0x1F) == 0);
+
+ switch (pConcealmentInfo->concealState)
+ {
+ case ConcealState_Ok:
+ /* Nothing to do here! */
+ break;
+
+ case ConcealState_Single:
+ case ConcealState_FadeOut:
+ {
+ /* restore frequency coefficients from buffer with a specific muting */
+ FIXP_SGL fac;
+ int win, numWindows = 1;
+ int windowLen = samplesPerFrame;
+ int tFadeFrames, lastWindow = 0;
+ int win_idx_stride = 1;
+
+ FDK_ASSERT(pConcealmentInfo != NULL);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames <= pConcealCommonData->numFadeOutFrames);
+
+ /* get attenuation factor */
+ tFadeFrames = pConcealmentInfo->cntFadeFrames;
+ fac = pConcealCommonData->fadeOutFactor[tFadeFrames];
+
+ /* set old window parameters */
+ {
+ pIcsInfo->WindowShape = pConcealmentInfo->windowShape;
+ pIcsInfo->WindowSequence = pConcealmentInfo->windowSequence;
+
+ if (pConcealmentInfo->windowSequence == 2) {
+ /* short block handling */
+ numWindows = 8;
+ windowLen = samplesPerFrame >> 3;
+ lastWindow = numWindows - pConcealmentInfo->lastWinGrpLen;
+ }
+ }
+
+ for (win = 0; win < numWindows; win++) {
+ FIXP_CNCL *pCncl = pConcealmentInfo->spectralCoefficient + (lastWindow * windowLen);
+ FIXP_DBL *pOut = pSpectralCoefficient + (win * windowLen);
+ int i;
+
+ FDK_ASSERT((lastWindow * windowLen + windowLen) <= samplesPerFrame);
+
+ /* restore frequency coefficients from buffer with a specific attenuation */
+ for (i = 0; i < windowLen; i++) {
+ pOut[i] = fMult(pCncl[i], fac);
+ }
+
+ /* apply random change of sign for spectral coefficients */
+ CConcealment_ApplyRandomSign(pConcealmentInfo->iRandomPhase,
+ pOut,
+ windowLen );
+
+ /* Increment random phase index to avoid repetition artifacts. */
+ pConcealmentInfo->iRandomPhase = (pConcealmentInfo->iRandomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1);
+
+ /* set old scale factors */
+ pSpecScale[win*win_idx_stride] = pConcealmentInfo->specScale[win_idx_stride*lastWindow++];
+
+ if ( (lastWindow >= numWindows)
+ && (numWindows > 1) )
+ {
+ /* end of sequence -> rewind */
+ lastWindow = numWindows - pConcealmentInfo->lastWinGrpLen;
+ /* update the attenuation factor to get a faster fade-out */
+ tFadeFrames += 1;
+ if (tFadeFrames < pConcealCommonData->numFadeOutFrames) {
+ fac = pConcealCommonData->fadeOutFactor[tFadeFrames];
+ } else {
+ fac = (FIXP_SGL)0;
+ }
+ }
+ }
+
+ /* store temp vars */
+ pConcealmentInfo->cntFadeFrames = tFadeFrames;
+ appliedProcessing = 1;
+ }
+ break;
+
+ case ConcealState_Mute:
+ {
+ /* set dummy window parameters */
+ pIcsInfo->Valid = 0; /* Trigger the generation of a consitent IcsInfo */
+ pIcsInfo->WindowShape = pConcealmentInfo->windowShape; /* Prevent an invalid WindowShape (required for F/T transform) */
+ pIcsInfo->WindowSequence = CConcealment_GetWinSeq(pConcealmentInfo->windowSequence);
+ pConcealmentInfo->windowSequence = pIcsInfo->WindowSequence; /* Store for next frame (spectrum in concealment buffer can't be used at all) */
+
+ /* mute spectral data */
+ FDKmemclear(pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL));
+
+ if ( !(flags & (AC_USAC|AC_RSVD50))
+ && pConcealCommonData->comfortNoiseLevel >= 0
+ && pConcealCommonData->comfortNoiseLevel <= 61 /* -90dB */)
+ {
+ /* insert comfort noise using PNS */
+ CConcealment_fakePnsData (
+ &pAacDecoderChannelInfo->data.aac.PnsData,
+ pIcsInfo,
+ pSamplingRateInfo,
+ pAacDecoderChannelInfo->pDynData->aSfbScale,
+ pAacDecoderChannelInfo->pDynData->aScaleFactor,
+ pConcealCommonData->comfortNoiseLevel
+ );
+
+ CPns_Apply (
+ &pAacDecoderChannelInfo->data.aac.PnsData,
+ pIcsInfo,
+ pAacDecoderChannelInfo->pSpectralCoefficient,
+ pAacDecoderChannelInfo->specScale,
+ pAacDecoderChannelInfo->pDynData->aScaleFactor,
+ pSamplingRateInfo,
+ pAacDecoderChannelInfo->granuleLength,
+ 0 /* always apply to first channel */
+ );
+ }
+ appliedProcessing = 1;
+ }
+ break;
+
+ case ConcealState_FadeIn:
+ {
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeInFrames);
+
+ /* attenuate signal to get a smooth fade-in */
+ FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1];
+ FIXP_SGL fac = pConcealCommonData->fadeInFactor[pConcealmentInfo->cntFadeFrames];
+ int i;
+
+ for (i = samplesPerFrame; i != 0; i--) {
+ *pOut = fMult(*pOut, fac);
+ pOut--;
+ }
+ appliedProcessing = 1;
+ }
+ break;
+
+ default:
+ /* we shouldn't come here anyway */
+ FDK_ASSERT(0);
+ break;
+ }
+
+ return appliedProcessing;
+}
+
+
+/*!
+ \brief Apply concealment interpolation
+
+ The function swaps the data from the current and the previous frame. If an
+ error has occured, frame interpolation is performed to restore the missing
+ frame. In case of multiple faulty frames, fade-in and fade-out is applied.
+
+ \return none
+*/
+static int
+ CConcealment_ApplyInter (
+ CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int samplesPerFrame,
+ const int improveTonal,
+ const int frameOk )
+{
+ CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams;
+
+ FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+
+
+ int sfbEnergyPrev[64];
+ int sfbEnergyAct [64];
+
+ int i, appliedProcessing = 0;
+
+ /* clear/init */
+ FDKmemclear(sfbEnergyPrev, 64 * sizeof(int));
+ FDKmemclear(sfbEnergyAct, 64 * sizeof(int));
+
+
+ if (!frameOk)
+ {
+ /* Restore last frame from concealment buffer */
+ pIcsInfo->WindowShape = pConcealmentInfo->windowShape;
+ pIcsInfo->WindowSequence = pConcealmentInfo->windowSequence;
+
+ /* Restore spectral data */
+ for (i = 0; i < samplesPerFrame; i++) {
+ pSpectralCoefficient[i] = FX_CNCL2FX_DBL(pConcealmentInfo->spectralCoefficient[i]);
+ }
+
+ /* Restore scale factors */
+ FDKmemcpy(pSpecScale, pConcealmentInfo->specScale, 8*sizeof(SHORT));
+ }
+
+ /* if previous frame was not ok */
+ if (!pConcealmentInfo->prevFrameOk[1]) {
+
+ /* if current frame (f_n) is ok and the last but one frame (f_(n-2))
+ was ok, too, then interpolate both frames in order to generate
+ the current output frame (f_(n-1)). Otherwise, use the last stored
+ frame (f_(n-2) or f_(n-3) or ...). */
+ if (frameOk && pConcealmentInfo->prevFrameOk[0])
+ {
+ appliedProcessing = 1;
+
+
+ /* Interpolate both frames in order to generate the current output frame (f_(n-1)). */
+ if (pIcsInfo->WindowSequence == EightShortSequence) {
+ /* f_(n-2) == EightShortSequence */
+ /* short--??????--short, short--??????--long interpolation */
+ /* short--short---short, short---long---long interpolation */
+
+ int wnd;
+
+ if (pConcealmentInfo->windowSequence == EightShortSequence) { /* f_n == EightShortSequence */
+ /* short--short---short interpolation */
+
+ int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short;
+ const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short;
+ pIcsInfo->WindowShape = 1;
+ pIcsInfo->WindowSequence = EightShortSequence;
+
+ for (wnd = 0; wnd < 8; wnd++)
+ {
+ CConcealment_CalcBandEnergy(
+ &pSpectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_(n-2) */
+ pSamplingRateInfo,
+ EightShortSequence,
+ CConcealment_NoExpand,
+ sfbEnergyPrev);
+
+ CConcealment_CalcBandEnergy(
+ &pConcealmentInfo->spectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_n */
+ pSamplingRateInfo,
+ EightShortSequence,
+ CConcealment_NoExpand,
+ sfbEnergyAct);
+
+ CConcealment_InterpolateBuffer(
+ &pSpectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_(n-1) */
+ &pSpecScale[wnd],
+ &pConcealmentInfo->specScale[wnd],
+ &pSpecScale[wnd],
+ sfbEnergyPrev,
+ sfbEnergyAct,
+ scaleFactorBandsTotal,
+ pSfbOffset);
+
+ }
+ } else { /* f_n != EightShortSequence */
+ /* short---long---long interpolation */
+
+ int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
+ const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long;
+ SHORT specScaleOut;
+
+ CConcealment_CalcBandEnergy(&pSpectralCoefficient[samplesPerFrame - (samplesPerFrame / 8)], /* [wnd] spec_(n-2) */
+ pSamplingRateInfo,
+ EightShortSequence,
+ CConcealment_Expand,
+ sfbEnergyAct);
+
+ CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */
+ pSamplingRateInfo,
+ OnlyLongSequence,
+ CConcealment_NoExpand,
+ sfbEnergyPrev);
+
+ pIcsInfo->WindowShape = 0;
+ pIcsInfo->WindowSequence = LongStopSequence;
+
+ for (i = 0; i < samplesPerFrame ; i++) {
+ pSpectralCoefficient[i] = pConcealmentInfo->spectralCoefficient[i]; /* spec_n */
+ }
+
+ for (i = 0; i < 8; i++) { /* search for max(specScale) */
+ if (pSpecScale[i] > pSpecScale[0]) {
+ pSpecScale[0] = pSpecScale[i];
+ }
+ }
+
+ CConcealment_InterpolateBuffer(
+ pSpectralCoefficient, /* spec_(n-1) */
+ &pConcealmentInfo->specScale[0],
+ &pSpecScale[0],
+ &specScaleOut,
+ sfbEnergyPrev,
+ sfbEnergyAct,
+ scaleFactorBandsTotal,
+ pSfbOffset);
+
+ pSpecScale[0] = specScaleOut;
+ }
+ } else {
+ /* long--??????--short, long--??????--long interpolation */
+ /* long---long---short, long---long---long interpolation */
+
+ int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
+ const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long;
+ SHORT specScaleAct = pConcealmentInfo->specScale[0];
+
+ CConcealment_CalcBandEnergy(pSpectralCoefficient, /* spec_(n-2) */
+ pSamplingRateInfo,
+ OnlyLongSequence,
+ CConcealment_NoExpand,
+ sfbEnergyPrev);
+
+ if (pConcealmentInfo->windowSequence == EightShortSequence) { /* f_n == EightShortSequence */
+ /* long---long---short interpolation */
+
+ pIcsInfo->WindowShape = 1;
+ pIcsInfo->WindowSequence = LongStartSequence;
+
+ for (i = 1; i < 8; i++) { /* search for max(specScale) */
+ if (pConcealmentInfo->specScale[i] > specScaleAct) {
+ specScaleAct = pConcealmentInfo->specScale[i];
+ }
+ }
+
+ /* Expand first short spectrum */
+ CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */
+ pSamplingRateInfo,
+ EightShortSequence,
+ CConcealment_Expand, /* !!! */
+ sfbEnergyAct);
+ } else {
+ /* long---long---long interpolation */
+
+ pIcsInfo->WindowShape = 0;
+ pIcsInfo->WindowSequence = OnlyLongSequence;
+
+ CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */
+ pSamplingRateInfo,
+ OnlyLongSequence,
+ CConcealment_NoExpand,
+ sfbEnergyAct);
+ }
+
+ CConcealment_InterpolateBuffer(
+ pSpectralCoefficient, /* spec_(n-1) */
+ &pSpecScale[0],
+ &specScaleAct,
+ &pSpecScale[0],
+ sfbEnergyPrev,
+ sfbEnergyAct,
+ scaleFactorBandsTotal,
+ pSfbOffset);
+
+ }
+ }
+
+ /* Noise substitution of sign of the output spectral coefficients */
+ CConcealment_ApplyRandomSign (pConcealmentInfo->iRandomPhase,
+ pSpectralCoefficient,
+ samplesPerFrame);
+ /* Increment random phase index to avoid repetition artifacts. */
+ pConcealmentInfo->iRandomPhase = (pConcealmentInfo->iRandomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1);
+ }
+
+ /* scale spectrum according to concealment state */
+ switch (pConcealmentInfo->concealState)
+ {
+ case ConcealState_Single:
+ appliedProcessing = 1;
+ break;
+
+ case ConcealState_FadeOut:
+ {
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeOutFrames);
+
+ /* restore frequency coefficients from buffer with a specific muting */
+ FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1];
+ FIXP_SGL fac = pConcealCommonData->fadeOutFactor[pConcealmentInfo->cntFadeFrames];
+
+ for (i = samplesPerFrame; i != 0; i--) {
+ *pOut = fMult(*pOut, fac);
+ pOut--;
+ }
+ appliedProcessing = 1;
+ }
+ break;
+
+ case ConcealState_FadeIn:
+ {
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS);
+ FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeInFrames);
+
+ /* attenuate signal to get a smooth fade-in */
+ FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1];
+ FIXP_SGL fac = pConcealCommonData->fadeInFactor[pConcealmentInfo->cntFadeFrames];
+
+ for (i = samplesPerFrame; i != 0; i--) {
+ *pOut = fMult(*pOut, fac);
+ pOut--;
+ }
+ appliedProcessing = 1;
+ }
+ break;
+
+ case ConcealState_Mute:
+ {
+ int fac = pConcealCommonData->comfortNoiseLevel;
+
+ /* set dummy window parameters */
+ pIcsInfo->Valid = 0; /* Trigger the generation of a consitent IcsInfo */
+ pIcsInfo->WindowShape = pConcealmentInfo->windowShape; /* Prevent an invalid WindowShape (required for F/T transform) */
+ pIcsInfo->WindowSequence = CConcealment_GetWinSeq(pConcealmentInfo->windowSequence);
+ pConcealmentInfo->windowSequence = pIcsInfo->WindowSequence; /* Store for next frame (spectrum in concealment buffer can't be used at all) */
+
+ /* mute spectral data */
+ FDKmemclear(pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL));
+
+ if (fac >= 0 && fac <= 61) {
+ /* insert comfort noise using PNS */
+ CConcealment_fakePnsData (
+ &pAacDecoderChannelInfo->data.aac.PnsData,
+ pIcsInfo,
+ pSamplingRateInfo,
+ pAacDecoderChannelInfo->specScale,
+ pAacDecoderChannelInfo->pDynData->aScaleFactor,
+ fac
+ );
+
+ CPns_Apply (
+ &pAacDecoderChannelInfo->data.aac.PnsData,
+ pIcsInfo,
+ pAacDecoderChannelInfo->pSpectralCoefficient,
+ pAacDecoderChannelInfo->specScale,
+ pAacDecoderChannelInfo->pDynData->aScaleFactor,
+ pSamplingRateInfo,
+ pAacDecoderChannelInfo->granuleLength,
+ 0 /* always apply to first channel */
+ );
+ }
+ appliedProcessing = 1;
+ }
+ break;
+
+ default:
+ /* nothing to do here */
+ break;
+ }
+
+ return appliedProcessing;
+}
+
+
+/*!
+ \brief Calculate the spectral energy
+
+ The function calculates band-wise the spectral energy. This is used for
+ frame interpolation.
+
+ \return none
+*/
+static void
+ CConcealment_CalcBandEnergy (
+ FIXP_DBL *spectrum,
+ const SamplingRateInfo *pSamplingRateInfo,
+ const int blockType,
+ CConcealmentExpandType expandType,
+ int *sfbEnergy )
+{
+ const SHORT *pSfbOffset;
+ int line, sfb, scaleFactorBandsTotal = 0;
+
+ /* In the following calculations, enAccu is initialized with LSB-value in order to avoid zero energy-level */
+
+ line = 0;
+
+ switch(blockType) {
+
+ case OnlyLongSequence:
+ case LongStartSequence:
+ case LongStopSequence:
+
+ if (expandType == CConcealment_NoExpand) {
+ /* standard long calculation */
+ scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
+ pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long;
+
+ for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) {
+ FIXP_DBL enAccu = (FIXP_DBL)(LONG)1;
+ int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1;
+ /* scaling depends on sfb width. */
+ for ( ; line < pSfbOffset[sfb+1]; line++) {
+ enAccu += fPow2Div2(*(spectrum + line)) >> sfbScale;
+ }
+ *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1;
+ }
+ }
+ else {
+ /* compress long to short */
+ scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short;
+ pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short;
+
+ for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) {
+ FIXP_DBL enAccu = (FIXP_DBL)(LONG)1;
+ int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1;
+ /* scaling depends on sfb width. */
+ for (; line < pSfbOffset[sfb+1] << 3; line++) {
+ enAccu += (enAccu + (fPow2Div2(*(spectrum + line)) >> sfbScale)) >> 3;
+ }
+ *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1;
+ }
+ }
+ break;
+
+ case EightShortSequence:
+
+ if (expandType == CConcealment_NoExpand) {
+ /* standard short calculation */
+ scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short;
+ pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short;
+
+ for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) {
+ FIXP_DBL enAccu = (FIXP_DBL)(LONG)1;
+ int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1;
+ /* scaling depends on sfb width. */
+ for ( ; line < pSfbOffset[sfb+1]; line++) {
+ enAccu += fPow2Div2(*(spectrum + line)) >> sfbScale;
+ }
+ *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1;
+ }
+ }
+ else {
+ /* expand short to long spectrum */
+ scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long;
+ pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long;
+
+ for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) {
+ FIXP_DBL enAccu = (FIXP_DBL)(LONG)1;
+ int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1;
+ /* scaling depends on sfb width. */
+ for ( ; line < pSfbOffset[sfb+1]; line++) {
+ enAccu += fPow2Div2(*(spectrum + (line >> 3))) >> sfbScale;
+ }
+ *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1;
+ }
+ }
+ break;
+ }
+}
+
+
+/*!
+ \brief Interpolate buffer
+
+ The function creates the interpolated spectral data according to the
+ energy of the last good frame and the current (good) frame.
+
+ \return none
+*/
+static void
+ CConcealment_InterpolateBuffer (
+ FIXP_DBL *spectrum,
+ SHORT *pSpecScalePrv,
+ SHORT *pSpecScaleAct,
+ SHORT *pSpecScaleOut,
+ int *enPrv,
+ int *enAct,
+ int sfbCnt,
+ const SHORT *pSfbOffset )
+{
+ int sfb, line = 0;
+ int fac_shift;
+ int fac_mod;
+ FIXP_DBL accu;
+
+ for (sfb = 0; sfb < sfbCnt; sfb++) {
+
+ fac_shift = enPrv[sfb] - enAct[sfb] + ((*pSpecScaleAct - *pSpecScalePrv) << 1);
+ fac_mod = fac_shift & 3;
+ fac_shift = (fac_shift >> 2) + 1;
+ fac_shift += *pSpecScalePrv - fixMax(*pSpecScalePrv, *pSpecScaleAct);
+
+ for (; line < pSfbOffset[sfb+1]; line++) {
+ accu = fMult(*(spectrum+line), facMod4Table[fac_mod]);
+ if (fac_shift < 0) {
+ accu >>= -fac_shift;
+ } else {
+ accu <<= fac_shift;
+ }
+ *(spectrum+line) = accu;
+ }
+ }
+ *pSpecScaleOut = fixMax(*pSpecScalePrv, *pSpecScaleAct);
+}
+
+
+
+
+static INT findEquiFadeFrame (
+ CConcealParams *pConcealCommonData,
+ INT actFadeIndex,
+ int direction )
+{
+ FIXP_SGL *pFactor;
+ FIXP_SGL referenceVal;
+ FIXP_SGL minDiff = (FIXP_SGL)MAXVAL_SGL;
+
+ INT numFrames = 0;
+ INT nextFadeIndex = 0;
+
+ int i;
+
+ /* init depending on direction */
+ if (direction == 0) { /* FADE-OUT => FADE-IN */
+ numFrames = pConcealCommonData->numFadeInFrames;
+ referenceVal = pConcealCommonData->fadeOutFactor[actFadeIndex] >> 1;
+ pFactor = pConcealCommonData->fadeInFactor;
+ }
+ else { /* FADE-IN => FADE-OUT */
+ numFrames = pConcealCommonData->numFadeOutFrames;
+ referenceVal = pConcealCommonData->fadeInFactor[actFadeIndex] >> 1;
+ pFactor = pConcealCommonData->fadeOutFactor;
+ }
+
+ /* search for minimum difference */
+ for (i = 0; i < numFrames; i++) {
+ FIXP_SGL diff = fixp_abs((pFactor[i]>>1) - referenceVal);
+ if (diff < minDiff) {
+ minDiff = diff;
+ nextFadeIndex = i;
+ }
+ }
+
+ /* check and adjust depending on direction */
+ if (direction == 0) { /* FADE-OUT => FADE-IN */
+ if (((pFactor[nextFadeIndex]>>1) <= referenceVal) && (nextFadeIndex > 0)) {
+ nextFadeIndex -= 1;
+ }
+ }
+ else { /* FADE-IN => FADE-OUT */
+ if (((pFactor[nextFadeIndex]>>1) >= referenceVal) && (nextFadeIndex < numFrames-1)) {
+ nextFadeIndex += 1;
+ }
+ }
+
+ return (nextFadeIndex);
+}
+
+
+/*!
+ \brief Update the concealment state
+
+ The function updates the state of the concealment state-machine. The
+ states are: mute, fade-in, fade-out, interpolate and frame-ok.
+
+ \return none
+*/
+static void
+ CConcealment_UpdateState (
+ CConcealmentInfo *pConcealmentInfo,
+ int frameOk )
+{
+ CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams;
+
+ switch (pConcealCommonData->method)
+ {
+ case ConcealMethodNoise:
+ {
+ if (pConcealmentInfo->concealState != ConcealState_Ok) {
+ /* count the valid frames during concealment process */
+ if (frameOk) {
+ pConcealmentInfo->cntValidFrames += 1;
+ } else {
+ pConcealmentInfo->cntValidFrames = 0;
+ }
+ }
+
+ /* -- STATE MACHINE for Noise Substitution -- */
+ switch (pConcealmentInfo->concealState)
+ {
+ case ConcealState_Ok:
+ if (!frameOk) {
+ /* change to state SINGLE-FRAME-LOSS */
+ pConcealmentInfo->concealState = ConcealState_Single;
+ pConcealmentInfo->cntFadeFrames = 0;
+ pConcealmentInfo->cntValidFrames = 0;
+ }
+ break;
+
+ case ConcealState_Single: /* Just a pre-stage before fade-out begins. Stay here only one frame! */
+ pConcealmentInfo->cntFadeFrames += 1;
+ if (frameOk) {
+ if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData,
+ pConcealmentInfo->cntFadeFrames-1,
+ 0 /* FadeOut -> FadeIn */);
+ } else {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ } else {
+ /* change to state FADE-OUT */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ }
+ }
+ break;
+
+ case ConcealState_FadeOut:
+ pConcealmentInfo->cntFadeFrames += 1; /* used to address the fade-out factors */
+ if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData,
+ pConcealmentInfo->cntFadeFrames-1,
+ 0 /* FadeOut -> FadeIn */);
+ } else {
+ if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ }
+ break;
+
+ case ConcealState_Mute:
+ if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = pConcealCommonData->numFadeInFrames - 1;
+ }
+ break;
+
+ case ConcealState_FadeIn:
+ pConcealmentInfo->cntFadeFrames -= 1; /* used to address the fade-in factors */
+ if (frameOk) {
+ if (pConcealmentInfo->cntFadeFrames < 0) {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ /* change to state FADE-OUT */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData,
+ pConcealmentInfo->cntFadeFrames+1,
+ 1 /* FadeIn -> FadeOut */);
+ }
+ break;
+
+ default:
+ FDK_ASSERT(0);
+ break;
+ }
+ }
+ break;
+
+ case ConcealMethodInter:
+ case ConcealMethodTonal:
+ {
+ if (pConcealmentInfo->concealState != ConcealState_Ok) {
+ /* count the valid frames during concealment process */
+ if ( pConcealmentInfo->prevFrameOk[1] ||
+ (pConcealmentInfo->prevFrameOk[0] && !pConcealmentInfo->prevFrameOk[1] && frameOk) ) {
+ /* The frame is OK even if it can be estimated by the energy interpolation algorithm */
+ pConcealmentInfo->cntValidFrames += 1;
+ } else {
+ pConcealmentInfo->cntValidFrames = 0;
+ }
+ }
+
+ /* -- STATE MACHINE for energy interpolation -- */
+ switch (pConcealmentInfo->concealState)
+ {
+ case ConcealState_Ok:
+ if (!(pConcealmentInfo->prevFrameOk[1] ||
+ (pConcealmentInfo->prevFrameOk[0] && !pConcealmentInfo->prevFrameOk[1] && frameOk))) {
+ /* Fade out only if the energy interpolation algorithm can not be applied! */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ pConcealmentInfo->cntFadeFrames = 0;
+ pConcealmentInfo->cntValidFrames = 0;
+ }
+ break;
+
+ case ConcealState_Single:
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ break;
+
+ case ConcealState_FadeOut:
+ pConcealmentInfo->cntFadeFrames += 1;
+
+ if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData,
+ pConcealmentInfo->cntFadeFrames-1,
+ 0 /* FadeOut -> FadeIn */);
+ } else {
+ if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ }
+ break;
+
+ case ConcealState_Mute:
+ if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = pConcealCommonData->numFadeInFrames - 1;
+ }
+ break;
+
+ case ConcealState_FadeIn:
+ pConcealmentInfo->cntFadeFrames -= 1; /* used to address the fade-in factors */
+
+ if (frameOk || pConcealmentInfo->prevFrameOk[1]) {
+ if (pConcealmentInfo->cntFadeFrames < 0) {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ /* change to state FADE-OUT */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData,
+ pConcealmentInfo->cntFadeFrames+1,
+ 1 /* FadeIn -> FadeOut */);
+ }
+ break;
+ } /* End switch(pConcealmentInfo->concealState) */
+ }
+ break;
+
+ default:
+ /* Don't need a state machine for other concealment methods. */
+ break;
+ }
+
+}
+
+
+/*!
+\brief Randomizes the sign of the spectral data
+
+ The function toggles the sign of the spectral data randomly. This is
+ useful to ensure the quality of the concealed frames.
+
+\return none
+ */
+static
+void CConcealment_ApplyRandomSign (int randomPhase,
+ FIXP_DBL *spec,
+ int samplesPerFrame
+ )
+{
+ int i;
+ USHORT packedSign=0;
+
+ /* random table 512x16bit has been reduced to 512 packed sign bits = 32x16 bit */
+
+ /* read current packed sign word */
+ packedSign = randomSign[randomPhase>>4];
+ packedSign >>= (randomPhase&0xf);
+
+ for (i = 0; i < samplesPerFrame ; i++) {
+ if ((randomPhase & 0xf) == 0) {
+ packedSign = randomSign[randomPhase>>4];
+ }
+
+ if (packedSign & 0x1) {
+ spec[i] = -spec[i];
+ }
+ packedSign >>= 1;
+
+ randomPhase = (randomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1);
+ }
+}
+
+
+/*!
+ \brief Get fadeing factor for current concealment state.
+
+ The function returns the factor used for fading that belongs to the current internal state.
+
+ \return Fade factor
+ */
+FIXP_DBL
+ CConcealment_GetFadeFactor (
+ CConcealmentInfo *hConcealmentInfo,
+ const int fPreviousFactor
+ )
+{
+ FIXP_DBL fac = (FIXP_DBL)0;
+
+ CConcealParams *pConcealCommonData = hConcealmentInfo->pConcealParams;
+
+ if (hConcealmentInfo->pConcealParams->method > ConcealMethodMute) {
+ switch (hConcealmentInfo->concealState) {
+ default:
+ case ConcealState_Mute:
+ /* Nothing to do here */
+ break;
+ case ConcealState_Ok:
+ fac = (FIXP_DBL)MAXVAL_DBL;
+ break;
+ case ConcealState_Single:
+ case ConcealState_FadeOut:
+ {
+ int idx = hConcealmentInfo->cntFadeFrames - ((fPreviousFactor != 0) ? 1 : 0);
+ fac = (idx < 0) ? (FIXP_DBL)MAXVAL_DBL : FX_SGL2FX_DBL(pConcealCommonData->fadeOutFactor[idx]);
+ }
+ break;
+ case ConcealState_FadeIn:
+ {
+ int idx = hConcealmentInfo->cntFadeFrames + ((fPreviousFactor != 0) ? 1 : 0);
+ fac = (idx >= hConcealmentInfo->pConcealParams->numFadeInFrames) ? (FIXP_DBL)0 : FX_SGL2FX_DBL(pConcealCommonData->fadeInFactor[idx]);
+ }
+ break;
+ }
+ }
+
+ return (fac);
+}
+
+
+/*!
+ \brief Get fadeing factor for current concealment state.
+
+ The function returns the state (ok or not) of the previous frame.
+ If called before the function CConcealment_Apply() set the fBeforeApply
+ flag to get the correct value.
+
+ \return Frame OK flag of previous frame.
+ */
+int
+ CConcealment_GetLastFrameOk (
+ CConcealmentInfo *hConcealmentInfo,
+ const int fBeforeApply
+ )
+{
+ int prevFrameOk = 1;
+
+ if (hConcealmentInfo != NULL) {
+ prevFrameOk = hConcealmentInfo->prevFrameOk[fBeforeApply & 0x1];
+ }
+
+ return prevFrameOk;
+}
+
+/*!
+ \brief Get the number of delay frames introduced by concealment technique.
+
+ \return Number of delay frames.
+ */
+UINT
+ CConcealment_GetDelay (
+ CConcealParams *pConcealCommonData
+ )
+{
+ UINT frameDelay = 0;
+
+ if (pConcealCommonData != NULL) {
+ switch (pConcealCommonData->method) {
+ case ConcealMethodTonal:
+ case ConcealMethodInter:
+ frameDelay = 1;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return frameDelay;
+}
+