Cortex-R DSP Software Library: arm_cfft_radix4

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------      
00002 * Copyright (C) 2011 ARM Limited. All rights reserved. 
00003 *      
00004 * $Date:        15. December 2011   
00005 * $Revision:    V2.0.0  
00006 *      
00007 * Project:      Cortex-R DSP Library 
00008 * Title:        arm_cfft_radix4_q15.c      
00009 *      
00010 * Description:  This file has function definition of Radix-4 FFT & IFFT function and      
00011 *               In-place bit reversal using bit reversal table      
00012 *      
00013 * Target Processor:          Cortex-R4/R5
00014 *
00015 * Version 1.0.0 2011/03/08
00016 *     Alpha release.
00017 *
00018 * Version 1.0.1 2011/09/30
00019 *     Beta release.
00020 *
00021 * Version 2.0.0 2011/12/15
00022 *     Final release. 
00023 * 
00024 * -------------------------------------------------------------------- */     
00025      
00026 #include "arm_math.h"     
00027      
00055 void arm_cfft_radix4_q15(     
00056   const arm_cfft_radix4_instance_q15 * S,     
00057   q15_t * pSrc)     
00058 {     
00059   if(S->ifftFlag == 1u)     
00060   {     
00061     /*  Complex IFFT radix-4  */     
00062     arm_radix4_butterfly_inverse_q15(pSrc, S->fftLen, S->pTwiddle,     
00063                                      S->twidCoefModifier);     
00064   }     
00065   else     
00066   {     
00067     /*  Complex FFT radix-4  */     
00068     arm_radix4_butterfly_q15(pSrc, S->fftLen, S->pTwiddle,     
00069                              S->twidCoefModifier);     
00070   }     
00071      
00072   if(S->bitReverseFlag == 1u)     
00073   {     
00074     /*  Bit Reversal */     
00075     arm_bitreversal_q15(pSrc, S->fftLen, S->bitRevFactor, S->pBitRevTable);     
00076   }     
00077      
00078 }     
00079      
00084 /*      
00085 * Radix-4 FFT algorithm used is :      
00086 *      
00087 * Input real and imaginary data:      
00088 * x(n) = xa + j * ya      
00089 * x(n+N/4 ) = xb + j * yb      
00090 * x(n+N/2 ) = xc + j * yc      
00091 * x(n+3N 4) = xd + j * yd      
00092 *      
00093 *      
00094 * Output real and imaginary data:      
00095 * x(4r) = xa'+ j * ya'      
00096 * x(4r+1) = xb'+ j * yb'      
00097 * x(4r+2) = xc'+ j * yc'      
00098 * x(4r+3) = xd'+ j * yd'      
00099 *      
00100 *      
00101 * Twiddle factors for radix-4 FFT:      
00102 * Wn = co1 + j * (- si1)      
00103 * W2n = co2 + j * (- si2)      
00104 * W3n = co3 + j * (- si3)      
00105       
00106 * The real and imaginary output values for the radix-4 butterfly are      
00107 * xa' = xa + xb + xc + xd      
00108 * ya' = ya + yb + yc + yd      
00109 * xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1)      
00110 * yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1)      
00111 * xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2)      
00112 * yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2)      
00113 * xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3)      
00114 * yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3)      
00115 *      
00116 */     
00117      
00127 void arm_radix4_butterfly_q15(     
00128   q15_t * pSrc16,     
00129   uint32_t fftLen,     
00130   q15_t * pCoef16,     
00131   uint32_t twidCoefModifier)     
00132 {     
00133   q31_t R, S, T, U;     
00134   q31_t C1, C2, C3, out1, out2;     
00135   uint32_t n1, n2, ic, i0, i1, i2, i3, j, k;     
00136   q15_t in;  
00137      
00138   q15_t *ptr1;   
00139      
00140      
00141      
00142   q31_t xaya, xbyb, xcyc, xdyd;   
00143      
00144   /* Total process is divided into three stages */     
00145      
00146   /* process first stage, middle stages, & last stage */     
00147      
00148   /*  Initializations for the first stage */     
00149   n2 = fftLen;     
00150   n1 = n2;     
00151      
00152   /* n2 = fftLen/4 */     
00153   n2 >>= 2u;     
00154      
00155   /* Index for twiddle coefficient */     
00156   ic = 0u;     
00157      
00158   /* Index for input read and output write */     
00159   i0 = 0u;     
00160   j = n2;     
00161      
00162   /* Input is in 1.15(q15) format */     
00163      
00164   /*  start of first stage process */     
00165   do     
00166   {     
00167     /*  Butterfly implementation */     
00168      
00169     /*  index calculation for the input as, */     
00170     /*  pSrc16[i0 + 0], pSrc16[i0 + fftLen/4], pSrc16[i0 + fftLen/2], pSrc16[i0 + 3fftLen/4] */     
00171     i1 = i0 + n2;     
00172     i2 = i1 + n2;     
00173     i3 = i2 + n2;     
00174      
00175     /*  Reading i0, i0+fftLen/2 inputs */     
00176     /* Read ya (real), xa(imag) input */     
00177     T = _SIMD32_OFFSET(pSrc16 + (2u * i0));     
00178     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00179     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00180   
00181     /* Read yc (real), xc(imag) input */     
00182     S = _SIMD32_OFFSET(pSrc16 + (2u * i2));     
00183     in = ((int16_t) (S & 0xFFFF)) >> 2;     
00184     S = ((S >> 2) & 0xFFFF0000) | (in & 0xFFFF);  
00185          
00186     /* R = packed((ya + yc), (xa + xc) ) */     
00187     R = __QADD16(T, S);     
00188   
00189     /* S = packed((ya - yc), (xa - xc) ) */     
00190     S = __QSUB16(T, S);     
00191      
00192     /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00193     /* Read yb (real), xb(imag) input */     
00194     T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00195     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00196     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);    
00197        
00198     /* Read yd (real), xd(imag) input */     
00199     U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00200     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00201     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);    
00202        
00203     /* T = packed((yb + yd), (xb + xd) ) */     
00204     T = __QADD16(T, U);     
00205      
00206     /*  writing the butterfly processed i0 sample */     
00207     /* xa' = xa + xb + xc + xd */     
00208     /* ya' = ya + yb + yc + yd */     
00209     _SIMD32_OFFSET(pSrc16 + (2u * i0)) = __SHADD16(R, T);     
00210      
00211     /* R = packed((ya + yc) - (yb + yd), (xa + xc)- (xb + xd)) */     
00212     R = __QSUB16(R, T);     
00213      
00214     /* co2 & si2 are read from SIMD Coefficient pointer */     
00215     C2 = _SIMD32_OFFSET(pCoef16 + (4u * ic));     
00216      
00217 #ifndef ARM_MATH_BIG_ENDIAN   
00218    
00219     /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00220     out1 = __SMUAD(C2, R) >> 16u;     
00221     /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00222     out2 = __SMUSDX(C2, R);     
00223      
00224 #else   
00225    
00226     /* xc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00227     out1 = __SMUSDX(R, C2) >> 16u;   
00228     /* yc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */   
00229     out2 = __SMUAD(C2, R);   
00230    
00231 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00232    
00233     /*  Reading i0+fftLen/4 */     
00234     /* T = packed(yb, xb) */     
00235     T = _SIMD32_OFFSET(pSrc16 + (2u * i1));    
00236     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00237     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00238      
00239     /* writing the butterfly processed i0 + fftLen/4 sample */     
00240     /* writing output(xc', yc') in little endian format */     
00241     _SIMD32_OFFSET(pSrc16 + (2u * i1)) = (q31_t) ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00242      
00243     /*  Butterfly calculations */     
00244     /* U = packed(yd, xd) */     
00245     U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00246     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00247     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00248   
00249     /* T = packed(yb-yd, xb-xd) */     
00250     T = __QSUB16(T, U);     
00251      
00252 #ifndef ARM_MATH_BIG_ENDIAN   
00253    
00254     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00255     R = __QASX(S, T);     
00256     /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */     
00257     S = __QSAX(S, T);     
00258      
00259 #else   
00260    
00261     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00262     R = __QSAX(S, T);   
00263     /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00264     S = __QASX(S, T);   
00265    
00266 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00267    
00268     /* co1 & si1 are read from SIMD Coefficient pointer */     
00269     C1 = _SIMD32_OFFSET(pCoef16 + (2u * ic));     
00270     /*  Butterfly process for the i0+fftLen/2 sample */   
00271    
00272 #ifndef ARM_MATH_BIG_ENDIAN   
00273    
00274     /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00275     out1 = __SMUAD(C1, S) >> 16u;     
00276     /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00277     out2 = __SMUSDX(C1, S);     
00278    
00279 #else   
00280    
00281     /* xb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */   
00282     out1 = __SMUSDX(S, C1) >> 16u;   
00283     /* yb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */   
00284     out2 = __SMUAD(C1, S);   
00285    
00286 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00287    
00288     /* writing output(xb', yb') in little endian format */     
00289     _SIMD32_OFFSET(pSrc16 + (2u * i2)) = ((out2) & 0xFFFF0000) | ((out1) & 0x0000FFFF);     
00290      
00291      
00292     /* co3 & si3 are read from SIMD Coefficient pointer */     
00293     C3 = _SIMD32_OFFSET(pCoef16 + (6u * ic));     
00294     /*  Butterfly process for the i0+3fftLen/4 sample */     
00295    
00296 #ifndef ARM_MATH_BIG_ENDIAN   
00297    
00298     /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00299     out1 = __SMUAD(C3, R) >> 16u;     
00300     /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00301     out2 = __SMUSDX(C3, R);     
00302    
00303 #else   
00304    
00305     /* xd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */   
00306     out1 = __SMUSDX(R, C3) >> 16u;   
00307     /* yd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */   
00308     out2 = __SMUAD(C3, R);   
00309    
00310 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00311    
00312     /* writing output(xd', yd') in little endian format */     
00313     _SIMD32_OFFSET(pSrc16 + (2u * i3)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00314      
00315     /*  Twiddle coefficients index modifier */     
00316     ic = ic + twidCoefModifier;     
00317      
00318     /*  Updating input index */     
00319     i0 = i0 + 1u;     
00320   
00321   } while(--j);     
00322   /* data is in 4.11(q11) format */     
00323      
00324   /* end of first stage process */     
00325      
00326      
00327   /* start of middle stage process */     
00328      
00329   /*  Twiddle coefficients index modifier */     
00330   twidCoefModifier <<= 2u;     
00331      
00332   /*  Calculation of Middle stage */     
00333   for (k = fftLen / 4u; k > 4u; k >>= 2u)     
00334   {     
00335     /*  Initializations for the middle stage */     
00336     n1 = n2;     
00337     n2 >>= 2u;     
00338     ic = 0u;     
00339      
00340     for (j = 0u; j <= (n2 - 1u); j++)     
00341     {     
00342       /*  index calculation for the coefficients */     
00343       C1 = _SIMD32_OFFSET(pCoef16 + (2u * ic));     
00344       C2 = _SIMD32_OFFSET(pCoef16 + (4u * ic));     
00345       C3 = _SIMD32_OFFSET(pCoef16 + (6u * ic));     
00346      
00347       /*  Twiddle coefficients index modifier */     
00348       ic = ic + twidCoefModifier;     
00349      
00350       /*  Butterfly implementation */     
00351       for (i0 = j; i0 < fftLen; i0 += n1)     
00352       {     
00353         /*  index calculation for the input as, */     
00354         /*  pSrc16[i0 + 0], pSrc16[i0 + fftLen/4], pSrc16[i0 + fftLen/2], pSrc16[i0 + 3fftLen/4] */     
00355         i1 = i0 + n2;     
00356         i2 = i1 + n2;     
00357         i3 = i2 + n2;     
00358      
00359         /*  Reading i0, i0+fftLen/2 inputs */     
00360         /* Read ya (real), xa(imag) input */     
00361         T = _SIMD32_OFFSET(pSrc16 + (2u * i0));     
00362      
00363         /* Read yc (real), xc(imag) input */     
00364         S = _SIMD32_OFFSET(pSrc16 + (2u * i2));     
00365      
00366         /* R = packed( (ya + yc), (xa + xc)) */     
00367         R = __QADD16(T, S);     
00368      
00369         /* S = packed((ya - yc), (xa - xc)) */     
00370         S = __QSUB16(T, S);     
00371      
00372         /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00373         /* Read yb (real), xb(imag) input */     
00374         T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00375      
00376         /* Read yd (real), xd(imag) input */     
00377         U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00378      
00379         /* T = packed( (yb + yd), (xb + xd)) */     
00380         T = __QADD16(T, U);     
00381      
00382         /*  writing the butterfly processed i0 sample */     
00383      
00384         /* xa' = xa + xb + xc + xd */     
00385         /* ya' = ya + yb + yc + yd */     
00386         out1 = __SHADD16(R, T);     
00387         in = ((int16_t) (out1 & 0xFFFF)) >> 1;     
00388         out1 = ((out1 >> 1) & 0xFFFF0000) | (in & 0xFFFF);     
00389         _SIMD32_OFFSET(pSrc16 + (2u * i0)) = out1;     
00390      
00391         /* R = packed( (ya + yc) - (yb + yd), (xa + xc) - (xb + xd)) */     
00392         R = __SHSUB16(R, T);     
00393      
00394 #ifndef ARM_MATH_BIG_ENDIAN   
00395    
00396         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */     
00397         out1 = __SMUAD(C2, R) >> 16u;     
00398      
00399         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00400         out2 = __SMUSDX(C2, R);     
00401      
00402 #else   
00403    
00404         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00405         out1 = __SMUSDX(R, C2) >> 16u;   
00406    
00407         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */   
00408         out2 = __SMUAD(C2, R);   
00409    
00410 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00411    
00412         /*  Reading i0+3fftLen/4 */     
00413         /* Read yb (real), xb(imag) input */     
00414         T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00415      
00416         /*  writing the butterfly processed i0 + fftLen/4 sample */     
00417         /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00418         /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00419         _SIMD32_OFFSET(pSrc16 + (2u * i1)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00420      
00421         /*  Butterfly calculations */     
00422      
00423         /* Read yd (real), xd(imag) input */     
00424         U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00425      
00426         /* T = packed(yb-yd, xb-xd) */     
00427         T = __QSUB16(T, U);     
00428      
00429 #ifndef ARM_MATH_BIG_ENDIAN   
00430    
00431         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00432         R = __SHASX(S, T);     
00433      
00434         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */     
00435         S = __SHSAX(S, T);     
00436      
00437      
00438         /*  Butterfly process for the i0+fftLen/2 sample */     
00439         out1 = __SMUAD(C1, S) >> 16u;     
00440         out2 = __SMUSDX(C1, S);     
00441      
00442 #else   
00443    
00444         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00445         R = __SHSAX(S, T);   
00446    
00447         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00448         S = __SHASX(S, T);   
00449    
00450    
00451         /*  Butterfly process for the i0+fftLen/2 sample */   
00452         out1 = __SMUSDX(S, C1) >> 16u;   
00453         out2 = __SMUAD(C1, S);   
00454    
00455 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00456    
00457         /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00458         /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00459         _SIMD32_OFFSET(pSrc16 + (2u * i2)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00460      
00461         /*  Butterfly process for the i0+3fftLen/4 sample */     
00462    
00463 #ifndef ARM_MATH_BIG_ENDIAN   
00464    
00465         out1 = __SMUAD(C3, R) >> 16u;     
00466         out2 = __SMUSDX(C3, R);     
00467    
00468 #else   
00469    
00470         out1 = __SMUSDX(R, C3) >> 16u;   
00471         out2 = __SMUAD(C3, R);   
00472    
00473 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00474    
00475         /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00476         /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00477         _SIMD32_OFFSET(pSrc16 + (2u * i3)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00478       }     
00479     }     
00480     /*  Twiddle coefficients index modifier */     
00481     twidCoefModifier <<= 2u;     
00482   }     
00483   /* end of middle stage process */     
00484      
00485      
00486   /* data is in 10.6(q6) format for the 1024 point */     
00487   /* data is in 8.8(q8) format for the 256 point */     
00488   /* data is in 6.10(q10) format for the 64 point */     
00489   /* data is in 4.12(q12) format for the 16 point */     
00490      
00491   /*  Initializations for the last stage */     
00492     j = fftLen >> 2;   
00493            
00494     ptr1 = &pSrc16[0];   
00495    
00496     /* start of last stage process */   
00497    
00498     /*  Butterfly implementation */   
00499     do   
00500     {   
00501         /* Read xa (real), ya(imag) input */   
00502         xaya = *__SIMD32(ptr1)++;    
00503    
00504         /* Read xb (real), yb(imag) input */   
00505         xbyb = *__SIMD32(ptr1)++;    
00506            
00507         /* Read xc (real), yc(imag) input */   
00508         xcyc = *__SIMD32(ptr1)++;      
00509    
00510         /* Read xd (real), yd(imag) input */   
00511         xdyd = *__SIMD32(ptr1)++;   
00512    
00513         /* R = packed((ya + yc), (xa + xc)) */     
00514         R = __QADD16(xaya, xcyc);    
00515    
00516         /* T = packed((yb + yd), (xb + xd)) */     
00517         T = __QADD16(xbyb, xdyd);   
00518    
00519         /* pointer updation for writing */   
00520         ptr1 = ptr1 - 8u;   
00521    
00522            
00523         /* xa' = xa + xb + xc + xd */     
00524         /* ya' = ya + yb + yc + yd */     
00525         *__SIMD32(ptr1)++ = __SHADD16(R, T);   
00526    
00527         /* T = packed((yb + yd), (xb + xd)) */     
00528         T = __QADD16(xbyb, xdyd);   
00529    
00530         /* xc' = (xa-xb+xc-xd) */     
00531         /* yc' = (ya-yb+yc-yd) */     
00532         *__SIMD32(ptr1)++ = __SHSUB16(R, T);   
00533    
00534         /* S = packed((ya - yc), (xa - xc)) */     
00535         S = __QSUB16(xaya, xcyc);     
00536    
00537         /* Read yd (real), xd(imag) input */     
00538         /* T = packed( (yb - yd), (xb - xd))  */     
00539         U = __QSUB16(xbyb, xdyd);     
00540    
00541 #ifndef ARM_MATH_BIG_ENDIAN   
00542            
00543         /* xb' = (xa+yb-xc-yd) */     
00544         /* yb' = (ya-xb-yc+xd) */     
00545         *__SIMD32(ptr1)++ = __SHSAX(S, U);     
00546    
00547            
00548         /* xd' = (xa-yb-xc+yd) */     
00549         /* yd' = (ya+xb-yc-xd) */     
00550         *__SIMD32(ptr1)++ = __SHASX(S, U);        
00551            
00552 #else   
00553    
00554         /* xb' = (xa+yb-xc-yd) */     
00555         /* yb' = (ya-xb-yc+xd) */     
00556         *__SIMD32(ptr1)++ = __SHASX(S, U);     
00557    
00558            
00559         /* xd' = (xa-yb-xc+yd) */     
00560         /* yd' = (ya+xb-yc-xd) */     
00561         *__SIMD32(ptr1)++ = __SHSAX(S, U);     
00562    
00563    
00564 #endif                   
00565    
00566     }while(--j);     
00567      
00568    
00569     
00570      
00571   /* end of last stage process */     
00572      
00573   /* output is in 11.5(q5) format for the 1024 point */     
00574   /* output is in 9.7(q7) format for the 256 point   */     
00575   /* output is in 7.9(q9) format for the 64 point  */     
00576   /* output is in 5.11(q11) format for the 16 point  */     
00577      
00578 }     
00579      
00580      
00590 /*      
00591 * Radix-4 IFFT algorithm used is :      
00592 *      
00593 * CIFFT uses same twiddle coefficients as CFFT function      
00594 *  x[k] = x[n] + (j)k * x[n + fftLen/4] + (-1)k * x[n+fftLen/2] + (-j)k * x[n+3*fftLen/4]      
00595 *      
00596 *      
00597 * IFFT is implemented with following changes in equations from FFT      
00598 *      
00599 * Input real and imaginary data:      
00600 * x(n) = xa + j * ya      
00601 * x(n+N/4 ) = xb + j * yb      
00602 * x(n+N/2 ) = xc + j * yc      
00603 * x(n+3N 4) = xd + j * yd      
00604 *      
00605 *      
00606 * Output real and imaginary data:      
00607 * x(4r) = xa'+ j * ya'      
00608 * x(4r+1) = xb'+ j * yb'      
00609 * x(4r+2) = xc'+ j * yc'      
00610 * x(4r+3) = xd'+ j * yd'      
00611 *      
00612 *      
00613 * Twiddle factors for radix-4 IFFT:      
00614 * Wn = co1 + j * (si1)      
00615 * W2n = co2 + j * (si2)      
00616 * W3n = co3 + j * (si3)      
00617       
00618 * The real and imaginary output values for the radix-4 butterfly are      
00619 * xa' = xa + xb + xc + xd      
00620 * ya' = ya + yb + yc + yd      
00621 * xb' = (xa-yb-xc+yd)* co1 - (ya+xb-yc-xd)* (si1)      
00622 * yb' = (ya+xb-yc-xd)* co1 + (xa-yb-xc+yd)* (si1)      
00623 * xc' = (xa-xb+xc-xd)* co2 - (ya-yb+yc-yd)* (si2)      
00624 * yc' = (ya-yb+yc-yd)* co2 + (xa-xb+xc-xd)* (si2)      
00625 * xd' = (xa+yb-xc-yd)* co3 - (ya-xb-yc+xd)* (si3)      
00626 * yd' = (ya-xb-yc+xd)* co3 + (xa+yb-xc-yd)* (si3)      
00627 *      
00628 */     
00629      
00630 void arm_radix4_butterfly_inverse_q15(     
00631   q15_t * pSrc16,     
00632   uint32_t fftLen,     
00633   q15_t * pCoef16,     
00634   uint32_t twidCoefModifier)     
00635 {     
00636   q31_t R, S, T, U;     
00637   q31_t C1, C2, C3, out1, out2;     
00638   uint32_t n1, n2, ic, i0, i1, i2, i3, j, k;     
00639   q15_t in;  
00640      
00641   q15_t *ptr1;   
00642      
00643      
00644      
00645   q31_t xaya, xbyb, xcyc, xdyd;   
00646      
00647   /* Total process is divided into three stages */     
00648      
00649   /* process first stage, middle stages, & last stage */     
00650      
00651   /*  Initializations for the first stage */     
00652   n2 = fftLen;     
00653   n1 = n2;     
00654      
00655   /* n2 = fftLen/4 */     
00656   n2 >>= 2u;     
00657      
00658   /* Index for twiddle coefficient */     
00659   ic = 0u;     
00660      
00661   /* Index for input read and output write */     
00662   i0 = 0u;     
00663   j = n2;     
00664      
00665   /* Input is in 1.15(q15) format */     
00666      
00667   /*  start of first stage process */     
00668   do     
00669   {     
00670     /*  Butterfly implementation */     
00671      
00672     /*  index calculation for the input as, */     
00673     /*  pSrc16[i0 + 0], pSrc16[i0 + fftLen/4], pSrc16[i0 + fftLen/2], pSrc16[i0 + 3fftLen/4] */     
00674     i1 = i0 + n2;     
00675     i2 = i1 + n2;     
00676     i3 = i2 + n2;     
00677      
00678     /*  Reading i0, i0+fftLen/2 inputs */     
00679     /* Read ya (real), xa(imag) input */     
00680     T = _SIMD32_OFFSET(pSrc16 + (2u * i0));     
00681     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00682     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00683   
00684     /* Read yc (real), xc(imag) input */     
00685     S = _SIMD32_OFFSET(pSrc16 + (2u * i2));     
00686     in = ((int16_t) (S & 0xFFFF)) >> 2;     
00687     S = ((S >> 2) & 0xFFFF0000) | (in & 0xFFFF);  
00688          
00689     /* R = packed((ya + yc), (xa + xc) ) */     
00690     R = __QADD16(T, S);     
00691   
00692     /* S = packed((ya - yc), (xa - xc) ) */     
00693     S = __QSUB16(T, S);     
00694      
00695     /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00696     /* Read yb (real), xb(imag) input */     
00697     T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00698     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00699     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);    
00700        
00701     /* Read yd (real), xd(imag) input */     
00702     U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00703     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00704     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);    
00705        
00706     /* T = packed((yb + yd), (xb + xd) ) */     
00707     T = __QADD16(T, U);     
00708      
00709     /*  writing the butterfly processed i0 sample */     
00710     /* xa' = xa + xb + xc + xd */     
00711     /* ya' = ya + yb + yc + yd */     
00712     _SIMD32_OFFSET(pSrc16 + (2u * i0)) = __SHADD16(R, T);     
00713      
00714     /* R = packed((ya + yc) - (yb + yd), (xa + xc)- (xb + xd)) */     
00715     R = __QSUB16(R, T);     
00716      
00717     /* co2 & si2 are read from SIMD Coefficient pointer */     
00718     C2 = _SIMD32_OFFSET(pCoef16 + (4u * ic));     
00719      
00720 #ifndef ARM_MATH_BIG_ENDIAN   
00721    
00722     /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00723     out1 = __SMUSD(C2, R) >> 16u;     
00724     /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00725     out2 = __SMUADX(C2, R);     
00726      
00727 #else   
00728    
00729     /* xc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00730     out1 = __SMUADX(C2, R) >> 16u;   
00731     /* yc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */   
00732     out2 = __SMUSD(-C2, R);   
00733    
00734 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00735    
00736     /*  Reading i0+fftLen/4 */     
00737     /* T = packed(yb, xb) */     
00738     T = _SIMD32_OFFSET(pSrc16 + (2u * i1));    
00739     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00740     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00741      
00742     /* writing the butterfly processed i0 + fftLen/4 sample */     
00743     /* writing output(xc', yc') in little endian format */     
00744     _SIMD32_OFFSET(pSrc16 + (2u * i1)) = (q31_t) ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00745      
00746     /*  Butterfly calculations */     
00747     /* U = packed(yd, xd) */     
00748     U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00749     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00750     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00751   
00752     /* T = packed(yb-yd, xb-xd) */     
00753     T = __QSUB16(T, U);     
00754      
00755 #ifndef ARM_MATH_BIG_ENDIAN   
00756    
00757     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00758     R = __QSAX(S, T);     
00759     /* S = packed((ya-yc) + (xb- xd),  (xa-xc) - (yb-yd)) */     
00760     S = __QASX(S, T);     
00761      
00762 #else   
00763    
00764     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00765     R = __QASX(S, T);   
00766     /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00767     S = __QSAX(S, T);   
00768    
00769 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00770    
00771     /* co1 & si1 are read from SIMD Coefficient pointer */     
00772     C1 = _SIMD32_OFFSET(pCoef16 + (2u * ic));     
00773     /*  Butterfly process for the i0+fftLen/2 sample */   
00774    
00775 #ifndef ARM_MATH_BIG_ENDIAN   
00776    
00777     /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00778     out1 = __SMUSD(C1, S) >> 16u;     
00779     /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00780     out2 = __SMUADX(C1, S);     
00781    
00782 #else   
00783    
00784     /* xb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */   
00785     out1 = __SMUADX(C1, S) >> 16u;   
00786     /* yb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */   
00787     out2 = __SMUSD(-C1, S);   
00788    
00789 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00790    
00791     /* writing output(xb', yb') in little endian format */     
00792     _SIMD32_OFFSET(pSrc16 + (2u * i2)) = ((out2) & 0xFFFF0000) | ((out1) & 0x0000FFFF);     
00793      
00794      
00795     /* co3 & si3 are read from SIMD Coefficient pointer */     
00796     C3 = _SIMD32_OFFSET(pCoef16 + (6u * ic));     
00797     /*  Butterfly process for the i0+3fftLen/4 sample */     
00798    
00799 #ifndef ARM_MATH_BIG_ENDIAN   
00800    
00801     /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00802     out1 = __SMUSD(C3, R) >> 16u;     
00803     /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00804     out2 = __SMUADX(C3, R);     
00805    
00806 #else   
00807    
00808     /* xd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */   
00809     out1 = __SMUADX(C3, R) >> 16u;   
00810     /* yd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */   
00811     out2 = __SMUSD(-C3, R);   
00812    
00813 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00814    
00815     /* writing output(xd', yd') in little endian format */     
00816     _SIMD32_OFFSET(pSrc16 + (2u * i3)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00817      
00818     /*  Twiddle coefficients index modifier */     
00819     ic = ic + twidCoefModifier;     
00820      
00821     /*  Updating input index */     
00822     i0 = i0 + 1u;     
00823   
00824   } while(--j);     
00825   /* data is in 4.11(q11) format */     
00826      
00827   /* end of first stage process */     
00828      
00829      
00830   /* start of middle stage process */     
00831      
00832   /*  Twiddle coefficients index modifier */     
00833   twidCoefModifier <<= 2u;     
00834      
00835   /*  Calculation of Middle stage */     
00836   for (k = fftLen / 4u; k > 4u; k >>= 2u)     
00837   {     
00838     /*  Initializations for the middle stage */     
00839     n1 = n2;     
00840     n2 >>= 2u;     
00841     ic = 0u;     
00842      
00843     for (j = 0u; j <= (n2 - 1u); j++)     
00844     {     
00845       /*  index calculation for the coefficients */     
00846       C1 = _SIMD32_OFFSET(pCoef16 + (2u * ic));     
00847       C2 = _SIMD32_OFFSET(pCoef16 + (4u * ic));     
00848       C3 = _SIMD32_OFFSET(pCoef16 + (6u * ic));     
00849      
00850       /*  Twiddle coefficients index modifier */     
00851       ic = ic + twidCoefModifier;     
00852      
00853       /*  Butterfly implementation */     
00854       for (i0 = j; i0 < fftLen; i0 += n1)     
00855       {     
00856         /*  index calculation for the input as, */     
00857         /*  pSrc16[i0 + 0], pSrc16[i0 + fftLen/4], pSrc16[i0 + fftLen/2], pSrc16[i0 + 3fftLen/4] */     
00858         i1 = i0 + n2;     
00859         i2 = i1 + n2;     
00860         i3 = i2 + n2;     
00861      
00862         /*  Reading i0, i0+fftLen/2 inputs */     
00863         /* Read ya (real), xa(imag) input */     
00864         T = _SIMD32_OFFSET(pSrc16 + (2u * i0));     
00865      
00866         /* Read yc (real), xc(imag) input */     
00867         S = _SIMD32_OFFSET(pSrc16 + (2u * i2));     
00868      
00869         /* R = packed( (ya + yc), (xa + xc)) */     
00870         R = __QADD16(T, S);     
00871      
00872         /* S = packed((ya - yc), (xa - xc)) */     
00873         S = __QSUB16(T, S);     
00874      
00875         /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00876         /* Read yb (real), xb(imag) input */     
00877         T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00878      
00879         /* Read yd (real), xd(imag) input */     
00880         U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00881      
00882         /* T = packed( (yb + yd), (xb + xd)) */     
00883         T = __QADD16(T, U);     
00884      
00885         /*  writing the butterfly processed i0 sample */     
00886      
00887         /* xa' = xa + xb + xc + xd */     
00888         /* ya' = ya + yb + yc + yd */     
00889         out1 = __SHADD16(R, T);     
00890         in = ((int16_t) (out1 & 0xFFFF)) >> 1;     
00891         out1 = ((out1 >> 1) & 0xFFFF0000) | (in & 0xFFFF);     
00892         _SIMD32_OFFSET(pSrc16 + (2u * i0)) = out1;     
00893      
00894         /* R = packed( (ya + yc) - (yb + yd), (xa + xc) - (xb + xd)) */     
00895         R = __SHSUB16(R, T);     
00896      
00897 #ifndef ARM_MATH_BIG_ENDIAN   
00898    
00899         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */     
00900         out1 = __SMUSD(C2, R) >> 16u;     
00901      
00902         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00903         out2 = __SMUADX(C2, R);     
00904      
00905 #else   
00906    
00907         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00908         out1 = __SMUADX(R, C2) >> 16u;   
00909    
00910         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */   
00911         out2 = __SMUSD(-C2, R);   
00912    
00913 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00914    
00915         /*  Reading i0+3fftLen/4 */     
00916         /* Read yb (real), xb(imag) input */     
00917         T = _SIMD32_OFFSET(pSrc16 + (2u * i1));     
00918      
00919         /*  writing the butterfly processed i0 + fftLen/4 sample */     
00920         /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00921         /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00922         _SIMD32_OFFSET(pSrc16 + (2u * i1)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00923      
00924         /*  Butterfly calculations */     
00925      
00926         /* Read yd (real), xd(imag) input */     
00927         U = _SIMD32_OFFSET(pSrc16 + (2u * i3));     
00928      
00929         /* T = packed(yb-yd, xb-xd) */     
00930         T = __QSUB16(T, U);     
00931      
00932 #ifndef ARM_MATH_BIG_ENDIAN   
00933    
00934         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00935         R = __SHSAX(S, T);     
00936      
00937         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */     
00938         S = __SHASX(S, T);     
00939      
00940      
00941         /*  Butterfly process for the i0+fftLen/2 sample */     
00942         out1 = __SMUSD(C1, S) >> 16u;     
00943         out2 = __SMUADX(C1, S);   
00944      
00945 #else   
00946    
00947         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00948         R = __SHASX(S, T);   
00949    
00950         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00951         S = __SHSAX(S, T);   
00952    
00953    
00954         /*  Butterfly process for the i0+fftLen/2 sample */   
00955         out1 = __SMUADX(S, C1) >> 16u;   
00956         out2 = __SMUSD(-C1, S);   
00957    
00958 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00959    
00960         /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00961         /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00962         _SIMD32_OFFSET(pSrc16 + (2u * i2)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00963      
00964         /*  Butterfly process for the i0+3fftLen/4 sample */     
00965    
00966 #ifndef ARM_MATH_BIG_ENDIAN   
00967    
00968         out1 = __SMUSD(C3, R) >> 16u;     
00969         out2 = __SMUADX(C3, R);     
00970    
00971 #else   
00972    
00973         out1 = __SMUADX(C3, R) >> 16u;   
00974         out2 = __SMUSD(-C3, R);   
00975    
00976 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00977    
00978         /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00979         /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00980         _SIMD32_OFFSET(pSrc16 + (2u * i3)) = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00981       }     
00982     }     
00983     /*  Twiddle coefficients index modifier */     
00984     twidCoefModifier <<= 2u;     
00985   }     
00986   /* end of middle stage process */     
00987      
00988                                   /* data is in 10.6(q6) format for the 1024 point */     
00989   /* data is in 8.8(q8) format for the 256 point */     
00990   /* data is in 6.10(q10) format for the 64 point */     
00991   /* data is in 4.12(q12) format for the 16 point */     
00992      
00993   /*  Initializations for the last stage */     
00994     j = fftLen >> 2;   
00995            
00996     ptr1 = &pSrc16[0];   
00997    
00998     /* start of last stage process */   
00999    
01000     /*  Butterfly implementation */   
01001     do   
01002     {   
01003         /* Read xa (real), ya(imag) input */   
01004         xaya = *__SIMD32(ptr1)++;    
01005    
01006         /* Read xb (real), yb(imag) input */   
01007         xbyb = *__SIMD32(ptr1)++;    
01008            
01009         /* Read xc (real), yc(imag) input */   
01010         xcyc = *__SIMD32(ptr1)++;      
01011    
01012         /* Read xd (real), yd(imag) input */   
01013         xdyd = *__SIMD32(ptr1)++;   
01014    
01015         /* R = packed((ya + yc), (xa + xc)) */     
01016         R = __QADD16(xaya, xcyc);    
01017    
01018         /* T = packed((yb + yd), (xb + xd)) */     
01019         T = __QADD16(xbyb, xdyd);   
01020    
01021         /* pointer updation for writing */   
01022         ptr1 = ptr1 - 8u;   
01023    
01024            
01025         /* xa' = xa + xb + xc + xd */     
01026         /* ya' = ya + yb + yc + yd */     
01027         *__SIMD32(ptr1)++ = __SHADD16(R, T);   
01028    
01029         /* T = packed((yb + yd), (xb + xd)) */     
01030         T = __QADD16(xbyb, xdyd);   
01031    
01032         /* xc' = (xa-xb+xc-xd) */     
01033         /* yc' = (ya-yb+yc-yd) */     
01034         *__SIMD32(ptr1)++ = __SHSUB16(R, T);   
01035    
01036         /* S = packed((ya - yc), (xa - xc)) */     
01037         S = __QSUB16(xaya, xcyc);     
01038    
01039         /* Read yd (real), xd(imag) input */     
01040         /* T = packed( (yb - yd), (xb - xd))  */     
01041         U = __QSUB16(xbyb, xdyd);     
01042    
01043 #ifndef ARM_MATH_BIG_ENDIAN   
01044            
01045         /* xb' = (xa+yb-xc-yd) */     
01046         /* yb' = (ya-xb-yc+xd) */     
01047         *__SIMD32(ptr1)++ = __SHASX(S, U);     
01048    
01049            
01050         /* xd' = (xa-yb-xc+yd) */     
01051         /* yd' = (ya+xb-yc-xd) */     
01052         *__SIMD32(ptr1)++ = __SHSAX(S, U);    
01053            
01054 #else   
01055    
01056         /* xb' = (xa+yb-xc-yd) */     
01057         /* yb' = (ya-xb-yc+xd) */     
01058         *__SIMD32(ptr1)++ = __SHSAX(S, U);     
01059    
01060            
01061         /* xd' = (xa-yb-xc+yd) */     
01062         /* yd' = (ya+xb-yc-xd) */     
01063         *__SIMD32(ptr1)++ = __SHASX(S, U);    
01064    
01065    
01066 #endif                   
01067    
01068    
01069     }while(--j);       
01070      
01071   /* end of last stage  process */     
01072      
01073   /* output is in 11.5(q5) format for the 1024 point */     
01074   /* output is in 9.7(q7) format for the 256 point   */     
01075   /* output is in 7.9(q9) format for the 64 point  */     
01076   /* output is in 5.11(q11) format for the 16 point  */     
01077 }     
01078      
01079      
01080 /*      
01081    * @brief  In-place bit reversal function.     
01082    * @param[in, out] *pSrc        points to the in-place buffer of Q15 data type.     
01083    * @param[in]      fftLen       length of the FFT.     
01084    * @param[in]      bitRevFactor bit reversal modifier that supports different size FFTs with the same bit reversal table     
01085    * @param[in]      *pBitRevTab  points to bit reversal table.     
01086    * @return none.     
01087  */     
01088      
01089 void arm_bitreversal_q15(     
01090   q15_t * pSrc16,     
01091   uint32_t fftLen,     
01092   uint16_t bitRevFactor,     
01093   uint16_t * pBitRevTab)     
01094 {     
01095   q31_t in;     
01096   uint32_t fftLenBy2, fftLenBy2p1;     
01097   uint32_t i, j;     
01098      
01099   /*  Initializations */     
01100   j = 0u;     
01101   fftLenBy2 = fftLen / 2u;     
01102   fftLenBy2p1 = (fftLen / 2u) + 1u;     
01103      
01104   /* Bit Reversal Implementation */     
01105   for (i = 0u; i <= (fftLenBy2 - 2u); i += 2u)     
01106   {     
01107     if(i < j)     
01108     {     
01109       /*  pSrc[i] <-> pSrc[j]; */     
01110       /*  pSrc[i+1u] <-> pSrc[j+1u] */     
01111       in = _SIMD32_OFFSET(pSrc16 +i * 2u);     
01112       _SIMD32_OFFSET(pSrc16 + i * 2u) = _SIMD32_OFFSET(pSrc16 + j * 2u);     
01113       _SIMD32_OFFSET(pSrc16 + j * 2u) = in;     
01114      
01115       /*  pSrc[i + fftLenBy2p1] <-> pSrc[j + fftLenBy2p1];  */     
01116       /*  pSrc[i + fftLenBy2p1+1u] <-> pSrc[j + fftLenBy2p1+1u] */     
01117       in = _SIMD32_OFFSET(pSrc16 + (i + fftLenBy2p1) * 2u);     
01118       _SIMD32_OFFSET(pSrc16 + (i + fftLenBy2p1) * 2u) = _SIMD32_OFFSET(pSrc16  + (j + fftLenBy2p1) * 2u);     
01119       _SIMD32_OFFSET(pSrc16 + (j + fftLenBy2p1) * 2u) = in;     
01120     }     
01121      
01122     /*  pSrc[i+1u] <-> pSrc[j+fftLenBy2];         */     
01123     /*  pSrc[i+2] <-> pSrc[j+fftLenBy2+1u]  */     
01124     in = _SIMD32_OFFSET(pSrc16 + (i + 1u) * 2u);     
01125     _SIMD32_OFFSET(pSrc16 + (i + 1u) * 2u) = _SIMD32_OFFSET(pSrc16 + (j + fftLenBy2) * 2u);     
01126     _SIMD32_OFFSET(pSrc16 + (j + fftLenBy2) * 2u) = in;     
01127      
01128     /*  Reading the index for the bit reversal */     
01129     j = *pBitRevTab;     
01130      
01131     /*  Updating the bit reversal index depending on the fft length  */     
01132     pBitRevTab += bitRevFactor;     
01133   }     
01134 }