1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
5 Forschung e.V. All rights reserved.
6
7 1. INTRODUCTION
8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10 scheme for digital audio. This FDK AAC Codec software is intended to be used on
11 a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14 general perceptual audio codecs. AAC-ELD is considered the best-performing
15 full-bandwidth communications codec by independent studies and is widely
16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17 specifications.
18
19 Patent licenses for necessary patent claims for the FDK AAC Codec (including
20 those of Fraunhofer) may be obtained through Via Licensing
21 (www.vialicensing.com) or through the respective patent owners individually for
22 the purpose of encoding or decoding bit streams in products that are compliant
23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24 Android devices already license these patent claims through Via Licensing or
25 directly from the patent owners, and therefore FDK AAC Codec software may
26 already be covered under those patent licenses when it is used for those
27 licensed purposes only.
28
29 Commercially-licensed AAC software libraries, including floating-point versions
30 with enhanced sound quality, are also available from Fraunhofer. Users are
31 encouraged to check the Fraunhofer website for additional applications
32 information and documentation.
33
34 2. COPYRIGHT LICENSE
35
36 Redistribution and use in source and binary forms, with or without modification,
37 are permitted without payment of copyright license fees provided that you
38 satisfy the following conditions:
39
40 You must retain the complete text of this software license in redistributions of
41 the FDK AAC Codec or your modifications thereto in source code form.
42
43 You must retain the complete text of this software license in the documentation
44 and/or other materials provided with redistributions of the FDK AAC Codec or
45 your modifications thereto in binary form. You must make available free of
46 charge copies of the complete source code of the FDK AAC Codec and your
47 modifications thereto to recipients of copies in binary form.
48
49 The name of Fraunhofer may not be used to endorse or promote products derived
50 from this library without prior written permission.
51
52 You may not charge copyright license fees for anyone to use, copy or distribute
53 the FDK AAC Codec software or your modifications thereto.
54
55 Your modified versions of the FDK AAC Codec must carry prominent notices stating
56 that you changed the software and the date of any change. For modified versions
57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59 AAC Codec Library for Android."
60
61 3. NO PATENT LICENSE
62
63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65 Fraunhofer provides no warranty of patent non-infringement with respect to this
66 software.
67
68 You may use this FDK AAC Codec software or modifications thereto only for
69 purposes that are authorized by appropriate patent licenses.
70
71 4. DISCLAIMER
72
73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75 including but not limited to the implied warranties of merchantability and
76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78 or consequential damages, including but not limited to procurement of substitute
79 goods or services; loss of use, data, or profits, or business interruption,
80 however caused and on any theory of liability, whether in contract, strict
81 liability, or tort (including negligence), arising in any way out of the use of
82 this software, even if advised of the possibility of such damage.
83
84 5. CONTACT INFORMATION
85
86 Fraunhofer Institute for Integrated Circuits IIS
87 Attention: Audio and Multimedia Departments - FDK AAC LL
88 Am Wolfsmantel 33
89 91058 Erlangen, Germany
90
91 www.iis.fraunhofer.de/amm
92 amm-info@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /*********************** MPEG surround decoder library *************************
96
97 Author(s):
98
99 Description: SAC Decoder Library Interface
100
101 *******************************************************************************/
102
103 #include "sac_dec_lib.h"
104 #include "sac_dec_interface.h"
105 #include "sac_dec.h"
106 #include "sac_bitdec.h"
107 #include "FDK_matrixCalloc.h"
108
109 #define MPS_DATA_BUFFER_SIZE (2048)
110
111 /**
112 * \brief MPEG Surround data indication.
113 **/
114 typedef enum {
115 MPEGS_ANCTYPE_FRAME = 0, /*!< MPEG Surround frame, see ISO/IEC 23003-1 */
116 MPEGS_ANCTYPE_HEADER_AND_FRAME = 1, /*!< MPEG Surround header and MPEG
117 Surround frame, see ISO/IEC 23003-1 */
118 MPEGS_ANCTYPE_RESERVED_1 = 2, /*!< reserved, see ISO/IEC 23003-1 */
119 MPEGS_ANCTYPE_RESERVED_2 = 3 /*!< reserved, see ISO/IEC 23003-1*/
120 } MPEGS_ANCTYPE;
121
122 /**
123 * \brief MPEG Surround data segment indication.
124 **/
125 typedef enum {
126 MPEGS_CONTINUE = 0, /*!< Indicates if data segment continues a data block. */
127 MPEGS_STOP = 1, /*!< Indicates if data segment ends a data block. */
128 MPEGS_START = 2, /*!< Indicates if data segment begins a data block. */
129 MPEGS_START_STOP =
130 3 /*!< Indicates if data segment begins and ends a data block. */
131 } MPEGS_ANCSTARTSTOP;
132
133 /**
134 * \brief MPEG Surround synchronizaiton state.
135 *
136 * CAUTION: Changing the enumeration values can break the sync mechanism
137 *because it is based on comparing the state values.
138 **/
139 typedef enum {
140 MPEGS_SYNC_LOST =
141 0, /*!< Indicates lost sync because of current discontinuity. */
142 MPEGS_SYNC_FOUND = 1, /*!< Parsed a valid header and (re)intialization was
143 successfully completed. */
144 MPEGS_SYNC_COMPLETE = 2 /*!< In sync and continuous. Found an independent
145 frame in addition to MPEGS_SYNC_FOUND.
146 Precondition: MPEGS_SYNC_FOUND. */
147 } MPEGS_SYNCSTATE;
148
149 /**
150 * \brief MPEG Surround operation mode.
151 **/
152 typedef enum {
153 MPEGS_OPMODE_EMM = 0, /*!< Mode: Enhanced Matrix Mode (Blind) */
154 MPEGS_OPMODE_MPS_PAYLOAD = 1, /*!< Mode: Normal, Stereo or Binaural */
155 MPEGS_OPMODE_NO_MPS_PAYLOAD = 2 /*!< Mode: no MPEG Surround payload */
156 } MPEGS_OPMODE;
157
158 /**
159 * \brief MPEG Surround init flags.
160 **/
161 typedef enum {
162 MPEGS_INIT_OK = 0x00000000, /*!< indicate correct initialization */
163 MPEGS_INIT_ENFORCE_REINIT =
164 0x00000001, /*!< indicate complete initialization */
165
166 MPEGS_INIT_CHANGE_OUTPUT_MODE =
167 0x00000010, /*!< indicate change of the output mode */
168 MPEGS_INIT_CHANGE_PARTIALLY_COMPLEX =
169 0x00000020, /*!< indicate change of low power/high quality */
170 MPEGS_INIT_CHANGE_TIME_FREQ_INTERFACE =
171 0x00000040, /*!< indicate change of qmf/time interface */
172 MPEGS_INIT_CHANGE_HEADER = 0x00000080, /*!< indicate change of header */
173
174 MPEGS_INIT_ERROR_PAYLOAD =
175 0x00000100, /*!< indicate payload/ancType/ancStartStop error */
176
177 MPEGS_INIT_BS_INTERRUPTION =
178 0x00001000, /*!< indicate bitstream interruption */
179 MPEGS_INIT_CLEAR_HISTORY =
180 0x00002000, /*!< indicate that all states shall be cleared */
181
182 /* Re-initialization of submodules */
183
184 MPEGS_INIT_CHANGE_CONCEAL_PARAMS = 0x00100000, /*!< indicate a change of at
185 least one error concealment
186 param */
187
188 /* No re-initialization needed, currently not used */
189 MPEGS_INIT_CHANGE_BYPASS_MODE =
190 0x01000000, /*!< indicate change of bypass mode */
191
192 /* Re-initialization needed, currently not used */
193 MPEGS_INIT_ERROR_ANC_TYPE = 0x10000000, /*!< indicate ancType error*/
194 MPEGS_INIT_ERROR_ANC_STARTSTOP =
195 0x20000000 /*!< indicate ancStartStop error */
196 } MPEGS_INIT_FLAGS;
197
198 struct MpegSurroundDecoder {
199 HANDLE_FDK_QMF_DOMAIN pQmfDomain;
200 UCHAR mpsData[MPS_DATA_BUFFER_SIZE]; /* Buffer for MPS payload accross more
201 than one segment */
202 INT mpsDataBits; /* Amount of bits in mpsData */
203 /* MPEG Surround decoder */
204 SPATIAL_SPECIFIC_CONFIG spatialSpecificConfig[1]; /* SSC delay line which is
205 used during decoding */
206 spatialDec *pSpatialDec;
207 SPATIAL_SPECIFIC_CONFIG
208 spatialSpecificConfigBackup; /* SSC used while parsing */
209
210 /* Creation parameter */
211 UCHAR mpegSurroundDecoderLevel;
212 /* Run-time parameter */
213 UCHAR mpegSurroundSscIsGlobalCfg; /* Flag telling that the SSC
214 (::spatialSpecificConfig) is a
215 out-of-band configuration. */
216 UCHAR mpegSurroundUseTimeInterface;
217
218 SPATIAL_BS_FRAME
219 bsFrames[1]; /* Bitstream Structs that contain data read from the
220 SpatialFrame() bitstream element */
221 BS_LL_STATE llState; /* Bit stream parser state memory */
222 UCHAR bsFrameParse; /* Current parse frame context index */
223 UCHAR bsFrameDecode; /* Current decode/apply frame context index */
224 UCHAR bsFrameDelay; /* Amount of frames delay between parsing and processing.
225 Required i.e. for interpolation error concealment. */
226
227 /* User prameters */
228 SPATIALDEC_PARAM mpegSurroundUserParams;
229
230 /* Internal flags */
231 SPATIAL_DEC_UPMIX_TYPE upmixType;
232 int initFlags[1];
233 MPEGS_ANCSTARTSTOP ancStartStopPrev;
234 MPEGS_SYNCSTATE fOnSync[1];
235
236 /* Inital decoder configuration */
237 SPATIAL_DEC_CONFIG decConfig;
238 };
239
240 static SACDEC_ERROR sscParseCheck(const SPATIAL_SPECIFIC_CONFIG *pSsc);
241
242 /**
243 * \brief Get the number of QMF bands from the sampling frequency (in Hz)
244 **/
mpegSurroundDecoder_GetNrOfQmfBands(const SPATIAL_SPECIFIC_CONFIG * pSsc,UINT sampleRate)245 static int mpegSurroundDecoder_GetNrOfQmfBands(
246 const SPATIAL_SPECIFIC_CONFIG *pSsc, UINT sampleRate) {
247 UINT samplingFrequency = sampleRate;
248 int qmfBands = 64;
249
250 if (pSsc != NULL) {
251 switch (pSsc->coreCodec) {
252 case AOT_USAC:
253 if ((pSsc->stereoConfigIndex == 3)) {
254 static const UCHAR mapIdx2QmfBands[3] = {24, 32, 16};
255 FDK_ASSERT((pSsc->coreSbrFrameLengthIndex >= 2) &&
256 (pSsc->coreSbrFrameLengthIndex <= 4));
257 qmfBands = mapIdx2QmfBands[pSsc->coreSbrFrameLengthIndex - 2];
258 }
259 return qmfBands;
260 default:
261 samplingFrequency = pSsc->samplingFreq;
262 break;
263 }
264 }
265
266 /* number of QMF bands depend on sampling frequency, see FDIS 23003-1:2006
267 * Chapter 6.3.3 */
268 if (samplingFrequency < 27713) {
269 qmfBands = 32;
270 }
271 if (samplingFrequency > 55426) {
272 qmfBands = 128;
273 }
274
275 return qmfBands;
276 }
277
278 /**
279 * \brief Analyse init flags
280 **/
mpegSurroundDecoder_CalcInitFlags(SPATIAL_SPECIFIC_CONFIG * pSsc1,SPATIAL_SPECIFIC_CONFIG * pSsc2,int upmixTypeFlag,int binauralQualityFlag,int partiallyComplexFlag,int * ctrlFlags)281 static int mpegSurroundDecoder_CalcInitFlags(SPATIAL_SPECIFIC_CONFIG *pSsc1,
282 SPATIAL_SPECIFIC_CONFIG *pSsc2,
283 int upmixTypeFlag,
284 int binauralQualityFlag,
285 int partiallyComplexFlag,
286 int *ctrlFlags) {
287 /* Analyse core coder */
288 if (pSsc1->coreCodec != pSsc2->coreCodec) {
289 *ctrlFlags |= MASK_MPEGS_INIT_ALL_STATES;
290 *ctrlFlags |= MASK_MPEGS_INIT_ALL_PARAMS;
291 } else {
292 /* Analyse elements for initialization of space analysis qmf filterbank */
293 if ((partiallyComplexFlag) || (pSsc1->treeConfig != pSsc2->treeConfig) ||
294 (pSsc1->samplingFreq != pSsc2->samplingFreq)) {
295 *ctrlFlags |= MPEGS_INIT_STATES_ANA_QMF_FILTER;
296 *ctrlFlags |= MPEGS_INIT_STATES_ANA_HYB_FILTER;
297 }
298
299 /* Analyse elements for initialization of space synthesis qmf filterbank */
300 if ((upmixTypeFlag) || (partiallyComplexFlag) ||
301 (pSsc1->treeConfig != pSsc2->treeConfig) ||
302 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
303 (pSsc1->bsFixedGainDMX != pSsc2->bsFixedGainDMX)) {
304 *ctrlFlags |= MPEGS_INIT_STATES_SYN_QMF_FILTER;
305 }
306
307 /* Analyse elements for initialization of decorrelator */
308 if ((upmixTypeFlag) || (partiallyComplexFlag) ||
309 (pSsc1->treeConfig != pSsc2->treeConfig) ||
310 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
311 (pSsc1->decorrConfig != pSsc2->decorrConfig)) {
312 *ctrlFlags |= MPEGS_INIT_STATES_DECORRELATOR;
313 }
314
315 /* Analyse elements for initialization of m1 and m2 calculation */
316 if ((upmixTypeFlag) || (binauralQualityFlag) ||
317 (pSsc1->treeConfig != pSsc2->treeConfig) ||
318 (pSsc1->samplingFreq != pSsc2->samplingFreq))
319
320 {
321 *ctrlFlags |= MPEGS_INIT_STATES_M1M2;
322 }
323
324 /* Analyse elements for initialization of GES */
325 if ((upmixTypeFlag) || (pSsc1->treeConfig != pSsc2->treeConfig) ||
326 (pSsc1->tempShapeConfig != pSsc2->tempShapeConfig)) {
327 *ctrlFlags |= MPEGS_INIT_STATES_GES;
328 }
329
330 /* Analyse elements for initialization of FDreverb */
331 if ((upmixTypeFlag) || (binauralQualityFlag) || (partiallyComplexFlag) ||
332 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
333 (pSsc1->nTimeSlots != pSsc2->nTimeSlots)) {
334 *ctrlFlags |= MPEGS_INIT_STATES_REVERB;
335 }
336
337 /* Reset previous frame data whenever the config changes */
338 if (*ctrlFlags & MPEGS_INIT_CONFIG) {
339 *ctrlFlags |= MPEGS_INIT_STATES_PARAM;
340 }
341 }
342
343 return MPS_OK;
344 }
345
346 /**
347 * \brief Reset MPEG Surround status info
348 **/
updateMpegSurroundDecoderStatus(CMpegSurroundDecoder * pMpegSurroundDecoder,int initFlags,MPEGS_SYNCSTATE fOnSync,MPEGS_ANCSTARTSTOP ancStartStopPrev)349 static void updateMpegSurroundDecoderStatus(
350 CMpegSurroundDecoder *pMpegSurroundDecoder, int initFlags,
351 MPEGS_SYNCSTATE fOnSync, MPEGS_ANCSTARTSTOP ancStartStopPrev) {
352 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
353 initFlags;
354 if ((pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg != 0) &&
355 (pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] >=
356 MPEGS_SYNC_FOUND) &&
357 (fOnSync < MPEGS_SYNC_FOUND)) {
358 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
359 MPEGS_SYNC_FOUND;
360 } else {
361 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
362 fOnSync;
363 }
364 pMpegSurroundDecoder->ancStartStopPrev = ancStartStopPrev;
365 }
366
367 static SACDEC_ERROR mpegSurroundDecoder_Create(
368 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
369 HANDLE_FDK_QMF_DOMAIN pQmfDomain);
370
371 SAC_INSTANCE_AVAIL
mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(CMpegSurroundDecoder * pMpegSurroundDecoder)372 mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(
373 CMpegSurroundDecoder *pMpegSurroundDecoder) {
374 SAC_INSTANCE_AVAIL instanceAvailable = SAC_INSTANCE_NOT_FULL_AVAILABLE;
375
376 if (pMpegSurroundDecoder->pSpatialDec != NULL) {
377 instanceAvailable = SAC_INSTANCE_FULL_AVAILABLE;
378 }
379
380 return instanceAvailable;
381 }
382
mpegSurroundDecoder_Open(CMpegSurroundDecoder ** pMpegSurroundDecoder,int stereoConfigIndex,HANDLE_FDK_QMF_DOMAIN pQmfDomain)383 SACDEC_ERROR mpegSurroundDecoder_Open(
384 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
385 HANDLE_FDK_QMF_DOMAIN pQmfDomain) {
386 SACDEC_ERROR error;
387
388 error = mpegSurroundDecoder_Create(pMpegSurroundDecoder, stereoConfigIndex,
389 pQmfDomain);
390
391 return error;
392 }
393
394 /**
395 * \brief Renamed function from getUpmixType to check_UParam_Build_DecConfig.
396 * This function checks if user params, decoder config and SSC are valid
397 * and if the decoder build can handle all this settings.
398 * The upmix type may be modified by this function.
399 * It is called in initMpegSurroundDecoder() after the ssc parse check,
400 * to have all checks in one place and to ensure these checks are always
401 * performed if config changes (inband and out-of-band).
402 *
403 * \param pUserParams User data handle.
404 * \param pDecConfig decoder config handle.
405 * \param pSsc spatial specific config handle.
406 * \param pUpmixType upmix type which is set by this function
407 *
408 * \return MPS_OK on sucess, and else on failure.
409 */
check_UParam_Build_DecConfig(SPATIALDEC_PARAM const * pUserParams,SPATIAL_DEC_CONFIG const * pDecConfig,const SPATIAL_SPECIFIC_CONFIG * pSsc,SPATIAL_DEC_UPMIX_TYPE * pUpmixType)410 static SACDEC_ERROR check_UParam_Build_DecConfig(
411 SPATIALDEC_PARAM const *pUserParams, SPATIAL_DEC_CONFIG const *pDecConfig,
412 const SPATIAL_SPECIFIC_CONFIG *pSsc, SPATIAL_DEC_UPMIX_TYPE *pUpmixType) {
413 int dmxChannels, outChannels, maxNumOutChannels;
414
415 FDK_ASSERT(pUserParams != NULL);
416 FDK_ASSERT(pUpmixType != NULL);
417
418 /* checks if implementation can handle the Ssc */
419
420 switch (pSsc->treeConfig) {
421 case SPATIALDEC_MODE_RSVD7: /* 212 */
422 dmxChannels = 1;
423 outChannels = 2;
424 break;
425 default:
426 return MPS_UNSUPPORTED_CONFIG;
427 }
428
429 /* ------------------------------------------- */
430
431 /* Analyse pDecConfig params */
432 switch (pDecConfig->binauralMode) {
433 case BINAURAL_NONE:
434 break;
435 default:
436 return MPS_UNSUPPORTED_CONFIG;
437 }
438
439 switch (pDecConfig->decoderMode) {
440 case EXT_HQ_ONLY:
441 break;
442 default:
443 return MPS_UNSUPPORTED_CONFIG;
444 }
445
446 switch (pDecConfig->maxNumOutputChannels) {
447 case OUTPUT_CHANNELS_DEFAULT:
448 /* No special restrictions -> Get the level restriction: */
449 switch (pDecConfig->decoderLevel) {
450 case DECODER_LEVEL_0:
451 maxNumOutChannels = 2;
452 break;
453 default:
454 return MPS_UNSUPPORTED_CONFIG;
455 }
456 break;
457 case OUTPUT_CHANNELS_2_0:
458 maxNumOutChannels = 2;
459 break;
460 default:
461 return MPS_UNSUPPORTED_CONFIG;
462 }
463 /* ------------------------- */
464
465 /* check if we can handle user params */
466 if (pUserParams->blindEnable == 1) {
467 return MPS_UNSUPPORTED_CONFIG;
468 }
469 {
470 switch ((SAC_DEC_OUTPUT_MODE)pUserParams->outputMode) {
471 case SACDEC_OUT_MODE_NORMAL:
472 if (maxNumOutChannels >= outChannels) {
473 *pUpmixType = UPMIX_TYPE_NORMAL;
474 } else {
475 { *pUpmixType = UPMIX_TYPE_BYPASS; }
476 }
477 break;
478 case SACDEC_OUT_MODE_STEREO:
479 if (dmxChannels == 1) {
480 if (outChannels == 2) {
481 *pUpmixType = UPMIX_TYPE_NORMAL;
482 }
483 } else {
484 *pUpmixType = UPMIX_TYPE_BYPASS;
485 }
486 break;
487 case SACDEC_OUT_MODE_6CHANNEL:
488 if (outChannels > 6) {
489 { *pUpmixType = UPMIX_TYPE_BYPASS; }
490 } else {
491 *pUpmixType = UPMIX_TYPE_NORMAL;
492 }
493 break;
494 default:
495 return MPS_UNSUPPORTED_CONFIG;
496 }
497 }
498
499 return MPS_OK;
500 }
501
502 /**
503 * \brief Init MPEG Surround decoder.
504 **/
initMpegSurroundDecoder(CMpegSurroundDecoder * pMpegSurroundDecoder)505 static SACDEC_ERROR initMpegSurroundDecoder(
506 CMpegSurroundDecoder *pMpegSurroundDecoder) {
507 SACDEC_ERROR err;
508 int initFlags = MPEGS_INIT_NONE, initFlagsDec;
509 int upmixTypeCurr = pMpegSurroundDecoder->upmixType;
510
511 FDK_ASSERT(pMpegSurroundDecoder != NULL);
512
513 SPATIAL_SPECIFIC_CONFIG *const pSSCinput =
514 &pMpegSurroundDecoder->spatialSpecificConfigBackup;
515 SPATIAL_SPECIFIC_CONFIG *const pSSCtarget =
516 &pMpegSurroundDecoder
517 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
518 initFlagsDec =
519 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode];
520
521 if (pSSCinput->coreCodec != AOT_USAC) {
522 /* here we check if we have a valid Ssc */
523 err = sscParseCheck(pSSCinput);
524 if (err != MPS_OK) goto bail;
525 }
526
527 /* here we check if Ssc matches build; also check UParams and DecConfig */
528 /* if desired upmixType is changes */
529 err = check_UParam_Build_DecConfig(
530 &pMpegSurroundDecoder->mpegSurroundUserParams,
531 &pMpegSurroundDecoder->decConfig, pSSCinput,
532 &pMpegSurroundDecoder->upmixType);
533 if (err != MPS_OK) goto bail;
534
535 /* init config */
536 if (initFlagsDec & MPEGS_INIT_CHANGE_HEADER) {
537 initFlags |= MPEGS_INIT_CONFIG;
538 }
539 /* init all states */
540 if (initFlagsDec & MPEGS_INIT_CLEAR_HISTORY) {
541 initFlags |= MASK_MPEGS_INIT_ALL_STATES;
542 }
543 if (initFlagsDec & MPEGS_INIT_CHANGE_CONCEAL_PARAMS) {
544 initFlags |= MPEGS_INIT_PARAMS_ERROR_CONCEALMENT;
545 }
546
547 if (initFlagsDec & MPEGS_INIT_ENFORCE_REINIT) {
548 /* init all states */
549 initFlags |= MASK_MPEGS_INIT_ALL_STATES;
550 initFlags |= MASK_MPEGS_INIT_ALL_PARAMS;
551 } else {
552 /* analyse states which have to be initialized */
553 mpegSurroundDecoder_CalcInitFlags(
554 pSSCtarget, pSSCinput,
555 (upmixTypeCurr !=
556 pMpegSurroundDecoder->upmixType), /* upmixType changed */
557 0, (initFlagsDec & MPEGS_INIT_CHANGE_PARTIALLY_COMPLEX) ? 1 : 0,
558 &initFlags);
559 }
560
561 {
562 int nrOfQmfBands;
563 FDKmemcpy(pSSCtarget, pSSCinput, sizeof(SPATIAL_SPECIFIC_CONFIG));
564
565 nrOfQmfBands = mpegSurroundDecoder_GetNrOfQmfBands(
566 pSSCtarget, pSSCtarget->samplingFreq);
567 err = FDK_SpatialDecInit(
568 pMpegSurroundDecoder->pSpatialDec,
569 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode],
570 pSSCtarget, nrOfQmfBands, pMpegSurroundDecoder->upmixType,
571 &pMpegSurroundDecoder->mpegSurroundUserParams, initFlags);
572
573 if (err != MPS_OK) goto bail;
574
575 /* Signal that we got a header and can go on decoding */
576 if (err == MPS_OK) {
577 initFlagsDec = MPEGS_INIT_OK;
578 {
579 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
580 MPEGS_SYNC_FOUND;
581 }
582 }
583 }
584
585 bail:
586 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] =
587 initFlagsDec;
588 return err;
589 }
590
591 /**
592 * \brief Init MPEG Surround decoder.
593 **/
mpegSurroundDecoder_Init(CMpegSurroundDecoder * pMpegSurroundDecoder)594 SACDEC_ERROR mpegSurroundDecoder_Init(
595 CMpegSurroundDecoder *pMpegSurroundDecoder) {
596 SACDEC_ERROR err = MPS_OK;
597
598 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
599 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
600 }
601 return err;
602 }
603
604 /**
605 * \brief Open MPEG Surround decoder.
606 **/
mpegSurroundDecoder_Create(CMpegSurroundDecoder ** pMpegSurroundDecoder,int stereoConfigIndex,HANDLE_FDK_QMF_DOMAIN pQmfDomain)607 static SACDEC_ERROR mpegSurroundDecoder_Create(
608 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
609 HANDLE_FDK_QMF_DOMAIN pQmfDomain) {
610 SACDEC_ERROR err = MPS_OK;
611 CMpegSurroundDecoder *sacDec = NULL;
612 spatialDec *self = NULL;
613
614 /* decoderLevel decoderMode maxNumOutputChannels binauralMode */
615 static const SPATIAL_DEC_CONFIG decConfig = {
616 (CFG_LEVEL)(0), EXT_HQ_ONLY, OUTPUT_CHANNELS_DEFAULT, BINAURAL_NONE};
617
618 if (*pMpegSurroundDecoder == NULL) {
619 FDK_ALLOCATE_MEMORY_1D(*pMpegSurroundDecoder, 1, CMpegSurroundDecoder)
620
621 for (int i = 0; i < 1; i++) {
622 err = SpatialDecCreateBsFrame(&(*pMpegSurroundDecoder)->bsFrames[i],
623 &(*pMpegSurroundDecoder)->llState);
624 if (err != MPS_OK) {
625 sacDec = *pMpegSurroundDecoder;
626 goto bail;
627 }
628 }
629 (*pMpegSurroundDecoder)->pQmfDomain = pQmfDomain;
630
631 (*pMpegSurroundDecoder)->bsFrameDelay = 1;
632 (*pMpegSurroundDecoder)->bsFrameParse = 0;
633 (*pMpegSurroundDecoder)->bsFrameDecode = 0;
634
635 return err;
636 } else {
637 sacDec = *pMpegSurroundDecoder;
638 }
639
640 if (sacDec->pSpatialDec == NULL) {
641 if ((self = FDK_SpatialDecOpen(&decConfig, stereoConfigIndex)) == NULL) {
642 err = MPS_OUTOFMEMORY;
643 goto bail;
644 }
645 } else {
646 self = sacDec->pSpatialDec;
647 }
648
649 self->pQmfDomain = sacDec->pQmfDomain;
650
651 sacDec->pSpatialDec = self;
652
653 /* default parameter set */
654 sacDec->mpegSurroundUserParams.outputMode = SACDEC_OUT_MODE_NORMAL;
655 sacDec->mpegSurroundUserParams.blindEnable = 0;
656 sacDec->mpegSurroundUserParams.bypassMode = 0;
657 sacDec->mpegSurroundUserParams.concealMethod = 1;
658 sacDec->mpegSurroundUserParams.concealNumKeepFrames = 10;
659 sacDec->mpegSurroundUserParams.concealFadeOutSlopeLength = 5;
660 sacDec->mpegSurroundUserParams.concealFadeInSlopeLength = 5;
661 sacDec->mpegSurroundUserParams.concealNumReleaseFrames = 3;
662 sacDec->mpegSurroundSscIsGlobalCfg = 0;
663 sacDec->mpegSurroundUseTimeInterface = 1;
664 sacDec->mpegSurroundDecoderLevel = decConfig.decoderLevel;
665
666 sacDec->upmixType = UPMIX_TYPE_NORMAL;
667
668 /* signalize spatial decoder re-initalization */
669 updateMpegSurroundDecoderStatus(sacDec, MPEGS_INIT_ENFORCE_REINIT,
670 MPEGS_SYNC_LOST, MPEGS_STOP);
671
672 /* return decoder instance */
673 *pMpegSurroundDecoder = sacDec;
674 sacDec->decConfig = decConfig;
675
676 SpatialDecInitParserContext(sacDec->pSpatialDec);
677
678 return err;
679
680 bail:
681 if (sacDec != NULL) {
682 mpegSurroundDecoder_Close(sacDec);
683 }
684 *pMpegSurroundDecoder = NULL;
685 if (err == MPS_OK) {
686 return MPS_OUTOFMEMORY;
687 } else {
688 return err;
689 }
690 }
691
692 /**
693 * \brief Config MPEG Surround decoder.
694 **/
mpegSurroundDecoder_Config(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,AUDIO_OBJECT_TYPE coreCodec,INT samplingRate,INT stereoConfigIndex,INT coreSbrFrameLengthIndex,INT configBytes,const UCHAR configMode,UCHAR * configChanged)695 SACDEC_ERROR mpegSurroundDecoder_Config(
696 CMpegSurroundDecoder *pMpegSurroundDecoder, HANDLE_FDK_BITSTREAM hBs,
697 AUDIO_OBJECT_TYPE coreCodec, INT samplingRate, INT stereoConfigIndex,
698 INT coreSbrFrameLengthIndex, INT configBytes, const UCHAR configMode,
699 UCHAR *configChanged) {
700 SACDEC_ERROR err = MPS_OK;
701 SPATIAL_SPECIFIC_CONFIG spatialSpecificConfig;
702
703 switch (coreCodec) {
704 case AOT_DRM_USAC:
705 case AOT_USAC:
706 if (configMode == AC_CM_DET_CFG_CHANGE) {
707 /* In config detection mode write spatial specific config parameters
708 * into temporarily allocated structure */
709 err = SpatialDecParseMps212Config(
710 hBs, &spatialSpecificConfig, samplingRate, coreCodec,
711 stereoConfigIndex, coreSbrFrameLengthIndex);
712 } else {
713 err = SpatialDecParseMps212Config(
714 hBs, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
715 samplingRate, coreCodec, stereoConfigIndex,
716 coreSbrFrameLengthIndex);
717 }
718 break;
719 case AOT_ER_AAC_ELD:
720 case AOT_ER_AAC_LD:
721 if (configMode == AC_CM_DET_CFG_CHANGE) {
722 /* In config detection mode write spatial specific config parameters
723 * into temporarily allocated structure */
724 err = SpatialDecParseSpecificConfig(hBs, &spatialSpecificConfig,
725 configBytes, coreCodec);
726 } else {
727 err = SpatialDecParseSpecificConfig(
728 hBs, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
729 configBytes, coreCodec);
730 }
731 break;
732 default:
733 err = MPS_UNSUPPORTED_FORMAT;
734 break;
735 }
736
737 if (err != MPS_OK) {
738 goto bail;
739 }
740
741 if (configMode & AC_CM_DET_CFG_CHANGE) {
742 return err;
743 }
744
745 if (configMode & AC_CM_ALLOC_MEM) {
746 if (*configChanged) {
747 if ((err = mpegSurroundDecoder_Open(&pMpegSurroundDecoder,
748 stereoConfigIndex, NULL))) {
749 return err;
750 }
751 }
752 }
753
754 {
755 SPATIAL_SPECIFIC_CONFIG *sscParse =
756 &pMpegSurroundDecoder
757 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
758
759 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
760 &pMpegSurroundDecoder->spatialSpecificConfigBackup, sscParse)) {
761 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameParse] |=
762 MPEGS_INIT_CHANGE_HEADER;
763 /* Error resilience code */
764 if (pMpegSurroundDecoder->pSpatialDec == NULL) {
765 err = MPS_NOTOK;
766 goto bail;
767 }
768 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
769 pMpegSurroundDecoder->pSpatialDec->pConfigCurrent =
770 &pMpegSurroundDecoder
771 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
772 }
773 }
774
775 if (err == MPS_OK) {
776 /* We got a valid out-of-band configuration so label it accordingly. */
777 pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg = 1;
778 }
779
780 bail:
781 return err;
782 }
783
784 /**
785 * \brief Determine MPEG Surround operation mode.
786 **/
mpegSurroundOperationMode(CMpegSurroundDecoder * pMpegSurroundDecoder,int mpsDataBits)787 static MPEGS_OPMODE mpegSurroundOperationMode(
788 CMpegSurroundDecoder *pMpegSurroundDecoder, int mpsDataBits) {
789 MPEGS_OPMODE mode;
790
791 {
792 if ((mpsDataBits > 0) &&
793 (pMpegSurroundDecoder->mpegSurroundUserParams.blindEnable == 0)) {
794 mode = MPEGS_OPMODE_MPS_PAYLOAD; /* Mode: Normal, Stereo or Binaural */
795 } else {
796 mode = MPEGS_OPMODE_NO_MPS_PAYLOAD; /* Mode: No MPEG Surround Payload */
797 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
798 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
799 MPEGS_STOP);
800 }
801 }
802
803 return (mode);
804 }
805
806 /**
807 * \brief Check ssc for parse errors.
808 * This one is called in initMpegSurroundDecoder()
809 * to ensure checking of inband and out-of-band mps configs.
810 * Only parse errors checked here! Check for valid config is done
811 * in check_UParam_Build_DecConfig()!
812 *
813 * \param pSsc spatial specific config handle.
814 *
815 * \return MPS_OK on sucess, and else on parse error.
816 */
sscParseCheck(const SPATIAL_SPECIFIC_CONFIG * pSsc)817 static SACDEC_ERROR sscParseCheck(const SPATIAL_SPECIFIC_CONFIG *pSsc) {
818 SACDEC_ERROR err = MPS_OK;
819
820 if (pSsc->samplingFreq > 96000) return MPS_PARSE_ERROR;
821 if (pSsc->samplingFreq < 8000) return MPS_PARSE_ERROR;
822
823 switch (pSsc->freqRes) {
824 case SPATIALDEC_FREQ_RES_28:
825 case SPATIALDEC_FREQ_RES_20:
826 case SPATIALDEC_FREQ_RES_14:
827 case SPATIALDEC_FREQ_RES_10:
828 case SPATIALDEC_FREQ_RES_23:
829 case SPATIALDEC_FREQ_RES_15:
830 case SPATIALDEC_FREQ_RES_12:
831 case SPATIALDEC_FREQ_RES_9:
832 case SPATIALDEC_FREQ_RES_7:
833 case SPATIALDEC_FREQ_RES_5:
834 case SPATIALDEC_FREQ_RES_4:
835 break;
836 case SPATIALDEC_FREQ_RES_40: /* 40 doesn't exist in ISO/IEC 23003-1 */
837 default:
838 return MPS_PARSE_ERROR;
839 }
840
841 if ((pSsc->treeConfig < 0) || (pSsc->treeConfig > 7)) {
842 return MPS_PARSE_ERROR;
843 }
844
845 if ((pSsc->quantMode < 0) || (pSsc->quantMode > 2)) {
846 return MPS_PARSE_ERROR;
847 }
848
849 if (pSsc->tempShapeConfig == 3) {
850 return MPS_PARSE_ERROR;
851 }
852
853 if (pSsc->decorrConfig == 3) {
854 return MPS_PARSE_ERROR;
855 }
856
857 /* now we are sure there were no parsing errors */
858
859 return err;
860 }
861
862 /**
863 * \brief Check number of time slots
864 *
865 * Basically the mps frame length must be a multiple of the core coder frame
866 * length. The below table shows all valid configurations in detail. See ISO/IEC
867 * 23003-1: "Table 4A - Allowed values for bsFrameLength in the Baseline MPEG
868 * Surround Profile"
869 *
870 * Downmix Coder Downmix Code Allowed values for bsFrameLength
871 * Allowed frame sizes for normal, downsampled and upsampled MPS Framelength
872 * (QMF Samples)
873 *
874 * AAC 1024 16 15, 31, 47, 63 1024 2048 3072 4096
875 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
876 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
877 * 5120 6144 7168 8192 9216
878 *
879 * AAC 960 15 14, 29, 44, 59 960 1920 2880 3840
880 * downsampled MPS 30 29, 59 960 1920 upsampled MPS
881 * 7,5 14, 29, 44, 59 1920 3840 5760 7680
882 *
883 * HE-AAC 1024/2048 32 31, 63 2048 4096 downsampled MPS
884 * 64 63 2048 upsampled MPS
885 * 16 15, 31, 47, 63 2048 4096 6144 8192
886 *
887 * HE-AAC 960/1920 30 29, 59 1920 3840 downsampled MPS
888 * 60 59 1920 upsampled MPS
889 * 15 14, 29, 44, 59 1920 3840 5760 7680
890 *
891 * BSAC 16 15, 31, 47, 63 1024 2048 3072 4096
892 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
893 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
894 * 5120 6144 7168 8192 9216
895 *
896 * BSAC with SBR 32 31, 63 2048 4096 downsampled MPS
897 * 64 63 2048 upsampled MPS
898 * 16 15, 31, 47, 63 2048 4096 6144 8192
899 *
900 * AAC LD 512 8 7, 15, 23, 31, 39, 47, 55, 63, 71
901 * 512 1024 1536 2048 2560 3072 3584 4096 4608 downsampled MPS
902 * 16 15, 31, 47, 63 512 1024 1536 2048
903 *
904 * AAC ELD 512 8 7, 15, 23, 31, 39, 47, 55, 63, 71
905 * 512 1024 1536 2048 2560 3072 3584 4096 4608 downsampled MPS
906 * 16 15, 31, 47, 63 512 1024 1536 2048
907 *
908 * AAC ELD with SBR 512/1024 16 15, 31, 47, 63 1024 2048 3072 4096
909 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
910 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
911 * 5120 6144 7168 8192 9216
912 *
913 * MPEG1/2 Layer II 18 17, 35, 53, 71 1152 2304 3456 4608
914 * downsampled MPS 36 35, 71 1152 2304
915 *
916 * MPEG1/2 Layer III 18 17, 35, 53, 71 1152 2304 3456 4608
917 * downsampled MPS 36 35, 71 1152 2304
918 *
919 * \param frameLength
920 * \param qmfBands
921 * \param timeSlots
922 *
923 * \return error code
924 */
checkTimeSlots(int frameLength,int qmfBands,int timeSlots)925 SACDEC_ERROR checkTimeSlots(int frameLength, int qmfBands, int timeSlots) {
926 int len;
927 int maxFrameLength;
928
929 if (qmfBands == 64) {
930 /* normal MPEG Surround */
931 switch (frameLength) {
932 case 960:
933 case 1920:
934 maxFrameLength = 3840;
935 break;
936 case 1024:
937 case 2048:
938 maxFrameLength = 4096;
939 break;
940 case 512:
941 case 1152:
942 maxFrameLength = 4608;
943 break;
944 default:
945 return MPS_PARSE_ERROR;
946 }
947 } else if (qmfBands == 32) {
948 /* downsampled MPEG Surround */
949 switch (frameLength) {
950 case 960:
951 case 1920:
952 maxFrameLength = 1920;
953 break;
954 case 512:
955 case 1024:
956 case 2048:
957 maxFrameLength = 2048;
958 break;
959 case 1152:
960 maxFrameLength = 2304;
961 break;
962 default:
963 return MPS_PARSE_ERROR;
964 }
965 } else if (qmfBands == 128) {
966 /* upsampled MPEG Surround */
967 switch (frameLength) {
968 case 1920:
969 maxFrameLength = 7680;
970 break;
971 case 1024:
972 maxFrameLength = 9216;
973 break;
974 case 2048:
975 maxFrameLength = 8192;
976 break;
977 case 512:
978 case 960:
979 case 1152:
980 /* no break, no support for upsampled MPEG Surround */
981 default:
982 return MPS_PARSE_ERROR;
983 }
984 } else {
985 return MPS_PARSE_ERROR;
986 }
987
988 len = frameLength;
989
990 while (len <= maxFrameLength) {
991 if (len == timeSlots * qmfBands) {
992 return MPS_OK;
993 }
994 len += frameLength;
995 }
996 return MPS_PARSE_ERROR;
997 }
998
999 /**
1000 * \brief Check ssc for consistency (e.g. bit errors could cause trouble)
1001 * First of currently two ssc-checks.
1002 * This (old) one is called in mpegSurroundDecoder_Apply()
1003 * only if inband mps config is contained in stream.
1004 *
1005 * New ssc check is split in two functions sscParseCheck() and
1006 * check_UParam_Build_DecConfig(). sscParseCheck() checks only for correct
1007 * parsing. check_UParam_Build_DecConfig() is used to check if we have a
1008 * valid config. Both are called in initMpegSurroundDecoder() to ensure
1009 * checking of inband and out-of-band mps configs.
1010 *
1011 * If this function can be integrated into the new functions.
1012 * We can remove this one.
1013 *
1014 * \param pSsc spatial specific config handle.
1015 * \param frameLength
1016 * \param sampleRate
1017 *
1018 * \return MPS_OK on sucess, and else on failure.
1019 */
sscCheckInBand(SPATIAL_SPECIFIC_CONFIG * pSsc,int frameLength,int sampleRate)1020 static SACDEC_ERROR sscCheckInBand(SPATIAL_SPECIFIC_CONFIG *pSsc,
1021 int frameLength, int sampleRate) {
1022 SACDEC_ERROR err = MPS_OK;
1023 int qmfBands;
1024
1025 FDK_ASSERT(pSsc != NULL);
1026
1027 /* core fs and mps fs must match */
1028 if (pSsc->samplingFreq != sampleRate) {
1029 err = MPS_PARSE_ERROR /* MPEGSDEC_SSC_PARSE_ERROR */;
1030 }
1031
1032 qmfBands = mpegSurroundDecoder_GetNrOfQmfBands(pSsc, pSsc->samplingFreq);
1033
1034 if (checkTimeSlots(frameLength, qmfBands, pSsc->nTimeSlots) != MPS_OK) {
1035 err = MPS_PARSE_ERROR;
1036 }
1037
1038 return err;
1039 }
1040
1041 SACDEC_ERROR
mpegSurroundDecoder_ConfigureQmfDomain(CMpegSurroundDecoder * pMpegSurroundDecoder,SAC_INPUT_CONFIG sac_dec_interface,UINT coreSamplingRate,AUDIO_OBJECT_TYPE coreCodec)1042 mpegSurroundDecoder_ConfigureQmfDomain(
1043 CMpegSurroundDecoder *pMpegSurroundDecoder,
1044 SAC_INPUT_CONFIG sac_dec_interface, UINT coreSamplingRate,
1045 AUDIO_OBJECT_TYPE coreCodec) {
1046 SACDEC_ERROR err = MPS_OK;
1047 FDK_QMF_DOMAIN_GC *pGC = NULL;
1048
1049 if (pMpegSurroundDecoder == NULL) {
1050 return MPS_INVALID_HANDLE;
1051 }
1052
1053 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1054
1055 pGC = &pMpegSurroundDecoder->pQmfDomain->globalConf;
1056 if (pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg) {
1057 SPATIAL_SPECIFIC_CONFIG *pSSC =
1058 &pMpegSurroundDecoder->spatialSpecificConfigBackup;
1059 if (sac_dec_interface == SAC_INTERFACE_TIME) {
1060 /* For SAC_INTERFACE_QMF these parameters are set by SBR. */
1061 pGC->nBandsAnalysis_requested = mpegSurroundDecoder_GetNrOfQmfBands(
1062 pSSC, coreSamplingRate); /* coreSamplingRate == outputSamplingRate for
1063 SAC_INTERFACE_TIME */
1064 pGC->nBandsSynthesis_requested = pGC->nBandsAnalysis_requested;
1065 pGC->nInputChannels_requested =
1066 fMax((UINT)pSSC->nInputChannels, (UINT)pGC->nInputChannels_requested);
1067 }
1068 pGC->nOutputChannels_requested =
1069 fMax((UINT)pSSC->nOutputChannels, (UINT)pGC->nOutputChannels_requested);
1070 } else {
1071 if (sac_dec_interface == SAC_INTERFACE_TIME) {
1072 /* For SAC_INTERFACE_QMF these parameters are set by SBR. */
1073 pGC->nBandsAnalysis_requested = mpegSurroundDecoder_GetNrOfQmfBands(
1074 NULL, coreSamplingRate); /* coreSamplingRate == outputSamplingRate for
1075 SAC_INTERFACE_TIME */
1076 pGC->nBandsSynthesis_requested = pGC->nBandsAnalysis_requested;
1077 pGC->nInputChannels_requested =
1078 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumInputChannels;
1079 }
1080 pGC->nOutputChannels_requested =
1081 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumOutputChannels;
1082 }
1083 pGC->nQmfProcBands_requested = 64;
1084 pGC->nQmfProcChannels_requested =
1085 fMin((INT)pGC->nInputChannels_requested,
1086 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumInputChannels);
1087
1088 if (coreCodec == AOT_ER_AAC_ELD) {
1089 pGC->flags_requested |= QMF_FLAG_MPSLDFB;
1090 }
1091
1092 return err;
1093 }
1094
1095 /**
1096 * \brief Decode MPEG Surround frame.
1097 **/
mpegSurroundDecoder_ParseNoHeader(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,int * pMpsDataBits,int fGlobalIndependencyFlag)1098 int mpegSurroundDecoder_ParseNoHeader(
1099 CMpegSurroundDecoder *pMpegSurroundDecoder, HANDLE_FDK_BITSTREAM hBs,
1100 int *pMpsDataBits, int fGlobalIndependencyFlag) {
1101 SACDEC_ERROR err = MPS_OK;
1102 SPATIAL_SPECIFIC_CONFIG *sscParse;
1103 int bitsAvail, numSacBits;
1104
1105 if (pMpegSurroundDecoder == NULL || hBs == NULL) {
1106 return MPS_INVALID_HANDLE;
1107 }
1108
1109 sscParse = &pMpegSurroundDecoder
1110 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
1111
1112 bitsAvail = FDKgetValidBits(hBs);
1113
1114 /* First spatial specific config is parsed into spatialSpecificConfigBackup,
1115 * second spatialSpecificConfigBackup is copied into
1116 * spatialSpecificConfig[bsFrameDecode] */
1117 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameParse]) {
1118 FDKmemcpy(sscParse, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1119 sizeof(SPATIAL_SPECIFIC_CONFIG));
1120 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameParse] =
1121 MPEGS_SYNC_FOUND;
1122 }
1123
1124 if (bitsAvail <= 0) {
1125 err = MPS_PARSE_ERROR;
1126 } else {
1127 err = SpatialDecParseFrameData(
1128 pMpegSurroundDecoder->pSpatialDec,
1129 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse],
1130 hBs, sscParse, (UPMIXTYPE)pMpegSurroundDecoder->upmixType,
1131 fGlobalIndependencyFlag);
1132 if (err == MPS_OK) {
1133 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1134 .newBsData = 1;
1135 }
1136 }
1137
1138 numSacBits = bitsAvail - (INT)FDKgetValidBits(hBs);
1139
1140 if (numSacBits > bitsAvail) {
1141 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1142 .newBsData = 0;
1143 err = MPS_PARSE_ERROR;
1144 }
1145
1146 *pMpsDataBits -= numSacBits;
1147
1148 return err;
1149 }
1150
1151 /**
1152 * \brief Check, if ancType is valid.
1153 **/
isValidAncType(CMpegSurroundDecoder * pMpegSurroundDecoder,int ancType)1154 static int isValidAncType(CMpegSurroundDecoder *pMpegSurroundDecoder,
1155 int ancType) {
1156 int ret = 1;
1157
1158 if ((ancType != MPEGS_ANCTYPE_HEADER_AND_FRAME) &&
1159 (ancType != MPEGS_ANCTYPE_FRAME)) {
1160 ret = 0;
1161 }
1162
1163 if (ret == 0) {
1164 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1165 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1166 MPEGS_STOP);
1167 }
1168
1169 return (ret);
1170 }
1171
1172 /**
1173 * \brief Check, if ancStartStop is valid.
1174 **/
isValidAncStartStop(CMpegSurroundDecoder * pMpegSurroundDecoder,int ancStartStop)1175 static int isValidAncStartStop(CMpegSurroundDecoder *pMpegSurroundDecoder,
1176 int ancStartStop) {
1177 int ret = 1;
1178
1179 switch (ancStartStop) {
1180 case MPEGS_START:
1181 /* Sequence start - start and continue - start not allowed */
1182 if ((pMpegSurroundDecoder->ancStartStopPrev == MPEGS_START) ||
1183 (pMpegSurroundDecoder->ancStartStopPrev == MPEGS_CONTINUE)) {
1184 ret = 0;
1185 }
1186 break;
1187
1188 case MPEGS_STOP:
1189 /* MPS payload of the previous frame must be valid if current type is stop
1190 Sequence startstop - stop and stop - stop not allowed
1191 Sequence startstop - continue and stop - continue are allowed */
1192 if ((pMpegSurroundDecoder->ancStartStopPrev == MPEGS_STOP) ||
1193 (pMpegSurroundDecoder->ancStartStopPrev == MPEGS_START_STOP)) {
1194 ret = 0;
1195 }
1196 break;
1197
1198 case MPEGS_CONTINUE:
1199 case MPEGS_START_STOP:
1200 /* No error detection possible for this states */
1201 break;
1202 }
1203
1204 if (ret == 0) {
1205 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1206 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1207 MPEGS_STOP);
1208 } else {
1209 pMpegSurroundDecoder->ancStartStopPrev = (MPEGS_ANCSTARTSTOP)ancStartStop;
1210 }
1211
1212 return (ret);
1213 }
1214
mpegSurroundDecoder_Parse(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,int * pMpsDataBits,AUDIO_OBJECT_TYPE coreCodec,int sampleRate,int frameSize,int fGlobalIndependencyFlag)1215 int mpegSurroundDecoder_Parse(CMpegSurroundDecoder *pMpegSurroundDecoder,
1216 HANDLE_FDK_BITSTREAM hBs, int *pMpsDataBits,
1217 AUDIO_OBJECT_TYPE coreCodec, int sampleRate,
1218 int frameSize, int fGlobalIndependencyFlag) {
1219 SACDEC_ERROR err = MPS_OK;
1220 SPATIAL_SPECIFIC_CONFIG *sscParse;
1221 SPATIAL_BS_FRAME *bsFrame;
1222 HANDLE_FDK_BITSTREAM hMpsBsData = NULL;
1223 FDK_BITSTREAM mpsBsData;
1224 int mpsDataBits = *pMpsDataBits;
1225 int mpsBsBits;
1226 MPEGS_ANCTYPE ancType;
1227 MPEGS_ANCSTARTSTOP ancStartStop;
1228
1229 if (pMpegSurroundDecoder == NULL) {
1230 return MPS_INVALID_HANDLE;
1231 }
1232
1233 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1234
1235 mpsBsBits = FDKgetValidBits(hBs);
1236
1237 sscParse = &pMpegSurroundDecoder
1238 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
1239 bsFrame = &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse];
1240
1241 /*
1242 Find operation mode of mpeg surround decoder:
1243 - MPEGS_OPMODE_EMM: Mode: Enhanced Matrix Mode (Blind)
1244 - MPEGS_OPMODE_MPS_PAYLOAD: Mode: Normal, Stereo or Binaural
1245 - MPEGS_OPMODE_NO_MPS_PAYLOAD: Mode: No MpegSurround Payload
1246 */
1247 {
1248 /* Parse ancType and ancStartStop */
1249 ancType = (MPEGS_ANCTYPE)FDKreadBits(hBs, 2);
1250 ancStartStop = (MPEGS_ANCSTARTSTOP)FDKreadBits(hBs, 2);
1251 mpsDataBits -= 4;
1252
1253 /* Set valid anc type flag, if ancType signals a payload with either header
1254 * and frame or frame */
1255 if (isValidAncType(pMpegSurroundDecoder, ancType)) {
1256 /* Set valid anc startstop flag, if transmitted sequence is not illegal */
1257 if (isValidAncStartStop(pMpegSurroundDecoder, ancStartStop)) {
1258 switch (ancStartStop) {
1259 case MPEGS_START:
1260 /* Assuming that core coder frame size (AAC) is smaller than MPS
1261 coder frame size. Save audio data for next frame. */
1262 if (mpsDataBits > MPS_DATA_BUFFER_SIZE * 8) {
1263 err = MPS_NOTOK;
1264 goto bail;
1265 }
1266 for (int i = 0; i < mpsDataBits / 8; i++) {
1267 pMpegSurroundDecoder->mpsData[i] = FDKreadBits(hBs, 8);
1268 }
1269 pMpegSurroundDecoder->mpsDataBits = mpsDataBits;
1270 break;
1271
1272 case MPEGS_CONTINUE:
1273 case MPEGS_STOP:
1274 /* Assuming that core coder frame size (AAC) is smaller than MPS
1275 coder frame size. Save audio data for next frame. */
1276 if ((pMpegSurroundDecoder->mpsDataBits + mpsDataBits) >
1277 MPS_DATA_BUFFER_SIZE * 8) {
1278 err = MPS_NOTOK;
1279 goto bail;
1280 }
1281 for (int i = 0; i < mpsDataBits / 8; i++) {
1282 pMpegSurroundDecoder
1283 ->mpsData[(pMpegSurroundDecoder->mpsDataBits / 8) + i] =
1284 FDKreadBits(hBs, 8);
1285 }
1286 pMpegSurroundDecoder->mpsDataBits += mpsDataBits;
1287 FDKinitBitStream(&mpsBsData, pMpegSurroundDecoder->mpsData,
1288 MAX_BUFSIZE_BYTES,
1289 pMpegSurroundDecoder->mpsDataBits, BS_READER);
1290 hMpsBsData = &mpsBsData;
1291 break;
1292
1293 case MPEGS_START_STOP:
1294 pMpegSurroundDecoder->mpsDataBits = mpsDataBits;
1295 hMpsBsData = hBs;
1296 break;
1297
1298 default:
1299 FDK_ASSERT(0);
1300 }
1301
1302 if ((ancStartStop == MPEGS_STOP) ||
1303 (ancStartStop == MPEGS_START_STOP)) {
1304 switch (ancType) {
1305 case MPEGS_ANCTYPE_HEADER_AND_FRAME: {
1306 int parseResult, bitsRead;
1307 SPATIAL_SPECIFIC_CONFIG spatialSpecificConfigTmp =
1308 pMpegSurroundDecoder->spatialSpecificConfigBackup;
1309
1310 /* Parse spatial specific config */
1311 bitsRead = FDKgetValidBits(hMpsBsData);
1312
1313 err = SpatialDecParseSpecificConfigHeader(
1314 hMpsBsData,
1315 &pMpegSurroundDecoder->spatialSpecificConfigBackup, coreCodec,
1316 pMpegSurroundDecoder->upmixType);
1317
1318 bitsRead = (bitsRead - FDKgetValidBits(hMpsBsData));
1319 parseResult = ((err == MPS_OK) ? bitsRead : -bitsRead);
1320
1321 if (parseResult < 0) {
1322 parseResult = -parseResult;
1323 err = MPS_PARSE_ERROR;
1324 } else if (err == MPS_OK) {
1325 /* Check SSC for consistency (e.g. bit errors could cause
1326 * trouble) */
1327 err = sscCheckInBand(
1328 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1329 frameSize, sampleRate);
1330 }
1331 if (err != MPS_OK) {
1332 pMpegSurroundDecoder->spatialSpecificConfigBackup =
1333 spatialSpecificConfigTmp;
1334 break;
1335 }
1336
1337 pMpegSurroundDecoder->mpsDataBits -= parseResult;
1338
1339 /* Initiate re-initialization, if header has changed */
1340 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
1341 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1342 sscParse) == MPS_UNEQUAL_SSC) {
1343 pMpegSurroundDecoder
1344 ->initFlags[pMpegSurroundDecoder->bsFrameParse] |=
1345 MPEGS_INIT_CHANGE_HEADER;
1346 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
1347 /* We found a valid in-band configuration. Therefore any
1348 * previous config is invalid now. */
1349 pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg = 0;
1350 }
1351 }
1352 case MPEGS_ANCTYPE_FRAME:
1353
1354 if (pMpegSurroundDecoder
1355 ->initFlags[pMpegSurroundDecoder->bsFrameParse] &
1356 MPEGS_INIT_ERROR_PAYLOAD) {
1357 err = MPS_PARSE_ERROR;
1358 break;
1359 }
1360
1361 /* First spatial specific config is parsed into
1362 * spatialSpecificConfigBackup, second spatialSpecificConfigBackup
1363 * is copied into spatialSpecificConfig[bsFrameDecode] */
1364 if (pMpegSurroundDecoder
1365 ->initFlags[pMpegSurroundDecoder->bsFrameParse]) {
1366 FDKmemcpy(sscParse,
1367 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1368 sizeof(SPATIAL_SPECIFIC_CONFIG));
1369 pMpegSurroundDecoder
1370 ->fOnSync[pMpegSurroundDecoder->bsFrameParse] =
1371 MPEGS_SYNC_FOUND;
1372 }
1373
1374 if (pMpegSurroundDecoder
1375 ->fOnSync[pMpegSurroundDecoder->bsFrameParse] >=
1376 MPEGS_SYNC_FOUND) {
1377 int nbits = 0, bitsAvail;
1378
1379 if (err != MPS_OK) {
1380 break;
1381 }
1382
1383 bitsAvail = FDKgetValidBits(hMpsBsData);
1384
1385 if (bitsAvail <= 0) {
1386 err = MPS_PARSE_ERROR;
1387 } else {
1388 err = SpatialDecParseFrameData(
1389 pMpegSurroundDecoder->pSpatialDec, bsFrame, hMpsBsData,
1390 sscParse, (UPMIXTYPE)pMpegSurroundDecoder->upmixType,
1391 fGlobalIndependencyFlag);
1392 if (err == MPS_OK) {
1393 bsFrame->newBsData = 1;
1394 }
1395 }
1396
1397 nbits = bitsAvail - (INT)FDKgetValidBits(hMpsBsData);
1398
1399 if ((nbits > bitsAvail) ||
1400 (nbits > pMpegSurroundDecoder->mpsDataBits) ||
1401 (pMpegSurroundDecoder->mpsDataBits > nbits + 7 &&
1402 !IS_LOWDELAY(coreCodec))) {
1403 bsFrame->newBsData = 0;
1404 err = MPS_PARSE_ERROR;
1405 break;
1406 }
1407 pMpegSurroundDecoder->mpsDataBits -= nbits;
1408 }
1409 break;
1410
1411 default: /* added to avoid compiler warning */
1412 err = MPS_NOTOK;
1413 break; /* added to avoid compiler warning */
1414 } /* switch (ancType) */
1415
1416 if (err == MPS_OK) {
1417 pMpegSurroundDecoder->ancStartStopPrev = ancStartStop;
1418 } else {
1419 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1420 MPEGS_INIT_ERROR_PAYLOAD,
1421 MPEGS_SYNC_LOST, MPEGS_STOP);
1422 pMpegSurroundDecoder->mpsDataBits = 0;
1423 }
1424 } /* (ancStartStop == MPEGS_STOP) || (ancStartStop == MPEGS_START_STOP)
1425 */
1426 } /* validAncStartStop */
1427 } /* validAncType */
1428 }
1429
1430 bail:
1431
1432 *pMpsDataBits -= (mpsBsBits - FDKgetValidBits(hBs));
1433
1434 return err;
1435 }
1436
mpegSurroundDecoder_Apply(CMpegSurroundDecoder * pMpegSurroundDecoder,INT_PCM * input,PCM_MPS * pTimeData,const int timeDataSize,int timeDataFrameSize,int * nChannels,int * frameSize,int sampleRate,AUDIO_OBJECT_TYPE coreCodec,AUDIO_CHANNEL_TYPE channelType[],UCHAR channelIndices[],const FDK_channelMapDescr * const mapDescr)1437 int mpegSurroundDecoder_Apply(CMpegSurroundDecoder *pMpegSurroundDecoder,
1438 INT_PCM *input, PCM_MPS *pTimeData,
1439 const int timeDataSize, int timeDataFrameSize,
1440 int *nChannels, int *frameSize, int sampleRate,
1441 AUDIO_OBJECT_TYPE coreCodec,
1442 AUDIO_CHANNEL_TYPE channelType[],
1443 UCHAR channelIndices[],
1444 const FDK_channelMapDescr *const mapDescr) {
1445 SACDEC_ERROR err = MPS_OK;
1446 PCM_MPS *pTimeOut = pTimeData;
1447 UINT initControlFlags = 0, controlFlags = 0;
1448 int timeDataRequiredSize = 0;
1449 int newData;
1450
1451 if (pMpegSurroundDecoder == NULL) {
1452 return MPS_INVALID_HANDLE;
1453 }
1454
1455 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1456
1457 if (!FDK_chMapDescr_isValid(mapDescr)) {
1458 return MPS_INVALID_HANDLE;
1459 }
1460
1461 if ((*nChannels <= 0) || (*nChannels > 2)) {
1462 return MPS_NOTOK;
1463 }
1464
1465 pMpegSurroundDecoder->pSpatialDec->pConfigCurrent =
1466 &pMpegSurroundDecoder
1467 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
1468 newData = pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1469 .newBsData;
1470
1471 switch (mpegSurroundOperationMode(pMpegSurroundDecoder, 1000)) {
1472 case MPEGS_OPMODE_MPS_PAYLOAD:
1473 if (pMpegSurroundDecoder
1474 ->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
1475 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
1476 }
1477
1478 if (err == MPS_OK) {
1479 if ((pMpegSurroundDecoder
1480 ->fOnSync[pMpegSurroundDecoder->bsFrameDecode] !=
1481 MPEGS_SYNC_COMPLETE) &&
1482 (pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode]
1483 .bsIndependencyFlag == 1)) {
1484 /* We got a valid header and independently decodeable frame data.
1485 -> Go to the next sync level and start processing. */
1486 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1487 MPEGS_SYNC_COMPLETE;
1488 }
1489 } else {
1490 /* We got a valid config header but found an error while parsing the
1491 bitstream. Wait for the next independent frame and apply error
1492 conealment in the meantime. */
1493 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1494 MPEGS_SYNC_FOUND;
1495 controlFlags |= MPEGS_CONCEAL;
1496 err = MPS_OK;
1497 }
1498 /*
1499 Concealment:
1500 - Bitstream is available, no sync found during bitstream processing
1501 - Bitstream is available, sync lost due to corrupted bitstream
1502 - Bitstream is available, sync found but no independent frame
1503 */
1504 if (pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] !=
1505 MPEGS_SYNC_COMPLETE) {
1506 controlFlags |= MPEGS_CONCEAL;
1507 }
1508 break;
1509
1510 case MPEGS_OPMODE_NO_MPS_PAYLOAD:
1511 /* Concealment: No bitstream is available */
1512 controlFlags |= MPEGS_CONCEAL;
1513 break;
1514
1515 default:
1516 err = MPS_NOTOK;
1517 }
1518
1519 if (err != MPS_OK) {
1520 goto bail;
1521 }
1522
1523 /*
1524 * Force BypassMode if choosen by user
1525 */
1526 if (pMpegSurroundDecoder->mpegSurroundUserParams.bypassMode) {
1527 controlFlags |= MPEGS_BYPASSMODE;
1528 }
1529
1530 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
1531 int startWithDfltCfg = 0;
1532 /*
1533 * Init with a default configuration if we came here and are still not
1534 * initialized.
1535 */
1536 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] &
1537 MPEGS_INIT_ENFORCE_REINIT) {
1538 /* Get default spatial specific config */
1539 if (FDK_SpatialDecInitDefaultSpatialSpecificConfig(
1540 &pMpegSurroundDecoder->spatialSpecificConfigBackup, coreCodec,
1541 *nChannels, sampleRate,
1542 *frameSize /
1543 mpegSurroundDecoder_GetNrOfQmfBands(NULL, sampleRate),
1544 pMpegSurroundDecoder->mpegSurroundDecoderLevel,
1545 pMpegSurroundDecoder->mpegSurroundUserParams.blindEnable)) {
1546 err = MPS_NOTOK;
1547 goto bail;
1548 }
1549
1550 /* Initiate re-initialization, if header has changed */
1551 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
1552 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1553 &pMpegSurroundDecoder->spatialSpecificConfig
1554 [pMpegSurroundDecoder->bsFrameDecode]) == MPS_UNEQUAL_SSC) {
1555 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1556 MPEGS_INIT_CHANGE_HEADER;
1557 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
1558 }
1559
1560 startWithDfltCfg = 1;
1561 }
1562
1563 /* First spatial specific config is parsed into spatialSpecificConfigBackup,
1564 * second spatialSpecificConfigBackup is copied into spatialSpecificConfig
1565 */
1566 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
1567
1568 if (startWithDfltCfg) {
1569 /* initialized with default config, but no sync found */
1570 /* maybe use updateMpegSurroundDecoderStatus later on */
1571 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1572 MPEGS_SYNC_LOST;
1573 }
1574
1575 /* Since we do not have state MPEGS_SYNC_COMPLETE apply concealment */
1576 controlFlags |= MPEGS_CONCEAL;
1577
1578 if (err != MPS_OK) {
1579 goto bail;
1580 }
1581 }
1582
1583 /*
1584 * Process MPEG Surround Audio
1585 */
1586 initControlFlags = controlFlags;
1587
1588 /* Check that provided output buffer is large enough. */
1589 timeDataRequiredSize =
1590 (timeDataFrameSize *
1591 pMpegSurroundDecoder->pSpatialDec->numOutputChannelsAT *
1592 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsSynthesis) /
1593 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsAnalysis;
1594 if (timeDataSize < timeDataRequiredSize) {
1595 err = MPS_OUTPUT_BUFFER_TOO_SMALL;
1596 goto bail;
1597 }
1598
1599 if ((pMpegSurroundDecoder->pSpatialDec->pConfigCurrent->syntaxFlags &
1600 SACDEC_SYNTAX_USAC) &&
1601 (pMpegSurroundDecoder->pSpatialDec->stereoConfigIndex > 1)) {
1602 FDK_ASSERT(timeDataRequiredSize >= timeDataFrameSize * *nChannels);
1603 /* Place samples comprising QMF time slots spaced at QMF output Band raster
1604 * to allow slot wise processing */
1605 int timeDataFrameSizeOut =
1606 (timeDataFrameSize *
1607 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsSynthesis) /
1608 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsAnalysis;
1609 pMpegSurroundDecoder->pQmfDomain->globalConf.TDinput =
1610 pTimeData + timeDataFrameSizeOut - timeDataFrameSize;
1611 for (int i = *nChannels - 1; i >= 0; i--) {
1612 FDKmemmove(pTimeData + (i + 1) * timeDataFrameSizeOut - timeDataFrameSize,
1613 pTimeData + timeDataFrameSize * i,
1614 sizeof(PCM_MPS) * timeDataFrameSize);
1615 FDKmemclear(pTimeData + i * timeDataFrameSizeOut,
1616 sizeof(PCM_MPS) * (timeDataFrameSizeOut - timeDataFrameSize));
1617 }
1618 } else {
1619 if (pMpegSurroundDecoder->mpegSurroundUseTimeInterface) {
1620 FDKmemcpy(input, pTimeData,
1621 sizeof(INT_PCM) * (*nChannels) * (*frameSize));
1622 pMpegSurroundDecoder->pQmfDomain->globalConf.TDinput = input;
1623 }
1624 }
1625
1626 /*
1627 * Process MPEG Surround Audio
1628 */
1629 err = SpatialDecApplyFrame(
1630 pMpegSurroundDecoder->pSpatialDec,
1631 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode],
1632 pMpegSurroundDecoder->mpegSurroundUseTimeInterface ? INPUTMODE_TIME
1633 : INPUTMODE_QMF_SBR,
1634 pMpegSurroundDecoder->pQmfDomain->globalConf.TDinput, NULL, NULL,
1635 pTimeOut, *frameSize, &controlFlags, *nChannels, mapDescr);
1636 *nChannels = pMpegSurroundDecoder->pSpatialDec->numOutputChannelsAT;
1637
1638 if (err !=
1639 MPS_OK) { /* A fatal error occured. Go back to start and try again: */
1640 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1641 MPEGS_INIT_ENFORCE_REINIT, MPEGS_SYNC_LOST,
1642 MPEGS_STOP);
1643 *frameSize =
1644 0; /* Declare that framework can not use the data in pTimeOut. */
1645 } else {
1646 if (((controlFlags & MPEGS_CONCEAL) &&
1647 !(initControlFlags & MPEGS_CONCEAL)) ||
1648 (pMpegSurroundDecoder->pSpatialDec->errInt !=
1649 MPS_OK)) { /* Account for errors that occured in
1650 SpatialDecApplyFrame(): */
1651 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1652 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1653 MPEGS_STOP);
1654 }
1655 }
1656
1657 if ((err == MPS_OK) && !(controlFlags & MPEGS_BYPASSMODE) &&
1658 !(pMpegSurroundDecoder->upmixType == UPMIX_TYPE_BYPASS)) {
1659 SpatialDecChannelProperties(pMpegSurroundDecoder->pSpatialDec, channelType,
1660 channelIndices, mapDescr);
1661 }
1662
1663 bail:
1664
1665 if (newData) {
1666 /* numParameterSetsPrev shall only be read in the decode process, because of
1667 that we can update this state variable here */
1668 pMpegSurroundDecoder->pSpatialDec->numParameterSetsPrev =
1669 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode]
1670 .numParameterSets;
1671 }
1672
1673 return (err);
1674 }
1675
1676 /**
1677 * \brief Free config dependent MPEG Surround memory.
1678 **/
mpegSurroundDecoder_FreeMem(CMpegSurroundDecoder * pMpegSurroundDecoder)1679 SACDEC_ERROR mpegSurroundDecoder_FreeMem(
1680 CMpegSurroundDecoder *pMpegSurroundDecoder) {
1681 SACDEC_ERROR err = MPS_OK;
1682
1683 if (pMpegSurroundDecoder != NULL) {
1684 FDK_SpatialDecClose(pMpegSurroundDecoder->pSpatialDec);
1685 pMpegSurroundDecoder->pSpatialDec = NULL;
1686 }
1687
1688 return err;
1689 }
1690
1691 /**
1692 * \brief Close MPEG Surround decoder.
1693 **/
mpegSurroundDecoder_Close(CMpegSurroundDecoder * pMpegSurroundDecoder)1694 void mpegSurroundDecoder_Close(CMpegSurroundDecoder *pMpegSurroundDecoder) {
1695 if (pMpegSurroundDecoder != NULL) {
1696 FDK_SpatialDecClose(pMpegSurroundDecoder->pSpatialDec);
1697 pMpegSurroundDecoder->pSpatialDec = NULL;
1698
1699 for (int i = 0; i < 1; i++) {
1700 SpatialDecCloseBsFrame(&pMpegSurroundDecoder->bsFrames[i]);
1701 }
1702
1703 FDK_FREE_MEMORY_1D(pMpegSurroundDecoder);
1704 }
1705 }
1706
1707 #define SACDEC_VL0 2
1708 #define SACDEC_VL1 0
1709 #define SACDEC_VL2 0
1710
mpegSurroundDecoder_GetLibInfo(LIB_INFO * info)1711 int mpegSurroundDecoder_GetLibInfo(LIB_INFO *info) {
1712 int i;
1713
1714 if (info == NULL) {
1715 return -1;
1716 }
1717
1718 /* search for next free tab */
1719 for (i = 0; i < FDK_MODULE_LAST; i++) {
1720 if (info[i].module_id == FDK_NONE) break;
1721 }
1722 if (i == FDK_MODULE_LAST) return -1;
1723
1724 info += i;
1725
1726 info->module_id = FDK_MPSDEC;
1727 #ifdef __ANDROID__
1728 info->build_date = "";
1729 info->build_time = "";
1730 #else
1731 info->build_date = __DATE__;
1732 info->build_time = __TIME__;
1733 #endif
1734 info->title = "MPEG Surround Decoder";
1735 info->version = LIB_VERSION(SACDEC_VL0, SACDEC_VL1, SACDEC_VL2);
1736 LIB_VERSION_STRING(info);
1737 info->flags = 0 | CAPF_MPS_LD | CAPF_MPS_USAC | CAPF_MPS_HQ |
1738 CAPF_MPS_1CH_IN | CAPF_MPS_2CH_OUT; /* end flags */
1739
1740 return 0;
1741 }
1742
mpegSurroundDecoder_SetParam(CMpegSurroundDecoder * pMpegSurroundDecoder,const SACDEC_PARAM param,const INT value)1743 SACDEC_ERROR mpegSurroundDecoder_SetParam(
1744 CMpegSurroundDecoder *pMpegSurroundDecoder, const SACDEC_PARAM param,
1745 const INT value) {
1746 SACDEC_ERROR err = MPS_OK;
1747 SPATIALDEC_PARAM *pUserParams = NULL;
1748
1749 /* check decoder handle */
1750 if (pMpegSurroundDecoder != NULL) {
1751 /* init local shortcuts */
1752 pUserParams = &pMpegSurroundDecoder->mpegSurroundUserParams;
1753 } else {
1754 err = MPS_INVALID_HANDLE;
1755 /* check the parameter values before exiting. */
1756 }
1757
1758 /* apply param value */
1759 switch (param) {
1760 case SACDEC_OUTPUT_MODE:
1761 switch ((SAC_DEC_OUTPUT_MODE)value) {
1762 case SACDEC_OUT_MODE_NORMAL:
1763 case SACDEC_OUT_MODE_STEREO:
1764 break;
1765 default:
1766 err = MPS_INVALID_PARAMETER;
1767 }
1768 if (err == MPS_OK) {
1769 if (0) {
1770 err = MPS_INVALID_PARAMETER;
1771 } else if (pUserParams->outputMode != (UCHAR)value) {
1772 pUserParams->outputMode = (UCHAR)value;
1773 pMpegSurroundDecoder
1774 ->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1775 MPEGS_INIT_CHANGE_OUTPUT_MODE;
1776 }
1777 }
1778 break;
1779
1780 case SACDEC_INTERFACE:
1781 if (value < 0 || value > 1) {
1782 err = MPS_INVALID_PARAMETER;
1783 }
1784 if (err != MPS_OK) {
1785 goto bail;
1786 }
1787 if (pMpegSurroundDecoder->mpegSurroundUseTimeInterface != (UCHAR)value) {
1788 pMpegSurroundDecoder->mpegSurroundUseTimeInterface = (UCHAR)value;
1789 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1790 MPEGS_INIT_CHANGE_TIME_FREQ_INTERFACE;
1791 }
1792 break;
1793
1794 case SACDEC_BS_INTERRUPTION:
1795 if ((err == MPS_OK) && (value != 0)) {
1796 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1797 MPEGS_INIT_BS_INTERRUPTION,
1798 MPEGS_SYNC_LOST, MPEGS_STOP);
1799 }
1800 break;
1801
1802 case SACDEC_CLEAR_HISTORY:
1803 if ((err == MPS_OK) && (value != 0)) {
1804 /* Just reset the states and go on. */
1805 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1806 MPEGS_INIT_CLEAR_HISTORY,
1807 MPEGS_SYNC_LOST, MPEGS_STOP);
1808 }
1809 break;
1810
1811 case SACDEC_CONCEAL_NUM_KEEP_FRAMES:
1812 if (value < 0) { /* Check valid value range */
1813 err = MPS_INVALID_PARAMETER;
1814 }
1815 if (err != MPS_OK) {
1816 goto bail;
1817 }
1818 if (pUserParams->concealNumKeepFrames != (UINT)value) {
1819 pUserParams->concealNumKeepFrames = (UINT)value;
1820 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1821 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1822 }
1823 break;
1824
1825 case SACDEC_CONCEAL_FADE_OUT_SLOPE_LENGTH:
1826 if (value < 0) { /* Check valid value range */
1827 err = MPS_INVALID_PARAMETER;
1828 }
1829 if (err != MPS_OK) {
1830 goto bail;
1831 }
1832 if (pUserParams->concealFadeOutSlopeLength != (UINT)value) {
1833 pUserParams->concealFadeOutSlopeLength = (UINT)value;
1834 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1835 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1836 }
1837 break;
1838
1839 case SACDEC_CONCEAL_FADE_IN_SLOPE_LENGTH:
1840 if (value < 0) { /* Check valid value range */
1841 err = MPS_INVALID_PARAMETER;
1842 }
1843 if (err != MPS_OK) {
1844 goto bail;
1845 }
1846 if (pUserParams->concealFadeInSlopeLength != (UINT)value) {
1847 pUserParams->concealFadeInSlopeLength = (UINT)value;
1848 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1849 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1850 }
1851 break;
1852
1853 case SACDEC_CONCEAL_NUM_RELEASE_FRAMES:
1854 if (value < 0) { /* Check valid value range */
1855 err = MPS_INVALID_PARAMETER;
1856 }
1857 if (err != MPS_OK) {
1858 goto bail;
1859 }
1860 if (pUserParams->concealNumReleaseFrames != (UINT)value) {
1861 pUserParams->concealNumReleaseFrames = (UINT)value;
1862 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1863 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1864 }
1865 break;
1866
1867 default:
1868 err = MPS_INVALID_PARAMETER;
1869 break;
1870 } /* switch(param) */
1871
1872 bail:
1873 return err;
1874 }
1875
mpegSurroundDecoder_IsPseudoLR(CMpegSurroundDecoder * pMpegSurroundDecoder,int * bsPseudoLr)1876 SACDEC_ERROR mpegSurroundDecoder_IsPseudoLR(
1877 CMpegSurroundDecoder *pMpegSurroundDecoder, int *bsPseudoLr) {
1878 if (pMpegSurroundDecoder != NULL) {
1879 const SPATIAL_SPECIFIC_CONFIG *sscDecode =
1880 &pMpegSurroundDecoder
1881 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
1882 *bsPseudoLr = (int)sscDecode->bsPseudoLr;
1883 return MPS_OK;
1884 } else
1885 return MPS_INVALID_HANDLE;
1886 }
1887
1888 /**
1889 * \brief Get the signal delay caused by the MPEG Surround decoder module.
1890 **/
mpegSurroundDecoder_GetDelay(const CMpegSurroundDecoder * self)1891 UINT mpegSurroundDecoder_GetDelay(const CMpegSurroundDecoder *self) {
1892 INT outputDelay = 0;
1893
1894 if (self != NULL) {
1895 const SPATIAL_SPECIFIC_CONFIG *sscDecode =
1896 &self->spatialSpecificConfig[self->bsFrameDecode];
1897 AUDIO_OBJECT_TYPE coreCodec = sscDecode->coreCodec;
1898
1899 /* See chapter 4.5 (delay and synchronization) of ISO/IEC FDIS 23003-1 and
1900 chapter 5.4.3 of ISO/IEC FDIS 23003-2 for details on the following
1901 figures. */
1902
1903 if (coreCodec > AOT_NULL_OBJECT) {
1904 if (IS_LOWDELAY(coreCodec)) {
1905 /* All low delay variants (ER-AAC-(E)LD): */
1906 outputDelay += 256;
1907 } else if (!IS_USAC(coreCodec)) {
1908 /* By the method of elimination this is the GA (AAC-LC, HE-AAC, ...)
1909 * branch: */
1910 outputDelay += 320 + 257; /* cos to exp delay + QMF synthesis */
1911 if (self->mpegSurroundUseTimeInterface) {
1912 outputDelay += 320 + 384; /* QMF and hybrid analysis */
1913 }
1914 }
1915 }
1916 }
1917
1918 return (outputDelay);
1919 }
1920