ffmpeg / libavcodec / fft.h @ 26f548bb
History  View  Annotate  Download (6.2 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 Libav.

6 
*

7 
* Libav 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 
* Libav 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 Libav; 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 
/**

43 
* Do the permutation needed BEFORE calling fft_calc().

44 
*/

45 
void (*fft_permute)(struct FFTContext *s, FFTComplex *z); 
46 
/**

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

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

49 
*/

50 
void (*fft_calc)(struct FFTContext *s, FFTComplex *z); 
51 
void (*imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
52 
void (*imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
53 
void (*mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input); 
54 
int fft_permutation;

55 
#define FF_FFT_PERM_DEFAULT 0 
56 
#define FF_FFT_PERM_SWAP_LSBS 1 
57 
int mdct_permutation;

58 
#define FF_MDCT_PERM_NONE 0 
59 
#define FF_MDCT_PERM_INTERLEAVE 1 
60 
}; 
61  
62 
#if CONFIG_HARDCODED_TABLES

63 
#define COSTABLE_CONST const 
64 
#define SINTABLE_CONST const 
65 
#define SINETABLE_CONST const 
66 
#else

67 
#define COSTABLE_CONST

68 
#define SINTABLE_CONST

69 
#define SINETABLE_CONST

70 
#endif

71  
72 
#define COSTABLE(size) \

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

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

77 
SINETABLE_CONST DECLARE_ALIGNED(16, float, ff_sine_##size)[size] 
78 
extern COSTABLE(16); 
79 
extern COSTABLE(32); 
80 
extern COSTABLE(64); 
81 
extern COSTABLE(128); 
82 
extern COSTABLE(256); 
83 
extern COSTABLE(512); 
84 
extern COSTABLE(1024); 
85 
extern COSTABLE(2048); 
86 
extern COSTABLE(4096); 
87 
extern COSTABLE(8192); 
88 
extern COSTABLE(16384); 
89 
extern COSTABLE(32768); 
90 
extern COSTABLE(65536); 
91 
extern COSTABLE_CONST FFTSample* const ff_cos_tabs[17]; 
92  
93 
/**

94 
* Initialize the cosine table in ff_cos_tabs[index]

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

96 
*/

97 
void ff_init_ff_cos_tabs(int index); 
98  
99 
extern SINTABLE(16); 
100 
extern SINTABLE(32); 
101 
extern SINTABLE(64); 
102 
extern SINTABLE(128); 
103 
extern SINTABLE(256); 
104 
extern SINTABLE(512); 
105 
extern SINTABLE(1024); 
106 
extern SINTABLE(2048); 
107 
extern SINTABLE(4096); 
108 
extern SINTABLE(8192); 
109 
extern SINTABLE(16384); 
110 
extern SINTABLE(32768); 
111 
extern SINTABLE(65536); 
112  
113 
/**

114 
* Set up a complex FFT.

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

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

117 
*/

118 
int ff_fft_init(FFTContext *s, int nbits, int inverse); 
119  
120 
void ff_fft_init_altivec(FFTContext *s);

121 
void ff_fft_init_mmx(FFTContext *s);

122 
void ff_fft_init_arm(FFTContext *s);

123 
void ff_dct_init_mmx(DCTContext *s);

124  
125 
void ff_fft_end(FFTContext *s);

126  
127 
/**

128 
* Maximum window size for ff_kbd_window_init.

129 
*/

130 
#define FF_KBD_WINDOW_MAX 1024 
131  
132 
/**

133 
* Generate a KaiserBessel Derived Window.

134 
* @param window pointer to half window

135 
* @param alpha determines window shape

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

137 
*/

138 
void ff_kbd_window_init(float *window, float alpha, int n); 
139  
140 
/**

141 
* Generate a sine window.

142 
* @param window pointer to half window

143 
* @param n size of half window

144 
*/

145 
void ff_sine_window_init(float *window, int n); 
146  
147 
/**

148 
* initialize the specified entry of ff_sine_windows

149 
*/

150 
void ff_init_ff_sine_windows(int index); 
151 
extern SINETABLE( 32); 
152 
extern SINETABLE( 64); 
153 
extern SINETABLE( 128); 
154 
extern SINETABLE( 256); 
155 
extern SINETABLE( 512); 
156 
extern SINETABLE(1024); 
157 
extern SINETABLE(2048); 
158 
extern SINETABLE(4096); 
159 
extern SINETABLE_CONST float * const ff_sine_windows[13]; 
160  
161 
int ff_mdct_init(FFTContext *s, int nbits, int inverse, double scale); 
162 
void ff_imdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
163 
void ff_imdct_half_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
164 
void ff_mdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
165 
void ff_mdct_end(FFTContext *s);

166  
167 
/* Real Discrete Fourier Transform */

168  
169 
struct RDFTContext {

170 
int nbits;

171 
int inverse;

172 
int sign_convention;

173  
174 
/* pre/post rotation tables */

175 
const FFTSample *tcos;

176 
SINTABLE_CONST FFTSample *tsin; 
177 
FFTContext fft; 
178 
void (*rdft_calc)(struct RDFTContext *s, FFTSample *z); 
179 
}; 
180  
181 
/**

182 
* Set up a real FFT.

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

184 
* @param trans the type of transform

185 
*/

186 
int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans); 
187 
void ff_rdft_end(RDFTContext *s);

188  
189 
void ff_rdft_init_arm(RDFTContext *s);

190  
191 
/* Discrete Cosine Transform */

192  
193 
struct DCTContext {

194 
int nbits;

195 
int inverse;

196 
RDFTContext rdft; 
197 
const float *costab; 
198 
FFTSample *csc2; 
199 
void (*dct_calc)(struct DCTContext *s, FFTSample *data); 
200 
void (*dct32)(FFTSample *out, const FFTSample *in); 
201 
}; 
202  
203 
/**

204 
* Set up DCT.

205 
* @param nbits size of the input array:

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

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

208 
*

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

210 
*/

211 
int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType type); 
212 
void ff_dct_end (DCTContext *s);

213  
214 
#endif /* AVCODEC_FFT_H */ 