Cortex-R DSP Software Library: arm_cfft_mag

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_mag_q15.c      
00009 *      
00010 * Description:  This file has function definition of Radix-4 FFT with magnitude 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      
00058 void arm_cfft_mag_q15(     
00059   const arm_cfft_radix4_instance_q15 * S,     
00060   q15_t * pSrc)     
00061 {     
00062   /*  Complex FFT Magnitude  */     
00063   arm_cfft_mag_butterfly_q15(pSrc, S->fftLen, S->pTwiddle,     
00064                              S->twidCoefModifier);     
00065      
00066   if(S->bitReverseFlag == 1u)     
00067   {     
00068     /*  Bit Reversal */     
00069     arm_cfft_mag_bitreversal_q15(pSrc, S->fftLen, S->bitRevFactor, S->pBitRevTable);     
00070   }     
00071      
00072 }     
00073      
00078 /*      
00079 * Radix-4 FFT algorithm used is :      
00080 *      
00081 * Input real and imaginary data:      
00082 * x(n) = xa + j * ya      
00083 * x(n+N/4 ) = xb + j * yb      
00084 * x(n+N/2 ) = xc + j * yc      
00085 * x(n+3N 4) = xd + j * yd      
00086 *      
00087 *      
00088 * Output real and imaginary data:      
00089 * x(4r) = xa'+ j * ya'      
00090 * x(4r+1) = xb'+ j * yb'      
00091 * x(4r+2) = xc'+ j * yc'      
00092 * x(4r+3) = xd'+ j * yd'      
00093 *      
00094 *      
00095 * Twiddle factors for radix-4 FFT:      
00096 * Wn = co1 + j * (- si1)      
00097 * W2n = co2 + j * (- si2)      
00098 * W3n = co3 + j * (- si3)      
00099       
00100 * The real and imaginary output values for the radix-4 butterfly are      
00101 * xa' = xa + xb + xc + xd      
00102 * ya' = ya + yb + yc + yd      
00103 * xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1)      
00104 * yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1)      
00105 * xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2)      
00106 * yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2)      
00107 * xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3)      
00108 * yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3)      
00109 *      
00110 */     
00111      
00121 void arm_cfft_mag_butterfly_q15(     
00122   q15_t * pSrc16,     
00123   uint32_t fftLen,     
00124   q15_t * pCoef16,     
00125   uint32_t twidCoefModifier)     
00126 {     
00127   q31_t R, S, T, U;     
00128   q31_t C1, C2, C3, out1, out2;     
00129   q31_t *pSrc, *pCoeff;     
00130   uint32_t n1, n2, ic, i0, i1, i2, i3, j, k;     
00131   q31_t in;  
00132   q31_t cmplxm1, cmplxm2;     
00133      
00134   q15_t *ptr1, *pDst = &pSrc16[0];   
00135      
00136      
00137      
00138   q31_t xaya, xbyb, xcyc, xdyd;   
00139      
00140   /* Total process is divided into three stages */     
00141      
00142   /* process first stage, middle stages, & last stage */     
00143      
00144   /*  pointer initializations for SIMD calculations */     
00145   pSrc = (q31_t *) pSrc16;     
00146   pCoeff = (q31_t *) pCoef16;     
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     /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[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 = pSrc[i0];     
00178     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00179     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00180     /* Read yc (real), xc(imag) input */     
00181     S = pSrc[i2];     
00182     in = ((int16_t) (S & 0xFFFF)) >> 2;     
00183     S = ((S >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00184     /* R = packed((ya + yc), (xa + xc) ) */     
00185     R = __QADD16(T, S);     
00186     /* S = packed((ya - yc), (xa - xc) ) */     
00187     S = __QSUB16(T, S);     
00188      
00189     /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00190     /* Read yb (real), xb(imag) input */     
00191     T = pSrc[i1];     
00192     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00193     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00194     /* Read yd (real), xd(imag) input */     
00195     U = pSrc[i3];     
00196     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00197     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00198     /* T = packed((yb + yd), (xb + xd) ) */     
00199     T = __QADD16(T, U);     
00200      
00201     /*  writing the butterfly processed i0 sample */     
00202     /* xa' = xa + xb + xc + xd */     
00203     /* ya' = ya + yb + yc + yd */     
00204     pSrc[i0] = __SHADD16(R, T);     
00205      
00206     /* R = packed((ya + yc) - (yb + yd), (xa + xc)- (xb + xd)) */     
00207     R = __QSUB16(R, T);     
00208      
00209     /* co2 & si2 are read from SIMD Coefficient pointer */     
00210     C2 = pCoeff[2u * ic];     
00211      
00212 #ifndef ARM_MATH_BIG_ENDIAN   
00213    
00214     /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00215     out1 = __SMUAD(C2, R) >> 16u;     
00216     /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00217     out2 = __SMUSDX(C2, R);     
00218      
00219 #else   
00220    
00221     /* xc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00222     out1 = __SMUSDX(R, C2) >> 16u;   
00223     /* yc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */   
00224     out2 = __SMUAD(C2, R);   
00225    
00226 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00227    
00228     /*  Reading i0+fftLen/4 */     
00229     /* T = packed(yb, xb) */     
00230     T = pSrc[i1];     
00231     in = ((int16_t) (T & 0xFFFF)) >> 2;     
00232     T = ((T >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00233      
00234     /* writing the butterfly processed i0 + fftLen/4 sample */     
00235     /* writing output(xc', yc') in little endian format */     
00236     pSrc[i1] = (q31_t) ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00237      
00238     /*  Butterfly calculations */     
00239     /* U = packed(yd, xd) */     
00240     U = pSrc[i3];     
00241     in = ((int16_t) (U & 0xFFFF)) >> 2;     
00242     U = ((U >> 2) & 0xFFFF0000) | (in & 0xFFFF);     
00243     /* T = packed(yb-yd, xb-xd) */     
00244     T = __QSUB16(T, U);     
00245      
00246 #ifndef ARM_MATH_BIG_ENDIAN   
00247    
00248     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00249     R = __QASX(S, T);     
00250     /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */     
00251     S = __QSAX(S, T);     
00252      
00253 #else   
00254    
00255     /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00256     R = __QSAX(S, T);   
00257     /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00258     S = __QASX(S, T);   
00259    
00260 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00261    
00262     /* co1 & si1 are read from SIMD Coefficient pointer */     
00263     C1 = pCoeff[ic];     
00264     /*  Butterfly process for the i0+fftLen/2 sample */   
00265    
00266 #ifndef ARM_MATH_BIG_ENDIAN   
00267    
00268     /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00269     out1 = __SMUAD(C1, S) >> 16u;     
00270     /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00271     out2 = __SMUSDX(C1, S);     
00272    
00273 #else   
00274    
00275     /* xb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */   
00276     out1 = __SMUSDX(S, C1) >> 16u;   
00277     /* yb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */   
00278     out2 = __SMUAD(C1, S);   
00279    
00280 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00281    
00282     /* writing output(xb', yb') in little endian format */     
00283     pSrc[i2] = ((out2) & 0xFFFF0000) | ((out1) & 0x0000FFFF);     
00284      
00285      
00286     /* co3 & si3 are read from SIMD Coefficient pointer */     
00287     C3 = pCoeff[3u * ic];     
00288     /*  Butterfly process for the i0+3fftLen/4 sample */     
00289    
00290 #ifndef ARM_MATH_BIG_ENDIAN   
00291    
00292     /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00293     out1 = __SMUAD(C3, R) >> 16u;     
00294     /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00295     out2 = __SMUSDX(C3, R);     
00296    
00297 #else   
00298    
00299     /* xd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */   
00300     out1 = __SMUSDX(R, C3) >> 16u;   
00301     /* yd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */   
00302     out2 = __SMUAD(C3, R);   
00303    
00304 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00305    
00306     /* writing output(xd', yd') in little endian format */     
00307     pSrc[i3] = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00308      
00309     /*  Twiddle coefficients index modifier */     
00310     ic = ic + twidCoefModifier;     
00311      
00312     /*  Updating input index */     
00313     i0 = i0 + 1u;     
00314      
00315   } while(--j);     
00316   /* data is in 4.11(q11) format */     
00317      
00318   /* end of first stage process */     
00319      
00320      
00321   /* start of middle stage process */     
00322      
00323   /*  Twiddle coefficients index modifier */     
00324   twidCoefModifier <<= 2u;     
00325      
00326   /*  Calculation of Middle stage */     
00327   for (k = fftLen / 4u; k > 4u; k >>= 2u)     
00328   {     
00329     /*  Initializations for the middle stage */     
00330     n1 = n2;     
00331     n2 >>= 2u;     
00332     ic = 0u;     
00333      
00334     for (j = 0u; j <= (n2 - 1u); j++)     
00335     {     
00336       /*  index calculation for the coefficients */     
00337       C1 = pCoeff[ic];     
00338       C2 = pCoeff[2u * ic];     
00339       C3 = pCoeff[3u * ic];     
00340      
00341       /*  Twiddle coefficients index modifier */     
00342       ic = ic + twidCoefModifier;     
00343      
00344       /*  Butterfly implementation */     
00345       for (i0 = j; i0 < fftLen; i0 += n1)     
00346       {     
00347         /*  index calculation for the input as, */     
00348         /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */     
00349         i1 = i0 + n2;     
00350         i2 = i1 + n2;     
00351         i3 = i2 + n2;     
00352      
00353         /*  Reading i0, i0+fftLen/2 inputs */     
00354         /* Read ya (real), xa(imag) input */     
00355         T = pSrc[i0];     
00356      
00357         /* Read yc (real), xc(imag) input */     
00358         S = pSrc[i2];     
00359      
00360         /* R = packed( (ya + yc), (xa + xc)) */     
00361         R = __QADD16(T, S);     
00362      
00363         /* S = packed((ya - yc), (xa - xc)) */     
00364         S = __QSUB16(T, S);     
00365      
00366         /*  Reading i0+fftLen/4 , i0+3fftLen/4 inputs */     
00367         /* Read yb (real), xb(imag) input */     
00368         T = pSrc[i1];     
00369      
00370         /* Read yd (real), xd(imag) input */     
00371         U = pSrc[i3];     
00372      
00373      
00374         /* T = packed( (yb + yd), (xb + xd)) */     
00375         T = __QADD16(T, U);     
00376      
00377      
00378         /*  writing the butterfly processed i0 sample */     
00379      
00380         /* xa' = xa + xb + xc + xd */     
00381         /* ya' = ya + yb + yc + yd */     
00382         out1 = __SHADD16(R, T);     
00383         in = ((int16_t) (out1 & 0xFFFF)) >> 1;     
00384         out1 = ((out1 >> 1) & 0xFFFF0000) | (in & 0xFFFF);     
00385         pSrc[i0] = out1;     
00386      
00387         /* R = packed( (ya + yc) - (yb + yd), (xa + xc) - (xb + xd)) */     
00388         R = __SHSUB16(R, T);     
00389      
00390 #ifndef ARM_MATH_BIG_ENDIAN   
00391    
00392         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */     
00393         out1 = __SMUAD(C2, R) >> 16u;     
00394      
00395         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00396         out2 = __SMUSDX(C2, R);     
00397      
00398 #else   
00399    
00400         /* (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */   
00401         out1 = __SMUSDX(R, C2) >> 16u;   
00402    
00403         /* (ya-yb+yc-yd)* (si2) + (xa-xb+xc-xd)* co2 */   
00404         out2 = __SMUAD(C2, R);   
00405    
00406 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00407    
00408         /*  Reading i0+3fftLen/4 */     
00409         /* Read yb (real), xb(imag) input */     
00410         T = pSrc[i1];     
00411      
00412         /*  writing the butterfly processed i0 + fftLen/4 sample */     
00413         /* xc' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2) */     
00414         /* yc' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2) */     
00415         pSrc[i1] = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00416      
00417         /*  Butterfly calculations */     
00418      
00419         /* Read yd (real), xd(imag) input */     
00420         U = pSrc[i3];     
00421      
00422         /* T = packed(yb-yd, xb-xd) */     
00423         T = __QSUB16(T, U);     
00424      
00425 #ifndef ARM_MATH_BIG_ENDIAN   
00426    
00427         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */     
00428         R = __SHASX(S, T);     
00429      
00430         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */     
00431         S = __SHSAX(S, T);     
00432      
00433      
00434         /*  Butterfly process for the i0+fftLen/2 sample */     
00435         out1 = __SMUAD(C1, S) >> 16u;     
00436         out2 = __SMUSDX(C1, S);     
00437      
00438 #else   
00439    
00440         /* R = packed((ya-yc) + (xb- xd) , (xa-xc) - (yb-yd)) */   
00441         R = __SHSAX(S, T);   
00442    
00443         /* S = packed((ya-yc) - (xb- xd),  (xa-xc) + (yb-yd)) */   
00444         S = __SHASX(S, T);   
00445    
00446    
00447         /*  Butterfly process for the i0+fftLen/2 sample */   
00448         out1 = __SMUSDX(S, C1) >> 16u;   
00449         out2 = __SMUAD(C1, S);   
00450    
00451 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00452    
00453         /* xb' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1) */     
00454         /* yb' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1) */     
00455         pSrc[i2] = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00456      
00457         /*  Butterfly process for the i0+3fftLen/4 sample */     
00458    
00459 #ifndef ARM_MATH_BIG_ENDIAN   
00460    
00461         out1 = __SMUAD(C3, R) >> 16u;     
00462         out2 = __SMUSDX(C3, R);     
00463    
00464 #else   
00465    
00466         out1 = __SMUSDX(R, C3) >> 16u;   
00467         out2 = __SMUAD(C3, R);   
00468    
00469 #endif /*      #ifndef ARM_MATH_BIG_ENDIAN     */   
00470    
00471         /* xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3) */     
00472         /* yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3) */     
00473         pSrc[i3] = ((out2) & 0xFFFF0000) | (out1 & 0x0000FFFF);     
00474       }     
00475     }     
00476     /*  Twiddle coefficients index modifier */     
00477     twidCoefModifier <<= 2u;     
00478   }     
00479   /* end of middle stage process */     
00480      
00481      
00482   /* data is in 10.6(q6) format for the 1024 point */     
00483   /* data is in 8.8(q8) format for the 256 point */     
00484   /* data is in 6.10(q10) format for the 64 point */     
00485   /* data is in 4.12(q12) format for the 16 point */     
00486      
00487   /*  Initializations for the last stage */     
00488     j = fftLen >> 2;   
00489            
00490     ptr1 = &pSrc16[0];   
00491    
00492     /* start of last stage process */   
00493    
00494     /*  Butterfly implementation */   
00495     do   
00496     {   
00497         /* Read xa (real), ya(imag) input */   
00498         xaya = *__SIMD32(ptr1)++;    
00499    
00500         /* Read xb (real), yb(imag) input */   
00501         xbyb = *__SIMD32(ptr1)++;    
00502            
00503         /* Read xc (real), yc(imag) input */   
00504         xcyc = *__SIMD32(ptr1)++;      
00505    
00506         /* Read xd (real), yd(imag) input */   
00507         xdyd = *__SIMD32(ptr1)++;   
00508    
00509         /* R = packed((ya + yc), (xa + xc)) */     
00510         R = __QADD16(xaya, xcyc);    
00511    
00512         /* T = packed((yb + yd), (xb + xd)) */     
00513         T = __QADD16(xbyb, xdyd);   
00514    
00515         /* xa' = xa + xb + xc + xd */     
00516         /* ya' = ya + yb + yc + yd */    
00517         in = __SHADD16(R,T);  
00518           
00519         /* T = packed((yb + yd), (xb + xd)) */     
00520         T = __QADD16(xbyb, xdyd);   
00521   
00522         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00523         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00524    
00525    
00526         /* xc' = (xa-xb+xc-xd) */     
00527         /* yc' = (ya-yb+yc-yd) */     
00528         in = __SHSUB16(R, T);   
00529           
00530         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00531   
00532         /* S = packed((ya - yc), (xa - xc)) */     
00533         S = __QSUB16(xaya, xcyc);     
00534   
00535         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00536         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00537    
00538         /* Read yd (real), xd(imag) input */     
00539         /* T = packed( (yb - yd), (xb - xd))  */     
00540         U = __QSUB16(xbyb, xdyd);     
00541           
00542         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00543   
00544 #ifndef ARM_MATH_BIG_ENDIAN   
00545            
00546          in = __SHSAX(S, U);  
00547         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00548         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00549           
00550         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00551         /* xb' = (xa+yb-xc-yd) */     
00552         /* yb' = (ya-xb-yc+xd) */     
00553 //      *__SIMD32(ptr1)++ = __SHSAX(S, U);     
00554    
00555            
00556          in = __SHASX(S, U);  
00557         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00558         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00559           
00560         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00561         /* xd' = (xa-yb-xc+yd) */     
00562         /* yd' = (ya+xb-yc-xd) */     
00563 //      *__SIMD32(ptr1)++ = __SHASX(S, U);        
00564            
00565 #else   
00566         /* xb' = (xa+yb-xc-yd) */     
00567         /* yb' = (ya-xb-yc+xd) */     
00568         in = __SHASX(S, U);  
00569         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00570         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00571           
00572         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00573   
00574            
00575         /* xd' = (xa-yb-xc+yd) */     
00576         /* yd' = (ya+xb-yc-xd) */     
00577         in = __SHSAX(S, U);  
00578         cmplxm1 = __SMUAD((q15_t)in, (q15_t)in);  
00579         cmplxm2 = __SMUAD((q15_t)(in>>16), (q15_t)(in>>16));  
00580           
00581         arm_sqrt_q15((q15_t) (((q63_t) cmplxm1 + cmplxm2) >> 17), pDst++);     
00582    
00583 #endif                   
00584    
00585     }while(--j);     
00586      
00587    
00588     
00589      
00590   /* end of last stage process */     
00591      
00592   /* output is in 11.5(q5) format for the 1024 point */     
00593   /* output is in 9.7(q7) format for the 256 point   */     
00594   /* output is in 7.9(q9) format for the 64 point  */     
00595   /* output is in 5.11(q11) format for the 16 point  */     
00596      
00597 }     
00598      
00599      
00600 /*      
00601    * @brief  In-place bit reversal function.     
00602    * @param[in, out] *pSrc        points to the in-place buffer of Q15 data type.     
00603    * @param[in]      fftLen       length of the FFT.     
00604    * @param[in]      bitRevFactor bit reversal modifier that supports different size FFTs with the same bit reversal table     
00605    * @param[in]      *pBitRevTab  points to bit reversal table.     
00606    * @return none.     
00607  */     
00608      
00609 void arm_cfft_mag_bitreversal_q15(     
00610   q15_t * pSrc16,     
00611   uint32_t fftLen,     
00612   uint16_t bitRevFactor,     
00613   uint16_t * pBitRevTab)     
00614 {     
00615   q15_t *pSrc = pSrc16;     
00616   q15_t in;     
00617   uint32_t fftLenBy2, fftLenBy2p1;     
00618   uint32_t i, j;     
00619      
00620   /*  Initializations */     
00621   j = 0u;     
00622   fftLenBy2 = fftLen / 2u;     
00623   fftLenBy2p1 = (fftLen / 2u) + 1u;     
00624      
00625   /* Bit Reversal Implementation */     
00626   for (i = 0u; i <= (fftLenBy2 - 2u); i += 2u)     
00627   {     
00628     if(i < j)     
00629     {     
00630       /*  pSrc[i] <-> pSrc[j]; */     
00631       /*  pSrc[i+1u] <-> pSrc[j+1u] */     
00632       in = pSrc[i];     
00633       pSrc[i] = pSrc[j];     
00634       pSrc[j] = in;     
00635      
00636       /*  pSrc[i + fftLenBy2p1] <-> pSrc[j + fftLenBy2p1];  */     
00637       /*  pSrc[i + fftLenBy2p1+1u] <-> pSrc[j + fftLenBy2p1+1u] */     
00638       in = pSrc[i + fftLenBy2p1];     
00639       pSrc[i + fftLenBy2p1] = pSrc[j + fftLenBy2p1];     
00640       pSrc[j + fftLenBy2p1] = in;     
00641     }     
00642      
00643     /*  pSrc[i+1u] <-> pSrc[j+fftLenBy2];         */     
00644     /*  pSrc[i+2] <-> pSrc[j+fftLenBy2+1u]  */     
00645     in = pSrc[i + 1u];     
00646     pSrc[i + 1u] = pSrc[j + fftLenBy2];     
00647     pSrc[j + fftLenBy2] = in;     
00648      
00649     /*  Reading the index for the bit reversal */     
00650     j = *pBitRevTab;     
00651      
00652     /*  Updating the bit reversal index depending on the fft length  */     
00653     pBitRevTab += bitRevFactor;     
00654   }     
00655 }