1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2020 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 SACDEC_ERROR
241 static sscCheckOutOfBand(const SPATIAL_SPECIFIC_CONFIG *pSsc,
242 const INT coreCodec, const INT sampleRate,
243 const INT frameSize);
244
245 static SACDEC_ERROR sscParseCheck(const SPATIAL_SPECIFIC_CONFIG *pSsc);
246
247 /**
248 * \brief Get the number of QMF bands from the sampling frequency (in Hz)
249 **/
mpegSurroundDecoder_GetNrOfQmfBands(const SPATIAL_SPECIFIC_CONFIG * pSsc,UINT sampleRate)250 static int mpegSurroundDecoder_GetNrOfQmfBands(
251 const SPATIAL_SPECIFIC_CONFIG *pSsc, UINT sampleRate) {
252 UINT samplingFrequency = sampleRate;
253 int qmfBands = 64;
254
255 if (pSsc != NULL) {
256 switch (pSsc->coreCodec) {
257 case AOT_USAC:
258 if ((pSsc->stereoConfigIndex == 3)) {
259 static const UCHAR mapIdx2QmfBands[3] = {24, 32, 16};
260 FDK_ASSERT((pSsc->coreSbrFrameLengthIndex >= 2) &&
261 (pSsc->coreSbrFrameLengthIndex <= 4));
262 qmfBands = mapIdx2QmfBands[pSsc->coreSbrFrameLengthIndex - 2];
263 }
264 return qmfBands;
265 default:
266 samplingFrequency = pSsc->samplingFreq;
267 break;
268 }
269 }
270
271 /* number of QMF bands depend on sampling frequency, see FDIS 23003-1:2006
272 * Chapter 6.3.3 */
273 if (samplingFrequency < 27713) {
274 qmfBands = 32;
275 }
276 if (samplingFrequency > 55426) {
277 qmfBands = 128;
278 }
279
280 return qmfBands;
281 }
282
283 /**
284 * \brief Analyse init flags
285 **/
mpegSurroundDecoder_CalcInitFlags(SPATIAL_SPECIFIC_CONFIG * pSsc1,SPATIAL_SPECIFIC_CONFIG * pSsc2,int upmixTypeFlag,int binauralQualityFlag,int partiallyComplexFlag,int * ctrlFlags)286 static int mpegSurroundDecoder_CalcInitFlags(SPATIAL_SPECIFIC_CONFIG *pSsc1,
287 SPATIAL_SPECIFIC_CONFIG *pSsc2,
288 int upmixTypeFlag,
289 int binauralQualityFlag,
290 int partiallyComplexFlag,
291 int *ctrlFlags) {
292 /* Analyse core coder */
293 if (pSsc1->coreCodec != pSsc2->coreCodec) {
294 *ctrlFlags |= MASK_MPEGS_INIT_ALL_STATES;
295 *ctrlFlags |= MASK_MPEGS_INIT_ALL_PARAMS;
296 } else {
297 /* Analyse elements for initialization of space analysis qmf filterbank */
298 if ((partiallyComplexFlag) || (pSsc1->treeConfig != pSsc2->treeConfig) ||
299 (pSsc1->samplingFreq != pSsc2->samplingFreq)) {
300 *ctrlFlags |= MPEGS_INIT_STATES_ANA_QMF_FILTER;
301 *ctrlFlags |= MPEGS_INIT_STATES_ANA_HYB_FILTER;
302 }
303
304 /* Analyse elements for initialization of space synthesis qmf filterbank */
305 if ((upmixTypeFlag) || (partiallyComplexFlag) ||
306 (pSsc1->treeConfig != pSsc2->treeConfig) ||
307 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
308 (pSsc1->bsFixedGainDMX != pSsc2->bsFixedGainDMX)) {
309 *ctrlFlags |= MPEGS_INIT_STATES_SYN_QMF_FILTER;
310 }
311
312 /* Analyse elements for initialization of decorrelator */
313 if ((upmixTypeFlag) || (partiallyComplexFlag) ||
314 (pSsc1->treeConfig != pSsc2->treeConfig) ||
315 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
316 (pSsc1->decorrConfig != pSsc2->decorrConfig)) {
317 *ctrlFlags |= MPEGS_INIT_STATES_DECORRELATOR;
318 }
319
320 /* Analyse elements for initialization of m1 and m2 calculation */
321 if ((upmixTypeFlag) || (binauralQualityFlag) ||
322 (pSsc1->treeConfig != pSsc2->treeConfig) ||
323 (pSsc1->samplingFreq != pSsc2->samplingFreq))
324
325 {
326 *ctrlFlags |= MPEGS_INIT_STATES_M1M2;
327 }
328
329 /* Analyse elements for initialization of GES */
330 if ((upmixTypeFlag) || (pSsc1->treeConfig != pSsc2->treeConfig) ||
331 (pSsc1->tempShapeConfig != pSsc2->tempShapeConfig)) {
332 *ctrlFlags |= MPEGS_INIT_STATES_GES;
333 }
334
335 /* Analyse elements for initialization of FDreverb */
336 if ((upmixTypeFlag) || (binauralQualityFlag) || (partiallyComplexFlag) ||
337 (pSsc1->samplingFreq != pSsc2->samplingFreq) ||
338 (pSsc1->nTimeSlots != pSsc2->nTimeSlots)) {
339 *ctrlFlags |= MPEGS_INIT_STATES_REVERB;
340 }
341
342 /* Reset previous frame data whenever the config changes */
343 if (*ctrlFlags & MPEGS_INIT_CONFIG) {
344 *ctrlFlags |= MPEGS_INIT_STATES_PARAM;
345 }
346 }
347
348 return MPS_OK;
349 }
350
351 /**
352 * \brief Reset MPEG Surround status info
353 **/
updateMpegSurroundDecoderStatus(CMpegSurroundDecoder * pMpegSurroundDecoder,int initFlags,MPEGS_SYNCSTATE fOnSync,MPEGS_ANCSTARTSTOP ancStartStopPrev)354 static void updateMpegSurroundDecoderStatus(
355 CMpegSurroundDecoder *pMpegSurroundDecoder, int initFlags,
356 MPEGS_SYNCSTATE fOnSync, MPEGS_ANCSTARTSTOP ancStartStopPrev) {
357 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
358 initFlags;
359 if ((pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg != 0) &&
360 (pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] >=
361 MPEGS_SYNC_FOUND) &&
362 (fOnSync < MPEGS_SYNC_FOUND)) {
363 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
364 MPEGS_SYNC_FOUND;
365 } else {
366 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
367 fOnSync;
368 }
369 pMpegSurroundDecoder->ancStartStopPrev = ancStartStopPrev;
370 }
371
372 static SACDEC_ERROR mpegSurroundDecoder_Create(
373 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
374 HANDLE_FDK_QMF_DOMAIN pQmfDomain);
375
376 SAC_INSTANCE_AVAIL
mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(CMpegSurroundDecoder * pMpegSurroundDecoder)377 mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(
378 CMpegSurroundDecoder *pMpegSurroundDecoder) {
379 SAC_INSTANCE_AVAIL instanceAvailable = SAC_INSTANCE_NOT_FULL_AVAILABLE;
380
381 if (pMpegSurroundDecoder->pSpatialDec != NULL) {
382 instanceAvailable = SAC_INSTANCE_FULL_AVAILABLE;
383 }
384
385 return instanceAvailable;
386 }
387
mpegSurroundDecoder_Open(CMpegSurroundDecoder ** pMpegSurroundDecoder,int stereoConfigIndex,HANDLE_FDK_QMF_DOMAIN pQmfDomain)388 SACDEC_ERROR mpegSurroundDecoder_Open(
389 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
390 HANDLE_FDK_QMF_DOMAIN pQmfDomain) {
391 SACDEC_ERROR error;
392
393 error = mpegSurroundDecoder_Create(pMpegSurroundDecoder, stereoConfigIndex,
394 pQmfDomain);
395
396 return error;
397 }
398
399 /**
400 * \brief Renamed function from getUpmixType to check_UParam_Build_DecConfig.
401 * This function checks if user params, decoder config and SSC are valid
402 * and if the decoder build can handle all this settings.
403 * The upmix type may be modified by this function.
404 * It is called in initMpegSurroundDecoder() after the ssc parse check,
405 * to have all checks in one place and to ensure these checks are always
406 * performed if config changes (inband and out-of-band).
407 *
408 * \param pUserParams User data handle.
409 * \param pDecConfig decoder config handle.
410 * \param pSsc spatial specific config handle.
411 * \param pUpmixType upmix type which is set by this function
412 *
413 * \return MPS_OK on sucess, and else on failure.
414 */
check_UParam_Build_DecConfig(SPATIALDEC_PARAM const * pUserParams,SPATIAL_DEC_CONFIG const * pDecConfig,const SPATIAL_SPECIFIC_CONFIG * pSsc,SPATIAL_DEC_UPMIX_TYPE * pUpmixType)415 static SACDEC_ERROR check_UParam_Build_DecConfig(
416 SPATIALDEC_PARAM const *pUserParams, SPATIAL_DEC_CONFIG const *pDecConfig,
417 const SPATIAL_SPECIFIC_CONFIG *pSsc, SPATIAL_DEC_UPMIX_TYPE *pUpmixType) {
418 int dmxChannels, outChannels, maxNumOutChannels;
419
420 FDK_ASSERT(pUserParams != NULL);
421 FDK_ASSERT(pUpmixType != NULL);
422
423 /* checks if implementation can handle the Ssc */
424
425 switch (pSsc->treeConfig) {
426 case SPATIALDEC_MODE_RSVD7: /* 212 */
427 dmxChannels = 1;
428 outChannels = 2;
429 break;
430 default:
431 return MPS_UNSUPPORTED_CONFIG;
432 }
433
434 /* ------------------------------------------- */
435
436 /* Analyse pDecConfig params */
437 switch (pDecConfig->binauralMode) {
438 case BINAURAL_NONE:
439 break;
440 default:
441 return MPS_UNSUPPORTED_CONFIG;
442 }
443
444 switch (pDecConfig->decoderMode) {
445 case EXT_HQ_ONLY:
446 break;
447 default:
448 return MPS_UNSUPPORTED_CONFIG;
449 }
450
451 switch (pDecConfig->maxNumOutputChannels) {
452 case OUTPUT_CHANNELS_DEFAULT:
453 /* No special restrictions -> Get the level restriction: */
454 switch (pDecConfig->decoderLevel) {
455 case DECODER_LEVEL_0:
456 maxNumOutChannels = 2;
457 break;
458 default:
459 return MPS_UNSUPPORTED_CONFIG;
460 }
461 break;
462 case OUTPUT_CHANNELS_2_0:
463 maxNumOutChannels = 2;
464 break;
465 default:
466 return MPS_UNSUPPORTED_CONFIG;
467 }
468 /* ------------------------- */
469
470 /* check if we can handle user params */
471 if (pUserParams->blindEnable == 1) {
472 return MPS_UNSUPPORTED_CONFIG;
473 }
474 {
475 switch ((SAC_DEC_OUTPUT_MODE)pUserParams->outputMode) {
476 case SACDEC_OUT_MODE_NORMAL:
477 if (maxNumOutChannels >= outChannels) {
478 *pUpmixType = UPMIX_TYPE_NORMAL;
479 } else {
480 { *pUpmixType = UPMIX_TYPE_BYPASS; }
481 }
482 break;
483 case SACDEC_OUT_MODE_STEREO:
484 if (dmxChannels == 1) {
485 if (outChannels == 2) {
486 *pUpmixType = UPMIX_TYPE_NORMAL;
487 }
488 } else {
489 *pUpmixType = UPMIX_TYPE_BYPASS;
490 }
491 break;
492 case SACDEC_OUT_MODE_6CHANNEL:
493 if (outChannels > 6) {
494 { *pUpmixType = UPMIX_TYPE_BYPASS; }
495 } else {
496 *pUpmixType = UPMIX_TYPE_NORMAL;
497 }
498 break;
499 default:
500 return MPS_UNSUPPORTED_CONFIG;
501 }
502 }
503
504 return MPS_OK;
505 }
506
507 /**
508 * \brief Init MPEG Surround decoder.
509 **/
initMpegSurroundDecoder(CMpegSurroundDecoder * pMpegSurroundDecoder)510 static SACDEC_ERROR initMpegSurroundDecoder(
511 CMpegSurroundDecoder *pMpegSurroundDecoder) {
512 SACDEC_ERROR err;
513 int initFlags = MPEGS_INIT_NONE, initFlagsDec;
514 int upmixTypeCurr = pMpegSurroundDecoder->upmixType;
515
516 FDK_ASSERT(pMpegSurroundDecoder != NULL);
517
518 SPATIAL_SPECIFIC_CONFIG *const pSSCinput =
519 &pMpegSurroundDecoder->spatialSpecificConfigBackup;
520 SPATIAL_SPECIFIC_CONFIG *const pSSCtarget =
521 &pMpegSurroundDecoder
522 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
523 initFlagsDec =
524 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode];
525
526 if (pSSCinput->coreCodec != AOT_USAC) {
527 /* here we check if we have a valid Ssc */
528 err = sscParseCheck(pSSCinput);
529 if (err != MPS_OK) goto bail;
530 }
531
532 /* here we check if Ssc matches build; also check UParams and DecConfig */
533 /* if desired upmixType is changes */
534 err = check_UParam_Build_DecConfig(
535 &pMpegSurroundDecoder->mpegSurroundUserParams,
536 &pMpegSurroundDecoder->decConfig, pSSCinput,
537 &pMpegSurroundDecoder->upmixType);
538 if (err != MPS_OK) goto bail;
539
540 /* init config */
541 if (initFlagsDec & MPEGS_INIT_CHANGE_HEADER) {
542 initFlags |= MPEGS_INIT_CONFIG;
543 }
544 /* init all states */
545 if (initFlagsDec & MPEGS_INIT_CLEAR_HISTORY) {
546 initFlags |= MASK_MPEGS_INIT_ALL_STATES;
547 }
548 if (initFlagsDec & MPEGS_INIT_CHANGE_CONCEAL_PARAMS) {
549 initFlags |= MPEGS_INIT_PARAMS_ERROR_CONCEALMENT;
550 }
551
552 if (initFlagsDec & MPEGS_INIT_ENFORCE_REINIT) {
553 /* init all states */
554 initFlags |= MASK_MPEGS_INIT_ALL_STATES;
555 initFlags |= MASK_MPEGS_INIT_ALL_PARAMS;
556 } else {
557 /* analyse states which have to be initialized */
558 mpegSurroundDecoder_CalcInitFlags(
559 pSSCtarget, pSSCinput,
560 (upmixTypeCurr !=
561 pMpegSurroundDecoder->upmixType), /* upmixType changed */
562 0, (initFlagsDec & MPEGS_INIT_CHANGE_PARTIALLY_COMPLEX) ? 1 : 0,
563 &initFlags);
564 }
565
566 {
567 int nrOfQmfBands;
568 FDKmemcpy(pSSCtarget, pSSCinput, sizeof(SPATIAL_SPECIFIC_CONFIG));
569
570 nrOfQmfBands = mpegSurroundDecoder_GetNrOfQmfBands(
571 pSSCtarget, pSSCtarget->samplingFreq);
572 err = FDK_SpatialDecInit(
573 pMpegSurroundDecoder->pSpatialDec,
574 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode],
575 pSSCtarget, nrOfQmfBands, pMpegSurroundDecoder->upmixType,
576 &pMpegSurroundDecoder->mpegSurroundUserParams, initFlags);
577
578 if (err != MPS_OK) goto bail;
579
580 /* Signal that we got a header and can go on decoding */
581 if (err == MPS_OK) {
582 initFlagsDec = MPEGS_INIT_OK;
583 {
584 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
585 MPEGS_SYNC_FOUND;
586 }
587 }
588 }
589
590 bail:
591 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] =
592 initFlagsDec;
593 return err;
594 }
595
596 /**
597 * \brief Init MPEG Surround decoder.
598 **/
mpegSurroundDecoder_Init(CMpegSurroundDecoder * pMpegSurroundDecoder)599 SACDEC_ERROR mpegSurroundDecoder_Init(
600 CMpegSurroundDecoder *pMpegSurroundDecoder) {
601 SACDEC_ERROR err = MPS_OK;
602
603 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
604 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
605 }
606 return err;
607 }
608
609 /**
610 * \brief Open MPEG Surround decoder.
611 **/
mpegSurroundDecoder_Create(CMpegSurroundDecoder ** pMpegSurroundDecoder,int stereoConfigIndex,HANDLE_FDK_QMF_DOMAIN pQmfDomain)612 static SACDEC_ERROR mpegSurroundDecoder_Create(
613 CMpegSurroundDecoder **pMpegSurroundDecoder, int stereoConfigIndex,
614 HANDLE_FDK_QMF_DOMAIN pQmfDomain) {
615 SACDEC_ERROR err = MPS_OK;
616 CMpegSurroundDecoder *sacDec = NULL;
617 spatialDec *self = NULL;
618
619 /* decoderLevel decoderMode maxNumOutputChannels binauralMode */
620 static const SPATIAL_DEC_CONFIG decConfig = {
621 (CFG_LEVEL)(0), EXT_HQ_ONLY, OUTPUT_CHANNELS_DEFAULT, BINAURAL_NONE};
622
623 if (*pMpegSurroundDecoder == NULL) {
624 FDK_ALLOCATE_MEMORY_1D(*pMpegSurroundDecoder, 1, CMpegSurroundDecoder)
625
626 for (int i = 0; i < 1; i++) {
627 err = SpatialDecCreateBsFrame(&(*pMpegSurroundDecoder)->bsFrames[i],
628 &(*pMpegSurroundDecoder)->llState);
629 if (err != MPS_OK) {
630 sacDec = *pMpegSurroundDecoder;
631 goto bail;
632 }
633 }
634 (*pMpegSurroundDecoder)->pQmfDomain = pQmfDomain;
635
636 (*pMpegSurroundDecoder)->bsFrameDelay = 1;
637 (*pMpegSurroundDecoder)->bsFrameParse = 0;
638 (*pMpegSurroundDecoder)->bsFrameDecode = 0;
639
640 return err;
641 } else {
642 sacDec = *pMpegSurroundDecoder;
643 }
644
645 if (sacDec->pSpatialDec == NULL) {
646 if ((self = FDK_SpatialDecOpen(&decConfig, stereoConfigIndex)) == NULL) {
647 err = MPS_OUTOFMEMORY;
648 goto bail;
649 }
650 } else {
651 self = sacDec->pSpatialDec;
652 }
653
654 self->pQmfDomain = sacDec->pQmfDomain;
655
656 sacDec->pSpatialDec = self;
657
658 /* default parameter set */
659 sacDec->mpegSurroundUserParams.outputMode = SACDEC_OUT_MODE_NORMAL;
660 sacDec->mpegSurroundUserParams.blindEnable = 0;
661 sacDec->mpegSurroundUserParams.bypassMode = 0;
662 sacDec->mpegSurroundUserParams.concealMethod = 1;
663 sacDec->mpegSurroundUserParams.concealNumKeepFrames = 10;
664 sacDec->mpegSurroundUserParams.concealFadeOutSlopeLength = 5;
665 sacDec->mpegSurroundUserParams.concealFadeInSlopeLength = 5;
666 sacDec->mpegSurroundUserParams.concealNumReleaseFrames = 3;
667 sacDec->mpegSurroundSscIsGlobalCfg = 0;
668 sacDec->mpegSurroundUseTimeInterface = 1;
669 sacDec->mpegSurroundDecoderLevel = decConfig.decoderLevel;
670
671 sacDec->upmixType = UPMIX_TYPE_NORMAL;
672
673 /* signalize spatial decoder re-initalization */
674 updateMpegSurroundDecoderStatus(sacDec, MPEGS_INIT_ENFORCE_REINIT,
675 MPEGS_SYNC_LOST, MPEGS_STOP);
676
677 /* return decoder instance */
678 *pMpegSurroundDecoder = sacDec;
679 sacDec->decConfig = decConfig;
680
681 SpatialDecInitParserContext(sacDec->pSpatialDec);
682
683 return err;
684
685 bail:
686 if (sacDec != NULL) {
687 mpegSurroundDecoder_Close(sacDec);
688 }
689 *pMpegSurroundDecoder = NULL;
690 if (err == MPS_OK) {
691 return MPS_OUTOFMEMORY;
692 } else {
693 return err;
694 }
695 }
696
697 /**
698 * \brief Config MPEG Surround decoder.
699 **/
mpegSurroundDecoder_Config(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,AUDIO_OBJECT_TYPE coreCodec,INT samplingRate,INT frameSize,INT numChannels,INT stereoConfigIndex,INT coreSbrFrameLengthIndex,INT configBytes,const UCHAR configMode,UCHAR * configChanged)700 SACDEC_ERROR mpegSurroundDecoder_Config(
701 CMpegSurroundDecoder *pMpegSurroundDecoder, HANDLE_FDK_BITSTREAM hBs,
702 AUDIO_OBJECT_TYPE coreCodec, INT samplingRate, INT frameSize,
703 INT numChannels, INT stereoConfigIndex, INT coreSbrFrameLengthIndex,
704 INT configBytes, const UCHAR configMode, UCHAR *configChanged) {
705 SACDEC_ERROR err = MPS_OK;
706 INT nInputChannels;
707 SPATIAL_SPECIFIC_CONFIG spatialSpecificConfig;
708 SPATIAL_SPECIFIC_CONFIG *pSsc =
709 &pMpegSurroundDecoder->spatialSpecificConfigBackup;
710
711 switch (coreCodec) {
712 case AOT_DRM_USAC:
713 case AOT_USAC:
714 if (configMode == AC_CM_DET_CFG_CHANGE) {
715 /* In config detection mode write spatial specific config parameters
716 * into temporarily allocated structure */
717 err = SpatialDecParseMps212Config(
718 hBs, &spatialSpecificConfig, samplingRate, coreCodec,
719 stereoConfigIndex, coreSbrFrameLengthIndex);
720 nInputChannels = spatialSpecificConfig.nInputChannels;
721 pSsc = &spatialSpecificConfig;
722 } else {
723 err = SpatialDecParseMps212Config(
724 hBs, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
725 samplingRate, coreCodec, stereoConfigIndex,
726 coreSbrFrameLengthIndex);
727 nInputChannels =
728 pMpegSurroundDecoder->spatialSpecificConfigBackup.nInputChannels;
729 }
730 if ((err == MPS_OK) && (numChannels != nInputChannels)) {
731 err = MPS_PARSE_ERROR;
732 }
733 break;
734 case AOT_ER_AAC_ELD:
735 case AOT_ER_AAC_LD:
736 if (configMode == AC_CM_DET_CFG_CHANGE) {
737 /* In config detection mode write spatial specific config parameters
738 * into temporarily allocated structure */
739 err = SpatialDecParseSpecificConfig(hBs, &spatialSpecificConfig,
740 configBytes, coreCodec);
741 nInputChannels = spatialSpecificConfig.nInputChannels;
742 pSsc = &spatialSpecificConfig;
743 } else {
744 err = SpatialDecParseSpecificConfig(
745 hBs, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
746 configBytes, coreCodec);
747 nInputChannels =
748 pMpegSurroundDecoder->spatialSpecificConfigBackup.nInputChannels;
749 }
750 /* check number of channels for channel_configuration > 0 */
751 if ((err == MPS_OK) && (numChannels > 0) &&
752 (numChannels != nInputChannels)) {
753 err = MPS_PARSE_ERROR;
754 }
755 break;
756 default:
757 err = MPS_UNSUPPORTED_FORMAT;
758 break;
759 }
760
761 if (err != MPS_OK) {
762 goto bail;
763 }
764
765 err = sscCheckOutOfBand(pSsc, coreCodec, samplingRate, frameSize);
766
767 if (err != MPS_OK) {
768 goto bail;
769 }
770
771 if (configMode & AC_CM_DET_CFG_CHANGE) {
772 return err;
773 }
774
775 if (configMode & AC_CM_ALLOC_MEM) {
776 if (*configChanged) {
777 err = mpegSurroundDecoder_Open(&pMpegSurroundDecoder, stereoConfigIndex,
778 NULL);
779 if (err) {
780 return err;
781 }
782 }
783 }
784
785 {
786 SPATIAL_SPECIFIC_CONFIG *sscParse =
787 &pMpegSurroundDecoder
788 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
789
790 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
791 &pMpegSurroundDecoder->spatialSpecificConfigBackup, sscParse)) {
792 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameParse] |=
793 MPEGS_INIT_CHANGE_HEADER;
794 /* Error resilience code */
795 if (pMpegSurroundDecoder->pSpatialDec == NULL) {
796 err = MPS_NOTOK;
797 goto bail;
798 }
799 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
800 pMpegSurroundDecoder->pSpatialDec->pConfigCurrent =
801 &pMpegSurroundDecoder
802 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
803 }
804 }
805
806 if (err == MPS_OK) {
807 /* We got a valid out-of-band configuration so label it accordingly. */
808 pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg = 1;
809 }
810
811 bail:
812 return err;
813 }
814
815 /**
816 * \brief Determine MPEG Surround operation mode.
817 **/
mpegSurroundOperationMode(CMpegSurroundDecoder * pMpegSurroundDecoder,int mpsDataBits)818 static MPEGS_OPMODE mpegSurroundOperationMode(
819 CMpegSurroundDecoder *pMpegSurroundDecoder, int mpsDataBits) {
820 MPEGS_OPMODE mode;
821
822 {
823 if ((mpsDataBits > 0) &&
824 (pMpegSurroundDecoder->mpegSurroundUserParams.blindEnable == 0)) {
825 mode = MPEGS_OPMODE_MPS_PAYLOAD; /* Mode: Normal, Stereo or Binaural */
826 } else {
827 mode = MPEGS_OPMODE_NO_MPS_PAYLOAD; /* Mode: No MPEG Surround Payload */
828 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
829 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
830 MPEGS_STOP);
831 }
832 }
833
834 return (mode);
835 }
836
837 /**
838 * \brief Check ssc for parse errors.
839 * This one is called in initMpegSurroundDecoder()
840 * to ensure checking of inband and out-of-band mps configs.
841 * Only parse errors checked here! Check for valid config is done
842 * in check_UParam_Build_DecConfig()!
843 *
844 * \param pSsc spatial specific config handle.
845 *
846 * \return MPS_OK on sucess, and else on parse error.
847 */
sscParseCheck(const SPATIAL_SPECIFIC_CONFIG * pSsc)848 static SACDEC_ERROR sscParseCheck(const SPATIAL_SPECIFIC_CONFIG *pSsc) {
849 if (pSsc->samplingFreq > 96000) return MPS_PARSE_ERROR;
850 if (pSsc->samplingFreq < 8000) return MPS_PARSE_ERROR;
851
852 if ((pSsc->treeConfig < 0) || (pSsc->treeConfig > 7)) {
853 return MPS_PARSE_ERROR;
854 }
855
856 if ((pSsc->quantMode < 0) || (pSsc->quantMode > 2)) {
857 return MPS_PARSE_ERROR;
858 }
859
860 /* now we are sure there were no parsing errors */
861
862 return MPS_OK;
863 }
864
865 /**
866 * \brief Check number of time slots
867 *
868 * Basically the mps frame length must be a multiple of the core coder frame
869 * length. The below table shows all valid configurations in detail. See ISO/IEC
870 * 23003-1: "Table 4A - Allowed values for bsFrameLength in the Baseline MPEG
871 * Surround Profile"
872 *
873 * Downmix Coder Downmix Code Allowed values for bsFrameLength
874 * Allowed frame sizes for normal, downsampled and upsampled MPS Framelength
875 * (QMF Samples)
876 *
877 * AAC 1024 16 15, 31, 47, 63 1024 2048 3072 4096
878 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
879 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
880 * 5120 6144 7168 8192 9216
881 *
882 * AAC 960 15 14, 29, 44, 59 960 1920 2880 3840
883 * downsampled MPS 30 29, 59 960 1920 upsampled MPS
884 * 7,5 14, 29, 44, 59 1920 3840 5760 7680
885 *
886 * HE-AAC 1024/2048 32 31, 63 2048 4096 downsampled MPS
887 * 64 63 2048 upsampled MPS
888 * 16 15, 31, 47, 63 2048 4096 6144 8192
889 *
890 * HE-AAC 960/1920 30 29, 59 1920 3840 downsampled MPS
891 * 60 59 1920 upsampled MPS
892 * 15 14, 29, 44, 59 1920 3840 5760 7680
893 *
894 * BSAC 16 15, 31, 47, 63 1024 2048 3072 4096
895 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
896 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
897 * 5120 6144 7168 8192 9216
898 *
899 * BSAC with SBR 32 31, 63 2048 4096 downsampled MPS
900 * 64 63 2048 upsampled MPS
901 * 16 15, 31, 47, 63 2048 4096 6144 8192
902 *
903 * AAC LD 512 8 7, 15, 23, 31, 39, 47, 55, 63, 71
904 * 512 1024 1536 2048 2560 3072 3584 4096 4608 downsampled MPS
905 * 16 15, 31, 47, 63 512 1024 1536 2048
906 *
907 * AAC ELD 512 8 7, 15, 23, 31, 39, 47, 55, 63, 71
908 * 512 1024 1536 2048 2560 3072 3584 4096 4608 downsampled MPS
909 * 16 15, 31, 47, 63 512 1024 1536 2048
910 *
911 * AAC ELD with SBR 512/1024 16 15, 31, 47, 63 1024 2048 3072 4096
912 * downsampled MPS 32 31, 63 1024 2048 upsampled MPS
913 * 8 7, 15, 23, 31, 39, 47, 55, 63, 71 1024 2048 3072 4096
914 * 5120 6144 7168 8192 9216
915 *
916 * MPEG1/2 Layer II 18 17, 35, 53, 71 1152 2304 3456 4608
917 * downsampled MPS 36 35, 71 1152 2304
918 *
919 * MPEG1/2 Layer III 18 17, 35, 53, 71 1152 2304 3456 4608
920 * downsampled MPS 36 35, 71 1152 2304
921 *
922 * \param frameLength
923 * \param qmfBands
924 * \param timeSlots
925 *
926 * \return error code
927 */
checkTimeSlots(int frameLength,int qmfBands,int timeSlots)928 SACDEC_ERROR checkTimeSlots(int frameLength, int qmfBands, int timeSlots) {
929 int len;
930 int maxFrameLength;
931
932 if (qmfBands == 64) {
933 /* normal MPEG Surround */
934 switch (frameLength) {
935 case 960:
936 case 1920:
937 maxFrameLength = 3840;
938 break;
939 case 1024:
940 case 2048:
941 maxFrameLength = 4096;
942 break;
943 case 512:
944 case 1152:
945 maxFrameLength = 4608;
946 break;
947 default:
948 return MPS_PARSE_ERROR;
949 }
950 } else if (qmfBands == 32) {
951 /* downsampled MPEG Surround */
952 switch (frameLength) {
953 case 960:
954 case 1920:
955 maxFrameLength = 1920;
956 break;
957 case 512:
958 case 1024:
959 case 2048:
960 maxFrameLength = 2048;
961 break;
962 case 1152:
963 maxFrameLength = 2304;
964 break;
965 default:
966 return MPS_PARSE_ERROR;
967 }
968 } else if (qmfBands == 128) {
969 /* upsampled MPEG Surround */
970 switch (frameLength) {
971 case 1920:
972 maxFrameLength = 7680;
973 break;
974 case 1024:
975 maxFrameLength = 9216;
976 break;
977 case 2048:
978 maxFrameLength = 8192;
979 break;
980 case 512:
981 case 960:
982 case 1152:
983 /* no break, no support for upsampled MPEG Surround */
984 default:
985 return MPS_PARSE_ERROR;
986 }
987 } else {
988 return MPS_PARSE_ERROR;
989 }
990
991 len = frameLength;
992
993 while (len <= maxFrameLength) {
994 if (len == timeSlots * qmfBands) {
995 return MPS_OK;
996 }
997 len += frameLength;
998 }
999 return MPS_PARSE_ERROR;
1000 }
1001
1002 /**
1003 * \brief Check ssc for consistency (e.g. bit errors could cause trouble)
1004 * First of currently two ssc-checks.
1005 * This (old) one is called in mpegSurroundDecoder_Apply()
1006 * only if inband mps config is contained in stream.
1007 *
1008 * New ssc check is split in two functions sscParseCheck() and
1009 * check_UParam_Build_DecConfig(). sscParseCheck() checks only for correct
1010 * parsing. check_UParam_Build_DecConfig() is used to check if we have a
1011 * valid config. Both are called in initMpegSurroundDecoder() to ensure
1012 * checking of inband and out-of-band mps configs.
1013 *
1014 * If this function can be integrated into the new functions.
1015 * We can remove this one.
1016 *
1017 * \param pSsc spatial specific config handle.
1018 * \param frameLength
1019 * \param sampleRate
1020 *
1021 * \return MPS_OK on sucess, and else on failure.
1022 */
sscCheckInBand(SPATIAL_SPECIFIC_CONFIG * pSsc,int frameLength,int sampleRate)1023 static SACDEC_ERROR sscCheckInBand(SPATIAL_SPECIFIC_CONFIG *pSsc,
1024 int frameLength, int sampleRate) {
1025 SACDEC_ERROR err = MPS_OK;
1026 int qmfBands;
1027
1028 FDK_ASSERT(pSsc != NULL);
1029
1030 /* check ssc for parse errors */
1031 if (sscParseCheck(pSsc) != MPS_OK) {
1032 err = MPS_PARSE_ERROR;
1033 }
1034
1035 /* core fs and mps fs must match */
1036 if (pSsc->samplingFreq != sampleRate) {
1037 err = MPS_PARSE_ERROR /* MPEGSDEC_SSC_PARSE_ERROR */;
1038 }
1039
1040 qmfBands = mpegSurroundDecoder_GetNrOfQmfBands(pSsc, pSsc->samplingFreq);
1041
1042 if (checkTimeSlots(frameLength, qmfBands, pSsc->nTimeSlots) != MPS_OK) {
1043 err = MPS_PARSE_ERROR;
1044 }
1045
1046 return err;
1047 }
1048
1049 SACDEC_ERROR
mpegSurroundDecoder_ConfigureQmfDomain(CMpegSurroundDecoder * pMpegSurroundDecoder,SAC_INPUT_CONFIG sac_dec_interface,UINT coreSamplingRate,AUDIO_OBJECT_TYPE coreCodec)1050 mpegSurroundDecoder_ConfigureQmfDomain(
1051 CMpegSurroundDecoder *pMpegSurroundDecoder,
1052 SAC_INPUT_CONFIG sac_dec_interface, UINT coreSamplingRate,
1053 AUDIO_OBJECT_TYPE coreCodec) {
1054 SACDEC_ERROR err = MPS_OK;
1055 FDK_QMF_DOMAIN_GC *pGC = NULL;
1056
1057 if (pMpegSurroundDecoder == NULL) {
1058 return MPS_INVALID_HANDLE;
1059 }
1060
1061 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1062
1063 pGC = &pMpegSurroundDecoder->pQmfDomain->globalConf;
1064 if (pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg) {
1065 SPATIAL_SPECIFIC_CONFIG *pSSC =
1066 &pMpegSurroundDecoder->spatialSpecificConfigBackup;
1067 if (sac_dec_interface == SAC_INTERFACE_TIME) {
1068 /* For SAC_INTERFACE_QMF these parameters are set by SBR. */
1069 pGC->nBandsAnalysis_requested = mpegSurroundDecoder_GetNrOfQmfBands(
1070 pSSC, coreSamplingRate); /* coreSamplingRate == outputSamplingRate for
1071 SAC_INTERFACE_TIME */
1072 pGC->nBandsSynthesis_requested = pGC->nBandsAnalysis_requested;
1073 pGC->nInputChannels_requested =
1074 fMax((UINT)pSSC->nInputChannels, (UINT)pGC->nInputChannels_requested);
1075 }
1076 pGC->nOutputChannels_requested =
1077 fMax((UINT)pSSC->nOutputChannels, (UINT)pGC->nOutputChannels_requested);
1078 } else {
1079 if (sac_dec_interface == SAC_INTERFACE_TIME) {
1080 /* For SAC_INTERFACE_QMF these parameters are set by SBR. */
1081 pGC->nBandsAnalysis_requested = mpegSurroundDecoder_GetNrOfQmfBands(
1082 NULL, coreSamplingRate); /* coreSamplingRate == outputSamplingRate for
1083 SAC_INTERFACE_TIME */
1084 pGC->nBandsSynthesis_requested = pGC->nBandsAnalysis_requested;
1085 pGC->nInputChannels_requested =
1086 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumInputChannels;
1087 }
1088 pGC->nOutputChannels_requested =
1089 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumOutputChannels;
1090 }
1091 pGC->nQmfProcBands_requested = 64;
1092 pGC->nQmfProcChannels_requested =
1093 fMin((INT)pGC->nInputChannels_requested,
1094 pMpegSurroundDecoder->pSpatialDec->createParams.maxNumInputChannels);
1095
1096 if (coreCodec == AOT_ER_AAC_ELD) {
1097 pGC->flags_requested |= QMF_FLAG_MPSLDFB;
1098 pGC->flags_requested &= ~QMF_FLAG_CLDFB;
1099 }
1100
1101 return err;
1102 }
1103
1104 /**
1105 * \brief Check out-of-band config
1106 *
1107 * \param pSsc spatial specific config handle.
1108 * \param coreCodec core codec.
1109 * \param sampleRate sampling frequency.
1110 *
1111 * \return errorStatus
1112 */
1113 SACDEC_ERROR
sscCheckOutOfBand(const SPATIAL_SPECIFIC_CONFIG * pSsc,const INT coreCodec,const INT sampleRate,const INT frameSize)1114 sscCheckOutOfBand(const SPATIAL_SPECIFIC_CONFIG *pSsc, const INT coreCodec,
1115 const INT sampleRate, const INT frameSize) {
1116 FDK_ASSERT(pSsc != NULL);
1117 int qmfBands = 0;
1118
1119 /* check ssc for parse errors */
1120 if (sscParseCheck(pSsc) != MPS_OK) {
1121 return MPS_PARSE_ERROR;
1122 }
1123
1124 switch (coreCodec) {
1125 case AOT_USAC:
1126 case AOT_DRM_USAC:
1127 /* ISO/IEC 23003-1:2007(E), Chapter 6.3.3, Support for lower and higher
1128 * sampling frequencies */
1129 if (pSsc->samplingFreq >= 55426) {
1130 return MPS_PARSE_ERROR;
1131 }
1132 break;
1133 case AOT_ER_AAC_LD:
1134 case AOT_ER_AAC_ELD:
1135 /* core fs and mps fs must match */
1136 if (pSsc->samplingFreq != sampleRate) {
1137 return MPS_PARSE_ERROR;
1138 }
1139
1140 /* ISO/IEC 14496-3:2009 FDAM 3: Chapter 1.5.2.3, Levels for the Low Delay
1141 * AAC v2 profile */
1142 if (pSsc->samplingFreq > 48000) {
1143 return MPS_PARSE_ERROR;
1144 }
1145
1146 qmfBands = mpegSurroundDecoder_GetNrOfQmfBands(pSsc, pSsc->samplingFreq);
1147 switch (frameSize) {
1148 case 480:
1149 if (!((qmfBands == 32) && (pSsc->nTimeSlots == 15))) {
1150 return MPS_PARSE_ERROR;
1151 }
1152 break;
1153 case 960:
1154 if (!((qmfBands == 64) && (pSsc->nTimeSlots == 15))) {
1155 return MPS_PARSE_ERROR;
1156 }
1157 break;
1158 case 512:
1159 if (!(((qmfBands == 32) && (pSsc->nTimeSlots == 16)) ||
1160 ((qmfBands == 64) && (pSsc->nTimeSlots == 8)))) {
1161 return MPS_PARSE_ERROR;
1162 }
1163 break;
1164 case 1024:
1165 if (!((qmfBands == 64) && (pSsc->nTimeSlots == 16))) {
1166 return MPS_PARSE_ERROR;
1167 }
1168 break;
1169 default:
1170 return MPS_PARSE_ERROR;
1171 }
1172 break;
1173 default:
1174 return MPS_PARSE_ERROR;
1175 break;
1176 }
1177
1178 return MPS_OK;
1179 }
1180
1181 /**
1182 * \brief Decode MPEG Surround frame.
1183 **/
mpegSurroundDecoder_ParseNoHeader(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,int * pMpsDataBits,int fGlobalIndependencyFlag)1184 int mpegSurroundDecoder_ParseNoHeader(
1185 CMpegSurroundDecoder *pMpegSurroundDecoder, HANDLE_FDK_BITSTREAM hBs,
1186 int *pMpsDataBits, int fGlobalIndependencyFlag) {
1187 SACDEC_ERROR err = MPS_OK;
1188 SPATIAL_SPECIFIC_CONFIG *sscParse;
1189 int bitsAvail, numSacBits;
1190
1191 if (pMpegSurroundDecoder == NULL || hBs == NULL) {
1192 return MPS_INVALID_HANDLE;
1193 }
1194
1195 sscParse = &pMpegSurroundDecoder
1196 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
1197
1198 bitsAvail = FDKgetValidBits(hBs);
1199
1200 /* First spatial specific config is parsed into spatialSpecificConfigBackup,
1201 * second spatialSpecificConfigBackup is copied into
1202 * spatialSpecificConfig[bsFrameDecode] */
1203 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameParse]) {
1204 FDKmemcpy(sscParse, &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1205 sizeof(SPATIAL_SPECIFIC_CONFIG));
1206 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameParse] =
1207 MPEGS_SYNC_FOUND;
1208 }
1209
1210 if (bitsAvail <= 0) {
1211 err = MPS_PARSE_ERROR;
1212 } else {
1213 err = SpatialDecParseFrameData(
1214 pMpegSurroundDecoder->pSpatialDec,
1215 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse],
1216 hBs, sscParse, (UPMIXTYPE)pMpegSurroundDecoder->upmixType,
1217 fGlobalIndependencyFlag);
1218 if (err == MPS_OK) {
1219 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1220 .newBsData = 1;
1221 }
1222 }
1223
1224 numSacBits = bitsAvail - (INT)FDKgetValidBits(hBs);
1225
1226 if (numSacBits > bitsAvail) {
1227 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1228 .newBsData = 0;
1229 err = MPS_PARSE_ERROR;
1230 }
1231
1232 *pMpsDataBits -= numSacBits;
1233
1234 return err;
1235 }
1236
1237 /**
1238 * \brief Check, if ancType is valid.
1239 **/
isValidAncType(CMpegSurroundDecoder * pMpegSurroundDecoder,int ancType)1240 static int isValidAncType(CMpegSurroundDecoder *pMpegSurroundDecoder,
1241 int ancType) {
1242 int ret = 1;
1243
1244 if ((ancType != MPEGS_ANCTYPE_HEADER_AND_FRAME) &&
1245 (ancType != MPEGS_ANCTYPE_FRAME)) {
1246 ret = 0;
1247 }
1248
1249 if (ret == 0) {
1250 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1251 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1252 MPEGS_STOP);
1253 }
1254
1255 return (ret);
1256 }
1257
1258 /**
1259 * \brief Check, if ancStartStop is valid.
1260 **/
isValidAncStartStop(CMpegSurroundDecoder * pMpegSurroundDecoder,int ancStartStop)1261 static int isValidAncStartStop(CMpegSurroundDecoder *pMpegSurroundDecoder,
1262 int ancStartStop) {
1263 int ret = 1;
1264
1265 switch (ancStartStop) {
1266 case MPEGS_START:
1267 /* Sequence start - start and continue - start not allowed */
1268 if ((pMpegSurroundDecoder->ancStartStopPrev == MPEGS_START) ||
1269 (pMpegSurroundDecoder->ancStartStopPrev == MPEGS_CONTINUE)) {
1270 ret = 0;
1271 }
1272 break;
1273
1274 case MPEGS_STOP:
1275 /* MPS payload of the previous frame must be valid if current type is stop
1276 Sequence startstop - stop and stop - stop not allowed
1277 Sequence startstop - continue and stop - continue are allowed */
1278 if ((pMpegSurroundDecoder->ancStartStopPrev == MPEGS_STOP) ||
1279 (pMpegSurroundDecoder->ancStartStopPrev == MPEGS_START_STOP)) {
1280 ret = 0;
1281 }
1282 break;
1283
1284 case MPEGS_CONTINUE:
1285 case MPEGS_START_STOP:
1286 /* No error detection possible for this states */
1287 break;
1288 }
1289
1290 if (ret == 0) {
1291 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1292 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1293 MPEGS_STOP);
1294 } else {
1295 pMpegSurroundDecoder->ancStartStopPrev = (MPEGS_ANCSTARTSTOP)ancStartStop;
1296 }
1297
1298 return (ret);
1299 }
1300
mpegSurroundDecoder_Parse(CMpegSurroundDecoder * pMpegSurroundDecoder,HANDLE_FDK_BITSTREAM hBs,int * pMpsDataBits,AUDIO_OBJECT_TYPE coreCodec,int sampleRate,int frameSize,int fGlobalIndependencyFlag)1301 int mpegSurroundDecoder_Parse(CMpegSurroundDecoder *pMpegSurroundDecoder,
1302 HANDLE_FDK_BITSTREAM hBs, int *pMpsDataBits,
1303 AUDIO_OBJECT_TYPE coreCodec, int sampleRate,
1304 int frameSize, int fGlobalIndependencyFlag) {
1305 SACDEC_ERROR err = MPS_OK;
1306 SPATIAL_SPECIFIC_CONFIG *sscParse;
1307 SPATIAL_BS_FRAME *bsFrame;
1308 HANDLE_FDK_BITSTREAM hMpsBsData = NULL;
1309 FDK_BITSTREAM mpsBsData;
1310 int mpsDataBits = *pMpsDataBits;
1311 int mpsBsBits;
1312 MPEGS_ANCTYPE ancType;
1313 MPEGS_ANCSTARTSTOP ancStartStop;
1314
1315 if (pMpegSurroundDecoder == NULL) {
1316 return MPS_INVALID_HANDLE;
1317 }
1318
1319 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1320
1321 mpsBsBits = (INT)FDKgetValidBits(hBs);
1322
1323 sscParse = &pMpegSurroundDecoder
1324 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameParse];
1325 bsFrame = &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse];
1326
1327 /*
1328 Find operation mode of mpeg surround decoder:
1329 - MPEGS_OPMODE_EMM: Mode: Enhanced Matrix Mode (Blind)
1330 - MPEGS_OPMODE_MPS_PAYLOAD: Mode: Normal, Stereo or Binaural
1331 - MPEGS_OPMODE_NO_MPS_PAYLOAD: Mode: No MpegSurround Payload
1332 */
1333 {
1334 /* Parse ancType and ancStartStop */
1335 ancType = (MPEGS_ANCTYPE)FDKreadBits(hBs, 2);
1336 ancStartStop = (MPEGS_ANCSTARTSTOP)FDKreadBits(hBs, 2);
1337 mpsDataBits -= 4;
1338
1339 /* Set valid anc type flag, if ancType signals a payload with either header
1340 * and frame or frame */
1341 if (isValidAncType(pMpegSurroundDecoder, ancType)) {
1342 /* Set valid anc startstop flag, if transmitted sequence is not illegal */
1343 if (isValidAncStartStop(pMpegSurroundDecoder, ancStartStop)) {
1344 switch (ancStartStop) {
1345 case MPEGS_START:
1346 /* Assuming that core coder frame size (AAC) is smaller than MPS
1347 coder frame size. Save audio data for next frame. */
1348 if (mpsDataBits > MPS_DATA_BUFFER_SIZE * 8) {
1349 err = MPS_NOTOK;
1350 goto bail;
1351 }
1352 for (int i = 0; i < mpsDataBits / 8; i++) {
1353 pMpegSurroundDecoder->mpsData[i] = FDKreadBits(hBs, 8);
1354 }
1355 pMpegSurroundDecoder->mpsDataBits = mpsDataBits;
1356 break;
1357
1358 case MPEGS_CONTINUE:
1359 case MPEGS_STOP:
1360 /* Assuming that core coder frame size (AAC) is smaller than MPS
1361 coder frame size. Save audio data for next frame. */
1362 if ((pMpegSurroundDecoder->mpsDataBits + mpsDataBits) >
1363 MPS_DATA_BUFFER_SIZE * 8) {
1364 err = MPS_NOTOK;
1365 goto bail;
1366 }
1367 for (int i = 0; i < mpsDataBits / 8; i++) {
1368 pMpegSurroundDecoder
1369 ->mpsData[(pMpegSurroundDecoder->mpsDataBits / 8) + i] =
1370 FDKreadBits(hBs, 8);
1371 }
1372 pMpegSurroundDecoder->mpsDataBits += mpsDataBits;
1373 FDKinitBitStream(&mpsBsData, pMpegSurroundDecoder->mpsData,
1374 MAX_BUFSIZE_BYTES,
1375 pMpegSurroundDecoder->mpsDataBits, BS_READER);
1376 hMpsBsData = &mpsBsData;
1377 break;
1378
1379 case MPEGS_START_STOP:
1380 pMpegSurroundDecoder->mpsDataBits = mpsDataBits;
1381 hMpsBsData = hBs;
1382 break;
1383
1384 default:
1385 FDK_ASSERT(0);
1386 }
1387
1388 if ((ancStartStop == MPEGS_STOP) ||
1389 (ancStartStop == MPEGS_START_STOP)) {
1390 switch (ancType) {
1391 case MPEGS_ANCTYPE_HEADER_AND_FRAME: {
1392 int parseResult, bitsRead;
1393 SPATIAL_SPECIFIC_CONFIG spatialSpecificConfigTmp =
1394 pMpegSurroundDecoder->spatialSpecificConfigBackup;
1395
1396 /* Parse spatial specific config */
1397 bitsRead = (INT)FDKgetValidBits(hMpsBsData);
1398
1399 err = SpatialDecParseSpecificConfigHeader(
1400 hMpsBsData,
1401 &pMpegSurroundDecoder->spatialSpecificConfigBackup, coreCodec,
1402 pMpegSurroundDecoder->upmixType);
1403
1404 bitsRead = (bitsRead - (INT)FDKgetValidBits(hMpsBsData));
1405 parseResult = ((err == MPS_OK) ? bitsRead : -bitsRead);
1406
1407 if (parseResult < 0) {
1408 parseResult = -parseResult;
1409 err = MPS_PARSE_ERROR;
1410 } else if (err == MPS_OK) {
1411 /* Check SSC for consistency (e.g. bit errors could cause
1412 * trouble) */
1413 err = sscCheckInBand(
1414 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1415 frameSize, sampleRate);
1416 }
1417 if (err != MPS_OK) {
1418 pMpegSurroundDecoder->spatialSpecificConfigBackup =
1419 spatialSpecificConfigTmp;
1420 break;
1421 }
1422
1423 pMpegSurroundDecoder->mpsDataBits -= parseResult;
1424
1425 /* Initiate re-initialization, if header has changed */
1426 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
1427 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1428 sscParse) == MPS_UNEQUAL_SSC) {
1429 pMpegSurroundDecoder
1430 ->initFlags[pMpegSurroundDecoder->bsFrameParse] |=
1431 MPEGS_INIT_CHANGE_HEADER;
1432 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
1433 /* We found a valid in-band configuration. Therefore any
1434 * previous config is invalid now. */
1435 pMpegSurroundDecoder->mpegSurroundSscIsGlobalCfg = 0;
1436 }
1437 }
1438 FDK_FALLTHROUGH;
1439 case MPEGS_ANCTYPE_FRAME:
1440
1441 if (pMpegSurroundDecoder
1442 ->initFlags[pMpegSurroundDecoder->bsFrameParse] &
1443 MPEGS_INIT_ERROR_PAYLOAD) {
1444 err = MPS_PARSE_ERROR;
1445 break;
1446 }
1447
1448 /* First spatial specific config is parsed into
1449 * spatialSpecificConfigBackup, second spatialSpecificConfigBackup
1450 * is copied into spatialSpecificConfig[bsFrameDecode] */
1451 if (pMpegSurroundDecoder
1452 ->initFlags[pMpegSurroundDecoder->bsFrameParse]) {
1453 FDKmemcpy(sscParse,
1454 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1455 sizeof(SPATIAL_SPECIFIC_CONFIG));
1456 pMpegSurroundDecoder
1457 ->fOnSync[pMpegSurroundDecoder->bsFrameParse] =
1458 MPEGS_SYNC_FOUND;
1459 }
1460
1461 if (pMpegSurroundDecoder
1462 ->fOnSync[pMpegSurroundDecoder->bsFrameParse] >=
1463 MPEGS_SYNC_FOUND) {
1464 int nbits = 0, bitsAvail;
1465
1466 if (err != MPS_OK) {
1467 break;
1468 }
1469
1470 bitsAvail = FDKgetValidBits(hMpsBsData);
1471
1472 if (bitsAvail <= 0) {
1473 err = MPS_PARSE_ERROR;
1474 } else {
1475 err = SpatialDecParseFrameData(
1476 pMpegSurroundDecoder->pSpatialDec, bsFrame, hMpsBsData,
1477 sscParse, (UPMIXTYPE)pMpegSurroundDecoder->upmixType,
1478 fGlobalIndependencyFlag);
1479 if (err == MPS_OK) {
1480 bsFrame->newBsData = 1;
1481 }
1482 }
1483
1484 nbits = bitsAvail - (INT)FDKgetValidBits(hMpsBsData);
1485
1486 if ((nbits > bitsAvail) ||
1487 (nbits > pMpegSurroundDecoder->mpsDataBits) ||
1488 (pMpegSurroundDecoder->mpsDataBits > nbits + 7 &&
1489 !IS_LOWDELAY(coreCodec))) {
1490 bsFrame->newBsData = 0;
1491 err = MPS_PARSE_ERROR;
1492 break;
1493 }
1494 pMpegSurroundDecoder->mpsDataBits -= nbits;
1495 }
1496 break;
1497
1498 default: /* added to avoid compiler warning */
1499 err = MPS_NOTOK;
1500 break; /* added to avoid compiler warning */
1501 } /* switch (ancType) */
1502
1503 if (err == MPS_OK) {
1504 pMpegSurroundDecoder->ancStartStopPrev = ancStartStop;
1505 } else {
1506 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1507 MPEGS_INIT_ERROR_PAYLOAD,
1508 MPEGS_SYNC_LOST, MPEGS_STOP);
1509 pMpegSurroundDecoder->mpsDataBits = 0;
1510 }
1511 } /* (ancStartStop == MPEGS_STOP) || (ancStartStop == MPEGS_START_STOP)
1512 */
1513 } /* validAncStartStop */
1514 } /* validAncType */
1515 }
1516
1517 bail:
1518
1519 *pMpsDataBits -= (mpsBsBits - (INT)FDKgetValidBits(hBs));
1520
1521 return err;
1522 }
1523
mpegSurroundDecoder_Apply(CMpegSurroundDecoder * pMpegSurroundDecoder,PCM_MPS * 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,const INT inDataHeadroom,INT * outDataHeadroom)1524 int mpegSurroundDecoder_Apply(CMpegSurroundDecoder *pMpegSurroundDecoder,
1525 PCM_MPS *input, PCM_MPS *pTimeData,
1526 const int timeDataSize, int timeDataFrameSize,
1527 int *nChannels, int *frameSize, int sampleRate,
1528 AUDIO_OBJECT_TYPE coreCodec,
1529 AUDIO_CHANNEL_TYPE channelType[],
1530 UCHAR channelIndices[],
1531 const FDK_channelMapDescr *const mapDescr,
1532 const INT inDataHeadroom, INT *outDataHeadroom) {
1533 SACDEC_ERROR err = MPS_OK;
1534 PCM_MPS *pTimeOut = pTimeData;
1535 PCM_MPS *TDinput = NULL;
1536 UINT initControlFlags = 0, controlFlags = 0;
1537 int timeDataRequiredSize = 0;
1538 int newData;
1539
1540 if (pMpegSurroundDecoder == NULL) {
1541 return MPS_INVALID_HANDLE;
1542 }
1543
1544 FDK_ASSERT(pMpegSurroundDecoder->pSpatialDec);
1545
1546 if (!FDK_chMapDescr_isValid(mapDescr)) {
1547 return MPS_INVALID_HANDLE;
1548 }
1549
1550 if ((*nChannels <= 0) || (*nChannels > 2)) {
1551 return MPS_NOTOK;
1552 }
1553
1554 pMpegSurroundDecoder->pSpatialDec->sacInDataHeadroom = inDataHeadroom;
1555 *outDataHeadroom = (INT)(8);
1556
1557 pMpegSurroundDecoder->pSpatialDec->pConfigCurrent =
1558 &pMpegSurroundDecoder
1559 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
1560 newData = pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameParse]
1561 .newBsData;
1562
1563 switch (mpegSurroundOperationMode(pMpegSurroundDecoder, 1000)) {
1564 case MPEGS_OPMODE_MPS_PAYLOAD:
1565 if (pMpegSurroundDecoder
1566 ->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
1567 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
1568 }
1569
1570 if (err == MPS_OK) {
1571 if ((pMpegSurroundDecoder
1572 ->fOnSync[pMpegSurroundDecoder->bsFrameDecode] !=
1573 MPEGS_SYNC_COMPLETE) &&
1574 (pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode]
1575 .bsIndependencyFlag == 1)) {
1576 /* We got a valid header and independently decodeable frame data.
1577 -> Go to the next sync level and start processing. */
1578 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1579 MPEGS_SYNC_COMPLETE;
1580 }
1581 } else {
1582 /* We got a valid config header but found an error while parsing the
1583 bitstream. Wait for the next independent frame and apply error
1584 conealment in the meantime. */
1585 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1586 MPEGS_SYNC_FOUND;
1587 controlFlags |= MPEGS_CONCEAL;
1588 err = MPS_OK;
1589 }
1590 /*
1591 Concealment:
1592 - Bitstream is available, no sync found during bitstream processing
1593 - Bitstream is available, sync lost due to corrupted bitstream
1594 - Bitstream is available, sync found but no independent frame
1595 */
1596 if (pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] !=
1597 MPEGS_SYNC_COMPLETE) {
1598 controlFlags |= MPEGS_CONCEAL;
1599 }
1600 break;
1601
1602 case MPEGS_OPMODE_NO_MPS_PAYLOAD:
1603 /* Concealment: No bitstream is available */
1604 controlFlags |= MPEGS_CONCEAL;
1605 break;
1606
1607 default:
1608 err = MPS_NOTOK;
1609 }
1610
1611 if (err != MPS_OK) {
1612 goto bail;
1613 }
1614
1615 /*
1616 * Force BypassMode if choosen by user
1617 */
1618 if (pMpegSurroundDecoder->mpegSurroundUserParams.bypassMode) {
1619 controlFlags |= MPEGS_BYPASSMODE;
1620 }
1621
1622 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode]) {
1623 int startWithDfltCfg = 0;
1624 /*
1625 * Init with a default configuration if we came here and are still not
1626 * initialized.
1627 */
1628 if (pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] &
1629 MPEGS_INIT_ENFORCE_REINIT) {
1630 /* Get default spatial specific config */
1631 if (FDK_SpatialDecInitDefaultSpatialSpecificConfig(
1632 &pMpegSurroundDecoder->spatialSpecificConfigBackup, coreCodec,
1633 *nChannels, sampleRate,
1634 *frameSize /
1635 mpegSurroundDecoder_GetNrOfQmfBands(NULL, sampleRate),
1636 pMpegSurroundDecoder->mpegSurroundDecoderLevel,
1637 pMpegSurroundDecoder->mpegSurroundUserParams.blindEnable)) {
1638 err = MPS_NOTOK;
1639 goto bail;
1640 }
1641
1642 /* Initiate re-initialization, if header has changed */
1643 if (FDK_SpatialDecCompareSpatialSpecificConfigHeader(
1644 &pMpegSurroundDecoder->spatialSpecificConfigBackup,
1645 &pMpegSurroundDecoder->spatialSpecificConfig
1646 [pMpegSurroundDecoder->bsFrameDecode]) == MPS_UNEQUAL_SSC) {
1647 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1648 MPEGS_INIT_CHANGE_HEADER;
1649 SpatialDecInitParserContext(pMpegSurroundDecoder->pSpatialDec);
1650 }
1651
1652 startWithDfltCfg = 1;
1653 }
1654
1655 /* First spatial specific config is parsed into spatialSpecificConfigBackup,
1656 * second spatialSpecificConfigBackup is copied into spatialSpecificConfig
1657 */
1658 err = initMpegSurroundDecoder(pMpegSurroundDecoder);
1659
1660 if (startWithDfltCfg) {
1661 /* initialized with default config, but no sync found */
1662 /* maybe use updateMpegSurroundDecoderStatus later on */
1663 pMpegSurroundDecoder->fOnSync[pMpegSurroundDecoder->bsFrameDecode] =
1664 MPEGS_SYNC_LOST;
1665 }
1666
1667 /* Since we do not have state MPEGS_SYNC_COMPLETE apply concealment */
1668 controlFlags |= MPEGS_CONCEAL;
1669
1670 if (err != MPS_OK) {
1671 goto bail;
1672 }
1673 }
1674
1675 /*
1676 * Process MPEG Surround Audio
1677 */
1678 initControlFlags = controlFlags;
1679
1680 /* Check that provided output buffer is large enough. */
1681 if (pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsAnalysis == 0) {
1682 err = MPS_UNSUPPORTED_FORMAT;
1683 goto bail;
1684 }
1685 timeDataRequiredSize =
1686 (timeDataFrameSize *
1687 pMpegSurroundDecoder->pSpatialDec->numOutputChannelsAT *
1688 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsSynthesis) /
1689 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsAnalysis;
1690 if (timeDataSize < timeDataRequiredSize) {
1691 err = MPS_OUTPUT_BUFFER_TOO_SMALL;
1692 goto bail;
1693 }
1694
1695 if ((pMpegSurroundDecoder->pSpatialDec->pConfigCurrent->syntaxFlags &
1696 SACDEC_SYNTAX_USAC) &&
1697 (pMpegSurroundDecoder->pSpatialDec->stereoConfigIndex > 1)) {
1698 FDK_ASSERT(timeDataRequiredSize >= timeDataFrameSize * *nChannels);
1699 /* Place samples comprising QMF time slots spaced at QMF output Band raster
1700 * to allow slot wise processing */
1701 int timeDataFrameSizeOut =
1702 (timeDataFrameSize *
1703 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsSynthesis) /
1704 pMpegSurroundDecoder->pQmfDomain->globalConf.nBandsAnalysis;
1705 TDinput = pTimeData + timeDataFrameSizeOut - timeDataFrameSize;
1706 for (int i = *nChannels - 1; i >= 0; i--) {
1707 FDKmemmove(pTimeData + (i + 1) * timeDataFrameSizeOut - timeDataFrameSize,
1708 pTimeData + timeDataFrameSize * i,
1709 sizeof(PCM_MPS) * timeDataFrameSize);
1710 FDKmemclear(pTimeData + i * timeDataFrameSizeOut,
1711 sizeof(PCM_MPS) * (timeDataFrameSizeOut - timeDataFrameSize));
1712 }
1713 } else {
1714 if (pMpegSurroundDecoder->mpegSurroundUseTimeInterface) {
1715 FDKmemcpy(input, pTimeData,
1716 sizeof(PCM_MPS) * (*nChannels) * (*frameSize));
1717 TDinput = input;
1718 }
1719 }
1720
1721 /*
1722 * Process MPEG Surround Audio
1723 */
1724 err = SpatialDecApplyFrame(
1725 pMpegSurroundDecoder->pSpatialDec,
1726 &pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode],
1727 pMpegSurroundDecoder->mpegSurroundUseTimeInterface ? INPUTMODE_TIME
1728 : INPUTMODE_QMF_SBR,
1729 TDinput, NULL, NULL, pTimeOut, *frameSize, &controlFlags, *nChannels,
1730 mapDescr);
1731 *nChannels = pMpegSurroundDecoder->pSpatialDec->numOutputChannelsAT;
1732
1733 if (err !=
1734 MPS_OK) { /* A fatal error occured. Go back to start and try again: */
1735 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1736 MPEGS_INIT_ENFORCE_REINIT, MPEGS_SYNC_LOST,
1737 MPEGS_STOP);
1738 *frameSize =
1739 0; /* Declare that framework can not use the data in pTimeOut. */
1740 } else {
1741 if (((controlFlags & MPEGS_CONCEAL) &&
1742 !(initControlFlags & MPEGS_CONCEAL)) ||
1743 (pMpegSurroundDecoder->pSpatialDec->errInt !=
1744 MPS_OK)) { /* Account for errors that occured in
1745 SpatialDecApplyFrame(): */
1746 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1747 MPEGS_INIT_ERROR_PAYLOAD, MPEGS_SYNC_LOST,
1748 MPEGS_STOP);
1749 }
1750 }
1751
1752 if ((err == MPS_OK) && !(controlFlags & MPEGS_BYPASSMODE) &&
1753 !(pMpegSurroundDecoder->upmixType == UPMIX_TYPE_BYPASS)) {
1754 SpatialDecChannelProperties(pMpegSurroundDecoder->pSpatialDec, channelType,
1755 channelIndices, mapDescr);
1756 }
1757
1758 bail:
1759
1760 if (newData) {
1761 /* numParameterSetsPrev shall only be read in the decode process, because of
1762 that we can update this state variable here */
1763 pMpegSurroundDecoder->pSpatialDec->numParameterSetsPrev =
1764 pMpegSurroundDecoder->bsFrames[pMpegSurroundDecoder->bsFrameDecode]
1765 .numParameterSets;
1766 }
1767
1768 return (err);
1769 }
1770
1771 /**
1772 * \brief Free config dependent MPEG Surround memory.
1773 **/
mpegSurroundDecoder_FreeMem(CMpegSurroundDecoder * pMpegSurroundDecoder)1774 SACDEC_ERROR mpegSurroundDecoder_FreeMem(
1775 CMpegSurroundDecoder *pMpegSurroundDecoder) {
1776 SACDEC_ERROR err = MPS_OK;
1777
1778 if (pMpegSurroundDecoder != NULL) {
1779 FDK_SpatialDecClose(pMpegSurroundDecoder->pSpatialDec);
1780 pMpegSurroundDecoder->pSpatialDec = NULL;
1781 }
1782
1783 return err;
1784 }
1785
1786 /**
1787 * \brief Close MPEG Surround decoder.
1788 **/
mpegSurroundDecoder_Close(CMpegSurroundDecoder * pMpegSurroundDecoder)1789 void mpegSurroundDecoder_Close(CMpegSurroundDecoder *pMpegSurroundDecoder) {
1790 if (pMpegSurroundDecoder != NULL) {
1791 FDK_SpatialDecClose(pMpegSurroundDecoder->pSpatialDec);
1792 pMpegSurroundDecoder->pSpatialDec = NULL;
1793
1794 for (int i = 0; i < 1; i++) {
1795 SpatialDecCloseBsFrame(&pMpegSurroundDecoder->bsFrames[i]);
1796 }
1797
1798 FDK_FREE_MEMORY_1D(pMpegSurroundDecoder);
1799 }
1800 }
1801
1802 #define SACDEC_VL0 2
1803 #define SACDEC_VL1 1
1804 #define SACDEC_VL2 0
1805
mpegSurroundDecoder_GetLibInfo(LIB_INFO * info)1806 int mpegSurroundDecoder_GetLibInfo(LIB_INFO *info) {
1807 int i;
1808
1809 if (info == NULL) {
1810 return -1;
1811 }
1812
1813 /* search for next free tab */
1814 for (i = 0; i < FDK_MODULE_LAST; i++) {
1815 if (info[i].module_id == FDK_NONE) break;
1816 }
1817 if (i == FDK_MODULE_LAST) return -1;
1818
1819 info += i;
1820
1821 info->module_id = FDK_MPSDEC;
1822 #ifdef SUPPRESS_BUILD_DATE_INFO
1823 info->build_date = "";
1824 info->build_time = "";
1825 #else
1826 info->build_date = __DATE__;
1827 info->build_time = __TIME__;
1828 #endif
1829 info->title = "MPEG Surround Decoder";
1830 info->version = LIB_VERSION(SACDEC_VL0, SACDEC_VL1, SACDEC_VL2);
1831 LIB_VERSION_STRING(info);
1832 info->flags = 0 | CAPF_MPS_LD | CAPF_MPS_USAC | CAPF_MPS_HQ |
1833 CAPF_MPS_1CH_IN | CAPF_MPS_2CH_OUT; /* end flags */
1834
1835 return 0;
1836 }
1837
mpegSurroundDecoder_SetParam(CMpegSurroundDecoder * pMpegSurroundDecoder,const SACDEC_PARAM param,const INT value)1838 SACDEC_ERROR mpegSurroundDecoder_SetParam(
1839 CMpegSurroundDecoder *pMpegSurroundDecoder, const SACDEC_PARAM param,
1840 const INT value) {
1841 SACDEC_ERROR err = MPS_OK;
1842 SPATIALDEC_PARAM *pUserParams = NULL;
1843
1844 /* check decoder handle */
1845 if (pMpegSurroundDecoder != NULL) {
1846 /* init local shortcuts */
1847 pUserParams = &pMpegSurroundDecoder->mpegSurroundUserParams;
1848 } else {
1849 err = MPS_INVALID_HANDLE;
1850 /* check the parameter values before exiting. */
1851 }
1852
1853 /* apply param value */
1854 switch (param) {
1855 case SACDEC_OUTPUT_MODE:
1856 switch ((SAC_DEC_OUTPUT_MODE)value) {
1857 case SACDEC_OUT_MODE_NORMAL:
1858 case SACDEC_OUT_MODE_STEREO:
1859 break;
1860 default:
1861 err = MPS_INVALID_PARAMETER;
1862 }
1863 if (err == MPS_OK) {
1864 if (0) {
1865 err = MPS_INVALID_PARAMETER;
1866 } else if (pUserParams->outputMode != (UCHAR)value) {
1867 pUserParams->outputMode = (UCHAR)value;
1868 pMpegSurroundDecoder
1869 ->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1870 MPEGS_INIT_CHANGE_OUTPUT_MODE;
1871 }
1872 }
1873 break;
1874
1875 case SACDEC_INTERFACE:
1876 if (value < 0 || value > 1) {
1877 err = MPS_INVALID_PARAMETER;
1878 }
1879 if (err != MPS_OK) {
1880 goto bail;
1881 }
1882 if (pMpegSurroundDecoder->mpegSurroundUseTimeInterface != (UCHAR)value) {
1883 pMpegSurroundDecoder->mpegSurroundUseTimeInterface = (UCHAR)value;
1884 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1885 MPEGS_INIT_CHANGE_TIME_FREQ_INTERFACE;
1886 }
1887 break;
1888
1889 case SACDEC_BS_INTERRUPTION:
1890 if ((err == MPS_OK) && (value != 0)) {
1891 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1892 MPEGS_INIT_BS_INTERRUPTION,
1893 MPEGS_SYNC_LOST, MPEGS_STOP);
1894 }
1895 break;
1896
1897 case SACDEC_CLEAR_HISTORY:
1898 if ((err == MPS_OK) && (value != 0)) {
1899 /* Just reset the states and go on. */
1900 updateMpegSurroundDecoderStatus(pMpegSurroundDecoder,
1901 MPEGS_INIT_CLEAR_HISTORY,
1902 MPEGS_SYNC_LOST, MPEGS_STOP);
1903 }
1904 break;
1905
1906 case SACDEC_CONCEAL_NUM_KEEP_FRAMES:
1907 if (value < 0) { /* Check valid value range */
1908 err = MPS_INVALID_PARAMETER;
1909 }
1910 if (err != MPS_OK) {
1911 goto bail;
1912 }
1913 if (pUserParams->concealNumKeepFrames != (UINT)value) {
1914 pUserParams->concealNumKeepFrames = (UINT)value;
1915 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1916 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1917 }
1918 break;
1919
1920 case SACDEC_CONCEAL_FADE_OUT_SLOPE_LENGTH:
1921 if (value < 0) { /* Check valid value range */
1922 err = MPS_INVALID_PARAMETER;
1923 }
1924 if (err != MPS_OK) {
1925 goto bail;
1926 }
1927 if (pUserParams->concealFadeOutSlopeLength != (UINT)value) {
1928 pUserParams->concealFadeOutSlopeLength = (UINT)value;
1929 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1930 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1931 }
1932 break;
1933
1934 case SACDEC_CONCEAL_FADE_IN_SLOPE_LENGTH:
1935 if (value < 0) { /* Check valid value range */
1936 err = MPS_INVALID_PARAMETER;
1937 }
1938 if (err != MPS_OK) {
1939 goto bail;
1940 }
1941 if (pUserParams->concealFadeInSlopeLength != (UINT)value) {
1942 pUserParams->concealFadeInSlopeLength = (UINT)value;
1943 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1944 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1945 }
1946 break;
1947
1948 case SACDEC_CONCEAL_NUM_RELEASE_FRAMES:
1949 if (value < 0) { /* Check valid value range */
1950 err = MPS_INVALID_PARAMETER;
1951 }
1952 if (err != MPS_OK) {
1953 goto bail;
1954 }
1955 if (pUserParams->concealNumReleaseFrames != (UINT)value) {
1956 pUserParams->concealNumReleaseFrames = (UINT)value;
1957 pMpegSurroundDecoder->initFlags[pMpegSurroundDecoder->bsFrameDecode] |=
1958 MPEGS_INIT_CHANGE_CONCEAL_PARAMS;
1959 }
1960 break;
1961
1962 default:
1963 err = MPS_INVALID_PARAMETER;
1964 break;
1965 } /* switch(param) */
1966
1967 bail:
1968 return err;
1969 }
1970
mpegSurroundDecoder_IsPseudoLR(CMpegSurroundDecoder * pMpegSurroundDecoder,int * bsPseudoLr)1971 SACDEC_ERROR mpegSurroundDecoder_IsPseudoLR(
1972 CMpegSurroundDecoder *pMpegSurroundDecoder, int *bsPseudoLr) {
1973 if (pMpegSurroundDecoder != NULL) {
1974 const SPATIAL_SPECIFIC_CONFIG *sscDecode =
1975 &pMpegSurroundDecoder
1976 ->spatialSpecificConfig[pMpegSurroundDecoder->bsFrameDecode];
1977 *bsPseudoLr = (int)sscDecode->bsPseudoLr;
1978 return MPS_OK;
1979 } else
1980 return MPS_INVALID_HANDLE;
1981 }
1982
1983 /**
1984 * \brief Get the signal delay caused by the MPEG Surround decoder module.
1985 **/
mpegSurroundDecoder_GetDelay(const CMpegSurroundDecoder * self)1986 UINT mpegSurroundDecoder_GetDelay(const CMpegSurroundDecoder *self) {
1987 INT outputDelay = 0;
1988
1989 if (self != NULL) {
1990 const SPATIAL_SPECIFIC_CONFIG *sscDecode =
1991 &self->spatialSpecificConfig[self->bsFrameDecode];
1992 AUDIO_OBJECT_TYPE coreCodec = sscDecode->coreCodec;
1993
1994 /* See chapter 4.5 (delay and synchronization) of ISO/IEC FDIS 23003-1 and
1995 chapter 5.4.3 of ISO/IEC FDIS 23003-2 for details on the following
1996 figures. */
1997
1998 if (coreCodec > AOT_NULL_OBJECT) {
1999 if (IS_LOWDELAY(coreCodec)) {
2000 /* All low delay variants (ER-AAC-(E)LD): */
2001 outputDelay += 256;
2002 } else if (!IS_USAC(coreCodec)) {
2003 /* By the method of elimination this is the GA (AAC-LC, HE-AAC, ...)
2004 * branch: */
2005 outputDelay += 320 + 257; /* cos to exp delay + QMF synthesis */
2006 if (self->mpegSurroundUseTimeInterface) {
2007 outputDelay += 320 + 384; /* QMF and hybrid analysis */
2008 }
2009 }
2010 }
2011 }
2012
2013 return (outputDelay);
2014 }
2015