Subversion Repositories DashDisplay

Rev

Rev 28 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /* ----------------------------------------------------------------------    
  2. * Copyright (C) 2010-2014 ARM Limited. All rights reserved.    
  3. *    
  4. * $Date:        19. March 2015
  5. * $Revision:    V.1.4.5  
  6. *    
  7. * Project:          CMSIS DSP Library    
  8. * Title:            arm_cfft_radix4_f32.c    
  9. *    
  10. * Description:  Radix-4 Decimation in Frequency CFFT & CIFFT Floating point processing function    
  11. *    
  12. *    
  13. * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0
  14. *  
  15. * Redistribution and use in source and binary forms, with or without
  16. * modification, are permitted provided that the following conditions
  17. * are met:
  18. *   - Redistributions of source code must retain the above copyright
  19. *     notice, this list of conditions and the following disclaimer.
  20. *   - Redistributions in binary form must reproduce the above copyright
  21. *     notice, this list of conditions and the following disclaimer in
  22. *     the documentation and/or other materials provided with the
  23. *     distribution.
  24. *   - Neither the name of ARM LIMITED nor the names of its contributors
  25. *     may be used to endorse or promote products derived from this
  26. *     software without specific prior written permission.
  27. *
  28. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  31. * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  32. * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  33. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  34. * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  35. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  36. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  38. * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39. * POSSIBILITY OF SUCH DAMAGE.    
  40. * -------------------------------------------------------------------- */
  41.  
  42. #include "arm_math.h"
  43.  
  44. extern void arm_bitreversal_f32(
  45. float32_t * pSrc,
  46. uint16_t fftSize,
  47. uint16_t bitRevFactor,
  48. uint16_t * pBitRevTab);
  49.  
  50. /**    
  51. * @ingroup groupTransforms    
  52. */
  53.  
  54. /* ----------------------------------------------------------------------    
  55. ** Internal helper function used by the FFTs    
  56. ** ------------------------------------------------------------------- */
  57.  
  58. /*    
  59. * @brief  Core function for the floating-point CFFT butterfly process.  
  60. * @param[in, out] *pSrc            points to the in-place buffer of floating-point data type.  
  61. * @param[in]      fftLen           length of the FFT.  
  62. * @param[in]      *pCoef           points to the twiddle coefficient buffer.  
  63. * @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.  
  64. * @return none.  
  65. */
  66.  
  67. void arm_radix4_butterfly_f32(
  68. float32_t * pSrc,
  69. uint16_t fftLen,
  70. float32_t * pCoef,
  71. uint16_t twidCoefModifier)
  72. {
  73.  
  74.    float32_t co1, co2, co3, si1, si2, si3;
  75.    uint32_t ia1, ia2, ia3;
  76.    uint32_t i0, i1, i2, i3;
  77.    uint32_t n1, n2, j, k;
  78.  
  79. #ifndef ARM_MATH_CM0_FAMILY_FAMILY
  80.  
  81.    /* Run the below code for Cortex-M4 and Cortex-M3 */
  82.  
  83.    float32_t xaIn, yaIn, xbIn, ybIn, xcIn, ycIn, xdIn, ydIn;
  84.    float32_t Xaplusc, Xbplusd, Yaplusc, Ybplusd, Xaminusc, Xbminusd, Yaminusc,
  85.    Ybminusd;
  86.    float32_t Xb12C_out, Yb12C_out, Xc12C_out, Yc12C_out, Xd12C_out, Yd12C_out;
  87.    float32_t Xb12_out, Yb12_out, Xc12_out, Yc12_out, Xd12_out, Yd12_out;
  88.    float32_t *ptr1;
  89.    float32_t p0,p1,p2,p3,p4,p5;
  90.    float32_t a0,a1,a2,a3,a4,a5,a6,a7;
  91.  
  92.    /*  Initializations for the first stage */
  93.    n2 = fftLen;
  94.    n1 = n2;
  95.  
  96.    /* n2 = fftLen/4 */
  97.    n2 >>= 2u;
  98.    i0 = 0u;
  99.    ia1 = 0u;
  100.  
  101.    j = n2;
  102.  
  103.    /*  Calculation of first stage */
  104.    do
  105.    {
  106.       /*  index calculation for the input as, */
  107.       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  108.       i1 = i0 + n2;
  109.       i2 = i1 + n2;
  110.       i3 = i2 + n2;
  111.  
  112.       xaIn = pSrc[(2u * i0)];
  113.       yaIn = pSrc[(2u * i0) + 1u];
  114.  
  115.       xbIn = pSrc[(2u * i1)];
  116.       ybIn = pSrc[(2u * i1) + 1u];
  117.  
  118.       xcIn = pSrc[(2u * i2)];
  119.       ycIn = pSrc[(2u * i2) + 1u];
  120.  
  121.       xdIn = pSrc[(2u * i3)];
  122.       ydIn = pSrc[(2u * i3) + 1u];
  123.  
  124.       /* xa + xc */
  125.       Xaplusc = xaIn + xcIn;
  126.       /* xb + xd */
  127.       Xbplusd = xbIn + xdIn;
  128.       /* ya + yc */
  129.       Yaplusc = yaIn + ycIn;
  130.       /* yb + yd */
  131.       Ybplusd = ybIn + ydIn;
  132.  
  133.       /*  index calculation for the coefficients */
  134.       ia2 = ia1 + ia1;
  135.       co2 = pCoef[ia2 * 2u];
  136.       si2 = pCoef[(ia2 * 2u) + 1u];
  137.  
  138.       /* xa - xc */
  139.       Xaminusc = xaIn - xcIn;
  140.       /* xb - xd */
  141.       Xbminusd = xbIn - xdIn;
  142.       /* ya - yc */
  143.       Yaminusc = yaIn - ycIn;
  144.       /* yb - yd */
  145.       Ybminusd = ybIn - ydIn;
  146.  
  147.       /* xa' = xa + xb + xc + xd */
  148.       pSrc[(2u * i0)] = Xaplusc + Xbplusd;
  149.       /* ya' = ya + yb + yc + yd */
  150.       pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
  151.  
  152.       /* (xa - xc) + (yb - yd) */
  153.       Xb12C_out = (Xaminusc + Ybminusd);
  154.       /* (ya - yc) + (xb - xd) */
  155.       Yb12C_out = (Yaminusc - Xbminusd);
  156.       /* (xa + xc) - (xb + xd) */
  157.       Xc12C_out = (Xaplusc - Xbplusd);
  158.       /* (ya + yc) - (yb + yd) */
  159.       Yc12C_out = (Yaplusc - Ybplusd);
  160.       /* (xa - xc) - (yb - yd) */
  161.       Xd12C_out = (Xaminusc - Ybminusd);
  162.       /* (ya - yc) + (xb - xd) */
  163.       Yd12C_out = (Xbminusd + Yaminusc);
  164.  
  165.       co1 = pCoef[ia1 * 2u];
  166.       si1 = pCoef[(ia1 * 2u) + 1u];
  167.  
  168.       /*  index calculation for the coefficients */
  169.       ia3 = ia2 + ia1;
  170.       co3 = pCoef[ia3 * 2u];
  171.       si3 = pCoef[(ia3 * 2u) + 1u];
  172.  
  173.       Xb12_out = Xb12C_out * co1;
  174.       Yb12_out = Yb12C_out * co1;
  175.       Xc12_out = Xc12C_out * co2;
  176.       Yc12_out = Yc12C_out * co2;
  177.       Xd12_out = Xd12C_out * co3;
  178.       Yd12_out = Yd12C_out * co3;
  179.          
  180.       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  181.       //Xb12_out -= Yb12C_out * si1;
  182.       p0 = Yb12C_out * si1;
  183.       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  184.       //Yb12_out += Xb12C_out * si1;
  185.       p1 = Xb12C_out * si1;
  186.       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  187.       //Xc12_out -= Yc12C_out * si2;
  188.       p2 = Yc12C_out * si2;
  189.       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  190.       //Yc12_out += Xc12C_out * si2;
  191.       p3 = Xc12C_out * si2;
  192.       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  193.       //Xd12_out -= Yd12C_out * si3;
  194.       p4 = Yd12C_out * si3;
  195.       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  196.       //Yd12_out += Xd12C_out * si3;
  197.       p5 = Xd12C_out * si3;
  198.      
  199.       Xb12_out += p0;
  200.       Yb12_out -= p1;
  201.       Xc12_out += p2;
  202.       Yc12_out -= p3;
  203.       Xd12_out += p4;
  204.       Yd12_out -= p5;
  205.  
  206.       /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
  207.       pSrc[2u * i1] = Xc12_out;
  208.  
  209.       /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
  210.       pSrc[(2u * i1) + 1u] = Yc12_out;
  211.  
  212.       /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
  213.       pSrc[2u * i2] = Xb12_out;
  214.  
  215.       /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
  216.       pSrc[(2u * i2) + 1u] = Yb12_out;
  217.  
  218.       /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
  219.       pSrc[2u * i3] = Xd12_out;
  220.  
  221.       /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
  222.       pSrc[(2u * i3) + 1u] = Yd12_out;
  223.  
  224.       /*  Twiddle coefficients index modifier */
  225.       ia1 += twidCoefModifier;
  226.  
  227.       /*  Updating input index */
  228.       i0++;
  229.  
  230.    }
  231.    while(--j);
  232.  
  233.    twidCoefModifier <<= 2u;
  234.  
  235.    /*  Calculation of second stage to excluding last stage */
  236.    for (k = fftLen >> 2u; k > 4u; k >>= 2u)
  237.    {
  238.       /*  Initializations for the first stage */
  239.       n1 = n2;
  240.       n2 >>= 2u;
  241.       ia1 = 0u;
  242.  
  243.       /*  Calculation of first stage */
  244.       j = 0;
  245.       do
  246.       {
  247.          /*  index calculation for the coefficients */
  248.          ia2 = ia1 + ia1;
  249.          ia3 = ia2 + ia1;
  250.          co1 = pCoef[ia1 * 2u];
  251.          si1 = pCoef[(ia1 * 2u) + 1u];
  252.          co2 = pCoef[ia2 * 2u];
  253.          si2 = pCoef[(ia2 * 2u) + 1u];
  254.          co3 = pCoef[ia3 * 2u];
  255.          si3 = pCoef[(ia3 * 2u) + 1u];
  256.  
  257.          /*  Twiddle coefficients index modifier */
  258.          ia1 += twidCoefModifier;
  259.      
  260.          i0 = j;
  261.          do
  262.          {
  263.             /*  index calculation for the input as, */
  264.             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  265.             i1 = i0 + n2;
  266.             i2 = i1 + n2;
  267.             i3 = i2 + n2;
  268.  
  269.             xaIn = pSrc[(2u * i0)];
  270.             yaIn = pSrc[(2u * i0) + 1u];
  271.  
  272.             xbIn = pSrc[(2u * i1)];
  273.             ybIn = pSrc[(2u * i1) + 1u];
  274.  
  275.             xcIn = pSrc[(2u * i2)];
  276.             ycIn = pSrc[(2u * i2) + 1u];
  277.  
  278.             xdIn = pSrc[(2u * i3)];
  279.             ydIn = pSrc[(2u * i3) + 1u];
  280.  
  281.             /* xa - xc */
  282.             Xaminusc = xaIn - xcIn;
  283.             /* (xb - xd) */
  284.             Xbminusd = xbIn - xdIn;
  285.             /* ya - yc */
  286.             Yaminusc = yaIn - ycIn;
  287.             /* (yb - yd) */
  288.             Ybminusd = ybIn - ydIn;
  289.  
  290.             /* xa + xc */
  291.             Xaplusc = xaIn + xcIn;
  292.             /* xb + xd */
  293.             Xbplusd = xbIn + xdIn;
  294.             /* ya + yc */
  295.             Yaplusc = yaIn + ycIn;
  296.             /* yb + yd */
  297.             Ybplusd = ybIn + ydIn;
  298.  
  299.             /* (xa - xc) + (yb - yd) */
  300.             Xb12C_out = (Xaminusc + Ybminusd);
  301.             /* (ya - yc) -  (xb - xd) */
  302.             Yb12C_out = (Yaminusc - Xbminusd);
  303.             /* xa + xc -(xb + xd) */
  304.             Xc12C_out = (Xaplusc - Xbplusd);
  305.             /* (ya + yc) - (yb + yd) */
  306.             Yc12C_out = (Yaplusc - Ybplusd);
  307.             /* (xa - xc) - (yb - yd) */
  308.             Xd12C_out = (Xaminusc - Ybminusd);
  309.             /* (ya - yc) +  (xb - xd) */
  310.             Yd12C_out = (Xbminusd + Yaminusc);
  311.  
  312.             pSrc[(2u * i0)] = Xaplusc + Xbplusd;
  313.             pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
  314.  
  315.             Xb12_out = Xb12C_out * co1;
  316.             Yb12_out = Yb12C_out * co1;
  317.             Xc12_out = Xc12C_out * co2;
  318.             Yc12_out = Yc12C_out * co2;
  319.             Xd12_out = Xd12C_out * co3;
  320.             Yd12_out = Yd12C_out * co3;
  321.          
  322.             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  323.             //Xb12_out -= Yb12C_out * si1;
  324.             p0 = Yb12C_out * si1;
  325.             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  326.             //Yb12_out += Xb12C_out * si1;
  327.             p1 = Xb12C_out * si1;
  328.             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  329.             //Xc12_out -= Yc12C_out * si2;
  330.             p2 = Yc12C_out * si2;
  331.             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  332.             //Yc12_out += Xc12C_out * si2;
  333.             p3 = Xc12C_out * si2;
  334.             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  335.             //Xd12_out -= Yd12C_out * si3;
  336.             p4 = Yd12C_out * si3;
  337.             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  338.             //Yd12_out += Xd12C_out * si3;
  339.             p5 = Xd12C_out * si3;
  340.            
  341.             Xb12_out += p0;
  342.             Yb12_out -= p1;
  343.             Xc12_out += p2;
  344.             Yc12_out -= p3;
  345.             Xd12_out += p4;
  346.             Yd12_out -= p5;
  347.  
  348.             /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
  349.             pSrc[2u * i1] = Xc12_out;
  350.  
  351.             /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
  352.             pSrc[(2u * i1) + 1u] = Yc12_out;
  353.  
  354.             /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
  355.             pSrc[2u * i2] = Xb12_out;
  356.  
  357.             /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
  358.             pSrc[(2u * i2) + 1u] = Yb12_out;
  359.  
  360.             /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
  361.             pSrc[2u * i3] = Xd12_out;
  362.  
  363.             /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
  364.             pSrc[(2u * i3) + 1u] = Yd12_out;
  365.  
  366.             i0 += n1;
  367.          } while(i0 < fftLen);
  368.          j++;
  369.       } while(j <= (n2 - 1u));
  370.       twidCoefModifier <<= 2u;
  371.    }
  372.  
  373.    j = fftLen >> 2;
  374.    ptr1 = &pSrc[0];
  375.  
  376.    /*  Calculations of last stage */
  377.    do
  378.    {
  379.       xaIn = ptr1[0];
  380.       yaIn = ptr1[1];
  381.       xbIn = ptr1[2];
  382.       ybIn = ptr1[3];
  383.       xcIn = ptr1[4];
  384.       ycIn = ptr1[5];
  385.       xdIn = ptr1[6];
  386.       ydIn = ptr1[7];
  387.  
  388.       /* xa + xc */
  389.       Xaplusc = xaIn + xcIn;
  390.  
  391.       /* xa - xc */
  392.       Xaminusc = xaIn - xcIn;
  393.  
  394.       /* ya + yc */
  395.       Yaplusc = yaIn + ycIn;
  396.  
  397.       /* ya - yc */
  398.       Yaminusc = yaIn - ycIn;
  399.  
  400.       /* xb + xd */
  401.       Xbplusd = xbIn + xdIn;
  402.  
  403.       /* yb + yd */
  404.       Ybplusd = ybIn + ydIn;
  405.  
  406.       /* (xb-xd) */
  407.       Xbminusd = xbIn - xdIn;
  408.  
  409.       /* (yb-yd) */
  410.       Ybminusd = ybIn - ydIn;
  411.  
  412.       /* xa' = xa + xb + xc + xd */
  413.       a0 = (Xaplusc + Xbplusd);
  414.       /* ya' = ya + yb + yc + yd */
  415.       a1 = (Yaplusc + Ybplusd);
  416.       /* xc' = (xa-xb+xc-xd) */
  417.       a2 = (Xaplusc - Xbplusd);
  418.       /* yc' = (ya-yb+yc-yd) */
  419.       a3 = (Yaplusc - Ybplusd);
  420.       /* xb' = (xa+yb-xc-yd) */
  421.       a4 = (Xaminusc + Ybminusd);
  422.       /* yb' = (ya-xb-yc+xd) */
  423.       a5 = (Yaminusc - Xbminusd);
  424.       /* xd' = (xa-yb-xc+yd)) */
  425.       a6 = (Xaminusc - Ybminusd);
  426.       /* yd' = (ya+xb-yc-xd) */
  427.       a7 = (Xbminusd + Yaminusc);
  428.    
  429.       ptr1[0] = a0;
  430.       ptr1[1] = a1;
  431.       ptr1[2] = a2;
  432.       ptr1[3] = a3;
  433.       ptr1[4] = a4;
  434.       ptr1[5] = a5;
  435.       ptr1[6] = a6;
  436.       ptr1[7] = a7;
  437.  
  438.       /* increment pointer by 8 */
  439.       ptr1 += 8u;
  440.    } while(--j);
  441.  
  442. #else
  443.  
  444.    float32_t t1, t2, r1, r2, s1, s2;
  445.  
  446.    /* Run the below code for Cortex-M0 */
  447.  
  448.    /*  Initializations for the fft calculation */
  449.    n2 = fftLen;
  450.    n1 = n2;
  451.    for (k = fftLen; k > 1u; k >>= 2u)
  452.    {
  453.       /*  Initializations for the fft calculation */
  454.       n1 = n2;
  455.       n2 >>= 2u;
  456.       ia1 = 0u;
  457.  
  458.       /*  FFT Calculation */
  459.       j = 0;
  460.       do
  461.       {
  462.          /*  index calculation for the coefficients */
  463.          ia2 = ia1 + ia1;
  464.          ia3 = ia2 + ia1;
  465.          co1 = pCoef[ia1 * 2u];
  466.          si1 = pCoef[(ia1 * 2u) + 1u];
  467.          co2 = pCoef[ia2 * 2u];
  468.          si2 = pCoef[(ia2 * 2u) + 1u];
  469.          co3 = pCoef[ia3 * 2u];
  470.          si3 = pCoef[(ia3 * 2u) + 1u];
  471.  
  472.          /*  Twiddle coefficients index modifier */
  473.          ia1 = ia1 + twidCoefModifier;
  474.  
  475.          i0 = j;
  476.          do
  477.          {
  478.             /*  index calculation for the input as, */
  479.             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  480.             i1 = i0 + n2;
  481.             i2 = i1 + n2;
  482.             i3 = i2 + n2;
  483.  
  484.             /* xa + xc */
  485.             r1 = pSrc[(2u * i0)] + pSrc[(2u * i2)];
  486.  
  487.             /* xa - xc */
  488.             r2 = pSrc[(2u * i0)] - pSrc[(2u * i2)];
  489.  
  490.             /* ya + yc */
  491.             s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
  492.  
  493.             /* ya - yc */
  494.             s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
  495.  
  496.             /* xb + xd */
  497.             t1 = pSrc[2u * i1] + pSrc[2u * i3];
  498.  
  499.             /* xa' = xa + xb + xc + xd */
  500.             pSrc[2u * i0] = r1 + t1;
  501.  
  502.             /* xa + xc -(xb + xd) */
  503.             r1 = r1 - t1;
  504.  
  505.             /* yb + yd */
  506.             t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
  507.  
  508.             /* ya' = ya + yb + yc + yd */
  509.             pSrc[(2u * i0) + 1u] = s1 + t2;
  510.  
  511.             /* (ya + yc) - (yb + yd) */
  512.             s1 = s1 - t2;
  513.  
  514.             /* (yb - yd) */
  515.             t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
  516.  
  517.             /* (xb - xd) */
  518.             t2 = pSrc[2u * i1] - pSrc[2u * i3];
  519.  
  520.             /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
  521.             pSrc[2u * i1] = (r1 * co2) + (s1 * si2);
  522.  
  523.             /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
  524.             pSrc[(2u * i1) + 1u] = (s1 * co2) - (r1 * si2);
  525.  
  526.             /* (xa - xc) + (yb - yd) */
  527.             r1 = r2 + t1;
  528.  
  529.             /* (xa - xc) - (yb - yd) */
  530.             r2 = r2 - t1;
  531.  
  532.             /* (ya - yc) -  (xb - xd) */
  533.             s1 = s2 - t2;
  534.  
  535.             /* (ya - yc) +  (xb - xd) */
  536.             s2 = s2 + t2;
  537.  
  538.             /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
  539.             pSrc[2u * i2] = (r1 * co1) + (s1 * si1);
  540.  
  541.             /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
  542.             pSrc[(2u * i2) + 1u] = (s1 * co1) - (r1 * si1);
  543.  
  544.             /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
  545.             pSrc[2u * i3] = (r2 * co3) + (s2 * si3);
  546.  
  547.             /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
  548.             pSrc[(2u * i3) + 1u] = (s2 * co3) - (r2 * si3);
  549.          
  550.             i0 += n1;
  551.          } while( i0 < fftLen);
  552.          j++;
  553.       } while(j <= (n2 - 1u));
  554.       twidCoefModifier <<= 2u;
  555.    }
  556.  
  557. #endif /* #ifndef ARM_MATH_CM0_FAMILY_FAMILY */
  558.  
  559. }
  560.  
  561. /*    
  562. * @brief  Core function for the floating-point CIFFT butterfly process.  
  563. * @param[in, out] *pSrc            points to the in-place buffer of floating-point data type.  
  564. * @param[in]      fftLen           length of the FFT.  
  565. * @param[in]      *pCoef           points to twiddle coefficient buffer.  
  566. * @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.  
  567. * @param[in]      onebyfftLen      value of 1/fftLen.  
  568. * @return none.  
  569. */
  570.  
  571. void arm_radix4_butterfly_inverse_f32(
  572. float32_t * pSrc,
  573. uint16_t fftLen,
  574. float32_t * pCoef,
  575. uint16_t twidCoefModifier,
  576. float32_t onebyfftLen)
  577. {
  578.    float32_t co1, co2, co3, si1, si2, si3;
  579.    uint32_t ia1, ia2, ia3;
  580.    uint32_t i0, i1, i2, i3;
  581.    uint32_t n1, n2, j, k;
  582.  
  583. #ifndef ARM_MATH_CM0_FAMILY_FAMILY
  584.  
  585.    float32_t xaIn, yaIn, xbIn, ybIn, xcIn, ycIn, xdIn, ydIn;
  586.    float32_t Xaplusc, Xbplusd, Yaplusc, Ybplusd, Xaminusc, Xbminusd, Yaminusc,
  587.    Ybminusd;
  588.    float32_t Xb12C_out, Yb12C_out, Xc12C_out, Yc12C_out, Xd12C_out, Yd12C_out;
  589.    float32_t Xb12_out, Yb12_out, Xc12_out, Yc12_out, Xd12_out, Yd12_out;
  590.    float32_t *ptr1;
  591.    float32_t p0,p1,p2,p3,p4,p5,p6,p7;
  592.    float32_t a0,a1,a2,a3,a4,a5,a6,a7;
  593.  
  594.  
  595.    /*  Initializations for the first stage */
  596.    n2 = fftLen;
  597.    n1 = n2;
  598.  
  599.    /* n2 = fftLen/4 */
  600.    n2 >>= 2u;
  601.    i0 = 0u;
  602.    ia1 = 0u;
  603.  
  604.    j = n2;
  605.  
  606.    /*  Calculation of first stage */
  607.    do
  608.    {
  609.       /*  index calculation for the input as, */
  610.       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  611.       i1 = i0 + n2;
  612.       i2 = i1 + n2;
  613.       i3 = i2 + n2;
  614.  
  615.       /*  Butterfly implementation */
  616.       xaIn = pSrc[(2u * i0)];
  617.       yaIn = pSrc[(2u * i0) + 1u];
  618.  
  619.       xcIn = pSrc[(2u * i2)];
  620.       ycIn = pSrc[(2u * i2) + 1u];
  621.  
  622.       xbIn = pSrc[(2u * i1)];
  623.       ybIn = pSrc[(2u * i1) + 1u];
  624.  
  625.       xdIn = pSrc[(2u * i3)];
  626.       ydIn = pSrc[(2u * i3) + 1u];
  627.  
  628.       /* xa + xc */
  629.       Xaplusc = xaIn + xcIn;
  630.       /* xb + xd */
  631.       Xbplusd = xbIn + xdIn;
  632.       /* ya + yc */
  633.       Yaplusc = yaIn + ycIn;
  634.       /* yb + yd */
  635.       Ybplusd = ybIn + ydIn;
  636.  
  637.       /*  index calculation for the coefficients */
  638.       ia2 = ia1 + ia1;
  639.       co2 = pCoef[ia2 * 2u];
  640.       si2 = pCoef[(ia2 * 2u) + 1u];
  641.  
  642.       /* xa - xc */
  643.       Xaminusc = xaIn - xcIn;
  644.       /* xb - xd */
  645.       Xbminusd = xbIn - xdIn;
  646.       /* ya - yc */
  647.       Yaminusc = yaIn - ycIn;
  648.       /* yb - yd */
  649.       Ybminusd = ybIn - ydIn;
  650.  
  651.       /* xa' = xa + xb + xc + xd */
  652.       pSrc[(2u * i0)] = Xaplusc + Xbplusd;
  653.  
  654.       /* ya' = ya + yb + yc + yd */
  655.       pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
  656.  
  657.       /* (xa - xc) - (yb - yd) */
  658.       Xb12C_out = (Xaminusc - Ybminusd);
  659.       /* (ya - yc) + (xb - xd) */
  660.       Yb12C_out = (Yaminusc + Xbminusd);
  661.       /* (xa + xc) - (xb + xd) */
  662.       Xc12C_out = (Xaplusc - Xbplusd);
  663.       /* (ya + yc) - (yb + yd) */
  664.       Yc12C_out = (Yaplusc - Ybplusd);
  665.       /* (xa - xc) + (yb - yd) */
  666.       Xd12C_out = (Xaminusc + Ybminusd);
  667.       /* (ya - yc) - (xb - xd) */
  668.       Yd12C_out = (Yaminusc - Xbminusd);
  669.  
  670.       co1 = pCoef[ia1 * 2u];
  671.       si1 = pCoef[(ia1 * 2u) + 1u];
  672.  
  673.       /*  index calculation for the coefficients */
  674.       ia3 = ia2 + ia1;
  675.       co3 = pCoef[ia3 * 2u];
  676.       si3 = pCoef[(ia3 * 2u) + 1u];
  677.  
  678.       Xb12_out = Xb12C_out * co1;
  679.       Yb12_out = Yb12C_out * co1;
  680.       Xc12_out = Xc12C_out * co2;
  681.       Yc12_out = Yc12C_out * co2;
  682.       Xd12_out = Xd12C_out * co3;
  683.       Yd12_out = Yd12C_out * co3;
  684.    
  685.       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  686.       //Xb12_out -= Yb12C_out * si1;
  687.       p0 = Yb12C_out * si1;
  688.       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  689.       //Yb12_out += Xb12C_out * si1;
  690.       p1 = Xb12C_out * si1;
  691.       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  692.       //Xc12_out -= Yc12C_out * si2;
  693.       p2 = Yc12C_out * si2;
  694.       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  695.       //Yc12_out += Xc12C_out * si2;
  696.       p3 = Xc12C_out * si2;
  697.       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  698.       //Xd12_out -= Yd12C_out * si3;
  699.       p4 = Yd12C_out * si3;
  700.       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  701.       //Yd12_out += Xd12C_out * si3;
  702.       p5 = Xd12C_out * si3;
  703.      
  704.       Xb12_out -= p0;
  705.       Yb12_out += p1;
  706.       Xc12_out -= p2;
  707.       Yc12_out += p3;
  708.       Xd12_out -= p4;
  709.       Yd12_out += p5;
  710.  
  711.       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  712.       pSrc[2u * i1] = Xc12_out;
  713.  
  714.       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  715.       pSrc[(2u * i1) + 1u] = Yc12_out;
  716.  
  717.       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  718.       pSrc[2u * i2] = Xb12_out;
  719.  
  720.       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  721.       pSrc[(2u * i2) + 1u] = Yb12_out;
  722.  
  723.       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  724.       pSrc[2u * i3] = Xd12_out;
  725.  
  726.       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  727.       pSrc[(2u * i3) + 1u] = Yd12_out;
  728.  
  729.       /*  Twiddle coefficients index modifier */
  730.       ia1 = ia1 + twidCoefModifier;
  731.  
  732.       /*  Updating input index */
  733.       i0 = i0 + 1u;
  734.  
  735.    } while(--j);
  736.  
  737.    twidCoefModifier <<= 2u;
  738.  
  739.    /*  Calculation of second stage to excluding last stage */
  740.    for (k = fftLen >> 2u; k > 4u; k >>= 2u)
  741.    {
  742.       /*  Initializations for the first stage */
  743.       n1 = n2;
  744.       n2 >>= 2u;
  745.       ia1 = 0u;
  746.  
  747.       /*  Calculation of first stage */
  748.       j = 0;
  749.       do
  750.       {
  751.          /*  index calculation for the coefficients */
  752.          ia2 = ia1 + ia1;
  753.          ia3 = ia2 + ia1;
  754.          co1 = pCoef[ia1 * 2u];
  755.          si1 = pCoef[(ia1 * 2u) + 1u];
  756.          co2 = pCoef[ia2 * 2u];
  757.          si2 = pCoef[(ia2 * 2u) + 1u];
  758.          co3 = pCoef[ia3 * 2u];
  759.          si3 = pCoef[(ia3 * 2u) + 1u];
  760.  
  761.          /*  Twiddle coefficients index modifier */
  762.          ia1 = ia1 + twidCoefModifier;
  763.  
  764.          i0 = j;
  765.          do
  766.          {
  767.             /*  index calculation for the input as, */
  768.             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  769.             i1 = i0 + n2;
  770.             i2 = i1 + n2;
  771.             i3 = i2 + n2;
  772.  
  773.             xaIn = pSrc[(2u * i0)];
  774.             yaIn = pSrc[(2u * i0) + 1u];
  775.  
  776.             xbIn = pSrc[(2u * i1)];
  777.             ybIn = pSrc[(2u * i1) + 1u];
  778.  
  779.             xcIn = pSrc[(2u * i2)];
  780.             ycIn = pSrc[(2u * i2) + 1u];
  781.  
  782.             xdIn = pSrc[(2u * i3)];
  783.             ydIn = pSrc[(2u * i3) + 1u];
  784.  
  785.             /* xa - xc */
  786.             Xaminusc = xaIn - xcIn;
  787.             /* (xb - xd) */
  788.             Xbminusd = xbIn - xdIn;
  789.             /* ya - yc */
  790.             Yaminusc = yaIn - ycIn;
  791.             /* (yb - yd) */
  792.             Ybminusd = ybIn - ydIn;
  793.  
  794.             /* xa + xc */
  795.             Xaplusc = xaIn + xcIn;
  796.             /* xb + xd */
  797.             Xbplusd = xbIn + xdIn;
  798.             /* ya + yc */
  799.             Yaplusc = yaIn + ycIn;
  800.             /* yb + yd */
  801.             Ybplusd = ybIn + ydIn;
  802.  
  803.             /* (xa - xc) - (yb - yd) */
  804.             Xb12C_out = (Xaminusc - Ybminusd);
  805.             /* (ya - yc) +  (xb - xd) */
  806.             Yb12C_out = (Yaminusc + Xbminusd);
  807.             /* xa + xc -(xb + xd) */
  808.             Xc12C_out = (Xaplusc - Xbplusd);
  809.             /* (ya + yc) - (yb + yd) */
  810.             Yc12C_out = (Yaplusc - Ybplusd);
  811.             /* (xa - xc) + (yb - yd) */
  812.             Xd12C_out = (Xaminusc + Ybminusd);
  813.             /* (ya - yc) -  (xb - xd) */
  814.             Yd12C_out = (Yaminusc - Xbminusd);
  815.  
  816.             pSrc[(2u * i0)] = Xaplusc + Xbplusd;
  817.             pSrc[(2u * i0) + 1u] = Yaplusc + Ybplusd;
  818.  
  819.             Xb12_out = Xb12C_out * co1;
  820.             Yb12_out = Yb12C_out * co1;
  821.             Xc12_out = Xc12C_out * co2;
  822.             Yc12_out = Yc12C_out * co2;
  823.             Xd12_out = Xd12C_out * co3;
  824.             Yd12_out = Yd12C_out * co3;
  825.  
  826.             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  827.             //Xb12_out -= Yb12C_out * si1;
  828.             p0 = Yb12C_out * si1;
  829.             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  830.             //Yb12_out += Xb12C_out * si1;
  831.             p1 = Xb12C_out * si1;
  832.             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  833.             //Xc12_out -= Yc12C_out * si2;
  834.             p2 = Yc12C_out * si2;
  835.             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  836.             //Yc12_out += Xc12C_out * si2;
  837.             p3 = Xc12C_out * si2;
  838.             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  839.             //Xd12_out -= Yd12C_out * si3;
  840.             p4 = Yd12C_out * si3;
  841.             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  842.             //Yd12_out += Xd12C_out * si3;
  843.             p5 = Xd12C_out * si3;
  844.            
  845.             Xb12_out -= p0;
  846.             Yb12_out += p1;
  847.             Xc12_out -= p2;
  848.             Yc12_out += p3;
  849.             Xd12_out -= p4;
  850.             Yd12_out += p5;
  851.  
  852.             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  853.             pSrc[2u * i1] = Xc12_out;
  854.  
  855.             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  856.             pSrc[(2u * i1) + 1u] = Yc12_out;
  857.  
  858.             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  859.             pSrc[2u * i2] = Xb12_out;
  860.  
  861.             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  862.             pSrc[(2u * i2) + 1u] = Yb12_out;
  863.  
  864.             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  865.             pSrc[2u * i3] = Xd12_out;
  866.  
  867.             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  868.             pSrc[(2u * i3) + 1u] = Yd12_out;
  869.  
  870.             i0 += n1;
  871.          } while(i0 < fftLen);
  872.          j++;
  873.       } while(j <= (n2 - 1u));
  874.       twidCoefModifier <<= 2u;
  875.    }
  876.    /*  Initializations of last stage */
  877.  
  878.    j = fftLen >> 2;
  879.    ptr1 = &pSrc[0];
  880.  
  881.    /*  Calculations of last stage */
  882.    do
  883.    {
  884.       xaIn = ptr1[0];
  885.       yaIn = ptr1[1];
  886.       xbIn = ptr1[2];
  887.       ybIn = ptr1[3];
  888.       xcIn = ptr1[4];
  889.       ycIn = ptr1[5];
  890.       xdIn = ptr1[6];
  891.       ydIn = ptr1[7];
  892.  
  893.       /*  Butterfly implementation */
  894.       /* xa + xc */
  895.       Xaplusc = xaIn + xcIn;
  896.  
  897.       /* xa - xc */
  898.       Xaminusc = xaIn - xcIn;
  899.  
  900.       /* ya + yc */
  901.       Yaplusc = yaIn + ycIn;
  902.  
  903.       /* ya - yc */
  904.       Yaminusc = yaIn - ycIn;
  905.  
  906.       /* xb + xd */
  907.       Xbplusd = xbIn + xdIn;
  908.  
  909.       /* yb + yd */
  910.       Ybplusd = ybIn + ydIn;
  911.  
  912.       /* (xb-xd) */
  913.       Xbminusd = xbIn - xdIn;
  914.  
  915.       /* (yb-yd) */
  916.       Ybminusd = ybIn - ydIn;
  917.      
  918.       /* xa' = (xa+xb+xc+xd) * onebyfftLen */
  919.       a0 = (Xaplusc + Xbplusd);
  920.       /* ya' = (ya+yb+yc+yd) * onebyfftLen */
  921.       a1 = (Yaplusc + Ybplusd);
  922.       /* xc' = (xa-xb+xc-xd) * onebyfftLen */
  923.       a2 = (Xaplusc - Xbplusd);
  924.       /* yc' = (ya-yb+yc-yd) * onebyfftLen  */
  925.       a3 = (Yaplusc - Ybplusd);
  926.       /* xb' = (xa-yb-xc+yd) * onebyfftLen */
  927.       a4 = (Xaminusc - Ybminusd);
  928.       /* yb' = (ya+xb-yc-xd) * onebyfftLen */
  929.       a5 = (Yaminusc + Xbminusd);
  930.       /* xd' = (xa-yb-xc+yd) * onebyfftLen */
  931.       a6 = (Xaminusc + Ybminusd);
  932.       /* yd' = (ya-xb-yc+xd) * onebyfftLen */
  933.       a7 = (Yaminusc - Xbminusd);
  934.    
  935.       p0 = a0 * onebyfftLen;
  936.       p1 = a1 * onebyfftLen;
  937.       p2 = a2 * onebyfftLen;
  938.       p3 = a3 * onebyfftLen;
  939.       p4 = a4 * onebyfftLen;
  940.       p5 = a5 * onebyfftLen;
  941.       p6 = a6 * onebyfftLen;
  942.       p7 = a7 * onebyfftLen;
  943.    
  944.       /* xa' = (xa+xb+xc+xd) * onebyfftLen */
  945.       ptr1[0] = p0;
  946.       /* ya' = (ya+yb+yc+yd) * onebyfftLen */
  947.       ptr1[1] = p1;
  948.       /* xc' = (xa-xb+xc-xd) * onebyfftLen */
  949.       ptr1[2] = p2;
  950.       /* yc' = (ya-yb+yc-yd) * onebyfftLen  */
  951.       ptr1[3] = p3;
  952.       /* xb' = (xa-yb-xc+yd) * onebyfftLen */
  953.       ptr1[4] = p4;
  954.       /* yb' = (ya+xb-yc-xd) * onebyfftLen */
  955.       ptr1[5] = p5;
  956.       /* xd' = (xa-yb-xc+yd) * onebyfftLen */
  957.       ptr1[6] = p6;
  958.       /* yd' = (ya-xb-yc+xd) * onebyfftLen */
  959.       ptr1[7] = p7;
  960.  
  961.       /* increment source pointer by 8 for next calculations */
  962.       ptr1 = ptr1 + 8u;
  963.  
  964.    } while(--j);
  965.  
  966. #else
  967.  
  968.    float32_t t1, t2, r1, r2, s1, s2;
  969.  
  970.    /* Run the below code for Cortex-M0 */
  971.  
  972.    /*  Initializations for the first stage */
  973.    n2 = fftLen;
  974.    n1 = n2;
  975.  
  976.    /*  Calculation of first stage */
  977.    for (k = fftLen; k > 4u; k >>= 2u)
  978.    {
  979.       /*  Initializations for the first stage */
  980.       n1 = n2;
  981.       n2 >>= 2u;
  982.       ia1 = 0u;
  983.  
  984.       /*  Calculation of first stage */
  985.       j = 0;
  986.       do
  987.       {
  988.          /*  index calculation for the coefficients */
  989.          ia2 = ia1 + ia1;
  990.          ia3 = ia2 + ia1;
  991.          co1 = pCoef[ia1 * 2u];
  992.          si1 = pCoef[(ia1 * 2u) + 1u];
  993.          co2 = pCoef[ia2 * 2u];
  994.          si2 = pCoef[(ia2 * 2u) + 1u];
  995.          co3 = pCoef[ia3 * 2u];
  996.          si3 = pCoef[(ia3 * 2u) + 1u];
  997.  
  998.          /*  Twiddle coefficients index modifier */
  999.          ia1 = ia1 + twidCoefModifier;
  1000.  
  1001.          i0 = j;
  1002.          do
  1003.          {
  1004.             /*  index calculation for the input as, */
  1005.             /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  1006.             i1 = i0 + n2;
  1007.             i2 = i1 + n2;
  1008.             i3 = i2 + n2;
  1009.  
  1010.             /* xa + xc */
  1011.             r1 = pSrc[(2u * i0)] + pSrc[(2u * i2)];
  1012.  
  1013.             /* xa - xc */
  1014.             r2 = pSrc[(2u * i0)] - pSrc[(2u * i2)];
  1015.  
  1016.             /* ya + yc */
  1017.             s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
  1018.  
  1019.             /* ya - yc */
  1020.             s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
  1021.  
  1022.             /* xb + xd */
  1023.             t1 = pSrc[2u * i1] + pSrc[2u * i3];
  1024.  
  1025.             /* xa' = xa + xb + xc + xd */
  1026.             pSrc[2u * i0] = r1 + t1;
  1027.  
  1028.             /* xa + xc -(xb + xd) */
  1029.             r1 = r1 - t1;
  1030.  
  1031.             /* yb + yd */
  1032.             t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
  1033.  
  1034.             /* ya' = ya + yb + yc + yd */
  1035.             pSrc[(2u * i0) + 1u] = s1 + t2;
  1036.  
  1037.             /* (ya + yc) - (yb + yd) */
  1038.             s1 = s1 - t2;
  1039.  
  1040.             /* (yb - yd) */
  1041.             t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
  1042.  
  1043.             /* (xb - xd) */
  1044.             t2 = pSrc[2u * i1] - pSrc[2u * i3];
  1045.  
  1046.             /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  1047.             pSrc[2u * i1] = (r1 * co2) - (s1 * si2);
  1048.  
  1049.             /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  1050.             pSrc[(2u * i1) + 1u] = (s1 * co2) + (r1 * si2);
  1051.  
  1052.             /* (xa - xc) - (yb - yd) */
  1053.             r1 = r2 - t1;
  1054.  
  1055.             /* (xa - xc) + (yb - yd) */
  1056.             r2 = r2 + t1;
  1057.  
  1058.             /* (ya - yc) +  (xb - xd) */
  1059.             s1 = s2 + t2;
  1060.  
  1061.             /* (ya - yc) -  (xb - xd) */
  1062.             s2 = s2 - t2;
  1063.  
  1064.             /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  1065.             pSrc[2u * i2] = (r1 * co1) - (s1 * si1);
  1066.  
  1067.             /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  1068.             pSrc[(2u * i2) + 1u] = (s1 * co1) + (r1 * si1);
  1069.  
  1070.             /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  1071.             pSrc[2u * i3] = (r2 * co3) - (s2 * si3);
  1072.  
  1073.             /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  1074.             pSrc[(2u * i3) + 1u] = (s2 * co3) + (r2 * si3);
  1075.          
  1076.             i0 += n1;
  1077.          } while( i0 < fftLen);
  1078.          j++;
  1079.       } while(j <= (n2 - 1u));
  1080.       twidCoefModifier <<= 2u;
  1081.    }
  1082.    /*  Initializations of last stage */
  1083.    n1 = n2;
  1084.    n2 >>= 2u;
  1085.  
  1086.    /*  Calculations of last stage */
  1087.    for (i0 = 0u; i0 <= (fftLen - n1); i0 += n1)
  1088.    {
  1089.       /*  index calculation for the input as, */
  1090.       /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
  1091.       i1 = i0 + n2;
  1092.       i2 = i1 + n2;
  1093.       i3 = i2 + n2;
  1094.  
  1095.       /*  Butterfly implementation */
  1096.       /* xa + xc */
  1097.       r1 = pSrc[2u * i0] + pSrc[2u * i2];
  1098.  
  1099.       /* xa - xc */
  1100.       r2 = pSrc[2u * i0] - pSrc[2u * i2];
  1101.  
  1102.       /* ya + yc */
  1103.       s1 = pSrc[(2u * i0) + 1u] + pSrc[(2u * i2) + 1u];
  1104.  
  1105.       /* ya - yc */
  1106.       s2 = pSrc[(2u * i0) + 1u] - pSrc[(2u * i2) + 1u];
  1107.  
  1108.       /* xc + xd */
  1109.       t1 = pSrc[2u * i1] + pSrc[2u * i3];
  1110.  
  1111.       /* xa' = xa + xb + xc + xd */
  1112.       pSrc[2u * i0] = (r1 + t1) * onebyfftLen;
  1113.  
  1114.       /* (xa + xb) - (xc + xd) */
  1115.       r1 = r1 - t1;
  1116.  
  1117.       /* yb + yd */
  1118.       t2 = pSrc[(2u * i1) + 1u] + pSrc[(2u * i3) + 1u];
  1119.  
  1120.       /* ya' = ya + yb + yc + yd */
  1121.       pSrc[(2u * i0) + 1u] = (s1 + t2) * onebyfftLen;
  1122.  
  1123.       /* (ya + yc) - (yb + yd) */
  1124.       s1 = s1 - t2;
  1125.  
  1126.       /* (yb-yd) */
  1127.       t1 = pSrc[(2u * i1) + 1u] - pSrc[(2u * i3) + 1u];
  1128.  
  1129.       /* (xb-xd) */
  1130.       t2 = pSrc[2u * i1] - pSrc[2u * i3];
  1131.  
  1132.       /* xc' = (xa-xb+xc-xd)co2 - (ya-yb+yc-yd)(si2) */
  1133.       pSrc[2u * i1] = r1 * onebyfftLen;
  1134.  
  1135.       /* yc' = (ya-yb+yc-yd)co2 + (xa-xb+xc-xd)(si2) */
  1136.       pSrc[(2u * i1) + 1u] = s1 * onebyfftLen;
  1137.  
  1138.       /* (xa - xc) - (yb-yd) */
  1139.       r1 = r2 - t1;
  1140.  
  1141.       /* (xa - xc) + (yb-yd) */
  1142.       r2 = r2 + t1;
  1143.  
  1144.       /* (ya - yc) + (xb-xd) */
  1145.       s1 = s2 + t2;
  1146.  
  1147.       /* (ya - yc) - (xb-xd) */
  1148.       s2 = s2 - t2;
  1149.  
  1150.       /* xb' = (xa+yb-xc-yd)co1 - (ya-xb-yc+xd)(si1) */
  1151.       pSrc[2u * i2] = r1 * onebyfftLen;
  1152.  
  1153.       /* yb' = (ya-xb-yc+xd)co1 + (xa+yb-xc-yd)(si1) */
  1154.       pSrc[(2u * i2) + 1u] = s1 * onebyfftLen;
  1155.  
  1156.       /* xd' = (xa-yb-xc+yd)co3 - (ya+xb-yc-xd)(si3) */
  1157.       pSrc[2u * i3] = r2 * onebyfftLen;
  1158.  
  1159.       /* yd' = (ya+xb-yc-xd)co3 + (xa-yb-xc+yd)(si3) */
  1160.       pSrc[(2u * i3) + 1u] = s2 * onebyfftLen;
  1161.    }
  1162.  
  1163. #endif /* #ifndef ARM_MATH_CM0_FAMILY_FAMILY */
  1164. }
  1165.  
  1166. /**    
  1167. * @addtogroup ComplexFFT    
  1168. * @{    
  1169. */
  1170.  
  1171. /**    
  1172. * @details    
  1173. * @brief Processing function for the floating-point Radix-4 CFFT/CIFFT.  
  1174. * @deprecated Do not use this function.  It has been superseded by \ref arm_cfft_f32 and will be removed
  1175. * in the future.
  1176. * @param[in]      *S    points to an instance of the floating-point Radix-4 CFFT/CIFFT structure.  
  1177. * @param[in, out] *pSrc points to the complex data buffer of size <code>2*fftLen</code>. Processing occurs in-place.  
  1178. * @return none.  
  1179. */
  1180.  
  1181. void arm_cfft_radix4_f32(
  1182. const arm_cfft_radix4_instance_f32 * S,
  1183. float32_t * pSrc)
  1184. {
  1185.  
  1186.    if(S->ifftFlag == 1u)
  1187.    {
  1188.       /*  Complex IFFT radix-4  */
  1189.       arm_radix4_butterfly_inverse_f32(pSrc, S->fftLen, S->pTwiddle,
  1190.       S->twidCoefModifier, S->onebyfftLen);
  1191.    }
  1192.    else
  1193.    {
  1194.       /*  Complex FFT radix-4  */
  1195.       arm_radix4_butterfly_f32(pSrc, S->fftLen, S->pTwiddle,
  1196.       S->twidCoefModifier);
  1197.    }
  1198.  
  1199.    if(S->bitReverseFlag == 1u)
  1200.    {
  1201.       /*  Bit Reversal */
  1202.       arm_bitreversal_f32(pSrc, S->fftLen, S->bitRevFactor, S->pBitRevTable);
  1203.    }
  1204.  
  1205. }
  1206.  
  1207. /**    
  1208. * @} end of ComplexFFT group    
  1209. */
  1210.  
  1211.