1 2 /* ----------------------------------------------------------------------------------------------------------- 3 Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5 Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16 of the MPEG specifications. 17 18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20 individually for the purpose of encoding or decoding bit streams in products that are compliant with 21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23 software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27 applications information and documentation. 28 29 2. COPYRIGHT LICENSE 30 31 Redistribution and use in source and binary forms, with or without modification, are permitted without 32 payment of copyright license fees provided that you satisfy the following conditions: 33 34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35 your modifications thereto in source code form. 36 37 You must retain the complete text of this software license in the documentation and/or other materials 38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40 modifications thereto to recipients of copies in binary form. 41 42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43 prior written permission. 44 45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46 software or your modifications thereto. 47 48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49 and the date of any change. For modified versions of the FDK AAC Codec, the term 50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 53 3. NO PATENT LICENSE 54 55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57 respect to this software. 58 59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60 by appropriate patent licenses. 61 62 4. DISCLAIMER 63 64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69 or business interruption, however caused and on any theory of liability, whether in contract, strict 70 liability, or tort (including negligence), arising in any way out of the use of this software, even if 71 advised of the possibility of such damage. 72 73 5. CONTACT INFORMATION 74 75 Fraunhofer Institute for Integrated Circuits IIS 76 Attention: Audio and Multimedia Departments - FDK AAC LL 77 Am Wolfsmantel 33 78 91058 Erlangen, Germany 79 80 www.iis.fraunhofer.de/amm 81 amm-info (at) iis.fraunhofer.de 82 ----------------------------------------------------------------------------------------------------------- */ 83 84 /***************************** MPEG-4 AAC Decoder ************************** 85 86 Author(s): Josef Hoepfl 87 Description: independent channel concealment 88 89 ******************************************************************************/ 90 91 /*! 92 \page concealment AAC core concealment 93 94 This AAC core implementation includes a concealment function, which can be enabled 95 using the several defines during compilation. 96 97 There are various tests inside the core, starting with simple CRC tests and ending in 98 a variety of plausibility checks. If such a check indicates an invalid bitstream, then 99 concealment is applied. 100 101 Concealment is also applied when the calling main program indicates a distorted or missing 102 data frame using the frameOK flag. This is used for error detection on the transport layer. 103 (See below) 104 105 There are three concealment-modes: 106 107 1) Muting: The spectral data is simply set to zero in case of an detected error. 108 109 2) Noise substitution: In case of an detected error, concealment copies the last frame and adds 110 attenuates the spectral data. For this mode you have to set the #CONCEAL_NOISE define. 111 Noise substitution adds no additional delay. 112 113 3) Interpolation: The interpolation routine swaps the spectral data from the previous and the 114 current frame just before the final frequency to time conversion. In case a single frame is 115 corrupted, concealmant interpolates between the last good and the first good frame to create 116 the spectral data for the missing frame. If multiple frames are corrupted, concealment 117 implements first a fade out based on slightly modified spectral values from the last good 118 frame. As soon as good frames are available, concealmant fades in the new spectral data. 119 For this mode you have to set the #CONCEAL_INTER define. Note that in this case, you also 120 need to set #SBR_BS_DELAY_ENABLE, which basically adds approriate delay in the SBR decoder. 121 Note that the Interpolating-Concealment increases the delay of your decoder by one frame 122 and that it does require additional resources such as memory and computational complexity. 123 124 <h2>How concealment can be used with errors on the transport layer</h2> 125 126 Many errors can or have to be detected on the transport layer. For example in IP based systems 127 packet loss can occur. The transport protocol used should indicate such packet loss by inserting 128 an empty frame with frameOK=0. 129 */ 130 131 #include "conceal.h" 132 133 #include "aac_rom.h" 134 #include "genericStds.h" 135 136 137 /* PNS (of block) */ 138 #include "aacdec_pns.h" 139 #include "block.h" 140 141 #include "FDK_tools_rom.h" 142 143 #define CONCEAL_DFLT_COMF_NOISE_LEVEL ( 46 ) /* ~= -70 dB */ 144 145 146 /* default settings */ 147 #define CONCEAL_DFLT_FADEOUT_FRAMES ( 5 ) 148 #define CONCEAL_DFLT_FADEIN_FRAMES ( 5 ) 149 #define CONCEAL_DFLT_MUTE_RELEASE_FRAMES ( 3 ) 150 151 #define CONCEAL_DFLT_FADE_FACTOR ( 0.707106781186548f ) /* 1/sqrt(2) */ 152 153 /* some often used constants: */ 154 #define FIXP_ZERO FL2FXCONST_DBL(0.0f) 155 #define FIXP_ONE FL2FXCONST_DBL(1.0f) 156 #define FIXP_FL_CORRECTION FL2FXCONST_DBL(0.53333333333333333f) 157 158 /* For parameter conversion */ 159 #define CONCEAL_PARAMETER_BITS ( 8 ) 160 #define CONCEAL_MAX_QUANT_FACTOR ( (1<<CONCEAL_PARAMETER_BITS)-1 ) 161 /*#define CONCEAL_MIN_ATTENUATION_FACTOR_025 ( FL2FXCONST_DBL(0.971627951577106174) )*/ /* -0.25 dB */ 162 #define CONCEAL_MIN_ATTENUATION_FACTOR_025_LD FL2FXCONST_DBL(-0.041524101186092029596853445212299) 163 /*#define CONCEAL_MIN_ATTENUATION_FACTOR_050 ( FL2FXCONST_DBL(0.944060876285923380) )*/ /* -0.50 dB */ 164 #define CONCEAL_MIN_ATTENUATION_FACTOR_050_LD FL2FXCONST_DBL(-0.083048202372184059253597008145293) 165 166 typedef enum { 167 CConcealment_NoExpand, 168 CConcealment_Expand, 169 CConcealment_Compress 170 } 171 CConcealmentExpandType; 172 173 static const FIXP_SGL facMod4Table[4] = { 174 FL2FXCONST_SGL(0.500000000f), /* FIXP_SGL(0x4000), 2^-(1-0,00) */ 175 FL2FXCONST_SGL(0.594603558f), /* FIXP_SGL(0x4c1b), 2^-(1-0,25) */ 176 FL2FXCONST_SGL(0.707106781f), /* FIXP_SGL(0x5a82), 2^-(1-0,50) */ 177 FL2FXCONST_SGL(0.840896415f) /* FIXP_SGL(0x6ba2) 2^-(1-0,75) */ 178 }; 179 180 181 182 183 static void 184 CConcealment_CalcBandEnergy ( 185 FIXP_DBL *spectrum, 186 const SamplingRateInfo *pSamplingRateInfo, 187 const int blockType, 188 CConcealmentExpandType ex, 189 int *sfbEnergy 190 ); 191 192 static void 193 CConcealment_InterpolateBuffer ( 194 FIXP_DBL *spectrum, 195 SHORT *pSpecScalePrev, 196 SHORT *pSpecScaleAct, 197 SHORT *pSpecScaleOut, 198 int *enPrv, 199 int *enAct, 200 int sfbCnt, 201 const SHORT *pSfbOffset 202 ); 203 204 static int 205 CConcealment_ApplyInter ( 206 CConcealmentInfo *pConcealmentInfo, 207 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 208 const SamplingRateInfo *pSamplingRateInfo, 209 const int samplesPerFrame, 210 const int improveTonal, 211 const int frameOk 212 ); 213 214 215 216 static int 217 CConcealment_ApplyNoise ( 218 CConcealmentInfo *pConcealmentInfo, 219 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 220 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo, 221 const SamplingRateInfo *pSamplingRateInfo, 222 const int samplesPerFrame, 223 const UINT flags 224 ); 225 226 static void 227 CConcealment_UpdateState ( 228 CConcealmentInfo *pConcealmentInfo, 229 int frameOk 230 ); 231 232 static void 233 CConcealment_ApplyRandomSign ( 234 int iRandomPhase, 235 FIXP_DBL *spec, 236 int samplesPerFrame 237 ); 238 239 240 static int CConcealment_GetWinSeq(int prevWinSeq) 241 { 242 int newWinSeq = OnlyLongSequence; 243 244 /* Try to have only long blocks */ 245 if ( prevWinSeq == LongStartSequence 246 || prevWinSeq == EightShortSequence ) 247 { 248 newWinSeq = LongStopSequence; 249 } 250 251 return (newWinSeq); 252 } 253 254 255 /*! 256 \brief Init common concealment information data 257 258 \pConcealCommonData Pointer to the concealment common data structure. 259 260 \return none 261 */ 262 void 263 CConcealment_InitCommonData (CConcealParams *pConcealCommonData) 264 { 265 if (pConcealCommonData != NULL) 266 { 267 int i; 268 269 /* Set default error concealment technique */ 270 pConcealCommonData->method = ConcealMethodInter; 271 272 pConcealCommonData->numFadeOutFrames = CONCEAL_DFLT_FADEOUT_FRAMES; 273 pConcealCommonData->numFadeInFrames = CONCEAL_DFLT_FADEIN_FRAMES; 274 pConcealCommonData->numMuteReleaseFrames = CONCEAL_DFLT_MUTE_RELEASE_FRAMES; 275 276 pConcealCommonData->comfortNoiseLevel = CONCEAL_DFLT_COMF_NOISE_LEVEL; 277 278 /* Init fade factors (symetric) */ 279 pConcealCommonData->fadeOutFactor[0] = FL2FXCONST_SGL( CONCEAL_DFLT_FADE_FACTOR ); 280 pConcealCommonData->fadeInFactor[0] = pConcealCommonData->fadeOutFactor[0]; 281 282 for (i = 1; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) { 283 pConcealCommonData->fadeOutFactor[i] = FX_DBL2FX_SGL(fMult(pConcealCommonData->fadeOutFactor[i-1],FL2FXCONST_SGL(CONCEAL_DFLT_FADE_FACTOR))); 284 pConcealCommonData->fadeInFactor[i] = pConcealCommonData->fadeOutFactor[i]; 285 } 286 } 287 } 288 289 290 291 /*! 292 \brief Get current concealment method. 293 294 \pConcealCommonData Pointer to common concealment data (for all channels) 295 296 \return Concealment method. 297 */ 298 CConcealmentMethod 299 CConcealment_GetMethod( CConcealParams *pConcealCommonData ) 300 { 301 CConcealmentMethod method = ConcealMethodNone; 302 303 if (pConcealCommonData != NULL) { 304 method = pConcealCommonData->method; 305 } 306 307 return (method); 308 } 309 310 311 /*! 312 \brief Init concealment information for each channel 313 314 The function initializes the concealment information. Two methods can be chosen: 315 0 = interpolation method (adds delay) 316 1 = noise substitution (no delay, low complexity) 317 318 \return none 319 */ 320 void 321 CConcealment_InitChannelData ( 322 CConcealmentInfo *pConcealChannelInfo, 323 CConcealParams *pConcealCommonData, 324 int samplesPerFrame ) 325 { 326 int i; 327 328 pConcealChannelInfo->pConcealParams = pConcealCommonData; 329 330 FDKmemclear(pConcealChannelInfo->spectralCoefficient, 1024 * sizeof(FIXP_CNCL)); 331 332 for (i = 0; i < 8; i++) { 333 pConcealChannelInfo->specScale[i] = 0; 334 } 335 336 pConcealChannelInfo->iRandomPhase = 0; 337 338 pConcealChannelInfo->windowSequence = 0; 339 pConcealChannelInfo->windowShape = 0; 340 341 pConcealChannelInfo->prevFrameOk[0] = 1; 342 pConcealChannelInfo->prevFrameOk[1] = 1; 343 344 pConcealChannelInfo->cntFadeFrames = 0; 345 pConcealChannelInfo->cntValidFrames = 0; 346 347 pConcealChannelInfo->concealState = ConcealState_Ok; 348 349 } 350 351 352 /*! 353 \brief Set error concealment parameters 354 355 \concealParams 356 \method 357 \fadeOutSlope 358 \fadeInSlope 359 \muteRelease 360 \comfNoiseLevel 361 362 \return none 363 */ 364 AAC_DECODER_ERROR 365 CConcealment_SetParams ( 366 CConcealParams *concealParams, 367 int method, 368 int fadeOutSlope, 369 int fadeInSlope, 370 int muteRelease, 371 int comfNoiseLevel ) 372 { 373 /* set concealment technique */ 374 if (method != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) { 375 switch ((CConcealmentMethod)method) 376 { 377 case ConcealMethodMute: 378 case ConcealMethodNoise: 379 case ConcealMethodInter: 380 /* Be sure to enable delay adjustment of SBR decoder! */ 381 if (concealParams == NULL) { 382 return AAC_DEC_INVALID_HANDLE; 383 } else { 384 /* set param */ 385 concealParams->method = (CConcealmentMethod)method; 386 } 387 break; 388 389 default: 390 return AAC_DEC_SET_PARAM_FAIL; 391 } 392 } 393 394 /* set number of frames for fade-out slope */ 395 if (fadeOutSlope != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) { 396 if ( (fadeOutSlope < CONCEAL_MAX_NUM_FADE_FACTORS) 397 && (fadeOutSlope >= 0) ) 398 { 399 if (concealParams == NULL) { 400 return AAC_DEC_INVALID_HANDLE; 401 } else { 402 /* set param */ 403 concealParams->numFadeOutFrames = fadeOutSlope; 404 } 405 } else { 406 return AAC_DEC_SET_PARAM_FAIL; 407 } 408 } 409 410 /* set number of frames for fade-in slope */ 411 if (fadeInSlope != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) { 412 if ( (fadeInSlope < CONCEAL_MAX_NUM_FADE_FACTORS) 413 && (fadeInSlope >= 1) ) 414 { 415 if (concealParams == NULL) { 416 return AAC_DEC_INVALID_HANDLE; 417 } else { 418 /* set param */ 419 concealParams->numFadeInFrames = fadeInSlope; 420 } 421 } else { 422 return AAC_DEC_SET_PARAM_FAIL; 423 } 424 } 425 426 /* set number of error-free frames after which the muting will be released */ 427 if (muteRelease != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) { 428 if ( (muteRelease < (CONCEAL_MAX_NUM_FADE_FACTORS<<1)) 429 && (muteRelease >= 0) ) 430 { 431 if (concealParams == NULL) { 432 return AAC_DEC_INVALID_HANDLE; 433 } else { 434 /* set param */ 435 concealParams->numMuteReleaseFrames = muteRelease; 436 } 437 } else { 438 return AAC_DEC_SET_PARAM_FAIL; 439 } 440 } 441 442 /* set confort noise level which will be inserted while in state 'muting' */ 443 if (comfNoiseLevel != AACDEC_CONCEAL_PARAM_NOT_SPECIFIED) { 444 if ( (comfNoiseLevel < -1) 445 || (comfNoiseLevel > 127) ) { 446 return AAC_DEC_SET_PARAM_FAIL; 447 } 448 if (concealParams == NULL) { 449 return AAC_DEC_INVALID_HANDLE; 450 } else { 451 concealParams->comfortNoiseLevel = comfNoiseLevel; 452 } 453 } 454 455 return (AAC_DEC_OK); 456 } 457 458 459 /*! 460 \brief Set fade-out/in attenuation factor vectors 461 462 \concealParams 463 \fadeOutAttenuationVector 464 \fadeInAttenuationVector 465 466 \return 0 if OK all other values indicate errors 467 */ 468 AAC_DECODER_ERROR 469 CConcealment_SetAttenuation ( 470 CConcealParams *concealParams, 471 SHORT *fadeOutAttenuationVector, 472 SHORT *fadeInAttenuationVector ) 473 { 474 if ( (fadeOutAttenuationVector == NULL) 475 && (fadeInAttenuationVector == NULL) ) { 476 return AAC_DEC_SET_PARAM_FAIL; 477 } 478 479 /* Fade-out factors */ 480 if (fadeOutAttenuationVector != NULL) 481 { 482 int i; 483 484 /* check quantized factors first */ 485 for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) { 486 if ((fadeOutAttenuationVector[i] < 0) || (fadeOutAttenuationVector[i] > CONCEAL_MAX_QUANT_FACTOR)) { 487 return AAC_DEC_SET_PARAM_FAIL; 488 } 489 } 490 if (concealParams == NULL) { 491 return AAC_DEC_INVALID_HANDLE; 492 } 493 494 /* now dequantize factors */ 495 for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) 496 { 497 concealParams->fadeOutFactor[i] = 498 FX_DBL2FX_SGL( fLdPow( CONCEAL_MIN_ATTENUATION_FACTOR_025_LD, 499 0, 500 (FIXP_DBL)((INT)(FL2FXCONST_DBL(1.0/2.0)>>(CONCEAL_PARAMETER_BITS-1)) * (INT)fadeOutAttenuationVector[i]), 501 CONCEAL_PARAMETER_BITS 502 ) 503 ); 504 } 505 } 506 507 /* Fade-in factors */ 508 if (fadeInAttenuationVector != NULL) 509 { 510 int i; 511 512 /* check quantized factors first */ 513 for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) { 514 if ((fadeInAttenuationVector[i] < 0) || (fadeInAttenuationVector[i] > CONCEAL_MAX_QUANT_FACTOR)) { 515 return AAC_DEC_SET_PARAM_FAIL; 516 } 517 } 518 if (concealParams == NULL) { 519 return AAC_DEC_INVALID_HANDLE; 520 } 521 522 /* now dequantize factors */ 523 for (i = 0; i < CONCEAL_MAX_NUM_FADE_FACTORS; i++) 524 { 525 concealParams->fadeInFactor[i] = 526 FX_DBL2FX_SGL( fLdPow( CONCEAL_MIN_ATTENUATION_FACTOR_025_LD, 527 0, 528 (FIXP_DBL)((INT)(FIXP_ONE>>CONCEAL_PARAMETER_BITS) * (INT)fadeInAttenuationVector[i]), 529 CONCEAL_PARAMETER_BITS 530 ) 531 ); 532 } 533 } 534 535 return (AAC_DEC_OK); 536 } 537 538 539 /*! 540 \brief Get state of concealment module. 541 542 \pConcealChannelInfo 543 544 \return Concealment state. 545 */ 546 CConcealmentState 547 CConcealment_GetState ( 548 CConcealmentInfo *pConcealChannelInfo 549 ) 550 { 551 CConcealmentState state = ConcealState_Ok; 552 553 if (pConcealChannelInfo != NULL) { 554 state = pConcealChannelInfo->concealState; 555 } 556 557 return (state); 558 } 559 560 561 static void CConcealment_fakePnsData ( 562 CPnsData *pPnsData, 563 CIcsInfo *pIcsInfo, 564 const SamplingRateInfo *pSamplingRateInfo, 565 SHORT *pSpecScale, 566 SHORT *pScaleFactor, 567 const int level ) 568 { 569 CPnsInterChannelData *pInterChannelData = pPnsData->pPnsInterChannelData; 570 571 int pnsBand, band, group, win; 572 //int delta = 0; 573 int windowsPerFrame = GetWindowsPerFrame(pIcsInfo); 574 int refLevel = (windowsPerFrame > 1) ? 82 : 91; 575 576 FDK_ASSERT(level >= 0 && level <= 127); 577 578 for (win = 0; win < windowsPerFrame; win++) { 579 pSpecScale[win] = 31; 580 } 581 582 /* fake ICS info if necessary */ 583 if (!IsValid(pIcsInfo)) { 584 pIcsInfo->WindowGroups = 1; 585 if (IsLongBlock(pIcsInfo)) { 586 pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Long; 587 pIcsInfo->WindowGroupLength[0] = 1; 588 } 589 else { 590 pIcsInfo->TotalSfBands = pSamplingRateInfo->NumberOfScaleFactorBands_Short; 591 pIcsInfo->WindowGroupLength[0] = 8; 592 } 593 pIcsInfo->MaxSfBands = pIcsInfo->TotalSfBands; 594 } 595 596 /* global activate PNS */ 597 pPnsData->PnsActive = 1; 598 /* set energy level */ 599 pPnsData->CurrentEnergy = fixMax( 0, refLevel - level ); 600 601 /* 602 value: | Avg. RMS power | Avg. RMS power | 603 | specScale = 22 | specScale = 31 | 604 -------+----------------+----------------+ 605 5 | | -99.0 dB 606 15 | | -90.0 dB 607 25 | | -89.7 dB 608 35 | | -85.3 dB 609 ... | ... | ... 610 45 | -69.9 dB | -70.0 dB 611 50 | -62.2 dB | 612 55 | -55.6 dB | -54.6 dB 613 60 | -47.0 dB | 614 65 | -39.5 dB | -39.5 dB 615 70 | -31.9 dB | 616 75 | -24.4 dB | -24.4 dB 617 80 | -16.9 dB | 618 85 | -9.4 dB (c) | -9.4 dB 619 90 | -3.9 dB (c) | 620 95 | | -2.1 dB 621 100 | | -1.6 dB 622 105 | | -1.4 dB 623 */ 624 625 for (group=0; group < GetWindowGroups(pIcsInfo); group++) 626 { 627 for (band=0; band < GetScaleFactorBandsTransmitted(pIcsInfo); band++) 628 { 629 pnsBand = group * 16 + band; 630 631 if (pnsBand >= NO_OFBANDS) { 632 return; 633 } 634 //pPnsData->CurrentEnergy += delta ; 635 pScaleFactor[pnsBand] = pPnsData->CurrentEnergy; 636 pInterChannelData->correlated[pnsBand] = 0; 637 pPnsData->pnsUsed[pnsBand] = 1; 638 } 639 } 640 } 641 642 643 /*! 644 \brief Store data for concealment techniques applied later 645 646 Interface function to store data for different concealment strategies 647 648 \return none 649 */ 650 void 651 CConcealment_Store ( 652 CConcealmentInfo *hConcealmentInfo, 653 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 654 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo ) 655 { 656 if ( !(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD 657 ) ) 658 { 659 FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); 660 SHORT *pSpecScale = pAacDecoderChannelInfo->specScale; 661 CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo; 662 663 SHORT tSpecScale[8]; 664 UCHAR tWindowShape, tWindowSequence; 665 666 /* store old window infos for swapping */ 667 tWindowSequence = hConcealmentInfo->windowSequence; 668 tWindowShape = hConcealmentInfo->windowShape; 669 670 /* store old scale factors for swapping */ 671 FDKmemcpy(tSpecScale, hConcealmentInfo->specScale, 8*sizeof(SHORT)); 672 673 /* store new window infos */ 674 hConcealmentInfo->windowSequence = GetWindowSequence(pIcsInfo); 675 hConcealmentInfo->windowShape = GetWindowShape(pIcsInfo); 676 hConcealmentInfo->lastWinGrpLen = *(GetWindowGroupLengthTable(pIcsInfo)+GetWindowGroups(pIcsInfo)-1); 677 678 /* store new scale factors */ 679 FDKmemcpy(hConcealmentInfo->specScale, pSpecScale, 8*sizeof(SHORT)); 680 681 if (CConcealment_GetDelay(hConcealmentInfo->pConcealParams) == 0) 682 { 683 /* store new spectral bins */ 684 #if (CNCL_FRACT_BITS == DFRACT_BITS) 685 FDKmemcpy(hConcealmentInfo->spectralCoefficient, pSpectralCoefficient, 1024 * sizeof(FIXP_CNCL)); 686 #else 687 FIXP_CNCL *RESTRICT pCncl = &hConcealmentInfo->spectralCoefficient[1024-1]; 688 FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024-1]; 689 int i; 690 691 for (i = 1024; i != 0; i--) { 692 *pCncl-- = FX_DBL2FX_CNCL(*pSpec--); 693 } 694 #endif 695 } 696 else 697 { 698 FIXP_CNCL *RESTRICT pCncl = &hConcealmentInfo->spectralCoefficient[1024-1]; 699 FIXP_DBL *RESTRICT pSpec = &pSpectralCoefficient[1024-1]; 700 int i; 701 702 /* swap spectral data */ 703 for (i = 1024; i != 0; i--) { 704 FIXP_DBL tSpec = *pSpec; 705 *pSpec-- = FX_CNCL2FX_DBL(*pCncl); 706 *pCncl-- = FX_DBL2FX_CNCL( tSpec); 707 } 708 709 /* complete swapping of window infos */ 710 pIcsInfo->WindowSequence = tWindowSequence; 711 pIcsInfo->WindowShape = tWindowShape; 712 713 /* complete swapping of scale factors */ 714 FDKmemcpy(pSpecScale, tSpecScale, 8*sizeof(SHORT)); 715 } 716 } 717 718 } 719 720 721 /*! 722 \brief Apply concealment 723 724 Interface function to different concealment strategies 725 726 \return none 727 */ 728 int 729 CConcealment_Apply ( 730 CConcealmentInfo *hConcealmentInfo, 731 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 732 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo, 733 const SamplingRateInfo *pSamplingRateInfo, 734 const int samplesPerFrame, 735 const UCHAR lastLpdMode, 736 const int frameOk, 737 const UINT flags) 738 { 739 int appliedProcessing = 0; 740 741 if ( (frameOk == 0) 742 && (pAacDecoderChannelInfo->renderMode != (AACDEC_RENDER_MODE)hConcealmentInfo->lastRenderMode) ) { 743 /* restore the last render mode to stay in the same domain which allows to do a proper concealment */ 744 pAacDecoderChannelInfo->renderMode = (AACDEC_RENDER_MODE)hConcealmentInfo->lastRenderMode; 745 } else { 746 /* otherwise store the current mode */ 747 hConcealmentInfo->lastRenderMode = (SCHAR)pAacDecoderChannelInfo->renderMode; 748 } 749 750 if ( frameOk ) 751 { 752 /* Rescue current data for concealment in future frames */ 753 CConcealment_Store ( hConcealmentInfo, 754 pAacDecoderChannelInfo, 755 pAacDecoderStaticChannelInfo ); 756 /* Reset index to random sign vector to make sign calculation frame agnostic 757 (only depends on number of subsequently concealed spectral blocks) */ 758 hConcealmentInfo->iRandomPhase = 0; 759 } 760 761 /* hand current frame status to the state machine */ 762 CConcealment_UpdateState( hConcealmentInfo, 763 frameOk ); 764 765 if ( !frameOk ) 766 { 767 /* Create data for signal rendering according to the selected concealment method and decoder operating mode. */ 768 769 770 if ( !(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD 771 ) 772 ) 773 { 774 switch (hConcealmentInfo->pConcealParams->method) 775 { 776 default: 777 case ConcealMethodMute: 778 /* Mute spectral data in case of errors */ 779 FDKmemclear(pAacDecoderChannelInfo->pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL)); 780 /* Set last window shape */ 781 pAacDecoderChannelInfo->icsInfo.WindowShape = hConcealmentInfo->windowShape; 782 appliedProcessing = 1; 783 break; 784 785 case ConcealMethodNoise: 786 /* Noise substitution error concealment technique */ 787 appliedProcessing = 788 CConcealment_ApplyNoise (hConcealmentInfo, 789 pAacDecoderChannelInfo, 790 pAacDecoderStaticChannelInfo, 791 pSamplingRateInfo, 792 samplesPerFrame, 793 flags); 794 break; 795 796 case ConcealMethodInter: 797 /* Energy interpolation concealment based on 3GPP */ 798 appliedProcessing = 799 CConcealment_ApplyInter (hConcealmentInfo, 800 pAacDecoderChannelInfo, 801 pSamplingRateInfo, 802 samplesPerFrame, 803 0, /* don't use tonal improvement */ 804 0); 805 break; 806 807 } 808 } 809 } 810 /* update history */ 811 hConcealmentInfo->prevFrameOk[0] = hConcealmentInfo->prevFrameOk[1]; 812 hConcealmentInfo->prevFrameOk[1] = frameOk; 813 814 return appliedProcessing; 815 } 816 817 /*! 818 \brief Apply concealment noise substitution 819 820 In case of frame lost this function produces a noisy frame with respect to the 821 energies values of past frame. 822 823 \return none 824 */ 825 static int 826 CConcealment_ApplyNoise (CConcealmentInfo *pConcealmentInfo, 827 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 828 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo, 829 const SamplingRateInfo *pSamplingRateInfo, 830 const int samplesPerFrame, 831 const UINT flags) 832 { 833 CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams; 834 835 FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); 836 SHORT *pSpecScale = pAacDecoderChannelInfo->specScale; 837 CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo; 838 839 int appliedProcessing = 0; 840 841 FDK_ASSERT((samplesPerFrame>=480) && (samplesPerFrame<=1024)); 842 FDK_ASSERT((samplesPerFrame&0x1F) == 0); 843 844 switch (pConcealmentInfo->concealState) 845 { 846 case ConcealState_Ok: 847 /* Nothing to do here! */ 848 break; 849 850 case ConcealState_Single: 851 case ConcealState_FadeOut: 852 { 853 /* restore frequency coefficients from buffer with a specific muting */ 854 FIXP_SGL fac; 855 int win, numWindows = 1; 856 int windowLen = samplesPerFrame; 857 int tFadeFrames, lastWindow = 0; 858 int win_idx_stride = 1; 859 860 FDK_ASSERT(pConcealmentInfo != NULL); 861 FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0); 862 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS); 863 FDK_ASSERT(pConcealmentInfo->cntFadeFrames <= pConcealCommonData->numFadeOutFrames); 864 865 /* get attenuation factor */ 866 tFadeFrames = pConcealmentInfo->cntFadeFrames; 867 fac = pConcealCommonData->fadeOutFactor[tFadeFrames]; 868 869 /* set old window parameters */ 870 { 871 pIcsInfo->WindowShape = pConcealmentInfo->windowShape; 872 pIcsInfo->WindowSequence = pConcealmentInfo->windowSequence; 873 874 if (pConcealmentInfo->windowSequence == 2) { 875 /* short block handling */ 876 numWindows = 8; 877 windowLen = samplesPerFrame >> 3; 878 lastWindow = numWindows - pConcealmentInfo->lastWinGrpLen; 879 } 880 } 881 882 for (win = 0; win < numWindows; win++) { 883 FIXP_CNCL *pCncl = pConcealmentInfo->spectralCoefficient + (lastWindow * windowLen); 884 FIXP_DBL *pOut = pSpectralCoefficient + (win * windowLen); 885 int i; 886 887 FDK_ASSERT((lastWindow * windowLen + windowLen) <= samplesPerFrame); 888 889 /* restore frequency coefficients from buffer with a specific attenuation */ 890 for (i = 0; i < windowLen; i++) { 891 pOut[i] = fMult(pCncl[i], fac); 892 } 893 894 /* apply random change of sign for spectral coefficients */ 895 CConcealment_ApplyRandomSign(pConcealmentInfo->iRandomPhase, 896 pOut, 897 windowLen ); 898 899 /* Increment random phase index to avoid repetition artifacts. */ 900 pConcealmentInfo->iRandomPhase = (pConcealmentInfo->iRandomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1); 901 902 /* set old scale factors */ 903 pSpecScale[win*win_idx_stride] = pConcealmentInfo->specScale[win_idx_stride*lastWindow++]; 904 905 if ( (lastWindow >= numWindows) 906 && (numWindows > 1) ) 907 { 908 /* end of sequence -> rewind */ 909 lastWindow = numWindows - pConcealmentInfo->lastWinGrpLen; 910 /* update the attenuation factor to get a faster fade-out */ 911 tFadeFrames += 1; 912 if (tFadeFrames < pConcealCommonData->numFadeOutFrames) { 913 fac = pConcealCommonData->fadeOutFactor[tFadeFrames]; 914 } else { 915 fac = (FIXP_SGL)0; 916 } 917 } 918 } 919 920 /* store temp vars */ 921 pConcealmentInfo->cntFadeFrames = tFadeFrames; 922 appliedProcessing = 1; 923 } 924 break; 925 926 case ConcealState_Mute: 927 { 928 /* set dummy window parameters */ 929 pIcsInfo->Valid = 0; /* Trigger the generation of a consitent IcsInfo */ 930 pIcsInfo->WindowShape = pConcealmentInfo->windowShape; /* Prevent an invalid WindowShape (required for F/T transform) */ 931 pIcsInfo->WindowSequence = CConcealment_GetWinSeq(pConcealmentInfo->windowSequence); 932 pConcealmentInfo->windowSequence = pIcsInfo->WindowSequence; /* Store for next frame (spectrum in concealment buffer can't be used at all) */ 933 934 /* mute spectral data */ 935 FDKmemclear(pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL)); 936 937 if ( !(flags & (AC_USAC|AC_RSVD50)) 938 && pConcealCommonData->comfortNoiseLevel >= 0 939 && pConcealCommonData->comfortNoiseLevel <= 61 /* -90dB */) 940 { 941 /* insert comfort noise using PNS */ 942 CConcealment_fakePnsData ( 943 &pAacDecoderChannelInfo->data.aac.PnsData, 944 pIcsInfo, 945 pSamplingRateInfo, 946 pAacDecoderChannelInfo->pDynData->aSfbScale, 947 pAacDecoderChannelInfo->pDynData->aScaleFactor, 948 pConcealCommonData->comfortNoiseLevel 949 ); 950 951 CPns_Apply ( 952 &pAacDecoderChannelInfo->data.aac.PnsData, 953 pIcsInfo, 954 pAacDecoderChannelInfo->pSpectralCoefficient, 955 pAacDecoderChannelInfo->specScale, 956 pAacDecoderChannelInfo->pDynData->aScaleFactor, 957 pSamplingRateInfo, 958 pAacDecoderChannelInfo->granuleLength, 959 0 /* always apply to first channel */ 960 ); 961 } 962 appliedProcessing = 1; 963 } 964 break; 965 966 case ConcealState_FadeIn: 967 { 968 FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0); 969 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS); 970 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeInFrames); 971 972 /* attenuate signal to get a smooth fade-in */ 973 FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1]; 974 FIXP_SGL fac = pConcealCommonData->fadeInFactor[pConcealmentInfo->cntFadeFrames]; 975 int i; 976 977 for (i = samplesPerFrame; i != 0; i--) { 978 *pOut = fMult(*pOut, fac); 979 pOut--; 980 } 981 appliedProcessing = 1; 982 } 983 break; 984 985 default: 986 /* we shouldn't come here anyway */ 987 FDK_ASSERT(0); 988 break; 989 } 990 991 return appliedProcessing; 992 } 993 994 995 /*! 996 \brief Apply concealment interpolation 997 998 The function swaps the data from the current and the previous frame. If an 999 error has occured, frame interpolation is performed to restore the missing 1000 frame. In case of multiple faulty frames, fade-in and fade-out is applied. 1001 1002 \return none 1003 */ 1004 static int 1005 CConcealment_ApplyInter ( 1006 CConcealmentInfo *pConcealmentInfo, 1007 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 1008 const SamplingRateInfo *pSamplingRateInfo, 1009 const int samplesPerFrame, 1010 const int improveTonal, 1011 const int frameOk ) 1012 { 1013 CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams; 1014 1015 FIXP_DBL *pSpectralCoefficient = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); 1016 CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo; 1017 SHORT *pSpecScale = pAacDecoderChannelInfo->specScale; 1018 1019 1020 int sfbEnergyPrev[64]; 1021 int sfbEnergyAct [64]; 1022 1023 int i, appliedProcessing = 0; 1024 1025 /* clear/init */ 1026 FDKmemclear(sfbEnergyPrev, 64 * sizeof(int)); 1027 FDKmemclear(sfbEnergyAct, 64 * sizeof(int)); 1028 1029 1030 if (!frameOk) 1031 { 1032 /* Restore last frame from concealment buffer */ 1033 pIcsInfo->WindowShape = pConcealmentInfo->windowShape; 1034 pIcsInfo->WindowSequence = pConcealmentInfo->windowSequence; 1035 1036 /* Restore spectral data */ 1037 for (i = 0; i < samplesPerFrame; i++) { 1038 pSpectralCoefficient[i] = FX_CNCL2FX_DBL(pConcealmentInfo->spectralCoefficient[i]); 1039 } 1040 1041 /* Restore scale factors */ 1042 FDKmemcpy(pSpecScale, pConcealmentInfo->specScale, 8*sizeof(SHORT)); 1043 } 1044 1045 /* if previous frame was not ok */ 1046 if (!pConcealmentInfo->prevFrameOk[1]) { 1047 1048 /* if current frame (f_n) is ok and the last but one frame (f_(n-2)) 1049 was ok, too, then interpolate both frames in order to generate 1050 the current output frame (f_(n-1)). Otherwise, use the last stored 1051 frame (f_(n-2) or f_(n-3) or ...). */ 1052 if (frameOk && pConcealmentInfo->prevFrameOk[0]) 1053 { 1054 appliedProcessing = 1; 1055 1056 1057 /* Interpolate both frames in order to generate the current output frame (f_(n-1)). */ 1058 if (pIcsInfo->WindowSequence == EightShortSequence) { 1059 /* f_(n-2) == EightShortSequence */ 1060 /* short--??????--short, short--??????--long interpolation */ 1061 /* short--short---short, short---long---long interpolation */ 1062 1063 int wnd; 1064 1065 if (pConcealmentInfo->windowSequence == EightShortSequence) { /* f_n == EightShortSequence */ 1066 /* short--short---short interpolation */ 1067 1068 int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short; 1069 const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short; 1070 pIcsInfo->WindowShape = 1; 1071 pIcsInfo->WindowSequence = EightShortSequence; 1072 1073 for (wnd = 0; wnd < 8; wnd++) 1074 { 1075 CConcealment_CalcBandEnergy( 1076 &pSpectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_(n-2) */ 1077 pSamplingRateInfo, 1078 EightShortSequence, 1079 CConcealment_NoExpand, 1080 sfbEnergyPrev); 1081 1082 CConcealment_CalcBandEnergy( 1083 &pConcealmentInfo->spectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_n */ 1084 pSamplingRateInfo, 1085 EightShortSequence, 1086 CConcealment_NoExpand, 1087 sfbEnergyAct); 1088 1089 CConcealment_InterpolateBuffer( 1090 &pSpectralCoefficient[wnd * (samplesPerFrame / 8)], /* spec_(n-1) */ 1091 &pSpecScale[wnd], 1092 &pConcealmentInfo->specScale[wnd], 1093 &pSpecScale[wnd], 1094 sfbEnergyPrev, 1095 sfbEnergyAct, 1096 scaleFactorBandsTotal, 1097 pSfbOffset); 1098 1099 } 1100 } else { /* f_n != EightShortSequence */ 1101 /* short---long---long interpolation */ 1102 1103 int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long; 1104 const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long; 1105 SHORT specScaleOut; 1106 1107 CConcealment_CalcBandEnergy(&pSpectralCoefficient[samplesPerFrame - (samplesPerFrame / 8)], /* [wnd] spec_(n-2) */ 1108 pSamplingRateInfo, 1109 EightShortSequence, 1110 CConcealment_Expand, 1111 sfbEnergyAct); 1112 1113 CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */ 1114 pSamplingRateInfo, 1115 OnlyLongSequence, 1116 CConcealment_NoExpand, 1117 sfbEnergyPrev); 1118 1119 pIcsInfo->WindowShape = 0; 1120 pIcsInfo->WindowSequence = LongStopSequence; 1121 1122 for (i = 0; i < samplesPerFrame ; i++) { 1123 pSpectralCoefficient[i] = pConcealmentInfo->spectralCoefficient[i]; /* spec_n */ 1124 } 1125 1126 for (i = 0; i < 8; i++) { /* search for max(specScale) */ 1127 if (pSpecScale[i] > pSpecScale[0]) { 1128 pSpecScale[0] = pSpecScale[i]; 1129 } 1130 } 1131 1132 CConcealment_InterpolateBuffer( 1133 pSpectralCoefficient, /* spec_(n-1) */ 1134 &pConcealmentInfo->specScale[0], 1135 &pSpecScale[0], 1136 &specScaleOut, 1137 sfbEnergyPrev, 1138 sfbEnergyAct, 1139 scaleFactorBandsTotal, 1140 pSfbOffset); 1141 1142 pSpecScale[0] = specScaleOut; 1143 } 1144 } else { 1145 /* long--??????--short, long--??????--long interpolation */ 1146 /* long---long---short, long---long---long interpolation */ 1147 1148 int scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long; 1149 const SHORT *pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long; 1150 SHORT specScaleAct = pConcealmentInfo->specScale[0]; 1151 1152 CConcealment_CalcBandEnergy(pSpectralCoefficient, /* spec_(n-2) */ 1153 pSamplingRateInfo, 1154 OnlyLongSequence, 1155 CConcealment_NoExpand, 1156 sfbEnergyPrev); 1157 1158 if (pConcealmentInfo->windowSequence == EightShortSequence) { /* f_n == EightShortSequence */ 1159 /* long---long---short interpolation */ 1160 1161 pIcsInfo->WindowShape = 1; 1162 pIcsInfo->WindowSequence = LongStartSequence; 1163 1164 for (i = 1; i < 8; i++) { /* search for max(specScale) */ 1165 if (pConcealmentInfo->specScale[i] > specScaleAct) { 1166 specScaleAct = pConcealmentInfo->specScale[i]; 1167 } 1168 } 1169 1170 /* Expand first short spectrum */ 1171 CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */ 1172 pSamplingRateInfo, 1173 EightShortSequence, 1174 CConcealment_Expand, /* !!! */ 1175 sfbEnergyAct); 1176 } else { 1177 /* long---long---long interpolation */ 1178 1179 pIcsInfo->WindowShape = 0; 1180 pIcsInfo->WindowSequence = OnlyLongSequence; 1181 1182 CConcealment_CalcBandEnergy(pConcealmentInfo->spectralCoefficient, /* spec_n */ 1183 pSamplingRateInfo, 1184 OnlyLongSequence, 1185 CConcealment_NoExpand, 1186 sfbEnergyAct); 1187 } 1188 1189 CConcealment_InterpolateBuffer( 1190 pSpectralCoefficient, /* spec_(n-1) */ 1191 &pSpecScale[0], 1192 &specScaleAct, 1193 &pSpecScale[0], 1194 sfbEnergyPrev, 1195 sfbEnergyAct, 1196 scaleFactorBandsTotal, 1197 pSfbOffset); 1198 1199 } 1200 } 1201 1202 /* Noise substitution of sign of the output spectral coefficients */ 1203 CConcealment_ApplyRandomSign (pConcealmentInfo->iRandomPhase, 1204 pSpectralCoefficient, 1205 samplesPerFrame); 1206 /* Increment random phase index to avoid repetition artifacts. */ 1207 pConcealmentInfo->iRandomPhase = (pConcealmentInfo->iRandomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1); 1208 } 1209 1210 /* scale spectrum according to concealment state */ 1211 switch (pConcealmentInfo->concealState) 1212 { 1213 case ConcealState_Single: 1214 appliedProcessing = 1; 1215 break; 1216 1217 case ConcealState_FadeOut: 1218 { 1219 FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0); 1220 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS); 1221 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeOutFrames); 1222 1223 /* restore frequency coefficients from buffer with a specific muting */ 1224 FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1]; 1225 FIXP_SGL fac = pConcealCommonData->fadeOutFactor[pConcealmentInfo->cntFadeFrames]; 1226 1227 for (i = samplesPerFrame; i != 0; i--) { 1228 *pOut = fMult(*pOut, fac); 1229 pOut--; 1230 } 1231 appliedProcessing = 1; 1232 } 1233 break; 1234 1235 case ConcealState_FadeIn: 1236 { 1237 FDK_ASSERT(pConcealmentInfo->cntFadeFrames >= 0); 1238 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < CONCEAL_MAX_NUM_FADE_FACTORS); 1239 FDK_ASSERT(pConcealmentInfo->cntFadeFrames < pConcealCommonData->numFadeInFrames); 1240 1241 /* attenuate signal to get a smooth fade-in */ 1242 FIXP_DBL *RESTRICT pOut = &pSpectralCoefficient[samplesPerFrame-1]; 1243 FIXP_SGL fac = pConcealCommonData->fadeInFactor[pConcealmentInfo->cntFadeFrames]; 1244 1245 for (i = samplesPerFrame; i != 0; i--) { 1246 *pOut = fMult(*pOut, fac); 1247 pOut--; 1248 } 1249 appliedProcessing = 1; 1250 } 1251 break; 1252 1253 case ConcealState_Mute: 1254 { 1255 int fac = pConcealCommonData->comfortNoiseLevel; 1256 1257 /* set dummy window parameters */ 1258 pIcsInfo->Valid = 0; /* Trigger the generation of a consitent IcsInfo */ 1259 pIcsInfo->WindowShape = pConcealmentInfo->windowShape; /* Prevent an invalid WindowShape (required for F/T transform) */ 1260 pIcsInfo->WindowSequence = CConcealment_GetWinSeq(pConcealmentInfo->windowSequence); 1261 pConcealmentInfo->windowSequence = pIcsInfo->WindowSequence; /* Store for next frame (spectrum in concealment buffer can't be used at all) */ 1262 1263 /* mute spectral data */ 1264 FDKmemclear(pSpectralCoefficient, samplesPerFrame * sizeof(FIXP_DBL)); 1265 1266 if (fac >= 0 && fac <= 61) { 1267 /* insert comfort noise using PNS */ 1268 CConcealment_fakePnsData ( 1269 &pAacDecoderChannelInfo->data.aac.PnsData, 1270 pIcsInfo, 1271 pSamplingRateInfo, 1272 pAacDecoderChannelInfo->specScale, 1273 pAacDecoderChannelInfo->pDynData->aScaleFactor, 1274 fac 1275 ); 1276 1277 CPns_Apply ( 1278 &pAacDecoderChannelInfo->data.aac.PnsData, 1279 pIcsInfo, 1280 pAacDecoderChannelInfo->pSpectralCoefficient, 1281 pAacDecoderChannelInfo->specScale, 1282 pAacDecoderChannelInfo->pDynData->aScaleFactor, 1283 pSamplingRateInfo, 1284 pAacDecoderChannelInfo->granuleLength, 1285 0 /* always apply to first channel */ 1286 ); 1287 } 1288 appliedProcessing = 1; 1289 } 1290 break; 1291 1292 default: 1293 /* nothing to do here */ 1294 break; 1295 } 1296 1297 return appliedProcessing; 1298 } 1299 1300 1301 /*! 1302 \brief Calculate the spectral energy 1303 1304 The function calculates band-wise the spectral energy. This is used for 1305 frame interpolation. 1306 1307 \return none 1308 */ 1309 static void 1310 CConcealment_CalcBandEnergy ( 1311 FIXP_DBL *spectrum, 1312 const SamplingRateInfo *pSamplingRateInfo, 1313 const int blockType, 1314 CConcealmentExpandType expandType, 1315 int *sfbEnergy ) 1316 { 1317 const SHORT *pSfbOffset; 1318 int line, sfb, scaleFactorBandsTotal = 0; 1319 1320 /* In the following calculations, enAccu is initialized with LSB-value in order to avoid zero energy-level */ 1321 1322 line = 0; 1323 1324 switch(blockType) { 1325 1326 case OnlyLongSequence: 1327 case LongStartSequence: 1328 case LongStopSequence: 1329 1330 if (expandType == CConcealment_NoExpand) { 1331 /* standard long calculation */ 1332 scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long; 1333 pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long; 1334 1335 for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) { 1336 FIXP_DBL enAccu = (FIXP_DBL)(LONG)1; 1337 int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1; 1338 /* scaling depends on sfb width. */ 1339 for ( ; line < pSfbOffset[sfb+1]; line++) { 1340 enAccu += fPow2Div2(*(spectrum + line)) >> sfbScale; 1341 } 1342 *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1; 1343 } 1344 } 1345 else { 1346 /* compress long to short */ 1347 scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short; 1348 pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short; 1349 1350 for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) { 1351 FIXP_DBL enAccu = (FIXP_DBL)(LONG)1; 1352 int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1; 1353 /* scaling depends on sfb width. */ 1354 for (; line < pSfbOffset[sfb+1] << 3; line++) { 1355 enAccu += (enAccu + (fPow2Div2(*(spectrum + line)) >> sfbScale)) >> 3; 1356 } 1357 *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1; 1358 } 1359 } 1360 break; 1361 1362 case EightShortSequence: 1363 1364 if (expandType == CConcealment_NoExpand) { 1365 /* standard short calculation */ 1366 scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Short; 1367 pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Short; 1368 1369 for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) { 1370 FIXP_DBL enAccu = (FIXP_DBL)(LONG)1; 1371 int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1; 1372 /* scaling depends on sfb width. */ 1373 for ( ; line < pSfbOffset[sfb+1]; line++) { 1374 enAccu += fPow2Div2(*(spectrum + line)) >> sfbScale; 1375 } 1376 *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1; 1377 } 1378 } 1379 else { 1380 /* expand short to long spectrum */ 1381 scaleFactorBandsTotal = pSamplingRateInfo->NumberOfScaleFactorBands_Long; 1382 pSfbOffset = pSamplingRateInfo->ScaleFactorBands_Long; 1383 1384 for (sfb = 0; sfb < scaleFactorBandsTotal; sfb++) { 1385 FIXP_DBL enAccu = (FIXP_DBL)(LONG)1; 1386 int sfbScale = (sizeof(LONG)<<3) - CntLeadingZeros(pSfbOffset[sfb+1] - pSfbOffset[sfb]) - 1; 1387 /* scaling depends on sfb width. */ 1388 for ( ; line < pSfbOffset[sfb+1]; line++) { 1389 enAccu += fPow2Div2(*(spectrum + (line >> 3))) >> sfbScale; 1390 } 1391 *(sfbEnergy + sfb) = CntLeadingZeros(enAccu) - 1; 1392 } 1393 } 1394 break; 1395 } 1396 } 1397 1398 1399 /*! 1400 \brief Interpolate buffer 1401 1402 The function creates the interpolated spectral data according to the 1403 energy of the last good frame and the current (good) frame. 1404 1405 \return none 1406 */ 1407 static void 1408 CConcealment_InterpolateBuffer ( 1409 FIXP_DBL *spectrum, 1410 SHORT *pSpecScalePrv, 1411 SHORT *pSpecScaleAct, 1412 SHORT *pSpecScaleOut, 1413 int *enPrv, 1414 int *enAct, 1415 int sfbCnt, 1416 const SHORT *pSfbOffset ) 1417 { 1418 int sfb, line = 0; 1419 int fac_shift; 1420 int fac_mod; 1421 FIXP_DBL accu; 1422 1423 for (sfb = 0; sfb < sfbCnt; sfb++) { 1424 1425 fac_shift = enPrv[sfb] - enAct[sfb] + ((*pSpecScaleAct - *pSpecScalePrv) << 1); 1426 fac_mod = fac_shift & 3; 1427 fac_shift = (fac_shift >> 2) + 1; 1428 fac_shift += *pSpecScalePrv - fixMax(*pSpecScalePrv, *pSpecScaleAct); 1429 1430 for (; line < pSfbOffset[sfb+1]; line++) { 1431 accu = fMult(*(spectrum+line), facMod4Table[fac_mod]); 1432 if (fac_shift < 0) { 1433 accu >>= -fac_shift; 1434 } else { 1435 accu <<= fac_shift; 1436 } 1437 *(spectrum+line) = accu; 1438 } 1439 } 1440 *pSpecScaleOut = fixMax(*pSpecScalePrv, *pSpecScaleAct); 1441 } 1442 1443 1444 1445 1446 static INT findEquiFadeFrame ( 1447 CConcealParams *pConcealCommonData, 1448 INT actFadeIndex, 1449 int direction ) 1450 { 1451 FIXP_SGL *pFactor; 1452 FIXP_SGL referenceVal; 1453 FIXP_SGL minDiff = (FIXP_SGL)MAXVAL_SGL; 1454 1455 INT numFrames = 0; 1456 INT nextFadeIndex = 0; 1457 1458 int i; 1459 1460 /* init depending on direction */ 1461 if (direction == 0) { /* FADE-OUT => FADE-IN */ 1462 numFrames = pConcealCommonData->numFadeInFrames; 1463 referenceVal = pConcealCommonData->fadeOutFactor[actFadeIndex] >> 1; 1464 pFactor = pConcealCommonData->fadeInFactor; 1465 } 1466 else { /* FADE-IN => FADE-OUT */ 1467 numFrames = pConcealCommonData->numFadeOutFrames; 1468 referenceVal = pConcealCommonData->fadeInFactor[actFadeIndex] >> 1; 1469 pFactor = pConcealCommonData->fadeOutFactor; 1470 } 1471 1472 /* search for minimum difference */ 1473 for (i = 0; i < numFrames; i++) { 1474 FIXP_SGL diff = fixp_abs((pFactor[i]>>1) - referenceVal); 1475 if (diff < minDiff) { 1476 minDiff = diff; 1477 nextFadeIndex = i; 1478 } 1479 } 1480 1481 /* check and adjust depending on direction */ 1482 if (direction == 0) { /* FADE-OUT => FADE-IN */ 1483 if (((pFactor[nextFadeIndex]>>1) <= referenceVal) && (nextFadeIndex > 0)) { 1484 nextFadeIndex -= 1; 1485 } 1486 } 1487 else { /* FADE-IN => FADE-OUT */ 1488 if (((pFactor[nextFadeIndex]>>1) >= referenceVal) && (nextFadeIndex < numFrames-1)) { 1489 nextFadeIndex += 1; 1490 } 1491 } 1492 1493 return (nextFadeIndex); 1494 } 1495 1496 1497 /*! 1498 \brief Update the concealment state 1499 1500 The function updates the state of the concealment state-machine. The 1501 states are: mute, fade-in, fade-out, interpolate and frame-ok. 1502 1503 \return none 1504 */ 1505 static void 1506 CConcealment_UpdateState ( 1507 CConcealmentInfo *pConcealmentInfo, 1508 int frameOk ) 1509 { 1510 CConcealParams *pConcealCommonData = pConcealmentInfo->pConcealParams; 1511 1512 switch (pConcealCommonData->method) 1513 { 1514 case ConcealMethodNoise: 1515 { 1516 if (pConcealmentInfo->concealState != ConcealState_Ok) { 1517 /* count the valid frames during concealment process */ 1518 if (frameOk) { 1519 pConcealmentInfo->cntValidFrames += 1; 1520 } else { 1521 pConcealmentInfo->cntValidFrames = 0; 1522 } 1523 } 1524 1525 /* -- STATE MACHINE for Noise Substitution -- */ 1526 switch (pConcealmentInfo->concealState) 1527 { 1528 case ConcealState_Ok: 1529 if (!frameOk) { 1530 if (pConcealCommonData->numFadeOutFrames > 0) { 1531 /* change to state SINGLE-FRAME-LOSS */ 1532 pConcealmentInfo->concealState = ConcealState_Single; 1533 } else { 1534 /* change to state MUTE */ 1535 pConcealmentInfo->concealState = ConcealState_Mute; 1536 } 1537 pConcealmentInfo->cntFadeFrames = 0; 1538 pConcealmentInfo->cntValidFrames = 0; 1539 } 1540 break; 1541 1542 case ConcealState_Single: /* Just a pre-stage before fade-out begins. Stay here only one frame! */ 1543 pConcealmentInfo->cntFadeFrames += 1; 1544 if (frameOk) { 1545 if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) { 1546 /* change to state FADE-IN */ 1547 pConcealmentInfo->concealState = ConcealState_FadeIn; 1548 pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData, 1549 pConcealmentInfo->cntFadeFrames-1, 1550 0 /* FadeOut -> FadeIn */); 1551 } else { 1552 /* change to state OK */ 1553 pConcealmentInfo->concealState = ConcealState_Ok; 1554 } 1555 } else { 1556 if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) { 1557 /* change to state MUTE */ 1558 pConcealmentInfo->concealState = ConcealState_Mute; 1559 } else { 1560 /* change to state FADE-OUT */ 1561 pConcealmentInfo->concealState = ConcealState_FadeOut; 1562 } 1563 } 1564 break; 1565 1566 case ConcealState_FadeOut: 1567 pConcealmentInfo->cntFadeFrames += 1; /* used to address the fade-out factors */ 1568 if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) { 1569 if (pConcealCommonData->numFadeInFrames > 0) { 1570 /* change to state FADE-IN */ 1571 pConcealmentInfo->concealState = ConcealState_FadeIn; 1572 pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData, 1573 pConcealmentInfo->cntFadeFrames-1, 1574 0 /* FadeOut -> FadeIn */); 1575 } else { 1576 /* change to state OK */ 1577 pConcealmentInfo->concealState = ConcealState_Ok; 1578 } 1579 } else { 1580 if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) { 1581 /* change to state MUTE */ 1582 pConcealmentInfo->concealState = ConcealState_Mute; 1583 } 1584 } 1585 break; 1586 1587 case ConcealState_Mute: 1588 if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) { 1589 if (pConcealCommonData->numFadeInFrames > 0) { 1590 /* change to state FADE-IN */ 1591 pConcealmentInfo->concealState = ConcealState_FadeIn; 1592 pConcealmentInfo->cntFadeFrames = pConcealCommonData->numFadeInFrames - 1; 1593 } else { 1594 /* change to state OK */ 1595 pConcealmentInfo->concealState = ConcealState_Ok; 1596 } 1597 } 1598 break; 1599 1600 case ConcealState_FadeIn: 1601 pConcealmentInfo->cntFadeFrames -= 1; /* used to address the fade-in factors */ 1602 if (frameOk) { 1603 if (pConcealmentInfo->cntFadeFrames < 0) { 1604 /* change to state OK */ 1605 pConcealmentInfo->concealState = ConcealState_Ok; 1606 } 1607 } else { 1608 if (pConcealCommonData->numFadeOutFrames > 0) { 1609 /* change to state FADE-OUT */ 1610 pConcealmentInfo->concealState = ConcealState_FadeOut; 1611 pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData, 1612 pConcealmentInfo->cntFadeFrames+1, 1613 1 /* FadeIn -> FadeOut */); 1614 } else { 1615 /* change to state MUTE */ 1616 pConcealmentInfo->concealState = ConcealState_Mute; 1617 } 1618 } 1619 break; 1620 1621 default: 1622 FDK_ASSERT(0); 1623 break; 1624 } 1625 } 1626 break; 1627 1628 case ConcealMethodInter: 1629 case ConcealMethodTonal: 1630 { 1631 if (pConcealmentInfo->concealState != ConcealState_Ok) { 1632 /* count the valid frames during concealment process */ 1633 if ( pConcealmentInfo->prevFrameOk[1] || 1634 (pConcealmentInfo->prevFrameOk[0] && !pConcealmentInfo->prevFrameOk[1] && frameOk) ) { 1635 /* The frame is OK even if it can be estimated by the energy interpolation algorithm */ 1636 pConcealmentInfo->cntValidFrames += 1; 1637 } else { 1638 pConcealmentInfo->cntValidFrames = 0; 1639 } 1640 } 1641 1642 /* -- STATE MACHINE for energy interpolation -- */ 1643 switch (pConcealmentInfo->concealState) 1644 { 1645 case ConcealState_Ok: 1646 if (!(pConcealmentInfo->prevFrameOk[1] || 1647 (pConcealmentInfo->prevFrameOk[0] && !pConcealmentInfo->prevFrameOk[1] && frameOk))) { 1648 if (pConcealCommonData->numFadeOutFrames > 0) { 1649 /* Fade out only if the energy interpolation algorithm can not be applied! */ 1650 pConcealmentInfo->concealState = ConcealState_FadeOut; 1651 } else { 1652 /* change to state MUTE */ 1653 pConcealmentInfo->concealState = ConcealState_Mute; 1654 } 1655 pConcealmentInfo->cntFadeFrames = 0; 1656 pConcealmentInfo->cntValidFrames = 0; 1657 } 1658 break; 1659 1660 case ConcealState_Single: 1661 pConcealmentInfo->concealState = ConcealState_Ok; 1662 break; 1663 1664 case ConcealState_FadeOut: 1665 pConcealmentInfo->cntFadeFrames += 1; 1666 1667 if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) { 1668 if (pConcealCommonData->numFadeInFrames > 0) { 1669 /* change to state FADE-IN */ 1670 pConcealmentInfo->concealState = ConcealState_FadeIn; 1671 pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData, 1672 pConcealmentInfo->cntFadeFrames-1, 1673 0 /* FadeOut -> FadeIn */); 1674 } else { 1675 /* change to state OK */ 1676 pConcealmentInfo->concealState = ConcealState_Ok; 1677 } 1678 } else { 1679 if (pConcealmentInfo->cntFadeFrames >= pConcealCommonData->numFadeOutFrames) { 1680 /* change to state MUTE */ 1681 pConcealmentInfo->concealState = ConcealState_Mute; 1682 } 1683 } 1684 break; 1685 1686 case ConcealState_Mute: 1687 if (pConcealmentInfo->cntValidFrames > pConcealCommonData->numMuteReleaseFrames) { 1688 if (pConcealCommonData->numFadeInFrames > 0) { 1689 /* change to state FADE-IN */ 1690 pConcealmentInfo->concealState = ConcealState_FadeIn; 1691 pConcealmentInfo->cntFadeFrames = pConcealCommonData->numFadeInFrames - 1; 1692 } else { 1693 /* change to state OK */ 1694 pConcealmentInfo->concealState = ConcealState_Ok; 1695 } 1696 } 1697 break; 1698 1699 case ConcealState_FadeIn: 1700 pConcealmentInfo->cntFadeFrames -= 1; /* used to address the fade-in factors */ 1701 1702 if (frameOk || pConcealmentInfo->prevFrameOk[1]) { 1703 if (pConcealmentInfo->cntFadeFrames < 0) { 1704 /* change to state OK */ 1705 pConcealmentInfo->concealState = ConcealState_Ok; 1706 } 1707 } else { 1708 if (pConcealCommonData->numFadeOutFrames > 0) { 1709 /* change to state FADE-OUT */ 1710 pConcealmentInfo->concealState = ConcealState_FadeOut; 1711 pConcealmentInfo->cntFadeFrames = findEquiFadeFrame( pConcealCommonData, 1712 pConcealmentInfo->cntFadeFrames+1, 1713 1 /* FadeIn -> FadeOut */); 1714 } else { 1715 /* change to state MUTE */ 1716 pConcealmentInfo->concealState = ConcealState_Mute; 1717 } 1718 } 1719 break; 1720 } /* End switch(pConcealmentInfo->concealState) */ 1721 } 1722 break; 1723 1724 default: 1725 /* Don't need a state machine for other concealment methods. */ 1726 break; 1727 } 1728 1729 } 1730 1731 1732 /*! 1733 \brief Randomizes the sign of the spectral data 1734 1735 The function toggles the sign of the spectral data randomly. This is 1736 useful to ensure the quality of the concealed frames. 1737 1738 \return none 1739 */ 1740 static 1741 void CConcealment_ApplyRandomSign (int randomPhase, 1742 FIXP_DBL *spec, 1743 int samplesPerFrame 1744 ) 1745 { 1746 int i; 1747 USHORT packedSign=0; 1748 1749 /* random table 512x16bit has been reduced to 512 packed sign bits = 32x16 bit */ 1750 1751 /* read current packed sign word */ 1752 packedSign = randomSign[randomPhase>>4]; 1753 packedSign >>= (randomPhase&0xf); 1754 1755 for (i = 0; i < samplesPerFrame ; i++) { 1756 if ((randomPhase & 0xf) == 0) { 1757 packedSign = randomSign[randomPhase>>4]; 1758 } 1759 1760 if (packedSign & 0x1) { 1761 spec[i] = -spec[i]; 1762 } 1763 packedSign >>= 1; 1764 1765 randomPhase = (randomPhase + 1) & (AAC_NF_NO_RANDOM_VAL - 1); 1766 } 1767 } 1768 1769 1770 /*! 1771 \brief Get fadeing factor for current concealment state. 1772 1773 The function returns the factor used for fading that belongs to the current internal state. 1774 1775 \return Fade factor 1776 */ 1777 FIXP_DBL 1778 CConcealment_GetFadeFactor ( 1779 CConcealmentInfo *hConcealmentInfo, 1780 const int fPreviousFactor 1781 ) 1782 { 1783 FIXP_DBL fac = (FIXP_DBL)0; 1784 1785 CConcealParams *pConcealCommonData = hConcealmentInfo->pConcealParams; 1786 1787 if (hConcealmentInfo->pConcealParams->method > ConcealMethodMute) { 1788 switch (hConcealmentInfo->concealState) { 1789 default: 1790 case ConcealState_Mute: 1791 /* Nothing to do here */ 1792 break; 1793 case ConcealState_Ok: 1794 fac = (FIXP_DBL)MAXVAL_DBL; 1795 break; 1796 case ConcealState_Single: 1797 case ConcealState_FadeOut: 1798 { 1799 int idx = hConcealmentInfo->cntFadeFrames - ((fPreviousFactor != 0) ? 1 : 0); 1800 fac = (idx < 0) ? (FIXP_DBL)MAXVAL_DBL : FX_SGL2FX_DBL(pConcealCommonData->fadeOutFactor[idx]); 1801 } 1802 break; 1803 case ConcealState_FadeIn: 1804 { 1805 int idx = hConcealmentInfo->cntFadeFrames + ((fPreviousFactor != 0) ? 1 : 0); 1806 fac = (idx >= hConcealmentInfo->pConcealParams->numFadeInFrames) ? (FIXP_DBL)0 : FX_SGL2FX_DBL(pConcealCommonData->fadeInFactor[idx]); 1807 } 1808 break; 1809 } 1810 } 1811 1812 return (fac); 1813 } 1814 1815 1816 /*! 1817 \brief Get fadeing factor for current concealment state. 1818 1819 The function returns the state (ok or not) of the previous frame. 1820 If called before the function CConcealment_Apply() set the fBeforeApply 1821 flag to get the correct value. 1822 1823 \return Frame OK flag of previous frame. 1824 */ 1825 int 1826 CConcealment_GetLastFrameOk ( 1827 CConcealmentInfo *hConcealmentInfo, 1828 const int fBeforeApply 1829 ) 1830 { 1831 int prevFrameOk = 1; 1832 1833 if (hConcealmentInfo != NULL) { 1834 prevFrameOk = hConcealmentInfo->prevFrameOk[fBeforeApply & 0x1]; 1835 } 1836 1837 return prevFrameOk; 1838 } 1839 1840 /*! 1841 \brief Get the number of delay frames introduced by concealment technique. 1842 1843 \return Number of delay frames. 1844 */ 1845 UINT 1846 CConcealment_GetDelay ( 1847 CConcealParams *pConcealCommonData 1848 ) 1849 { 1850 UINT frameDelay = 0; 1851 1852 if (pConcealCommonData != NULL) { 1853 switch (pConcealCommonData->method) { 1854 case ConcealMethodTonal: 1855 case ConcealMethodInter: 1856 frameDelay = 1; 1857 break; 1858 default: 1859 break; 1860 } 1861 } 1862 1863 return frameDelay; 1864 } 1865 1866
