Subversion Repositories AFRtranscoder

Rev

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

  1. #include "ref.h"       
  2. #include "arm_const_structs.h"
  3.        
  4. void ref_rfft_f32(
  5.         arm_rfft_instance_f32 * S,
  6.   float32_t * pSrc,
  7.   float32_t * pDst)
  8. {
  9.         uint32_t i;
  10.        
  11.         if (S->ifftFlagR)
  12.         {
  13.                 for(i=0;i<S->fftLenReal*2;i++)
  14.                 {
  15.                         pDst[i] = pSrc[i];
  16.                 }
  17.         }
  18.         else
  19.         {
  20.                 for(i=0;i<S->fftLenReal;i++)
  21.                 {
  22.                         pDst[2*i+0] = pSrc[i];
  23.                         pDst[2*i+1] = 0.0f;
  24.                 }
  25.         }
  26.        
  27.         switch(S->fftLenReal)
  28.         {  
  29.    case 128:
  30.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, pDst, S->ifftFlagR, S->bitReverseFlagR);
  31.                  break;
  32.    
  33.    case 512:
  34.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, pDst, S->ifftFlagR, S->bitReverseFlagR);
  35.                  break;
  36.    
  37.    case 2048:
  38.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, pDst, S->ifftFlagR, S->bitReverseFlagR);
  39.                  break;
  40.    
  41.    case 8192:
  42.                  ref_cfft_f32(&ref_cfft_sR_f32_len8192, pDst, S->ifftFlagR, S->bitReverseFlagR);
  43.                  break;
  44.         }
  45.        
  46.         if (S->ifftFlagR)
  47.         {
  48.                 //throw away the imaginary part which should be all zeros
  49.                 for(i=0;i<S->fftLenReal;i++)
  50.                 {
  51.                         pDst[i] = pDst[2*i];
  52.                 }
  53.         }
  54. }
  55.        
  56. void ref_rfft_fast_f32(
  57.         arm_rfft_fast_instance_f32 * S,
  58.         float32_t * p, float32_t * pOut,
  59.         uint8_t ifftFlag)
  60. {
  61.         uint32_t i,j;
  62.        
  63.         if (ifftFlag)
  64.         {
  65.                 for(i=0;i<S->fftLenRFFT;i++)
  66.                 {
  67.                         pOut[i] = p[i];
  68.                 }
  69.                 //unpack first sample's complex part into middle sample's real part
  70.                 pOut[S->fftLenRFFT] = pOut[1];
  71.                 pOut[S->fftLenRFFT+1] = 0;
  72.                 pOut[1] = 0;
  73.                 j=4;
  74.                 for(i = S->fftLenRFFT / 2 + 1;i < S->fftLenRFFT;i++)
  75.                 {
  76.                         pOut[2*i+0] = p[2*i+0 - j];
  77.                         pOut[2*i+1] = -p[2*i+1 - j];
  78.                         j+=4;
  79.                 }
  80.         }
  81.         else
  82.         {
  83.                 for(i=0;i<S->fftLenRFFT;i++)
  84.                 {
  85.                         pOut[2*i+0] = p[i];
  86.                         pOut[2*i+1] = 0.0f;
  87.                 }
  88.         }
  89.        
  90.         switch(S->fftLenRFFT)
  91.         {  
  92.    case 32:
  93.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, pOut, ifftFlag, 1);
  94.                  break;
  95.    
  96.    case 64:
  97.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, pOut, ifftFlag, 1);
  98.                  break;
  99.    
  100.    case 128:
  101.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, pOut, ifftFlag, 1);
  102.                  break;
  103.    
  104.    case 256:
  105.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, pOut, ifftFlag, 1);
  106.                  break;
  107.    
  108.    case 512:
  109.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, pOut, ifftFlag, 1);
  110.                  break;
  111.    
  112.    case 1024:
  113.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, pOut, ifftFlag, 1);
  114.                  break;
  115.    
  116.    case 2048:
  117.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, pOut, ifftFlag, 1);
  118.                  break;
  119.    
  120.    case 4096:
  121.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, pOut, ifftFlag, 1);
  122.                  break;
  123.         }
  124.        
  125.         if (ifftFlag)
  126.         {
  127.                 //throw away the imaginary part which should be all zeros
  128.                 for(i=0;i<S->fftLenRFFT;i++)
  129.                 {
  130.                         pOut[i] = pOut[2*i];
  131.                 }
  132.         }
  133.         else
  134.         {
  135.                 //pack last sample's real part into first sample's complex part
  136.                 pOut[1] = pOut[S->fftLenRFFT];
  137.         }
  138. }
  139.        
  140. void ref_rfft_q31(
  141.   const arm_rfft_instance_q31 * S,
  142.   q31_t * pSrc,
  143.   q31_t * pDst)
  144. {
  145.         uint32_t i;
  146.         float32_t *fDst = (float32_t*)pDst;
  147.        
  148.         if (S->ifftFlagR)
  149.         {
  150.                 for(i=0;i<S->fftLenReal*2;i++)
  151.                 {
  152.                         fDst[i] = (float32_t)pSrc[i] / 2147483648.0f;
  153.                 }
  154.         }
  155.         else
  156.         {
  157.                 for(i=0;i<S->fftLenReal;i++)
  158.                 {
  159.                         fDst[2*i+0] = (float32_t)pSrc[i] / 2147483648.0f;
  160.                         fDst[2*i+1] = 0.0f;
  161.                 }
  162.         }
  163.        
  164.         switch(S->fftLenReal)
  165.         {
  166.    case 32:
  167.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
  168.                  break;
  169.          
  170.    case 64:
  171.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
  172.                  break;
  173.          
  174.    case 128:
  175.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
  176.                  break;
  177.          
  178.    case 256:
  179.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
  180.                  break;
  181.          
  182.    case 512:
  183.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
  184.                  break;
  185.          
  186.    case 1024:
  187.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
  188.                  break;
  189.    
  190.    case 2048:
  191.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
  192.                  break;
  193.    
  194.    case 4096:
  195.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
  196.                  break;
  197.    
  198.    case 8192:
  199.                  ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
  200.                  break;
  201.         }
  202.        
  203.         if (S->ifftFlagR)
  204.         {
  205.                 //throw away the imaginary part which should be all zeros              
  206.                 for(i=0;i<S->fftLenReal;i++)
  207.                 {
  208.                         //read the float data, scale up for q31, cast to q31
  209.                         pDst[i] = (q31_t)( fDst[2*i] * 2147483648.0f);
  210.                 }
  211.         }
  212.         else
  213.         {
  214.                 for(i=0;i<S->fftLenReal;i++)
  215.                 {
  216.                         //read the float data, scale up for q31, cast to q31
  217.                         pDst[i] = (q31_t)( fDst[i] * 2147483648.0f / (float32_t)S->fftLenReal);
  218.                 }
  219.         }
  220. }
  221.  
  222. void ref_rfft_q15(
  223.   const arm_rfft_instance_q15 * S,
  224.   q15_t * pSrc,
  225.   q15_t * pDst)
  226. {
  227.         uint32_t i;
  228.         float32_t *fDst = (float32_t*)pDst;
  229.        
  230.        
  231.         if (S->ifftFlagR)
  232.         {
  233.                 for(i=0;i<S->fftLenReal*2;i++)
  234.                 {
  235.                         fDst[i] = (float32_t)pSrc[i] / 32768.0f;
  236.                 }
  237.         }
  238.         else
  239.         {
  240.                 for(i=0;i<S->fftLenReal;i++)
  241.                 {
  242.                         //read the q15 data, cast to float, scale down for float
  243.                         fDst[2*i+0] = (float32_t)pSrc[i] / 32768.0f;
  244.                         fDst[2*i+1] = 0.0f;
  245.                 }
  246.         }
  247.        
  248.         switch(S->fftLenReal)
  249.         {  
  250.    case 32:
  251.                  ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
  252.                  break;
  253.          
  254.    case 64:
  255.                  ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
  256.                  break;
  257.          
  258.    case 128:
  259.                  ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
  260.                  break;
  261.          
  262.    case 256:
  263.                  ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
  264.                  break;
  265.          
  266.    case 512:
  267.                  ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
  268.                  break;
  269.          
  270.    case 1024:
  271.                  ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
  272.                  break;
  273.    
  274.    case 2048:
  275.                  ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
  276.                  break;
  277.    
  278.    case 4096:
  279.                  ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
  280.                  break;
  281.    
  282.    case 8192:
  283.                  ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
  284.                  break;
  285.         }
  286.        
  287.         if (S->ifftFlagR)
  288.         {
  289.                 //throw away the imaginary part which should be all zeros
  290.                 for(i=0;i<S->fftLenReal;i++)
  291.                 {
  292.                         pDst[i] = (q15_t)( fDst[2*i] * 32768.0f);
  293.                 }
  294.         }
  295.         else
  296.         {
  297.                 for(i=0;i<S->fftLenReal;i++)
  298.                 {
  299.                         pDst[i] = (q15_t)( fDst[i] * 32768.0f / (float32_t)S->fftLenReal);
  300.                 }
  301.         }
  302. }
  303.