Fixed following bugs:
[ep-processor-libraries/dsplib.git] / ti / dsplib / examples / fft_sp_ex / fft_example_sp.c
1 /* ======================================================================= */
2 /* fft_sp_example.c -- FFT Example File                                    */
3 /*                                                                         */
4 /*        This example demonstrates the usage of the various FFT kernels   */
5 /*        provided with the C6x DSPLIB. The example shows:                 */
6 /*        - Twiddle factor generation for the various kernels              */
7 /*        - Scaling that needs to be applied to get similar output         */
8 /*          when using different kernels                                   */
9 /*        - Demonstrates the usage of FFT APIs                             */
10 /*                                                                         */
11 /* Rev 0.0.1                                                               */
12 /*                                                                         */
13 /* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/  */ 
14 /*                                                                         */
15 /*                                                                         */
16 /*  Redistribution and use in source and binary forms, with or without     */
17 /*  modification, are permitted provided that the following conditions     */
18 /*  are met:                                                               */
19 /*                                                                         */
20 /*    Redistributions of source code must retain the above copyright       */
21 /*    notice, this list of conditions and the following disclaimer.        */
22 /*                                                                         */
23 /*    Redistributions in binary form must reproduce the above copyright    */
24 /*    notice, this list of conditions and the following disclaimer in the  */
25 /*    documentation and/or other materials provided with the               */
26 /*    distribution.                                                        */
27 /*                                                                         */
28 /*    Neither the name of Texas Instruments Incorporated nor the names of  */
29 /*    its contributors may be used to endorse or promote products derived  */
30 /*    from this software without specific prior written permission.        */
31 /*                                                                         */
32 /*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS    */
33 /*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT      */
34 /*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR  */
35 /*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT   */
36 /*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,  */
37 /*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT       */
38 /*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,  */
39 /*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY  */
40 /*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT    */
41 /*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  */
42 /*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   */
43 /*                                                                         */
44 /* ----------------------------------------------------------------------- */
45 /*            Copyright (c) 2011 Texas Instruments, Incorporated.          */
46 /*                           All Rights Reserved.                          */
47 /* ======================================================================= */
49 #include <stdint.h>
50 #include <math.h>
51 #include <ti/dsplib/dsplib.h>
53 /* Global definitions */
54 /* Number of samples for which FFT needs to be calculated */
55 #define N 256 
56 /* Number of unique sine waves in input data */
57 #define NUM_SIN_WAVES 4
59 /* Align the tables that we have to use */
60 #pragma DATA_ALIGN(x_ref, 8);
61 float   x_ref [2*N];
63 #pragma DATA_ALIGN(x_sp, 8);
64 float   x_sp [2*N];
65 #pragma DATA_ALIGN(y_sp, 8);
66 float   y_sp [2*N];
67 #pragma DATA_ALIGN(w_sp, 8);
68 float   w_sp [2*N];
70 unsigned char brev[64] = {
71     0x0, 0x20, 0x10, 0x30, 0x8, 0x28, 0x18, 0x38,
72     0x4, 0x24, 0x14, 0x34, 0xc, 0x2c, 0x1c, 0x3c,
73     0x2, 0x22, 0x12, 0x32, 0xa, 0x2a, 0x1a, 0x3a,
74     0x6, 0x26, 0x16, 0x36, 0xe, 0x2e, 0x1e, 0x3e,
75     0x1, 0x21, 0x11, 0x31, 0x9, 0x29, 0x19, 0x39,
76     0x5, 0x25, 0x15, 0x35, 0xd, 0x2d, 0x1d, 0x3d,
77     0x3, 0x23, 0x13, 0x33, 0xb, 0x2b, 0x1b, 0x3b,
78     0x7, 0x27, 0x17, 0x37, 0xf, 0x2f, 0x1f, 0x3f
79 };
81 /*  
82     This function generates the input data and also updates the 
83     input data arrays used by the various FFT kernels
84 */
85 void generateInput (int numSinWaves) {
86     int   i, j;
87     float sinWaveIncFreq, sinWaveMag;
89     /* 
90         Based on numSinWave information, create the input data. The
91         input data is first created using floating point dataType. The
92         floating point data type is then converted to the appropriate
93         fixed point notation
94     */
96     /* Clear the input floating point array */
97     for (i = 0; i < N; i++) {
98         x_ref[2*i]   = (float)0.0;      
99         x_ref[2*i+1] = (float)0.0;  
100     }
102     /* Calculate the incremental freq for each sin wave */
103     sinWaveIncFreq = ((float)3.142)/(numSinWaves*(float)1.0);
105     /* Calculate the magnitude for each sin wave */
106     sinWaveMag = (float)1.0/(numSinWaves * (float)1.0*N);
108     /* Create the input array as sum of the various sin wave data */
109     for (j = 0; j < numSinWaves; j++) {
110         for (i = 0; i < N; i++) {
111             x_ref[2*i]  += sinWaveMag * (float)cos(sinWaveIncFreq*j*i);        
112             x_ref[2*i+1] = (float) 0.0;
113         } 
114     }
115         
116     /* Copy the reference input data to the various input arrays */     
117     for (i = 0; i < N; i++) {
118         x_sp [2*i]   = x_ref[2*i];
119         x_sp [2*i+1] = x_ref[2*i+1];
120     }
123 /* 
124     The seperateRealImg function seperates the real and imaginary data
125     of the FFT output. This is needed so that the data can be plotted
126     using the CCS graph feature
127 */
129 float y_real_sp [N];
130 float y_imag_sp [N];
132 seperateRealImg () {
133     int i, j;
135     for (i = 0, j = 0; j < N; i+=2, j++) {
136         y_real_sp[j] = y_sp[i];
137         y_imag_sp[j] = y_sp[i + 1];
138     }
141 /*
142     The main function that implements the example functionality.
143     This example demonstrates the usage of the various FFT kernels provided 
144     with the C6x DSPLIB. The example shows:
145         - Twiddle factor generation for the various kernels
146         - Needed scaling to get correct output
147         - Demonstrates usage of FFT APIs
148 */
150 /* Function for generating Specialized sequence of twiddle factors */
151 void gen_twiddle_fft_sp (float *w, int n)
153     int i, j, k;
154     const double PI = 3.141592654;
156     for (j = 1, k = 0; j <= n >> 2; j = j << 2)
157     {
158         for (i = 0; i < n >> 2; i += j)
159         {
160 #ifdef _LITTLE_ENDIAN
161             w[k] = (float) sin (2 * PI * i / n);
162             w[k + 1] = (float) cos (2 * PI * i / n);
163             w[k + 2] = (float) sin (4 * PI * i / n);
164             w[k + 3] = (float) cos (4 * PI * i / n);
165             w[k + 4] = (float) sin (6 * PI * i / n);
166             w[k + 5] = (float) cos (6 * PI * i / n);
167 #else
168             w[k] = (float) cos (2 * PI * i / n);
169             w[k + 1] = (float) -sin (2 * PI * i / n);
170             w[k + 2] = (float) cos (4 * PI * i / n);
171             w[k + 3] = (float) -sin (4 * PI * i / n);
172             w[k + 4] = (float) cos (6 * PI * i / n);
173             w[k + 5] = (float) -sin (6 * PI * i / n);
174 #endif
175             k += 6;
176         }
177     }
180 void main () {
181     /* Generate the input data */
182     generateInput (NUM_SIN_WAVES);
183     
184     /* Genarate twiddle factors */
185     gen_twiddle_fft_sp(w_sp, N);
187     /* Call FFT routine */
188     DSPF_sp_fftSPxSP(N, x_sp, w_sp, y_sp, brev, 4, 0, N);
190     /* Call the test code to seperate the real and imaginary data */
191     seperateRealImg ();
194 /* ======================================================================== */
195 /*  End of file:  fft_example.c                                             */
196 /* ------------------------------------------------------------------------ */
197 /*            Copyright (c) 2011 Texas Instruments, Incorporated.           */
198 /*                           All Rights Reserved.                           */
199 /* ======================================================================== */