1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5� Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16of the MPEG specifications. 17 18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20individually for the purpose of encoding or decoding bit streams in products that are compliant with 21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27applications information and documentation. 28 292. COPYRIGHT LICENSE 30 31Redistribution and use in source and binary forms, with or without modification, are permitted without 32payment of copyright license fees provided that you satisfy the following conditions: 33 34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35your modifications thereto in source code form. 36 37You must retain the complete text of this software license in the documentation and/or other materials 38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40modifications thereto to recipients of copies in binary form. 41 42The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43prior written permission. 44 45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46software or your modifications thereto. 47 48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49and 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 533. NO PATENT LICENSE 54 55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57respect to this software. 58 59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60by appropriate patent licenses. 61 624. DISCLAIMER 63 64This 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 66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69or business interruption, however caused and on any theory of liability, whether in contract, strict 70liability, or tort (including negligence), arising in any way out of the use of this software, even if 71advised of the possibility of such damage. 72 735. CONTACT INFORMATION 74 75Fraunhofer Institute for Integrated Circuits IIS 76Attention: Audio and Multimedia Departments - FDK AAC LL 77Am Wolfsmantel 33 7891058 Erlangen, Germany 79 80www.iis.fraunhofer.de/amm 81amm-info@iis.fraunhofer.de 82----------------------------------------------------------------------------------------------------------- */ 83 84/***************************** MPEG-4 AAC Decoder *************************** 85 86 Author(s): Robert Weidner (DSP Solutions) 87 Description: HCR Decoder: HCR initialization, preprocess HCR sideinfo, 88 decode priority codewords (PCWs) 89 90*******************************************************************************/ 91 92#include "aacdec_hcr.h" 93 94 95 96#include "aacdec_hcr_types.h" 97#include "aacdec_hcr_bit.h" 98#include "aacdec_hcrs.h" 99#include "aac_ram.h" 100#include "aac_rom.h" 101#include "channel.h" 102#include "block.h" 103 104#include "aacdecoder.h" /* for ID_CPE, ID_SCE ... */ 105#include "FDK_bitstream.h" 106 107extern int mlFileChCurr; 108 109static void errDetectorInHcrSideinfoShrt(SCHAR cb, 110 SHORT numLine, 111 UINT *errorWord); 112 113static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword, 114 SHORT lengthOfReorderedSpectralData, 115 UINT *errorWord); 116 117static void HcrCalcNumCodeword (H_HCR_INFO pHcr); 118static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr); 119static void HcrPrepareSegmentationGrid (H_HCR_INFO pHcr); 120static void HcrExtendedSectionInfo (H_HCR_INFO pHcr); 121 122static void DeriveNumberOfExtendedSortedSectionsInSets(UINT numSegment, 123 USHORT *pNumExtendedSortedCodewordInSection, 124 int numExtendedSortedCodewordInSectionIdx, 125 USHORT *pNumExtendedSortedSectionsInSets, 126 int numExtendedSortedSectionsInSetsIdx); 127 128static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, 129 INT quantSpecCoef, 130 USHORT *pLeftStartOfSegment, 131 SCHAR *pRemainingBitsInSegment, 132 int *pNumDecodedBits 133 ); 134 135static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, 136 UINT codebookDim, 137 const SCHAR *pQuantVal, 138 FIXP_DBL *pQuantSpecCoef, 139 int *quantSpecCoefIdx, 140 USHORT *pLeftStartOfSegment, 141 SCHAR *pRemainingBitsInSegment, 142 int *pNumDecodedBits 143 ); 144 145static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, 146 const UINT *pCurrentTree, 147 const SCHAR *pQuantValBase, 148 USHORT *pLeftStartOfSegment, 149 SCHAR *pRemainingBitsInSegment, 150 int *pNumDecodedBits 151 ); 152 153static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr); 154 155static void HcrReorderQuantizedSpectralCoefficients( 156 H_HCR_INFO pHcr, 157 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 158 const SamplingRateInfo *pSamplingRateInfo 159 ); 160 161 162#if CHECK_SEGMENTATION_IMMEDIATELY 163static UCHAR errDetectPcwSegmentation(SCHAR remainingBitsInSegment, 164 H_HCR_INFO pHcr, 165 PCW_TYPE kind, 166 FIXP_DBL *qsc_base_of_cw, 167 UCHAR dimension); 168#endif 169 170#if CHECK_SEGMENTATION_FINAL 171static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr); 172#endif 173 174/*--------------------------------------------------------------------------------------------- 175 description: Check if codebook and numSect are within allowed range (short only) 176-------------------------------------------------------------------------------------------- */ 177static void errDetectorInHcrSideinfoShrt(SCHAR cb, SHORT numLine,UINT* errorWord) 178{ 179 180 181 182 if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) { 183 *errorWord |= CB_OUT_OF_RANGE_SHORT_BLOCK; 184 } 185 if ( numLine < 0 || numLine > 1024 ) { 186 *errorWord |= LINE_IN_SECT_OUT_OF_RANGE_SHORT_BLOCK; 187 } 188} 189 190/*--------------------------------------------------------------------------------------------- 191 description: Check both HCR lengths 192-------------------------------------------------------------------------------------------- */ 193static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword, 194 SHORT lengthOfReorderedSpectralData, 195 UINT *errorWord) 196{ 197 if ( lengthOfReorderedSpectralData < lengthOfLongestCodeword ) { 198 *errorWord |= HCR_SI_LENGTHS_FAILURE; 199 } 200} 201 202/*--------------------------------------------------------------------------------------------- 203 description: Decode (and adapt if necessary) the two HCR sideinfo components: 204 'reordered_spectral_data_length' and 'longest_codeword_length' 205-------------------------------------------------------------------------------------------- */ 206 207void CHcr_Read(HANDLE_FDK_BITSTREAM bs, 208 CAacDecoderChannelInfo *pAacDecoderChannelInfo) 209{ 210 INT globalHcrType = getHcrType(&pAacDecoderChannelInfo->pComData->overlay.aac.erHcrInfo); 211 SHORT lengOfReorderedSpectralData; 212 SCHAR lengOfLongestCodeword; 213 214 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = 0; 215 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = 0; 216 217 218 219 /* ------- SI-Value No 1 ------- */ 220 lengOfReorderedSpectralData = FDKreadBits(bs,14) + ERROR_LORSD; 221 if ( globalHcrType == ID_CPE ) { 222 if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= CPE_TOP_LENGTH)) { 223 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */ 224 } 225 else { 226 if (lengOfReorderedSpectralData > CPE_TOP_LENGTH) { 227 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = CPE_TOP_LENGTH; /* use valid maximum */ 228 } 229 } 230 } 231 else if (globalHcrType == ID_SCE || globalHcrType == ID_LFE || globalHcrType == ID_CCE ) { 232 if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= SCE_TOP_LENGTH)) { 233 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */ 234 } 235 else { 236 if (lengOfReorderedSpectralData > SCE_TOP_LENGTH) { 237 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = SCE_TOP_LENGTH; /* use valid maximum */ 238 } 239 } 240 } 241 242 /* ------- SI-Value No 2 ------- */ 243 lengOfLongestCodeword = FDKreadBits(bs,6) + ERROR_LOLC; 244 if ((lengOfLongestCodeword >= 0) && (lengOfLongestCodeword <= LEN_OF_LONGEST_CW_TOP_LENGTH)) { 245 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = lengOfLongestCodeword; /* the decoded value is within range */ 246 } 247 else { 248 if (lengOfLongestCodeword > LEN_OF_LONGEST_CW_TOP_LENGTH) { 249 pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = LEN_OF_LONGEST_CW_TOP_LENGTH; /* use valid maximum */ 250 } 251 } 252} 253 254 255/*--------------------------------------------------------------------------------------------- 256 description: Sets up HCR ROM-Tables 257-------------------------------------------------------------------------------------------- */ 258 259void HcrInitRom(H_HCR_INFO pHcr) 260{ 261 pHcr->cbPairs.pMinOfCbPair = aMinOfCbPair; 262 pHcr->cbPairs.pMaxOfCbPair = aMaxOfCbPair; 263 264 pHcr->tableInfo.pMaxCwLength = aMaxCwLen; 265 pHcr->tableInfo.pCbDimension = aDimCb; 266 pHcr->tableInfo.pCbDimShift = aDimCbShift; 267 pHcr->tableInfo.pCbSign = aSignCb; 268 pHcr->tableInfo.pCbPriority = aCbPriority; 269 pHcr->tableInfo.pLargestAbsVal = aLargestAbsoluteValue; 270} 271 272/*--------------------------------------------------------------------------------------------- 273 description: Set up HCR - must be called before every call to HcrDecoder(). 274 For short block a sorting algorithm is applied to get the SI in the order 275 that HCR could assemble the qsc's as if it is a long block. 276----------------------------------------------------------------------------------------------- 277 return: error log 278-------------------------------------------------------------------------------------------- */ 279 280UINT HcrInit(H_HCR_INFO pHcr, 281 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 282 const SamplingRateInfo *pSamplingRateInfo, 283 HANDLE_FDK_BITSTREAM bs) 284{ 285 CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo; 286 SHORT *pNumLinesInSec; 287 UCHAR *pCodeBk; 288 SHORT numSection; 289 SCHAR cb; 290 int numLine; 291 int i; 292 293 pHcr->decInOut.lengthOfReorderedSpectralData = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData; 294 pHcr->decInOut.lengthOfLongestCodeword = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword; 295 pHcr->decInOut.pQuantizedSpectralCoefficientsBase = pAacDecoderChannelInfo->pSpectralCoefficient; 296 pHcr->decInOut.quantizedSpectralCoefficientsIdx = 0; 297 pHcr->decInOut.pCodebook = pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr; 298 pHcr->decInOut.pNumLineInSect = pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr; 299 pHcr->decInOut.numSection = pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection; 300 pHcr->decInOut.errorLog = 0; 301 pHcr->nonPcwSideinfo.pResultBase = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); 302 303 FDKsyncCache(bs); 304 pHcr->decInOut.bitstreamIndex = FDKgetBitCnt(bs); 305 306 if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) /* short block */ 307 { 308 SHORT band; 309 SHORT maxBand; 310 SCHAR group; 311 SCHAR winGroupLen; 312 SCHAR window; 313 SCHAR numUnitInBand; 314 SCHAR cntUnitInBand; 315 SCHAR groupWin; 316 SCHAR cb_prev; 317 318 UCHAR *pCodeBook; 319 const SHORT *BandOffsets; 320 SCHAR numOfGroups; 321 322 323 pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook; /* in */ 324 pNumLinesInSec = pHcr->decInOut.pNumLineInSect; /* out */ 325 pCodeBk = pHcr->decInOut.pCodebook; /* out */ 326 BandOffsets = GetScaleFactorBandOffsets(pIcsInfo, pSamplingRateInfo); /* aux */ 327 numOfGroups = GetWindowGroups(pIcsInfo); 328 329 numLine = 0; 330 numSection = 0; 331 cb = pCodeBook[0]; 332 cb_prev = pCodeBook[0]; 333 334 /* convert HCR-sideinfo into a unitwise manner: When the cb changes, a new section starts */ 335 336 *pCodeBk++ = cb_prev; 337 338 maxBand = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo); 339 for (band = 0; band < maxBand; band++) { /* from low to high sfbs i.e. from low to high frequencies */ 340 numUnitInBand = ((BandOffsets[band+1] - BandOffsets[band]) >> FOUR_LOG_DIV_TWO_LOG); /* get the number of units in current sfb */ 341 for (cntUnitInBand = numUnitInBand; cntUnitInBand != 0; cntUnitInBand-- ) { /* for every unit in the band */ 342 for (window = 0, group = 0; group < numOfGroups; group++) { 343 winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); 344 for (groupWin = winGroupLen; groupWin != 0; groupWin--, window++) { 345 cb = pCodeBook[group * 16 + band]; 346 if (cb != cb_prev) { 347#if CHECK_VALID_HCR_INPUT /* short-block 1 of 2 */ 348 errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog ); 349 if (pHcr->decInOut.errorLog != 0 ) { 350 return ( pHcr->decInOut.errorLog ); 351 } 352#endif 353 *pCodeBk++ = cb; 354 *pNumLinesInSec++ = numLine; 355 numSection++; 356 357 cb_prev = cb; 358 numLine = LINES_PER_UNIT; 359 } 360 else { 361 numLine += LINES_PER_UNIT; 362 } 363 } 364 } 365 } 366 } 367 368 numSection++; 369 370#if CHECK_VALID_HCR_INPUT /* short-block 2 of 2 */ 371 errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog ); 372 if ( numSection <= 0 || numSection > 1024/2 ) { 373 pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_SHORT_BLOCK; 374 } 375 errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword, 376 pHcr->decInOut.lengthOfReorderedSpectralData, 377 &pHcr->decInOut.errorLog); 378 if (pHcr->decInOut.errorLog != 0 ) { 379 return ( pHcr->decInOut.errorLog ); 380 } 381#endif 382 383 *pCodeBk = cb; 384 *pNumLinesInSec = numLine; 385 pHcr->decInOut.numSection = numSection; 386 387 } else /* end short block prepare SI */ 388 { /* long block */ 389#if CHECK_VALID_HCR_INPUT /* long-block 1 of 1 */ 390 errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword, 391 pHcr->decInOut.lengthOfReorderedSpectralData, 392 &pHcr->decInOut.errorLog); 393 numSection = pHcr->decInOut.numSection; 394 pNumLinesInSec = pHcr->decInOut.pNumLineInSect; 395 pCodeBk = pHcr->decInOut.pCodebook; 396 if ( numSection <= 0 || numSection > 64 ) { 397 pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_LONG_BLOCK; 398 numSection = 0; 399 } 400 401 for ( i = numSection; i != 0; i-- ) 402 { 403 cb = *pCodeBk++; 404 405 if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) { 406 pHcr->decInOut.errorLog |= CB_OUT_OF_RANGE_LONG_BLOCK; 407 } 408 409 numLine = *pNumLinesInSec++; 410 /* FDK_ASSERT(numLine > 0); */ 411 412 if ( (numLine <= 0) || (numLine > 1024) ) { 413 pHcr->decInOut.errorLog |= LINE_IN_SECT_OUT_OF_RANGE_LONG_BLOCK; 414 } 415 } 416 if (pHcr->decInOut.errorLog != 0 ) { 417 return ( pHcr->decInOut.errorLog ); 418 } 419#endif /* CHECK_VALID_HCR_INPUT */ 420 } 421 422 pCodeBk = pHcr->decInOut.pCodebook; 423 for ( i = 0; i < numSection; i++ ) { 424 if ( 425 (*pCodeBk == NOISE_HCB) || 426 (*pCodeBk == INTENSITY_HCB2) || 427 (*pCodeBk == INTENSITY_HCB)) 428 { 429 *pCodeBk = 0; 430 } 431 pCodeBk++; 432 } 433 434 /* HCR-sideinfo-input is complete and seems to be valid */ 435 436 437 438 return ( pHcr->decInOut.errorLog ); 439} 440 441 442 443 444#if USE_HCR_DUMMY 445 446/*--------------------------------------------------------------------------------------------- 447 448 description: This HCR - dummy - function writes only a dirac-sequence in output buffer 449 450-------------------------------------------------------------------------------------------- */ 451UINT HcrDecoder(H_HCR_INFO pHcr, 452 const CAacDecoderChannelInfo *pAacDecoderChannelInfo, 453 HANDLE_FDK_BITSTREAM bs) 454{ 455 for (SHORT i=0; i < 1024; i++ ) { 456 pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = FL2FXCONST_DBL(0.0f); 457 if ( i % 30 == 0) { 458 pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = (FIXP_DBL)HCR_DIRAC; 459 } 460 } 461 return 0; 462} 463 464#else /* USE_HCR_DUMMY */ 465 466/*--------------------------------------------------------------------------------------------- 467 description: This function decodes the codewords of the spectral coefficients from the 468 bitstream according to the HCR algorithm and stores the quantized spectral 469 coefficients in correct order in the output buffer. 470-------------------------------------------------------------------------------------------- */ 471 472UINT HcrDecoder(H_HCR_INFO pHcr, 473 CAacDecoderChannelInfo *pAacDecoderChannelInfo, 474 const SamplingRateInfo *pSamplingRateInfo, 475 HANDLE_FDK_BITSTREAM bs) 476{ 477 int pTmp1, pTmp2, pTmp3, pTmp4; 478#if DETECT_TOO_LONG_CW_READS 479 int pTmp5; 480#endif 481 482 INT bitCntOffst; 483 UINT saveBitCnt = FDKgetBitCnt(bs); /* save bitstream position */ 484 485 HcrCalcNumCodeword(pHcr); 486 487 HcrSortCodebookAndNumCodewordInSection(pHcr); 488 489 HcrPrepareSegmentationGrid(pHcr); 490 491 HcrExtendedSectionInfo(pHcr); 492 493 if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) != 0 ) { 494 return ( pHcr->decInOut.errorLog ); /* sideinfo is massively corrupt, return from HCR without having decoded anything */ 495 } 496 497 DeriveNumberOfExtendedSortedSectionsInSets(pHcr->segmentInfo.numSegment, 498 pHcr->sectionInfo.pNumExtendedSortedCodewordInSection, 499 pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx, 500 pHcr->sectionInfo.pNumExtendedSortedSectionsInSets, 501 pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx); 502 503 /* store */ 504 pTmp1 = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx; 505 pTmp2 = pHcr->sectionInfo.extendedSortedCodebookIdx; 506 pTmp3 = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx; 507 pTmp4 = pHcr->decInOut.quantizedSpectralCoefficientsIdx; 508#if DETECT_TOO_LONG_CW_READS 509 pTmp5 = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx; 510#endif 511 512 /* ------- decode meaningful PCWs ------ */ 513 DecodePCWs(bs, pHcr); 514 515 if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) == 0 ) { 516 /* ------ decode the non-PCWs -------- */ 517 DecodeNonPCWs(bs, pHcr); 518 } 519 520 521#if CHECK_SEGMENTATION_FINAL 522 errDetectWithinSegmentationFinal(pHcr); 523#endif 524 525 /* restore */ 526 pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = pTmp1; 527 pHcr->sectionInfo.extendedSortedCodebookIdx = pTmp2; 528 pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = pTmp3; 529 pHcr->decInOut.quantizedSpectralCoefficientsIdx = pTmp4; 530#if DETECT_TOO_LONG_CW_READS 531 pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = pTmp5; 532#endif 533 534 HcrReorderQuantizedSpectralCoefficients(pHcr, pAacDecoderChannelInfo, pSamplingRateInfo); 535 536 /* restore bitstream position */ 537 bitCntOffst = saveBitCnt - FDKgetBitCnt(bs); 538 if( bitCntOffst ) { 539 FDKpushBiDirectional(bs, bitCntOffst); 540 } 541 542 return ( pHcr->decInOut.errorLog ); 543} 544 545 546#endif /* USE_HCR_DUMMY */ 547 548 549 550 551/*--------------------------------------------------------------------------------------------- 552 description: This function reorders the quantized spectral coefficients sectionwise for 553 long- and short-blocks and compares to the LAV (Largest Absolute Value of 554 the current codebook) -- a counter is incremented if there is an error 555 detected. 556 Additional for short-blocks a unit-based-deinterleaving is applied. 557 Moreover (for short blocks) the scaling is derived (compare plain huffman 558 decoder). 559-------------------------------------------------------------------------------------------- */ 560 561static void HcrReorderQuantizedSpectralCoefficients( 562 H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo, 563 const SamplingRateInfo *pSamplingRateInfo 564 ) 565{ 566 INT qsc; 567 UINT abs_qsc; 568 UINT i,j; 569 USHORT numSpectralValuesInSection; 570 FIXP_DBL *pTeVa; 571 USHORT lavErrorCnt = 0; 572 573 UINT numSection = pHcr->decInOut.numSection; 574 SPECTRAL_PTR pQuantizedSpectralCoefficientsBase = pHcr->decInOut.pQuantizedSpectralCoefficientsBase; 575 FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase); 576 const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; 577 const USHORT *pLargestAbsVal = pHcr->tableInfo.pLargestAbsVal; 578 UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; 579 USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; 580 USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset; 581 FIXP_DBL *pTempValues = pHcr->segmentInfo.pTempValues; 582 FIXP_DBL *pBak = pHcr->segmentInfo.pTempValues; 583 584 FDKmemclear(pTempValues,1024*sizeof(FIXP_DBL)); 585 586 /* long and short: check if decoded huffman-values (quantized spectral coefficients) are within range */ 587 for ( i=numSection; i != 0; i-- ) { 588 numSpectralValuesInSection = *pNumSortedCodewordInSection++ << pCbDimShift[*pSortedCodebook]; 589 pTeVa = &pTempValues[*pReorderOffset++]; 590 for( j = numSpectralValuesInSection; j != 0; j-- ) { 591 qsc = *pQuantizedSpectralCoefficients++; 592 abs_qsc = FDKabs(qsc); 593#if VALID_LAV_ERROR_TRIGGER 594 if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) { 595 *pTeVa++ = (FIXP_DBL)qsc; /* the qsc value is within range */ 596 } 597 else { /* line is too high .. */ 598 if ( abs_qsc == Q_VALUE_INVALID ) { /* .. because of previous marking --> dont set LAV flag (would be confusing), just copy out the already marked value */ 599 *pTeVa++ = (FIXP_DBL) qsc; 600 } 601 else { /* .. because a too high value was decoded for this cb --> set LAV flag */ 602 *pTeVa++ = (FIXP_DBL) Q_VALUE_INVALID; 603 lavErrorCnt += 1; 604 } 605 } 606#else 607 if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) { 608 *pTeVa++ = qsc; 609 } 610 else { 611 *pTeVa++ = Q_VALUE_INVALID; 612 lavErrorCnt += 1; 613 } 614#endif 615 } 616 pSortedCodebook++; 617 } 618 619 if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) 620 { 621 FIXP_DBL *pOut; 622 FIXP_DBL locMax; 623 FIXP_DBL tmp; 624 SCHAR groupoffset; 625 SCHAR group; 626 SCHAR band; 627 SCHAR groupwin; 628 SCHAR window; 629 SCHAR numWinGroup; 630 SHORT interm; 631 SCHAR numSfbTransm; 632 SCHAR winGroupLen; 633 SHORT index; 634 INT msb; 635 INT lsb; 636 637 SHORT *pScaleFacHcr = pAacDecoderChannelInfo->pDynData->aScaleFactor; 638 SHORT *pSfbSclHcr = pAacDecoderChannelInfo->pDynData->aSfbScale; 639 const SHORT *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo); 640 641 pBak = pHcr->segmentInfo.pTempValues; 642 /* deinterleave unitwise for short blocks */ 643 for ( window = 0; window < (8); window++ ) { 644 pOut = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength); 645 for ( i=0; i < (LINES_PER_UNIT_GROUP); i++ ) { 646 pTeVa = pBak + (window << FOUR_LOG_DIV_TWO_LOG) + i * 32; /* distance of lines between unit groups has to be constant for every framelength (32)! */ 647 for ( j=(LINES_PER_UNIT); j != 0; j-- ) { 648 *pOut++ = *pTeVa++; 649 } 650 } 651 } 652 653 /* short blocks only */ 654 /* derive global scaling-value for every sfb and every window (as it is done in plain-huffman-decoder at short blocks) */ 655 groupoffset = 0; 656 657 numWinGroup = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); 658 numSfbTransm = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo); 659 660 for (group = 0; group < numWinGroup; group++) { 661 winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); 662 for (band = 0; band < numSfbTransm; band++) { 663 interm = group * 16 + band; 664 msb = pScaleFacHcr[interm] >> 2; 665 lsb = pScaleFacHcr[interm] & 3; 666 for (groupwin = 0; groupwin < winGroupLen; groupwin++) { 667 window = groupoffset + groupwin; 668 pBak = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength); 669 locMax = FL2FXCONST_DBL(0.0f); 670 for (index = BandOffsets[band]; index < BandOffsets[band+1]; index += LINES_PER_UNIT) { 671 pTeVa = &pBak[index]; 672 for ( i = LINES_PER_UNIT; i != 0; i --) { 673 tmp = (*pTeVa < FL2FXCONST_DBL(0.0f))? -*pTeVa++ : *pTeVa++; 674 locMax = fixMax(tmp,locMax); 675 } 676 } 677 if ( fixp_abs(locMax) > (FIXP_DBL)MAX_QUANTIZED_VALUE ) { 678 locMax = (FIXP_DBL)MAX_QUANTIZED_VALUE; 679 } 680 pSfbSclHcr[window*16+band] = msb - GetScaleFromValue(locMax, lsb); /* save global scale maxima in this sfb */ 681 } 682 } 683 groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); 684 } 685 } else 686 { 687 /* copy straight for long-blocks */ 688 pQuantizedSpectralCoefficients = SPEC_LONG(pQuantizedSpectralCoefficientsBase); 689 for ( i = 1024; i != 0; i-- ) { 690 *pQuantizedSpectralCoefficients++ = *pBak++; 691 } 692 } 693 694 if ( lavErrorCnt != 0 ) { 695 pHcr->decInOut.errorLog |= LAV_VIOLATION; 696 } 697} 698 699 700/*--------------------------------------------------------------------------------------------- 701 description: This function calculates the number of codewords 702 for each section (numCodewordInSection) and the number of codewords 703 for all sections (numCodeword). 704 For zero and intensity codebooks a entry is also done in the variable 705 numCodewordInSection. It is assumed that the codebook is a two tuples 706 codebook. This is needed later for the calculation of the base addresses 707 for the reordering of the quantize spectral coefficients at the end of the 708 hcr tool. 709 The variable numCodeword contain the number of codewords which are really 710 in the bitstream. Zero or intensity codebooks does not increase the 711 variable numCodewords. 712----------------------------------------------------------------------------------------------- 713 return: - 714-------------------------------------------------------------------------------------------- */ 715 716static void HcrCalcNumCodeword(H_HCR_INFO pHcr) 717{ 718 int hcrSection; 719 UINT numCodeword; 720 721 UINT numSection = pHcr->decInOut.numSection; 722 UCHAR *pCodebook = pHcr->decInOut.pCodebook; 723 SHORT *pNumLineInSection = pHcr->decInOut.pNumLineInSect; 724 const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; 725 USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection; 726 727 numCodeword = 0; 728 for ( hcrSection = numSection; hcrSection != 0; hcrSection-- ) { 729 *pNumCodewordInSection = *pNumLineInSection++ >> pCbDimShift[*pCodebook]; 730 if ( *pCodebook != 0 ) { 731 numCodeword += *pNumCodewordInSection; 732 } 733 pNumCodewordInSection++; 734 pCodebook++; 735 } 736 pHcr->sectionInfo.numCodeword = numCodeword; 737} 738 739 740/*--------------------------------------------------------------------------------------------- 741 description: This function calculates the number 742 of sorted codebooks and sorts the codebooks and the numCodewordInSection 743 according to the priority. 744-------------------------------------------------------------------------------------------- */ 745 746static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr) 747{ 748 749 UINT i,j,k; 750 UCHAR temp; 751 UINT counter; 752 UINT startOffset; 753 UINT numZeroSection; 754 UCHAR *pDest; 755 UINT numSectionDec; 756 757 UINT numSection = pHcr->decInOut.numSection; 758 UCHAR *pCodebook = pHcr->decInOut.pCodebook; 759 UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; 760 USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection; 761 USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; 762 UCHAR *pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch; 763 USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset; 764 const UCHAR *pCbPriority = pHcr->tableInfo.pCbPriority; 765 const UCHAR *pMinOfCbPair = pHcr->cbPairs.pMinOfCbPair; 766 const UCHAR *pMaxOfCbPair = pHcr->cbPairs.pMaxOfCbPair; 767 const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; 768 769 UINT searchStart = 0; 770 771 /* calculate *pNumSortedSection and store the priorities in array pSortedCdebook */ 772 pDest = pSortedCodebook; 773 numZeroSection = 0; 774 for ( i=numSection; i != 0; i-- ) { 775 if ( pCbPriority[*pCodebook] == 0 ) { 776 numZeroSection += 1; 777 } 778 *pDest++ = pCbPriority[*pCodebook++]; 779 } 780 pHcr->sectionInfo.numSortedSection = numSection - numZeroSection; /* numSortedSection contains no zero or intensity section */ 781 pCodebook = pHcr->decInOut.pCodebook; 782 783 /* sort priorities of the codebooks in array pSortedCdebook[] */ 784 numSectionDec = numSection - 1; 785 if ( numSectionDec > 0 ) { 786 counter = numSectionDec; 787 for ( j=numSectionDec; j != 0; j-- ) { 788 for ( i=0; i < counter; i++ ) { 789 /* swap priorities */ 790 if ( pSortedCodebook[i+1] > pSortedCodebook[i] ) { 791 temp = pSortedCodebook[i]; 792 pSortedCodebook[i] = pSortedCodebook[i+1]; 793 pSortedCodebook[i+1] = temp; 794 } 795 } 796 counter -= 1; 797 } 798 } 799 800 /* clear codebookSwitch array */ 801 for ( i = numSection; i != 0; i--) { 802 *pCodebookSwitch++ = 0; 803 } 804 pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch; 805 806 /* sort sectionCodebooks and numCodwordsInSection and calculate pReorderOffst[j] */ 807 for ( j = 0; j < numSection; j++ ) { 808 for ( i = searchStart; i < numSection; i++ ) { 809 if ( pCodebookSwitch[i] == 0 && ( pMinOfCbPair[pSortedCodebook[j]] == pCodebook[i] || pMaxOfCbPair[pSortedCodebook[j]] == pCodebook[i] )) { 810 pCodebookSwitch[i] = 1; 811 pSortedCodebook[j] = pCodebook[i]; /* sort codebook */ 812 pNumSortedCodewordInSection[j] = pNumCodewordInSection[i]; /* sort NumCodewordInSection */ 813 814 startOffset = 0; 815 for ( k = 0; k < i; k++ ) { /* make entry in pReorderOffst */ 816 startOffset += pNumCodewordInSection[k] << pCbDimShift[pCodebook[k]]; 817 } 818 pReorderOffset[j] = startOffset; /* offset for reordering the codewords */ 819 820 if(i == searchStart) { 821 UINT k = i; 822 while(pCodebookSwitch[k++] == 1) searchStart++; 823 } 824 break; 825 } 826 } 827 } 828} 829 830 831/*--------------------------------------------------------------------------------------------- 832 description: This function calculates the segmentation, which includes numSegment, 833 leftStartOfSegment, rightStartOfSegment and remainingBitsInSegment. 834 The segmentation could be visualized a as kind of 'overlay-grid' for the 835 bitstream-block holding the HCR-encoded quantized-spectral-coefficients. 836-------------------------------------------------------------------------------------------- */ 837 838static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) 839{ 840 USHORT i,j; 841 USHORT numSegment = 0; 842 USHORT segmentStart = 0; 843 UCHAR segmentWidth; 844 UCHAR lastSegmentWidth; 845 UCHAR sortedCodebook; 846 UCHAR endFlag = 0; 847 USHORT intermediateResult; 848 849 SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword; 850 SHORT lengthOfReorderedSpectralData = pHcr->decInOut.lengthOfReorderedSpectralData; 851 UINT numSortedSection = pHcr->sectionInfo.numSortedSection; 852 UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; 853 USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; 854 USHORT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 855 USHORT *pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 856 SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 857 USHORT bitstreamIndex = pHcr->decInOut.bitstreamIndex; 858 const UCHAR *pMaxCwLength = pHcr->tableInfo.pMaxCwLength; 859 860 for ( i=numSortedSection; i != 0; i-- ) { 861 sortedCodebook = *pSortedCodebook++; 862 segmentWidth = FDKmin(pMaxCwLength[sortedCodebook],lengthOfLongestCodeword); 863 864 for ( j = *pNumSortedCodewordInSection; j != 0 ; j-- ) { 865 /* width allows a new segment */ 866 intermediateResult = bitstreamIndex + segmentStart; 867 if ( (segmentStart + segmentWidth) <= lengthOfReorderedSpectralData ) { 868 /* store segment start, segment length and increment the number of segments */ 869 *pLeftStartOfSegment++ = intermediateResult; 870 *pRightStartOfSegment++ = intermediateResult + segmentWidth - 1; 871 *pRemainingBitsInSegment++ = segmentWidth; 872 segmentStart += segmentWidth; 873 numSegment += 1; 874 } 875 /* width does not allow a new segment */ 876 else { 877 /* correct the last segment length */ 878 pLeftStartOfSegment--; 879 pRightStartOfSegment--; 880 pRemainingBitsInSegment--; 881 segmentStart = *pLeftStartOfSegment - bitstreamIndex; 882 883 lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart; 884 *pRemainingBitsInSegment = lastSegmentWidth; 885 *pRightStartOfSegment = bitstreamIndex + segmentStart + lastSegmentWidth - 1; 886 endFlag = 1; 887 break; 888 } 889 } 890 pNumSortedCodewordInSection++; 891 if (endFlag != 0) { 892 break; 893 } 894 } 895 pHcr->segmentInfo.numSegment = numSegment; 896 897} 898 899 900/*--------------------------------------------------------------------------------------------- 901 description: This function adapts the sorted section boundaries to the boundaries of 902 segmentation. If the section lengths does not fit completely into the 903 current segment, the section is spitted into two so called 'extended 904 sections'. The extended-section-info (pNumExtendedSortedCodewordInSectin 905 and pExtendedSortedCodebook) is updated in this case. 906 907-------------------------------------------------------------------------------------------- */ 908 909static void HcrExtendedSectionInfo(H_HCR_INFO pHcr) 910{ 911 UINT srtSecCnt = 0; /* counter for sorted sections */ 912 UINT xSrtScCnt = 0; /* counter for extended sorted sections */ 913 UINT remainNumCwInSortSec; 914 UINT inSegmentRemainNumCW; 915 916 UINT numSortedSection = pHcr->sectionInfo.numSortedSection; 917 UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; 918 USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; 919 UCHAR *pExtendedSortedCoBo = pHcr->sectionInfo.pExtendedSortedCodebook; 920 USHORT *pNumExtSortCwInSect = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection; 921 UINT numSegment = pHcr->segmentInfo.numSegment; 922#if DETECT_TOO_LONG_CW_READS 923 UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec; 924 SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword; 925 const UCHAR *pMaxCwLength = pHcr->tableInfo.pMaxCwLength; 926#endif 927 928 remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; 929 inSegmentRemainNumCW = numSegment; 930 931 while (srtSecCnt < numSortedSection) { 932 if (inSegmentRemainNumCW < remainNumCwInSortSec) { 933 934 pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW; 935 pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; 936 937 remainNumCwInSortSec -= inSegmentRemainNumCW; 938 inSegmentRemainNumCW = numSegment; 939 /* data of a sorted section was not integrated in extended sorted section */ 940 } 941 else if (inSegmentRemainNumCW == remainNumCwInSortSec) { 942 pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW; 943 pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; 944 945 srtSecCnt++; 946 remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; 947 inSegmentRemainNumCW = numSegment; 948 /* data of a sorted section was integrated in extended sorted section */ 949 } 950 else { /* inSegmentRemainNumCW > remainNumCwInSortSec */ 951 pNumExtSortCwInSect[xSrtScCnt] = remainNumCwInSortSec; 952 pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; 953 954 955 inSegmentRemainNumCW -= remainNumCwInSortSec; 956 srtSecCnt++; 957 remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; 958 /* data of a sorted section was integrated in extended sorted section */ 959 } 960#if DETECT_TOO_LONG_CW_READS 961 pMaxLenOfCbInExtSrtSec[xSrtScCnt] = FDKmin(pMaxCwLength[pExtendedSortedCoBo[xSrtScCnt]],lengthOfLongestCodeword); 962#endif 963 964 965 966 xSrtScCnt += 1; 967 968 if ( xSrtScCnt >= (MAX_SFB_HCR + MAX_HCR_SETS) ) { 969 pHcr->decInOut.errorLog |= EXTENDED_SORTED_COUNTER_OVERFLOW; 970 return; 971 } 972 973 } 974 pNumExtSortCwInSect[xSrtScCnt] = 0; 975 976} 977 978 979/*--------------------------------------------------------------------------------------------- 980 description: This function calculates the number of extended sorted sections which 981 belong to the sets. Each set from set 0 (one and only set for the PCWs) 982 till to the last set gets a entry in the array to which 983 'pNumExtendedSortedSectinsInSets' points to. 984 985 Calculation: The entrys in pNumExtendedSortedCodewordInSectin are added 986 untill the value numSegment is reached. Then the sum_variable is cleared 987 and the calculation starts from the beginning. As much extended sorted 988 Sections are summed up to reach the value numSegment, as much is the 989 current entry in *pNumExtendedSortedCodewordInSectin. 990-------------------------------------------------------------------------------------------- */ 991static void DeriveNumberOfExtendedSortedSectionsInSets(UINT numSegment, 992 USHORT *pNumExtendedSortedCodewordInSection, 993 int numExtendedSortedCodewordInSectionIdx, 994 USHORT *pNumExtendedSortedSectionsInSets, 995 int numExtendedSortedSectionsInSetsIdx) 996{ 997 USHORT counter = 0; 998 UINT cwSum = 0; 999 USHORT *pNumExSortCwInSec = pNumExtendedSortedCodewordInSection; 1000 USHORT *pNumExSortSecInSets = pNumExtendedSortedSectionsInSets; 1001 1002 while (pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx] != 0) 1003 { 1004 cwSum += pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx]; 1005 numExtendedSortedCodewordInSectionIdx++; 1006 if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { 1007 return; 1008 } 1009 if (cwSum > numSegment) { 1010 return; 1011 } 1012 counter++; 1013 if (counter > 1024/4) { 1014 return; 1015 } 1016 if ( cwSum == numSegment ) { 1017 pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter; 1018 numExtendedSortedSectionsInSetsIdx++; 1019 if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) { 1020 return; 1021 } 1022 counter = 0; 1023 cwSum = 0; 1024 } 1025 } 1026 pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter; /* save last entry for the last - probably shorter - set */ 1027} 1028 1029 1030/*--------------------------------------------------------------------------------------------- 1031 description: This function decodes all priority codewords (PCWs) in a spectrum (within 1032 set 0). The calculation of the PCWs is managed in two loops. The 1033 loopcounter of the outer loop is set to the first value pointer 1034 pNumExtendedSortedSectionsInSets points to. This value represents the 1035 number of extended sorted sections within set 0. 1036 The loopcounter of the inner loop is set to the first value pointer 1037 pNumExtendedSortedCodewordInSectin points to. The value represents the 1038 number of extended sorted codewords in sections (the original sections have 1039 been splitted to go along with the borders of the sets). 1040 Each time the number of the extended sorted codewords in sections are de- 1041 coded, the pointer 'pNumExtendedSortedCodewordInSectin' is incremented by 1042 one. 1043-------------------------------------------------------------------------------------------- */ 1044static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) 1045{ 1046 UINT i; 1047 USHORT extSortSec; 1048 USHORT curExtSortCwInSec; 1049 UCHAR codebook; 1050 UCHAR dimension; 1051 const UINT *pCurrentTree; 1052 const SCHAR *pQuantValBase; 1053 const SCHAR *pQuantVal; 1054 1055 USHORT *pNumExtendedSortedCodewordInSection = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection; 1056 int numExtendedSortedCodewordInSectionIdx = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx; 1057 UCHAR *pExtendedSortedCodebook = pHcr->sectionInfo.pExtendedSortedCodebook; 1058 int extendedSortedCodebookIdx = pHcr->sectionInfo.extendedSortedCodebookIdx; 1059 USHORT *pNumExtendedSortedSectionsInSets = pHcr->sectionInfo.pNumExtendedSortedSectionsInSets; 1060 int numExtendedSortedSectionsInSetsIdx = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx; 1061 FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase); 1062 int quantizedSpectralCoefficientsIdx = pHcr->decInOut.quantizedSpectralCoefficientsIdx; 1063 USHORT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 1064 SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 1065#if DETECT_TOO_LONG_CW_READS 1066 UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec; 1067 int maxLenOfCbInExtSrtSecIdx = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx; 1068 UCHAR maxAllowedCwLen; 1069 int numDecodedBits; 1070#endif 1071 const UCHAR *pCbDimension = pHcr->tableInfo.pCbDimension; 1072 const UCHAR *pCbSign = pHcr->tableInfo.pCbSign; 1073 1074 /* clear result array */ 1075 //pQSC = &pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]; 1076 //pQSC = *pQuantizedSpectralCoefficients; 1077 1078 FDKmemclear(pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx,1024*sizeof(FIXP_DBL)); 1079 1080 /* decode all PCWs in the extended sorted section(s) belonging to set 0 */ 1081 for ( extSortSec = pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx]; extSortSec != 0; extSortSec-- ) { 1082 1083 codebook = pExtendedSortedCodebook[extendedSortedCodebookIdx]; /* get codebook for this extended sorted section and increment ptr to cb of next ext. sort sec */ 1084 extendedSortedCodebookIdx++; 1085 if (extendedSortedCodebookIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { 1086 return; 1087 } 1088 dimension = pCbDimension[codebook]; /* get dimension of codebook of this extended sort. sec. */ 1089 pCurrentTree = aHuffTable [codebook]; /* convert codebook to pointer to QSCs */ 1090 pQuantValBase = aQuantTable [codebook]; /* convert codebook to index to table of QSCs */ 1091#if DETECT_TOO_LONG_CW_READS 1092 maxAllowedCwLen = pMaxLenOfCbInExtSrtSec[maxLenOfCbInExtSrtSecIdx]; 1093 maxLenOfCbInExtSrtSecIdx++; 1094 if (maxLenOfCbInExtSrtSecIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { 1095 return; 1096 } 1097#endif 1098 1099 /* switch for decoding with different codebooks: */ 1100 if ( pCbSign[codebook] == 0 ) { /* no sign bits follow after the codeword-body */ 1101 /* PCW_BodyONLY */ 1102 /*==============*/ 1103 1104 for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) { 1105 numDecodedBits = 0; 1106 1107 /* decode PCW_BODY */ 1108 pQuantVal = DecodePCW_Body(bs, 1109 pCurrentTree, 1110 pQuantValBase, 1111 pLeftStartOfSegment, 1112 pRemainingBitsInSegment, 1113 &numDecodedBits 1114 ); 1115 1116 /* result is written out here because NO sign bits follow the body */ 1117 for( i=dimension; i != 0 ; i-- ) { 1118 pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) *pQuantVal++; /* write quant. spec. coef. into spectrum; sign is already valid */ 1119 quantizedSpectralCoefficientsIdx++; 1120 if (quantizedSpectralCoefficientsIdx >= 1024) { 1121 return; 1122 } 1123 } 1124 1125 /* one more PCW should be decoded */ 1126 1127#if DETECT_TOO_LONG_CW_READS 1128 if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_ONLY_TOO_LONG) ) { 1129 pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_BITS_DECODED; 1130 } 1131#endif 1132 1133#if CHECK_SEGMENTATION_IMMEDIATELY 1134 if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY,pHcr,PCW_BODY,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) { 1135 return; 1136 } 1137#endif 1138 pLeftStartOfSegment++; /* update pointer for decoding the next PCW */ 1139 pRemainingBitsInSegment++; /* update pointer for decoding the next PCW */ 1140 } 1141 } 1142 else if (( pCbSign[codebook] == 1 ) && ( codebook < 11 )) { /* possibly there follow 1,2,3 or 4 sign bits after the codeword-body */ 1143 /* PCW_Body and PCW_Sign */ 1144 /*=======================*/ 1145 1146 for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) 1147 { 1148 int err; 1149 numDecodedBits = 0; 1150 1151 pQuantVal = DecodePCW_Body(bs, 1152 pCurrentTree, 1153 pQuantValBase, 1154 pLeftStartOfSegment, 1155 pRemainingBitsInSegment, 1156 &numDecodedBits 1157 ); 1158 1159 err = DecodePCW_Sign( bs, 1160 dimension, 1161 pQuantVal, 1162 pQuantizedSpectralCoefficients, 1163 &quantizedSpectralCoefficientsIdx, 1164 pLeftStartOfSegment, 1165 pRemainingBitsInSegment, 1166 &numDecodedBits 1167 ); 1168 if (err != 0) { 1169 return; 1170 } 1171 /* one more PCW should be decoded */ 1172 1173#if DETECT_TOO_LONG_CW_READS 1174 if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_TOO_LONG) ) { 1175 pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_BITS_DECODED; 1176 } 1177#endif 1178 1179#if CHECK_SEGMENTATION_IMMEDIATELY 1180 if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN,pHcr,PCW_BODY_SIGN, pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) { 1181 return; 1182 } 1183#endif 1184 pLeftStartOfSegment++; 1185 pRemainingBitsInSegment++; 1186 } 1187 } 1188 else if (( pCbSign[codebook] == 1 ) && ( codebook >= 11 )) { /* possibly there follow some sign bits and maybe one or two escape sequences after the cw-body */ 1189 /* PCW_Body, PCW_Sign and maybe PCW_Escape */ 1190 /*=========================================*/ 1191 1192 for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) 1193 { 1194 int err; 1195 numDecodedBits = 0; 1196 1197 /* decode PCW_BODY */ 1198 pQuantVal = DecodePCW_Body(bs, 1199 pCurrentTree, 1200 pQuantValBase, 1201 pLeftStartOfSegment, 1202 pRemainingBitsInSegment, 1203 &numDecodedBits 1204 ); 1205 1206 err = DecodePCW_Sign( bs, 1207 dimension, 1208 pQuantVal, 1209 pQuantizedSpectralCoefficients, 1210 &quantizedSpectralCoefficientsIdx, 1211 pLeftStartOfSegment, 1212 pRemainingBitsInSegment, 1213 &numDecodedBits 1214 ); 1215 if (err != 0) { 1216 return; 1217 } 1218 1219 /* decode PCW_ESCAPE if present */ 1220 quantizedSpectralCoefficientsIdx -= DIMENSION_OF_ESCAPE_CODEBOOK; 1221 1222 if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) { 1223 pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs, 1224 pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx], 1225 pLeftStartOfSegment, 1226 pRemainingBitsInSegment, 1227 &numDecodedBits 1228 ); 1229 } 1230 quantizedSpectralCoefficientsIdx++; 1231 if (quantizedSpectralCoefficientsIdx >= 1024) { 1232 return; 1233 } 1234 1235 if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) { 1236 pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs, 1237 pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx], 1238 pLeftStartOfSegment, 1239 pRemainingBitsInSegment, 1240 &numDecodedBits 1241 ); 1242 } 1243 quantizedSpectralCoefficientsIdx++; 1244 if (quantizedSpectralCoefficientsIdx >= 1024) { 1245 return; 1246 } 1247 1248 /* one more PCW should be decoded */ 1249 1250#if DETECT_TOO_LONG_CW_READS 1251 if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_ESC_TOO_LONG) ) { 1252 pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_ESC_BITS_DECODED; 1253 } 1254#endif 1255 1256#if CHECK_SEGMENTATION_IMMEDIATELY 1257 if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN_ESC,pHcr,PCW_BODY_SIGN_ESC,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-DIMENSION_OF_ESCAPE_CODEBOOK,DIMENSION_OF_ESCAPE_CODEBOOK)) { 1258 return; 1259 } 1260#endif 1261 pLeftStartOfSegment++; 1262 pRemainingBitsInSegment++; 1263 } 1264 } 1265 1266 /* all PCWs belonging to this extended section should be decoded */ 1267 numExtendedSortedCodewordInSectionIdx++; 1268 if (numExtendedSortedCodewordInSectionIdx >= MAX_SFB_HCR+MAX_HCR_SETS) { 1269 return; 1270 } 1271 } 1272 /* all PCWs should be decoded */ 1273 1274 numExtendedSortedSectionsInSetsIdx++; 1275 if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) { 1276 return; 1277 } 1278 1279 /* Write back indexes into structure */ 1280 pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx; 1281 pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx; 1282 pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx; 1283 pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx; 1284 pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = maxLenOfCbInExtSrtSecIdx; 1285} 1286 1287#if CHECK_SEGMENTATION_IMMEDIATELY 1288/*--------------------------------------------------------------------------------------------- 1289 description: This function checks immediately after every decoded PCW, whether out of 1290 the current segment too many bits have been read or not. If an error occurrs, 1291 probably the sideinfo or the HCR-bitstream block holding the huffman 1292 encoded quantized spectral coefficients is distorted. In this case the two 1293 or four quantized spectral coefficients belonging to the current codeword 1294 are marked (for being detected by concealment later). 1295-------------------------------------------------------------------------------------------- */ 1296static UCHAR errDetectPcwSegmentation(SCHAR remainingBitsInSegment, 1297 H_HCR_INFO pHcr, 1298 PCW_TYPE kind, 1299 FIXP_DBL *qsc_base_of_cw, 1300 UCHAR dimension) 1301{ 1302 SCHAR i; 1303 if ( remainingBitsInSegment < 0 ) { 1304 /* log the error */ 1305 switch (kind) { 1306 case PCW_BODY: 1307 pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY; 1308 break; 1309 case PCW_BODY_SIGN: 1310 pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN; 1311 break; 1312 case PCW_BODY_SIGN_ESC: 1313 pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN_ESC; 1314 break; 1315 } 1316 /* mark the erred lines */ 1317 for ( i = dimension; i != 0; i-- ) { 1318 *qsc_base_of_cw++ = (FIXP_DBL) Q_VALUE_INVALID; 1319 } 1320 return 1; 1321 } 1322 return 0; 1323} 1324#endif 1325 1326#if CHECK_SEGMENTATION_FINAL 1327/*--------------------------------------------------------------------------------------------- 1328 description: This function checks if all segments are empty after decoding. There 1329 are _no lines markded_ as invalid because it could not be traced back 1330 where from the remaining bits are. 1331-------------------------------------------------------------------------------------------- */ 1332static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr) 1333{ 1334 UCHAR segmentationErrorFlag = 0; 1335 USHORT i; 1336 SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 1337 UINT numSegment = pHcr->segmentInfo.numSegment; 1338 1339 for ( i=numSegment; i != 0 ; i--) { 1340 if (*pRemainingBitsInSegment++ != 0) { 1341 segmentationErrorFlag = 1; 1342 } 1343 } 1344 if (segmentationErrorFlag == 1) { 1345 pHcr->decInOut.errorLog |= BIT_IN_SEGMENTATION_ERROR; 1346 } 1347} 1348#endif 1349 1350/*--------------------------------------------------------------------------------------------- 1351 description: This function walks one step within the decoding tree. Which branch is 1352 taken depends on the decoded carryBit input parameter. 1353-------------------------------------------------------------------------------------------- */ 1354void CarryBitToBranchValue(UCHAR carryBit, 1355 UINT treeNode, 1356 UINT *branchValue, 1357 UINT *branchNode) 1358{ 1359 if (carryBit == 0) { 1360 *branchNode = (treeNode & MASK_LEFT) >> LEFT_OFFSET; /* MASK_LEFT: 00FFF000 */ 1361 } 1362 else { 1363 *branchNode = treeNode & MASK_RIGHT; /* MASK_RIGHT: 00000FFF */ 1364 } 1365 1366 *branchValue = *branchNode & CLR_BIT_10; /* clear bit 10 (if set) */ 1367} 1368 1369 1370/*--------------------------------------------------------------------------------------------- 1371 description: Decodes the body of a priority codeword (PCW) 1372----------------------------------------------------------------------------------------------- 1373 return: - return value is pointer to first of two or four quantized spectral 1374 coefficients 1375-------------------------------------------------------------------------------------------- */ 1376static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, 1377 const UINT *pCurrentTree, 1378 const SCHAR *pQuantValBase, 1379 USHORT *pLeftStartOfSegment, 1380 SCHAR *pRemainingBitsInSegment, 1381 int *pNumDecodedBits 1382 ) 1383{ 1384 UCHAR carryBit; 1385 UINT branchNode; 1386 UINT treeNode; 1387 UINT branchValue; 1388 const SCHAR *pQuantVal; 1389 1390 /* decode PCW_BODY */ 1391 treeNode = *pCurrentTree; /* get first node of current tree belonging to current codebook */ 1392 1393 /* decode whole PCW-codeword-body */ 1394 while (1) { 1395 1396 carryBit = HcrGetABitFromBitstream(bs, 1397 pLeftStartOfSegment, 1398 pLeftStartOfSegment, /* dummy */ 1399 FROM_LEFT_TO_RIGHT); 1400 *pRemainingBitsInSegment -= 1; 1401 *pNumDecodedBits += 1; 1402 1403 CarryBitToBranchValue(carryBit, 1404 treeNode, 1405 &branchValue, 1406 &branchNode); 1407 1408 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set --> codeword-body is complete */ 1409 break; /* end of branch in tree reached i.e. a whole PCW-Body is decoded */ 1410 } 1411 else { 1412 treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */ 1413 } 1414 1415 } 1416 1417 pQuantVal = pQuantValBase + branchValue; /* update pointer to valid first of 2 or 4 quantized values */ 1418 1419 return pQuantVal; 1420} 1421 1422 1423/*--------------------------------------------------------------------------------------------- 1424 description: This function decodes one escape sequence. In case of a escape codebook 1425 and in case of the absolute value of the quantized spectral value == 16, 1426 a escapeSequence is decoded in two steps: 1427 1. escape prefix 1428 2. escape word 1429-------------------------------------------------------------------------------------------- */ 1430 1431static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, 1432 INT quantSpecCoef, 1433 USHORT *pLeftStartOfSegment, 1434 SCHAR *pRemainingBitsInSegment, 1435 int *pNumDecodedBits 1436 ) 1437{ 1438 UINT i; 1439 INT sign; 1440 UINT escapeOnesCounter = 0; 1441 UINT carryBit; 1442 INT escape_word = 0; 1443 1444 /* decode escape prefix */ 1445 while (1) { 1446 carryBit = HcrGetABitFromBitstream(bs, 1447 pLeftStartOfSegment, 1448 pLeftStartOfSegment, /* dummy */ 1449 FROM_LEFT_TO_RIGHT); 1450 *pRemainingBitsInSegment -= 1; 1451 *pNumDecodedBits += 1; 1452 1453 if (carryBit != 0) { 1454 escapeOnesCounter += 1; 1455 } 1456 else { 1457 escapeOnesCounter += 4; 1458 break; 1459 } 1460 } 1461 1462 /* decode escape word */ 1463 for( i=escapeOnesCounter; i != 0 ; i-- ) { 1464 carryBit = HcrGetABitFromBitstream(bs, 1465 pLeftStartOfSegment, 1466 pLeftStartOfSegment, /* dummy */ 1467 FROM_LEFT_TO_RIGHT); 1468 *pRemainingBitsInSegment -= 1; 1469 *pNumDecodedBits += 1; 1470 1471 escape_word <<= 1; 1472 escape_word = escape_word | carryBit; 1473 } 1474 1475 sign = (quantSpecCoef >= 0) ? 1 : -1; 1476 1477 quantSpecCoef = sign * (((INT ) 1 << escapeOnesCounter) + escape_word); 1478 1479 return quantSpecCoef; 1480} 1481 1482 1483/*--------------------------------------------------------------------------------------------- 1484 description: Decodes the Signbits of a priority codeword (PCW) and writes out the 1485 resulting quantized spectral values into unsorted sections 1486----------------------------------------------------------------------------------------------- 1487 output: - two or four lines at position in corresponding section (which are not 1488 located at the desired position, i.e. they must be reordered in the last 1489 of eight function of HCR) 1490----------------------------------------------------------------------------------------------- 1491 return: - updated pQuantSpecCoef pointer (to next empty storage for a line) 1492-------------------------------------------------------------------------------------------- */ 1493static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, 1494 UINT codebookDim, 1495 const SCHAR *pQuantVal, 1496 FIXP_DBL *pQuantSpecCoef, 1497 int *quantSpecCoefIdx, 1498 USHORT *pLeftStartOfSegment, 1499 SCHAR *pRemainingBitsInSegment, 1500 int *pNumDecodedBits 1501 ) 1502{ 1503 UINT i; 1504 UINT carryBit; 1505 INT quantSpecCoef; 1506 1507 for( i=codebookDim; i != 0 ; i-- ) { 1508 quantSpecCoef = *pQuantVal++; 1509 if (quantSpecCoef != 0) { 1510 carryBit = HcrGetABitFromBitstream(bs, 1511 pLeftStartOfSegment, 1512 pLeftStartOfSegment, /* dummy */ 1513 FROM_LEFT_TO_RIGHT); 1514 *pRemainingBitsInSegment -= 1; 1515 *pNumDecodedBits += 1; 1516 if (*pRemainingBitsInSegment < 0 || *pNumDecodedBits >= (1024>>1)) { 1517 return -1; 1518 } 1519 1520 /* adapt sign of values according to the decoded sign bit */ 1521 if (carryBit != 0) { 1522 pQuantSpecCoef[*quantSpecCoefIdx] = -(FIXP_DBL)quantSpecCoef; 1523 } 1524 else { 1525 pQuantSpecCoef[*quantSpecCoefIdx] = (FIXP_DBL)quantSpecCoef; 1526 } 1527 } 1528 else { 1529 pQuantSpecCoef[*quantSpecCoefIdx] = FL2FXCONST_DBL(0.0f); 1530 } 1531 *quantSpecCoefIdx += 1 ; 1532 if (*quantSpecCoefIdx >= 1024) { 1533 return -1; 1534 } 1535 } 1536 return 0; 1537} 1538 1539 1540/*--------------------------------------------------------------------------------------------- 1541 description: Mutes spectral lines which have been marked as erroneous (Q_VALUE_INVALID) 1542-------------------------------------------------------------------------------------------- */ 1543void HcrMuteErroneousLines(H_HCR_INFO hHcr) 1544{ 1545 int c; 1546 FIXP_DBL *RESTRICT pLong = SPEC_LONG(hHcr->decInOut.pQuantizedSpectralCoefficientsBase); 1547 1548 /* if there is a line with value Q_VALUE_INVALID mute it */ 1549 for (c = 0; c < 1024; c++) { 1550 if (pLong[c] == (FIXP_DBL)Q_VALUE_INVALID) { 1551#if HCR_LISTEN_TO_MUTED_LINES 1552 pLong[c] = (FIXP_DBL)HCR_DIRAC; /* marking */ 1553#else 1554 pLong[c] = FL2FXCONST_DBL(0.0f); /* muting */ 1555#endif 1556 } 1557 } 1558} 1559 1560 1561/*--------------------------------------------------------------------------------------------- 1562 description: Sets global HCR type 1563-------------------------------------------------------------------------------------------- */ 1564void setHcrType(H_HCR_INFO hHcr, MP4_ELEMENT_ID type) 1565{ 1566 switch (type) { 1567 case ID_SCE: 1568 hHcr->globalHcrType = 0; 1569 break; 1570 case ID_CPE: 1571 hHcr->globalHcrType = 1; 1572 break; 1573 default: 1574 break; 1575 } 1576} 1577 1578 1579/*--------------------------------------------------------------------------------------------- 1580 description: Gets HCR type from the HCR data structure 1581----------------------------------------------------------------------------------------------- 1582 return: - global HCR type 1583-------------------------------------------------------------------------------------------- */ 1584INT getHcrType(H_HCR_INFO hHcr) 1585{ 1586 return hHcr->globalHcrType; 1587} 1588 1589 1590 1591 1592