ffmpeg / libavcodec / fft.h @ a45fbda9
History  View  Annotate  Download (5.85 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 
* Generate a sine window.

129 
* @param window pointer to half window

130 
* @param n size of half window

131 
*/

132 
void ff_sine_window_init(float *window, int n); 
133  
134 
/**

135 
* initialize the specified entry of ff_sine_windows

136 
*/

137 
void ff_init_ff_sine_windows(int index); 
138 
extern SINETABLE( 32); 
139 
extern SINETABLE( 64); 
140 
extern SINETABLE( 128); 
141 
extern SINETABLE( 256); 
142 
extern SINETABLE( 512); 
143 
extern SINETABLE(1024); 
144 
extern SINETABLE(2048); 
145 
extern SINETABLE(4096); 
146 
extern SINETABLE_CONST float * const ff_sine_windows[13]; 
147  
148 
int ff_mdct_init(FFTContext *s, int nbits, int inverse, double scale); 
149 
void ff_imdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
150 
void ff_imdct_half_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
151 
void ff_mdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input); 
152 
void ff_mdct_end(FFTContext *s);

153  
154 
/* Real Discrete Fourier Transform */

155  
156 
struct RDFTContext {

157 
int nbits;

158 
int inverse;

159 
int sign_convention;

160  
161 
/* pre/post rotation tables */

162 
const FFTSample *tcos;

163 
SINTABLE_CONST FFTSample *tsin; 
164 
FFTContext fft; 
165 
void (*rdft_calc)(struct RDFTContext *s, FFTSample *z); 
166 
}; 
167  
168 
/**

169 
* Set up a real FFT.

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

171 
* @param trans the type of transform

172 
*/

173 
int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans); 
174 
void ff_rdft_end(RDFTContext *s);

175  
176 
void ff_rdft_init_arm(RDFTContext *s);

177  
178 
/* Discrete Cosine Transform */

179  
180 
struct DCTContext {

181 
int nbits;

182 
int inverse;

183 
RDFTContext rdft; 
184 
const float *costab; 
185 
FFTSample *csc2; 
186 
void (*dct_calc)(struct DCTContext *s, FFTSample *data); 
187 
void (*dct32)(FFTSample *out, const FFTSample *in); 
188 
}; 
189  
190 
/**

191 
* Set up DCT.

192 
* @param nbits size of the input array:

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

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

195 
*

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

197 
*/

198 
int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType type); 
199 
void ff_dct_end (DCTContext *s);

200  
201 
#endif /* AVCODEC_FFT_H */ 