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