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):   Josef Hoepfl
98 
99    Description:
100 
101 *******************************************************************************/
102 
103 #include "channel.h"
104 #include "aacdecoder.h"
105 #include "block.h"
106 #include "aacdec_tns.h"
107 #include "FDK_bitstream.h"
108 
109 #include "conceal.h"
110 
111 #include "rvlc.h"
112 
113 #include "aacdec_hcr.h"
114 
115 #include "usacdec_lpd.h"
116 #include "usacdec_fac.h"
117 
MapMidSideMaskToPnsCorrelation(CAacDecoderChannelInfo * pAacDecoderChannelInfo[2])118 static void MapMidSideMaskToPnsCorrelation(
119     CAacDecoderChannelInfo *pAacDecoderChannelInfo[2]) {
120   int group;
121 
122   for (group = 0; group < pAacDecoderChannelInfo[L]->icsInfo.WindowGroups;
123        group++) {
124     UCHAR groupMask = 1 << group;
125 
126     for (UCHAR band = 0; band < pAacDecoderChannelInfo[L]->icsInfo.MaxSfBands;
127          band++) {
128       if (pAacDecoderChannelInfo[L]->pComData->jointStereoData.MsUsed[band] &
129           groupMask) { /* channels are correlated */
130         CPns_SetCorrelation(&pAacDecoderChannelInfo[L]->data.aac.PnsData, group,
131                             band, 0);
132 
133         if (CPns_IsPnsUsed(&pAacDecoderChannelInfo[L]->data.aac.PnsData, group,
134                            band) &&
135             CPns_IsPnsUsed(&pAacDecoderChannelInfo[R]->data.aac.PnsData, group,
136                            band))
137           pAacDecoderChannelInfo[L]->pComData->jointStereoData.MsUsed[band] ^=
138               groupMask; /* clear the groupMask-bit */
139       }
140     }
141   }
142 }
143 
Clean_Complex_Prediction_coefficients(CJointStereoPersistentData * pJointStereoPersistentData,int windowGroups,const int low_limit,const int high_limit)144 static void Clean_Complex_Prediction_coefficients(
145     CJointStereoPersistentData *pJointStereoPersistentData, int windowGroups,
146     const int low_limit, const int high_limit) {
147   for (int group = 0; group < windowGroups; group++) {
148     for (int sfb = low_limit; sfb < high_limit; sfb++) {
149       pJointStereoPersistentData->alpha_q_re_prev[group][sfb] = 0;
150       pJointStereoPersistentData->alpha_q_im_prev[group][sfb] = 0;
151     }
152   }
153 }
154 
155 /*!
156   \brief Decode channel pair element
157 
158   The function decodes a channel pair element.
159 
160   \return  none
161 */
CChannelElement_Decode(CAacDecoderChannelInfo * pAacDecoderChannelInfo[2],CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo[2],SamplingRateInfo * pSamplingRateInfo,UINT flags,UINT elFlags,int el_channels)162 void CChannelElement_Decode(
163     CAacDecoderChannelInfo
164         *pAacDecoderChannelInfo[2], /*!< pointer to aac decoder channel info */
165     CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[2],
166     SamplingRateInfo *pSamplingRateInfo, UINT flags, UINT elFlags,
167     int el_channels) {
168   int ch = 0;
169 
170   int maxSfBandsL = 0, maxSfBandsR = 0;
171   int maybe_jstereo = (el_channels > 1);
172 
173   if (flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA) && el_channels == 2) {
174     if (pAacDecoderChannelInfo[L]->data.usac.core_mode ||
175         pAacDecoderChannelInfo[R]->data.usac.core_mode) {
176       maybe_jstereo = 0;
177     }
178   }
179 
180   if (maybe_jstereo) {
181     maxSfBandsL =
182         GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo[L]->icsInfo);
183     maxSfBandsR =
184         GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo[R]->icsInfo);
185 
186     /* apply ms */
187     if (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow) {
188       if (!(flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA))) {
189         if (pAacDecoderChannelInfo[L]->data.aac.PnsData.PnsActive ||
190             pAacDecoderChannelInfo[R]->data.aac.PnsData.PnsActive) {
191           MapMidSideMaskToPnsCorrelation(pAacDecoderChannelInfo);
192         }
193       }
194       /* if tns_on_lr == 1 run MS */ /* &&
195                                         (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_active
196                                         == 1) */
197       if (((flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) &&
198            (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_on_lr ==
199             1)) ||
200           ((flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) == 0)) {
201         int max_sfb_ste = (INT)(pAacDecoderChannelInfo[L]->icsInfo.max_sfb_ste);
202 
203         CJointStereo_ApplyMS(
204             pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo,
205             pAacDecoderChannelInfo[L]->pSpectralCoefficient,
206             pAacDecoderChannelInfo[R]->pSpectralCoefficient,
207             pAacDecoderChannelInfo[L]->pDynData->aSfbScale,
208             pAacDecoderChannelInfo[R]->pDynData->aSfbScale,
209             pAacDecoderChannelInfo[L]->specScale,
210             pAacDecoderChannelInfo[R]->specScale,
211             GetScaleFactorBandOffsets(&pAacDecoderChannelInfo[L]->icsInfo,
212                                       pSamplingRateInfo),
213             GetWindowGroupLengthTable(&pAacDecoderChannelInfo[L]->icsInfo),
214             GetWindowGroups(&pAacDecoderChannelInfo[L]->icsInfo), max_sfb_ste,
215             maxSfBandsL, maxSfBandsR,
216             pAacDecoderChannelInfo[L]
217                 ->pComData->jointStereoData.store_dmx_re_prev,
218             &(pAacDecoderChannelInfo[L]
219                   ->pComData->jointStereoData.store_dmx_re_prev_e),
220             1);
221 
222       } /* if ( ((elFlags & AC_EL_USAC_CP_POSSIBLE).... */
223     }   /* if (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow)*/
224 
225     /* apply intensity stereo */ /* modifies pAacDecoderChannelInfo[]->aSpecSfb
226                                   */
227     if (!(flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA))) {
228       if ((pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow ==
229            1) &&
230           (el_channels == 2)) {
231         CJointStereo_ApplyIS(
232             pAacDecoderChannelInfo,
233             GetScaleFactorBandOffsets(&pAacDecoderChannelInfo[L]->icsInfo,
234                                       pSamplingRateInfo),
235             GetWindowGroupLengthTable(&pAacDecoderChannelInfo[L]->icsInfo),
236             GetWindowGroups(&pAacDecoderChannelInfo[L]->icsInfo),
237             GetScaleFactorBandsTransmitted(
238                 &pAacDecoderChannelInfo[L]->icsInfo));
239       }
240     }
241   } /* maybe_stereo */
242 
243   for (ch = 0; ch < el_channels; ch++) {
244     if (pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_LPD) {
245       /* Decode LPD data */
246       CLpdChannelStream_Decode(pAacDecoderChannelInfo[ch],
247                                pAacDecoderStaticChannelInfo[ch], flags);
248     } else {
249       UCHAR noSfbs =
250           GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo[ch]->icsInfo);
251       /* For USAC common window: max_sfb of both channels may differ
252        * (common_max_sfb == 0). */
253       if ((maybe_jstereo == 1) &&
254           (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow ==
255            1)) {
256         noSfbs = fMax(maxSfBandsL, maxSfBandsR);
257       }
258       int CP_active = 0;
259       if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
260         CP_active = pAacDecoderChannelInfo[ch]
261                         ->pComData->jointStereoData.cplx_pred_flag;
262       }
263 
264       /* Omit writing of pAacDecoderChannelInfo[ch]->specScale for complex
265          stereo prediction since scaling has already been carried out. */
266       int max_sfb_ste = (INT)(pAacDecoderChannelInfo[L]->icsInfo.max_sfb_ste);
267 
268       if ((!CP_active) || (CP_active && (max_sfb_ste < noSfbs)) ||
269           ((flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) &&
270            (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_on_lr ==
271             0))) {
272         CBlock_ScaleSpectralData(pAacDecoderChannelInfo[ch], noSfbs,
273                                  pSamplingRateInfo);
274 
275         /*Active for the case of TNS applied before MS/CP*/
276         if ((flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) &&
277             (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_on_lr ==
278              0)) {
279           if (IsLongBlock(&pAacDecoderChannelInfo[ch]->icsInfo)) {
280             for (int i = 0; i < noSfbs; i++) {
281               pAacDecoderChannelInfo[ch]->pDynData->aSfbScale[i] =
282                   pAacDecoderChannelInfo[ch]->specScale[0];
283             }
284           } else {
285             for (int i = 0; i < 8; i++) {
286               for (int j = 0; j < noSfbs; j++) {
287                 pAacDecoderChannelInfo[ch]->pDynData->aSfbScale[i * 16 + j] =
288                     pAacDecoderChannelInfo[ch]->specScale[i];
289               }
290             }
291           }
292         }
293       }
294     }
295   } /* End "for (ch = 0; ch < el_channels; ch++)" */
296 
297   if (maybe_jstereo) {
298     /* apply ms */
299     if (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow) {
300     } /* CommonWindow */
301     else {
302       if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
303         FDKmemclear(
304             pAacDecoderStaticChannelInfo[L]
305                 ->pCpeStaticData->jointStereoPersistentData.alpha_q_re_prev,
306             JointStereoMaximumGroups * JointStereoMaximumBands * sizeof(SHORT));
307         FDKmemclear(
308             pAacDecoderStaticChannelInfo[L]
309                 ->pCpeStaticData->jointStereoPersistentData.alpha_q_im_prev,
310             JointStereoMaximumGroups * JointStereoMaximumBands * sizeof(SHORT));
311       }
312     }
313 
314   } /* if (maybe_jstereo) */
315 
316   for (ch = 0; ch < el_channels; ch++) {
317     if (pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_LPD) {
318     } else {
319       if (!(flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA))) {
320         /* Use same seed for coupled channels (CPE) */
321         int pnsCh = (ch > 0) ? L : ch;
322         CPns_UpdateNoiseState(
323             &pAacDecoderChannelInfo[ch]->data.aac.PnsData,
324             pAacDecoderChannelInfo[pnsCh]->data.aac.PnsData.currentSeed,
325             pAacDecoderChannelInfo[ch]->pComData->pnsRandomSeed);
326       }
327 
328       if ((!(flags & (AC_USAC))) ||
329           ((flags & (AC_USAC)) &&
330            (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_active ==
331             1)) ||
332           (maybe_jstereo == 0)) {
333         ApplyTools(
334             pAacDecoderChannelInfo, pSamplingRateInfo, flags, elFlags, ch,
335             pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow);
336       }
337     } /* End "} else" */
338   }   /* End "for (ch = 0; ch < el_channels; ch++)" */
339 
340   if (maybe_jstereo) {
341     /* apply ms */
342     if (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow) {
343       /* if tns_on_lr == 0 run MS */
344       if ((flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) &&
345           (pAacDecoderChannelInfo[L]->pDynData->specificTo.usac.tns_on_lr ==
346            0)) {
347         int max_sfb_ste = (INT)(pAacDecoderChannelInfo[L]->icsInfo.max_sfb_ste);
348 
349         CJointStereo_ApplyMS(
350             pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo,
351             pAacDecoderChannelInfo[L]->pSpectralCoefficient,
352             pAacDecoderChannelInfo[R]->pSpectralCoefficient,
353             pAacDecoderChannelInfo[L]->pDynData->aSfbScale,
354             pAacDecoderChannelInfo[R]->pDynData->aSfbScale,
355             pAacDecoderChannelInfo[L]->specScale,
356             pAacDecoderChannelInfo[R]->specScale,
357             GetScaleFactorBandOffsets(&pAacDecoderChannelInfo[L]->icsInfo,
358                                       pSamplingRateInfo),
359             GetWindowGroupLengthTable(&pAacDecoderChannelInfo[L]->icsInfo),
360             GetWindowGroups(&pAacDecoderChannelInfo[L]->icsInfo), max_sfb_ste,
361             maxSfBandsL, maxSfBandsR,
362             pAacDecoderChannelInfo[L]
363                 ->pComData->jointStereoData.store_dmx_re_prev,
364             &(pAacDecoderChannelInfo[L]
365                   ->pComData->jointStereoData.store_dmx_re_prev_e),
366             1);
367       }
368 
369     } /* if (pAacDecoderChannelInfo[L]->pDynData->RawDataInfo.CommonWindow) */
370 
371   } /* if (maybe_jstereo) */
372 
373   for (ch = 0; ch < el_channels; ch++) {
374     if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
375       pAacDecoderStaticChannelInfo[L]
376           ->pCpeStaticData->jointStereoPersistentData.clearSpectralCoeffs = 0;
377     }
378   }
379 
380   CRvlc_ElementCheck(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo,
381                      flags, el_channels);
382 }
383 
CChannel_CodebookTableInit(CAacDecoderChannelInfo * pAacDecoderChannelInfo)384 void CChannel_CodebookTableInit(
385     CAacDecoderChannelInfo *pAacDecoderChannelInfo) {
386   int b, w, maxBands, maxWindows;
387   int maxSfb = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
388   UCHAR *pCodeBook = pAacDecoderChannelInfo->pDynData->aCodeBook;
389 
390   if (IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) {
391     maxBands = 64;
392     maxWindows = 1;
393   } else {
394     maxBands = 16;
395     maxWindows = 8;
396   }
397 
398   for (w = 0; w < maxWindows; w++) {
399     for (b = 0; b < maxSfb; b++) {
400       pCodeBook[b] = ESCBOOK;
401     }
402     for (; b < maxBands; b++) {
403       pCodeBook[b] = ZERO_HCB;
404     }
405     pCodeBook += maxBands;
406   }
407 }
408 
409 /*
410  * Arbitrary order bitstream parser
411  */
CChannelElement_Read(HANDLE_FDK_BITSTREAM hBs,CAacDecoderChannelInfo * pAacDecoderChannelInfo[],CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo[],const AUDIO_OBJECT_TYPE aot,SamplingRateInfo * pSamplingRateInfo,const UINT flags,const UINT elFlags,const UINT frame_length,const UCHAR numberOfChannels,const SCHAR epConfig,HANDLE_TRANSPORTDEC pTpDec)412 AAC_DECODER_ERROR CChannelElement_Read(
413     HANDLE_FDK_BITSTREAM hBs, CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
414     CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
415     const AUDIO_OBJECT_TYPE aot, SamplingRateInfo *pSamplingRateInfo,
416     const UINT flags, const UINT elFlags, const UINT frame_length,
417     const UCHAR numberOfChannels, const SCHAR epConfig,
418     HANDLE_TRANSPORTDEC pTpDec) {
419   AAC_DECODER_ERROR error = AAC_DEC_OK;
420   const element_list_t *list;
421   int i, ch, decision_bit;
422   int crcReg1 = -1, crcReg2 = -1;
423   int cplxPred;
424   int ind_sw_cce_flag = 0, num_gain_element_lists = 0;
425 
426   FDK_ASSERT((numberOfChannels == 1) || (numberOfChannels == 2));
427 
428   /* Get channel element sequence table */
429   list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0, elFlags);
430   if (list == NULL) {
431     error = AAC_DEC_UNSUPPORTED_FORMAT;
432     goto bail;
433   }
434 
435   CTns_Reset(&pAacDecoderChannelInfo[0]->pDynData->TnsData);
436   /* Set common window to 0 by default. If signalized in the bit stream it will
437    * be overwritten later explicitely */
438   pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
439   if (flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) {
440     pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active = 0;
441     pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr = 0;
442   }
443   if (numberOfChannels == 2) {
444     CTns_Reset(&pAacDecoderChannelInfo[1]->pDynData->TnsData);
445     pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
446   }
447 
448   cplxPred = 0;
449   if (pAacDecoderStaticChannelInfo != NULL) {
450     if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
451       pAacDecoderChannelInfo[0]->pComData->jointStereoData.cplx_pred_flag = 0;
452       cplxPred = 1;
453     }
454   }
455 
456   if (0 || (flags & (AC_ELD | AC_SCALABLE))) {
457     pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 1;
458     if (numberOfChannels == 2) {
459       pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
460           pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
461     }
462   }
463 
464   /* Iterate through sequence table */
465   i = 0;
466   ch = 0;
467   decision_bit = 0;
468   do {
469     switch (list->id[i]) {
470       case element_instance_tag:
471         pAacDecoderChannelInfo[0]->ElementInstanceTag = FDKreadBits(hBs, 4);
472         if (numberOfChannels == 2) {
473           pAacDecoderChannelInfo[1]->ElementInstanceTag =
474               pAacDecoderChannelInfo[0]->ElementInstanceTag;
475         }
476         break;
477       case common_window:
478         decision_bit =
479             pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow =
480                 FDKreadBits(hBs, 1);
481         if (numberOfChannels == 2) {
482           pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
483               pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
484         }
485         break;
486       case ics_info:
487         /* store last window sequence (utilized in complex stereo prediction)
488          * before reading new channel-info */
489         if (cplxPred) {
490           if (pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
491             pAacDecoderStaticChannelInfo[0]
492                 ->pCpeStaticData->jointStereoPersistentData.winSeqPrev =
493                 pAacDecoderChannelInfo[0]->icsInfo.WindowSequence;
494             pAacDecoderStaticChannelInfo[0]
495                 ->pCpeStaticData->jointStereoPersistentData.winShapePrev =
496                 pAacDecoderChannelInfo[0]->icsInfo.WindowShape;
497           }
498         }
499         /* Read individual channel info */
500         error = IcsRead(hBs, &pAacDecoderChannelInfo[ch]->icsInfo,
501                         pSamplingRateInfo, flags);
502 
503         if (elFlags & AC_EL_LFE &&
504             GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) !=
505                 BLOCK_LONG) {
506           error = AAC_DEC_PARSE_ERROR;
507           break;
508         }
509 
510         if (numberOfChannels == 2 &&
511             pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
512           pAacDecoderChannelInfo[1]->icsInfo =
513               pAacDecoderChannelInfo[0]->icsInfo;
514         }
515         break;
516 
517       case common_max_sfb:
518         if (FDKreadBit(hBs) == 0) {
519           error = IcsReadMaxSfb(hBs, &pAacDecoderChannelInfo[1]->icsInfo,
520                                 pSamplingRateInfo);
521         }
522         break;
523 
524       case ltp_data_present:
525         if (FDKreadBits(hBs, 1) != 0) {
526           error = AAC_DEC_UNSUPPORTED_PREDICTION;
527         }
528         break;
529 
530       case ms:
531 
532         INT max_sfb_ste;
533         INT max_sfb_ste_clear;
534 
535         max_sfb_ste = GetScaleMaxFactorBandsTransmitted(
536             &pAacDecoderChannelInfo[0]->icsInfo,
537             &pAacDecoderChannelInfo[1]->icsInfo);
538 
539         max_sfb_ste_clear = 64;
540 
541         pAacDecoderChannelInfo[0]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
542         pAacDecoderChannelInfo[1]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
543 
544         if (flags & (AC_USAC | AC_RSV603DA) &&
545             pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow ==
546                 0) {
547           Clean_Complex_Prediction_coefficients(
548               &pAacDecoderStaticChannelInfo[0]
549                    ->pCpeStaticData->jointStereoPersistentData,
550               GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo), 0, 64);
551         }
552 
553         if (CJointStereo_Read(
554                 hBs, &pAacDecoderChannelInfo[0]->pComData->jointStereoData,
555                 GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo),
556                 max_sfb_ste, max_sfb_ste_clear,
557                 /* jointStereoPersistentData and cplxPredictionData are only
558                    available/allocated if cplxPred is active. */
559                 ((cplxPred == 0) || (pAacDecoderStaticChannelInfo == NULL))
560                     ? NULL
561                     : &pAacDecoderStaticChannelInfo[0]
562                            ->pCpeStaticData->jointStereoPersistentData,
563                 ((cplxPred == 0) || (pAacDecoderChannelInfo[0] == NULL))
564                     ? NULL
565                     : pAacDecoderChannelInfo[0]
566                           ->pComStaticData->cplxPredictionData,
567                 cplxPred,
568                 GetScaleFactorBandsTotal(&pAacDecoderChannelInfo[0]->icsInfo),
569                 GetWindowSequence(&pAacDecoderChannelInfo[0]->icsInfo),
570                 flags)) {
571           error = AAC_DEC_PARSE_ERROR;
572         }
573 
574         break;
575 
576       case global_gain:
577         pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.GlobalGain =
578             (UCHAR)FDKreadBits(hBs, 8);
579         break;
580 
581       case section_data:
582         error = CBlock_ReadSectionData(hBs, pAacDecoderChannelInfo[ch],
583                                        pSamplingRateInfo, flags);
584         break;
585 
586       case scale_factor_data_usac:
587         pAacDecoderChannelInfo[ch]->currAliasingSymmetry = 0;
588         /* Set active sfb codebook indexes to HCB_ESC to make them "active" */
589         CChannel_CodebookTableInit(
590             pAacDecoderChannelInfo[ch]); /*  equals ReadSectionData(self,
591                                             bs) in float soft. block.c
592                                             line: ~599 */
593         /* Note: The missing "break" is intentional here, since we need to call
594          * CBlock_ReadScaleFactorData(). */
595         FDK_FALLTHROUGH;
596 
597       case scale_factor_data:
598         if (flags & AC_ER_RVLC) {
599           /* read RVLC data from bitstream (error sens. cat. 1) */
600           CRvlc_Read(pAacDecoderChannelInfo[ch], hBs);
601         } else {
602           error = CBlock_ReadScaleFactorData(pAacDecoderChannelInfo[ch], hBs,
603                                              flags);
604         }
605         break;
606 
607       case pulse:
608         if (CPulseData_Read(
609                 hBs,
610                 &pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.PulseData,
611                 pSamplingRateInfo->ScaleFactorBands_Long, /* pulse data is only
612                                                              allowed to be
613                                                              present in long
614                                                              blocks! */
615                 (void *)&pAacDecoderChannelInfo[ch]->icsInfo,
616                 frame_length) != 0) {
617           error = AAC_DEC_DECODE_FRAME_ERROR;
618         }
619         break;
620       case tns_data_present:
621         CTns_ReadDataPresentFlag(
622             hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData);
623         if (elFlags & AC_EL_LFE &&
624             pAacDecoderChannelInfo[ch]->pDynData->TnsData.DataPresent) {
625           error = AAC_DEC_PARSE_ERROR;
626         }
627         break;
628       case tns_data:
629         /* tns_data_present is checked inside CTns_Read(). */
630         error = CTns_Read(hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData,
631                           &pAacDecoderChannelInfo[ch]->icsInfo, flags);
632 
633         break;
634 
635       case gain_control_data:
636         break;
637 
638       case gain_control_data_present:
639         if (FDKreadBits(hBs, 1)) {
640           error = AAC_DEC_UNSUPPORTED_GAIN_CONTROL_DATA;
641         }
642         break;
643 
644       case tw_data:
645         break;
646       case common_tw:
647         break;
648       case tns_data_present_usac:
649         if (pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active) {
650           CTns_ReadDataPresentUsac(
651               hBs, &pAacDecoderChannelInfo[0]->pDynData->TnsData,
652               &pAacDecoderChannelInfo[1]->pDynData->TnsData,
653               &pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr,
654               &pAacDecoderChannelInfo[0]->icsInfo, flags, elFlags,
655               pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow);
656         } else {
657           pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr =
658               (UCHAR)1;
659         }
660         break;
661       case core_mode:
662         decision_bit = FDKreadBits(hBs, 1);
663         pAacDecoderChannelInfo[ch]->data.usac.core_mode = decision_bit;
664         if ((ch == 1) && (pAacDecoderChannelInfo[0]->data.usac.core_mode !=
665                           pAacDecoderChannelInfo[1]->data.usac.core_mode)) {
666           /* StereoCoreToolInfo(core_mode[ch] ) */
667           pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
668           pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
669         }
670         break;
671       case tns_active:
672         pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active =
673             FDKreadBit(hBs);
674         break;
675       case noise:
676         if (elFlags & AC_EL_USAC_NOISE) {
677           pAacDecoderChannelInfo[ch]
678               ->pDynData->specificTo.usac.fd_noise_level_and_offset =
679               FDKreadBits(hBs, 3 + 5); /* Noise level */
680         }
681         break;
682       case lpd_channel_stream:
683 
684       {
685         error = CLpdChannelStream_Read(/* = lpd_channel_stream() */
686                                        hBs, pAacDecoderChannelInfo[ch],
687                                        pAacDecoderStaticChannelInfo[ch],
688                                        pSamplingRateInfo, flags);
689       }
690 
691         pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_LPD;
692         break;
693       case fac_data: {
694         int fFacDatPresent = FDKreadBit(hBs);
695 
696         /* Wee need a valid fac_data[0] even if no FAC data is present (as
697          * temporal buffer) */
698         pAacDecoderChannelInfo[ch]->data.usac.fac_data[0] =
699             pAacDecoderChannelInfo[ch]->data.usac.fac_data0;
700 
701         if (fFacDatPresent) {
702           if (elFlags & AC_EL_LFE) {
703             error = AAC_DEC_PARSE_ERROR;
704             break;
705           }
706           /* FAC data present, this frame is FD, so the last mode had to be
707            * ACELP. */
708           if (pAacDecoderStaticChannelInfo[ch]->last_core_mode != LPD ||
709               pAacDecoderStaticChannelInfo[ch]->last_lpd_mode != 0) {
710             pAacDecoderChannelInfo[ch]->data.usac.core_mode_last = LPD;
711             pAacDecoderChannelInfo[ch]->data.usac.lpd_mode_last = 0;
712             /* We can't change the past! So look to the future and go ahead! */
713           }
714           CLpd_FAC_Read(hBs, pAacDecoderChannelInfo[ch]->data.usac.fac_data[0],
715                         pAacDecoderChannelInfo[ch]->data.usac.fac_data_e,
716                         CLpd_FAC_getLength(
717                             IsLongBlock(&pAacDecoderChannelInfo[ch]->icsInfo),
718                             pAacDecoderChannelInfo[ch]->granuleLength),
719                         1, 0);
720         } else {
721           if (pAacDecoderStaticChannelInfo[ch]->last_core_mode == LPD &&
722               pAacDecoderStaticChannelInfo[ch]->last_lpd_mode == 0) {
723             /* ACELP to FD transitons without FAC are possible. That is why we
724             zero it out (i.e FAC will not be considered in the subsequent
725             calculations */
726             FDKmemclear(pAacDecoderChannelInfo[ch]->data.usac.fac_data0,
727                         LFAC * sizeof(FIXP_DBL));
728           }
729         }
730       } break;
731       case esc2_rvlc:
732         if (flags & AC_ER_RVLC) {
733           CRvlc_Decode(pAacDecoderChannelInfo[ch],
734                        pAacDecoderStaticChannelInfo[ch], hBs);
735         }
736         break;
737 
738       case esc1_hcr:
739         if (flags & AC_ER_HCR) {
740           CHcr_Read(hBs, pAacDecoderChannelInfo[ch],
741                     numberOfChannels == 2 ? ID_CPE : ID_SCE);
742         }
743         break;
744 
745       case spectral_data:
746         error = CBlock_ReadSpectralData(hBs, pAacDecoderChannelInfo[ch],
747                                         pSamplingRateInfo, flags);
748         if (flags & AC_ELD) {
749           pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_ELDFB;
750         } else {
751           if (flags & AC_HDAAC) {
752             pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_INTIMDCT;
753           } else {
754             pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
755           }
756         }
757         break;
758 
759       case ac_spectral_data:
760         error = CBlock_ReadAcSpectralData(
761             hBs, pAacDecoderChannelInfo[ch], pAacDecoderStaticChannelInfo[ch],
762             pSamplingRateInfo, frame_length, flags);
763         pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
764         break;
765 
766       case coupled_elements: {
767         int num_coupled_elements, c;
768 
769         ind_sw_cce_flag = FDKreadBit(hBs);
770         num_coupled_elements = FDKreadBits(hBs, 3);
771 
772         for (c = 0; c < (num_coupled_elements + 1); c++) {
773           int cc_target_is_cpe;
774 
775           num_gain_element_lists++;
776           cc_target_is_cpe = FDKreadBit(hBs); /* cc_target_is_cpe[c] */
777           FDKreadBits(hBs, 4);                /* cc_target_tag_select[c] */
778 
779           if (cc_target_is_cpe) {
780             int cc_l, cc_r;
781 
782             cc_l = FDKreadBit(hBs); /* cc_l[c] */
783             cc_r = FDKreadBit(hBs); /* cc_r[c] */
784 
785             if (cc_l && cc_r) {
786               num_gain_element_lists++;
787             }
788           }
789         }
790         FDKreadBit(hBs);     /* cc_domain */
791         FDKreadBit(hBs);     /* gain_element_sign  */
792         FDKreadBits(hBs, 2); /* gain_element_scale */
793       } break;
794 
795       case gain_element_lists: {
796         const CodeBookDescription *hcb;
797         UCHAR *pCodeBook;
798         int c;
799 
800         hcb = &AACcodeBookDescriptionTable[BOOKSCL];
801         pCodeBook = pAacDecoderChannelInfo[ch]->pDynData->aCodeBook;
802 
803         for (c = 1; c < num_gain_element_lists; c++) {
804           int cge;
805           if (ind_sw_cce_flag) {
806             cge = 1;
807           } else {
808             cge = FDKreadBits(hBs, 1); /* common_gain_element_present[c] */
809           }
810           if (cge) {
811             /* Huffman */
812             CBlock_DecodeHuffmanWord(
813                 hBs, hcb); /* hcod_sf[common_gain_element[c]] 1..19 */
814           } else {
815             int g, sfb;
816             for (g = 0;
817                  g < GetWindowGroups(&pAacDecoderChannelInfo[ch]->icsInfo);
818                  g++) {
819               for (sfb = 0; sfb < GetScaleFactorBandsTransmitted(
820                                       &pAacDecoderChannelInfo[ch]->icsInfo);
821                    sfb++) {
822                 if (pCodeBook[sfb] != ZERO_HCB) {
823                   /* Huffman */
824                   CBlock_DecodeHuffmanWord(
825                       hBs,
826                       hcb); /* hcod_sf[dpcm_gain_element[c][g][sfb]] 1..19 */
827                 }
828               }
829             }
830           }
831         }
832       } break;
833 
834         /* CRC handling */
835       case adtscrc_start_reg1:
836         if (pTpDec != NULL) {
837           crcReg1 = transportDec_CrcStartReg(pTpDec, 192);
838         }
839         break;
840       case adtscrc_start_reg2:
841         if (pTpDec != NULL) {
842           crcReg2 = transportDec_CrcStartReg(pTpDec, 128);
843         }
844         break;
845       case adtscrc_end_reg1:
846       case drmcrc_end_reg:
847         if (pTpDec != NULL) {
848           transportDec_CrcEndReg(pTpDec, crcReg1);
849           crcReg1 = -1;
850         }
851         break;
852       case adtscrc_end_reg2:
853         if (crcReg1 != -1) {
854           error = AAC_DEC_DECODE_FRAME_ERROR;
855         } else if (pTpDec != NULL) {
856           transportDec_CrcEndReg(pTpDec, crcReg2);
857           crcReg2 = -1;
858         }
859         break;
860       case drmcrc_start_reg:
861         if (pTpDec != NULL) {
862           crcReg1 = transportDec_CrcStartReg(pTpDec, 0);
863         }
864         break;
865 
866         /* Non data cases */
867       case next_channel:
868         ch = (ch + 1) % numberOfChannels;
869         break;
870       case link_sequence:
871         list = list->next[decision_bit];
872         i = -1;
873         break;
874 
875       default:
876         error = AAC_DEC_UNSUPPORTED_FORMAT;
877         break;
878     }
879 
880     if (error != AAC_DEC_OK) {
881       goto bail;
882     }
883 
884     i++;
885 
886   } while (list->id[i] != end_of_sequence);
887 
888   for (ch = 0; ch < numberOfChannels; ch++) {
889     if (pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_IMDCT ||
890         pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_ELDFB) {
891       /* Shows which bands are empty. */
892       UCHAR *band_is_noise =
893           pAacDecoderChannelInfo[ch]->pDynData->band_is_noise;
894       FDKmemset(band_is_noise, (UCHAR)1, sizeof(UCHAR) * (8 * 16));
895 
896       error = CBlock_InverseQuantizeSpectralData(
897           pAacDecoderChannelInfo[ch], pSamplingRateInfo, band_is_noise, 1);
898       if (error != AAC_DEC_OK) {
899         return error;
900       }
901 
902       if (elFlags & AC_EL_USAC_NOISE) {
903         CBlock_ApplyNoise(pAacDecoderChannelInfo[ch], pSamplingRateInfo,
904                           &pAacDecoderStaticChannelInfo[ch]->nfRandomSeed,
905                           band_is_noise);
906 
907       } /* if (elFlags & AC_EL_USAC_NOISE) */
908     }
909   }
910 
911 bail:
912   if (crcReg1 != -1 || crcReg2 != -1) {
913     if (error == AAC_DEC_OK) {
914       error = AAC_DEC_DECODE_FRAME_ERROR;
915     }
916     if (crcReg1 != -1) {
917       transportDec_CrcEndReg(pTpDec, crcReg1);
918     }
919     if (crcReg2 != -1) {
920       transportDec_CrcEndReg(pTpDec, crcReg2);
921     }
922   }
923   return error;
924 }
925