Subversion Repositories canSerial

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. #include "ref.h"
  2. #include "arm_const_structs.h"
  3.          
  4. void ref_cfft_f32(
  5.    const arm_cfft_instance_f32 * S,
  6.    float32_t * p1,
  7.    uint8_t ifftFlag,
  8.    uint8_t bitReverseFlag)
  9. {
  10.         int n, mmax, m, j, istep, i;
  11.         float32_t wtemp, wr, wpr, wpi, wi, theta;
  12.         float32_t tempr, tempi;
  13.         float32_t *  data = p1;
  14.         uint32_t N = S->fftLen;
  15.         int32_t dir = (ifftFlag) ? -1 : 1;
  16.  
  17.         // decrement pointer since the original version used fortran style indexing.
  18.         data--;
  19.  
  20.         n = N << 1;
  21.         j = 1;
  22.         for (i = 1; i < n; i += 2) {
  23.                 if (j > i) {
  24.                         tempr = data[j];     data[j] = data[i];     data[i] = tempr;
  25.                         tempr = data[j+1]; data[j+1] = data[i+1]; data[i+1] = tempr;
  26.                 }
  27.                 m = n >> 1;
  28.                 while (m >= 2 && j > m) {
  29.                         j -= m;
  30.                         m >>= 1;
  31.                 }
  32.                 j += m;
  33.         }
  34.         mmax = 2;
  35.         while (n > mmax) {
  36.                 istep = 2*mmax;
  37.                 theta = -6.283185307179586f/(dir*mmax);
  38.                 wtemp = sinf(0.5f*theta);
  39.                 wpr = -2.0f*wtemp*wtemp;
  40.                 wpi = sinf(theta);
  41.                 wr = 1.0f;
  42.                 wi = 0.0f;
  43.                 for (m = 1; m < mmax; m += 2) {
  44.                         for (i = m; i <= n; i += istep) {
  45.                                 j =i + mmax;
  46.                                 tempr = wr*data[j]   - wi*data[j+1];
  47.                                 tempi = wr*data[j+1] + wi*data[j];
  48.                                 data[j]   = data[i]   - tempr;
  49.                                 data[j+1] = data[i+1] - tempi;
  50.                                 data[i] += tempr;
  51.                                 data[i+1] += tempi;
  52.                         }
  53.                         wr = (wtemp = wr)*wpr - wi*wpi + wr;
  54.                         wi = wi*wpr + wtemp*wpi + wi;
  55.                 }
  56.                 mmax = istep;
  57.         }
  58.  
  59.         // Inverse transform is scaled by 1/N
  60.         if (ifftFlag)
  61.         {
  62.                 data++;
  63.                 for(i = 0; i<2*N; i++)
  64.                 {
  65.                         data[i] /= N;
  66.                 }
  67.         }
  68. }
  69.  
  70. void ref_cfft_q31(
  71.         const arm_cfft_instance_q31 * S,
  72.     q31_t * p1,
  73.     uint8_t ifftFlag,
  74.     uint8_t bitReverseFlag)
  75. {
  76.         uint32_t i;
  77.         float32_t *fSrc = (float32_t*)p1;
  78.        
  79.         for(i=0;i<S->fftLen*2;i++)
  80.         {
  81.                 //read the q31 data, cast to float, scale down for float
  82.                 fSrc[i] = (float32_t)p1[i] / 2147483648.0f;
  83.         }
  84.        
  85.         switch(S->fftLen)
  86.         {
  87.    case 16:
  88.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
  89.                  break;
  90.    
  91.    case 32:
  92.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
  93.                  break;
  94.    
  95.    case 64:
  96.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
  97.                  break;
  98.    
  99.    case 128:
  100.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
  101.                  break;
  102.    
  103.    case 256:
  104.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
  105.                  break;
  106.    
  107.    case 512:
  108.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
  109.                  break;
  110.    
  111.    case 1024:
  112.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
  113.                  break;
  114.    
  115.    case 2048:
  116.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
  117.                  break;
  118.    
  119.    case 4096:
  120.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
  121.                  break;
  122.         }
  123.        
  124.         if (ifftFlag)
  125.         {
  126.                 for(i=0;i<S->fftLen*2;i++)
  127.                 {
  128.                         //read the float data, scale up for q31, cast to q31
  129.                         p1[i] = (q31_t)( fSrc[i] * 2147483648.0f );
  130.                 }
  131.         }
  132.         else
  133.         {
  134.                 for(i=0;i<S->fftLen*2;i++)
  135.                 {
  136.                         //read the float data, scale up for q31, cast to q31
  137.                         p1[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
  138.                 }
  139.         }
  140. }
  141.  
  142. void ref_cfft_q15(
  143.         const arm_cfft_instance_q15 * S,
  144.     q15_t * pSrc,
  145.     uint8_t ifftFlag,
  146.     uint8_t bitReverseFlag)
  147. {
  148.         uint32_t i;
  149.         float32_t *fSrc = (float32_t*)pSrc;
  150.        
  151.         for(i=0;i<S->fftLen*2;i++)
  152.         {
  153.                 //read the q15 data, cast to float, scale down for float, place in temporary buffer
  154.                 scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
  155.         }
  156.        
  157.         for(i=0;i<S->fftLen*2;i++)
  158.         {
  159.                 //copy from temp buffer to final buffer
  160.                 fSrc[i] = scratchArray[i];
  161.         }
  162.        
  163.         switch(S->fftLen)
  164.         {
  165.    case 16:
  166.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
  167.                  break;
  168.    
  169.    case 32:
  170.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
  171.                  break;
  172.    
  173.    case 64:
  174.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
  175.                  break;
  176.    
  177.    case 128:
  178.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
  179.                  break;
  180.    
  181.    case 256:
  182.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
  183.                  break;
  184.    
  185.    case 512:
  186.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
  187.                  break;
  188.    
  189.    case 1024:
  190.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
  191.                  break;
  192.    
  193.    case 2048:
  194.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
  195.                  break;
  196.    
  197.    case 4096:
  198.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
  199.                  break;
  200.         }
  201.        
  202.         if (ifftFlag)
  203.         {
  204.                 for(i=0;i<S->fftLen*2;i++)
  205.                 {
  206.                         //read the float data, scale up for q15, cast to q15
  207.                         pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
  208.                 }
  209.         }
  210.         else
  211.         {
  212.                 for(i=0;i<S->fftLen*2;i++)
  213.                 {
  214.                         //read the float data, scale up for q15, cast to q15
  215.                         pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
  216.                 }
  217.         }
  218. }
  219.  
  220. void ref_cfft_radix2_f32(
  221.         const arm_cfft_radix2_instance_f32 * S,
  222.         float32_t * pSrc)
  223. {
  224.         switch(S->fftLen)
  225.         {
  226.    case 16:
  227.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
  228.                  break;
  229.    
  230.    case 32:
  231.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
  232.                  break;
  233.    
  234.    case 64:
  235.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
  236.                  break;
  237.    
  238.    case 128:
  239.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
  240.                  break;
  241.    
  242.    case 256:
  243.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
  244.                  break;
  245.    
  246.    case 512:
  247.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
  248.                  break;
  249.    
  250.    case 1024:
  251.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
  252.                  break;
  253.    
  254.    case 2048:
  255.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
  256.                  break;
  257.    
  258.    case 4096:
  259.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
  260.                  break;
  261.         }
  262. }
  263.  
  264. void ref_cfft_radix2_q31(
  265.         const arm_cfft_radix2_instance_q31 * S,
  266.         q31_t * pSrc)
  267. {
  268.         uint32_t i;
  269.         float32_t *fSrc = (float32_t*)pSrc;
  270.        
  271.         for(i=0;i<S->fftLen*2;i++)
  272.         {
  273.                 //read the q31 data, cast to float, scale down for float
  274.                 fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
  275.         }
  276.        
  277.         switch(S->fftLen)
  278.         {
  279.    case 16:
  280.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
  281.                  break;
  282.    
  283.    case 32:
  284.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
  285.                  break;
  286.    
  287.    case 64:
  288.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
  289.                  break;
  290.    
  291.    case 128:
  292.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
  293.                  break;
  294.    
  295.    case 256:
  296.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
  297.                  break;
  298.    
  299.    case 512:
  300.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
  301.                  break;
  302.    
  303.    case 1024:
  304.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
  305.                  break;
  306.    
  307.    case 2048:
  308.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
  309.                  break;
  310.    
  311.    case 4096:
  312.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
  313.                  break;
  314.         }
  315.        
  316.         if (S->ifftFlag)
  317.         {
  318.                 for(i=0;i<S->fftLen*2;i++)
  319.                 {
  320.                         //read the float data, scale up for q31, cast to q31
  321.                         pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
  322.                 }
  323.         }
  324.         else
  325.         {
  326.                 for(i=0;i<S->fftLen*2;i++)
  327.                 {
  328.                         //read the float data, scale up for q31, cast to q31
  329.                         pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
  330.                 }
  331.         }
  332. }
  333.  
  334. void ref_cfft_radix2_q15(
  335.         const arm_cfft_radix2_instance_q15 * S,
  336.         q15_t * pSrc)
  337. {
  338.         uint32_t i;
  339.         float32_t *fSrc = (float32_t*)pSrc;
  340.        
  341.         for(i=0;i<S->fftLen*2;i++)
  342.         {
  343.                 //read the q15 data, cast to float, scale down for float, place in temporary buffer
  344.                 scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
  345.         }
  346.        
  347.         for(i=0;i<S->fftLen*2;i++)
  348.         {
  349.                 //copy from temp buffer to final buffer
  350.                 fSrc[i] = scratchArray[i];
  351.         }
  352.        
  353.         switch(S->fftLen)
  354.         {
  355.    case 16:
  356.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
  357.                  break;
  358.    
  359.    case 32:
  360.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
  361.                  break;
  362.    
  363.    case 64:
  364.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
  365.                  break;
  366.    
  367.    case 128:
  368.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
  369.                  break;
  370.    
  371.    case 256:
  372.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
  373.                  break;
  374.    
  375.    case 512:
  376.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
  377.                  break;
  378.    
  379.    case 1024:
  380.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
  381.                  break;
  382.    
  383.    case 2048:
  384.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
  385.                  break;
  386.    
  387.    case 4096:
  388.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
  389.                  break;
  390.         }
  391.        
  392.         if (S->ifftFlag)
  393.         {
  394.                 for(i=0;i<S->fftLen*2;i++)
  395.                 {
  396.                 //read the float data, scale up for q15, cast to q15
  397.                 pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
  398.                 }
  399.         }
  400.         else
  401.         {
  402.                 for(i=0;i<S->fftLen*2;i++)
  403.                 {
  404.                 //read the float data, scale up for q15, cast to q15
  405.                 pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
  406.                 }
  407.         }
  408. }
  409.  
  410. void ref_cfft_radix4_f32(
  411.         const arm_cfft_radix4_instance_f32 * S,
  412.         float32_t * pSrc)
  413. {              
  414.         switch(S->fftLen)
  415.         {
  416.    case 16:
  417.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
  418.                  break;
  419.    
  420.    case 32:
  421.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
  422.                  break;
  423.    
  424.    case 64:
  425.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
  426.                  break;
  427.    
  428.    case 128:
  429.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
  430.                  break;
  431.    
  432.    case 256:
  433.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
  434.                  break;
  435.    
  436.    case 512:
  437.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
  438.                  break;
  439.    
  440.    case 1024:
  441.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
  442.                  break;
  443.    
  444.    case 2048:
  445.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
  446.                  break;
  447.    
  448.    case 4096:
  449.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
  450.                  break;
  451.         }
  452. }
  453.  
  454. void ref_cfft_radix4_q31(
  455.         const arm_cfft_radix4_instance_q31 * S,
  456.         q31_t * pSrc)
  457. {
  458.         uint32_t i;
  459.         float32_t *fSrc = (float32_t*)pSrc;
  460.        
  461.         for(i=0;i<S->fftLen*2;i++)
  462.         {
  463.                 //read the q31 data, cast to float, scale down for float
  464.                 fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
  465.         }
  466.        
  467.         switch(S->fftLen)
  468.         {
  469.    case 16:
  470.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
  471.                  break;
  472.    
  473.    case 32:
  474.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
  475.                  break;
  476.    
  477.    case 64:
  478.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
  479.                  break;
  480.    
  481.    case 128:
  482.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
  483.                  break;
  484.    
  485.    case 256:
  486.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
  487.                  break;
  488.    
  489.    case 512:
  490.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
  491.                  break;
  492.    
  493.    case 1024:
  494.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
  495.                  break;
  496.    
  497.    case 2048:
  498.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
  499.                  break;
  500.    
  501.    case 4096:
  502.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
  503.                  break;
  504.         }
  505.        
  506.         if (S->ifftFlag)
  507.         {
  508.                 for(i=0;i<S->fftLen*2;i++)
  509.                 {
  510.                         //read the float data, scale up for q31, cast to q31
  511.                         pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
  512.                 }
  513.         }
  514.         else
  515.         {
  516.                 for(i=0;i<S->fftLen*2;i++)
  517.                 {
  518.                         //read the float data, scale up for q31, cast to q31
  519.                         pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
  520.                 }
  521.         }
  522. }
  523.  
  524. void ref_cfft_radix4_q15(
  525.         const arm_cfft_radix4_instance_q15 * S,
  526.         q15_t * pSrc)
  527. {
  528.         uint32_t i;
  529.         float32_t *fSrc = (float32_t*)pSrc;
  530.        
  531.         for(i=0;i<S->fftLen*2;i++)
  532.         {
  533.                 //read the q15 data, cast to float, scale down for float, place in temporary buffer
  534.                 scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
  535.         }
  536.        
  537.         for(i=0;i<S->fftLen*2;i++)
  538.         {
  539.                 //copy from temp buffer to final buffer
  540.                 fSrc[i] = scratchArray[i];
  541.         }
  542.        
  543.         switch(S->fftLen)
  544.         {
  545.    case 16:
  546.                  ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
  547.                  break;
  548.    
  549.    case 32:
  550.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
  551.                  break;
  552.    
  553.    case 64:
  554.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
  555.                  break;
  556.    
  557.    case 128:
  558.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
  559.                  break;
  560.    
  561.    case 256:
  562.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
  563.                  break;
  564.    
  565.    case 512:
  566.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
  567.                  break;
  568.    
  569.    case 1024:
  570.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
  571.                  break;
  572.    
  573.    case 2048:
  574.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
  575.                  break;
  576.    
  577.    case 4096:
  578.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
  579.                  break;
  580.         }
  581.        
  582.         if (S->ifftFlag)
  583.         {
  584.                 for(i=0;i<S->fftLen*2;i++)
  585.                 {
  586.                 //read the float data, scale up for q15, cast to q15
  587.                 pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
  588.                 }
  589.         }
  590.         else
  591.         {
  592.                 for(i=0;i<S->fftLen*2;i++)
  593.                 {
  594.                 //read the float data, scale up for q15, cast to q15
  595.                 pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
  596.                 }
  597.         }
  598. }
  599.