ffmpeg / libavcodec / fft.h @ d4a84771
History  View  Annotate  Download (6.86 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 *tmp_buf; 
37 
int mdct_size; /* size of MDCT (i.e. number of input data * 2) */ 
38 
int mdct_bits; /* n = 2^nbits */ 
39 
/* pre/post rotation tables */

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

48 
#define FF_MDCT_PERM_NONE 0 
49 
#define FF_MDCT_PERM_INTERLEAVE 1 
50 
}; 
51  
52 
#if CONFIG_HARDCODED_TABLES

53 
#define COSTABLE_CONST const 
54 
#define SINTABLE_CONST const 
55 
#define SINETABLE_CONST const 
56 
#else

57 
#define COSTABLE_CONST

58 
#define SINTABLE_CONST

59 
#define SINETABLE_CONST

60 
#endif

61  
62 
#define COSTABLE(size) \

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

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

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

84 
* Initialize the cosine table in ff_cos_tabs[index]

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

86 
*/

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

104 
* Set up a complex FFT.

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

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

107 
*/

108 
int ff_fft_init(FFTContext *s, int nbits, int inverse); 
109  
110 
void ff_fft_init_altivec(FFTContext *s);

111 
void ff_fft_init_mmx(FFTContext *s);

112 
void ff_fft_init_arm(FFTContext *s);

113 
void ff_dct_init_mmx(DCTContext *s);

114  
115 
/**

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

117 
*/

118 
static inline void ff_fft_permute(FFTContext *s, FFTComplex *z) 
119 
{ 
120 
s>fft_permute(s, z); 
121 
} 
122 
/**

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

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

125 
*/

126 
static inline void ff_fft_calc(FFTContext *s, FFTComplex *z) 
127 
{ 
128 
s>fft_calc(s, z); 
129 
} 
130 
void ff_fft_end(FFTContext *s);

131  
132 
/* MDCT computation */

133  
134 
static inline void ff_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input) 
135 
{ 
136 
s>imdct_calc(s, output, input); 
137 
} 
138 
static inline void ff_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input) 
139 
{ 
140 
s>imdct_half(s, output, input); 
141 
} 
142  
143 
static inline void ff_mdct_calc(FFTContext *s, FFTSample *output, 
144 
const FFTSample *input)

145 
{ 
146 
s>mdct_calc(s, output, input); 
147 
} 
148  
149 
/**

150 
* Maximum window size for ff_kbd_window_init.

151 
*/

152 
#define FF_KBD_WINDOW_MAX 1024 
153  
154 
/**

155 
* Generate a KaiserBessel Derived Window.

156 
* @param window pointer to half window

157 
* @param alpha determines window shape

158 
* @param n size of half window, max FF_KBD_WINDOW_MAX

159 
*/

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

163 
* Generate a sine window.

164 
* @param window pointer to half window

165 
* @param n size of half window

166 
*/

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

170 
* initialize the specified entry of ff_sine_windows

171 
*/

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

188  
189 
/* Real Discrete Fourier Transform */

190  
191 
struct RDFTContext {

192 
int nbits;

193 
int inverse;

194 
int sign_convention;

195  
196 
/* pre/post rotation tables */

197 
const FFTSample *tcos;

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

204 
* Set up a real FFT.

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

206 
* @param trans the type of transform

207 
*/

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

210  
211 
void ff_rdft_init_arm(RDFTContext *s);

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

219  
220 
struct DCTContext {

221 
int nbits;

222 
int inverse;

223 
RDFTContext rdft; 
224 
const float *costab; 
225 
FFTSample *csc2; 
226 
void (*dct_calc)(struct DCTContext *s, FFTSample *data); 
227 
void (*dct32)(FFTSample *out, const FFTSample *in); 
228 
}; 
229  
230 
/**

231 
* Set up DCT.

232 
* @param nbits size of the input array:

233 
* (1 << nbits) for DCTII, DCTIII and DSTI

234 
* (1 << nbits) + 1 for DCTI

235 
*

236 
* @note the first element of the input of DSTI is ignored

237 
*/

238 
int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType type); 
239 
void ff_dct_calc(DCTContext *s, FFTSample *data);

240 
void ff_dct_end (DCTContext *s);

241  
242 
#endif /* AVCODEC_FFT_H */ 