dspf_sp_ifftspxsp.h

详细的OFDM设计过程

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      DSPF_sp_ifftSPxSP -- Single Precision floating point mixed radix    */
/*      inverse FFT with complex input                                      */
/*                                                                          */
/*  USAGE                                                                   */
/*          This routine is C-callable and can be called as:                */
/*                                                                          */
/*          void DSPF_sp_ifftSPxSP(                                         */
/*              int n, float * ptr_x, float * ptr_w, float * ptr_y,         */
/*              unsigned char * brev, int n_min, int offset, int n_max);    */
/*                                                                          */
/*      n   : Length of ifft in complex samples, power of 2 such that       */
/*             n >=8 and n <= 16384.                                        */
/*    ptr_x : Pointer to complex data input (normal order)                  */
/*    ptr_w : Pointer to complex twiddle factor (see below)                 */
/*    ptr_y : Pointer to complex output data (normal order)                 */
/*    brev  : Pointer to bit reverse table containing 64 entries            */
/*    n_min : Smallest ifft butterfly used in computation                   */
/*            used for decomposing ifft into subiffts, see notes            */
/*    offset: Index in complex samples of sub-ifft from start of            */
/*                   main ifft                                              */
/*    n_max : Size of main ifft in complex samples                          */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*                                                                          */
/*         The benchmark performs a mixed radix forwards ifft using         */
/*         a special sequence of coefficients generated in the following    */
/*         way:                                                             */
/*                                                                          */
/*         //generate vector of twiddle factors for optimized algorithm//   */
/*          void tw_gen(float * w, int N)                                   */
/*          {                                                               */
/*            int j, k;                                                     */
/*            double x_t, y_t, theta1, theta2, theta3;                      */
/*            const double PI = 3.141592654;                                */
/*                                                                          */
/*            for (j=1, k=0; j <= N>>2; j = j<<2)                           */
/*            {                                                             */
/*                for (i=0; i < N>>2; i+=j)                                 */
/*                {                                                         */
/*                    theta1 = 2*PI*i/N;                                    */
/*                    x_t = cos(theta1);                                    */
/*                    y_t = sin(theta1);                                    */
/*                    w[k]   =  (float)x_t;                                 */
/*                    w[k+1] =  (float)y_t;                                 */
/*                                                                          */
/*                    theta2 = 4*PI*i/N;                                    */
/*                    x_t = cos(theta2);                                    */
/*                    y_t = sin(theta2);                                    */
/*                    w[k+2] =  (float)x_t;                                 */
/*                    w[k+3] =  (float)y_t;                                 */
/*                                                                          */
/*                    theta3 = 6*PI*i/N;                                    */
/*                    x_t = cos(theta3);                                    */
/*                    y_t = sin(theta3);                                    */
/*                    w[k+4] =  (float)x_t;                                 */
/*                    w[k+5] =  (float)y_t;                                 */
/*                    k+=6;                                                 */
/*                }                                                         */
/*            }                                                             */
/*          }                                                               */
/*        This redundant set of twiddle factors is size 2*N float samples.  */
/*        The function is accurate to about 130dB of signal to noise ratio  */
/*        to the IDFT function below:                                       */
/*                                                                          */
/*          void idft(int n, float x[], float y[])                          */
/*          {                                                               */
/*            int k,i, index;                                               */
/*            const float PI = 3.14159654;                                  */
/*            float * p_x;                                                  */
/*            float arg, fx_0, fx_1, fy_0, fy_1, co, si;                    */
/*                                                                          */
/*            for(k = 0; k<n; k++)                                          */
/*            {                                                             */
/*              p_x = x;                                                    */
/*              fy_0 = 0;                                                   */
/*              fy_1 = 0;                                                   */
/*              for(i=0; i<n; i++)                                          */
/*              {                                                           */
/*                fx_0 = p_x[0];                                            */
/*                fx_1 = p_x[1];                                            */
/*                p_x += 2;                                                 */
/*                index = (i*k) % n;                                        */
/*                arg = 2*PI*index/n;                                       */
/*                co = cos(arg);                                            */
/*                si = sin(arg);                                            */
/*                fy_0 += ((fx_0 * co) - (fx_1 * si));                      */
/*                fy_1 += ((fx_1 * co) + (fx_0 * si));                      */
/*              }                                                           */
/*              y[2*k] = fy_0/n;                                            */
/*              y[2*k+1] = fy_1/n;                                          */
/*            }                                                             */
/*         }                                                                */
/*                                                                          */
/*         The function takes the table and input data and calculates the   */
/*         ifft producing the frequency domain data in the Y array. the     */
/*         output is scaled by a scaling factor of 1/N.                     */
/*                                                                          */
/*         As the ifft allows every input point to effect every output      */
/*         point in a cache based system such as the c6711, this causes     */