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  envelope decoding
     87   This module provides envelope decoding and error concealment algorithms. The main
     88   entry point is decodeSbrData().
     89 
     90   \sa decodeSbrData(),\ref documentationOverview
     91 */
     92 
     93 #include "env_dec.h"
     94 
     95 #include "env_extr.h"
     96 #include "transcendent.h"
     97 
     98 #include "genericStds.h"
     99 
    100 
    101 static void decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
    102                             HANDLE_SBR_FRAME_DATA h_sbr_data,
    103                             HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
    104                             HANDLE_SBR_PREV_FRAME_DATA h_prev_data_otherChannel);
    105 static void sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData,
    106                                     HANDLE_SBR_FRAME_DATA h_data_left,
    107                                     HANDLE_SBR_FRAME_DATA h_data_right);
    108 static void requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data,
    109                                     int ampResolution);
    110 static void deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,
    111                                               HANDLE_SBR_FRAME_DATA h_sbr_data,
    112                                               HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
    113 static void decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,
    114                                     HANDLE_SBR_FRAME_DATA h_sbr_data,
    115                                     HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
    116 static void timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
    117                                          HANDLE_SBR_FRAME_DATA h_sbr_data,
    118                                          HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
    119 static int checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,
    120                               HANDLE_SBR_FRAME_DATA h_sbr_data,
    121                               HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
    122 
    123 
    124 
    125 #define SBR_ENERGY_PAN_OFFSET   (12 << ENV_EXP_FRACT)
    126 #define SBR_MAX_ENERGY          (35 << ENV_EXP_FRACT)
    127 
    128 #define DECAY                   ( 1 << ENV_EXP_FRACT)
    129 
    130 #if ENV_EXP_FRACT
    131 #define DECAY_COUPLING          ( 1 << (ENV_EXP_FRACT-1) ) /*!< corresponds to a value of 0.5 */
    132 #else
    133 #define DECAY_COUPLING            1  /*!< If the energy data is not shifted, use 1 instead of 0.5 */
    134 #endif
    135 
    136 
    137 /*!
    138   \brief  Convert table index
    139 */
    140 static int indexLow2High(int offset, /*!< mapping factor */
    141                          int index,  /*!< index to scalefactor band */
    142                          int res)    /*!< frequency resolution */
    143 {
    144   if(res == 0)
    145   {
    146     if (offset >= 0)
    147     {
    148         if (index < offset)
    149           return(index);
    150         else
    151           return(2*index - offset);
    152     }
    153     else
    154     {
    155         offset = -offset;
    156         if (index < offset)
    157           return(2*index+index);
    158         else
    159           return(2*index + offset);
    160     }
    161   }
    162   else
    163     return(index);
    164 }
    165 
    166 
    167 /*!
    168   \brief  Update previous envelope value for delta-coding
    169 
    170   The current envelope values needs to be stored for delta-coding
    171   in the next frame.  The stored envelope is always represented with
    172   the high frequency resolution.  If the current envelope uses the
    173   low frequency resolution, the energy value will be mapped to the
    174   corresponding high-res bands.
    175 */
    176 static void mapLowResEnergyVal(FIXP_SGL currVal,  /*!< current energy value */
    177                                FIXP_SGL* prevData,/*!< pointer to previous data vector */
    178                                int offset,      /*!< mapping factor */
    179                                int index,       /*!< index to scalefactor band */
    180                                int res)         /*!< frequeny resolution */
    181 {
    182   if(res == 0)
    183   {
    184     if (offset >= 0)
    185     {
    186         if(index < offset)
    187             prevData[index] = currVal;
    188         else
    189         {
    190             prevData[2*index - offset] = currVal;
    191             prevData[2*index+1 - offset] = currVal;
    192         }
    193     }
    194     else
    195     {
    196         offset = -offset;
    197         if (index < offset)
    198         {
    199             prevData[3*index] = currVal;
    200             prevData[3*index+1] = currVal;
    201             prevData[3*index+2] = currVal;
    202         }
    203         else
    204         {
    205             prevData[2*index + offset] = currVal;
    206             prevData[2*index + 1 + offset] = currVal;
    207         }
    208     }
    209   }
    210   else
    211     prevData[index] = currVal;
    212 }
    213 
    214 
    215 
    216 /*!
    217   \brief    Convert raw envelope and noisefloor data to energy levels
    218 
    219   This function is being called by sbrDecoder_ParseElement() and provides two important algorithms:
    220 
    221   First the function decodes envelopes and noise floor levels as described in requantizeEnvelopeData()
    222   and sbr_envelope_unmapping(). The function also implements concealment algorithms in case there are errors
    223   within the sbr data. For both operations fractional arithmetic is used.
    224   Therefore you might encounter different output values on your target
    225   system compared to the reference implementation.
    226 */
    227 void
    228 decodeSbrData (HANDLE_SBR_HEADER_DATA hHeaderData,          /*!< Static control data */
    229                HANDLE_SBR_FRAME_DATA h_data_left,           /*!< pointer to left channel frame data */
    230                HANDLE_SBR_PREV_FRAME_DATA h_prev_data_left, /*!< pointer to left channel previous frame data */
    231                HANDLE_SBR_FRAME_DATA h_data_right,          /*!< pointer to right channel frame data */
    232                HANDLE_SBR_PREV_FRAME_DATA h_prev_data_right)/*!< pointer to right channel previous frame data */
    233 {
    234   FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
    235   int errLeft;
    236 
    237   /* Save previous energy values to be able to reuse them later for concealment. */
    238   FDKmemcpy (tempSfbNrgPrev, h_prev_data_left->sfb_nrg_prev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
    239 
    240   decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
    241   decodeNoiseFloorlevels (hHeaderData, h_data_left, h_prev_data_left);
    242 
    243   if(h_data_right != NULL) {
    244     errLeft = hHeaderData->frameErrorFlag;
    245     decodeEnvelope (hHeaderData, h_data_right, h_prev_data_right, h_prev_data_left);
    246     decodeNoiseFloorlevels (hHeaderData, h_data_right, h_prev_data_right);
    247 
    248     if (!errLeft && hHeaderData->frameErrorFlag) {
    249       /* If an error occurs in the right channel where the left channel seemed ok,
    250          we apply concealment also on the left channel. This ensures that the coupling
    251          modes of both channels match and that we have the same number of envelopes in
    252          coupling mode.
    253          However, as the left channel has already been processed before, the resulting
    254          energy levels are not the same as if the left channel had been concealed
    255          during the first call of decodeEnvelope().
    256       */
    257       /* Restore previous energy values for concealment, because the values have been
    258          overwritten by the first call of decodeEnvelope(). */
    259       FDKmemcpy (h_prev_data_left->sfb_nrg_prev, tempSfbNrgPrev, MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
    260       /* Do concealment */
    261       decodeEnvelope (hHeaderData, h_data_left, h_prev_data_left, h_prev_data_right);
    262     }
    263 
    264     if (h_data_left->coupling) {
    265       sbr_envelope_unmapping (hHeaderData, h_data_left, h_data_right);
    266     }
    267   }
    268 
    269   /* Display the data for debugging: */
    270 }
    271 
    272 
    273 /*!
    274   \brief   Convert from coupled channels to independent L/R data
    275 */
    276 static void
    277 sbr_envelope_unmapping (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    278                         HANDLE_SBR_FRAME_DATA h_data_left,  /*!< pointer to left channel */
    279                         HANDLE_SBR_FRAME_DATA h_data_right) /*!< pointer to right channel */
    280 {
    281   int i;
    282   FIXP_SGL tempL_m, tempR_m, tempRplus1_m, newL_m, newR_m;
    283   SCHAR   tempL_e, tempR_e, tempRplus1_e, newL_e, newR_e;
    284 
    285 
    286   /* 1. Unmap (already dequantized) coupled envelope energies */
    287 
    288   for (i = 0; i < h_data_left->nScaleFactors; i++) {
    289     tempR_m = (FIXP_SGL)((LONG)h_data_right->iEnvelope[i] & MASK_M);
    290     tempR_e = (SCHAR)((LONG)h_data_right->iEnvelope[i] & MASK_E);
    291 
    292     tempR_e -= (18 + NRG_EXP_OFFSET);  /* -18 = ld(UNMAPPING_SCALE / h_data_right->nChannels) */
    293     tempL_m = (FIXP_SGL)((LONG)h_data_left->iEnvelope[i] & MASK_M);
    294     tempL_e = (SCHAR)((LONG)h_data_left->iEnvelope[i] & MASK_E);
    295 
    296     tempL_e -= NRG_EXP_OFFSET;
    297 
    298     /* Calculate tempRight+1 */
    299     FDK_add_MantExp( tempR_m, tempR_e,
    300                      FL2FXCONST_SGL(0.5f), 1,  /* 1.0 */
    301                      &tempRplus1_m, &tempRplus1_e);
    302 
    303     FDK_divide_MantExp( tempL_m, tempL_e+1,  /*  2 * tempLeft */
    304                        tempRplus1_m, tempRplus1_e,
    305                        &newR_m, &newR_e );
    306 
    307     if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
    308       newR_m >>= 1;
    309       newR_e += 1;
    310     }
    311 
    312     newL_m = FX_DBL2FX_SGL(fMult(tempR_m,newR_m));
    313     newL_e = tempR_e + newR_e;
    314 
    315     h_data_right->iEnvelope[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
    316                                   (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NRG_EXP_OFFSET) & MASK_E);
    317     h_data_left->iEnvelope[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
    318                                   (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NRG_EXP_OFFSET) & MASK_E);
    319   }
    320 
    321   /* 2. Dequantize and unmap coupled noise floor levels */
    322 
    323   for (i = 0; i < hHeaderData->freqBandData.nNfb * h_data_left->frameInfo.nNoiseEnvelopes; i++) {
    324 
    325     tempL_e = (SCHAR)(6 - (LONG)h_data_left->sbrNoiseFloorLevel[i]);
    326     tempR_e = (SCHAR)((LONG)h_data_right->sbrNoiseFloorLevel[i] - 12) /*SBR_ENERGY_PAN_OFFSET*/;
    327 
    328     /* Calculate tempR+1 */
    329     FDK_add_MantExp( FL2FXCONST_SGL(0.5f), 1+tempR_e, /* tempR */
    330                      FL2FXCONST_SGL(0.5f), 1,         /*  1.0  */
    331                      &tempRplus1_m, &tempRplus1_e);
    332 
    333     /* Calculate 2*tempLeft/(tempR+1) */
    334     FDK_divide_MantExp( FL2FXCONST_SGL(0.5f), tempL_e+2,  /*  2 * tempLeft */
    335                        tempRplus1_m, tempRplus1_e,
    336                        &newR_m, &newR_e );
    337 
    338     /* if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
    339       newR_m >>= 1;
    340       newR_e += 1;
    341     } */
    342 
    343     /* L = tempR * R */
    344     newL_m = newR_m;
    345     newL_e = newR_e + tempR_e;
    346     h_data_right->sbrNoiseFloorLevel[i] = ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
    347                                            (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NOISE_EXP_OFFSET) & MASK_E);
    348     h_data_left->sbrNoiseFloorLevel[i] =  ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
    349                                            (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NOISE_EXP_OFFSET) & MASK_E);
    350   }
    351 }
    352 
    353 
    354 /*!
    355   \brief    Simple alternative to the real SBR concealment
    356 
    357   If the real frameInfo is not available due to a frame loss, a replacement will
    358   be constructed with 1 envelope spanning the whole frame (FIX-FIX).
    359   The delta-coded energies are set to negative values, resulting in a fade-down.
    360   In case of coupling, the balance-channel will move towards the center.
    361 */
    362 static void
    363 leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    364                    HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
    365                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
    366                    )
    367 {
    368   FIXP_SGL target;  /* targeted level for sfb_nrg_prev during fade-down */
    369   FIXP_SGL step;    /* speed of fade */
    370   int i;
    371 
    372   int currentStartPos = h_prev_data->stopPos - hHeaderData->numberTimeSlots;
    373   int currentStopPos = hHeaderData->numberTimeSlots;
    374 
    375 
    376   /* Use some settings of the previous frame */
    377   h_sbr_data->ampResolutionCurrentFrame = h_prev_data->ampRes;
    378   h_sbr_data->coupling = h_prev_data->coupling;
    379   for(i=0;i<MAX_INVF_BANDS;i++)
    380     h_sbr_data->sbr_invf_mode[i] = h_prev_data->sbr_invf_mode[i];
    381 
    382   /* Generate concealing control data */
    383 
    384   h_sbr_data->frameInfo.nEnvelopes = 1;
    385   h_sbr_data->frameInfo.borders[0] = currentStartPos;
    386   h_sbr_data->frameInfo.borders[1] = currentStopPos;
    387   h_sbr_data->frameInfo.freqRes[0] = 1;
    388   h_sbr_data->frameInfo.tranEnv = -1;  /* no transient */
    389   h_sbr_data->frameInfo.nNoiseEnvelopes = 1;
    390   h_sbr_data->frameInfo.bordersNoise[0] = currentStartPos;
    391   h_sbr_data->frameInfo.bordersNoise[1] = currentStopPos;
    392 
    393   h_sbr_data->nScaleFactors = hHeaderData->freqBandData.nSfb[1];
    394 
    395   /* Generate fake envelope data */
    396 
    397   h_sbr_data->domain_vec[0] = 1;
    398 
    399   if (h_sbr_data->coupling == COUPLING_BAL) {
    400     target = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
    401     step = (FIXP_SGL)DECAY_COUPLING;
    402   }
    403   else {
    404     target = FL2FXCONST_SGL(0.0f);
    405     step   = (FIXP_SGL)DECAY;
    406   }
    407   if (hHeaderData->bs_info.ampResolution == 0) {
    408     target <<= 1;
    409     step   <<= 1;
    410   }
    411 
    412   for (i=0; i < h_sbr_data->nScaleFactors; i++) {
    413     if (h_prev_data->sfb_nrg_prev[i] > target)
    414       h_sbr_data->iEnvelope[i] = -step;
    415     else
    416       h_sbr_data->iEnvelope[i] = step;
    417   }
    418 
    419   /* Noisefloor levels are always cleared ... */
    420 
    421   h_sbr_data->domain_vec_noise[0] = 1;
    422   for (i=0; i < hHeaderData->freqBandData.nNfb; i++)
    423     h_sbr_data->sbrNoiseFloorLevel[i] = FL2FXCONST_SGL(0.0f);
    424 
    425   /* ... and so are the sines */
    426   FDKmemclear(h_sbr_data->addHarmonics, MAX_FREQ_COEFFS);
    427 }
    428 
    429 
    430 /*!
    431   \brief   Build reference energies and noise levels from bitstream elements
    432 */
    433 static void
    434 decodeEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    435                 HANDLE_SBR_FRAME_DATA  h_sbr_data,      /*!< pointer to current data */
    436                 HANDLE_SBR_PREV_FRAME_DATA h_prev_data, /*!< pointer to data of last frame */
    437                 HANDLE_SBR_PREV_FRAME_DATA otherChannel /*!< other channel's last frame data */
    438                 )
    439 {
    440   int i;
    441   int fFrameError = hHeaderData->frameErrorFlag;
    442   FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
    443 
    444   if (!fFrameError) {
    445     /*
    446       To avoid distortions after bad frames, set the error flag if delta coding in time occurs.
    447       However, SBR can take a little longer to come up again.
    448     */
    449     if ( h_prev_data->frameErrorFlag ) {
    450       if (h_sbr_data->domain_vec[0] != 0) {
    451         fFrameError = 1;
    452       }
    453     } else {
    454       /* Check that the previous stop position and the current start position match.
    455          (Could be done in checkFrameInfo(), but the previous frame data is not available there) */
    456       if ( h_sbr_data->frameInfo.borders[0] != h_prev_data->stopPos - hHeaderData->numberTimeSlots ) {
    457         /* Both the previous as well as the current frame are flagged to be ok, but they do not match! */
    458         if (h_sbr_data->domain_vec[0] == 1) {
    459           /* Prefer concealment over delta-time coding between the mismatching frames */
    460           fFrameError = 1;
    461         }
    462         else {
    463           /* Close the gap in time by triggering timeCompensateFirstEnvelope() */
    464           fFrameError = 1;
    465         }
    466       }
    467     }
    468   }
    469 
    470 
    471   if (fFrameError)       /* Error is detected */
    472     {
    473       leanSbrConcealment(hHeaderData,
    474                          h_sbr_data,
    475                          h_prev_data);
    476 
    477       /* decode the envelope data to linear PCM */
    478       deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
    479     }
    480   else                          /*Do a temporary dummy decoding and check that the envelope values are within limits */
    481     {
    482       if (h_prev_data->frameErrorFlag) {
    483         timeCompensateFirstEnvelope (hHeaderData, h_sbr_data, h_prev_data);
    484         if (h_sbr_data->coupling != h_prev_data->coupling) {
    485           /*
    486             Coupling mode has changed during concealment.
    487              The stored energy levels need to be converted.
    488            */
    489           for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
    490             /* Former Level-Channel will be used for both channels */
    491             if (h_prev_data->coupling == COUPLING_BAL)
    492               h_prev_data->sfb_nrg_prev[i] = otherChannel->sfb_nrg_prev[i];
    493             /* Former L/R will be combined as the new Level-Channel */
    494             else if (h_sbr_data->coupling == COUPLING_LEVEL)
    495               h_prev_data->sfb_nrg_prev[i] = (h_prev_data->sfb_nrg_prev[i] + otherChannel->sfb_nrg_prev[i]) >> 1;
    496             else if (h_sbr_data->coupling == COUPLING_BAL)
    497               h_prev_data->sfb_nrg_prev[i] = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
    498           }
    499         }
    500       }
    501       FDKmemcpy (tempSfbNrgPrev, h_prev_data->sfb_nrg_prev,
    502               MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
    503 
    504       deltaToLinearPcmEnvelopeDecoding (hHeaderData, h_sbr_data, h_prev_data);
    505 
    506       fFrameError = checkEnvelopeData (hHeaderData, h_sbr_data, h_prev_data);
    507 
    508       if (fFrameError)
    509         {
    510           hHeaderData->frameErrorFlag = 1;
    511           FDKmemcpy (h_prev_data->sfb_nrg_prev, tempSfbNrgPrev,
    512                   MAX_FREQ_COEFFS * sizeof (FIXP_SGL));
    513           decodeEnvelope (hHeaderData, h_sbr_data, h_prev_data, otherChannel);
    514           return;
    515         }
    516     }
    517 
    518   requantizeEnvelopeData (h_sbr_data, h_sbr_data->ampResolutionCurrentFrame);
    519 
    520   hHeaderData->frameErrorFlag = fFrameError;
    521 }
    522 
    523 
    524 /*!
    525   \brief   Verify that envelope energies are within the allowed range
    526   \return  0 if all is fine, 1 if an envelope value was too high
    527 */
    528 static int
    529 checkEnvelopeData (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    530                    HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
    531                    HANDLE_SBR_PREV_FRAME_DATA h_prev_data  /*!< pointer to data of last frame */
    532                    )
    533 {
    534   FIXP_SGL *iEnvelope = h_sbr_data->iEnvelope;
    535   FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
    536   int    i = 0, errorFlag = 0;
    537   FIXP_SGL sbr_max_energy =
    538     (h_sbr_data->ampResolutionCurrentFrame == 1) ? SBR_MAX_ENERGY : (SBR_MAX_ENERGY << 1);
    539 
    540   /*
    541     Range check for current energies
    542   */
    543   for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
    544     if (iEnvelope[i] > sbr_max_energy) {
    545       errorFlag = 1;
    546     }
    547     if (iEnvelope[i] < FL2FXCONST_SGL(0.0f)) {
    548       errorFlag = 1;
    549       /* iEnvelope[i] = FL2FXCONST_SGL(0.0f); */
    550     }
    551   }
    552 
    553   /*
    554     Range check for previous energies
    555   */
    556   for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
    557     sfb_nrg_prev[i] = fixMax(sfb_nrg_prev[i], FL2FXCONST_SGL(0.0f));
    558     sfb_nrg_prev[i] = fixMin(sfb_nrg_prev[i], sbr_max_energy);
    559   }
    560 
    561   return (errorFlag);
    562 }
    563 
    564 
    565 /*!
    566   \brief   Verify that the noise levels are within the allowed range
    567 
    568   The function is equivalent to checkEnvelopeData().
    569   When the noise-levels are being decoded, it is already too late for
    570   concealment. Therefore the noise levels are simply limited here.
    571 */
    572 static void
    573 limitNoiseLevels(HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    574                  HANDLE_SBR_FRAME_DATA h_sbr_data)       /*!< pointer to current data */
    575 {
    576   int i;
    577   int nNfb = hHeaderData->freqBandData.nNfb;
    578 
    579   /*
    580     Set range limits. The exact values depend on the coupling mode.
    581     However this limitation is primarily intended to avoid unlimited
    582     accumulation of the delta-coded noise levels.
    583   */
    584   #define lowerLimit   ((FIXP_SGL)0)     /* lowerLimit actually refers to the _highest_ noise energy */
    585   #define upperLimit   ((FIXP_SGL)35)    /* upperLimit actually refers to the _lowest_ noise energy */
    586 
    587   /*
    588     Range check for current noise levels
    589   */
    590   for (i = 0; i < h_sbr_data->frameInfo.nNoiseEnvelopes * nNfb; i++) {
    591     h_sbr_data->sbrNoiseFloorLevel[i] = fixMin(h_sbr_data->sbrNoiseFloorLevel[i], upperLimit);
    592     h_sbr_data->sbrNoiseFloorLevel[i] = fixMax(h_sbr_data->sbrNoiseFloorLevel[i], lowerLimit);
    593   }
    594 }
    595 
    596 
    597 /*!
    598   \brief   Compensate for the wrong timing that might occur after a frame error.
    599 */
    600 static void
    601 timeCompensateFirstEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
    602                              HANDLE_SBR_FRAME_DATA h_sbr_data,   /*!< pointer to actual data */
    603                              HANDLE_SBR_PREV_FRAME_DATA h_prev_data)  /*!< pointer to data of last frame */
    604 {
    605   int i, nScalefactors;
    606   FRAME_INFO *pFrameInfo = &h_sbr_data->frameInfo;
    607   UCHAR *nSfb = hHeaderData->freqBandData.nSfb;
    608   int estimatedStartPos = h_prev_data->stopPos - hHeaderData->numberTimeSlots;
    609   int refLen, newLen, shift;
    610   FIXP_SGL  deltaExp;
    611 
    612   /* Original length of first envelope according to bitstream */
    613   refLen = pFrameInfo->borders[1] - pFrameInfo->borders[0];
    614   /* Corrected length of first envelope (concealing can make the first envelope longer) */
    615   newLen = pFrameInfo->borders[1] - estimatedStartPos;
    616 
    617   if (newLen <= 0) {
    618     /* An envelope length of <= 0 would not work, so we don't use it.
    619        May occur if the previous frame was flagged bad due to a mismatch
    620        of the old and new frame infos. */
    621     newLen = refLen;
    622     estimatedStartPos = pFrameInfo->borders[0];
    623   }
    624 
    625   deltaExp = FDK_getNumOctavesDiv8(newLen, refLen);
    626 
    627   /* Shift by -3 to rescale ld-table, ampRes-1 to enable coarser steps */
    628   shift = (FRACT_BITS - 1 - ENV_EXP_FRACT - 1 + h_sbr_data->ampResolutionCurrentFrame - 3);
    629   deltaExp = deltaExp >> shift;
    630   pFrameInfo->borders[0] = estimatedStartPos;
    631   pFrameInfo->bordersNoise[0] = estimatedStartPos;
    632 
    633   if (h_sbr_data->coupling != COUPLING_BAL) {
    634     nScalefactors = (pFrameInfo->freqRes[0]) ? nSfb[1] : nSfb[0];
    635 
    636     for (i = 0; i < nScalefactors; i++)
    637       h_sbr_data->iEnvelope[i] = h_sbr_data->iEnvelope[i] + deltaExp;
    638   }
    639 }
    640 
    641 
    642 
    643 /*!
    644   \brief   Convert each envelope value from logarithmic to linear domain
    645 
    646   Energy levels are transmitted in powers of 2, i.e. only the exponent
    647   is extracted from the bitstream.
    648   Therefore, normally only integer exponents can occur. However during
    649   fading (in case of a corrupt bitstream), a fractional part can also
    650   occur. The data in the array iEnvelope is shifted left by ENV_EXP_FRACT
    651   compared to an integer representation so that numbers smaller than 1
    652   can be represented.
    653 
    654   This function calculates a mantissa corresponding to the fractional
    655   part of the exponent for each reference energy. The array iEnvelope
    656   is converted in place to save memory. Input and output data must
    657   be interpreted differently, as shown in the below figure:
    658 
    659   \image html  EnvelopeData.png
    660 
    661   The data is then used in calculateSbrEnvelope().
    662 */
    663 static void
    664 requantizeEnvelopeData (HANDLE_SBR_FRAME_DATA h_sbr_data, int ampResolution)
    665 {
    666   int i;
    667   FIXP_SGL mantissa;
    668   int ampShift = 1 - ampResolution;
    669   int exponent;
    670 
    671   /* In case that ENV_EXP_FRACT is changed to something else but 0 or 8,
    672      the initialization of this array has to be adapted!
    673   */
    674 #if ENV_EXP_FRACT
    675   static const FIXP_SGL pow2[ENV_EXP_FRACT] =
    676   {
    677     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 1))), /* 0.7071 */
    678     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 2))), /* 0.5946 */
    679     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 3))),
    680     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 4))),
    681     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 5))),
    682     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 6))),
    683     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 7))),
    684     FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 8)))  /* 0.5013 */
    685   };
    686 
    687   int bit, mask;
    688 #endif
    689 
    690   for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
    691     exponent = (LONG)h_sbr_data->iEnvelope[i];
    692 
    693 #if ENV_EXP_FRACT
    694 
    695     exponent = exponent >> ampShift;
    696     mantissa = 0.5f;
    697 
    698     /* Amplify mantissa according to the fractional part of the
    699        exponent (result will be between 0.500000 and 0.999999)
    700     */
    701     mask = 1;  /* begin with lowest bit of exponent */
    702 
    703     for ( bit=ENV_EXP_FRACT-1; bit>=0; bit-- ) {
    704       if (exponent & mask) {
    705         /* The current bit of the exponent is set,
    706            multiply mantissa with the corresponding factor: */
    707         mantissa = (FIXP_SGL)( (mantissa * pow2[bit]) << 1);
    708       }
    709       /* Advance to next bit */
    710       mask = mask << 1;
    711     }
    712 
    713     /* Make integer part of exponent right aligned */
    714     exponent = exponent >> ENV_EXP_FRACT;
    715 
    716 #else
    717     /* In case of the high amplitude resolution, 1 bit of the exponent gets lost by the shift.
    718        This will be compensated by a mantissa of 0.5*sqrt(2) instead of 0.5 if that bit is 1. */
    719     mantissa = (exponent & ampShift) ? FL2FXCONST_SGL(0.707106781186548f) : FL2FXCONST_SGL(0.5f);
    720     exponent = exponent >> ampShift;
    721 #endif
    722 
    723     /*
    724       Mantissa was set to 0.5 (instead of 1.0, therefore increase exponent by 1).
    725       Multiply by L=nChannels=64 by increasing exponent by another 6.
    726       => Increase exponent by 7
    727     */
    728     exponent += 7 + NRG_EXP_OFFSET;
    729 
    730     /* Combine mantissa and exponent and write back the result */
    731     h_sbr_data->iEnvelope[i] = (FIXP_SGL)(((LONG)mantissa & MASK_M) | (exponent & MASK_E));
    732 
    733   }
    734 }
    735 
    736 
    737 /*!
    738   \brief   Build new reference energies from old ones and delta coded data
    739 */
    740 static void
    741 deltaToLinearPcmEnvelopeDecoding (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    742                                   HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
    743                                   HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
    744 {
    745   int i, domain, no_of_bands, band, freqRes;
    746 
    747   FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
    748   FIXP_SGL *ptr_nrg = h_sbr_data->iEnvelope;
    749 
    750   int offset = 2 * hHeaderData->freqBandData.nSfb[0] - hHeaderData->freqBandData.nSfb[1];
    751 
    752   for (i = 0; i < h_sbr_data->frameInfo.nEnvelopes; i++) {
    753     domain = h_sbr_data->domain_vec[i];
    754     freqRes = h_sbr_data->frameInfo.freqRes[i];
    755 
    756     FDK_ASSERT(freqRes >= 0 && freqRes <= 1);
    757 
    758     no_of_bands = hHeaderData->freqBandData.nSfb[freqRes];
    759 
    760     FDK_ASSERT(no_of_bands < (64));
    761 
    762     if (domain == 0)
    763     {
    764       mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, 0, freqRes);
    765       ptr_nrg++;
    766       for (band = 1; band < no_of_bands; band++)
    767       {
    768         *ptr_nrg = *ptr_nrg + *(ptr_nrg-1);
    769         mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
    770         ptr_nrg++;
    771       }
    772     }
    773     else
    774     {
    775       for (band = 0; band < no_of_bands; band++)
    776       {
    777         *ptr_nrg = *ptr_nrg + sfb_nrg_prev[indexLow2High(offset, band, freqRes)];
    778         mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
    779         ptr_nrg++;
    780       }
    781     }
    782   }
    783 }
    784 
    785 
    786 /*!
    787   \brief   Build new noise levels from old ones and delta coded data
    788 */
    789 static void
    790 decodeNoiseFloorlevels (HANDLE_SBR_HEADER_DATA hHeaderData,     /*!< Static control data */
    791                         HANDLE_SBR_FRAME_DATA h_sbr_data,       /*!< pointer to current data */
    792                         HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
    793 {
    794   int i;
    795   int nNfb = hHeaderData->freqBandData.nNfb;
    796   int nNoiseFloorEnvelopes = h_sbr_data->frameInfo.nNoiseEnvelopes;
    797 
    798   /* Decode first noise envelope */
    799 
    800   if (h_sbr_data->domain_vec_noise[0] == 0) {
    801     FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[0];
    802     for (i = 1; i < nNfb; i++) {
    803       noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
    804       h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
    805     }
    806   }
    807   else {
    808     for (i = 0; i < nNfb; i++) {
    809       h_sbr_data->sbrNoiseFloorLevel[i] += h_prev_data->prevNoiseLevel[i];
    810     }
    811   }
    812 
    813   /* If present, decode the second noise envelope
    814      Note:  nNoiseFloorEnvelopes can only be 1 or 2 */
    815 
    816   if (nNoiseFloorEnvelopes > 1) {
    817     if (h_sbr_data->domain_vec_noise[1] == 0) {
    818       FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[nNfb];
    819       for (i = nNfb + 1; i < 2*nNfb; i++) {
    820         noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
    821         h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
    822       }
    823     }
    824     else {
    825       for (i = 0; i < nNfb; i++) {
    826         h_sbr_data->sbrNoiseFloorLevel[i + nNfb] += h_sbr_data->sbrNoiseFloorLevel[i];
    827       }
    828     }
    829   }
    830 
    831   limitNoiseLevels(hHeaderData, h_sbr_data);
    832 
    833   /* Update prevNoiseLevel with the last noise envelope */
    834   for (i = 0; i < nNfb; i++)
    835     h_prev_data->prevNoiseLevel[i] = h_sbr_data->sbrNoiseFloorLevel[i + nNfb*(nNoiseFloorEnvelopes-1)];
    836 
    837 
    838   /* Requantize the noise floor levels in COUPLING_OFF-mode */
    839   if (!h_sbr_data->coupling) {
    840     int nf_e;
    841 
    842     for (i = 0; i < nNoiseFloorEnvelopes*nNfb; i++) {
    843       nf_e = 6 - (LONG)h_sbr_data->sbrNoiseFloorLevel[i] + 1 + NOISE_EXP_OFFSET;
    844       /* +1 to compensate for a mantissa of 0.5 instead of 1.0 */
    845 
    846       h_sbr_data->sbrNoiseFloorLevel[i] =
    847         (FIXP_SGL)( ((LONG)FL2FXCONST_SGL(0.5f)) +  /* mantissa */
    848                   (nf_e & MASK_E) ); /* exponent */
    849 
    850     }
    851   }
    852 }
    853