1 /* ----------------------------------------------------------------------------- 2 Software License for The Fraunhofer FDK AAC Codec Library for Android 3 4 Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Frderung der angewandten 5 Forschung e.V. All rights reserved. 6 7 1. INTRODUCTION 8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software 9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding 10 scheme for digital audio. This FDK AAC Codec software is intended to be used on 11 a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient 14 general perceptual audio codecs. AAC-ELD is considered the best-performing 15 full-bandwidth communications codec by independent studies and is widely 16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG 17 specifications. 18 19 Patent licenses for necessary patent claims for the FDK AAC Codec (including 20 those of Fraunhofer) may be obtained through Via Licensing 21 (www.vialicensing.com) or through the respective patent owners individually for 22 the purpose of encoding or decoding bit streams in products that are compliant 23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of 24 Android devices already license these patent claims through Via Licensing or 25 directly from the patent owners, and therefore FDK AAC Codec software may 26 already be covered under those patent licenses when it is used for those 27 licensed purposes only. 28 29 Commercially-licensed AAC software libraries, including floating-point versions 30 with enhanced sound quality, are also available from Fraunhofer. Users are 31 encouraged to check the Fraunhofer website for additional applications 32 information and documentation. 33 34 2. COPYRIGHT LICENSE 35 36 Redistribution and use in source and binary forms, with or without modification, 37 are permitted without payment of copyright license fees provided that you 38 satisfy the following conditions: 39 40 You must retain the complete text of this software license in redistributions of 41 the FDK AAC Codec or your modifications thereto in source code form. 42 43 You must retain the complete text of this software license in the documentation 44 and/or other materials provided with redistributions of the FDK AAC Codec or 45 your modifications thereto in binary form. You must make available free of 46 charge copies of the complete source code of the FDK AAC Codec and your 47 modifications thereto to recipients of copies in binary form. 48 49 The name of Fraunhofer may not be used to endorse or promote products derived 50 from this library without prior written permission. 51 52 You may not charge copyright license fees for anyone to use, copy or distribute 53 the FDK AAC Codec software or your modifications thereto. 54 55 Your modified versions of the FDK AAC Codec must carry prominent notices stating 56 that you changed the software and the date of any change. For modified versions 57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" 58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK 59 AAC Codec Library for Android." 60 61 3. NO PATENT LICENSE 62 63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without 64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. 65 Fraunhofer provides no warranty of patent non-infringement with respect to this 66 software. 67 68 You may use this FDK AAC Codec software or modifications thereto only for 69 purposes that are authorized by appropriate patent licenses. 70 71 4. DISCLAIMER 72 73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright 74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, 75 including but not limited to the implied warranties of merchantability and 76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, 78 or consequential damages, including but not limited to procurement of substitute 79 goods or services; loss of use, data, or profits, or business interruption, 80 however caused and on any theory of liability, whether in contract, strict 81 liability, or tort (including negligence), arising in any way out of the use of 82 this software, even if advised of the possibility of such damage. 83 84 5. CONTACT INFORMATION 85 86 Fraunhofer Institute for Integrated Circuits IIS 87 Attention: Audio and Multimedia Departments - FDK AAC LL 88 Am Wolfsmantel 33 89 91058 Erlangen, Germany 90 91 www.iis.fraunhofer.de/amm 92 amm-info (at) iis.fraunhofer.de 93 ----------------------------------------------------------------------------- */ 94 95 /**************************** AAC decoder library ****************************** 96 97 Author(s): 98 99 Description: 100 101 *******************************************************************************/ 102 103 /*! 104 \file 105 \brief RVLC Decoder 106 \author Robert Weidner 107 */ 108 109 #include "rvlc.h" 110 111 #include "block.h" 112 113 #include "aac_rom.h" 114 #include "rvlcbit.h" 115 #include "rvlcconceal.h" 116 #include "aacdec_hcr.h" 117 118 /*--------------------------------------------------------------------------------------------- 119 function: rvlcInit 120 121 description: init RVLC by data from channelinfo, which was decoded 122 previously and set up pointers 123 ----------------------------------------------------------------------------------------------- 124 input: - pointer rvlc structure 125 - pointer channel info structure 126 - pointer bitstream structure 127 ----------------------------------------------------------------------------------------------- 128 return: - 129 -------------------------------------------------------------------------------------------- 130 */ 131 132 static void rvlcInit(CErRvlcInfo *pRvlc, 133 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 134 HANDLE_FDK_BITSTREAM bs) { 135 /* RVLC common initialization part 2 of 2 */ 136 SHORT *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc; 137 SHORT *pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd; 138 SHORT *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd; 139 SHORT *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor; 140 int bnds; 141 142 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = 0; 143 144 pRvlc->numDecodedEscapeWordsEsc = 0; 145 pRvlc->numDecodedEscapeWordsFwd = 0; 146 pRvlc->numDecodedEscapeWordsBwd = 0; 147 148 pRvlc->intensity_used = 0; 149 pRvlc->errorLogRvlc = 0; 150 151 pRvlc->conceal_max = CONCEAL_MAX_INIT; 152 pRvlc->conceal_min = CONCEAL_MIN_INIT; 153 154 pRvlc->conceal_max_esc = CONCEAL_MAX_INIT; 155 pRvlc->conceal_min_esc = CONCEAL_MIN_INIT; 156 157 pRvlc->pHuffTreeRvlcEscape = aHuffTreeRvlcEscape; 158 pRvlc->pHuffTreeRvlCodewds = aHuffTreeRvlCodewds; 159 160 /* init scf arrays (for savety (in case of there are only zero codebooks)) */ 161 for (bnds = 0; bnds < RVLC_MAX_SFB; bnds++) { 162 pScfFwd[bnds] = 0; 163 pScfBwd[bnds] = 0; 164 pScfEsc[bnds] = 0; 165 pScaleFactor[bnds] = 0; 166 } 167 168 /* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2)) 169 */ 170 FDKsyncCache(bs); 171 pRvlc->bsAnchor = (INT)FDKgetValidBits(bs); 172 173 pRvlc->bitstreamIndexRvlFwd = 174 0; /* first bit within RVL coded block as start address for forward 175 decoding */ 176 pRvlc->bitstreamIndexRvlBwd = 177 pRvlc->length_of_rvlc_sf - 1; /* last bit within RVL coded block as start 178 address for backward decoding */ 179 180 /* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS 181 * data (if present) */ 182 FDKpushFor(bs, pRvlc->length_of_rvlc_sf); 183 184 if (pRvlc->sf_escapes_present != 0) { 185 /* locate internal bitstream ptr at escapes (which is the second part) */ 186 FDKsyncCache(bs); 187 pRvlc->bitstreamIndexEsc = pRvlc->bsAnchor - (INT)FDKgetValidBits(bs); 188 189 /* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present) to 190 * make decoder continue */ 191 /* decoding of RVLC should work despite this second pushFor during 192 * initialization because */ 193 /* bitstream initialization is valid for both ESC2 data parts (RVL-coded 194 * values and ESC-coded values) */ 195 FDKpushFor(bs, pRvlc->length_of_rvlc_escapes); 196 } 197 } 198 199 /*--------------------------------------------------------------------------------------------- 200 function: rvlcCheckIntensityCb 201 202 description: Check if a intensity codebook is used in the current channel. 203 ----------------------------------------------------------------------------------------------- 204 input: - pointer rvlc structure 205 - pointer channel info structure 206 ----------------------------------------------------------------------------------------------- 207 output: - intensity_used: 0 no intensity codebook is used 208 1 intensity codebook is used 209 ----------------------------------------------------------------------------------------------- 210 return: - 211 -------------------------------------------------------------------------------------------- 212 */ 213 214 static void rvlcCheckIntensityCb( 215 CErRvlcInfo *pRvlc, CAacDecoderChannelInfo *pAacDecoderChannelInfo) { 216 int group, band, bnds; 217 218 pRvlc->intensity_used = 0; 219 220 for (group = 0; group < pRvlc->numWindowGroups; group++) { 221 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 222 bnds = 16 * group + band; 223 if ((pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == 224 INTENSITY_HCB) || 225 (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == 226 INTENSITY_HCB2)) { 227 pRvlc->intensity_used = 1; 228 break; 229 } 230 } 231 } 232 } 233 234 /*--------------------------------------------------------------------------------------------- 235 function: rvlcDecodeEscapeWord 236 237 description: Decode a huffman coded RVLC Escape-word. This value is part 238 of a DPCM coded scalefactor. 239 ----------------------------------------------------------------------------------------------- 240 input: - pointer rvlc structure 241 ----------------------------------------------------------------------------------------------- 242 return: - a single RVLC-Escape value which had to be applied to a 243 DPCM value (which has a absolute value of 7) 244 -------------------------------------------------------------------------------------------- 245 */ 246 247 static SCHAR rvlcDecodeEscapeWord(CErRvlcInfo *pRvlc, HANDLE_FDK_BITSTREAM bs) { 248 int i; 249 SCHAR value; 250 UCHAR carryBit; 251 UINT treeNode; 252 UINT branchValue; 253 UINT branchNode; 254 255 INT *pBitstreamIndexEsc; 256 const UINT *pEscTree; 257 258 pEscTree = pRvlc->pHuffTreeRvlcEscape; 259 pBitstreamIndexEsc = &(pRvlc->bitstreamIndexEsc); 260 treeNode = *pEscTree; /* init at starting node */ 261 262 for (i = MAX_LEN_RVLC_ESCAPE_WORD - 1; i >= 0; i--) { 263 carryBit = 264 rvlcReadBitFromBitstream(bs, /* get next bit */ 265 pRvlc->bsAnchor, pBitstreamIndexEsc, FWD); 266 267 CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in 268 huffman decoding tree */ 269 treeNode, &branchValue, &branchNode); 270 271 if ((branchNode & TEST_BIT_10) == 272 TEST_BIT_10) { /* test bit 10 ; if set --> a RVLC-escape-word is 273 completely decoded */ 274 value = (SCHAR)branchNode & CLR_BIT_10; 275 pRvlc->length_of_rvlc_escapes -= (MAX_LEN_RVLC_ESCAPE_WORD - i); 276 277 if (pRvlc->length_of_rvlc_escapes < 0) { 278 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID; 279 value = -1; 280 } 281 282 return value; 283 } else { 284 treeNode = *( 285 pEscTree + 286 branchValue); /* update treeNode for further step in decoding tree */ 287 } 288 } 289 290 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID; 291 292 return -1; /* should not be reached */ 293 } 294 295 /*--------------------------------------------------------------------------------------------- 296 function: rvlcDecodeEscapes 297 298 description: Decodes all huffman coded RVLC Escape Words. 299 Here a difference to the pseudo-code-implementation from 300 standard can be found. A while loop (and not two nested for loops) is used for 301 two reasons: 302 303 1. The plain huffman encoded escapes are decoded before the 304 RVL-coded scalefactors. Therefore the escapes are present in the second step 305 when decoding the RVL-coded-scalefactor values in forward 306 and backward direction. 307 308 When the RVL-coded scalefactors are decoded and there a 309 escape is needed, then it is just taken out of the array in ascending order. 310 311 2. It's faster. 312 ----------------------------------------------------------------------------------------------- 313 input: - pointer rvlc structure 314 - handle to FDK bitstream 315 ----------------------------------------------------------------------------------------------- 316 return: - 0 ok the decoded escapes seem to be valid 317 - 1 error there was a error detected during decoding escapes 318 --> all escapes are invalid 319 -------------------------------------------------------------------------------------------- 320 */ 321 322 static void rvlcDecodeEscapes(CErRvlcInfo *pRvlc, SHORT *pEsc, 323 HANDLE_FDK_BITSTREAM bs) { 324 SCHAR escWord; 325 SCHAR escCnt = 0; 326 SHORT *pEscBitCntSum; 327 328 pEscBitCntSum = &(pRvlc->length_of_rvlc_escapes); 329 330 /* Decode all RVLC-Escape words with a plain Huffman-Decoder */ 331 while (*pEscBitCntSum > 0) { 332 escWord = rvlcDecodeEscapeWord(pRvlc, bs); 333 334 if (escWord >= 0) { 335 pEsc[escCnt] = escWord; 336 escCnt++; 337 } else { 338 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID; 339 pRvlc->numDecodedEscapeWordsEsc = escCnt; 340 341 return; 342 } 343 } /* all RVLC escapes decoded */ 344 345 pRvlc->numDecodedEscapeWordsEsc = escCnt; 346 } 347 348 /*--------------------------------------------------------------------------------------------- 349 function: decodeRVLCodeword 350 351 description: Decodes a RVL-coded dpcm-word (-part). 352 ----------------------------------------------------------------------------------------------- 353 input: - FDK bitstream handle 354 - pointer rvlc structure 355 ----------------------------------------------------------------------------------------------- 356 return: - a dpcm value which is within range [0,1,..,14] in case of 357 no errors. The offset of 7 must be subtracted to get a valid dpcm scalefactor 358 value. In case of errors a forbidden codeword is detected --> returning -1 359 -------------------------------------------------------------------------------------------- 360 */ 361 362 SCHAR decodeRVLCodeword(HANDLE_FDK_BITSTREAM bs, CErRvlcInfo *pRvlc) { 363 int i; 364 SCHAR value; 365 UCHAR carryBit; 366 UINT branchValue; 367 UINT branchNode; 368 369 const UINT *pRvlCodeTree = pRvlc->pHuffTreeRvlCodewds; 370 UCHAR direction = pRvlc->direction; 371 INT *pBitstrIndxRvl = pRvlc->pBitstrIndxRvl_RVL; 372 UINT treeNode = *pRvlCodeTree; 373 374 for (i = MAX_LEN_RVLC_CODE_WORD - 1; i >= 0; i--) { 375 carryBit = 376 rvlcReadBitFromBitstream(bs, /* get next bit */ 377 pRvlc->bsAnchor, pBitstrIndxRvl, direction); 378 379 CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in 380 huffman decoding tree */ 381 treeNode, &branchValue, &branchNode); 382 383 if ((branchNode & TEST_BIT_10) == 384 TEST_BIT_10) { /* test bit 10 ; if set --> a 385 RVLC-codeword is completely decoded 386 */ 387 value = (SCHAR)(branchNode & CLR_BIT_10); 388 *pRvlc->pRvlBitCnt_RVL -= (MAX_LEN_RVLC_CODE_WORD - i); 389 390 /* check available bits for decoding */ 391 if (*pRvlc->pRvlBitCnt_RVL < 0) { 392 if (direction == FWD) { 393 pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_FWD; 394 } else { 395 pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_BWD; 396 } 397 value = -1; /* signalize an error in return value, because too many bits 398 was decoded */ 399 } 400 401 /* check max value of dpcm value */ 402 if (value > MAX_ALLOWED_DPCM_INDEX) { 403 if (direction == FWD) { 404 pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD; 405 } else { 406 pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD; 407 } 408 value = -1; /* signalize an error in return value, because a forbidden 409 cw was detected*/ 410 } 411 412 return value; /* return a dpcm value with offset +7 or an error status */ 413 } else { 414 treeNode = *( 415 pRvlCodeTree + 416 branchValue); /* update treeNode for further step in decoding tree */ 417 } 418 } 419 420 return -1; 421 } 422 423 /*--------------------------------------------------------------------------------------------- 424 function: rvlcDecodeForward 425 426 description: Decode RVL-coded codewords in forward direction. 427 ----------------------------------------------------------------------------------------------- 428 input: - pointer rvlc structure 429 - pointer channel info structure 430 - handle to FDK bitstream 431 ----------------------------------------------------------------------------------------------- 432 return: - 433 -------------------------------------------------------------------------------------------- 434 */ 435 436 static void rvlcDecodeForward(CErRvlcInfo *pRvlc, 437 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 438 HANDLE_FDK_BITSTREAM bs) { 439 int band = 0; 440 int group = 0; 441 int bnds = 0; 442 443 SHORT dpcm; 444 445 SHORT factor = 446 pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET; 447 SHORT position = -SF_OFFSET; 448 SHORT noisenrg = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - 449 SF_OFFSET - 90 - 256; 450 451 SHORT *pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd; 452 SHORT *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc; 453 UCHAR *pEscFwdCnt = &(pRvlc->numDecodedEscapeWordsFwd); 454 455 pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_fwd); 456 pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlFwd); 457 458 *pEscFwdCnt = 0; 459 pRvlc->direction = FWD; 460 pRvlc->noise_used = 0; 461 pRvlc->sf_used = 0; 462 pRvlc->lastScf = 0; 463 pRvlc->lastNrg = 0; 464 pRvlc->lastIs = 0; 465 466 rvlcCheckIntensityCb(pRvlc, pAacDecoderChannelInfo); 467 468 /* main loop fwd long */ 469 for (group = 0; group < pRvlc->numWindowGroups; group++) { 470 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 471 bnds = 16 * group + band; 472 473 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) { 474 case ZERO_HCB: 475 pScfFwd[bnds] = 0; 476 break; 477 478 case INTENSITY_HCB2: 479 case INTENSITY_HCB: 480 /* store dpcm_is_position */ 481 dpcm = decodeRVLCodeword(bs, pRvlc); 482 if (dpcm < 0) { 483 pRvlc->conceal_max = bnds; 484 return; 485 } 486 dpcm -= TABLE_OFFSET; 487 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 488 if (pRvlc->length_of_rvlc_escapes) { 489 pRvlc->conceal_max = bnds; 490 return; 491 } else { 492 if (dpcm == MIN_RVL) { 493 dpcm -= *pScfEsc++; 494 } else { 495 dpcm += *pScfEsc++; 496 } 497 (*pEscFwdCnt)++; 498 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) { 499 pRvlc->conceal_max_esc = bnds; 500 } 501 } 502 } 503 position += dpcm; 504 pScfFwd[bnds] = position; 505 pRvlc->lastIs = position; 506 break; 507 508 case NOISE_HCB: 509 if (pRvlc->noise_used == 0) { 510 pRvlc->noise_used = 1; 511 pRvlc->first_noise_band = bnds; 512 noisenrg += pRvlc->dpcm_noise_nrg; 513 pScfFwd[bnds] = 100 + noisenrg; 514 pRvlc->lastNrg = noisenrg; 515 } else { 516 dpcm = decodeRVLCodeword(bs, pRvlc); 517 if (dpcm < 0) { 518 pRvlc->conceal_max = bnds; 519 return; 520 } 521 dpcm -= TABLE_OFFSET; 522 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 523 if (pRvlc->length_of_rvlc_escapes) { 524 pRvlc->conceal_max = bnds; 525 return; 526 } else { 527 if (dpcm == MIN_RVL) { 528 dpcm -= *pScfEsc++; 529 } else { 530 dpcm += *pScfEsc++; 531 } 532 (*pEscFwdCnt)++; 533 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) { 534 pRvlc->conceal_max_esc = bnds; 535 } 536 } 537 } 538 noisenrg += dpcm; 539 pScfFwd[bnds] = 100 + noisenrg; 540 pRvlc->lastNrg = noisenrg; 541 } 542 pAacDecoderChannelInfo->data.aac.PnsData.pnsUsed[bnds] = 1; 543 break; 544 545 default: 546 pRvlc->sf_used = 1; 547 dpcm = decodeRVLCodeword(bs, pRvlc); 548 if (dpcm < 0) { 549 pRvlc->conceal_max = bnds; 550 return; 551 } 552 dpcm -= TABLE_OFFSET; 553 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 554 if (pRvlc->length_of_rvlc_escapes) { 555 pRvlc->conceal_max = bnds; 556 return; 557 } else { 558 if (dpcm == MIN_RVL) { 559 dpcm -= *pScfEsc++; 560 } else { 561 dpcm += *pScfEsc++; 562 } 563 (*pEscFwdCnt)++; 564 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) { 565 pRvlc->conceal_max_esc = bnds; 566 } 567 } 568 } 569 factor += dpcm; 570 pScfFwd[bnds] = factor; 571 pRvlc->lastScf = factor; 572 break; 573 } 574 } 575 } 576 577 /* postfetch fwd long */ 578 if (pRvlc->intensity_used) { 579 dpcm = decodeRVLCodeword(bs, pRvlc); /* dpcm_is_last_position */ 580 if (dpcm < 0) { 581 pRvlc->conceal_max = bnds; 582 return; 583 } 584 dpcm -= TABLE_OFFSET; 585 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 586 if (pRvlc->length_of_rvlc_escapes) { 587 pRvlc->conceal_max = bnds; 588 return; 589 } else { 590 if (dpcm == MIN_RVL) { 591 dpcm -= *pScfEsc++; 592 } else { 593 dpcm += *pScfEsc++; 594 } 595 (*pEscFwdCnt)++; 596 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) { 597 pRvlc->conceal_max_esc = bnds; 598 } 599 } 600 } 601 pRvlc->dpcm_is_last_position = dpcm; 602 } 603 } 604 605 /*--------------------------------------------------------------------------------------------- 606 function: rvlcDecodeBackward 607 608 description: Decode RVL-coded codewords in backward direction. 609 ----------------------------------------------------------------------------------------------- 610 input: - pointer rvlc structure 611 - pointer channel info structure 612 - handle FDK bitstream 613 ----------------------------------------------------------------------------------------------- 614 return: - 615 -------------------------------------------------------------------------------------------- 616 */ 617 618 static void rvlcDecodeBackward(CErRvlcInfo *pRvlc, 619 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 620 HANDLE_FDK_BITSTREAM bs) { 621 SHORT band, group, dpcm, offset; 622 SHORT bnds = pRvlc->maxSfbTransmitted - 1; 623 624 SHORT factor = pRvlc->rev_global_gain - SF_OFFSET; 625 SHORT position = pRvlc->dpcm_is_last_position - SF_OFFSET; 626 SHORT noisenrg = pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - 627 SF_OFFSET - 90 - 256; 628 629 SHORT *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd; 630 SHORT *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc; 631 UCHAR *pEscEscCnt = &(pRvlc->numDecodedEscapeWordsEsc); 632 UCHAR *pEscBwdCnt = &(pRvlc->numDecodedEscapeWordsBwd); 633 634 pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_bwd); 635 pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlBwd); 636 637 *pEscBwdCnt = 0; 638 pRvlc->direction = BWD; 639 pScfEsc += *pEscEscCnt - 1; /* set pScfEsc to last entry */ 640 pRvlc->firstScf = 0; 641 pRvlc->firstNrg = 0; 642 pRvlc->firstIs = 0; 643 644 /* prefetch long BWD */ 645 if (pRvlc->intensity_used) { 646 dpcm = decodeRVLCodeword(bs, pRvlc); /* dpcm_is_last_position */ 647 if (dpcm < 0) { 648 pRvlc->dpcm_is_last_position = 0; 649 pRvlc->conceal_min = bnds; 650 return; 651 } 652 dpcm -= TABLE_OFFSET; 653 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 654 if (pRvlc->length_of_rvlc_escapes) { 655 pRvlc->conceal_min = bnds; 656 return; 657 } else { 658 if (dpcm == MIN_RVL) { 659 dpcm -= *pScfEsc--; 660 } else { 661 dpcm += *pScfEsc--; 662 } 663 (*pEscBwdCnt)++; 664 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) { 665 pRvlc->conceal_min_esc = bnds; 666 } 667 } 668 } 669 pRvlc->dpcm_is_last_position = dpcm; 670 } 671 672 /* main loop long BWD */ 673 for (group = pRvlc->numWindowGroups - 1; group >= 0; group--) { 674 for (band = pRvlc->maxSfbTransmitted - 1; band >= 0; band--) { 675 bnds = 16 * group + band; 676 if ((band == 0) && (pRvlc->numWindowGroups != 1)) 677 offset = 16 - pRvlc->maxSfbTransmitted + 1; 678 else 679 offset = 1; 680 681 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) { 682 case ZERO_HCB: 683 pScfBwd[bnds] = 0; 684 break; 685 686 case INTENSITY_HCB2: 687 case INTENSITY_HCB: 688 /* store dpcm_is_position */ 689 dpcm = decodeRVLCodeword(bs, pRvlc); 690 if (dpcm < 0) { 691 pScfBwd[bnds] = position; 692 pRvlc->conceal_min = fMax(0, bnds - offset); 693 return; 694 } 695 dpcm -= TABLE_OFFSET; 696 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 697 if (pRvlc->length_of_rvlc_escapes) { 698 pScfBwd[bnds] = position; 699 pRvlc->conceal_min = fMax(0, bnds - offset); 700 return; 701 } else { 702 if (dpcm == MIN_RVL) { 703 dpcm -= *pScfEsc--; 704 } else { 705 dpcm += *pScfEsc--; 706 } 707 (*pEscBwdCnt)++; 708 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) { 709 pRvlc->conceal_min_esc = fMax(0, bnds - offset); 710 } 711 } 712 } 713 pScfBwd[bnds] = position; 714 position -= dpcm; 715 pRvlc->firstIs = position; 716 break; 717 718 case NOISE_HCB: 719 if (bnds == pRvlc->first_noise_band) { 720 pScfBwd[bnds] = 721 pRvlc->dpcm_noise_nrg + 722 pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - 723 SF_OFFSET - 90 - 256; 724 pRvlc->firstNrg = pScfBwd[bnds]; 725 } else { 726 dpcm = decodeRVLCodeword(bs, pRvlc); 727 if (dpcm < 0) { 728 pScfBwd[bnds] = noisenrg; 729 pRvlc->conceal_min = fMax(0, bnds - offset); 730 return; 731 } 732 dpcm -= TABLE_OFFSET; 733 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 734 if (pRvlc->length_of_rvlc_escapes) { 735 pScfBwd[bnds] = noisenrg; 736 pRvlc->conceal_min = fMax(0, bnds - offset); 737 return; 738 } else { 739 if (dpcm == MIN_RVL) { 740 dpcm -= *pScfEsc--; 741 } else { 742 dpcm += *pScfEsc--; 743 } 744 (*pEscBwdCnt)++; 745 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) { 746 pRvlc->conceal_min_esc = fMax(0, bnds - offset); 747 } 748 } 749 } 750 pScfBwd[bnds] = noisenrg; 751 noisenrg -= dpcm; 752 pRvlc->firstNrg = noisenrg; 753 } 754 break; 755 756 default: 757 dpcm = decodeRVLCodeword(bs, pRvlc); 758 if (dpcm < 0) { 759 pScfBwd[bnds] = factor; 760 pRvlc->conceal_min = fMax(0, bnds - offset); 761 return; 762 } 763 dpcm -= TABLE_OFFSET; 764 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) { 765 if (pRvlc->length_of_rvlc_escapes) { 766 pScfBwd[bnds] = factor; 767 pRvlc->conceal_min = fMax(0, bnds - offset); 768 return; 769 } else { 770 if (dpcm == MIN_RVL) { 771 dpcm -= *pScfEsc--; 772 } else { 773 dpcm += *pScfEsc--; 774 } 775 (*pEscBwdCnt)++; 776 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) { 777 pRvlc->conceal_min_esc = fMax(0, bnds - offset); 778 } 779 } 780 } 781 pScfBwd[bnds] = factor; 782 factor -= dpcm; 783 pRvlc->firstScf = factor; 784 break; 785 } 786 } 787 } 788 } 789 790 /*--------------------------------------------------------------------------------------------- 791 function: rvlcFinalErrorDetection 792 793 description: Call RVLC concealment if error was detected in decoding 794 process 795 ----------------------------------------------------------------------------------------------- 796 input: - pointer rvlc structure 797 - pointer channel info structure 798 ----------------------------------------------------------------------------------------------- 799 return: - 800 -------------------------------------------------------------------------------------------- 801 */ 802 803 static void rvlcFinalErrorDetection( 804 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 805 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo) { 806 CErRvlcInfo *pRvlc = 807 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo; 808 UCHAR ErrorStatusComplete = 0; 809 UCHAR ErrorStatusLengthFwd = 0; 810 UCHAR ErrorStatusLengthBwd = 0; 811 UCHAR ErrorStatusLengthEscapes = 0; 812 UCHAR ErrorStatusFirstScf = 0; 813 UCHAR ErrorStatusLastScf = 0; 814 UCHAR ErrorStatusFirstNrg = 0; 815 UCHAR ErrorStatusLastNrg = 0; 816 UCHAR ErrorStatusFirstIs = 0; 817 UCHAR ErrorStatusLastIs = 0; 818 UCHAR ErrorStatusForbiddenCwFwd = 0; 819 UCHAR ErrorStatusForbiddenCwBwd = 0; 820 UCHAR ErrorStatusNumEscapesFwd = 0; 821 UCHAR ErrorStatusNumEscapesBwd = 0; 822 UCHAR ConcealStatus = 1; 823 UCHAR currentBlockType; /* short: 0, not short: 1*/ 824 825 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 1; 826 827 /* invalid escape words, bit counter unequal zero, forbidden codeword detected 828 */ 829 if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD) 830 ErrorStatusForbiddenCwFwd = 1; 831 832 if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD) 833 ErrorStatusForbiddenCwBwd = 1; 834 835 /* bit counter forward unequal zero */ 836 if (pRvlc->length_of_rvlc_sf_fwd) ErrorStatusLengthFwd = 1; 837 838 /* bit counter backward unequal zero */ 839 if (pRvlc->length_of_rvlc_sf_bwd) ErrorStatusLengthBwd = 1; 840 841 /* bit counter escape sequences unequal zero */ 842 if (pRvlc->sf_escapes_present) 843 if (pRvlc->length_of_rvlc_escapes) ErrorStatusLengthEscapes = 1; 844 845 if (pRvlc->sf_used) { 846 /* first decoded scf does not match to global gain in backward direction */ 847 if (pRvlc->firstScf != 848 (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET)) 849 ErrorStatusFirstScf = 1; 850 851 /* last decoded scf does not match to rev global gain in forward direction 852 */ 853 if (pRvlc->lastScf != (pRvlc->rev_global_gain - SF_OFFSET)) 854 ErrorStatusLastScf = 1; 855 } 856 857 if (pRvlc->noise_used) { 858 /* first decoded nrg does not match to dpcm_noise_nrg in backward direction 859 */ 860 if (pRvlc->firstNrg != 861 (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain + 862 pRvlc->dpcm_noise_nrg - SF_OFFSET - 90 - 256)) 863 ErrorStatusFirstNrg = 1; 864 865 /* last decoded nrg does not match to dpcm_noise_last_position in forward 866 * direction */ 867 if (pRvlc->lastNrg != 868 (pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 869 90 - 256)) 870 ErrorStatusLastNrg = 1; 871 } 872 873 if (pRvlc->intensity_used) { 874 /* first decoded is position does not match in backward direction */ 875 if (pRvlc->firstIs != (-SF_OFFSET)) ErrorStatusFirstIs = 1; 876 877 /* last decoded is position does not match in forward direction */ 878 if (pRvlc->lastIs != (pRvlc->dpcm_is_last_position - SF_OFFSET)) 879 ErrorStatusLastIs = 1; 880 } 881 882 /* decoded escapes and used escapes in forward direction do not fit */ 883 if ((pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc) && 884 (pRvlc->conceal_max == CONCEAL_MAX_INIT)) { 885 ErrorStatusNumEscapesFwd = 1; 886 } 887 888 /* decoded escapes and used escapes in backward direction do not fit */ 889 if ((pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc) && 890 (pRvlc->conceal_min == CONCEAL_MIN_INIT)) { 891 ErrorStatusNumEscapesBwd = 1; 892 } 893 894 if (ErrorStatusLengthEscapes || 895 (((pRvlc->conceal_max == CONCEAL_MAX_INIT) && 896 (pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc) && 897 (ErrorStatusLastScf || ErrorStatusLastNrg || ErrorStatusLastIs)) 898 899 && 900 901 ((pRvlc->conceal_min == CONCEAL_MIN_INIT) && 902 (pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc) && 903 (ErrorStatusFirstScf || ErrorStatusFirstNrg || ErrorStatusFirstIs))) || 904 ((pRvlc->conceal_max == CONCEAL_MAX_INIT) && 905 ((pRvlc->rev_global_gain - SF_OFFSET - pRvlc->lastScf) < -15)) || 906 ((pRvlc->conceal_min == CONCEAL_MIN_INIT) && 907 ((pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 908 pRvlc->firstScf) < -15))) { 909 if ((pRvlc->conceal_max == CONCEAL_MAX_INIT) || 910 (pRvlc->conceal_min == CONCEAL_MIN_INIT)) { 911 pRvlc->conceal_max = 0; 912 pRvlc->conceal_min = fMax( 913 0, (pRvlc->numWindowGroups - 1) * 16 + pRvlc->maxSfbTransmitted - 1); 914 } else { 915 pRvlc->conceal_max = fMin(pRvlc->conceal_max, pRvlc->conceal_max_esc); 916 pRvlc->conceal_min = fMax(pRvlc->conceal_min, pRvlc->conceal_min_esc); 917 } 918 } 919 920 ErrorStatusComplete = ErrorStatusLastScf || ErrorStatusFirstScf || 921 ErrorStatusLastNrg || ErrorStatusFirstNrg || 922 ErrorStatusLastIs || ErrorStatusFirstIs || 923 ErrorStatusForbiddenCwFwd || 924 ErrorStatusForbiddenCwBwd || ErrorStatusLengthFwd || 925 ErrorStatusLengthBwd || ErrorStatusLengthEscapes || 926 ErrorStatusNumEscapesFwd || ErrorStatusNumEscapesBwd; 927 928 currentBlockType = 929 (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT) ? 0 930 : 1; 931 932 if (!ErrorStatusComplete) { 933 int band; 934 int group; 935 int bnds; 936 int lastSfbIndex; 937 938 lastSfbIndex = (pRvlc->numWindowGroups > 1) ? 16 : 64; 939 940 for (group = 0; group < pRvlc->numWindowGroups; group++) { 941 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 942 bnds = 16 * group + band; 943 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = 944 pAacDecoderStaticChannelInfo->concealmentInfo 945 .aRvlcPreviousScaleFactor[bnds] = 946 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds]; 947 } 948 } 949 950 for (group = 0; group < pRvlc->numWindowGroups; group++) { 951 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 952 bnds = 16 * group + band; 953 pAacDecoderStaticChannelInfo->concealmentInfo 954 .aRvlcPreviousCodebook[bnds] = 955 pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]; 956 } 957 for (; band < lastSfbIndex; band++) { 958 bnds = 16 * group + band; 959 FDK_ASSERT(bnds >= 0 && bnds < RVLC_MAX_SFB); 960 pAacDecoderStaticChannelInfo->concealmentInfo 961 .aRvlcPreviousCodebook[bnds] = ZERO_HCB; 962 } 963 } 964 } else { 965 int band; 966 int group; 967 968 /* A single bit error was detected in decoding of dpcm values. It also could 969 be an error with more bits in decoding of escapes and dpcm values whereby 970 an illegal codeword followed not directly after the corrupted bits but 971 just after decoding some more (wrong) scalefactors. Use the smaller 972 scalefactor from forward decoding, backward decoding and previous frame. 973 */ 974 if (((pRvlc->conceal_min != CONCEAL_MIN_INIT) || 975 (pRvlc->conceal_max != CONCEAL_MAX_INIT)) && 976 (pRvlc->conceal_min <= pRvlc->conceal_max) && 977 (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == 978 currentBlockType) && 979 pAacDecoderStaticChannelInfo->concealmentInfo 980 .rvlcPreviousScaleFactorOK && 981 pRvlc->sf_concealment && ConcealStatus) { 982 BidirectionalEstimation_UseScfOfPrevFrameAsReference( 983 pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo); 984 ConcealStatus = 0; 985 } 986 987 /* A single bit error was detected in decoding of dpcm values. It also could 988 be an error with more bits in decoding of escapes and dpcm values whereby 989 an illegal codeword followed not directly after the corrupted bits but 990 just after decoding some more (wrong) scalefactors. Use the smaller 991 scalefactor from forward and backward decoding. */ 992 if ((pRvlc->conceal_min <= pRvlc->conceal_max) && 993 ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || 994 (pRvlc->conceal_max != CONCEAL_MAX_INIT)) && 995 !(pAacDecoderStaticChannelInfo->concealmentInfo 996 .rvlcPreviousScaleFactorOK && 997 pRvlc->sf_concealment && 998 (pAacDecoderStaticChannelInfo->concealmentInfo 999 .rvlcPreviousBlockType == currentBlockType)) && 1000 ConcealStatus) { 1001 BidirectionalEstimation_UseLowerScfOfCurrentFrame(pAacDecoderChannelInfo); 1002 ConcealStatus = 0; 1003 } 1004 1005 /* No errors were detected in decoding of escapes and dpcm values however 1006 the first and last value of a group (is,nrg,sf) is incorrect */ 1007 if ((pRvlc->conceal_min <= pRvlc->conceal_max) && 1008 ((ErrorStatusLastScf && ErrorStatusFirstScf) || 1009 (ErrorStatusLastNrg && ErrorStatusFirstNrg) || 1010 (ErrorStatusLastIs && ErrorStatusFirstIs)) && 1011 !(ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd || 1012 ErrorStatusLengthEscapes) && 1013 ConcealStatus) { 1014 StatisticalEstimation(pAacDecoderChannelInfo); 1015 ConcealStatus = 0; 1016 } 1017 1018 /* A error with more bits in decoding of escapes and dpcm values was 1019 detected. Use the smaller scalefactor from forward decoding, backward 1020 decoding and previous frame. */ 1021 if ((pRvlc->conceal_min <= pRvlc->conceal_max) && 1022 pAacDecoderStaticChannelInfo->concealmentInfo 1023 .rvlcPreviousScaleFactorOK && 1024 pRvlc->sf_concealment && 1025 (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == 1026 currentBlockType) && 1027 ConcealStatus) { 1028 PredictiveInterpolation(pAacDecoderChannelInfo, 1029 pAacDecoderStaticChannelInfo); 1030 ConcealStatus = 0; 1031 } 1032 1033 /* Call frame concealment, because no better strategy was found. Setting the 1034 scalefactors to zero is done for debugging purposes */ 1035 if (ConcealStatus) { 1036 for (group = 0; group < pRvlc->numWindowGroups; group++) { 1037 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 1038 pAacDecoderChannelInfo->pDynData->aScaleFactor[16 * group + band] = 0; 1039 } 1040 } 1041 pAacDecoderChannelInfo->pDynData->specificTo.aac 1042 .rvlcCurrentScaleFactorOK = 0; 1043 } 1044 } 1045 } 1046 1047 /*--------------------------------------------------------------------------------------------- 1048 function: CRvlc_Read 1049 1050 description: Read RVLC ESC1 data (side info) from bitstream. 1051 ----------------------------------------------------------------------------------------------- 1052 input: - pointer rvlc structure 1053 - pointer channel info structure 1054 - pointer bitstream structure 1055 ----------------------------------------------------------------------------------------------- 1056 return: - 1057 -------------------------------------------------------------------------------------------- 1058 */ 1059 1060 void CRvlc_Read(CAacDecoderChannelInfo *pAacDecoderChannelInfo, 1061 HANDLE_FDK_BITSTREAM bs) { 1062 CErRvlcInfo *pRvlc = 1063 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo; 1064 1065 int group, band; 1066 1067 /* RVLC long specific initialization Init part 1 of 2 */ 1068 pRvlc->numWindowGroups = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); 1069 pRvlc->maxSfbTransmitted = 1070 GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo); 1071 pRvlc->noise_used = 0; /* noise detection */ 1072 pRvlc->dpcm_noise_nrg = 0; /* only for debugging */ 1073 pRvlc->dpcm_noise_last_position = 0; /* only for debugging */ 1074 pRvlc->length_of_rvlc_escapes = 1075 -1; /* default value is used for error detection and concealment */ 1076 1077 /* read only error sensitivity class 1 data (ESC 1 - data) */ 1078 pRvlc->sf_concealment = FDKreadBits(bs, 1); /* #1 */ 1079 pRvlc->rev_global_gain = FDKreadBits(bs, 8); /* #2 */ 1080 1081 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT) { 1082 pRvlc->length_of_rvlc_sf = FDKreadBits(bs, 11); /* #3 */ 1083 } else { 1084 pRvlc->length_of_rvlc_sf = FDKreadBits(bs, 9); /* #3 */ 1085 } 1086 1087 /* check if noise codebook is used */ 1088 for (group = 0; group < pRvlc->numWindowGroups; group++) { 1089 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) { 1090 if (pAacDecoderChannelInfo->pDynData->aCodeBook[16 * group + band] == 1091 NOISE_HCB) { 1092 pRvlc->noise_used = 1; 1093 break; 1094 } 1095 } 1096 } 1097 1098 if (pRvlc->noise_used) 1099 pRvlc->dpcm_noise_nrg = FDKreadBits(bs, 9); /* #4 PNS */ 1100 1101 pRvlc->sf_escapes_present = FDKreadBits(bs, 1); /* #5 */ 1102 1103 if (pRvlc->sf_escapes_present) { 1104 pRvlc->length_of_rvlc_escapes = FDKreadBits(bs, 8); /* #6 */ 1105 } 1106 1107 if (pRvlc->noise_used) { 1108 pRvlc->dpcm_noise_last_position = FDKreadBits(bs, 9); /* #7 PNS */ 1109 pRvlc->length_of_rvlc_sf -= 9; 1110 } 1111 1112 pRvlc->length_of_rvlc_sf_fwd = pRvlc->length_of_rvlc_sf; 1113 pRvlc->length_of_rvlc_sf_bwd = pRvlc->length_of_rvlc_sf; 1114 } 1115 1116 /*--------------------------------------------------------------------------------------------- 1117 function: CRvlc_Decode 1118 1119 description: Decode rvlc data 1120 The function reads both the escape sequences and the 1121 scalefactors in forward and backward direction. If an error occured during 1122 decoding process which can not be concealed with the rvlc concealment frame 1123 concealment will be initiated. Then the element "rvlcCurrentScaleFactorOK" in 1124 the decoder channel info is set to 0 otherwise it is set to 1. 1125 ----------------------------------------------------------------------------------------------- 1126 input: - pointer rvlc structure 1127 - pointer channel info structure 1128 - pointer to persistent channel info structure 1129 - pointer bitstream structure 1130 ----------------------------------------------------------------------------------------------- 1131 return: ErrorStatus = AAC_DEC_OK 1132 -------------------------------------------------------------------------------------------- 1133 */ 1134 1135 void CRvlc_Decode(CAacDecoderChannelInfo *pAacDecoderChannelInfo, 1136 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo, 1137 HANDLE_FDK_BITSTREAM bs) { 1138 CErRvlcInfo *pRvlc = 1139 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo; 1140 INT bitCntOffst; 1141 INT saveBitCnt; 1142 1143 rvlcInit(pRvlc, pAacDecoderChannelInfo, bs); 1144 1145 /* save bitstream position */ 1146 saveBitCnt = (INT)FDKgetValidBits(bs); 1147 1148 if (pRvlc->sf_escapes_present) 1149 rvlcDecodeEscapes( 1150 pRvlc, pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc, bs); 1151 1152 rvlcDecodeForward(pRvlc, pAacDecoderChannelInfo, bs); 1153 rvlcDecodeBackward(pRvlc, pAacDecoderChannelInfo, bs); 1154 rvlcFinalErrorDetection(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo); 1155 1156 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = 1157 pRvlc->intensity_used; 1158 pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used; 1159 1160 /* restore bitstream position */ 1161 bitCntOffst = (INT)FDKgetValidBits(bs) - saveBitCnt; 1162 if (bitCntOffst) { 1163 FDKpushBiDirectional(bs, bitCntOffst); 1164 } 1165 } 1166 1167 void CRvlc_ElementCheck( 1168 CAacDecoderChannelInfo *pAacDecoderChannelInfo[], 1169 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[], 1170 const UINT flags, const INT elChannels) { 1171 int ch; 1172 1173 /* Required for MPS residuals. */ 1174 if (pAacDecoderStaticChannelInfo == NULL) { 1175 return; 1176 } 1177 1178 /* RVLC specific sanity checks */ 1179 if ((flags & AC_ER_RVLC) && (elChannels == 2)) { /* to be reviewed */ 1180 if (((pAacDecoderChannelInfo[0] 1181 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) || 1182 (pAacDecoderChannelInfo[1] 1183 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0)) && 1184 pAacDecoderChannelInfo[0]->pComData->jointStereoData.MsMaskPresent) { 1185 pAacDecoderChannelInfo[0] 1186 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0; 1187 pAacDecoderChannelInfo[1] 1188 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0; 1189 } 1190 1191 if ((pAacDecoderChannelInfo[0] 1192 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) && 1193 (pAacDecoderChannelInfo[1] 1194 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 1) && 1195 (pAacDecoderChannelInfo[1] 1196 ->pDynData->specificTo.aac.rvlcIntensityUsed == 1)) { 1197 pAacDecoderChannelInfo[1] 1198 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0; 1199 } 1200 } 1201 1202 for (ch = 0; ch < elChannels; ch++) { 1203 pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousBlockType = 1204 (GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) == BLOCK_SHORT) 1205 ? 0 1206 : 1; 1207 if (flags & AC_ER_RVLC) { 1208 pAacDecoderStaticChannelInfo[ch] 1209 ->concealmentInfo.rvlcPreviousScaleFactorOK = 1210 pAacDecoderChannelInfo[ch] 1211 ->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK; 1212 } else { 1213 pAacDecoderStaticChannelInfo[ch] 1214 ->concealmentInfo.rvlcPreviousScaleFactorOK = 0; 1215 } 1216 } 1217 } 1218
