/* ----------------------------------------------------------------------------- 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; } } }