• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3 
4 © Copyright  1995 - 2021 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 /**************************** SBR decoder library ******************************
96 
97    Author(s):
98 
99    Description:
100 
101 *******************************************************************************/
102 
103 /*!
104   \file
105   \brief  SBR decoder frontend
106   This module provides a frontend to the SBR decoder. The function openSBR() is
107   called for initialization. The function sbrDecoder_Apply() is called for each
108   frame. sbr_Apply() will call the required functions to decode the raw SBR data
109   (provided by env_extr.cpp), to decode the envelope data and noise floor levels
110   [decodeSbrData()], and to finally apply SBR to the current frame [sbr_dec()].
111 
112   \sa sbrDecoder_Apply(), \ref documentationOverview
113 */
114 
115 /*!
116   \page documentationOverview Overview of important information resources and
117   source code documentation
118 
119   As part of this documentation you can find more extensive descriptions about
120   key concepts and algorithms at the following locations:
121 
122   <h2>Programming</h2>
123 
124   \li Buffer management: sbrDecoder_Apply() and sbr_dec()
125   \li Internal scale factors to maximize SNR on fixed point processors:
126   #QMF_SCALE_FACTOR \li Special mantissa-exponent format: Created in
127   requantizeEnvelopeData() and used in calculateSbrEnvelope()
128 
129   <h2>Algorithmic details</h2>
130   \li About the SBR data format: \ref SBR_HEADER_ELEMENT and \ref
131   SBR_STANDARD_ELEMENT \li Details about the bitstream decoder: env_extr.cpp \li
132   Details about the QMF filterbank and the provided polyphase implementation:
133   qmf_dec.cpp \li Details about the transposer: lpp_tran.cpp \li Details about
134   the envelope adjuster: env_calc.cpp
135 
136 */
137 
138 #include "sbrdecoder.h"
139 
140 #include "FDK_bitstream.h"
141 
142 #include "sbrdec_freq_sca.h"
143 #include "env_extr.h"
144 #include "sbr_dec.h"
145 #include "env_dec.h"
146 #include "FDK_crc.h"
147 #include "sbr_ram.h"
148 #include "sbr_rom.h"
149 #include "lpp_tran.h"
150 #include "transcendent.h"
151 
152 #include "sbrdec_drc.h"
153 
154 #include "psbitdec.h"
155 
156 /* Decoder library info */
157 #define SBRDECODER_LIB_VL0 3
158 #define SBRDECODER_LIB_VL1 1
159 #define SBRDECODER_LIB_VL2 0
160 #define SBRDECODER_LIB_TITLE "SBR Decoder"
161 #ifdef SUPPRESS_BUILD_DATE_INFO
162 #define SBRDECODER_LIB_BUILD_DATE ""
163 #define SBRDECODER_LIB_BUILD_TIME ""
164 #else
165 #define SBRDECODER_LIB_BUILD_DATE __DATE__
166 #define SBRDECODER_LIB_BUILD_TIME __TIME__
167 #endif
168 
setFrameErrorFlag(SBR_DECODER_ELEMENT * pSbrElement,UCHAR value)169 static void setFrameErrorFlag(SBR_DECODER_ELEMENT *pSbrElement, UCHAR value) {
170   if (pSbrElement != NULL) {
171     switch (value) {
172       case FRAME_ERROR_ALLSLOTS:
173         FDKmemset(pSbrElement->frameErrorFlag, FRAME_ERROR,
174                   sizeof(pSbrElement->frameErrorFlag));
175         break;
176       default:
177         pSbrElement->frameErrorFlag[pSbrElement->useFrameSlot] = value;
178     }
179   }
180 }
181 
getHeaderSlot(UCHAR currentSlot,UCHAR hdrSlotUsage[(1)+1])182 static UCHAR getHeaderSlot(UCHAR currentSlot, UCHAR hdrSlotUsage[(1) + 1]) {
183   UINT occupied = 0;
184   int s;
185   UCHAR slot = hdrSlotUsage[currentSlot];
186 
187   FDK_ASSERT((1) + 1 < 32);
188 
189   for (s = 0; s < (1) + 1; s++) {
190     if ((hdrSlotUsage[s] == slot) && (s != slot)) {
191       occupied = 1;
192       break;
193     }
194   }
195 
196   if (occupied) {
197     occupied = 0;
198 
199     for (s = 0; s < (1) + 1; s++) {
200       occupied |= 1 << hdrSlotUsage[s];
201     }
202     for (s = 0; s < (1) + 1; s++) {
203       if (!(occupied & 0x1)) {
204         slot = s;
205         break;
206       }
207       occupied >>= 1;
208     }
209   }
210 
211   return slot;
212 }
213 
copySbrHeader(HANDLE_SBR_HEADER_DATA hDst,const HANDLE_SBR_HEADER_DATA hSrc)214 static void copySbrHeader(HANDLE_SBR_HEADER_DATA hDst,
215                           const HANDLE_SBR_HEADER_DATA hSrc) {
216   /* copy the whole header memory (including pointers) */
217   FDKmemcpy(hDst, hSrc, sizeof(SBR_HEADER_DATA));
218 
219   /* update pointers */
220   hDst->freqBandData.freqBandTable[0] = hDst->freqBandData.freqBandTableLo;
221   hDst->freqBandData.freqBandTable[1] = hDst->freqBandData.freqBandTableHi;
222 }
223 
compareSbrHeader(const HANDLE_SBR_HEADER_DATA hHdr1,const HANDLE_SBR_HEADER_DATA hHdr2)224 static int compareSbrHeader(const HANDLE_SBR_HEADER_DATA hHdr1,
225                             const HANDLE_SBR_HEADER_DATA hHdr2) {
226   int result = 0;
227 
228   /* compare basic data */
229   result |= (hHdr1->syncState != hHdr2->syncState) ? 1 : 0;
230   result |= (hHdr1->status != hHdr2->status) ? 1 : 0;
231   result |= (hHdr1->frameErrorFlag != hHdr2->frameErrorFlag) ? 1 : 0;
232   result |= (hHdr1->numberTimeSlots != hHdr2->numberTimeSlots) ? 1 : 0;
233   result |=
234       (hHdr1->numberOfAnalysisBands != hHdr2->numberOfAnalysisBands) ? 1 : 0;
235   result |= (hHdr1->timeStep != hHdr2->timeStep) ? 1 : 0;
236   result |= (hHdr1->sbrProcSmplRate != hHdr2->sbrProcSmplRate) ? 1 : 0;
237 
238   /* compare bitstream data */
239   result |=
240       FDKmemcmp(&hHdr1->bs_data, &hHdr2->bs_data, sizeof(SBR_HEADER_DATA_BS));
241   result |=
242       FDKmemcmp(&hHdr1->bs_dflt, &hHdr2->bs_dflt, sizeof(SBR_HEADER_DATA_BS));
243   result |= FDKmemcmp(&hHdr1->bs_info, &hHdr2->bs_info,
244                       sizeof(SBR_HEADER_DATA_BS_INFO));
245 
246   /* compare frequency band data */
247   result |= FDKmemcmp(&hHdr1->freqBandData, &hHdr2->freqBandData,
248                       (8 + MAX_NUM_LIMITERS + 1) * sizeof(UCHAR));
249   result |= FDKmemcmp(hHdr1->freqBandData.freqBandTableLo,
250                       hHdr2->freqBandData.freqBandTableLo,
251                       (MAX_FREQ_COEFFS / 2 + 1) * sizeof(UCHAR));
252   result |= FDKmemcmp(hHdr1->freqBandData.freqBandTableHi,
253                       hHdr2->freqBandData.freqBandTableHi,
254                       (MAX_FREQ_COEFFS + 1) * sizeof(UCHAR));
255   result |= FDKmemcmp(hHdr1->freqBandData.freqBandTableNoise,
256                       hHdr2->freqBandData.freqBandTableNoise,
257                       (MAX_NOISE_COEFFS + 1) * sizeof(UCHAR));
258   result |=
259       FDKmemcmp(hHdr1->freqBandData.v_k_master, hHdr2->freqBandData.v_k_master,
260                 (MAX_FREQ_COEFFS + 1) * sizeof(UCHAR));
261 
262   return result;
263 }
264 
265 /*!
266   \brief Reset SBR decoder.
267 
268   Reset should only be called if SBR has been sucessfully detected by
269   an appropriate checkForPayload() function.
270 
271   \return Error code.
272 */
sbrDecoder_ResetElement(HANDLE_SBRDECODER self,int sampleRateIn,int sampleRateOut,int samplesPerFrame,const MP4_ELEMENT_ID elementID,const int elementIndex,const int overlap)273 static SBR_ERROR sbrDecoder_ResetElement(HANDLE_SBRDECODER self,
274                                          int sampleRateIn, int sampleRateOut,
275                                          int samplesPerFrame,
276                                          const MP4_ELEMENT_ID elementID,
277                                          const int elementIndex,
278                                          const int overlap) {
279   SBR_ERROR sbrError = SBRDEC_OK;
280   HANDLE_SBR_HEADER_DATA hSbrHeader;
281   UINT qmfFlags = 0;
282 
283   int i, synDownsampleFac;
284 
285   /* USAC: assuming theoretical case 8 kHz output sample rate with 4:1 SBR */
286   const int sbr_min_sample_rate_in = IS_USAC(self->coreCodec) ? 2000 : 6400;
287 
288   /* Check in/out samplerates */
289   if (sampleRateIn < sbr_min_sample_rate_in || sampleRateIn > (96000)) {
290     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
291     goto bail;
292   }
293 
294   if (sampleRateOut > (96000)) {
295     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
296     goto bail;
297   }
298 
299   /* Set QMF mode flags */
300   if (self->flags & SBRDEC_LOW_POWER) qmfFlags |= QMF_FLAG_LP;
301 
302   if (self->coreCodec == AOT_ER_AAC_ELD) {
303     if (self->flags & SBRDEC_LD_MPS_QMF) {
304       qmfFlags |= QMF_FLAG_MPSLDFB;
305     } else {
306       qmfFlags |= QMF_FLAG_CLDFB;
307     }
308   }
309 
310   /* Set downsampling factor for synthesis filter bank */
311   if (sampleRateOut == 0) {
312     /* no single rate mode */
313     sampleRateOut =
314         sampleRateIn
315         << 1; /* In case of implicit signalling, assume dual rate SBR */
316   }
317 
318   if (sampleRateIn == sampleRateOut) {
319     synDownsampleFac = 2;
320     self->flags |= SBRDEC_DOWNSAMPLE;
321   } else {
322     synDownsampleFac = 1;
323     self->flags &= ~SBRDEC_DOWNSAMPLE;
324   }
325 
326   self->synDownsampleFac = synDownsampleFac;
327   self->sampleRateOut = sampleRateOut;
328 
329   {
330     for (i = 0; i < (1) + 1; i++) {
331       int setDflt;
332       hSbrHeader = &(self->sbrHeader[elementIndex][i]);
333       setDflt = ((hSbrHeader->syncState == SBR_NOT_INITIALIZED) ||
334                  (self->flags & SBRDEC_FORCE_RESET))
335                     ? 1
336                     : 0;
337 
338       /* init a default header such that we can at least do upsampling later */
339       sbrError = initHeaderData(hSbrHeader, sampleRateIn, sampleRateOut,
340                                 self->downscaleFactor, samplesPerFrame,
341                                 self->flags, setDflt);
342 
343       /* Set synchState to UPSAMPLING in case it already is initialized */
344       hSbrHeader->syncState = hSbrHeader->syncState > UPSAMPLING
345                                   ? UPSAMPLING
346                                   : hSbrHeader->syncState;
347     }
348   }
349 
350   if (sbrError != SBRDEC_OK) {
351     goto bail;
352   }
353 
354   if (!self->pQmfDomain->globalConf.qmfDomainExplicitConfig) {
355     self->pQmfDomain->globalConf.flags_requested |= qmfFlags;
356     self->pQmfDomain->globalConf.nBandsAnalysis_requested =
357         self->sbrHeader[elementIndex][0].numberOfAnalysisBands;
358     self->pQmfDomain->globalConf.nBandsSynthesis_requested =
359         (synDownsampleFac == 1) ? 64 : 32; /* may be overwritten by MPS */
360     self->pQmfDomain->globalConf.nBandsSynthesis_requested /=
361         self->downscaleFactor;
362     self->pQmfDomain->globalConf.nQmfTimeSlots_requested =
363         self->sbrHeader[elementIndex][0].numberTimeSlots *
364         self->sbrHeader[elementIndex][0].timeStep;
365     self->pQmfDomain->globalConf.nQmfOvTimeSlots_requested = overlap;
366     self->pQmfDomain->globalConf.nQmfProcBands_requested = 64; /* always 64 */
367     self->pQmfDomain->globalConf.nQmfProcChannels_requested =
368         1; /* may be overwritten by MPS */
369   }
370 
371   /* Init SBR channels going to be assigned to a SBR element */
372   {
373     int ch;
374     for (ch = 0; ch < self->pSbrElement[elementIndex]->nChannels; ch++) {
375       int headerIndex =
376           getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
377                         self->pSbrElement[elementIndex]->useHeaderSlot);
378 
379       /* and create sbrDec */
380       sbrError =
381           createSbrDec(self->pSbrElement[elementIndex]->pSbrChannel[ch],
382                        &self->sbrHeader[elementIndex][headerIndex],
383                        &self->pSbrElement[elementIndex]->transposerSettings,
384                        synDownsampleFac, qmfFlags, self->flags, overlap, ch,
385                        self->codecFrameSize);
386 
387       if (sbrError != SBRDEC_OK) {
388         goto bail;
389       }
390     }
391   }
392 
393   // FDKmemclear(sbr_OverlapBuffer, sizeof(sbr_OverlapBuffer));
394 
395   if (self->numSbrElements == 1) {
396     switch (self->coreCodec) {
397       case AOT_AAC_LC:
398       case AOT_SBR:
399       case AOT_PS:
400       case AOT_ER_AAC_SCAL:
401       case AOT_DRM_AAC:
402       case AOT_DRM_SURROUND:
403         if (CreatePsDec(&self->hParametricStereoDec, samplesPerFrame)) {
404           sbrError = SBRDEC_CREATE_ERROR;
405           goto bail;
406         }
407         break;
408       default:
409         break;
410     }
411   }
412 
413   /* Init frame delay slot handling */
414   self->pSbrElement[elementIndex]->useFrameSlot = 0;
415   for (i = 0; i < ((1) + 1); i++) {
416     self->pSbrElement[elementIndex]->useHeaderSlot[i] = i;
417   }
418 
419 bail:
420 
421   return sbrError;
422 }
423 
424 /*!
425   \brief Assign QMF domain provided QMF channels to SBR channels.
426 
427   \return void
428 */
sbrDecoder_AssignQmfChannels2SbrChannels(HANDLE_SBRDECODER self)429 static void sbrDecoder_AssignQmfChannels2SbrChannels(HANDLE_SBRDECODER self) {
430   int ch, el, absCh_offset = 0;
431   for (el = 0; el < self->numSbrElements; el++) {
432     if (self->pSbrElement[el] != NULL) {
433       for (ch = 0; ch < self->pSbrElement[el]->nChannels; ch++) {
434         FDK_ASSERT(((absCh_offset + ch) < ((8) + (1))) &&
435                    ((absCh_offset + ch) < ((8) + (1))));
436         self->pSbrElement[el]->pSbrChannel[ch]->SbrDec.qmfDomainInCh =
437             &self->pQmfDomain->QmfDomainIn[absCh_offset + ch];
438         self->pSbrElement[el]->pSbrChannel[ch]->SbrDec.qmfDomainOutCh =
439             &self->pQmfDomain->QmfDomainOut[absCh_offset + ch];
440       }
441       absCh_offset += self->pSbrElement[el]->nChannels;
442     }
443   }
444 }
445 
sbrDecoder_Open(HANDLE_SBRDECODER * pSelf,HANDLE_FDK_QMF_DOMAIN pQmfDomain)446 SBR_ERROR sbrDecoder_Open(HANDLE_SBRDECODER *pSelf,
447                           HANDLE_FDK_QMF_DOMAIN pQmfDomain) {
448   HANDLE_SBRDECODER self = NULL;
449   SBR_ERROR sbrError = SBRDEC_OK;
450   int elIdx;
451 
452   if ((pSelf == NULL) || (pQmfDomain == NULL)) {
453     return SBRDEC_INVALID_ARGUMENT;
454   }
455 
456   /* Get memory for this instance */
457   self = GetRam_SbrDecoder();
458   if (self == NULL) {
459     sbrError = SBRDEC_MEM_ALLOC_FAILED;
460     goto bail;
461   }
462 
463   self->pQmfDomain = pQmfDomain;
464 
465   /*
466   Already zero because of calloc
467   self->numSbrElements = 0;
468   self->numSbrChannels = 0;
469   self->codecFrameSize = 0;
470   */
471 
472   self->numDelayFrames = (1); /* set to the max value by default */
473 
474   /* Initialize header sync state */
475   for (elIdx = 0; elIdx < (8); elIdx += 1) {
476     int i;
477     for (i = 0; i < (1) + 1; i += 1) {
478       self->sbrHeader[elIdx][i].syncState = SBR_NOT_INITIALIZED;
479     }
480   }
481 
482   *pSelf = self;
483 
484 bail:
485   return sbrError;
486 }
487 
488 /**
489  * \brief determine if the given core codec AOT can be processed or not.
490  * \param coreCodec core codec audio object type.
491  * \return 1 if SBR can be processed, 0 if SBR cannot be processed/applied.
492  */
sbrDecoder_isCoreCodecValid(AUDIO_OBJECT_TYPE coreCodec)493 static int sbrDecoder_isCoreCodecValid(AUDIO_OBJECT_TYPE coreCodec) {
494   switch (coreCodec) {
495     case AOT_AAC_LC:
496     case AOT_SBR:
497     case AOT_PS:
498     case AOT_ER_AAC_SCAL:
499     case AOT_ER_AAC_ELD:
500     case AOT_DRM_AAC:
501     case AOT_DRM_SURROUND:
502     case AOT_USAC:
503       return 1;
504     default:
505       return 0;
506   }
507 }
508 
sbrDecoder_DestroyElement(HANDLE_SBRDECODER self,const int elementIndex)509 static void sbrDecoder_DestroyElement(HANDLE_SBRDECODER self,
510                                       const int elementIndex) {
511   if (self->pSbrElement[elementIndex] != NULL) {
512     int ch;
513 
514     for (ch = 0; ch < SBRDEC_MAX_CH_PER_ELEMENT; ch++) {
515       if (self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) {
516         deleteSbrDec(self->pSbrElement[elementIndex]->pSbrChannel[ch]);
517         FreeRam_SbrDecChannel(
518             &self->pSbrElement[elementIndex]->pSbrChannel[ch]);
519         self->numSbrChannels -= 1;
520       }
521     }
522     FreeRam_SbrDecElement(&self->pSbrElement[elementIndex]);
523     self->numSbrElements -= 1;
524   }
525 }
526 
sbrDecoder_InitElement(HANDLE_SBRDECODER self,const int sampleRateIn,const int sampleRateOut,const int samplesPerFrame,const AUDIO_OBJECT_TYPE coreCodec,const MP4_ELEMENT_ID elementID,const int elementIndex,const UCHAR harmonicSBR,const UCHAR stereoConfigIndex,const UCHAR configMode,UCHAR * configChanged,const INT downscaleFactor)527 SBR_ERROR sbrDecoder_InitElement(
528     HANDLE_SBRDECODER self, const int sampleRateIn, const int sampleRateOut,
529     const int samplesPerFrame, const AUDIO_OBJECT_TYPE coreCodec,
530     const MP4_ELEMENT_ID elementID, const int elementIndex,
531     const UCHAR harmonicSBR, const UCHAR stereoConfigIndex,
532     const UCHAR configMode, UCHAR *configChanged, const INT downscaleFactor) {
533   SBR_ERROR sbrError = SBRDEC_OK;
534   int chCnt = 0;
535   int nSbrElementsStart;
536   int nSbrChannelsStart;
537   if (self == NULL) {
538     return SBRDEC_INVALID_ARGUMENT;
539   }
540 
541   nSbrElementsStart = self->numSbrElements;
542   nSbrChannelsStart = self->numSbrChannels;
543 
544   /* Check core codec AOT */
545   if (!sbrDecoder_isCoreCodecValid(coreCodec) || elementIndex >= (8)) {
546     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
547     goto bail;
548   }
549 
550   if (elementID != ID_SCE && elementID != ID_CPE && elementID != ID_LFE) {
551     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
552     goto bail;
553   }
554 
555   if (self->sampleRateIn == sampleRateIn &&
556       self->codecFrameSize == samplesPerFrame && self->coreCodec == coreCodec &&
557       self->pSbrElement[elementIndex] != NULL &&
558       self->pSbrElement[elementIndex]->elementID == elementID &&
559       !(self->flags & SBRDEC_FORCE_RESET) &&
560       ((sampleRateOut == 0) ? 1 : (self->sampleRateOut == sampleRateOut)) &&
561       ((harmonicSBR == 2) ? 1
562                           : (self->harmonicSBR ==
563                              harmonicSBR)) /* The value 2 signalizes that
564                                               harmonicSBR shall be ignored in
565                                               the config change detection */
566   ) {
567     /* Nothing to do */
568     return SBRDEC_OK;
569   } else {
570     if (configMode & AC_CM_DET_CFG_CHANGE) {
571       *configChanged = 1;
572     }
573   }
574 
575   /* reaching this point the SBR-decoder gets (re-)configured */
576 
577   /* The flags field is used for all elements! */
578   self->flags &=
579       (SBRDEC_FORCE_RESET | SBRDEC_FLUSH); /* Keep the global flags. They will
580                                               be reset after decoding. */
581   self->flags |= (downscaleFactor > 1) ? SBRDEC_ELD_DOWNSCALE : 0;
582   self->flags |= (coreCodec == AOT_ER_AAC_ELD) ? SBRDEC_ELD_GRID : 0;
583   self->flags |= (coreCodec == AOT_ER_AAC_SCAL) ? SBRDEC_SYNTAX_SCAL : 0;
584   self->flags |=
585       (coreCodec == AOT_DRM_AAC) ? SBRDEC_SYNTAX_SCAL | SBRDEC_SYNTAX_DRM : 0;
586   self->flags |= (coreCodec == AOT_DRM_SURROUND)
587                      ? SBRDEC_SYNTAX_SCAL | SBRDEC_SYNTAX_DRM
588                      : 0;
589   self->flags |= (coreCodec == AOT_USAC) ? SBRDEC_SYNTAX_USAC : 0;
590   /* Robustness: Take integer division rounding into consideration. E.g. 22050
591    * Hz with 4:1 SBR => 5512 Hz core sampling rate. */
592   self->flags |= (sampleRateIn == sampleRateOut / 4) ? SBRDEC_QUAD_RATE : 0;
593   self->flags |= (harmonicSBR == 1) ? SBRDEC_USAC_HARMONICSBR : 0;
594 
595   if (configMode & AC_CM_DET_CFG_CHANGE) {
596     return SBRDEC_OK;
597   }
598 
599   self->sampleRateIn = sampleRateIn;
600   self->codecFrameSize = samplesPerFrame;
601   self->coreCodec = coreCodec;
602   self->harmonicSBR = harmonicSBR;
603   self->downscaleFactor = downscaleFactor;
604 
605   /* Init SBR elements */
606   {
607     int elChannels, ch;
608 
609     if (self->pSbrElement[elementIndex] == NULL) {
610       self->pSbrElement[elementIndex] = GetRam_SbrDecElement(elementIndex);
611       if (self->pSbrElement[elementIndex] == NULL) {
612         sbrError = SBRDEC_MEM_ALLOC_FAILED;
613         goto bail;
614       }
615       self->numSbrElements++;
616     } else {
617       self->numSbrChannels -= self->pSbrElement[elementIndex]->nChannels;
618     }
619 
620     /* Determine amount of channels for this element */
621     switch (elementID) {
622       case ID_NONE:
623       case ID_CPE:
624         elChannels = 2;
625         break;
626       case ID_LFE:
627       case ID_SCE:
628         elChannels = 1;
629         break;
630       default:
631         elChannels = 0;
632         break;
633     }
634 
635     /* Handle case of Parametric Stereo */
636     if (elementIndex == 0 && elementID == ID_SCE) {
637       switch (coreCodec) {
638         case AOT_AAC_LC:
639         case AOT_SBR:
640         case AOT_PS:
641         case AOT_ER_AAC_SCAL:
642         case AOT_DRM_AAC:
643         case AOT_DRM_SURROUND:
644           elChannels = 2;
645           break;
646         default:
647           break;
648       }
649     }
650 
651     /* Sanity check to avoid memory leaks */
652     if (elChannels < self->pSbrElement[elementIndex]->nChannels ||
653         (self->numSbrChannels + elChannels) > (8) + (1)) {
654       self->numSbrChannels += self->pSbrElement[elementIndex]->nChannels;
655       sbrError = SBRDEC_PARSE_ERROR;
656       goto bail;
657     }
658 
659     /* Save element ID for sanity checks and to have a fallback for concealment.
660      */
661     self->pSbrElement[elementIndex]->elementID = elementID;
662     self->pSbrElement[elementIndex]->nChannels = elChannels;
663 
664     for (ch = 0; ch < elChannels; ch++) {
665       if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
666         self->pSbrElement[elementIndex]->pSbrChannel[ch] =
667             GetRam_SbrDecChannel(chCnt);
668         if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
669           sbrError = SBRDEC_MEM_ALLOC_FAILED;
670           goto bail;
671         }
672       }
673       self->numSbrChannels++;
674 
675       sbrDecoder_drcInitChannel(&self->pSbrElement[elementIndex]
676                                      ->pSbrChannel[ch]
677                                      ->SbrDec.sbrDrcChannel);
678 
679       chCnt++;
680     }
681   }
682 
683   if (!self->pQmfDomain->globalConf.qmfDomainExplicitConfig) {
684     self->pQmfDomain->globalConf.nInputChannels_requested =
685         self->numSbrChannels;
686     self->pQmfDomain->globalConf.nOutputChannels_requested =
687         fMax((INT)self->numSbrChannels,
688              (INT)self->pQmfDomain->globalConf.nOutputChannels_requested);
689   }
690 
691   /* Make sure each SBR channel has one QMF channel assigned even if
692    * numSbrChannels or element set-up has changed. */
693   sbrDecoder_AssignQmfChannels2SbrChannels(self);
694 
695   /* clear error flags for all delay slots */
696   FDKmemclear(self->pSbrElement[elementIndex]->frameErrorFlag,
697               ((1) + 1) * sizeof(UCHAR));
698 
699   {
700     int overlap;
701 
702     if (coreCodec == AOT_ER_AAC_ELD) {
703       overlap = 0;
704     } else if (self->flags & SBRDEC_QUAD_RATE) {
705       overlap = (3 * 4);
706     } else {
707       overlap = (3 * 2);
708     }
709     /* Initialize this instance */
710     sbrError = sbrDecoder_ResetElement(self, sampleRateIn, sampleRateOut,
711                                        samplesPerFrame, elementID, elementIndex,
712                                        overlap);
713   }
714 
715 bail:
716   if (sbrError != SBRDEC_OK) {
717     if ((nSbrElementsStart < self->numSbrElements) ||
718         (nSbrChannelsStart < self->numSbrChannels)) {
719       /* Free the memory allocated for this element */
720       sbrDecoder_DestroyElement(self, elementIndex);
721     } else if ((elementIndex < (8)) &&
722                (self->pSbrElement[elementIndex] !=
723                 NULL)) { /* Set error flag to trigger concealment */
724       setFrameErrorFlag(self->pSbrElement[elementIndex], FRAME_ERROR);
725     }
726   }
727 
728   return sbrError;
729 }
730 
731 /**
732  * \brief Free config dependent SBR memory.
733  * \param self SBR decoder instance handle
734  */
sbrDecoder_FreeMem(HANDLE_SBRDECODER * self)735 SBR_ERROR sbrDecoder_FreeMem(HANDLE_SBRDECODER *self) {
736   int i;
737   int elIdx;
738 
739   if (self != NULL && *self != NULL) {
740     for (i = 0; i < (8); i++) {
741       sbrDecoder_DestroyElement(*self, i);
742     }
743 
744     for (elIdx = 0; elIdx < (8); elIdx += 1) {
745       for (i = 0; i < (1) + 1; i += 1) {
746         (*self)->sbrHeader[elIdx][i].syncState = SBR_NOT_INITIALIZED;
747       }
748     }
749   }
750 
751   return SBRDEC_OK;
752 }
753 
754 /**
755  * \brief Apply decoded SBR header for one element.
756  * \param self SBR decoder instance handle
757  * \param hSbrHeader SBR header handle to be processed.
758  * \param hSbrChannel pointer array to the SBR element channels corresponding to
759  * the SBR header.
760  * \param headerStatus header status value returned from SBR header parser.
761  * \param numElementChannels amount of channels for the SBR element whos header
762  * is to be processed.
763  */
sbrDecoder_HeaderUpdate(HANDLE_SBRDECODER self,HANDLE_SBR_HEADER_DATA hSbrHeader,SBR_HEADER_STATUS headerStatus,HANDLE_SBR_CHANNEL hSbrChannel[],const int numElementChannels)764 static SBR_ERROR sbrDecoder_HeaderUpdate(HANDLE_SBRDECODER self,
765                                          HANDLE_SBR_HEADER_DATA hSbrHeader,
766                                          SBR_HEADER_STATUS headerStatus,
767                                          HANDLE_SBR_CHANNEL hSbrChannel[],
768                                          const int numElementChannels) {
769   SBR_ERROR errorStatus = SBRDEC_OK;
770 
771   /*
772     change of control data, reset decoder
773   */
774   errorStatus = resetFreqBandTables(hSbrHeader, self->flags);
775 
776   if (errorStatus == SBRDEC_OK) {
777     if (hSbrHeader->syncState == UPSAMPLING && headerStatus != HEADER_RESET) {
778 #if (SBRDEC_MAX_HB_FADE_FRAMES > 0)
779       int ch;
780       for (ch = 0; ch < numElementChannels; ch += 1) {
781         hSbrChannel[ch]->SbrDec.highBandFadeCnt = SBRDEC_MAX_HB_FADE_FRAMES;
782       }
783 
784 #endif
785       /* As the default header would limit the frequency range,
786          lowSubband and highSubband must be patched. */
787       hSbrHeader->freqBandData.lowSubband = hSbrHeader->numberOfAnalysisBands;
788       hSbrHeader->freqBandData.highSubband = hSbrHeader->numberOfAnalysisBands;
789     }
790 
791     /* Trigger a reset before processing this slot */
792     hSbrHeader->status |= SBRDEC_HDR_STAT_RESET;
793   }
794 
795   return errorStatus;
796 }
797 
sbrDecoder_Header(HANDLE_SBRDECODER self,HANDLE_FDK_BITSTREAM hBs,const INT sampleRateIn,const INT sampleRateOut,const INT samplesPerFrame,const AUDIO_OBJECT_TYPE coreCodec,const MP4_ELEMENT_ID elementID,const INT elementIndex,const UCHAR harmonicSBR,const UCHAR stereoConfigIndex,const UCHAR configMode,UCHAR * configChanged,const INT downscaleFactor)798 INT sbrDecoder_Header(HANDLE_SBRDECODER self, HANDLE_FDK_BITSTREAM hBs,
799                       const INT sampleRateIn, const INT sampleRateOut,
800                       const INT samplesPerFrame,
801                       const AUDIO_OBJECT_TYPE coreCodec,
802                       const MP4_ELEMENT_ID elementID, const INT elementIndex,
803                       const UCHAR harmonicSBR, const UCHAR stereoConfigIndex,
804                       const UCHAR configMode, UCHAR *configChanged,
805                       const INT downscaleFactor) {
806   SBR_HEADER_STATUS headerStatus;
807   HANDLE_SBR_HEADER_DATA hSbrHeader;
808   SBR_ERROR sbrError = SBRDEC_OK;
809   int headerIndex;
810   UINT flagsSaved =
811       0; /* flags should not be changed in AC_CM_DET_CFG_CHANGE - mode after
812             parsing */
813 
814   if (self == NULL || elementIndex >= (8)) {
815     return SBRDEC_UNSUPPORTED_CONFIG;
816   }
817 
818   if (!sbrDecoder_isCoreCodecValid(coreCodec)) {
819     return SBRDEC_UNSUPPORTED_CONFIG;
820   }
821 
822   if (configMode & AC_CM_DET_CFG_CHANGE) {
823     flagsSaved = self->flags; /* store */
824   }
825 
826   sbrError = sbrDecoder_InitElement(
827       self, sampleRateIn, sampleRateOut, samplesPerFrame, coreCodec, elementID,
828       elementIndex, harmonicSBR, stereoConfigIndex, configMode, configChanged,
829       downscaleFactor);
830 
831   if ((sbrError != SBRDEC_OK) || (elementID == ID_LFE)) {
832     goto bail;
833   }
834 
835   if (configMode & AC_CM_DET_CFG_CHANGE) {
836     hSbrHeader = NULL;
837   } else {
838     headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
839                                 self->pSbrElement[elementIndex]->useHeaderSlot);
840 
841     hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
842   }
843 
844   headerStatus = sbrGetHeaderData(hSbrHeader, hBs, self->flags, 0, configMode);
845 
846   if (coreCodec == AOT_USAC) {
847     if (configMode & AC_CM_DET_CFG_CHANGE) {
848       self->flags = flagsSaved; /* restore */
849     }
850     return sbrError;
851   }
852 
853   if (configMode & AC_CM_ALLOC_MEM) {
854     SBR_DECODER_ELEMENT *pSbrElement;
855 
856     pSbrElement = self->pSbrElement[elementIndex];
857 
858     /* Sanity check */
859     if (pSbrElement != NULL) {
860       if ((elementID == ID_CPE && pSbrElement->nChannels != 2) ||
861           (elementID != ID_CPE && pSbrElement->nChannels != 1)) {
862         return SBRDEC_UNSUPPORTED_CONFIG;
863       }
864       if (headerStatus == HEADER_RESET) {
865         sbrError = sbrDecoder_HeaderUpdate(self, hSbrHeader, headerStatus,
866                                            pSbrElement->pSbrChannel,
867                                            pSbrElement->nChannels);
868 
869         if (sbrError == SBRDEC_OK) {
870           hSbrHeader->syncState = SBR_HEADER;
871           hSbrHeader->status |= SBRDEC_HDR_STAT_UPDATE;
872         } else {
873           hSbrHeader->syncState = SBR_NOT_INITIALIZED;
874           hSbrHeader->status = HEADER_ERROR;
875         }
876       }
877     }
878   }
879 bail:
880   if (configMode & AC_CM_DET_CFG_CHANGE) {
881     self->flags = flagsSaved; /* restore */
882   }
883   return sbrError;
884 }
885 
sbrDecoder_SetParam(HANDLE_SBRDECODER self,const SBRDEC_PARAM param,const INT value)886 SBR_ERROR sbrDecoder_SetParam(HANDLE_SBRDECODER self, const SBRDEC_PARAM param,
887                               const INT value) {
888   SBR_ERROR errorStatus = SBRDEC_OK;
889 
890   /* configure the subsystems */
891   switch (param) {
892     case SBR_SYSTEM_BITSTREAM_DELAY:
893       if (value < 0 || value > (1)) {
894         errorStatus = SBRDEC_SET_PARAM_FAIL;
895         break;
896       }
897       if (self == NULL) {
898         errorStatus = SBRDEC_NOT_INITIALIZED;
899       } else {
900         self->numDelayFrames = (UCHAR)value;
901       }
902       break;
903     case SBR_QMF_MODE:
904       if (self == NULL) {
905         errorStatus = SBRDEC_NOT_INITIALIZED;
906       } else {
907         if (value == 1) {
908           self->flags |= SBRDEC_LOW_POWER;
909         } else {
910           self->flags &= ~SBRDEC_LOW_POWER;
911         }
912       }
913       break;
914     case SBR_LD_QMF_TIME_ALIGN:
915       if (self == NULL) {
916         errorStatus = SBRDEC_NOT_INITIALIZED;
917       } else {
918         if (value == 1) {
919           self->flags |= SBRDEC_LD_MPS_QMF;
920         } else {
921           self->flags &= ~SBRDEC_LD_MPS_QMF;
922         }
923       }
924       break;
925     case SBR_FLUSH_DATA:
926       if (value != 0) {
927         if (self == NULL) {
928           errorStatus = SBRDEC_NOT_INITIALIZED;
929         } else {
930           self->flags |= SBRDEC_FLUSH;
931         }
932       }
933       break;
934     case SBR_CLEAR_HISTORY:
935       if (value != 0) {
936         if (self == NULL) {
937           errorStatus = SBRDEC_NOT_INITIALIZED;
938         } else {
939           self->flags |= SBRDEC_FORCE_RESET;
940         }
941       }
942       break;
943     case SBR_BS_INTERRUPTION: {
944       int elementIndex;
945 
946       if (self == NULL) {
947         errorStatus = SBRDEC_NOT_INITIALIZED;
948         break;
949       }
950 
951       /* Loop over SBR elements */
952       for (elementIndex = 0; elementIndex < self->numSbrElements;
953            elementIndex++) {
954         if (self->pSbrElement[elementIndex] != NULL) {
955           HANDLE_SBR_HEADER_DATA hSbrHeader;
956           int headerIndex =
957               getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
958                             self->pSbrElement[elementIndex]->useHeaderSlot);
959 
960           hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
961 
962           /* Set sync state UPSAMPLING for the corresponding slot.
963              This switches off bitstream parsing until a new header arrives. */
964           if (hSbrHeader->syncState != SBR_NOT_INITIALIZED) {
965             hSbrHeader->syncState = UPSAMPLING;
966             hSbrHeader->status |= SBRDEC_HDR_STAT_UPDATE;
967           }
968         }
969       }
970     } break;
971 
972     case SBR_SKIP_QMF:
973       if (self == NULL) {
974         errorStatus = SBRDEC_NOT_INITIALIZED;
975       } else {
976         if (value == 1) {
977           self->flags |= SBRDEC_SKIP_QMF_ANA;
978         } else {
979           self->flags &= ~SBRDEC_SKIP_QMF_ANA;
980         }
981         if (value == 2) {
982           self->flags |= SBRDEC_SKIP_QMF_SYN;
983         } else {
984           self->flags &= ~SBRDEC_SKIP_QMF_SYN;
985         }
986       }
987       break;
988     default:
989       errorStatus = SBRDEC_SET_PARAM_FAIL;
990       break;
991   } /* switch(param) */
992 
993   return (errorStatus);
994 }
995 
sbrDecoder_drcGetChannel(const HANDLE_SBRDECODER self,const INT channel)996 static SBRDEC_DRC_CHANNEL *sbrDecoder_drcGetChannel(
997     const HANDLE_SBRDECODER self, const INT channel) {
998   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
999   int elementIndex, elChanIdx = 0, numCh = 0;
1000 
1001   for (elementIndex = 0; (elementIndex < (8)) && (numCh <= channel);
1002        elementIndex++) {
1003     SBR_DECODER_ELEMENT *pSbrElement = self->pSbrElement[elementIndex];
1004     int c, elChannels;
1005 
1006     elChanIdx = 0;
1007     if (pSbrElement == NULL) break;
1008 
1009     /* Determine amount of channels for this element */
1010     switch (pSbrElement->elementID) {
1011       case ID_CPE:
1012         elChannels = 2;
1013         break;
1014       case ID_LFE:
1015       case ID_SCE:
1016         elChannels = 1;
1017         break;
1018       case ID_NONE:
1019       default:
1020         elChannels = 0;
1021         break;
1022     }
1023 
1024     /* Limit with actual allocated element channels */
1025     elChannels = fMin(elChannels, pSbrElement->nChannels);
1026 
1027     for (c = 0; (c < elChannels) && (numCh <= channel); c++) {
1028       if (pSbrElement->pSbrChannel[elChanIdx] != NULL) {
1029         numCh++;
1030         elChanIdx++;
1031       }
1032     }
1033   }
1034   elementIndex -= 1;
1035   elChanIdx -= 1;
1036 
1037   if (elChanIdx < 0 || elementIndex < 0) {
1038     return NULL;
1039   }
1040 
1041   if (self->pSbrElement[elementIndex] != NULL) {
1042     if (self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx] != NULL) {
1043       pSbrDrcChannelData = &self->pSbrElement[elementIndex]
1044                                 ->pSbrChannel[elChanIdx]
1045                                 ->SbrDec.sbrDrcChannel;
1046     }
1047   }
1048 
1049   return (pSbrDrcChannelData);
1050 }
1051 
sbrDecoder_drcFeedChannel(HANDLE_SBRDECODER self,INT ch,UINT numBands,FIXP_DBL * pNextFact_mag,INT nextFact_exp,SHORT drcInterpolationScheme,UCHAR winSequence,USHORT * pBandTop)1052 SBR_ERROR sbrDecoder_drcFeedChannel(HANDLE_SBRDECODER self, INT ch,
1053                                     UINT numBands, FIXP_DBL *pNextFact_mag,
1054                                     INT nextFact_exp,
1055                                     SHORT drcInterpolationScheme,
1056                                     UCHAR winSequence, USHORT *pBandTop) {
1057   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
1058   int band, isValidData = 0;
1059 
1060   if (self == NULL) {
1061     return SBRDEC_NOT_INITIALIZED;
1062   }
1063   if (ch > (8) || pNextFact_mag == NULL) {
1064     return SBRDEC_SET_PARAM_FAIL;
1065   }
1066 
1067   /* Search for gain values different to 1.0f */
1068   for (band = 0; band < (int)numBands; band += 1) {
1069     if (!((pNextFact_mag[band] == FL2FXCONST_DBL(0.5)) &&
1070           (nextFact_exp == 1)) &&
1071         !((pNextFact_mag[band] == (FIXP_DBL)MAXVAL_DBL) &&
1072           (nextFact_exp == 0))) {
1073       isValidData = 1;
1074       break;
1075     }
1076   }
1077 
1078   /* Find the right SBR channel */
1079   pSbrDrcChannelData = sbrDecoder_drcGetChannel(self, ch);
1080 
1081   if (pSbrDrcChannelData != NULL) {
1082     if (pSbrDrcChannelData->enable ||
1083         isValidData) { /* Activate processing only with real and valid data */
1084       int i;
1085 
1086       pSbrDrcChannelData->enable = 1;
1087       pSbrDrcChannelData->numBandsNext = numBands;
1088 
1089       pSbrDrcChannelData->winSequenceNext = winSequence;
1090       pSbrDrcChannelData->drcInterpolationSchemeNext = drcInterpolationScheme;
1091       pSbrDrcChannelData->nextFact_exp = nextFact_exp;
1092 
1093       for (i = 0; i < (int)numBands; i++) {
1094         pSbrDrcChannelData->bandTopNext[i] = pBandTop[i];
1095         pSbrDrcChannelData->nextFact_mag[i] = pNextFact_mag[i];
1096       }
1097     }
1098   }
1099 
1100   return SBRDEC_OK;
1101 }
1102 
sbrDecoder_drcDisable(HANDLE_SBRDECODER self,INT ch)1103 void sbrDecoder_drcDisable(HANDLE_SBRDECODER self, INT ch) {
1104   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
1105 
1106   if ((self == NULL) || (ch > (8)) || (self->numSbrElements == 0) ||
1107       (self->numSbrChannels == 0)) {
1108     return;
1109   }
1110 
1111   /* Find the right SBR channel */
1112   pSbrDrcChannelData = sbrDecoder_drcGetChannel(self, ch);
1113 
1114   if (pSbrDrcChannelData != NULL) {
1115     sbrDecoder_drcInitChannel(pSbrDrcChannelData);
1116   }
1117 }
1118 
sbrDecoder_Parse(HANDLE_SBRDECODER self,HANDLE_FDK_BITSTREAM hBs,UCHAR * pDrmBsBuffer,USHORT drmBsBufferSize,int * count,int bsPayLen,int crcFlag,MP4_ELEMENT_ID prevElement,int elementIndex,UINT acFlags,UINT acElFlags[])1119 SBR_ERROR sbrDecoder_Parse(HANDLE_SBRDECODER self, HANDLE_FDK_BITSTREAM hBs,
1120                            UCHAR *pDrmBsBuffer, USHORT drmBsBufferSize,
1121                            int *count, int bsPayLen, int crcFlag,
1122                            MP4_ELEMENT_ID prevElement, int elementIndex,
1123                            UINT acFlags, UINT acElFlags[]) {
1124   SBR_DECODER_ELEMENT *hSbrElement = NULL;
1125   HANDLE_SBR_HEADER_DATA hSbrHeader = NULL;
1126   HANDLE_SBR_CHANNEL *pSbrChannel;
1127 
1128   SBR_FRAME_DATA *hFrameDataLeft = NULL;
1129   SBR_FRAME_DATA *hFrameDataRight = NULL;
1130   SBR_FRAME_DATA frameDataLeftCopy;
1131   SBR_FRAME_DATA frameDataRightCopy;
1132 
1133   SBR_ERROR errorStatus = SBRDEC_OK;
1134   SBR_HEADER_STATUS headerStatus = HEADER_NOT_PRESENT;
1135 
1136   INT startPos = FDKgetValidBits(hBs);
1137   FDK_CRCINFO crcInfo;
1138   INT crcReg = 0;
1139   USHORT sbrCrc = 0;
1140   UINT crcPoly;
1141   UINT crcStartValue = 0;
1142   UINT crcLen;
1143 
1144   HANDLE_FDK_BITSTREAM hBsOriginal = hBs;
1145   FDK_BITSTREAM bsBwd;
1146 
1147   const int fGlobalIndependencyFlag = acFlags & AC_INDEP;
1148   const int bs_pvc = acElFlags[elementIndex] & AC_EL_USAC_PVC;
1149   const int bs_interTes = acElFlags[elementIndex] & AC_EL_USAC_ITES;
1150   int stereo;
1151   int fDoDecodeSbrData = 1;
1152   int alignBits = 0;
1153 
1154   int lastSlot, lastHdrSlot = 0, thisHdrSlot = 0;
1155 
1156   if (*count <= 0) {
1157     setFrameErrorFlag(self->pSbrElement[elementIndex], FRAME_ERROR);
1158     return SBRDEC_OK;
1159   }
1160 
1161   /* SBR sanity checks */
1162   if (self == NULL) {
1163     errorStatus = SBRDEC_NOT_INITIALIZED;
1164     goto bail;
1165   }
1166 
1167   /* Reverse bits of DRM SBR payload */
1168   if ((self->flags & SBRDEC_SYNTAX_DRM) && *count > 0) {
1169     int dataBytes, dataBits;
1170 
1171     FDK_ASSERT(drmBsBufferSize >= (512));
1172     dataBits = *count;
1173 
1174     if (dataBits > ((512) * 8)) {
1175       /* do not flip more data than needed */
1176       dataBits = (512) * 8;
1177     }
1178 
1179     dataBytes = (dataBits + 7) >> 3;
1180 
1181     int j;
1182 
1183     if ((j = (int)FDKgetValidBits(hBs)) != 8) {
1184       FDKpushBiDirectional(hBs, (j - 8));
1185     }
1186 
1187     j = 0;
1188     for (; dataBytes > 0; dataBytes--) {
1189       int i;
1190       UCHAR tmpByte;
1191       UCHAR buffer = 0x00;
1192 
1193       tmpByte = (UCHAR)FDKreadBits(hBs, 8);
1194       for (i = 0; i < 4; i++) {
1195         int shift = 2 * i + 1;
1196         buffer |= (tmpByte & (0x08 >> i)) << shift;
1197         buffer |= (tmpByte & (0x10 << i)) >> shift;
1198       }
1199       pDrmBsBuffer[j++] = buffer;
1200       FDKpushBack(hBs, 16);
1201     }
1202 
1203     FDKinitBitStream(&bsBwd, pDrmBsBuffer, (512), dataBits, BS_READER);
1204 
1205     /* Use reversed data */
1206     hBs = &bsBwd;
1207     bsPayLen = *count;
1208   }
1209 
1210   /* Remember start position of  SBR element */
1211   startPos = FDKgetValidBits(hBs);
1212 
1213   /* SBR sanity checks */
1214   if (self->pSbrElement[elementIndex] == NULL) {
1215     errorStatus = SBRDEC_NOT_INITIALIZED;
1216     goto bail;
1217   }
1218   hSbrElement = self->pSbrElement[elementIndex];
1219 
1220   lastSlot = (hSbrElement->useFrameSlot > 0) ? hSbrElement->useFrameSlot - 1
1221                                              : self->numDelayFrames;
1222   lastHdrSlot = hSbrElement->useHeaderSlot[lastSlot];
1223   thisHdrSlot = getHeaderSlot(
1224       hSbrElement->useFrameSlot,
1225       hSbrElement->useHeaderSlot); /* Get a free header slot not used by
1226                                       frames not processed yet. */
1227 
1228   /* Assign the free slot to store a new header if there is one. */
1229   hSbrHeader = &self->sbrHeader[elementIndex][thisHdrSlot];
1230 
1231   pSbrChannel = hSbrElement->pSbrChannel;
1232   stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
1233 
1234   hFrameDataLeft = &self->pSbrElement[elementIndex]
1235                         ->pSbrChannel[0]
1236                         ->frameData[hSbrElement->useFrameSlot];
1237   if (stereo) {
1238     hFrameDataRight = &self->pSbrElement[elementIndex]
1239                            ->pSbrChannel[1]
1240                            ->frameData[hSbrElement->useFrameSlot];
1241   }
1242 
1243   /* store frameData; new parsed frameData possibly corrupted */
1244   FDKmemcpy(&frameDataLeftCopy, hFrameDataLeft, sizeof(SBR_FRAME_DATA));
1245   if (stereo) {
1246     FDKmemcpy(&frameDataRightCopy, hFrameDataRight, sizeof(SBR_FRAME_DATA));
1247   }
1248 
1249   /* reset PS flag; will be set after PS was found */
1250   self->flags &= ~SBRDEC_PS_DECODED;
1251 
1252   if (hSbrHeader->status & SBRDEC_HDR_STAT_UPDATE) {
1253     /* Got a new header from extern (e.g. from an ASC) */
1254     headerStatus = HEADER_OK;
1255     hSbrHeader->status &= ~SBRDEC_HDR_STAT_UPDATE;
1256   } else if (thisHdrSlot != lastHdrSlot) {
1257     /* Copy the last header into this slot otherwise the
1258        header compare will trigger more HEADER_RESETs than needed. */
1259     copySbrHeader(hSbrHeader, &self->sbrHeader[elementIndex][lastHdrSlot]);
1260   }
1261 
1262   /*
1263      Check if bit stream data is valid and matches the element context
1264   */
1265   if (((prevElement != ID_SCE) && (prevElement != ID_CPE)) ||
1266       prevElement != hSbrElement->elementID) {
1267     /* In case of LFE we also land here, since there is no LFE SBR element (do
1268      * upsampling only) */
1269     fDoDecodeSbrData = 0;
1270   }
1271 
1272   if (fDoDecodeSbrData) {
1273     if ((INT)FDKgetValidBits(hBs) <= 0) {
1274       fDoDecodeSbrData = 0;
1275     }
1276   }
1277 
1278   /*
1279      SBR CRC-check
1280   */
1281   if (fDoDecodeSbrData) {
1282     if (crcFlag) {
1283       switch (self->coreCodec) {
1284         case AOT_DRM_AAC:
1285         case AOT_DRM_SURROUND:
1286           crcPoly = 0x001d;
1287           crcLen = 8;
1288           crcStartValue = 0x000000ff;
1289           break;
1290         default:
1291           crcPoly = 0x0633;
1292           crcLen = 10;
1293           crcStartValue = 0x00000000;
1294           break;
1295       }
1296       sbrCrc = (USHORT)FDKreadBits(hBs, crcLen);
1297       /* Setup CRC decoder */
1298       FDKcrcInit(&crcInfo, crcPoly, crcStartValue, crcLen);
1299       /* Start CRC region */
1300       crcReg = FDKcrcStartReg(&crcInfo, hBs, 0);
1301     }
1302   } /* if (fDoDecodeSbrData) */
1303 
1304   /*
1305      Read in the header data and issue a reset if change occured
1306   */
1307   if (fDoDecodeSbrData) {
1308     int sbrHeaderPresent;
1309 
1310     if (self->flags & (SBRDEC_SYNTAX_RSVD50 | SBRDEC_SYNTAX_USAC)) {
1311       SBR_HEADER_DATA_BS_INFO newSbrInfo;
1312       int sbrInfoPresent;
1313 
1314       if (bs_interTes) {
1315         self->flags |= SBRDEC_USAC_ITES;
1316       } else {
1317         self->flags &= ~SBRDEC_USAC_ITES;
1318       }
1319 
1320       if (fGlobalIndependencyFlag) {
1321         self->flags |= SBRDEC_USAC_INDEP;
1322         sbrInfoPresent = 1;
1323         sbrHeaderPresent = 1;
1324       } else {
1325         self->flags &= ~SBRDEC_USAC_INDEP;
1326         sbrInfoPresent = FDKreadBit(hBs);
1327         if (sbrInfoPresent) {
1328           sbrHeaderPresent = FDKreadBit(hBs);
1329         } else {
1330           sbrHeaderPresent = 0;
1331         }
1332       }
1333 
1334       if (sbrInfoPresent) {
1335         newSbrInfo.ampResolution = FDKreadBit(hBs);
1336         newSbrInfo.xover_band = FDKreadBits(hBs, 4);
1337         newSbrInfo.sbr_preprocessing = FDKreadBit(hBs);
1338         if (bs_pvc) {
1339           newSbrInfo.pvc_mode = FDKreadBits(hBs, 2);
1340           /* bs_pvc_mode: 0 -> no PVC, 1 -> PVC mode 1, 2 -> PVC mode 2, 3 ->
1341            * reserved */
1342           if (newSbrInfo.pvc_mode > 2) {
1343             headerStatus = HEADER_ERROR;
1344           }
1345           if (stereo && newSbrInfo.pvc_mode > 0) {
1346             /* bs_pvc is always transmitted but pvc_mode is set to zero in case
1347              * of stereo SBR. The config might be wrong but we cannot tell for
1348              * sure. */
1349             newSbrInfo.pvc_mode = 0;
1350           }
1351         } else {
1352           newSbrInfo.pvc_mode = 0;
1353         }
1354         if (headerStatus != HEADER_ERROR) {
1355           if (FDKmemcmp(&hSbrHeader->bs_info, &newSbrInfo,
1356                         sizeof(SBR_HEADER_DATA_BS_INFO))) {
1357             /* in case of ampResolution and preprocessing change no full reset
1358              * required    */
1359             /* HEADER reset would trigger HBE transposer reset which breaks
1360              * eSbr_3_Eaa.mp4 */
1361             if ((hSbrHeader->bs_info.pvc_mode != newSbrInfo.pvc_mode) ||
1362                 (hSbrHeader->bs_info.xover_band != newSbrInfo.xover_band)) {
1363               headerStatus = HEADER_RESET;
1364             } else {
1365               headerStatus = HEADER_OK;
1366             }
1367 
1368             hSbrHeader->bs_info = newSbrInfo;
1369           } else {
1370             headerStatus = HEADER_OK;
1371           }
1372         }
1373       }
1374       if (headerStatus == HEADER_ERROR) {
1375         /* Corrupt SBR info data, do not decode and switch to UPSAMPLING */
1376         hSbrHeader->syncState = hSbrHeader->syncState > UPSAMPLING
1377                                     ? UPSAMPLING
1378                                     : hSbrHeader->syncState;
1379         fDoDecodeSbrData = 0;
1380         sbrHeaderPresent = 0;
1381       }
1382 
1383       if (sbrHeaderPresent && fDoDecodeSbrData) {
1384         int useDfltHeader;
1385 
1386         useDfltHeader = FDKreadBit(hBs);
1387 
1388         if (useDfltHeader) {
1389           sbrHeaderPresent = 0;
1390           if (FDKmemcmp(&hSbrHeader->bs_data, &hSbrHeader->bs_dflt,
1391                         sizeof(SBR_HEADER_DATA_BS)) ||
1392               hSbrHeader->syncState != SBR_ACTIVE) {
1393             hSbrHeader->bs_data = hSbrHeader->bs_dflt;
1394             headerStatus = HEADER_RESET;
1395           }
1396         }
1397       }
1398     } else {
1399       sbrHeaderPresent = FDKreadBit(hBs);
1400     }
1401 
1402     if (sbrHeaderPresent) {
1403       headerStatus = sbrGetHeaderData(hSbrHeader, hBs, self->flags, 1, 0);
1404     }
1405 
1406     if (headerStatus == HEADER_RESET) {
1407       errorStatus = sbrDecoder_HeaderUpdate(
1408           self, hSbrHeader, headerStatus, pSbrChannel, hSbrElement->nChannels);
1409 
1410       if (errorStatus == SBRDEC_OK) {
1411         hSbrHeader->syncState = SBR_HEADER;
1412       } else {
1413         hSbrHeader->syncState = SBR_NOT_INITIALIZED;
1414         headerStatus = HEADER_ERROR;
1415       }
1416     }
1417 
1418     if (errorStatus != SBRDEC_OK) {
1419       fDoDecodeSbrData = 0;
1420     }
1421   } /* if (fDoDecodeSbrData) */
1422 
1423   /*
1424     Print debugging output only if state has changed
1425   */
1426 
1427   /* read frame data */
1428   if ((hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) {
1429     int sbrFrameOk;
1430     /* read the SBR element data */
1431     if (!stereo && (self->hParametricStereoDec != NULL)) {
1432       /* update slot index for PS bitstream parsing */
1433       self->hParametricStereoDec->bsLastSlot =
1434           self->hParametricStereoDec->bsReadSlot;
1435       self->hParametricStereoDec->bsReadSlot = hSbrElement->useFrameSlot;
1436     }
1437     sbrFrameOk = sbrGetChannelElement(
1438         hSbrHeader, hFrameDataLeft, (stereo) ? hFrameDataRight : NULL,
1439         &pSbrChannel[0]->prevFrameData,
1440         pSbrChannel[0]->SbrDec.PvcStaticData.pvc_mode_last, hBs,
1441         (stereo) ? NULL : self->hParametricStereoDec, self->flags,
1442         self->pSbrElement[elementIndex]->transposerSettings.overlap);
1443 
1444     if (!sbrFrameOk) {
1445       fDoDecodeSbrData = 0;
1446     } else {
1447       INT valBits;
1448 
1449       if (bsPayLen > 0) {
1450         valBits = bsPayLen - ((INT)startPos - (INT)FDKgetValidBits(hBs));
1451       } else {
1452         valBits = (INT)FDKgetValidBits(hBs);
1453       }
1454 
1455       /* sanity check of remaining bits */
1456       if (valBits < 0) {
1457         fDoDecodeSbrData = 0;
1458       } else {
1459         switch (self->coreCodec) {
1460           case AOT_SBR:
1461           case AOT_PS:
1462           case AOT_AAC_LC: {
1463             /* This sanity check is only meaningful with General Audio
1464              * bitstreams */
1465             alignBits = valBits & 0x7;
1466 
1467             if (valBits > alignBits) {
1468               fDoDecodeSbrData = 0;
1469             }
1470           } break;
1471           default:
1472             /* No sanity check available */
1473             break;
1474         }
1475       }
1476     }
1477   } else {
1478     /* The returned bit count will not be the actual payload size since we did
1479        not parse the frame data. Return an error so that the caller can react
1480        respectively. */
1481     errorStatus = SBRDEC_PARSE_ERROR;
1482   }
1483 
1484   if (crcFlag && (hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) {
1485     FDKpushFor(hBs, alignBits);
1486     FDKcrcEndReg(&crcInfo, hBs, crcReg); /* End CRC region */
1487     FDKpushBack(hBs, alignBits);
1488     /* Check CRC */
1489     if ((FDKcrcGetCRC(&crcInfo) ^ crcStartValue) != sbrCrc) {
1490       fDoDecodeSbrData = 0;
1491       if (headerStatus != HEADER_NOT_PRESENT) {
1492         headerStatus = HEADER_ERROR;
1493         hSbrHeader->syncState = SBR_NOT_INITIALIZED;
1494       }
1495     }
1496   }
1497 
1498   if (!fDoDecodeSbrData) {
1499     /* Set error flag for this slot to trigger concealment */
1500     setFrameErrorFlag(self->pSbrElement[elementIndex], FRAME_ERROR);
1501     /* restore old frameData for concealment */
1502     FDKmemcpy(hFrameDataLeft, &frameDataLeftCopy, sizeof(SBR_FRAME_DATA));
1503     if (stereo) {
1504       FDKmemcpy(hFrameDataRight, &frameDataRightCopy, sizeof(SBR_FRAME_DATA));
1505     }
1506     errorStatus = SBRDEC_PARSE_ERROR;
1507   } else {
1508     /* Everything seems to be ok so clear the error flag */
1509     setFrameErrorFlag(self->pSbrElement[elementIndex], FRAME_OK);
1510   }
1511 
1512   if (!stereo) {
1513     /* Turn coupling off explicitely to avoid access to absent right frame data
1514        that might occur with corrupt bitstreams. */
1515     hFrameDataLeft->coupling = COUPLING_OFF;
1516   }
1517 
1518 bail:
1519 
1520   if (self != NULL) {
1521     if (self->flags & SBRDEC_SYNTAX_DRM) {
1522       hBs = hBsOriginal;
1523     }
1524 
1525     if (errorStatus != SBRDEC_NOT_INITIALIZED) {
1526       int useOldHdr =
1527           ((headerStatus == HEADER_NOT_PRESENT) ||
1528            (headerStatus == HEADER_ERROR) ||
1529            (headerStatus == HEADER_RESET && errorStatus == SBRDEC_PARSE_ERROR))
1530               ? 1
1531               : 0;
1532 
1533       if (!useOldHdr && (thisHdrSlot != lastHdrSlot) && (hSbrHeader != NULL)) {
1534         useOldHdr |=
1535             (compareSbrHeader(hSbrHeader,
1536                               &self->sbrHeader[elementIndex][lastHdrSlot]) == 0)
1537                 ? 1
1538                 : 0;
1539       }
1540 
1541       if (hSbrElement != NULL) {
1542         if (useOldHdr != 0) {
1543           /* Use the old header for this frame */
1544           hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = lastHdrSlot;
1545         } else {
1546           /* Use the new header for this frame */
1547           hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = thisHdrSlot;
1548         }
1549 
1550         /* Move frame pointer to the next slot which is up to be decoded/applied
1551          * next */
1552         hSbrElement->useFrameSlot =
1553             (hSbrElement->useFrameSlot + 1) % (self->numDelayFrames + 1);
1554       }
1555     }
1556   }
1557 
1558   *count -= startPos - (INT)FDKgetValidBits(hBs);
1559 
1560   return errorStatus;
1561 }
1562 
1563 /**
1564  * \brief Render one SBR element into time domain signal.
1565  * \param self SBR decoder handle
1566  * \param timeData pointer to output buffer
1567  * \param channelMapping pointer to UCHAR array where next 2 channel offsets are
1568  * stored.
1569  * \param elementIndex enumerating index of the SBR element to render.
1570  * \param numInChannels number of channels from core coder.
1571  * \param numOutChannels pointer to a location to return number of output
1572  * channels.
1573  * \param psPossible flag indicating if PS is possible or not.
1574  * \return SBRDEC_OK if successfull, else error code
1575  */
sbrDecoder_DecodeElement(HANDLE_SBRDECODER self,LONG * input,LONG * timeData,const int timeDataSize,const FDK_channelMapDescr * const mapDescr,const int mapIdx,int channelIndex,const int elementIndex,const int numInChannels,int * numOutChannels,const int psPossible)1576 static SBR_ERROR sbrDecoder_DecodeElement(
1577     HANDLE_SBRDECODER self, LONG *input, LONG *timeData, const int timeDataSize,
1578     const FDK_channelMapDescr *const mapDescr, const int mapIdx,
1579     int channelIndex, const int elementIndex, const int numInChannels,
1580     int *numOutChannels, const int psPossible) {
1581   SBR_DECODER_ELEMENT *hSbrElement = self->pSbrElement[elementIndex];
1582   HANDLE_SBR_CHANNEL *pSbrChannel =
1583       self->pSbrElement[elementIndex]->pSbrChannel;
1584   HANDLE_SBR_HEADER_DATA hSbrHeader =
1585       &self->sbrHeader[elementIndex]
1586                       [hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot]];
1587   HANDLE_PS_DEC h_ps_d = self->hParametricStereoDec;
1588 
1589   /* get memory for frame data from scratch */
1590   SBR_FRAME_DATA *hFrameDataLeft = NULL;
1591   SBR_FRAME_DATA *hFrameDataRight = NULL;
1592 
1593   SBR_ERROR errorStatus = SBRDEC_OK;
1594 
1595   INT strideOut, offset0 = 255, offset0_block = 0, offset1 = 255,
1596                  offset1_block = 0;
1597   INT codecFrameSize = self->codecFrameSize;
1598 
1599   int stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
1600   int numElementChannels =
1601       hSbrElement
1602           ->nChannels; /* Number of channels of the current SBR element */
1603 
1604   hFrameDataLeft =
1605       &hSbrElement->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
1606   if (stereo) {
1607     hFrameDataRight =
1608         &hSbrElement->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
1609   }
1610 
1611   if (self->flags & SBRDEC_FLUSH) {
1612     if (self->numFlushedFrames > self->numDelayFrames) {
1613       int hdrIdx;
1614       /* No valid SBR payload available, hence switch to upsampling (in all
1615        * headers) */
1616       for (hdrIdx = 0; hdrIdx < ((1) + 1); hdrIdx += 1) {
1617         if (self->sbrHeader[elementIndex][hdrIdx].syncState > UPSAMPLING) {
1618           self->sbrHeader[elementIndex][hdrIdx].syncState = UPSAMPLING;
1619         }
1620       }
1621     } else {
1622       /* Move frame pointer to the next slot which is up to be decoded/applied
1623        * next */
1624       hSbrElement->useFrameSlot =
1625           (hSbrElement->useFrameSlot + 1) % (self->numDelayFrames + 1);
1626       /* Update header and frame data pointer because they have already been set
1627        */
1628       hSbrHeader =
1629           &self->sbrHeader[elementIndex]
1630                           [hSbrElement
1631                                ->useHeaderSlot[hSbrElement->useFrameSlot]];
1632       hFrameDataLeft =
1633           &hSbrElement->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
1634       if (stereo) {
1635         hFrameDataRight =
1636             &hSbrElement->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
1637       }
1638     }
1639   }
1640 
1641   /* Update the header error flag */
1642   hSbrHeader->frameErrorFlag =
1643       hSbrElement->frameErrorFlag[hSbrElement->useFrameSlot];
1644 
1645   /*
1646      Prepare filterbank for upsampling if no valid bit stream data is available.
1647    */
1648   if (hSbrHeader->syncState == SBR_NOT_INITIALIZED) {
1649     errorStatus =
1650         initHeaderData(hSbrHeader, self->sampleRateIn, self->sampleRateOut,
1651                        self->downscaleFactor, codecFrameSize, self->flags,
1652                        1 /* SET_DEFAULT_HDR */
1653         );
1654 
1655     if (errorStatus != SBRDEC_OK) {
1656       return errorStatus;
1657     }
1658 
1659     hSbrHeader->syncState = UPSAMPLING;
1660 
1661     errorStatus = sbrDecoder_HeaderUpdate(self, hSbrHeader, HEADER_NOT_PRESENT,
1662                                           pSbrChannel, hSbrElement->nChannels);
1663 
1664     if (errorStatus != SBRDEC_OK) {
1665       hSbrHeader->syncState = SBR_NOT_INITIALIZED;
1666       return errorStatus;
1667     }
1668   }
1669 
1670   /* reset */
1671   if (hSbrHeader->status & SBRDEC_HDR_STAT_RESET) {
1672     int ch;
1673     int applySbrProc = (hSbrHeader->syncState == SBR_ACTIVE ||
1674                         (hSbrHeader->frameErrorFlag == 0 &&
1675                          hSbrHeader->syncState == SBR_HEADER));
1676     for (ch = 0; ch < numElementChannels; ch++) {
1677       SBR_ERROR errorStatusTmp = SBRDEC_OK;
1678 
1679       errorStatusTmp = resetSbrDec(
1680           &pSbrChannel[ch]->SbrDec, hSbrHeader, &pSbrChannel[ch]->prevFrameData,
1681           self->synDownsampleFac, self->flags, pSbrChannel[ch]->frameData);
1682 
1683       if (errorStatusTmp != SBRDEC_OK) {
1684         hSbrHeader->syncState = UPSAMPLING;
1685       }
1686     }
1687     if (applySbrProc) {
1688       hSbrHeader->status &= ~SBRDEC_HDR_STAT_RESET;
1689     }
1690   }
1691 
1692   /* decoding */
1693   if ((hSbrHeader->syncState == SBR_ACTIVE) ||
1694       ((hSbrHeader->syncState == SBR_HEADER) &&
1695        (hSbrHeader->frameErrorFlag == 0))) {
1696     errorStatus = SBRDEC_OK;
1697 
1698     decodeSbrData(hSbrHeader, hFrameDataLeft, &pSbrChannel[0]->prevFrameData,
1699                   (stereo) ? hFrameDataRight : NULL,
1700                   (stereo) ? &pSbrChannel[1]->prevFrameData : NULL);
1701 
1702     /* Now we have a full parameter set and can do parameter
1703        based concealment instead of plain upsampling. */
1704     hSbrHeader->syncState = SBR_ACTIVE;
1705   }
1706 
1707   if (timeDataSize <
1708       hSbrHeader->numberTimeSlots * hSbrHeader->timeStep *
1709           self->pQmfDomain->globalConf.nBandsSynthesis *
1710           (psPossible ? fMax(2, numInChannels) : numInChannels)) {
1711     return SBRDEC_OUTPUT_BUFFER_TOO_SMALL;
1712   }
1713 
1714   {
1715     self->flags &= ~SBRDEC_PS_DECODED;
1716     C_ALLOC_SCRATCH_START(pPsScratch, struct PS_DEC_COEFFICIENTS, 1)
1717 
1718     /* decode PS data if available */
1719     if (h_ps_d != NULL && psPossible && (hSbrHeader->syncState == SBR_ACTIVE)) {
1720       int applyPs = 1;
1721 
1722       /* define which frame delay line slot to process */
1723       h_ps_d->processSlot = hSbrElement->useFrameSlot;
1724 
1725       applyPs = DecodePs(h_ps_d, hSbrHeader->frameErrorFlag, pPsScratch);
1726       self->flags |= (applyPs) ? SBRDEC_PS_DECODED : 0;
1727     }
1728 
1729     offset0 = FDK_chMapDescr_getMapValue(mapDescr, channelIndex, mapIdx);
1730     offset0_block = offset0 * codecFrameSize;
1731     if (stereo || psPossible) {
1732       /* the value of offset1 only matters if the condition is true, however if
1733       it is not true channelIndex+1 may exceed the channel map resutling in an
1734       error, though the value of offset1 is actually meaningless. This is
1735       prevented here. */
1736       offset1 = FDK_chMapDescr_getMapValue(mapDescr, channelIndex + 1, mapIdx);
1737       offset1_block = offset1 * codecFrameSize;
1738     }
1739     /* Set strides for reading and writing */
1740     if (psPossible)
1741       strideOut = (numInChannels < 2) ? 2 : numInChannels;
1742     else
1743       strideOut = numInChannels;
1744 
1745     /* use same buffers for left and right channel and apply PS per timeslot */
1746     /* Process left channel */
1747     sbr_dec(&pSbrChannel[0]->SbrDec, input + offset0_block, timeData + offset0,
1748             (self->flags & SBRDEC_PS_DECODED) ? &pSbrChannel[1]->SbrDec : NULL,
1749             timeData + offset1, strideOut, hSbrHeader, hFrameDataLeft,
1750             &pSbrChannel[0]->prevFrameData,
1751             (hSbrHeader->syncState == SBR_ACTIVE), h_ps_d, self->flags,
1752             codecFrameSize, self->sbrInDataHeadroom);
1753 
1754     if (stereo) {
1755       /* Process right channel */
1756       sbr_dec(&pSbrChannel[1]->SbrDec, input + offset1_block,
1757               timeData + offset1, NULL, NULL, strideOut, hSbrHeader,
1758               hFrameDataRight, &pSbrChannel[1]->prevFrameData,
1759               (hSbrHeader->syncState == SBR_ACTIVE), NULL, self->flags,
1760               codecFrameSize, self->sbrInDataHeadroom);
1761     }
1762 
1763     C_ALLOC_SCRATCH_END(pPsScratch, struct PS_DEC_COEFFICIENTS, 1)
1764   }
1765 
1766   if (h_ps_d != NULL) {
1767     /* save PS status for next run */
1768     h_ps_d->psDecodedPrv = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0;
1769   }
1770 
1771   if (psPossible && !(self->flags & SBRDEC_SKIP_QMF_SYN)) {
1772     FDK_ASSERT(strideOut > 1);
1773     if (!(self->flags & SBRDEC_PS_DECODED)) {
1774       /* A decoder which is able to decode PS has to produce a stereo output
1775        * even if no PS data is available. */
1776       /* So copy left channel to right channel. */
1777       int copyFrameSize =
1778           codecFrameSize * self->pQmfDomain->QmfDomainOut->fb.no_channels;
1779       copyFrameSize /= self->pQmfDomain->QmfDomainIn->fb.no_channels;
1780       LONG *ptr;
1781       INT i;
1782       FDK_ASSERT(strideOut == 2);
1783 
1784       ptr = timeData;
1785       for (i = copyFrameSize >> 1; i--;) {
1786         LONG tmp; /* This temporal variable is required because some compilers
1787                      can't do *ptr++ = *ptr++ correctly. */
1788         tmp = *ptr++;
1789         *ptr++ = tmp;
1790         tmp = *ptr++;
1791         *ptr++ = tmp;
1792       }
1793     }
1794     *numOutChannels = 2; /* Output minimum two channels when PS is enabled. */
1795   }
1796 
1797   return errorStatus;
1798 }
1799 
sbrDecoder_Apply(HANDLE_SBRDECODER self,LONG * input,LONG * timeData,const int timeDataSize,int * numChannels,int * sampleRate,const FDK_channelMapDescr * const mapDescr,const int mapIdx,const int coreDecodedOk,UCHAR * psDecoded,const INT inDataHeadroom,INT * outDataHeadroom)1800 SBR_ERROR sbrDecoder_Apply(HANDLE_SBRDECODER self, LONG *input, LONG *timeData,
1801                            const int timeDataSize, int *numChannels,
1802                            int *sampleRate,
1803                            const FDK_channelMapDescr *const mapDescr,
1804                            const int mapIdx, const int coreDecodedOk,
1805                            UCHAR *psDecoded, const INT inDataHeadroom,
1806                            INT *outDataHeadroom) {
1807   SBR_ERROR errorStatus = SBRDEC_OK;
1808 
1809   int psPossible;
1810   int sbrElementNum;
1811   int numCoreChannels;
1812   int numSbrChannels = 0;
1813 
1814   if ((self == NULL) || (timeData == NULL) || (numChannels == NULL) ||
1815       (sampleRate == NULL) || (psDecoded == NULL) ||
1816       !FDK_chMapDescr_isValid(mapDescr)) {
1817     return SBRDEC_INVALID_ARGUMENT;
1818   }
1819 
1820   psPossible = *psDecoded;
1821   numCoreChannels = *numChannels;
1822   if (numCoreChannels <= 0) {
1823     return SBRDEC_INVALID_ARGUMENT;
1824   }
1825 
1826   if (self->numSbrElements < 1) {
1827     /* exit immediately to avoid access violations */
1828     return SBRDEC_NOT_INITIALIZED;
1829   }
1830 
1831   /* Sanity check of allocated SBR elements. */
1832   for (sbrElementNum = 0; sbrElementNum < self->numSbrElements;
1833        sbrElementNum++) {
1834     if (self->pSbrElement[sbrElementNum] == NULL) {
1835       return SBRDEC_NOT_INITIALIZED;
1836     }
1837   }
1838 
1839   if (self->numSbrElements != 1 || self->pSbrElement[0]->elementID != ID_SCE) {
1840     psPossible = 0;
1841   }
1842 
1843   self->sbrInDataHeadroom = inDataHeadroom;
1844   *outDataHeadroom = (INT)(8);
1845 
1846   /* Make sure that even if no SBR data was found/parsed *psDecoded is returned
1847    * 1 if psPossible was 0. */
1848   if (psPossible == 0) {
1849     self->flags &= ~SBRDEC_PS_DECODED;
1850   }
1851 
1852   /* replaces channel based reset inside sbr_dec() */
1853   if (((self->flags & SBRDEC_LOW_POWER) ? 1 : 0) !=
1854       ((self->pQmfDomain->globalConf.flags & QMF_FLAG_LP) ? 1 : 0)) {
1855     if (self->flags & SBRDEC_LOW_POWER) {
1856       self->pQmfDomain->globalConf.flags |= QMF_FLAG_LP;
1857       self->pQmfDomain->globalConf.flags_requested |= QMF_FLAG_LP;
1858     } else {
1859       self->pQmfDomain->globalConf.flags &= ~QMF_FLAG_LP;
1860       self->pQmfDomain->globalConf.flags_requested &= ~QMF_FLAG_LP;
1861     }
1862     if (FDK_QmfDomain_InitFilterBank(self->pQmfDomain, QMF_FLAG_KEEP_STATES)) {
1863       return SBRDEC_UNSUPPORTED_CONFIG;
1864     }
1865   }
1866   if (self->numSbrChannels > self->pQmfDomain->globalConf.nInputChannels) {
1867     return SBRDEC_UNSUPPORTED_CONFIG;
1868   }
1869 
1870   if (self->flags & SBRDEC_FLUSH) {
1871     /* flushing is signalized, hence increment the flush frame counter */
1872     self->numFlushedFrames++;
1873   } else {
1874     /* no flushing is signalized, hence reset the flush frame counter */
1875     self->numFlushedFrames = 0;
1876   }
1877 
1878   /* Loop over SBR elements */
1879   for (sbrElementNum = 0; sbrElementNum < self->numSbrElements;
1880        sbrElementNum++) {
1881     int numElementChan;
1882 
1883     if (psPossible &&
1884         self->pSbrElement[sbrElementNum]->pSbrChannel[1] == NULL) {
1885       /* Disable PS and try decoding SBR mono. */
1886       psPossible = 0;
1887     }
1888 
1889     numElementChan =
1890         (self->pSbrElement[sbrElementNum]->elementID == ID_CPE) ? 2 : 1;
1891 
1892     /* If core signal is bad then force upsampling */
1893     if (!coreDecodedOk) {
1894       setFrameErrorFlag(self->pSbrElement[sbrElementNum], FRAME_ERROR_ALLSLOTS);
1895     }
1896 
1897     errorStatus = sbrDecoder_DecodeElement(
1898         self, input, timeData, timeDataSize, mapDescr, mapIdx, numSbrChannels,
1899         sbrElementNum,
1900         numCoreChannels, /* is correct even for USC SCI==2 case */
1901         &numElementChan, psPossible);
1902 
1903     if (errorStatus != SBRDEC_OK) {
1904       goto bail;
1905     }
1906 
1907     numSbrChannels += numElementChan;
1908 
1909     if (numSbrChannels >= numCoreChannels) {
1910       break;
1911     }
1912   }
1913 
1914   /* Update numChannels and samplerate */
1915   /* Do not mess with output channels in case of USAC. numSbrChannels !=
1916    * numChannels for stereoConfigIndex == 2 */
1917   if (!(self->flags & SBRDEC_SYNTAX_USAC)) {
1918     *numChannels = numSbrChannels;
1919   }
1920   *sampleRate = self->sampleRateOut;
1921   *psDecoded = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0;
1922 
1923   /* Clear reset and flush flag because everything seems to be done
1924    * successfully. */
1925   self->flags &= ~SBRDEC_FORCE_RESET;
1926   self->flags &= ~SBRDEC_FLUSH;
1927 
1928 bail:
1929 
1930   return errorStatus;
1931 }
1932 
sbrDecoder_Close(HANDLE_SBRDECODER * pSelf)1933 SBR_ERROR sbrDecoder_Close(HANDLE_SBRDECODER *pSelf) {
1934   HANDLE_SBRDECODER self = *pSelf;
1935   int i;
1936 
1937   if (self != NULL) {
1938     if (self->hParametricStereoDec != NULL) {
1939       DeletePsDec(&self->hParametricStereoDec);
1940     }
1941 
1942     for (i = 0; i < (8); i++) {
1943       sbrDecoder_DestroyElement(self, i);
1944     }
1945 
1946     FreeRam_SbrDecoder(pSelf);
1947   }
1948 
1949   return SBRDEC_OK;
1950 }
1951 
sbrDecoder_GetLibInfo(LIB_INFO * info)1952 INT sbrDecoder_GetLibInfo(LIB_INFO *info) {
1953   int i;
1954 
1955   if (info == NULL) {
1956     return -1;
1957   }
1958 
1959   /* search for next free tab */
1960   for (i = 0; i < FDK_MODULE_LAST; i++) {
1961     if (info[i].module_id == FDK_NONE) break;
1962   }
1963   if (i == FDK_MODULE_LAST) return -1;
1964   info += i;
1965 
1966   info->module_id = FDK_SBRDEC;
1967   info->version =
1968       LIB_VERSION(SBRDECODER_LIB_VL0, SBRDECODER_LIB_VL1, SBRDECODER_LIB_VL2);
1969   LIB_VERSION_STRING(info);
1970   info->build_date = SBRDECODER_LIB_BUILD_DATE;
1971   info->build_time = SBRDECODER_LIB_BUILD_TIME;
1972   info->title = SBRDECODER_LIB_TITLE;
1973 
1974   /* Set flags */
1975   info->flags = 0 | CAPF_SBR_HQ | CAPF_SBR_LP | CAPF_SBR_PS_MPEG |
1976                 CAPF_SBR_DRM_BS | CAPF_SBR_CONCEALMENT | CAPF_SBR_DRC |
1977                 CAPF_SBR_ELD_DOWNSCALE | CAPF_SBR_HBEHQ;
1978   /* End of flags */
1979 
1980   return 0;
1981 }
1982 
sbrDecoder_GetDelay(const HANDLE_SBRDECODER self)1983 UINT sbrDecoder_GetDelay(const HANDLE_SBRDECODER self) {
1984   UINT outputDelay = 0;
1985 
1986   if (self != NULL) {
1987     UINT flags = self->flags;
1988 
1989     /* See chapter 1.6.7.2 of ISO/IEC 14496-3 for the GA-SBR figures below. */
1990 
1991     /* Are we initialized? */
1992     if ((self->numSbrChannels > 0) && (self->numSbrElements > 0)) {
1993       /* Add QMF synthesis delay */
1994       if ((flags & SBRDEC_ELD_GRID) && IS_LOWDELAY(self->coreCodec)) {
1995         /* Low delay SBR: */
1996         if (!(flags & SBRDEC_SKIP_QMF_SYN)) {
1997           outputDelay +=
1998               (flags & SBRDEC_DOWNSAMPLE) ? 32 : 64; /* QMF synthesis */
1999           if (flags & SBRDEC_LD_MPS_QMF) {
2000             outputDelay += 32;
2001           }
2002         }
2003       } else if (!IS_USAC(self->coreCodec)) {
2004         /* By the method of elimination this is the GA (AAC-LC, HE-AAC, ...)
2005          * branch: */
2006         outputDelay += (flags & SBRDEC_DOWNSAMPLE) ? 481 : 962;
2007         if (flags & SBRDEC_SKIP_QMF_SYN) {
2008           outputDelay -= 257; /* QMF synthesis */
2009         }
2010       }
2011     }
2012   }
2013 
2014   return (outputDelay);
2015 }
2016