ffmpeg / libavcodec / fft.h @ 2881c831
History  View  Annotate  Download (6.67 KB)
1 
/*


2 
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard

3 
* Copyright (c) 20022004 Michael Niedermayer <michaelni@gmx.at>

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
#ifndef AVCODEC_FFT_H

23 
#define AVCODEC_FFT_H

24  
25 
#include <stdint.h> 
26 
#include "config.h" 
27 
#include "libavutil/mem.h" 
28 
#include "avfft.h" 
29  
30 
/* FFT computation */

31  
32 
struct FFTContext {

33 
int nbits;

34 
int inverse;

35 
uint16_t *revtab; 
36 
FFTComplex *exptab; 
37 
FFTComplex *exptab1; /* only used by SSE code */

38 
FFTComplex *tmp_buf; 
39 
int mdct_size; /* size of MDCT (i.e. number of input data * 2) */ 
40 
int mdct_bits; /* n = 2^nbits */ 
41 
/* pre/post rotation tables */

42 
FFTSample *tcos; 
43 
FFTSample *tsin; 
44 
void (*fft_permute)(struct FFTContext *s, FFTComplex *z); 
45 
void (*fft_calc)(struct FFTContext *s, FFTComplex *z); 
46 
void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
47 
void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
48 
void (*mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
49 
int split_radix;

50 
int permutation;

51 
#define FF_MDCT_PERM_NONE 0 
52 
#define FF_MDCT_PERM_INTERLEAVE 1 
53 
}; 
54  
55 
#if CONFIG_HARDCODED_TABLES

56 
#define COSTABLE_CONST const 
57 
#define SINTABLE_CONST const 
58 
#define SINETABLE_CONST const 
59 
#else

60 
#define COSTABLE_CONST

61 
#define SINTABLE_CONST

62 
#define SINETABLE_CONST

63 
#endif

64  
65 
#define COSTABLE(size) \

66 
COSTABLE_CONST DECLARE_ALIGNED(16, FFTSample, ff_cos_##size)[size/2] 
67 
#define SINTABLE(size) \

68 
SINTABLE_CONST DECLARE_ALIGNED(16, FFTSample, ff_sin_##size)[size/2] 
69 
#define SINETABLE(size) \

70 
SINETABLE_CONST DECLARE_ALIGNED(16, float, ff_sine_##size)[size] 
71 
extern COSTABLE(16); 
72 
extern COSTABLE(32); 
73 
extern COSTABLE(64); 
74 
extern COSTABLE(128); 
75 
extern COSTABLE(256); 
76 
extern COSTABLE(512); 
77 
extern COSTABLE(1024); 
78 
extern COSTABLE(2048); 
79 
extern COSTABLE(4096); 
80 
extern COSTABLE(8192); 
81 
extern COSTABLE(16384); 
82 
extern COSTABLE(32768); 
83 
extern COSTABLE(65536); 
84 
extern COSTABLE_CONST FFTSample* const ff_cos_tabs[17]; 
85  
86 
/**

87 
* Initializes the cosine table in ff_cos_tabs[index]

88 
* \param index index in ff_cos_tabs array of the table to initialize

89 
*/

90 
void ff_init_ff_cos_tabs(int index); 
91  
92 
extern SINTABLE(16); 
93 
extern SINTABLE(32); 
94 
extern SINTABLE(64); 
95 
extern SINTABLE(128); 
96 
extern SINTABLE(256); 
97 
extern SINTABLE(512); 
98 
extern SINTABLE(1024); 
99 
extern SINTABLE(2048); 
100 
extern SINTABLE(4096); 
101 
extern SINTABLE(8192); 
102 
extern SINTABLE(16384); 
103 
extern SINTABLE(32768); 
104 
extern SINTABLE(65536); 
105  
106 
/**

107 
* Sets up a complex FFT.

108 
* @param nbits log2 of the length of the input array

109 
* @param inverse if 0 perform the forward transform, if 1 perform the inverse

110 
*/

111 
int ff_fft_init(FFTContext *s, int nbits, int inverse); 
112 
void ff_fft_permute_c(FFTContext *s, FFTComplex *z);

113 
void ff_fft_calc_c(FFTContext *s, FFTComplex *z);

114  
115 
void ff_fft_init_altivec(FFTContext *s);

116 
void ff_fft_init_mmx(FFTContext *s);

117 
void ff_fft_init_arm(FFTContext *s);

118  
119 
/**

120 
* Do the permutation needed BEFORE calling ff_fft_calc().

121 
*/

122 
static inline void ff_fft_permute(FFTContext *s, FFTComplex *z) 
123 
{ 
124 
s>fft_permute(s, z); 
125 
} 
126 
/**

127 
* Do a complex FFT with the parameters defined in ff_fft_init(). The

128 
* input data must be permuted before. No 1.0/sqrt(n) normalization is done.

129 
*/

130 
static inline void ff_fft_calc(FFTContext *s, FFTComplex *z) 
131 
{ 
132 
s>fft_calc(s, z); 
133 
} 
134 
void ff_fft_end(FFTContext *s);

135  
136 
/* MDCT computation */

137  
138 
static inline void ff_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input) 
139 
{ 
140 
s>imdct_calc(s, output, input); 
141 
} 
142 
static inline void ff_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input) 
143 
{ 
144 
s>imdct_half(s, output, input); 
145 
} 
146  
147 
static inline void ff_mdct_calc(FFTContext *s, FFTSample *output, 
148 
const FFTSample *input)

149 
{ 
150 
s>mdct_calc(s, output, input); 
151 
} 
152  
153 
/**

154 
* Generate a KaiserBessel Derived Window.

155 
* @param window pointer to half window

156 
* @param alpha determines window shape

157 
* @param n size of half window

158 
*/

159 
void ff_kbd_window_init(float *window, float alpha, int n); 
160  
161 
/**

162 
* Generate a sine window.

163 
* @param window pointer to half window

164 
* @param n size of half window

165 
*/

166 
void ff_sine_window_init(float *window, int n); 
167  
168 
/**

169 
* initialize the specified entry of ff_sine_windows

170 
*/

171 
void ff_init_ff_sine_windows(int index); 
172 
extern SINETABLE( 32); 
173 
extern SINETABLE( 64); 
174 
extern SINETABLE( 128); 
175 
extern SINETABLE( 256); 
176 
extern SINETABLE( 512); 
177 
extern SINETABLE(1024); 
178 
extern SINETABLE(2048); 
179 
extern SINETABLE(4096); 
180 
extern SINETABLE_CONST float * const ff_sine_windows[13]; 
181  
182 
int ff_mdct_init(FFTContext *s, int nbits, int inverse, double scale); 
183 
void ff_imdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
184 
void ff_imdct_half_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
185 
void ff_mdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
186 
void ff_mdct_end(FFTContext *s);

187  
188 
/* Real Discrete Fourier Transform */

189  
190 
struct RDFTContext {

191 
int nbits;

192 
int inverse;

193 
int sign_convention;

194  
195 
/* pre/post rotation tables */

196 
const FFTSample *tcos;

197 
SINTABLE_CONST FFTSample *tsin; 
198 
FFTContext fft; 
199 
void (*rdft_calc)(struct RDFTContext *s, FFTSample *z); 
200 
}; 
201  
202 
/**

203 
* Sets up a real FFT.

204 
* @param nbits log2 of the length of the input array

205 
* @param trans the type of transform

206 
*/

207 
int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans); 
208 
void ff_rdft_end(RDFTContext *s);

209  
210 
static av_always_inline void ff_rdft_calc(RDFTContext *s, FFTSample *data) 
211 
{ 
212 
s>rdft_calc(s, data); 
213 
} 
214  
215 
/* Discrete Cosine Transform */

216  
217 
struct DCTContext {

218 
int nbits;

219 
int inverse;

220 
FFTSample *data; 
221 
RDFTContext rdft; 
222 
const float *costab; 
223 
FFTSample *csc2; 
224 
}; 
225  
226 
/**

227 
* Sets up (Inverse)DCT.

228 
* @param nbits log2 of the length of the input array

229 
* @param inverse >0 forward transform, <0 inverse transform

230 
*/

231 
int ff_dct_init(DCTContext *s, int nbits, int inverse); 
232 
void ff_dct_calc(DCTContext *s, FFTSample *data);

233 
void ff_dct_end (DCTContext *s);

234  
235 
#endif /* AVCODEC_FFT_H */ 