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