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