/* ======================================================================== */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*    DSPF_sp_cfftr2_dit- Single Precision floating point radix-2 FFT with  */
/*    complex input                                                         */
/*                                                                          */
/*  USAGE                                                                   */
/*          This routine is C-callable and can be called as:                */
/*                                                                          */
/*          void DSPF_sp_cfftr2_dit(float * x, float * w, short n);         */
/*                                                                          */
/*          x : Pointer to complex data input                               */
/*          w : pointer to complex twiddle factor in bit reverse order      */
/*          n : Length of FFT in complex samples, power of 2 such that      */
/*          n >= 32                                                         */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*                                                                          */
/*      This routine performs the Decimation-in-Time (DIT) Radix-2 FFT      */
/*      of the input array x.                                               */
/*                                                                          */
/*      x has N complex floating point numbers arranged as successive       */
/*      real and imaginary number pairs. Input array x contains N           */
/*      complex points (N*2 elements). The coefficients for the             */
/*      FFT are passed to the function in array w which contains            */
/*      N/2 complex numbers (N elements) as successive real and             */
/*      imaginary number pairs.                                             */
/*                                                                          */
/*      The FFT Coefficients w are in N/2 bit-reversed order                */
/*      The elements of input array x are in normal order                   */
/*      The assembly routine performs 4 output samples (2 real and 2        */
/*      imaginary) for a pass through inner loop.                           */
/*                                                                          */
/*  How to Use                                                              */
/*                                                                          */
/*  void main(void)                                                         */
/*         {                                                                */
/*            gen_w_r2(w, N);         // Generate coefficient table         */
/*            bit_rev(w, N>>1);       // Bit-reverse coefficient table      */
/*            DSPF_DSPF_sp_cfftr2_dit(x, w, N);                             */
/*                                                                          */
/*                                    // input in normal order, output in   */
/*                                    // order bit-reversed                 */
/*                                                                          */
/*                                    // coefficient table in bit-reversed  */
/*                                    // order                              */
/*         }                                                                */
/*                                                                          */
/*      Note that (bit-reversed) coefficients for higher order FFT (1024    */
/*      point) can be used unchanged as coefficients for a lower order      */
/*      FFT (512, 256, 128 ... ,2)                                          */
/*                                                                          */
/*      The routine can be used to implement Inverse-FFT by any ONE of      */
/*      the following methods:                                              */
/*                                                                          */
/*      1.Inputs (x) are replaced by their Complex-conjugate values         */
/*        Output values are divided by N                                    */
/*                                                                          */
/*      2.FFT Coefficients (w) are replaced by their Complex-conjugates     */
/*        Output values are divided by N                                    */
/*                                                                          */
/*      3.Swap Real and Imaginary values of input                           */
/*                                                                          */
/*      4.Swap Real and Imaginary values of output                          */
/*                                                                          */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2003 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#ifndef DSPF_SP_CFFTR2_DIT_
#define DSPF_SP_CFFTR2_DIT_ 1

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

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