aboutsummaryrefslogtreecommitdiffstats
path: root/fdk-aac/libAACdec/src/conceal.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fdk-aac/libAACdec/src/conceal.cpp')
-rw-r--r--fdk-aac/libAACdec/src/conceal.cpp2095
1 files changed, 2095 insertions, 0 deletions
diff --git a/fdk-aac/libAACdec/src/conceal.cpp b/fdk-aac/libAACdec/src/conceal.cpp
new file mode 100644
index 0000000..5895cb8
--- /dev/null
+++ b/fdk-aac/libAACdec/src/conceal.cpp
@@ -0,0 +1,2095 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** AAC decoder library ******************************
+
+ Author(s): Josef Hoepfl
+
+ Description: independent channel concealment
+
+*******************************************************************************/
+
+/*!
+ \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"
+
+#define CONCEAL_DFLT_COMF_NOISE_LEVEL (0x100000)
+
+#define CONCEAL_NOT_DEFINED ((UCHAR)-1)
+
+/* default settings */
+#define CONCEAL_DFLT_FADEOUT_FRAMES (6)
+#define CONCEAL_DFLT_FADEIN_FRAMES (5)
+#define CONCEAL_DFLT_MUTE_RELEASE_FRAMES (0)
+
+#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, const int mute_release_active);
+
+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,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const int samplesPerFrame, CAacDecoderChannelInfo *pAacDecoderChannelInfo);
+
+static void CConcealment_ApplyRandomSign(int iRandomPhase, FIXP_DBL *spec,
+ int samplesPerFrame);
+
+/* TimeDomainFading */
+static void CConcealment_TDFadePcmAtt(int start, int len, FIXP_DBL fadeStart,
+ FIXP_DBL fadeStop, FIXP_PCM *pcmdata);
+static void CConcealment_TDFadeFillFadingStations(FIXP_DBL *fadingStations,
+ int *fadingSteps,
+ FIXP_DBL fadeStop,
+ FIXP_DBL fadeStart,
+ TDfadingType fadingType);
+static void CConcealment_TDFading_doLinearFadingSteps(int *fadingSteps);
+
+/* Streamline the state machine */
+static int CConcealment_ApplyFadeOut(
+ int mode, CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const int samplesPerFrame, CAacDecoderChannelInfo *pAacDecoderChannelInfo);
+
+static int CConcealment_TDNoise_Random(ULONG *seed);
+static void CConcealment_TDNoise_Apply(CConcealmentInfo *const pConcealmentInfo,
+ const int len, FIXP_PCM *const pcmdata);
+
+static BLOCK_TYPE CConcealment_GetWinSeq(int prevWinSeq) {
+ BLOCK_TYPE newWinSeq = BLOCK_LONG;
+
+ /* Try to have only long blocks */
+ if (prevWinSeq == BLOCK_START || prevWinSeq == BLOCK_SHORT) {
+ newWinSeq = BLOCK_STOP;
+ }
+
+ return (newWinSeq);
+}
+
+/*!
+ \brief Init common concealment information data
+
+ \param pConcealCommonData Pointer to the concealment common data structure.
+*/
+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 =
+ (FIXP_DBL)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.
+
+ \param pConcealCommonData Pointer to common concealment data (for all
+ channels)
+*/
+CConcealmentMethod CConcealment_GetMethod(CConcealParams *pConcealCommonData) {
+ CConcealmentMethod method = ConcealMethodNone;
+
+ if (pConcealCommonData != NULL) {
+ method = pConcealCommonData->method;
+ }
+
+ return (method);
+}
+
+/*!
+ \brief Init concealment information for each channel
+
+ \param pConcealChannelInfo Pointer to the channel related concealment info
+ structure to be initialized. \param pConcealCommonData Pointer to common
+ concealment data (for all channels) \param initRenderMode Initial render
+ mode to be set for the current channel. \param samplesPerFrame The number
+ of samples per frame.
+*/
+void CConcealment_InitChannelData(CConcealmentInfo *pConcealChannelInfo,
+ CConcealParams *pConcealCommonData,
+ AACDEC_RENDER_MODE initRenderMode,
+ int samplesPerFrame) {
+ int i;
+ pConcealChannelInfo->TDNoiseSeed = 0;
+ FDKmemclear(pConcealChannelInfo->TDNoiseStates,
+ sizeof(pConcealChannelInfo->TDNoiseStates));
+ pConcealChannelInfo->TDNoiseCoef[0] = FL2FXCONST_SGL(0.05f);
+ pConcealChannelInfo->TDNoiseCoef[1] = FL2FXCONST_SGL(0.5f);
+ pConcealChannelInfo->TDNoiseCoef[2] = FL2FXCONST_SGL(0.45f);
+
+ pConcealChannelInfo->pConcealParams = pConcealCommonData;
+
+ pConcealChannelInfo->lastRenderMode = initRenderMode;
+
+ pConcealChannelInfo->windowShape = CONCEAL_NOT_DEFINED;
+ pConcealChannelInfo->windowSequence = BLOCK_LONG; /* default type */
+ pConcealChannelInfo->lastWinGrpLen = 1;
+
+ pConcealChannelInfo->concealState = ConcealState_Ok;
+
+ FDKmemclear(pConcealChannelInfo->spectralCoefficient,
+ 1024 * sizeof(FIXP_CNCL));
+
+ for (i = 0; i < 8; i++) {
+ pConcealChannelInfo->specScale[i] = 0;
+ }
+
+ pConcealChannelInfo->iRandomPhase = 0;
+
+ pConcealChannelInfo->prevFrameOk[0] = 1;
+ pConcealChannelInfo->prevFrameOk[1] = 1;
+
+ pConcealChannelInfo->cntFadeFrames = 0;
+ pConcealChannelInfo->cntValidFrames = 0;
+ pConcealChannelInfo->fade_old = (FIXP_DBL)MAXVAL_DBL;
+ pConcealChannelInfo->winGrpOffset[0] = 0;
+ pConcealChannelInfo->winGrpOffset[1] = 0;
+ pConcealChannelInfo->attGrpOffset[0] = 0;
+ pConcealChannelInfo->attGrpOffset[1] = 0;
+}
+
+/*!
+ \brief Set error concealment parameters
+
+ \param concealParams
+ \param method
+ \param fadeOutSlope
+ \param fadeInSlope
+ \param muteRelease
+ \param comfNoiseLevel
+*/
+AAC_DECODER_ERROR
+CConcealment_SetParams(CConcealParams *concealParams, int method,
+ int fadeOutSlope, int fadeInSlope, int muteRelease,
+ FIXP_DBL 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 >= 0)) {
+ 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 != (FIXP_DBL)AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) {
+ if ((comfNoiseLevel < (FIXP_DBL)0) ||
+ (comfNoiseLevel > (FIXP_DBL)MAXVAL_DBL)) {
+ return AAC_DEC_SET_PARAM_FAIL;
+ }
+ if (concealParams == NULL) {
+ return AAC_DEC_INVALID_HANDLE;
+ } else {
+ concealParams->comfortNoiseLevel = (FIXP_DBL)comfNoiseLevel;
+ }
+ }
+
+ return (AAC_DEC_OK);
+}
+
+/*!
+ \brief Set fade-out/in attenuation factor vectors
+
+ \param concealParams
+ \param fadeOutAttenuationVector
+ \param fadeInAttenuationVector
+
+ \return 0 if OK all other values indicate errors
+*/
+AAC_DECODER_ERROR
+CConcealment_SetAttenuation(CConcealParams *concealParams,
+ const SHORT *fadeOutAttenuationVector,
+ const 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.
+
+ \param pConcealChannelInfo
+
+ \return Concealment state.
+*/
+CConcealmentState CConcealment_GetState(CConcealmentInfo *pConcealChannelInfo) {
+ CConcealmentState state = ConcealState_Ok;
+
+ if (pConcealChannelInfo != NULL) {
+ state = pConcealChannelInfo->concealState;
+ }
+
+ return (state);
+}
+
+/*!
+ \brief Store data for concealment techniques applied later
+
+ Interface function to store data for different concealment strategies
+ */
+void CConcealment_Store(
+ CConcealmentInfo *hConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo) {
+ UCHAR nbDiv = NB_DIV;
+
+ if (!(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD &&
+ pAacDecoderChannelInfo->data.usac.mod[nbDiv - 1] == 0))
+
+ {
+ FIXP_DBL *pSpectralCoefficient =
+ SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+
+ SHORT tSpecScale[8];
+ UCHAR tWindowShape;
+ BLOCK_TYPE 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 (hConcealmentInfo->pConcealParams->method < ConcealMethodInter) {
+ /* 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 {
+ /* swap spectral data */
+#if (FIXP_CNCL == FIXP_DBL)
+ C_ALLOC_SCRATCH_START(pSpecTmp, FIXP_DBL, 1024);
+ FDKmemcpy(pSpecTmp, pSpectralCoefficient, 1024 * sizeof(FIXP_DBL));
+ FDKmemcpy(pSpectralCoefficient, hConcealmentInfo->spectralCoefficient,
+ 1024 * sizeof(FIXP_DBL));
+ FDKmemcpy(hConcealmentInfo->spectralCoefficient, pSpecTmp,
+ 1024 * sizeof(FIXP_DBL));
+ C_ALLOC_SCRATCH_END(pSpecTmp, FIXP_DBL, 1024);
+#else
+ FIXP_CNCL *RESTRICT pCncl =
+ &hConcealmentInfo->spectralCoefficient[1024 - 1];
+ FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024 - 1];
+ FIXP_DBL tSpec;
+
+ for (int i = 1024; i != 0; i--) {
+ tSpec = *pSpec;
+ *pSpec-- = FX_CNCL2FX_DBL(*pCncl);
+ *pCncl-- = FX_DBL2FX_CNCL(tSpec);
+ }
+#endif
+
+ /* complete swapping of window infos */
+ pIcsInfo->WindowSequence = tWindowSequence;
+ pIcsInfo->WindowShape = tWindowShape;
+
+ /* complete swapping of scale factors */
+ FDKmemcpy(pSpecScale, tSpecScale, 8 * sizeof(SHORT));
+ }
+ }
+
+ if (pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD) {
+ /* Store LSF4 */
+ FDKmemcpy(hConcealmentInfo->lsf4, pAacDecoderStaticChannelInfo->lpc4_lsf,
+ sizeof(hConcealmentInfo->lsf4));
+ /* Store TCX gain */
+ hConcealmentInfo->last_tcx_gain =
+ pAacDecoderStaticChannelInfo->last_tcx_gain;
+ hConcealmentInfo->last_tcx_gain_e =
+ pAacDecoderStaticChannelInfo->last_tcx_gain_e;
+ }
+}
+
+/*!
+ \brief Apply concealment
+
+ Interface function to different concealment strategies
+ */
+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;
+ const int mute_release_active =
+ frameOk && (hConcealmentInfo->concealState >= ConcealState_Mute) &&
+ (hConcealmentInfo->cntValidFrames + 1 <=
+ hConcealmentInfo->pConcealParams->numMuteReleaseFrames);
+
+ if (hConcealmentInfo->windowShape == CONCEAL_NOT_DEFINED) {
+ /* Initialize window_shape with same value as in the current (parsed) frame.
+ Because section 4.6.11.3.2 (Windowing and block switching) of ISO/IEC
+ 14496-3:2009 says: For the first raw_data_block() to be decoded the
+ window_shape of the left and right half of the window are identical. */
+ hConcealmentInfo->windowShape = pAacDecoderChannelInfo->icsInfo.WindowShape;
+ }
+
+ if (frameOk && !mute_release_active) {
+ /* Update render mode if frameOk except for ongoing mute release state. */
+ hConcealmentInfo->lastRenderMode =
+ (SCHAR)pAacDecoderChannelInfo->renderMode;
+
+ /* 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;
+ } else {
+ if (hConcealmentInfo->lastRenderMode == AACDEC_RENDER_INVALID) {
+ hConcealmentInfo->lastRenderMode = AACDEC_RENDER_IMDCT;
+ }
+ pAacDecoderChannelInfo->renderMode =
+ (AACDEC_RENDER_MODE)hConcealmentInfo->lastRenderMode;
+ }
+
+ /* hand current frame status to the state machine */
+ CConcealment_UpdateState(hConcealmentInfo, frameOk,
+ pAacDecoderStaticChannelInfo, samplesPerFrame,
+ pAacDecoderChannelInfo);
+
+ {
+ if (!frameOk && pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_IMDCT) {
+ /* LPC extrapolation */
+ CLpc_Conceal(pAacDecoderChannelInfo->data.usac.lsp_coeff,
+ pAacDecoderStaticChannelInfo->lpc4_lsf,
+ pAacDecoderStaticChannelInfo->lsf_adaptive_mean,
+ hConcealmentInfo->lastRenderMode == AACDEC_RENDER_IMDCT);
+ FDKmemcpy(hConcealmentInfo->lsf4, pAacDecoderStaticChannelInfo->lpc4_lsf,
+ sizeof(pAacDecoderStaticChannelInfo->lpc4_lsf));
+ }
+
+ /* Create data for signal rendering according to the selected concealment
+ * method and decoder operating mode. */
+
+ if ((!frameOk || mute_release_active) &&
+ (pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD)) {
+ /* Restore old LSF4 */
+ FDKmemcpy(pAacDecoderStaticChannelInfo->lpc4_lsf, hConcealmentInfo->lsf4,
+ sizeof(pAacDecoderStaticChannelInfo->lpc4_lsf));
+ /* Restore old TCX gain */
+ pAacDecoderStaticChannelInfo->last_tcx_gain =
+ hConcealmentInfo->last_tcx_gain;
+ pAacDecoderStaticChannelInfo->last_tcx_gain_e =
+ hConcealmentInfo->last_tcx_gain_e;
+ }
+
+ if (!(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD &&
+ pAacDecoderStaticChannelInfo->last_lpd_mode == 0)) {
+ switch (hConcealmentInfo->pConcealParams->method) {
+ default:
+ case ConcealMethodMute:
+ if (!frameOk) {
+ /* 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 */
+ frameOk, mute_release_active);
+ break;
+ }
+ } else if (!frameOk || mute_release_active) {
+ /* simply restore the buffer */
+ FIXP_DBL *pSpectralCoefficient =
+ SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+#if (CNCL_FRACT_BITS != DFRACT_BITS)
+ FIXP_CNCL *RESTRICT pCncl =
+ &hConcealmentInfo->spectralCoefficient[1024 - 1];
+ FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024 - 1];
+ int i;
+#endif
+
+ /* restore window infos (gri) do we need that? */
+ pIcsInfo->WindowSequence = hConcealmentInfo->windowSequence;
+ pIcsInfo->WindowShape = hConcealmentInfo->windowShape;
+
+ if (hConcealmentInfo->concealState != ConcealState_Mute) {
+ /* restore scale factors */
+ FDKmemcpy(pSpecScale, hConcealmentInfo->specScale, 8 * sizeof(SHORT));
+
+ /* restore spectral bins */
+#if (CNCL_FRACT_BITS == DFRACT_BITS)
+ FDKmemcpy(pSpectralCoefficient, hConcealmentInfo->spectralCoefficient,
+ 1024 * sizeof(FIXP_DBL));
+#else
+ for (i = 1024; i != 0; i--) {
+ *pSpec-- = FX_CNCL2FX_DBL(*pCncl--);
+ }
+#endif
+ } else {
+ /* clear scale factors */
+ FDKmemclear(pSpecScale, 8 * sizeof(SHORT));
+
+ /* clear buffer */
+ FDKmemclear(pSpectralCoefficient, 1024 * sizeof(FIXP_CNCL));
+ }
+ }
+ }
+ /* update history */
+ hConcealmentInfo->prevFrameOk[0] = hConcealmentInfo->prevFrameOk[1];
+ hConcealmentInfo->prevFrameOk[1] = frameOk;
+
+ return mute_release_active ? -1 : 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.
+ */
+static int CConcealment_ApplyNoise(
+ CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo, const int samplesPerFrame,
+ const UINT flags) {
+ FIXP_DBL *pSpectralCoefficient =
+ SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+
+ int appliedProcessing = 0;
+
+ FDK_ASSERT(pConcealmentInfo != NULL);
+ FDK_ASSERT((samplesPerFrame >= 120) && (samplesPerFrame <= 1024));
+
+ switch (pConcealmentInfo->concealState) {
+ case ConcealState_Ok:
+ /* Nothing to do here! */
+ break;
+
+ case ConcealState_Single:
+ case ConcealState_FadeOut:
+ appliedProcessing = CConcealment_ApplyFadeOut(
+ /*mode =*/1, pConcealmentInfo, pAacDecoderStaticChannelInfo,
+ samplesPerFrame, pAacDecoderChannelInfo);
+ 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));
+ FDKmemclear(pConcealmentInfo->spectralCoefficient,
+ samplesPerFrame * sizeof(FIXP_DBL));
+
+ appliedProcessing = 1;
+ } break;
+
+ case ConcealState_FadeIn: {
+ /* TimeDomainFading: */
+ /* Attenuation of signal is done in CConcealment_TDFading() */
+
+ 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.
+*/
+static int CConcealment_ApplyInter(
+ CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderChannelInfo *pAacDecoderChannelInfo,
+ const SamplingRateInfo *pSamplingRateInfo, const int samplesPerFrame,
+ const int improveTonal, const int frameOk, const int mute_release_active) {
+#if defined(FDK_ASSERT_ENABLE)
+ CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams;
+#endif
+
+ 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 || mute_release_active) {
+ /* 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] || mute_release_active) {
+ /* 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] && !mute_release_active) {
+ appliedProcessing = 1;
+
+ /* Interpolate both frames in order to generate the current output frame
+ * (f_(n-1)). */
+ if (pIcsInfo->WindowSequence == BLOCK_SHORT) {
+ /* f_(n-2) == BLOCK_SHORT */
+ /* short--??????--short, short--??????--long interpolation */
+ /* short--short---short, short---long---long interpolation */
+
+ int wnd;
+
+ if (pConcealmentInfo->windowSequence ==
+ BLOCK_SHORT) { /* f_n == BLOCK_SHORT */
+ /* short--short---short interpolation */
+
+ int scaleFactorBandsTotal =
+ pSamplingRateInfo->NumberOfScaleFactorBands_Short;
+ const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short;
+ pIcsInfo->WindowShape = (samplesPerFrame <= 512) ? 2 : 1;
+ pIcsInfo->WindowSequence = BLOCK_SHORT;
+
+ for (wnd = 0; wnd < 8; wnd++) {
+ CConcealment_CalcBandEnergy(
+ &pSpectralCoefficient[wnd *
+ (samplesPerFrame / 8)], /* spec_(n-2) */
+ pSamplingRateInfo, BLOCK_SHORT, CConcealment_NoExpand,
+ sfbEnergyPrev);
+
+ CConcealment_CalcBandEnergy(
+ &pConcealmentInfo->spectralCoefficient[wnd * (samplesPerFrame /
+ 8)], /* spec_n */
+ pSamplingRateInfo, BLOCK_SHORT, 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 != BLOCK_SHORT */
+ /* 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, BLOCK_SHORT, CConcealment_Expand,
+ sfbEnergyAct);
+
+ CConcealment_CalcBandEnergy(
+ pConcealmentInfo->spectralCoefficient, /* spec_n */
+ pSamplingRateInfo, BLOCK_LONG, CConcealment_NoExpand,
+ sfbEnergyPrev);
+
+ pIcsInfo->WindowShape = 0;
+ pIcsInfo->WindowSequence = BLOCK_STOP;
+
+ 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, BLOCK_LONG,
+ CConcealment_NoExpand, sfbEnergyPrev);
+
+ if (pConcealmentInfo->windowSequence ==
+ BLOCK_SHORT) { /* f_n == BLOCK_SHORT */
+ /* long---long---short interpolation */
+
+ pIcsInfo->WindowShape = (samplesPerFrame <= 512) ? 2 : 1;
+ pIcsInfo->WindowSequence = BLOCK_START;
+
+ 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, BLOCK_SHORT, CConcealment_Expand, /* !!! */
+ sfbEnergyAct);
+ } else {
+ /* long---long---long interpolation */
+
+ pIcsInfo->WindowShape = 0;
+ pIcsInfo->WindowSequence = BLOCK_LONG;
+
+ CConcealment_CalcBandEnergy(
+ pConcealmentInfo->spectralCoefficient, /* spec_n */
+ pSamplingRateInfo, BLOCK_LONG, 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);
+
+ /* TimeDomainFading: */
+ /* Attenuation of signal is done in CConcealment_TDFading() */
+
+ 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);
+
+ /* TimeDomainFading: */
+ /* Attenuation of signal is done in CConcealment_TDFading() */
+
+ 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));
+
+ 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.
+*/
+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 BLOCK_LONG:
+ case BLOCK_START:
+ case BLOCK_STOP:
+
+ 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 BLOCK_SHORT:
+
+ 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.
+*/
+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);
+}
+
+/*!
+ \brief Find next fading frame in case of changing fading direction
+
+ \param pConcealCommonData Pointer to the concealment common data structure.
+ \param actFadeIndex Last index used for fading
+ \param direction Direction of change: 0 : change from FADE-OUT to FADE-IN, 1
+ : change from FADE-IN to FADE-OUT
+
+ This function determines the next fading index to be used for the fading
+ direction to be changed to.
+*/
+
+static INT findEquiFadeFrame(CConcealParams *pConcealCommonData,
+ INT actFadeIndex, int direction) {
+ FIXP_SGL *pFactor;
+ FIXP_SGL referenceVal;
+ FIXP_SGL minDiff = (FIXP_SGL)MAXVAL_SGL;
+
+ INT nextFadeIndex = 0;
+
+ int i;
+
+ /* init depending on direction */
+ if (direction == 0) { /* FADE-OUT => FADE-IN */
+ if (actFadeIndex < 0) {
+ referenceVal = (FIXP_SGL)MAXVAL_SGL;
+ } else {
+ referenceVal = pConcealCommonData->fadeOutFactor[actFadeIndex] >> 1;
+ }
+ pFactor = pConcealCommonData->fadeInFactor;
+ } else { /* FADE-IN => FADE-OUT */
+ if (actFadeIndex < 0) {
+ referenceVal = (FIXP_SGL)MAXVAL_SGL;
+ } else {
+ referenceVal = pConcealCommonData->fadeInFactor[actFadeIndex] >> 1;
+ }
+ pFactor = pConcealCommonData->fadeOutFactor;
+ }
+
+ /* search for minimum difference */
+ for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; 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 (nextFadeIndex > pConcealCommonData->numFadeInFrames) {
+ nextFadeIndex = fMax(pConcealCommonData->numFadeInFrames - 1, 0);
+ }
+ if (((pFactor[nextFadeIndex] >> 1) <= referenceVal) &&
+ (nextFadeIndex > 0)) {
+ nextFadeIndex -= 1;
+ }
+ } else { /* FADE-IN => FADE-OUT */
+ if (((pFactor[nextFadeIndex] >> 1) >= referenceVal) &&
+ (nextFadeIndex < CONCEAL_MAX_NUM_FADE_FACTORS - 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.
+*/
+static void CConcealment_UpdateState(
+ CConcealmentInfo *pConcealmentInfo, int frameOk,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const int samplesPerFrame, CAacDecoderChannelInfo *pAacDecoderChannelInfo) {
+ 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) {
+ pConcealmentInfo->cntFadeFrames = 0;
+ pConcealmentInfo->cntValidFrames = 0;
+ pConcealmentInfo->attGrpOffset[0] = 0;
+ pConcealmentInfo->attGrpOffset[1] = 0;
+ pConcealmentInfo->winGrpOffset[0] = 0;
+ pConcealmentInfo->winGrpOffset[1] = 0;
+ if (pConcealCommonData->numFadeOutFrames > 0) {
+ /* change to state SINGLE-FRAME-LOSS */
+ pConcealmentInfo->concealState = ConcealState_Single;
+ /* mode 0 just updates the Fading counter */
+ CConcealment_ApplyFadeOut(
+ /*mode =*/0, pConcealmentInfo, pAacDecoderStaticChannelInfo,
+ samplesPerFrame, pAacDecoderChannelInfo);
+
+ } else {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ }
+ break;
+
+ case ConcealState_Single: /* Just a pre-stage before fade-out begins.
+ Stay here only one frame! */
+ if (frameOk) {
+ /* 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;
+ /* mode 0 just updates the Fading counter */
+ CConcealment_ApplyFadeOut(
+ /*mode =*/0, pConcealmentInfo, pAacDecoderStaticChannelInfo,
+ samplesPerFrame, pAacDecoderChannelInfo);
+ }
+ }
+ break;
+
+ case ConcealState_FadeOut:
+ if (pConcealmentInfo->cntValidFrames >
+ pConcealCommonData->numMuteReleaseFrames) {
+ if (pConcealCommonData->numFadeInFrames > 0) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame(
+ pConcealCommonData, pConcealmentInfo->cntFadeFrames,
+ 0 /* FadeOut -> FadeIn */);
+ } else {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ if (frameOk) {
+ /* we have good frame information but stay fully in concealment -
+ * reset winGrpOffset/attGrpOffset */
+ pConcealmentInfo->winGrpOffset[0] = 0;
+ pConcealmentInfo->winGrpOffset[1] = 0;
+ pConcealmentInfo->attGrpOffset[0] = 0;
+ pConcealmentInfo->attGrpOffset[1] = 0;
+ }
+ if (pConcealmentInfo->cntFadeFrames >=
+ pConcealCommonData->numFadeOutFrames) {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ } else /* Stay in FADE-OUT */
+ {
+ /* mode 0 just updates the Fading counter */
+ CConcealment_ApplyFadeOut(
+ /*mode =*/0, pConcealmentInfo, pAacDecoderStaticChannelInfo,
+ samplesPerFrame, pAacDecoderChannelInfo);
+ }
+ }
+ break;
+
+ case ConcealState_Mute:
+ if (pConcealmentInfo->cntValidFrames >
+ pConcealCommonData->numMuteReleaseFrames) {
+ if (pConcealCommonData->numFadeInFrames > 0) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames =
+ pConcealCommonData->numFadeInFrames - 1;
+ } else {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ if (frameOk) {
+ /* we have good frame information but stay fully in concealment -
+ * reset winGrpOffset/attGrpOffset */
+ pConcealmentInfo->winGrpOffset[0] = 0;
+ pConcealmentInfo->winGrpOffset[1] = 0;
+ pConcealmentInfo->attGrpOffset[0] = 0;
+ pConcealmentInfo->attGrpOffset[1] = 0;
+ }
+ }
+ break;
+
+ case ConcealState_FadeIn:
+ pConcealmentInfo->cntFadeFrames -= 1;
+ if (frameOk) {
+ if (pConcealmentInfo->cntFadeFrames < 0) {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ } else {
+ if (pConcealCommonData->numFadeOutFrames > 0) {
+ /* change to state FADE-OUT */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame(
+ pConcealCommonData, pConcealmentInfo->cntFadeFrames + 1,
+ 1 /* FadeIn -> FadeOut */);
+ pConcealmentInfo->winGrpOffset[0] = 0;
+ pConcealmentInfo->winGrpOffset[1] = 0;
+ pConcealmentInfo->attGrpOffset[0] = 0;
+ pConcealmentInfo->attGrpOffset[1] = 0;
+
+ pConcealmentInfo
+ ->cntFadeFrames--; /* decrease because
+ CConcealment_ApplyFadeOut() will
+ increase, accordingly */
+ /* mode 0 just updates the Fading counter */
+ CConcealment_ApplyFadeOut(
+ /*mode =*/0, pConcealmentInfo, pAacDecoderStaticChannelInfo,
+ samplesPerFrame, pAacDecoderChannelInfo);
+ } else {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ }
+ 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))) {
+ if (pConcealCommonData->numFadeOutFrames > 0) {
+ /* Fade out only if the energy interpolation algorithm can not be
+ * applied! */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ } else {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ 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) {
+ if (pConcealCommonData->numFadeInFrames > 0) {
+ /* 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;
+ }
+ }
+ break;
+
+ case ConcealState_Mute:
+ if (pConcealmentInfo->cntValidFrames >
+ pConcealCommonData->numMuteReleaseFrames) {
+ if (pConcealCommonData->numFadeInFrames > 0) {
+ /* change to state FADE-IN */
+ pConcealmentInfo->concealState = ConcealState_FadeIn;
+ pConcealmentInfo->cntFadeFrames =
+ pConcealCommonData->numFadeInFrames - 1;
+ } else {
+ /* change to state OK */
+ pConcealmentInfo->concealState = ConcealState_Ok;
+ }
+ }
+ 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 {
+ if (pConcealCommonData->numFadeOutFrames > 0) {
+ /* change to state FADE-OUT */
+ pConcealmentInfo->concealState = ConcealState_FadeOut;
+ pConcealmentInfo->cntFadeFrames = findEquiFadeFrame(
+ pConcealCommonData, pConcealmentInfo->cntFadeFrames + 1,
+ 1 /* FadeIn -> FadeOut */);
+ } else {
+ /* change to state MUTE */
+ pConcealmentInfo->concealState = ConcealState_Mute;
+ }
+ }
+ 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.
+ */
+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 = AacDec_randomSign[randomPhase >> 4];
+ packedSign >>= (randomPhase & 0xf);
+
+ for (i = 0; i < samplesPerFrame; i++) {
+ if ((randomPhase & 0xf) == 0) {
+ packedSign = AacDec_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 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;
+}
+
+static int CConcealment_ApplyFadeOut(
+ int mode, CConcealmentInfo *pConcealmentInfo,
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
+ const int samplesPerFrame, CAacDecoderChannelInfo *pAacDecoderChannelInfo) {
+ /* mode 1 = apply RandomSign and mute spectral coefficients if necessary, *
+ * mode 0 = Update cntFadeFrames */
+
+ /* restore frequency coefficients from buffer with a specific muting */
+ int srcWin, dstWin, numWindows = 1;
+ int windowLen = samplesPerFrame;
+ int srcGrpStart = 0;
+ int winIdxStride = 1;
+ int numWinGrpPerFac, attIdx, attIdxStride;
+ int i;
+ int appliedProcessing = 0;
+
+ CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
+ FIXP_DBL *pSpectralCoefficient =
+ SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
+ SHORT *pSpecScale = pAacDecoderChannelInfo->specScale;
+
+ /* set old window parameters */
+ if (pConcealmentInfo->lastRenderMode == AACDEC_RENDER_LPD) {
+ switch (pAacDecoderStaticChannelInfo->last_lpd_mode) {
+ case 1:
+ numWindows = 4;
+ srcGrpStart = 3;
+ windowLen = samplesPerFrame >> 2;
+ break;
+ case 2:
+ numWindows = 2;
+ srcGrpStart = 1;
+ windowLen = samplesPerFrame >> 1;
+ winIdxStride = 2;
+ break;
+ case 3:
+ numWindows = 1;
+ srcGrpStart = 0;
+ windowLen = samplesPerFrame;
+ winIdxStride = 4;
+ break;
+ }
+ pConcealmentInfo->lastWinGrpLen = 1;
+ } else {
+ pIcsInfo->WindowShape = pConcealmentInfo->windowShape;
+ pIcsInfo->WindowSequence = pConcealmentInfo->windowSequence;
+
+ if (pConcealmentInfo->windowSequence == BLOCK_SHORT) {
+ /* short block handling */
+ numWindows = 8;
+ windowLen = samplesPerFrame >> 3;
+ srcGrpStart = numWindows - pConcealmentInfo->lastWinGrpLen;
+ }
+ }
+
+ attIdxStride =
+ fMax(1, (int)(numWindows / (pConcealmentInfo->lastWinGrpLen + 1)));
+
+ /* load last state */
+ attIdx = pConcealmentInfo->cntFadeFrames;
+ numWinGrpPerFac = pConcealmentInfo->attGrpOffset[mode];
+ srcWin = srcGrpStart + pConcealmentInfo->winGrpOffset[mode];
+
+ FDK_ASSERT((srcGrpStart * windowLen + windowLen) <= samplesPerFrame);
+ FDK_ASSERT((srcWin * windowLen + windowLen) <= 1024);
+
+ for (dstWin = 0; dstWin < numWindows; dstWin += 1) {
+ FIXP_CNCL *pCncl =
+ pConcealmentInfo->spectralCoefficient + (srcWin * windowLen);
+ FIXP_DBL *pOut = pSpectralCoefficient + (dstWin * windowLen);
+
+ if (mode == 1) {
+ /* mute if attIdx gets large enaugh */
+ if (attIdx > pConcealmentInfo->pConcealParams->numFadeOutFrames) {
+ FDKmemclear(pCncl, sizeof(FIXP_DBL) * windowLen);
+ }
+
+ /* restore frequency coefficients from buffer - attenuation is done later
+ */
+ for (i = 0; i < windowLen; i++) {
+ pOut[i] = pCncl[i];
+ }
+
+ /* 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[dstWin * winIdxStride] =
+ pConcealmentInfo->specScale[srcWin * winIdxStride];
+ }
+
+ srcWin += 1;
+
+ if (srcWin >= numWindows) {
+ /* end of sequence -> rewind to first window of group */
+ srcWin = srcGrpStart;
+ numWinGrpPerFac += 1;
+ if (numWinGrpPerFac >= attIdxStride) {
+ numWinGrpPerFac = 0;
+ attIdx += 1;
+ }
+ }
+ }
+
+ /* store current state */
+
+ pConcealmentInfo->winGrpOffset[mode] = srcWin - srcGrpStart;
+ FDK_ASSERT((pConcealmentInfo->winGrpOffset[mode] >= 0) &&
+ (pConcealmentInfo->winGrpOffset[mode] < 8));
+ pConcealmentInfo->attGrpOffset[mode] = numWinGrpPerFac;
+ FDK_ASSERT((pConcealmentInfo->attGrpOffset[mode] >= 0) &&
+ (pConcealmentInfo->attGrpOffset[mode] < attIdxStride));
+
+ if (mode == 0) {
+ pConcealmentInfo->cntFadeFrames = attIdx;
+ }
+
+ appliedProcessing = 1;
+
+ return appliedProcessing;
+}
+
+/*!
+ \brief Do Time domain fading (TDFading) in concealment case
+
+ In case of concealment, this function takes care of the fading, after time
+domain signal has been rendered by the respective signal rendering functions.
+ The fading out in case of ACELP decoding is not done by this function but by
+the ACELP decoder for the first concealed frame if CONCEAL_CORE_IGNORANT_FADE is
+not set.
+
+ TimeDomain fading never creates jumps in energy / discontinuities, it always
+does a continuous fading. To achieve this, fading is always done from a starting
+point to a target point, while the starting point is always determined to be the
+last target point. By varying the target point of a fading, the fading slope can
+be controlled.
+
+ This principle is applied to the fading within a frame and the fading from
+frame to frame.
+
+ One frame is divided into 8 subframes to obtain 8 parts of fading slopes
+within a frame, each maybe with its own gradient.
+
+ Workflow:
+ 1.) Determine Fading behavior and end-of-frame target fading level, based on
+concealmentState (determined by CConcealment_UpdateState()) and the core mode.
+ - By _DEFAULT_,
+ The target fading level is determined by fadeOutFactor[cntFadeFrames]
+in case of fadeOut, or fadeInFactor[cntFadeFrames] in case of fadeIn.
+ --> fading type is FADE_TIMEDOMAIN in this case. Target fading level
+is determined by fading index cntFadeFrames.
+
+ - If concealmentState is signalling a _MUTED SIGNAL_,
+ TDFading decays to 0 within 1/8th of a frame if numFadeOutFrames == 0.
+ --> fading type is FADE_TIMEDOMAIN_TOSPECTRALMUTE in this case.
+
+ - If concealmentState is signalling the _END OF MUTING_,
+ TDFading fades to target fading level within 1/8th of a frame if
+numFadeInFrames == 0.
+ --> fading type is FADE_TIMEDOMAIN_FROMSPECTRALMUTE in this case.
+Target fading level is determined by fading index cntFadeFrames.
+
+#ifndef CONCEAL_CORE_IGNORANT_FADE
+ - In case of an _ACELP FADEOUT_,
+ TDFading leaves fading control to ACELP decoder for 1/2 frame.
+ --> fading type is FADE_ACELPDOMAIN in this case.
+#endif
+
+ 2.) Render fading levels within current frame and do the final fading:
+ Map Fading slopes to fading levels and apply to time domain signal.
+
+
+*/
+
+INT CConcealment_TDFading(
+ int len, CAacDecoderStaticChannelInfo **ppAacDecoderStaticChannelInfo,
+ FIXP_PCM *pcmdata, FIXP_PCM *pcmdata_1) {
+ /*
+ Do the fading in Time domain based on concealment states and core mode
+ */
+ FIXP_DBL fadeStop, attMute = (FIXP_DBL)0;
+ int idx = 0, ii;
+ CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo =
+ *ppAacDecoderStaticChannelInfo;
+ CConcealmentInfo *pConcealmentInfo =
+ &pAacDecoderStaticChannelInfo->concealmentInfo;
+ CConcealParams *pConcealParams = pConcealmentInfo->pConcealParams;
+ const CConcealmentState concealState = pConcealmentInfo->concealState;
+ TDfadingType fadingType;
+ FIXP_DBL fadingStations[9] = {0};
+ int fadingSteps[8] = {0};
+ const FIXP_DBL fadeStart =
+ pConcealmentInfo
+ ->fade_old; /* start fading at last end-of-frame attenuation */
+ FIXP_SGL *fadeFactor = pConcealParams->fadeOutFactor;
+ const INT cntFadeFrames = pConcealmentInfo->cntFadeFrames;
+ int TDFadeOutStopBeforeMute = 1;
+ int TDFadeInStopBeforeFullLevel = 1;
+
+ /*
+ determine Fading behaviour (end-of-frame attenuation and fading type) (1.)
+ */
+
+ switch (concealState) {
+ case ConcealState_Single:
+ case ConcealState_Mute:
+ case ConcealState_FadeOut:
+ idx = (pConcealParams->method == ConcealMethodNoise) ? cntFadeFrames - 1
+ : cntFadeFrames;
+ fadingType = FADE_TIMEDOMAIN;
+
+ if (concealState == ConcealState_Mute ||
+ (cntFadeFrames + TDFadeOutStopBeforeMute) >
+ pConcealmentInfo->pConcealParams->numFadeOutFrames) {
+ fadingType = FADE_TIMEDOMAIN_TOSPECTRALMUTE;
+ }
+
+ break;
+ case ConcealState_FadeIn:
+ idx = cntFadeFrames;
+ idx -= TDFadeInStopBeforeFullLevel;
+ FDK_FALLTHROUGH;
+ case ConcealState_Ok:
+ fadeFactor = pConcealParams->fadeInFactor;
+ idx = (concealState == ConcealState_Ok) ? -1 : idx;
+ fadingType = (pConcealmentInfo->concealState_old == ConcealState_Mute)
+ ? FADE_TIMEDOMAIN_FROMSPECTRALMUTE
+ : FADE_TIMEDOMAIN;
+ break;
+ default:
+ FDK_ASSERT(0);
+ fadingType = FADE_TIMEDOMAIN_TOSPECTRALMUTE;
+ break;
+ }
+
+ /* determine Target end-of-frame fading level and fading slope */
+ switch (fadingType) {
+ case FADE_TIMEDOMAIN_FROMSPECTRALMUTE:
+ fadeStop =
+ (idx < 0) ? (FIXP_DBL)MAXVAL_DBL : FX_SGL2FX_DBL(fadeFactor[idx]);
+ if (pConcealmentInfo->pConcealParams->numFadeInFrames == 0) {
+ /* do step as fast as possible */
+ fadingSteps[0] = 1;
+ break;
+ }
+ CConcealment_TDFading_doLinearFadingSteps(&fadingSteps[0]);
+ break;
+ case FADE_TIMEDOMAIN:
+ fadeStop =
+ (idx < 0) ? (FIXP_DBL)MAXVAL_DBL : FX_SGL2FX_DBL(fadeFactor[idx]);
+ CConcealment_TDFading_doLinearFadingSteps(&fadingSteps[0]);
+ break;
+ case FADE_TIMEDOMAIN_TOSPECTRALMUTE:
+ fadeStop = attMute;
+ if (pConcealmentInfo->pConcealParams->numFadeOutFrames == 0) {
+ /* do step as fast as possible */
+ fadingSteps[0] = 1;
+ break;
+ }
+ CConcealment_TDFading_doLinearFadingSteps(&fadingSteps[0]);
+ break;
+ }
+
+ /*
+ Render fading levels within current frame and do the final fading (2.)
+ */
+
+ len >>= 3;
+ CConcealment_TDFadeFillFadingStations(fadingStations, fadingSteps, fadeStop,
+ fadeStart, fadingType);
+
+ if ((fadingStations[8] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[7] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[6] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[5] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[4] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[3] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[2] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[1] != (FIXP_DBL)MAXVAL_DBL) ||
+ (fadingStations[0] !=
+ (FIXP_DBL)MAXVAL_DBL)) /* if there's something to fade */
+ {
+ int start = 0;
+ for (ii = 0; ii < 8; ii++) {
+ CConcealment_TDFadePcmAtt(start, len, fadingStations[ii],
+ fadingStations[ii + 1], pcmdata);
+ start += len;
+ }
+ }
+ CConcealment_TDNoise_Apply(pConcealmentInfo, len, pcmdata);
+
+ /* Save end-of-frame attenuation and fading type */
+ pConcealmentInfo->lastFadingType = fadingType;
+ pConcealmentInfo->fade_old = fadeStop;
+ pConcealmentInfo->concealState_old = concealState;
+
+ return 1;
+}
+
+/* attenuate pcmdata in Time Domain Fading process */
+static void CConcealment_TDFadePcmAtt(int start, int len, FIXP_DBL fadeStart,
+ FIXP_DBL fadeStop, FIXP_PCM *pcmdata) {
+ int i;
+ FIXP_DBL dStep;
+ FIXP_DBL dGain;
+ FIXP_DBL dGain_apply;
+ int bitshift = (DFRACT_BITS - SAMPLE_BITS);
+
+ /* set start energy */
+ dGain = fadeStart;
+ /* determine energy steps from sample to sample */
+ dStep = (FIXP_DBL)((int)((fadeStart >> 1) - (fadeStop >> 1)) / len) << 1;
+
+ for (i = start; i < (start + len); i++) {
+ dGain -= dStep;
+ /* prevent gain from getting negative due to possible fixpoint inaccuracies
+ */
+ dGain_apply = fMax((FIXP_DBL)0, dGain);
+ /* finally, attenuate samples */
+ pcmdata[i] = (FIXP_PCM)((fMult(pcmdata[i], (dGain_apply))) >> bitshift);
+ }
+}
+
+/*
+\brief Fill FadingStations
+
+The fadingstations are the attenuation factors, being applied to its dedicated
+portions of pcm data. They are calculated using the fadingsteps. One fadingstep
+is the weighted contribution to the fading slope within its dedicated portion of
+pcm data.
+
+*Fadingsteps : 0 0 0 1 0 1 2 0
+
+ |<- 1 Frame pcm data ->|
+ fadeStart-->|__________ |
+ ^ ^ ^ ^ \____ |
+ Attenuation : | | | | ^ ^\__ |
+ | | | | | | ^\ |
+ | | | | | | | \___|<-- fadeStop
+ | | | | | | | ^ ^
+ | | | | | | | | |
+Fadingstations: [0][1][2][3][4][5][6][7][8]
+
+(Fadingstations "[0]" is "[8] from previous frame", therefore its not meaningful
+to be edited)
+
+*/
+static void CConcealment_TDFadeFillFadingStations(FIXP_DBL *fadingStations,
+ int *fadingSteps,
+ FIXP_DBL fadeStop,
+ FIXP_DBL fadeStart,
+ TDfadingType fadingType) {
+ int i;
+ INT fadingSteps_sum = 0;
+ INT fadeDiff;
+
+ fadingSteps_sum = fadingSteps[0] + fadingSteps[1] + fadingSteps[2] +
+ fadingSteps[3] + fadingSteps[4] + fadingSteps[5] +
+ fadingSteps[6] + fadingSteps[7];
+ fadeDiff = ((INT)(fadeStop - fadeStart) / fMax(fadingSteps_sum, (INT)1));
+ fadingStations[0] = fadeStart;
+ for (i = 1; i < 8; i++) {
+ fadingStations[i] =
+ fadingStations[i - 1] + (FIXP_DBL)(fadeDiff * fadingSteps[i - 1]);
+ }
+ fadingStations[8] = fadeStop;
+}
+
+static void CConcealment_TDFading_doLinearFadingSteps(int *fadingSteps) {
+ fadingSteps[0] = fadingSteps[1] = fadingSteps[2] = fadingSteps[3] =
+ fadingSteps[4] = fadingSteps[5] = fadingSteps[6] = fadingSteps[7] = 1;
+}
+
+/* end of TimeDomainFading functions */
+
+/* derived from int UsacRandomSign() */
+static int CConcealment_TDNoise_Random(ULONG *seed) {
+ *seed = (ULONG)(((UINT64)(*seed) * 69069) + 5);
+ return (int)(*seed);
+}
+
+static void CConcealment_TDNoise_Apply(CConcealmentInfo *const pConcealmentInfo,
+ const int len, FIXP_PCM *const pcmdata) {
+ FIXP_PCM *states = pConcealmentInfo->TDNoiseStates;
+ FIXP_PCM noiseVal;
+ FIXP_DBL noiseValLong;
+ FIXP_SGL *coef = pConcealmentInfo->TDNoiseCoef;
+ FIXP_DBL TDNoiseAtt;
+ ULONG seed = pConcealmentInfo->TDNoiseSeed =
+ (ULONG)CConcealment_TDNoise_Random(&pConcealmentInfo->TDNoiseSeed) + 1;
+
+ TDNoiseAtt = pConcealmentInfo->pConcealParams->comfortNoiseLevel;
+
+ int ii;
+
+ if ((pConcealmentInfo->concealState != ConcealState_Ok ||
+ pConcealmentInfo->concealState_old != ConcealState_Ok) &&
+ TDNoiseAtt != (FIXP_DBL)0) {
+ for (ii = 0; ii < (len << 3); ii++) {
+ /* create filtered noise */
+ states[2] = states[1];
+ states[1] = states[0];
+ states[0] = ((FIXP_PCM)CConcealment_TDNoise_Random(&seed));
+ noiseValLong = fMult(states[0], coef[0]) + fMult(states[1], coef[1]) +
+ fMult(states[2], coef[2]);
+ noiseVal = FX_DBL2FX_PCM(fMult(noiseValLong, TDNoiseAtt));
+
+ /* add filtered noise - check for clipping, before */
+ if (noiseVal > (FIXP_PCM)0 &&
+ pcmdata[ii] > (FIXP_PCM)MAXVAL_FIXP_PCM - noiseVal) {
+ noiseVal = noiseVal * (FIXP_PCM)-1;
+ } else if (noiseVal < (FIXP_PCM)0 &&
+ pcmdata[ii] < (FIXP_PCM)MINVAL_FIXP_PCM - noiseVal) {
+ noiseVal = noiseVal * (FIXP_PCM)-1;
+ }
+
+ pcmdata[ii] += noiseVal;
+ }
+ }
+}