Home | History | Annotate | Download | only in arm
      1 
      2 /* -----------------------------------------------------------------------------------------------------------
      3 Software License for The Fraunhofer FDK AAC Codec Library for Android
      4 
      5  Copyright  1995 - 2012 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 #if (QMF_NO_POLY==5)
     85 
     86 #define FUNCTION_qmfForwardModulationLP_odd
     87 
     88 #ifdef FUNCTION_qmfForwardModulationLP_odd
     89 static void
     90 qmfForwardModulationLP_odd( HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank  */
     91                             const FIXP_QMF *timeIn,        /*!< Time Signal */
     92                             FIXP_QMF *rSubband )           /*!< Real Output */
     93 {
     94   int i;
     95   int L = anaQmf->no_channels;
     96   int M = L>>1;
     97   int shift = (anaQmf->no_channels>>6) + 1;
     98   int rSubband_e = 0;
     99 
    100   FIXP_QMF *rSubbandPtr0 = &rSubband[M+0];                /* runs with increment */
    101   FIXP_QMF *rSubbandPtr1 = &rSubband[M-1];                /* runs with decrement */
    102   FIXP_QMF *timeIn0 = (FIXP_DBL *) &timeIn[0];            /* runs with increment */
    103   FIXP_QMF *timeIn1 = (FIXP_DBL *) &timeIn[L];            /* runs with increment */
    104   FIXP_QMF *timeIn2 = (FIXP_DBL *) &timeIn[L-1];          /* runs with decrement */
    105   FIXP_QMF *timeIn3 = (FIXP_DBL *) &timeIn[2*L-1];        /* runs with decrement */
    106 
    107   for (i = 0; i < M; i++)
    108   {
    109     *rSubbandPtr0++ = (*timeIn2-- >> 1) - (*timeIn0++ >> shift);
    110     *rSubbandPtr1-- = (*timeIn1++ >> 1) + (*timeIn3-- >> shift);
    111   }
    112 
    113   dct_IV(rSubband,L, &rSubband_e);
    114 }
    115 #endif /* FUNCTION_qmfForwardModulationLP_odd */
    116 
    117 
    118 /* NEON optimized QMF currently builts only with RVCT toolchain */
    119 
    120 #if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_5TE__)
    121 
    122 #if (SAMPLE_BITS == 16)
    123 #define FUNCTION_qmfAnaPrototypeFirSlot
    124 #endif
    125 
    126 #ifdef FUNCTION_qmfAnaPrototypeFirSlot
    127 
    128 #if defined(__GNUC__)	/* cppp replaced: elif */
    129 
    130 inline INT SMULBB (const SHORT a, const LONG b)
    131 {
    132   INT result ;
    133   __asm__ ("smulbb %0, %1, %2"
    134      : "=r" (result)
    135      : "r" (a), "r" (b)) ;
    136   return result ;
    137 }
    138 inline INT SMULBT (const SHORT a, const LONG b)
    139 {
    140   INT result ;
    141   __asm__ ("smulbt %0, %1, %2"
    142      : "=r" (result)
    143      : "r" (a), "r" (b)) ;
    144   return result ;
    145 }
    146 
    147 inline INT SMLABB(const LONG accu, const SHORT a, const LONG b)
    148 {
    149   INT result ;
    150   __asm__ ("smlabb %0, %1, %2,%3"
    151      : "=r" (result)
    152      : "r" (a), "r" (b), "r" (accu)) ;
    153   return result;
    154 }
    155 inline INT SMLABT(const LONG accu, const SHORT a, const LONG b)
    156 {
    157   INT result ;
    158   __asm__ ("smlabt %0, %1, %2,%3"
    159      : "=r" (result)
    160      : "r" (a), "r" (b), "r" (accu)) ;
    161   return result;
    162 }
    163 #endif /* compiler selection  */
    164 
    165 
    166 void qmfAnaPrototypeFirSlot( FIXP_QMF *analysisBuffer,
    167                              int       no_channels,             /*!< Number channels of analysis filter */
    168                              const FIXP_PFT *p_filter,
    169                              int       p_stride,                /*!< Stide of analysis filter    */
    170                              FIXP_QAS *RESTRICT pFilterStates
    171                             )
    172 {
    173   LONG *p_flt = (LONG *) p_filter;
    174   LONG flt;
    175   FIXP_QMF *RESTRICT pData_0 = analysisBuffer + 2*no_channels - 1;
    176   FIXP_QMF *RESTRICT pData_1 = analysisBuffer;
    177 
    178   FIXP_QAS *RESTRICT sta_0 = (FIXP_QAS *)pFilterStates;
    179   FIXP_QAS *RESTRICT sta_1 = (FIXP_QAS *)pFilterStates + (2*QMF_NO_POLY*no_channels) - 1;
    180 
    181   FIXP_DBL accu0, accu1;
    182   FIXP_QAS sta0, sta1;
    183 
    184   int staStep1 =  no_channels<<1;
    185   int staStep2 = (no_channels<<3) - 1; /* Rewind one less */
    186 
    187   if (p_stride == 1)
    188   {
    189     /* FIR filter 0 */
    190     flt = *p_flt++;
    191     sta1 = *sta_1;  sta_1 -= staStep1;
    192     accu1 = SMULBB(        sta1, flt);
    193     sta1 = *sta_1;  sta_1 -= staStep1;
    194     accu1 = SMLABT( accu1, sta1, flt);
    195 
    196     flt = *p_flt++;
    197     sta1 = *sta_1;  sta_1 -= staStep1;
    198     accu1 = SMLABB( accu1, sta1, flt);
    199     sta1 = *sta_1;  sta_1 -= staStep1;
    200     accu1 = SMLABT( accu1, sta1, flt);
    201 
    202     flt = *p_flt++;
    203     sta1 = *sta_1;  sta_1 += staStep2;
    204     accu1 = SMLABB( accu1, sta1, flt);
    205     *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    206 
    207     /* FIR filters 1..63 127..65 or 1..31 63..33 */
    208     no_channels >>= 1;
    209     for (; --no_channels; )
    210     {
    211       sta0 = *sta_0; sta_0 += staStep1;  /* 1,3,5, ... 29/61 */
    212       sta1 = *sta_1; sta_1 -= staStep1;
    213       accu0 = SMULBT(        sta0, flt);
    214       accu1 = SMULBT(        sta1, flt);
    215 
    216       flt = *p_flt++;
    217       sta0 = *sta_0; sta_0 += staStep1;
    218       sta1 = *sta_1; sta_1 -= staStep1;
    219       accu0 = SMLABB( accu0, sta0, flt);
    220       accu1 = SMLABB( accu1, sta1, flt);
    221 
    222       sta0 = *sta_0; sta_0 += staStep1;
    223       sta1 = *sta_1; sta_1 -= staStep1;
    224       accu0 = SMLABT( accu0, sta0, flt);
    225       accu1 = SMLABT( accu1, sta1, flt);
    226 
    227       flt = *p_flt++;
    228       sta0 = *sta_0; sta_0 += staStep1;
    229       sta1 = *sta_1; sta_1 -= staStep1;
    230       accu0 = SMLABB( accu0, sta0, flt);
    231       accu1 = SMLABB( accu1, sta1, flt);
    232 
    233       sta0 = *sta_0; sta_0 -= staStep2;
    234       sta1 = *sta_1; sta_1 += staStep2;
    235       accu0 = SMLABT( accu0, sta0, flt);
    236       accu1 = SMLABT( accu1, sta1, flt);
    237 
    238       *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    239       *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    240 
    241       /* Same sequence as above, but mix B=bottom with T=Top */
    242 
    243       flt = *p_flt++;
    244       sta0 = *sta_0; sta_0 += staStep1;  /* 2,4,6, ... 30/62 */
    245       sta1 = *sta_1; sta_1 -= staStep1;
    246       accu0 = SMULBB(        sta0, flt);
    247       accu1 = SMULBB(        sta1, flt);
    248 
    249       sta0 = *sta_0; sta_0 += staStep1;
    250       sta1 = *sta_1; sta_1 -= staStep1;
    251       accu0 = SMLABT( accu0, sta0, flt);
    252       accu1 = SMLABT( accu1, sta1, flt);
    253 
    254       flt = *p_flt++;
    255       sta0 = *sta_0; sta_0 += staStep1;
    256       sta1 = *sta_1; sta_1 -= staStep1;
    257       accu0 = SMLABB( accu0, sta0, flt);
    258       accu1 = SMLABB( accu1, sta1, flt);
    259 
    260       sta0 = *sta_0; sta_0 += staStep1;
    261       sta1 = *sta_1; sta_1 -= staStep1;
    262       accu0 = SMLABT( accu0, sta0, flt);
    263       accu1 = SMLABT( accu1, sta1, flt);
    264 
    265       flt = *p_flt++;
    266       sta0 = *sta_0; sta_0 -= staStep2;
    267       sta1 = *sta_1; sta_1 += staStep2;
    268       accu0 = SMLABB( accu0, sta0, flt);
    269       accu1 = SMLABB( accu1, sta1, flt);
    270 
    271       *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    272       *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    273     }
    274 
    275     /* FIR filter 31/63 and 33/65 */
    276     sta0 = *sta_0; sta_0 += staStep1;
    277     sta1 = *sta_1; sta_1 -= staStep1;
    278     accu0 = SMULBT(        sta0, flt);
    279     accu1 = SMULBT(        sta1, flt);
    280 
    281     flt = *p_flt++;
    282     sta0 = *sta_0; sta_0 += staStep1;
    283     sta1 = *sta_1; sta_1 -= staStep1;
    284     accu0 = SMLABB( accu0, sta0, flt);
    285     accu1 = SMLABB( accu1, sta1, flt);
    286 
    287     sta0 = *sta_0; sta_0 += staStep1;
    288     sta1 = *sta_1; sta_1 -= staStep1;
    289     accu0 = SMLABT( accu0, sta0, flt);
    290     accu1 = SMLABT( accu1, sta1, flt);
    291 
    292     flt = *p_flt++;
    293     sta0 = *sta_0; sta_0 += staStep1;
    294     sta1 = *sta_1; sta_1 -= staStep1;
    295     accu0 = SMLABB( accu0, sta0, flt);
    296     accu1 = SMLABB( accu1, sta1, flt);
    297 
    298     sta0 = *sta_0; sta_0 -= staStep2;
    299     sta1 = *sta_1; sta_1 += staStep2;
    300     accu0 = SMLABT( accu0, sta0, flt);
    301     accu1 = SMLABT( accu1, sta1, flt);
    302 
    303     *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    304     *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    305 
    306     /* FIR filter 32/64 */
    307     flt = *p_flt++;
    308     sta0 = *sta_0; sta_0 += staStep1;
    309     sta1 = *sta_1; sta_1 -= staStep1;
    310     accu0 = SMULBB(        sta0, flt);
    311     accu1 = SMULBB(        sta1, flt);
    312 
    313     sta0 = *sta_0; sta_0 += staStep1;
    314     sta1 = *sta_1; sta_1 -= staStep1;
    315     accu0 = SMLABT( accu0, sta0, flt);
    316     accu1 = SMLABT( accu1, sta1, flt);
    317 
    318     flt = *p_flt++;
    319     sta0 = *sta_0; sta_0 += staStep1;
    320     sta1 = *sta_1; sta_1 -= staStep1;
    321     accu0 = SMLABB( accu0, sta0, flt);
    322     accu1 = SMLABB( accu1, sta1, flt);
    323 
    324     sta0 = *sta_0; sta_0 += staStep1;
    325     sta1 = *sta_1; sta_1 -= staStep1;
    326     accu0 = SMLABT( accu0, sta0, flt);
    327     accu1 = SMLABT( accu1, sta1, flt);
    328 
    329     flt = *p_flt;
    330     sta0 = *sta_0;
    331     sta1 = *sta_1;
    332     accu0 = SMLABB( accu0, sta0, flt);
    333     accu1 = SMLABB( accu1, sta1, flt);
    334 
    335     *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    336     *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    337   }
    338   else
    339   {
    340     int pfltStep = QMF_NO_POLY * (p_stride-1);
    341 
    342     flt = p_flt[0];
    343     sta1 = *sta_1;  sta_1 -= staStep1;
    344     accu1 = SMULBB(        sta1, flt);
    345     sta1 = *sta_1;  sta_1 -= staStep1;
    346     accu1 = SMLABT( accu1, sta1, flt);
    347 
    348     flt = p_flt[1];
    349     sta1 = *sta_1;  sta_1 -= staStep1;
    350     accu1 = SMLABB( accu1, sta1, flt);
    351     sta1 = *sta_1;  sta_1 -= staStep1;
    352     accu1 = SMLABT( accu1, sta1, flt);
    353 
    354     flt = p_flt[2]; p_flt += pfltStep;
    355     sta1 = *sta_1;  sta_1 += staStep2;
    356     accu1 = SMLABB( accu1, sta1, flt);
    357     *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    358 
    359     /* FIR filters 1..63 127..65 or 1..31 63..33 */
    360     for (; --no_channels; )
    361     {
    362       flt = p_flt[0];
    363       sta0 = *sta_0; sta_0 += staStep1;
    364       sta1 = *sta_1; sta_1 -= staStep1;
    365       accu0 = SMULBB(        sta0, flt);
    366       accu1 = SMULBB(        sta1, flt);
    367 
    368       sta0 = *sta_0; sta_0 += staStep1;
    369       sta1 = *sta_1; sta_1 -= staStep1;
    370       accu0 = SMLABT( accu0, sta0, flt);
    371       accu1 = SMLABT( accu1, sta1, flt);
    372 
    373       flt = p_flt[1];
    374       sta0 = *sta_0; sta_0 += staStep1;
    375       sta1 = *sta_1; sta_1 -= staStep1;
    376       accu0 = SMLABB( accu0, sta0, flt);
    377       accu1 = SMLABB( accu1, sta1, flt);
    378 
    379       sta0 = *sta_0; sta_0 += staStep1;
    380       sta1 = *sta_1; sta_1 -= staStep1;
    381       accu0 = SMLABT( accu0, sta0, flt);
    382       accu1 = SMLABT( accu1, sta1, flt);
    383 
    384       flt = p_flt[2]; p_flt += pfltStep;
    385       sta0 = *sta_0; sta_0 -= staStep2;
    386       sta1 = *sta_1; sta_1 += staStep2;
    387       accu0 = SMLABB( accu0, sta0, flt);
    388       accu1 = SMLABB( accu1, sta1, flt);
    389 
    390       *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    391       *pData_1++ = FX_DBL2FX_QMF(accu1<<1);
    392     }
    393 
    394     /* FIR filter 32/64 */
    395     flt = p_flt[0];
    396     sta0 = *sta_0; sta_0 += staStep1;
    397     accu0 = SMULBB(        sta0, flt);
    398     sta0 = *sta_0; sta_0 += staStep1;
    399     accu0 = SMLABT( accu0, sta0, flt);
    400 
    401     flt = p_flt[1];
    402     sta0 = *sta_0; sta_0 += staStep1;
    403     accu0 = SMLABB( accu0, sta0, flt);
    404     sta0 = *sta_0; sta_0 += staStep1;
    405     accu0 = SMLABT( accu0, sta0, flt);
    406 
    407     flt = p_flt[2];
    408     sta0 = *sta_0;
    409     accu0 = SMLABB( accu0, sta0, flt);
    410     *pData_0-- = FX_DBL2FX_QMF(accu0<<1);
    411   }
    412 }
    413 #endif /* FUNCTION_qmfAnaPrototypeFirSlot */
    414 #endif /* #if defined(__CC_ARM) && defined(__ARM_ARCH_6__) */
    415 
    416 #if ( defined(__ARM_ARCH_5TE__) && (SAMPLE_BITS == 16) ) && !defined(QMF_TABLE_FULL)
    417 
    418 #define FUNCTION_qmfSynPrototypeFirSlot
    419 
    420 #if defined(FUNCTION_qmfSynPrototypeFirSlot)
    421 
    422 #if defined(__GNUC__)	/* cppp replaced: elif */
    423 
    424 inline INT SMULWB (const LONG a, const LONG b)
    425 {
    426   INT result ;
    427   __asm__ ("smulwb %0, %1, %2"
    428     : "=r" (result)
    429     : "r" (a), "r" (b)) ;
    430 
    431   return result ;
    432 }
    433 inline INT SMULWT (const LONG a, const LONG b)
    434 {
    435   INT result ;
    436   __asm__ ("smulwt %0, %1, %2"
    437     : "=r" (result)
    438     : "r" (a), "r" (b)) ;
    439 
    440   return result ;
    441 }
    442 
    443 inline INT SMLAWB(const LONG accu, const LONG a, const LONG b)
    444 {
    445   INT result;
    446   asm("smlawb %0, %1, %2, %3 "
    447         : "=r" (result)
    448         : "r" (a), "r" (b), "r" (accu) );
    449   return result ;
    450 }
    451 
    452 inline INT SMLAWT(const LONG accu, const LONG a, const LONG b)
    453 {
    454   INT result;
    455   asm("smlawt %0, %1, %2, %3 "
    456         : "=r" (result)
    457         : "r" (a), "r" (b), "r" (accu) );
    458   return result ;
    459 }
    460 
    461 #endif /* ARM compiler selector */
    462 
    463 
    464 static void qmfSynPrototypeFirSlot1_filter(FIXP_QMF *RESTRICT realSlot,
    465                                            FIXP_QMF *RESTRICT imagSlot,
    466                                            const FIXP_DBL *RESTRICT p_flt,
    467                                            FIXP_QSS *RESTRICT sta,
    468                                            FIXP_DBL *pMyTimeOut,
    469                                            int no_channels)
    470 {
    471   /* This code was the base for the above listed assembler sequence */
    472   /* It can be used for debugging purpose or further optimizations  */
    473   const FIXP_DBL *RESTRICT p_fltm = p_flt + 155;
    474 
    475   do
    476   {
    477      FIXP_DBL result;
    478      FIXP_DBL A, B, real, imag, sta0;
    479 
    480      real = *--realSlot;
    481      imag = *--imagSlot;
    482      B = p_flt[4];                        /* Bottom=[8] Top=[9]     */
    483      A = p_fltm[3];                       /* Bottom=[316] Top=[317] */
    484      sta0 = sta[0];                       /* save state[0]          */
    485      *sta++ = SMLAWT( sta[1], imag, B );  /* index=9...........319  */
    486      *sta++ = SMLAWB( sta[1], real, A );  /* index=316...........6  */
    487      *sta++ = SMLAWB( sta[1], imag, B );  /* index=8,18,    ...318  */
    488      B = p_flt[3];                        /* Bottom=[6] Top=[7]     */
    489      *sta++ = SMLAWT( sta[1], real, A );  /* index=317...........7  */
    490      A = p_fltm[4];                       /* Bottom=[318] Top=[319] */
    491      *sta++ = SMLAWT( sta[1], imag, B );  /* index=7...........317  */
    492      *sta++ = SMLAWB( sta[1], real, A );  /* index=318...........8  */
    493      *sta++ = SMLAWB( sta[1], imag, B );  /* index=6...........316  */
    494      B = p_flt[2];                        /* Bottom=[X] Top=[5]     */
    495      *sta++ = SMLAWT( sta[1], real, A );  /* index=9...........319  */
    496      A = p_fltm[2];                       /* Bottom=[X] Top=[315]   */
    497      *sta++ =         SMULWT( imag, B );  /* index=5,15, ...   315  */
    498      result = SMLAWT( sta0,   real, A );  /* index=315...........5  */
    499 
    500      *pMyTimeOut++ = result;
    501 
    502      real = *--realSlot;
    503      imag = *--imagSlot;
    504      A = p_fltm[0];                       /* Bottom=[310] Top=[311] */
    505      B = p_flt[7];                        /* Bottom=[14]  Top=[15]  */
    506      result = SMLAWB( sta[0], real, A );  /* index=310...........0  */
    507      *sta++ = SMLAWB( sta[1], imag, B );  /* index=14..........324  */
    508      *pMyTimeOut++ = result;
    509      B = p_flt[6];                        /* Bottom=[12]  Top=[13]  */
    510      *sta++ = SMLAWT( sta[1], real, A );  /* index=311...........1  */
    511      A = p_fltm[1];                       /* Bottom=[312] Top=[313] */
    512      *sta++ = SMLAWT( sta[1], imag, B );  /* index=13..........323  */
    513      *sta++ = SMLAWB( sta[1], real, A );  /* index=312...........2  */
    514      *sta++ = SMLAWB( sta[1], imag, B );  /* index=12..........322  */
    515      *sta++ = SMLAWT( sta[1], real, A );  /* index=313...........3  */
    516      A = p_fltm[2];                       /* Bottom=[314] Top=[315] */
    517      B = p_flt[5];                        /* Bottom=[10]  Top=[11]  */
    518      *sta++ = SMLAWT( sta[1], imag, B );  /* index=11..........321  */
    519      *sta++ = SMLAWB( sta[1], real, A );  /* index=314...........4  */
    520      *sta++ =         SMULWB( imag, B );  /* index=10..........320  */
    521 
    522 
    523      p_flt    += 5;
    524      p_fltm   -= 5;
    525   }
    526   while ((--no_channels) != 0);
    527 
    528 }
    529 
    530 
    531 
    532 INT qmfSynPrototypeFirSlot2(
    533                              HANDLE_QMF_FILTER_BANK qmf,
    534                              FIXP_QMF *RESTRICT realSlot,            /*!< Input: Pointer to real Slot */
    535                              FIXP_QMF *RESTRICT imagSlot,            /*!< Input: Pointer to imag Slot */
    536                              INT_PCM  *RESTRICT timeOut,             /*!< Time domain data */
    537                              INT       stride                        /*!< Time output buffer stride factor*/
    538                             )
    539 {
    540   FIXP_QSS *RESTRICT sta = (FIXP_QSS*)qmf->FilterStates;
    541   int no_channels = qmf->no_channels;
    542   int scale = ((DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor);
    543 
    544   /* We map an arry of 16-bit values upon an array of 2*16-bit values to read 2 values in one shot */
    545   const FIXP_DBL *RESTRICT p_flt  = (FIXP_DBL *) qmf->p_filter;           /* low=[0],   high=[1]   */
    546   const FIXP_DBL *RESTRICT p_fltm = (FIXP_DBL *) qmf->p_filter + 155;     /* low=[310], high=[311] */
    547 
    548   FDK_ASSERT(SAMPLE_BITS-1-qmf->outScalefactor >= 0); //   (DFRACT_BITS-SAMPLE_BITS)-1-qmf->outScalefactor >= 0);
    549   FDK_ASSERT(qmf->p_stride==2 && qmf->no_channels == 32);
    550 
    551   FDK_ASSERT((no_channels&3) == 0);  /* should be a multiple of 4 */
    552 
    553   realSlot += no_channels-1;    // ~~"~~
    554   imagSlot += no_channels-1;    // no_channels-1 .. 0
    555 
    556   FIXP_DBL MyTimeOut[32];
    557   FIXP_DBL *pMyTimeOut = &MyTimeOut[0];
    558 
    559   for (no_channels = no_channels; no_channels--;)
    560   {
    561      FIXP_DBL result;
    562      FIXP_DBL A, B, real, imag;
    563 
    564      real = *realSlot--;
    565      imag = *imagSlot--;
    566      A = p_fltm[0];                       /* Bottom=[310] Top=[311] */
    567      B = p_flt[7];                        /* Bottom=[14]  Top=[15]  */
    568      result = SMLAWB( sta[0], real, A );  /* index=310...........0  */
    569      *sta++ = SMLAWB( sta[1], imag, B );  /* index=14..........324  */
    570      B = p_flt[6];                        /* Bottom=[12]  Top=[13]  */
    571      *sta++ = SMLAWT( sta[1], real, A );  /* index=311...........1  */
    572      A = p_fltm[1];                       /* Bottom=[312] Top=[313] */
    573      *sta++ = SMLAWT( sta[1], imag, B );  /* index=13..........323  */
    574      *sta++ = SMLAWB( sta[1], real, A );  /* index=312...........2  */
    575      *sta++ = SMLAWB( sta[1], imag, B );  /* index=12..........322  */
    576      *sta++ = SMLAWT( sta[1], real, A );  /* index=313...........3  */
    577      A = p_fltm[2];                       /* Bottom=[314] Top=[315] */
    578      B = p_flt[5];                        /* Bottom=[10]  Top=[11]  */
    579      *sta++ = SMLAWT( sta[1], imag, B );  /* index=11..........321  */
    580      *sta++ = SMLAWB( sta[1], real, A );  /* index=314...........4  */
    581      *sta++ =         SMULWB( imag, B );  /* index=10..........320  */
    582 
    583      *pMyTimeOut++ = result;
    584 
    585      p_fltm   -= 5;
    586      p_flt    += 5;
    587   }
    588 
    589   pMyTimeOut = &MyTimeOut[0];
    590 #if (SAMPLE_BITS == 16)
    591   const FIXP_DBL max_pos = (FIXP_DBL) 0x00007FFF << scale;
    592   const FIXP_DBL max_neg = (FIXP_DBL) 0xFFFF8001 << scale;
    593 #else
    594   scale = -scale;
    595   const FIXP_DBL max_pos = (FIXP_DBL) 0x7FFFFFFF >> scale;
    596   const FIXP_DBL max_neg = (FIXP_DBL) 0x80000001 >> scale;
    597 #endif
    598   const FIXP_DBL add_neg = (1 << scale) - 1;
    599 
    600   no_channels = qmf->no_channels;
    601 
    602   timeOut += no_channels*stride;
    603 
    604   FDK_ASSERT(scale >= 0);
    605 
    606   if (qmf->outGain != 0x80000000)
    607   {
    608     FIXP_DBL gain = qmf->outGain;
    609     for (no_channels>>=2; no_channels--;)
    610     {
    611       FIXP_DBL result1, result2;
    612 
    613       result1 = *pMyTimeOut++;
    614       result2 = *pMyTimeOut++;
    615 
    616       result1 = fMult(result1,gain);
    617       timeOut -= stride;
    618       if (result1 < 0)        result1 += add_neg;
    619       if (result1 < max_neg)  result1 = max_neg;
    620       if (result1 > max_pos)  result1 = max_pos;
    621 #if (SAMPLE_BITS == 16)
    622       timeOut[0] = result1 >> scale;
    623 #else
    624       timeOut[0] = result1 << scale;
    625 #endif
    626 
    627       result2 = fMult(result2,gain);
    628       timeOut -= stride;
    629       if (result2 < 0)        result2 += add_neg;
    630       if (result2 < max_neg)  result2 = max_neg;
    631       if (result2 > max_pos)  result2 = max_pos;
    632 #if (SAMPLE_BITS == 16)
    633       timeOut[0] = result2 >> scale;
    634 #else
    635       timeOut[0] = result2 << scale;
    636 #endif
    637 
    638       result1 = *pMyTimeOut++;
    639       result2 = *pMyTimeOut++;
    640 
    641       result1 = fMult(result1,gain);
    642       timeOut -= stride;
    643       if (result1 < 0)        result1 += add_neg;
    644       if (result1 < max_neg)  result1 = max_neg;
    645       if (result1 > max_pos)  result1 = max_pos;
    646 #if (SAMPLE_BITS == 16)
    647       timeOut[0] = result1 >> scale;
    648 #else
    649       timeOut[0] = result1 << scale;
    650 #endif
    651 
    652       result2 = fMult(result2,gain);
    653       timeOut -= stride;
    654       if (result2 < 0)        result2 += add_neg;
    655       if (result2 < max_neg)  result2 = max_neg;
    656       if (result2 > max_pos)  result2 = max_pos;
    657 #if (SAMPLE_BITS == 16)
    658       timeOut[0] = result2 >> scale;
    659 #else
    660       timeOut[0] = result2 << scale;
    661 #endif
    662     }
    663   }
    664   else
    665   {
    666     for (no_channels>>=2; no_channels--;)
    667     {
    668       FIXP_DBL result1, result2;
    669       result1 = *pMyTimeOut++;
    670       result2 = *pMyTimeOut++;
    671       timeOut -= stride;
    672       if (result1 < 0)        result1 += add_neg;
    673       if (result1 < max_neg)  result1 = max_neg;
    674       if (result1 > max_pos)  result1 = max_pos;
    675 #if (SAMPLE_BITS == 16)
    676       timeOut[0] = result1 >> scale;
    677 #else
    678       timeOut[0] = result1 << scale;
    679 #endif
    680 
    681       timeOut -= stride;
    682       if (result2 < 0)        result2 += add_neg;
    683       if (result2 < max_neg)  result2 = max_neg;
    684       if (result2 > max_pos)  result2 = max_pos;
    685 #if (SAMPLE_BITS == 16)
    686       timeOut[0] = result2 >> scale;
    687 #else
    688       timeOut[0] = result2 << scale;
    689 #endif
    690 
    691       result1 = *pMyTimeOut++;
    692       result2 = *pMyTimeOut++;
    693       timeOut -= stride;
    694       if (result1 < 0)        result1 += add_neg;
    695       if (result1 < max_neg)  result1 = max_neg;
    696       if (result1 > max_pos)  result1 = max_pos;
    697 #if (SAMPLE_BITS == 16)
    698       timeOut[0] = result1 >> scale;
    699 #else
    700       timeOut[0] = result1 << scale;
    701 #endif
    702 
    703       timeOut -= stride;
    704       if (result2 < 0)        result2 += add_neg;
    705       if (result2 < max_neg)  result2 = max_neg;
    706       if (result2 > max_pos)  result2 = max_pos;
    707 #if (SAMPLE_BITS == 16)
    708       timeOut[0] = result2 >> scale;
    709 #else
    710       timeOut[0] = result2 << scale;
    711 #endif
    712     }
    713   }
    714   return 0;
    715 }
    716 
    717 static
    718 void qmfSynPrototypeFirSlot_fallback( HANDLE_QMF_FILTER_BANK qmf,
    719                              FIXP_DBL *realSlot,      /*!< Input: Pointer to real Slot */
    720                              FIXP_DBL *imagSlot,      /*!< Input: Pointer to imag Slot */
    721                              INT_PCM  *timeOut,             /*!< Time domain data */
    722                              const int       stride
    723                             );
    724 
    725 /*!
    726   \brief Perform Synthesis Prototype Filtering on a single slot of input data.
    727 
    728   The filter takes 2 * #MAX_SYNTHESIS_CHANNELS of input data and
    729   generates #MAX_SYNTHESIS_CHANNELS time domain output samples.
    730 */
    731 
    732 static
    733 void qmfSynPrototypeFirSlot( HANDLE_QMF_FILTER_BANK qmf,
    734                              FIXP_DBL *realSlot,      /*!< Input: Pointer to real Slot */
    735                              FIXP_DBL *imagSlot,      /*!< Input: Pointer to imag Slot */
    736                              INT_PCM  *timeOut,             /*!< Time domain data */
    737                              const int       stride
    738                             )
    739 {
    740     INT err = -1;
    741 
    742     switch (qmf->p_stride) {
    743     case 2:
    744       err = qmfSynPrototypeFirSlot2(qmf, realSlot, imagSlot, timeOut, stride);
    745       break;
    746     default:
    747       err = -1;
    748     }
    749 
    750     /* fallback if configuration not available or failed */
    751     if(err!=0) {
    752         qmfSynPrototypeFirSlot_fallback(qmf, realSlot, imagSlot, timeOut, stride);
    753     }
    754 }
    755 #endif /* FUNCTION_qmfSynPrototypeFirSlot */
    756 
    757 #endif  /*  ( defined(__CC_ARM) && defined(__ARM_ARCH_5TE__) && (SAMPLE_BITS == 16) ) && !defined(QMF_TABLE_FULL) */
    758 
    759 
    760 
    761 /* #####################################################################################*/
    762 
    763 
    764 
    765 #endif  /* (QMF_NO_POLY==5) */
    766 
    767