1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
/**********************************************************************
FFT3.h -- FFT routines, based on the following but renamed with "3"
to avoid naming problems. This early implementation from Audacity has
been upated and the current Audacity version imports wxChar, but if I
adapt the latest code into the scorealign library, then scorealign
will depend upon wxWindows. On the other hand, if I don't update to
the latest, then there are name conflicts when scorealign is used
within Audacity. For now, at least, I'm just renaming functions,
which has no real impact on scorealign (other than function names
with the mystery "3" appended), but will result in duplicated code
in Audacity. -RBD
FFT.h
Dominic Mazzoni
September 2000
This file contains a few FFT routines, including a real-FFT
routine that is almost twice as fast as a normal complex FFT,
and a power spectrum routine which is more convenient when
you know you don't care about phase information. It now also
contains a few basic windowing functions.
Some of this code was based on a free implementation of an FFT
by Don Cross, available on the web at:
http://www.intersrv.com/~dcross/fft.html
The basic algorithm for his code was based on Numerical Recipes
in Fortran. I optimized his code further by reducing array
accesses, caching the bit reversal table, and eliminating
float-to-float conversions, and I added the routines to
calculate a real FFT and a real power spectrum.
Note: all of these routines use single-precision floats.
I have found that in practice, floats work well until you
get above 8192 samples. If you need to do a larger FFT,
you need to use floats.
**********************************************************************/
#ifndef M_PI
#define M_PI 3.14159265358979323846 /* pi */
#endif
#define false 0
#define true 1
/*
* This is the function you will use the most often.
* Given an array of floats, this will compute the power
* spectrum by doing a Real FFT and then computing the
* sum of the squares of the real and imaginary parts.
* Note that the output array is half the length of the
* input array, and that NumSamples must be a power of two.
*/
void PowerSpectrum3(int NumSamples, float *In, float *Out);
/*
* Computes an FFT when the input data is real but you still
* want complex data as output. The output arrays are half
* the length of the input, and NumSamples must be a power of
* two.
*/
void RealFFT3(int NumSamples,
float *RealIn, float *RealOut, float *ImagOut);
/*
* Computes a FFT of complex input and returns complex output.
* Currently this is the only function here that supports the
* inverse transform as well.
*/
void FFT3(int NumSamples,
int InverseTransform,
float *RealIn, float *ImagIn, float *RealOut, float *ImagOut);
/*
* Applies a windowing function to the data in place
*
* 0: Rectangular (no window)
* 1: Bartlett (triangular)
* 2: Hamming
* 3: Hanning
*/
void WindowFunc3(int whichFunction, int NumSamples, float *data);
/*
* Returns the name of the windowing function (for UI display)
*/
const char *WindowFuncName3(int whichFunction);
/*
* Returns the number of windowing functions supported
*/
int NumWindowFuncs3();
|
