Home | History | Annotate | Download | only in src
      1 
      2 /* -----------------------------------------------------------------------------------------------------------
      3 Software License for The Fraunhofer FDK AAC Codec Library for Android
      4 
      5  Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V.
      6   All rights reserved.
      7 
      8  1.    INTRODUCTION
      9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
     10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
     11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
     12 
     13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
     14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
     15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
     16 of the MPEG specifications.
     17 
     18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
     19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
     20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
     21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
     22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
     23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
     24 
     25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
     26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
     27 applications information and documentation.
     28 
     29 2.    COPYRIGHT LICENSE
     30 
     31 Redistribution and use in source and binary forms, with or without modification, are permitted without
     32 payment of copyright license fees provided that you satisfy the following conditions:
     33 
     34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
     35 your modifications thereto in source code form.
     36 
     37 You must retain the complete text of this software license in the documentation and/or other materials
     38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
     39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
     40 modifications thereto to recipients of copies in binary form.
     41 
     42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
     43 prior written permission.
     44 
     45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
     46 software or your modifications thereto.
     47 
     48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
     49 and the date of any change. For modified versions of the FDK AAC Codec, the term
     50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
     51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
     52 
     53 3.    NO PATENT LICENSE
     54 
     55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
     56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
     57 respect to this software.
     58 
     59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
     60 by appropriate patent licenses.
     61 
     62 4.    DISCLAIMER
     63 
     64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
     65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
     66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
     68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
     69 or business interruption, however caused and on any theory of liability, whether in contract, strict
     70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
     71 advised of the possibility of such damage.
     72 
     73 5.    CONTACT INFORMATION
     74 
     75 Fraunhofer Institute for Integrated Circuits IIS
     76 Attention: Audio and Multimedia Departments - FDK AAC LL
     77 Am Wolfsmantel 33
     78 91058 Erlangen, Germany
     79 
     80 www.iis.fraunhofer.de/amm
     81 amm-info (at) iis.fraunhofer.de
     82 ----------------------------------------------------------------------------------------------------------- */
     83 
     84 /*!
     85   \file
     86   \brief  SBR decoder frontend
     87   This module provides a frontend to the SBR decoder. The function openSBR() is called for
     88   initialization. The function sbrDecoder_Apply() is called for each frame. sbr_Apply() will call the
     89   required functions to decode the raw SBR data (provided by env_extr.cpp), to decode the envelope data and noise floor levels [decodeSbrData()],
     90   and to finally apply SBR to the current frame [sbr_dec()].
     91 
     92   \sa sbrDecoder_Apply(), \ref documentationOverview
     93 */
     94 
     95 /*!
     96   \page documentationOverview Overview of important information resources and source code documentation
     97 
     98   The primary source code documentation is based on generated and cross-referenced HTML files using
     99   <a HREF="http://www.doxygen.org">doxygen</a>. As part of this documentation
    100   you can find more extensive descriptions about key concepts and algorithms at the following locations:
    101 
    102   <h2>Programming</h2>
    103 
    104   \li Buffer management: sbrDecoder_Apply() and sbr_dec()
    105   \li Internal scale factors to maximize SNR on fixed point processors: #QMF_SCALE_FACTOR
    106   \li Special mantissa-exponent format: Created in requantizeEnvelopeData() and used in calculateSbrEnvelope()
    107 
    108   <h2>Algorithmic details</h2>
    109   \li About the SBR data format: \ref SBR_HEADER_ELEMENT and \ref SBR_STANDARD_ELEMENT
    110   \li Details about the bitstream decoder: env_extr.cpp
    111   \li Details about the QMF filterbank and the provided polyphase implementation: qmf_dec.cpp
    112   \li Details about the transposer: lpp_tran.cpp
    113   \li Details about the envelope adjuster: env_calc.cpp
    114 
    115 */
    116 
    117 #include "sbrdecoder.h"
    118 
    119 #include "FDK_bitstream.h"
    120 
    121 #include "sbrdec_freq_sca.h"
    122 #include "env_extr.h"
    123 #include "sbr_dec.h"
    124 #include "env_dec.h"
    125 #include "sbr_crc.h"
    126 #include "sbr_ram.h"
    127 #include "sbr_rom.h"
    128 #include "lpp_tran.h"
    129 #include "transcendent.h"
    130 
    131 
    132 #include "sbrdec_drc.h"
    133 
    134 #include "psbitdec.h"
    135 
    136 
    137 /* Decoder library info */
    138 #define SBRDECODER_LIB_VL0 2
    139 #define SBRDECODER_LIB_VL1 2
    140 #define SBRDECODER_LIB_VL2 3
    141 #define SBRDECODER_LIB_TITLE "SBR Decoder"
    142 #define SBRDECODER_LIB_BUILD_DATE __DATE__
    143 #define SBRDECODER_LIB_BUILD_TIME __TIME__
    144 
    145 
    146 
    147 
    148 static UCHAR getHeaderSlot( UCHAR currentSlot, UCHAR hdrSlotUsage[(1)+1] )
    149 {
    150   UINT  occupied = 0;
    151   int   s;
    152   UCHAR slot = hdrSlotUsage[currentSlot];
    153 
    154   FDK_ASSERT((1)+1 < 32);
    155 
    156   for (s = 0; s < (1)+1; s++) {
    157     if ( (hdrSlotUsage[s] == slot)
    158       && (s != slot) ) {
    159       occupied = 1;
    160       break;
    161     }
    162   }
    163 
    164   if (occupied) {
    165     occupied = 0;
    166 
    167     for (s = 0; s < (1)+1; s++) {
    168       occupied |= 1 << hdrSlotUsage[s];
    169     }
    170     for (s = 0; s < (1)+1; s++) {
    171       if ( !(occupied & 0x1) ) {
    172         slot = s;
    173         break;
    174       }
    175       occupied >>= 1;
    176     }
    177   }
    178 
    179   return slot;
    180 }
    181 
    182 static void copySbrHeader( HANDLE_SBR_HEADER_DATA hDst, const HANDLE_SBR_HEADER_DATA hSrc )
    183 {
    184   /* copy the whole header memory (including pointers) */
    185   FDKmemcpy( hDst, hSrc, sizeof(SBR_HEADER_DATA) );
    186 
    187   /* update pointers */
    188   hDst->freqBandData.freqBandTable[0]  = hDst->freqBandData.freqBandTableLo;
    189   hDst->freqBandData.freqBandTable[1] = hDst->freqBandData.freqBandTableHi;
    190 }
    191 
    192 
    193 /*!
    194   \brief Reset SBR decoder.
    195 
    196   Reset should only be called if SBR has been sucessfully detected by
    197   an appropriate checkForPayload() function.
    198 
    199   \return Error code.
    200 */
    201 static
    202 SBR_ERROR sbrDecoder_ResetElement (
    203         HANDLE_SBRDECODER    self,
    204         int                  sampleRateIn,
    205         int                  sampleRateOut,
    206         int                  samplesPerFrame,
    207         const MP4_ELEMENT_ID elementID,
    208         const int            elementIndex,
    209         const int            overlap
    210         )
    211 {
    212   SBR_ERROR sbrError = SBRDEC_OK;
    213   HANDLE_SBR_HEADER_DATA hSbrHeader;
    214   UINT qmfFlags = 0;
    215 
    216   int i, synDownsampleFac;
    217 
    218   /* Check in/out samplerates */
    219   if ( sampleRateIn < 6400
    220     || sampleRateIn > 48000
    221      )
    222   {
    223     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
    224     goto bail;
    225   }
    226 
    227   if ( sampleRateOut > 96000 )
    228   {
    229     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
    230     goto bail;
    231   }
    232 
    233   /* Set QMF mode flags */
    234   if (self->flags & SBRDEC_LOW_POWER)
    235     qmfFlags |= QMF_FLAG_LP;
    236 
    237   if (self->coreCodec == AOT_ER_AAC_ELD) {
    238     if (self->flags & SBRDEC_LD_MPS_QMF) {
    239       qmfFlags |=  QMF_FLAG_MPSLDFB;
    240     } else {
    241       qmfFlags |=  QMF_FLAG_CLDFB;
    242     }
    243   }
    244 
    245   /* Set downsampling factor for synthesis filter bank */
    246   if (sampleRateOut == 0)
    247   {
    248     /* no single rate mode */
    249       sampleRateOut = sampleRateIn<<1; /* In case of implicit signalling, assume dual rate SBR */
    250   }
    251 
    252   if ( sampleRateIn == sampleRateOut ) {
    253     synDownsampleFac = 2;
    254   } else {
    255     synDownsampleFac = 1;
    256   }
    257 
    258   self->synDownsampleFac = synDownsampleFac;
    259   self->sampleRateOut = sampleRateOut;
    260 
    261   {
    262     int i;
    263 
    264     for (i = 0; i < (1)+1; i++)
    265     {
    266       hSbrHeader = &(self->sbrHeader[elementIndex][i]);
    267 
    268       /* init a default header such that we can at least do upsampling later */
    269       sbrError = initHeaderData(
    270               hSbrHeader,
    271               sampleRateIn,
    272               sampleRateOut,
    273               samplesPerFrame,
    274               self->flags
    275               );
    276     }
    277   }
    278 
    279   if (sbrError != SBRDEC_OK) {
    280     goto bail;
    281   }
    282 
    283   /* Init SBR channels going to be assigned to a SBR element */
    284   {
    285     int ch;
    286 
    287     for (ch=0; ch<self->pSbrElement[elementIndex]->nChannels; ch++)
    288     {
    289       /* and create sbrDec */
    290       sbrError = createSbrDec (self->pSbrElement[elementIndex]->pSbrChannel[ch],
    291                           hSbrHeader,
    292                          &self->pSbrElement[elementIndex]->transposerSettings,
    293                           synDownsampleFac,
    294                           qmfFlags,
    295                           self->flags,
    296                           overlap,
    297                           ch );
    298 
    299       if (sbrError != SBRDEC_OK) {
    300         goto bail;
    301       }
    302     }
    303   }
    304 
    305   //FDKmemclear(sbr_OverlapBuffer, sizeof(sbr_OverlapBuffer));
    306 
    307   if (self->numSbrElements == 1) {
    308     switch ( self->coreCodec ) {
    309     case AOT_AAC_LC:
    310     case AOT_SBR:
    311     case AOT_PS:
    312     case AOT_ER_AAC_SCAL:
    313     case AOT_DRM_AAC:
    314     case AOT_DRM_SURROUND:
    315       if (CreatePsDec ( &self->hParametricStereoDec, samplesPerFrame )) {
    316         sbrError = SBRDEC_CREATE_ERROR;
    317         goto bail;
    318       }
    319       break;
    320     default:
    321       break;
    322     }
    323   }
    324 
    325   /* Init frame delay slot handling */
    326   self->pSbrElement[elementIndex]->useFrameSlot = 0;
    327   for (i = 0; i < ((1)+1); i++) {
    328     self->pSbrElement[elementIndex]->useHeaderSlot[i] = i;
    329   }
    330 
    331 bail:
    332 
    333   return sbrError;
    334 }
    335 
    336 
    337 SBR_ERROR sbrDecoder_Open ( HANDLE_SBRDECODER  * pSelf )
    338 {
    339   HANDLE_SBRDECODER    self = NULL;
    340   SBR_ERROR sbrError = SBRDEC_OK;
    341 
    342   /* Get memory for this instance */
    343   self = GetRam_SbrDecoder();
    344   if (self == NULL) {
    345     sbrError = SBRDEC_MEM_ALLOC_FAILED;
    346     goto bail;
    347   }
    348 
    349   self->workBuffer1 = GetRam_SbrDecWorkBuffer1();
    350   self->workBuffer2 = GetRam_SbrDecWorkBuffer2();
    351 
    352   if (  self->workBuffer1 == NULL
    353      || self->workBuffer2 == NULL )
    354   {
    355     sbrError = SBRDEC_MEM_ALLOC_FAILED;
    356     goto bail;
    357   }
    358 
    359   /*
    360   Already zero because of calloc
    361   self->numSbrElements = 0;
    362   self->numSbrChannels = 0;
    363   self->codecFrameSize = 0;
    364   */
    365 
    366   self->numDelayFrames = (1);  /* set to the max value by default */
    367 
    368   *pSelf = self;
    369 
    370 bail:
    371   return sbrError;
    372 }
    373 
    374 /**
    375  * \brief determine if the given core codec AOT can be processed or not.
    376  * \param coreCodec core codec audio object type.
    377  * \return 1 if SBR can be processed, 0 if SBR cannot be processed/applied.
    378  */
    379 static
    380 int sbrDecoder_isCoreCodecValid(AUDIO_OBJECT_TYPE coreCodec)
    381 {
    382   switch (coreCodec) {
    383     case AOT_AAC_LC:
    384     case AOT_SBR:
    385     case AOT_PS:
    386     case AOT_ER_AAC_SCAL:
    387     case AOT_ER_AAC_ELD:
    388       return 1;
    389     default:
    390       return 0;
    391   }
    392 }
    393 
    394 static
    395 void sbrDecoder_DestroyElement (
    396         HANDLE_SBRDECODER       self,
    397         const int               elementIndex
    398         )
    399 {
    400   if (self->pSbrElement[elementIndex] != NULL) {
    401     int ch;
    402 
    403     for (ch=0; ch<SBRDEC_MAX_CH_PER_ELEMENT; ch++) {
    404       if (self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) {
    405         deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] );
    406         FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] );
    407         self->numSbrChannels -= 1;
    408       }
    409     }
    410     FreeRam_SbrDecElement( &self->pSbrElement[elementIndex] );
    411     self->numSbrElements -= 1;
    412   }
    413 }
    414 
    415 
    416 SBR_ERROR sbrDecoder_InitElement (
    417         HANDLE_SBRDECODER       self,
    418         const int               sampleRateIn,
    419         const int               sampleRateOut,
    420         const int               samplesPerFrame,
    421         const AUDIO_OBJECT_TYPE coreCodec,
    422         const MP4_ELEMENT_ID    elementID,
    423         const int               elementIndex
    424         )
    425 {
    426   SBR_ERROR sbrError = SBRDEC_OK;
    427   int chCnt=0;
    428   int nSbrElementsStart = self->numSbrElements;
    429 
    430   /* Check core codec AOT */
    431   if (! sbrDecoder_isCoreCodecValid(coreCodec) || elementIndex >= (4)) {
    432     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
    433     goto bail;
    434   }
    435 
    436   if ( elementID != ID_SCE && elementID != ID_CPE && elementID != ID_LFE )
    437   {
    438     sbrError = SBRDEC_UNSUPPORTED_CONFIG;
    439     goto bail;
    440   }
    441 
    442   if (  self->sampleRateIn == sampleRateIn
    443      && self->codecFrameSize == samplesPerFrame
    444      && self->coreCodec == coreCodec
    445      && self->pSbrElement[elementIndex] != NULL
    446      && self->pSbrElement[elementIndex]->elementID == elementID
    447      )
    448   {
    449      /* Nothing to do */
    450      return SBRDEC_OK;
    451   }
    452 
    453   self->sampleRateIn = sampleRateIn;
    454   self->codecFrameSize = samplesPerFrame;
    455   self->coreCodec = coreCodec;
    456 
    457   self->flags = 0;
    458   self->flags |= (coreCodec == AOT_ER_AAC_ELD) ? SBRDEC_ELD_GRID : 0;
    459 
    460   /* Init SBR elements */
    461   {
    462     int elChannels, ch;
    463 
    464     if (self->pSbrElement[elementIndex] == NULL) {
    465       self->pSbrElement[elementIndex] = GetRam_SbrDecElement(elementIndex);
    466       if (self->pSbrElement[elementIndex] == NULL) {
    467         sbrError = SBRDEC_MEM_ALLOC_FAILED;
    468         goto bail;
    469       }
    470       self->numSbrElements ++;
    471     } else {
    472       self->numSbrChannels -= self->pSbrElement[elementIndex]->nChannels;
    473     }
    474 
    475     /* Save element ID for sanity checks and to have a fallback for concealment. */
    476     self->pSbrElement[elementIndex]->elementID = elementID;
    477 
    478     /* Determine amount of channels for this element */
    479     switch (elementID) {
    480       case ID_NONE:
    481       case ID_CPE: elChannels=2;
    482         break;
    483       case ID_LFE:
    484       case ID_SCE: elChannels=1;
    485         break;
    486       default: elChannels=0;
    487         break;
    488     }
    489 
    490     /* Handle case of Parametric Stereo */
    491     if ( elementIndex == 0 && elementID == ID_SCE ) {
    492       switch (coreCodec) {
    493         case AOT_AAC_LC:
    494         case AOT_SBR:
    495         case AOT_PS:
    496         case AOT_ER_AAC_SCAL:
    497         case AOT_DRM_AAC:
    498         case AOT_DRM_SURROUND:
    499           elChannels = 2;
    500           break;
    501         default:
    502           break;
    503       }
    504     }
    505 
    506     self->pSbrElement[elementIndex]->nChannels = elChannels;
    507 
    508     for (ch=0; ch<elChannels; ch++)
    509     {
    510       if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
    511         self->pSbrElement[elementIndex]->pSbrChannel[ch] = GetRam_SbrDecChannel(chCnt);
    512         if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) {
    513           sbrError = SBRDEC_MEM_ALLOC_FAILED;
    514           goto bail;
    515         }
    516       }
    517       self->numSbrChannels ++;
    518 
    519       sbrDecoder_drcInitChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.sbrDrcChannel );
    520 
    521       /* Add reference pointer to workbuffers. */
    522       self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer1 = self->workBuffer1;
    523       self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer2 = self->workBuffer2;
    524       chCnt++;
    525     }
    526     if (elChannels == 1 && self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) {
    527       deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] );
    528       FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] );
    529     }
    530   }
    531 
    532   /* clear error flags for all delay slots */
    533   FDKmemclear(self->pSbrElement[elementIndex]->frameErrorFlag, ((1)+1)*sizeof(UCHAR));
    534 
    535   /* Initialize this instance */
    536   sbrError = sbrDecoder_ResetElement(
    537           self,
    538           sampleRateIn,
    539           sampleRateOut,
    540           samplesPerFrame,
    541           elementID,
    542           elementIndex,
    543           (coreCodec == AOT_ER_AAC_ELD) ? 0 : (6)
    544           );
    545 
    546 
    547 
    548 bail:
    549   if (sbrError != SBRDEC_OK) {
    550     if (nSbrElementsStart < self->numSbrElements) {
    551       /* Free the memory allocated for this element */
    552       sbrDecoder_DestroyElement( self, elementIndex );
    553     } else if (self->pSbrElement[elementIndex] != NULL) {
    554       /* Set error flag to trigger concealment */
    555       self->pSbrElement[elementIndex]->frameErrorFlag[self->pSbrElement[elementIndex]->useFrameSlot] = 1;
    556     }
    557   }
    558 
    559   return sbrError;
    560 }
    561 
    562 /**
    563  * \brief Apply decoded SBR header for one element.
    564  * \param self SBR decoder instance handle
    565  * \param hSbrHeader SBR header handle to be processed.
    566  * \param hSbrChannel pointer array to the SBR element channels corresponding to the SBR header.
    567  * \param headerStatus header status value returned from SBR header parser.
    568  * \param numElementChannels amount of channels for the SBR element whos header is to be processed.
    569  */
    570 static
    571 SBR_ERROR sbrDecoder_HeaderUpdate(
    572         HANDLE_SBRDECODER self,
    573         HANDLE_SBR_HEADER_DATA hSbrHeader,
    574         SBR_HEADER_STATUS headerStatus,
    575         HANDLE_SBR_CHANNEL hSbrChannel[],
    576         const int numElementChannels
    577         )
    578 {
    579   SBR_ERROR errorStatus = SBRDEC_OK;
    580 
    581   /*
    582     change of control data, reset decoder
    583   */
    584   errorStatus = resetFreqBandTables(hSbrHeader, self->flags);
    585 
    586   if (errorStatus == SBRDEC_OK) {
    587     if (hSbrHeader->syncState == UPSAMPLING && headerStatus != HEADER_RESET)
    588     {
    589       /* As the default header would limit the frequency range,
    590          lowSubband and highSubband must be patched. */
    591       hSbrHeader->freqBandData.lowSubband = hSbrHeader->numberOfAnalysisBands;
    592       hSbrHeader->freqBandData.highSubband = hSbrHeader->numberOfAnalysisBands;
    593     }
    594 
    595     /* Trigger a reset before processing this slot */
    596     hSbrHeader->status |= SBRDEC_HDR_STAT_RESET;
    597   }
    598 
    599   return errorStatus;
    600 }
    601 
    602 INT sbrDecoder_Header (
    603         HANDLE_SBRDECODER       self,
    604         HANDLE_FDK_BITSTREAM    hBs,
    605         const INT sampleRateIn,
    606         const INT sampleRateOut,
    607         const INT samplesPerFrame,
    608         const AUDIO_OBJECT_TYPE coreCodec,
    609         const MP4_ELEMENT_ID    elementID,
    610         const INT               elementIndex
    611         )
    612 {
    613   SBR_HEADER_STATUS headerStatus;
    614   HANDLE_SBR_HEADER_DATA hSbrHeader;
    615   SBR_ERROR sbrError = SBRDEC_OK;
    616   int headerIndex;
    617 
    618   if ( self == NULL || elementIndex > (4) )
    619   {
    620     return SBRDEC_UNSUPPORTED_CONFIG;
    621   }
    622 
    623   if (! sbrDecoder_isCoreCodecValid(coreCodec)) {
    624     return SBRDEC_UNSUPPORTED_CONFIG;
    625   }
    626 
    627   sbrError = sbrDecoder_InitElement(
    628           self,
    629           sampleRateIn,
    630           sampleRateOut,
    631           samplesPerFrame,
    632           coreCodec,
    633           elementID,
    634           elementIndex
    635           );
    636 
    637   if (sbrError != SBRDEC_OK) {
    638     goto bail;
    639   }
    640 
    641   headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
    642                               self->pSbrElement[elementIndex]->useHeaderSlot);
    643   hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
    644 
    645   headerStatus = sbrGetHeaderData ( hSbrHeader,
    646                                     hBs,
    647                                     self->flags,
    648                                     0);
    649 
    650 
    651   {
    652     SBR_DECODER_ELEMENT *pSbrElement;
    653 
    654     pSbrElement = self->pSbrElement[elementIndex];
    655 
    656     /* Sanity check */
    657     if (pSbrElement != NULL) {
    658       if ( (elementID == ID_CPE && pSbrElement->nChannels != 2)
    659         || (elementID != ID_CPE && pSbrElement->nChannels != 1) )
    660       {
    661         return SBRDEC_UNSUPPORTED_CONFIG;
    662       }
    663       if ( headerStatus == HEADER_RESET ) {
    664 
    665         sbrError = sbrDecoder_HeaderUpdate(
    666               self,
    667               hSbrHeader,
    668               headerStatus,
    669               pSbrElement->pSbrChannel,
    670               pSbrElement->nChannels
    671               );
    672 
    673         if (sbrError == SBRDEC_OK) {
    674           hSbrHeader->syncState = SBR_HEADER;
    675           hSbrHeader->status   |= SBRDEC_HDR_STAT_UPDATE;
    676         }
    677         /* else {
    678           Since we already have overwritten the old SBR header the only way out is UPSAMPLING!
    679           This will be prepared in the next step.
    680         } */
    681       }
    682     }
    683   }
    684 bail:
    685   return sbrError;
    686 }
    687 
    688 
    689 SBR_ERROR sbrDecoder_SetParam (HANDLE_SBRDECODER   self,
    690                                const SBRDEC_PARAM  param,
    691                                const INT           value )
    692 {
    693   SBR_ERROR errorStatus = SBRDEC_OK;
    694 
    695   /* configure the subsystems */
    696   switch (param)
    697   {
    698   case SBR_SYSTEM_BITSTREAM_DELAY:
    699     if (value < 0 || value > (1)) {
    700       errorStatus = SBRDEC_SET_PARAM_FAIL;
    701       break;
    702     }
    703     if (self == NULL) {
    704       errorStatus = SBRDEC_NOT_INITIALIZED;
    705     } else {
    706       self->numDelayFrames = (UCHAR)value;
    707     }
    708     break;
    709   case SBR_QMF_MODE:
    710     if (self == NULL) {
    711       errorStatus = SBRDEC_NOT_INITIALIZED;
    712     } else {
    713       if (value == 1) {
    714         self->flags |= SBRDEC_LOW_POWER;
    715       } else {
    716         self->flags &= ~SBRDEC_LOW_POWER;
    717       }
    718     }
    719     break;
    720   case SBR_LD_QMF_TIME_ALIGN:
    721     if (self == NULL) {
    722       errorStatus = SBRDEC_NOT_INITIALIZED;
    723     } else {
    724       if (value == 1) {
    725         self->flags |= SBRDEC_LD_MPS_QMF;
    726       } else {
    727         self->flags &= ~SBRDEC_LD_MPS_QMF;
    728       }
    729     }
    730     break;
    731   case SBR_BS_INTERRUPTION:
    732     {
    733       int elementIndex;
    734 
    735       if (self == NULL) {
    736         errorStatus = SBRDEC_NOT_INITIALIZED;
    737         break;
    738       }
    739 
    740       /* Loop over SBR elements */
    741       for (elementIndex = 0; elementIndex < self->numSbrElements; elementIndex++)
    742       {
    743         HANDLE_SBR_HEADER_DATA hSbrHeader;
    744         int headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot,
    745                                         self->pSbrElement[elementIndex]->useHeaderSlot);
    746 
    747         hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]);
    748 
    749         /* Set sync state UPSAMPLING for the corresponding slot.
    750            This switches off bitstream parsing until a new header arrives. */
    751         hSbrHeader->syncState = UPSAMPLING;
    752         hSbrHeader->status   |= SBRDEC_HDR_STAT_UPDATE;
    753       }
    754     }
    755     break;
    756   default:
    757     errorStatus = SBRDEC_SET_PARAM_FAIL;
    758     break;
    759   }  /* switch(param) */
    760 
    761   return (errorStatus);
    762 }
    763 
    764 static
    765 SBRDEC_DRC_CHANNEL * sbrDecoder_drcGetChannel( const HANDLE_SBRDECODER self, const INT channel )
    766 {
    767   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
    768   int elementIndex, elChanIdx=0, numCh=0;
    769 
    770   for (elementIndex = 0; (elementIndex < (4)) && (numCh <= channel); elementIndex++)
    771   {
    772     SBR_DECODER_ELEMENT *pSbrElement = self->pSbrElement[elementIndex];
    773     int c, elChannels;
    774 
    775     elChanIdx = 0;
    776     if (pSbrElement == NULL) break;
    777 
    778     /* Determine amount of channels for this element */
    779     switch (pSbrElement->elementID) {
    780       case ID_CPE: elChannels = 2;
    781         break;
    782       case ID_LFE:
    783       case ID_SCE: elChannels = 1;
    784         break;
    785       case ID_NONE:
    786       default: elChannels = 0;
    787         break;
    788     }
    789 
    790     /* Limit with actual allocated element channels */
    791     elChannels = FDKmin(elChannels, pSbrElement->nChannels);
    792 
    793     for (c = 0; (c < elChannels) && (numCh <= channel); c++) {
    794       if (pSbrElement->pSbrChannel[elChanIdx] != NULL) {
    795         numCh++;
    796         elChanIdx++;
    797       }
    798     }
    799   }
    800   elementIndex -= 1;
    801   elChanIdx -= 1;
    802 
    803   if (elChanIdx < 0 || elementIndex < 0) {
    804     return NULL;
    805   }
    806 
    807   if ( self->pSbrElement[elementIndex] != NULL ) {
    808     if ( self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx] != NULL )
    809     {
    810       pSbrDrcChannelData = &self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx]->SbrDec.sbrDrcChannel;
    811     }
    812   }
    813 
    814   return (pSbrDrcChannelData);
    815 }
    816 
    817 SBR_ERROR sbrDecoder_drcFeedChannel ( HANDLE_SBRDECODER  self,
    818                                       INT                ch,
    819                                       UINT               numBands,
    820                                       FIXP_DBL          *pNextFact_mag,
    821                                       INT                nextFact_exp,
    822                                       SHORT              drcInterpolationScheme,
    823                                       UCHAR              winSequence,
    824                                       USHORT            *pBandTop )
    825 {
    826   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
    827   int band, isValidData = 0;
    828 
    829   if (self == NULL) {
    830     return SBRDEC_NOT_INITIALIZED;
    831   }
    832   if (ch > (6) || pNextFact_mag == NULL) {
    833     return SBRDEC_SET_PARAM_FAIL;
    834   }
    835 
    836   /* Search for gain values different to 1.0f */
    837   for (band = 0; band < numBands; band += 1) {
    838     if ( !((pNextFact_mag[band] == FL2FXCONST_DBL(0.5))  && (nextFact_exp == 1))
    839       && !((pNextFact_mag[band] == (FIXP_DBL)MAXVAL_DBL) && (nextFact_exp == 0)) ) {
    840       isValidData = 1;
    841       break;
    842     }
    843   }
    844 
    845   /* Find the right SBR channel */
    846   pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch );
    847 
    848   if ( pSbrDrcChannelData != NULL ) {
    849     if ( pSbrDrcChannelData->enable || isValidData )
    850   { /* Activate processing only with real and valid data */
    851     int i;
    852 
    853     pSbrDrcChannelData->enable   = 1;
    854     pSbrDrcChannelData->numBandsNext = numBands;
    855 
    856     pSbrDrcChannelData->winSequenceNext            = winSequence;
    857     pSbrDrcChannelData->drcInterpolationSchemeNext = drcInterpolationScheme;
    858     pSbrDrcChannelData->nextFact_exp               = nextFact_exp;
    859 
    860     for (i = 0; i < (int)numBands; i++) {
    861       pSbrDrcChannelData->bandTopNext[i]  = pBandTop[i];
    862       pSbrDrcChannelData->nextFact_mag[i] = pNextFact_mag[i];
    863     }
    864   }
    865   }
    866 
    867   return SBRDEC_OK;
    868 }
    869 
    870 
    871 void sbrDecoder_drcDisable ( HANDLE_SBRDECODER  self,
    872                              INT                ch )
    873 {
    874   SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL;
    875 
    876   if ( (self == NULL)
    877     || (ch > (6))
    878     || (self->numSbrElements == 0)
    879     || (self->numSbrChannels == 0) ) {
    880     return;
    881   }
    882 
    883   /* Find the right SBR channel */
    884   pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch );
    885 
    886   if ( pSbrDrcChannelData != NULL ) {
    887     sbrDecoder_drcInitChannel( pSbrDrcChannelData );
    888   }
    889 }
    890 
    891 
    892 
    893 SBR_ERROR sbrDecoder_Parse(
    894         HANDLE_SBRDECODER self,
    895         HANDLE_FDK_BITSTREAM  hBs,
    896         int *count,
    897         int  bsPayLen,
    898         int  crcFlag,
    899         MP4_ELEMENT_ID prevElement,
    900         int elementIndex,
    901         int fGlobalIndependencyFlag
    902         )
    903 {
    904   SBR_DECODER_ELEMENT   *hSbrElement;
    905   HANDLE_SBR_HEADER_DATA hSbrHeader;
    906   HANDLE_SBR_CHANNEL    *pSbrChannel;
    907 
    908   SBR_FRAME_DATA *hFrameDataLeft;
    909   SBR_FRAME_DATA *hFrameDataRight;
    910 
    911   SBR_ERROR errorStatus = SBRDEC_OK;
    912   SBR_SYNC_STATE initialSyncState;
    913   SBR_HEADER_STATUS headerStatus = HEADER_NOT_PRESENT;
    914 
    915   INT  startPos;
    916   INT  CRCLen = 0;
    917 
    918   int  stereo;
    919   int  fDoDecodeSbrData = 1;
    920 
    921   int lastSlot, lastHdrSlot = 0, thisHdrSlot;
    922 
    923   /* Remember start position of  SBR element */
    924   startPos = FDKgetValidBits(hBs);
    925 
    926   /* SBR sanity checks */
    927   if ( self == NULL || self->pSbrElement[elementIndex] == NULL ) {
    928     errorStatus = SBRDEC_NOT_INITIALIZED;
    929     goto bail;
    930   }
    931 
    932   hSbrElement = self->pSbrElement[elementIndex];
    933 
    934   lastSlot    = (hSbrElement->useFrameSlot > 0) ? hSbrElement->useFrameSlot-1 : self->numDelayFrames;
    935   lastHdrSlot =  hSbrElement->useHeaderSlot[lastSlot];
    936   thisHdrSlot =  getHeaderSlot( hSbrElement->useFrameSlot, hSbrElement->useHeaderSlot );  /* Get a free header slot not used by frames not processed yet. */
    937 
    938   /* Assign the free slot to store a new header if there is one. */
    939   hSbrHeader = &self->sbrHeader[elementIndex][thisHdrSlot];
    940 
    941   pSbrChannel = hSbrElement->pSbrChannel;
    942   stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
    943 
    944   hFrameDataLeft  = &self->pSbrElement[elementIndex]->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
    945   hFrameDataRight = &self->pSbrElement[elementIndex]->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
    946 
    947   initialSyncState = hSbrHeader->syncState;
    948 
    949   /* reset PS flag; will be set after PS was found */
    950   self->flags &= ~SBRDEC_PS_DECODED;
    951 
    952   if (hSbrHeader->status & SBRDEC_HDR_STAT_UPDATE) {
    953     /* Got a new header from extern (e.g. from an ASC) */
    954     headerStatus = HEADER_OK;
    955     hSbrHeader->status &= ~SBRDEC_HDR_STAT_UPDATE;
    956   }
    957   else if (thisHdrSlot != lastHdrSlot) {
    958     /* Copy the last header into this slot otherwise the
    959        header compare will trigger more HEADER_RESETs than needed. */
    960     copySbrHeader( hSbrHeader, &self->sbrHeader[elementIndex][lastHdrSlot] );
    961   }
    962 
    963   /*
    964      Check if bit stream data is valid and matches the element context
    965   */
    966   if ( ((prevElement != ID_SCE) && (prevElement != ID_CPE)) || prevElement != hSbrElement->elementID) {
    967     /* In case of LFE we also land here, since there is no LFE SBR element (do upsampling only) */
    968     fDoDecodeSbrData = 0;
    969   }
    970 
    971   if (fDoDecodeSbrData)
    972   {
    973     if ((INT)FDKgetValidBits(hBs) <= 0) {
    974       fDoDecodeSbrData = 0;
    975     }
    976   }
    977 
    978   /*
    979      SBR CRC-check
    980   */
    981   if (fDoDecodeSbrData)
    982   {
    983     if (crcFlag == 1) {
    984       switch (self->coreCodec) {
    985       case AOT_ER_AAC_ELD:
    986         FDKpushFor (hBs, 10);
    987         /* check sbrcrc later: we don't know the payload length now */
    988         break;
    989       default:
    990         CRCLen = bsPayLen - 10;                     /* change: 0 => i */
    991         if (CRCLen < 0) {
    992           fDoDecodeSbrData = 0;
    993         } else {
    994           fDoDecodeSbrData = SbrCrcCheck (hBs, CRCLen);
    995         }
    996         break;
    997       }
    998     }
    999   } /* if (fDoDecodeSbrData) */
   1000 
   1001   /*
   1002      Read in the header data and issue a reset if change occured
   1003   */
   1004   if (fDoDecodeSbrData)
   1005   {
   1006     int sbrHeaderPresent;
   1007 
   1008     {
   1009       sbrHeaderPresent = FDKreadBit(hBs);
   1010     }
   1011 
   1012     if ( sbrHeaderPresent ) {
   1013       headerStatus = sbrGetHeaderData (hSbrHeader,
   1014                                        hBs,
   1015                                        self->flags,
   1016                                        1);
   1017     }
   1018 
   1019     if (headerStatus == HEADER_RESET)
   1020     {
   1021       errorStatus = sbrDecoder_HeaderUpdate(
   1022             self,
   1023             hSbrHeader,
   1024             headerStatus,
   1025             pSbrChannel,
   1026             hSbrElement->nChannels
   1027             );
   1028 
   1029       if (errorStatus == SBRDEC_OK) {
   1030         hSbrHeader->syncState = SBR_HEADER;
   1031       } else {
   1032         hSbrHeader->syncState = SBR_NOT_INITIALIZED;
   1033       }
   1034     }
   1035 
   1036     if (errorStatus != SBRDEC_OK) {
   1037       fDoDecodeSbrData = 0;
   1038     }
   1039   } /* if (fDoDecodeSbrData) */
   1040 
   1041   /*
   1042     Print debugging output only if state has changed
   1043   */
   1044 
   1045   /* read frame data */
   1046   if ((hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) {
   1047     int sbrFrameOk;
   1048     /* read the SBR element data */
   1049     if (stereo) {
   1050       sbrFrameOk = sbrGetChannelPairElement(hSbrHeader,
   1051                                             hFrameDataLeft,
   1052                                             hFrameDataRight,
   1053                                             hBs,
   1054                                             self->flags,
   1055                                             self->pSbrElement[elementIndex]->transposerSettings.overlap);
   1056     }
   1057     else {
   1058       if (self->hParametricStereoDec != NULL) {
   1059         /* update slot index for PS bitstream parsing */
   1060         self->hParametricStereoDec->bsLastSlot = self->hParametricStereoDec->bsReadSlot;
   1061         self->hParametricStereoDec->bsReadSlot = hSbrElement->useFrameSlot;
   1062       }
   1063       sbrFrameOk = sbrGetSingleChannelElement(hSbrHeader,
   1064                                               hFrameDataLeft,
   1065                                               hBs,
   1066                                               self->hParametricStereoDec,
   1067                                               self->flags,
   1068                                               self->pSbrElement[elementIndex]->transposerSettings.overlap);
   1069     }
   1070     if (!sbrFrameOk) {
   1071       fDoDecodeSbrData = 0;
   1072     }
   1073     else {
   1074       INT valBits;
   1075 
   1076       if (bsPayLen > 0) {
   1077         valBits = bsPayLen - ((INT)startPos - (INT)FDKgetValidBits(hBs));
   1078       } else {
   1079         valBits = (INT)FDKgetValidBits(hBs);
   1080       }
   1081 
   1082       if ( crcFlag == 1 ) {
   1083         switch (self->coreCodec) {
   1084         case AOT_ER_AAC_ELD:
   1085           {
   1086             /* late crc check for eld */
   1087             INT payloadbits = (INT)startPos - (INT)FDKgetValidBits(hBs) - startPos;
   1088             INT crcLen      = payloadbits - 10;
   1089             FDKpushBack(hBs, payloadbits);
   1090             fDoDecodeSbrData      = SbrCrcCheck (hBs, crcLen);
   1091             FDKpushFor(hBs, crcLen);
   1092           }
   1093           break;
   1094         default:
   1095           break;
   1096         }
   1097       }
   1098 
   1099       /* sanity check of remaining bits */
   1100       if (valBits < 0) {
   1101         fDoDecodeSbrData = 0;
   1102       } else {
   1103         switch (self->coreCodec) {
   1104         case AOT_SBR:
   1105         case AOT_PS:
   1106         case AOT_AAC_LC:
   1107           {
   1108             /* This sanity check is only meaningful with General Audio bitstreams */
   1109             int alignBits = valBits & 0x7;
   1110 
   1111             if (valBits > alignBits) {
   1112               fDoDecodeSbrData = 0;
   1113             }
   1114           }
   1115           break;
   1116         default:
   1117           /* No sanity check available */
   1118           break;
   1119         }
   1120       }
   1121     }
   1122   }
   1123 
   1124   if (!fDoDecodeSbrData) {
   1125     /* Set error flag for this slot to trigger concealment */
   1126     self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 1;
   1127     errorStatus = SBRDEC_PARSE_ERROR;
   1128   } else {
   1129     /* Everything seems to be ok so clear the error flag */
   1130     self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 0;
   1131   }
   1132 
   1133   if (!stereo) {
   1134     /* Turn coupling off explicitely to avoid access to absent right frame data
   1135        that might occur with corrupt bitstreams. */
   1136     hFrameDataLeft->coupling = COUPLING_OFF;
   1137   }
   1138 
   1139 bail:
   1140   if (errorStatus == SBRDEC_OK) {
   1141     if (headerStatus == HEADER_NOT_PRESENT) {
   1142       /* Use the old header for this frame */
   1143       hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = lastHdrSlot;
   1144     } else {
   1145       /* Use the new header for this frame */
   1146       hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = thisHdrSlot;
   1147     }
   1148 
   1149     /* Move frame pointer to the next slot which is up to be decoded/applied next */
   1150     hSbrElement->useFrameSlot = (hSbrElement->useFrameSlot+1) % (self->numDelayFrames+1);
   1151   }
   1152 
   1153   *count -= startPos - FDKgetValidBits(hBs);
   1154 
   1155   return errorStatus;
   1156 }
   1157 
   1158 
   1159 /**
   1160  * \brief Render one SBR element into time domain signal.
   1161  * \param self SBR decoder handle
   1162  * \param timeData pointer to output buffer
   1163  * \param interleaved flag indicating interleaved channel output
   1164  * \param channelMapping pointer to UCHAR array where next 2 channel offsets are stored.
   1165  * \param elementIndex enumerating index of the SBR element to render.
   1166  * \param numInChannels number of channels from core coder (reading stride).
   1167  * \param numOutChannels pointer to a location to return number of output channels.
   1168  * \param psPossible flag indicating if PS is possible or not.
   1169  * \return SBRDEC_OK if successfull, else error code
   1170  */
   1171 static SBR_ERROR
   1172 sbrDecoder_DecodeElement (
   1173         HANDLE_SBRDECODER    self,
   1174         INT_PCM             *timeData,
   1175         const int            interleaved,
   1176         const UCHAR         *channelMapping,
   1177         const int            elementIndex,
   1178         const int            numInChannels,
   1179         int                 *numOutChannels,
   1180         const int            psPossible
   1181         )
   1182 {
   1183   SBR_DECODER_ELEMENT *hSbrElement = self->pSbrElement[elementIndex];
   1184   HANDLE_SBR_CHANNEL    *pSbrChannel = self->pSbrElement[elementIndex]->pSbrChannel;
   1185   HANDLE_SBR_HEADER_DATA hSbrHeader = &self->sbrHeader[elementIndex][hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot]];
   1186   HANDLE_PS_DEC h_ps_d = self->hParametricStereoDec;
   1187 
   1188   /* get memory for frame data from scratch */
   1189   SBR_FRAME_DATA *hFrameDataLeft  = &hSbrElement->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot];
   1190   SBR_FRAME_DATA *hFrameDataRight = &hSbrElement->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot];
   1191 
   1192   SBR_ERROR errorStatus = SBRDEC_OK;
   1193 
   1194 
   1195   INT  strideIn, strideOut, offset0, offset1;
   1196   INT  codecFrameSize = self->codecFrameSize;
   1197 
   1198   int  stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0;
   1199   int  numElementChannels = hSbrElement->nChannels; /* Number of channels of the current SBR element */
   1200 
   1201   /* Update the header error flag */
   1202   hSbrHeader->frameErrorFlag = hSbrElement->frameErrorFlag[hSbrElement->useFrameSlot];
   1203 
   1204   /*
   1205      Prepare filterbank for upsampling if no valid bit stream data is available.
   1206    */
   1207   if ( hSbrHeader->syncState == SBR_NOT_INITIALIZED )
   1208   {
   1209     errorStatus = initHeaderData(
   1210             hSbrHeader,
   1211             self->sampleRateIn,
   1212             self->sampleRateOut,
   1213             codecFrameSize,
   1214             self->flags
   1215             );
   1216 
   1217     if (errorStatus != SBRDEC_OK) {
   1218       return errorStatus;
   1219     }
   1220 
   1221     hSbrHeader->syncState = UPSAMPLING;
   1222 
   1223     errorStatus = sbrDecoder_HeaderUpdate(
   1224             self,
   1225             hSbrHeader,
   1226             HEADER_NOT_PRESENT,
   1227             pSbrChannel,
   1228             hSbrElement->nChannels
   1229             );
   1230 
   1231     if (errorStatus != SBRDEC_OK) {
   1232       hSbrHeader->syncState = SBR_NOT_INITIALIZED;
   1233       return errorStatus;
   1234     }
   1235   }
   1236 
   1237   /* reset */
   1238   if (hSbrHeader->status & SBRDEC_HDR_STAT_RESET) {
   1239     int ch;
   1240     for (ch = 0 ; ch < numElementChannels; ch++) {
   1241       SBR_ERROR errorStatusTmp = SBRDEC_OK;
   1242 
   1243       errorStatusTmp = resetSbrDec (
   1244              &pSbrChannel[ch]->SbrDec,
   1245               hSbrHeader,
   1246              &pSbrChannel[ch]->prevFrameData,
   1247               self->flags & SBRDEC_LOW_POWER,
   1248               self->synDownsampleFac
   1249               );
   1250 
   1251       if (errorStatusTmp != SBRDEC_OK) {
   1252         errorStatus = errorStatusTmp;
   1253       }
   1254     }
   1255     hSbrHeader->status &= ~SBRDEC_HDR_STAT_RESET;
   1256   }
   1257 
   1258   /* decoding */
   1259   if ( (hSbrHeader->syncState == SBR_ACTIVE)
   1260     || ((hSbrHeader->syncState == SBR_HEADER) && (hSbrHeader->frameErrorFlag == 0)) )
   1261   {
   1262     errorStatus = SBRDEC_OK;
   1263 
   1264     decodeSbrData (hSbrHeader,
   1265                    hFrameDataLeft,
   1266                   &pSbrChannel[0]->prevFrameData,
   1267                    (stereo) ? hFrameDataRight : NULL,
   1268                    (stereo) ? &pSbrChannel[1]->prevFrameData : NULL);
   1269 
   1270 
   1271     /* Now we have a full parameter set and can do parameter
   1272        based concealment instead of plain upsampling. */
   1273     hSbrHeader->syncState = SBR_ACTIVE;
   1274   }
   1275 
   1276   /* decode PS data if available */
   1277   if (h_ps_d != NULL && psPossible) {
   1278     int applyPs = 1;
   1279 
   1280     /* define which frame delay line slot to process */
   1281     h_ps_d->processSlot = hSbrElement->useFrameSlot;
   1282 
   1283     applyPs = DecodePs(h_ps_d, hSbrHeader->frameErrorFlag);
   1284     self->flags |= (applyPs) ? SBRDEC_PS_DECODED : 0;
   1285   }
   1286 
   1287   /* Set strides for reading and writing */
   1288   if (interleaved) {
   1289     strideIn = numInChannels;
   1290     if ( psPossible )
   1291       strideOut = (numInChannels < 2) ? 2 : numInChannels;
   1292     else
   1293       strideOut = numInChannels;
   1294     offset0 = channelMapping[0];
   1295     offset1 = channelMapping[1];
   1296   } else {
   1297     strideIn  = 1;
   1298     strideOut = 1;
   1299     offset0 = channelMapping[0]*2*codecFrameSize;
   1300     offset1 = channelMapping[1]*2*codecFrameSize;
   1301   }
   1302 
   1303   /* use same buffers for left and right channel and apply PS per timeslot */
   1304   /* Process left channel */
   1305 //FDKprintf("self->codecFrameSize %d\t%d\n",self->codecFrameSize,self->sampleRateIn);
   1306   sbr_dec (&pSbrChannel[0]->SbrDec,
   1307             timeData + offset0,
   1308             timeData + offset0,
   1309            &pSbrChannel[1]->SbrDec,
   1310             timeData + offset1,
   1311             strideIn,
   1312             strideOut,
   1313             hSbrHeader,
   1314             hFrameDataLeft,
   1315            &pSbrChannel[0]->prevFrameData,
   1316             (hSbrHeader->syncState == SBR_ACTIVE),
   1317             h_ps_d,
   1318             self->flags
   1319           );
   1320 
   1321   if (stereo) {
   1322     /* Process right channel */
   1323     sbr_dec (&pSbrChannel[1]->SbrDec,
   1324               timeData + offset1,
   1325               timeData + offset1,
   1326               NULL,
   1327               NULL,
   1328               strideIn,
   1329               strideOut,
   1330               hSbrHeader,
   1331               hFrameDataRight,
   1332              &pSbrChannel[1]->prevFrameData,
   1333               (hSbrHeader->syncState == SBR_ACTIVE),
   1334               NULL,
   1335               self->flags
   1336             );
   1337   }
   1338 
   1339   if (h_ps_d != NULL) {
   1340     /* save PS status for next run */
   1341     h_ps_d->psDecodedPrv = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0 ;
   1342   }
   1343 
   1344   if ( psPossible
   1345     )
   1346   {
   1347     FDK_ASSERT(strideOut > 1);
   1348     if ( !(self->flags & SBRDEC_PS_DECODED) ) {
   1349       /* A decoder which is able to decode PS has to produce a stereo output even if no PS data is availble. */
   1350       /* So copy left channel to right channel.                                                              */
   1351       if (interleaved) {
   1352         INT_PCM *ptr;
   1353         INT i;
   1354         FDK_ASSERT(strideOut == 2);
   1355 
   1356         ptr = timeData;
   1357         for (i = codecFrameSize; i--; )
   1358         {
   1359           INT_PCM tmp; /* This temporal variable is required because some compilers can't do *ptr++ = *ptr++ correctly. */
   1360           tmp = *ptr++; *ptr++ = tmp;
   1361           tmp = *ptr++; *ptr++ = tmp;
   1362         }
   1363       } else {
   1364         FDKmemcpy( timeData+2*codecFrameSize, timeData, 2*codecFrameSize*sizeof(INT_PCM) );
   1365       }
   1366     }
   1367     *numOutChannels = 2;  /* Output minimum two channels when PS is enabled. */
   1368   }
   1369 
   1370   return errorStatus;
   1371 }
   1372 
   1373 
   1374 SBR_ERROR sbrDecoder_Apply ( HANDLE_SBRDECODER   self,
   1375                              INT_PCM            *timeData,
   1376                              int                *numChannels,
   1377                              int                *sampleRate,
   1378                              const UCHAR         channelMapping[(6)],
   1379                              const int           interleaved,
   1380                              const int           coreDecodedOk,
   1381                              UCHAR              *psDecoded )
   1382 {
   1383   SBR_ERROR errorStatus = SBRDEC_OK;
   1384 
   1385   int   psPossible = 0;
   1386   int   sbrElementNum;
   1387   int   numCoreChannels = *numChannels;
   1388   int   numSbrChannels  = 0;
   1389 
   1390   psPossible = *psDecoded;
   1391 
   1392   if (self->numSbrElements < 1) {
   1393     /* exit immediately to avoid access violations */
   1394     return SBRDEC_CREATE_ERROR;
   1395   }
   1396 
   1397   /* Sanity check of allocated SBR elements. */
   1398   for (sbrElementNum=0; sbrElementNum<self->numSbrElements; sbrElementNum++) {
   1399     if (self->pSbrElement[sbrElementNum] == NULL) {
   1400       return SBRDEC_CREATE_ERROR;
   1401     }
   1402   }
   1403 
   1404   if (self->numSbrElements != 1 || self->pSbrElement[0]->elementID != ID_SCE) {
   1405     psPossible = 0;
   1406   }
   1407 
   1408 
   1409   /* In case of non-interleaved time domain data and upsampling, make room for bigger SBR output. */
   1410   if (self->synDownsampleFac == 1 && interleaved == 0) {
   1411     int c, outputFrameSize;
   1412 
   1413     outputFrameSize =
   1414             self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_channels
   1415             * self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_col;
   1416 
   1417     for (c=numCoreChannels-1; c>0; c--) {
   1418       FDKmemmove(timeData + c*outputFrameSize, timeData + c*self->codecFrameSize , self->codecFrameSize*sizeof(INT_PCM));
   1419     }
   1420   }
   1421 
   1422 
   1423   /* Make sure that even if no SBR data was found/parsed *psDecoded is returned 1 if psPossible was 0. */
   1424   if (psPossible == 0) {
   1425     self->flags &= ~SBRDEC_PS_DECODED;
   1426   }
   1427 
   1428   /* Loop over SBR elements */
   1429   for (sbrElementNum = 0; sbrElementNum<self->numSbrElements; sbrElementNum++)
   1430   {
   1431     int numElementChan;
   1432 
   1433     if (psPossible && self->pSbrElement[sbrElementNum]->pSbrChannel[1] == NULL) {
   1434       errorStatus = SBRDEC_UNSUPPORTED_CONFIG;
   1435       goto bail;
   1436     }
   1437 
   1438     numElementChan = (self->pSbrElement[sbrElementNum]->elementID == ID_CPE) ? 2 : 1;
   1439 
   1440     /* If core signal is bad then force upsampling */
   1441     if ( ! coreDecodedOk ) {
   1442       self->pSbrElement[sbrElementNum]->frameErrorFlag[self->pSbrElement[sbrElementNum]->useFrameSlot] = 1;
   1443     }
   1444 
   1445     errorStatus = sbrDecoder_DecodeElement (
   1446                                  self,
   1447                                  timeData,
   1448                                  interleaved,
   1449                                  channelMapping,
   1450                                  sbrElementNum,
   1451                                  numCoreChannels,
   1452                                 &numElementChan,
   1453                                  psPossible
   1454                                );
   1455 
   1456     if (errorStatus != SBRDEC_OK) {
   1457       goto bail;
   1458     }
   1459 
   1460     numSbrChannels += numElementChan;
   1461     channelMapping += numElementChan;
   1462 
   1463     if (numSbrChannels >= numCoreChannels) {
   1464       break;
   1465     }
   1466   }
   1467 
   1468   /* Update numChannels and samplerate */
   1469   *numChannels = numSbrChannels;
   1470   *sampleRate = self->sampleRateOut;
   1471   *psDecoded = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0;
   1472 
   1473 
   1474 
   1475 bail:
   1476 
   1477   return errorStatus;
   1478 }
   1479 
   1480 
   1481 SBR_ERROR sbrDecoder_Close ( HANDLE_SBRDECODER *pSelf )
   1482 {
   1483   HANDLE_SBRDECODER self = *pSelf;
   1484   int i;
   1485 
   1486   if (self != NULL)
   1487   {
   1488     if (self->hParametricStereoDec != NULL) {
   1489       DeletePsDec ( &self->hParametricStereoDec );
   1490     }
   1491 
   1492     if (self->workBuffer1 != NULL) {
   1493       FreeRam_SbrDecWorkBuffer1(&self->workBuffer1);
   1494     }
   1495     if (self->workBuffer2 != NULL) {
   1496       FreeRam_SbrDecWorkBuffer2(&self->workBuffer2);
   1497     }
   1498 
   1499     for (i = 0; i < (4); i++) {
   1500       sbrDecoder_DestroyElement( self, i );
   1501     }
   1502 
   1503     FreeRam_SbrDecoder(pSelf);
   1504   }
   1505 
   1506   return SBRDEC_OK;
   1507 }
   1508 
   1509 
   1510 INT sbrDecoder_GetLibInfo( LIB_INFO *info )
   1511 {
   1512   int i;
   1513 
   1514   if (info == NULL) {
   1515     return -1;
   1516   }
   1517 
   1518   /* search for next free tab */
   1519   for (i = 0; i < FDK_MODULE_LAST; i++) {
   1520     if (info[i].module_id == FDK_NONE)
   1521       break;
   1522   }
   1523   if (i == FDK_MODULE_LAST)
   1524     return -1;
   1525   info += i;
   1526 
   1527   info->module_id = FDK_SBRDEC;
   1528   info->version = LIB_VERSION(SBRDECODER_LIB_VL0, SBRDECODER_LIB_VL1, SBRDECODER_LIB_VL2);
   1529   LIB_VERSION_STRING(info);
   1530   info->build_date = (char *)SBRDECODER_LIB_BUILD_DATE;
   1531   info->build_time = (char *)SBRDECODER_LIB_BUILD_TIME;
   1532   info->title      = (char *)SBRDECODER_LIB_TITLE;
   1533 
   1534   /* Set flags */
   1535   info->flags = 0
   1536     | CAPF_SBR_HQ
   1537     | CAPF_SBR_LP
   1538     | CAPF_SBR_PS_MPEG
   1539     | CAPF_SBR_CONCEALMENT
   1540     | CAPF_SBR_DRC
   1541       ;
   1542   /* End of flags */
   1543 
   1544   return 0;
   1545 }
   1546 
   1547