1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2019 Fraunhofer-Gesellschaft zur Förderung der angewandten
5 Forschung e.V. All rights reserved.
6
7 1. INTRODUCTION
8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10 scheme for digital audio. This FDK AAC Codec software is intended to be used on
11 a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14 general perceptual audio codecs. AAC-ELD is considered the best-performing
15 full-bandwidth communications codec by independent studies and is widely
16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17 specifications.
18
19 Patent licenses for necessary patent claims for the FDK AAC Codec (including
20 those of Fraunhofer) may be obtained through Via Licensing
21 (www.vialicensing.com) or through the respective patent owners individually for
22 the purpose of encoding or decoding bit streams in products that are compliant
23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24 Android devices already license these patent claims through Via Licensing or
25 directly from the patent owners, and therefore FDK AAC Codec software may
26 already be covered under those patent licenses when it is used for those
27 licensed purposes only.
28
29 Commercially-licensed AAC software libraries, including floating-point versions
30 with enhanced sound quality, are also available from Fraunhofer. Users are
31 encouraged to check the Fraunhofer website for additional applications
32 information and documentation.
33
34 2. COPYRIGHT LICENSE
35
36 Redistribution and use in source and binary forms, with or without modification,
37 are permitted without payment of copyright license fees provided that you
38 satisfy the following conditions:
39
40 You must retain the complete text of this software license in redistributions of
41 the FDK AAC Codec or your modifications thereto in source code form.
42
43 You must retain the complete text of this software license in the documentation
44 and/or other materials provided with redistributions of the FDK AAC Codec or
45 your modifications thereto in binary form. You must make available free of
46 charge copies of the complete source code of the FDK AAC Codec and your
47 modifications thereto to recipients of copies in binary form.
48
49 The name of Fraunhofer may not be used to endorse or promote products derived
50 from this library without prior written permission.
51
52 You may not charge copyright license fees for anyone to use, copy or distribute
53 the FDK AAC Codec software or your modifications thereto.
54
55 Your modified versions of the FDK AAC Codec must carry prominent notices stating
56 that you changed the software and the date of any change. For modified versions
57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59 AAC Codec Library for Android."
60
61 3. NO PATENT LICENSE
62
63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65 Fraunhofer provides no warranty of patent non-infringement with respect to this
66 software.
67
68 You may use this FDK AAC Codec software or modifications thereto only for
69 purposes that are authorized by appropriate patent licenses.
70
71 4. DISCLAIMER
72
73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75 including but not limited to the implied warranties of merchantability and
76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78 or consequential damages, including but not limited to procurement of substitute
79 goods or services; loss of use, data, or profits, or business interruption,
80 however caused and on any theory of liability, whether in contract, strict
81 liability, or tort (including negligence), arising in any way out of the use of
82 this software, even if advised of the possibility of such damage.
83
84 5. CONTACT INFORMATION
85
86 Fraunhofer Institute for Integrated Circuits IIS
87 Attention: Audio and Multimedia Departments - FDK AAC LL
88 Am Wolfsmantel 33
89 91058 Erlangen, Germany
90
91 www.iis.fraunhofer.de/amm
92 amm-info@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /**************************** AAC decoder library ******************************
96
97 Author(s): Josef Hoepfl
98
99 Description:
100
101 *******************************************************************************/
102
103 /*!
104 \page default General Overview of the AAC Decoder Implementation
105
106 The main entry point to decode a AAC frame is CAacDecoder_DecodeFrame(). It
107 handles the different transport multiplexes and bitstream formats supported by
108 this implementation. It extracts the AAC_raw_data_blocks from these bitstreams
109 to further process then in the actual decoding stages.
110
111 Note: Click on a function of file in the above image to see details about the
112 function. Also note, that this is just an overview of the most important
113 functions and not a complete call graph.
114
115 <h2>1 Bitstream deformatter</h2>
116 The basic bit stream parser function CChannelElement_Read() is called. It uses
117 other subcalls in order to parse and unpack the bitstreams. Note, that this
118 includes huffmann decoding of the coded spectral data. This operation can be
119 computational significant specifically at higher bitrates. Optimization is
120 likely in CBlock_ReadSpectralData().
121
122 The bitstream deformatter also includes many bitfield operations. Profiling on
123 the target will determine required optimizations.
124
125 <h2>2 Actual decoding to retain the time domain output</h2>
126 The basic bitstream deformatter function CChannelElement_Decode() for CPE
127 elements and SCE elements are called. Except for the stereo processing (2.1)
128 which is only used for CPE elements, the function calls for CPE or SCE are
129 similar, except that CPE always processes to independent channels while SCE
130 only processes one channel.
131
132 Often there is the distinction between long blocks and short blocks. However,
133 computational expensive functions that ususally require optimization are being
134 shared by these two groups,
135
136 <h3>2.1 Stereo processing for CPE elements</h3>
137 CChannelPairElement_Decode() first calles the joint stereo tools in
138 stereo.cpp when required.
139
140 <h3>2.2 Scaling of spectral data</h3>
141 CBlock_ScaleSpectralData().
142
143 <h3>2.3 Apply additional coding tools</h3>
144 ApplyTools() calles the PNS tools in case of MPEG-4 bitstreams, and TNS
145 filtering CTns_Apply() for MPEG-2 and MPEG-4 bitstreams. The function
146 TnsFilterIIR() which is called by CTns_Apply() (2.3.1) might require some
147 optimization.
148
149 <h2>3 Frequency-To-Time conversion</h3>
150 The filterbank is called using CBlock_FrequencyToTime() using the MDCT module
151 from the FDK Tools
152
153 */
154
155 #include "aacdecoder.h"
156
157 #include "aac_rom.h"
158 #include "aac_ram.h"
159 #include "channel.h"
160 #include "FDK_audio.h"
161
162 #include "aacdec_pns.h"
163
164 #include "sbrdecoder.h"
165
166 #include "sac_dec_lib.h"
167
168 #include "aacdec_hcr.h"
169 #include "rvlc.h"
170
171 #include "usacdec_lpd.h"
172
173 #include "ac_arith_coder.h"
174
175 #include "tpdec_lib.h"
176
177 #include "conceal.h"
178
179 #include "FDK_crc.h"
180 #define PS_IS_EXPLICITLY_DISABLED(aot, flags) \
181 (((aot) == AOT_DRM_AAC) && !(flags & AC_PS_PRESENT))
182
183 #define IS_STEREO_SBR(el_id, stereoConfigIndex) \
184 (((el_id) == ID_USAC_CPE && (stereoConfigIndex) == 0) || \
185 ((el_id) == ID_USAC_CPE && (stereoConfigIndex) == 3))
186
CAacDecoder_SyncQmfMode(HANDLE_AACDECODER self)187 void CAacDecoder_SyncQmfMode(HANDLE_AACDECODER self) {
188 FDK_ASSERT(
189 !((self->flags[0] & AC_MPS_PRESENT) && (self->flags[0] & AC_PS_PRESENT)));
190
191 /* Assign user requested mode */
192 self->qmfModeCurr = self->qmfModeUser;
193
194 if (IS_USAC(self->streamInfo.aot)) {
195 self->qmfModeCurr = MODE_HQ;
196 }
197
198 if (self->qmfModeCurr == NOT_DEFINED) {
199 if ((IS_LOWDELAY(self->streamInfo.aot) &&
200 (self->flags[0] & AC_MPS_PRESENT)) ||
201 ((self->streamInfo.aacNumChannels == 1) &&
202 ((CAN_DO_PS(self->streamInfo.aot) &&
203 !(self->flags[0] & AC_MPS_PRESENT)) ||
204 (IS_USAC(self->streamInfo.aot))))) {
205 self->qmfModeCurr = MODE_HQ;
206 } else {
207 self->qmfModeCurr = MODE_LP;
208 }
209 }
210
211 if (self->mpsEnableCurr) {
212 if (IS_LOWDELAY(self->streamInfo.aot) &&
213 (self->qmfModeCurr == MODE_LP)) { /* Overrule user requested QMF mode */
214 self->qmfModeCurr = MODE_HQ;
215 }
216 /* Set and check if MPS decoder allows the current mode */
217 switch (mpegSurroundDecoder_SetParam(
218 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder,
219 SACDEC_PARTIALLY_COMPLEX, self->qmfModeCurr == MODE_LP)) {
220 case MPS_OK:
221 break;
222 case MPS_INVALID_PARAMETER: { /* Only one mode supported. Find out which
223 one: */
224 LIB_INFO libInfo[FDK_MODULE_LAST];
225 UINT mpsCaps;
226
227 FDKinitLibInfo(libInfo);
228 mpegSurroundDecoder_GetLibInfo(libInfo);
229 mpsCaps = FDKlibInfo_getCapabilities(libInfo, FDK_MPSDEC);
230
231 if (((mpsCaps & CAPF_MPS_LP) && (self->qmfModeCurr == MODE_LP)) ||
232 ((mpsCaps & CAPF_MPS_HQ) &&
233 (self->qmfModeCurr ==
234 MODE_HQ))) { /* MPS decoder does support the requested mode. */
235 break;
236 }
237 }
238 FDK_FALLTHROUGH;
239 default:
240 if (self->qmfModeUser == NOT_DEFINED) {
241 /* Revert in case mpegSurroundDecoder_SetParam() fails. */
242 self->qmfModeCurr =
243 (self->qmfModeCurr == MODE_LP) ? MODE_HQ : MODE_LP;
244 } else {
245 /* in case specific mode was requested we disable MPS and playout the
246 * downmix */
247 self->mpsEnableCurr = 0;
248 }
249 }
250 }
251
252 /* Set SBR to current QMF mode. Error does not matter. */
253 sbrDecoder_SetParam(self->hSbrDecoder, SBR_QMF_MODE,
254 (self->qmfModeCurr == MODE_LP));
255 self->psPossible =
256 ((CAN_DO_PS(self->streamInfo.aot) &&
257 !PS_IS_EXPLICITLY_DISABLED(self->streamInfo.aot, self->flags[0]) &&
258 self->streamInfo.aacNumChannels == 1 &&
259 !(self->flags[0] & AC_MPS_PRESENT))) &&
260 self->qmfModeCurr == MODE_HQ;
261 FDK_ASSERT(!((self->flags[0] & AC_MPS_PRESENT) && self->psPossible));
262 }
263
CAacDecoder_SignalInterruption(HANDLE_AACDECODER self)264 void CAacDecoder_SignalInterruption(HANDLE_AACDECODER self) {
265 if (self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) {
266 int i;
267
268 for (i = 0; i < fMin(self->aacChannels, (8)); i++) {
269 if (self->pAacDecoderStaticChannelInfo
270 [i]) { /* number of active channels can be smaller */
271 self->pAacDecoderStaticChannelInfo[i]->hArCo->m_numberLinesPrev = 0;
272 }
273 }
274 }
275 }
276
277 /*!
278 \brief Calculates the number of element channels
279
280 \type channel type
281 \usacStereoConfigIndex usac stereo config index
282
283 \return element channels
284 */
CAacDecoder_GetELChannels(MP4_ELEMENT_ID type,UCHAR usacStereoConfigIndex)285 static int CAacDecoder_GetELChannels(MP4_ELEMENT_ID type,
286 UCHAR usacStereoConfigIndex) {
287 int el_channels = 0;
288
289 switch (type) {
290 case ID_USAC_CPE:
291 if (usacStereoConfigIndex == 1) {
292 el_channels = 1;
293 } else {
294 el_channels = 2;
295 }
296 break;
297 case ID_CPE:
298 el_channels = 2;
299 break;
300 case ID_USAC_SCE:
301 case ID_USAC_LFE:
302 case ID_SCE:
303 case ID_LFE:
304 el_channels = 1;
305 break;
306 default:
307 el_channels = 0;
308 break;
309 }
310
311 return el_channels;
312 }
313
314 /*!
315 \brief Reset ancillary data struct. Call before parsing a new frame.
316
317 \ancData Pointer to ancillary data structure
318
319 \return Error code
320 */
CAacDecoder_AncDataReset(CAncData * ancData)321 static AAC_DECODER_ERROR CAacDecoder_AncDataReset(CAncData *ancData) {
322 int i;
323 for (i = 0; i < 8; i++) {
324 ancData->offset[i] = 0;
325 }
326 ancData->nrElements = 0;
327
328 return AAC_DEC_OK;
329 }
330
331 /*!
332 \brief Initialize ancillary buffer
333
334 \ancData Pointer to ancillary data structure
335 \buffer Pointer to (external) anc data buffer
336 \size Size of the buffer pointed on by buffer in bytes
337
338 \return Error code
339 */
CAacDecoder_AncDataInit(CAncData * ancData,unsigned char * buffer,int size)340 AAC_DECODER_ERROR CAacDecoder_AncDataInit(CAncData *ancData,
341 unsigned char *buffer, int size) {
342 if (size >= 0) {
343 ancData->buffer = buffer;
344 ancData->bufferSize = size;
345
346 CAacDecoder_AncDataReset(ancData);
347
348 return AAC_DEC_OK;
349 }
350
351 return AAC_DEC_ANC_DATA_ERROR;
352 }
353
354 /*!
355 \brief Get one ancillary data element
356
357 \ancData Pointer to ancillary data structure
358 \index Index of the anc data element to get
359 \ptr Pointer to a buffer receiving a pointer to the requested anc data element
360 \size Pointer to a buffer receiving the length of the requested anc data
361 element in bytes
362
363 \return Error code
364 */
CAacDecoder_AncDataGet(CAncData * ancData,int index,unsigned char ** ptr,int * size)365 AAC_DECODER_ERROR CAacDecoder_AncDataGet(CAncData *ancData, int index,
366 unsigned char **ptr, int *size) {
367 AAC_DECODER_ERROR error = AAC_DEC_OK;
368
369 *ptr = NULL;
370 *size = 0;
371
372 if (index >= 0 && index < 8 - 1 && index < ancData->nrElements) {
373 *ptr = &ancData->buffer[ancData->offset[index]];
374 *size = ancData->offset[index + 1] - ancData->offset[index];
375 }
376
377 return error;
378 }
379
380 /*!
381 \brief Parse ancillary data
382
383 \ancData Pointer to ancillary data structure
384 \hBs Handle to FDK bitstream
385 \ancBytes Length of ancillary data to read from the bitstream
386
387 \return Error code
388 */
CAacDecoder_AncDataParse(CAncData * ancData,HANDLE_FDK_BITSTREAM hBs,const int ancBytes)389 static AAC_DECODER_ERROR CAacDecoder_AncDataParse(CAncData *ancData,
390 HANDLE_FDK_BITSTREAM hBs,
391 const int ancBytes) {
392 AAC_DECODER_ERROR error = AAC_DEC_OK;
393 int readBytes = 0;
394
395 if (ancData->buffer != NULL) {
396 if (ancBytes > 0) {
397 /* write ancillary data to external buffer */
398 int offset = ancData->offset[ancData->nrElements];
399
400 if ((offset + ancBytes) > ancData->bufferSize) {
401 error = AAC_DEC_TOO_SMALL_ANC_BUFFER;
402 } else if (ancData->nrElements >= 8 - 1) {
403 error = AAC_DEC_TOO_MANY_ANC_ELEMENTS;
404 } else {
405 int i;
406
407 for (i = 0; i < ancBytes; i++) {
408 ancData->buffer[i + offset] = FDKreadBits(hBs, 8);
409 readBytes++;
410 }
411
412 ancData->nrElements++;
413 ancData->offset[ancData->nrElements] =
414 ancBytes + ancData->offset[ancData->nrElements - 1];
415 }
416 }
417 }
418
419 readBytes = ancBytes - readBytes;
420
421 if (readBytes > 0) {
422 /* skip data */
423 FDKpushFor(hBs, readBytes << 3);
424 }
425
426 return error;
427 }
428
429 /*!
430 \brief Read Stream Data Element
431
432 \bs Bitstream Handle
433
434 \return Error code
435 */
CDataStreamElement_Read(HANDLE_AACDECODER self,HANDLE_FDK_BITSTREAM bs,UCHAR * elementInstanceTag,UINT alignmentAnchor)436 static AAC_DECODER_ERROR CDataStreamElement_Read(HANDLE_AACDECODER self,
437 HANDLE_FDK_BITSTREAM bs,
438 UCHAR *elementInstanceTag,
439 UINT alignmentAnchor) {
440 AAC_DECODER_ERROR error = AAC_DEC_OK;
441 UINT dseBits;
442 INT dataStart;
443 int dataByteAlignFlag, count;
444
445 FDK_ASSERT(self != NULL);
446
447 int crcReg = transportDec_CrcStartReg(self->hInput, 0);
448
449 /* Element Instance Tag */
450 *elementInstanceTag = FDKreadBits(bs, 4);
451 /* Data Byte Align Flag */
452 dataByteAlignFlag = FDKreadBits(bs, 1);
453
454 count = FDKreadBits(bs, 8);
455
456 if (count == 255) {
457 count += FDKreadBits(bs, 8); /* EscCount */
458 }
459 dseBits = count * 8;
460
461 if (dataByteAlignFlag) {
462 FDKbyteAlign(bs, alignmentAnchor);
463 }
464
465 dataStart = (INT)FDKgetValidBits(bs);
466
467 error = CAacDecoder_AncDataParse(&self->ancData, bs, count);
468 transportDec_CrcEndReg(self->hInput, crcReg);
469
470 {
471 /* Move to the beginning of the data chunk */
472 FDKpushBack(bs, dataStart - (INT)FDKgetValidBits(bs));
473
474 /* Read Anc data if available */
475 aacDecoder_drcMarkPayload(self->hDrcInfo, bs, DVB_DRC_ANC_DATA);
476 }
477
478 {
479 PCMDMX_ERROR dmxErr = PCMDMX_OK;
480
481 /* Move to the beginning of the data chunk */
482 FDKpushBack(bs, dataStart - (INT)FDKgetValidBits(bs));
483
484 /* Read DMX meta-data */
485 dmxErr = pcmDmx_Parse(self->hPcmUtils, bs, dseBits, 0 /* not mpeg2 */);
486 if (error == AAC_DEC_OK && dmxErr != PCMDMX_OK) {
487 error = AAC_DEC_UNKNOWN;
488 }
489 }
490
491 /* Move to the very end of the element. */
492 FDKpushBiDirectional(bs, (INT)FDKgetValidBits(bs) - dataStart + (INT)dseBits);
493
494 return error;
495 }
496
497 /*!
498 \brief Read Program Config Element
499
500 \bs Bitstream Handle
501 \pTp Transport decoder handle for CRC handling
502 \pce Pointer to PCE buffer
503 \channelConfig Current channel configuration
504 \alignAnchor Anchor for byte alignment
505
506 \return PCE status (-1: fail, 0: no new PCE, 1: PCE updated, 2: PCE updated
507 need re-config).
508 */
CProgramConfigElement_Read(HANDLE_FDK_BITSTREAM bs,HANDLE_TRANSPORTDEC pTp,CProgramConfig * pce,const UINT channelConfig,const UINT alignAnchor)509 static int CProgramConfigElement_Read(HANDLE_FDK_BITSTREAM bs,
510 HANDLE_TRANSPORTDEC pTp,
511 CProgramConfig *pce,
512 const UINT channelConfig,
513 const UINT alignAnchor) {
514 int pceStatus = 0;
515 int crcReg;
516
517 /* read PCE to temporal buffer first */
518 C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
519
520 CProgramConfig_Init(tmpPce);
521
522 crcReg = transportDec_CrcStartReg(pTp, 0);
523
524 CProgramConfig_Read(tmpPce, bs, alignAnchor);
525
526 transportDec_CrcEndReg(pTp, crcReg);
527
528 if (CProgramConfig_IsValid(tmpPce) && (tmpPce->Profile == 1)) {
529 if (!CProgramConfig_IsValid(pce) && (channelConfig > 0)) {
530 /* Create a standard channel config PCE to compare with */
531 CProgramConfig_GetDefault(pce, channelConfig);
532 }
533
534 if (CProgramConfig_IsValid(pce)) {
535 /* Compare the new and the old PCE (tags ignored) */
536 switch (CProgramConfig_Compare(pce, tmpPce)) {
537 case 1: /* Channel configuration not changed. Just new metadata. */
538 FDKmemcpy(pce, tmpPce,
539 sizeof(CProgramConfig)); /* Store the complete PCE */
540 pceStatus = 1; /* New PCE but no change of config */
541 break;
542 case 2: /* The number of channels are identical but not the config */
543 case -1: /* The channel configuration is completely different */
544 pceStatus = -1; /* Not supported! */
545 break;
546 case 0: /* Nothing to do because PCE matches the old one exactly. */
547 default:
548 /* pceStatus = 0; */
549 break;
550 }
551 }
552 }
553
554 C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
555
556 return pceStatus;
557 }
558
559 /*!
560 \brief Prepares crossfade for USAC DASH IPF config change
561
562 \pTimeData Pointer to time data
563 \pTimeDataFlush Pointer to flushed time data
564 \numChannels Number of channels
565 \frameSize Size of frame
566 \interleaved Indicates if time data is interleaved
567
568 \return Error code
569 */
CAacDecoder_PrepareCrossFade(const INT_PCM * pTimeData,INT_PCM ** pTimeDataFlush,const INT numChannels,const INT frameSize,const INT interleaved)570 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_PrepareCrossFade(
571 const INT_PCM *pTimeData, INT_PCM **pTimeDataFlush, const INT numChannels,
572 const INT frameSize, const INT interleaved) {
573 int i, ch, s1, s2;
574 AAC_DECODER_ERROR ErrorStatus;
575
576 ErrorStatus = AAC_DEC_OK;
577
578 if (interleaved) {
579 s1 = 1;
580 s2 = numChannels;
581 } else {
582 s1 = frameSize;
583 s2 = 1;
584 }
585
586 for (ch = 0; ch < numChannels; ch++) {
587 const INT_PCM *pIn = &pTimeData[ch * s1];
588 for (i = 0; i < TIME_DATA_FLUSH_SIZE; i++) {
589 pTimeDataFlush[ch][i] = *pIn;
590 pIn += s2;
591 }
592 }
593
594 return ErrorStatus;
595 }
596
597 /*!
598 \brief Applies crossfade for USAC DASH IPF config change
599
600 \pTimeData Pointer to time data
601 \pTimeDataFlush Pointer to flushed time data
602 \numChannels Number of channels
603 \frameSize Size of frame
604 \interleaved Indicates if time data is interleaved
605
606 \return Error code
607 */
CAacDecoder_ApplyCrossFade(INT_PCM * pTimeData,INT_PCM ** pTimeDataFlush,const INT numChannels,const INT frameSize,const INT interleaved)608 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_ApplyCrossFade(
609 INT_PCM *pTimeData, INT_PCM **pTimeDataFlush, const INT numChannels,
610 const INT frameSize, const INT interleaved) {
611 int i, ch, s1, s2;
612 AAC_DECODER_ERROR ErrorStatus;
613
614 ErrorStatus = AAC_DEC_OK;
615
616 if (interleaved) {
617 s1 = 1;
618 s2 = numChannels;
619 } else {
620 s1 = frameSize;
621 s2 = 1;
622 }
623
624 for (ch = 0; ch < numChannels; ch++) {
625 INT_PCM *pIn = &pTimeData[ch * s1];
626 for (i = 0; i < TIME_DATA_FLUSH_SIZE; i++) {
627 FIXP_SGL alpha = (FIXP_SGL)i
628 << (FRACT_BITS - 1 - TIME_DATA_FLUSH_SIZE_SF);
629 FIXP_DBL time = FX_PCM2FX_DBL(*pIn);
630 FIXP_DBL timeFlush = FX_PCM2FX_DBL(pTimeDataFlush[ch][i]);
631
632 *pIn = (INT_PCM)(FIXP_PCM)FX_DBL2FX_PCM(
633 timeFlush - fMult(timeFlush, alpha) + fMult(time, alpha));
634 pIn += s2;
635 }
636 }
637
638 return ErrorStatus;
639 }
640
641 /*!
642 \brief Parse PreRoll Extension Payload
643
644 \self Handle of AAC decoder
645 \numPrerollAU Number of preRoll AUs
646 \prerollAUOffset Offset to each preRoll AU
647 \prerollAULength Length of each preRoll AU
648
649 \return Error code
650 */
CAacDecoder_PreRollExtensionPayloadParse(HANDLE_AACDECODER self,UINT * numPrerollAU,UINT * prerollAUOffset,UINT * prerollAULength)651 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_PreRollExtensionPayloadParse(
652 HANDLE_AACDECODER self, UINT *numPrerollAU, UINT *prerollAUOffset,
653 UINT *prerollAULength) {
654 FDK_BITSTREAM bs;
655 HANDLE_FDK_BITSTREAM hBs;
656 AAC_DECODER_ERROR ErrorStatus;
657
658 INT auStartAnchor;
659 UINT independencyFlag;
660 UINT extPayloadPresentFlag;
661 UINT useDefaultLengthFlag;
662 UINT configLength = 0;
663 UINT preRollPossible = 1;
664 UINT i;
665 UCHAR configChanged = 0;
666 UCHAR config[TP_USAC_MAX_CONFIG_LEN] = {0};
667 UCHAR
668 implicitExplicitCfgDiff = 0; /* in case implicit and explicit config is
669 equal preroll AU's should be processed
670 after decoder reset */
671
672 ErrorStatus = AAC_DEC_OK;
673
674 hBs = transportDec_GetBitstream(self->hInput, 0);
675 bs = *hBs;
676
677 auStartAnchor = (INT)FDKgetValidBits(hBs);
678 if (auStartAnchor <= 0) {
679 ErrorStatus = AAC_DEC_NOT_ENOUGH_BITS;
680 goto bail;
681 }
682
683 /* Independency flag */
684 FDKreadBit(hBs);
685
686 /* Payload present flag of extension ID_EXT_ELE_AUDIOPREROLL must be one */
687 extPayloadPresentFlag = FDKreadBits(hBs, 1);
688 if (!extPayloadPresentFlag) {
689 preRollPossible = 0;
690 }
691
692 /* Default length flag of extension ID_EXT_ELE_AUDIOPREROLL must be zero */
693 useDefaultLengthFlag = FDKreadBits(hBs, 1);
694 if (useDefaultLengthFlag) {
695 preRollPossible = 0;
696 }
697
698 if (preRollPossible) { /* extPayloadPresentFlag && !useDefaultLengthFlag */
699 /* Read overall ext payload length, useDefaultLengthFlag must be zero. */
700 escapedValue(hBs, 8, 16, 0);
701
702 /* Read RSVD60 Config size */
703 configLength = escapedValue(hBs, 4, 4, 8);
704
705 /* Avoid decoding pre roll frames if there was no config change and no
706 * config is included in the pre roll ext payload. */
707 }
708
709 /* If pre roll not possible then exit. */
710 if (preRollPossible == 0) {
711 /* Sanity check: if flushing is switched on, preRollPossible must be 1 */
712 if (self->flushStatus != AACDEC_FLUSH_OFF) {
713 /* Mismatch of current payload and flushing status */
714 self->flushStatus = AACDEC_FLUSH_OFF;
715 ErrorStatus = AAC_DEC_PARSE_ERROR;
716 }
717 goto bail;
718 }
719
720 if (self->flags[0] & AC_USAC) {
721 if (configLength > 0) {
722 /* DASH IPF USAC Config Change: Read new config and compare with current
723 * config. Apply reconfiguration if config's are different. */
724 for (i = 0; i < configLength; i++) {
725 config[i] = FDKreadBits(hBs, 8);
726 }
727 TRANSPORTDEC_ERROR terr;
728 terr = transportDec_InBandConfig(self->hInput, config, configLength,
729 self->buildUpStatus, &configChanged, 0,
730 &implicitExplicitCfgDiff);
731 if (terr != TRANSPORTDEC_OK) {
732 ErrorStatus = AAC_DEC_PARSE_ERROR;
733 goto bail;
734 }
735 }
736 }
737
738 /* For the first frame buildUpStatus is not set and no flushing is performed
739 * but preroll AU's should processed. */
740 /* For USAC there is no idle state. */
741 if ((self->streamInfo.numChannels == 0) && !implicitExplicitCfgDiff &&
742 (self->flags[0] & AC_USAC)) {
743 self->buildUpStatus = AACDEC_USAC_BUILD_UP_ON;
744 /* sanity check: if buildUp status on -> flushing must be off */
745 if (self->flushStatus != AACDEC_FLUSH_OFF) {
746 self->flushStatus = AACDEC_FLUSH_OFF;
747 ErrorStatus = AAC_DEC_PARSE_ERROR;
748 goto bail;
749 }
750 }
751
752 if (self->flags[0] & AC_USAC) {
753 /* We are interested in preroll AUs if an explicit or an implicit config
754 * change is signalized in other words if the build up status is set. */
755 if (self->buildUpStatus == AACDEC_USAC_BUILD_UP_ON) {
756 self->applyCrossfade |= FDKreadBit(hBs);
757 FDKreadBit(hBs); /* reserved */
758 /* Read num preroll AU's */
759 *numPrerollAU = escapedValue(hBs, 2, 4, 0);
760 /* check limits for USAC */
761 if (*numPrerollAU > AACDEC_MAX_NUM_PREROLL_AU_USAC) {
762 *numPrerollAU = 0;
763 ErrorStatus = AAC_DEC_PARSE_ERROR;
764 goto bail;
765 }
766 }
767 }
768
769 for (i = 0; i < *numPrerollAU; i++) {
770 /* For every AU get length and offset in the bitstream */
771 prerollAULength[i] = escapedValue(hBs, 16, 16, 0);
772 if (prerollAULength[i] > 0) {
773 prerollAUOffset[i] = auStartAnchor - (INT)FDKgetValidBits(hBs);
774 independencyFlag = FDKreadBit(hBs);
775 if (i == 0 && !independencyFlag) {
776 *numPrerollAU = 0;
777 ErrorStatus = AAC_DEC_PARSE_ERROR;
778 goto bail;
779 }
780 FDKpushFor(hBs, prerollAULength[i] * 8 - 1);
781 self->prerollAULength[i] = (prerollAULength[i] * 8) + prerollAUOffset[i];
782 } else {
783 *numPrerollAU = 0;
784 ErrorStatus = AAC_DEC_PARSE_ERROR; /* Something is wrong */
785 goto bail;
786 }
787 }
788
789 bail:
790
791 *hBs = bs;
792
793 return ErrorStatus;
794 }
795
796 /*!
797 \brief Parse Extension Payload
798
799 \self Handle of AAC decoder
800 \count Pointer to bit counter.
801 \previous_element ID of previous element (required by some extension payloads)
802
803 \return Error code
804 */
CAacDecoder_ExtPayloadParse(HANDLE_AACDECODER self,HANDLE_FDK_BITSTREAM hBs,int * count,MP4_ELEMENT_ID previous_element,int elIndex,int fIsFillElement)805 static AAC_DECODER_ERROR CAacDecoder_ExtPayloadParse(
806 HANDLE_AACDECODER self, HANDLE_FDK_BITSTREAM hBs, int *count,
807 MP4_ELEMENT_ID previous_element, int elIndex, int fIsFillElement) {
808 AAC_DECODER_ERROR error = AAC_DEC_OK;
809 EXT_PAYLOAD_TYPE extension_type;
810 int bytes = (*count) >> 3;
811 int crcFlag = 0;
812
813 if (*count < 4) {
814 return AAC_DEC_PARSE_ERROR;
815 } else if ((INT)FDKgetValidBits(hBs) < *count) {
816 return AAC_DEC_DECODE_FRAME_ERROR;
817 }
818
819 extension_type =
820 (EXT_PAYLOAD_TYPE)FDKreadBits(hBs, 4); /* bs_extension_type */
821 *count -= 4;
822
823 /* For ELD, the SBR signaling is explicit and parsed in
824 aacDecoder_ParseExplicitMpsAndSbr(), therefore skip SBR if implicit
825 present. */
826 if ((self->flags[0] & AC_ELD) && ((extension_type == EXT_SBR_DATA_CRC) ||
827 (extension_type == EXT_SBR_DATA))) {
828 extension_type = EXT_FIL; /* skip sbr data */
829 }
830
831 switch (extension_type) {
832 case EXT_DYNAMIC_RANGE: {
833 INT readBits =
834 aacDecoder_drcMarkPayload(self->hDrcInfo, hBs, MPEG_DRC_EXT_DATA);
835
836 if (readBits > *count) { /* Read too much. Something went wrong! */
837 error = AAC_DEC_PARSE_ERROR;
838 }
839 *count -= readBits;
840 } break;
841 case EXT_UNI_DRC: {
842 DRC_DEC_ERROR drcErr = DRC_DEC_OK;
843 DRC_DEC_CODEC_MODE drcDecCodecMode = DRC_DEC_CODEC_MODE_UNDEFINED;
844 INT nBitsRemaining = FDKgetValidBits(hBs);
845 INT readBits;
846
847 switch (self->streamInfo.aot) {
848 case AOT_AAC_LC:
849 case AOT_SBR:
850 case AOT_PS:
851 drcDecCodecMode = DRC_DEC_MPEG_4_AAC;
852 break;
853 default:
854 error = AAC_DEC_PARSE_ERROR;
855 goto bail;
856 }
857
858 drcErr = FDK_drcDec_SetCodecMode(self->hUniDrcDecoder, drcDecCodecMode);
859 if (drcErr) {
860 error = AAC_DEC_PARSE_ERROR;
861 goto bail;
862 }
863
864 drcErr = FDK_drcDec_ReadUniDrc(self->hUniDrcDecoder, hBs);
865 if (drcErr) {
866 error = AAC_DEC_PARSE_ERROR;
867 goto bail;
868 }
869 readBits = (INT)nBitsRemaining - (INT)FDKgetValidBits(hBs);
870 if (readBits > *count) { /* Read too much. Something went wrong! */
871 error = AAC_DEC_PARSE_ERROR;
872 }
873 *count -= readBits;
874 /* Skip any trailing bits */
875 FDKpushFor(hBs, *count);
876 *count = 0;
877 } break;
878 case EXT_LDSAC_DATA:
879 case EXT_SAC_DATA:
880 /* Read MPEG Surround Extension payload */
881 {
882 int err, mpsSampleRate, mpsFrameSize;
883
884 if (self->flags[0] & AC_PS_PRESENT) {
885 error = AAC_DEC_PARSE_ERROR;
886 goto bail;
887 }
888
889 /* Handle SBR dual rate case */
890 if (self->streamInfo.extSamplingRate != 0) {
891 mpsSampleRate = self->streamInfo.extSamplingRate;
892 mpsFrameSize = self->streamInfo.aacSamplesPerFrame *
893 (self->streamInfo.extSamplingRate /
894 self->streamInfo.aacSampleRate);
895 } else {
896 mpsSampleRate = self->streamInfo.aacSampleRate;
897 mpsFrameSize = self->streamInfo.aacSamplesPerFrame;
898 }
899 /* Setting of internal MPS state; may be reset in
900 CAacDecoder_SyncQmfMode if decoder is unable to decode with user
901 defined qmfMode */
902 if (!(self->flags[0] & (AC_USAC | AC_RSVD50 | AC_ELD))) {
903 self->mpsEnableCurr = self->mpsEnableUser;
904 }
905 if (self->mpsEnableCurr) {
906 if (!self->qmfDomain.globalConf.qmfDomainExplicitConfig) {
907 /* if not done yet, allocate full MPEG Surround decoder instance */
908 if (mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(
909 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder) ==
910 SAC_INSTANCE_NOT_FULL_AVAILABLE) {
911 if (mpegSurroundDecoder_Open(
912 (CMpegSurroundDecoder **)&self->pMpegSurroundDecoder, -1,
913 &self->qmfDomain)) {
914 return AAC_DEC_OUT_OF_MEMORY;
915 }
916 }
917 }
918 err = mpegSurroundDecoder_Parse(
919 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder, hBs, count,
920 self->streamInfo.aot, mpsSampleRate, mpsFrameSize,
921 self->flags[0] & AC_INDEP);
922 if (err == MPS_OK) {
923 self->flags[0] |= AC_MPS_PRESENT;
924 } else {
925 error = AAC_DEC_PARSE_ERROR;
926 }
927 }
928 /* Skip any trailing bytes */
929 FDKpushFor(hBs, *count);
930 *count = 0;
931 }
932 break;
933
934 case EXT_SBR_DATA_CRC:
935 crcFlag = 1;
936 FDK_FALLTHROUGH;
937 case EXT_SBR_DATA:
938 if (IS_CHANNEL_ELEMENT(previous_element)) {
939 SBR_ERROR sbrError;
940 UCHAR configMode = 0;
941 UCHAR configChanged = 0;
942
943 CAacDecoder_SyncQmfMode(self);
944
945 configMode |= AC_CM_ALLOC_MEM;
946
947 sbrError = sbrDecoder_InitElement(
948 self->hSbrDecoder, self->streamInfo.aacSampleRate,
949 self->streamInfo.extSamplingRate,
950 self->streamInfo.aacSamplesPerFrame, self->streamInfo.aot,
951 previous_element, elIndex,
952 2, /* Signalize that harmonicSBR shall be ignored in the config
953 change detection */
954 0, configMode, &configChanged, self->downscaleFactor);
955
956 if (sbrError == SBRDEC_OK) {
957 sbrError = sbrDecoder_Parse(self->hSbrDecoder, hBs,
958 self->pDrmBsBuffer, self->drmBsBufferSize,
959 count, *count, crcFlag, previous_element,
960 elIndex, self->flags[0], self->elFlags);
961 /* Enable SBR for implicit SBR signalling but only if no severe error
962 * happend. */
963 if ((sbrError == SBRDEC_OK) || (sbrError == SBRDEC_PARSE_ERROR)) {
964 self->sbrEnabled = 1;
965 }
966 } else {
967 /* Do not try to apply SBR because initializing the element failed. */
968 self->sbrEnabled = 0;
969 }
970 /* Citation from ISO/IEC 14496-3 chapter 4.5.2.1.5.2
971 Fill elements containing an extension_payload() with an extension_type
972 of EXT_SBR_DATA or EXT_SBR_DATA_CRC shall not contain any other
973 extension_payload of any other extension_type.
974 */
975 if (fIsFillElement) {
976 FDKpushBiDirectional(hBs, *count);
977 *count = 0;
978 } else {
979 /* If this is not a fill element with a known length, we are screwed
980 * and further parsing makes no sense. */
981 if (sbrError != SBRDEC_OK) {
982 self->frameOK = 0;
983 }
984 }
985 } else {
986 error = AAC_DEC_PARSE_ERROR;
987 }
988 break;
989
990 case EXT_FILL_DATA: {
991 int temp;
992
993 temp = FDKreadBits(hBs, 4);
994 bytes--;
995 if (temp != 0) {
996 error = AAC_DEC_PARSE_ERROR;
997 break;
998 }
999 while (bytes > 0) {
1000 temp = FDKreadBits(hBs, 8);
1001 bytes--;
1002 if (temp != 0xa5) {
1003 error = AAC_DEC_PARSE_ERROR;
1004 break;
1005 }
1006 }
1007 *count = bytes << 3;
1008 } break;
1009
1010 case EXT_DATA_ELEMENT: {
1011 int dataElementVersion;
1012
1013 dataElementVersion = FDKreadBits(hBs, 4);
1014 *count -= 4;
1015 if (dataElementVersion == 0) /* ANC_DATA */
1016 {
1017 int temp, dataElementLength = 0;
1018 do {
1019 temp = FDKreadBits(hBs, 8);
1020 *count -= 8;
1021 dataElementLength += temp;
1022 } while (temp == 255);
1023
1024 CAacDecoder_AncDataParse(&self->ancData, hBs, dataElementLength);
1025 *count -= (dataElementLength << 3);
1026 } else {
1027 /* align = 0 */
1028 error = AAC_DEC_PARSE_ERROR;
1029 goto bail;
1030 }
1031 } break;
1032
1033 case EXT_DATA_LENGTH:
1034 if (!fIsFillElement /* Makes no sens to have an additional length in a
1035 fill ... */
1036 &&
1037 (self->flags[0] &
1038 AC_ER)) /* ... element because this extension payload type was ... */
1039 { /* ... created to circumvent the missing length in ER-Syntax. */
1040 int bitCnt, len = FDKreadBits(hBs, 4);
1041 *count -= 4;
1042
1043 if (len == 15) {
1044 int add_len = FDKreadBits(hBs, 8);
1045 *count -= 8;
1046 len += add_len;
1047
1048 if (add_len == 255) {
1049 len += FDKreadBits(hBs, 16);
1050 *count -= 16;
1051 }
1052 }
1053 len <<= 3;
1054 bitCnt = len;
1055
1056 if ((EXT_PAYLOAD_TYPE)FDKreadBits(hBs, 4) == EXT_DATA_LENGTH) {
1057 /* Check NOTE 2: The extension_payload() included here must
1058 not have extension_type == EXT_DATA_LENGTH. */
1059 error = AAC_DEC_PARSE_ERROR;
1060 goto bail;
1061 } else {
1062 /* rewind and call myself again. */
1063 FDKpushBack(hBs, 4);
1064
1065 error = CAacDecoder_ExtPayloadParse(
1066 self, hBs, &bitCnt, previous_element, elIndex,
1067 1); /* Treat same as fill element */
1068
1069 *count -= len - bitCnt;
1070 }
1071 /* Note: the fall through in case the if statement above is not taken is
1072 * intentional. */
1073 break;
1074 }
1075 FDK_FALLTHROUGH;
1076
1077 case EXT_FIL:
1078
1079 default:
1080 /* align = 4 */
1081 FDKpushFor(hBs, *count);
1082 *count = 0;
1083 break;
1084 }
1085
1086 bail:
1087 if ((error != AAC_DEC_OK) &&
1088 fIsFillElement) { /* Skip the remaining extension bytes */
1089 FDKpushBiDirectional(hBs, *count);
1090 *count = 0;
1091 /* Patch error code because decoding can go on. */
1092 error = AAC_DEC_OK;
1093 /* Be sure that parsing errors have been stored. */
1094 }
1095 return error;
1096 }
1097
aacDecoder_ParseExplicitMpsAndSbr(HANDLE_AACDECODER self,HANDLE_FDK_BITSTREAM bs,const MP4_ELEMENT_ID previous_element,const int previous_element_index,const int element_index,const int el_cnt[])1098 static AAC_DECODER_ERROR aacDecoder_ParseExplicitMpsAndSbr(
1099 HANDLE_AACDECODER self, HANDLE_FDK_BITSTREAM bs,
1100 const MP4_ELEMENT_ID previous_element, const int previous_element_index,
1101 const int element_index, const int el_cnt[]) {
1102 AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
1103 INT bitCnt = 0;
1104
1105 /* get the remaining bits of this frame */
1106 bitCnt = transportDec_GetAuBitsRemaining(self->hInput, 0);
1107
1108 if ((self->flags[0] & AC_SBR_PRESENT) &&
1109 (self->flags[0] & (AC_USAC | AC_RSVD50 | AC_ELD | AC_DRM))) {
1110 SBR_ERROR err = SBRDEC_OK;
1111 int chElIdx, numChElements = el_cnt[ID_SCE] + el_cnt[ID_CPE] +
1112 el_cnt[ID_LFE] + el_cnt[ID_USAC_SCE] +
1113 el_cnt[ID_USAC_CPE] + el_cnt[ID_USAC_LFE];
1114 INT bitCntTmp = bitCnt;
1115
1116 if (self->flags[0] & AC_USAC) {
1117 chElIdx = numChElements - 1;
1118 } else {
1119 chElIdx = 0; /* ELD case */
1120 }
1121
1122 for (; chElIdx < numChElements; chElIdx += 1) {
1123 MP4_ELEMENT_ID sbrType;
1124 SBR_ERROR errTmp;
1125 if (self->flags[0] & (AC_USAC)) {
1126 FDK_ASSERT((self->elements[element_index] == ID_USAC_SCE) ||
1127 (self->elements[element_index] == ID_USAC_CPE));
1128 sbrType = IS_STEREO_SBR(self->elements[element_index],
1129 self->usacStereoConfigIndex[element_index])
1130 ? ID_CPE
1131 : ID_SCE;
1132 } else
1133 sbrType = self->elements[chElIdx];
1134 errTmp = sbrDecoder_Parse(self->hSbrDecoder, bs, self->pDrmBsBuffer,
1135 self->drmBsBufferSize, &bitCnt, -1,
1136 self->flags[0] & AC_SBRCRC, sbrType, chElIdx,
1137 self->flags[0], self->elFlags);
1138 if (errTmp != SBRDEC_OK) {
1139 err = errTmp;
1140 bitCntTmp = bitCnt;
1141 bitCnt = 0;
1142 }
1143 }
1144 switch (err) {
1145 case SBRDEC_PARSE_ERROR:
1146 /* Can not go on parsing because we do not
1147 know the length of the SBR extension data. */
1148 FDKpushFor(bs, bitCntTmp);
1149 bitCnt = 0;
1150 break;
1151 case SBRDEC_OK:
1152 self->sbrEnabled = 1;
1153 break;
1154 default:
1155 self->frameOK = 0;
1156 break;
1157 }
1158 }
1159
1160 if ((bitCnt > 0) && (self->flags[0] & (AC_USAC | AC_RSVD50))) {
1161 if ((self->flags[0] & AC_MPS_PRESENT) ||
1162 (self->elFlags[element_index] & AC_EL_USAC_MPS212)) {
1163 int err;
1164
1165 err = mpegSurroundDecoder_ParseNoHeader(
1166 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder, bs, &bitCnt,
1167 self->flags[0] & AC_INDEP);
1168 if (err != MPS_OK) {
1169 self->frameOK = 0;
1170 ErrorStatus = AAC_DEC_PARSE_ERROR;
1171 }
1172 }
1173 }
1174
1175 if (self->flags[0] & AC_DRM) {
1176 if ((bitCnt = (INT)FDKgetValidBits(bs)) != 0) {
1177 FDKpushBiDirectional(bs, bitCnt);
1178 }
1179 }
1180
1181 if (!(self->flags[0] & (AC_USAC | AC_RSVD50 | AC_DRM))) {
1182 while (bitCnt > 7) {
1183 ErrorStatus = CAacDecoder_ExtPayloadParse(
1184 self, bs, &bitCnt, previous_element, previous_element_index, 0);
1185 if (ErrorStatus != AAC_DEC_OK) {
1186 self->frameOK = 0;
1187 ErrorStatus = AAC_DEC_PARSE_ERROR;
1188 break;
1189 }
1190 }
1191 }
1192 return ErrorStatus;
1193 }
1194
1195 /* Stream Configuration and Information.
1196
1197 This class holds configuration and information data for a stream to be
1198 decoded. It provides the calling application as well as the decoder with
1199 substantial information, e.g. profile, sampling rate, number of channels
1200 found in the bitstream etc.
1201 */
CStreamInfoInit(CStreamInfo * pStreamInfo)1202 static void CStreamInfoInit(CStreamInfo *pStreamInfo) {
1203 pStreamInfo->aacSampleRate = 0;
1204 pStreamInfo->profile = -1;
1205 pStreamInfo->aot = AOT_NONE;
1206
1207 pStreamInfo->channelConfig = -1;
1208 pStreamInfo->bitRate = 0;
1209 pStreamInfo->aacSamplesPerFrame = 0;
1210
1211 pStreamInfo->extAot = AOT_NONE;
1212 pStreamInfo->extSamplingRate = 0;
1213
1214 pStreamInfo->flags = 0;
1215
1216 pStreamInfo->epConfig = -1; /* default: no ER */
1217
1218 pStreamInfo->numChannels = 0;
1219 pStreamInfo->sampleRate = 0;
1220 pStreamInfo->frameSize = 0;
1221
1222 pStreamInfo->outputDelay = 0;
1223
1224 /* DRC */
1225 pStreamInfo->drcProgRefLev =
1226 -1; /* set program reference level to not indicated */
1227 pStreamInfo->drcPresMode = -1; /* default: presentation mode not indicated */
1228 }
1229
1230 /*!
1231 \brief Initialization of AacDecoderChannelInfo
1232
1233 The function initializes the pointers to AacDecoderChannelInfo for each
1234 channel, set the start values for window shape and window sequence of
1235 overlap&add to zero, set the overlap buffer to zero and initializes the
1236 pointers to the window coefficients. \param bsFormat is the format of the AAC
1237 bitstream
1238
1239 \return AACDECODER instance
1240 */
CAacDecoder_Open(TRANSPORT_TYPE bsFormat)1241 LINKSPEC_CPP HANDLE_AACDECODER CAacDecoder_Open(
1242 TRANSPORT_TYPE bsFormat) /*!< bitstream format (adif,adts,loas,...). */
1243 {
1244 HANDLE_AACDECODER self;
1245
1246 self = GetAacDecoder();
1247 if (self == NULL) {
1248 goto bail;
1249 }
1250
1251 FDK_QmfDomain_ClearRequested(&self->qmfDomain.globalConf);
1252
1253 /* Assign channel mapping info arrays (doing so removes dependency of settings
1254 * header in API header). */
1255 self->streamInfo.pChannelIndices = self->channelIndices;
1256 self->streamInfo.pChannelType = self->channelType;
1257 self->downscaleFactor = 1;
1258 self->downscaleFactorInBS = 1;
1259
1260 /* initialize anc data */
1261 CAacDecoder_AncDataInit(&self->ancData, NULL, 0);
1262
1263 /* initialize stream info */
1264 CStreamInfoInit(&self->streamInfo);
1265
1266 /* initialize progam config */
1267 CProgramConfig_Init(&self->pce);
1268
1269 /* initialize error concealment common data */
1270 CConcealment_InitCommonData(&self->concealCommonData);
1271 self->concealMethodUser = ConcealMethodNone; /* undefined -> auto mode */
1272
1273 self->hDrcInfo = GetDrcInfo();
1274 if (self->hDrcInfo == NULL) {
1275 goto bail;
1276 }
1277 /* Init common DRC structure */
1278 aacDecoder_drcInit(self->hDrcInfo);
1279 /* Set default frame delay */
1280 aacDecoder_drcSetParam(self->hDrcInfo, DRC_BS_DELAY,
1281 CConcealment_GetDelay(&self->concealCommonData));
1282
1283 self->workBufferCore2 = GetWorkBufferCore2();
1284 if (self->workBufferCore2 == NULL) goto bail;
1285
1286 /* When RSVD60 is active use dedicated memory for core decoding */
1287 self->pTimeData2 = GetWorkBufferCore5();
1288 self->timeData2Size = GetRequiredMemWorkBufferCore5();
1289 if (self->pTimeData2 == NULL) {
1290 goto bail;
1291 }
1292
1293 return self;
1294
1295 bail:
1296 CAacDecoder_Close(self);
1297
1298 return NULL;
1299 }
1300
1301 /* Revert CAacDecoder_Init() */
CAacDecoder_DeInit(HANDLE_AACDECODER self,const int subStreamIndex)1302 static void CAacDecoder_DeInit(HANDLE_AACDECODER self,
1303 const int subStreamIndex) {
1304 int ch;
1305 int aacChannelOffset = 0, aacChannels = (8);
1306 int numElements = (((8)) + (8)), elementOffset = 0;
1307
1308 if (self == NULL) return;
1309
1310 {
1311 self->ascChannels[0] = 0;
1312 self->elements[0] = ID_END;
1313 }
1314
1315 for (ch = aacChannelOffset; ch < aacChannelOffset + aacChannels; ch++) {
1316 if (self->pAacDecoderChannelInfo[ch] != NULL) {
1317 if (self->pAacDecoderChannelInfo[ch]->pComStaticData != NULL) {
1318 if (self->pAacDecoderChannelInfo[ch]
1319 ->pComStaticData->pWorkBufferCore1 != NULL) {
1320 if (ch == aacChannelOffset) {
1321 FreeWorkBufferCore1(&self->pAacDecoderChannelInfo[ch]
1322 ->pComStaticData->pWorkBufferCore1);
1323 }
1324 }
1325 if (self->pAacDecoderChannelInfo[ch]
1326 ->pComStaticData->cplxPredictionData != NULL) {
1327 FreeCplxPredictionData(&self->pAacDecoderChannelInfo[ch]
1328 ->pComStaticData->cplxPredictionData);
1329 }
1330 /* Avoid double free of linked pComStaticData in case of CPE by settings
1331 * pointer to NULL. */
1332 if (ch < (8) - 1) {
1333 if ((self->pAacDecoderChannelInfo[ch + 1] != NULL) &&
1334 (self->pAacDecoderChannelInfo[ch + 1]->pComStaticData ==
1335 self->pAacDecoderChannelInfo[ch]->pComStaticData)) {
1336 self->pAacDecoderChannelInfo[ch + 1]->pComStaticData = NULL;
1337 }
1338 }
1339 FDKfree(self->pAacDecoderChannelInfo[ch]->pComStaticData);
1340 self->pAacDecoderChannelInfo[ch]->pComStaticData = NULL;
1341 }
1342 if (self->pAacDecoderChannelInfo[ch]->pComData != NULL) {
1343 /* Avoid double free of linked pComData in case of CPE by settings
1344 * pointer to NULL. */
1345 if (ch < (8) - 1) {
1346 if ((self->pAacDecoderChannelInfo[ch + 1] != NULL) &&
1347 (self->pAacDecoderChannelInfo[ch + 1]->pComData ==
1348 self->pAacDecoderChannelInfo[ch]->pComData)) {
1349 self->pAacDecoderChannelInfo[ch + 1]->pComData = NULL;
1350 }
1351 }
1352 if (ch == aacChannelOffset) {
1353 FreeWorkBufferCore6(
1354 (SCHAR **)&self->pAacDecoderChannelInfo[ch]->pComData);
1355 } else {
1356 FDKafree(self->pAacDecoderChannelInfo[ch]->pComData);
1357 }
1358 self->pAacDecoderChannelInfo[ch]->pComData = NULL;
1359 }
1360 }
1361 if (self->pAacDecoderStaticChannelInfo[ch] != NULL) {
1362 if (self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer != NULL) {
1363 FreeOverlapBuffer(
1364 &self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer);
1365 }
1366 if (self->pAacDecoderStaticChannelInfo[ch]->hArCo != NULL) {
1367 CArco_Destroy(self->pAacDecoderStaticChannelInfo[ch]->hArCo);
1368 }
1369 FreeAacDecoderStaticChannelInfo(&self->pAacDecoderStaticChannelInfo[ch]);
1370 }
1371 if (self->pAacDecoderChannelInfo[ch] != NULL) {
1372 FreeAacDecoderChannelInfo(&self->pAacDecoderChannelInfo[ch]);
1373 }
1374 }
1375
1376 {
1377 int el;
1378 for (el = elementOffset; el < elementOffset + numElements; el++) {
1379 if (self->cpeStaticData[el] != NULL) {
1380 FreeCpePersistentData(&self->cpeStaticData[el]);
1381 }
1382 }
1383 }
1384
1385 FDK_Delay_Destroy(&self->usacResidualDelay);
1386
1387 self->aacChannels = 0;
1388 self->streamInfo.aacSampleRate = 0;
1389 self->streamInfo.sampleRate = 0;
1390 /* This samplerate value is checked for configuration change, not the others
1391 * above. */
1392 self->samplingRateInfo[subStreamIndex].samplingRate = 0;
1393 }
1394
1395 /*!
1396 * \brief CAacDecoder_CtrlCFGChange Set config change parameters.
1397 *
1398 * \param self [i] handle to AACDECODER structure
1399 * \param flushStatus [i] flush status: on|off
1400 * \param flushCnt [i] flush frame counter
1401 * \param buildUpStatus [i] build up status: on|off
1402 * \param buildUpCnt [i] build up frame counter
1403 *
1404 * \return error
1405 */
CAacDecoder_CtrlCFGChange(HANDLE_AACDECODER self,UCHAR flushStatus,SCHAR flushCnt,UCHAR buildUpStatus,SCHAR buildUpCnt)1406 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_CtrlCFGChange(HANDLE_AACDECODER self,
1407 UCHAR flushStatus,
1408 SCHAR flushCnt,
1409 UCHAR buildUpStatus,
1410 SCHAR buildUpCnt) {
1411 AAC_DECODER_ERROR err = AAC_DEC_OK;
1412
1413 self->flushStatus = flushStatus;
1414 self->flushCnt = flushCnt;
1415 self->buildUpStatus = buildUpStatus;
1416 self->buildUpCnt = buildUpCnt;
1417
1418 return (err);
1419 }
1420
1421 /*!
1422 * \brief CAacDecoder_FreeMem Free config dependent AAC memory.
1423 *
1424 * \param self [i] handle to AACDECODER structure
1425 *
1426 * \return error
1427 */
CAacDecoder_FreeMem(HANDLE_AACDECODER self,const int subStreamIndex)1428 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_FreeMem(HANDLE_AACDECODER self,
1429 const int subStreamIndex) {
1430 AAC_DECODER_ERROR err = AAC_DEC_OK;
1431
1432 CAacDecoder_DeInit(self, subStreamIndex);
1433
1434 return (err);
1435 }
1436
1437 /* Destroy aac decoder */
CAacDecoder_Close(HANDLE_AACDECODER self)1438 LINKSPEC_CPP void CAacDecoder_Close(HANDLE_AACDECODER self) {
1439 if (self == NULL) return;
1440
1441 CAacDecoder_DeInit(self, 0);
1442
1443 {
1444 int ch;
1445 for (ch = 0; ch < (8); ch++) {
1446 if (self->pTimeDataFlush[ch] != NULL) {
1447 FreeTimeDataFlush(&self->pTimeDataFlush[ch]);
1448 }
1449 }
1450 }
1451
1452 if (self->hDrcInfo) {
1453 FreeDrcInfo(&self->hDrcInfo);
1454 }
1455
1456 /* Free WorkBufferCore2 */
1457 if (self->workBufferCore2 != NULL) {
1458 FreeWorkBufferCore2(&self->workBufferCore2);
1459 }
1460 if (self->pTimeData2 != NULL) {
1461 FreeWorkBufferCore5(&self->pTimeData2);
1462 }
1463
1464 FDK_QmfDomain_Close(&self->qmfDomain);
1465
1466 FreeAacDecoder(&self);
1467 }
1468
1469 /*!
1470 \brief Initialization of decoder instance
1471
1472 The function initializes the decoder.
1473
1474 \return error status: 0 for success, <>0 for unsupported configurations
1475 */
1476 LINKSPEC_CPP AAC_DECODER_ERROR
CAacDecoder_Init(HANDLE_AACDECODER self,const CSAudioSpecificConfig * asc,UCHAR configMode,UCHAR * configChanged)1477 CAacDecoder_Init(HANDLE_AACDECODER self, const CSAudioSpecificConfig *asc,
1478 UCHAR configMode, UCHAR *configChanged) {
1479 AAC_DECODER_ERROR err = AAC_DEC_OK;
1480 INT ascChannels, ascChanged = 0;
1481 AACDEC_RENDER_MODE initRenderMode = AACDEC_RENDER_INVALID;
1482 SCHAR usacStereoConfigIndex = -1;
1483 int usacResidualDelayCompSamples = 0;
1484 int elementOffset, aacChannelsOffset, aacChannelsOffsetIdx;
1485 const int streamIndex = 0;
1486 INT flushChannels = 0;
1487
1488 if (!self) return AAC_DEC_INVALID_HANDLE;
1489
1490 UCHAR downscaleFactor = self->downscaleFactor;
1491 UCHAR downscaleFactorInBS = self->downscaleFactorInBS;
1492
1493 // set profile and check for supported aot
1494 // leave profile on default (=-1) for all other supported MPEG-4 aot's except
1495 // aot=2 (=AAC-LC)
1496 switch (asc->m_aot) {
1497 case AOT_AAC_LC:
1498 self->streamInfo.profile = 1;
1499 FDK_FALLTHROUGH;
1500 case AOT_ER_AAC_SCAL:
1501 if (asc->m_sc.m_gaSpecificConfig.m_layer > 0) {
1502 /* aac_scalable_extension_element() currently not supported. */
1503 return AAC_DEC_UNSUPPORTED_FORMAT;
1504 }
1505 FDK_FALLTHROUGH;
1506 case AOT_SBR:
1507 case AOT_PS:
1508 case AOT_ER_AAC_LC:
1509 case AOT_ER_AAC_LD:
1510 case AOT_DRM_AAC:
1511 case AOT_DRM_SURROUND:
1512 initRenderMode = AACDEC_RENDER_IMDCT;
1513 break;
1514 case AOT_ER_AAC_ELD:
1515 initRenderMode = AACDEC_RENDER_ELDFB;
1516 break;
1517 case AOT_USAC:
1518 initRenderMode = AACDEC_RENDER_IMDCT;
1519 break;
1520 default:
1521 return AAC_DEC_UNSUPPORTED_AOT;
1522 }
1523
1524 if (CProgramConfig_IsValid(&self->pce) && (asc->m_channelConfiguration > 0)) {
1525 /* Compare the stored (old) PCE with a default PCE created from the (new)
1526 channel_config (on a temporal buffer) to find out wheter we can keep it
1527 (and its metadata) or not. */
1528 int pceCmpResult;
1529 C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
1530
1531 CProgramConfig_GetDefault(tmpPce, asc->m_channelConfiguration);
1532 pceCmpResult = CProgramConfig_Compare(&self->pce, tmpPce);
1533 if ((pceCmpResult < 0) /* Reset if PCEs are completely different ... */
1534 ||
1535 (pceCmpResult > 1)) { /* ... or have a different layout. */
1536 CProgramConfig_Init(&self->pce);
1537 } /* Otherwise keep the PCE (and its metadata). */
1538 C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
1539 } else {
1540 CProgramConfig_Init(&self->pce);
1541 }
1542
1543 /* set channels */
1544 switch (asc->m_channelConfiguration) {
1545 case 0:
1546 switch (asc->m_aot) {
1547 case AOT_USAC:
1548 self->chMapIndex = 0;
1549 ascChannels = asc->m_sc.m_usacConfig.m_nUsacChannels;
1550 break;
1551 default:
1552 /* get channels from program config (ASC) */
1553 if (CProgramConfig_IsValid(&asc->m_progrConfigElement)) {
1554 ascChannels = asc->m_progrConfigElement.NumChannels;
1555 if (ascChannels > 0) {
1556 int el_tmp;
1557 /* valid number of channels -> copy program config element (PCE)
1558 * from ASC */
1559 FDKmemcpy(&self->pce, &asc->m_progrConfigElement,
1560 sizeof(CProgramConfig));
1561 /* Built element table */
1562 el_tmp = CProgramConfig_GetElementTable(
1563 &asc->m_progrConfigElement, self->elements, (((8)) + (8)),
1564 &self->chMapIndex);
1565 for (; el_tmp < (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1);
1566 el_tmp++) {
1567 self->elements[el_tmp] = ID_NONE;
1568 }
1569 } else {
1570 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
1571 }
1572 } else {
1573 self->chMapIndex = 0;
1574 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
1575 }
1576 break;
1577 }
1578 break;
1579 case 1:
1580 case 2:
1581 case 3:
1582 case 4:
1583 case 5:
1584 case 6:
1585 ascChannels = asc->m_channelConfiguration;
1586 break;
1587 case 11:
1588 ascChannels = 7;
1589 break;
1590 case 7:
1591 case 12:
1592 case 14:
1593 ascChannels = 8;
1594 break;
1595 default:
1596 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
1597 }
1598
1599 if (asc->m_aot == AOT_USAC) {
1600 flushChannels = fMin(ascChannels, (8));
1601 INT numChannel;
1602 pcmDmx_GetParam(self->hPcmUtils, MIN_NUMBER_OF_OUTPUT_CHANNELS,
1603 &numChannel);
1604 flushChannels = fMin(fMax(numChannel, flushChannels), (8));
1605 }
1606
1607 if (IS_USAC(asc->m_aot)) {
1608 for (int el = 0; el < (INT)asc->m_sc.m_usacConfig.m_usacNumElements; el++) {
1609 /* fix number of core channels aka ascChannels for stereoConfigIndex = 1
1610 * cases */
1611 if (asc->m_sc.m_usacConfig.element[el].m_stereoConfigIndex == 1) {
1612 ascChannels--; /* stereoConfigIndex == 1 stereo cases do actually
1613 contain only a mono core channel. */
1614 } else if (asc->m_sc.m_usacConfig.element[el].m_stereoConfigIndex == 2) {
1615 /* In this case it is necessary to follow up the DMX signal delay caused
1616 by HBE also with the residual signal (2nd core channel). The SBR
1617 overlap delay is not regarded here, this is handled by the MPS212
1618 implementation.
1619 */
1620 if (asc->m_sc.m_usacConfig.element[el].m_harmonicSBR) {
1621 usacResidualDelayCompSamples += asc->m_samplesPerFrame;
1622 }
1623 if (asc->m_sc.m_usacConfig.m_coreSbrFrameLengthIndex == 4) {
1624 usacResidualDelayCompSamples +=
1625 6 * 16; /* difference between 12 SBR
1626 overlap slots from SBR and 6
1627 slots delayed in MPS212 */
1628 }
1629 }
1630 }
1631 }
1632
1633 aacChannelsOffset = 0;
1634 aacChannelsOffsetIdx = 0;
1635 elementOffset = 0;
1636 if ((ascChannels <= 0) || (ascChannels > (8)) ||
1637 (asc->m_channelConfiguration > AACDEC_MAX_CH_CONF)) {
1638 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
1639 }
1640
1641 /* Set syntax flags */
1642 self->flags[streamIndex] = 0;
1643 { FDKmemclear(self->elFlags, sizeof(self->elFlags)); }
1644
1645 if ((asc->m_channelConfiguration > 0) || IS_USAC(asc->m_aot)) {
1646 if (IS_USAC(asc->m_aot)) {
1647 /* copy pointer to usac config
1648 (this is preliminary since there's an ongoing discussion about storing
1649 the config-part of the bitstream rather than the complete decoded
1650 configuration) */
1651 self->pUsacConfig[streamIndex] = &asc->m_sc.m_usacConfig;
1652
1653 /* copy list of elements */
1654 if (self->pUsacConfig[streamIndex]->m_usacNumElements >
1655 (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
1656 goto bail;
1657 }
1658
1659 if (self->numUsacElements[streamIndex] !=
1660 asc->m_sc.m_usacConfig.m_usacNumElements) {
1661 ascChanged = 1;
1662 }
1663
1664 if (configMode & AC_CM_ALLOC_MEM) {
1665 self->numUsacElements[streamIndex] =
1666 asc->m_sc.m_usacConfig.m_usacNumElements;
1667 }
1668
1669 self->mpsEnableCurr = 0;
1670 for (int _el = 0;
1671 _el < (int)self->pUsacConfig[streamIndex]->m_usacNumElements;
1672 _el++) {
1673 int el = _el + elementOffset;
1674 if (self->elements[el] !=
1675 self->pUsacConfig[streamIndex]->element[_el].usacElementType) {
1676 ascChanged = 1;
1677 }
1678 if (self->usacStereoConfigIndex[el] !=
1679 asc->m_sc.m_usacConfig.element[_el].m_stereoConfigIndex) {
1680 ascChanged = 1;
1681 }
1682 if (configMode & AC_CM_ALLOC_MEM) {
1683 self->elements[el] =
1684 self->pUsacConfig[streamIndex]->element[_el].usacElementType;
1685 /* for Unified Stereo Coding */
1686 self->usacStereoConfigIndex[el] =
1687 asc->m_sc.m_usacConfig.element[_el].m_stereoConfigIndex;
1688 if (self->elements[el] == ID_USAC_CPE) {
1689 self->mpsEnableCurr |= self->usacStereoConfigIndex[el] ? 1 : 0;
1690 }
1691 }
1692
1693 self->elFlags[el] |=
1694 (asc->m_sc.m_usacConfig.element[_el].m_noiseFilling)
1695 ? AC_EL_USAC_NOISE
1696 : 0;
1697 self->elFlags[el] |=
1698 (asc->m_sc.m_usacConfig.element[_el].m_stereoConfigIndex > 0)
1699 ? AC_EL_USAC_MPS212
1700 : 0;
1701 self->elFlags[el] |= (asc->m_sc.m_usacConfig.element[_el].m_interTes)
1702 ? AC_EL_USAC_ITES
1703 : 0;
1704 self->elFlags[el] |=
1705 (asc->m_sc.m_usacConfig.element[_el].m_pvc) ? AC_EL_USAC_PVC : 0;
1706 self->elFlags[el] |=
1707 (asc->m_sc.m_usacConfig.element[_el].usacElementType == ID_USAC_LFE)
1708 ? AC_EL_USAC_LFE
1709 : 0;
1710 self->elFlags[el] |=
1711 (asc->m_sc.m_usacConfig.element[_el].usacElementType == ID_USAC_LFE)
1712 ? AC_EL_LFE
1713 : 0;
1714 if ((asc->m_sc.m_usacConfig.element[_el].usacElementType ==
1715 ID_USAC_CPE) &&
1716 ((self->usacStereoConfigIndex[el] == 0))) {
1717 self->elFlags[el] |= AC_EL_USAC_CP_POSSIBLE;
1718 }
1719 }
1720
1721 self->hasAudioPreRoll = 0;
1722 if (self->pUsacConfig[streamIndex]->m_usacNumElements) {
1723 self->hasAudioPreRoll = asc->m_sc.m_usacConfig.element[0]
1724 .extElement.usacExtElementHasAudioPreRoll;
1725 }
1726 if (configMode & AC_CM_ALLOC_MEM) {
1727 self->elements[elementOffset +
1728 self->pUsacConfig[streamIndex]->m_usacNumElements] =
1729 ID_END;
1730 }
1731 } else {
1732 /* Initialize constant mappings for channel config 1-7 */
1733 int i;
1734 for (i = 0; i < AACDEC_CH_ELEMENTS_TAB_SIZE; i++) {
1735 self->elements[i] = elementsTab[asc->m_channelConfiguration - 1][i];
1736 }
1737 for (; i < (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1); i++) {
1738 self->elements[i] = ID_NONE;
1739 }
1740 }
1741
1742 {
1743 int ch;
1744
1745 for (ch = 0; ch < ascChannels; ch++) {
1746 self->chMapping[ch] = ch;
1747 }
1748 for (; ch < (8); ch++) {
1749 self->chMapping[ch] = 255;
1750 }
1751 }
1752
1753 self->chMapIndex = asc->m_channelConfiguration;
1754 } else {
1755 if (CProgramConfig_IsValid(&asc->m_progrConfigElement)) {
1756 /* Set matrix mixdown infos if available from PCE. */
1757 pcmDmx_SetMatrixMixdownFromPce(
1758 self->hPcmUtils, asc->m_progrConfigElement.MatrixMixdownIndexPresent,
1759 asc->m_progrConfigElement.MatrixMixdownIndex,
1760 asc->m_progrConfigElement.PseudoSurroundEnable);
1761 }
1762 }
1763
1764 self->streamInfo.channelConfig = asc->m_channelConfiguration;
1765
1766 if (self->streamInfo.aot != asc->m_aot) {
1767 if (configMode & AC_CM_ALLOC_MEM) {
1768 self->streamInfo.aot = asc->m_aot;
1769 }
1770 ascChanged = 1;
1771 }
1772
1773 if (asc->m_aot == AOT_ER_AAC_ELD &&
1774 asc->m_sc.m_eldSpecificConfig.m_downscaledSamplingFrequency != 0) {
1775 if (self->samplingRateInfo[0].samplingRate !=
1776 asc->m_sc.m_eldSpecificConfig.m_downscaledSamplingFrequency ||
1777 self->samplingRateInfo[0].samplingRate * self->downscaleFactor !=
1778 asc->m_samplingFrequency) {
1779 /* get downscaledSamplingFrequency from ESC and compute the downscale
1780 * factor */
1781 downscaleFactorInBS =
1782 asc->m_samplingFrequency /
1783 asc->m_sc.m_eldSpecificConfig.m_downscaledSamplingFrequency;
1784 if (downscaleFactorInBS == 1 || downscaleFactorInBS == 2 ||
1785 downscaleFactorInBS == 3 || downscaleFactorInBS == 4) {
1786 downscaleFactor = downscaleFactorInBS;
1787 }
1788 }
1789 } else {
1790 downscaleFactorInBS = 1;
1791 downscaleFactor = 1;
1792 }
1793
1794 if (self->downscaleFactorInBS != downscaleFactorInBS) {
1795 if (configMode & AC_CM_ALLOC_MEM) {
1796 self->downscaleFactorInBS = downscaleFactorInBS;
1797 self->downscaleFactor = downscaleFactor;
1798 }
1799 ascChanged = 1;
1800 }
1801
1802 if ((INT)asc->m_samplesPerFrame % downscaleFactor != 0) {
1803 return AAC_DEC_UNSUPPORTED_SAMPLINGRATE; /* frameSize/dsf must be an integer
1804 number */
1805 }
1806
1807 self->streamInfo.bitRate = 0;
1808
1809 if (asc->m_aot == AOT_ER_AAC_ELD) {
1810 if (self->useLdQmfTimeAlign !=
1811 asc->m_sc.m_eldSpecificConfig.m_useLdQmfTimeAlign) {
1812 ascChanged = 1;
1813 }
1814 if (configMode & AC_CM_ALLOC_MEM) {
1815 self->useLdQmfTimeAlign =
1816 asc->m_sc.m_eldSpecificConfig.m_useLdQmfTimeAlign;
1817 }
1818 if (self->sbrEnabled != asc->m_sbrPresentFlag) {
1819 ascChanged = 1;
1820 }
1821 }
1822
1823 self->streamInfo.extAot = asc->m_extensionAudioObjectType;
1824 if (self->streamInfo.extSamplingRate !=
1825 (INT)asc->m_extensionSamplingFrequency) {
1826 ascChanged = 1;
1827 }
1828 if (configMode & AC_CM_ALLOC_MEM) {
1829 self->streamInfo.extSamplingRate = asc->m_extensionSamplingFrequency;
1830 }
1831 self->flags[streamIndex] |= (asc->m_sbrPresentFlag) ? AC_SBR_PRESENT : 0;
1832 self->flags[streamIndex] |= (asc->m_psPresentFlag) ? AC_PS_PRESENT : 0;
1833 if (asc->m_sbrPresentFlag) {
1834 self->sbrEnabled = 1;
1835 self->sbrEnabledPrev = 1;
1836 } else {
1837 self->sbrEnabled = 0;
1838 self->sbrEnabledPrev = 0;
1839 }
1840 if (self->sbrEnabled && asc->m_extensionSamplingFrequency) {
1841 if (downscaleFactor != 1 && (downscaleFactor)&1) {
1842 return AAC_DEC_UNSUPPORTED_SAMPLINGRATE; /* SBR needs an even downscale
1843 factor */
1844 }
1845 if (configMode & AC_CM_ALLOC_MEM) {
1846 self->streamInfo.extSamplingRate =
1847 self->streamInfo.extSamplingRate / self->downscaleFactor;
1848 }
1849 }
1850
1851 /* --------- vcb11 ------------ */
1852 self->flags[streamIndex] |= (asc->m_vcb11Flag) ? AC_ER_VCB11 : 0;
1853
1854 /* ---------- rvlc ------------ */
1855 self->flags[streamIndex] |= (asc->m_rvlcFlag) ? AC_ER_RVLC : 0;
1856
1857 /* ----------- hcr ------------ */
1858 self->flags[streamIndex] |= (asc->m_hcrFlag) ? AC_ER_HCR : 0;
1859
1860 if (asc->m_aot == AOT_ER_AAC_ELD) {
1861 self->mpsEnableCurr = 0;
1862 self->flags[streamIndex] |= AC_ELD;
1863 self->flags[streamIndex] |=
1864 (asc->m_sbrPresentFlag)
1865 ? AC_SBR_PRESENT
1866 : 0; /* Need to set the SBR flag for backward-compatibility
1867 reasons. Even if SBR is not supported. */
1868 self->flags[streamIndex] |=
1869 (asc->m_sc.m_eldSpecificConfig.m_sbrCrcFlag) ? AC_SBRCRC : 0;
1870 self->flags[streamIndex] |=
1871 (asc->m_sc.m_eldSpecificConfig.m_useLdQmfTimeAlign) ? AC_MPS_PRESENT
1872 : 0;
1873 if (self->mpsApplicable) {
1874 self->mpsEnableCurr = asc->m_sc.m_eldSpecificConfig.m_useLdQmfTimeAlign;
1875 }
1876 }
1877 self->flags[streamIndex] |= (asc->m_aot == AOT_ER_AAC_LD) ? AC_LD : 0;
1878 self->flags[streamIndex] |= (asc->m_epConfig >= 0) ? AC_ER : 0;
1879
1880 if (asc->m_aot == AOT_USAC) {
1881 self->flags[streamIndex] |= AC_USAC;
1882 self->flags[streamIndex] |=
1883 (asc->m_sc.m_usacConfig.element[0].m_stereoConfigIndex > 0)
1884 ? AC_MPS_PRESENT
1885 : 0;
1886 }
1887 if (asc->m_aot == AOT_DRM_AAC) {
1888 self->flags[streamIndex] |= AC_DRM | AC_SBRCRC | AC_SCALABLE;
1889 }
1890 if (asc->m_aot == AOT_DRM_SURROUND) {
1891 self->flags[streamIndex] |=
1892 AC_DRM | AC_SBRCRC | AC_SCALABLE | AC_MPS_PRESENT;
1893 FDK_ASSERT(!asc->m_psPresentFlag);
1894 }
1895 if ((asc->m_aot == AOT_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_SCAL)) {
1896 self->flags[streamIndex] |= AC_SCALABLE;
1897 }
1898
1899 if ((asc->m_epConfig >= 0) && (asc->m_channelConfiguration <= 0)) {
1900 /* we have to know the number of channels otherwise no decoding is possible
1901 */
1902 return AAC_DEC_UNSUPPORTED_ER_FORMAT;
1903 }
1904
1905 self->streamInfo.epConfig = asc->m_epConfig;
1906 /* self->hInput->asc.m_epConfig = asc->m_epConfig; */
1907
1908 if (asc->m_epConfig > 1) return AAC_DEC_UNSUPPORTED_ER_FORMAT;
1909
1910 /* Check if samplerate changed. */
1911 if ((self->samplingRateInfo[streamIndex].samplingRate !=
1912 asc->m_samplingFrequency) ||
1913 (self->streamInfo.aacSamplesPerFrame !=
1914 (INT)asc->m_samplesPerFrame / downscaleFactor)) {
1915 AAC_DECODER_ERROR error;
1916
1917 ascChanged = 1;
1918
1919 if (configMode & AC_CM_ALLOC_MEM) {
1920 /* Update samplerate info. */
1921 error = getSamplingRateInfo(
1922 &self->samplingRateInfo[streamIndex], asc->m_samplesPerFrame,
1923 asc->m_samplingFrequencyIndex, asc->m_samplingFrequency);
1924 if (error != AAC_DEC_OK) {
1925 return error;
1926 }
1927 self->streamInfo.aacSampleRate =
1928 self->samplingRateInfo[0].samplingRate / self->downscaleFactor;
1929 self->streamInfo.aacSamplesPerFrame =
1930 asc->m_samplesPerFrame / self->downscaleFactor;
1931 }
1932 }
1933
1934 /* Check if amount of channels has changed. */
1935 if (self->ascChannels[streamIndex] != ascChannels) {
1936 ascChanged = 1;
1937 }
1938
1939 /* detect config change */
1940 if (configMode & AC_CM_DET_CFG_CHANGE) {
1941 if (ascChanged != 0) {
1942 *configChanged = 1;
1943 }
1944 return err;
1945 }
1946
1947 /* set AC_USAC_SCFGI3 globally if any usac element uses */
1948 switch (asc->m_aot) {
1949 case AOT_USAC:
1950 if (self->sbrEnabled) {
1951 for (int _el = 0;
1952 _el < (int)self->pUsacConfig[streamIndex]->m_usacNumElements;
1953 _el++) {
1954 int el = elementOffset + _el;
1955 if (IS_USAC_CHANNEL_ELEMENT(self->elements[el])) {
1956 if (usacStereoConfigIndex < 0) {
1957 usacStereoConfigIndex = self->usacStereoConfigIndex[el];
1958 } else {
1959 if ((usacStereoConfigIndex != self->usacStereoConfigIndex[el]) ||
1960 (self->usacStereoConfigIndex[el] > 0)) {
1961 goto bail;
1962 }
1963 }
1964 }
1965 }
1966
1967 if (usacStereoConfigIndex < 0) {
1968 goto bail;
1969 }
1970
1971 if (usacStereoConfigIndex == 3) {
1972 self->flags[streamIndex] |= AC_USAC_SCFGI3;
1973 }
1974 }
1975 break;
1976 default:
1977 break;
1978 }
1979
1980 if (*configChanged) {
1981 /* Set up QMF domain for AOTs with explicit signalling of SBR and or MPS.
1982 This is to be able to play out the first frame alway with the correct
1983 frame size and sampling rate even in case of concealment.
1984 */
1985 switch (asc->m_aot) {
1986 case AOT_USAC:
1987 if (self->sbrEnabled) {
1988 const UCHAR map_sbrRatio_2_nAnaBands[] = {16, 24, 32};
1989
1990 FDK_ASSERT(asc->m_sc.m_usacConfig.m_sbrRatioIndex > 0);
1991 FDK_ASSERT(streamIndex == 0);
1992
1993 self->qmfDomain.globalConf.nInputChannels_requested = ascChannels;
1994 self->qmfDomain.globalConf.nOutputChannels_requested =
1995 (usacStereoConfigIndex == 1) ? 2 : ascChannels;
1996 self->qmfDomain.globalConf.flags_requested = 0;
1997 self->qmfDomain.globalConf.nBandsAnalysis_requested =
1998 map_sbrRatio_2_nAnaBands[asc->m_sc.m_usacConfig.m_sbrRatioIndex -
1999 1];
2000 self->qmfDomain.globalConf.nBandsSynthesis_requested = 64;
2001 self->qmfDomain.globalConf.nQmfTimeSlots_requested =
2002 (asc->m_sc.m_usacConfig.m_sbrRatioIndex == 1) ? 64 : 32;
2003 self->qmfDomain.globalConf.nQmfOvTimeSlots_requested =
2004 (asc->m_sc.m_usacConfig.m_sbrRatioIndex == 1) ? 12 : 6;
2005 self->qmfDomain.globalConf.nQmfProcBands_requested = 64;
2006 self->qmfDomain.globalConf.nQmfProcChannels_requested = 1;
2007 self->qmfDomain.globalConf.parkChannel =
2008 (usacStereoConfigIndex == 3) ? 1 : 0;
2009 self->qmfDomain.globalConf.parkChannel_requested =
2010 (usacStereoConfigIndex == 3) ? 1 : 0;
2011 self->qmfDomain.globalConf.qmfDomainExplicitConfig = 1;
2012 }
2013 break;
2014 case AOT_ER_AAC_ELD:
2015 if (self->mpsEnableCurr &&
2016 asc->m_sc.m_eldSpecificConfig.m_useLdQmfTimeAlign) {
2017 SAC_INPUT_CONFIG sac_interface =
2018 (self->sbrEnabled && self->hSbrDecoder) ? SAC_INTERFACE_QMF
2019 : SAC_INTERFACE_TIME;
2020 mpegSurroundDecoder_ConfigureQmfDomain(
2021 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder, sac_interface,
2022 (UINT)self->streamInfo.aacSampleRate, asc->m_aot);
2023 self->qmfDomain.globalConf.qmfDomainExplicitConfig = 1;
2024 }
2025 break;
2026 default:
2027 self->qmfDomain.globalConf.qmfDomainExplicitConfig =
2028 0; /* qmfDomain is initialized by SBR and MPS init functions if
2029 required */
2030 break;
2031 }
2032
2033 /* Allocate all memory structures for each channel */
2034 {
2035 int ch = aacChannelsOffset;
2036 for (int _ch = 0; _ch < ascChannels; _ch++) {
2037 if (ch >= (8)) {
2038 goto bail;
2039 }
2040 self->pAacDecoderChannelInfo[ch] = GetAacDecoderChannelInfo(ch);
2041 /* This is temporary until the DynamicData is split into two or more
2042 regions! The memory could be reused after completed core decoding. */
2043 if (self->pAacDecoderChannelInfo[ch] == NULL) {
2044 goto bail;
2045 }
2046 ch++;
2047 }
2048
2049 int chIdx = aacChannelsOffsetIdx;
2050 ch = aacChannelsOffset;
2051 int _numElements;
2052 _numElements = (((8)) + (8));
2053 if (self->flags[streamIndex] & (AC_RSV603DA | AC_USAC)) {
2054 _numElements = (int)asc->m_sc.m_usacConfig.m_usacNumElements;
2055 }
2056 for (int _el = 0; _el < _numElements; _el++) {
2057 int el_channels = 0;
2058 int el = elementOffset + _el;
2059
2060 if (self->flags[streamIndex] &
2061 (AC_ER | AC_LD | AC_ELD | AC_RSV603DA | AC_USAC | AC_RSVD50)) {
2062 if (ch >= ascChannels) {
2063 break;
2064 }
2065 }
2066
2067 switch (self->elements[el]) {
2068 case ID_SCE:
2069 case ID_CPE:
2070 case ID_LFE:
2071 case ID_USAC_SCE:
2072 case ID_USAC_CPE:
2073 case ID_USAC_LFE:
2074
2075 el_channels = CAacDecoder_GetELChannels(
2076 self->elements[el], self->usacStereoConfigIndex[el]);
2077
2078 {
2079 self->pAacDecoderChannelInfo[ch]->pComStaticData =
2080 (CAacDecoderCommonStaticData *)FDKcalloc(
2081 1, sizeof(CAacDecoderCommonStaticData));
2082 if (self->pAacDecoderChannelInfo[ch]->pComStaticData == NULL) {
2083 goto bail;
2084 }
2085 if (ch == aacChannelsOffset) {
2086 self->pAacDecoderChannelInfo[ch]->pComData =
2087 (CAacDecoderCommonData *)GetWorkBufferCore6();
2088 self->pAacDecoderChannelInfo[ch]
2089 ->pComStaticData->pWorkBufferCore1 = GetWorkBufferCore1();
2090 } else {
2091 self->pAacDecoderChannelInfo[ch]->pComData =
2092 (CAacDecoderCommonData *)FDKaalloc(
2093 sizeof(CAacDecoderCommonData), ALIGNMENT_DEFAULT);
2094 self->pAacDecoderChannelInfo[ch]
2095 ->pComStaticData->pWorkBufferCore1 =
2096 self->pAacDecoderChannelInfo[aacChannelsOffset]
2097 ->pComStaticData->pWorkBufferCore1;
2098 }
2099 if ((self->pAacDecoderChannelInfo[ch]->pComData == NULL) ||
2100 (self->pAacDecoderChannelInfo[ch]
2101 ->pComStaticData->pWorkBufferCore1 == NULL)) {
2102 goto bail;
2103 }
2104 self->pAacDecoderChannelInfo[ch]->pDynData =
2105 &(self->pAacDecoderChannelInfo[ch]
2106 ->pComData->pAacDecoderDynamicData[0]);
2107 self->pAacDecoderChannelInfo[ch]->pSpectralCoefficient =
2108 (SPECTRAL_PTR)&self->workBufferCore2[ch * 1024];
2109
2110 if (el_channels == 2) {
2111 if (ch >= (8) - 1) {
2112 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
2113 }
2114 self->pAacDecoderChannelInfo[ch + 1]->pComData =
2115 self->pAacDecoderChannelInfo[ch]->pComData;
2116 self->pAacDecoderChannelInfo[ch + 1]->pComStaticData =
2117 self->pAacDecoderChannelInfo[ch]->pComStaticData;
2118 self->pAacDecoderChannelInfo[ch + 1]
2119 ->pComStaticData->pWorkBufferCore1 =
2120 self->pAacDecoderChannelInfo[ch]
2121 ->pComStaticData->pWorkBufferCore1;
2122 self->pAacDecoderChannelInfo[ch + 1]->pDynData =
2123 &(self->pAacDecoderChannelInfo[ch]
2124 ->pComData->pAacDecoderDynamicData[1]);
2125 self->pAacDecoderChannelInfo[ch + 1]->pSpectralCoefficient =
2126 (SPECTRAL_PTR)&self->workBufferCore2[(ch + 1) * 1024];
2127 }
2128
2129 ch += el_channels;
2130 }
2131 chIdx += el_channels;
2132 break;
2133
2134 default:
2135 break;
2136 }
2137
2138 if (self->elements[el] == ID_END) {
2139 break;
2140 }
2141
2142 el++;
2143 }
2144
2145 chIdx = aacChannelsOffsetIdx;
2146 ch = aacChannelsOffset;
2147 for (int _ch = 0; _ch < ascChannels; _ch++) {
2148 /* Allocate persistent channel memory */
2149 {
2150 self->pAacDecoderStaticChannelInfo[ch] =
2151 GetAacDecoderStaticChannelInfo(ch);
2152 if (self->pAacDecoderStaticChannelInfo[ch] == NULL) {
2153 goto bail;
2154 }
2155 self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer =
2156 GetOverlapBuffer(ch); /* This area size depends on the AOT */
2157 if (self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer == NULL) {
2158 goto bail;
2159 }
2160 if (self->flags[streamIndex] &
2161 (AC_USAC | AC_RSVD50 | AC_RSV603DA /*|AC_BSAC*/)) {
2162 self->pAacDecoderStaticChannelInfo[ch]->hArCo = CArco_Create();
2163 if (self->pAacDecoderStaticChannelInfo[ch]->hArCo == NULL) {
2164 goto bail;
2165 }
2166 }
2167
2168 if (!(self->flags[streamIndex] & (AC_USAC | AC_RSV603DA))) {
2169 CPns_UpdateNoiseState(
2170 &self->pAacDecoderChannelInfo[ch]->data.aac.PnsData,
2171 &self->pAacDecoderStaticChannelInfo[ch]->pnsCurrentSeed,
2172 self->pAacDecoderChannelInfo[ch]->pComData->pnsRandomSeed);
2173 }
2174 ch++;
2175 }
2176 chIdx++;
2177 }
2178
2179 if (self->flags[streamIndex] & AC_USAC) {
2180 for (int _ch = 0; _ch < flushChannels; _ch++) {
2181 ch = aacChannelsOffset + _ch;
2182 if (self->pTimeDataFlush[ch] == NULL) {
2183 self->pTimeDataFlush[ch] = GetTimeDataFlush(ch);
2184 if (self->pTimeDataFlush[ch] == NULL) {
2185 goto bail;
2186 }
2187 }
2188 }
2189 }
2190
2191 if (self->flags[streamIndex] & (AC_USAC | AC_RSV603DA)) {
2192 int complexStereoPredPossible = 0;
2193 ch = aacChannelsOffset;
2194 chIdx = aacChannelsOffsetIdx;
2195 for (int _el2 = 0; _el2 < (int)asc->m_sc.m_usacConfig.m_usacNumElements;
2196 _el2++) {
2197 int el2 = elementOffset + _el2;
2198 int elCh = 0, ch2;
2199
2200 if ((self->elements[el2] == ID_USAC_CPE) &&
2201 !(self->usacStereoConfigIndex[el2] == 1)) {
2202 elCh = 2;
2203 } else if (IS_CHANNEL_ELEMENT(self->elements[el2])) {
2204 elCh = 1;
2205 }
2206
2207 if (self->elFlags[el2] & AC_EL_USAC_CP_POSSIBLE) {
2208 complexStereoPredPossible = 1;
2209 if (self->cpeStaticData[el2] == NULL) {
2210 self->cpeStaticData[el2] = GetCpePersistentData();
2211 if (self->cpeStaticData[el2] == NULL) {
2212 goto bail;
2213 }
2214 }
2215 }
2216
2217 for (ch2 = 0; ch2 < elCh; ch2++) {
2218 /* Hook element specific cpeStaticData into channel specific
2219 * aacDecoderStaticChannelInfo */
2220 self->pAacDecoderStaticChannelInfo[ch]->pCpeStaticData =
2221 self->cpeStaticData[el2];
2222 if (self->pAacDecoderStaticChannelInfo[ch]->pCpeStaticData !=
2223 NULL) {
2224 self->pAacDecoderStaticChannelInfo[ch]
2225 ->pCpeStaticData->jointStereoPersistentData
2226 .spectralCoeffs[ch2] =
2227 self->pAacDecoderStaticChannelInfo[ch]
2228 ->concealmentInfo.spectralCoefficient;
2229 self->pAacDecoderStaticChannelInfo[ch]
2230 ->pCpeStaticData->jointStereoPersistentData.specScale[ch2] =
2231 self->pAacDecoderStaticChannelInfo[ch]
2232 ->concealmentInfo.specScale;
2233 self->pAacDecoderStaticChannelInfo[ch]
2234 ->pCpeStaticData->jointStereoPersistentData.scratchBuffer =
2235 (FIXP_DBL *)self->pTimeData2;
2236 }
2237 chIdx++;
2238 ch++;
2239 } /* for each channel in current element */
2240 if (complexStereoPredPossible && (elCh == 2)) {
2241 /* needed once for all channels */
2242 if (self->pAacDecoderChannelInfo[ch - 1]
2243 ->pComStaticData->cplxPredictionData == NULL) {
2244 self->pAacDecoderChannelInfo[ch - 1]
2245 ->pComStaticData->cplxPredictionData =
2246 GetCplxPredictionData();
2247 }
2248 if (self->pAacDecoderChannelInfo[ch - 1]
2249 ->pComStaticData->cplxPredictionData == NULL) {
2250 goto bail;
2251 }
2252 }
2253 if (elCh > 0) {
2254 self->pAacDecoderStaticChannelInfo[ch - elCh]->nfRandomSeed =
2255 (ULONG)0x3039;
2256 if (self->elements[el2] == ID_USAC_CPE) {
2257 if (asc->m_sc.m_usacConfig.element[el2].m_stereoConfigIndex !=
2258 1) {
2259 self->pAacDecoderStaticChannelInfo[ch - elCh + 1]
2260 ->nfRandomSeed = (ULONG)0x10932;
2261 }
2262 }
2263 }
2264 } /* for each element */
2265 }
2266
2267 if (ascChannels != self->aacChannels) {
2268 /* Make allocated channel count persistent in decoder context. */
2269 self->aacChannels = aacChannelsOffset + ch;
2270 }
2271 }
2272
2273 if (usacResidualDelayCompSamples) {
2274 INT delayErr = FDK_Delay_Create(&self->usacResidualDelay,
2275 (USHORT)usacResidualDelayCompSamples, 1);
2276 if (delayErr) {
2277 goto bail;
2278 }
2279 }
2280
2281 /* Make amount of signalled channels persistent in decoder context. */
2282 self->ascChannels[streamIndex] = ascChannels;
2283 /* Init the previous channel count values. This is required to avoid a
2284 mismatch of memory accesses in the error concealment module and the
2285 allocated channel structures in this function. */
2286 self->aacChannelsPrev = 0;
2287 }
2288
2289 if (self->pAacDecoderChannelInfo[0] != NULL) {
2290 self->pDrmBsBuffer = self->pAacDecoderChannelInfo[0]
2291 ->pComStaticData->pWorkBufferCore1->DrmBsBuffer;
2292 self->drmBsBufferSize = DRM_BS_BUFFER_SIZE;
2293 }
2294
2295 /* Update structures */
2296 if (*configChanged) {
2297 /* Things to be done for each channel, which do not involve allocating
2298 memory. Doing these things only on the channels needed for the current
2299 configuration (ascChannels) could lead to memory access violation later
2300 (error concealment). */
2301 int ch = 0;
2302 int chIdx = 0;
2303 for (int _ch = 0; _ch < self->ascChannels[streamIndex]; _ch++) {
2304 switch (self->streamInfo.aot) {
2305 case AOT_ER_AAC_ELD:
2306 case AOT_ER_AAC_LD:
2307 self->pAacDecoderChannelInfo[ch]->granuleLength =
2308 self->streamInfo.aacSamplesPerFrame;
2309 break;
2310 default:
2311 self->pAacDecoderChannelInfo[ch]->granuleLength =
2312 self->streamInfo.aacSamplesPerFrame / 8;
2313 break;
2314 }
2315 self->pAacDecoderChannelInfo[ch]->renderMode = initRenderMode;
2316
2317 mdct_init(&self->pAacDecoderStaticChannelInfo[ch]->IMdct,
2318 self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer,
2319 OverlapBufferSize);
2320
2321 self->pAacDecoderStaticChannelInfo[ch]->last_core_mode = FD_LONG;
2322 self->pAacDecoderStaticChannelInfo[ch]->last_lpd_mode = 255;
2323
2324 self->pAacDecoderStaticChannelInfo[ch]->last_tcx_pitch = L_DIV;
2325
2326 /* Reset DRC control data for this channel */
2327 aacDecoder_drcInitChannelData(
2328 &self->pAacDecoderStaticChannelInfo[ch]->drcData);
2329
2330 /* Delete mixdown metadata from the past */
2331 pcmDmx_Reset(self->hPcmUtils, PCMDMX_RESET_BS_DATA);
2332
2333 /* Reset concealment only if ASC changed. Otherwise it will be done with
2334 any config callback. E.g. every time the LATM SMC is present. */
2335 CConcealment_InitChannelData(
2336 &self->pAacDecoderStaticChannelInfo[ch]->concealmentInfo,
2337 &self->concealCommonData, initRenderMode,
2338 self->streamInfo.aacSamplesPerFrame);
2339 ch++;
2340 chIdx++;
2341 }
2342 }
2343
2344 /* Update externally visible copy of flags */
2345 self->streamInfo.flags = self->flags[0];
2346
2347 if (*configChanged) {
2348 int drcDecSampleRate, drcDecFrameSize;
2349
2350 if (self->streamInfo.extSamplingRate != 0) {
2351 drcDecSampleRate = self->streamInfo.extSamplingRate;
2352 drcDecFrameSize = (self->streamInfo.aacSamplesPerFrame *
2353 self->streamInfo.extSamplingRate) /
2354 self->streamInfo.aacSampleRate;
2355 } else {
2356 drcDecSampleRate = self->streamInfo.aacSampleRate;
2357 drcDecFrameSize = self->streamInfo.aacSamplesPerFrame;
2358 }
2359
2360 if (FDK_drcDec_Init(self->hUniDrcDecoder, drcDecFrameSize, drcDecSampleRate,
2361 self->aacChannels) != 0)
2362 goto bail;
2363 }
2364
2365 if (asc->m_aot == AOT_USAC) {
2366 pcmLimiter_SetAttack(self->hLimiter, (5));
2367 pcmLimiter_SetThreshold(self->hLimiter, FL2FXCONST_DBL(0.89125094f));
2368 }
2369
2370 return err;
2371
2372 bail:
2373 CAacDecoder_DeInit(self, 0);
2374 return AAC_DEC_OUT_OF_MEMORY;
2375 }
2376
CAacDecoder_DecodeFrame(HANDLE_AACDECODER self,const UINT flags,FIXP_PCM * pTimeData,const INT timeDataSize,const int timeDataChannelOffset)2377 LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_DecodeFrame(
2378 HANDLE_AACDECODER self, const UINT flags, FIXP_PCM *pTimeData,
2379 const INT timeDataSize, const int timeDataChannelOffset) {
2380 AAC_DECODER_ERROR ErrorStatus = AAC_DEC_OK;
2381
2382 CProgramConfig *pce;
2383 HANDLE_FDK_BITSTREAM bs = transportDec_GetBitstream(self->hInput, 0);
2384
2385 MP4_ELEMENT_ID type = ID_NONE; /* Current element type */
2386 INT aacChannels = 0; /* Channel counter for channels found in the bitstream */
2387 const int streamIndex = 0; /* index of the current substream */
2388
2389 INT auStartAnchor = (INT)FDKgetValidBits(
2390 bs); /* AU start bit buffer position for AU byte alignment */
2391
2392 INT checkSampleRate = self->streamInfo.aacSampleRate;
2393
2394 INT CConceal_TDFading_Applied[(8)] = {
2395 0}; /* Initialize status of Time Domain fading */
2396
2397 if (self->aacChannels <= 0) {
2398 return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
2399 }
2400
2401 /* Any supported base layer valid AU will require more than 16 bits. */
2402 if ((transportDec_GetAuBitsRemaining(self->hInput, 0) < 15) &&
2403 (flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) == 0) {
2404 self->frameOK = 0;
2405 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
2406 }
2407
2408 /* Reset Program Config structure */
2409 pce = &self->pce;
2410 CProgramConfig_Reset(pce);
2411
2412 CAacDecoder_AncDataReset(&self->ancData);
2413 if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) &&
2414 !(self->flags[0] & (AC_USAC | AC_RSV603DA))) {
2415 int ch;
2416 if (self->streamInfo.channelConfig == 0) {
2417 /* Init Channel/Element mapping table */
2418 for (ch = 0; ch < (8); ch++) {
2419 self->chMapping[ch] = 255;
2420 }
2421 if (!CProgramConfig_IsValid(pce)) {
2422 int el;
2423 for (el = 0; el < (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1);
2424 el++) {
2425 self->elements[el] = ID_NONE;
2426 }
2427 }
2428 }
2429 }
2430
2431 if (self->downscaleFactor > 1 && (self->flags[0] & AC_ELD)) {
2432 self->flags[0] |= AC_ELD_DOWNSCALE;
2433 } else {
2434 self->flags[0] &= ~AC_ELD_DOWNSCALE;
2435 }
2436 /* unsupported dsf (aacSampleRate has not yet been divided by dsf) -> divide
2437 */
2438 if (self->downscaleFactorInBS > 1 &&
2439 (self->flags[0] & AC_ELD_DOWNSCALE) == 0) {
2440 checkSampleRate =
2441 self->streamInfo.aacSampleRate / self->downscaleFactorInBS;
2442 }
2443
2444 /* Check sampling frequency */
2445 if (self->streamInfo.aacSampleRate <= 0) {
2446 /* Instance maybe uninitialized! */
2447 return AAC_DEC_UNSUPPORTED_SAMPLINGRATE;
2448 }
2449 switch (checkSampleRate) {
2450 case 96000:
2451 case 88200:
2452 case 64000:
2453 case 16000:
2454 case 12000:
2455 case 11025:
2456 case 8000:
2457 case 7350:
2458 case 48000:
2459 case 44100:
2460 case 32000:
2461 case 24000:
2462 case 22050:
2463 break;
2464 default:
2465 if (!(self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA))) {
2466 return AAC_DEC_UNSUPPORTED_SAMPLINGRATE;
2467 }
2468 break;
2469 }
2470
2471 if (flags & AACDEC_CLRHIST) {
2472 if (!(self->flags[0] & AC_USAC)) {
2473 int ch;
2474 /* Clear history */
2475 for (ch = 0; ch < self->aacChannels; ch++) {
2476 /* Reset concealment */
2477 CConcealment_InitChannelData(
2478 &self->pAacDecoderStaticChannelInfo[ch]->concealmentInfo,
2479 &self->concealCommonData,
2480 self->pAacDecoderChannelInfo[0]->renderMode,
2481 self->streamInfo.aacSamplesPerFrame);
2482 /* Clear overlap-add buffers to avoid clicks. */
2483 FDKmemclear(self->pAacDecoderStaticChannelInfo[ch]->pOverlapBuffer,
2484 OverlapBufferSize * sizeof(FIXP_DBL));
2485 }
2486 if (self->streamInfo.channelConfig > 0) {
2487 /* Declare the possibly adopted old PCE (with outdated metadata)
2488 * invalid. */
2489 CProgramConfig_Init(pce);
2490 }
2491 }
2492 }
2493
2494 int pceRead = 0; /* Flag indicating a PCE in the current raw_data_block() */
2495
2496 INT hdaacDecoded = 0;
2497 MP4_ELEMENT_ID previous_element =
2498 ID_END; /* Last element ID (required for extension payload mapping */
2499 UCHAR previous_element_index = 0; /* Canonical index of last element */
2500 int element_count =
2501 0; /* Element counter for elements found in the bitstream */
2502 int channel_element_count = 0; /* Channel element counter */
2503 MP4_ELEMENT_ID
2504 channel_elements[(3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) +
2505 1)]; /* Channel elements in bit stream order. */
2506 int el_cnt[ID_LAST] = {0}; /* element counter ( robustness ) */
2507 int element_count_prev_streams =
2508 0; /* Element count of all previous sub streams. */
2509
2510 while ((type != ID_END) && (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH))) &&
2511 self->frameOK) {
2512 int el_channels;
2513
2514 if (!(self->flags[0] &
2515 (AC_USAC | AC_RSVD50 | AC_RSV603DA | AC_ELD | AC_SCALABLE | AC_ER)))
2516 type = (MP4_ELEMENT_ID)FDKreadBits(bs, 3);
2517 else {
2518 if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
2519 self->frameOK = 0;
2520 ErrorStatus = AAC_DEC_PARSE_ERROR;
2521 break;
2522 }
2523 type = self->elements[element_count];
2524 }
2525
2526 if ((self->flags[streamIndex] & (AC_USAC | AC_RSVD50) &&
2527 element_count == 0) ||
2528 (self->flags[streamIndex] & AC_RSV603DA)) {
2529 self->flags[streamIndex] &= ~AC_INDEP;
2530
2531 if (FDKreadBit(bs)) {
2532 self->flags[streamIndex] |= AC_INDEP;
2533 }
2534
2535 int ch = aacChannels;
2536 for (int chIdx = aacChannels; chIdx < self->ascChannels[streamIndex];
2537 chIdx++) {
2538 {
2539 /* Robustness check */
2540 if (ch >= self->aacChannels) {
2541 return AAC_DEC_UNKNOWN;
2542 }
2543
2544 /* if last frame was broken and this frame is no independent frame,
2545 * correct decoding is impossible we need to trigger concealment */
2546 if ((CConcealment_GetLastFrameOk(
2547 &self->pAacDecoderStaticChannelInfo[ch]->concealmentInfo,
2548 1) == 0) &&
2549 !(self->flags[streamIndex] & AC_INDEP)) {
2550 self->frameOK = 0;
2551 }
2552 ch++;
2553 }
2554 }
2555 }
2556
2557 if ((INT)FDKgetValidBits(bs) < 0) {
2558 self->frameOK = 0;
2559 }
2560
2561 switch (type) {
2562 case ID_SCE:
2563 case ID_CPE:
2564 case ID_LFE:
2565 case ID_USAC_SCE:
2566 case ID_USAC_CPE:
2567 case ID_USAC_LFE:
2568 if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
2569 self->frameOK = 0;
2570 ErrorStatus = AAC_DEC_PARSE_ERROR;
2571 break;
2572 }
2573
2574 el_channels = CAacDecoder_GetELChannels(
2575 type, self->usacStereoConfigIndex[element_count]);
2576
2577 /*
2578 Consistency check
2579 */
2580 {
2581 int totalAscChannels = 0;
2582
2583 for (int i = 0; i < (1 * 1); i++) {
2584 totalAscChannels += self->ascChannels[i];
2585 }
2586 if ((el_cnt[type] >= (totalAscChannels >> (el_channels - 1))) ||
2587 (aacChannels > (totalAscChannels - el_channels))) {
2588 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
2589 self->frameOK = 0;
2590 break;
2591 }
2592 }
2593
2594 if (!(self->flags[streamIndex] & (AC_USAC | AC_RSVD50 | AC_RSV603DA))) {
2595 int ch;
2596 for (ch = 0; ch < el_channels; ch += 1) {
2597 CPns_ResetData(&self->pAacDecoderChannelInfo[aacChannels + ch]
2598 ->data.aac.PnsData,
2599 &self->pAacDecoderChannelInfo[aacChannels + ch]
2600 ->pComData->pnsInterChannelData);
2601 }
2602 }
2603
2604 if (self->frameOK) {
2605 ErrorStatus = CChannelElement_Read(
2606 bs, &self->pAacDecoderChannelInfo[aacChannels],
2607 &self->pAacDecoderStaticChannelInfo[aacChannels],
2608 self->streamInfo.aot, &self->samplingRateInfo[streamIndex],
2609 self->flags[streamIndex], self->elFlags[element_count],
2610 self->streamInfo.aacSamplesPerFrame, el_channels,
2611 self->streamInfo.epConfig, self->hInput);
2612 if (ErrorStatus != AAC_DEC_OK) {
2613 self->frameOK = 0;
2614 }
2615 }
2616
2617 if (self->frameOK) {
2618 /* Lookup the element and decode it only if it belongs to the current
2619 * program */
2620 if (CProgramConfig_LookupElement(
2621 pce, self->streamInfo.channelConfig,
2622 self->pAacDecoderChannelInfo[aacChannels]->ElementInstanceTag,
2623 aacChannels, self->chMapping, self->channelType,
2624 self->channelIndices, (8), &previous_element_index,
2625 self->elements, type)) {
2626 channel_elements[channel_element_count++] = type;
2627 aacChannels += el_channels;
2628 } else {
2629 self->frameOK = 0;
2630 }
2631 /* Create SBR element for SBR for upsampling for LFE elements,
2632 and if SBR was implicitly signaled, because the first frame(s)
2633 may not contain SBR payload (broken encoder, bit errors). */
2634 if (self->frameOK &&
2635 ((self->flags[streamIndex] & AC_SBR_PRESENT) ||
2636 (self->sbrEnabled == 1)) &&
2637 !(self->flags[streamIndex] &
2638 AC_USAC) /* Is done during explicit config set up */
2639 ) {
2640 SBR_ERROR sbrError;
2641 UCHAR configMode = 0;
2642 UCHAR configChanged = 0;
2643 configMode |= AC_CM_ALLOC_MEM;
2644
2645 sbrError = sbrDecoder_InitElement(
2646 self->hSbrDecoder, self->streamInfo.aacSampleRate,
2647 self->streamInfo.extSamplingRate,
2648 self->streamInfo.aacSamplesPerFrame, self->streamInfo.aot, type,
2649 previous_element_index, 2, /* Signalize that harmonicSBR shall
2650 be ignored in the config change
2651 detection */
2652 0, configMode, &configChanged, self->downscaleFactor);
2653 if (sbrError != SBRDEC_OK) {
2654 /* Do not try to apply SBR because initializing the element
2655 * failed. */
2656 self->sbrEnabled = 0;
2657 }
2658 }
2659 }
2660
2661 el_cnt[type]++;
2662 if (self->frameOK && (self->flags[streamIndex] & AC_USAC) &&
2663 (type == ID_USAC_CPE || type == ID_USAC_SCE)) {
2664 ErrorStatus = aacDecoder_ParseExplicitMpsAndSbr(
2665 self, bs, previous_element, previous_element_index, element_count,
2666 el_cnt);
2667 if (ErrorStatus != AAC_DEC_OK) {
2668 self->frameOK = 0;
2669 }
2670 }
2671 break;
2672
2673 case ID_CCE:
2674 /*
2675 Consistency check
2676 */
2677 if (el_cnt[type] > self->ascChannels[streamIndex]) {
2678 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
2679 self->frameOK = 0;
2680 break;
2681 }
2682
2683 if (self->frameOK) {
2684 CAacDecoderCommonData commonData;
2685 CAacDecoderCommonStaticData commonStaticData;
2686 CWorkBufferCore1 workBufferCore1;
2687 commonStaticData.pWorkBufferCore1 = &workBufferCore1;
2688 /* memory for spectral lines temporal on scratch */
2689 C_AALLOC_SCRATCH_START(mdctSpec, FIXP_DBL, 1024);
2690
2691 /* create dummy channel for CCE parsing on stack */
2692 CAacDecoderChannelInfo tmpAacDecoderChannelInfo,
2693 *pTmpAacDecoderChannelInfo;
2694
2695 FDKmemclear(mdctSpec, 1024 * sizeof(FIXP_DBL));
2696
2697 tmpAacDecoderChannelInfo.pDynData = commonData.pAacDecoderDynamicData;
2698 tmpAacDecoderChannelInfo.pComData = &commonData;
2699 tmpAacDecoderChannelInfo.pComStaticData = &commonStaticData;
2700 tmpAacDecoderChannelInfo.pSpectralCoefficient =
2701 (SPECTRAL_PTR)mdctSpec;
2702 /* Assume AAC-LC */
2703 tmpAacDecoderChannelInfo.granuleLength =
2704 self->streamInfo.aacSamplesPerFrame / 8;
2705 /* Reset PNS data. */
2706 CPns_ResetData(
2707 &tmpAacDecoderChannelInfo.data.aac.PnsData,
2708 &tmpAacDecoderChannelInfo.pComData->pnsInterChannelData);
2709 pTmpAacDecoderChannelInfo = &tmpAacDecoderChannelInfo;
2710 /* do CCE parsing */
2711 ErrorStatus = CChannelElement_Read(
2712 bs, &pTmpAacDecoderChannelInfo, NULL, self->streamInfo.aot,
2713 &self->samplingRateInfo[streamIndex], self->flags[streamIndex],
2714 AC_EL_GA_CCE, self->streamInfo.aacSamplesPerFrame, 1,
2715 self->streamInfo.epConfig, self->hInput);
2716
2717 C_AALLOC_SCRATCH_END(mdctSpec, FIXP_DBL, 1024);
2718
2719 if (ErrorStatus) {
2720 self->frameOK = 0;
2721 }
2722
2723 if (self->frameOK) {
2724 /* Lookup the element and decode it only if it belongs to the
2725 * current program */
2726 if (CProgramConfig_LookupElement(
2727 pce, self->streamInfo.channelConfig,
2728 pTmpAacDecoderChannelInfo->ElementInstanceTag, 0,
2729 self->chMapping, self->channelType, self->channelIndices,
2730 (8), &previous_element_index, self->elements, type)) {
2731 /* decoding of CCE not supported */
2732 } else {
2733 self->frameOK = 0;
2734 }
2735 }
2736 }
2737 el_cnt[type]++;
2738 break;
2739
2740 case ID_DSE: {
2741 UCHAR element_instance_tag;
2742
2743 CDataStreamElement_Read(self, bs, &element_instance_tag, auStartAnchor);
2744
2745 if (!CProgramConfig_LookupElement(
2746 pce, self->streamInfo.channelConfig, element_instance_tag, 0,
2747 self->chMapping, self->channelType, self->channelIndices, (8),
2748 &previous_element_index, self->elements, type)) {
2749 /* most likely an error in bitstream occured */
2750 // self->frameOK = 0;
2751 }
2752 } break;
2753
2754 case ID_PCE: {
2755 int result = CProgramConfigElement_Read(bs, self->hInput, pce,
2756 self->streamInfo.channelConfig,
2757 auStartAnchor);
2758 if (result < 0) {
2759 /* Something went wrong */
2760 ErrorStatus = AAC_DEC_PARSE_ERROR;
2761 self->frameOK = 0;
2762 } else if (result > 1) {
2763 /* Built element table */
2764 int elIdx = CProgramConfig_GetElementTable(
2765 pce, self->elements, (((8)) + (8)), &self->chMapIndex);
2766 /* Reset the remaining tabs */
2767 for (; elIdx < (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1);
2768 elIdx++) {
2769 self->elements[elIdx] = ID_NONE;
2770 }
2771 /* Make new number of channel persistent */
2772 self->ascChannels[streamIndex] = pce->NumChannels;
2773 /* If PCE is not first element conceal this frame to avoid
2774 * inconsistencies */
2775 if (element_count != 0) {
2776 self->frameOK = 0;
2777 }
2778 }
2779 pceRead = (result >= 0) ? 1 : 0;
2780 } break;
2781
2782 case ID_FIL: {
2783 int bitCnt = FDKreadBits(bs, 4); /* bs_count */
2784
2785 if (bitCnt == 15) {
2786 int esc_count = FDKreadBits(bs, 8); /* bs_esc_count */
2787 bitCnt = esc_count + 14;
2788 }
2789
2790 /* Convert to bits */
2791 bitCnt <<= 3;
2792
2793 while (bitCnt > 0) {
2794 ErrorStatus = CAacDecoder_ExtPayloadParse(
2795 self, bs, &bitCnt, previous_element, previous_element_index, 1);
2796 if (ErrorStatus != AAC_DEC_OK) {
2797 self->frameOK = 0;
2798 break;
2799 }
2800 }
2801 } break;
2802
2803 case ID_EXT:
2804 if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
2805 self->frameOK = 0;
2806 ErrorStatus = AAC_DEC_PARSE_ERROR;
2807 break;
2808 }
2809
2810 ErrorStatus = aacDecoder_ParseExplicitMpsAndSbr(
2811 self, bs, previous_element, previous_element_index, element_count,
2812 el_cnt);
2813 break;
2814
2815 case ID_USAC_EXT: {
2816 if ((element_count - element_count_prev_streams) >=
2817 TP_USAC_MAX_ELEMENTS) {
2818 self->frameOK = 0;
2819 ErrorStatus = AAC_DEC_PARSE_ERROR;
2820 break;
2821 }
2822 /* parse extension element payload
2823 q.v. rsv603daExtElement() ISO/IEC DIS 23008-3 Table 30
2824 or UsacExElement() ISO/IEC FDIS 23003-3:2011(E) Table 21
2825 */
2826 int usacExtElementPayloadLength;
2827 /* int usacExtElementStart, usacExtElementStop; */
2828
2829 if (FDKreadBit(bs)) { /* usacExtElementPresent */
2830 if (FDKreadBit(bs)) { /* usacExtElementUseDefaultLength */
2831 usacExtElementPayloadLength =
2832 self->pUsacConfig[streamIndex]
2833 ->element[element_count - element_count_prev_streams]
2834 .extElement.usacExtElementDefaultLength;
2835 } else {
2836 usacExtElementPayloadLength = FDKreadBits(bs, 8);
2837 if (usacExtElementPayloadLength == (UINT)(1 << 8) - 1) {
2838 UINT valueAdd = FDKreadBits(bs, 16);
2839 usacExtElementPayloadLength += (INT)valueAdd - 2;
2840 }
2841 }
2842 if (usacExtElementPayloadLength > 0) {
2843 int usacExtBitPos;
2844
2845 if (self->pUsacConfig[streamIndex]
2846 ->element[element_count - element_count_prev_streams]
2847 .extElement.usacExtElementPayloadFrag) {
2848 /* usacExtElementStart = */ FDKreadBit(bs);
2849 /* usacExtElementStop = */ FDKreadBit(bs);
2850 } else {
2851 /* usacExtElementStart = 1; */
2852 /* usacExtElementStop = 1; */
2853 }
2854
2855 usacExtBitPos = (INT)FDKgetValidBits(bs);
2856
2857 USAC_EXT_ELEMENT_TYPE usacExtElementType =
2858 self->pUsacConfig[streamIndex]
2859 ->element[element_count - element_count_prev_streams]
2860 .extElement.usacExtElementType;
2861
2862 switch (usacExtElementType) {
2863 case ID_EXT_ELE_UNI_DRC: /* uniDrcGain() */
2864 if (streamIndex == 0) {
2865 int drcErr;
2866
2867 drcErr = FDK_drcDec_ReadUniDrcGain(self->hUniDrcDecoder, bs);
2868 if (drcErr != 0) {
2869 ErrorStatus = AAC_DEC_PARSE_ERROR;
2870 }
2871 }
2872 break;
2873
2874 default:
2875 break;
2876 }
2877
2878 /* Skip any remaining bits of extension payload */
2879 usacExtBitPos = (usacExtElementPayloadLength * 8) -
2880 (usacExtBitPos - (INT)FDKgetValidBits(bs));
2881 if (usacExtBitPos < 0) {
2882 self->frameOK = 0;
2883 ErrorStatus = AAC_DEC_PARSE_ERROR;
2884 }
2885 FDKpushBiDirectional(bs, usacExtBitPos);
2886 }
2887 }
2888 } break;
2889 case ID_END:
2890 case ID_USAC_END:
2891 break;
2892
2893 default:
2894 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
2895 self->frameOK = 0;
2896 break;
2897 }
2898
2899 previous_element = type;
2900 element_count++;
2901
2902 } /* while ( (type != ID_END) ... ) */
2903
2904 if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH))) {
2905 /* float decoder checks if bitsLeft is in range 0-7; only prerollAUs are
2906 * byteAligned with respect to the first bit */
2907 /* Byte alignment with respect to the first bit of the raw_data_block(). */
2908 if (!(self->flags[streamIndex] & (AC_RSVD50 | AC_USAC)) ||
2909 (self->prerollAULength[self->accessUnit]) /* indicates preroll */
2910 ) {
2911 FDKbyteAlign(bs, auStartAnchor);
2912 }
2913
2914 /* Check if all bits of the raw_data_block() have been read. */
2915 if (transportDec_GetAuBitsTotal(self->hInput, 0) > 0) {
2916 INT unreadBits = transportDec_GetAuBitsRemaining(self->hInput, 0);
2917 /* for pre-roll frames pre-roll length has to be used instead of total AU
2918 * lenght */
2919 /* unreadBits regarding preroll bounds */
2920 if (self->prerollAULength[self->accessUnit]) {
2921 unreadBits = unreadBits - transportDec_GetAuBitsTotal(self->hInput, 0) +
2922 (INT)self->prerollAULength[self->accessUnit];
2923 }
2924 if (((self->flags[streamIndex] & (AC_RSVD50 | AC_USAC)) &&
2925 ((unreadBits < 0) || (unreadBits > 7)) &&
2926 !(self->prerollAULength[self->accessUnit])) ||
2927 ((!(self->flags[streamIndex] & (AC_RSVD50 | AC_USAC)) ||
2928 (self->prerollAULength[self->accessUnit])) &&
2929 (unreadBits != 0))) {
2930 if ((((unreadBits < 0) || (unreadBits > 7)) && self->frameOK) &&
2931 ((transportDec_GetFormat(self->hInput) == TT_DRM) &&
2932 (self->flags[streamIndex] & AC_USAC))) {
2933 /* Set frame OK because of fill bits. */
2934 self->frameOK = 1;
2935 } else {
2936 self->frameOK = 0;
2937 }
2938
2939 /* Do not overwrite current error */
2940 if (ErrorStatus == AAC_DEC_OK && self->frameOK == 0) {
2941 ErrorStatus = AAC_DEC_PARSE_ERROR;
2942 }
2943 /* Always put the bitbuffer at the right position after the current
2944 * Access Unit. */
2945 FDKpushBiDirectional(bs, unreadBits);
2946 }
2947 }
2948
2949 /* Check the last element. The terminator (ID_END) has to be the last one
2950 * (even if ER syntax is used). */
2951 if (self->frameOK && type != ID_END) {
2952 /* Do not overwrite current error */
2953 if (ErrorStatus == AAC_DEC_OK) {
2954 ErrorStatus = AAC_DEC_PARSE_ERROR;
2955 }
2956 self->frameOK = 0;
2957 }
2958 }
2959
2960 if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) && self->frameOK) {
2961 channel_elements[channel_element_count++] = ID_END;
2962 }
2963 element_count = 0;
2964 aacChannels = 0;
2965 type = ID_NONE;
2966 previous_element_index = 0;
2967
2968 while (type != ID_END &&
2969 element_count < (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
2970 int el_channels;
2971
2972 if ((flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) || !self->frameOK) {
2973 channel_elements[element_count] = self->elements[element_count];
2974 if (channel_elements[element_count] == ID_NONE) {
2975 channel_elements[element_count] = ID_END;
2976 }
2977 }
2978
2979 if (self->flags[streamIndex] & (AC_USAC | AC_RSV603DA | AC_BSAC)) {
2980 type = self->elements[element_count];
2981 } else {
2982 type = channel_elements[element_count];
2983 }
2984
2985 if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) && self->frameOK) {
2986 switch (type) {
2987 case ID_SCE:
2988 case ID_CPE:
2989 case ID_LFE:
2990 case ID_USAC_SCE:
2991 case ID_USAC_CPE:
2992 case ID_USAC_LFE:
2993
2994 el_channels = CAacDecoder_GetELChannels(
2995 type, self->usacStereoConfigIndex[element_count]);
2996
2997 if (!hdaacDecoded) {
2998 if (self->pAacDecoderStaticChannelInfo[aacChannels]
2999 ->pCpeStaticData != NULL) {
3000 self->pAacDecoderStaticChannelInfo[aacChannels]
3001 ->pCpeStaticData->jointStereoPersistentData.scratchBuffer =
3002 (FIXP_DBL *)pTimeData;
3003 }
3004 CChannelElement_Decode(
3005 &self->pAacDecoderChannelInfo[aacChannels],
3006 &self->pAacDecoderStaticChannelInfo[aacChannels],
3007 &self->samplingRateInfo[streamIndex], self->flags[streamIndex],
3008 self->elFlags[element_count], el_channels);
3009 }
3010 aacChannels += el_channels;
3011 break;
3012 case ID_NONE:
3013 type = ID_END;
3014 break;
3015 default:
3016 break;
3017 }
3018 }
3019 element_count++;
3020 }
3021
3022 /* More AAC channels than specified by the ASC not allowed. */
3023 if ((aacChannels == 0 || aacChannels > self->aacChannels) &&
3024 !(flags & (AACDEC_CONCEAL | AACDEC_FLUSH))) {
3025 /* Do not overwrite current error */
3026 if (ErrorStatus == AAC_DEC_OK) {
3027 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
3028 }
3029 self->frameOK = 0;
3030 aacChannels = 0;
3031 }
3032
3033 if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH))) {
3034 if (TRANSPORTDEC_OK != transportDec_CrcCheck(self->hInput)) {
3035 ErrorStatus = AAC_DEC_CRC_ERROR;
3036 self->frameOK = 0;
3037 }
3038 }
3039
3040 /* Ensure that in case of concealment a proper error status is set. */
3041 if ((self->frameOK == 0) && (ErrorStatus == AAC_DEC_OK)) {
3042 ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
3043 }
3044
3045 if (self->frameOK && (flags & AACDEC_FLUSH)) {
3046 aacChannels = self->aacChannelsPrev;
3047 /* Because the downmix could be active, its necessary to restore the channel
3048 * type and indices. */
3049 FDKmemcpy(self->channelType, self->channelTypePrev,
3050 (8) * sizeof(AUDIO_CHANNEL_TYPE)); /* restore */
3051 FDKmemcpy(self->channelIndices, self->channelIndicesPrev,
3052 (8) * sizeof(UCHAR)); /* restore */
3053 self->sbrEnabled = self->sbrEnabledPrev;
3054 } else {
3055 /* store or restore the number of channels and the corresponding info */
3056 if (self->frameOK && !(flags & AACDEC_CONCEAL)) {
3057 self->aacChannelsPrev = aacChannels; /* store */
3058 FDKmemcpy(self->channelTypePrev, self->channelType,
3059 (8) * sizeof(AUDIO_CHANNEL_TYPE)); /* store */
3060 FDKmemcpy(self->channelIndicesPrev, self->channelIndices,
3061 (8) * sizeof(UCHAR)); /* store */
3062 self->sbrEnabledPrev = self->sbrEnabled;
3063 } else {
3064 if (self->aacChannels > 0) {
3065 if ((self->buildUpStatus == AACDEC_RSV60_BUILD_UP_ON) ||
3066 (self->buildUpStatus == AACDEC_RSV60_BUILD_UP_ON_IN_BAND) ||
3067 (self->buildUpStatus == AACDEC_USAC_BUILD_UP_ON)) {
3068 aacChannels = self->aacChannels;
3069 self->aacChannelsPrev = aacChannels; /* store */
3070 } else {
3071 aacChannels = self->aacChannelsPrev; /* restore */
3072 }
3073 FDKmemcpy(self->channelType, self->channelTypePrev,
3074 (8) * sizeof(AUDIO_CHANNEL_TYPE)); /* restore */
3075 FDKmemcpy(self->channelIndices, self->channelIndicesPrev,
3076 (8) * sizeof(UCHAR)); /* restore */
3077 self->sbrEnabled = self->sbrEnabledPrev;
3078 }
3079 }
3080 }
3081
3082 /* Update number of output channels */
3083 self->streamInfo.aacNumChannels = aacChannels;
3084
3085 /* Ensure consistency of IS_OUTPUT_VALID() macro. */
3086 if (aacChannels == 0) {
3087 ErrorStatus = AAC_DEC_UNKNOWN;
3088 }
3089
3090 if (pceRead == 1 && CProgramConfig_IsValid(pce)) {
3091 /* Set matrix mixdown infos if available from PCE. */
3092 pcmDmx_SetMatrixMixdownFromPce(
3093 self->hPcmUtils, pce->MatrixMixdownIndexPresent,
3094 pce->MatrixMixdownIndex, pce->PseudoSurroundEnable);
3095 ;
3096 }
3097
3098 /* If there is no valid data to transfrom into time domain, return. */
3099 if (!IS_OUTPUT_VALID(ErrorStatus)) {
3100 return ErrorStatus;
3101 }
3102
3103 /* Setup the output channel mapping. The table below shows the three
3104 * possibilities: # | chCfg | PCE | chMapIndex
3105 * ---+-------+-----+------------------
3106 * 1 | > 0 | no | chCfg
3107 * 2 | 0 | yes | cChCfg
3108 * 3 | 0 | no | aacChannels || 0
3109 * ---+-------+-----+--------+------------------
3110 * Where chCfg is the channel configuration index from ASC and cChCfg is a
3111 * corresponding chCfg derived from a given PCE. The variable aacChannels
3112 * represents the number of channel found during bitstream decoding. Due to
3113 * the structure of the mapping table it can only be used for mapping if its
3114 * value is smaller than 7. Otherwise we use the fallback (0) which is a
3115 * simple pass-through. The possibility #3 should appear only with MPEG-2
3116 * (ADTS) streams. This is mode is called "implicit channel mapping".
3117 */
3118 if ((self->streamInfo.channelConfig == 0) && !pce->isValid) {
3119 self->chMapIndex = (aacChannels < 7) ? aacChannels : 0;
3120 }
3121
3122 /*
3123 Inverse transform
3124 */
3125 {
3126 int c, cIdx;
3127 int mapped, fCopyChMap = 1;
3128 UCHAR drcChMap[(8)];
3129
3130 if ((self->streamInfo.channelConfig == 0) && CProgramConfig_IsValid(pce)) {
3131 /* ISO/IEC 14496-3 says:
3132 If a PCE is present, the exclude_mask bits correspond to the audio
3133 channels in the SCE, CPE, CCE and LFE syntax elements in the order of
3134 their appearance in the PCE. In the case of a CPE, the first
3135 transmitted mask bit corresponds to the first channel in the CPE, the
3136 second transmitted mask bit to the second channel. In the case of a
3137 CCE, a mask bit is transmitted only if the coupling channel is
3138 specified to be an independently switched coupling channel. Thus we
3139 have to convert the internal channel mapping from "canonical" MPEG to
3140 PCE order: */
3141 UCHAR tmpChMap[(8)];
3142 if (CProgramConfig_GetPceChMap(pce, tmpChMap, (8)) == 0) {
3143 for (c = 0; c < aacChannels; c += 1) {
3144 drcChMap[c] =
3145 (self->chMapping[c] == 255) ? 255 : tmpChMap[self->chMapping[c]];
3146 }
3147 fCopyChMap = 0;
3148 }
3149 }
3150 if (fCopyChMap != 0) {
3151 FDKmemcpy(drcChMap, self->chMapping, (8) * sizeof(UCHAR));
3152 }
3153
3154 /* Turn on/off DRC modules level normalization in digital domain depending
3155 * on the limiter status. */
3156 aacDecoder_drcSetParam(self->hDrcInfo, APPLY_NORMALIZATION,
3157 (self->limiterEnableCurr) ? 0 : 1);
3158
3159 /* deactivate legacy DRC in case uniDrc is active, i.e. uniDrc payload is
3160 * present and one of DRC or Loudness Normalization is switched on */
3161 aacDecoder_drcSetParam(
3162 self->hDrcInfo, UNIDRC_PRECEDENCE,
3163 FDK_drcDec_GetParam(self->hUniDrcDecoder, DRC_DEC_IS_ACTIVE));
3164
3165 /* Extract DRC control data and map it to channels (without bitstream delay)
3166 */
3167 mapped = aacDecoder_drcProlog(
3168 self->hDrcInfo, bs, self->pAacDecoderStaticChannelInfo,
3169 pce->ElementInstanceTag, drcChMap, aacChannels);
3170 if (mapped > 0) {
3171 /* If at least one DRC thread has been mapped to a channel threre was DRC
3172 * data in the bitstream. */
3173 self->flags[streamIndex] |= AC_DRC_PRESENT;
3174 }
3175
3176 /* Create a reverse mapping table */
3177 UCHAR Reverse_chMapping[((8) * 2)];
3178 for (c = 0; c < aacChannels; c++) {
3179 int d;
3180 for (d = 0; d < aacChannels - 1; d++) {
3181 if (self->chMapping[d] == c) {
3182 break;
3183 }
3184 }
3185 Reverse_chMapping[c] = d;
3186 }
3187
3188 int el;
3189 int el_channels;
3190 c = 0;
3191 cIdx = 0;
3192 el_channels = 0;
3193 for (el = 0; el < element_count; el++) {
3194 int frameOk_butConceal =
3195 0; /* Force frame concealment during mute release active state. */
3196 int concealApplyReturnCode;
3197
3198 if (self->flags[streamIndex] & (AC_USAC | AC_RSV603DA | AC_BSAC)) {
3199 type = self->elements[el];
3200 } else {
3201 type = channel_elements[el];
3202 }
3203
3204 {
3205 int nElementChannels;
3206
3207 nElementChannels =
3208 CAacDecoder_GetELChannels(type, self->usacStereoConfigIndex[el]);
3209
3210 el_channels += nElementChannels;
3211
3212 if (nElementChannels == 0) {
3213 continue;
3214 }
3215 }
3216
3217 int offset;
3218 int elCh = 0;
3219 /* "c" iterates in canonical MPEG channel order */
3220 for (; cIdx < el_channels; c++, cIdx++, elCh++) {
3221 /* Robustness check */
3222 if (c >= aacChannels) {
3223 return AAC_DEC_UNKNOWN;
3224 }
3225
3226 CAacDecoderChannelInfo *pAacDecoderChannelInfo =
3227 self->pAacDecoderChannelInfo[c];
3228 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo =
3229 self->pAacDecoderStaticChannelInfo[c];
3230
3231 /* Setup offset for time buffer traversal. */
3232 {
3233 pAacDecoderStaticChannelInfo =
3234 self->pAacDecoderStaticChannelInfo[Reverse_chMapping[c]];
3235 offset =
3236 FDK_chMapDescr_getMapValue(
3237 &self->mapDescr, Reverse_chMapping[cIdx], self->chMapIndex) *
3238 timeDataChannelOffset;
3239 }
3240
3241 if (flags & AACDEC_FLUSH) {
3242 /* Clear pAacDecoderChannelInfo->pSpectralCoefficient because with
3243 * AACDEC_FLUSH set it contains undefined data. */
3244 FDKmemclear(pAacDecoderChannelInfo->pSpectralCoefficient,
3245 sizeof(FIXP_DBL) * self->streamInfo.aacSamplesPerFrame);
3246 }
3247
3248 /* if The ics info is not valid and it will be stored and used in the
3249 * following concealment method, mark the frame as erroneous */
3250 {
3251 CIcsInfo *pIcsInfo = &pAacDecoderChannelInfo->icsInfo;
3252 CConcealmentInfo *hConcealmentInfo =
3253 &pAacDecoderStaticChannelInfo->concealmentInfo;
3254 const int mute_release_active =
3255 (self->frameOK && !(flags & AACDEC_CONCEAL)) &&
3256 ((hConcealmentInfo->concealState >= ConcealState_Mute) &&
3257 (hConcealmentInfo->cntValidFrames + 1 <=
3258 hConcealmentInfo->pConcealParams->numMuteReleaseFrames));
3259 const int icsIsInvalid = (GetScaleFactorBandsTransmitted(pIcsInfo) >
3260 GetScaleFactorBandsTotal(pIcsInfo));
3261 const int icsInfoUsedinFadeOut =
3262 !(pAacDecoderChannelInfo->renderMode == AACDEC_RENDER_LPD &&
3263 pAacDecoderStaticChannelInfo->last_lpd_mode == 0);
3264 if (icsInfoUsedinFadeOut && icsIsInvalid && !mute_release_active) {
3265 self->frameOK = 0;
3266 }
3267 }
3268
3269 /*
3270 Conceal defective spectral data
3271 */
3272 {
3273 CAacDecoderChannelInfo **ppAacDecoderChannelInfo =
3274 &pAacDecoderChannelInfo;
3275 CAacDecoderStaticChannelInfo **ppAacDecoderStaticChannelInfo =
3276 &pAacDecoderStaticChannelInfo;
3277 {
3278 concealApplyReturnCode = CConcealment_Apply(
3279 &(*ppAacDecoderStaticChannelInfo)->concealmentInfo,
3280 *ppAacDecoderChannelInfo, *ppAacDecoderStaticChannelInfo,
3281 &self->samplingRateInfo[streamIndex],
3282 self->streamInfo.aacSamplesPerFrame,
3283 pAacDecoderStaticChannelInfo->last_lpd_mode,
3284 (self->frameOK && !(flags & AACDEC_CONCEAL)),
3285 self->flags[streamIndex]);
3286 }
3287 }
3288 if (concealApplyReturnCode == -1) {
3289 frameOk_butConceal = 1;
3290 }
3291
3292 if (flags & (AACDEC_INTR)) {
3293 /* Reset DRC control data for this channel */
3294 aacDecoder_drcInitChannelData(&pAacDecoderStaticChannelInfo->drcData);
3295 }
3296 if (flags & (AACDEC_CLRHIST)) {
3297 if (!(self->flags[0] & AC_USAC)) {
3298 /* Reset DRC control data for this channel */
3299 aacDecoder_drcInitChannelData(
3300 &pAacDecoderStaticChannelInfo->drcData);
3301 }
3302 }
3303 /* The DRC module demands to be called with the gain field holding the
3304 * gain scale. */
3305 self->extGain[0] = (FIXP_DBL)TDL_GAIN_SCALING;
3306 /* DRC processing */
3307 aacDecoder_drcApply(
3308 self->hDrcInfo, self->hSbrDecoder, pAacDecoderChannelInfo,
3309 &pAacDecoderStaticChannelInfo->drcData, self->extGain, c,
3310 self->streamInfo.aacSamplesPerFrame, self->sbrEnabled
3311
3312 );
3313
3314 if (timeDataSize < timeDataChannelOffset * self->aacChannels) {
3315 ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
3316 break;
3317 }
3318 if (self->flushStatus && (self->flushCnt > 0) &&
3319 !(flags & AACDEC_CONCEAL)) {
3320 FDKmemclear(pTimeData + offset,
3321 sizeof(FIXP_PCM) * self->streamInfo.aacSamplesPerFrame);
3322 } else
3323 switch (pAacDecoderChannelInfo->renderMode) {
3324 case AACDEC_RENDER_IMDCT:
3325
3326 CBlock_FrequencyToTime(
3327 pAacDecoderStaticChannelInfo, pAacDecoderChannelInfo,
3328 pTimeData + offset, self->streamInfo.aacSamplesPerFrame,
3329 (self->frameOK && !(flags & AACDEC_CONCEAL) &&
3330 !frameOk_butConceal),
3331 pAacDecoderChannelInfo->pComStaticData->pWorkBufferCore1
3332 ->mdctOutTemp,
3333 self->elFlags[el], elCh);
3334
3335 self->extGainDelay = self->streamInfo.aacSamplesPerFrame;
3336 break;
3337 case AACDEC_RENDER_ELDFB: {
3338 CBlock_FrequencyToTimeLowDelay(
3339 pAacDecoderStaticChannelInfo, pAacDecoderChannelInfo,
3340 pTimeData + offset, self->streamInfo.aacSamplesPerFrame);
3341 self->extGainDelay =
3342 (self->streamInfo.aacSamplesPerFrame * 2 -
3343 self->streamInfo.aacSamplesPerFrame / 2 - 1) /
3344 2;
3345 } break;
3346 case AACDEC_RENDER_LPD:
3347
3348 CLpd_RenderTimeSignal(
3349 pAacDecoderStaticChannelInfo, pAacDecoderChannelInfo,
3350 pTimeData + offset, self->streamInfo.aacSamplesPerFrame,
3351 &self->samplingRateInfo[streamIndex],
3352 (self->frameOK && !(flags & AACDEC_CONCEAL) &&
3353 !frameOk_butConceal),
3354 flags, self->flags[streamIndex]);
3355
3356 self->extGainDelay = self->streamInfo.aacSamplesPerFrame;
3357 break;
3358 default:
3359 ErrorStatus = AAC_DEC_UNKNOWN;
3360 break;
3361 }
3362 /* TimeDomainFading */
3363 if (!CConceal_TDFading_Applied[c]) {
3364 CConceal_TDFading_Applied[c] = CConcealment_TDFading(
3365 self->streamInfo.aacSamplesPerFrame,
3366 &self->pAacDecoderStaticChannelInfo[c], pTimeData + offset, 0);
3367 if (c + 1 < (8) && c < aacChannels - 1) {
3368 /* update next TDNoise Seed to avoid muting in case of Parametric
3369 * Stereo */
3370 self->pAacDecoderStaticChannelInfo[c + 1]
3371 ->concealmentInfo.TDNoiseSeed =
3372 self->pAacDecoderStaticChannelInfo[c]
3373 ->concealmentInfo.TDNoiseSeed;
3374 }
3375 }
3376 }
3377 }
3378
3379 if (self->flags[streamIndex] & AC_USAC) {
3380 int bsPseudoLr = 0;
3381 mpegSurroundDecoder_IsPseudoLR(
3382 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder, &bsPseudoLr);
3383 /* ISO/IEC 23003-3, 7.11.2.6 Modification of core decoder output (pseudo
3384 * LR) */
3385 if ((aacChannels == 2) && bsPseudoLr) {
3386 int i, offset2;
3387 const FIXP_SGL invSqrt2 = FL2FXCONST_SGL(0.707106781186547f);
3388 FIXP_PCM *pTD = pTimeData;
3389
3390 offset2 = timeDataChannelOffset;
3391
3392 for (i = 0; i < self->streamInfo.aacSamplesPerFrame; i++) {
3393 FIXP_DBL L = FX_PCM2FX_DBL(pTD[0]);
3394 FIXP_DBL R = FX_PCM2FX_DBL(pTD[offset2]);
3395 L = fMult(L, invSqrt2);
3396 R = fMult(R, invSqrt2);
3397 #if (SAMPLE_BITS == 16)
3398 pTD[0] = FX_DBL2FX_PCM(fAddSaturate(L + R, (FIXP_DBL)0x8000));
3399 pTD[offset2] = FX_DBL2FX_PCM(fAddSaturate(L - R, (FIXP_DBL)0x8000));
3400 #else
3401 pTD[0] = FX_DBL2FX_PCM(L + R);
3402 pTD[offset2] = FX_DBL2FX_PCM(L - R);
3403 #endif
3404 pTD++;
3405 }
3406 }
3407 }
3408
3409 /* Extract DRC control data and map it to channels (with bitstream delay) */
3410 mapped = aacDecoder_drcEpilog(
3411 self->hDrcInfo, bs, self->pAacDecoderStaticChannelInfo,
3412 pce->ElementInstanceTag, drcChMap, aacChannels);
3413 if (mapped > 0) {
3414 /* If at least one DRC thread has been mapped to a channel threre was DRC
3415 * data in the bitstream. */
3416 self->flags[streamIndex] |= AC_DRC_PRESENT;
3417 }
3418 }
3419
3420 /* Add additional concealment delay */
3421 self->streamInfo.outputDelay +=
3422 CConcealment_GetDelay(&self->concealCommonData) *
3423 self->streamInfo.aacSamplesPerFrame;
3424
3425 /* Map DRC data to StreamInfo structure */
3426 aacDecoder_drcGetInfo(self->hDrcInfo, &self->streamInfo.drcPresMode,
3427 &self->streamInfo.drcProgRefLev);
3428
3429 /* Reorder channel type information tables. */
3430 if (!(self->flags[0] & AC_RSV603DA)) {
3431 AUDIO_CHANNEL_TYPE types[(8)];
3432 UCHAR idx[(8)];
3433 int c;
3434 int mapValue;
3435
3436 FDK_ASSERT(sizeof(self->channelType) == sizeof(types));
3437 FDK_ASSERT(sizeof(self->channelIndices) == sizeof(idx));
3438
3439 FDKmemcpy(types, self->channelType, sizeof(types));
3440 FDKmemcpy(idx, self->channelIndices, sizeof(idx));
3441
3442 for (c = 0; c < aacChannels; c++) {
3443 mapValue =
3444 FDK_chMapDescr_getMapValue(&self->mapDescr, c, self->chMapIndex);
3445 self->channelType[mapValue] = types[c];
3446 self->channelIndices[mapValue] = idx[c];
3447 }
3448 }
3449
3450 self->blockNumber++;
3451
3452 return ErrorStatus;
3453 }
3454
3455 /*!
3456 \brief returns the streaminfo pointer
3457
3458 The function hands back a pointer to the streaminfo structure
3459
3460 \return pointer to the struct
3461 */
CAacDecoder_GetStreamInfo(HANDLE_AACDECODER self)3462 LINKSPEC_CPP CStreamInfo *CAacDecoder_GetStreamInfo(HANDLE_AACDECODER self) {
3463 if (!self) {
3464 return NULL;
3465 }
3466 return &self->streamInfo;
3467 }
3468