Home | History | Annotate | Download | only in src
      1 /* -----------------------------------------------------------------------------
      2 Software License for The Fraunhofer FDK AAC Codec Library for Android
      3 
      4  Copyright  1995 - 2019 Fraunhofer-Gesellschaft zur Frderung 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 (at) iis.fraunhofer.de
     93 ----------------------------------------------------------------------------- */
     94 
     95 /**************************** AAC decoder library ******************************
     96 
     97    Author(s):   Manuel Jander
     98 
     99    Description:
    100 
    101 *******************************************************************************/
    102 
    103 #include "aacdecoder_lib.h"
    104 
    105 #include "aac_ram.h"
    106 #include "aacdecoder.h"
    107 #include "tpdec_lib.h"
    108 #include "FDK_core.h" /* FDK_tools version info */
    109 
    110 #include "sbrdecoder.h"
    111 
    112 #include "conceal.h"
    113 
    114 #include "aacdec_drc.h"
    115 
    116 #include "sac_dec_lib.h"
    117 
    118 #include "pcm_utils.h"
    119 
    120 /* Decoder library info */
    121 #define AACDECODER_LIB_VL0 3
    122 #define AACDECODER_LIB_VL1 1
    123 #define AACDECODER_LIB_VL2 2
    124 #define AACDECODER_LIB_TITLE "AAC Decoder Lib"
    125 #ifdef __ANDROID__
    126 #define AACDECODER_LIB_BUILD_DATE ""
    127 #define AACDECODER_LIB_BUILD_TIME ""
    128 #else
    129 #define AACDECODER_LIB_BUILD_DATE __DATE__
    130 #define AACDECODER_LIB_BUILD_TIME __TIME__
    131 #endif
    132 
    133 static AAC_DECODER_ERROR setConcealMethod(const HANDLE_AACDECODER self,
    134                                           const INT method);
    135 
    136 static void aacDecoder_setMetadataExpiry(const HANDLE_AACDECODER self,
    137                                          const INT value) {
    138   /* check decoder handle */
    139   if (self != NULL) {
    140     INT mdExpFrame = 0; /* default: disable */
    141 
    142     if ((value > 0) &&
    143         (self->streamInfo.aacSamplesPerFrame >
    144          0)) { /* Determine the corresponding number of frames: */
    145       FIXP_DBL frameTime = fDivNorm(self->streamInfo.aacSampleRate,
    146                                     self->streamInfo.aacSamplesPerFrame * 1000);
    147       mdExpFrame = fMultIceil(frameTime, value);
    148     }
    149 
    150     /* Configure DRC module */
    151     aacDecoder_drcSetParam(self->hDrcInfo, DRC_DATA_EXPIRY_FRAME, mdExpFrame);
    152 
    153     /* Configure PCM downmix module */
    154     pcmDmx_SetParam(self->hPcmUtils, DMX_BS_DATA_EXPIRY_FRAME, mdExpFrame);
    155   }
    156 }
    157 
    158 LINKSPEC_CPP AAC_DECODER_ERROR
    159 aacDecoder_GetFreeBytes(const HANDLE_AACDECODER self, UINT *pFreeBytes) {
    160   /* reset free bytes */
    161   *pFreeBytes = 0;
    162 
    163   /* check handle */
    164   if (!self) return AAC_DEC_INVALID_HANDLE;
    165 
    166   /* return nr of free bytes */
    167   HANDLE_FDK_BITSTREAM hBs = transportDec_GetBitstream(self->hInput, 0);
    168   *pFreeBytes = FDKgetFreeBits(hBs) >> 3;
    169 
    170   /* success */
    171   return AAC_DEC_OK;
    172 }
    173 
    174 /**
    175  * Config Decoder using a CSAudioSpecificConfig struct.
    176  */
    177 static LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_Config(
    178     HANDLE_AACDECODER self, const CSAudioSpecificConfig *pAscStruct,
    179     UCHAR configMode, UCHAR *configChanged) {
    180   AAC_DECODER_ERROR err;
    181 
    182   /* Initialize AAC core decoder, and update self->streaminfo */
    183   err = CAacDecoder_Init(self, pAscStruct, configMode, configChanged);
    184 
    185   if (!FDK_chMapDescr_isValid(&self->mapDescr)) {
    186     return AAC_DEC_UNSUPPORTED_CHANNELCONFIG;
    187   }
    188 
    189   return err;
    190 }
    191 
    192 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_ConfigRaw(HANDLE_AACDECODER self,
    193                                                     UCHAR *conf[],
    194                                                     const UINT length[]) {
    195   AAC_DECODER_ERROR err = AAC_DEC_OK;
    196   TRANSPORTDEC_ERROR errTp;
    197   UINT layer, nrOfLayers = self->nrOfLayers;
    198 
    199   for (layer = 0; layer < nrOfLayers; layer++) {
    200     if (length[layer] > 0) {
    201       errTp = transportDec_OutOfBandConfig(self->hInput, conf[layer],
    202                                            length[layer], layer);
    203       if (errTp != TRANSPORTDEC_OK) {
    204         switch (errTp) {
    205           case TRANSPORTDEC_NEED_TO_RESTART:
    206             err = AAC_DEC_NEED_TO_RESTART;
    207             break;
    208           case TRANSPORTDEC_UNSUPPORTED_FORMAT:
    209             err = AAC_DEC_UNSUPPORTED_FORMAT;
    210             break;
    211           default:
    212             err = AAC_DEC_UNKNOWN;
    213             break;
    214         }
    215         /* if baselayer is OK we continue decoding */
    216         if (layer >= 1) {
    217           self->nrOfLayers = layer;
    218           err = AAC_DEC_OK;
    219         }
    220         break;
    221       }
    222     }
    223   }
    224 
    225   return err;
    226 }
    227 
    228 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_RawISOBMFFData(HANDLE_AACDECODER self,
    229                                                          UCHAR *buffer,
    230                                                          UINT length) {
    231   FDK_BITSTREAM bs;
    232   HANDLE_FDK_BITSTREAM hBs = &bs;
    233   AAC_DECODER_ERROR err = AAC_DEC_OK;
    234 
    235   if (length < 8) return AAC_DEC_UNKNOWN;
    236 
    237   while (length >= 8) {
    238     UINT size =
    239         (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
    240     DRC_DEC_ERROR uniDrcErr = DRC_DEC_OK;
    241 
    242     if (length < size) return AAC_DEC_UNKNOWN;
    243     if (size <= 8) return AAC_DEC_UNKNOWN;
    244 
    245     FDKinitBitStream(hBs, buffer + 8, 0x10000000, (size - 8) * 8);
    246 
    247     if ((buffer[4] == 'l') && (buffer[5] == 'u') && (buffer[6] == 'd') &&
    248         (buffer[7] == 't')) {
    249       uniDrcErr = FDK_drcDec_ReadLoudnessBox(self->hUniDrcDecoder, hBs);
    250     } else if ((buffer[4] == 'd') && (buffer[5] == 'm') && (buffer[6] == 'i') &&
    251                (buffer[7] == 'x')) {
    252       uniDrcErr =
    253           FDK_drcDec_ReadDownmixInstructions_Box(self->hUniDrcDecoder, hBs);
    254     } else if ((buffer[4] == 'u') && (buffer[5] == 'd') && (buffer[6] == 'i') &&
    255                (buffer[7] == '2')) {
    256       uniDrcErr =
    257           FDK_drcDec_ReadUniDrcInstructions_Box(self->hUniDrcDecoder, hBs);
    258     } else if ((buffer[4] == 'u') && (buffer[5] == 'd') && (buffer[6] == 'c') &&
    259                (buffer[7] == '2')) {
    260       uniDrcErr =
    261           FDK_drcDec_ReadUniDrcCoefficients_Box(self->hUniDrcDecoder, hBs);
    262     }
    263 
    264     if (uniDrcErr != DRC_DEC_OK) err = AAC_DEC_UNKNOWN;
    265 
    266     buffer += size;
    267     length -= size;
    268   }
    269 
    270   return err;
    271 }
    272 
    273 static INT aacDecoder_ConfigCallback(void *handle,
    274                                      const CSAudioSpecificConfig *pAscStruct,
    275                                      UCHAR configMode, UCHAR *configChanged) {
    276   HANDLE_AACDECODER self = (HANDLE_AACDECODER)handle;
    277   AAC_DECODER_ERROR err = AAC_DEC_OK;
    278   TRANSPORTDEC_ERROR errTp;
    279 
    280   FDK_ASSERT(self != NULL);
    281   {
    282     { err = aacDecoder_Config(self, pAscStruct, configMode, configChanged); }
    283   }
    284   if (err == AAC_DEC_OK) {
    285     /*
    286     revert concealment method if either
    287        - Interpolation concealment might not be meaningful
    288        - Interpolation concealment is not implemented
    289     */
    290     if ((self->flags[0] & (AC_LD | AC_ELD) &&
    291          (self->concealMethodUser == ConcealMethodNone) &&
    292          CConcealment_GetDelay(&self->concealCommonData) >
    293              0) /* might not be meaningful but allow if user has set it
    294                    expicitly */
    295         || (self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA) &&
    296             CConcealment_GetDelay(&self->concealCommonData) >
    297                 0) /* not implemented */
    298     ) {
    299       /* Revert to error concealment method Noise Substitution.
    300          Because interpolation is not implemented for USAC or
    301          the additional delay is unwanted for low delay codecs. */
    302       setConcealMethod(self, 1);
    303     }
    304     aacDecoder_setMetadataExpiry(self, self->metadataExpiry);
    305     errTp = TRANSPORTDEC_OK;
    306   } else {
    307     if (err == AAC_DEC_NEED_TO_RESTART) {
    308       errTp = TRANSPORTDEC_NEED_TO_RESTART;
    309     } else if (IS_INIT_ERROR(err)) {
    310       errTp = TRANSPORTDEC_UNSUPPORTED_FORMAT;
    311     } /* Fatal errors */
    312     else {
    313       errTp = TRANSPORTDEC_UNKOWN_ERROR;
    314     }
    315   }
    316 
    317   return errTp;
    318 }
    319 
    320 static INT aacDecoder_FreeMemCallback(void *handle,
    321                                       const CSAudioSpecificConfig *pAscStruct) {
    322   TRANSPORTDEC_ERROR errTp = TRANSPORTDEC_OK;
    323   HANDLE_AACDECODER self = (HANDLE_AACDECODER)handle;
    324 
    325   const int subStreamIndex = 0;
    326 
    327   FDK_ASSERT(self != NULL);
    328 
    329   if (CAacDecoder_FreeMem(self, subStreamIndex) != AAC_DEC_OK) {
    330     errTp = TRANSPORTDEC_UNKOWN_ERROR;
    331   }
    332 
    333   /* free Ram_SbrDecoder and Ram_SbrDecChannel */
    334   if (self->hSbrDecoder != NULL) {
    335     if (sbrDecoder_FreeMem(&self->hSbrDecoder) != SBRDEC_OK) {
    336       errTp = TRANSPORTDEC_UNKOWN_ERROR;
    337     }
    338   }
    339 
    340   /* free pSpatialDec and mpsData */
    341   if (self->pMpegSurroundDecoder != NULL) {
    342     if (mpegSurroundDecoder_FreeMem(
    343             (CMpegSurroundDecoder *)self->pMpegSurroundDecoder) != MPS_OK) {
    344       errTp = TRANSPORTDEC_UNKOWN_ERROR;
    345     }
    346   }
    347 
    348   /* free persistent qmf domain buffer, QmfWorkBufferCore3, QmfWorkBufferCore4,
    349    * QmfWorkBufferCore5 and configuration variables */
    350   FDK_QmfDomain_FreeMem(&self->qmfDomain);
    351 
    352   return errTp;
    353 }
    354 
    355 static INT aacDecoder_CtrlCFGChangeCallback(
    356     void *handle, const CCtrlCFGChange *pCtrlCFGChangeStruct) {
    357   TRANSPORTDEC_ERROR errTp = TRANSPORTDEC_OK;
    358   HANDLE_AACDECODER self = (HANDLE_AACDECODER)handle;
    359 
    360   if (self != NULL) {
    361     CAacDecoder_CtrlCFGChange(
    362         self, pCtrlCFGChangeStruct->flushStatus, pCtrlCFGChangeStruct->flushCnt,
    363         pCtrlCFGChangeStruct->buildUpStatus, pCtrlCFGChangeStruct->buildUpCnt);
    364   } else {
    365     errTp = TRANSPORTDEC_UNKOWN_ERROR;
    366   }
    367 
    368   return errTp;
    369 }
    370 
    371 static INT aacDecoder_SbrCallback(
    372     void *handle, HANDLE_FDK_BITSTREAM hBs, const INT sampleRateIn,
    373     const INT sampleRateOut, const INT samplesPerFrame,
    374     const AUDIO_OBJECT_TYPE coreCodec, const MP4_ELEMENT_ID elementID,
    375     const INT elementIndex, const UCHAR harmonicSBR,
    376     const UCHAR stereoConfigIndex, const UCHAR configMode, UCHAR *configChanged,
    377     const INT downscaleFactor) {
    378   HANDLE_SBRDECODER self = (HANDLE_SBRDECODER)handle;
    379 
    380   INT errTp = sbrDecoder_Header(self, hBs, sampleRateIn, sampleRateOut,
    381                                 samplesPerFrame, coreCodec, elementID,
    382                                 elementIndex, harmonicSBR, stereoConfigIndex,
    383                                 configMode, configChanged, downscaleFactor);
    384 
    385   return errTp;
    386 }
    387 
    388 static INT aacDecoder_SscCallback(void *handle, HANDLE_FDK_BITSTREAM hBs,
    389                                   const AUDIO_OBJECT_TYPE coreCodec,
    390                                   const INT samplingRate, const INT frameSize,
    391                                   const INT stereoConfigIndex,
    392                                   const INT coreSbrFrameLengthIndex,
    393                                   const INT configBytes, const UCHAR configMode,
    394                                   UCHAR *configChanged) {
    395   SACDEC_ERROR err;
    396   TRANSPORTDEC_ERROR errTp;
    397   HANDLE_AACDECODER hAacDecoder = (HANDLE_AACDECODER)handle;
    398 
    399   err = mpegSurroundDecoder_Config(
    400       (CMpegSurroundDecoder *)hAacDecoder->pMpegSurroundDecoder, hBs, coreCodec,
    401       samplingRate, frameSize, stereoConfigIndex, coreSbrFrameLengthIndex,
    402       configBytes, configMode, configChanged);
    403 
    404   switch (err) {
    405     case MPS_UNSUPPORTED_CONFIG:
    406       /* MPS found but invalid or not decodable by this instance            */
    407       /* We switch off MPS and keep going                                   */
    408       hAacDecoder->mpsEnableCurr = 0;
    409       hAacDecoder->mpsApplicable = 0;
    410       errTp = TRANSPORTDEC_OK;
    411       break;
    412     case MPS_PARSE_ERROR:
    413       /* MPS found but invalid or not decodable by this instance            */
    414       hAacDecoder->mpsEnableCurr = 0;
    415       hAacDecoder->mpsApplicable = 0;
    416       if ((coreCodec == AOT_USAC) || (coreCodec == AOT_DRM_USAC) ||
    417           IS_LOWDELAY(coreCodec)) {
    418         errTp = TRANSPORTDEC_PARSE_ERROR;
    419       } else {
    420         errTp = TRANSPORTDEC_OK;
    421       }
    422       break;
    423     case MPS_OK:
    424       hAacDecoder->mpsApplicable = 1;
    425       errTp = TRANSPORTDEC_OK;
    426       break;
    427     default:
    428       /* especially Parsing error is critical for transport layer          */
    429       hAacDecoder->mpsApplicable = 0;
    430       errTp = TRANSPORTDEC_UNKOWN_ERROR;
    431   }
    432 
    433   return (INT)errTp;
    434 }
    435 
    436 static INT aacDecoder_UniDrcCallback(void *handle, HANDLE_FDK_BITSTREAM hBs,
    437                                      const INT fullPayloadLength,
    438                                      const INT payloadType,
    439                                      const INT subStreamIndex,
    440                                      const INT payloadStart,
    441                                      const AUDIO_OBJECT_TYPE aot) {
    442   DRC_DEC_ERROR err = DRC_DEC_OK;
    443   TRANSPORTDEC_ERROR errTp;
    444   HANDLE_AACDECODER hAacDecoder = (HANDLE_AACDECODER)handle;
    445   DRC_DEC_CODEC_MODE drcDecCodecMode = DRC_DEC_CODEC_MODE_UNDEFINED;
    446 
    447   if (subStreamIndex != 0) {
    448     return TRANSPORTDEC_OK;
    449   }
    450 
    451   else if (aot == AOT_USAC) {
    452     drcDecCodecMode = DRC_DEC_MPEG_D_USAC;
    453   }
    454 
    455   err = FDK_drcDec_SetCodecMode(hAacDecoder->hUniDrcDecoder, drcDecCodecMode);
    456   if (err) return (INT)TRANSPORTDEC_UNKOWN_ERROR;
    457 
    458   if (payloadType == 0) /* uniDrcConfig */
    459   {
    460     err = FDK_drcDec_ReadUniDrcConfig(hAacDecoder->hUniDrcDecoder, hBs);
    461   } else /* loudnessInfoSet */
    462   {
    463     err = FDK_drcDec_ReadLoudnessInfoSet(hAacDecoder->hUniDrcDecoder, hBs);
    464     hAacDecoder->loudnessInfoSetPosition[1] = payloadStart;
    465     hAacDecoder->loudnessInfoSetPosition[2] = fullPayloadLength;
    466   }
    467 
    468   if (err == DRC_DEC_OK)
    469     errTp = TRANSPORTDEC_OK;
    470   else
    471     errTp = TRANSPORTDEC_UNKOWN_ERROR;
    472 
    473   return (INT)errTp;
    474 }
    475 
    476 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_AncDataInit(HANDLE_AACDECODER self,
    477                                                       UCHAR *buffer, int size) {
    478   CAncData *ancData = &self->ancData;
    479 
    480   return CAacDecoder_AncDataInit(ancData, buffer, size);
    481 }
    482 
    483 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_AncDataGet(HANDLE_AACDECODER self,
    484                                                      int index, UCHAR **ptr,
    485                                                      int *size) {
    486   CAncData *ancData = &self->ancData;
    487 
    488   return CAacDecoder_AncDataGet(ancData, index, ptr, size);
    489 }
    490 
    491 /* If MPS is present in stream, but not supported by this instance, we'll
    492    have to switch off MPS and use QMF synthesis in the SBR module if required */
    493 static int isSupportedMpsConfig(AUDIO_OBJECT_TYPE aot,
    494                                 unsigned int numInChannels,
    495                                 unsigned int fMpsPresent) {
    496   LIB_INFO libInfo[FDK_MODULE_LAST];
    497   UINT mpsCaps;
    498   int isSupportedCfg = 1;
    499 
    500   FDKinitLibInfo(libInfo);
    501 
    502   mpegSurroundDecoder_GetLibInfo(libInfo);
    503 
    504   mpsCaps = FDKlibInfo_getCapabilities(libInfo, FDK_MPSDEC);
    505 
    506   if (!(mpsCaps & CAPF_MPS_LD) && IS_LOWDELAY(aot)) {
    507     /* We got an LD AOT but MPS decoder does not support LD. */
    508     isSupportedCfg = 0;
    509   }
    510   if ((mpsCaps & CAPF_MPS_LD) && IS_LOWDELAY(aot) && !fMpsPresent) {
    511     /* We got an LD AOT and the MPS decoder supports it.
    512      * But LD-MPS is not explicitly signaled. */
    513     isSupportedCfg = 0;
    514   }
    515   if (!(mpsCaps & CAPF_MPS_USAC) && IS_USAC(aot)) {
    516     /* We got an USAC AOT but MPS decoder does not support USAC. */
    517     isSupportedCfg = 0;
    518   }
    519   if (!(mpsCaps & CAPF_MPS_STD) && !IS_LOWDELAY(aot) && !IS_USAC(aot)) {
    520     /* We got an GA AOT but MPS decoder does not support it. */
    521     isSupportedCfg = 0;
    522   }
    523   /* Check whether the MPS modul supports the given number of input channels: */
    524   switch (numInChannels) {
    525     case 1:
    526       if (!(mpsCaps & CAPF_MPS_1CH_IN)) {
    527         /* We got a one channel input to MPS decoder but it does not support it.
    528          */
    529         isSupportedCfg = 0;
    530       }
    531       break;
    532     case 2:
    533       if (!(mpsCaps & CAPF_MPS_2CH_IN)) {
    534         /* We got a two channel input to MPS decoder but it does not support it.
    535          */
    536         isSupportedCfg = 0;
    537       }
    538       break;
    539     case 5:
    540     case 6:
    541       if (!(mpsCaps & CAPF_MPS_6CH_IN)) {
    542         /* We got a six channel input to MPS decoder but it does not support it.
    543          */
    544         isSupportedCfg = 0;
    545       }
    546       break;
    547     default:
    548       isSupportedCfg = 0;
    549   }
    550 
    551   return (isSupportedCfg);
    552 }
    553 
    554 static AAC_DECODER_ERROR setConcealMethod(
    555     const HANDLE_AACDECODER self, /*!< Handle of the decoder instance */
    556     const INT method) {
    557   AAC_DECODER_ERROR errorStatus = AAC_DEC_OK;
    558   CConcealParams *pConcealData = NULL;
    559   int method_revert = 0;
    560   HANDLE_SBRDECODER hSbrDec = NULL;
    561   HANDLE_AAC_DRC hDrcInfo = NULL;
    562   HANDLE_PCM_DOWNMIX hPcmDmx = NULL;
    563   CConcealmentMethod backupMethod = ConcealMethodNone;
    564   int backupDelay = 0;
    565   int bsDelay = 0;
    566 
    567   /* check decoder handle */
    568   if (self != NULL) {
    569     pConcealData = &self->concealCommonData;
    570     hSbrDec = self->hSbrDecoder;
    571     hDrcInfo = self->hDrcInfo;
    572     hPcmDmx = self->hPcmUtils;
    573     if (self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA) && method >= 2) {
    574       /* Interpolation concealment is not implemented for USAC/RSVD50 */
    575       /* errorStatus = AAC_DEC_SET_PARAM_FAIL;
    576          goto bail; */
    577       method_revert = 1;
    578     }
    579     if (self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA) && method >= 2) {
    580       /* Interpolation concealment is not implemented for USAC/RSVD50 */
    581       errorStatus = AAC_DEC_SET_PARAM_FAIL;
    582       goto bail;
    583     }
    584   }
    585 
    586   /* Get current method/delay */
    587   backupMethod = CConcealment_GetMethod(pConcealData);
    588   backupDelay = CConcealment_GetDelay(pConcealData);
    589 
    590   /* Be sure to set AAC and SBR concealment method simultaneously! */
    591   errorStatus = CConcealment_SetParams(
    592       pConcealData,
    593       (method_revert == 0) ? (int)method : (int)1,  // concealMethod
    594       AACDEC_CONCEAL_PARAM_NOT_SPECIFIED,           // concealFadeOutSlope
    595       AACDEC_CONCEAL_PARAM_NOT_SPECIFIED,           // concealFadeInSlope
    596       AACDEC_CONCEAL_PARAM_NOT_SPECIFIED,           // concealMuteRelease
    597       AACDEC_CONCEAL_PARAM_NOT_SPECIFIED            // concealComfNoiseLevel
    598   );
    599   if ((errorStatus != AAC_DEC_OK) && (errorStatus != AAC_DEC_INVALID_HANDLE)) {
    600     goto bail;
    601   }
    602 
    603   /* Get new delay */
    604   bsDelay = CConcealment_GetDelay(pConcealData);
    605 
    606   {
    607     SBR_ERROR sbrErr = SBRDEC_OK;
    608 
    609     /* set SBR bitstream delay */
    610     sbrErr = sbrDecoder_SetParam(hSbrDec, SBR_SYSTEM_BITSTREAM_DELAY, bsDelay);
    611 
    612     switch (sbrErr) {
    613       case SBRDEC_OK:
    614       case SBRDEC_NOT_INITIALIZED:
    615         if (self != NULL) {
    616           /* save the param value and set later
    617              (when SBR has been initialized) */
    618           self->sbrParams.bsDelay = bsDelay;
    619         }
    620         break;
    621       default:
    622         errorStatus = AAC_DEC_SET_PARAM_FAIL;
    623         goto bail;
    624     }
    625   }
    626 
    627   errorStatus = aacDecoder_drcSetParam(hDrcInfo, DRC_BS_DELAY, bsDelay);
    628   if ((errorStatus != AAC_DEC_OK) && (errorStatus != AAC_DEC_INVALID_HANDLE)) {
    629     goto bail;
    630   }
    631 
    632   if (errorStatus == AAC_DEC_OK) {
    633     PCMDMX_ERROR err = pcmDmx_SetParam(hPcmDmx, DMX_BS_DATA_DELAY, bsDelay);
    634     switch (err) {
    635       case PCMDMX_INVALID_HANDLE:
    636         errorStatus = AAC_DEC_INVALID_HANDLE;
    637         break;
    638       case PCMDMX_OK:
    639         break;
    640       default:
    641         errorStatus = AAC_DEC_SET_PARAM_FAIL;
    642         goto bail;
    643     }
    644   }
    645 
    646 bail:
    647   if ((errorStatus != AAC_DEC_OK) && (errorStatus != AAC_DEC_INVALID_HANDLE)) {
    648     /* Revert to the initial state */
    649     CConcealment_SetParams(
    650         pConcealData, (int)backupMethod, AACDEC_CONCEAL_PARAM_NOT_SPECIFIED,
    651         AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, AACDEC_CONCEAL_PARAM_NOT_SPECIFIED,
    652         AACDEC_CONCEAL_PARAM_NOT_SPECIFIED);
    653     /* Revert SBR bitstream delay */
    654     sbrDecoder_SetParam(hSbrDec, SBR_SYSTEM_BITSTREAM_DELAY, backupDelay);
    655     /* Revert DRC bitstream delay */
    656     aacDecoder_drcSetParam(hDrcInfo, DRC_BS_DELAY, backupDelay);
    657     /* Revert PCM mixdown bitstream delay */
    658     pcmDmx_SetParam(hPcmDmx, DMX_BS_DATA_DELAY, backupDelay);
    659   }
    660 
    661   return errorStatus;
    662 }
    663 
    664 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_SetParam(
    665     const HANDLE_AACDECODER self, /*!< Handle of the decoder instance */
    666     const AACDEC_PARAM param,     /*!< Parameter to set               */
    667     const INT value)              /*!< Parameter valued               */
    668 {
    669   AAC_DECODER_ERROR errorStatus = AAC_DEC_OK;
    670   HANDLE_TRANSPORTDEC hTpDec = NULL;
    671   TRANSPORTDEC_ERROR errTp = TRANSPORTDEC_OK;
    672   HANDLE_AAC_DRC hDrcInfo = NULL;
    673   HANDLE_PCM_DOWNMIX hPcmDmx = NULL;
    674   PCMDMX_ERROR dmxErr = PCMDMX_OK;
    675   TDLimiterPtr hPcmTdl = NULL;
    676   DRC_DEC_ERROR uniDrcErr = DRC_DEC_OK;
    677 
    678   /* check decoder handle */
    679   if (self != NULL) {
    680     hTpDec = self->hInput;
    681     hDrcInfo = self->hDrcInfo;
    682     hPcmDmx = self->hPcmUtils;
    683     hPcmTdl = self->hLimiter;
    684   } else {
    685     errorStatus = AAC_DEC_INVALID_HANDLE;
    686     goto bail;
    687   }
    688 
    689   /* configure the subsystems */
    690   switch (param) {
    691     case AAC_PCM_MIN_OUTPUT_CHANNELS:
    692       if (value < -1 || value > (8)) {
    693         return AAC_DEC_SET_PARAM_FAIL;
    694       }
    695       dmxErr = pcmDmx_SetParam(hPcmDmx, MIN_NUMBER_OF_OUTPUT_CHANNELS, value);
    696       break;
    697 
    698     case AAC_PCM_MAX_OUTPUT_CHANNELS:
    699       if (value < -1 || value > (8)) {
    700         return AAC_DEC_SET_PARAM_FAIL;
    701       }
    702       dmxErr = pcmDmx_SetParam(hPcmDmx, MAX_NUMBER_OF_OUTPUT_CHANNELS, value);
    703 
    704       if (dmxErr != PCMDMX_OK) {
    705         goto bail;
    706       }
    707       errorStatus =
    708           aacDecoder_drcSetParam(hDrcInfo, MAX_OUTPUT_CHANNELS, value);
    709       if (value > 0) {
    710         uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder,
    711                                         DRC_DEC_TARGET_CHANNEL_COUNT_REQUESTED,
    712                                         (FIXP_DBL)value);
    713       }
    714       break;
    715 
    716     case AAC_PCM_DUAL_CHANNEL_OUTPUT_MODE:
    717       dmxErr = pcmDmx_SetParam(hPcmDmx, DMX_DUAL_CHANNEL_MODE, value);
    718       break;
    719 
    720     case AAC_PCM_LIMITER_ENABLE:
    721       if (value < -2 || value > 1) {
    722         return AAC_DEC_SET_PARAM_FAIL;
    723       }
    724       self->limiterEnableUser = value;
    725       break;
    726 
    727     case AAC_PCM_LIMITER_ATTACK_TIME:
    728       if (value <= 0) { /* module function converts value to unsigned */
    729         return AAC_DEC_SET_PARAM_FAIL;
    730       }
    731       switch (pcmLimiter_SetAttack(hPcmTdl, value)) {
    732         case TDLIMIT_OK:
    733           break;
    734         case TDLIMIT_INVALID_HANDLE:
    735           return AAC_DEC_INVALID_HANDLE;
    736         case TDLIMIT_INVALID_PARAMETER:
    737         default:
    738           return AAC_DEC_SET_PARAM_FAIL;
    739       }
    740       break;
    741 
    742     case AAC_PCM_LIMITER_RELEAS_TIME:
    743       if (value <= 0) { /* module function converts value to unsigned */
    744         return AAC_DEC_SET_PARAM_FAIL;
    745       }
    746       switch (pcmLimiter_SetRelease(hPcmTdl, value)) {
    747         case TDLIMIT_OK:
    748           break;
    749         case TDLIMIT_INVALID_HANDLE:
    750           return AAC_DEC_INVALID_HANDLE;
    751         case TDLIMIT_INVALID_PARAMETER:
    752         default:
    753           return AAC_DEC_SET_PARAM_FAIL;
    754       }
    755       break;
    756 
    757     case AAC_METADATA_PROFILE: {
    758       DMX_PROFILE_TYPE dmxProfile;
    759       INT mdExpiry = -1; /* in ms (-1: don't change) */
    760 
    761       switch ((AAC_MD_PROFILE)value) {
    762         case AAC_MD_PROFILE_MPEG_STANDARD:
    763           dmxProfile = DMX_PRFL_STANDARD;
    764           break;
    765         case AAC_MD_PROFILE_MPEG_LEGACY:
    766           dmxProfile = DMX_PRFL_MATRIX_MIX;
    767           break;
    768         case AAC_MD_PROFILE_MPEG_LEGACY_PRIO:
    769           dmxProfile = DMX_PRFL_FORCE_MATRIX_MIX;
    770           break;
    771         case AAC_MD_PROFILE_ARIB_JAPAN:
    772           dmxProfile = DMX_PRFL_ARIB_JAPAN;
    773           mdExpiry = 550; /* ms */
    774           break;
    775         default:
    776           return AAC_DEC_SET_PARAM_FAIL;
    777       }
    778       dmxErr = pcmDmx_SetParam(hPcmDmx, DMX_PROFILE_SETTING, (INT)dmxProfile);
    779       if (dmxErr != PCMDMX_OK) {
    780         goto bail;
    781       }
    782       if ((self != NULL) && (mdExpiry >= 0)) {
    783         self->metadataExpiry = mdExpiry;
    784         /* Determine the corresponding number of frames and configure all
    785          * related modules. */
    786         aacDecoder_setMetadataExpiry(self, mdExpiry);
    787       }
    788     } break;
    789 
    790     case AAC_METADATA_EXPIRY_TIME:
    791       if (value < 0) {
    792         return AAC_DEC_SET_PARAM_FAIL;
    793       }
    794       if (self != NULL) {
    795         self->metadataExpiry = value;
    796         /* Determine the corresponding number of frames and configure all
    797          * related modules. */
    798         aacDecoder_setMetadataExpiry(self, value);
    799       }
    800       break;
    801 
    802     case AAC_PCM_OUTPUT_CHANNEL_MAPPING:
    803       if (value < 0 || value > 1) {
    804         return AAC_DEC_SET_PARAM_FAIL;
    805       }
    806       /* CAUTION: The given value must be inverted to match the logic! */
    807       FDK_chMapDescr_setPassThrough(&self->mapDescr, !value);
    808       break;
    809 
    810     case AAC_QMF_LOWPOWER:
    811       if (value < -1 || value > 1) {
    812         return AAC_DEC_SET_PARAM_FAIL;
    813       }
    814 
    815       /**
    816        * Set QMF mode (might be overriden)
    817        *  0:HQ (complex)
    818        *  1:LP (partially complex)
    819        */
    820       self->qmfModeUser = (QMF_MODE)value;
    821       break;
    822 
    823     case AAC_DRC_ATTENUATION_FACTOR:
    824       /* DRC compression factor (where 0 is no and 127 is max compression) */
    825       errorStatus = aacDecoder_drcSetParam(hDrcInfo, DRC_CUT_SCALE, value);
    826       uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_COMPRESS,
    827                                       value * (FL2FXCONST_DBL(0.5f / 127.0f)));
    828       break;
    829 
    830     case AAC_DRC_BOOST_FACTOR:
    831       /* DRC boost factor (where 0 is no and 127 is max boost) */
    832       errorStatus = aacDecoder_drcSetParam(hDrcInfo, DRC_BOOST_SCALE, value);
    833       uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_BOOST,
    834                                       value * (FL2FXCONST_DBL(0.5f / 127.0f)));
    835       break;
    836 
    837     case AAC_DRC_REFERENCE_LEVEL:
    838       if ((value >= 0) &&
    839           ((value < 40) || (value > 127))) /* allowed range: -10 to -31.75 dB */
    840         return AAC_DEC_SET_PARAM_FAIL;
    841       /* DRC target reference level quantized in 0.25dB steps using values
    842          [40..127]. Negative values switch off loudness normalisation. Negative
    843          values also switch off MPEG-4 DRC, while MPEG-D DRC can be separately
    844          switched on/off with AAC_UNIDRC_SET_EFFECT */
    845       errorStatus = aacDecoder_drcSetParam(hDrcInfo, TARGET_REF_LEVEL, value);
    846       uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder,
    847                                       DRC_DEC_LOUDNESS_NORMALIZATION_ON,
    848                                       (FIXP_DBL)(value >= 0));
    849       /* set target loudness also for MPEG-D DRC */
    850       self->defaultTargetLoudness = (SCHAR)value;
    851       break;
    852 
    853     case AAC_DRC_HEAVY_COMPRESSION:
    854       /* Don't need to overwrite cut/boost values */
    855       errorStatus =
    856           aacDecoder_drcSetParam(hDrcInfo, APPLY_HEAVY_COMPRESSION, value);
    857       break;
    858 
    859     case AAC_DRC_DEFAULT_PRESENTATION_MODE:
    860       /* DRC default presentation mode */
    861       errorStatus =
    862           aacDecoder_drcSetParam(hDrcInfo, DEFAULT_PRESENTATION_MODE, value);
    863       break;
    864 
    865     case AAC_DRC_ENC_TARGET_LEVEL:
    866       /* Encoder target level for light (i.e. not heavy) compression:
    867          Target reference level assumed at encoder for deriving limiting gains
    868        */
    869       errorStatus =
    870           aacDecoder_drcSetParam(hDrcInfo, ENCODER_TARGET_LEVEL, value);
    871       break;
    872 
    873     case AAC_UNIDRC_SET_EFFECT:
    874       if ((value < -1) || (value > 6)) return AAC_DEC_SET_PARAM_FAIL;
    875       uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_EFFECT_TYPE,
    876                                       (FIXP_DBL)value);
    877       break;
    878     case AAC_UNIDRC_ALBUM_MODE:
    879       uniDrcErr = FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_ALBUM_MODE,
    880                                       (FIXP_DBL)value);
    881       break;
    882 
    883     case AAC_TPDEC_CLEAR_BUFFER:
    884       errTp = transportDec_SetParam(hTpDec, TPDEC_PARAM_RESET, 1);
    885       self->streamInfo.numLostAccessUnits = 0;
    886       self->streamInfo.numBadBytes = 0;
    887       self->streamInfo.numTotalBytes = 0;
    888       /* aacDecoder_SignalInterruption(self); */
    889       break;
    890     case AAC_CONCEAL_METHOD:
    891       /* Changing the concealment method can introduce additional bitstream
    892          delay. And that in turn affects sub libraries and modules which makes
    893          the whole thing quite complex.  So the complete changing routine is
    894          packed into a helper function which keeps all modules and libs in a
    895          consistent state even in the case an error occures. */
    896       errorStatus = setConcealMethod(self, value);
    897       if (errorStatus == AAC_DEC_OK) {
    898         self->concealMethodUser = (CConcealmentMethod)value;
    899       }
    900       break;
    901 
    902     default:
    903       return AAC_DEC_SET_PARAM_FAIL;
    904   } /* switch(param) */
    905 
    906 bail:
    907 
    908   if (errorStatus == AAC_DEC_OK) {
    909     /* Check error code returned by DMX module library: */
    910     switch (dmxErr) {
    911       case PCMDMX_OK:
    912         break;
    913       case PCMDMX_INVALID_HANDLE:
    914         errorStatus = AAC_DEC_INVALID_HANDLE;
    915         break;
    916       default:
    917         errorStatus = AAC_DEC_SET_PARAM_FAIL;
    918     }
    919   }
    920 
    921   if (errTp != TRANSPORTDEC_OK && errorStatus == AAC_DEC_OK) {
    922     errorStatus = AAC_DEC_SET_PARAM_FAIL;
    923   }
    924 
    925   if (errorStatus == AAC_DEC_OK) {
    926     /* Check error code returned by MPEG-D DRC decoder library: */
    927     switch (uniDrcErr) {
    928       case 0:
    929         break;
    930       case -9998:
    931         errorStatus = AAC_DEC_INVALID_HANDLE;
    932         break;
    933       default:
    934         errorStatus = AAC_DEC_SET_PARAM_FAIL;
    935         break;
    936     }
    937   }
    938 
    939   return (errorStatus);
    940 }
    941 LINKSPEC_CPP HANDLE_AACDECODER aacDecoder_Open(TRANSPORT_TYPE transportFmt,
    942                                                UINT nrOfLayers) {
    943   AAC_DECODER_INSTANCE *aacDec = NULL;
    944   HANDLE_TRANSPORTDEC pIn;
    945   int err = 0;
    946   int stereoConfigIndex = -1;
    947 
    948   UINT nrOfLayers_min = fMin(nrOfLayers, (UINT)1);
    949 
    950   /* Allocate transport layer struct. */
    951   pIn = transportDec_Open(transportFmt, TP_FLAG_MPEG4, nrOfLayers_min);
    952   if (pIn == NULL) {
    953     return NULL;
    954   }
    955 
    956   /* Allocate AAC decoder core struct. */
    957   aacDec = CAacDecoder_Open(transportFmt);
    958 
    959   if (aacDec == NULL) {
    960     transportDec_Close(&pIn);
    961     goto bail;
    962   }
    963   aacDec->hInput = pIn;
    964 
    965   aacDec->nrOfLayers = nrOfLayers_min;
    966 
    967   /* Setup channel mapping descriptor. */
    968   FDK_chMapDescr_init(&aacDec->mapDescr, NULL, 0, 0);
    969 
    970   /* Register Config Update callback. */
    971   transportDec_RegisterAscCallback(pIn, aacDecoder_ConfigCallback,
    972                                    (void *)aacDec);
    973 
    974   /* Register Free Memory callback. */
    975   transportDec_RegisterFreeMemCallback(pIn, aacDecoder_FreeMemCallback,
    976                                        (void *)aacDec);
    977 
    978   /* Register config switch control callback. */
    979   transportDec_RegisterCtrlCFGChangeCallback(
    980       pIn, aacDecoder_CtrlCFGChangeCallback, (void *)aacDec);
    981 
    982   FDKmemclear(&aacDec->qmfDomain, sizeof(FDK_QMF_DOMAIN));
    983   /* open SBR decoder */
    984   if (SBRDEC_OK != sbrDecoder_Open(&aacDec->hSbrDecoder, &aacDec->qmfDomain)) {
    985     err = -1;
    986     goto bail;
    987   }
    988   aacDec->qmfModeUser = NOT_DEFINED;
    989   transportDec_RegisterSbrCallback(aacDec->hInput, aacDecoder_SbrCallback,
    990                                    (void *)aacDec->hSbrDecoder);
    991 
    992   if (mpegSurroundDecoder_Open(
    993           (CMpegSurroundDecoder **)&aacDec->pMpegSurroundDecoder,
    994           stereoConfigIndex, &aacDec->qmfDomain)) {
    995     err = -1;
    996     goto bail;
    997   }
    998   /* Set MPEG Surround defaults */
    999   aacDec->mpsEnableUser = 0;
   1000   aacDec->mpsEnableCurr = 0;
   1001   aacDec->mpsApplicable = 0;
   1002   aacDec->mpsOutputMode = (SCHAR)SACDEC_OUT_MODE_NORMAL;
   1003   transportDec_RegisterSscCallback(pIn, aacDecoder_SscCallback, (void *)aacDec);
   1004 
   1005   {
   1006     if (FDK_drcDec_Open(&(aacDec->hUniDrcDecoder), DRC_DEC_ALL) != 0) {
   1007       err = -1;
   1008       goto bail;
   1009     }
   1010   }
   1011 
   1012   transportDec_RegisterUniDrcConfigCallback(pIn, aacDecoder_UniDrcCallback,
   1013                                             (void *)aacDec,
   1014                                             aacDec->loudnessInfoSetPosition);
   1015   aacDec->defaultTargetLoudness = (SCHAR)96;
   1016 
   1017   pcmDmx_Open(&aacDec->hPcmUtils);
   1018   if (aacDec->hPcmUtils == NULL) {
   1019     err = -1;
   1020     goto bail;
   1021   }
   1022 
   1023   aacDec->hLimiter =
   1024       pcmLimiter_Create(TDL_ATTACK_DEFAULT_MS, TDL_RELEASE_DEFAULT_MS,
   1025                         (FIXP_DBL)MAXVAL_DBL, (8), 96000);
   1026   if (NULL == aacDec->hLimiter) {
   1027     err = -1;
   1028     goto bail;
   1029   }
   1030   aacDec->limiterEnableUser = (UCHAR)-1;
   1031   aacDec->limiterEnableCurr = 0;
   1032 
   1033   /* Assure that all modules have same delay */
   1034   if (setConcealMethod(aacDec,
   1035                        CConcealment_GetMethod(&aacDec->concealCommonData))) {
   1036     err = -1;
   1037     goto bail;
   1038   }
   1039 
   1040 bail:
   1041   if (err == -1) {
   1042     aacDecoder_Close(aacDec);
   1043     aacDec = NULL;
   1044   }
   1045   return aacDec;
   1046 }
   1047 
   1048 LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_Fill(HANDLE_AACDECODER self,
   1049                                                UCHAR *pBuffer[],
   1050                                                const UINT bufferSize[],
   1051                                                UINT *pBytesValid) {
   1052   TRANSPORTDEC_ERROR tpErr;
   1053   /* loop counter for layers; if not TT_MP4_RAWPACKETS used as index for only
   1054      available layer */
   1055   INT layer = 0;
   1056   INT nrOfLayers = self->nrOfLayers;
   1057 
   1058   {
   1059     for (layer = 0; layer < nrOfLayers; layer++) {
   1060       {
   1061         tpErr = transportDec_FillData(self->hInput, pBuffer[layer],
   1062                                       bufferSize[layer], &pBytesValid[layer],
   1063                                       layer);
   1064         if (tpErr != TRANSPORTDEC_OK) {
   1065           return AAC_DEC_UNKNOWN; /* Must be an internal error */
   1066         }
   1067       }
   1068     }
   1069   }
   1070 
   1071   return AAC_DEC_OK;
   1072 }
   1073 
   1074 static void aacDecoder_SignalInterruption(HANDLE_AACDECODER self) {
   1075   CAacDecoder_SignalInterruption(self);
   1076 
   1077   if (self->hSbrDecoder != NULL) {
   1078     sbrDecoder_SetParam(self->hSbrDecoder, SBR_BS_INTERRUPTION, 1);
   1079   }
   1080   if (self->mpsEnableUser) {
   1081     mpegSurroundDecoder_SetParam(
   1082         (CMpegSurroundDecoder *)self->pMpegSurroundDecoder,
   1083         SACDEC_BS_INTERRUPTION, 1);
   1084   }
   1085 }
   1086 
   1087 static void aacDecoder_UpdateBitStreamCounters(CStreamInfo *pSi,
   1088                                                HANDLE_FDK_BITSTREAM hBs,
   1089                                                INT nBits,
   1090                                                AAC_DECODER_ERROR ErrorStatus) {
   1091   /* calculate bit difference (amount of bits moved forward) */
   1092   nBits = nBits - (INT)FDKgetValidBits(hBs);
   1093 
   1094   /* Note: The amount of bits consumed might become negative when parsing a
   1095      bit stream with several sub frames, and we find out at the last sub frame
   1096      that the total frame length does not match the sum of sub frame length.
   1097      If this happens, the transport decoder might want to rewind to the supposed
   1098      ending of the transport frame, and this position might be before the last
   1099      access unit beginning. */
   1100 
   1101   /* Calc bitrate. */
   1102   if (pSi->frameSize > 0) {
   1103     /* bitRate = nBits * sampleRate / frameSize */
   1104     int ratio_e = 0;
   1105     FIXP_DBL ratio_m = fDivNorm(pSi->sampleRate, pSi->frameSize, &ratio_e);
   1106     pSi->bitRate = (INT)fMultNorm(nBits, DFRACT_BITS - 1, ratio_m, ratio_e,
   1107                                   DFRACT_BITS - 1);
   1108   }
   1109 
   1110   /* bit/byte counters */
   1111   {
   1112     INT nBytes;
   1113 
   1114     nBytes = nBits >> 3;
   1115     pSi->numTotalBytes += nBytes;
   1116     if (IS_OUTPUT_VALID(ErrorStatus)) {
   1117       pSi->numTotalAccessUnits++;
   1118     }
   1119     if (IS_DECODE_ERROR(ErrorStatus)) {
   1120       pSi->numBadBytes += nBytes;
   1121       pSi->numBadAccessUnits++;
   1122     }
   1123   }
   1124 }
   1125 
   1126 static INT aacDecoder_EstimateNumberOfLostFrames(HANDLE_AACDECODER self) {
   1127   INT n;
   1128 
   1129   transportDec_GetMissingAccessUnitCount(&n, self->hInput);
   1130 
   1131   return n;
   1132 }
   1133 
   1134 LINKSPEC_CPP AAC_DECODER_ERROR
   1135 aacDecoder_DecodeFrame(HANDLE_AACDECODER self, INT_PCM *pTimeData_extern,
   1136                        const INT timeDataSize_extern, const UINT flags) {
   1137   AAC_DECODER_ERROR ErrorStatus;
   1138   INT layer;
   1139   INT nBits;
   1140   HANDLE_FDK_BITSTREAM hBs;
   1141   int fTpInterruption = 0; /* Transport originated interruption detection. */
   1142   int fTpConceal = 0;      /* Transport originated concealment. */
   1143   INT_PCM *pTimeData = NULL;
   1144   INT timeDataSize = 0;
   1145   UINT accessUnit = 0;
   1146   UINT numAccessUnits = 1;
   1147   UINT numPrerollAU = 0;
   1148   int fEndAuNotAdjusted = 0;  /* The end of the access unit was not adjusted */
   1149   int applyCrossfade = 1;     /* flag indicates if flushing was possible */
   1150   FIXP_PCM *pTimeDataFixpPcm; /* Signal buffer for decoding process before PCM
   1151                                  processing */
   1152   INT timeDataFixpPcmSize;
   1153   PCM_DEC *pTimeDataPcmPost; /* Signal buffer for PCM post-processing */
   1154   INT timeDataPcmPostSize;
   1155 
   1156   if (self == NULL) {
   1157     return AAC_DEC_INVALID_HANDLE;
   1158   }
   1159 
   1160   pTimeData = self->pcmOutputBuffer;
   1161   timeDataSize = sizeof(self->pcmOutputBuffer) / sizeof(*self->pcmOutputBuffer);
   1162 
   1163   if (flags & AACDEC_INTR) {
   1164     self->streamInfo.numLostAccessUnits = 0;
   1165   }
   1166   hBs = transportDec_GetBitstream(self->hInput, 0);
   1167 
   1168   /* Get current bits position for bitrate calculation. */
   1169   nBits = FDKgetValidBits(hBs);
   1170 
   1171   if (flags & AACDEC_CLRHIST) {
   1172     if (self->flags[0] & AC_USAC) {
   1173       /* 1) store AudioSpecificConfig always in AudioSpecificConfig_Parse() */
   1174       /* 2) free memory of dynamic allocated data */
   1175       CSAudioSpecificConfig asc;
   1176       transportDec_GetAsc(self->hInput, 0, &asc);
   1177       aacDecoder_FreeMemCallback(self, &asc);
   1178       self->streamInfo.numChannels = 0;
   1179       /* 3) restore AudioSpecificConfig */
   1180       transportDec_OutOfBandConfig(self->hInput, asc.config,
   1181                                    (asc.configBits + 7) >> 3, 0);
   1182     }
   1183   }
   1184 
   1185   if (!((flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) ||
   1186         (self->flushStatus == AACDEC_RSV60_DASH_IPF_ATSC_FLUSH_ON) ||
   1187         (self->flushStatus == AACDEC_USAC_DASH_IPF_FLUSH_ON) ||
   1188         (self->buildUpStatus == AACDEC_RSV60_BUILD_UP_IDLE_IN_BAND))) {
   1189     TRANSPORTDEC_ERROR err;
   1190 
   1191     for (layer = 0; layer < self->nrOfLayers; layer++) {
   1192       err = transportDec_ReadAccessUnit(self->hInput, layer);
   1193       if (err != TRANSPORTDEC_OK) {
   1194         switch (err) {
   1195           case TRANSPORTDEC_NOT_ENOUGH_BITS:
   1196             ErrorStatus = AAC_DEC_NOT_ENOUGH_BITS;
   1197             goto bail;
   1198           case TRANSPORTDEC_SYNC_ERROR:
   1199             self->streamInfo.numLostAccessUnits =
   1200                 aacDecoder_EstimateNumberOfLostFrames(self);
   1201             fTpInterruption = 1;
   1202             break;
   1203           case TRANSPORTDEC_NEED_TO_RESTART:
   1204             ErrorStatus = AAC_DEC_NEED_TO_RESTART;
   1205             goto bail;
   1206           case TRANSPORTDEC_CRC_ERROR:
   1207             fTpConceal = 1;
   1208             break;
   1209           case TRANSPORTDEC_UNSUPPORTED_FORMAT:
   1210             ErrorStatus = AAC_DEC_UNSUPPORTED_FORMAT;
   1211             goto bail;
   1212           default:
   1213             ErrorStatus = AAC_DEC_UNKNOWN;
   1214             goto bail;
   1215         }
   1216       }
   1217     }
   1218   } else {
   1219     if (self->streamInfo.numLostAccessUnits > 0) {
   1220       self->streamInfo.numLostAccessUnits--;
   1221     }
   1222   }
   1223 
   1224   self->frameOK = 1;
   1225 
   1226   UINT prerollAUOffset[AACDEC_MAX_NUM_PREROLL_AU];
   1227   UINT prerollAULength[AACDEC_MAX_NUM_PREROLL_AU];
   1228   for (int i = 0; i < AACDEC_MAX_NUM_PREROLL_AU + 1; i++)
   1229     self->prerollAULength[i] = 0;
   1230 
   1231   INT auStartAnchor;
   1232   HANDLE_FDK_BITSTREAM hBsAu;
   1233 
   1234   /* Process preroll frames and current frame */
   1235   do {
   1236     if (!(flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) &&
   1237         (self->flushStatus != AACDEC_RSV60_CFG_CHANGE_ATSC_FLUSH_ON) &&
   1238         (accessUnit == 0) &&
   1239         (self->hasAudioPreRoll ||
   1240          (self->buildUpStatus == AACDEC_RSV60_BUILD_UP_IDLE_IN_BAND)) &&
   1241         !fTpInterruption &&
   1242         !fTpConceal /* Bit stream pointer needs to be at the beginning of a
   1243                        (valid) AU. */
   1244     ) {
   1245       ErrorStatus = CAacDecoder_PreRollExtensionPayloadParse(
   1246           self, &numPrerollAU, prerollAUOffset, prerollAULength);
   1247 
   1248       if (ErrorStatus != AAC_DEC_OK) {
   1249         switch (ErrorStatus) {
   1250           case AAC_DEC_NOT_ENOUGH_BITS:
   1251             goto bail;
   1252           case AAC_DEC_PARSE_ERROR:
   1253             self->frameOK = 0;
   1254             break;
   1255           default:
   1256             break;
   1257         }
   1258       }
   1259 
   1260       numAccessUnits += numPrerollAU;
   1261     }
   1262 
   1263     hBsAu = transportDec_GetBitstream(self->hInput, 0);
   1264     auStartAnchor = (INT)FDKgetValidBits(hBsAu);
   1265 
   1266     self->accessUnit = accessUnit;
   1267     if (accessUnit < numPrerollAU) {
   1268       FDKpushFor(hBsAu, prerollAUOffset[accessUnit]);
   1269     }
   1270 
   1271     /* Signal bit stream interruption to other modules if required. */
   1272     if (fTpInterruption || (flags & AACDEC_INTR)) {
   1273       aacDecoder_SignalInterruption(self);
   1274       if (!(flags & AACDEC_INTR)) {
   1275         ErrorStatus = AAC_DEC_TRANSPORT_SYNC_ERROR;
   1276         goto bail;
   1277       }
   1278     }
   1279 
   1280     /* Clearing core data will be done in CAacDecoder_DecodeFrame() below.
   1281        Tell other modules to clear states if required. */
   1282     if (flags & AACDEC_CLRHIST) {
   1283       if (!(self->flags[0] & AC_USAC)) {
   1284         sbrDecoder_SetParam(self->hSbrDecoder, SBR_CLEAR_HISTORY, 1);
   1285         mpegSurroundDecoder_SetParam(
   1286             (CMpegSurroundDecoder *)self->pMpegSurroundDecoder,
   1287             SACDEC_CLEAR_HISTORY, 1);
   1288         if (FDK_QmfDomain_ClearPersistentMemory(&self->qmfDomain) != 0) {
   1289           ErrorStatus = AAC_DEC_UNKNOWN;
   1290           goto bail;
   1291         }
   1292       }
   1293     }
   1294 
   1295     /* Empty bit buffer in case of flush request. */
   1296     if (flags & AACDEC_FLUSH && !(flags & AACDEC_CONCEAL)) {
   1297       if (!self->flushStatus) {
   1298         transportDec_SetParam(self->hInput, TPDEC_PARAM_RESET, 1);
   1299         self->streamInfo.numLostAccessUnits = 0;
   1300         self->streamInfo.numBadBytes = 0;
   1301         self->streamInfo.numTotalBytes = 0;
   1302       }
   1303     }
   1304     /* Reset the output delay field. The modules will add their figures one
   1305      * after another. */
   1306     self->streamInfo.outputDelay = 0;
   1307 
   1308     if (self->limiterEnableUser == (UCHAR)-2) {
   1309       /* Enable limiter only for RSVD60. */
   1310       self->limiterEnableCurr = (self->flags[0] & AC_RSV603DA) ? 1 : 0;
   1311     } else if (self->limiterEnableUser == (UCHAR)-1) {
   1312       /* Enable limiter for all non-lowdelay AOT's. */
   1313       self->limiterEnableCurr = (self->flags[0] & (AC_LD | AC_ELD)) ? 0 : 1;
   1314     } else {
   1315       /* Use limiter configuration as requested. */
   1316       self->limiterEnableCurr = self->limiterEnableUser;
   1317     }
   1318     /* reset limiter gain on a per frame basis */
   1319     self->extGain[0] = FL2FXCONST_DBL(1.0f / (float)(1 << TDL_GAIN_SCALING));
   1320 
   1321     pTimeDataFixpPcm = pTimeData;
   1322     timeDataFixpPcmSize = timeDataSize;
   1323 
   1324     ErrorStatus = CAacDecoder_DecodeFrame(
   1325         self,
   1326         flags | (fTpConceal ? AACDEC_CONCEAL : 0) |
   1327             ((self->flushStatus && !(flags & AACDEC_CONCEAL)) ? AACDEC_FLUSH
   1328                                                               : 0),
   1329         pTimeDataFixpPcm + 0, timeDataFixpPcmSize,
   1330         self->streamInfo.aacSamplesPerFrame + 0);
   1331 
   1332     /* if flushing for USAC DASH IPF was not possible go on with decoding
   1333      * preroll */
   1334     if ((self->flags[0] & AC_USAC) &&
   1335         (self->flushStatus == AACDEC_USAC_DASH_IPF_FLUSH_ON) &&
   1336         !(flags & AACDEC_CONCEAL) && (ErrorStatus != AAC_DEC_OK)) {
   1337       applyCrossfade = 0;
   1338     } else /* USAC DASH IPF flushing possible begin */
   1339     {
   1340       if (!((flags & (AACDEC_CONCEAL | AACDEC_FLUSH)) || fTpConceal ||
   1341             self->flushStatus) &&
   1342           (!(IS_OUTPUT_VALID(ErrorStatus)) || !(accessUnit < numPrerollAU))) {
   1343         TRANSPORTDEC_ERROR tpErr;
   1344         tpErr = transportDec_EndAccessUnit(self->hInput);
   1345         if (tpErr != TRANSPORTDEC_OK) {
   1346           self->frameOK = 0;
   1347         }
   1348       } else { /* while preroll processing later possibly an error in the
   1349                   renderer part occurrs */
   1350         if (IS_OUTPUT_VALID(ErrorStatus)) {
   1351           fEndAuNotAdjusted = 1;
   1352         }
   1353       }
   1354 
   1355       /* If the current pTimeDataFixpPcm does not contain a valid signal, there
   1356        * nothing else we can do, so bail. */
   1357       if (!IS_OUTPUT_VALID(ErrorStatus)) {
   1358         goto bail;
   1359       }
   1360 
   1361       {
   1362         self->streamInfo.sampleRate = self->streamInfo.aacSampleRate;
   1363         self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame;
   1364       }
   1365 
   1366       self->streamInfo.numChannels = self->streamInfo.aacNumChannels;
   1367 
   1368       {
   1369         FDK_Delay_Apply(&self->usacResidualDelay,
   1370                         pTimeDataFixpPcm +
   1371                             1 * (self->streamInfo.aacSamplesPerFrame + 0) + 0,
   1372                         self->streamInfo.frameSize, 0);
   1373       }
   1374 
   1375       /* Setting of internal MPS state; may be reset in CAacDecoder_SyncQmfMode
   1376          if decoder is unable to decode with user defined qmfMode */
   1377       if (!(self->flags[0] & (AC_USAC | AC_RSVD50 | AC_RSV603DA | AC_ELD))) {
   1378         self->mpsEnableCurr =
   1379             (self->mpsEnableUser &&
   1380              isSupportedMpsConfig(self->streamInfo.aot,
   1381                                   self->streamInfo.numChannels,
   1382                                   (self->flags[0] & AC_MPS_PRESENT) ? 1 : 0));
   1383       }
   1384 
   1385       if (!self->qmfDomain.globalConf.qmfDomainExplicitConfig &&
   1386           self->mpsEnableCurr) {
   1387         /* if not done yet, allocate full MPEG Surround decoder instance */
   1388         if (mpegSurroundDecoder_IsFullMpegSurroundDecoderInstanceAvailable(
   1389                 (CMpegSurroundDecoder *)self->pMpegSurroundDecoder) ==
   1390             SAC_INSTANCE_NOT_FULL_AVAILABLE) {
   1391           if (mpegSurroundDecoder_Open(
   1392                   (CMpegSurroundDecoder **)&self->pMpegSurroundDecoder, -1,
   1393                   &self->qmfDomain)) {
   1394             return AAC_DEC_OUT_OF_MEMORY;
   1395           }
   1396         }
   1397       }
   1398 
   1399       CAacDecoder_SyncQmfMode(self);
   1400 
   1401       if (!self->qmfDomain.globalConf.qmfDomainExplicitConfig &&
   1402           self->mpsEnableCurr) {
   1403         SAC_INPUT_CONFIG sac_interface = (self->sbrEnabled && self->hSbrDecoder)
   1404                                              ? SAC_INTERFACE_QMF
   1405                                              : SAC_INTERFACE_TIME;
   1406         /* needs to be done before first SBR apply. */
   1407         mpegSurroundDecoder_ConfigureQmfDomain(
   1408             (CMpegSurroundDecoder *)self->pMpegSurroundDecoder, sac_interface,
   1409             (UINT)self->streamInfo.aacSampleRate, self->streamInfo.aot);
   1410         if (self->qmfDomain.globalConf.nBandsAnalysis_requested > 0) {
   1411           self->qmfDomain.globalConf.nQmfTimeSlots_requested =
   1412               self->streamInfo.aacSamplesPerFrame /
   1413               self->qmfDomain.globalConf.nBandsAnalysis_requested;
   1414         } else {
   1415           self->qmfDomain.globalConf.nQmfTimeSlots_requested = 0;
   1416         }
   1417       }
   1418 
   1419       self->qmfDomain.globalConf.TDinput = pTimeData;
   1420 
   1421       switch (FDK_QmfDomain_Configure(&self->qmfDomain)) {
   1422         default:
   1423         case QMF_DOMAIN_INIT_ERROR:
   1424           ErrorStatus = AAC_DEC_UNKNOWN;
   1425           goto bail;
   1426         case QMF_DOMAIN_OUT_OF_MEMORY:
   1427           ErrorStatus = AAC_DEC_OUT_OF_MEMORY;
   1428           goto bail;
   1429         case QMF_DOMAIN_OK:
   1430           break;
   1431       }
   1432 
   1433       /* sbr decoder */
   1434 
   1435       if ((ErrorStatus != AAC_DEC_OK) || (flags & AACDEC_CONCEAL) ||
   1436           self->pAacDecoderStaticChannelInfo[0]->concealmentInfo.concealState >
   1437               ConcealState_FadeIn) {
   1438         self->frameOK = 0; /* if an error has occured do concealment in the SBR
   1439                               decoder too */
   1440       }
   1441 
   1442       if (self->sbrEnabled && (!(self->flags[0] & AC_USAC_SCFGI3))) {
   1443         SBR_ERROR sbrError = SBRDEC_OK;
   1444         int chIdx, numCoreChannel = self->streamInfo.numChannels;
   1445 
   1446         /* set params */
   1447         sbrDecoder_SetParam(self->hSbrDecoder, SBR_SYSTEM_BITSTREAM_DELAY,
   1448                             self->sbrParams.bsDelay);
   1449         sbrDecoder_SetParam(
   1450             self->hSbrDecoder, SBR_FLUSH_DATA,
   1451             (flags & AACDEC_FLUSH) |
   1452                 ((self->flushStatus && !(flags & AACDEC_CONCEAL)) ? AACDEC_FLUSH
   1453                                                                   : 0));
   1454 
   1455         if (self->streamInfo.aot == AOT_ER_AAC_ELD) {
   1456           /* Configure QMF */
   1457           sbrDecoder_SetParam(self->hSbrDecoder, SBR_LD_QMF_TIME_ALIGN,
   1458                               (self->flags[0] & AC_MPS_PRESENT) ? 1 : 0);
   1459         }
   1460 
   1461         {
   1462           PCMDMX_ERROR dmxErr;
   1463           INT maxOutCh = 0;
   1464 
   1465           dmxErr = pcmDmx_GetParam(self->hPcmUtils,
   1466                                    MAX_NUMBER_OF_OUTPUT_CHANNELS, &maxOutCh);
   1467           if ((dmxErr == PCMDMX_OK) && (maxOutCh == 1)) {
   1468             /* Disable PS processing if we have to create a mono output signal.
   1469              */
   1470             self->psPossible = 0;
   1471           }
   1472         }
   1473 
   1474         sbrDecoder_SetParam(self->hSbrDecoder, SBR_SKIP_QMF,
   1475                             (self->mpsEnableCurr) ? 2 : 0);
   1476 
   1477         INT_PCM *input;
   1478         input = (INT_PCM *)self->workBufferCore2;
   1479         FDKmemcpy(input, pTimeData,
   1480                   sizeof(INT_PCM) * (self->streamInfo.numChannels) *
   1481                       (self->streamInfo.frameSize));
   1482 
   1483         /* apply SBR processing */
   1484         sbrError = sbrDecoder_Apply(self->hSbrDecoder, input, pTimeData,
   1485                                     timeDataSize, &self->streamInfo.numChannels,
   1486                                     &self->streamInfo.sampleRate,
   1487                                     &self->mapDescr, self->chMapIndex,
   1488                                     self->frameOK, &self->psPossible);
   1489 
   1490         if (sbrError == SBRDEC_OK) {
   1491           /* Update data in streaminfo structure. Assume that the SBR upsampling
   1492              factor is either 1, 2, 8/3 or 4. Maximum upsampling factor is 4
   1493              (CELP+SBR or USAC 4:1 SBR) */
   1494           self->flags[0] |= AC_SBR_PRESENT;
   1495           if (self->streamInfo.aacSampleRate != self->streamInfo.sampleRate) {
   1496             if (self->streamInfo.aacSampleRate >> 2 ==
   1497                 self->streamInfo.sampleRate) {
   1498               self->streamInfo.frameSize =
   1499                   self->streamInfo.aacSamplesPerFrame >> 2;
   1500               self->streamInfo.outputDelay = self->streamInfo.outputDelay >> 2;
   1501             } else if (self->streamInfo.aacSampleRate >> 1 ==
   1502                        self->streamInfo.sampleRate) {
   1503               self->streamInfo.frameSize =
   1504                   self->streamInfo.aacSamplesPerFrame >> 1;
   1505               self->streamInfo.outputDelay = self->streamInfo.outputDelay >> 1;
   1506             } else if (self->streamInfo.aacSampleRate << 1 ==
   1507                        self->streamInfo.sampleRate) {
   1508               self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame
   1509                                            << 1;
   1510               self->streamInfo.outputDelay = self->streamInfo.outputDelay << 1;
   1511             } else if (self->streamInfo.aacSampleRate << 2 ==
   1512                        self->streamInfo.sampleRate) {
   1513               self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame
   1514                                            << 2;
   1515               self->streamInfo.outputDelay = self->streamInfo.outputDelay << 2;
   1516             } else if (self->streamInfo.frameSize == 768) {
   1517               self->streamInfo.frameSize =
   1518                   (self->streamInfo.aacSamplesPerFrame << 3) / 3;
   1519               self->streamInfo.outputDelay =
   1520                   (self->streamInfo.outputDelay << 3) / 3;
   1521             } else {
   1522               ErrorStatus = AAC_DEC_SET_PARAM_FAIL;
   1523               goto bail;
   1524             }
   1525           } else {
   1526             self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame;
   1527           }
   1528           self->streamInfo.outputDelay +=
   1529               sbrDecoder_GetDelay(self->hSbrDecoder);
   1530 
   1531           if (self->psPossible) {
   1532             self->flags[0] |= AC_PS_PRESENT;
   1533           }
   1534           for (chIdx = numCoreChannel; chIdx < self->streamInfo.numChannels;
   1535                chIdx += 1) {
   1536             self->channelType[chIdx] = ACT_FRONT;
   1537             self->channelIndices[chIdx] = chIdx;
   1538           }
   1539         }
   1540         if (sbrError == SBRDEC_OUTPUT_BUFFER_TOO_SMALL) {
   1541           ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
   1542           goto bail;
   1543         }
   1544       }
   1545 
   1546       if (self->mpsEnableCurr) {
   1547         int err, sac_interface, nChannels, frameSize;
   1548 
   1549         nChannels = self->streamInfo.numChannels;
   1550         frameSize = self->streamInfo.frameSize;
   1551         sac_interface = SAC_INTERFACE_TIME;
   1552 
   1553         if (self->sbrEnabled && self->hSbrDecoder)
   1554           sac_interface = SAC_INTERFACE_QMF;
   1555         if (self->streamInfo.aot == AOT_USAC) {
   1556           if (self->flags[0] & AC_USAC_SCFGI3) {
   1557             sac_interface = SAC_INTERFACE_TIME;
   1558           }
   1559         }
   1560         err = mpegSurroundDecoder_SetParam(
   1561             (CMpegSurroundDecoder *)self->pMpegSurroundDecoder,
   1562             SACDEC_INTERFACE, sac_interface);
   1563 
   1564         if (err == 0) {
   1565           err = mpegSurroundDecoder_Apply(
   1566               (CMpegSurroundDecoder *)self->pMpegSurroundDecoder,
   1567               (INT_PCM *)self->workBufferCore2, pTimeData, timeDataSize,
   1568               self->streamInfo.aacSamplesPerFrame, &nChannels, &frameSize,
   1569               self->streamInfo.sampleRate, self->streamInfo.aot,
   1570               self->channelType, self->channelIndices, &self->mapDescr);
   1571         }
   1572 
   1573         if (err == MPS_OUTPUT_BUFFER_TOO_SMALL) {
   1574           ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
   1575           goto bail;
   1576         }
   1577         if (err == 0) {
   1578           /* Update output parameter */
   1579           self->streamInfo.numChannels = nChannels;
   1580           self->streamInfo.frameSize = frameSize;
   1581           self->streamInfo.outputDelay += mpegSurroundDecoder_GetDelay(
   1582               (CMpegSurroundDecoder *)self->pMpegSurroundDecoder);
   1583           /* Save current parameter for possible concealment of next frame */
   1584           self->mpsOutChannelsLast = nChannels;
   1585           self->mpsFrameSizeLast = frameSize;
   1586         } else if ((self->mpsOutChannelsLast > 0) &&
   1587                    (self->mpsFrameSizeLast > 0)) {
   1588           /* Restore parameters of last frame ... */
   1589           self->streamInfo.numChannels = self->mpsOutChannelsLast;
   1590           self->streamInfo.frameSize = self->mpsFrameSizeLast;
   1591           /* ... and clear output buffer so that potentially corrupted data does
   1592            * not reach the framework. */
   1593           FDKmemclear(pTimeData, self->mpsOutChannelsLast *
   1594                                      self->mpsFrameSizeLast * sizeof(INT_PCM));
   1595           /* Additionally proclaim that this frame had errors during decoding.
   1596            */
   1597           ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
   1598         } else {
   1599           ErrorStatus = AAC_DEC_UNKNOWN; /* no output */
   1600         }
   1601       }
   1602 
   1603       /* SBR decoder for Unified Stereo Config (stereoConfigIndex == 3) */
   1604 
   1605       if (self->sbrEnabled && (self->flags[0] & AC_USAC_SCFGI3)) {
   1606         SBR_ERROR sbrError = SBRDEC_OK;
   1607 
   1608         /* set params */
   1609         sbrDecoder_SetParam(self->hSbrDecoder, SBR_SYSTEM_BITSTREAM_DELAY,
   1610                             self->sbrParams.bsDelay);
   1611 
   1612         sbrDecoder_SetParam(self->hSbrDecoder, SBR_SKIP_QMF, 1);
   1613 
   1614         /* apply SBR processing */
   1615         sbrError = sbrDecoder_Apply(self->hSbrDecoder, pTimeData, pTimeData,
   1616                                     timeDataSize, &self->streamInfo.numChannels,
   1617                                     &self->streamInfo.sampleRate,
   1618                                     &self->mapDescr, self->chMapIndex,
   1619                                     self->frameOK, &self->psPossible);
   1620 
   1621         if (sbrError == SBRDEC_OK) {
   1622           /* Update data in streaminfo structure. Assume that the SBR upsampling
   1623            * factor is either 1,2 or 4 */
   1624           self->flags[0] |= AC_SBR_PRESENT;
   1625           if (self->streamInfo.aacSampleRate != self->streamInfo.sampleRate) {
   1626             if (self->streamInfo.frameSize == 768) {
   1627               self->streamInfo.frameSize =
   1628                   (self->streamInfo.aacSamplesPerFrame * 8) / 3;
   1629             } else if (self->streamInfo.aacSampleRate << 2 ==
   1630                        self->streamInfo.sampleRate) {
   1631               self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame
   1632                                            << 2;
   1633             } else {
   1634               self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame
   1635                                            << 1;
   1636             }
   1637           }
   1638 
   1639           self->flags[0] &= ~AC_PS_PRESENT;
   1640         }
   1641         if (sbrError == SBRDEC_OUTPUT_BUFFER_TOO_SMALL) {
   1642           ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
   1643           goto bail;
   1644         }
   1645       }
   1646 
   1647       /* Use dedicated memory for PCM postprocessing */
   1648       pTimeDataPcmPost = self->pTimeData2;
   1649       timeDataPcmPostSize = self->timeData2Size;
   1650 
   1651       {
   1652         const int size =
   1653             self->streamInfo.frameSize * self->streamInfo.numChannels;
   1654         FDK_ASSERT(timeDataPcmPostSize >= size);
   1655         for (int i = 0; i < size; i++) {
   1656           pTimeDataPcmPost[i] =
   1657               (PCM_DEC)FX_PCM2PCM_DEC(pTimeData[i]) >> PCM_OUT_HEADROOM;
   1658         }
   1659       }
   1660 
   1661       {
   1662         if ((FDK_drcDec_GetParam(self->hUniDrcDecoder, DRC_DEC_IS_ACTIVE)) &&
   1663             !(self->flags[0] & AC_RSV603DA)) {
   1664           /* Apply DRC gains*/
   1665           int ch, drcDelay = 0;
   1666           int needsDeinterleaving = 0;
   1667           FIXP_DBL *drcWorkBuffer = NULL;
   1668           FIXP_DBL channelGain[(8)];
   1669           int reverseInChannelMap[(8)];
   1670           int reverseOutChannelMap[(8)];
   1671           int numDrcOutChannels = FDK_drcDec_GetParam(
   1672               self->hUniDrcDecoder, DRC_DEC_TARGET_CHANNEL_COUNT_SELECTED);
   1673           FDKmemclear(channelGain, sizeof(channelGain));
   1674           for (ch = 0; ch < (8); ch++) {
   1675             reverseInChannelMap[ch] = ch;
   1676             reverseOutChannelMap[ch] = ch;
   1677           }
   1678 
   1679           /* Update sampleRate and frameSize. This may be necessary in case of
   1680            * implicit SBR signaling */
   1681           FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_SAMPLE_RATE,
   1682                               self->streamInfo.sampleRate);
   1683           FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_FRAME_SIZE,
   1684                               self->streamInfo.frameSize);
   1685 
   1686           /* If SBR and/or MPS is active, the DRC gains are aligned to the QMF
   1687              domain signal before the QMF synthesis. Therefore the DRC gains
   1688              need to be delayed by the QMF synthesis delay. */
   1689           if (self->sbrEnabled) drcDelay = 257;
   1690           if (self->mpsEnableCurr) drcDelay = 257;
   1691           /* Take into account concealment delay */
   1692           drcDelay += CConcealment_GetDelay(&self->concealCommonData) *
   1693                       self->streamInfo.frameSize;
   1694 
   1695           for (ch = 0; ch < self->streamInfo.numChannels; ch++) {
   1696             UCHAR mapValue = FDK_chMapDescr_getMapValue(
   1697                 &self->mapDescr, (UCHAR)ch, self->chMapIndex);
   1698             if (mapValue < (8)) reverseInChannelMap[mapValue] = ch;
   1699           }
   1700           for (ch = 0; ch < (int)numDrcOutChannels; ch++) {
   1701             UCHAR mapValue = FDK_chMapDescr_getMapValue(
   1702                 &self->mapDescr, (UCHAR)ch, numDrcOutChannels);
   1703             if (mapValue < (8)) reverseOutChannelMap[mapValue] = ch;
   1704           }
   1705 
   1706           /* The output of SBR and MPS is interleaved. Deinterleaving may be
   1707            * necessary for FDK_drcDec_ProcessTime, which accepts deinterleaved
   1708            * audio only. */
   1709           if ((self->streamInfo.numChannels > 1) &&
   1710               (0 || (self->sbrEnabled) || (self->mpsEnableCurr))) {
   1711             /* interleaving/deinterleaving is performed on upper part of
   1712              * pTimeDataPcmPost. Check if this buffer is large enough. */
   1713             if (timeDataPcmPostSize <
   1714                 (INT)(2 * self->streamInfo.numChannels *
   1715                       self->streamInfo.frameSize * sizeof(PCM_DEC))) {
   1716               ErrorStatus = AAC_DEC_UNKNOWN;
   1717               goto bail;
   1718             }
   1719             needsDeinterleaving = 1;
   1720             drcWorkBuffer =
   1721                 (FIXP_DBL *)pTimeDataPcmPost +
   1722                 self->streamInfo.numChannels * self->streamInfo.frameSize;
   1723             FDK_deinterleave(
   1724                 pTimeDataPcmPost, drcWorkBuffer, self->streamInfo.numChannels,
   1725                 self->streamInfo.frameSize, self->streamInfo.frameSize);
   1726           } else {
   1727             drcWorkBuffer = (FIXP_DBL *)pTimeDataPcmPost;
   1728           }
   1729 
   1730           /* prepare Loudness Normalisation gain */
   1731           FDK_drcDec_SetParam(self->hUniDrcDecoder, DRC_DEC_TARGET_LOUDNESS,
   1732                               (INT)-self->defaultTargetLoudness *
   1733                                   FL2FXCONST_DBL(1.0f / (float)(1 << 9)));
   1734           FDK_drcDec_SetChannelGains(self->hUniDrcDecoder,
   1735                                      self->streamInfo.numChannels,
   1736                                      self->streamInfo.frameSize, channelGain,
   1737                                      drcWorkBuffer, self->streamInfo.frameSize);
   1738           FDK_drcDec_Preprocess(self->hUniDrcDecoder);
   1739 
   1740           /* apply DRC1 gain sequence */
   1741           for (ch = 0; ch < self->streamInfo.numChannels; ch++) {
   1742             FDK_drcDec_ProcessTime(self->hUniDrcDecoder, drcDelay, DRC_DEC_DRC1,
   1743                                    ch, reverseInChannelMap[ch] - ch, 1,
   1744                                    drcWorkBuffer, self->streamInfo.frameSize);
   1745           }
   1746           /* apply downmix */
   1747           FDK_drcDec_ApplyDownmix(
   1748               self->hUniDrcDecoder, reverseInChannelMap, reverseOutChannelMap,
   1749               drcWorkBuffer,
   1750               &self->streamInfo.numChannels); /* self->streamInfo.numChannels
   1751                                                  may change here */
   1752           /* apply DRC2/3 gain sequence */
   1753           for (ch = 0; ch < self->streamInfo.numChannels; ch++) {
   1754             FDK_drcDec_ProcessTime(self->hUniDrcDecoder, drcDelay,
   1755                                    DRC_DEC_DRC2_DRC3, ch,
   1756                                    reverseOutChannelMap[ch] - ch, 1,
   1757                                    drcWorkBuffer, self->streamInfo.frameSize);
   1758           }
   1759 
   1760           if (needsDeinterleaving) {
   1761             FDK_interleave(
   1762                 drcWorkBuffer, pTimeDataPcmPost, self->streamInfo.numChannels,
   1763                 self->streamInfo.frameSize, self->streamInfo.frameSize);
   1764           }
   1765         }
   1766       }
   1767 
   1768       if (self->streamInfo.extAot != AOT_AAC_SLS) {
   1769         INT pcmLimiterScale = 0;
   1770         PCMDMX_ERROR dmxErr = PCMDMX_OK;
   1771         if (flags & (AACDEC_INTR)) {
   1772           /* delete data from the past (e.g. mixdown coeficients) */
   1773           pcmDmx_Reset(self->hPcmUtils, PCMDMX_RESET_BS_DATA);
   1774         }
   1775         if (flags & (AACDEC_CLRHIST)) {
   1776           if (!(self->flags[0] & AC_USAC)) {
   1777             /* delete data from the past (e.g. mixdown coeficients) */
   1778             pcmDmx_Reset(self->hPcmUtils, PCMDMX_RESET_BS_DATA);
   1779           }
   1780         }
   1781 
   1782         INT interleaved = 0;
   1783         interleaved |= (self->sbrEnabled) ? 1 : 0;
   1784         interleaved |= (self->mpsEnableCurr) ? 1 : 0;
   1785 
   1786         /* do PCM post processing */
   1787         dmxErr = pcmDmx_ApplyFrame(
   1788             self->hPcmUtils, pTimeDataPcmPost, timeDataFixpPcmSize,
   1789             self->streamInfo.frameSize, &self->streamInfo.numChannels,
   1790             interleaved, self->channelType, self->channelIndices,
   1791             &self->mapDescr,
   1792             (self->limiterEnableCurr) ? &pcmLimiterScale : NULL);
   1793         if (dmxErr == PCMDMX_OUTPUT_BUFFER_TOO_SMALL) {
   1794           ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
   1795           goto bail;
   1796         }
   1797         if ((ErrorStatus == AAC_DEC_OK) && (dmxErr == PCMDMX_INVALID_MODE)) {
   1798           /* Announce the framework that the current combination of channel
   1799            * configuration and downmix settings are not know to produce a
   1800            * predictable behavior and thus maybe produce strange output. */
   1801           ErrorStatus = AAC_DEC_DECODE_FRAME_ERROR;
   1802         }
   1803 
   1804         if (flags & AACDEC_CLRHIST) {
   1805           if (!(self->flags[0] & AC_USAC)) {
   1806             /* Delete the delayed signal. */
   1807             pcmLimiter_Reset(self->hLimiter);
   1808           }
   1809         }
   1810 
   1811         if (self->limiterEnableCurr) {
   1812           /* use workBufferCore2 buffer for interleaving */
   1813           PCM_LIM *pInterleaveBuffer;
   1814           int blockLength = self->streamInfo.frameSize;
   1815 
   1816           /* Set actual signal parameters */
   1817           pcmLimiter_SetNChannels(self->hLimiter, self->streamInfo.numChannels);
   1818           pcmLimiter_SetSampleRate(self->hLimiter, self->streamInfo.sampleRate);
   1819           pcmLimiterScale += PCM_OUT_HEADROOM;
   1820 
   1821           if ((self->streamInfo.numChannels == 1) || (self->sbrEnabled) ||
   1822               (self->mpsEnableCurr)) {
   1823             pInterleaveBuffer = (PCM_LIM *)pTimeDataPcmPost;
   1824           } else {
   1825             pInterleaveBuffer = (PCM_LIM *)pTimeData;
   1826             /* applyLimiter requests for interleaved data */
   1827             /* Interleave ouput buffer */
   1828             FDK_interleave(pTimeDataPcmPost, pInterleaveBuffer,
   1829                            self->streamInfo.numChannels, blockLength,
   1830                            self->streamInfo.frameSize);
   1831           }
   1832 
   1833           pcmLimiter_Apply(self->hLimiter, pInterleaveBuffer, pTimeData,
   1834                            self->extGain, &pcmLimiterScale, 1,
   1835                            self->extGainDelay, self->streamInfo.frameSize);
   1836 
   1837           {
   1838             /* Announce the additional limiter output delay */
   1839             self->streamInfo.outputDelay += pcmLimiter_GetDelay(self->hLimiter);
   1840           }
   1841         } else {
   1842           /* If numChannels = 1 we do not need interleaving. The same applies if
   1843           SBR or MPS are used, since their output is interleaved already
   1844           (resampled or not) */
   1845           if ((self->streamInfo.numChannels == 1) || (self->sbrEnabled) ||
   1846               (self->mpsEnableCurr)) {
   1847             scaleValuesSaturate(
   1848                 pTimeData, pTimeDataPcmPost,
   1849                 self->streamInfo.frameSize * self->streamInfo.numChannels,
   1850                 PCM_OUT_HEADROOM);
   1851 
   1852           } else {
   1853             scaleValuesSaturate(
   1854                 (INT_PCM *)self->workBufferCore2, pTimeDataPcmPost,
   1855                 self->streamInfo.frameSize * self->streamInfo.numChannels,
   1856                 PCM_OUT_HEADROOM);
   1857             /* Interleave ouput buffer */
   1858             FDK_interleave((INT_PCM *)self->workBufferCore2, pTimeData,
   1859                            self->streamInfo.numChannels,
   1860                            self->streamInfo.frameSize,
   1861                            self->streamInfo.frameSize);
   1862           }
   1863         }
   1864       } /* if (self->streamInfo.extAot != AOT_AAC_SLS)*/
   1865 
   1866       if (self->flags[0] & AC_USAC) {
   1867         if (self->flushStatus == AACDEC_USAC_DASH_IPF_FLUSH_ON &&
   1868             !(flags & AACDEC_CONCEAL)) {
   1869           CAacDecoder_PrepareCrossFade(pTimeData, self->pTimeDataFlush,
   1870                                        self->streamInfo.numChannels,
   1871                                        self->streamInfo.frameSize, 1);
   1872         }
   1873 
   1874         /* prepare crossfade buffer for fade in */
   1875         if (!applyCrossfade && self->applyCrossfade &&
   1876             !(flags & AACDEC_CONCEAL)) {
   1877           for (int ch = 0; ch < self->streamInfo.numChannels; ch++) {
   1878             for (int i = 0; i < TIME_DATA_FLUSH_SIZE; i++) {
   1879               self->pTimeDataFlush[ch][i] = 0;
   1880             }
   1881           }
   1882           applyCrossfade = 1;
   1883         }
   1884 
   1885         if (applyCrossfade && self->applyCrossfade &&
   1886             !(accessUnit < numPrerollAU) &&
   1887             (self->buildUpStatus == AACDEC_USAC_BUILD_UP_ON)) {
   1888           CAacDecoder_ApplyCrossFade(pTimeData, self->pTimeDataFlush,
   1889                                      self->streamInfo.numChannels,
   1890                                      self->streamInfo.frameSize, 1);
   1891           self->applyCrossfade = 0;
   1892         }
   1893       }
   1894 
   1895       /* Signal interruption to take effect in next frame. */
   1896       if ((flags & AACDEC_FLUSH || self->flushStatus) &&
   1897           !(flags & AACDEC_CONCEAL)) {
   1898         aacDecoder_SignalInterruption(self);
   1899       }
   1900 
   1901       /* Update externally visible copy of flags */
   1902       self->streamInfo.flags = self->flags[0];
   1903 
   1904     } /* USAC DASH IPF flushing possible end */
   1905     if (accessUnit < numPrerollAU) {
   1906       FDKpushBack(hBsAu, auStartAnchor - (INT)FDKgetValidBits(hBsAu));
   1907     } else {
   1908       if ((self->buildUpStatus == AACDEC_RSV60_BUILD_UP_ON) ||
   1909           (self->buildUpStatus == AACDEC_RSV60_BUILD_UP_ON_IN_BAND) ||
   1910           (self->buildUpStatus == AACDEC_USAC_BUILD_UP_ON)) {
   1911         self->buildUpCnt--;
   1912 
   1913         if (self->buildUpCnt < 0) {
   1914           self->buildUpStatus = 0;
   1915         }
   1916       }
   1917 
   1918       if (self->flags[0] & AC_USAC) {
   1919         if (self->flushStatus == AACDEC_USAC_DASH_IPF_FLUSH_ON &&
   1920             !(flags & AACDEC_CONCEAL)) {
   1921           self->streamInfo.frameSize = 0;
   1922         }
   1923       }
   1924     }
   1925 
   1926     if (self->flushStatus != AACDEC_USAC_DASH_IPF_FLUSH_ON) {
   1927       accessUnit++;
   1928     }
   1929   } while ((accessUnit < numAccessUnits) ||
   1930            ((self->flushStatus == AACDEC_USAC_DASH_IPF_FLUSH_ON) &&
   1931             !(flags & AACDEC_CONCEAL)));
   1932 
   1933 bail:
   1934 
   1935   /* error in renderer part occurred, ErrorStatus was set to invalid output */
   1936   if (fEndAuNotAdjusted && !IS_OUTPUT_VALID(ErrorStatus) &&
   1937       (accessUnit < numPrerollAU)) {
   1938     transportDec_EndAccessUnit(self->hInput);
   1939   }
   1940 
   1941   /* Update Statistics */
   1942   aacDecoder_UpdateBitStreamCounters(&self->streamInfo, hBs, nBits,
   1943                                      ErrorStatus);
   1944   if (((self->streamInfo.numChannels <= 0) ||
   1945        (self->streamInfo.frameSize <= 0) ||
   1946        (self->streamInfo.sampleRate <= 0)) &&
   1947       IS_OUTPUT_VALID(ErrorStatus)) {
   1948     /* Ensure consistency of IS_OUTPUT_VALID() macro. */
   1949     ErrorStatus = AAC_DEC_UNKNOWN;
   1950   }
   1951 
   1952   /* Check whether external output buffer is large enough. */
   1953   if (timeDataSize_extern <
   1954       self->streamInfo.numChannels * self->streamInfo.frameSize) {
   1955     ErrorStatus = AAC_DEC_OUTPUT_BUFFER_TOO_SMALL;
   1956   }
   1957 
   1958   /* Update external output buffer. */
   1959   if (IS_OUTPUT_VALID(ErrorStatus)) {
   1960     FDKmemcpy(pTimeData_extern, pTimeData,
   1961               self->streamInfo.numChannels * self->streamInfo.frameSize *
   1962                   sizeof(*pTimeData));
   1963   } else {
   1964     FDKmemclear(pTimeData_extern,
   1965                 timeDataSize_extern * sizeof(*pTimeData_extern));
   1966   }
   1967 
   1968   return ErrorStatus;
   1969 }
   1970 
   1971 LINKSPEC_CPP void aacDecoder_Close(HANDLE_AACDECODER self) {
   1972   if (self == NULL) return;
   1973 
   1974   if (self->hLimiter != NULL) {
   1975     pcmLimiter_Destroy(self->hLimiter);
   1976   }
   1977 
   1978   if (self->hPcmUtils != NULL) {
   1979     pcmDmx_Close(&self->hPcmUtils);
   1980   }
   1981 
   1982   FDK_drcDec_Close(&self->hUniDrcDecoder);
   1983 
   1984   if (self->pMpegSurroundDecoder != NULL) {
   1985     mpegSurroundDecoder_Close(
   1986         (CMpegSurroundDecoder *)self->pMpegSurroundDecoder);
   1987   }
   1988 
   1989   if (self->hSbrDecoder != NULL) {
   1990     sbrDecoder_Close(&self->hSbrDecoder);
   1991   }
   1992 
   1993   if (self->hInput != NULL) {
   1994     transportDec_Close(&self->hInput);
   1995   }
   1996 
   1997   CAacDecoder_Close(self);
   1998 }
   1999 
   2000 LINKSPEC_CPP CStreamInfo *aacDecoder_GetStreamInfo(HANDLE_AACDECODER self) {
   2001   return CAacDecoder_GetStreamInfo(self);
   2002 }
   2003 
   2004 LINKSPEC_CPP INT aacDecoder_GetLibInfo(LIB_INFO *info) {
   2005   int i;
   2006 
   2007   if (info == NULL) {
   2008     return -1;
   2009   }
   2010 
   2011   sbrDecoder_GetLibInfo(info);
   2012   mpegSurroundDecoder_GetLibInfo(info);
   2013   transportDec_GetLibInfo(info);
   2014   FDK_toolsGetLibInfo(info);
   2015   pcmDmx_GetLibInfo(info);
   2016   pcmLimiter_GetLibInfo(info);
   2017   FDK_drcDec_GetLibInfo(info);
   2018 
   2019   /* search for next free tab */
   2020   for (i = 0; i < FDK_MODULE_LAST; i++) {
   2021     if (info[i].module_id == FDK_NONE) break;
   2022   }
   2023   if (i == FDK_MODULE_LAST) {
   2024     return -1;
   2025   }
   2026   info += i;
   2027 
   2028   info->module_id = FDK_AACDEC;
   2029   /* build own library info */
   2030   info->version =
   2031       LIB_VERSION(AACDECODER_LIB_VL0, AACDECODER_LIB_VL1, AACDECODER_LIB_VL2);
   2032   LIB_VERSION_STRING(info);
   2033   info->build_date = AACDECODER_LIB_BUILD_DATE;
   2034   info->build_time = AACDECODER_LIB_BUILD_TIME;
   2035   info->title = AACDECODER_LIB_TITLE;
   2036 
   2037   /* Set flags */
   2038   info->flags = 0 | CAPF_AAC_LC | CAPF_ER_AAC_LC | CAPF_ER_AAC_SCAL |
   2039                 CAPF_AAC_VCB11 | CAPF_AAC_HCR | CAPF_AAC_RVLC | CAPF_ER_AAC_LD |
   2040                 CAPF_ER_AAC_ELD | CAPF_AAC_CONCEALMENT | CAPF_AAC_DRC |
   2041                 CAPF_AAC_MPEG4 | CAPF_AAC_DRM_BSFORMAT | CAPF_AAC_1024 |
   2042                 CAPF_AAC_960 | CAPF_AAC_512 | CAPF_AAC_480 |
   2043                 CAPF_AAC_ELD_DOWNSCALE
   2044 
   2045                 | CAPF_AAC_USAC | CAPF_ER_AAC_ELDV2 | CAPF_AAC_UNIDRC;
   2046   /* End of flags */
   2047 
   2048   return 0;
   2049 }
   2050