| |
| /* ----------------------------------------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. |
| All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements |
| the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. |
| This FDK AAC Codec software is intended to be used on a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual |
| audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by |
| independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part |
| of the MPEG specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) |
| may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners |
| individually for the purpose of encoding or decoding bit streams in products that are compliant with |
| the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license |
| these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec |
| software may already be covered under those patent licenses when it is used for those licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, |
| are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional |
| applications information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, are permitted without |
| payment of copyright license fees provided that you satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of the FDK AAC Codec or |
| your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation and/or other materials |
| provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. |
| You must make available free of charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived from this library without |
| prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec |
| software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software |
| and the date of any change. For modified versions of the FDK AAC Codec, the term |
| "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term |
| "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, |
| ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with |
| respect to this software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized |
| by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors |
| "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties |
| of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, |
| including but not limited to procurement of substitute goods or services; loss of use, data, or profits, |
| or business interruption, however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of this software, even if |
| advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------------------------------------- */ |
| |
| /***************************** MPEG-4 AAC Decoder *************************** |
| |
| Author(s): Robert Weidner (DSP Solutions) |
| Description: HCR Decoder: HCR initialization, preprocess HCR sideinfo, |
| decode priority codewords (PCWs) |
| |
| *******************************************************************************/ |
| |
| #include "aacdec_hcr.h" |
| |
| |
| |
| #include "aacdec_hcr_types.h" |
| #include "aacdec_hcr_bit.h" |
| #include "aacdec_hcrs.h" |
| #include "aac_ram.h" |
| #include "aac_rom.h" |
| #include "channel.h" |
| #include "block.h" |
| |
| #include "aacdecoder.h" /* for ID_CPE, ID_SCE ... */ |
| #include "FDK_bitstream.h" |
| |
| extern int mlFileChCurr; |
| |
| static void errDetectorInHcrSideinfoShrt(SCHAR cb, |
| SHORT numLine, |
| UINT *errorWord); |
| |
| static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword, |
| SHORT lengthOfReorderedSpectralData, |
| UINT *errorWord); |
| |
| static void HcrCalcNumCodeword (H_HCR_INFO pHcr); |
| static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr); |
| static void HcrPrepareSegmentationGrid (H_HCR_INFO pHcr); |
| static void HcrExtendedSectionInfo (H_HCR_INFO pHcr); |
| |
| static void DeriveNumberOfExtendedSortedSectionsInSets(UINT numSegment, |
| USHORT *pNumExtendedSortedCodewordInSection, |
| int numExtendedSortedCodewordInSectionIdx, |
| USHORT *pNumExtendedSortedSectionsInSets, |
| int numExtendedSortedSectionsInSetsIdx); |
| |
| static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, |
| INT quantSpecCoef, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ); |
| |
| static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, |
| UINT codebookDim, |
| const SCHAR *pQuantVal, |
| FIXP_DBL *pQuantSpecCoef, |
| int *quantSpecCoefIdx, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ); |
| |
| static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, |
| const UINT *pCurrentTree, |
| const SCHAR *pQuantValBase, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ); |
| |
| static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr); |
| |
| static void HcrReorderQuantizedSpectralCoefficients( |
| H_HCR_INFO pHcr, |
| CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
| const SamplingRateInfo *pSamplingRateInfo |
| ); |
| |
| |
| #if CHECK_SEGMENTATION_IMMEDIATELY |
| static UCHAR errDetectPcwSegmentation(SCHAR remainingBitsInSegment, |
| H_HCR_INFO pHcr, |
| PCW_TYPE kind, |
| FIXP_DBL *qsc_base_of_cw, |
| UCHAR dimension); |
| #endif |
| |
| #if CHECK_SEGMENTATION_FINAL |
| static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr); |
| #endif |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Check if codebook and numSect are within allowed range (short only) |
| -------------------------------------------------------------------------------------------- */ |
| static void errDetectorInHcrSideinfoShrt(SCHAR cb, SHORT numLine,UINT* errorWord) |
| { |
| |
| |
| |
| if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) { |
| *errorWord |= CB_OUT_OF_RANGE_SHORT_BLOCK; |
| } |
| if ( numLine < 0 || numLine > 1024 ) { |
| *errorWord |= LINE_IN_SECT_OUT_OF_RANGE_SHORT_BLOCK; |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Check both HCR lengths |
| -------------------------------------------------------------------------------------------- */ |
| static void errDetectorInHcrLengths(SCHAR lengthOfLongestCodeword, |
| SHORT lengthOfReorderedSpectralData, |
| UINT *errorWord) |
| { |
| if ( lengthOfReorderedSpectralData < lengthOfLongestCodeword ) { |
| *errorWord |= HCR_SI_LENGTHS_FAILURE; |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Decode (and adapt if necessary) the two HCR sideinfo components: |
| 'reordered_spectral_data_length' and 'longest_codeword_length' |
| -------------------------------------------------------------------------------------------- */ |
| |
| void CHcr_Read(HANDLE_FDK_BITSTREAM bs, |
| CAacDecoderChannelInfo *pAacDecoderChannelInfo) |
| { |
| INT globalHcrType = getHcrType(&pAacDecoderChannelInfo->pComData->overlay.aac.erHcrInfo); |
| SHORT lengOfReorderedSpectralData; |
| SCHAR lengOfLongestCodeword; |
| |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = 0; |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = 0; |
| |
| |
| |
| /* ------- SI-Value No 1 ------- */ |
| lengOfReorderedSpectralData = FDKreadBits(bs,14) + ERROR_LORSD; |
| if ( globalHcrType == ID_CPE ) { |
| if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= CPE_TOP_LENGTH)) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */ |
| } |
| else { |
| if (lengOfReorderedSpectralData > CPE_TOP_LENGTH) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = CPE_TOP_LENGTH; /* use valid maximum */ |
| } |
| } |
| } |
| else if (globalHcrType == ID_SCE || globalHcrType == ID_LFE || globalHcrType == ID_CCE ) { |
| if ((lengOfReorderedSpectralData >= 0) && (lengOfReorderedSpectralData <= SCE_TOP_LENGTH)) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = lengOfReorderedSpectralData; /* the decoded value is within range */ |
| } |
| else { |
| if (lengOfReorderedSpectralData > SCE_TOP_LENGTH) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData = SCE_TOP_LENGTH; /* use valid maximum */ |
| } |
| } |
| } |
| |
| /* ------- SI-Value No 2 ------- */ |
| lengOfLongestCodeword = FDKreadBits(bs,6) + ERROR_LOLC; |
| if ((lengOfLongestCodeword >= 0) && (lengOfLongestCodeword <= LEN_OF_LONGEST_CW_TOP_LENGTH)) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = lengOfLongestCodeword; /* the decoded value is within range */ |
| } |
| else { |
| if (lengOfLongestCodeword > LEN_OF_LONGEST_CW_TOP_LENGTH) { |
| pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword = LEN_OF_LONGEST_CW_TOP_LENGTH; /* use valid maximum */ |
| } |
| } |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Sets up HCR ROM-Tables |
| -------------------------------------------------------------------------------------------- */ |
| |
| void HcrInitRom(H_HCR_INFO pHcr) |
| { |
| pHcr->cbPairs.pMinOfCbPair = aMinOfCbPair; |
| pHcr->cbPairs.pMaxOfCbPair = aMaxOfCbPair; |
| |
| pHcr->tableInfo.pMaxCwLength = aMaxCwLen; |
| pHcr->tableInfo.pCbDimension = aDimCb; |
| pHcr->tableInfo.pCbDimShift = aDimCbShift; |
| pHcr->tableInfo.pCbSign = aSignCb; |
| pHcr->tableInfo.pCbPriority = aCbPriority; |
| pHcr->tableInfo.pLargestAbsVal = aLargestAbsoluteValue; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Set up HCR - must be called before every call to HcrDecoder(). |
| For short block a sorting algorithm is applied to get the SI in the order |
| that HCR could assemble the qsc's as if it is a long block. |
| ----------------------------------------------------------------------------------------------- |
| return: error log |
| -------------------------------------------------------------------------------------------- */ |
| |
| UINT HcrInit(H_HCR_INFO pHcr, |
| CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
| const SamplingRateInfo *pSamplingRateInfo, |
| HANDLE_FDK_BITSTREAM bs) |
| { |
| CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo; |
| SHORT *pNumLinesInSec; |
| UCHAR *pCodeBk; |
| SHORT numSection; |
| SCHAR cb; |
| int numLine; |
| int i; |
| |
| pHcr->decInOut.lengthOfReorderedSpectralData = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfReorderedSpectralData; |
| pHcr->decInOut.lengthOfLongestCodeword = pAacDecoderChannelInfo->pDynData->specificTo.aac.lenOfLongestCodeword; |
| pHcr->decInOut.pQuantizedSpectralCoefficientsBase = pAacDecoderChannelInfo->pSpectralCoefficient; |
| pHcr->decInOut.quantizedSpectralCoefficientsIdx = 0; |
| pHcr->decInOut.pCodebook = pAacDecoderChannelInfo->pDynData->specificTo.aac.aCodeBooks4Hcr; |
| pHcr->decInOut.pNumLineInSect = pAacDecoderChannelInfo->pDynData->specificTo.aac.aNumLineInSec4Hcr; |
| pHcr->decInOut.numSection = pAacDecoderChannelInfo->pDynData->specificTo.aac.numberSection; |
| pHcr->decInOut.errorLog = 0; |
| pHcr->nonPcwSideinfo.pResultBase = SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); |
| |
| FDKsyncCache(bs); |
| pHcr->decInOut.bitstreamIndex = FDKgetBitCnt(bs); |
| |
| if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) /* short block */ |
| { |
| SHORT band; |
| SHORT maxBand; |
| SCHAR group; |
| SCHAR winGroupLen; |
| SCHAR window; |
| SCHAR numUnitInBand; |
| SCHAR cntUnitInBand; |
| SCHAR groupWin; |
| SCHAR cb_prev; |
| |
| UCHAR *pCodeBook; |
| const SHORT *BandOffsets; |
| SCHAR numOfGroups; |
| |
| |
| pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook; /* in */ |
| pNumLinesInSec = pHcr->decInOut.pNumLineInSect; /* out */ |
| pCodeBk = pHcr->decInOut.pCodebook; /* out */ |
| BandOffsets = GetScaleFactorBandOffsets(pIcsInfo, pSamplingRateInfo); /* aux */ |
| numOfGroups = GetWindowGroups(pIcsInfo); |
| |
| numLine = 0; |
| numSection = 0; |
| cb = pCodeBook[0]; |
| cb_prev = pCodeBook[0]; |
| |
| /* convert HCR-sideinfo into a unitwise manner: When the cb changes, a new section starts */ |
| |
| *pCodeBk++ = cb_prev; |
| |
| maxBand = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo); |
| for (band = 0; band < maxBand; band++) { /* from low to high sfbs i.e. from low to high frequencies */ |
| numUnitInBand = ((BandOffsets[band+1] - BandOffsets[band]) >> FOUR_LOG_DIV_TWO_LOG); /* get the number of units in current sfb */ |
| for (cntUnitInBand = numUnitInBand; cntUnitInBand != 0; cntUnitInBand-- ) { /* for every unit in the band */ |
| for (window = 0, group = 0; group < numOfGroups; group++) { |
| winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); |
| for (groupWin = winGroupLen; groupWin != 0; groupWin--, window++) { |
| cb = pCodeBook[group * 16 + band]; |
| if (cb != cb_prev) { |
| #if CHECK_VALID_HCR_INPUT /* short-block 1 of 2 */ |
| errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog ); |
| if (pHcr->decInOut.errorLog != 0 ) { |
| return ( pHcr->decInOut.errorLog ); |
| } |
| #endif |
| *pCodeBk++ = cb; |
| *pNumLinesInSec++ = numLine; |
| numSection++; |
| |
| cb_prev = cb; |
| numLine = LINES_PER_UNIT; |
| } |
| else { |
| numLine += LINES_PER_UNIT; |
| } |
| } |
| } |
| } |
| } |
| |
| numSection++; |
| |
| #if CHECK_VALID_HCR_INPUT /* short-block 2 of 2 */ |
| errDetectorInHcrSideinfoShrt(cb,numLine,&pHcr->decInOut.errorLog ); |
| if ( numSection <= 0 || numSection > 1024/2 ) { |
| pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_SHORT_BLOCK; |
| } |
| errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword, |
| pHcr->decInOut.lengthOfReorderedSpectralData, |
| &pHcr->decInOut.errorLog); |
| if (pHcr->decInOut.errorLog != 0 ) { |
| return ( pHcr->decInOut.errorLog ); |
| } |
| #endif |
| |
| *pCodeBk = cb; |
| *pNumLinesInSec = numLine; |
| pHcr->decInOut.numSection = numSection; |
| |
| } else /* end short block prepare SI */ |
| { /* long block */ |
| #if CHECK_VALID_HCR_INPUT /* long-block 1 of 1 */ |
| errDetectorInHcrLengths(pHcr->decInOut.lengthOfLongestCodeword, |
| pHcr->decInOut.lengthOfReorderedSpectralData, |
| &pHcr->decInOut.errorLog); |
| numSection = pHcr->decInOut.numSection; |
| pNumLinesInSec = pHcr->decInOut.pNumLineInSect; |
| pCodeBk = pHcr->decInOut.pCodebook; |
| if ( numSection <= 0 || numSection > 64 ) { |
| pHcr->decInOut.errorLog |= NUM_SECT_OUT_OF_RANGE_LONG_BLOCK; |
| numSection = 0; |
| } |
| |
| for ( i = numSection; i != 0; i-- ) |
| { |
| cb = *pCodeBk++; |
| |
| if ( cb < ZERO_HCB || cb >= MAX_CB_CHECK || cb == BOOKSCL ) { |
| pHcr->decInOut.errorLog |= CB_OUT_OF_RANGE_LONG_BLOCK; |
| } |
| |
| numLine = *pNumLinesInSec++; |
| /* FDK_ASSERT(numLine > 0); */ |
| |
| if ( (numLine <= 0) || (numLine > 1024) ) { |
| pHcr->decInOut.errorLog |= LINE_IN_SECT_OUT_OF_RANGE_LONG_BLOCK; |
| } |
| } |
| if (pHcr->decInOut.errorLog != 0 ) { |
| return ( pHcr->decInOut.errorLog ); |
| } |
| #endif /* CHECK_VALID_HCR_INPUT */ |
| } |
| |
| pCodeBk = pHcr->decInOut.pCodebook; |
| for ( i = 0; i < numSection; i++ ) { |
| if ( |
| (*pCodeBk == NOISE_HCB) || |
| (*pCodeBk == INTENSITY_HCB2) || |
| (*pCodeBk == INTENSITY_HCB)) |
| { |
| *pCodeBk = 0; |
| } |
| pCodeBk++; |
| } |
| |
| /* HCR-sideinfo-input is complete and seems to be valid */ |
| |
| |
| |
| return ( pHcr->decInOut.errorLog ); |
| } |
| |
| |
| |
| |
| #if USE_HCR_DUMMY |
| |
| /*--------------------------------------------------------------------------------------------- |
| |
| description: This HCR - dummy - function writes only a dirac-sequence in output buffer |
| |
| -------------------------------------------------------------------------------------------- */ |
| UINT HcrDecoder(H_HCR_INFO pHcr, |
| const CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
| HANDLE_FDK_BITSTREAM bs) |
| { |
| for (SHORT i=0; i < 1024; i++ ) { |
| pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = FL2FXCONST_DBL(0.0f); |
| if ( i % 30 == 0) { |
| pHcr->decInOut.pQuantizedSpectralCoefficients->Long[i] = (FIXP_DBL)HCR_DIRAC; |
| } |
| } |
| return 0; |
| } |
| |
| #else /* USE_HCR_DUMMY */ |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function decodes the codewords of the spectral coefficients from the |
| bitstream according to the HCR algorithm and stores the quantized spectral |
| coefficients in correct order in the output buffer. |
| -------------------------------------------------------------------------------------------- */ |
| |
| UINT HcrDecoder(H_HCR_INFO pHcr, |
| CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
| const SamplingRateInfo *pSamplingRateInfo, |
| HANDLE_FDK_BITSTREAM bs) |
| { |
| int pTmp1, pTmp2, pTmp3, pTmp4; |
| #if DETECT_TOO_LONG_CW_READS |
| int pTmp5; |
| #endif |
| |
| INT bitCntOffst; |
| UINT saveBitCnt = FDKgetBitCnt(bs); /* save bitstream position */ |
| |
| HcrCalcNumCodeword(pHcr); |
| |
| HcrSortCodebookAndNumCodewordInSection(pHcr); |
| |
| HcrPrepareSegmentationGrid(pHcr); |
| |
| HcrExtendedSectionInfo(pHcr); |
| |
| if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) != 0 ) { |
| return ( pHcr->decInOut.errorLog ); /* sideinfo is massively corrupt, return from HCR without having decoded anything */ |
| } |
| |
| DeriveNumberOfExtendedSortedSectionsInSets(pHcr->segmentInfo.numSegment, |
| pHcr->sectionInfo.pNumExtendedSortedCodewordInSection, |
| pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx, |
| pHcr->sectionInfo.pNumExtendedSortedSectionsInSets, |
| pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx); |
| |
| /* store */ |
| pTmp1 = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx; |
| pTmp2 = pHcr->sectionInfo.extendedSortedCodebookIdx; |
| pTmp3 = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx; |
| pTmp4 = pHcr->decInOut.quantizedSpectralCoefficientsIdx; |
| #if DETECT_TOO_LONG_CW_READS |
| pTmp5 = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx; |
| #endif |
| |
| /* ------- decode meaningful PCWs ------ */ |
| DecodePCWs(bs, pHcr); |
| |
| if (( pHcr->decInOut.errorLog & HCR_FATAL_PCW_ERROR_MASK ) == 0 ) { |
| /* ------ decode the non-PCWs -------- */ |
| DecodeNonPCWs(bs, pHcr); |
| } |
| |
| |
| #if CHECK_SEGMENTATION_FINAL |
| errDetectWithinSegmentationFinal(pHcr); |
| #endif |
| |
| /* restore */ |
| pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = pTmp1; |
| pHcr->sectionInfo.extendedSortedCodebookIdx = pTmp2; |
| pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = pTmp3; |
| pHcr->decInOut.quantizedSpectralCoefficientsIdx = pTmp4; |
| #if DETECT_TOO_LONG_CW_READS |
| pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = pTmp5; |
| #endif |
| |
| HcrReorderQuantizedSpectralCoefficients(pHcr, pAacDecoderChannelInfo, pSamplingRateInfo); |
| |
| /* restore bitstream position */ |
| bitCntOffst = saveBitCnt - FDKgetBitCnt(bs); |
| if( bitCntOffst ) { |
| FDKpushBiDirectional(bs, bitCntOffst); |
| } |
| |
| return ( pHcr->decInOut.errorLog ); |
| } |
| |
| |
| #endif /* USE_HCR_DUMMY */ |
| |
| |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function reorders the quantized spectral coefficients sectionwise for |
| long- and short-blocks and compares to the LAV (Largest Absolute Value of |
| the current codebook) -- a counter is incremented if there is an error |
| detected. |
| Additional for short-blocks a unit-based-deinterleaving is applied. |
| Moreover (for short blocks) the scaling is derived (compare plain huffman |
| decoder). |
| -------------------------------------------------------------------------------------------- */ |
| |
| static void HcrReorderQuantizedSpectralCoefficients( |
| H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
| const SamplingRateInfo *pSamplingRateInfo |
| ) |
| { |
| INT qsc; |
| UINT abs_qsc; |
| UINT i,j; |
| USHORT numSpectralValuesInSection; |
| FIXP_DBL *pTeVa; |
| USHORT lavErrorCnt = 0; |
| |
| UINT numSection = pHcr->decInOut.numSection; |
| SPECTRAL_PTR pQuantizedSpectralCoefficientsBase = pHcr->decInOut.pQuantizedSpectralCoefficientsBase; |
| FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase); |
| const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; |
| const USHORT *pLargestAbsVal = pHcr->tableInfo.pLargestAbsVal; |
| UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; |
| USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; |
| USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset; |
| FIXP_DBL *pTempValues = pHcr->segmentInfo.pTempValues; |
| FIXP_DBL *pBak = pHcr->segmentInfo.pTempValues; |
| |
| FDKmemclear(pTempValues,1024*sizeof(FIXP_DBL)); |
| |
| /* long and short: check if decoded huffman-values (quantized spectral coefficients) are within range */ |
| for ( i=numSection; i != 0; i-- ) { |
| numSpectralValuesInSection = *pNumSortedCodewordInSection++ << pCbDimShift[*pSortedCodebook]; |
| pTeVa = &pTempValues[*pReorderOffset++]; |
| for( j = numSpectralValuesInSection; j != 0; j-- ) { |
| qsc = *pQuantizedSpectralCoefficients++; |
| abs_qsc = FDKabs(qsc); |
| #if VALID_LAV_ERROR_TRIGGER |
| if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) { |
| *pTeVa++ = (FIXP_DBL)qsc; /* the qsc value is within range */ |
| } |
| else { /* line is too high .. */ |
| if ( abs_qsc == Q_VALUE_INVALID ) { /* .. because of previous marking --> dont set LAV flag (would be confusing), just copy out the already marked value */ |
| *pTeVa++ = (FIXP_DBL) qsc; |
| } |
| else { /* .. because a too high value was decoded for this cb --> set LAV flag */ |
| *pTeVa++ = (FIXP_DBL) Q_VALUE_INVALID; |
| lavErrorCnt += 1; |
| } |
| } |
| #else |
| if ( abs_qsc <= pLargestAbsVal[*pSortedCodebook] ) { |
| *pTeVa++ = qsc; |
| } |
| else { |
| *pTeVa++ = Q_VALUE_INVALID; |
| lavErrorCnt += 1; |
| } |
| #endif |
| } |
| pSortedCodebook++; |
| } |
| |
| if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) |
| { |
| FIXP_DBL *pOut; |
| FIXP_DBL locMax; |
| FIXP_DBL tmp; |
| SCHAR groupoffset; |
| SCHAR group; |
| SCHAR band; |
| SCHAR groupwin; |
| SCHAR window; |
| SCHAR numWinGroup; |
| SHORT interm; |
| SCHAR numSfbTransm; |
| SCHAR winGroupLen; |
| SHORT index; |
| INT msb; |
| INT lsb; |
| |
| SHORT *pScaleFacHcr = pAacDecoderChannelInfo->pDynData->aScaleFactor; |
| SHORT *pSfbSclHcr = pAacDecoderChannelInfo->pDynData->aSfbScale; |
| const SHORT *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->icsInfo, pSamplingRateInfo); |
| |
| pBak = pHcr->segmentInfo.pTempValues; |
| /* deinterleave unitwise for short blocks */ |
| for ( window = 0; window < (8); window++ ) { |
| pOut = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength); |
| for ( i=0; i < (LINES_PER_UNIT_GROUP); i++ ) { |
| pTeVa = pBak + (window << FOUR_LOG_DIV_TWO_LOG) + i * 32; /* distance of lines between unit groups has to be constant for every framelength (32)! */ |
| for ( j=(LINES_PER_UNIT); j != 0; j-- ) { |
| *pOut++ = *pTeVa++; |
| } |
| } |
| } |
| |
| /* short blocks only */ |
| /* derive global scaling-value for every sfb and every window (as it is done in plain-huffman-decoder at short blocks) */ |
| groupoffset = 0; |
| |
| numWinGroup = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo); |
| numSfbTransm = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo); |
| |
| for (group = 0; group < numWinGroup; group++) { |
| winGroupLen = GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); |
| for (band = 0; band < numSfbTransm; band++) { |
| interm = group * 16 + band; |
| msb = pScaleFacHcr[interm] >> 2; |
| lsb = pScaleFacHcr[interm] & 3; |
| for (groupwin = 0; groupwin < winGroupLen; groupwin++) { |
| window = groupoffset + groupwin; |
| pBak = SPEC(pQuantizedSpectralCoefficientsBase, window, pAacDecoderChannelInfo->granuleLength); |
| locMax = FL2FXCONST_DBL(0.0f); |
| for (index = BandOffsets[band]; index < BandOffsets[band+1]; index += LINES_PER_UNIT) { |
| pTeVa = &pBak[index]; |
| for ( i = LINES_PER_UNIT; i != 0; i --) { |
| tmp = (*pTeVa < FL2FXCONST_DBL(0.0f))? -*pTeVa++ : *pTeVa++; |
| locMax = fixMax(tmp,locMax); |
| } |
| } |
| if ( fixp_abs(locMax) > (FIXP_DBL)MAX_QUANTIZED_VALUE ) { |
| locMax = (FIXP_DBL)MAX_QUANTIZED_VALUE; |
| } |
| pSfbSclHcr[window*16+band] = msb - GetScaleFromValue(locMax, lsb); /* save global scale maxima in this sfb */ |
| } |
| } |
| groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->icsInfo,group); |
| } |
| } else |
| { |
| /* copy straight for long-blocks */ |
| pQuantizedSpectralCoefficients = SPEC_LONG(pQuantizedSpectralCoefficientsBase); |
| for ( i = 1024; i != 0; i-- ) { |
| *pQuantizedSpectralCoefficients++ = *pBak++; |
| } |
| } |
| |
| if ( lavErrorCnt != 0 ) { |
| pHcr->decInOut.errorLog |= LAV_VIOLATION; |
| } |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function calculates the number of codewords |
| for each section (numCodewordInSection) and the number of codewords |
| for all sections (numCodeword). |
| For zero and intensity codebooks a entry is also done in the variable |
| numCodewordInSection. It is assumed that the codebook is a two tuples |
| codebook. This is needed later for the calculation of the base addresses |
| for the reordering of the quantize spectral coefficients at the end of the |
| hcr tool. |
| The variable numCodeword contain the number of codewords which are really |
| in the bitstream. Zero or intensity codebooks does not increase the |
| variable numCodewords. |
| ----------------------------------------------------------------------------------------------- |
| return: - |
| -------------------------------------------------------------------------------------------- */ |
| |
| static void HcrCalcNumCodeword(H_HCR_INFO pHcr) |
| { |
| int hcrSection; |
| UINT numCodeword; |
| |
| UINT numSection = pHcr->decInOut.numSection; |
| UCHAR *pCodebook = pHcr->decInOut.pCodebook; |
| SHORT *pNumLineInSection = pHcr->decInOut.pNumLineInSect; |
| const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; |
| USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection; |
| |
| numCodeword = 0; |
| for ( hcrSection = numSection; hcrSection != 0; hcrSection-- ) { |
| *pNumCodewordInSection = *pNumLineInSection++ >> pCbDimShift[*pCodebook]; |
| if ( *pCodebook != 0 ) { |
| numCodeword += *pNumCodewordInSection; |
| } |
| pNumCodewordInSection++; |
| pCodebook++; |
| } |
| pHcr->sectionInfo.numCodeword = numCodeword; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function calculates the number |
| of sorted codebooks and sorts the codebooks and the numCodewordInSection |
| according to the priority. |
| -------------------------------------------------------------------------------------------- */ |
| |
| static void HcrSortCodebookAndNumCodewordInSection(H_HCR_INFO pHcr) |
| { |
| |
| UINT i,j,k; |
| UCHAR temp; |
| UINT counter; |
| UINT startOffset; |
| UINT numZeroSection; |
| UCHAR *pDest; |
| UINT numSectionDec; |
| |
| UINT numSection = pHcr->decInOut.numSection; |
| UCHAR *pCodebook = pHcr->decInOut.pCodebook; |
| UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; |
| USHORT *pNumCodewordInSection = pHcr->sectionInfo.pNumCodewordInSection; |
| USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; |
| UCHAR *pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch; |
| USHORT *pReorderOffset = pHcr->sectionInfo.pReorderOffset; |
| const UCHAR *pCbPriority = pHcr->tableInfo.pCbPriority; |
| const UCHAR *pMinOfCbPair = pHcr->cbPairs.pMinOfCbPair; |
| const UCHAR *pMaxOfCbPair = pHcr->cbPairs.pMaxOfCbPair; |
| const UCHAR *pCbDimShift = pHcr->tableInfo.pCbDimShift; |
| |
| UINT searchStart = 0; |
| |
| /* calculate *pNumSortedSection and store the priorities in array pSortedCdebook */ |
| pDest = pSortedCodebook; |
| numZeroSection = 0; |
| for ( i=numSection; i != 0; i-- ) { |
| if ( pCbPriority[*pCodebook] == 0 ) { |
| numZeroSection += 1; |
| } |
| *pDest++ = pCbPriority[*pCodebook++]; |
| } |
| pHcr->sectionInfo.numSortedSection = numSection - numZeroSection; /* numSortedSection contains no zero or intensity section */ |
| pCodebook = pHcr->decInOut.pCodebook; |
| |
| /* sort priorities of the codebooks in array pSortedCdebook[] */ |
| numSectionDec = numSection - 1; |
| if ( numSectionDec > 0 ) { |
| counter = numSectionDec; |
| for ( j=numSectionDec; j != 0; j-- ) { |
| for ( i=0; i < counter; i++ ) { |
| /* swap priorities */ |
| if ( pSortedCodebook[i+1] > pSortedCodebook[i] ) { |
| temp = pSortedCodebook[i]; |
| pSortedCodebook[i] = pSortedCodebook[i+1]; |
| pSortedCodebook[i+1] = temp; |
| } |
| } |
| counter -= 1; |
| } |
| } |
| |
| /* clear codebookSwitch array */ |
| for ( i = numSection; i != 0; i--) { |
| *pCodebookSwitch++ = 0; |
| } |
| pCodebookSwitch = pHcr->sectionInfo.pCodebookSwitch; |
| |
| /* sort sectionCodebooks and numCodwordsInSection and calculate pReorderOffst[j] */ |
| for ( j = 0; j < numSection; j++ ) { |
| for ( i = searchStart; i < numSection; i++ ) { |
| if ( pCodebookSwitch[i] == 0 && ( pMinOfCbPair[pSortedCodebook[j]] == pCodebook[i] || pMaxOfCbPair[pSortedCodebook[j]] == pCodebook[i] )) { |
| pCodebookSwitch[i] = 1; |
| pSortedCodebook[j] = pCodebook[i]; /* sort codebook */ |
| pNumSortedCodewordInSection[j] = pNumCodewordInSection[i]; /* sort NumCodewordInSection */ |
| |
| startOffset = 0; |
| for ( k = 0; k < i; k++ ) { /* make entry in pReorderOffst */ |
| startOffset += pNumCodewordInSection[k] << pCbDimShift[pCodebook[k]]; |
| } |
| pReorderOffset[j] = startOffset; /* offset for reordering the codewords */ |
| |
| if(i == searchStart) { |
| UINT k = i; |
| while(pCodebookSwitch[k++] == 1) searchStart++; |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function calculates the segmentation, which includes numSegment, |
| leftStartOfSegment, rightStartOfSegment and remainingBitsInSegment. |
| The segmentation could be visualized a as kind of 'overlay-grid' for the |
| bitstream-block holding the HCR-encoded quantized-spectral-coefficients. |
| -------------------------------------------------------------------------------------------- */ |
| |
| static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) |
| { |
| USHORT i,j; |
| USHORT numSegment = 0; |
| USHORT segmentStart = 0; |
| UCHAR segmentWidth; |
| UCHAR lastSegmentWidth; |
| UCHAR sortedCodebook; |
| UCHAR endFlag = 0; |
| USHORT intermediateResult; |
| |
| SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword; |
| SHORT lengthOfReorderedSpectralData = pHcr->decInOut.lengthOfReorderedSpectralData; |
| UINT numSortedSection = pHcr->sectionInfo.numSortedSection; |
| UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; |
| USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; |
| USHORT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; |
| USHORT *pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; |
| SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; |
| USHORT bitstreamIndex = pHcr->decInOut.bitstreamIndex; |
| const UCHAR *pMaxCwLength = pHcr->tableInfo.pMaxCwLength; |
| |
| for ( i=numSortedSection; i != 0; i-- ) { |
| sortedCodebook = *pSortedCodebook++; |
| segmentWidth = FDKmin(pMaxCwLength[sortedCodebook],lengthOfLongestCodeword); |
| |
| for ( j = *pNumSortedCodewordInSection; j != 0 ; j-- ) { |
| /* width allows a new segment */ |
| intermediateResult = bitstreamIndex + segmentStart; |
| if ( (segmentStart + segmentWidth) <= lengthOfReorderedSpectralData ) { |
| /* store segment start, segment length and increment the number of segments */ |
| *pLeftStartOfSegment++ = intermediateResult; |
| *pRightStartOfSegment++ = intermediateResult + segmentWidth - 1; |
| *pRemainingBitsInSegment++ = segmentWidth; |
| segmentStart += segmentWidth; |
| numSegment += 1; |
| } |
| /* width does not allow a new segment */ |
| else { |
| /* correct the last segment length */ |
| pLeftStartOfSegment--; |
| pRightStartOfSegment--; |
| pRemainingBitsInSegment--; |
| segmentStart = *pLeftStartOfSegment - bitstreamIndex; |
| |
| lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart; |
| *pRemainingBitsInSegment = lastSegmentWidth; |
| *pRightStartOfSegment = bitstreamIndex + segmentStart + lastSegmentWidth - 1; |
| endFlag = 1; |
| break; |
| } |
| } |
| pNumSortedCodewordInSection++; |
| if (endFlag != 0) { |
| break; |
| } |
| } |
| pHcr->segmentInfo.numSegment = numSegment; |
| |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function adapts the sorted section boundaries to the boundaries of |
| segmentation. If the section lengths does not fit completely into the |
| current segment, the section is spitted into two so called 'extended |
| sections'. The extended-section-info (pNumExtendedSortedCodewordInSectin |
| and pExtendedSortedCodebook) is updated in this case. |
| |
| -------------------------------------------------------------------------------------------- */ |
| |
| static void HcrExtendedSectionInfo(H_HCR_INFO pHcr) |
| { |
| UINT srtSecCnt = 0; /* counter for sorted sections */ |
| UINT xSrtScCnt = 0; /* counter for extended sorted sections */ |
| UINT remainNumCwInSortSec; |
| UINT inSegmentRemainNumCW; |
| |
| UINT numSortedSection = pHcr->sectionInfo.numSortedSection; |
| UCHAR *pSortedCodebook = pHcr->sectionInfo.pSortedCodebook; |
| USHORT *pNumSortedCodewordInSection = pHcr->sectionInfo.pNumSortedCodewordInSection; |
| UCHAR *pExtendedSortedCoBo = pHcr->sectionInfo.pExtendedSortedCodebook; |
| USHORT *pNumExtSortCwInSect = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection; |
| UINT numSegment = pHcr->segmentInfo.numSegment; |
| #if DETECT_TOO_LONG_CW_READS |
| UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec; |
| SCHAR lengthOfLongestCodeword = pHcr->decInOut.lengthOfLongestCodeword; |
| const UCHAR *pMaxCwLength = pHcr->tableInfo.pMaxCwLength; |
| #endif |
| |
| remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; |
| inSegmentRemainNumCW = numSegment; |
| |
| while (srtSecCnt < numSortedSection) { |
| if (inSegmentRemainNumCW < remainNumCwInSortSec) { |
| |
| pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW; |
| pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; |
| |
| remainNumCwInSortSec -= inSegmentRemainNumCW; |
| inSegmentRemainNumCW = numSegment; |
| /* data of a sorted section was not integrated in extended sorted section */ |
| } |
| else if (inSegmentRemainNumCW == remainNumCwInSortSec) { |
| pNumExtSortCwInSect[xSrtScCnt] = inSegmentRemainNumCW; |
| pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; |
| |
| srtSecCnt++; |
| remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; |
| inSegmentRemainNumCW = numSegment; |
| /* data of a sorted section was integrated in extended sorted section */ |
| } |
| else { /* inSegmentRemainNumCW > remainNumCwInSortSec */ |
| pNumExtSortCwInSect[xSrtScCnt] = remainNumCwInSortSec; |
| pExtendedSortedCoBo[xSrtScCnt] = pSortedCodebook[srtSecCnt]; |
| |
| |
| inSegmentRemainNumCW -= remainNumCwInSortSec; |
| srtSecCnt++; |
| remainNumCwInSortSec = pNumSortedCodewordInSection[srtSecCnt]; |
| /* data of a sorted section was integrated in extended sorted section */ |
| } |
| #if DETECT_TOO_LONG_CW_READS |
| pMaxLenOfCbInExtSrtSec[xSrtScCnt] = FDKmin(pMaxCwLength[pExtendedSortedCoBo[xSrtScCnt]],lengthOfLongestCodeword); |
| #endif |
| |
| |
| |
| xSrtScCnt += 1; |
| |
| if ( xSrtScCnt >= (MAX_SFB_HCR + MAX_HCR_SETS) ) { |
| pHcr->decInOut.errorLog |= EXTENDED_SORTED_COUNTER_OVERFLOW; |
| return; |
| } |
| |
| } |
| pNumExtSortCwInSect[xSrtScCnt] = 0; |
| |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function calculates the number of extended sorted sections which |
| belong to the sets. Each set from set 0 (one and only set for the PCWs) |
| till to the last set gets a entry in the array to which |
| 'pNumExtendedSortedSectinsInSets' points to. |
| |
| Calculation: The entrys in pNumExtendedSortedCodewordInSectin are added |
| untill the value numSegment is reached. Then the sum_variable is cleared |
| and the calculation starts from the beginning. As much extended sorted |
| Sections are summed up to reach the value numSegment, as much is the |
| current entry in *pNumExtendedSortedCodewordInSectin. |
| -------------------------------------------------------------------------------------------- */ |
| static void DeriveNumberOfExtendedSortedSectionsInSets(UINT numSegment, |
| USHORT *pNumExtendedSortedCodewordInSection, |
| int numExtendedSortedCodewordInSectionIdx, |
| USHORT *pNumExtendedSortedSectionsInSets, |
| int numExtendedSortedSectionsInSetsIdx) |
| { |
| USHORT counter = 0; |
| UINT cwSum = 0; |
| USHORT *pNumExSortCwInSec = pNumExtendedSortedCodewordInSection; |
| USHORT *pNumExSortSecInSets = pNumExtendedSortedSectionsInSets; |
| |
| while (pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx] != 0) |
| { |
| cwSum += pNumExSortCwInSec[numExtendedSortedCodewordInSectionIdx]; |
| numExtendedSortedCodewordInSectionIdx++; |
| if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { |
| return; |
| } |
| if (cwSum > numSegment) { |
| return; |
| } |
| counter++; |
| if (counter > 1024/4) { |
| return; |
| } |
| if ( cwSum == numSegment ) { |
| pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter; |
| numExtendedSortedSectionsInSetsIdx++; |
| if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) { |
| return; |
| } |
| counter = 0; |
| cwSum = 0; |
| } |
| } |
| pNumExSortSecInSets[numExtendedSortedSectionsInSetsIdx] = counter; /* save last entry for the last - probably shorter - set */ |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function decodes all priority codewords (PCWs) in a spectrum (within |
| set 0). The calculation of the PCWs is managed in two loops. The |
| loopcounter of the outer loop is set to the first value pointer |
| pNumExtendedSortedSectionsInSets points to. This value represents the |
| number of extended sorted sections within set 0. |
| The loopcounter of the inner loop is set to the first value pointer |
| pNumExtendedSortedCodewordInSectin points to. The value represents the |
| number of extended sorted codewords in sections (the original sections have |
| been splitted to go along with the borders of the sets). |
| Each time the number of the extended sorted codewords in sections are de- |
| coded, the pointer 'pNumExtendedSortedCodewordInSectin' is incremented by |
| one. |
| -------------------------------------------------------------------------------------------- */ |
| static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) |
| { |
| UINT i; |
| USHORT extSortSec; |
| USHORT curExtSortCwInSec; |
| UCHAR codebook; |
| UCHAR dimension; |
| const UINT *pCurrentTree; |
| const SCHAR *pQuantValBase; |
| const SCHAR *pQuantVal; |
| |
| USHORT *pNumExtendedSortedCodewordInSection = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection; |
| int numExtendedSortedCodewordInSectionIdx = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx; |
| UCHAR *pExtendedSortedCodebook = pHcr->sectionInfo.pExtendedSortedCodebook; |
| int extendedSortedCodebookIdx = pHcr->sectionInfo.extendedSortedCodebookIdx; |
| USHORT *pNumExtendedSortedSectionsInSets = pHcr->sectionInfo.pNumExtendedSortedSectionsInSets; |
| int numExtendedSortedSectionsInSetsIdx = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx; |
| FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase); |
| int quantizedSpectralCoefficientsIdx = pHcr->decInOut.quantizedSpectralCoefficientsIdx; |
| USHORT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; |
| SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; |
| #if DETECT_TOO_LONG_CW_READS |
| UCHAR *pMaxLenOfCbInExtSrtSec = pHcr->sectionInfo.pMaxLenOfCbInExtSrtSec; |
| int maxLenOfCbInExtSrtSecIdx = pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx; |
| UCHAR maxAllowedCwLen; |
| int numDecodedBits; |
| #endif |
| const UCHAR *pCbDimension = pHcr->tableInfo.pCbDimension; |
| const UCHAR *pCbSign = pHcr->tableInfo.pCbSign; |
| |
| /* clear result array */ |
| //pQSC = &pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]; |
| //pQSC = *pQuantizedSpectralCoefficients; |
| |
| FDKmemclear(pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx,1024*sizeof(FIXP_DBL)); |
| |
| /* decode all PCWs in the extended sorted section(s) belonging to set 0 */ |
| for ( extSortSec = pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx]; extSortSec != 0; extSortSec-- ) { |
| |
| codebook = pExtendedSortedCodebook[extendedSortedCodebookIdx]; /* get codebook for this extended sorted section and increment ptr to cb of next ext. sort sec */ |
| extendedSortedCodebookIdx++; |
| if (extendedSortedCodebookIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { |
| return; |
| } |
| dimension = pCbDimension[codebook]; /* get dimension of codebook of this extended sort. sec. */ |
| pCurrentTree = aHuffTable [codebook]; /* convert codebook to pointer to QSCs */ |
| pQuantValBase = aQuantTable [codebook]; /* convert codebook to index to table of QSCs */ |
| #if DETECT_TOO_LONG_CW_READS |
| maxAllowedCwLen = pMaxLenOfCbInExtSrtSec[maxLenOfCbInExtSrtSecIdx]; |
| maxLenOfCbInExtSrtSecIdx++; |
| if (maxLenOfCbInExtSrtSecIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { |
| return; |
| } |
| #endif |
| |
| /* switch for decoding with different codebooks: */ |
| if ( pCbSign[codebook] == 0 ) { /* no sign bits follow after the codeword-body */ |
| /* PCW_BodyONLY */ |
| /*==============*/ |
| |
| for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) { |
| numDecodedBits = 0; |
| |
| /* decode PCW_BODY */ |
| pQuantVal = DecodePCW_Body(bs, |
| pCurrentTree, |
| pQuantValBase, |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| |
| /* result is written out here because NO sign bits follow the body */ |
| for( i=dimension; i != 0 ; i-- ) { |
| pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) *pQuantVal++; /* write quant. spec. coef. into spectrum; sign is already valid */ |
| quantizedSpectralCoefficientsIdx++; |
| if (quantizedSpectralCoefficientsIdx >= 1024) { |
| return; |
| } |
| } |
| |
| /* one more PCW should be decoded */ |
| |
| #if DETECT_TOO_LONG_CW_READS |
| if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_ONLY_TOO_LONG) ) { |
| pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_BITS_DECODED; |
| } |
| #endif |
| |
| #if CHECK_SEGMENTATION_IMMEDIATELY |
| if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY,pHcr,PCW_BODY,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) { |
| return; |
| } |
| #endif |
| pLeftStartOfSegment++; /* update pointer for decoding the next PCW */ |
| pRemainingBitsInSegment++; /* update pointer for decoding the next PCW */ |
| } |
| } |
| else if (( pCbSign[codebook] == 1 ) && ( codebook < 11 )) { /* possibly there follow 1,2,3 or 4 sign bits after the codeword-body */ |
| /* PCW_Body and PCW_Sign */ |
| /*=======================*/ |
| |
| for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) |
| { |
| int err; |
| numDecodedBits = 0; |
| |
| pQuantVal = DecodePCW_Body(bs, |
| pCurrentTree, |
| pQuantValBase, |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| |
| err = DecodePCW_Sign( bs, |
| dimension, |
| pQuantVal, |
| pQuantizedSpectralCoefficients, |
| &quantizedSpectralCoefficientsIdx, |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| if (err != 0) { |
| return; |
| } |
| /* one more PCW should be decoded */ |
| |
| #if DETECT_TOO_LONG_CW_READS |
| if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_TOO_LONG) ) { |
| pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_BITS_DECODED; |
| } |
| #endif |
| |
| #if CHECK_SEGMENTATION_IMMEDIATELY |
| if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN,pHcr,PCW_BODY_SIGN, pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-dimension,dimension)) { |
| return; |
| } |
| #endif |
| pLeftStartOfSegment++; |
| pRemainingBitsInSegment++; |
| } |
| } |
| else if (( pCbSign[codebook] == 1 ) && ( codebook >= 11 )) { /* possibly there follow some sign bits and maybe one or two escape sequences after the cw-body */ |
| /* PCW_Body, PCW_Sign and maybe PCW_Escape */ |
| /*=========================================*/ |
| |
| for ( curExtSortCwInSec = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx] ; curExtSortCwInSec != 0; curExtSortCwInSec--) |
| { |
| int err; |
| numDecodedBits = 0; |
| |
| /* decode PCW_BODY */ |
| pQuantVal = DecodePCW_Body(bs, |
| pCurrentTree, |
| pQuantValBase, |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| |
| err = DecodePCW_Sign( bs, |
| dimension, |
| pQuantVal, |
| pQuantizedSpectralCoefficients, |
| &quantizedSpectralCoefficientsIdx, |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| if (err != 0) { |
| return; |
| } |
| |
| /* decode PCW_ESCAPE if present */ |
| quantizedSpectralCoefficientsIdx -= DIMENSION_OF_ESCAPE_CODEBOOK; |
| |
| if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) { |
| pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs, |
| pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx], |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| } |
| quantizedSpectralCoefficientsIdx++; |
| if (quantizedSpectralCoefficientsIdx >= 1024) { |
| return; |
| } |
| |
| if ( fixp_abs(pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx]) == (FIXP_DBL)ESCAPE_VALUE ) { |
| pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = (FIXP_DBL) DecodeEscapeSequence( bs, |
| pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx], |
| pLeftStartOfSegment, |
| pRemainingBitsInSegment, |
| &numDecodedBits |
| ); |
| } |
| quantizedSpectralCoefficientsIdx++; |
| if (quantizedSpectralCoefficientsIdx >= 1024) { |
| return; |
| } |
| |
| /* one more PCW should be decoded */ |
| |
| #if DETECT_TOO_LONG_CW_READS |
| if ( maxAllowedCwLen < (numDecodedBits + ERROR_PCW_BODY_SIGN_ESC_TOO_LONG) ) { |
| pHcr->decInOut.errorLog |= TOO_MANY_PCW_BODY_SIGN_ESC_BITS_DECODED; |
| } |
| #endif |
| |
| #if CHECK_SEGMENTATION_IMMEDIATELY |
| if (1 == errDetectPcwSegmentation(*pRemainingBitsInSegment-ERROR_PCW_BODY_SIGN_ESC,pHcr,PCW_BODY_SIGN_ESC,pQuantizedSpectralCoefficients+quantizedSpectralCoefficientsIdx-DIMENSION_OF_ESCAPE_CODEBOOK,DIMENSION_OF_ESCAPE_CODEBOOK)) { |
| return; |
| } |
| #endif |
| pLeftStartOfSegment++; |
| pRemainingBitsInSegment++; |
| } |
| } |
| |
| /* all PCWs belonging to this extended section should be decoded */ |
| numExtendedSortedCodewordInSectionIdx++; |
| if (numExtendedSortedCodewordInSectionIdx >= MAX_SFB_HCR+MAX_HCR_SETS) { |
| return; |
| } |
| } |
| /* all PCWs should be decoded */ |
| |
| numExtendedSortedSectionsInSetsIdx++; |
| if (numExtendedSortedSectionsInSetsIdx >= MAX_HCR_SETS) { |
| return; |
| } |
| |
| /* Write back indexes into structure */ |
| pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx; |
| pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx; |
| pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx; |
| pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx; |
| pHcr->sectionInfo.maxLenOfCbInExtSrtSecIdx = maxLenOfCbInExtSrtSecIdx; |
| } |
| |
| #if CHECK_SEGMENTATION_IMMEDIATELY |
| /*--------------------------------------------------------------------------------------------- |
| description: This function checks immediately after every decoded PCW, whether out of |
| the current segment too many bits have been read or not. If an error occurrs, |
| probably the sideinfo or the HCR-bitstream block holding the huffman |
| encoded quantized spectral coefficients is distorted. In this case the two |
| or four quantized spectral coefficients belonging to the current codeword |
| are marked (for being detected by concealment later). |
| -------------------------------------------------------------------------------------------- */ |
| static UCHAR errDetectPcwSegmentation(SCHAR remainingBitsInSegment, |
| H_HCR_INFO pHcr, |
| PCW_TYPE kind, |
| FIXP_DBL *qsc_base_of_cw, |
| UCHAR dimension) |
| { |
| SCHAR i; |
| if ( remainingBitsInSegment < 0 ) { |
| /* log the error */ |
| switch (kind) { |
| case PCW_BODY: |
| pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY; |
| break; |
| case PCW_BODY_SIGN: |
| pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN; |
| break; |
| case PCW_BODY_SIGN_ESC: |
| pHcr->decInOut.errorLog |= SEGMENT_OVERRIDE_ERR_PCW_BODY_SIGN_ESC; |
| break; |
| } |
| /* mark the erred lines */ |
| for ( i = dimension; i != 0; i-- ) { |
| *qsc_base_of_cw++ = (FIXP_DBL) Q_VALUE_INVALID; |
| } |
| return 1; |
| } |
| return 0; |
| } |
| #endif |
| |
| #if CHECK_SEGMENTATION_FINAL |
| /*--------------------------------------------------------------------------------------------- |
| description: This function checks if all segments are empty after decoding. There |
| are _no lines markded_ as invalid because it could not be traced back |
| where from the remaining bits are. |
| -------------------------------------------------------------------------------------------- */ |
| static void errDetectWithinSegmentationFinal(H_HCR_INFO pHcr) |
| { |
| UCHAR segmentationErrorFlag = 0; |
| USHORT i; |
| SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; |
| UINT numSegment = pHcr->segmentInfo.numSegment; |
| |
| for ( i=numSegment; i != 0 ; i--) { |
| if (*pRemainingBitsInSegment++ != 0) { |
| segmentationErrorFlag = 1; |
| } |
| } |
| if (segmentationErrorFlag == 1) { |
| pHcr->decInOut.errorLog |= BIT_IN_SEGMENTATION_ERROR; |
| } |
| } |
| #endif |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function walks one step within the decoding tree. Which branch is |
| taken depends on the decoded carryBit input parameter. |
| -------------------------------------------------------------------------------------------- */ |
| void CarryBitToBranchValue(UCHAR carryBit, |
| UINT treeNode, |
| UINT *branchValue, |
| UINT *branchNode) |
| { |
| if (carryBit == 0) { |
| *branchNode = (treeNode & MASK_LEFT) >> LEFT_OFFSET; /* MASK_LEFT: 00FFF000 */ |
| } |
| else { |
| *branchNode = treeNode & MASK_RIGHT; /* MASK_RIGHT: 00000FFF */ |
| } |
| |
| *branchValue = *branchNode & CLR_BIT_10; /* clear bit 10 (if set) */ |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Decodes the body of a priority codeword (PCW) |
| ----------------------------------------------------------------------------------------------- |
| return: - return value is pointer to first of two or four quantized spectral |
| coefficients |
| -------------------------------------------------------------------------------------------- */ |
| static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, |
| const UINT *pCurrentTree, |
| const SCHAR *pQuantValBase, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ) |
| { |
| UCHAR carryBit; |
| UINT branchNode; |
| UINT treeNode; |
| UINT branchValue; |
| const SCHAR *pQuantVal; |
| |
| /* decode PCW_BODY */ |
| treeNode = *pCurrentTree; /* get first node of current tree belonging to current codebook */ |
| |
| /* decode whole PCW-codeword-body */ |
| while (1) { |
| |
| carryBit = HcrGetABitFromBitstream(bs, |
| pLeftStartOfSegment, |
| pLeftStartOfSegment, /* dummy */ |
| FROM_LEFT_TO_RIGHT); |
| *pRemainingBitsInSegment -= 1; |
| *pNumDecodedBits += 1; |
| |
| CarryBitToBranchValue(carryBit, |
| treeNode, |
| &branchValue, |
| &branchNode); |
| |
| if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set --> codeword-body is complete */ |
| break; /* end of branch in tree reached i.e. a whole PCW-Body is decoded */ |
| } |
| else { |
| treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */ |
| } |
| |
| } |
| |
| pQuantVal = pQuantValBase + branchValue; /* update pointer to valid first of 2 or 4 quantized values */ |
| |
| return pQuantVal; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: This function decodes one escape sequence. In case of a escape codebook |
| and in case of the absolute value of the quantized spectral value == 16, |
| a escapeSequence is decoded in two steps: |
| 1. escape prefix |
| 2. escape word |
| -------------------------------------------------------------------------------------------- */ |
| |
| static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, |
| INT quantSpecCoef, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ) |
| { |
| UINT i; |
| INT sign; |
| UINT escapeOnesCounter = 0; |
| UINT carryBit; |
| INT escape_word = 0; |
| |
| /* decode escape prefix */ |
| while (1) { |
| carryBit = HcrGetABitFromBitstream(bs, |
| pLeftStartOfSegment, |
| pLeftStartOfSegment, /* dummy */ |
| FROM_LEFT_TO_RIGHT); |
| *pRemainingBitsInSegment -= 1; |
| *pNumDecodedBits += 1; |
| |
| if (carryBit != 0) { |
| escapeOnesCounter += 1; |
| } |
| else { |
| escapeOnesCounter += 4; |
| break; |
| } |
| } |
| |
| /* decode escape word */ |
| for( i=escapeOnesCounter; i != 0 ; i-- ) { |
| carryBit = HcrGetABitFromBitstream(bs, |
| pLeftStartOfSegment, |
| pLeftStartOfSegment, /* dummy */ |
| FROM_LEFT_TO_RIGHT); |
| *pRemainingBitsInSegment -= 1; |
| *pNumDecodedBits += 1; |
| |
| escape_word <<= 1; |
| escape_word = escape_word | carryBit; |
| } |
| |
| sign = (quantSpecCoef >= 0) ? 1 : -1; |
| |
| quantSpecCoef = sign * (((INT ) 1 << escapeOnesCounter) + escape_word); |
| |
| return quantSpecCoef; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Decodes the Signbits of a priority codeword (PCW) and writes out the |
| resulting quantized spectral values into unsorted sections |
| ----------------------------------------------------------------------------------------------- |
| output: - two or four lines at position in corresponding section (which are not |
| located at the desired position, i.e. they must be reordered in the last |
| of eight function of HCR) |
| ----------------------------------------------------------------------------------------------- |
| return: - updated pQuantSpecCoef pointer (to next empty storage for a line) |
| -------------------------------------------------------------------------------------------- */ |
| static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, |
| UINT codebookDim, |
| const SCHAR *pQuantVal, |
| FIXP_DBL *pQuantSpecCoef, |
| int *quantSpecCoefIdx, |
| USHORT *pLeftStartOfSegment, |
| SCHAR *pRemainingBitsInSegment, |
| int *pNumDecodedBits |
| ) |
| { |
| UINT i; |
| UINT carryBit; |
| INT quantSpecCoef; |
| |
| for( i=codebookDim; i != 0 ; i-- ) { |
| quantSpecCoef = *pQuantVal++; |
| if (quantSpecCoef != 0) { |
| carryBit = HcrGetABitFromBitstream(bs, |
| pLeftStartOfSegment, |
| pLeftStartOfSegment, /* dummy */ |
| FROM_LEFT_TO_RIGHT); |
| *pRemainingBitsInSegment -= 1; |
| *pNumDecodedBits += 1; |
| if (*pRemainingBitsInSegment < 0 || *pNumDecodedBits >= (1024>>1)) { |
| return -1; |
| } |
| |
| /* adapt sign of values according to the decoded sign bit */ |
| if (carryBit != 0) { |
| pQuantSpecCoef[*quantSpecCoefIdx] = -(FIXP_DBL)quantSpecCoef; |
| } |
| else { |
| pQuantSpecCoef[*quantSpecCoefIdx] = (FIXP_DBL)quantSpecCoef; |
| } |
| } |
| else { |
| pQuantSpecCoef[*quantSpecCoefIdx] = FL2FXCONST_DBL(0.0f); |
| } |
| *quantSpecCoefIdx += 1 ; |
| if (*quantSpecCoefIdx >= 1024) { |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Mutes spectral lines which have been marked as erroneous (Q_VALUE_INVALID) |
| -------------------------------------------------------------------------------------------- */ |
| void HcrMuteErroneousLines(H_HCR_INFO hHcr) |
| { |
| int c; |
| FIXP_DBL *RESTRICT pLong = SPEC_LONG(hHcr->decInOut.pQuantizedSpectralCoefficientsBase); |
| |
| /* if there is a line with value Q_VALUE_INVALID mute it */ |
| for (c = 0; c < 1024; c++) { |
| if (pLong[c] == (FIXP_DBL)Q_VALUE_INVALID) { |
| #if HCR_LISTEN_TO_MUTED_LINES |
| pLong[c] = (FIXP_DBL)HCR_DIRAC; /* marking */ |
| #else |
| pLong[c] = FL2FXCONST_DBL(0.0f); /* muting */ |
| #endif |
| } |
| } |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Sets global HCR type |
| -------------------------------------------------------------------------------------------- */ |
| void setHcrType(H_HCR_INFO hHcr, MP4_ELEMENT_ID type) |
| { |
| switch (type) { |
| case ID_SCE: |
| hHcr->globalHcrType = 0; |
| break; |
| case ID_CPE: |
| hHcr->globalHcrType = 1; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| description: Gets HCR type from the HCR data structure |
| ----------------------------------------------------------------------------------------------- |
| return: - global HCR type |
| -------------------------------------------------------------------------------------------- */ |
| INT getHcrType(H_HCR_INFO hHcr) |
| { |
| return hHcr->globalHcrType; |
| } |
| |
| |
| |
| |
