arm_cfft_radix4_f32.c

00001 /* ----------------------------------------------------------------------    
00002 * Copyright (C) 2010-2013 ARM Limited. All rights reserved.    
00003 *    
00004 * $Date:        17. January 2013  
00005 * $Revision:    V1.4.1  
00006 *    
00007 * Project:      CMSIS DSP Library    
00008 * Title:        arm_cfft_radix4_f32.c    
00009 *    
00010 * Description:  Radix-4 Decimation in Frequency CFFT & CIFFT Floating point processing function    
00011 *    
00012 *    
00013 * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0
00014 *  
00015 * Redistribution and use in source and binary forms, with or without 
00016 * modification, are permitted provided that the following conditions
00017 * are met:
00018 *   - Redistributions of source code must retain the above copyright
00019 *     notice, this list of conditions and the following disclaimer.
00020 *   - Redistributions in binary form must reproduce the above copyright
00021 *     notice, this list of conditions and the following disclaimer in
00022 *     the documentation and/or other materials provided with the 
00023 *     distribution.
00024 *   - Neither the name of ARM LIMITED nor the names of its contributors
00025 *     may be used to endorse or promote products derived from this
00026 *     software without specific prior written permission.
00027 *
00028 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00029 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00030 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00031 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
00032 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00033 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00034 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00035 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00036 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00037 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
00038 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00039 * POSSIBILITY OF SUCH DAMAGE.    
00040 * -------------------------------------------------------------------- */
00041 
00042 #include "arm_math.h"
00043 
00044 extern void arm_bitreversal_f32(
00045 float32_t * pSrc,
00046 uint16_t fftSize,
00047 uint16_t bitRevFactor,
00048 uint16_t * pBitRevTab);
00049 
00050 /**    
00051 * @ingroup groupTransforms    
00052 */
00053 
00054 /* ----------------------------------------------------------------------    
00055 ** Internal helper function used by the FFTs    
00056 ** ------------------------------------------------------------------- */
00057 
00058 /*    
00059 * @brief  Core function for the floating-point CFFT butterfly process.   
00060 * @param[in, out] *pSrc            points to the in-place buffer of floating-point data type.   
00061 * @param[in]      fftLen           length of the FFT.   
00062 * @param[in]      *pCoef           points to the twiddle coefficient buffer.   
00063 * @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.   
00064 * @return none.   
00065 */
00066 
00067 void arm_radix4_butterfly_f32(
00068 float32_t * pSrc,
00069 uint16_t fftLen,
00070 float32_t * pCoef,
00071 uint16_t twidCoefModifier)
00072 {
00073 
00074    float32_t co1, co2, co3, si1, si2, si3;
00075    uint32_t ia1, ia2, ia3;
00076    uint32_t i0, i1, i2, i3;
00077    uint32_t n1, n2, j, k;
00078 
00079 #ifndef ARM_MATH_CM0_FAMILY_FAMILY
00080 
00081    /* Run the below code for Cortex-M4 and Cortex-M3 */
00082 
00083    float32_t xaIn, yaIn, xbIn, ybIn, xcIn, ycIn, xdIn, ydIn;
00084    float32_t Xaplusc, Xbplusd, Yaplusc, Ybplusd, Xaminusc, Xbminusd, Yaminusc,
00085    Ybminusd;
00086    float32_t Xb12C_out, Yb12C_out, Xc12C_out, Yc12C_out, Xd12C_out, Yd12C_out;
00087    float32_t Xb12_out, Yb12_out, Xc12_out, Yc12_out, Xd12_out, Yd12_out;
00088    float32_t *ptr1;
00089    float32_t p0,p1,p2,p3,p4,p5;
00090    float32_t a0,a1,a2,a3,a4,a5,a6,a7;
00091 
00092    /*  Initializations for the first stage */
00093    n2 = fftLen;
00094    n1 = n2;
00095 
00096    /* n2 = fftLen/4 */
00097    n2 >>= 2u;
00098    i0 = 0u;
00099    ia1 = 0u;
00100 
00101    j = n2;
00102 
00103    /*  Calculation of first stage */
00104    do
00105    {
00106       /*  index calculation for the input as, */
00107       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
00108       i1 = i0 + n2;
00109       i2 = i1 + n2;
00110       i3 = i2 + n2;
00111 
00112       xaIn = pSrc[(2u * i0)];
00113       yaIn = pSrc[(2u * i0) + 1u];
00114 
00115       xbIn = pSrc[(2u * i1)];
00116       ybIn = pSrc[(2u * i1) + 1u];
00117 
00118       xcIn = pSrc[(2u * i2)];
00119       ycIn = pSrc[(2u * i2) + 1u];
00120 
00121       xdIn = pSrc[(2u * i3)];
00122       ydIn = pSrc[(2u * i3) + 1u];
00123 
00124       /* xa + xc */
00125       Xaplusc = xaIn + xcIn;
00126       /* xb + xd */
00127       Xbplusd = xbIn + xdIn;
00128       /* ya + yc */
00129       Yaplusc = yaIn + ycIn;
00130       /* yb + yd */
00131       Ybplusd = ybIn + ydIn;
00132 
00133       /*  index calculation for the coefficients */
00134       ia2 = ia1 + ia1;
00135       co2 = pCoef[ia2 * 2u];
00136       si2 = pCoef[(ia2 * 2u) + 1u];
00137 
00138       /* xa - xc */
00139       Xaminusc = xaIn - xcIn;
00140       /* xb - xd */
00141       Xbminusd = xbIn - xdIn;
00142       /* ya - yc */
00143       Yaminusc = yaIn - ycIn;
00144       /* yb - yd */
00145       Ybminusd = ybIn - ydIn;
00146 
00147       /* xa' = xa + xb + xc + xd */
00148       pSrc[(2u * i0)] = Xaplusc + Xbplusd;
00149       /* ya' = ya + yb + yc + yd */
00150       pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
00151 
00152       /* (xa - xc) + (yb - yd) */
00153       Xb12C_out = (Xaminusc + Ybminusd);
00154       /* (ya - yc) + (xb - xd) */
00155       Yb12C_out = (Yaminusc - Xbminusd);
00156       /* (xa + xc) - (xb + xd) */
00157       Xc12C_out = (Xaplusc - Xbplusd);
00158       /* (ya + yc) - (yb + yd) */
00159       Yc12C_out = (Yaplusc - Ybplusd);
00160       /* (xa - xc) - (yb - yd) */
00161       Xd12C_out = (Xaminusc - Ybminusd);
00162       /* (ya - yc) + (xb - xd) */
00163       Yd12C_out = (Xbminusd + Yaminusc);
00164 
00165       co1 = pCoef[ia1 * 2u];
00166       si1 = pCoef[(ia1 * 2u) + 1u];
00167 
00168       /*  index calculation for the coefficients */
00169       ia3 = ia2 + ia1;
00170       co3 = pCoef[ia3 * 2u];
00171       si3 = pCoef[(ia3 * 2u) + 1u];
00172 
00173       Xb12_out = Xb12C_out * co1;
00174       Yb12_out = Yb12C_out * co1;
00175       Xc12_out = Xc12C_out * co2;
00176       Yc12_out = Yc12C_out * co2;
00177       Xd12_out = Xd12C_out * co3;
00178       Yd12_out = Yd12C_out * co3;
00179          
00180       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00181       //Xb12_out -= Yb12C_out * si1;
00182       p0 = Yb12C_out * si1;
00183       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00184       //Yb12_out += Xb12C_out * si1;
00185       p1 = Xb12C_out * si1;
00186       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00187       //Xc12_out -= Yc12C_out * si2;
00188       p2 = Yc12C_out * si2;
00189       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00190       //Yc12_out += Xc12C_out * si2;
00191       p3 = Xc12C_out * si2;
00192       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00193       //Xd12_out -= Yd12C_out * si3;
00194       p4 = Yd12C_out * si3;
00195       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00196       //Yd12_out += Xd12C_out * si3;
00197       p5 = Xd12C_out * si3;
00198       
00199       Xb12_out += p0;
00200       Yb12_out -= p1;
00201       Xc12_out += p2;
00202       Yc12_out -= p3;
00203       Xd12_out += p4;
00204       Yd12_out -= p5;
00205 
00206       /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
00207       pSrc[2u * i1] = Xc12_out;
00208 
00209       /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
00210       pSrc[(2u * i1) + 1u] = Yc12_out;
00211 
00212       /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
00213       pSrc[2u * i2] = Xb12_out;
00214 
00215       /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
00216       pSrc[(2u * i2) + 1u] = Yb12_out;
00217 
00218       /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
00219       pSrc[2u * i3] = Xd12_out;
00220 
00221       /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
00222       pSrc[(2u * i3) + 1u] = Yd12_out;
00223 
00224       /*  Twiddle coefficients index modifier */
00225       ia1 += twidCoefModifier;
00226 
00227       /*  Updating input index */
00228       i0++;
00229 
00230    }
00231    while(--j);
00232 
00233    twidCoefModifier <<= 2u;
00234 
00235    /*  Calculation of second stage to excluding last stage */
00236    for (k = fftLen >> 2u; k > 4u; k >>= 2u)
00237    {
00238       /*  Initializations for the first stage */
00239       n1 = n2;
00240       n2 >>= 2u;
00241       ia1 = 0u;
00242 
00243       /*  Calculation of first stage */
00244       j = 0;
00245       do
00246       {
00247          /*  index calculation for the coefficients */
00248          ia2 = ia1 + ia1;
00249          ia3 = ia2 + ia1;
00250          co1 = pCoef[ia1 * 2u];
00251          si1 = pCoef[(ia1 * 2u) + 1u];
00252          co2 = pCoef[ia2 * 2u];
00253          si2 = pCoef[(ia2 * 2u) + 1u];
00254          co3 = pCoef[ia3 * 2u];
00255          si3 = pCoef[(ia3 * 2u) + 1u];
00256 
00257          /*  Twiddle coefficients index modifier */
00258          ia1 += twidCoefModifier;
00259       
00260          i0 = j;
00261          do
00262          {
00263             /*  index calculation for the input as, */
00264             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
00265             i1 = i0 + n2;
00266             i2 = i1 + n2;
00267             i3 = i2 + n2;
00268 
00269             xaIn = pSrc[(2u * i0)];
00270             yaIn = pSrc[(2u * i0) + 1u];
00271 
00272             xbIn = pSrc[(2u * i1)];
00273             ybIn = pSrc[(2u * i1) + 1u];
00274 
00275             xcIn = pSrc[(2u * i2)];
00276             ycIn = pSrc[(2u * i2) + 1u];
00277 
00278             xdIn = pSrc[(2u * i3)];
00279             ydIn = pSrc[(2u * i3) + 1u];
00280 
00281             /* xa - xc */
00282             Xaminusc = xaIn - xcIn;
00283             /* (xb - xd) */
00284             Xbminusd = xbIn - xdIn;
00285             /* ya - yc */
00286             Yaminusc = yaIn - ycIn;
00287             /* (yb - yd) */
00288             Ybminusd = ybIn - ydIn;
00289 
00290             /* xa + xc */
00291             Xaplusc = xaIn + xcIn;
00292             /* xb + xd */
00293             Xbplusd = xbIn + xdIn;
00294             /* ya + yc */
00295             Yaplusc = yaIn + ycIn;
00296             /* yb + yd */
00297             Ybplusd = ybIn + ydIn;
00298 
00299             /* (xa - xc) + (yb - yd) */
00300             Xb12C_out = (Xaminusc + Ybminusd);
00301             /* (ya - yc) -  (xb - xd) */
00302             Yb12C_out = (Yaminusc - Xbminusd);
00303             /* xa + xc -(xb + xd) */
00304             Xc12C_out = (Xaplusc - Xbplusd);
00305             /* (ya + yc) - (yb + yd) */
00306             Yc12C_out = (Yaplusc - Ybplusd);
00307             /* (xa - xc) - (yb - yd) */
00308             Xd12C_out = (Xaminusc - Ybminusd);
00309             /* (ya - yc) +  (xb - xd) */
00310             Yd12C_out = (Xbminusd + Yaminusc);
00311 
00312             pSrc[(2u * i0)] = Xaplusc + Xbplusd;
00313             pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
00314 
00315             Xb12_out = Xb12C_out * co1;
00316             Yb12_out = Yb12C_out * co1;
00317             Xc12_out = Xc12C_out * co2;
00318             Yc12_out = Yc12C_out * co2;
00319             Xd12_out = Xd12C_out * co3;
00320             Yd12_out = Yd12C_out * co3;
00321          
00322             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00323             //Xb12_out -= Yb12C_out * si1;
00324             p0 = Yb12C_out * si1;
00325             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00326             //Yb12_out += Xb12C_out * si1;
00327             p1 = Xb12C_out * si1;
00328             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00329             //Xc12_out -= Yc12C_out * si2;
00330             p2 = Yc12C_out * si2;
00331             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00332             //Yc12_out += Xc12C_out * si2;
00333             p3 = Xc12C_out * si2;
00334             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00335             //Xd12_out -= Yd12C_out * si3;
00336             p4 = Yd12C_out * si3;
00337             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00338             //Yd12_out += Xd12C_out * si3;
00339             p5 = Xd12C_out * si3;
00340             
00341             Xb12_out += p0;
00342             Yb12_out -= p1;
00343             Xc12_out += p2;
00344             Yc12_out -= p3;
00345             Xd12_out += p4;
00346             Yd12_out -= p5;
00347 
00348             /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
00349             pSrc[2u * i1] = Xc12_out;
00350 
00351             /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
00352             pSrc[(2u * i1) + 1u] = Yc12_out;
00353 
00354             /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
00355             pSrc[2u * i2] = Xb12_out;
00356 
00357             /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
00358             pSrc[(2u * i2) + 1u] = Yb12_out;
00359 
00360             /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
00361             pSrc[2u * i3] = Xd12_out;
00362 
00363             /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
00364             pSrc[(2u * i3) + 1u] = Yd12_out;
00365 
00366             i0 += n1;
00367          } while(i0 < fftLen);
00368          j++;
00369       } while(j <= (n2 - 1u));
00370       twidCoefModifier <<= 2u;
00371    }
00372 
00373    j = fftLen >> 2;
00374    ptr1 = &pSrc[0];
00375 
00376    /*  Calculations of last stage */
00377    do
00378    {
00379       xaIn = ptr1[0];
00380       yaIn = ptr1[1];
00381       xbIn = ptr1[2];
00382       ybIn = ptr1[3];
00383       xcIn = ptr1[4];
00384       ycIn = ptr1[5];
00385       xdIn = ptr1[6];
00386       ydIn = ptr1[7];
00387 
00388       /* xa + xc */
00389       Xaplusc = xaIn + xcIn;
00390 
00391       /* xa - xc */
00392       Xaminusc = xaIn - xcIn;
00393 
00394       /* ya + yc */
00395       Yaplusc = yaIn + ycIn;
00396 
00397       /* ya - yc */
00398       Yaminusc = yaIn - ycIn;
00399 
00400       /* xb + xd */
00401       Xbplusd = xbIn + xdIn;
00402 
00403       /* yb + yd */
00404       Ybplusd = ybIn + ydIn;
00405 
00406       /* (xb-xd) */
00407       Xbminusd = xbIn - xdIn;
00408 
00409       /* (yb-yd) */
00410       Ybminusd = ybIn - ydIn;
00411 
00412       /* xa' = xa + xb + xc + xd */
00413       a0 = (Xaplusc + Xbplusd);
00414       /* ya' = ya + yb + yc + yd */
00415       a1 = (Yaplusc + Ybplusd);
00416       /* xc' = (xa-xb+xc-xd) */
00417       a2 = (Xaplusc - Xbplusd);
00418       /* yc' = (ya-yb+yc-yd) */
00419       a3 = (Yaplusc - Ybplusd);
00420       /* xb' = (xa+yb-xc-yd) */
00421       a4 = (Xaminusc + Ybminusd);
00422       /* yb' = (ya-xb-yc+xd) */
00423       a5 = (Yaminusc - Xbminusd);
00424       /* xd' = (xa-yb-xc+yd)) */
00425       a6 = (Xaminusc - Ybminusd);
00426       /* yd' = (ya+xb-yc-xd) */
00427       a7 = (Xbminusd + Yaminusc);
00428    
00429       ptr1[0] = a0;
00430       ptr1[1] = a1;
00431       ptr1[2] = a2;
00432       ptr1[3] = a3;
00433       ptr1[4] = a4;
00434       ptr1[5] = a5;
00435       ptr1[6] = a6;
00436       ptr1[7] = a7;
00437 
00438       /* increment pointer by 8 */
00439       ptr1 += 8u;
00440    } while(--j);
00441 
00442 #else
00443 
00444    float32_t t1, t2, r1, r2, s1, s2;
00445 
00446    /* Run the below code for Cortex-M0 */
00447 
00448    /*  Initializations for the fft calculation */
00449    n2 = fftLen;
00450    n1 = n2;
00451    for (k = fftLen; k > 1u; k >>= 2u)
00452    {
00453       /*  Initializations for the fft calculation */
00454       n1 = n2;
00455       n2 >>= 2u;
00456       ia1 = 0u;
00457 
00458       /*  FFT Calculation */
00459       j = 0;
00460       do
00461       {
00462          /*  index calculation for the coefficients */
00463          ia2 = ia1 + ia1;
00464          ia3 = ia2 + ia1;
00465          co1 = pCoef[ia1 * 2u];
00466          si1 = pCoef[(ia1 * 2u) + 1u];
00467          co2 = pCoef[ia2 * 2u];
00468          si2 = pCoef[(ia2 * 2u) + 1u];
00469          co3 = pCoef[ia3 * 2u];
00470          si3 = pCoef[(ia3 * 2u) + 1u];
00471 
00472          /*  Twiddle coefficients index modifier */
00473          ia1 = ia1 + twidCoefModifier;
00474 
00475          i0 = j;
00476          do
00477          {
00478             /*  index calculation for the input as, */
00479             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
00480             i1 = i0 + n2;
00481             i2 = i1 + n2;
00482             i3 = i2 + n2;
00483 
00484             /* xa + xc */
00485             r1 = pSrc[(2u * i0)] + pSrc[(2u * i2)];
00486 
00487             /* xa - xc */
00488             r2 = pSrc[(2u * i0)] - pSrc[(2u * i2)];
00489 
00490             /* ya + yc */
00491             s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
00492 
00493             /* ya - yc */
00494             s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
00495 
00496             /* xb + xd */
00497             t1 = pSrc[2u * i1] + pSrc[2u * i3];
00498 
00499             /* xa' = xa + xb + xc + xd */
00500             pSrc[2u * i0] = r1 + t1;
00501 
00502             /* xa + xc -(xb + xd) */
00503             r1 = r1 - t1;
00504 
00505             /* yb + yd */
00506             t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
00507 
00508             /* ya' = ya + yb + yc + yd */
00509             pSrc[(2u * i0) + 1u] = s1 + t2;
00510 
00511             /* (ya + yc) - (yb + yd) */
00512             s1 = s1 - t2;
00513 
00514             /* (yb - yd) */
00515             t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
00516 
00517             /* (xb - xd) */
00518             t2 = pSrc[2u * i1] - pSrc[2u * i3];
00519 
00520             /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
00521             pSrc[2u * i1] = (r1 * co2) + (s1 * si2);
00522 
00523             /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
00524             pSrc[(2u * i1) + 1u] = (s1 * co2) - (r1 * si2);
00525 
00526             /* (xa - xc) + (yb - yd) */
00527             r1 = r2 + t1;
00528 
00529             /* (xa - xc) - (yb - yd) */
00530             r2 = r2 - t1;
00531 
00532             /* (ya - yc) -  (xb - xd) */
00533             s1 = s2 - t2;
00534 
00535             /* (ya - yc) +  (xb - xd) */
00536             s2 = s2 + t2;
00537 
00538             /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
00539             pSrc[2u * i2] = (r1 * co1) + (s1 * si1);
00540 
00541             /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
00542             pSrc[(2u * i2) + 1u] = (s1 * co1) - (r1 * si1);
00543 
00544             /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
00545             pSrc[2u * i3] = (r2 * co3) + (s2 * si3);
00546 
00547             /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
00548             pSrc[(2u * i3) + 1u] = (s2 * co3) - (r2 * si3);
00549          
00550             i0 += n1;
00551          } while( i0 < fftLen);
00552          j++;
00553       } while(j <= (n2 - 1u));
00554       twidCoefModifier <<= 2u;
00555    }
00556 
00557 #endif /* #ifndef ARM_MATH_CM0_FAMILY_FAMILY */
00558 
00559 }
00560 
00561 /*    
00562 * @brief  Core function for the floating-point CIFFT butterfly process.   
00563 * @param[in, out] *pSrc            points to the in-place buffer of floating-point data type.   
00564 * @param[in]      fftLen           length of the FFT.   
00565 * @param[in]      *pCoef           points to twiddle coefficient buffer.   
00566 * @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.   
00567 * @param[in]      onebyfftLen      value of 1/fftLen.   
00568 * @return none.   
00569 */
00570 
00571 void arm_radix4_butterfly_inverse_f32(
00572 float32_t * pSrc,
00573 uint16_t fftLen,
00574 float32_t * pCoef,
00575 uint16_t twidCoefModifier,
00576 float32_t onebyfftLen)
00577 {
00578    float32_t co1, co2, co3, si1, si2, si3;
00579    uint32_t ia1, ia2, ia3;
00580    uint32_t i0, i1, i2, i3;
00581    uint32_t n1, n2, j, k;
00582 
00583 #ifndef ARM_MATH_CM0_FAMILY_FAMILY
00584 
00585    float32_t xaIn, yaIn, xbIn, ybIn, xcIn, ycIn, xdIn, ydIn;
00586    float32_t Xaplusc, Xbplusd, Yaplusc, Ybplusd, Xaminusc, Xbminusd, Yaminusc,
00587    Ybminusd;
00588    float32_t Xb12C_out, Yb12C_out, Xc12C_out, Yc12C_out, Xd12C_out, Yd12C_out;
00589    float32_t Xb12_out, Yb12_out, Xc12_out, Yc12_out, Xd12_out, Yd12_out;
00590    float32_t *ptr1;
00591    float32_t p0,p1,p2,p3,p4,p5,p6,p7;
00592    float32_t a0,a1,a2,a3,a4,a5,a6,a7;
00593 
00594 
00595    /*  Initializations for the first stage */
00596    n2 = fftLen;
00597    n1 = n2;
00598 
00599    /* n2 = fftLen/4 */
00600    n2 >>= 2u;
00601    i0 = 0u;
00602    ia1 = 0u;
00603 
00604    j = n2;
00605 
00606    /*  Calculation of first stage */
00607    do
00608    {
00609       /*  index calculation for the input as, */
00610       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
00611       i1 = i0 + n2;
00612       i2 = i1 + n2;
00613       i3 = i2 + n2;
00614 
00615       /*  Butterfly implementation */
00616       xaIn = pSrc[(2u * i0)];
00617       yaIn = pSrc[(2u * i0) + 1u];
00618 
00619       xcIn = pSrc[(2u * i2)];
00620       ycIn = pSrc[(2u * i2) + 1u];
00621 
00622       xbIn = pSrc[(2u * i1)];
00623       ybIn = pSrc[(2u * i1) + 1u];
00624 
00625       xdIn = pSrc[(2u * i3)];
00626       ydIn = pSrc[(2u * i3) + 1u];
00627 
00628       /* xa + xc */
00629       Xaplusc = xaIn + xcIn;
00630       /* xb + xd */
00631       Xbplusd = xbIn + xdIn;
00632       /* ya + yc */
00633       Yaplusc = yaIn + ycIn;
00634       /* yb + yd */
00635       Ybplusd = ybIn + ydIn;
00636 
00637       /*  index calculation for the coefficients */
00638       ia2 = ia1 + ia1;
00639       co2 = pCoef[ia2 * 2u];
00640       si2 = pCoef[(ia2 * 2u) + 1u];
00641 
00642       /* xa - xc */
00643       Xaminusc = xaIn - xcIn;
00644       /* xb - xd */
00645       Xbminusd = xbIn - xdIn;
00646       /* ya - yc */
00647       Yaminusc = yaIn - ycIn;
00648       /* yb - yd */
00649       Ybminusd = ybIn - ydIn;
00650 
00651       /* xa' = xa + xb + xc + xd */
00652       pSrc[(2u * i0)] = Xaplusc + Xbplusd;
00653 
00654       /* ya' = ya + yb + yc + yd */
00655       pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
00656 
00657       /* (xa - xc) - (yb - yd) */
00658       Xb12C_out = (Xaminusc - Ybminusd);
00659       /* (ya - yc) + (xb - xd) */
00660       Yb12C_out = (Yaminusc + Xbminusd);
00661       /* (xa + xc) - (xb + xd) */
00662       Xc12C_out = (Xaplusc - Xbplusd);
00663       /* (ya + yc) - (yb + yd) */
00664       Yc12C_out = (Yaplusc - Ybplusd);
00665       /* (xa - xc) + (yb - yd) */
00666       Xd12C_out = (Xaminusc + Ybminusd);
00667       /* (ya - yc) - (xb - xd) */
00668       Yd12C_out = (Yaminusc - Xbminusd);
00669 
00670       co1 = pCoef[ia1 * 2u];
00671       si1 = pCoef[(ia1 * 2u) + 1u];
00672 
00673       /*  index calculation for the coefficients */
00674       ia3 = ia2 + ia1;
00675       co3 = pCoef[ia3 * 2u];
00676       si3 = pCoef[(ia3 * 2u) + 1u];
00677 
00678       Xb12_out = Xb12C_out * co1;
00679       Yb12_out = Yb12C_out * co1;
00680       Xc12_out = Xc12C_out * co2;
00681       Yc12_out = Yc12C_out * co2;
00682       Xd12_out = Xd12C_out * co3;
00683       Yd12_out = Yd12C_out * co3;
00684    
00685       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00686       //Xb12_out -= Yb12C_out * si1;
00687       p0 = Yb12C_out * si1;
00688       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00689       //Yb12_out += Xb12C_out * si1;
00690       p1 = Xb12C_out * si1;
00691       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00692       //Xc12_out -= Yc12C_out * si2;
00693       p2 = Yc12C_out * si2;
00694       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00695       //Yc12_out += Xc12C_out * si2;
00696       p3 = Xc12C_out * si2;
00697       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00698       //Xd12_out -= Yd12C_out * si3;
00699       p4 = Yd12C_out * si3;
00700       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00701       //Yd12_out += Xd12C_out * si3;
00702       p5 = Xd12C_out * si3;
00703       
00704       Xb12_out -= p0;
00705       Yb12_out += p1;
00706       Xc12_out -= p2;
00707       Yc12_out += p3;
00708       Xd12_out -= p4;
00709       Yd12_out += p5;
00710 
00711       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00712       pSrc[2u * i1] = Xc12_out;
00713 
00714       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00715       pSrc[(2u * i1) + 1u] = Yc12_out;
00716 
00717       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00718       pSrc[2u * i2] = Xb12_out;
00719 
00720       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00721       pSrc[(2u * i2) + 1u] = Yb12_out;
00722 
00723       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00724       pSrc[2u * i3] = Xd12_out;
00725 
00726       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00727       pSrc[(2u * i3) + 1u] = Yd12_out;
00728 
00729       /*  Twiddle coefficients index modifier */
00730       ia1 = ia1 + twidCoefModifier;
00731 
00732       /*  Updating input index */
00733       i0 = i0 + 1u;
00734 
00735    } while(--j);
00736 
00737    twidCoefModifier <<= 2u;
00738 
00739    /*  Calculation of second stage to excluding last stage */
00740    for (k = fftLen >> 2u; k > 4u; k >>= 2u)
00741    {
00742       /*  Initializations for the first stage */
00743       n1 = n2;
00744       n2 >>= 2u;
00745       ia1 = 0u;
00746 
00747       /*  Calculation of first stage */
00748       j = 0;
00749       do
00750       {
00751          /*  index calculation for the coefficients */
00752          ia2 = ia1 + ia1;
00753          ia3 = ia2 + ia1;
00754          co1 = pCoef[ia1 * 2u];
00755          si1 = pCoef[(ia1 * 2u) + 1u];
00756          co2 = pCoef[ia2 * 2u];
00757          si2 = pCoef[(ia2 * 2u) + 1u];
00758          co3 = pCoef[ia3 * 2u];
00759          si3 = pCoef[(ia3 * 2u) + 1u];
00760 
00761          /*  Twiddle coefficients index modifier */
00762          ia1 = ia1 + twidCoefModifier;
00763 
00764          i0 = j;
00765          do
00766          {
00767             /*  index calculation for the input as, */
00768             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
00769             i1 = i0 + n2;
00770             i2 = i1 + n2;
00771             i3 = i2 + n2;
00772 
00773             xaIn = pSrc[(2u * i0)];
00774             yaIn = pSrc[(2u * i0) + 1u];
00775 
00776             xbIn = pSrc[(2u * i1)];
00777             ybIn = pSrc[(2u * i1) + 1u];
00778 
00779             xcIn = pSrc[(2u * i2)];
00780             ycIn = pSrc[(2u * i2) + 1u];
00781 
00782             xdIn = pSrc[(2u * i3)];
00783             ydIn = pSrc[(2u * i3) + 1u];
00784 
00785             /* xa - xc */
00786             Xaminusc = xaIn - xcIn;
00787             /* (xb - xd) */
00788             Xbminusd = xbIn - xdIn;
00789             /* ya - yc */
00790             Yaminusc = yaIn - ycIn;
00791             /* (yb - yd) */
00792             Ybminusd = ybIn - ydIn;
00793 
00794             /* xa + xc */
00795             Xaplusc = xaIn + xcIn;
00796             /* xb + xd */
00797             Xbplusd = xbIn + xdIn;
00798             /* ya + yc */
00799             Yaplusc = yaIn + ycIn;
00800             /* yb + yd */
00801             Ybplusd = ybIn + ydIn;
00802 
00803             /* (xa - xc) - (yb - yd) */
00804             Xb12C_out = (Xaminusc - Ybminusd);
00805             /* (ya - yc) +  (xb - xd) */
00806             Yb12C_out = (Yaminusc + Xbminusd);
00807             /* xa + xc -(xb + xd) */
00808             Xc12C_out = (Xaplusc - Xbplusd);
00809             /* (ya + yc) - (yb + yd) */
00810             Yc12C_out = (Yaplusc - Ybplusd);
00811             /* (xa - xc) + (yb - yd) */
00812             Xd12C_out = (Xaminusc + Ybminusd);
00813             /* (ya - yc) -  (xb - xd) */
00814             Yd12C_out = (Yaminusc - Xbminusd);
00815 
00816             pSrc[(2u * i0)] = Xaplusc + Xbplusd;
00817             pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
00818 
00819             Xb12_out = Xb12C_out * co1;
00820             Yb12_out = Yb12C_out * co1;
00821             Xc12_out = Xc12C_out * co2;
00822             Yc12_out = Yc12C_out * co2;
00823             Xd12_out = Xd12C_out * co3;
00824             Yd12_out = Yd12C_out * co3;
00825 
00826             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00827             //Xb12_out -= Yb12C_out * si1;
00828             p0 = Yb12C_out * si1;
00829             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00830             //Yb12_out += Xb12C_out * si1;
00831             p1 = Xb12C_out * si1;
00832             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00833             //Xc12_out -= Yc12C_out * si2;
00834             p2 = Yc12C_out * si2;
00835             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00836             //Yc12_out += Xc12C_out * si2;
00837             p3 = Xc12C_out * si2;
00838             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00839             //Xd12_out -= Yd12C_out * si3;
00840             p4 = Yd12C_out * si3;
00841             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00842             //Yd12_out += Xd12C_out * si3;
00843             p5 = Xd12C_out * si3;
00844             
00845             Xb12_out -= p0;
00846             Yb12_out += p1;
00847             Xc12_out -= p2;
00848             Yc12_out += p3;
00849             Xd12_out -= p4;
00850             Yd12_out += p5;
00851 
00852             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
00853             pSrc[2u * i1] = Xc12_out;
00854 
00855             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
00856             pSrc[(2u * i1) + 1u] = Yc12_out;
00857 
00858             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
00859             pSrc[2u * i2] = Xb12_out;
00860 
00861             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
00862             pSrc[(2u * i2) + 1u] = Yb12_out;
00863 
00864             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
00865             pSrc[2u * i3] = Xd12_out;
00866 
00867             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
00868             pSrc[(2u * i3) + 1u] = Yd12_out;
00869 
00870             i0 += n1;
00871          } while(i0 < fftLen);
00872          j++;
00873       } while(j <= (n2 - 1u));
00874       twidCoefModifier <<= 2u;
00875    }
00876    /*  Initializations of last stage */
00877 
00878    j = fftLen >> 2;
00879    ptr1 = &pSrc[0];
00880 
00881    /*  Calculations of last stage */
00882    do
00883    {
00884       xaIn = ptr1[0];
00885       yaIn = ptr1[1];
00886       xbIn = ptr1[2];
00887       ybIn = ptr1[3];
00888       xcIn = ptr1[4];
00889       ycIn = ptr1[5];
00890       xdIn = ptr1[6];
00891       ydIn = ptr1[7];
00892 
00893       /*  Butterfly implementation */
00894       /* xa + xc */
00895       Xaplusc = xaIn + xcIn;
00896 
00897       /* xa - xc */
00898       Xaminusc = xaIn - xcIn;
00899 
00900       /* ya + yc */
00901       Yaplusc = yaIn + ycIn;
00902 
00903       /* ya - yc */
00904       Yaminusc = yaIn - ycIn;
00905 
00906       /* xb + xd */
00907       Xbplusd = xbIn + xdIn;
00908 
00909       /* yb + yd */
00910       Ybplusd = ybIn + ydIn;
00911 
00912       /* (xb-xd) */
00913       Xbminusd = xbIn - xdIn;
00914 
00915       /* (yb-yd) */
00916       Ybminusd = ybIn - ydIn;
00917       
00918       /* xa' = (xa+xb+xc+xd) * onebyfftLen */
00919       a0 = (Xaplusc + Xbplusd);
00920       /* ya' = (ya+yb+yc+yd) * onebyfftLen */
00921       a1 = (Yaplusc + Ybplusd);
00922       /* xc' = (xa-xb+xc-xd) * onebyfftLen */
00923       a2 = (Xaplusc - Xbplusd);
00924       /* yc' = (ya-yb+yc-yd) * onebyfftLen  */
00925       a3 = (Yaplusc - Ybplusd);
00926       /* xb' = (xa-yb-xc+yd) * onebyfftLen */
00927       a4 = (Xaminusc - Ybminusd);
00928       /* yb' = (ya+xb-yc-xd) * onebyfftLen */
00929       a5 = (Yaminusc + Xbminusd);
00930       /* xd' = (xa-yb-xc+yd) * onebyfftLen */
00931       a6 = (Xaminusc + Ybminusd);
00932       /* yd' = (ya-xb-yc+xd) * onebyfftLen */
00933       a7 = (Yaminusc - Xbminusd);
00934    
00935       p0 = a0 * onebyfftLen;
00936       p1 = a1 * onebyfftLen;
00937       p2 = a2 * onebyfftLen;
00938       p3 = a3 * onebyfftLen;
00939       p4 = a4 * onebyfftLen;
00940       p5 = a5 * onebyfftLen;
00941       p6 = a6 * onebyfftLen;
00942       p7 = a7 * onebyfftLen;
00943    
00944       /* xa' = (xa+xb+xc+xd) * onebyfftLen */
00945       ptr1[0] = p0;
00946       /* ya' = (ya+yb+yc+yd) * onebyfftLen */
00947       ptr1[1] = p1;
00948       /* xc' = (xa-xb+xc-xd) * onebyfftLen */
00949       ptr1[2] = p2;
00950       /* yc' = (ya-yb+yc-yd) * onebyfftLen  */
00951       ptr1[3] = p3;
00952       /* xb' = (xa-yb-xc+yd) * onebyfftLen */
00953       ptr1[4] = p4;
00954       /* yb' = (ya+xb-yc-xd) * onebyfftLen */
00955       ptr1[5] = p5;
00956       /* xd' = (xa-yb-xc+yd) * onebyfftLen */
00957       ptr1[6] = p6;
00958       /* yd' = (ya-xb-yc+xd) * onebyfftLen */
00959       ptr1[7] = p7;
00960 
00961       /* increment source pointer by 8 for next calculations */
00962       ptr1 = ptr1 + 8u;
00963 
00964    } while(--j);
00965 
00966 #else
00967 
00968    float32_t t1, t2, r1, r2, s1, s2;
00969 
00970    /* Run the below code for Cortex-M0 */
00971 
00972    /*  Initializations for the first stage */
00973    n2 = fftLen;
00974    n1 = n2;
00975 
00976    /*  Calculation of first stage */
00977    for (k = fftLen; k > 4u; k >>= 2u)
00978    {
00979       /*  Initializations for the first stage */
00980       n1 = n2;
00981       n2 >>= 2u;
00982       ia1 = 0u;
00983 
00984       /*  Calculation of first stage */
00985       j = 0;
00986       do
00987       {
00988          /*  index calculation for the coefficients */
00989          ia2 = ia1 + ia1;
00990          ia3 = ia2 + ia1;
00991          co1 = pCoef[ia1 * 2u];
00992          si1 = pCoef[(ia1 * 2u) + 1u];
00993          co2 = pCoef[ia2 * 2u];
00994          si2 = pCoef[(ia2 * 2u) + 1u];
00995          co3 = pCoef[ia3 * 2u];
00996          si3 = pCoef[(ia3 * 2u) + 1u];
00997 
00998          /*  Twiddle coefficients index modifier */
00999          ia1 = ia1 + twidCoefModifier;
01000 
01001          i0 = j;
01002          do
01003          {
01004             /*  index calculation for the input as, */
01005             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
01006             i1 = i0 + n2;
01007             i2 = i1 + n2;
01008             i3 = i2 + n2;
01009 
01010             /* xa + xc */
01011             r1 = pSrc[(2u * i0)] + pSrc[(2u * i2)];
01012 
01013             /* xa - xc */
01014             r2 = pSrc[(2u * i0)] - pSrc[(2u * i2)];
01015 
01016             /* ya + yc */
01017             s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
01018 
01019             /* ya - yc */
01020             s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
01021 
01022             /* xb + xd */
01023             t1 = pSrc[2u * i1] + pSrc[2u * i3];
01024 
01025             /* xa' = xa + xb + xc + xd */
01026             pSrc[2u * i0] = r1 + t1;
01027 
01028             /* xa + xc -(xb + xd) */
01029             r1 = r1 - t1;
01030 
01031             /* yb + yd */
01032             t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
01033 
01034             /* ya' = ya + yb + yc + yd */
01035             pSrc[(2u * i0) + 1u] = s1 + t2;
01036 
01037             /* (ya + yc) - (yb + yd) */
01038             s1 = s1 - t2;
01039 
01040             /* (yb - yd) */
01041             t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
01042 
01043             /* (xb - xd) */
01044             t2 = pSrc[2u * i1] - pSrc[2u * i3];
01045 
01046             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
01047             pSrc[2u * i1] = (r1 * co2) - (s1 * si2);
01048 
01049             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
01050             pSrc[(2u * i1) + 1u] = (s1 * co2) + (r1 * si2);
01051 
01052             /* (xa - xc) - (yb - yd) */
01053             r1 = r2 - t1;
01054 
01055             /* (xa - xc) + (yb - yd) */
01056             r2 = r2 + t1;
01057 
01058             /* (ya - yc) +  (xb - xd) */
01059             s1 = s2 + t2;
01060 
01061             /* (ya - yc) -  (xb - xd) */
01062             s2 = s2 - t2;
01063 
01064             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
01065             pSrc[2u * i2] = (r1 * co1) - (s1 * si1);
01066 
01067             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
01068             pSrc[(2u * i2) + 1u] = (s1 * co1) + (r1 * si1);
01069 
01070             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
01071             pSrc[2u * i3] = (r2 * co3) - (s2 * si3);
01072 
01073             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
01074             pSrc[(2u * i3) + 1u] = (s2 * co3) + (r2 * si3);
01075          
01076             i0 += n1;
01077          } while( i0 < fftLen);
01078          j++;
01079       } while(j <= (n2 - 1u));
01080       twidCoefModifier <<= 2u;
01081    }
01082    /*  Initializations of last stage */
01083    n1 = n2;
01084    n2 >>= 2u;
01085 
01086    /*  Calculations of last stage */
01087    for (i0 = 0u; i0 <= (fftLen - n1); i0 += n1)
01088    {
01089       /*  index calculation for the input as, */
01090       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
01091       i1 = i0 + n2;
01092       i2 = i1 + n2;
01093       i3 = i2 + n2;
01094 
01095       /*  Butterfly implementation */
01096       /* xa + xc */
01097       r1 = pSrc[2u * i0] + pSrc[2u * i2];
01098 
01099       /* xa - xc */
01100       r2 = pSrc[2u * i0] - pSrc[2u * i2];
01101 
01102       /* ya + yc */
01103       s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
01104 
01105       /* ya - yc */
01106       s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
01107 
01108       /* xc + xd */
01109       t1 = pSrc[2u * i1] + pSrc[2u * i3];
01110 
01111       /* xa' = xa + xb + xc + xd */
01112       pSrc[2u * i0] = (r1 + t1) * onebyfftLen;
01113 
01114       /* (xa + xb) - (xc + xd) */
01115       r1 = r1 - t1;
01116 
01117       /* yb + yd */
01118       t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
01119 
01120       /* ya' = ya + yb + yc + yd */
01121       pSrc[(2u * i0) + 1u] = (s1 + t2) * onebyfftLen;
01122 
01123       /* (ya + yc) - (yb + yd) */
01124       s1 = s1 - t2;
01125 
01126       /* (yb-yd) */
01127       t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
01128 
01129       /* (xb-xd) */
01130       t2 = pSrc[2u * i1] - pSrc[2u * i3];
01131 
01132       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
01133       pSrc[2u * i1] = r1 * onebyfftLen;
01134 
01135       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
01136       pSrc[(2u * i1) + 1u] = s1 * onebyfftLen;
01137 
01138       /* (xa - xc) - (yb-yd) */
01139       r1 = r2 - t1;
01140 
01141       /* (xa - xc) + (yb-yd) */
01142       r2 = r2 + t1;
01143 
01144       /* (ya - yc) + (xb-xd) */
01145       s1 = s2 + t2;
01146 
01147       /* (ya - yc) - (xb-xd) */
01148       s2 = s2 - t2;
01149 
01150       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
01151       pSrc[2u * i2] = r1 * onebyfftLen;
01152 
01153       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
01154       pSrc[(2u * i2) + 1u] = s1 * onebyfftLen;
01155 
01156       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
01157       pSrc[2u * i3] = r2 * onebyfftLen;
01158 
01159       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
01160       pSrc[(2u * i3) + 1u] = s2 * onebyfftLen;
01161    }
01162 
01163 #endif /* #ifndef ARM_MATH_CM0_FAMILY_FAMILY */
01164 }
01165 
01166 /**    
01167 * @addtogroup ComplexFFT    
01168 * @{    
01169 */
01170 
01171 /**    
01172 * @details    
01173 * @brief Processing function for the floating-point Radix-4 CFFT/CIFFT.   
01174 * @deprecated Do not use this function.  It has been superceded by \ref arm_cfft_f32 and will be removed
01175 * in the future.
01176 * @param[in]      *S    points to an instance of the floating-point Radix-4 CFFT/CIFFT structure.   
01177 * @param[in, out] *pSrc points to the complex data buffer of size <code>2*fftLen</code>. Processing occurs in-place.   
01178 * @return none.   
01179 */
01180 
01181 void arm_cfft_radix4_f32(
01182 const arm_cfft_radix4_instance_f32 * S,
01183 float32_t * pSrc)
01184 {
01185 
01186    if(S->ifftFlag == 1u)
01187    {
01188       /*  Complex IFFT radix-4  */
01189       arm_radix4_butterfly_inverse_f32(pSrc, S->fftLen, S->pTwiddle,
01190       S->twidCoefModifier, S->onebyfftLen);
01191    }
01192    else
01193    {
01194       /*  Complex FFT radix-4  */
01195       arm_radix4_butterfly_f32(pSrc, S->fftLen, S->pTwiddle,
01196       S->twidCoefModifier);
01197    }
01198 
01199    if(S->bitReverseFlag == 1u)
01200    {
01201       /*  Bit Reversal */
01202       arm_bitreversal_f32(pSrc, S->fftLen, S->bitRevFactor, S->pBitRevTable);
01203    }
01204 
01205 }
01206 
01207 /**    
01208 * @} end of ComplexFFT group    
01209 */
01210