dspf_sp_icfftr2_dif.h

详细的OFDM设计过程

/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      DSPF_sp_icfftr2_dif -- Radix-2 DIF Inverse FFT with complex inputs  */
/*                                                                          */
/*  USAGE                                                                   */
/*         This routine is C-callable and can be called as:                 */
/*                                                                          */
/*         void DSPF_sp_icfftr2_dif(float* x, float* w, short n)            */
/*                                                                          */
/*         x : input and output sequences (dim-n)      (input/output)       */
/*             x has n complex numbers (2*n SP values).                     */
/*             The real and imaginary values are interleaved in memory.     */
/*             The input is in bit reversed order and output is in Normal   */
/*             Order.                                                       */
/*         w : FFT coefficients (dim-n/2)              (input)              */
/*             w has n/2 complex numbers (n SP values).                     */
/*             FFT coeficients must be in bit-reversed order                */
/*             The real and imaginary values are interleaved in memory      */
/*         n : FFT size                                (input)              */
/*                                                                          */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*       This routine is used to compute the Inverse, Complex, Radix-2,     */
/*       Decimation-in-Frequency Fast Fourier Transform of a single         */
/*       precision complex sequence of size n, and a power of 2. The        */
/*       routine requires bit-reversed input and bit-reversed coefficents   */
/*       (twiddle factors) and produces results that are in normal order.   */
/*       Final scaling by 1/N is not done in this function.                 */
/*                                                                          */
/*         How To Use                                                       */
/*                                                                          */
/*         void main(void)                                                  */
/*         {                                                                */
/*            gen_w_r2(w, N);         // Generate coefficient table         */
/*            bit_rev(w, N>>1);       // Bit-reverse coefficient table      */
/*            DSPF_sp_cfftr2_dit(x, w, N);                                  */
/*                                // radix-2 DIT forward FFT                */
/*                                    // input in normal order, output in   */
/*                                    // order bit-reversed                 */
/*                                                                          */
/*                                    // coefficient table in bit-reversed  */
/*                                    // order                              */
/*            DSPF_DSPF_sp_icfftr2_dif(x, w, N);                            */
/*                                // Inverse radix 2 FFT                    */
/*                                    // input in bit-reversed order,       */
/*                                    // order output in normal             */
/*                                                                          */
/*                                    // coefficient table in bit-reversed  */
/*                                    // order                              */
/*            divide(x, N);           // scale inverse FFT output           */
/*                                    // result is the same as original     */
/*                    // input                                              */
/*         }                                                                */
/*                                                                          */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2003 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#ifndef DSPF_SP_ICFFTR2_DIF_
#define DSPF_SP_ICFFTR2_DIF_ 1

void DSPF_sp_icfftr2_dif(float * x, float * w, short n);

#endif
/* ======================================================================== */
/*  End of file: dspf_sp_icfftr2_dif.h                                      */
/* ------------------------------------------------------------------------ */
/*          Copyright (C) 2003 Texas Instruments, Incorporated.             */
/*                          All Rights Reserved.                            */
/* ======================================================================== */