Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : /*====================================================================================
34 : EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
35 : ====================================================================================*/
36 :
37 : #include <assert.h>
38 : #include <stdint.h>
39 : #include "options.h"
40 : #ifdef DEBUGGING
41 : #include "debug.h"
42 : #endif
43 : #include <math.h>
44 : #include "cnst.h"
45 : #include "prot.h"
46 : #include "rom_com.h"
47 : #include "wmc_auto.h"
48 :
49 : #ifdef _MSC_VER
50 : #pragma warning( disable : 4310 )
51 : #endif
52 :
53 : /*-----------------------------------------------------------------*
54 : * Local constants
55 : *-----------------------------------------------------------------*/
56 :
57 : #define FFT_15PONIT_WNK1 0.55901699f /* EDCT & EMDCT constants */
58 : #define FFT_15PONIT_WNK2 0.95105652f /* EDCT & EMDCT constants */
59 : #define FFT_15PONIT_WNK3 0.58778525f /* EDCT & EMDCT constants */
60 : #define FFT_15PONIT_WNK4 0.86602540f /* EDCT & EMDCT constants */
61 : #define FFT_15PONIT_WNK5 0.25000000f /* EDCT & EMDCT constants */
62 :
63 : /* FFT constants */
64 : #define FFT_C31 -0.8660254037f
65 : #define FFT_C51 0.9510565195f
66 : #define FFT_C52 -1.5388417989f
67 : #define FFT_C53 -0.3632712597f
68 : #define FFT_C54 0.5590169895f
69 : #define FFT_C55 -1.2500000000f
70 : #define FFT_C61 0.8660254036f
71 : #define FFT_C81 0.7071067811f
72 : #define FFT_C82 -0.7071067811f
73 : #define FFT_C161 0.7071067811f
74 : #define FFT_C162 -0.7071067811f
75 : #define FFT_C163 0.9238795325f
76 : #define FFT_C164 -0.9238795325f
77 : #define FFT_C165 0.3826834323f
78 : #define FFT_C166 -0.3826834323f
79 :
80 :
81 : /*-----------------------------------------------------------------*
82 : * Local function prototypes
83 : *-----------------------------------------------------------------*/
84 :
85 : static void cdftForw( int16_t n, float *a, const int16_t *ip, const float *w );
86 : static void bitrv2_SR( int16_t n, const int16_t *ip, float *a );
87 : static void cftfsub( int16_t n, float *a, const float *w );
88 : static void cft1st( int16_t n, float *a, const float *w );
89 : static void cftmdl( int16_t n, int16_t l, float *a, const float *w );
90 : static void fft16( float *x, float *y, const int16_t *Idx );
91 : static void fft5_shift1( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
92 : static void fft8( float *x, float *y, const int16_t *Idx );
93 : static void fft15_shift2( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
94 : static void fft15_shift8( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
95 : static void fft5_shift4( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
96 : static void fft5_32( float *zRe, float *zIm, const int16_t *Idx );
97 : static void fft64( float *x, float *y, const int16_t *Idx );
98 : static void fft32_15( float *x, float *y, const int16_t *Idx );
99 : static void fft32_5( float *x, float *y, const int16_t *Idx );
100 : static void fft8_5( float *x, float *y, const int16_t *Idx );
101 : static void fft5_8( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
102 : static void fft4_5( float *x, float *y, const int16_t *Idx );
103 : static void fft5_4( int16_t n1, float *zRe, float *zIm, const int16_t *Idx );
104 :
105 67239072 : static float fmac( float a, float b, float c )
106 : {
107 67239072 : return ( ( ( a ) * ( b ) ) + ( c ) );
108 : }
109 :
110 246543264 : static float fnms( float a, float b, float c )
111 : {
112 246543264 : return ( ( c ) - ( ( a ) * ( b ) ) );
113 : }
114 :
115 : /*-----------------------------------------------------------------*
116 : * fft15_shift2()
117 : * 15-point FFT with 2-point circular shift
118 : *-----------------------------------------------------------------*/
119 :
120 108752 : static void fft15_shift2(
121 : int16_t n1, /* i : length of data */
122 : float *zRe, /* i/o: real part of input and output data */
123 : float *zIm, /* i/o: imaginary part of input and output data */
124 : const int16_t *Idx /* i : pointer of the address table */
125 : )
126 : {
127 : int16_t in0, in8, in16, in24, in32, in1, in9, in17, in25, in33, in2, in10, in18, in26, in34;
128 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8, fi9, fi10, fi11, fi12, fi13, fi14, fi15;
129 : float fi16, fi17, fi18, fi19, fi20, fi21, fi22, fi23, fi24, fi25, fi26, fi27, fi28, fi29, fi30;
130 : float f2i1, f2i2, f2i3, f2i4, f2i5, f2i6, f2i7, f2i8, f2i9, f2i10, f2i11, f2i12;
131 : float f2i13, f2i14, f2i15, f2i16, f2i17, f2i18, f2i19, f2i20, f2i21, f2i22, f2i23, f2i24;
132 : float f3i1, f3i2, f3i3, f3i4, f3i5, f3i6, f3i7, f3i8, f3i9, f3i10, f3i11, f3i12, f3i13, f3i14, f3i15;
133 : float f4i1, f4i2, f4i3, f4i4, f4i5, f4i6, f4i7, f4i8, f4i9;
134 : float f4i10, f4i11, f4i12, f4i13, f4i14, f4i15, f4i16, f4i17, f4i18, f4i19, f4i20, fo1, fo2, fo3, fo4;
135 : float fo5, fo6, fo7, fo8, fo9, fo10, fo11, fo12, fo13, fo14, fo15, fo16, fo17, fo18;
136 : float f2o1, f2o2, f2o3, f2o4, f2o5, f2o6, f2o7, f2o8, f2o9, f2o10, f2o11, f2o12, f2o13;
137 : float f2o14, f2o15, f3o1, f3o2, f3o3, f3o4, f3o5, f3o6, f3o7, f3o8, f3o9, f3o10, f3o11;
138 : float f3o12, f3o13, f3o14, f3o15, f4o1, f4o2, f4o3, f4o4, f4o5, f4o6;
139 : float f4o7, f4o8, f4o9, f4o10, f4o11, f4o12, f4o13, f4o14, f4o15, f4o16, f4o17, f4o18, f4o19;
140 :
141 108752 : in0 = Idx[0];
142 108752 : in8 = Idx[n1];
143 108752 : in16 = Idx[n1 * 2];
144 108752 : in24 = Idx[n1 * 3];
145 108752 : in32 = Idx[n1 * 4];
146 108752 : in1 = Idx[n1 * 5];
147 108752 : in9 = Idx[n1 * 6];
148 108752 : in17 = Idx[n1 * 7];
149 108752 : in25 = Idx[n1 * 8];
150 108752 : in33 = Idx[n1 * 9];
151 108752 : in2 = Idx[n1 * 10];
152 108752 : in10 = Idx[n1 * 11];
153 108752 : in18 = Idx[n1 * 12];
154 108752 : in26 = Idx[n1 * 13];
155 108752 : in34 = Idx[n1 * 14];
156 :
157 108752 : f2i13 = zRe[in0];
158 108752 : f2i14 = zIm[in0];
159 108752 : f2i21 = zRe[in1];
160 108752 : f2i22 = zRe[in2];
161 108752 : f2i23 = zIm[in1];
162 108752 : f2i24 = zIm[in2];
163 :
164 108752 : f2i15 = f2i21 + f2i22;
165 108752 : f2i16 = FFT_15PONIT_WNK4 * ( f2i22 - f2i21 );
166 108752 : f2i17 = FFT_15PONIT_WNK4 * ( f2i23 - f2i24 );
167 108752 : f2i18 = f2i23 + f2i24;
168 108752 : fi1 = f2i13 + f2i15;
169 108752 : fi2 = f2i14 + f2i18;
170 :
171 108752 : f2i19 = fnms( 0.5f, f2i15, f2i13 );
172 108752 : f2i20 = fnms( 0.5f, f2i18, f2i14 );
173 108752 : fi3 = f2i19 - f2i17;
174 108752 : fi4 = f2i19 + f2i17;
175 108752 : fi5 = f2i16 + f2i20;
176 108752 : fi6 = f2i20 - f2i16;
177 :
178 108752 : f3i1 = zRe[in9];
179 108752 : f4i2 = zRe[in10];
180 108752 : f4i3 = zRe[in8];
181 108752 : f3i2 = f4i2 + f4i3;
182 108752 : f3i3 = fnms( 0.5f, f3i2, f3i1 );
183 108752 : f3i4 = FFT_15PONIT_WNK4 * ( f4i3 - f4i2 );
184 :
185 108752 : f3i5 = zIm[in9];
186 108752 : f4i4 = zIm[in10];
187 108752 : f4i5 = zIm[in8];
188 108752 : f3i6 = f4i4 + f4i5;
189 108752 : f3i7 = FFT_15PONIT_WNK4 * ( f4i4 - f4i5 );
190 108752 : f3i8 = fnms( 0.5f, f3i6, f3i5 );
191 :
192 108752 : f3i9 = zRe[in33];
193 108752 : f4i6 = zRe[in34];
194 108752 : f4i7 = zRe[in32];
195 108752 : f3i10 = f4i6 + f4i7;
196 108752 : f3i11 = fnms( 0.5f, f3i10, f3i9 );
197 108752 : f3i12 = FFT_15PONIT_WNK4 * ( f4i7 - f4i6 );
198 :
199 108752 : f3i13 = zIm[in33];
200 108752 : f4i8 = zIm[in34];
201 108752 : f4i9 = zIm[in32];
202 108752 : f3i14 = f4i8 + f4i9;
203 108752 : f3i15 = FFT_15PONIT_WNK4 * ( f4i8 - f4i9 );
204 108752 : f4i1 = fnms( 0.5f, f3i14, f3i13 );
205 :
206 108752 : fi7 = f3i1 + f3i2;
207 108752 : fi8 = f3i9 + f3i10;
208 108752 : fi9 = fi7 + fi8;
209 108752 : fi10 = f3i3 - f3i7;
210 108752 : fi11 = f3i11 - f3i15;
211 108752 : fi12 = fi10 + fi11;
212 108752 : fi13 = f3i5 + f3i6;
213 108752 : fi14 = f3i13 + f3i14;
214 108752 : fi15 = fi13 + fi14;
215 108752 : fi16 = f3i8 - f3i4;
216 108752 : fi17 = f4i1 - f3i12;
217 108752 : fi18 = fi16 + fi17;
218 108752 : fi19 = f3i4 + f3i8;
219 108752 : fi20 = f3i12 + f4i1;
220 108752 : fi21 = fi19 + fi20;
221 108752 : fi22 = f3i3 + f3i7;
222 108752 : fi23 = f3i11 + f3i15;
223 108752 : fi24 = fi22 + fi23;
224 :
225 108752 : f4i10 = zRe[in24];
226 108752 : fo6 = zRe[in25];
227 108752 : fo7 = zRe[in26];
228 108752 : f4i11 = fo6 + fo7;
229 108752 : f4i12 = fnms( 0.5f, f4i11, f4i10 );
230 108752 : f4i13 = FFT_15PONIT_WNK4 * ( fo7 - fo6 );
231 :
232 108752 : f4i14 = zIm[in24];
233 108752 : fo8 = zIm[in25];
234 108752 : fo9 = zIm[in26];
235 108752 : f4i15 = fo8 + fo9;
236 108752 : f4i16 = FFT_15PONIT_WNK4 * ( fo8 - fo9 );
237 108752 : f4i17 = fnms( 0.5f, f4i15, f4i14 );
238 :
239 108752 : f4i18 = zRe[in18];
240 108752 : f2o10 = zRe[in16];
241 108752 : f2o11 = zRe[in17];
242 108752 : f4i19 = f2o10 + f2o11;
243 108752 : f4i20 = fnms( 0.5f, f4i19, f4i18 );
244 108752 : fo1 = FFT_15PONIT_WNK4 * ( f2o11 - f2o10 );
245 :
246 108752 : fo2 = zIm[in18];
247 108752 : f2o12 = zIm[in16];
248 108752 : f2o13 = zIm[in17];
249 108752 : fo3 = f2o12 + f2o13;
250 108752 : fo4 = FFT_15PONIT_WNK4 * ( f2o12 - f2o13 );
251 108752 : fo5 = fnms( 0.5f, fo3, fo2 );
252 :
253 108752 : fi25 = f4i10 + f4i11;
254 108752 : fi26 = f4i18 + f4i19;
255 108752 : fi27 = fi25 + fi26;
256 108752 : fi28 = f4i12 - f4i16;
257 108752 : fi29 = f4i20 - fo4;
258 108752 : fi30 = fi28 + fi29;
259 108752 : f2i1 = f4i14 + f4i15;
260 108752 : f2i2 = fo2 + fo3;
261 108752 : f2i3 = f2i1 + f2i2;
262 108752 : f2i4 = f4i17 - f4i13;
263 108752 : f2i5 = fo5 - fo1;
264 108752 : f2i6 = f2i4 + f2i5;
265 108752 : f2i7 = f4i13 + f4i17;
266 108752 : f2i8 = fo1 + fo5;
267 108752 : f2i9 = f2i7 + f2i8;
268 108752 : f2i10 = f4i12 + f4i16;
269 108752 : f2i11 = f4i20 + fo4;
270 108752 : f2i12 = f2i10 + f2i11;
271 :
272 108752 : fo10 = FFT_15PONIT_WNK1 * ( fi27 - fi9 );
273 108752 : fo11 = fi27 + fi9;
274 108752 : fo12 = fnms( FFT_15PONIT_WNK5, fo11, fi1 );
275 108752 : fo15 = fi13 - fi14;
276 108752 : fo16 = f2i1 - f2i2;
277 108752 : fo13 = fnms( FFT_15PONIT_WNK3, fo16, FFT_15PONIT_WNK2 * fo15 );
278 108752 : fo14 = fmac( FFT_15PONIT_WNK2, fo16, FFT_15PONIT_WNK3 * fo15 );
279 :
280 108752 : zRe[in0] = fi1 + fo11;
281 108752 : fo17 = fo10 + fo12;
282 108752 : zRe[in18] = fo17 - fo14;
283 108752 : zRe[in24] = fo17 + fo14;
284 108752 : fo18 = fo12 - fo10;
285 108752 : zRe[in9] = fo18 - fo13;
286 108752 : zRe[in33] = fo18 + fo13;
287 :
288 108752 : f2o1 = FFT_15PONIT_WNK1 * ( f2i3 - fi15 );
289 108752 : f2o2 = f2i3 + fi15;
290 108752 : f2o3 = fnms( FFT_15PONIT_WNK5, f2o2, fi2 );
291 108752 : f2o6 = fi7 - fi8;
292 108752 : f2o7 = fi25 - fi26;
293 108752 : f2o4 = fnms( FFT_15PONIT_WNK3, f2o7, FFT_15PONIT_WNK2 * f2o6 );
294 108752 : f2o5 = fmac( FFT_15PONIT_WNK2, f2o7, FFT_15PONIT_WNK3 * f2o6 );
295 108752 : zIm[in0] = fi2 + f2o2;
296 108752 : f2o8 = f2o1 + f2o3;
297 108752 : zIm[in24] = f2o8 - f2o5;
298 108752 : zIm[in18] = f2o5 + f2o8;
299 108752 : f2o9 = f2o3 - f2o1;
300 108752 : zIm[in33] = f2o9 - f2o4;
301 108752 : zIm[in9] = f2o4 + f2o9;
302 :
303 108752 : f2o14 = FFT_15PONIT_WNK1 * ( fi30 - fi12 );
304 108752 : f2o15 = fi30 + fi12;
305 108752 : f3o1 = fnms( FFT_15PONIT_WNK5, f2o15, fi3 );
306 108752 : f3o4 = fi16 - fi17;
307 108752 : f3o5 = f2i4 - f2i5;
308 108752 : f3o2 = fnms( FFT_15PONIT_WNK3, f3o5, FFT_15PONIT_WNK2 * f3o4 );
309 108752 : f3o3 = fmac( FFT_15PONIT_WNK2, f3o5, FFT_15PONIT_WNK3 * f3o4 );
310 108752 : zRe[in2] = fi3 + f2o15;
311 108752 : f3o6 = f2o14 + f3o1;
312 108752 : zRe[in17] = f3o6 - f3o3;
313 108752 : zRe[in26] = f3o6 + f3o3;
314 108752 : f3o7 = f3o1 - f2o14;
315 108752 : zRe[in8] = f3o7 - f3o2;
316 108752 : zRe[in32] = f3o7 + f3o2;
317 :
318 108752 : f3o8 = FFT_15PONIT_WNK1 * ( f2i6 - fi18 );
319 108752 : f3o9 = f2i6 + fi18;
320 108752 : f3o10 = fnms( FFT_15PONIT_WNK5, f3o9, fi6 );
321 108752 : f3o13 = fi10 - fi11;
322 108752 : f3o14 = fi28 - fi29;
323 108752 : f3o11 = fnms( FFT_15PONIT_WNK3, f3o14, FFT_15PONIT_WNK2 * f3o13 );
324 108752 : f3o12 = fmac( FFT_15PONIT_WNK2, f3o14, FFT_15PONIT_WNK3 * f3o13 );
325 108752 : zIm[in2] = fi6 + f3o9;
326 108752 : f3o15 = f3o8 + f3o10;
327 108752 : zIm[in26] = f3o15 - f3o12;
328 108752 : zIm[in17] = f3o12 + f3o15;
329 108752 : f4o1 = f3o10 - f3o8;
330 108752 : zIm[in8] = f3o11 + f4o1;
331 108752 : zIm[in32] = f4o1 - f3o11;
332 :
333 108752 : f4o2 = FFT_15PONIT_WNK1 * ( f2i9 - fi21 );
334 108752 : f4o3 = f2i9 + fi21;
335 108752 : f4o4 = fnms( FFT_15PONIT_WNK5, f4o3, fi5 );
336 108752 : f4o7 = f2i10 - f2i11;
337 108752 : f4o8 = fi22 - fi23;
338 108752 : f4o5 = fmac( FFT_15PONIT_WNK2, f4o7, FFT_15PONIT_WNK3 * f4o8 );
339 108752 : f4o6 = fnms( FFT_15PONIT_WNK3, f4o7, FFT_15PONIT_WNK2 * f4o8 );
340 108752 : zIm[in1] = fi5 + f4o3;
341 108752 : f4o9 = f4o4 - f4o2;
342 108752 : f4o10 = f4o2 + f4o4;
343 :
344 108752 : zIm[in10] = f4o6 + f4o9;
345 108752 : zIm[in34] = f4o9 - f4o6;
346 108752 : zIm[in25] = f4o10 - f4o5;
347 108752 : zIm[in16] = f4o5 + f4o10;
348 :
349 108752 : f4o11 = FFT_15PONIT_WNK1 * ( f2i12 - fi24 );
350 108752 : f4o12 = f2i12 + fi24;
351 108752 : f4o13 = fnms( FFT_15PONIT_WNK5, f4o12, fi4 );
352 108752 : f4o16 = f2i7 - f2i8;
353 108752 : f4o17 = fi19 - fi20;
354 108752 : f4o14 = fmac( FFT_15PONIT_WNK2, f4o16, FFT_15PONIT_WNK3 * f4o17 );
355 108752 : f4o15 = fnms( FFT_15PONIT_WNK3, f4o16, FFT_15PONIT_WNK2 * f4o17 );
356 108752 : zRe[in1] = fi4 + f4o12;
357 108752 : f4o18 = f4o13 - f4o11;
358 108752 : f4o19 = f4o11 + f4o13;
359 :
360 108752 : zRe[in10] = f4o18 - f4o15;
361 108752 : zRe[in34] = f4o18 + f4o15;
362 108752 : zRe[in16] = f4o19 - f4o14;
363 108752 : zRe[in25] = f4o19 + f4o14;
364 :
365 108752 : return;
366 : }
367 :
368 : /*-----------------------------------------------------------------*
369 : * fft15_shift8()
370 : * 15-point FFT with 8-point circular shift
371 : *-----------------------------------------------------------------*/
372 :
373 11097760 : static void fft15_shift8(
374 : int16_t n1, /* i : length of data */
375 : float *zRe, /* i/o: real part of input and output data */
376 : float *zIm, /* i/o: imaginary part of input and output data */
377 : const int16_t *Idx /* i : pointer of the address table */
378 : )
379 : {
380 : int16_t in0, in8, in16, in24, in32, in1, in9, in17, in25, in33, in2, in10, in18, in26, in34;
381 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8, fi9, fi10, fi11, fi12, fi13, fi14, fi15;
382 : float fi16, fi17, fi18, fi19, fi20, fi21, fi22, fi23, fi24, fi25, fi26, fi27, fi28, fi29, fi30;
383 : float f2i1, f2i2, f2i3, f2i4, f2i5, f2i6, f2i7, f2i8, f2i9, f2i10, f2i11, f2i12;
384 : float f2i13, f2i14, f2i15, f3i1, f3i2, f3i3, f3i4, f3i5, f3i6, f3i7, f3i8, f3i9;
385 : float f3i10, f3i11, f3i12, f3i13, f3i14, f3i15, f4i1, f4i2, f4i3, f4i4, f4i5, f4i6, f4i7, f4i8, f4i9;
386 : float f4i10, f4i11, f4i12, f4i13, f4i14, f4i15, fo1, fo2, fo3, fo4, fo5, fo6;
387 : float fo7, fo8, fo9, fo10, fo11, fo12, fo13, fo14, fo15, f2o1, f2o2, f2o3, f2o4;
388 : float f2o5, f2o6, f2o7, f2o8, f2o9, f2o10, f2o11, f2o12, f2o13, f2o14, f2o15;
389 : float f3o1, f3o2, f3o3, f3o4, f3o5, f3o6, f3o7, f3o8, f3o9, f3o10, f3o11, f3o12;
390 : float f3o13, f3o14, f3o15, f4o1, f4o2, f4o3, f4o4, f4o5, f4o6, f4o7, f4o8, f4o9;
391 : float f4o10, f4o11, f4o12, f4o13, f4o14, f4o15, f5o1, f5o2, f5o3, f5o4, f5o5, f5o6, f5o7;
392 : float f5o8, f5o9, f5o10, f5o11, f5o12, f5o13, f5o14, f5o15, f5o16, f5o17, f5o18, f5o19, f5o21, f5o22;
393 :
394 11097760 : in0 = Idx[0];
395 11097760 : in8 = Idx[n1];
396 11097760 : in16 = Idx[n1 * 2];
397 11097760 : in24 = Idx[n1 * 3];
398 11097760 : in32 = Idx[n1 * 4];
399 11097760 : in1 = Idx[n1 * 5];
400 11097760 : in9 = Idx[n1 * 6];
401 11097760 : in17 = Idx[n1 * 7];
402 11097760 : in25 = Idx[n1 * 8];
403 11097760 : in33 = Idx[n1 * 9];
404 11097760 : in2 = Idx[n1 * 10];
405 11097760 : in10 = Idx[n1 * 11];
406 11097760 : in18 = Idx[n1 * 12];
407 11097760 : in26 = Idx[n1 * 13];
408 11097760 : in34 = Idx[n1 * 14];
409 :
410 11097760 : f2i13 = zRe[in0];
411 11097760 : f2i14 = zIm[in0];
412 11097760 : f3i6 = zRe[in1];
413 11097760 : f3i7 = zRe[in2];
414 11097760 : f3i8 = zIm[in1];
415 11097760 : f3i9 = zIm[in2];
416 :
417 11097760 : f2i15 = f3i6 + f3i7;
418 11097760 : f3i1 = FFT_15PONIT_WNK4 * ( f3i7 - f3i6 );
419 11097760 : f3i2 = FFT_15PONIT_WNK4 * ( f3i8 - f3i9 );
420 11097760 : f3i3 = f3i8 + f3i9;
421 :
422 11097760 : fi1 = f2i13 + f2i15;
423 11097760 : fi2 = f2i14 + f3i3;
424 11097760 : f3i4 = fnms( 0.5f, f2i15, f2i13 );
425 11097760 : fi3 = f3i4 - f3i2;
426 11097760 : fi4 = f3i4 + f3i2;
427 11097760 : f3i5 = fnms( 0.5f, f3i3, f2i14 );
428 11097760 : fi5 = f3i1 + f3i5;
429 11097760 : fi6 = f3i5 - f3i1;
430 :
431 11097760 : f3i10 = zRe[in9];
432 11097760 : f4i11 = zRe[in10];
433 11097760 : f4i12 = zRe[in8];
434 11097760 : f3i14 = zIm[in9];
435 11097760 : f4i13 = zIm[in10];
436 11097760 : f4i14 = zIm[in8];
437 11097760 : f4i3 = zRe[in33];
438 11097760 : f4i15 = zRe[in34];
439 11097760 : fo1 = zRe[in32];
440 11097760 : f4i7 = zIm[in33];
441 11097760 : fo2 = zIm[in34];
442 11097760 : fo3 = zIm[in32];
443 :
444 :
445 11097760 : f3i11 = f4i11 + f4i12;
446 11097760 : f3i12 = fnms( 0.5f, f3i11, f3i10 );
447 11097760 : f3i13 = FFT_15PONIT_WNK4 * ( f4i12 - f4i11 );
448 11097760 : f3i15 = f4i13 + f4i14;
449 11097760 : f4i1 = FFT_15PONIT_WNK4 * ( f4i13 - f4i14 );
450 11097760 : f4i2 = fnms( 0.5f, f3i15, f3i14 );
451 11097760 : f4i4 = f4i15 + fo1;
452 11097760 : f4i5 = fnms( 0.5f, f4i4, f4i3 );
453 11097760 : f4i6 = FFT_15PONIT_WNK4 * ( fo1 - f4i15 );
454 11097760 : f4i8 = fo2 + fo3;
455 11097760 : f4i9 = FFT_15PONIT_WNK4 * ( fo2 - fo3 );
456 11097760 : f4i10 = fnms( 0.5f, f4i8, f4i7 );
457 :
458 11097760 : fi7 = f3i10 + f3i11;
459 11097760 : fi8 = f4i3 + f4i4;
460 11097760 : fi9 = fi7 + fi8;
461 11097760 : fi10 = f3i12 - f4i1;
462 11097760 : fi11 = f4i5 - f4i9;
463 11097760 : fi12 = fi10 + fi11;
464 11097760 : fi13 = f3i14 + f3i15;
465 11097760 : fi14 = f4i7 + f4i8;
466 11097760 : fi15 = fi13 + fi14;
467 11097760 : fi16 = f4i2 - f3i13;
468 11097760 : fi17 = f4i10 - f4i6;
469 11097760 : fi18 = fi16 + fi17;
470 11097760 : fi19 = f3i13 + f4i2;
471 11097760 : fi20 = f4i6 + f4i10;
472 11097760 : fi21 = fi19 + fi20;
473 11097760 : fi22 = f3i12 + f4i1;
474 11097760 : fi23 = f4i5 + f4i9;
475 11097760 : fi24 = fi22 + fi23;
476 :
477 11097760 : fo4 = zRe[in24];
478 11097760 : f2o5 = zRe[in25];
479 11097760 : f2o6 = zRe[in26];
480 11097760 : fo8 = zIm[in24];
481 11097760 : f2o7 = zIm[in25];
482 11097760 : f2o8 = zIm[in26];
483 11097760 : fo12 = zRe[in18];
484 11097760 : f2o9 = zRe[in16];
485 11097760 : f2o10 = zRe[in17];
486 11097760 : f2o1 = zIm[in18];
487 11097760 : f2o11 = zIm[in16];
488 11097760 : f2o12 = zIm[in17];
489 :
490 :
491 11097760 : fo5 = f2o5 + f2o6;
492 11097760 : fo6 = fnms( 0.5f, fo5, fo4 );
493 11097760 : fo7 = FFT_15PONIT_WNK4 * ( f2o6 - f2o5 );
494 11097760 : fo9 = f2o7 + f2o8;
495 11097760 : fo10 = FFT_15PONIT_WNK4 * ( f2o7 - f2o8 );
496 11097760 : fo11 = fnms( 0.5f, fo9, fo8 );
497 11097760 : fo13 = f2o9 + f2o10;
498 11097760 : fo14 = fnms( 0.5f, fo13, fo12 );
499 11097760 : fo15 = FFT_15PONIT_WNK4 * ( f2o10 - f2o9 );
500 11097760 : f2o2 = f2o11 + f2o12;
501 11097760 : f2o3 = FFT_15PONIT_WNK4 * ( f2o11 - f2o12 );
502 11097760 : f2o4 = fnms( 0.5f, f2o2, f2o1 );
503 :
504 11097760 : fi25 = fo4 + fo5;
505 11097760 : fi26 = fo12 + fo13;
506 11097760 : fi27 = fi25 + fi26;
507 11097760 : fi28 = fo6 - fo10;
508 11097760 : fi29 = fo14 - f2o3;
509 11097760 : fi30 = fi28 + fi29;
510 11097760 : f2i1 = fo8 + fo9;
511 11097760 : f2i2 = f2o1 + f2o2;
512 11097760 : f2i3 = f2i1 + f2i2;
513 11097760 : f2i4 = fo11 - fo7;
514 11097760 : f2i5 = f2o4 - fo15;
515 11097760 : f2i6 = f2i4 + f2i5;
516 11097760 : f2i7 = fo7 + fo11;
517 11097760 : f2i8 = fo15 + f2o4;
518 11097760 : f2i9 = f2i7 + f2i8;
519 11097760 : f2i10 = fo6 + fo10;
520 11097760 : f2i11 = fo14 + f2o3;
521 11097760 : f2i12 = f2i10 + f2i11;
522 :
523 11097760 : f2o13 = FFT_15PONIT_WNK1 * ( fi27 - fi9 );
524 11097760 : f2o14 = fi27 + fi9;
525 11097760 : f2o15 = fnms( FFT_15PONIT_WNK5, f2o14, fi1 );
526 11097760 : f3o3 = fi13 - fi14;
527 11097760 : f3o4 = f2i1 - f2i2;
528 11097760 : f3o1 = fnms( FFT_15PONIT_WNK3, f3o4, FFT_15PONIT_WNK2 * f3o3 );
529 11097760 : f3o2 = fmac( FFT_15PONIT_WNK2, f3o4, FFT_15PONIT_WNK3 * f3o3 );
530 11097760 : zRe[in0] = fi1 + f2o14;
531 11097760 : f3o5 = f2o13 + f2o15;
532 11097760 : zRe[in24] = f3o5 - f3o2;
533 11097760 : zRe[in18] = f3o5 + f3o2;
534 11097760 : f3o6 = f2o15 - f2o13;
535 11097760 : zRe[in33] = f3o6 - f3o1;
536 11097760 : zRe[in9] = f3o6 + f3o1;
537 :
538 11097760 : f3o7 = FFT_15PONIT_WNK1 * ( f2i3 - fi15 );
539 11097760 : f3o8 = f2i3 + fi15;
540 11097760 : f3o9 = fnms( FFT_15PONIT_WNK5, f3o8, fi2 );
541 11097760 : f3o12 = fi7 - fi8;
542 11097760 : f3o13 = fi25 - fi26;
543 11097760 : f3o10 = fnms( FFT_15PONIT_WNK3, f3o13, FFT_15PONIT_WNK2 * f3o12 );
544 11097760 : f3o11 = fmac( FFT_15PONIT_WNK2, f3o13, FFT_15PONIT_WNK3 * f3o12 );
545 11097760 : zIm[in0] = fi2 + f3o8;
546 11097760 : f3o14 = f3o7 + f3o9;
547 11097760 : zIm[in18] = f3o14 - f3o11;
548 11097760 : zIm[in24] = f3o11 + f3o14;
549 11097760 : f3o15 = f3o9 - f3o7;
550 11097760 : zIm[in9] = f3o15 - f3o10;
551 11097760 : zIm[in33] = f3o10 + f3o15;
552 :
553 11097760 : f4o1 = FFT_15PONIT_WNK1 * ( fi30 - fi12 );
554 11097760 : f4o2 = fi30 + fi12;
555 11097760 : f4o3 = fnms( FFT_15PONIT_WNK5, f4o2, fi3 );
556 11097760 : f4o6 = fi16 - fi17;
557 11097760 : f4o7 = f2i4 - f2i5;
558 11097760 : f4o4 = fnms( FFT_15PONIT_WNK3, f4o7, FFT_15PONIT_WNK2 * f4o6 );
559 11097760 : f4o5 = fmac( FFT_15PONIT_WNK2, f4o7, FFT_15PONIT_WNK3 * f4o6 );
560 11097760 : zRe[in2] = fi3 + f4o2;
561 11097760 : f4o8 = f4o1 + f4o3;
562 11097760 : zRe[in26] = f4o8 - f4o5;
563 11097760 : zRe[in17] = f4o8 + f4o5;
564 11097760 : f4o9 = f4o3 - f4o1;
565 11097760 : zRe[in32] = f4o9 - f4o4;
566 11097760 : zRe[in8] = f4o9 + f4o4;
567 :
568 11097760 : f4o10 = FFT_15PONIT_WNK1 * ( f2i6 - fi18 );
569 11097760 : f4o11 = f2i6 + fi18;
570 11097760 : f4o12 = fnms( FFT_15PONIT_WNK5, f4o11, fi6 );
571 11097760 : f4o15 = fi10 - fi11;
572 11097760 : f5o1 = fi28 - fi29;
573 11097760 : f4o13 = fnms( FFT_15PONIT_WNK3, f5o1, FFT_15PONIT_WNK2 * f4o15 );
574 11097760 : f4o14 = fmac( FFT_15PONIT_WNK2, f5o1, FFT_15PONIT_WNK3 * f4o15 );
575 11097760 : zIm[in2] = fi6 + f4o11;
576 11097760 : f5o2 = f4o10 + f4o12;
577 11097760 : zIm[in17] = f5o2 - f4o14;
578 11097760 : zIm[in26] = f4o14 + f5o2;
579 11097760 : f5o3 = f4o12 - f4o10;
580 11097760 : zIm[in32] = f4o13 + f5o3;
581 11097760 : zIm[in8] = f5o3 - f4o13;
582 :
583 11097760 : f5o4 = FFT_15PONIT_WNK1 * ( f2i9 - fi21 );
584 11097760 : f5o5 = f2i9 + fi21;
585 11097760 : f5o6 = fnms( FFT_15PONIT_WNK5, f5o5, fi5 );
586 11097760 : f5o9 = f2i10 - f2i11;
587 11097760 : f5o10 = fi22 - fi23;
588 11097760 : f5o7 = fmac( FFT_15PONIT_WNK2, f5o9, FFT_15PONIT_WNK3 * f5o10 );
589 11097760 : f5o8 = fnms( FFT_15PONIT_WNK3, f5o9, FFT_15PONIT_WNK2 * f5o10 );
590 11097760 : zIm[in1] = fi5 + f5o5;
591 11097760 : f5o11 = f5o6 - f5o4;
592 11097760 : f5o12 = f5o4 + f5o6;
593 11097760 : zIm[in34] = f5o8 + f5o11;
594 11097760 : zIm[in10] = f5o11 - f5o8;
595 :
596 11097760 : zIm[in16] = f5o12 - f5o7;
597 11097760 : zIm[in25] = f5o7 + f5o12;
598 :
599 11097760 : f5o13 = FFT_15PONIT_WNK1 * ( f2i12 - fi24 );
600 11097760 : f5o14 = f2i12 + fi24;
601 11097760 : f5o15 = fnms( FFT_15PONIT_WNK5, f5o14, fi4 );
602 11097760 : f5o18 = f2i7 - f2i8;
603 11097760 : f5o19 = fi19 - fi20;
604 11097760 : f5o16 = fmac( FFT_15PONIT_WNK2, f5o18, FFT_15PONIT_WNK3 * f5o19 );
605 11097760 : f5o17 = fnms( FFT_15PONIT_WNK3, f5o18, FFT_15PONIT_WNK2 * f5o19 );
606 11097760 : zRe[in1] = fi4 + f5o14;
607 11097760 : f5o21 = f5o15 - f5o13;
608 11097760 : f5o22 = f5o13 + f5o15;
609 :
610 11097760 : zRe[in34] = f5o21 - f5o17;
611 11097760 : zRe[in10] = f5o21 + f5o17;
612 11097760 : zRe[in25] = f5o22 - f5o16;
613 11097760 : zRe[in16] = f5o22 + f5o16;
614 :
615 11097760 : return;
616 : }
617 :
618 : /*-----------------------------------------------------------------*
619 : * fft5_shift1()
620 : * 5-point FFT with 1-point circular shift
621 : *-----------------------------------------------------------------*/
622 :
623 5221408 : static void fft5_shift1(
624 : int16_t n1, /* i : length of data */
625 : float *zRe, /* i/o: real part of input and output data */
626 : float *zIm, /* i/o: imaginary part of input and output data */
627 : const int16_t *Idx /* i : pointer of the address table */
628 : )
629 : {
630 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8;
631 : float fo1, fo2, fo3, fo4, fo5, fo6, fo7, fo8;
632 : int16_t in1, in2, in3, in4, in5;
633 :
634 5221408 : in1 = Idx[0];
635 5221408 : in2 = Idx[n1];
636 5221408 : in3 = Idx[n1 * 2];
637 5221408 : in4 = Idx[n1 * 3];
638 5221408 : in5 = Idx[n1 * 4];
639 :
640 5221408 : fi1 = zRe[in1];
641 5221408 : fi2 = zIm[in1];
642 5221408 : fo3 = zRe[in2];
643 5221408 : fo4 = zRe[in5];
644 5221408 : fo6 = zRe[in3];
645 5221408 : fo7 = zRe[in4];
646 :
647 5221408 : fo5 = fo3 + fo4;
648 5221408 : fo8 = fo6 + fo7;
649 5221408 : fi3 = fo5 + fo8;
650 5221408 : fi4 = fo6 - fo7;
651 5221408 : fi5 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
652 5221408 : fi6 = fo3 - fo4;
653 :
654 5221408 : fo3 = zIm[in2];
655 5221408 : fo4 = zIm[in5];
656 5221408 : fo6 = zIm[in3];
657 5221408 : fo7 = zIm[in4];
658 :
659 5221408 : fo5 = fo3 + fo4;
660 5221408 : fo8 = fo6 + fo7;
661 5221408 : fi7 = fo3 - fo4;
662 5221408 : fi8 = fo5 + fo8;
663 5221408 : fo1 = fo6 - fo7;
664 5221408 : fo2 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
665 :
666 5221408 : zRe[in1] = fi1 + fi3;
667 5221408 : zIm[in1] = fi2 + fi8;
668 :
669 5221408 : fo3 = FFT_15PONIT_WNK2 * fi7 + FFT_15PONIT_WNK3 * fo1;
670 5221408 : fo4 = FFT_15PONIT_WNK2 * fo1 - FFT_15PONIT_WNK3 * fi7;
671 5221408 : fo7 = fi1 - fi3 / 4;
672 5221408 : fo5 = fi5 + fo7;
673 5221408 : fo6 = fo7 - fi5;
674 :
675 5221408 : zRe[in2] = fo5 + fo3;
676 5221408 : zRe[in3] = fo6 - fo4;
677 5221408 : zRe[in4] = fo6 + fo4;
678 5221408 : zRe[in5] = fo5 - fo3;
679 :
680 5221408 : fo3 = FFT_15PONIT_WNK2 * fi6 + FFT_15PONIT_WNK3 * fi4;
681 5221408 : fo4 = FFT_15PONIT_WNK2 * fi4 - FFT_15PONIT_WNK3 * fi6;
682 5221408 : fo7 = fi2 - fi8 / 4;
683 5221408 : fo5 = fo2 + fo7;
684 5221408 : fo6 = fo7 - fo2;
685 :
686 5221408 : zIm[in2] = fo5 - fo3;
687 5221408 : zIm[in3] = fo4 + fo6;
688 5221408 : zIm[in4] = fo6 - fo4;
689 5221408 : zIm[in5] = fo3 + fo5;
690 :
691 5221408 : return;
692 : }
693 :
694 : /*-----------------------------------------------------------------*
695 : * fft5_shift4()
696 : * 5-point FFT with 4-point circular shift
697 : *-----------------------------------------------------------------*/
698 :
699 436891200 : static void fft5_shift4(
700 : int16_t n1, /* i : length of data */
701 : float *zRe, /* i/o: real part of input and output data */
702 : float *zIm, /* i/o: imaginary part of input and output data */
703 : const int16_t *Idx /* i : pointer of the address table */
704 : )
705 : {
706 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8;
707 : float fo1, fo2, fo3, fo4, fo5, fo6, fo7, fo8;
708 : int16_t in1, in2, in3, in4, in5;
709 :
710 436891200 : in1 = Idx[0];
711 436891200 : in2 = Idx[n1];
712 436891200 : in3 = Idx[n1 * 2];
713 436891200 : in4 = Idx[n1 * 3];
714 436891200 : in5 = Idx[n1 * 4];
715 :
716 436891200 : fi1 = zRe[in1];
717 436891200 : fi2 = zIm[in1];
718 436891200 : fo3 = zRe[in2];
719 436891200 : fo4 = zRe[in5];
720 436891200 : fo6 = zRe[in3];
721 436891200 : fo7 = zRe[in4];
722 :
723 436891200 : fo5 = fo3 + fo4;
724 436891200 : fo8 = fo6 + fo7;
725 436891200 : fi3 = fo5 + fo8;
726 436891200 : fi4 = fo6 - fo7;
727 436891200 : fi5 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
728 436891200 : fi6 = fo3 - fo4;
729 :
730 436891200 : fo3 = zIm[in2];
731 436891200 : fo4 = zIm[in5];
732 436891200 : fo6 = zIm[in3];
733 436891200 : fo7 = zIm[in4];
734 :
735 436891200 : fo5 = fo3 + fo4;
736 436891200 : fo8 = fo6 + fo7;
737 436891200 : fi7 = fo3 - fo4;
738 436891200 : fi8 = fo5 + fo8;
739 436891200 : fo1 = fo6 - fo7;
740 436891200 : fo2 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
741 :
742 436891200 : zRe[in1] = fi1 + fi3;
743 436891200 : zIm[in1] = fi2 + fi8;
744 :
745 436891200 : fo3 = FFT_15PONIT_WNK2 * fi7 + FFT_15PONIT_WNK3 * fo1;
746 436891200 : fo4 = FFT_15PONIT_WNK2 * fo1 - FFT_15PONIT_WNK3 * fi7;
747 436891200 : fo7 = fi1 - fi3 / 4;
748 436891200 : fo5 = fi5 + fo7;
749 436891200 : fo6 = fo7 - fi5;
750 436891200 : zRe[in2] = fo5 - fo3;
751 436891200 : zRe[in4] = fo6 - fo4;
752 436891200 : zRe[in3] = fo6 + fo4;
753 436891200 : zRe[in5] = fo5 + fo3;
754 :
755 436891200 : fo3 = FFT_15PONIT_WNK2 * fi6 + FFT_15PONIT_WNK3 * fi4;
756 436891200 : fo4 = FFT_15PONIT_WNK2 * fi4 - FFT_15PONIT_WNK3 * fi6;
757 436891200 : fo7 = fi2 - fi8 / 4;
758 436891200 : fo5 = fo2 + fo7;
759 436891200 : fo6 = fo7 - fo2;
760 :
761 436891200 : zIm[in3] = fo6 - fo4;
762 436891200 : zIm[in2] = fo3 + fo5;
763 436891200 : zIm[in4] = fo4 + fo6;
764 436891200 : zIm[in5] = fo5 - fo3;
765 :
766 436891200 : return;
767 : }
768 :
769 : /*-----------------------------------------------------------------*
770 : * fft5_32()
771 : * 5-point FFT called for 32 times
772 : *-----------------------------------------------------------------*/
773 :
774 14869056 : static void fft5_32(
775 : float *zRe, /* i/o: real part of input and output data */
776 : float *zIm, /* i/o: imaginary part of input and output data */
777 : const int16_t *Idx /* i : pointer of the address table */
778 : )
779 : {
780 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8;
781 : float fo1, fo2, fo3, fo4, fo5, fo6, fo7, fo8;
782 : int16_t in1, in2, in3, in4, in5;
783 :
784 14869056 : in1 = Idx[0];
785 14869056 : in2 = Idx[32];
786 14869056 : in3 = Idx[64];
787 14869056 : in4 = Idx[96];
788 14869056 : in5 = Idx[128];
789 :
790 14869056 : fi1 = zRe[in1];
791 14869056 : fi2 = zIm[in1];
792 14869056 : fo3 = zRe[in2];
793 14869056 : fo4 = zRe[in5];
794 14869056 : fo6 = zRe[in3];
795 14869056 : fo7 = zRe[in4];
796 :
797 14869056 : fo5 = fo3 + fo4;
798 14869056 : fo8 = fo6 + fo7;
799 14869056 : fi3 = fo5 + fo8;
800 14869056 : fi4 = fo6 - fo7;
801 14869056 : fi5 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
802 14869056 : fi6 = fo3 - fo4;
803 :
804 14869056 : fo3 = zIm[in2];
805 14869056 : fo4 = zIm[in5];
806 14869056 : fo6 = zIm[in3];
807 14869056 : fo7 = zIm[in4];
808 :
809 14869056 : fo5 = fo3 + fo4;
810 14869056 : fo8 = fo6 + fo7;
811 14869056 : fi7 = fo3 - fo4;
812 14869056 : fi8 = fo5 + fo8;
813 14869056 : fo1 = fo6 - fo7;
814 14869056 : fo2 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
815 :
816 14869056 : zRe[in1] = fi1 + fi3;
817 14869056 : zIm[in1] = fi2 + fi8;
818 :
819 14869056 : fo3 = FFT_15PONIT_WNK2 * fi7 + FFT_15PONIT_WNK3 * fo1;
820 14869056 : fo4 = FFT_15PONIT_WNK2 * fo1 - FFT_15PONIT_WNK3 * fi7;
821 14869056 : fo7 = fi1 - fi3 / 4;
822 14869056 : fo5 = fi5 + fo7;
823 14869056 : fo6 = fo7 - fi5;
824 :
825 14869056 : zRe[in2] = fo6 + fo4;
826 14869056 : zRe[in3] = fo5 + fo3;
827 14869056 : zRe[in4] = fo5 - fo3;
828 14869056 : zRe[in5] = fo6 - fo4;
829 :
830 14869056 : fo3 = FFT_15PONIT_WNK2 * fi6 + FFT_15PONIT_WNK3 * fi4;
831 14869056 : fo4 = FFT_15PONIT_WNK2 * fi4 - FFT_15PONIT_WNK3 * fi6;
832 14869056 : fo7 = fi2 - fi8 / 4;
833 14869056 : fo5 = fo2 + fo7;
834 14869056 : fo6 = fo7 - fo2;
835 :
836 14869056 : zIm[in2] = fo6 - fo4;
837 14869056 : zIm[in3] = fo5 - fo3;
838 14869056 : zIm[in4] = fo3 + fo5;
839 14869056 : zIm[in5] = fo4 + fo6;
840 :
841 14869056 : return;
842 : }
843 :
844 : /*-----------------------------------------------------------------*
845 : * fft64()
846 : * 64-point FFT
847 : *-----------------------------------------------------------------*/
848 :
849 34132125 : static void fft64(
850 : float *x, /* i/o: real part of input and output data */
851 : float *y, /* i/o: imaginary part of input and output data */
852 : const int16_t *Idx /* i : pointer of the address table */
853 : )
854 : {
855 : int16_t i, id, jd;
856 : float z[128];
857 2218588125 : for ( i = 0; i < 64; i++ )
858 : {
859 2184456000 : id = Idx[i];
860 2184456000 : z[2 * i] = x[id];
861 2184456000 : z[2 * i + 1] = y[id];
862 : }
863 :
864 34132125 : cdftForw( 128, z, Ip_fft64, w_fft64 );
865 :
866 2218588125 : for ( i = 0; i < 64; i++ )
867 : {
868 2184456000 : jd = Odx_fft64[i];
869 2184456000 : id = Idx[jd];
870 2184456000 : x[id] = z[2 * i];
871 2184456000 : y[id] = z[2 * i + 1];
872 : }
873 :
874 34132125 : return;
875 : }
876 :
877 :
878 : /*-----------------------------------------------------------------*
879 : * fft32_15()
880 : * 32-point FFT called for 15 times
881 : *-----------------------------------------------------------------*/
882 :
883 5202075 : static void fft32_15(
884 : float *x, /* i/o: real part of input and output data */
885 : float *y, /* i/o: imaginary part of input and output data */
886 : const int16_t *Idx /* i : pointer of the address table */
887 : )
888 : {
889 : int16_t i, id, jd;
890 : float z[64];
891 :
892 171668475 : for ( i = 0; i < 32; i++ )
893 : {
894 166466400 : id = Idx[i];
895 166466400 : z[2 * i] = x[id];
896 166466400 : z[2 * i + 1] = y[id];
897 : }
898 :
899 5202075 : cdftForw( 64, z, Ip_fft32, w_fft32 );
900 :
901 171668475 : for ( i = 0; i < 32; i++ )
902 : {
903 166466400 : jd = Odx_fft32_15[i];
904 166466400 : id = Idx[jd];
905 166466400 : x[id] = z[2 * i];
906 166466400 : y[id] = z[2 * i + 1];
907 : }
908 :
909 5202075 : return;
910 : }
911 :
912 : /*-----------------------------------------------------------------*
913 : * fft32_5()
914 : * 32-point FFT called for 5 times
915 : *-----------------------------------------------------------------*/
916 :
917 2323290 : static void fft32_5(
918 : float *x, /* i/o: real part of input and output data */
919 : float *y, /* i/o: imaginary part of input and output data */
920 : const int16_t *Idx /* i : pointer of the address table */
921 : )
922 : {
923 : int16_t i, id, jd;
924 : float z[64];
925 :
926 76668570 : for ( i = 0; i < 32; i++ )
927 : {
928 74345280 : id = Idx[i];
929 74345280 : z[2 * i] = x[id];
930 74345280 : z[2 * i + 1] = y[id];
931 : }
932 :
933 2323290 : cdftForw( 64, z, Ip_fft32, w_fft32 );
934 :
935 76668570 : for ( i = 0; i < 32; i++ )
936 : {
937 74345280 : jd = Odx_fft32_5[i];
938 74345280 : id = Idx[jd];
939 74345280 : x[id] = z[2 * i];
940 74345280 : y[id] = z[2 * i + 1];
941 : }
942 :
943 2323290 : return;
944 : }
945 :
946 : /*-----------------------------------------------------------------*
947 : * fft16()
948 : * 16-point FFT
949 : *-----------------------------------------------------------------*/
950 :
951 1631690 : static void fft16(
952 : float *x, /* i/o: real part of input and output data */
953 : float *y, /* i/o: imaginary part of input and output data */
954 : const int16_t *Idx /* i : pointer of the address table */
955 : )
956 : {
957 : int16_t i, id, jd;
958 : float z[32];
959 :
960 27738730 : for ( i = 0; i < 16; i++ )
961 : {
962 26107040 : id = Idx[i];
963 26107040 : z[2 * i] = x[id];
964 26107040 : z[2 * i + 1] = y[id];
965 : }
966 :
967 1631690 : cdftForw( 32, z, Ip_fft16, w_fft16 );
968 :
969 27738730 : for ( i = 0; i < 16; i++ )
970 : {
971 26107040 : jd = Odx_fft16[i];
972 26107040 : id = Idx[jd];
973 26107040 : x[id] = z[2 * i];
974 26107040 : y[id] = z[2 * i + 1];
975 : }
976 :
977 1631690 : return;
978 : }
979 :
980 : /*-----------------------------------------------------------------*
981 : * fft8()
982 : * 8-point FFT
983 : *-----------------------------------------------------------------*/
984 :
985 203910 : static void fft8(
986 : float *x, /* i/o: real part of input and output data */
987 : float *y, /* i/o: imaginary part of input and output data */
988 : const int16_t *Idx /* i : pointer of the address table */
989 : )
990 : {
991 : int16_t i, id;
992 : float z[16];
993 :
994 1835190 : for ( i = 0; i < 8; i++ )
995 : {
996 1631280 : id = Idx[i];
997 1631280 : z[2 * i] = x[id];
998 1631280 : z[2 * i + 1] = y[id];
999 : }
1000 :
1001 203910 : cdftForw( 16, z, Ip_fft8, w_fft8 );
1002 :
1003 1835190 : for ( i = 0; i < 8; i++ )
1004 : {
1005 1631280 : id = Idx[i];
1006 1631280 : x[id] = z[2 * i];
1007 1631280 : y[id] = z[2 * i + 1];
1008 : }
1009 :
1010 203910 : return;
1011 : }
1012 :
1013 : /*-----------------------------------------------------------------*
1014 : * fft8_5()
1015 : * 8-point FFT with shift 5
1016 : *-----------------------------------------------------------------*/
1017 :
1018 21220 : static void fft8_5(
1019 : float *x, /* i/o: real part of input and output data */
1020 : float *y, /* i/o: imaginary part of input and output data */
1021 : const int16_t *Idx /* i : pointer of the address table */
1022 : )
1023 : {
1024 : int16_t i, id, jd;
1025 : float z[16];
1026 :
1027 190980 : for ( i = 0; i < 8; i++ )
1028 : {
1029 169760 : id = Idx[i];
1030 169760 : z[2 * i] = x[id];
1031 169760 : z[2 * i + 1] = y[id];
1032 : }
1033 :
1034 21220 : cdftForw( 16, z, Ip_fft8, w_fft8 );
1035 :
1036 190980 : for ( i = 0; i < 8; i++ )
1037 : {
1038 169760 : jd = Odx_fft8_5[i];
1039 169760 : id = Idx[jd];
1040 169760 : x[id] = z[2 * i];
1041 169760 : y[id] = z[2 * i + 1];
1042 : }
1043 21220 : return;
1044 : }
1045 :
1046 : /*-----------------------------------------------------------------*
1047 : * fft5_8()
1048 : * 5-point FFT with shift 2
1049 : *-----------------------------------------------------------------*/
1050 :
1051 33952 : static void fft5_8(
1052 : int16_t n1, /* i : length of data */
1053 : float *zRe, /* i/o: real part of input and output data */
1054 : float *zIm, /* i/o: imaginary part of input and output data */
1055 : const int16_t *Idx /* i : pointer of the address table */
1056 : )
1057 : {
1058 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8;
1059 : float fo1, fo2, fo3, fo4, fo5, fo6, fo7, fo8;
1060 : int16_t in1, in2, in3, in4, in5;
1061 :
1062 33952 : in1 = Idx[0];
1063 33952 : in2 = Idx[n1];
1064 33952 : in3 = Idx[n1 * 2];
1065 33952 : in4 = Idx[n1 * 3];
1066 33952 : in5 = Idx[n1 * 4];
1067 :
1068 33952 : fi1 = zRe[in1];
1069 33952 : fi2 = zIm[in1];
1070 33952 : fo3 = zRe[in2];
1071 33952 : fo4 = zRe[in5];
1072 33952 : fo6 = zRe[in3];
1073 33952 : fo7 = zRe[in4];
1074 :
1075 33952 : fo5 = fo3 + fo4;
1076 33952 : fo8 = fo6 + fo7;
1077 33952 : fi3 = fo5 + fo8;
1078 33952 : fi4 = fo6 - fo7;
1079 33952 : fi5 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
1080 33952 : fi6 = fo3 - fo4;
1081 :
1082 33952 : fo3 = zIm[in2];
1083 33952 : fo4 = zIm[in5];
1084 33952 : fo6 = zIm[in3];
1085 33952 : fo7 = zIm[in4];
1086 :
1087 33952 : fo5 = fo3 + fo4;
1088 33952 : fo8 = fo6 + fo7;
1089 33952 : fi7 = fo3 - fo4;
1090 33952 : fi8 = fo5 + fo8;
1091 33952 : fo1 = fo6 - fo7;
1092 33952 : fo2 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
1093 :
1094 33952 : zRe[in1] = fi1 + fi3;
1095 33952 : zIm[in1] = fi2 + fi8;
1096 :
1097 33952 : fo3 = FFT_15PONIT_WNK2 * fi7 + FFT_15PONIT_WNK3 * fo1;
1098 33952 : fo4 = FFT_15PONIT_WNK2 * fo1 - FFT_15PONIT_WNK3 * fi7;
1099 33952 : fo7 = fi1 - fi3 / 4;
1100 33952 : fo5 = fi5 + fo7;
1101 33952 : fo6 = fo7 - fi5;
1102 :
1103 33952 : zRe[in2] = fo6 - fo4;
1104 33952 : zRe[in3] = fo5 - fo3;
1105 33952 : zRe[in5] = fo6 + fo4;
1106 33952 : zRe[in4] = fo5 + fo3;
1107 :
1108 33952 : fo3 = FFT_15PONIT_WNK2 * fi6 + FFT_15PONIT_WNK3 * fi4;
1109 33952 : fo4 = FFT_15PONIT_WNK2 * fi4 - FFT_15PONIT_WNK3 * fi6;
1110 33952 : fo7 = fi2 - fi8 / 4;
1111 33952 : fo5 = fo2 + fo7;
1112 33952 : fo6 = fo7 - fo2;
1113 :
1114 33952 : zIm[in2] = fo4 + fo6;
1115 33952 : zIm[in3] = fo3 + fo5;
1116 33952 : zIm[in4] = fo5 - fo3;
1117 33952 : zIm[in5] = fo6 - fo4;
1118 :
1119 33952 : return;
1120 : }
1121 :
1122 : /*-----------------------------------------------------------------*
1123 : * fft4_5()
1124 : * 8-point FFT with shift 1
1125 : *-----------------------------------------------------------------*/
1126 :
1127 2440 : static void fft4_5(
1128 : float *x, /* i/o: real part of input and output data */
1129 : float *y, /* i/o: imaginary part of input and output data */
1130 : const int16_t *Idx /* i : pointer of the address table */
1131 : )
1132 : {
1133 : int16_t i, id, jd;
1134 : float z[8];
1135 :
1136 12200 : for ( i = 0; i < 4; i++ )
1137 : {
1138 9760 : id = Idx[i];
1139 9760 : z[2 * i] = x[id];
1140 9760 : z[2 * i + 1] = y[id];
1141 : }
1142 :
1143 2440 : cdftForw( 8, z, Ip_fft4, w_fft4 );
1144 :
1145 12200 : for ( i = 0; i < 4; i++ )
1146 : {
1147 9760 : jd = Odx_fft4_5[i];
1148 9760 : id = Idx[jd];
1149 9760 : x[id] = z[2 * i];
1150 9760 : y[id] = z[2 * i + 1];
1151 : }
1152 2440 : return;
1153 : }
1154 :
1155 : /*-----------------------------------------------------------------*
1156 : * fft5_4()
1157 : * 5-point FFT with shift 4
1158 : *-----------------------------------------------------------------*/
1159 :
1160 1952 : static void fft5_4(
1161 : int16_t n1,
1162 : float *zRe,
1163 : float *zIm,
1164 : const int16_t *Idx )
1165 : {
1166 : float fi1, fi2, fi3, fi4, fi5, fi6, fi7, fi8;
1167 : float fo1, fo2, fo3, fo4, fo5, fo6, fo7, fo8;
1168 : int16_t in1, in2, in3, in4, in5;
1169 :
1170 1952 : in1 = Idx[0];
1171 1952 : in2 = Idx[n1];
1172 1952 : in3 = Idx[n1 * 2];
1173 1952 : in4 = Idx[n1 * 3];
1174 1952 : in5 = Idx[n1 * 4];
1175 :
1176 1952 : fi1 = zRe[in1];
1177 1952 : fi2 = zIm[in1];
1178 1952 : fo3 = zRe[in2];
1179 1952 : fo4 = zRe[in5];
1180 1952 : fo6 = zRe[in3];
1181 1952 : fo7 = zRe[in4];
1182 :
1183 1952 : fo5 = fo3 + fo4;
1184 1952 : fo8 = fo6 + fo7;
1185 1952 : fi3 = fo5 + fo8;
1186 1952 : fi4 = fo6 - fo7;
1187 1952 : fi5 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
1188 1952 : fi6 = fo3 - fo4;
1189 :
1190 1952 : fo3 = zIm[in2];
1191 1952 : fo4 = zIm[in5];
1192 1952 : fo6 = zIm[in3];
1193 1952 : fo7 = zIm[in4];
1194 :
1195 1952 : fo5 = fo3 + fo4;
1196 1952 : fo8 = fo6 + fo7;
1197 1952 : fi7 = fo3 - fo4;
1198 1952 : fi8 = fo5 + fo8;
1199 1952 : fo1 = fo6 - fo7;
1200 1952 : fo2 = FFT_15PONIT_WNK1 * ( fo5 - fo8 );
1201 :
1202 1952 : zRe[in1] = fi1 + fi3;
1203 1952 : zIm[in1] = fi2 + fi8;
1204 :
1205 1952 : fo3 = FFT_15PONIT_WNK2 * fi7 + FFT_15PONIT_WNK3 * fo1;
1206 1952 : fo4 = FFT_15PONIT_WNK2 * fo1 - FFT_15PONIT_WNK3 * fi7;
1207 1952 : fo7 = fi1 - fi3 / 4;
1208 1952 : fo5 = fi5 + fo7;
1209 1952 : fo6 = fo7 - fi5;
1210 :
1211 1952 : zRe[in2] = fo5 - fo3;
1212 1952 : zRe[in4] = fo6 - fo4;
1213 1952 : zRe[in3] = fo6 + fo4;
1214 1952 : zRe[in5] = fo5 + fo3;
1215 :
1216 1952 : fo3 = FFT_15PONIT_WNK2 * fi6 + FFT_15PONIT_WNK3 * fi4;
1217 1952 : fo4 = FFT_15PONIT_WNK2 * fi4 - FFT_15PONIT_WNK3 * fi6;
1218 1952 : fo7 = fi2 - fi8 / 4;
1219 1952 : fo5 = fo2 + fo7;
1220 1952 : fo6 = fo7 - fo2;
1221 :
1222 1952 : zIm[in2] = fo3 + fo5;
1223 1952 : zIm[in3] = fo6 - fo4;
1224 1952 : zIm[in4] = fo4 + fo6;
1225 1952 : zIm[in5] = fo5 - fo3;
1226 :
1227 1952 : return;
1228 : }
1229 :
1230 :
1231 : /*-----------------------------------------------------------------*
1232 : * DoRTFT80()
1233 : * a low complexity 2-dimensional DFT of 80 points
1234 : *-----------------------------------------------------------------*/
1235 :
1236 326338 : void DoRTFT80(
1237 : float *x, /* i/o: real part of input and output data */
1238 : float *y /* i/o: imaginary part of input and output data */
1239 : )
1240 : {
1241 : int16_t j;
1242 :
1243 : /* Applying 16-point FFT for 5 times based on the address table Idx_dortft80 */
1244 1958028 : for ( j = 0; j < 5; j++ )
1245 : {
1246 1631690 : fft16( x, y, Idx_dortft80 + 16 * j );
1247 : }
1248 :
1249 : /* Applying 5-point FFT for 16 times based on the address table Idx_dortft80 */
1250 5547746 : for ( j = 0; j < 16; j++ )
1251 : {
1252 5221408 : fft5_shift1( 16, x, y, Idx_dortft80 + j );
1253 : }
1254 :
1255 326338 : return;
1256 : }
1257 :
1258 : /*-----------------------------------------------------------------*
1259 : * DoRTFT120()
1260 : * a low complexity 2-dimensional DFT of 120 points
1261 : *-----------------------------------------------------------------*/
1262 :
1263 13594 : void DoRTFT120(
1264 : float *x, /* i/o: real part of input and output data */
1265 : float *y /* i/o: imaginary part of input and output data */
1266 : )
1267 : {
1268 : int16_t j;
1269 :
1270 : /* Applying 8-point FFT for 15 times based on the address table Idx_dortft120 */
1271 217504 : for ( j = 0; j < 15; j++ )
1272 : {
1273 203910 : fft8( x, y, Idx_dortft120 + 8 * j );
1274 : }
1275 :
1276 : /* Applying 15-point FFT for 8 times based on the address table Idx_dortft120 */
1277 122346 : for ( j = 0; j < 8; j++ )
1278 : {
1279 108752 : fft15_shift2( 8, x, y, Idx_dortft120 + j );
1280 : }
1281 :
1282 13594 : return;
1283 : }
1284 :
1285 : /*-----------------------------------------------------------------*
1286 : * DoRTFT160()
1287 : * a low complexity 2-dimensional DFT of 160 points
1288 : *-----------------------------------------------------------------*/
1289 :
1290 464658 : void DoRTFT160(
1291 : float x[], /* i/o: real part of input and output data */
1292 : float y[] /* i/o: imaginary part of input and output data */
1293 : )
1294 : {
1295 : int16_t j;
1296 :
1297 : /* Applying 32-point FFT for 5 times based on the address table Idx_dortft160 */
1298 2787948 : for ( j = 0; j < 5; j++ )
1299 : {
1300 2323290 : fft32_5( x, y, Idx_dortft160 + 32 * j );
1301 : }
1302 :
1303 : /* Applying 5-point FFT for 32 times based on the address table Idx_dortft160 */
1304 15333714 : for ( j = 0; j < 32; j++ )
1305 : {
1306 14869056 : fft5_32( x, y, Idx_dortft160 + j );
1307 : }
1308 :
1309 464658 : return;
1310 : }
1311 :
1312 : /*-----------------------------------------------------------------*
1313 : * DoRTFT320()
1314 : * a low complexity 2-dimensional DFT of 320 points
1315 : *-----------------------------------------------------------------*/
1316 :
1317 6826425 : void DoRTFT320(
1318 : float *x, /* i/o: real part of input and output data */
1319 : float *y /* i/o: imaginary part of input and output data */
1320 : )
1321 : {
1322 : int16_t j;
1323 :
1324 : /* Applying 64-point FFT for 5 times based on the address table Idx_dortft160 */
1325 40958550 : for ( j = 0; j < 5; j++ )
1326 : {
1327 34132125 : fft64( x, y, Idx_dortft320 + 64 * j );
1328 : }
1329 :
1330 : /* Applying 5-point FFT for 64 times based on the address table Idx_dortft160 */
1331 443717625 : for ( j = 0; j < 64; j++ )
1332 : {
1333 436891200 : fft5_shift4( 64, x, y, Idx_dortft320 + j );
1334 : }
1335 :
1336 6826425 : return;
1337 : }
1338 :
1339 : /*-----------------------------------------------------------------*
1340 : * DoRTFT480()
1341 : * a low complexity 2-dimensional DFT of 480 points
1342 : *-----------------------------------------------------------------*/
1343 :
1344 346805 : void DoRTFT480(
1345 : float *x, /* i/o: real part of input and output data */
1346 : float *y /* i/o: imaginary part of input and output data */
1347 : )
1348 : {
1349 : int16_t j;
1350 :
1351 : /* Applying 32-point FFT for 15 times based on the address table Idx_dortft160 */
1352 5548880 : for ( j = 0; j < 15; j++ )
1353 : {
1354 5202075 : fft32_15( x, y, Idx_dortft480 + 32 * j );
1355 : }
1356 :
1357 : /* Applying 5-point FFT for 32 times based on the address table Idx_dortft160 */
1358 11444565 : for ( j = 0; j < 32; j++ )
1359 : {
1360 11097760 : fft15_shift8( 32, x, y, Idx_dortft480 + j );
1361 : }
1362 :
1363 346805 : return;
1364 : }
1365 :
1366 : /*-----------------------------------------------------------------*
1367 : * DoRTFT40()
1368 : * a low complexity 2-dimensional DFT of 40 points
1369 : *-----------------------------------------------------------------*/
1370 :
1371 4244 : void DoRTFT40(
1372 : float *x, /* i/o: real part of input and output data */
1373 : float *y /* i/o: imaginary part of input and output data */
1374 : )
1375 : {
1376 : int16_t j;
1377 : /* Applying 8-point FFT for 5 times based on the address table Idx_dortft40 */
1378 25464 : for ( j = 0; j < 5; j++ )
1379 : {
1380 21220 : fft8_5( x, y, Idx_dortft40 + 8 * j );
1381 : }
1382 :
1383 : /* Applying 5-point FFT for 8 times based on the address table Idx_dortft40 */
1384 38196 : for ( j = 0; j < 8; j++ )
1385 : {
1386 33952 : fft5_8( 8, x, y, Idx_dortft40 + j );
1387 : }
1388 :
1389 4244 : return;
1390 : }
1391 :
1392 : /*-----------------------------------------------------------------*
1393 : * DoRTFT20()
1394 : * a low complexity 2-dimensional DFT of 20 points
1395 : *-----------------------------------------------------------------*/
1396 :
1397 488 : void DoRTFT20(
1398 : float *x, /* i/o: real part of input and output data */
1399 : float *y /* i/o: imaginary part of input and output data */
1400 : )
1401 : {
1402 : int16_t j;
1403 :
1404 : /* Applying 4-point FFT for 5 times based on the address table Idx_dortft20 */
1405 2928 : for ( j = 0; j < 5; j++ )
1406 : {
1407 2440 : fft4_5( x, y, Idx_dortft20 + 4 * j );
1408 : }
1409 :
1410 : /* Applying 5-point FFT for 4 times based on the address table Idx_dortft20 */
1411 2440 : for ( j = 0; j < 4; j++ )
1412 : {
1413 1952 : fft5_4( 4, x, y, Idx_dortft20 + j );
1414 : }
1415 :
1416 488 : return;
1417 : }
1418 :
1419 : /*-----------------------------------------------------------------*
1420 : * DoRTFT128()
1421 : * FFT with 128 points
1422 : *-----------------------------------------------------------------*/
1423 :
1424 18621234 : void DoRTFT128(
1425 : float *x, /* i/o: real part of input and output data */
1426 : float *y /* i/o: imaginary part of input and output data */
1427 : )
1428 : {
1429 :
1430 : int16_t i;
1431 : float z[256];
1432 :
1433 2402139186 : for ( i = 0; i < 128; i++ )
1434 : {
1435 2383517952 : z[2 * i] = x[i];
1436 2383517952 : z[2 * i + 1] = y[i];
1437 : }
1438 :
1439 18621234 : cdftForw( 256, z, Ip_fft128, w_fft128 );
1440 :
1441 18621234 : x[0] = z[0];
1442 18621234 : y[0] = z[1];
1443 2383517952 : for ( i = 1; i < 128; i++ )
1444 : {
1445 2364896718 : x[128 - i] = z[2 * i];
1446 2364896718 : y[128 - i] = z[2 * i + 1];
1447 : }
1448 :
1449 18621234 : return;
1450 : }
1451 :
1452 : /*-----------------------------------------------------------------*
1453 : * cdftForw()
1454 : * Main fuction of Complex Discrete Fourier Transform
1455 : *-----------------------------------------------------------------*/
1456 :
1457 238332750 : static void cdftForw(
1458 : int16_t n, /* i : data length of real and imag */
1459 : float *a, /* i/o: input/output data */
1460 : const int16_t *ip, /* i : work area for bit reversal */
1461 : const float *w /* i : cos/sin table */
1462 : )
1463 : {
1464 : /* bit reversal */
1465 238332750 : bitrv2_SR( n, ip + 2, a );
1466 :
1467 : /* Do FFT */
1468 238332750 : cftfsub( n, a, w );
1469 238332750 : }
1470 :
1471 : /*-----------------------------------------------------------------*
1472 : * bitrv2_SR()
1473 : * Bit reversal
1474 : *-----------------------------------------------------------------*/
1475 :
1476 240505650 : static void bitrv2_SR(
1477 : int16_t n, /* i : data length of real and imag */
1478 : const int16_t *ip, /* i/o: work area for bit reversal */
1479 : float *a /* i/o: input/output data */
1480 : )
1481 : {
1482 : int16_t j, j1, k, k1, m, m2;
1483 : int16_t l;
1484 : float xr, xi, yr, yi;
1485 :
1486 240505650 : if ( n == 64 )
1487 : {
1488 9698265 : m = 4;
1489 9698265 : l = -1;
1490 : }
1491 230807385 : else if ( n == 256 )
1492 : {
1493 18621242 : m = 8;
1494 18621242 : l = -1;
1495 : }
1496 212186143 : else if ( n == 16 )
1497 : {
1498 225130 : m = 2;
1499 225130 : l = -1;
1500 : }
1501 : else
1502 : {
1503 211961013 : l = n;
1504 211961013 : m = 1;
1505 :
1506 930539102 : while ( ( m << 3 ) < l )
1507 : {
1508 718578089 : l >>= 1;
1509 718578089 : m <<= 1;
1510 : }
1511 211961013 : l -= m * 8;
1512 : }
1513 :
1514 240505650 : m2 = 2 * m;
1515 :
1516 240505650 : if ( l == 0 )
1517 : {
1518 679405342 : for ( k = 0; k < m; k++ )
1519 : {
1520 2361208556 : for ( j = 0; j < k; j++ )
1521 : {
1522 1773580820 : j1 = 2 * j + ip[k];
1523 1773580820 : k1 = 2 * k + ip[j];
1524 1773580820 : xr = a[j1];
1525 1773580820 : xi = a[j1 + 1];
1526 1773580820 : yr = a[k1];
1527 1773580820 : yi = a[k1 + 1];
1528 1773580820 : a[j1] = yr;
1529 1773580820 : a[j1 + 1] = yi;
1530 1773580820 : a[k1] = xr;
1531 1773580820 : a[k1 + 1] = xi;
1532 1773580820 : j1 += m2;
1533 1773580820 : k1 += 2 * m2;
1534 1773580820 : xr = a[j1];
1535 1773580820 : xi = a[j1 + 1];
1536 1773580820 : yr = a[k1];
1537 1773580820 : yi = a[k1 + 1];
1538 1773580820 : a[j1] = yr;
1539 1773580820 : a[j1 + 1] = yi;
1540 1773580820 : a[k1] = xr;
1541 1773580820 : a[k1 + 1] = xi;
1542 1773580820 : j1 += m2;
1543 1773580820 : k1 -= m2;
1544 1773580820 : xr = a[j1];
1545 1773580820 : xi = a[j1 + 1];
1546 1773580820 : yr = a[k1];
1547 1773580820 : yi = a[k1 + 1];
1548 1773580820 : a[j1] = yr;
1549 1773580820 : a[j1 + 1] = yi;
1550 1773580820 : a[k1] = xr;
1551 1773580820 : a[k1 + 1] = xi;
1552 1773580820 : j1 += m2;
1553 1773580820 : k1 += 2 * m2;
1554 1773580820 : xr = a[j1];
1555 1773580820 : xi = a[j1 + 1];
1556 1773580820 : yr = a[k1];
1557 1773580820 : yi = a[k1 + 1];
1558 1773580820 : a[j1] = yr;
1559 1773580820 : a[j1 + 1] = yi;
1560 1773580820 : a[k1] = xr;
1561 1773580820 : a[k1 + 1] = xi;
1562 : }
1563 :
1564 587627736 : j1 = 2 * k + m2 + ip[k];
1565 587627736 : k1 = j1 + m2;
1566 587627736 : xr = a[j1];
1567 587627736 : xi = a[j1 + 1];
1568 587627736 : yr = a[k1];
1569 587627736 : yi = a[k1 + 1];
1570 587627736 : a[j1] = yr;
1571 587627736 : a[j1 + 1] = yi;
1572 587627736 : a[k1] = xr;
1573 587627736 : a[k1 + 1] = xi;
1574 : }
1575 : }
1576 : else
1577 : {
1578 2111147768 : for ( k = 1; k < m; k++ )
1579 : {
1580 16964238060 : for ( j = 0; j < k; j++ )
1581 : {
1582 15001818336 : j1 = 2 * j + ip[k];
1583 15001818336 : k1 = 2 * k + ip[j];
1584 15001818336 : xr = a[j1];
1585 15001818336 : xi = a[j1 + 1];
1586 15001818336 : yr = a[k1];
1587 15001818336 : yi = a[k1 + 1];
1588 15001818336 : a[j1] = yr;
1589 15001818336 : a[j1 + 1] = yi;
1590 15001818336 : a[k1] = xr;
1591 15001818336 : a[k1 + 1] = xi;
1592 15001818336 : j1 += m2;
1593 15001818336 : k1 += m2;
1594 15001818336 : xr = a[j1];
1595 15001818336 : xi = a[j1 + 1];
1596 15001818336 : yr = a[k1];
1597 15001818336 : yi = a[k1 + 1];
1598 15001818336 : a[j1] = yr;
1599 15001818336 : a[j1 + 1] = yi;
1600 15001818336 : a[k1] = xr;
1601 15001818336 : a[k1 + 1] = xi;
1602 : }
1603 : }
1604 : }
1605 :
1606 240505650 : return;
1607 : }
1608 :
1609 : /*-----------------------------------------------------------------*
1610 : * cftfsub()
1611 : * Complex Discrete Fourier Transform
1612 : *-----------------------------------------------------------------*/
1613 :
1614 240058675 : static void cftfsub(
1615 : int16_t n, /* i : data length of real and imag */
1616 : float *a, /* i/o: input/output data */
1617 : const float *w /* i : cos/sin table */
1618 : )
1619 : {
1620 : int16_t j, j1, j2, j3, l;
1621 : float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
1622 :
1623 240058675 : l = 2;
1624 240058675 : if ( n > 8 )
1625 : {
1626 240056235 : cft1st( n, a, w );
1627 :
1628 240056235 : l = 8;
1629 793169525 : while ( ( l << 2 ) < n )
1630 : {
1631 553113290 : cftmdl( n, l, a, w );
1632 553113290 : l <<= 2;
1633 : }
1634 : }
1635 :
1636 240058675 : if ( ( l << 2 ) == n )
1637 : {
1638 4226566982 : for ( j = 0; j < l; j += 2 )
1639 : {
1640 4134789376 : j1 = j + l;
1641 4134789376 : j2 = j1 + l;
1642 4134789376 : j3 = j2 + l;
1643 4134789376 : x0r = a[j] + a[j1];
1644 4134789376 : x0i = a[j + 1] + a[j1 + 1];
1645 4134789376 : x1r = a[j] - a[j1];
1646 4134789376 : x1i = a[j + 1] - a[j1 + 1];
1647 4134789376 : x2r = a[j2] + a[j3];
1648 4134789376 : x2i = a[j2 + 1] + a[j3 + 1];
1649 4134789376 : x3r = a[j2] - a[j3];
1650 4134789376 : x3i = a[j2 + 1] - a[j3 + 1];
1651 4134789376 : a[j] = x0r + x2r;
1652 4134789376 : a[j + 1] = x0i + x2i;
1653 4134789376 : a[j2] = x0r - x2r;
1654 4134789376 : a[j2 + 1] = x0i - x2i;
1655 4134789376 : a[j1] = x1r - x3i;
1656 4134789376 : a[j1 + 1] = x1i + x3r;
1657 4134789376 : a[j3] = x1r + x3i;
1658 4134789376 : a[j3 + 1] = x1i - x3r;
1659 : }
1660 : }
1661 : else
1662 : {
1663 32255913909 : for ( j = 0; j < l; j += 2 )
1664 : {
1665 32107632840 : j1 = j + l;
1666 32107632840 : x0r = a[j] - a[j1];
1667 32107632840 : x0i = a[j + 1] - a[j1 + 1];
1668 32107632840 : a[j] += a[j1];
1669 32107632840 : a[j + 1] += a[j1 + 1];
1670 32107632840 : a[j1] = x0r;
1671 32107632840 : a[j1 + 1] = x0i;
1672 : }
1673 : }
1674 :
1675 240058675 : return;
1676 : }
1677 :
1678 : /*-----------------------------------------------------------------*
1679 : * cft1st()
1680 : * Subfunction of Complex Discrete Fourier Transform
1681 : *-----------------------------------------------------------------*/
1682 :
1683 240503210 : static void cft1st(
1684 : int16_t n, /* i : data length of real and imag */
1685 : float *a, /* i/o: input/output data */
1686 : const float *w /* i : cos/sin table */
1687 : )
1688 : {
1689 : int16_t j, k1, k2;
1690 : float wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
1691 : float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
1692 :
1693 240503210 : x0r = a[0] + a[2];
1694 240503210 : x0i = a[1] + a[3];
1695 240503210 : x1r = a[0] - a[2];
1696 240503210 : x1i = a[1] - a[3];
1697 240503210 : x2r = a[4] + a[6];
1698 240503210 : x2i = a[5] + a[7];
1699 240503210 : x3r = a[4] - a[6];
1700 240503210 : x3i = a[5] - a[7];
1701 240503210 : a[0] = x0r + x2r;
1702 240503210 : a[1] = x0i + x2i;
1703 240503210 : a[4] = x0r - x2r;
1704 240503210 : a[5] = x0i - x2i;
1705 240503210 : a[2] = x1r - x3i;
1706 240503210 : a[3] = x1i + x3r;
1707 240503210 : a[6] = x1r + x3i;
1708 240503210 : a[7] = x1i - x3r;
1709 240503210 : wk1r = w[2];
1710 240503210 : x0r = a[8] + a[10];
1711 240503210 : x0i = a[9] + a[11];
1712 240503210 : x1r = a[8] - a[10];
1713 240503210 : x1i = a[9] - a[11];
1714 240503210 : x2r = a[12] + a[14];
1715 240503210 : x2i = a[13] + a[15];
1716 240503210 : x3r = a[12] - a[14];
1717 240503210 : x3i = a[13] - a[15];
1718 240503210 : a[8] = x0r + x2r;
1719 240503210 : a[9] = x0i + x2i;
1720 240503210 : a[12] = x2i - x0i;
1721 240503210 : a[13] = x0r - x2r;
1722 240503210 : x0r = x1r - x3i;
1723 240503210 : x0i = x1i + x3r;
1724 240503210 : a[10] = wk1r * ( x0r - x0i );
1725 240503210 : a[11] = wk1r * ( x0r + x0i );
1726 240503210 : x0r = x3i + x1r;
1727 240503210 : x0i = x3r - x1i;
1728 240503210 : a[14] = wk1r * ( x0i - x0r );
1729 240503210 : a[15] = wk1r * ( x0i + x0r );
1730 240503210 : k1 = 0;
1731 :
1732 10096089578 : for ( j = 16; j < n; j += 16 )
1733 : {
1734 9855586368 : k1 += 2;
1735 9855586368 : k2 = 2 * k1;
1736 9855586368 : wk2r = w[k1];
1737 9855586368 : wk2i = w[k1 + 1];
1738 9855586368 : wk1r = w[k2];
1739 9855586368 : wk1i = w[k2 + 1];
1740 9855586368 : wk3r = wk1r - 2 * wk2i * wk1i;
1741 9855586368 : wk3i = 2 * wk2i * wk1r - wk1i;
1742 9855586368 : x0r = a[j] + a[j + 2];
1743 9855586368 : x0i = a[j + 1] + a[j + 3];
1744 9855586368 : x1r = a[j] - a[j + 2];
1745 9855586368 : x1i = a[j + 1] - a[j + 3];
1746 9855586368 : x2r = a[j + 4] + a[j + 6];
1747 9855586368 : x2i = a[j + 5] + a[j + 7];
1748 9855586368 : x3r = a[j + 4] - a[j + 6];
1749 9855586368 : x3i = a[j + 5] - a[j + 7];
1750 9855586368 : a[j] = x0r + x2r;
1751 9855586368 : a[j + 1] = x0i + x2i;
1752 9855586368 : x0r -= x2r;
1753 9855586368 : x0i -= x2i;
1754 9855586368 : a[j + 4] = wk2r * x0r - wk2i * x0i;
1755 9855586368 : a[j + 5] = wk2r * x0i + wk2i * x0r;
1756 9855586368 : x0r = x1r - x3i;
1757 9855586368 : x0i = x1i + x3r;
1758 9855586368 : a[j + 2] = wk1r * x0r - wk1i * x0i;
1759 9855586368 : a[j + 3] = wk1r * x0i + wk1i * x0r;
1760 9855586368 : x0r = x1r + x3i;
1761 9855586368 : x0i = x1i - x3r;
1762 9855586368 : a[j + 6] = wk3r * x0r - wk3i * x0i;
1763 9855586368 : a[j + 7] = wk3r * x0i + wk3i * x0r;
1764 9855586368 : wk1r = w[k2 + 2];
1765 9855586368 : wk1i = w[k2 + 3];
1766 9855586368 : wk3r = wk1r - 2 * wk2r * wk1i;
1767 9855586368 : wk3i = 2 * wk2r * wk1r - wk1i;
1768 9855586368 : x0r = a[j + 8] + a[j + 10];
1769 9855586368 : x0i = a[j + 9] + a[j + 11];
1770 9855586368 : x1r = a[j + 8] - a[j + 10];
1771 9855586368 : x1i = a[j + 9] - a[j + 11];
1772 9855586368 : x2r = a[j + 12] + a[j + 14];
1773 9855586368 : x2i = a[j + 13] + a[j + 15];
1774 9855586368 : x3r = a[j + 12] - a[j + 14];
1775 9855586368 : x3i = a[j + 13] - a[j + 15];
1776 9855586368 : a[j + 8] = x0r + x2r;
1777 9855586368 : a[j + 9] = x0i + x2i;
1778 9855586368 : x0r -= x2r;
1779 9855586368 : x0i -= x2i;
1780 9855586368 : a[j + 12] = -wk2i * x0r - wk2r * x0i;
1781 9855586368 : a[j + 13] = -wk2i * x0i + wk2r * x0r;
1782 9855586368 : x0r = x1r - x3i;
1783 9855586368 : x0i = x1i + x3r;
1784 9855586368 : a[j + 10] = wk1r * x0r - wk1i * x0i;
1785 9855586368 : a[j + 11] = wk1r * x0i + wk1i * x0r;
1786 9855586368 : x0r = x1r + x3i;
1787 9855586368 : x0i = x1i - x3r;
1788 9855586368 : a[j + 14] = wk3r * x0r - wk3i * x0i;
1789 9855586368 : a[j + 15] = wk3r * x0i + wk3i * x0r;
1790 : }
1791 :
1792 240503210 : return;
1793 : }
1794 :
1795 : /*-----------------------------------------------------------------*
1796 : * cftmdl()
1797 : * Subfunction of Complex Discrete Fourier Transform
1798 : *-----------------------------------------------------------------*/
1799 :
1800 553560265 : static void cftmdl(
1801 : int16_t n, /* i : data length of real and imag */
1802 : int16_t l, /* i : initial shift for processing */
1803 : float *a, /* i/o: input/output data */
1804 : const float *w /* i : cos/sin table */
1805 : )
1806 : {
1807 : int16_t j, j1, j2, j3, k, k1, k2, m, m2;
1808 : float wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
1809 : float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
1810 :
1811 553560265 : m = l << 2;
1812 12316079777 : for ( j = 0; j < l; j += 2 )
1813 : {
1814 11762519512 : j1 = j + l;
1815 11762519512 : j2 = j1 + l;
1816 11762519512 : j3 = j2 + l;
1817 11762519512 : x0r = a[j] + a[j1];
1818 11762519512 : x0i = a[j + 1] + a[j1 + 1];
1819 11762519512 : x1r = a[j] - a[j1];
1820 11762519512 : x1i = a[j + 1] - a[j1 + 1];
1821 11762519512 : x2r = a[j2] + a[j3];
1822 11762519512 : x2i = a[j2 + 1] + a[j3 + 1];
1823 11762519512 : x3r = a[j2] - a[j3];
1824 11762519512 : x3i = a[j2 + 1] - a[j3 + 1];
1825 11762519512 : a[j] = x0r + x2r;
1826 11762519512 : a[j + 1] = x0i + x2i;
1827 11762519512 : a[j2] = x0r - x2r;
1828 11762519512 : a[j2 + 1] = x0i - x2i;
1829 11762519512 : a[j1] = x1r - x3i;
1830 11762519512 : a[j1 + 1] = x1i + x3r;
1831 11762519512 : a[j3] = x1r + x3i;
1832 11762519512 : a[j3 + 1] = x1i - x3r;
1833 : }
1834 :
1835 553560265 : wk1r = w[2];
1836 12316079777 : for ( j = m; j < l + m; j += 2 )
1837 : {
1838 11762519512 : j1 = j + l;
1839 11762519512 : j2 = j1 + l;
1840 11762519512 : j3 = j2 + l;
1841 11762519512 : x0r = a[j] + a[j1];
1842 11762519512 : x0i = a[j + 1] + a[j1 + 1];
1843 11762519512 : x1r = a[j] - a[j1];
1844 11762519512 : x1i = a[j + 1] - a[j1 + 1];
1845 11762519512 : x2r = a[j2] + a[j3];
1846 11762519512 : x2i = a[j2 + 1] + a[j3 + 1];
1847 11762519512 : x3r = a[j2] - a[j3];
1848 11762519512 : x3i = a[j2 + 1] - a[j3 + 1];
1849 11762519512 : a[j] = x0r + x2r;
1850 11762519512 : a[j + 1] = x0i + x2i;
1851 11762519512 : a[j2] = x2i - x0i;
1852 11762519512 : a[j2 + 1] = x0r - x2r;
1853 11762519512 : x0r = x1r - x3i;
1854 11762519512 : x0i = x1i + x3r;
1855 11762519512 : a[j1] = wk1r * ( x0r - x0i );
1856 11762519512 : a[j1 + 1] = wk1r * ( x0r + x0i );
1857 11762519512 : x0r = x3i + x1r;
1858 11762519512 : x0i = x3r - x1i;
1859 11762519512 : a[j3] = wk1r * ( x0i - x0r );
1860 11762519512 : a[j3 + 1] = wk1r * ( x0i + x0r );
1861 : }
1862 :
1863 553560265 : k1 = 0;
1864 553560265 : m2 = 2 * m;
1865 3254603734 : for ( k = m2; k < n; k += m2 )
1866 : {
1867 2701043469 : k1 += 2;
1868 2701043469 : k2 = 2 * k1;
1869 2701043469 : wk2r = w[k1];
1870 2701043469 : wk2i = w[k1 + 1];
1871 2701043469 : wk1r = w[k2];
1872 2701043469 : wk1i = w[k2 + 1];
1873 2701043469 : wk3r = wk1r - 2 * wk2i * wk1i;
1874 2701043469 : wk3i = 2 * wk2i * wk1r - wk1i;
1875 18503438241 : for ( j = k; j < l + k; j += 2 )
1876 : {
1877 15802394772 : j1 = j + l;
1878 15802394772 : j2 = j1 + l;
1879 15802394772 : j3 = j2 + l;
1880 15802394772 : x0r = a[j] + a[j1];
1881 15802394772 : x0i = a[j + 1] + a[j1 + 1];
1882 15802394772 : x1r = a[j] - a[j1];
1883 15802394772 : x1i = a[j + 1] - a[j1 + 1];
1884 15802394772 : x2r = a[j2] + a[j3];
1885 15802394772 : x2i = a[j2 + 1] + a[j3 + 1];
1886 15802394772 : x3r = a[j2] - a[j3];
1887 15802394772 : x3i = a[j2 + 1] - a[j3 + 1];
1888 15802394772 : a[j] = x0r + x2r;
1889 15802394772 : a[j + 1] = x0i + x2i;
1890 15802394772 : x0r -= x2r;
1891 15802394772 : x0i -= x2i;
1892 15802394772 : a[j2] = wk2r * x0r - wk2i * x0i;
1893 15802394772 : a[j2 + 1] = wk2r * x0i + wk2i * x0r;
1894 15802394772 : x0r = x1r - x3i;
1895 15802394772 : x0i = x1i + x3r;
1896 15802394772 : a[j1] = wk1r * x0r - wk1i * x0i;
1897 15802394772 : a[j1 + 1] = wk1r * x0i + wk1i * x0r;
1898 15802394772 : x0r = x1r + x3i;
1899 15802394772 : x0i = x1i - x3r;
1900 15802394772 : a[j3] = wk3r * x0r - wk3i * x0i;
1901 15802394772 : a[j3 + 1] = wk3r * x0i + wk3i * x0r;
1902 : }
1903 :
1904 2701043469 : wk1r = w[k2 + 2];
1905 2701043469 : wk1i = w[k2 + 3];
1906 2701043469 : wk3r = wk1r - 2 * wk2r * wk1i;
1907 2701043469 : wk3i = 2 * wk2r * wk1r - wk1i;
1908 18503438241 : for ( j = k + m; j < l + ( k + m ); j += 2 )
1909 : {
1910 15802394772 : j1 = j + l;
1911 15802394772 : j2 = j1 + l;
1912 15802394772 : j3 = j2 + l;
1913 15802394772 : x0r = a[j] + a[j1];
1914 15802394772 : x0i = a[j + 1] + a[j1 + 1];
1915 15802394772 : x1r = a[j] - a[j1];
1916 15802394772 : x1i = a[j + 1] - a[j1 + 1];
1917 15802394772 : x2r = a[j2] + a[j3];
1918 15802394772 : x2i = a[j2 + 1] + a[j3 + 1];
1919 15802394772 : x3r = a[j2] - a[j3];
1920 15802394772 : x3i = a[j2 + 1] - a[j3 + 1];
1921 15802394772 : a[j] = x0r + x2r;
1922 15802394772 : a[j + 1] = x0i + x2i;
1923 15802394772 : x0r -= x2r;
1924 15802394772 : x0i -= x2i;
1925 15802394772 : a[j2] = -wk2i * x0r - wk2r * x0i;
1926 15802394772 : a[j2 + 1] = -wk2i * x0i + wk2r * x0r;
1927 15802394772 : x0r = x1r - x3i;
1928 15802394772 : x0i = x1i + x3r;
1929 15802394772 : a[j1] = wk1r * x0r - wk1i * x0i;
1930 15802394772 : a[j1 + 1] = wk1r * x0i + wk1i * x0r;
1931 15802394772 : x0r = x1r + x3i;
1932 15802394772 : x0i = x1i - x3r;
1933 15802394772 : a[j3] = wk3r * x0r - wk3i * x0i;
1934 15802394772 : a[j3 + 1] = wk3r * x0i + wk3i * x0r;
1935 : }
1936 : }
1937 :
1938 553560265 : return;
1939 : }
1940 :
1941 446975 : static void cftbsub(
1942 : int16_t n,
1943 : float *a,
1944 : const float *w /* i : cos/sin table */
1945 : )
1946 : {
1947 : int16_t j, j1, j2, j3, l;
1948 : float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
1949 :
1950 446975 : l = 2;
1951 446975 : if ( n > 8 )
1952 : {
1953 446975 : cft1st( n, a, w );
1954 446975 : l = 8;
1955 :
1956 893950 : while ( ( l << 2 ) < n )
1957 : {
1958 446975 : cftmdl( n, l, a, w );
1959 446975 : l <<= 2;
1960 : }
1961 : }
1962 :
1963 446975 : if ( ( l << 2 ) == n )
1964 : {
1965 0 : for ( j = 0; j < l; j += 2 )
1966 : {
1967 0 : j1 = j + l;
1968 0 : j2 = j1 + l;
1969 0 : j3 = j2 + l;
1970 0 : x0r = a[j] + a[j1];
1971 0 : x0i = -a[j + 1] - a[j1 + 1];
1972 0 : x1r = a[j] - a[j1];
1973 0 : x1i = -a[j + 1] + a[j1 + 1];
1974 0 : x2r = a[j2] + a[j3];
1975 0 : x2i = a[j2 + 1] + a[j3 + 1];
1976 0 : x3r = a[j2] - a[j3];
1977 0 : x3i = a[j2 + 1] - a[j3 + 1];
1978 0 : a[j] = x0r + x2r;
1979 0 : a[j + 1] = x0i - x2i;
1980 0 : a[j2] = x0r - x2r;
1981 0 : a[j2 + 1] = x0i + x2i;
1982 0 : a[j1] = x1r - x3i;
1983 0 : a[j1 + 1] = x1i - x3r;
1984 0 : a[j3] = x1r + x3i;
1985 0 : a[j3 + 1] = x1i + x3r;
1986 : }
1987 : }
1988 : else
1989 : {
1990 7598575 : for ( j = 0; j < l; j += 2 )
1991 : {
1992 7151600 : j1 = j + l;
1993 7151600 : x0r = a[j] - a[j1];
1994 7151600 : x0i = -a[j + 1] + a[j1 + 1];
1995 7151600 : a[j] += a[j1];
1996 7151600 : a[j + 1] = -a[j + 1] - a[j1 + 1];
1997 7151600 : a[j1] = x0r;
1998 7151600 : a[j1 + 1] = x0i;
1999 : }
2000 : }
2001 :
2002 446975 : return;
2003 : }
2004 :
2005 1725925 : static void rftfsub(
2006 : int16_t n,
2007 : float *a,
2008 : int16_t nc,
2009 : const float *c )
2010 : {
2011 : int16_t j, k, kk, ks, m;
2012 : float wkr, wki, xr, xi, yr, yi;
2013 :
2014 1725925 : m = n >> 1;
2015 1725925 : ks = 2 * nc / m;
2016 1725925 : kk = 0;
2017 27614800 : for ( j = 2; j < m; j += 2 )
2018 : {
2019 25888875 : k = n - j;
2020 25888875 : kk += ks;
2021 25888875 : wkr = 0.5f - c[nc - kk];
2022 25888875 : wki = c[kk];
2023 25888875 : xr = a[j] - a[k];
2024 25888875 : xi = a[j + 1] + a[k + 1];
2025 25888875 : yr = wkr * xr - wki * xi;
2026 25888875 : yi = wkr * xi + wki * xr;
2027 25888875 : a[j] -= yr;
2028 25888875 : a[j + 1] -= yi;
2029 25888875 : a[k] += yr;
2030 25888875 : a[k + 1] -= yi;
2031 : }
2032 :
2033 1725925 : return;
2034 : }
2035 :
2036 :
2037 446975 : static void rftbsub(
2038 : int16_t n,
2039 : float *a,
2040 : int16_t nc,
2041 : const float *c )
2042 : {
2043 : int16_t j, k, kk, ks, m;
2044 : float wkr, wki, xr, xi, yr, yi;
2045 :
2046 446975 : a[1] = -a[1];
2047 446975 : m = n >> 1;
2048 446975 : ks = 2 * nc / m;
2049 446975 : kk = 0;
2050 7151600 : for ( j = 2; j < m; j += 2 )
2051 : {
2052 6704625 : k = n - j;
2053 6704625 : kk += ks;
2054 6704625 : wkr = 0.5f - c[nc - kk];
2055 6704625 : wki = c[kk];
2056 6704625 : xr = a[j] - a[k];
2057 6704625 : xi = a[j + 1] + a[k + 1];
2058 6704625 : yr = wkr * xr + wki * xi;
2059 6704625 : yi = wkr * xi - wki * xr;
2060 6704625 : a[j] -= yr;
2061 6704625 : a[j + 1] = yi - a[j + 1];
2062 6704625 : a[k] += yr;
2063 6704625 : a[k + 1] = yi - a[k + 1];
2064 : }
2065 446975 : a[m + 1] = -a[m + 1];
2066 :
2067 446975 : return;
2068 : }
2069 :
2070 :
2071 2172900 : static void dctsub(
2072 : int16_t n,
2073 : float *a,
2074 : int16_t nc,
2075 : const float *c )
2076 : {
2077 : int16_t j, k, kk, ks, m;
2078 : float wkr, wki, xr;
2079 :
2080 2172900 : m = n >> 1;
2081 2172900 : ks = nc / n;
2082 2172900 : kk = 0;
2083 69532800 : for ( j = 1; j < m; j++ )
2084 : {
2085 67359900 : k = n - j;
2086 67359900 : kk += ks;
2087 67359900 : wkr = c[kk] - c[nc - kk];
2088 67359900 : wki = c[kk] + c[nc - kk];
2089 67359900 : xr = wki * a[j] - wkr * a[k];
2090 67359900 : a[j] = wkr * a[j] + wki * a[k];
2091 67359900 : a[k] = xr;
2092 : }
2093 2172900 : a[m] *= c[0];
2094 :
2095 2172900 : return;
2096 : }
2097 :
2098 :
2099 : /*-----------------------------------------------------------------*
2100 : * edct2()
2101 : *
2102 : * Transformation of the signal to DCT domain
2103 : * OR Inverse EDCT-II for short frames
2104 : *-----------------------------------------------------------------*/
2105 :
2106 2172900 : void edct2(
2107 : const int16_t n,
2108 : const int16_t isgn,
2109 : float *in,
2110 : float *a,
2111 : const int16_t *ip,
2112 : const float *w )
2113 : {
2114 : int16_t j, nw, nc;
2115 : float xr;
2116 :
2117 2172900 : mvr2r( in, a, n );
2118 :
2119 2172900 : nw = ip[0];
2120 2172900 : if ( n > ( nw << 2 ) )
2121 : {
2122 0 : nw = n >> 2;
2123 : }
2124 :
2125 2172900 : nc = ip[1];
2126 2172900 : if ( n > nc )
2127 : {
2128 0 : nc = n;
2129 : }
2130 :
2131 2172900 : if ( isgn < 0 )
2132 : {
2133 446975 : xr = a[n - 1];
2134 14303200 : for ( j = n - 2; j >= 2; j -= 2 )
2135 : {
2136 13856225 : a[j + 1] = a[j] - a[j - 1];
2137 13856225 : a[j] += a[j - 1];
2138 : }
2139 446975 : a[1] = a[0] - xr;
2140 446975 : a[0] += xr;
2141 :
2142 446975 : if ( n > 4 )
2143 : {
2144 446975 : rftbsub( n, a, nc, w + nw );
2145 446975 : bitrv2_SR( n, ip + 2, a );
2146 446975 : cftbsub( n, a, w );
2147 : }
2148 0 : else if ( n == 4 )
2149 : {
2150 0 : cftfsub( n, a, w );
2151 : }
2152 : }
2153 :
2154 2172900 : if ( isgn >= 0 )
2155 : {
2156 1725925 : a[0] *= 0.5f;
2157 : }
2158 :
2159 2172900 : dctsub( n, a, nc, w + nw );
2160 :
2161 2172900 : if ( isgn >= 0 )
2162 : {
2163 1725925 : if ( n > 4 )
2164 : {
2165 1725925 : bitrv2_SR( n, ip + 2, a );
2166 1725925 : cftfsub( n, a, w );
2167 1725925 : rftfsub( n, a, nc, w + nw );
2168 : }
2169 0 : else if ( n == 4 )
2170 : {
2171 0 : cftfsub( n, a, w );
2172 : }
2173 1725925 : xr = a[0] - a[1];
2174 1725925 : a[0] += a[1];
2175 55229600 : for ( j = 2; j < n; j += 2 )
2176 : {
2177 53503675 : a[j - 1] = a[j] - a[j + 1];
2178 53503675 : a[j] += a[j + 1];
2179 : }
2180 1725925 : a[n - 1] = xr;
2181 :
2182 112185125 : for ( j = 0; j < n; j++ )
2183 : {
2184 110459200 : a[j] /= 32.0f;
2185 : }
2186 : }
2187 2172900 : }
2188 :
2189 :
2190 176194766 : void DoRTFTn(
2191 : float *x, /* i/o: real part of input and output data */
2192 : float *y, /* i/o: imaginary part of input and output data */
2193 : const int16_t n /* i : size of the FFT up to 1024 */
2194 : )
2195 : {
2196 :
2197 : int16_t i;
2198 : float z[2048];
2199 :
2200 76038684878 : for ( i = 0; i < n; i++ )
2201 : {
2202 75862490112 : z[2 * i] = x[i];
2203 75862490112 : z[2 * i + 1] = y[i];
2204 : }
2205 :
2206 176194766 : switch ( n )
2207 : {
2208 42368 : case ( 16 ):
2209 42368 : cdftForw( 2 * n, z, Ip_fft16, w_fft16 );
2210 42368 : break;
2211 0 : case ( 32 ):
2212 0 : cdftForw( 2 * n, z, Ip_fft32, w_fft32 );
2213 0 : break;
2214 796 : case ( 64 ):
2215 796 : cdftForw( 2 * n, z, Ip_fft64, w_fft64 );
2216 796 : break;
2217 8 : case ( 128 ):
2218 8 : cdftForw( 2 * n, z, Ip_fft128, w_fft128 );
2219 8 : break;
2220 55968187 : case ( 256 ):
2221 55968187 : cdftForw( 2 * n, z, Ip_fft256, w_fft256 );
2222 55968187 : break;
2223 120183407 : case ( 512 ):
2224 120183407 : cdftForw( 2 * n, z, Ip_fft512, w_fft512 );
2225 120183407 : break;
2226 0 : default:
2227 0 : assert( 0 );
2228 : }
2229 :
2230 176194766 : x[0] = z[0];
2231 176194766 : y[0] = z[1];
2232 75862490112 : for ( i = 1; i < n; i++ )
2233 : {
2234 75686295346 : x[n - i] = z[2 * i];
2235 75686295346 : y[n - i] = z[2 * i + 1];
2236 : }
2237 :
2238 176194766 : return;
2239 : }
2240 :
2241 :
2242 8670 : void fft3(
2243 : const float X[],
2244 : float Y[],
2245 : const int16_t n )
2246 : {
2247 : float Z[PH_ECU_SPEC_SIZE];
2248 : float *Z0, *Z1, *Z2;
2249 : float *z0, *z1, *z2;
2250 : const float *x;
2251 8670 : const float *t_sin = sincos_t_rad3;
2252 : int16_t m, step, order;
2253 : int16_t i, j;
2254 : int16_t c1_ind, s1_ind, c2_ind, s2_ind;
2255 : int16_t c1_step, s1_step, c2_step, s2_step;
2256 : float *RY, *IY, *RZ0, *IZ0, *RZ1, *IZ1, *RZ2, *IZ2;
2257 :
2258 : /* Determine the order of the transform, the length of decimated */
2259 : /* transforms m, and the step for the sine and cosine tables. */
2260 8670 : switch ( n )
2261 : {
2262 2890 : case 1536:
2263 2890 : order = 9;
2264 2890 : m = 512;
2265 2890 : step = 1;
2266 2890 : break;
2267 5780 : case 384:
2268 5780 : order = 7;
2269 5780 : m = 128;
2270 5780 : step = 4;
2271 5780 : break;
2272 0 : default:
2273 0 : order = 9;
2274 0 : m = 512;
2275 0 : step = 1;
2276 : }
2277 :
2278 : /* Compose decimated sequences X[3i], X[3i+1],X[3i+2] */
2279 : /* compute their FFT of length m. */
2280 8670 : Z0 = &Z[0];
2281 8670 : z0 = &Z0[0];
2282 8670 : Z1 = &Z0[m];
2283 8670 : z1 = &Z1[0]; /* Z1 = &Z[ m]; */
2284 8670 : Z2 = &Z1[m];
2285 8670 : z2 = &Z2[0]; /* Z2 = &Z[2m]; */
2286 8670 : x = &X[0];
2287 2228190 : for ( i = 0; i < n / 3; i++ )
2288 : {
2289 2219520 : *z0++ = *x++; /* Z0[i] = X[3i]; */
2290 2219520 : *z1++ = *x++; /* Z1[i] = X[3i+1]; */
2291 2219520 : *z2++ = *x++; /* Z2[i] = X[3i+2]; */
2292 : }
2293 :
2294 8670 : fft_rel( &Z0[0], m, order );
2295 8670 : fft_rel( &Z1[0], m, order );
2296 8670 : fft_rel( &Z2[0], m, order );
2297 :
2298 : /* Butterflies of order 3. */
2299 : /* pointer initialization */
2300 8670 : RY = &Y[0];
2301 8670 : IY = &Y[n];
2302 8670 : RZ0 = &Z0[0];
2303 8670 : IZ0 = &Z0[m];
2304 8670 : RZ1 = &Z1[0];
2305 8670 : IZ1 = &Z1[m];
2306 8670 : RZ2 = &Z2[0];
2307 8670 : IZ2 = &Z2[m];
2308 :
2309 8670 : c1_step = -step;
2310 8670 : s1_step = step;
2311 8670 : c2_step = -2 * step;
2312 8670 : s2_step = 2 * step;
2313 8670 : c1_ind = T_SIN_PI_2 + c1_step;
2314 8670 : s1_ind = s1_step;
2315 8670 : c2_ind = T_SIN_PI_2 + c2_step;
2316 8670 : s2_ind = s2_step;
2317 :
2318 : /* special case: i = 0 */
2319 8670 : RY[0] = RZ0[0] + RZ1[0] + RZ2[0];
2320 :
2321 : /* first 3/12 */
2322 832320 : for ( i = 1; i < 3 * m / 8; i++, c1_ind += c1_step, s1_ind += s1_step, c2_ind += c2_step, s2_ind += s2_step )
2323 : {
2324 823650 : RY[i] = RZ0[i] + RZ1[i] * t_sin[c1_ind] + IZ1[-i] * t_sin[s1_ind] + RZ2[i] * t_sin[c2_ind] + IZ2[-i] * t_sin[s2_ind];
2325 823650 : IY[-i] = IZ0[-i] - RZ1[i] * t_sin[s1_ind] + IZ1[-i] * t_sin[c1_ind] - RZ2[i] * t_sin[s2_ind] + IZ2[-i] * t_sin[c2_ind];
2326 : }
2327 :
2328 : /* next 1/12 */
2329 286110 : for ( ; i < 4 * m / 8; i++, c1_ind += c1_step, s1_ind += s1_step, c2_ind -= c2_step, s2_ind -= s2_step )
2330 : {
2331 277440 : RY[i] = RZ0[i] + RZ1[i] * t_sin[c1_ind] + IZ1[-i] * t_sin[s1_ind] - RZ2[i] * t_sin[c2_ind] + IZ2[-i] * t_sin[s2_ind];
2332 277440 : IY[-i] = IZ0[-i] - RZ1[i] * t_sin[s1_ind] + IZ1[-i] * t_sin[c1_ind] - RZ2[i] * t_sin[s2_ind] - IZ2[-i] * t_sin[c2_ind];
2333 : }
2334 :
2335 : /* special case: i = m/2 i.e. 1/3 */
2336 8670 : RY[i] = RZ0[i] + RZ1[i] * t_sin[c1_ind] - RZ2[i] * t_sin[c2_ind];
2337 8670 : IY[-i] = -RZ1[i] * t_sin[s1_ind] - RZ2[i] * t_sin[s2_ind];
2338 8670 : i++;
2339 :
2340 8670 : c1_ind += c1_step, s1_ind += s1_step, c2_ind -= c2_step, s2_ind -= s2_step;
2341 :
2342 : /* next 2/12 */
2343 554880 : for ( j = i - 2; i < 6 * m / 8; i++, j--, c1_ind += c1_step, s1_ind += s1_step, c2_ind -= c2_step, s2_ind -= s2_step )
2344 : {
2345 546210 : RY[i] = RZ0[j] + RZ1[j] * t_sin[c1_ind] - IZ1[-j] * t_sin[s1_ind] - RZ2[j] * t_sin[c2_ind] - IZ2[-j] * t_sin[s2_ind];
2346 546210 : IY[-i] = -IZ0[-j] - RZ1[j] * t_sin[s1_ind] - IZ1[-j] * t_sin[c1_ind] - RZ2[j] * t_sin[s2_ind] + IZ2[-j] * t_sin[c2_ind];
2347 : }
2348 :
2349 : /*--------------------------half--------------------------*/
2350 : /* next 2/12 */
2351 563550 : for ( ; i < 8 * m / 8; i++, j--, c1_ind -= c1_step, s1_ind -= s1_step, c2_ind += c2_step, s2_ind += s2_step )
2352 : {
2353 554880 : RY[i] = RZ0[j] - RZ1[j] * t_sin[c1_ind] - IZ1[-j] * t_sin[s1_ind] - RZ2[j] * t_sin[c2_ind] + IZ2[-j] * t_sin[s2_ind];
2354 554880 : IY[-i] = -IZ0[-j] - RZ1[j] * t_sin[s1_ind] + IZ1[-j] * t_sin[c1_ind] + RZ2[j] * t_sin[s2_ind] + IZ2[-j] * t_sin[c2_ind];
2355 : }
2356 :
2357 : /* special case: i = m, i.e 2/3 */
2358 8670 : RY[i] = RZ0[j] - RZ1[j] * t_sin[c1_ind] - RZ2[j] * t_sin[c2_ind];
2359 8670 : IY[-i++] = -RZ1[j] * t_sin[s1_ind] + RZ2[j] * t_sin[s2_ind];
2360 8670 : c1_ind -= c1_step, s1_ind -= s1_step, c2_ind += c2_step, s2_ind += s2_step;
2361 :
2362 : /* next 1/12 */
2363 277440 : for ( j = 1; i < 9 * m / 8; i++, j++, c1_ind -= c1_step, s1_ind -= s1_step, c2_ind += c2_step, s2_ind += s2_step )
2364 : {
2365 268770 : RY[i] = RZ0[j] - RZ1[j] * t_sin[c1_ind] + IZ1[-j] * t_sin[s1_ind] - RZ2[j] * t_sin[c2_ind] - IZ2[-j] * t_sin[s2_ind];
2366 268770 : IY[-i] = IZ0[-j] - RZ1[j] * t_sin[s1_ind] - IZ1[-j] * t_sin[c1_ind] + RZ2[j] * t_sin[s2_ind] - IZ2[-j] * t_sin[c2_ind];
2367 : }
2368 :
2369 : /* last 3/12 */
2370 840990 : for ( ; i < 12 * m / 8; i++, j++, c1_ind -= c1_step, s1_ind -= s1_step, c2_ind -= c2_step, s2_ind -= s2_step )
2371 : {
2372 832320 : RY[i] = RZ0[j] - RZ1[j] * t_sin[c1_ind] + IZ1[-j] * t_sin[s1_ind] + RZ2[j] * t_sin[c2_ind] - IZ2[-j] * t_sin[s2_ind];
2373 832320 : IY[-i] = IZ0[-j] - RZ1[j] * t_sin[s1_ind] - IZ1[-j] * t_sin[c1_ind] + RZ2[j] * t_sin[s2_ind] + IZ2[-j] * t_sin[c2_ind];
2374 : }
2375 :
2376 : /* special case: i = 3*m/2 */
2377 8670 : RY[i] = RZ0[j] - RZ1[j] * t_sin[c1_ind] + RZ2[j] * t_sin[c2_ind];
2378 :
2379 8670 : return;
2380 : }
2381 :
2382 5794 : void ifft3(
2383 : const float Z[],
2384 : float X[],
2385 : const int16_t n )
2386 : {
2387 : float Y[PH_ECU_SPEC_SIZE];
2388 5794 : const float *t_sin = sincos_t_rad3;
2389 : int16_t m, step, step2, order;
2390 : int16_t i;
2391 : int16_t c0_ind, s0_ind, c1_ind, s1_ind, c2_ind, s2_ind;
2392 : float scale;
2393 : const float *RZ0, *IZ0, *RZ1, *IZ1, *RZ2, *IZ2;
2394 : float *RY0, *IY0, *RY1, *IY1, *RY2, *IY2, *y0, *y1, *y2;
2395 :
2396 : /* Determine the order of the transform, the length of decimated */
2397 : /* transforms m, and the step for the sine and cosine tables. */
2398 5794 : switch ( n )
2399 : {
2400 5794 : case 1536:
2401 5794 : order = 9;
2402 5794 : m = 512;
2403 5794 : step = 1;
2404 5794 : break;
2405 0 : case 384:
2406 0 : order = 7;
2407 0 : m = 128;
2408 0 : step = 4;
2409 0 : break;
2410 0 : default:
2411 0 : order = 9;
2412 0 : m = 512;
2413 0 : step = 1;
2414 : }
2415 :
2416 : /* pointer initialization */
2417 5794 : RY0 = &Y[0];
2418 5794 : IY0 = &RY0[m];
2419 5794 : RY1 = &RY0[m];
2420 5794 : IY1 = &RY1[m];
2421 5794 : RY2 = &RY1[m];
2422 5794 : IY2 = &RY2[m];
2423 :
2424 5794 : RZ0 = &Z[0];
2425 5794 : RZ1 = RZ0 + m;
2426 5794 : RZ2 = RZ0 + n / 2 - m / 2;
2427 5794 : IZ0 = &Z[n];
2428 5794 : IZ1 = IZ0 - m;
2429 5794 : IZ2 = IZ0 - n / 2 + m / 2;
2430 :
2431 : /* Inverse butterflies of order 3. */
2432 :
2433 : /* Construction of Y0 */
2434 5794 : RY0[0] = RZ0[0] + RZ1[0] + RZ2[0];
2435 1483264 : for ( i = 1; i < m / 2; i++ )
2436 : {
2437 1477470 : RY0[i] = RZ0[i] + RZ1[i] + RZ2[-i];
2438 1477470 : IY0[-i] = IZ0[-i] + IZ1[-i] - IZ2[i];
2439 : }
2440 :
2441 : /* m/2 */
2442 5794 : RY0[i] = RZ0[i] + RZ1[i] + RZ2[-i];
2443 :
2444 : /* Construction of Y1 */
2445 5794 : c0_ind = T_SIN_PI_2;
2446 5794 : s0_ind = 0;
2447 5794 : c1_ind = T_SIN_PI_2 * 1 / 3;
2448 5794 : s1_ind = T_SIN_PI_2 * 2 / 3;
2449 5794 : c2_ind = T_SIN_PI_2 * 1 / 3;
2450 5794 : s2_ind = T_SIN_PI_2 * 2 / 3;
2451 :
2452 5794 : RY1[0] = RZ0[0] * t_sin[c0_ind] - RZ1[0] * t_sin[c1_ind] - RZ2[0] * t_sin[c2_ind] - IZ1[0] * t_sin[s1_ind] - IZ2[0] * t_sin[s2_ind];
2453 :
2454 5794 : c0_ind -= step, s0_ind += step, c1_ind += step, s1_ind -= step, c2_ind -= step, s2_ind += step;
2455 741632 : for ( i = 1; i < m / 4; i++, c0_ind -= step, s0_ind += step, c1_ind += step, s1_ind -= step, c2_ind -= step, s2_ind += step )
2456 : {
2457 735838 : RY1[i] = RZ0[i] * t_sin[c0_ind] - RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] - IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2458 735838 : IY1[-i] = IZ0[-i] * t_sin[c0_ind] - IZ1[-i] * t_sin[c1_ind] + IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] + RZ1[i] * t_sin[s1_ind] - RZ2[-i] * t_sin[s2_ind];
2459 : }
2460 :
2461 747426 : for ( ; i < m / 2; i++, c0_ind -= step, s0_ind += step, c1_ind += step, s1_ind -= step, c2_ind += step, s2_ind -= step )
2462 : {
2463 741632 : RY1[i] = RZ0[i] * t_sin[c0_ind] - RZ1[i] * t_sin[c1_ind] + RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] - IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2464 741632 : IY1[-i] = IZ0[-i] * t_sin[c0_ind] - IZ1[-i] * t_sin[c1_ind] - IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] + RZ1[i] * t_sin[s1_ind] - RZ2[-i] * t_sin[s2_ind];
2465 : }
2466 :
2467 : /* m/2 */
2468 5794 : RY1[i] = RZ0[i] * t_sin[c0_ind] - RZ1[i] * t_sin[c1_ind] + RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] - IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2469 :
2470 : /* Construction of Y2 */
2471 5794 : c0_ind = T_SIN_PI_2;
2472 5794 : s0_ind = 0;
2473 5794 : c1_ind = T_SIN_PI_2 * 1 / 3;
2474 5794 : s1_ind = T_SIN_PI_2 * 2 / 3;
2475 5794 : c2_ind = T_SIN_PI_2 * 1 / 3;
2476 5794 : s2_ind = T_SIN_PI_2 * 2 / 3;
2477 5794 : step2 = 2 * step;
2478 5794 : RY2[0] = RZ0[0] * t_sin[c0_ind] - RZ1[0] * t_sin[c1_ind] - RZ2[0] * t_sin[c2_ind] + IZ1[0] * t_sin[s1_ind] + IZ2[0] * t_sin[s2_ind];
2479 :
2480 5794 : c0_ind -= step2, s0_ind += step2, c1_ind -= step2, s1_ind += step2, c2_ind += step2, s2_ind -= step2;
2481 370816 : for ( i = 1; i < m / 8; i++, c0_ind -= step2, s0_ind += step2, c1_ind -= step2, s1_ind += step2, c2_ind += step2, s2_ind -= step2 )
2482 : {
2483 365022 : RY2[i] = RZ0[i] * t_sin[c0_ind] - RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] + IZ1[-i] * t_sin[s1_ind] + IZ2[i] * t_sin[s2_ind];
2484 365022 : IY2[-i] = IZ0[-i] * t_sin[c0_ind] - IZ1[-i] * t_sin[c1_ind] + IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] - RZ1[i] * t_sin[s1_ind] + RZ2[-i] * t_sin[s2_ind];
2485 : }
2486 :
2487 376610 : for ( ; i < m / 4; i++, c0_ind -= step2, s0_ind += step2, c1_ind += step2, s1_ind -= step2, c2_ind += step2, s2_ind -= step2 )
2488 : {
2489 370816 : RY2[i] = RZ0[i] * t_sin[c0_ind] + RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] + IZ1[-i] * t_sin[s1_ind] + IZ2[i] * t_sin[s2_ind];
2490 370816 : IY2[-i] = IZ0[-i] * t_sin[c0_ind] + IZ1[-i] * t_sin[c1_ind] + IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] - RZ1[i] * t_sin[s1_ind] + RZ2[-i] * t_sin[s2_ind];
2491 : }
2492 :
2493 376610 : for ( ; i < 3 * m / 8; i++, c0_ind -= step2, s0_ind += step2, c1_ind += step2, s1_ind -= step2, c2_ind -= step2, s2_ind += step2 )
2494 : {
2495 370816 : RY2[i] = RZ0[i] * t_sin[c0_ind] + RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] + IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2496 370816 : IY2[-i] = IZ0[-i] * t_sin[c0_ind] + IZ1[-i] * t_sin[c1_ind] + IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] - RZ1[i] * t_sin[s1_ind] - RZ2[-i] * t_sin[s2_ind];
2497 : }
2498 :
2499 376610 : for ( ; i < m / 2; i++, c0_ind += step2, s0_ind -= step2, c1_ind += step2, s1_ind -= step2, c2_ind -= step2, s2_ind += step2 )
2500 : {
2501 370816 : RY2[i] = -RZ0[i] * t_sin[c0_ind] + RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] + IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2502 370816 : IY2[-i] = -IZ0[-i] * t_sin[c0_ind] + IZ1[-i] * t_sin[c1_ind] + IZ2[i] * t_sin[c2_ind] + RZ0[i] * t_sin[s0_ind] - RZ1[i] * t_sin[s1_ind] - RZ2[-i] * t_sin[s2_ind];
2503 : }
2504 :
2505 : /* m/2 */
2506 5794 : RY2[i] = -RZ0[i] * t_sin[c0_ind] + RZ1[i] * t_sin[c1_ind] - RZ2[-i] * t_sin[c2_ind] - IZ0[-i] * t_sin[s0_ind] + IZ1[-i] * t_sin[s1_ind] - IZ2[i] * t_sin[s2_ind];
2507 :
2508 : /* Compute the inverse FFT for all 3 blocks. */
2509 5794 : ifft_rel( RY0, m, order );
2510 5794 : ifft_rel( RY1, m, order );
2511 5794 : ifft_rel( RY2, m, order );
2512 :
2513 5794 : y0 = RY0;
2514 5794 : y1 = RY1;
2515 5794 : y2 = RY2;
2516 :
2517 : /* Interlacing and scaling, scale = 1/3 */
2518 5794 : scale = 1.0f / 3;
2519 2972322 : for ( i = 0; i < n; )
2520 : {
2521 2966528 : X[i++] = ( *y0++ ) * scale;
2522 2966528 : X[i++] = ( *y1++ ) * scale;
2523 2966528 : X[i++] = ( *y2++ ) * scale;
2524 : }
2525 :
2526 5794 : return;
2527 : }
2528 :
2529 :
2530 3554294 : static void rfft_post(
2531 : const float *sine_table,
2532 : float *buf,
2533 : const int16_t len )
2534 : {
2535 : float tmp1, tmp2, tmp3, tmp4, s, c;
2536 3554294 : int16_t i = 0;
2537 :
2538 3554294 : tmp1 = buf[0] + buf[1];
2539 3554294 : buf[1] = buf[0] - buf[1];
2540 3554294 : buf[0] = tmp1;
2541 :
2542 572241334 : for ( i = 1; i <= ( len + 2 ) / 4; i++ )
2543 : {
2544 568687040 : s = sine_table[i]; /* sin(pi*i/(len/2)) */
2545 568687040 : c = sine_table[i + len / 4]; /* cos(pi*i/(len/2)) */
2546 :
2547 568687040 : tmp1 = buf[2 * i] - buf[len - 2 * i];
2548 568687040 : tmp2 = buf[2 * i + 1] + buf[len - 2 * i + 1];
2549 568687040 : tmp3 = s * tmp1 - c * tmp2; /* real part of j*W(k,N)*[T(k) - T'(N-k)] */
2550 568687040 : tmp4 = c * tmp1 + s * tmp2; /* imag part of j*W(k,N)*[T(k) - T'(N-k)] */
2551 568687040 : tmp1 = buf[2 * i] + buf[len - 2 * i];
2552 568687040 : tmp2 = buf[2 * i + 1] - buf[len - 2 * i + 1];
2553 :
2554 568687040 : buf[2 * i] = 0.5f * ( tmp1 - tmp3 );
2555 568687040 : buf[2 * i + 1] = 0.5f * ( tmp2 - tmp4 );
2556 568687040 : buf[len - 2 * i] = 0.5f * ( tmp1 + tmp3 );
2557 568687040 : buf[len - 2 * i + 1] = -0.5f * ( tmp2 + tmp4 );
2558 : }
2559 3554294 : }
2560 :
2561 2463921 : static void rfft_pre(
2562 : const float *sine_table,
2563 : float *buf,
2564 : const int16_t len )
2565 : {
2566 2463921 : const float scale = 1.0f / len;
2567 : float tmp1, tmp2, tmp3, tmp4, s, c;
2568 2463921 : int16_t i = 0;
2569 :
2570 2463921 : tmp1 = buf[0] + buf[1];
2571 2463921 : buf[1] = scale * ( buf[0] - buf[1] );
2572 2463921 : buf[0] = scale * tmp1;
2573 :
2574 396691281 : for ( i = 1; i <= ( len + 2 ) / 4; i++ )
2575 : {
2576 394227360 : s = sine_table[i]; /* sin(pi*i/(len/2)) */
2577 394227360 : c = sine_table[i + len / 4]; /* cos(pi*i/(len/2)) */
2578 :
2579 394227360 : tmp1 = buf[2 * i] - buf[len - 2 * i];
2580 394227360 : tmp2 = buf[2 * i + 1] + buf[len - 2 * i + 1];
2581 394227360 : tmp3 = s * tmp1 + c * tmp2; /* real part of j*W(k,N)*[T(k) - T'(N-k)] */
2582 394227360 : tmp4 = -c * tmp1 + s * tmp2; /* imag part of j*W(k,N)*[T(k) - T'(N-k)] */
2583 394227360 : tmp1 = buf[2 * i] + buf[len - 2 * i];
2584 394227360 : tmp2 = buf[2 * i + 1] - buf[len - 2 * i + 1];
2585 :
2586 394227360 : buf[2 * i] = scale * ( tmp1 + tmp3 );
2587 394227360 : buf[2 * i + 1] = -scale * ( tmp2 + tmp4 );
2588 394227360 : buf[len - 2 * i] = scale * ( tmp1 - tmp3 );
2589 394227360 : buf[len - 2 * i + 1] = scale * ( tmp2 - tmp4 );
2590 : }
2591 :
2592 2463921 : return;
2593 : }
2594 :
2595 11131092 : int16_t RFFTN(
2596 : float *data,
2597 : const float *sine_table,
2598 : const int16_t len,
2599 : const int16_t sign )
2600 : {
2601 11131092 : assert( len <= 640 && len > 0 );
2602 :
2603 11131092 : if ( len == 640 )
2604 : {
2605 : float x[320], y[320];
2606 : int16_t i;
2607 :
2608 6018215 : if ( sign != -1 )
2609 : {
2610 2463921 : rfft_pre( sine_table, data, len );
2611 : }
2612 :
2613 1931847015 : for ( i = 0; i < 320; i++ )
2614 : {
2615 1925828800 : x[i] = data[2 * i];
2616 1925828800 : y[i] = data[2 * i + 1];
2617 : }
2618 6018215 : DoRTFT320( x, y );
2619 1931847015 : for ( i = 0; i < 320; i++ )
2620 : {
2621 1925828800 : data[2 * i] = x[i];
2622 1925828800 : data[2 * i + 1] = y[i];
2623 : }
2624 :
2625 6018215 : if ( sign == -1 )
2626 : {
2627 3554294 : rfft_post( sine_table, data, len );
2628 : }
2629 : }
2630 : else
2631 : {
2632 5112877 : if ( len == 512 )
2633 : {
2634 : int16_t i;
2635 5112877 : const int16_t log2 = 9;
2636 : float reordered_data[512];
2637 :
2638 5112877 : if ( sign == -1 )
2639 : {
2640 3127918 : fft_rel( data, len, log2 );
2641 3127918 : reordered_data[0] = data[0];
2642 3127918 : reordered_data[1] = data[len / 2];
2643 800747008 : for ( i = 1; i < len / 2; i++ )
2644 : {
2645 797619090 : reordered_data[2 * i] = data[i];
2646 797619090 : reordered_data[2 * i + 1] = data[len - i];
2647 : }
2648 : }
2649 : else
2650 : {
2651 1984959 : reordered_data[0] = data[0];
2652 1984959 : reordered_data[len / 2] = data[1];
2653 508149504 : for ( i = 1; i < len / 2; i++ )
2654 : {
2655 506164545 : reordered_data[i] = data[2 * i];
2656 506164545 : reordered_data[len - i] = data[2 * i + 1];
2657 : }
2658 1984959 : ifft_rel( reordered_data, len, log2 );
2659 : }
2660 5112877 : mvr2r( reordered_data, data, len );
2661 : }
2662 : else
2663 : {
2664 0 : assert( !"Not supported FFT length!" );
2665 : }
2666 : }
2667 :
2668 11131092 : return 0;
2669 : }
2670 :
2671 633420570 : static void butterfly(
2672 : const float a,
2673 : const float b,
2674 : float *aPlusb,
2675 : float *aMinusb )
2676 : {
2677 633420570 : *aPlusb = a + b;
2678 633420570 : *aMinusb = a - b;
2679 :
2680 633420570 : return;
2681 : }
2682 :
2683 420352880 : static void fft2(
2684 : float *pInOut )
2685 : {
2686 : /* FFT MATRIX:
2687 : 1.0000 1.0000
2688 : 1.0000 -1.0000
2689 : */
2690 : float re1, im1;
2691 : float re2, im2;
2692 :
2693 420352880 : re1 = pInOut[0];
2694 420352880 : im1 = pInOut[1];
2695 420352880 : re2 = pInOut[2];
2696 420352880 : im2 = pInOut[3];
2697 420352880 : pInOut[0] = re1 + re2;
2698 420352880 : pInOut[1] = im1 + im2;
2699 :
2700 420352880 : pInOut[2] = re1 - re2;
2701 420352880 : pInOut[3] = im1 - im2;
2702 :
2703 420352880 : return;
2704 : }
2705 :
2706 : static const float C31 = 0.5f; /* cos(PI/3); sin(2*PI/3) */
2707 : static const float C32 = 0.866025403784439f; /* cos(PI/3); sin(2*PI/3) */
2708 :
2709 280366320 : static void fft3_2(
2710 : float *pInOut )
2711 : {
2712 : float re1, im1;
2713 : float re2, im2;
2714 : float re3, im3;
2715 :
2716 : float tmp1, tmp2;
2717 : float tmp3, tmp4;
2718 :
2719 280366320 : re1 = pInOut[0];
2720 280366320 : im1 = pInOut[1];
2721 280366320 : re2 = pInOut[2];
2722 280366320 : im2 = pInOut[3];
2723 280366320 : re3 = pInOut[4];
2724 280366320 : im3 = pInOut[5];
2725 :
2726 : /* FFT MATRIX:
2727 : 1.0000 1.0000 1.0000
2728 : C31 C32
2729 : 1.0000 -0.5000 - 0.8660i -0.5000 + 0.8660i
2730 : 1.0000 -0.5000 + 0.8660i -0.5000 - 0.8660i
2731 : */
2732 280366320 : tmp1 = re2 + re3;
2733 280366320 : tmp3 = im2 + im3;
2734 280366320 : tmp2 = re2 - re3;
2735 280366320 : tmp4 = im2 - im3;
2736 280366320 : pInOut[0] = re1 + tmp1;
2737 280366320 : pInOut[1] = im1 + tmp3;
2738 280366320 : pInOut[2] = re1 - C31 * tmp1 + C32 * tmp4;
2739 280366320 : pInOut[4] = re1 - C31 * tmp1 - C32 * tmp4;
2740 :
2741 280366320 : pInOut[3] = im1 - C32 * tmp2 - C31 * tmp3;
2742 280366320 : pInOut[5] = im1 + C32 * tmp2 - C31 * tmp3;
2743 280366320 : }
2744 :
2745 :
2746 2275 : static void fft4(
2747 : float *pInOut )
2748 : {
2749 : float re1, im1;
2750 : float re2, im2;
2751 : float re3, im3;
2752 : float re4, im4;
2753 :
2754 : float tmp1, tmp2;
2755 : float tmp3, tmp4;
2756 : float tmp5, tmp6;
2757 : float tmp7, tmp8;
2758 :
2759 2275 : re1 = pInOut[0];
2760 2275 : im1 = pInOut[1];
2761 2275 : re2 = pInOut[2];
2762 2275 : im2 = pInOut[3];
2763 2275 : re3 = pInOut[4];
2764 2275 : im3 = pInOut[5];
2765 2275 : re4 = pInOut[6];
2766 2275 : im4 = pInOut[7];
2767 :
2768 : /*
2769 : 1.0000 1.0000 1.0000 1.0000
2770 : 1.0000 -1.0000i -1.0000 1.0000i
2771 : 1.0000 -1.0000 1.0000 -1.0000
2772 : 1.0000 1.0000i -1.0000 -1.0000i
2773 : */
2774 2275 : tmp1 = re1 + re3;
2775 2275 : tmp3 = re2 + re4;
2776 2275 : tmp5 = im1 + im3;
2777 2275 : tmp7 = im2 + im4;
2778 2275 : pInOut[0] = tmp1 + tmp3;
2779 2275 : pInOut[4] = tmp1 - tmp3;
2780 :
2781 2275 : pInOut[1] = tmp5 + tmp7;
2782 2275 : pInOut[5] = tmp5 - tmp7;
2783 2275 : tmp2 = re1 - re3;
2784 2275 : tmp4 = re2 - re4;
2785 2275 : tmp6 = im1 - im3;
2786 2275 : tmp8 = im2 - im4;
2787 2275 : pInOut[2] = tmp2 + tmp8;
2788 2275 : pInOut[6] = tmp2 - tmp8;
2789 :
2790 2275 : pInOut[3] = -tmp4 + tmp6;
2791 2275 : pInOut[7] = tmp4 + tmp6;
2792 :
2793 2275 : return;
2794 : }
2795 :
2796 : static const float C51 = 0.309016994374947f; /* cos(2*PI/5); */
2797 : static const float C52 = 0.951056516295154f; /* sin(2*PI/5); */
2798 : static const float C53 = 0.809016994374947f; /* cos( PI/5); */
2799 : static const float C54 = 0.587785252292473f; /* sin( PI/5); */
2800 :
2801 169788632 : static void fft5(
2802 : float *pInOut )
2803 : {
2804 : float re1, im1;
2805 : float re2, im2;
2806 : float re3, im3;
2807 : float re4, im4;
2808 : float re5, im5;
2809 :
2810 : float tmp1, tmp2;
2811 : float tmp3, tmp4;
2812 : float tmp5, tmp6;
2813 : float tmp7, tmp8;
2814 :
2815 :
2816 169788632 : re1 = pInOut[0];
2817 169788632 : im1 = pInOut[1];
2818 169788632 : re2 = pInOut[2];
2819 169788632 : im2 = pInOut[3];
2820 169788632 : re3 = pInOut[4];
2821 169788632 : im3 = pInOut[5];
2822 169788632 : re4 = pInOut[6];
2823 169788632 : im4 = pInOut[7];
2824 169788632 : re5 = pInOut[8];
2825 169788632 : im5 = pInOut[9];
2826 :
2827 : /*
2828 : 1.0000 1.0000 1.0000 1.0000 1.0000
2829 : C51 C52 C53 C54
2830 : 1.0000 0.3090 - 0.9511i -0.8090 - 0.5878i -0.8090 + 0.5878i 0.3090 + 0.9511i
2831 : 1.0000 -0.8090 - 0.5878i 0.3090 + 0.9511i 0.3090 - 0.9511i -0.8090 + 0.5878i
2832 : 1.0000 -0.8090 + 0.5878i 0.3090 - 0.9511i 0.3090 + 0.9511i -0.8090 - 0.5878i
2833 : 1.0000 0.3090 + 0.9511i -0.8090 + 0.5878i -0.8090 - 0.5878i 0.3090 - 0.9511i
2834 : */
2835 169788632 : tmp1 = re2 + re5;
2836 169788632 : tmp2 = re2 - re5;
2837 169788632 : tmp3 = im2 + im5;
2838 169788632 : tmp4 = im2 - im5;
2839 169788632 : tmp5 = re3 + re4;
2840 169788632 : tmp6 = re3 - re4;
2841 169788632 : tmp7 = im3 + im4;
2842 169788632 : tmp8 = im3 - im4;
2843 :
2844 :
2845 169788632 : pInOut[0] = re1 + tmp1 + tmp5;
2846 169788632 : pInOut[1] = im1 + tmp3 + tmp7;
2847 :
2848 169788632 : pInOut[2] = re1 + C51 * tmp1 - C53 * tmp5 + C52 * tmp4 + C54 * tmp8;
2849 169788632 : pInOut[8] = re1 + C51 * tmp1 - C53 * tmp5 - C52 * tmp4 - C54 * tmp8;
2850 169788632 : pInOut[3] = im1 - C52 * tmp2 - C54 * tmp6 + C51 * tmp3 - C53 * tmp7;
2851 169788632 : pInOut[9] = im1 + C52 * tmp2 + C54 * tmp6 + C51 * tmp3 - C53 * tmp7;
2852 169788632 : pInOut[4] = re1 - C53 * tmp1 + C51 * tmp5 + C54 * tmp4 - C52 * tmp8;
2853 169788632 : pInOut[6] = re1 - C53 * tmp1 + C51 * tmp5 - C54 * tmp4 + C52 * tmp8;
2854 169788632 : pInOut[5] = im1 - C54 * tmp2 + C52 * tmp6 - C53 * tmp3 + C51 * tmp7;
2855 169788632 : pInOut[7] = im1 + C54 * tmp2 - C52 * tmp6 - C53 * tmp3 + C51 * tmp7;
2856 :
2857 169788632 : return;
2858 : }
2859 :
2860 : static const float C81 = 0.707106781186548f; /* cos(PI/4); */
2861 :
2862 105570095 : static void fft8_2(
2863 : float *pInOut )
2864 : {
2865 : float re0, im0, re4, im4;
2866 :
2867 : float re1_7p, re1_7m;
2868 : float im1_7p, im1_7m;
2869 : float re2_6p, re2_6m;
2870 : float im2_6p, im2_6m;
2871 : float re3_5p, re3_5m;
2872 : float im3_5p, im3_5m;
2873 :
2874 105570095 : re0 = pInOut[0];
2875 105570095 : im0 = pInOut[1];
2876 105570095 : re4 = pInOut[8];
2877 105570095 : im4 = pInOut[9];
2878 105570095 : butterfly( pInOut[1 * 2], pInOut[7 * 2], &re1_7p, &re1_7m );
2879 105570095 : butterfly( pInOut[1 * 2 + 1], pInOut[7 * 2 + 1], &im1_7p, &im1_7m );
2880 105570095 : butterfly( pInOut[2 * 2], pInOut[6 * 2], &re2_6p, &re2_6m );
2881 105570095 : butterfly( pInOut[2 * 2 + 1], pInOut[6 * 2 + 1], &im2_6p, &im2_6m );
2882 105570095 : butterfly( pInOut[3 * 2], pInOut[5 * 2], &re3_5p, &re3_5m );
2883 105570095 : butterfly( pInOut[3 * 2 + 1], pInOut[5 * 2 + 1], &im3_5p, &im3_5m );
2884 :
2885 : /*
2886 : 0: 1 + 0i 1 + 0i 1 + 0i 1 + 0i 1 + 0i 1 + 0i 1 + 0i 1 + 0i
2887 : 1: 1 + 0i C81 - C81i 0 - 1i -C81 - C81i -1 - 0i -C81 + C81i - 0 + 1i C81 + C81i
2888 : 2: 1 + 0i 0 - 1i -1 - 0i - 0 + 1i 1 + 0i 0 - 1i - 1 - 0i - 0 + 1i
2889 : 3: 1 + 0i -C81 - C81i -0 + 1i C81 - C81i -1 - 0i C81 + C81i 0 - 1i -C81 + C81i
2890 : 4: 1 + 0i - 1 - 0i 1 + 0i - 1 - 0i 1 + 0i - 1 - 0i 1 + 0i - 1 - 0i
2891 : 5: 1 + 0i -C81 + C81i 0 - 1i C81 + C81i -1 - 0i C81 - C81i - 0 + 1i -C81 - C81i
2892 : 6: 1 + 0i - 0 + 1i -1 - 0i 0 - 1i 1 + 0i - 0 + 1i - 1 - 0i - 0 - 1i
2893 : 7: 1 + 0i C81 + C81i -0 + 1i -C81 + C81i -1 - 0i -C81 - C81i - 0 - 1i C81 - C81i
2894 : */
2895 105570095 : pInOut[0] = re0 + re4 + re1_7p + re2_6p + re3_5p;
2896 105570095 : pInOut[1] = im0 + im4 + im1_7p + im2_6p + im3_5p;
2897 :
2898 105570095 : pInOut[2] = re0 + C81 * ( re1_7p - re3_5p ) - re4 + C81 * ( im1_7m + im3_5m ) + im2_6m;
2899 105570095 : pInOut[3] = im0 + C81 * ( im1_7p - im3_5p ) - im4 - C81 * ( re1_7m + re3_5m ) - re2_6m;
2900 :
2901 105570095 : pInOut[4] = re0 - re2_6p + re4 + im1_7m - im3_5m;
2902 105570095 : pInOut[5] = im0 - im2_6p + im4 - re1_7m + re3_5m;
2903 :
2904 105570095 : pInOut[6] = re0 + C81 * ( -re1_7p + re3_5p ) - re4 + C81 * ( im1_7m + im3_5m ) - im2_6m;
2905 105570095 : pInOut[7] = im0 + C81 * ( -im1_7p + im3_5p ) - im4 - C81 * ( re1_7m + re3_5m ) + re2_6m;
2906 :
2907 105570095 : pInOut[8] = re0 - re1_7p + re2_6p - re3_5p + re4;
2908 105570095 : pInOut[9] = im0 - im1_7p + im2_6p - im3_5p + im4;
2909 :
2910 105570095 : pInOut[10] = re0 + C81 * ( -re1_7p + re3_5p ) - re4 - C81 * ( im1_7m + im3_5m ) + im2_6m;
2911 105570095 : pInOut[11] = im0 + C81 * ( -im1_7p + im3_5p ) - im4 + C81 * ( re1_7m + re3_5m ) - re2_6m;
2912 :
2913 105570095 : pInOut[12] = re0 - re2_6p + re4 - im1_7m + im3_5m;
2914 105570095 : pInOut[13] = im0 - im2_6p + im4 + re1_7m - re3_5m;
2915 :
2916 105570095 : pInOut[14] = re0 + C81 * ( re1_7p - re3_5p ) - re4 - C81 * ( im1_7m + im3_5m ) - im2_6m;
2917 105570095 : pInOut[15] = im0 + C81 * ( im1_7p - im3_5p ) - im4 + C81 * ( re1_7m + re3_5m ) + re2_6m;
2918 :
2919 105570095 : return;
2920 : }
2921 :
2922 105962880 : static void nextFFT(
2923 : float *x,
2924 : const int16_t length )
2925 : {
2926 105962880 : switch ( length )
2927 : {
2928 0 : case 2:
2929 0 : fft2( x );
2930 0 : break;
2931 0 : case 3:
2932 0 : fft3_2( x );
2933 0 : break;
2934 0 : case 4:
2935 0 : fft4( x );
2936 0 : break;
2937 874660 : case 5:
2938 874660 : fft5( x );
2939 874660 : break;
2940 105088220 : case 8:
2941 105088220 : fft8_2( x );
2942 105088220 : break;
2943 0 : default:
2944 0 : assert( !"length not supported" );
2945 : break;
2946 : }
2947 :
2948 105962880 : return;
2949 : }
2950 :
2951 : static const int16_t CTFFTfactors[] = { 9, 8, 7, 5, 4, 3, 2, 0 };
2952 :
2953 52719042 : static __inline int16_t findFactor(
2954 : const int16_t length )
2955 : {
2956 52719042 : int16_t i = 0;
2957 52719042 : int16_t factor = 0;
2958 :
2959 105787948 : while ( CTFFTfactors[i] != 0 )
2960 : {
2961 105787948 : if ( 0 == ( length % CTFFTfactors[i] ) )
2962 : {
2963 52719042 : factor = CTFFTfactors[i];
2964 52719042 : break;
2965 : }
2966 53068906 : i++;
2967 : }
2968 52719042 : return factor;
2969 : }
2970 :
2971 52719042 : static __inline void twiddle(
2972 : float *x,
2973 : const int16_t length,
2974 : const int16_t n1,
2975 : const int16_t n2 )
2976 : {
2977 : int16_t i, ii;
2978 52719042 : double pi = 4. * atan( 1. );
2979 : float sinValOrg, cosValOrg;
2980 52719042 : float sinVal = 0.f, cosVal = 1.f;
2981 52719042 : float twReal = 0.f, twImag = 1.f;
2982 :
2983 52719042 : cosValOrg = (float) cos( -2 * pi * 1. / (double) length );
2984 52719042 : sinValOrg = (float) sin( -2 * pi * 1. / (double) length );
2985 421227540 : for ( i = 1; i < n1; i++ )
2986 : {
2987 : float tmp;
2988 368508498 : twReal = 1.f;
2989 368508498 : twImag = 0.f;
2990 368508498 : tmp = cosVal * cosValOrg - sinVal * sinValOrg;
2991 368508498 : sinVal = sinVal * cosValOrg + cosVal * sinValOrg;
2992 368508498 : cosVal = tmp;
2993 739116180 : for ( ii = 1; ii < n2; ii++ )
2994 : {
2995 : float xRe, xIm, tmpReal;
2996 : /* cos(x+y) = cos(x)*cos(y) - sin(x)*sin(y); */
2997 : /* sin(x+y) = sin(x)*cos(y) + sin(y)*cos(x); */
2998 370607682 : tmpReal = twReal * cosVal - twImag * sinVal;
2999 370607682 : twImag = twImag * cosVal + sinVal * twReal;
3000 370607682 : twReal = tmpReal;
3001 370607682 : xRe = x[2 * ( i * n2 + ii )];
3002 370607682 : xIm = x[2 * ( i * n2 + ii ) + 1];
3003 370607682 : x[2 * ( i * n2 + ii )] = twReal * xRe - twImag * xIm;
3004 370607682 : x[2 * ( i * n2 + ii ) + 1] = twImag * xRe + twReal * xIm;
3005 : }
3006 368508498 : tmp = cosVal;
3007 : }
3008 :
3009 52719042 : return;
3010 : }
3011 :
3012 922836364 : static void cooleyTukeyFFT(
3013 : float *x,
3014 : const int16_t length,
3015 : float *scratch )
3016 : {
3017 : int16_t factor;
3018 : int16_t i, ii;
3019 : int16_t n1, n2;
3020 922836364 : int16_t cnt = 0;
3021 : float *src, *dest;
3022 :
3023 922836364 : switch ( length )
3024 : {
3025 0 : case 1:
3026 0 : break;
3027 420352880 : case 2:
3028 420352880 : fft2( x );
3029 420352880 : break;
3030 280366320 : case 3:
3031 280366320 : fft3_2( x );
3032 280366320 : break;
3033 2275 : case 4:
3034 2275 : fft4( x );
3035 2275 : break;
3036 168913972 : case 5:
3037 168913972 : fft5( x );
3038 168913972 : break;
3039 481875 : case 8:
3040 481875 : fft8_2( x );
3041 481875 : break;
3042 52719042 : default:
3043 : {
3044 52719042 : factor = findFactor( length );
3045 52719042 : if ( factor > 0 && ( length / factor > 1 ) )
3046 : {
3047 52719042 : n1 = factor;
3048 52719042 : n2 = length / factor;
3049 :
3050 : /* DATA Resorting for stage1 */
3051 52719042 : dest = scratch;
3052 473946582 : for ( i = 0; i < 2 * n1; i += 2 )
3053 : {
3054 421227540 : src = x + i;
3055 1266306600 : for ( ii = 0; ii < n2; ii++ )
3056 : {
3057 : /* *dest++ = x[2*(i+ii*n1)]; */
3058 : /* *dest++ = x[2*(i+ii*n1)+1]; */
3059 845079060 : *dest++ = *src;
3060 845079060 : *dest++ = *( src + 1 );
3061 845079060 : src += 2 * n1;
3062 : }
3063 : }
3064 52719042 : src = scratch;
3065 52719042 : dest = x;
3066 897798102 : for ( i = 0; i < length; i++ )
3067 : {
3068 845079060 : *dest++ = *src++;
3069 845079060 : *dest++ = *src++;
3070 : }
3071 : /* perform n1 ffts of length n2 */
3072 473946582 : for ( i = 0; i < n1; i++ )
3073 : {
3074 421227540 : cooleyTukeyFFT( x + 2 * i * n2, n2, scratch + 2 * i * n2 );
3075 : }
3076 : /*data twiddeling */
3077 52719042 : twiddle( x, length, n1, n2 );
3078 : /* DATA Resorting for stage2 */
3079 52719042 : cnt = 0;
3080 158681922 : for ( i = 0; i < n2; i++ )
3081 : {
3082 951041940 : for ( ii = 0; ii < n1; ii++ )
3083 : {
3084 845079060 : scratch[2 * cnt] = x[2 * ( i + ii * n2 )];
3085 845079060 : scratch[2 * cnt + 1] = x[2 * ( i + ii * n2 ) + 1];
3086 845079060 : cnt++;
3087 : }
3088 : }
3089 : /* perform n2 ffts of length n1 */
3090 158681922 : for ( i = 0; i < n2; i++ )
3091 : {
3092 105962880 : nextFFT( scratch + 2 * i * n1, n1 );
3093 : }
3094 52719042 : cnt = 0;
3095 473946582 : for ( i = 0; i < n1; i++ )
3096 : {
3097 1266306600 : for ( ii = 0; ii < n2; ii++ )
3098 : {
3099 845079060 : x[2 * cnt] = scratch[2 * ( i + ii * n1 )];
3100 845079060 : x[2 * cnt + 1] = scratch[2 * ( i + ii * n1 ) + 1];
3101 845079060 : cnt++;
3102 : }
3103 : }
3104 : }
3105 : else
3106 : {
3107 0 : assert( !"length not supported" );
3108 : }
3109 : }
3110 : }
3111 :
3112 922836364 : return;
3113 : }
3114 :
3115 340338649 : static void pfaDFT(
3116 : float *x,
3117 : const int16_t length,
3118 : float *scratch1,
3119 : const int16_t numFactors,
3120 : const int16_t *factor )
3121 : {
3122 : int16_t i, ii;
3123 : int16_t cnt;
3124 :
3125 340338649 : if ( numFactors > 1 )
3126 : {
3127 59569154 : float *tmp = scratch1;
3128 59569154 : int16_t n1_inv = 1, n2_inv = 1;
3129 59569154 : int16_t n2 = factor[0 /*idx*/];
3130 59569154 : int16_t n1 = length / n2;
3131 : int16_t idx, incr;
3132 :
3133 165027907 : while ( ( ( n1_inv * n1 ) % n2 ) != 1 )
3134 : {
3135 105458753 : n1_inv++;
3136 : }
3137 115630042 : while ( ( ( n2_inv * n2 ) % n1 ) != 1 )
3138 : {
3139 56060888 : n2_inv++;
3140 : }
3141 59569154 : idx = 0;
3142 59569154 : incr = n1 * n1_inv;
3143 59569154 : cnt = 0;
3144 280408483 : for ( i = 0; i < n1; i++ )
3145 : {
3146 1685668820 : for ( ii = 0; ii < n2 - 1; ii++ )
3147 : {
3148 1464829491 : tmp[cnt++] = x[2 * idx];
3149 1464829491 : tmp[cnt++] = x[2 * idx + 1];
3150 :
3151 1464829491 : idx += incr;
3152 1464829491 : if ( idx > length )
3153 : {
3154 963018414 : idx -= length;
3155 : }
3156 : }
3157 220839329 : tmp[cnt++] = x[2 * idx];
3158 220839329 : tmp[cnt++] = x[2 * idx + 1];
3159 220839329 : idx++;
3160 : }
3161 280408483 : for ( cnt = 0; cnt < length; cnt += n2 )
3162 : {
3163 220839329 : cooleyTukeyFFT( tmp + 2 * cnt, n2, x + 2 * cnt );
3164 : }
3165 280408483 : for ( cnt = 0; cnt < n1; cnt++ )
3166 : {
3167 1906508149 : for ( i = 0; i < n2; i++ )
3168 : {
3169 1685668820 : x[2 * ( cnt + i * n1 )] = tmp[2 * ( cnt * n2 + i )];
3170 1685668820 : x[2 * ( cnt + i * n1 ) + 1] = tmp[2 * ( cnt * n2 + i ) + 1];
3171 : }
3172 : }
3173 396389353 : for ( cnt = 0; cnt < length; cnt += n1 )
3174 : {
3175 336820199 : pfaDFT( x + 2 * cnt, n1, tmp, numFactors - 1, &factor[1] );
3176 : }
3177 59569154 : idx = 0;
3178 59569154 : cnt = 0;
3179 396389353 : for ( i = 0; i < n2; i++ )
3180 : {
3181 336820199 : idx = i * n1;
3182 2022489019 : for ( ii = 0; ii < n1; ii++ )
3183 : {
3184 1685668820 : tmp[2 * idx] = x[cnt++];
3185 1685668820 : tmp[2 * idx + 1] = x[cnt++];
3186 1685668820 : idx += n2;
3187 1685668820 : if ( idx > length )
3188 : {
3189 277251045 : idx -= length;
3190 : }
3191 : }
3192 : }
3193 1745237974 : for ( cnt = 0; cnt < length; cnt++ )
3194 : {
3195 1685668820 : x[2 * cnt] = tmp[2 * cnt];
3196 1685668820 : x[2 * cnt + 1] = tmp[2 * cnt + 1];
3197 : }
3198 : }
3199 : else
3200 : {
3201 280769495 : cooleyTukeyFFT( x, length, scratch1 );
3202 : }
3203 :
3204 340338649 : return;
3205 : }
3206 :
3207 3518450 : static void fftf_interleave(
3208 : float *re,
3209 : float *im,
3210 : float *out,
3211 : const int16_t len )
3212 : {
3213 3518450 : int16_t i = 0;
3214 :
3215 848088310 : for ( i = 0; i < len; i++ )
3216 : {
3217 844569860 : *out++ = *re++;
3218 844569860 : *out++ = *im++;
3219 : }
3220 :
3221 3518450 : return;
3222 : }
3223 :
3224 3518450 : static void fftf_deinterleave(
3225 : float *in,
3226 : float *re,
3227 : float *im,
3228 : const int16_t len )
3229 : {
3230 3518450 : int16_t i = 0;
3231 :
3232 848088310 : for ( i = 0; i < len; i++ )
3233 : {
3234 844569860 : *re++ = *in++;
3235 844569860 : *im++ = *in++;
3236 : }
3237 :
3238 3518450 : return;
3239 : }
3240 :
3241 1504 : static void DoRTFT600(
3242 : float *x, /* i/o: real part of input and output data */
3243 : float *y /* i/o: imaginary part of input and output data */
3244 : )
3245 : {
3246 : float scratch[1200], cmplx[1200];
3247 1504 : const int16_t factors[3] = { 25, 8, 3 };
3248 :
3249 1504 : fftf_interleave( x, y, cmplx, 600 );
3250 1504 : pfaDFT( cmplx, 600, scratch, 3, factors );
3251 1504 : fftf_deinterleave( cmplx, x, y, 600 );
3252 :
3253 1504 : return;
3254 : }
3255 :
3256 1273 : static void DoRTFT400(
3257 : float *x, /* i/o: real part of input and output data */
3258 : float *y /* i/o: imaginary part of input and output data */
3259 : )
3260 : {
3261 : float scratch[800], cmplx[800];
3262 1273 : const int16_t factors[2] = { 25, 16 };
3263 :
3264 1273 : fftf_interleave( x, y, cmplx, 400 );
3265 1273 : pfaDFT( cmplx, 400, scratch, 2, factors );
3266 1273 : fftf_deinterleave( cmplx, x, y, 400 );
3267 :
3268 :
3269 1273 : return;
3270 : }
3271 :
3272 3500819 : static void DoRTFT240(
3273 : float *x, /* i/o: real part of input and output data */
3274 : float *y /* i/o: imaginary part of input and output data */
3275 : )
3276 : {
3277 : float scratch[480], cmplx[480];
3278 3500819 : const int16_t factors[3] = { 16, 5, 3 };
3279 :
3280 3500819 : fftf_interleave( x, y, cmplx, 240 );
3281 3500819 : pfaDFT( cmplx, 240, scratch, 3, factors );
3282 3500819 : fftf_deinterleave( cmplx, x, y, 240 );
3283 :
3284 3500819 : return;
3285 : }
3286 :
3287 14763 : static void DoRTFT200(
3288 : float *x, /* i/o: real part of input and output data */
3289 : float *y /* i/o: imaginary part of input and output data */
3290 : )
3291 : {
3292 : float scratch[400], cmplx[400];
3293 14763 : const int16_t factors[2] = { 25, 8 };
3294 :
3295 14763 : fftf_interleave( x, y, cmplx, 200 );
3296 14763 : pfaDFT( cmplx, 200, scratch, 2, factors );
3297 14763 : fftf_deinterleave( cmplx, x, y, 200 );
3298 :
3299 14763 : return;
3300 : }
3301 :
3302 91 : static void DoRTFT100(
3303 : float *x, /* i/o: real part of input and output data */
3304 : float *y /* i/o: imaginary part of input and output data */
3305 : )
3306 : {
3307 : float scratch[200], cmplx[200];
3308 91 : const int16_t factors[2] = { 25, 4 };
3309 :
3310 91 : fftf_interleave( x, y, cmplx, 100 );
3311 91 : pfaDFT( cmplx, 100, scratch, 2, factors );
3312 91 : fftf_deinterleave( cmplx, x, y, 100 );
3313 :
3314 91 : return;
3315 : }
3316 :
3317 :
3318 24112574 : void DoFFT(
3319 : float *re2,
3320 : float *im2,
3321 : const int16_t length )
3322 : {
3323 24112574 : switch ( length )
3324 : {
3325 1504 : case 600:
3326 1504 : DoRTFT600( re2, im2 );
3327 1504 : break;
3328 346805 : case 480:
3329 346805 : DoRTFT480( re2, im2 );
3330 346805 : break;
3331 1273 : case 400:
3332 1273 : DoRTFT400( re2, im2 );
3333 1273 : break;
3334 808210 : case 320:
3335 808210 : DoRTFT320( re2, im2 );
3336 808210 : break;
3337 7857 : case 256:
3338 7857 : DoRTFTn( re2, im2, 256 );
3339 7857 : break;
3340 3500819 : case 240:
3341 3500819 : DoRTFT240( re2, im2 );
3342 3500819 : break;
3343 14763 : case 200:
3344 14763 : DoRTFT200( re2, im2 );
3345 14763 : break;
3346 464658 : case 160:
3347 464658 : DoRTFT160( re2, im2 );
3348 464658 : break;
3349 18621234 : case 128:
3350 18621234 : DoRTFT128( re2, im2 );
3351 18621234 : break;
3352 13594 : case 120:
3353 13594 : DoRTFT120( re2, im2 );
3354 13594 : break;
3355 91 : case 100:
3356 91 : DoRTFT100( re2, im2 );
3357 91 : break;
3358 326338 : case 80:
3359 326338 : DoRTFT80( re2, im2 );
3360 326338 : break;
3361 696 : case 64:
3362 696 : DoRTFTn( re2, im2, 64 );
3363 696 : break;
3364 4244 : case 40:
3365 4244 : DoRTFT40( re2, im2 );
3366 4244 : break;
3367 488 : case 20:
3368 488 : DoRTFT20( re2, im2 );
3369 488 : break;
3370 0 : default:
3371 0 : assert( !"fft is not supported!" );
3372 : }
3373 :
3374 24112574 : return;
3375 : }
3376 :
3377 : /*-----------------------------------------------------------------*
3378 : * Low-complexity implementation of FFT
3379 : *-----------------------------------------------------------------*/
3380 :
3381 7374856 : static void fft_len5(
3382 : float *re,
3383 : float *im,
3384 : const int16_t s )
3385 : {
3386 : float x0, x1, x2, x3, x4;
3387 : float r1, r2, r3, r4;
3388 : float s1, s2, s3, s4;
3389 : float t;
3390 :
3391 7374856 : x0 = re[s * 0];
3392 7374856 : x1 = re[s * 1];
3393 7374856 : x2 = re[s * 2];
3394 7374856 : x3 = re[s * 3];
3395 7374856 : x4 = re[s * 4];
3396 :
3397 7374856 : r1 = ( x1 + x4 );
3398 7374856 : r4 = ( x1 - x4 );
3399 7374856 : r3 = ( x2 + x3 );
3400 7374856 : r2 = ( x2 - x3 );
3401 7374856 : t = ( ( r1 - r3 ) * FFT_C54 );
3402 7374856 : r1 = ( r1 + r3 );
3403 7374856 : re[0] = ( x0 + r1 );
3404 :
3405 7374856 : r1 = ( re[0] + ( ( r1 * FFT_C55 ) ) );
3406 7374856 : r3 = ( r1 - t );
3407 7374856 : r1 = ( r1 + t );
3408 7374856 : t = ( ( r4 + r2 ) * FFT_C51 );
3409 :
3410 7374856 : r4 = ( t + ( r4 * FFT_C52 ) );
3411 7374856 : r2 = ( t + ( r2 * FFT_C53 ) );
3412 :
3413 7374856 : x0 = im[s * 0];
3414 7374856 : x1 = im[s * 1];
3415 7374856 : x2 = im[s * 2];
3416 7374856 : x3 = im[s * 3];
3417 7374856 : x4 = im[s * 4];
3418 :
3419 7374856 : s1 = ( x1 + x4 );
3420 7374856 : s4 = ( x1 - x4 );
3421 7374856 : s3 = ( x2 + x3 );
3422 7374856 : s2 = ( x2 - x3 );
3423 7374856 : t = ( ( s1 - s3 ) * FFT_C54 );
3424 7374856 : s1 = ( s1 + s3 );
3425 7374856 : im[0] = ( x0 + s1 );
3426 :
3427 7374856 : s1 = ( im[0] + ( s1 * FFT_C55 ) );
3428 7374856 : s3 = ( s1 - t );
3429 7374856 : s1 = ( s1 + t );
3430 7374856 : t = ( ( s4 + s2 ) * FFT_C51 );
3431 :
3432 7374856 : s4 = ( t + ( s4 * FFT_C52 ) );
3433 7374856 : s2 = ( t + ( s2 * FFT_C53 ) );
3434 :
3435 7374856 : re[s * 1] = ( r1 + s2 );
3436 7374856 : re[s * 4] = ( r1 - s2 );
3437 7374856 : re[s * 2] = ( r3 - s4 );
3438 7374856 : re[s * 3] = ( r3 + s4 );
3439 :
3440 7374856 : im[s * 1] = ( s1 - r2 );
3441 7374856 : im[s * 4] = ( s1 + r2 );
3442 7374856 : im[s * 2] = ( s3 + r4 );
3443 7374856 : im[s * 3] = ( s3 - r4 );
3444 :
3445 7374856 : return;
3446 : }
3447 :
3448 8249336 : static void fft_len8(
3449 : float *re,
3450 : float *im,
3451 : const int16_t s )
3452 : {
3453 : float x00, x01, x02, x03, x04, x05, x06, x07;
3454 : float x08, x09, x10, x11, x12, x13, x14, x15;
3455 : float t00, t01, t02, t03, t04, t05, t06, t07;
3456 : float t08, t09, t10, t11, t12, t13, t14, t15;
3457 : float s00, s01, s02, s03, s04, s05, s06, s07;
3458 : float s08, s09, s10, s11, s12, s13, s14, s15;
3459 :
3460 8249336 : x00 = re[s * 0];
3461 8249336 : x01 = im[s * 0];
3462 8249336 : x02 = re[s * 1];
3463 8249336 : x03 = im[s * 1];
3464 8249336 : x04 = re[s * 2];
3465 8249336 : x05 = im[s * 2];
3466 8249336 : x06 = re[s * 3];
3467 8249336 : x07 = im[s * 3];
3468 8249336 : x08 = re[s * 4];
3469 8249336 : x09 = im[s * 4];
3470 8249336 : x10 = re[s * 5];
3471 8249336 : x11 = im[s * 5];
3472 8249336 : x12 = re[s * 6];
3473 8249336 : x13 = im[s * 6];
3474 8249336 : x14 = re[s * 7];
3475 8249336 : x15 = im[s * 7];
3476 :
3477 8249336 : t00 = ( x00 + x08 );
3478 8249336 : t02 = ( x00 - x08 );
3479 8249336 : t01 = ( x01 + x09 );
3480 8249336 : t03 = ( x01 - x09 );
3481 8249336 : t04 = ( x02 + x10 );
3482 8249336 : t06 = ( x02 - x10 );
3483 8249336 : t05 = ( x03 + x11 );
3484 8249336 : t07 = ( x03 - x11 );
3485 8249336 : t08 = ( x04 + x12 );
3486 8249336 : t10 = ( x04 - x12 );
3487 8249336 : t09 = ( x05 + x13 );
3488 8249336 : t11 = ( x05 - x13 );
3489 8249336 : t12 = ( x06 + x14 );
3490 8249336 : t14 = ( x06 - x14 );
3491 8249336 : t13 = ( x07 + x15 );
3492 8249336 : t15 = ( x07 - x15 );
3493 :
3494 8249336 : s00 = ( t00 + t08 );
3495 8249336 : s04 = ( t00 - t08 );
3496 8249336 : s01 = ( t01 + t09 );
3497 8249336 : s05 = ( t01 - t09 );
3498 8249336 : s08 = ( t02 - t11 );
3499 8249336 : s10 = ( t02 + t11 );
3500 8249336 : s09 = ( t03 + t10 );
3501 8249336 : s11 = ( t03 - t10 );
3502 8249336 : s02 = ( t04 + t12 );
3503 8249336 : s07 = ( t04 - t12 );
3504 8249336 : s03 = ( t05 + t13 );
3505 8249336 : s06 = ( t13 - t05 );
3506 :
3507 8249336 : t01 = ( t06 + t14 );
3508 8249336 : t02 = ( t06 - t14 );
3509 8249336 : t00 = ( t07 + t15 );
3510 8249336 : t03 = ( t07 - t15 );
3511 :
3512 8249336 : s12 = ( ( t00 + t02 ) * FFT_C81 );
3513 8249336 : s14 = ( ( t00 - t02 ) * FFT_C81 );
3514 8249336 : s13 = ( ( t03 - t01 ) * FFT_C81 );
3515 8249336 : s15 = ( ( t01 + t03 ) * FFT_C82 );
3516 :
3517 8249336 : re[s * 0] = ( s00 + s02 );
3518 8249336 : re[s * 4] = ( s00 - s02 );
3519 8249336 : im[s * 0] = ( s01 + s03 );
3520 8249336 : im[s * 4] = ( s01 - s03 );
3521 8249336 : re[s * 2] = ( s04 - s06 );
3522 8249336 : re[s * 6] = ( s04 + s06 );
3523 8249336 : im[s * 2] = ( s05 - s07 );
3524 8249336 : im[s * 6] = ( s05 + s07 );
3525 8249336 : re[s * 3] = ( s08 + s14 );
3526 8249336 : re[s * 7] = ( s08 - s14 );
3527 8249336 : im[s * 3] = ( s09 + s15 );
3528 8249336 : im[s * 7] = ( s09 - s15 );
3529 8249336 : re[s * 1] = ( s10 + s12 );
3530 8249336 : re[s * 5] = ( s10 - s12 );
3531 8249336 : im[s * 1] = ( s11 + s13 );
3532 8249336 : im[s * 5] = ( s11 - s13 );
3533 :
3534 8249336 : return;
3535 : }
3536 :
3537 2219582356 : static void fft_len10(
3538 : float *re,
3539 : float *im,
3540 : const int16_t s )
3541 : {
3542 : float t;
3543 : float x0, x1, x2, x3, x4;
3544 : float r1, r2, r3, r4;
3545 : float s1, s2, s3, s4;
3546 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
3547 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
3548 :
3549 2219582356 : x0 = re[s * 0];
3550 2219582356 : x1 = re[s * 2];
3551 2219582356 : x2 = re[s * 4];
3552 2219582356 : x3 = re[s * 6];
3553 2219582356 : x4 = re[s * 8];
3554 :
3555 2219582356 : r1 = ( x3 + x2 );
3556 2219582356 : r4 = ( x3 - x2 );
3557 2219582356 : r3 = ( x1 + x4 );
3558 2219582356 : r2 = ( x1 - x4 );
3559 2219582356 : t = ( ( r1 - r3 ) * FFT_C54 );
3560 2219582356 : r1 = ( r1 + r3 );
3561 2219582356 : y00 = ( x0 + r1 );
3562 2219582356 : r1 = ( y00 + ( ( r1 * FFT_C55 ) ) );
3563 2219582356 : r3 = ( r1 - t );
3564 2219582356 : r1 = ( r1 + t );
3565 2219582356 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
3566 2219582356 : r4 = ( t + ( r4 * FFT_C52 ) );
3567 2219582356 : r2 = ( t + ( r2 * FFT_C53 ) );
3568 :
3569 2219582356 : x0 = im[s * 0];
3570 2219582356 : x1 = im[s * 2];
3571 2219582356 : x2 = im[s * 4];
3572 2219582356 : x3 = im[s * 6];
3573 2219582356 : x4 = im[s * 8];
3574 :
3575 2219582356 : s1 = ( x3 + x2 );
3576 2219582356 : s4 = ( x3 - x2 );
3577 2219582356 : s3 = ( x1 + x4 );
3578 2219582356 : s2 = ( x1 - x4 );
3579 2219582356 : t = ( ( s1 - s3 ) * FFT_C54 );
3580 2219582356 : s1 = ( s1 + s3 );
3581 2219582356 : y01 = ( x0 + s1 );
3582 2219582356 : s1 = ( y01 + ( s1 * FFT_C55 ) );
3583 2219582356 : s3 = ( s1 - t );
3584 2219582356 : s1 = ( s1 + t );
3585 2219582356 : t = ( ( s4 + s2 ) * FFT_C51 );
3586 2219582356 : s4 = ( t + ( s4 * FFT_C52 ) );
3587 2219582356 : s2 = ( t + ( s2 * FFT_C53 ) );
3588 :
3589 2219582356 : y04 = ( r1 + s2 );
3590 2219582356 : y16 = ( r1 - s2 );
3591 2219582356 : y08 = ( r3 - s4 );
3592 2219582356 : y12 = ( r3 + s4 );
3593 :
3594 2219582356 : y05 = ( s1 - r2 );
3595 2219582356 : y17 = ( s1 + r2 );
3596 2219582356 : y09 = ( s3 + r4 );
3597 2219582356 : y13 = ( s3 - r4 );
3598 :
3599 2219582356 : x0 = re[s * 5];
3600 2219582356 : x1 = re[s * 1];
3601 2219582356 : x2 = re[s * 3];
3602 2219582356 : x3 = re[s * 7];
3603 2219582356 : x4 = re[s * 9];
3604 :
3605 2219582356 : r1 = ( x1 + x4 );
3606 2219582356 : r4 = ( x1 - x4 );
3607 2219582356 : r3 = ( x3 + x2 );
3608 2219582356 : r2 = ( x3 - x2 );
3609 2219582356 : t = ( ( r1 - r3 ) * FFT_C54 );
3610 2219582356 : r1 = ( r1 + r3 );
3611 2219582356 : y02 = ( x0 + r1 );
3612 2219582356 : r1 = ( y02 + ( ( r1 * FFT_C55 ) ) );
3613 2219582356 : r3 = ( r1 - t );
3614 2219582356 : r1 = ( r1 + t );
3615 2219582356 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
3616 2219582356 : r4 = ( t + ( r4 * FFT_C52 ) );
3617 2219582356 : r2 = ( t + ( r2 * FFT_C53 ) );
3618 :
3619 2219582356 : x0 = im[s * 5];
3620 2219582356 : x1 = im[s * 1];
3621 2219582356 : x2 = im[s * 3];
3622 2219582356 : x3 = im[s * 7];
3623 2219582356 : x4 = im[s * 9];
3624 :
3625 2219582356 : s1 = ( x1 + x4 );
3626 2219582356 : s4 = ( x1 - x4 );
3627 2219582356 : s3 = ( x3 + x2 );
3628 2219582356 : s2 = ( x3 - x2 );
3629 2219582356 : t = ( ( s1 - s3 ) * FFT_C54 );
3630 2219582356 : s1 = ( s1 + s3 );
3631 2219582356 : y03 = ( x0 + s1 );
3632 2219582356 : s1 = ( y03 + ( s1 * FFT_C55 ) );
3633 2219582356 : s3 = ( s1 - t );
3634 2219582356 : s1 = ( s1 + t );
3635 2219582356 : t = ( ( s4 + s2 ) * FFT_C51 );
3636 2219582356 : s4 = ( t + ( s4 * FFT_C52 ) );
3637 2219582356 : s2 = ( t + ( s2 * FFT_C53 ) );
3638 :
3639 2219582356 : y06 = ( r1 + s2 );
3640 2219582356 : y18 = ( r1 - s2 );
3641 2219582356 : y10 = ( r3 - s4 );
3642 2219582356 : y14 = ( r3 + s4 );
3643 :
3644 2219582356 : y07 = ( s1 - r2 );
3645 2219582356 : y19 = ( s1 + r2 );
3646 2219582356 : y11 = ( s3 + r4 );
3647 2219582356 : y15 = ( s3 - r4 );
3648 :
3649 2219582356 : re[s * 0] = ( y00 + y02 );
3650 2219582356 : im[s * 0] = ( y01 + y03 );
3651 2219582356 : re[s * 5] = ( y00 - y02 );
3652 2219582356 : im[s * 5] = ( y01 - y03 );
3653 :
3654 2219582356 : re[s * 2] = ( y04 + y06 );
3655 2219582356 : im[s * 2] = ( y05 + y07 );
3656 2219582356 : re[s * 7] = ( y04 - y06 );
3657 2219582356 : im[s * 7] = ( y05 - y07 );
3658 :
3659 2219582356 : re[s * 4] = ( y08 + y10 );
3660 2219582356 : im[s * 4] = ( y09 + y11 );
3661 2219582356 : re[s * 9] = ( y08 - y10 );
3662 2219582356 : im[s * 9] = ( y09 - y11 );
3663 :
3664 2219582356 : re[s * 6] = ( y12 + y14 );
3665 2219582356 : im[s * 6] = ( y13 + y15 );
3666 2219582356 : re[s * 1] = ( y12 - y14 );
3667 2219582356 : im[s * 1] = ( y13 - y15 );
3668 :
3669 2219582356 : re[s * 8] = ( y16 + y18 );
3670 2219582356 : im[s * 8] = ( y17 + y19 );
3671 2219582356 : re[s * 3] = ( y16 - y18 );
3672 2219582356 : im[s * 3] = ( y17 - y19 );
3673 :
3674 2219582356 : return;
3675 : }
3676 :
3677 76913240 : static void fft_len15(
3678 : float *re,
3679 : float *im,
3680 : const int16_t s )
3681 : {
3682 : float t;
3683 : float r1, r2, r3, r4;
3684 : float s1, s2, s3, s4;
3685 : float x00, x01, x02, x03, x04, x05, x06, x07, x08, x09;
3686 : float x10, x11, x12, x13, x14, x15, x16, x17, x18, x19;
3687 : float x20, x21, x22, x23, x24, x25, x26, x27, x28, x29;
3688 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
3689 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
3690 : float y20, y21, y22, y23, y24, y25, y26, y27, y28, y29;
3691 :
3692 76913240 : x00 = re[s * 0];
3693 76913240 : x01 = im[s * 0];
3694 76913240 : x02 = re[s * 3];
3695 76913240 : x03 = im[s * 3];
3696 76913240 : x04 = re[s * 6];
3697 76913240 : x05 = im[s * 6];
3698 76913240 : x06 = re[s * 9];
3699 76913240 : x07 = im[s * 9];
3700 76913240 : x08 = re[s * 12];
3701 76913240 : x09 = im[s * 12];
3702 :
3703 76913240 : x10 = re[s * 5];
3704 76913240 : x11 = im[s * 5];
3705 76913240 : x12 = re[s * 8];
3706 76913240 : x13 = im[s * 8];
3707 76913240 : x14 = re[s * 11];
3708 76913240 : x15 = im[s * 11];
3709 76913240 : x16 = re[s * 14];
3710 76913240 : x17 = im[s * 14];
3711 76913240 : x18 = re[s * 2];
3712 76913240 : x19 = im[s * 2];
3713 :
3714 76913240 : x20 = re[s * 10];
3715 76913240 : x21 = im[s * 10];
3716 76913240 : x22 = re[s * 13];
3717 76913240 : x23 = im[s * 13];
3718 76913240 : x24 = re[s * 1];
3719 76913240 : x25 = im[s * 1];
3720 76913240 : x26 = re[s * 4];
3721 76913240 : x27 = im[s * 4];
3722 76913240 : x28 = re[s * 7];
3723 76913240 : x29 = im[s * 7];
3724 :
3725 76913240 : r1 = ( x02 + x08 );
3726 76913240 : r4 = ( x02 - x08 );
3727 76913240 : r3 = ( x04 + x06 );
3728 76913240 : r2 = ( x04 - x06 );
3729 76913240 : t = ( ( r1 - r3 ) * FFT_C54 );
3730 76913240 : r1 = ( r1 + r3 );
3731 76913240 : y00 = ( x00 + r1 );
3732 76913240 : r1 = ( y00 + ( ( r1 * FFT_C55 ) ) );
3733 76913240 : r3 = ( r1 - t );
3734 76913240 : r1 = ( r1 + t );
3735 76913240 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
3736 76913240 : r4 = ( t + ( r4 * FFT_C52 ) );
3737 76913240 : r2 = ( t + ( r2 * FFT_C53 ) );
3738 :
3739 76913240 : s1 = ( x03 + x09 );
3740 76913240 : s4 = ( x03 - x09 );
3741 76913240 : s3 = ( x05 + x07 );
3742 76913240 : s2 = ( x05 - x07 );
3743 76913240 : t = ( ( s1 - s3 ) * FFT_C54 );
3744 76913240 : s1 = ( s1 + s3 );
3745 76913240 : y01 = ( x01 + s1 );
3746 76913240 : s1 = ( y01 + ( s1 * FFT_C55 ) );
3747 76913240 : s3 = ( s1 - t );
3748 76913240 : s1 = ( s1 + t );
3749 76913240 : t = ( ( s4 + s2 ) * FFT_C51 );
3750 76913240 : s4 = ( t + ( s4 * FFT_C52 ) );
3751 76913240 : s2 = ( t + ( s2 * FFT_C53 ) );
3752 :
3753 76913240 : y02 = ( r1 + s2 );
3754 76913240 : y08 = ( r1 - s2 );
3755 76913240 : y04 = ( r3 - s4 );
3756 76913240 : y06 = ( r3 + s4 );
3757 :
3758 76913240 : y03 = ( s1 - r2 );
3759 76913240 : y09 = ( s1 + r2 );
3760 76913240 : y05 = ( s3 + r4 );
3761 76913240 : y07 = ( s3 - r4 );
3762 :
3763 76913240 : r1 = ( x12 + x18 );
3764 76913240 : r4 = ( x12 - x18 );
3765 76913240 : r3 = ( x14 + x16 );
3766 76913240 : r2 = ( x14 - x16 );
3767 76913240 : t = ( ( r1 - r3 ) * FFT_C54 );
3768 76913240 : r1 = ( r1 + r3 );
3769 76913240 : y10 = ( x10 + r1 );
3770 76913240 : r1 = ( y10 + ( ( r1 * FFT_C55 ) ) );
3771 76913240 : r3 = ( r1 - t );
3772 76913240 : r1 = ( r1 + t );
3773 76913240 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
3774 76913240 : r4 = ( t + ( r4 * FFT_C52 ) );
3775 76913240 : r2 = ( t + ( r2 * FFT_C53 ) );
3776 :
3777 76913240 : s1 = ( x13 + x19 );
3778 76913240 : s4 = ( x13 - x19 );
3779 76913240 : s3 = ( x15 + x17 );
3780 76913240 : s2 = ( x15 - x17 );
3781 76913240 : t = ( ( s1 - s3 ) * FFT_C54 );
3782 76913240 : s1 = ( s1 + s3 );
3783 76913240 : y11 = ( x11 + s1 );
3784 76913240 : s1 = ( y11 + ( s1 * FFT_C55 ) );
3785 76913240 : s3 = ( s1 - t );
3786 76913240 : s1 = ( s1 + t );
3787 76913240 : t = ( ( s4 + s2 ) * FFT_C51 );
3788 76913240 : s4 = ( t + ( s4 * FFT_C52 ) );
3789 76913240 : s2 = ( t + ( s2 * FFT_C53 ) );
3790 :
3791 76913240 : y12 = ( r1 + s2 );
3792 76913240 : y18 = ( r1 - s2 );
3793 76913240 : y14 = ( r3 - s4 );
3794 76913240 : y16 = ( r3 + s4 );
3795 :
3796 76913240 : y13 = ( s1 - r2 );
3797 76913240 : y19 = ( s1 + r2 );
3798 76913240 : y15 = ( s3 + r4 );
3799 76913240 : y17 = ( s3 - r4 );
3800 :
3801 76913240 : r1 = ( x22 + x28 );
3802 76913240 : r4 = ( x22 - x28 );
3803 76913240 : r3 = ( x24 + x26 );
3804 76913240 : r2 = ( x24 - x26 );
3805 76913240 : t = ( ( r1 - r3 ) * FFT_C54 );
3806 76913240 : r1 = ( r1 + r3 );
3807 76913240 : y20 = ( x20 + r1 );
3808 76913240 : r1 = ( y20 + ( ( r1 * FFT_C55 ) ) );
3809 76913240 : r3 = ( r1 - t );
3810 76913240 : r1 = ( r1 + t );
3811 76913240 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
3812 76913240 : r4 = ( t + ( r4 * FFT_C52 ) );
3813 76913240 : r2 = ( t + ( r2 * FFT_C53 ) );
3814 :
3815 76913240 : s1 = ( x23 + x29 );
3816 76913240 : s4 = ( x23 - x29 );
3817 76913240 : s3 = ( x25 + x27 );
3818 76913240 : s2 = ( x25 - x27 );
3819 76913240 : t = ( ( s1 - s3 ) * FFT_C54 );
3820 76913240 : s1 = ( s1 + s3 );
3821 76913240 : y21 = ( x21 + s1 );
3822 76913240 : s1 = ( y21 + ( s1 * FFT_C55 ) );
3823 76913240 : s3 = ( s1 - t );
3824 76913240 : s1 = ( s1 + t );
3825 76913240 : t = ( ( s4 + s2 ) * FFT_C51 );
3826 76913240 : s4 = ( t + ( s4 * FFT_C52 ) );
3827 76913240 : s2 = ( t + ( s2 * FFT_C53 ) );
3828 :
3829 76913240 : y22 = ( r1 + s2 );
3830 76913240 : y28 = ( r1 - s2 );
3831 76913240 : y24 = ( r3 - s4 );
3832 76913240 : y26 = ( r3 + s4 );
3833 :
3834 76913240 : y23 = ( s1 - r2 );
3835 76913240 : y29 = ( s1 + r2 );
3836 76913240 : y25 = ( s3 + r4 );
3837 76913240 : y27 = ( s3 - r4 );
3838 :
3839 76913240 : r1 = ( y10 + y20 );
3840 76913240 : r2 = ( ( y10 - y20 ) * FFT_C31 );
3841 76913240 : re[s * 0] = ( y00 + r1 );
3842 76913240 : r1 = ( y00 - r1 * 0.5f );
3843 :
3844 76913240 : s1 = ( y11 + y21 );
3845 76913240 : s2 = ( ( y11 - y21 ) * FFT_C31 );
3846 76913240 : im[s * 0] = ( y01 + s1 );
3847 76913240 : s1 = ( y01 - s1 * 0.5f );
3848 :
3849 76913240 : re[s * 10] = ( r1 - s2 );
3850 76913240 : re[s * 5] = ( r1 + s2 );
3851 76913240 : im[s * 10] = ( s1 + r2 );
3852 76913240 : im[s * 5] = ( s1 - r2 );
3853 :
3854 76913240 : r1 = ( y12 + y22 );
3855 76913240 : r2 = ( ( y12 - y22 ) * FFT_C31 );
3856 76913240 : re[s * 6] = ( y02 + r1 );
3857 76913240 : r1 = ( y02 - r1 * 0.5f );
3858 :
3859 76913240 : s1 = ( y13 + y23 );
3860 76913240 : s2 = ( ( y13 - y23 ) * FFT_C31 );
3861 76913240 : im[s * 6] = ( y03 + s1 );
3862 76913240 : s1 = ( y03 - s1 * 0.5f );
3863 :
3864 76913240 : re[s * 1] = ( r1 - s2 );
3865 76913240 : re[s * 11] = ( r1 + s2 );
3866 76913240 : im[s * 1] = ( s1 + r2 );
3867 76913240 : im[s * 11] = ( s1 - r2 );
3868 :
3869 76913240 : r1 = ( y14 + y24 );
3870 76913240 : r2 = ( ( y14 - y24 ) * FFT_C31 );
3871 76913240 : re[s * 12] = ( y04 + r1 );
3872 76913240 : r1 = ( y04 - r1 * 0.5f );
3873 :
3874 76913240 : s1 = ( y15 + y25 );
3875 76913240 : s2 = ( ( y15 - y25 ) * FFT_C31 );
3876 76913240 : im[s * 12] = ( y05 + s1 );
3877 76913240 : s1 = ( y05 - s1 * 0.5f );
3878 :
3879 76913240 : re[s * 7] = ( r1 - s2 );
3880 76913240 : re[s * 2] = ( r1 + s2 );
3881 76913240 : im[s * 7] = ( s1 + r2 );
3882 76913240 : im[s * 2] = ( s1 - r2 );
3883 :
3884 76913240 : r1 = ( y16 + y26 );
3885 76913240 : r2 = ( ( y16 - y26 ) * FFT_C31 );
3886 76913240 : re[s * 3] = ( y06 + r1 );
3887 76913240 : r1 = ( y06 - r1 * 0.5f );
3888 :
3889 76913240 : s1 = ( y17 + y27 );
3890 76913240 : s2 = ( ( y17 - y27 ) * FFT_C31 );
3891 76913240 : im[s * 3] = ( y07 + s1 );
3892 76913240 : s1 = ( y07 - s1 * 0.5f );
3893 :
3894 76913240 : re[s * 13] = ( r1 - s2 );
3895 76913240 : re[s * 8] = ( r1 + s2 );
3896 76913240 : im[s * 13] = ( s1 + r2 );
3897 76913240 : im[s * 8] = ( s1 - r2 );
3898 :
3899 76913240 : r1 = ( y18 + y28 );
3900 76913240 : r2 = ( ( y18 - y28 ) * FFT_C31 );
3901 76913240 : re[s * 9] = ( y08 + r1 );
3902 76913240 : r1 = ( y08 - r1 * 0.5f );
3903 :
3904 76913240 : s1 = ( y19 + y29 );
3905 76913240 : s2 = ( ( y19 - y29 ) * FFT_C31 );
3906 76913240 : im[s * 9] = ( y09 + s1 );
3907 76913240 : s1 = ( y09 - s1 * 0.5f );
3908 :
3909 76913240 : re[s * 4] = ( r1 - s2 );
3910 76913240 : re[s * 14] = ( r1 + s2 );
3911 76913240 : im[s * 4] = ( s1 + r2 );
3912 76913240 : im[s * 14] = ( s1 - r2 );
3913 :
3914 76913240 : return;
3915 : }
3916 :
3917 2798277808 : static void fft_len16(
3918 : float *re,
3919 : float *im,
3920 : const int16_t s )
3921 : {
3922 : float x0, x1, x2, x3, x4, x5, x6, x7;
3923 : float t0, t1, t2, t3, t4, t5, t6, t7;
3924 : float y00, y01, y02, y03, y04, y05, y06, y07;
3925 : float y08, y09, y10, y11, y12, y13, y14, y15;
3926 : float y16, y17, y18, y19, y20, y21, y22, y23;
3927 : float y24, y25, y26, y27, y28, y29, y30, y31;
3928 :
3929 2798277808 : x0 = re[s * 0];
3930 2798277808 : x1 = im[s * 0];
3931 2798277808 : x2 = re[s * 4];
3932 2798277808 : x3 = im[s * 4];
3933 2798277808 : x4 = re[s * 8];
3934 2798277808 : x5 = im[s * 8];
3935 2798277808 : x6 = re[s * 12];
3936 2798277808 : x7 = im[s * 12];
3937 :
3938 2798277808 : t0 = ( x0 + x4 );
3939 2798277808 : t2 = ( x0 - x4 );
3940 2798277808 : t1 = ( x1 + x5 );
3941 2798277808 : t3 = ( x1 - x5 );
3942 2798277808 : t4 = ( x2 + x6 );
3943 2798277808 : t7 = ( x2 - x6 );
3944 2798277808 : t5 = ( x7 + x3 );
3945 2798277808 : t6 = ( x7 - x3 );
3946 :
3947 2798277808 : y00 = ( t0 + t4 );
3948 2798277808 : y01 = ( t1 + t5 );
3949 2798277808 : y02 = ( t2 - t6 );
3950 2798277808 : y03 = ( t3 - t7 );
3951 2798277808 : y04 = ( t0 - t4 );
3952 2798277808 : y05 = ( t1 - t5 );
3953 2798277808 : y06 = ( t2 + t6 );
3954 2798277808 : y07 = ( t3 + t7 );
3955 :
3956 2798277808 : x0 = re[s * 1];
3957 2798277808 : x1 = im[s * 1];
3958 2798277808 : x2 = re[s * 5];
3959 2798277808 : x3 = im[s * 5];
3960 2798277808 : x4 = re[s * 9];
3961 2798277808 : x5 = im[s * 9];
3962 2798277808 : x6 = re[s * 13];
3963 2798277808 : x7 = im[s * 13];
3964 :
3965 2798277808 : t0 = ( x0 + x4 );
3966 2798277808 : t2 = ( x0 - x4 );
3967 2798277808 : t1 = ( x1 + x5 );
3968 2798277808 : t3 = ( x1 - x5 );
3969 2798277808 : t4 = ( x2 + x6 );
3970 2798277808 : t7 = ( x2 - x6 );
3971 2798277808 : t5 = ( x7 + x3 );
3972 2798277808 : t6 = ( x7 - x3 );
3973 :
3974 2798277808 : y08 = ( t0 + t4 );
3975 2798277808 : y09 = ( t1 + t5 );
3976 2798277808 : y10 = ( t2 - t6 );
3977 2798277808 : y11 = ( t3 - t7 );
3978 2798277808 : y12 = ( t0 - t4 );
3979 2798277808 : y13 = ( t1 - t5 );
3980 2798277808 : y14 = ( t2 + t6 );
3981 2798277808 : y15 = ( t3 + t7 );
3982 :
3983 2798277808 : x0 = re[s * 2];
3984 2798277808 : x1 = im[s * 2];
3985 2798277808 : x2 = re[s * 6];
3986 2798277808 : x3 = im[s * 6];
3987 2798277808 : x4 = re[s * 10];
3988 2798277808 : x5 = im[s * 10];
3989 2798277808 : x6 = re[s * 14];
3990 2798277808 : x7 = im[s * 14];
3991 :
3992 2798277808 : t0 = ( x0 + x4 );
3993 2798277808 : t2 = ( x0 - x4 );
3994 2798277808 : t1 = ( x1 + x5 );
3995 2798277808 : t3 = ( x1 - x5 );
3996 2798277808 : t4 = ( x2 + x6 );
3997 2798277808 : t7 = ( x2 - x6 );
3998 2798277808 : t5 = ( x7 + x3 );
3999 2798277808 : t6 = ( x7 - x3 );
4000 :
4001 2798277808 : y16 = ( t0 + t4 );
4002 2798277808 : y17 = ( t1 + t5 );
4003 2798277808 : y18 = ( t2 - t6 );
4004 2798277808 : y19 = ( t3 - t7 );
4005 2798277808 : y20 = ( t1 - t5 );
4006 2798277808 : y21 = ( t4 - t0 );
4007 2798277808 : y22 = ( t2 + t6 );
4008 2798277808 : y23 = ( t3 + t7 );
4009 :
4010 2798277808 : x0 = re[s * 3];
4011 2798277808 : x1 = im[s * 3];
4012 2798277808 : x2 = re[s * 7];
4013 2798277808 : x3 = im[s * 7];
4014 2798277808 : x4 = re[s * 11];
4015 2798277808 : x5 = im[s * 11];
4016 2798277808 : x6 = re[s * 15];
4017 2798277808 : x7 = im[s * 15];
4018 :
4019 2798277808 : t0 = ( x0 + x4 );
4020 2798277808 : t2 = ( x0 - x4 );
4021 2798277808 : t1 = ( x1 + x5 );
4022 2798277808 : t3 = ( x1 - x5 );
4023 2798277808 : t4 = ( x2 + x6 );
4024 2798277808 : t7 = ( x2 - x6 );
4025 2798277808 : t5 = ( x7 + x3 );
4026 2798277808 : t6 = ( x7 - x3 );
4027 :
4028 2798277808 : y24 = ( t0 + t4 );
4029 2798277808 : y25 = ( t1 + t5 );
4030 2798277808 : y26 = ( t2 - t6 );
4031 2798277808 : y27 = ( t3 - t7 );
4032 2798277808 : y28 = ( t0 - t4 );
4033 2798277808 : y29 = ( t1 - t5 );
4034 2798277808 : y30 = ( t2 + t6 );
4035 2798277808 : y31 = ( t3 + t7 );
4036 :
4037 2798277808 : x0 = ( y22 * FFT_C162 );
4038 2798277808 : x1 = ( y23 * FFT_C162 );
4039 2798277808 : y22 = ( x0 - x1 );
4040 2798277808 : y23 = ( x0 + x1 );
4041 :
4042 2798277808 : x0 = ( y28 * FFT_C162 );
4043 2798277808 : x1 = ( y29 * FFT_C162 );
4044 2798277808 : y28 = ( x0 - x1 );
4045 2798277808 : y29 = ( x0 + x1 );
4046 :
4047 2798277808 : x0 = ( y12 * FFT_C161 );
4048 2798277808 : x1 = ( y13 * FFT_C161 );
4049 2798277808 : y12 = ( x0 + x1 );
4050 2798277808 : y13 = ( x1 - x0 );
4051 :
4052 2798277808 : x0 = ( y18 * FFT_C161 );
4053 2798277808 : x1 = ( y19 * FFT_C161 );
4054 2798277808 : y18 = ( x0 + x1 );
4055 2798277808 : y19 = ( x1 - x0 );
4056 :
4057 2798277808 : x0 = ( y10 * FFT_C163 );
4058 2798277808 : x1 = ( y11 * FFT_C166 );
4059 2798277808 : x2 = ( y10 * FFT_C166 );
4060 2798277808 : x3 = ( y11 * FFT_C163 );
4061 2798277808 : y10 = ( x0 - x1 );
4062 2798277808 : y11 = ( x2 + x3 );
4063 :
4064 2798277808 : x0 = ( y14 * FFT_C165 );
4065 2798277808 : x1 = ( y15 * FFT_C164 );
4066 2798277808 : x2 = ( y14 * FFT_C164 );
4067 2798277808 : x3 = ( y15 * FFT_C165 );
4068 2798277808 : y14 = ( x0 - x1 );
4069 2798277808 : y15 = ( x2 + x3 );
4070 :
4071 2798277808 : x0 = ( y26 * FFT_C165 );
4072 2798277808 : x1 = ( y27 * FFT_C164 );
4073 2798277808 : x2 = ( y26 * FFT_C164 );
4074 2798277808 : x3 = ( y27 * FFT_C165 );
4075 2798277808 : y26 = ( x0 - x1 );
4076 2798277808 : y27 = ( x2 + x3 );
4077 :
4078 2798277808 : x0 = ( y30 * FFT_C164 );
4079 2798277808 : x1 = ( y31 * FFT_C165 );
4080 2798277808 : x2 = ( y30 * FFT_C165 );
4081 2798277808 : x3 = ( y31 * FFT_C164 );
4082 2798277808 : y30 = ( x0 - x1 );
4083 2798277808 : y31 = ( x2 + x3 );
4084 :
4085 2798277808 : t0 = ( y00 + y16 );
4086 2798277808 : t2 = ( y00 - y16 );
4087 2798277808 : t1 = ( y01 + y17 );
4088 2798277808 : t3 = ( y01 - y17 );
4089 2798277808 : t4 = ( y08 + y24 );
4090 2798277808 : t7 = ( y08 - y24 );
4091 2798277808 : t5 = ( y25 + y09 );
4092 2798277808 : t6 = ( y25 - y09 );
4093 :
4094 2798277808 : re[s * 0] = ( t0 + t4 );
4095 2798277808 : im[s * 0] = ( t1 + t5 );
4096 2798277808 : re[s * 4] = ( t2 - t6 );
4097 2798277808 : im[s * 4] = ( t3 - t7 );
4098 2798277808 : re[s * 8] = ( t0 - t4 );
4099 2798277808 : im[s * 8] = ( t1 - t5 );
4100 2798277808 : re[s * 12] = ( t2 + t6 );
4101 2798277808 : im[s * 12] = ( t3 + t7 );
4102 :
4103 2798277808 : t0 = ( y02 + y18 );
4104 2798277808 : t2 = ( y02 - y18 );
4105 2798277808 : t1 = ( y03 + y19 );
4106 2798277808 : t3 = ( y03 - y19 );
4107 2798277808 : t4 = ( y10 + y26 );
4108 2798277808 : t7 = ( y10 - y26 );
4109 2798277808 : t5 = ( y27 + y11 );
4110 2798277808 : t6 = ( y27 - y11 );
4111 :
4112 2798277808 : re[s * 1] = ( t0 + t4 );
4113 2798277808 : im[s * 1] = ( t1 + t5 );
4114 2798277808 : re[s * 5] = ( t2 - t6 );
4115 2798277808 : im[s * 5] = ( t3 - t7 );
4116 2798277808 : re[s * 9] = ( t0 - t4 );
4117 2798277808 : im[s * 9] = ( t1 - t5 );
4118 2798277808 : re[s * 13] = ( t2 + t6 );
4119 2798277808 : im[s * 13] = ( t3 + t7 );
4120 :
4121 2798277808 : t0 = ( y04 + y20 );
4122 2798277808 : t2 = ( y04 - y20 );
4123 2798277808 : t1 = ( y05 + y21 );
4124 2798277808 : t3 = ( y05 - y21 );
4125 2798277808 : t4 = ( y12 + y28 );
4126 2798277808 : t7 = ( y12 - y28 );
4127 2798277808 : t5 = ( y29 + y13 );
4128 2798277808 : t6 = ( y29 - y13 );
4129 :
4130 2798277808 : re[s * 2] = ( t0 + t4 );
4131 2798277808 : im[s * 2] = ( t1 + t5 );
4132 2798277808 : re[s * 6] = ( t2 - t6 );
4133 2798277808 : im[s * 6] = ( t3 - t7 );
4134 2798277808 : re[s * 10] = ( t0 - t4 );
4135 2798277808 : im[s * 10] = ( t1 - t5 );
4136 2798277808 : re[s * 14] = ( t2 + t6 );
4137 2798277808 : im[s * 14] = ( t3 + t7 );
4138 :
4139 2798277808 : t0 = ( y06 + y22 );
4140 2798277808 : t2 = ( y06 - y22 );
4141 2798277808 : t1 = ( y07 + y23 );
4142 2798277808 : t3 = ( y07 - y23 );
4143 2798277808 : t4 = ( y14 + y30 );
4144 2798277808 : t7 = ( y14 - y30 );
4145 2798277808 : t5 = ( y31 + y15 );
4146 2798277808 : t6 = ( y31 - y15 );
4147 :
4148 2798277808 : re[s * 3] = ( t0 + t4 );
4149 2798277808 : im[s * 3] = ( t1 + t5 );
4150 2798277808 : re[s * 7] = ( t2 - t6 );
4151 2798277808 : im[s * 7] = ( t3 - t7 );
4152 2798277808 : re[s * 11] = ( t0 - t4 );
4153 2798277808 : im[s * 11] = ( t1 - t5 );
4154 2798277808 : re[s * 15] = ( t2 + t6 );
4155 2798277808 : im[s * 15] = ( t3 + t7 );
4156 :
4157 2798277808 : return;
4158 : }
4159 :
4160 3518063696 : static void fft_len20(
4161 : float *re,
4162 : float *im,
4163 : const int16_t s )
4164 : {
4165 : float r1, r2, r3, r4;
4166 : float s1, s2, s3, s4;
4167 : float x0, x1, x2, x3, x4;
4168 : float t, t0, t1, t2, t3, t4, t5, t6, t7;
4169 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
4170 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
4171 : float y20, y21, y22, y23, y24, y25, y26, y27, y28, y29;
4172 : float y30, y31, y32, y33, y34, y35, y36, y37, y38, y39;
4173 :
4174 3518063696 : x0 = re[s * 0];
4175 3518063696 : x1 = re[s * 16];
4176 3518063696 : x2 = re[s * 12];
4177 3518063696 : x3 = re[s * 8];
4178 3518063696 : x4 = re[s * 4];
4179 :
4180 3518063696 : r1 = ( x1 + x4 );
4181 3518063696 : r4 = ( x1 - x4 );
4182 3518063696 : r3 = ( x2 + x3 );
4183 3518063696 : r2 = ( x2 - x3 );
4184 3518063696 : t = ( ( r1 - r3 ) * FFT_C54 );
4185 3518063696 : r1 = ( r1 + r3 );
4186 3518063696 : y00 = ( x0 + r1 );
4187 3518063696 : r1 = ( y00 + ( ( r1 * FFT_C55 ) ) );
4188 3518063696 : r3 = ( r1 - t );
4189 3518063696 : r1 = ( r1 + t );
4190 3518063696 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4191 3518063696 : r4 = ( t + ( r4 * FFT_C52 ) );
4192 3518063696 : r2 = ( t + ( r2 * FFT_C53 ) );
4193 :
4194 3518063696 : x0 = im[s * 0];
4195 3518063696 : x1 = im[s * 16];
4196 3518063696 : x2 = im[s * 12];
4197 3518063696 : x3 = im[s * 8];
4198 3518063696 : x4 = im[s * 4];
4199 :
4200 3518063696 : s1 = ( x1 + x4 );
4201 3518063696 : s4 = ( x1 - x4 );
4202 3518063696 : s3 = ( x2 + x3 );
4203 3518063696 : s2 = ( x2 - x3 );
4204 3518063696 : t = ( ( s1 - s3 ) * FFT_C54 );
4205 3518063696 : s1 = ( s1 + s3 );
4206 3518063696 : y01 = ( x0 + s1 );
4207 3518063696 : s1 = ( y01 + ( s1 * FFT_C55 ) );
4208 3518063696 : s3 = ( s1 - t );
4209 3518063696 : s1 = ( s1 + t );
4210 3518063696 : t = ( ( s4 + s2 ) * FFT_C51 );
4211 3518063696 : s4 = ( t + ( s4 * FFT_C52 ) );
4212 3518063696 : s2 = ( t + ( s2 * FFT_C53 ) );
4213 :
4214 3518063696 : y08 = ( r1 + s2 );
4215 3518063696 : y32 = ( r1 - s2 );
4216 3518063696 : y16 = ( r3 - s4 );
4217 3518063696 : y24 = ( r3 + s4 );
4218 :
4219 3518063696 : y09 = ( s1 - r2 );
4220 3518063696 : y33 = ( s1 + r2 );
4221 3518063696 : y17 = ( s3 + r4 );
4222 3518063696 : y25 = ( s3 - r4 );
4223 :
4224 3518063696 : x0 = re[s * 5];
4225 3518063696 : x1 = re[s * 1];
4226 3518063696 : x2 = re[s * 17];
4227 3518063696 : x3 = re[s * 13];
4228 3518063696 : x4 = re[s * 9];
4229 :
4230 3518063696 : r1 = ( x1 + x4 );
4231 3518063696 : r4 = ( x1 - x4 );
4232 3518063696 : r3 = ( x2 + x3 );
4233 3518063696 : r2 = ( x2 - x3 );
4234 3518063696 : t = ( ( r1 - r3 ) * FFT_C54 );
4235 3518063696 : r1 = ( r1 + r3 );
4236 3518063696 : y02 = ( x0 + r1 );
4237 3518063696 : r1 = ( y02 + ( ( r1 * FFT_C55 ) ) );
4238 3518063696 : r3 = ( r1 - t );
4239 3518063696 : r1 = ( r1 + t );
4240 3518063696 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4241 3518063696 : r4 = ( t + ( r4 * FFT_C52 ) );
4242 3518063696 : r2 = ( t + ( r2 * FFT_C53 ) );
4243 :
4244 3518063696 : x0 = im[s * 5];
4245 3518063696 : x1 = im[s * 1];
4246 3518063696 : x2 = im[s * 17];
4247 3518063696 : x3 = im[s * 13];
4248 3518063696 : x4 = im[s * 9];
4249 :
4250 3518063696 : s1 = ( x1 + x4 );
4251 3518063696 : s4 = ( x1 - x4 );
4252 3518063696 : s3 = ( x2 + x3 );
4253 3518063696 : s2 = ( x2 - x3 );
4254 3518063696 : t = ( ( s1 - s3 ) * FFT_C54 );
4255 3518063696 : s1 = ( s1 + s3 );
4256 3518063696 : y03 = ( x0 + s1 );
4257 3518063696 : s1 = ( y03 + ( s1 * FFT_C55 ) );
4258 3518063696 : s3 = ( s1 - t );
4259 3518063696 : s1 = ( s1 + t );
4260 3518063696 : t = ( ( s4 + s2 ) * FFT_C51 );
4261 3518063696 : s4 = ( t + ( s4 * FFT_C52 ) );
4262 3518063696 : s2 = ( t + ( s2 * FFT_C53 ) );
4263 :
4264 3518063696 : y10 = ( r1 + s2 );
4265 3518063696 : y34 = ( r1 - s2 );
4266 3518063696 : y18 = ( r3 - s4 );
4267 3518063696 : y26 = ( r3 + s4 );
4268 :
4269 3518063696 : y11 = ( s1 - r2 );
4270 3518063696 : y35 = ( s1 + r2 );
4271 3518063696 : y19 = ( s3 + r4 );
4272 3518063696 : y27 = ( s3 - r4 );
4273 :
4274 3518063696 : x0 = re[s * 10];
4275 3518063696 : x1 = re[s * 6];
4276 3518063696 : x2 = re[s * 2];
4277 3518063696 : x3 = re[s * 18];
4278 3518063696 : x4 = re[s * 14];
4279 :
4280 3518063696 : r1 = ( x1 + x4 );
4281 3518063696 : r4 = ( x1 - x4 );
4282 3518063696 : r3 = ( x2 + x3 );
4283 3518063696 : r2 = ( x2 - x3 );
4284 3518063696 : t = ( ( r1 - r3 ) * FFT_C54 );
4285 3518063696 : r1 = ( r1 + r3 );
4286 3518063696 : y04 = ( x0 + r1 );
4287 3518063696 : r1 = ( y04 + ( ( r1 * FFT_C55 ) ) );
4288 3518063696 : r3 = ( r1 - t );
4289 3518063696 : r1 = ( r1 + t );
4290 3518063696 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4291 3518063696 : r4 = ( t + ( r4 * FFT_C52 ) );
4292 3518063696 : r2 = ( t + ( r2 * FFT_C53 ) );
4293 :
4294 3518063696 : x0 = im[s * 10];
4295 3518063696 : x1 = im[s * 6];
4296 3518063696 : x2 = im[s * 2];
4297 3518063696 : x3 = im[s * 18];
4298 3518063696 : x4 = im[s * 14];
4299 :
4300 3518063696 : s1 = ( x1 + x4 );
4301 3518063696 : s4 = ( x1 - x4 );
4302 3518063696 : s3 = ( x2 + x3 );
4303 3518063696 : s2 = ( x2 - x3 );
4304 3518063696 : t = ( ( s1 - s3 ) * FFT_C54 );
4305 3518063696 : s1 = ( s1 + s3 );
4306 3518063696 : y05 = ( x0 + s1 );
4307 3518063696 : s1 = ( y05 + ( s1 * FFT_C55 ) );
4308 3518063696 : s3 = ( s1 - t );
4309 3518063696 : s1 = ( s1 + t );
4310 3518063696 : t = ( ( s4 + s2 ) * FFT_C51 );
4311 3518063696 : s4 = ( t + ( s4 * FFT_C52 ) );
4312 3518063696 : s2 = ( t + ( s2 * FFT_C53 ) );
4313 :
4314 3518063696 : y12 = ( r1 + s2 );
4315 3518063696 : y36 = ( r1 - s2 );
4316 3518063696 : y20 = ( r3 - s4 );
4317 3518063696 : y28 = ( r3 + s4 );
4318 :
4319 3518063696 : y13 = ( s1 - r2 );
4320 3518063696 : y37 = ( s1 + r2 );
4321 3518063696 : y21 = ( s3 + r4 );
4322 3518063696 : y29 = ( s3 - r4 );
4323 :
4324 3518063696 : x0 = re[s * 15];
4325 3518063696 : x1 = re[s * 11];
4326 3518063696 : x2 = re[s * 7];
4327 3518063696 : x3 = re[s * 3];
4328 3518063696 : x4 = re[s * 19];
4329 :
4330 3518063696 : r1 = ( x1 + x4 );
4331 3518063696 : r4 = ( x1 - x4 );
4332 3518063696 : r3 = ( x2 + x3 );
4333 3518063696 : r2 = ( x2 - x3 );
4334 3518063696 : t = ( ( r1 - r3 ) * FFT_C54 );
4335 3518063696 : r1 = ( r1 + r3 );
4336 3518063696 : y06 = ( x0 + r1 );
4337 3518063696 : r1 = ( y06 + ( ( r1 * FFT_C55 ) ) );
4338 3518063696 : r3 = ( r1 - t );
4339 3518063696 : r1 = ( r1 + t );
4340 3518063696 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4341 3518063696 : r4 = ( t + ( r4 * FFT_C52 ) );
4342 3518063696 : r2 = ( t + ( r2 * FFT_C53 ) );
4343 :
4344 3518063696 : x0 = im[s * 15];
4345 3518063696 : x1 = im[s * 11];
4346 3518063696 : x2 = im[s * 7];
4347 3518063696 : x3 = im[s * 3];
4348 3518063696 : x4 = im[s * 19];
4349 :
4350 3518063696 : s1 = ( x1 + x4 );
4351 3518063696 : s4 = ( x1 - x4 );
4352 3518063696 : s3 = ( x2 + x3 );
4353 3518063696 : s2 = ( x2 - x3 );
4354 3518063696 : t = ( ( s1 - s3 ) * FFT_C54 );
4355 3518063696 : s1 = ( s1 + s3 );
4356 3518063696 : y07 = ( x0 + s1 );
4357 3518063696 : s1 = ( y07 + ( s1 * FFT_C55 ) );
4358 3518063696 : s3 = ( s1 - t );
4359 3518063696 : s1 = ( s1 + t );
4360 3518063696 : t = ( ( s4 + s2 ) * FFT_C51 );
4361 3518063696 : s4 = ( t + ( s4 * FFT_C52 ) );
4362 3518063696 : s2 = ( t + ( s2 * FFT_C53 ) );
4363 :
4364 3518063696 : y14 = ( r1 + s2 );
4365 3518063696 : y38 = ( r1 - s2 );
4366 3518063696 : y22 = ( r3 - s4 );
4367 3518063696 : y30 = ( r3 + s4 );
4368 :
4369 3518063696 : y15 = ( s1 - r2 );
4370 3518063696 : y39 = ( s1 + r2 );
4371 3518063696 : y23 = ( s3 + r4 );
4372 3518063696 : y31 = ( s3 - r4 );
4373 :
4374 3518063696 : t0 = ( y00 + y04 );
4375 3518063696 : t2 = ( y00 - y04 );
4376 3518063696 : t1 = ( y01 + y05 );
4377 3518063696 : t3 = ( y01 - y05 );
4378 3518063696 : t4 = ( y02 + y06 );
4379 3518063696 : t7 = ( y02 - y06 );
4380 3518063696 : t5 = ( y07 + y03 );
4381 3518063696 : t6 = ( y07 - y03 );
4382 :
4383 3518063696 : re[s * 0] = ( t0 + t4 );
4384 3518063696 : im[s * 0] = ( t1 + t5 );
4385 3518063696 : re[s * 5] = ( t2 - t6 );
4386 3518063696 : im[s * 5] = ( t3 - t7 );
4387 3518063696 : re[s * 10] = ( t0 - t4 );
4388 3518063696 : im[s * 10] = ( t1 - t5 );
4389 3518063696 : re[s * 15] = ( t2 + t6 );
4390 3518063696 : im[s * 15] = ( t3 + t7 );
4391 :
4392 3518063696 : t0 = ( y08 + y12 );
4393 3518063696 : t2 = ( y08 - y12 );
4394 3518063696 : t1 = ( y09 + y13 );
4395 3518063696 : t3 = ( y09 - y13 );
4396 3518063696 : t4 = ( y10 + y14 );
4397 3518063696 : t7 = ( y10 - y14 );
4398 3518063696 : t5 = ( y15 + y11 );
4399 3518063696 : t6 = ( y15 - y11 );
4400 :
4401 3518063696 : re[s * 4] = ( t0 + t4 );
4402 3518063696 : im[s * 4] = ( t1 + t5 );
4403 3518063696 : re[s * 9] = ( t2 - t6 );
4404 3518063696 : im[s * 9] = ( t3 - t7 );
4405 3518063696 : re[s * 14] = ( t0 - t4 );
4406 3518063696 : im[s * 14] = ( t1 - t5 );
4407 3518063696 : re[s * 19] = ( t2 + t6 );
4408 3518063696 : im[s * 19] = ( t3 + t7 );
4409 :
4410 3518063696 : t0 = ( y16 + y20 );
4411 3518063696 : t2 = ( y16 - y20 );
4412 3518063696 : t1 = ( y17 + y21 );
4413 3518063696 : t3 = ( y17 - y21 );
4414 3518063696 : t4 = ( y18 + y22 );
4415 3518063696 : t7 = ( y18 - y22 );
4416 3518063696 : t5 = ( y23 + y19 );
4417 3518063696 : t6 = ( y23 - y19 );
4418 :
4419 3518063696 : re[s * 8] = ( t0 + t4 );
4420 3518063696 : im[s * 8] = ( t1 + t5 );
4421 3518063696 : re[s * 13] = ( t2 - t6 );
4422 3518063696 : im[s * 13] = ( t3 - t7 );
4423 3518063696 : re[s * 18] = ( t0 - t4 );
4424 3518063696 : im[s * 18] = ( t1 - t5 );
4425 3518063696 : re[s * 3] = ( t2 + t6 );
4426 3518063696 : im[s * 3] = ( t3 + t7 );
4427 :
4428 3518063696 : t0 = ( y24 + y28 );
4429 3518063696 : t2 = ( y24 - y28 );
4430 3518063696 : t1 = ( y25 + y29 );
4431 3518063696 : t3 = ( y25 - y29 );
4432 3518063696 : t4 = ( y26 + y30 );
4433 3518063696 : t7 = ( y26 - y30 );
4434 3518063696 : t5 = ( y31 + y27 );
4435 3518063696 : t6 = ( y31 - y27 );
4436 :
4437 3518063696 : re[s * 12] = ( t0 + t4 );
4438 3518063696 : im[s * 12] = ( t1 + t5 );
4439 3518063696 : re[s * 17] = ( t2 - t6 );
4440 3518063696 : im[s * 17] = ( t3 - t7 );
4441 3518063696 : re[s * 2] = ( t0 - t4 );
4442 3518063696 : im[s * 2] = ( t1 - t5 );
4443 3518063696 : re[s * 7] = ( t2 + t6 );
4444 3518063696 : im[s * 7] = ( t3 + t7 );
4445 :
4446 3518063696 : t0 = ( y32 + y36 );
4447 3518063696 : t2 = ( y32 - y36 );
4448 3518063696 : t1 = ( y33 + y37 );
4449 3518063696 : t3 = ( y33 - y37 );
4450 3518063696 : t4 = ( y34 + y38 );
4451 3518063696 : t7 = ( y34 - y38 );
4452 3518063696 : t5 = ( y39 + y35 );
4453 3518063696 : t6 = ( y39 - y35 );
4454 :
4455 3518063696 : re[s * 16] = ( t0 + t4 );
4456 3518063696 : im[s * 16] = ( t1 + t5 );
4457 3518063696 : re[s * 1] = ( t2 - t6 );
4458 3518063696 : im[s * 1] = ( t3 - t7 );
4459 3518063696 : re[s * 6] = ( t0 - t4 );
4460 3518063696 : im[s * 6] = ( t1 - t5 );
4461 3518063696 : re[s * 11] = ( t2 + t6 );
4462 3518063696 : im[s * 11] = ( t3 + t7 );
4463 :
4464 3518063696 : return;
4465 : }
4466 :
4467 4556148764 : static void fft_len30(
4468 : float *re,
4469 : float *im,
4470 : const int16_t s )
4471 : {
4472 : float t;
4473 : float r1, r2, r3, r4;
4474 : float s1, s2, s3, s4;
4475 : float x00, x01, x02, x03, x04, x05, x06, x07, x08, x09;
4476 : float x10, x11, x12, x13, x14, x15, x16, x17, x18, x19;
4477 : float x20, x21, x22, x23, x24, x25, x26, x27, x28, x29;
4478 :
4479 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
4480 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
4481 : float y20, y21, y22, y23, y24, y25, y26, y27, y28, y29;
4482 :
4483 : float z00, z01, z02, z03, z04, z05, z06, z07, z08, z09;
4484 : float z10, z11, z12, z13, z14, z15, z16, z17, z18, z19;
4485 : float z20, z21, z22, z23, z24, z25, z26, z27, z28, z29;
4486 : float z30, z31, z32, z33, z34, z35, z36, z37, z38, z39;
4487 : float z40, z41, z42, z43, z44, z45, z46, z47, z48, z49;
4488 : float z50, z51, z52, z53, z54, z55, z56, z57, z58, z59;
4489 :
4490 : float *rel, *reh, *iml, *imh;
4491 :
4492 4556148764 : rel = &re[s * 0];
4493 4556148764 : reh = &re[s * 15];
4494 4556148764 : iml = &im[s * 0];
4495 4556148764 : imh = &im[s * 15];
4496 :
4497 4556148764 : x00 = re[s * 0];
4498 4556148764 : x01 = im[s * 0];
4499 4556148764 : x02 = re[s * 18];
4500 4556148764 : x03 = im[s * 18];
4501 4556148764 : x04 = re[s * 6];
4502 4556148764 : x05 = im[s * 6];
4503 4556148764 : x06 = re[s * 24];
4504 4556148764 : x07 = im[s * 24];
4505 4556148764 : x08 = re[s * 12];
4506 4556148764 : x09 = im[s * 12];
4507 :
4508 4556148764 : x10 = re[s * 20];
4509 4556148764 : x11 = im[s * 20];
4510 4556148764 : x12 = re[s * 8];
4511 4556148764 : x13 = im[s * 8];
4512 4556148764 : x14 = re[s * 26];
4513 4556148764 : x15 = im[s * 26];
4514 4556148764 : x16 = re[s * 14];
4515 4556148764 : x17 = im[s * 14];
4516 4556148764 : x18 = re[s * 2];
4517 4556148764 : x19 = im[s * 2];
4518 :
4519 4556148764 : x20 = re[s * 10];
4520 4556148764 : x21 = im[s * 10];
4521 4556148764 : x22 = re[s * 28];
4522 4556148764 : x23 = im[s * 28];
4523 4556148764 : x24 = re[s * 16];
4524 4556148764 : x25 = im[s * 16];
4525 4556148764 : x26 = re[s * 4];
4526 4556148764 : x27 = im[s * 4];
4527 4556148764 : x28 = re[s * 22];
4528 4556148764 : x29 = im[s * 22];
4529 :
4530 4556148764 : r1 = ( x02 + x08 );
4531 4556148764 : r4 = ( x02 - x08 );
4532 4556148764 : r3 = ( x04 + x06 );
4533 4556148764 : r2 = ( x04 - x06 );
4534 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4535 4556148764 : r1 = ( r1 + r3 );
4536 4556148764 : y00 = ( x00 + r1 );
4537 4556148764 : r1 = ( y00 + ( ( r1 * FFT_C55 ) ) );
4538 4556148764 : r3 = ( r1 - t );
4539 4556148764 : r1 = ( r1 + t );
4540 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4541 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4542 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4543 :
4544 4556148764 : s1 = ( x03 + x09 );
4545 4556148764 : s4 = ( x03 - x09 );
4546 4556148764 : s3 = ( x05 + x07 );
4547 4556148764 : s2 = ( x05 - x07 );
4548 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4549 4556148764 : s1 = ( s1 + s3 );
4550 4556148764 : y01 = ( x01 + s1 );
4551 4556148764 : s1 = ( y01 + ( s1 * FFT_C55 ) );
4552 4556148764 : s3 = ( s1 - t );
4553 4556148764 : s1 = ( s1 + t );
4554 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4555 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4556 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4557 :
4558 4556148764 : y02 = ( r1 + s2 );
4559 4556148764 : y08 = ( r1 - s2 );
4560 4556148764 : y04 = ( r3 - s4 );
4561 4556148764 : y06 = ( r3 + s4 );
4562 :
4563 4556148764 : y03 = ( s1 - r2 );
4564 4556148764 : y09 = ( s1 + r2 );
4565 4556148764 : y05 = ( s3 + r4 );
4566 4556148764 : y07 = ( s3 - r4 );
4567 :
4568 4556148764 : r1 = ( x12 + x18 );
4569 4556148764 : r4 = ( x12 - x18 );
4570 4556148764 : r3 = ( x14 + x16 );
4571 4556148764 : r2 = ( x14 - x16 );
4572 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4573 4556148764 : r1 = ( r1 + r3 );
4574 4556148764 : y10 = ( x10 + r1 );
4575 4556148764 : r1 = ( y10 + ( ( r1 * FFT_C55 ) ) );
4576 4556148764 : r3 = ( r1 - t );
4577 4556148764 : r1 = ( r1 + t );
4578 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4579 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4580 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4581 :
4582 4556148764 : s1 = ( x13 + x19 );
4583 4556148764 : s4 = ( x13 - x19 );
4584 4556148764 : s3 = ( x15 + x17 );
4585 4556148764 : s2 = ( x15 - x17 );
4586 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4587 4556148764 : s1 = ( s1 + s3 );
4588 4556148764 : y11 = ( x11 + s1 );
4589 4556148764 : s1 = ( y11 + ( s1 * FFT_C55 ) );
4590 4556148764 : s3 = ( s1 - t );
4591 4556148764 : s1 = ( s1 + t );
4592 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4593 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4594 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4595 :
4596 4556148764 : y12 = ( r1 + s2 );
4597 4556148764 : y18 = ( r1 - s2 );
4598 4556148764 : y14 = ( r3 - s4 );
4599 4556148764 : y16 = ( r3 + s4 );
4600 :
4601 4556148764 : y13 = ( s1 - r2 );
4602 4556148764 : y19 = ( s1 + r2 );
4603 4556148764 : y15 = ( s3 + r4 );
4604 4556148764 : y17 = ( s3 - r4 );
4605 :
4606 4556148764 : r1 = ( x22 + x28 );
4607 4556148764 : r4 = ( x22 - x28 );
4608 4556148764 : r3 = ( x24 + x26 );
4609 4556148764 : r2 = ( x24 - x26 );
4610 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4611 4556148764 : r1 = ( r1 + r3 );
4612 4556148764 : y20 = ( x20 + r1 );
4613 4556148764 : r1 = ( y20 + ( ( r1 * FFT_C55 ) ) );
4614 4556148764 : r3 = ( r1 - t );
4615 4556148764 : r1 = ( r1 + t );
4616 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4617 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4618 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4619 :
4620 4556148764 : s1 = ( x23 + x29 );
4621 4556148764 : s4 = ( x23 - x29 );
4622 4556148764 : s3 = ( x25 + x27 );
4623 4556148764 : s2 = ( x25 - x27 );
4624 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4625 4556148764 : s1 = ( s1 + s3 );
4626 4556148764 : y21 = ( x21 + s1 );
4627 4556148764 : s1 = ( y21 + ( s1 * FFT_C55 ) );
4628 4556148764 : s3 = ( s1 - t );
4629 4556148764 : s1 = ( s1 + t );
4630 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4631 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4632 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4633 :
4634 4556148764 : y22 = ( r1 + s2 );
4635 4556148764 : y28 = ( r1 - s2 );
4636 4556148764 : y24 = ( r3 - s4 );
4637 4556148764 : y26 = ( r3 + s4 );
4638 :
4639 4556148764 : y23 = ( s1 - r2 );
4640 4556148764 : y29 = ( s1 + r2 );
4641 4556148764 : y25 = ( s3 + r4 );
4642 4556148764 : y27 = ( s3 - r4 );
4643 :
4644 4556148764 : r1 = ( y10 + y20 );
4645 4556148764 : r2 = ( ( y10 - y20 ) * FFT_C31 );
4646 4556148764 : z00 = ( y00 + r1 );
4647 4556148764 : r1 = ( y00 - r1 * 0.5f );
4648 :
4649 4556148764 : s1 = ( y11 + y21 );
4650 4556148764 : s2 = ( ( y11 - y21 ) * FFT_C31 );
4651 4556148764 : z01 = ( y01 + s1 );
4652 4556148764 : s1 = ( y01 - s1 * 0.5f );
4653 :
4654 4556148764 : z20 = ( r1 - s2 );
4655 4556148764 : z10 = ( r1 + s2 );
4656 4556148764 : z21 = ( s1 + r2 );
4657 4556148764 : z11 = ( s1 - r2 );
4658 :
4659 4556148764 : r1 = ( y12 + y22 );
4660 4556148764 : r2 = ( ( y12 - y22 ) * FFT_C31 );
4661 4556148764 : z12 = ( y02 + r1 );
4662 4556148764 : r1 = ( y02 - r1 * 0.5f );
4663 :
4664 4556148764 : s1 = ( y13 + y23 );
4665 4556148764 : s2 = ( ( y13 - y23 ) * FFT_C31 );
4666 4556148764 : z13 = ( y03 + s1 );
4667 4556148764 : s1 = ( y03 - s1 * 0.5f );
4668 :
4669 4556148764 : z02 = ( r1 - s2 );
4670 4556148764 : z22 = ( r1 + s2 );
4671 4556148764 : z03 = ( s1 + r2 );
4672 4556148764 : z23 = ( s1 - r2 );
4673 :
4674 4556148764 : r1 = ( y14 + y24 );
4675 4556148764 : r2 = ( ( y14 - y24 ) * FFT_C31 );
4676 4556148764 : z24 = ( y04 + r1 );
4677 4556148764 : r1 = ( y04 - r1 * 0.5f );
4678 :
4679 4556148764 : s1 = ( y15 + y25 );
4680 4556148764 : s2 = ( ( y15 - y25 ) * FFT_C31 );
4681 4556148764 : z25 = ( y05 + s1 );
4682 4556148764 : s1 = ( y05 - s1 * 0.5f );
4683 :
4684 4556148764 : z14 = ( r1 - s2 );
4685 4556148764 : z04 = ( r1 + s2 );
4686 4556148764 : z15 = ( s1 + r2 );
4687 4556148764 : z05 = ( s1 - r2 );
4688 :
4689 4556148764 : r1 = ( y16 + y26 );
4690 4556148764 : r2 = ( ( y16 - y26 ) * FFT_C31 );
4691 4556148764 : z06 = ( y06 + r1 );
4692 4556148764 : r1 = ( y06 - r1 * 0.5f );
4693 :
4694 4556148764 : s1 = ( y17 + y27 );
4695 4556148764 : s2 = ( ( y17 - y27 ) * FFT_C31 );
4696 4556148764 : z07 = ( y07 + s1 );
4697 4556148764 : s1 = ( y07 - s1 * 0.5f );
4698 :
4699 4556148764 : z26 = ( r1 - s2 );
4700 4556148764 : z16 = ( r1 + s2 );
4701 4556148764 : z27 = ( s1 + r2 );
4702 4556148764 : z17 = ( s1 - r2 );
4703 :
4704 4556148764 : r1 = ( y18 + y28 );
4705 4556148764 : r2 = ( ( y18 - y28 ) * FFT_C31 );
4706 4556148764 : z18 = ( y08 + r1 );
4707 4556148764 : r1 = ( y08 - r1 * 0.5f );
4708 :
4709 4556148764 : s1 = ( y19 + y29 );
4710 4556148764 : s2 = ( ( y19 - y29 ) * FFT_C31 );
4711 4556148764 : z19 = ( y09 + s1 );
4712 4556148764 : s1 = ( y09 - s1 * 0.5f );
4713 :
4714 4556148764 : z08 = ( r1 - s2 );
4715 4556148764 : z28 = ( r1 + s2 );
4716 4556148764 : z09 = ( s1 + r2 );
4717 4556148764 : z29 = ( s1 - r2 );
4718 :
4719 4556148764 : x00 = re[s * 15];
4720 4556148764 : x01 = im[s * 15];
4721 4556148764 : x02 = re[s * 3];
4722 4556148764 : x03 = im[s * 3];
4723 4556148764 : x04 = re[s * 21];
4724 4556148764 : x05 = im[s * 21];
4725 4556148764 : x06 = re[s * 9];
4726 4556148764 : x07 = im[s * 9];
4727 4556148764 : x08 = re[s * 27];
4728 4556148764 : x09 = im[s * 27];
4729 :
4730 4556148764 : x10 = re[s * 5];
4731 4556148764 : x11 = im[s * 5];
4732 4556148764 : x12 = re[s * 23];
4733 4556148764 : x13 = im[s * 23];
4734 4556148764 : x14 = re[s * 11];
4735 4556148764 : x15 = im[s * 11];
4736 4556148764 : x16 = re[s * 29];
4737 4556148764 : x17 = im[s * 29];
4738 4556148764 : x18 = re[s * 17];
4739 4556148764 : x19 = im[s * 17];
4740 :
4741 4556148764 : x20 = re[s * 25];
4742 4556148764 : x21 = im[s * 25];
4743 4556148764 : x22 = re[s * 13];
4744 4556148764 : x23 = im[s * 13];
4745 4556148764 : x24 = re[s * 1];
4746 4556148764 : x25 = im[s * 1];
4747 4556148764 : x26 = re[s * 19];
4748 4556148764 : x27 = im[s * 19];
4749 4556148764 : x28 = re[s * 7];
4750 4556148764 : x29 = im[s * 7];
4751 :
4752 4556148764 : r1 = ( x02 + x08 );
4753 4556148764 : r4 = ( x02 - x08 );
4754 4556148764 : r3 = ( x04 + x06 );
4755 4556148764 : r2 = ( x04 - x06 );
4756 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4757 4556148764 : r1 = ( r1 + r3 );
4758 4556148764 : y00 = ( x00 + r1 );
4759 4556148764 : r1 = ( y00 + ( ( r1 * FFT_C55 ) ) );
4760 4556148764 : r3 = ( r1 - t );
4761 4556148764 : r1 = ( r1 + t );
4762 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4763 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4764 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4765 :
4766 4556148764 : s1 = ( x03 + x09 );
4767 4556148764 : s4 = ( x03 - x09 );
4768 4556148764 : s3 = ( x05 + x07 );
4769 4556148764 : s2 = ( x05 - x07 );
4770 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4771 4556148764 : s1 = ( s1 + s3 );
4772 4556148764 : y01 = ( x01 + s1 );
4773 4556148764 : s1 = ( y01 + ( s1 * FFT_C55 ) );
4774 4556148764 : s3 = ( s1 - t );
4775 4556148764 : s1 = ( s1 + t );
4776 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4777 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4778 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4779 :
4780 4556148764 : y02 = ( r1 + s2 );
4781 4556148764 : y08 = ( r1 - s2 );
4782 4556148764 : y04 = ( r3 - s4 );
4783 4556148764 : y06 = ( r3 + s4 );
4784 :
4785 4556148764 : y03 = ( s1 - r2 );
4786 4556148764 : y09 = ( s1 + r2 );
4787 4556148764 : y05 = ( s3 + r4 );
4788 4556148764 : y07 = ( s3 - r4 );
4789 :
4790 4556148764 : r1 = ( x12 + x18 );
4791 4556148764 : r4 = ( x12 - x18 );
4792 4556148764 : r3 = ( x14 + x16 );
4793 4556148764 : r2 = ( x14 - x16 );
4794 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4795 4556148764 : r1 = ( r1 + r3 );
4796 4556148764 : y10 = ( x10 + r1 );
4797 4556148764 : r1 = ( y10 + ( ( r1 * FFT_C55 ) ) );
4798 4556148764 : r3 = ( r1 - t );
4799 4556148764 : r1 = ( r1 + t );
4800 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4801 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4802 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4803 :
4804 4556148764 : s1 = ( x13 + x19 );
4805 4556148764 : s4 = ( x13 - x19 );
4806 4556148764 : s3 = ( x15 + x17 );
4807 4556148764 : s2 = ( x15 - x17 );
4808 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4809 4556148764 : s1 = ( s1 + s3 );
4810 4556148764 : y11 = ( x11 + s1 );
4811 4556148764 : s1 = ( y11 + ( s1 * FFT_C55 ) );
4812 4556148764 : s3 = ( s1 - t );
4813 4556148764 : s1 = ( s1 + t );
4814 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4815 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4816 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4817 :
4818 4556148764 : y12 = ( r1 + s2 );
4819 4556148764 : y18 = ( r1 - s2 );
4820 4556148764 : y14 = ( r3 - s4 );
4821 4556148764 : y16 = ( r3 + s4 );
4822 :
4823 4556148764 : y13 = ( s1 - r2 );
4824 4556148764 : y19 = ( s1 + r2 );
4825 4556148764 : y15 = ( s3 + r4 );
4826 4556148764 : y17 = ( s3 - r4 );
4827 :
4828 4556148764 : r1 = ( x22 + x28 );
4829 4556148764 : r4 = ( x22 - x28 );
4830 4556148764 : r3 = ( x24 + x26 );
4831 4556148764 : r2 = ( x24 - x26 );
4832 4556148764 : t = ( ( r1 - r3 ) * FFT_C54 );
4833 4556148764 : r1 = ( r1 + r3 );
4834 4556148764 : y20 = ( x20 + r1 );
4835 4556148764 : r1 = ( y20 + ( ( r1 * FFT_C55 ) ) );
4836 4556148764 : r3 = ( r1 - t );
4837 4556148764 : r1 = ( r1 + t );
4838 4556148764 : t = ( ( ( r4 + r2 ) ) * FFT_C51 );
4839 4556148764 : r4 = ( t + ( r4 * FFT_C52 ) );
4840 4556148764 : r2 = ( t + ( r2 * FFT_C53 ) );
4841 :
4842 4556148764 : s1 = ( x23 + x29 );
4843 4556148764 : s4 = ( x23 - x29 );
4844 4556148764 : s3 = ( x25 + x27 );
4845 4556148764 : s2 = ( x25 - x27 );
4846 4556148764 : t = ( ( s1 - s3 ) * FFT_C54 );
4847 4556148764 : s1 = ( s1 + s3 );
4848 4556148764 : y21 = ( x21 + s1 );
4849 4556148764 : s1 = ( y21 + ( s1 * FFT_C55 ) );
4850 4556148764 : s3 = ( s1 - t );
4851 4556148764 : s1 = ( s1 + t );
4852 4556148764 : t = ( ( s4 + s2 ) * FFT_C51 );
4853 4556148764 : s4 = ( t + ( s4 * FFT_C52 ) );
4854 4556148764 : s2 = ( t + ( s2 * FFT_C53 ) );
4855 :
4856 4556148764 : y22 = ( r1 + s2 );
4857 4556148764 : y28 = ( r1 - s2 );
4858 4556148764 : y24 = ( r3 - s4 );
4859 4556148764 : y26 = ( r3 + s4 );
4860 :
4861 4556148764 : y23 = ( s1 - r2 );
4862 4556148764 : y29 = ( s1 + r2 );
4863 4556148764 : y25 = ( s3 + r4 );
4864 4556148764 : y27 = ( s3 - r4 );
4865 :
4866 4556148764 : r1 = ( y10 + y20 );
4867 4556148764 : r2 = ( ( y10 - y20 ) * FFT_C31 );
4868 4556148764 : z30 = ( y00 + r1 );
4869 4556148764 : r1 = ( y00 - r1 * 0.5f );
4870 :
4871 4556148764 : s1 = ( y11 + y21 );
4872 4556148764 : s2 = ( ( y11 - y21 ) * FFT_C31 );
4873 4556148764 : z31 = ( y01 + s1 );
4874 4556148764 : s1 = ( y01 - s1 * 0.5f );
4875 :
4876 4556148764 : z50 = ( r1 - s2 );
4877 4556148764 : z40 = ( r1 + s2 );
4878 4556148764 : z51 = ( s1 + r2 );
4879 4556148764 : z41 = ( s1 - r2 );
4880 :
4881 4556148764 : r1 = ( y12 + y22 );
4882 4556148764 : r2 = ( ( y12 - y22 ) * FFT_C31 );
4883 4556148764 : z42 = ( y02 + r1 );
4884 4556148764 : r1 = ( y02 - r1 * 0.5f );
4885 :
4886 4556148764 : s1 = ( y13 + y23 );
4887 4556148764 : s2 = ( ( y13 - y23 ) * FFT_C31 );
4888 4556148764 : z43 = ( y03 + s1 );
4889 4556148764 : s1 = ( y03 - s1 * 0.5f );
4890 :
4891 4556148764 : z32 = ( r1 - s2 );
4892 4556148764 : z52 = ( r1 + s2 );
4893 4556148764 : z33 = ( s1 + r2 );
4894 4556148764 : z53 = ( s1 - r2 );
4895 :
4896 4556148764 : r1 = ( y14 + y24 );
4897 4556148764 : r2 = ( ( y14 - y24 ) * FFT_C31 );
4898 4556148764 : z54 = ( y04 + r1 );
4899 4556148764 : r1 = ( y04 - r1 * 0.5f );
4900 :
4901 4556148764 : s1 = ( y15 + y25 );
4902 4556148764 : s2 = ( ( y15 - y25 ) * FFT_C31 );
4903 4556148764 : z55 = ( y05 + s1 );
4904 4556148764 : s1 = ( y05 - s1 * 0.5f );
4905 :
4906 4556148764 : z44 = ( r1 - s2 );
4907 4556148764 : z34 = ( r1 + s2 );
4908 4556148764 : z45 = ( s1 + r2 );
4909 4556148764 : z35 = ( s1 - r2 );
4910 :
4911 4556148764 : r1 = ( y16 + y26 );
4912 4556148764 : r2 = ( ( y16 - y26 ) * FFT_C31 );
4913 4556148764 : z36 = ( y06 + r1 );
4914 4556148764 : r1 = ( y06 - r1 * 0.5f );
4915 :
4916 4556148764 : s1 = ( y17 + y27 );
4917 4556148764 : s2 = ( ( y17 - y27 ) * FFT_C31 );
4918 4556148764 : z37 = ( y07 + s1 );
4919 4556148764 : s1 = ( y07 - s1 * 0.5f );
4920 :
4921 4556148764 : z56 = ( r1 - s2 );
4922 4556148764 : z46 = ( r1 + s2 );
4923 4556148764 : z57 = ( s1 + r2 );
4924 4556148764 : z47 = ( s1 - r2 );
4925 :
4926 4556148764 : r1 = ( y18 + y28 );
4927 4556148764 : r2 = ( ( y18 - y28 ) * FFT_C31 );
4928 4556148764 : z48 = ( y08 + r1 );
4929 4556148764 : r1 = ( y08 - r1 * 0.5f );
4930 :
4931 4556148764 : s1 = ( y19 + y29 );
4932 4556148764 : s2 = ( ( y19 - y29 ) * FFT_C31 );
4933 4556148764 : z49 = ( y09 + s1 );
4934 4556148764 : s1 = ( y09 - s1 * 0.5f );
4935 :
4936 4556148764 : z38 = ( r1 - s2 );
4937 4556148764 : z58 = ( r1 + s2 );
4938 4556148764 : z39 = ( s1 + r2 );
4939 4556148764 : z59 = ( s1 - r2 );
4940 :
4941 4556148764 : r1 = z00;
4942 4556148764 : r2 = z30;
4943 4556148764 : r3 = z01;
4944 4556148764 : r4 = z31;
4945 4556148764 : *rel = ( r1 + r2 );
4946 4556148764 : *reh = ( r1 - r2 );
4947 4556148764 : *iml = ( r3 + r4 );
4948 4556148764 : *imh = ( r3 - r4 );
4949 4556148764 : rel += s, reh += s, iml += s;
4950 4556148764 : imh += s;
4951 :
4952 4556148764 : r1 = z16;
4953 4556148764 : r2 = z46;
4954 4556148764 : r3 = z17;
4955 4556148764 : r4 = z47;
4956 4556148764 : *reh = ( r1 + r2 );
4957 4556148764 : *rel = ( r1 - r2 );
4958 4556148764 : *imh = ( r3 + r4 );
4959 4556148764 : *iml = ( r3 - r4 );
4960 4556148764 : rel += s, reh += s, iml += s;
4961 4556148764 : imh += s;
4962 :
4963 4556148764 : r1 = z02;
4964 4556148764 : r2 = z32;
4965 4556148764 : r3 = z03;
4966 4556148764 : r4 = z33;
4967 4556148764 : *rel = ( r1 + r2 );
4968 4556148764 : *reh = ( r1 - r2 );
4969 4556148764 : *iml = ( r3 + r4 );
4970 4556148764 : *imh = ( r3 - r4 );
4971 4556148764 : rel += s, reh += s, iml += s;
4972 4556148764 : imh += s;
4973 :
4974 4556148764 : r1 = z18;
4975 4556148764 : r2 = z48;
4976 4556148764 : r3 = z19;
4977 4556148764 : r4 = z49;
4978 4556148764 : *reh = ( r1 + r2 );
4979 4556148764 : *rel = ( r1 - r2 );
4980 4556148764 : *imh = ( r3 + r4 );
4981 4556148764 : *iml = ( r3 - r4 );
4982 4556148764 : rel += s, reh += s, iml += s;
4983 4556148764 : imh += s;
4984 :
4985 4556148764 : r1 = z04;
4986 4556148764 : r2 = z34;
4987 4556148764 : r3 = z05;
4988 4556148764 : r4 = z35;
4989 4556148764 : *rel = ( r1 + r2 );
4990 4556148764 : *reh = ( r1 - r2 );
4991 4556148764 : *iml = ( r3 + r4 );
4992 4556148764 : *imh = ( r3 - r4 );
4993 4556148764 : rel += s, reh += s, iml += s;
4994 4556148764 : imh += s;
4995 :
4996 4556148764 : r1 = z20;
4997 4556148764 : r2 = z50;
4998 4556148764 : r3 = z21;
4999 4556148764 : r4 = z51;
5000 4556148764 : *reh = ( r1 + r2 );
5001 4556148764 : *rel = ( r1 - r2 );
5002 4556148764 : *imh = ( r3 + r4 );
5003 4556148764 : *iml = ( r3 - r4 );
5004 4556148764 : rel += s, reh += s, iml += s;
5005 4556148764 : imh += s;
5006 :
5007 4556148764 : r1 = z06;
5008 4556148764 : r2 = z36;
5009 4556148764 : r3 = z07;
5010 4556148764 : r4 = z37;
5011 4556148764 : *rel = ( r1 + r2 );
5012 4556148764 : *reh = ( r1 - r2 );
5013 4556148764 : *iml = ( r3 + r4 );
5014 4556148764 : *imh = ( r3 - r4 );
5015 4556148764 : rel += s, reh += s, iml += s;
5016 4556148764 : imh += s;
5017 :
5018 4556148764 : r1 = z22;
5019 4556148764 : r2 = z52;
5020 4556148764 : r3 = z23;
5021 4556148764 : r4 = z53;
5022 4556148764 : *reh = ( r1 + r2 );
5023 4556148764 : *rel = ( r1 - r2 );
5024 4556148764 : *imh = ( r3 + r4 );
5025 4556148764 : *iml = ( r3 - r4 );
5026 4556148764 : rel += s, reh += s, iml += s;
5027 4556148764 : imh += s;
5028 :
5029 4556148764 : r1 = z08;
5030 4556148764 : r2 = z38;
5031 4556148764 : r3 = z09;
5032 4556148764 : r4 = z39;
5033 4556148764 : *rel = ( r1 + r2 );
5034 4556148764 : *reh = ( r1 - r2 );
5035 4556148764 : *iml = ( r3 + r4 );
5036 4556148764 : *imh = ( r3 - r4 );
5037 4556148764 : rel += s, reh += s, iml += s;
5038 4556148764 : imh += s;
5039 :
5040 4556148764 : r1 = z24;
5041 4556148764 : r2 = z54;
5042 4556148764 : r3 = z25;
5043 4556148764 : r4 = z55;
5044 4556148764 : *reh = ( r1 + r2 );
5045 4556148764 : *rel = ( r1 - r2 );
5046 4556148764 : *imh = ( r3 + r4 );
5047 4556148764 : *iml = ( r3 - r4 );
5048 4556148764 : rel += s, reh += s, iml += s;
5049 4556148764 : imh += s;
5050 :
5051 4556148764 : r1 = z10;
5052 4556148764 : r2 = z40;
5053 4556148764 : r3 = z11;
5054 4556148764 : r4 = z41;
5055 4556148764 : *rel = ( r1 + r2 );
5056 4556148764 : *reh = ( r1 - r2 );
5057 4556148764 : *iml = ( r3 + r4 );
5058 4556148764 : *imh = ( r3 - r4 );
5059 4556148764 : rel += s, reh += s, iml += s;
5060 4556148764 : imh += s;
5061 :
5062 4556148764 : r1 = z26;
5063 4556148764 : r2 = z56;
5064 4556148764 : r3 = z27;
5065 4556148764 : r4 = z57;
5066 4556148764 : *reh = ( r1 + r2 );
5067 4556148764 : *rel = ( r1 - r2 );
5068 4556148764 : *imh = ( r3 + r4 );
5069 4556148764 : *iml = ( r3 - r4 );
5070 4556148764 : rel += s, reh += s, iml += s;
5071 4556148764 : imh += s;
5072 :
5073 4556148764 : r1 = z12;
5074 4556148764 : r2 = z42;
5075 4556148764 : r3 = z13;
5076 4556148764 : r4 = z43;
5077 4556148764 : *rel = ( r1 + r2 );
5078 4556148764 : *reh = ( r1 - r2 );
5079 4556148764 : *iml = ( r3 + r4 );
5080 4556148764 : *imh = ( r3 - r4 );
5081 4556148764 : rel += s, reh += s, iml += s;
5082 4556148764 : imh += s;
5083 :
5084 4556148764 : r1 = z28;
5085 4556148764 : r2 = z58;
5086 4556148764 : r3 = z29;
5087 4556148764 : r4 = z59;
5088 4556148764 : *reh = ( r1 + r2 );
5089 4556148764 : *rel = ( r1 - r2 );
5090 4556148764 : *imh = ( r3 + r4 );
5091 4556148764 : *iml = ( r3 - r4 );
5092 4556148764 : rel += s, reh += s, iml += s;
5093 4556148764 : imh += s;
5094 :
5095 4556148764 : r1 = z14;
5096 4556148764 : r2 = z44;
5097 4556148764 : r3 = z15;
5098 4556148764 : r4 = z45;
5099 4556148764 : *rel = ( r1 + r2 );
5100 4556148764 : *reh = ( r1 - r2 );
5101 4556148764 : *iml = ( r3 + r4 );
5102 4556148764 : *imh = ( r3 - r4 );
5103 4556148764 : rel += s, reh += s, iml += s;
5104 4556148764 : imh += s;
5105 :
5106 4556148764 : return;
5107 : }
5108 :
5109 553806948 : static void fft_len32(
5110 : float *re,
5111 : float *im,
5112 : const int16_t s )
5113 : {
5114 : float as, bs;
5115 : float x00, x01, x02, x03, x04, x05, x06, x07;
5116 : float x08, x09, x10, x11, x12, x13, x14, x15;
5117 : float t00, t01, t02, t03, t04, t05, t06, t07;
5118 : float t08, t09, t10, t11, t12, t13, t14, t15;
5119 : float s00, s01, s02, s03, s04, s05, s06, s07;
5120 : float s08, s09, s10, s11, s12, s13, s14, s15;
5121 :
5122 : float y00, y01, y02, y03, y04, y05, y06, y07;
5123 : float y08, y09, y10, y11, y12, y13, y14, y15;
5124 : float y16, y17, y18, y19, y20, y21, y22, y23;
5125 : float y24, y25, y26, y27, y28, y29, y30, y31;
5126 : float y32, y33, y34, y35, y36, y37, y38, y39;
5127 : float y40, y41, y42, y43, y44, y45, y46, y47;
5128 : float y48, y49, y50, y51, y52, y53, y54, y55;
5129 : float y56, y57, y58, y59, y60, y61, y62, y63;
5130 :
5131 553806948 : x00 = re[s * 0];
5132 553806948 : x01 = im[s * 0];
5133 553806948 : x02 = re[s * 4];
5134 553806948 : x03 = im[s * 4];
5135 553806948 : x04 = re[s * 8];
5136 553806948 : x05 = im[s * 8];
5137 553806948 : x06 = re[s * 12];
5138 553806948 : x07 = im[s * 12];
5139 553806948 : x08 = re[s * 16];
5140 553806948 : x09 = im[s * 16];
5141 553806948 : x10 = re[s * 20];
5142 553806948 : x11 = im[s * 20];
5143 553806948 : x12 = re[s * 24];
5144 553806948 : x13 = im[s * 24];
5145 553806948 : x14 = re[s * 28];
5146 553806948 : x15 = im[s * 28];
5147 :
5148 553806948 : t00 = ( x00 + x08 );
5149 553806948 : t02 = ( x00 - x08 );
5150 553806948 : t01 = ( x01 + x09 );
5151 553806948 : t03 = ( x01 - x09 );
5152 553806948 : t04 = ( x02 + x10 );
5153 553806948 : t06 = ( x02 - x10 );
5154 553806948 : t05 = ( x03 + x11 );
5155 553806948 : t07 = ( x03 - x11 );
5156 553806948 : t08 = ( x04 + x12 );
5157 553806948 : t10 = ( x04 - x12 );
5158 553806948 : t09 = ( x05 + x13 );
5159 553806948 : t11 = ( x05 - x13 );
5160 553806948 : t12 = ( x06 + x14 );
5161 553806948 : t14 = ( x06 - x14 );
5162 553806948 : t13 = ( x07 + x15 );
5163 553806948 : t15 = ( x07 - x15 );
5164 :
5165 553806948 : s00 = ( t00 + t08 );
5166 553806948 : s04 = ( t00 - t08 );
5167 553806948 : s01 = ( t01 + t09 );
5168 553806948 : s05 = ( t01 - t09 );
5169 553806948 : s08 = ( t02 - t11 );
5170 553806948 : s10 = ( t02 + t11 );
5171 553806948 : s09 = ( t03 + t10 );
5172 553806948 : s11 = ( t03 - t10 );
5173 553806948 : s02 = ( t04 + t12 );
5174 553806948 : s07 = ( t04 - t12 );
5175 553806948 : s03 = ( t05 + t13 );
5176 553806948 : s06 = ( t13 - t05 );
5177 553806948 : t01 = ( t06 + t14 );
5178 553806948 : t02 = ( t06 - t14 );
5179 553806948 : t00 = ( t07 + t15 );
5180 553806948 : t03 = ( t07 - t15 );
5181 :
5182 : {
5183 553806948 : s12 = ( ( t00 + t02 ) * FFT_C81 );
5184 553806948 : s14 = ( ( t00 - t02 ) * FFT_C81 );
5185 553806948 : s13 = ( ( t03 - t01 ) * FFT_C81 );
5186 553806948 : s15 = ( ( t01 + t03 ) * FFT_C82 );
5187 : };
5188 :
5189 553806948 : y00 = ( s00 + s02 );
5190 553806948 : y08 = ( s00 - s02 );
5191 553806948 : y01 = ( s01 + s03 );
5192 553806948 : y09 = ( s01 - s03 );
5193 553806948 : y04 = ( s04 - s06 );
5194 553806948 : y12 = ( s04 + s06 );
5195 553806948 : y05 = ( s05 - s07 );
5196 553806948 : y13 = ( s05 + s07 );
5197 553806948 : y06 = ( s08 + s14 );
5198 553806948 : y14 = ( s08 - s14 );
5199 553806948 : y07 = ( s09 + s15 );
5200 553806948 : y15 = ( s09 - s15 );
5201 553806948 : y02 = ( s10 + s12 );
5202 553806948 : y10 = ( s10 - s12 );
5203 553806948 : y03 = ( s11 + s13 );
5204 553806948 : y11 = ( s11 - s13 );
5205 :
5206 553806948 : x00 = re[s * 1];
5207 553806948 : x01 = im[s * 1];
5208 553806948 : x02 = re[s * 5];
5209 553806948 : x03 = im[s * 5];
5210 553806948 : x04 = re[s * 9];
5211 553806948 : x05 = im[s * 9];
5212 553806948 : x06 = re[s * 13];
5213 553806948 : x07 = im[s * 13];
5214 553806948 : x08 = re[s * 17];
5215 553806948 : x09 = im[s * 17];
5216 553806948 : x10 = re[s * 21];
5217 553806948 : x11 = im[s * 21];
5218 553806948 : x12 = re[s * 25];
5219 553806948 : x13 = im[s * 25];
5220 553806948 : x14 = re[s * 29];
5221 553806948 : x15 = im[s * 29];
5222 :
5223 553806948 : t00 = ( x00 + x08 );
5224 553806948 : t02 = ( x00 - x08 );
5225 553806948 : t01 = ( x01 + x09 );
5226 553806948 : t03 = ( x01 - x09 );
5227 553806948 : t04 = ( x02 + x10 );
5228 553806948 : t06 = ( x02 - x10 );
5229 553806948 : t05 = ( x03 + x11 );
5230 553806948 : t07 = ( x03 - x11 );
5231 553806948 : t08 = ( x04 + x12 );
5232 553806948 : t10 = ( x04 - x12 );
5233 553806948 : t09 = ( x05 + x13 );
5234 553806948 : t11 = ( x05 - x13 );
5235 553806948 : t12 = ( x06 + x14 );
5236 553806948 : t14 = ( x06 - x14 );
5237 553806948 : t13 = ( x07 + x15 );
5238 553806948 : t15 = ( x07 - x15 );
5239 :
5240 553806948 : s00 = ( t00 + t08 );
5241 553806948 : s04 = ( t00 - t08 );
5242 553806948 : s01 = ( t01 + t09 );
5243 553806948 : s05 = ( t01 - t09 );
5244 553806948 : s08 = ( t02 - t11 );
5245 553806948 : s10 = ( t02 + t11 );
5246 553806948 : s09 = ( t03 + t10 );
5247 553806948 : s11 = ( t03 - t10 );
5248 553806948 : s02 = ( t04 + t12 );
5249 553806948 : s07 = ( t04 - t12 );
5250 553806948 : s03 = ( t05 + t13 );
5251 553806948 : s06 = ( t13 - t05 );
5252 553806948 : t01 = ( t06 + t14 );
5253 553806948 : t02 = ( t06 - t14 );
5254 553806948 : t00 = ( t07 + t15 );
5255 553806948 : t03 = ( t07 - t15 );
5256 :
5257 : {
5258 553806948 : s12 = ( ( t00 + t02 ) * FFT_C81 );
5259 553806948 : s14 = ( ( t00 - t02 ) * FFT_C81 );
5260 553806948 : s13 = ( ( t03 - t01 ) * FFT_C81 );
5261 553806948 : s15 = ( ( t01 + t03 ) * FFT_C82 );
5262 : };
5263 :
5264 553806948 : y16 = ( s00 + s02 );
5265 553806948 : y24 = ( s00 - s02 );
5266 553806948 : y17 = ( s01 + s03 );
5267 553806948 : y25 = ( s01 - s03 );
5268 553806948 : y20 = ( s04 - s06 );
5269 553806948 : y28 = ( s04 + s06 );
5270 553806948 : y21 = ( s05 - s07 );
5271 553806948 : y29 = ( s05 + s07 );
5272 553806948 : y22 = ( s08 + s14 );
5273 553806948 : y30 = ( s08 - s14 );
5274 553806948 : y23 = ( s09 + s15 );
5275 553806948 : y31 = ( s09 - s15 );
5276 553806948 : y18 = ( s10 + s12 );
5277 553806948 : y26 = ( s10 - s12 );
5278 553806948 : y19 = ( s11 + s13 );
5279 553806948 : y27 = ( s11 - s13 );
5280 :
5281 553806948 : x00 = re[s * 2];
5282 553806948 : x01 = im[s * 2];
5283 553806948 : x02 = re[s * 6];
5284 553806948 : x03 = im[s * 6];
5285 553806948 : x04 = re[s * 10];
5286 553806948 : x05 = im[s * 10];
5287 553806948 : x06 = re[s * 14];
5288 553806948 : x07 = im[s * 14];
5289 553806948 : x08 = re[s * 18];
5290 553806948 : x09 = im[s * 18];
5291 553806948 : x10 = re[s * 22];
5292 553806948 : x11 = im[s * 22];
5293 553806948 : x12 = re[s * 26];
5294 553806948 : x13 = im[s * 26];
5295 553806948 : x14 = re[s * 30];
5296 553806948 : x15 = im[s * 30];
5297 :
5298 553806948 : t00 = ( x00 + x08 );
5299 553806948 : t02 = ( x00 - x08 );
5300 553806948 : t01 = ( x01 + x09 );
5301 553806948 : t03 = ( x01 - x09 );
5302 553806948 : t04 = ( x02 + x10 );
5303 553806948 : t06 = ( x02 - x10 );
5304 553806948 : t05 = ( x03 + x11 );
5305 553806948 : t07 = ( x03 - x11 );
5306 553806948 : t08 = ( x04 + x12 );
5307 553806948 : t10 = ( x04 - x12 );
5308 553806948 : t09 = ( x05 + x13 );
5309 553806948 : t11 = ( x05 - x13 );
5310 553806948 : t12 = ( x06 + x14 );
5311 553806948 : t14 = ( x06 - x14 );
5312 553806948 : t13 = ( x07 + x15 );
5313 553806948 : t15 = ( x07 - x15 );
5314 :
5315 553806948 : s00 = ( t00 + t08 );
5316 553806948 : s04 = ( t00 - t08 );
5317 553806948 : s01 = ( t01 + t09 );
5318 553806948 : s05 = ( t01 - t09 );
5319 553806948 : s08 = ( t02 - t11 );
5320 553806948 : s10 = ( t02 + t11 );
5321 553806948 : s09 = ( t03 + t10 );
5322 553806948 : s11 = ( t03 - t10 );
5323 553806948 : s02 = ( t04 + t12 );
5324 553806948 : s07 = ( t04 - t12 );
5325 553806948 : s03 = ( t05 + t13 );
5326 553806948 : s06 = ( t13 - t05 );
5327 553806948 : t01 = ( t06 + t14 );
5328 553806948 : t02 = ( t06 - t14 );
5329 553806948 : t00 = ( t07 + t15 );
5330 553806948 : t03 = ( t07 - t15 );
5331 :
5332 : {
5333 553806948 : s12 = ( ( t00 + t02 ) * FFT_C81 );
5334 553806948 : s14 = ( ( t00 - t02 ) * FFT_C81 );
5335 553806948 : s13 = ( ( t03 - t01 ) * FFT_C81 );
5336 553806948 : s15 = ( ( t01 + t03 ) * FFT_C82 );
5337 : };
5338 :
5339 553806948 : y32 = ( s00 + s02 );
5340 553806948 : y40 = ( s00 - s02 );
5341 553806948 : y33 = ( s01 + s03 );
5342 553806948 : y41 = ( s01 - s03 );
5343 553806948 : y36 = ( s04 - s06 );
5344 553806948 : y44 = ( s04 + s06 );
5345 553806948 : y37 = ( s05 - s07 );
5346 553806948 : y45 = ( s05 + s07 );
5347 553806948 : y38 = ( s08 + s14 );
5348 553806948 : y46 = ( s08 - s14 );
5349 553806948 : y39 = ( s09 + s15 );
5350 553806948 : y47 = ( s09 - s15 );
5351 553806948 : y34 = ( s10 + s12 );
5352 553806948 : y42 = ( s10 - s12 );
5353 553806948 : y35 = ( s11 + s13 );
5354 553806948 : y43 = ( s11 - s13 );
5355 :
5356 553806948 : x00 = re[s * 3];
5357 553806948 : x01 = im[s * 3];
5358 553806948 : x02 = re[s * 7];
5359 553806948 : x03 = im[s * 7];
5360 553806948 : x04 = re[s * 11];
5361 553806948 : x05 = im[s * 11];
5362 553806948 : x06 = re[s * 15];
5363 553806948 : x07 = im[s * 15];
5364 553806948 : x08 = re[s * 19];
5365 553806948 : x09 = im[s * 19];
5366 553806948 : x10 = re[s * 23];
5367 553806948 : x11 = im[s * 23];
5368 553806948 : x12 = re[s * 27];
5369 553806948 : x13 = im[s * 27];
5370 553806948 : x14 = re[s * 31];
5371 553806948 : x15 = im[s * 31];
5372 :
5373 553806948 : t00 = ( x00 + x08 );
5374 553806948 : t02 = ( x00 - x08 );
5375 553806948 : t01 = ( x01 + x09 );
5376 553806948 : t03 = ( x01 - x09 );
5377 553806948 : t04 = ( x02 + x10 );
5378 553806948 : t06 = ( x02 - x10 );
5379 553806948 : t05 = ( x03 + x11 );
5380 553806948 : t07 = ( x03 - x11 );
5381 553806948 : t08 = ( x04 + x12 );
5382 553806948 : t10 = ( x04 - x12 );
5383 553806948 : t09 = ( x05 + x13 );
5384 553806948 : t11 = ( x05 - x13 );
5385 553806948 : t12 = ( x06 + x14 );
5386 553806948 : t14 = ( x06 - x14 );
5387 553806948 : t13 = ( x07 + x15 );
5388 553806948 : t15 = ( x07 - x15 );
5389 :
5390 553806948 : s00 = ( t00 + t08 );
5391 553806948 : s04 = ( t00 - t08 );
5392 553806948 : s01 = ( t01 + t09 );
5393 553806948 : s05 = ( t01 - t09 );
5394 553806948 : s08 = ( t02 - t11 );
5395 553806948 : s10 = ( t02 + t11 );
5396 553806948 : s09 = ( t03 + t10 );
5397 553806948 : s11 = ( t03 - t10 );
5398 553806948 : s02 = ( t04 + t12 );
5399 553806948 : s07 = ( t04 - t12 );
5400 553806948 : s03 = ( t05 + t13 );
5401 553806948 : s06 = ( t13 - t05 );
5402 553806948 : t01 = ( t06 + t14 );
5403 553806948 : t02 = ( t06 - t14 );
5404 553806948 : t00 = ( t07 + t15 );
5405 553806948 : t03 = ( t07 - t15 );
5406 :
5407 : {
5408 553806948 : s12 = ( ( t00 + t02 ) * FFT_C81 );
5409 553806948 : s14 = ( ( t00 - t02 ) * FFT_C81 );
5410 553806948 : s13 = ( ( t03 - t01 ) * FFT_C81 );
5411 553806948 : s15 = ( ( t01 + t03 ) * FFT_C82 );
5412 : };
5413 :
5414 553806948 : y48 = ( s00 + s02 );
5415 553806948 : y56 = ( s00 - s02 );
5416 553806948 : y49 = ( s01 + s03 );
5417 553806948 : y57 = ( s01 - s03 );
5418 553806948 : y52 = ( s04 - s06 );
5419 553806948 : y60 = ( s04 + s06 );
5420 553806948 : y53 = ( s05 - s07 );
5421 553806948 : y61 = ( s05 + s07 );
5422 553806948 : y54 = ( s08 + s14 );
5423 553806948 : y62 = ( s08 - s14 );
5424 553806948 : y55 = ( s09 + s15 );
5425 553806948 : y63 = ( s09 - s15 );
5426 553806948 : y50 = ( s10 + s12 );
5427 553806948 : y58 = ( s10 - s12 );
5428 553806948 : y51 = ( s11 + s13 );
5429 553806948 : y59 = ( s11 - s13 );
5430 :
5431 :
5432 : {
5433 553806948 : as = y18;
5434 553806948 : bs = y19;
5435 553806948 : y18 = ( ( as * FFT_RotVector_32[2 * 0 + 0] ) - ( bs * FFT_RotVector_32[2 * 0 + 1] ) );
5436 553806948 : y19 = ( ( as * FFT_RotVector_32[2 * 0 + 1] ) + ( bs * FFT_RotVector_32[2 * 0 + 0] ) );
5437 : };
5438 : {
5439 553806948 : as = y20;
5440 553806948 : bs = y21;
5441 553806948 : y20 = ( ( as * FFT_RotVector_32[2 * 1 + 0] ) - ( bs * FFT_RotVector_32[2 * 1 + 1] ) );
5442 553806948 : y21 = ( ( as * FFT_RotVector_32[2 * 1 + 1] ) + ( bs * FFT_RotVector_32[2 * 1 + 0] ) );
5443 : };
5444 : {
5445 553806948 : as = y22;
5446 553806948 : bs = y23;
5447 553806948 : y22 = ( ( as * FFT_RotVector_32[2 * 2 + 0] ) - ( bs * FFT_RotVector_32[2 * 2 + 1] ) );
5448 553806948 : y23 = ( ( as * FFT_RotVector_32[2 * 2 + 1] ) + ( bs * FFT_RotVector_32[2 * 2 + 0] ) );
5449 : };
5450 : {
5451 553806948 : as = y24;
5452 553806948 : bs = y25;
5453 553806948 : y24 = ( ( as * FFT_RotVector_32[2 * 3 + 0] ) - ( bs * FFT_RotVector_32[2 * 3 + 1] ) );
5454 553806948 : y25 = ( ( as * FFT_RotVector_32[2 * 3 + 1] ) + ( bs * FFT_RotVector_32[2 * 3 + 0] ) );
5455 : };
5456 : {
5457 553806948 : as = y26;
5458 553806948 : bs = y27;
5459 553806948 : y26 = ( ( as * FFT_RotVector_32[2 * 4 + 0] ) - ( bs * FFT_RotVector_32[2 * 4 + 1] ) );
5460 553806948 : y27 = ( ( as * FFT_RotVector_32[2 * 4 + 1] ) + ( bs * FFT_RotVector_32[2 * 4 + 0] ) );
5461 : };
5462 : {
5463 553806948 : as = y28;
5464 553806948 : bs = y29;
5465 553806948 : y28 = ( ( as * FFT_RotVector_32[2 * 5 + 0] ) - ( bs * FFT_RotVector_32[2 * 5 + 1] ) );
5466 553806948 : y29 = ( ( as * FFT_RotVector_32[2 * 5 + 1] ) + ( bs * FFT_RotVector_32[2 * 5 + 0] ) );
5467 : };
5468 : {
5469 553806948 : as = y30;
5470 553806948 : bs = y31;
5471 553806948 : y30 = ( ( as * FFT_RotVector_32[2 * 6 + 0] ) - ( bs * FFT_RotVector_32[2 * 6 + 1] ) );
5472 553806948 : y31 = ( ( as * FFT_RotVector_32[2 * 6 + 1] ) + ( bs * FFT_RotVector_32[2 * 6 + 0] ) );
5473 : };
5474 : {
5475 553806948 : as = y34;
5476 553806948 : bs = y35;
5477 553806948 : y34 = ( ( as * FFT_RotVector_32[2 * 7 + 0] ) - ( bs * FFT_RotVector_32[2 * 7 + 1] ) );
5478 553806948 : y35 = ( ( as * FFT_RotVector_32[2 * 7 + 1] ) + ( bs * FFT_RotVector_32[2 * 7 + 0] ) );
5479 : };
5480 : {
5481 553806948 : as = y36;
5482 553806948 : bs = y37;
5483 553806948 : y36 = ( ( as * FFT_RotVector_32[2 * 8 + 0] ) - ( bs * FFT_RotVector_32[2 * 8 + 1] ) );
5484 553806948 : y37 = ( ( as * FFT_RotVector_32[2 * 8 + 1] ) + ( bs * FFT_RotVector_32[2 * 8 + 0] ) );
5485 : };
5486 : {
5487 553806948 : as = y38;
5488 553806948 : bs = y39;
5489 553806948 : y38 = ( ( as * FFT_RotVector_32[2 * 9 + 0] ) - ( bs * FFT_RotVector_32[2 * 9 + 1] ) );
5490 553806948 : y39 = ( ( as * FFT_RotVector_32[2 * 9 + 1] ) + ( bs * FFT_RotVector_32[2 * 9 + 0] ) );
5491 : };
5492 : {
5493 553806948 : as = y42;
5494 553806948 : bs = y43;
5495 553806948 : y42 = ( ( as * FFT_RotVector_32[2 * 10 + 0] ) - ( bs * FFT_RotVector_32[2 * 10 + 1] ) );
5496 553806948 : y43 = ( ( as * FFT_RotVector_32[2 * 10 + 1] ) + ( bs * FFT_RotVector_32[2 * 10 + 0] ) );
5497 : };
5498 : {
5499 553806948 : as = y44;
5500 553806948 : bs = y45;
5501 553806948 : y44 = ( ( as * FFT_RotVector_32[2 * 11 + 0] ) - ( bs * FFT_RotVector_32[2 * 11 + 1] ) );
5502 553806948 : y45 = ( ( as * FFT_RotVector_32[2 * 11 + 1] ) + ( bs * FFT_RotVector_32[2 * 11 + 0] ) );
5503 : };
5504 : {
5505 553806948 : as = y46;
5506 553806948 : bs = y47;
5507 553806948 : y46 = ( ( as * FFT_RotVector_32[2 * 12 + 0] ) - ( bs * FFT_RotVector_32[2 * 12 + 1] ) );
5508 553806948 : y47 = ( ( as * FFT_RotVector_32[2 * 12 + 1] ) + ( bs * FFT_RotVector_32[2 * 12 + 0] ) );
5509 : };
5510 : {
5511 553806948 : as = y50;
5512 553806948 : bs = y51;
5513 553806948 : y50 = ( ( as * FFT_RotVector_32[2 * 13 + 0] ) - ( bs * FFT_RotVector_32[2 * 13 + 1] ) );
5514 553806948 : y51 = ( ( as * FFT_RotVector_32[2 * 13 + 1] ) + ( bs * FFT_RotVector_32[2 * 13 + 0] ) );
5515 : };
5516 : {
5517 553806948 : as = y52;
5518 553806948 : bs = y53;
5519 553806948 : y52 = ( ( as * FFT_RotVector_32[2 * 14 + 0] ) - ( bs * FFT_RotVector_32[2 * 14 + 1] ) );
5520 553806948 : y53 = ( ( as * FFT_RotVector_32[2 * 14 + 1] ) + ( bs * FFT_RotVector_32[2 * 14 + 0] ) );
5521 : };
5522 : {
5523 553806948 : as = y54;
5524 553806948 : bs = y55;
5525 553806948 : y54 = ( ( as * FFT_RotVector_32[2 * 15 + 0] ) - ( bs * FFT_RotVector_32[2 * 15 + 1] ) );
5526 553806948 : y55 = ( ( as * FFT_RotVector_32[2 * 15 + 1] ) + ( bs * FFT_RotVector_32[2 * 15 + 0] ) );
5527 : };
5528 : {
5529 553806948 : as = y56;
5530 553806948 : bs = y57;
5531 553806948 : y56 = ( ( as * FFT_RotVector_32[2 * 16 + 0] ) - ( bs * FFT_RotVector_32[2 * 16 + 1] ) );
5532 553806948 : y57 = ( ( as * FFT_RotVector_32[2 * 16 + 1] ) + ( bs * FFT_RotVector_32[2 * 16 + 0] ) );
5533 : };
5534 : {
5535 553806948 : as = y58;
5536 553806948 : bs = y59;
5537 553806948 : y58 = ( ( as * FFT_RotVector_32[2 * 17 + 0] ) - ( bs * FFT_RotVector_32[2 * 17 + 1] ) );
5538 553806948 : y59 = ( ( as * FFT_RotVector_32[2 * 17 + 1] ) + ( bs * FFT_RotVector_32[2 * 17 + 0] ) );
5539 : };
5540 : {
5541 553806948 : as = y60;
5542 553806948 : bs = y61;
5543 553806948 : y60 = ( ( as * FFT_RotVector_32[2 * 18 + 0] ) - ( bs * FFT_RotVector_32[2 * 18 + 1] ) );
5544 553806948 : y61 = ( ( as * FFT_RotVector_32[2 * 18 + 1] ) + ( bs * FFT_RotVector_32[2 * 18 + 0] ) );
5545 : };
5546 : {
5547 553806948 : as = y62;
5548 553806948 : bs = y63;
5549 553806948 : y62 = ( ( as * FFT_RotVector_32[2 * 19 + 0] ) - ( bs * FFT_RotVector_32[2 * 19 + 1] ) );
5550 553806948 : y63 = ( ( as * FFT_RotVector_32[2 * 19 + 1] ) + ( bs * FFT_RotVector_32[2 * 19 + 0] ) );
5551 : };
5552 :
5553 553806948 : t00 = ( y00 + y32 );
5554 553806948 : t02 = ( y00 - y32 );
5555 553806948 : t01 = ( y01 + y33 );
5556 553806948 : t03 = ( y01 - y33 );
5557 553806948 : t04 = ( y16 + y48 );
5558 553806948 : t07 = ( y16 - y48 );
5559 553806948 : t05 = ( y49 + y17 );
5560 553806948 : t06 = ( y49 - y17 );
5561 :
5562 553806948 : re[s * 0] = ( t00 + t04 );
5563 553806948 : im[s * 0] = ( t01 + t05 );
5564 553806948 : re[s * 8] = ( t02 - t06 );
5565 553806948 : im[s * 8] = ( t03 - t07 );
5566 553806948 : re[s * 16] = ( t00 - t04 );
5567 553806948 : im[s * 16] = ( t01 - t05 );
5568 553806948 : re[s * 24] = ( t02 + t06 );
5569 553806948 : im[s * 24] = ( t03 + t07 );
5570 :
5571 553806948 : t00 = ( y02 + y34 );
5572 553806948 : t02 = ( y02 - y34 );
5573 553806948 : t01 = ( y03 + y35 );
5574 553806948 : t03 = ( y03 - y35 );
5575 553806948 : t04 = ( y18 + y50 );
5576 553806948 : t07 = ( y18 - y50 );
5577 553806948 : t05 = ( y51 + y19 );
5578 553806948 : t06 = ( y51 - y19 );
5579 :
5580 553806948 : re[s * 1] = ( t00 + t04 );
5581 553806948 : im[s * 1] = ( t01 + t05 );
5582 553806948 : re[s * 9] = ( t02 - t06 );
5583 553806948 : im[s * 9] = ( t03 - t07 );
5584 553806948 : re[s * 17] = ( t00 - t04 );
5585 553806948 : im[s * 17] = ( t01 - t05 );
5586 553806948 : re[s * 25] = ( t02 + t06 );
5587 553806948 : im[s * 25] = ( t03 + t07 );
5588 :
5589 553806948 : t00 = ( y04 + y36 );
5590 553806948 : t02 = ( y04 - y36 );
5591 553806948 : t01 = ( y05 + y37 );
5592 553806948 : t03 = ( y05 - y37 );
5593 553806948 : t04 = ( y20 + y52 );
5594 553806948 : t07 = ( y20 - y52 );
5595 553806948 : t05 = ( y53 + y21 );
5596 553806948 : t06 = ( y53 - y21 );
5597 :
5598 553806948 : re[s * 2] = ( t00 + t04 );
5599 553806948 : im[s * 2] = ( t01 + t05 );
5600 553806948 : re[s * 10] = ( t02 - t06 );
5601 553806948 : im[s * 10] = ( t03 - t07 );
5602 553806948 : re[s * 18] = ( t00 - t04 );
5603 553806948 : im[s * 18] = ( t01 - t05 );
5604 553806948 : re[s * 26] = ( t02 + t06 );
5605 553806948 : im[s * 26] = ( t03 + t07 );
5606 :
5607 553806948 : t00 = ( y06 + y38 );
5608 553806948 : t02 = ( y06 - y38 );
5609 553806948 : t01 = ( y07 + y39 );
5610 553806948 : t03 = ( y07 - y39 );
5611 553806948 : t04 = ( y22 + y54 );
5612 553806948 : t07 = ( y22 - y54 );
5613 553806948 : t05 = ( y55 + y23 );
5614 553806948 : t06 = ( y55 - y23 );
5615 :
5616 553806948 : re[s * 3] = ( t00 + t04 );
5617 553806948 : im[s * 3] = ( t01 + t05 );
5618 553806948 : re[s * 11] = ( t02 - t06 );
5619 553806948 : im[s * 11] = ( t03 - t07 );
5620 553806948 : re[s * 19] = ( t00 - t04 );
5621 553806948 : im[s * 19] = ( t01 - t05 );
5622 553806948 : re[s * 27] = ( t02 + t06 );
5623 553806948 : im[s * 27] = ( t03 + t07 );
5624 :
5625 553806948 : t00 = ( y08 + y41 );
5626 553806948 : t02 = ( y08 - y41 );
5627 553806948 : t01 = ( y09 - y40 );
5628 553806948 : t03 = ( y09 + y40 );
5629 553806948 : t04 = ( y24 + y56 );
5630 553806948 : t07 = ( y24 - y56 );
5631 553806948 : t05 = ( y57 + y25 );
5632 553806948 : t06 = ( y57 - y25 );
5633 :
5634 553806948 : re[s * 4] = ( t00 + t04 );
5635 553806948 : im[s * 4] = ( t01 + t05 );
5636 553806948 : re[s * 12] = ( t02 - t06 );
5637 553806948 : im[s * 12] = ( t03 - t07 );
5638 553806948 : re[s * 20] = ( t00 - t04 );
5639 553806948 : im[s * 20] = ( t01 - t05 );
5640 553806948 : re[s * 28] = ( t02 + t06 );
5641 553806948 : im[s * 28] = ( t03 + t07 );
5642 :
5643 553806948 : t00 = ( y10 + y42 );
5644 553806948 : t02 = ( y10 - y42 );
5645 553806948 : t01 = ( y11 + y43 );
5646 553806948 : t03 = ( y11 - y43 );
5647 553806948 : t04 = ( y26 + y58 );
5648 553806948 : t07 = ( y26 - y58 );
5649 553806948 : t05 = ( y59 + y27 );
5650 553806948 : t06 = ( y59 - y27 );
5651 :
5652 553806948 : re[s * 5] = ( t00 + t04 );
5653 553806948 : im[s * 5] = ( t01 + t05 );
5654 553806948 : re[s * 13] = ( t02 - t06 );
5655 553806948 : im[s * 13] = ( t03 - t07 );
5656 553806948 : re[s * 21] = ( t00 - t04 );
5657 553806948 : im[s * 21] = ( t01 - t05 );
5658 553806948 : re[s * 29] = ( t02 + t06 );
5659 553806948 : im[s * 29] = ( t03 + t07 );
5660 :
5661 553806948 : t00 = ( y12 + y44 );
5662 553806948 : t02 = ( y12 - y44 );
5663 553806948 : t01 = ( y13 + y45 );
5664 553806948 : t03 = ( y13 - y45 );
5665 553806948 : t04 = ( y28 + y60 );
5666 553806948 : t07 = ( y28 - y60 );
5667 553806948 : t05 = ( y61 + y29 );
5668 553806948 : t06 = ( y61 - y29 );
5669 :
5670 553806948 : re[s * 6] = ( t00 + t04 );
5671 553806948 : im[s * 6] = ( t01 + t05 );
5672 553806948 : re[s * 14] = ( t02 - t06 );
5673 553806948 : im[s * 14] = ( t03 - t07 );
5674 553806948 : re[s * 22] = ( t00 - t04 );
5675 553806948 : im[s * 22] = ( t01 - t05 );
5676 553806948 : re[s * 30] = ( t02 + t06 );
5677 553806948 : im[s * 30] = ( t03 + t07 );
5678 :
5679 553806948 : t00 = ( y14 + y46 );
5680 553806948 : t02 = ( y14 - y46 );
5681 553806948 : t01 = ( y15 + y47 );
5682 553806948 : t03 = ( y15 - y47 );
5683 553806948 : t04 = ( y30 + y62 );
5684 553806948 : t07 = ( y30 - y62 );
5685 553806948 : t05 = ( y63 + y31 );
5686 553806948 : t06 = ( y63 - y31 );
5687 :
5688 553806948 : re[s * 7] = ( t00 + t04 );
5689 553806948 : im[s * 7] = ( t01 + t05 );
5690 553806948 : re[s * 15] = ( t02 - t06 );
5691 553806948 : im[s * 15] = ( t03 - t07 );
5692 553806948 : re[s * 23] = ( t00 - t04 );
5693 553806948 : im[s * 23] = ( t01 - t05 );
5694 553806948 : re[s * 31] = ( t02 + t06 );
5695 553806948 : im[s * 31] = ( t03 + t07 );
5696 :
5697 553806948 : return;
5698 : }
5699 :
5700 1174776348 : static void fft_lenN(
5701 : float *re,
5702 : float *im,
5703 : const float *W,
5704 : const int16_t len,
5705 : const int16_t dim1,
5706 : const int16_t dim2,
5707 : const int16_t sx,
5708 : const int16_t sc,
5709 : const int16_t Woff )
5710 : {
5711 : int16_t i, j;
5712 : float x[L_FRAME_MAX * 2];
5713 :
5714 11803511502 : for ( i = 0; i < dim2; i++ )
5715 : {
5716 >24724*10^7 : for ( j = 0; j < dim1; j++ )
5717 : {
5718 >23661*10^7 : x[2 * i * dim1 + 2 * j] = re[sx * i + sx * j * dim2];
5719 >23661*10^7 : x[2 * i * dim1 + 2 * j + 1] = im[sx * i + sx * j * dim2];
5720 : }
5721 : }
5722 :
5723 1174776348 : switch ( dim1 )
5724 : {
5725 921857 : case 5:
5726 8296713 : for ( i = 0; i < dim2; i++ )
5727 : {
5728 7374856 : fft_len5( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5729 : }
5730 921857 : break;
5731 :
5732 1031167 : case 8:
5733 9280503 : for ( i = 0; i < dim2; i++ )
5734 : {
5735 8249336 : fft_len8( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5736 : }
5737 1031167 : break;
5738 :
5739 275986372 : case 10:
5740 2483877348 : for ( i = 0; i < dim2; i++ )
5741 : {
5742 2207890976 : fft_len10( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5743 : }
5744 275986372 : break;
5745 :
5746 9614155 : case 15:
5747 86527395 : for ( i = 0; i < dim2; i++ )
5748 : {
5749 76913240 : fft_len15( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5750 : }
5751 9614155 : break;
5752 :
5753 16466706 : case 16:
5754 148200354 : for ( i = 0; i < dim2; i++ )
5755 : {
5756 131733648 : fft_len16( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5757 : }
5758 16466706 : break;
5759 :
5760 369797431 : case 20:
5761 3870062997 : for ( i = 0; i < dim2; i++ )
5762 : {
5763 3500265566 : fft_len20( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5764 : }
5765 369797431 : break;
5766 :
5767 483438814 : case 30:
5768 5039587578 : for ( i = 0; i < dim2; i++ )
5769 : {
5770 4556148764 : fft_len30( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5771 : }
5772 483438814 : break;
5773 :
5774 17519846 : case 32:
5775 157678614 : for ( i = 0; i < dim2; i++ )
5776 : {
5777 140158768 : fft_len32( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
5778 : }
5779 17519846 : break;
5780 : }
5781 :
5782 1174776348 : switch ( dim2 )
5783 : {
5784 :
5785 1053565392 : case 8:
5786 : {
5787 : float x00, x01, x02, x03, x04, x05, x06, x07, x08, x09, x10, x11, x12, x13, x14, x15;
5788 : float t00, t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15;
5789 : float s00, s01, s02, s03, s04, s05, s06, s07, s08, s09, s10, s11, s12, s13, s14, s15;
5790 :
5791 1053565392 : if ( dim1 == 30 || dim1 == 20 || dim1 == 15 || dim1 == 10 || dim1 == 5 )
5792 : {
5793 22716664193 : for ( i = 0; i < dim1; i++ )
5794 : {
5795 : {
5796 21698116520 : x00 = x[2 * i + 2 * 0 * dim1];
5797 21698116520 : x01 = x[2 * i + 2 * 0 * dim1 + 1];
5798 : };
5799 21698116520 : if ( i == 0 )
5800 : {
5801 : {
5802 1018547673 : x02 = x[2 * i + 2 * 1 * dim1];
5803 1018547673 : x03 = x[2 * i + 2 * 1 * dim1 + 1];
5804 : };
5805 : {
5806 1018547673 : x04 = x[2 * i + 2 * 2 * dim1];
5807 1018547673 : x05 = x[2 * i + 2 * 2 * dim1 + 1];
5808 : };
5809 : {
5810 1018547673 : x06 = x[2 * i + 2 * 3 * dim1];
5811 1018547673 : x07 = x[2 * i + 2 * 3 * dim1 + 1];
5812 : };
5813 : {
5814 1018547673 : x08 = x[2 * i + 2 * 4 * dim1];
5815 1018547673 : x09 = x[2 * i + 2 * 4 * dim1 + 1];
5816 : };
5817 : {
5818 1018547673 : x10 = x[2 * i + 2 * 5 * dim1];
5819 1018547673 : x11 = x[2 * i + 2 * 5 * dim1 + 1];
5820 : };
5821 : {
5822 1018547673 : x12 = x[2 * i + 2 * 6 * dim1];
5823 1018547673 : x13 = x[2 * i + 2 * 6 * dim1 + 1];
5824 : };
5825 : {
5826 1018547673 : x14 = x[2 * i + 2 * 7 * dim1];
5827 1018547673 : x15 = x[2 * i + 2 * 7 * dim1 + 1];
5828 : };
5829 : }
5830 : else
5831 : {
5832 : {
5833 20679568847 : x02 = ( x[2 * i + 2 * 1 * dim1] * W[sc * i + sc * 1 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 1 * dim1 + 1] * W[sc * i + sc * 1 * dim1 * 2 + 1 - Woff] );
5834 20679568847 : x03 = ( x[2 * i + 2 * 1 * dim1] * W[sc * i + sc * 1 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 1 * dim1 + 1] * W[sc * i + sc * 1 * dim1 * 2 - Woff] );
5835 : };
5836 : {
5837 20679568847 : x04 = ( x[2 * i + 2 * 2 * dim1] * W[sc * i + sc * 2 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 2 * dim1 + 1] * W[sc * i + sc * 2 * dim1 * 2 + 1 - Woff] );
5838 20679568847 : x05 = ( x[2 * i + 2 * 2 * dim1] * W[sc * i + sc * 2 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 2 * dim1 + 1] * W[sc * i + sc * 2 * dim1 * 2 - Woff] );
5839 : };
5840 : {
5841 20679568847 : x06 = ( x[2 * i + 2 * 3 * dim1] * W[sc * i + sc * 3 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 3 * dim1 + 1] * W[sc * i + sc * 3 * dim1 * 2 + 1 - Woff] );
5842 20679568847 : x07 = ( x[2 * i + 2 * 3 * dim1] * W[sc * i + sc * 3 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 3 * dim1 + 1] * W[sc * i + sc * 3 * dim1 * 2 - Woff] );
5843 : };
5844 : {
5845 20679568847 : x08 = ( x[2 * i + 2 * 4 * dim1] * W[sc * i + sc * 4 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 4 * dim1 + 1] * W[sc * i + sc * 4 * dim1 * 2 + 1 - Woff] );
5846 20679568847 : x09 = ( x[2 * i + 2 * 4 * dim1] * W[sc * i + sc * 4 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 4 * dim1 + 1] * W[sc * i + sc * 4 * dim1 * 2 - Woff] );
5847 : };
5848 : {
5849 20679568847 : x10 = ( x[2 * i + 2 * 5 * dim1] * W[sc * i + sc * 5 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 5 * dim1 + 1] * W[sc * i + sc * 5 * dim1 * 2 + 1 - Woff] );
5850 20679568847 : x11 = ( x[2 * i + 2 * 5 * dim1] * W[sc * i + sc * 5 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 5 * dim1 + 1] * W[sc * i + sc * 5 * dim1 * 2 - Woff] );
5851 : };
5852 : {
5853 20679568847 : x12 = ( x[2 * i + 2 * 6 * dim1] * W[sc * i + sc * 6 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 6 * dim1 + 1] * W[sc * i + sc * 6 * dim1 * 2 + 1 - Woff] );
5854 20679568847 : x13 = ( x[2 * i + 2 * 6 * dim1] * W[sc * i + sc * 6 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 6 * dim1 + 1] * W[sc * i + sc * 6 * dim1 * 2 - Woff] );
5855 : };
5856 : {
5857 20679568847 : x14 = ( x[2 * i + 2 * 7 * dim1] * W[sc * i + sc * 7 * dim1 * 2 - Woff] ) - ( x[2 * i + 2 * 7 * dim1 + 1] * W[sc * i + sc * 7 * dim1 * 2 + 1 - Woff] );
5858 20679568847 : x15 = ( x[2 * i + 2 * 7 * dim1] * W[sc * i + sc * 7 * dim1 * 2 + 1 - Woff] ) + ( x[2 * i + 2 * 7 * dim1 + 1] * W[sc * i + sc * 7 * dim1 * 2 - Woff] );
5859 : };
5860 : }
5861 :
5862 21698116520 : t00 = ( x00 + x08 );
5863 21698116520 : t02 = ( x00 - x08 );
5864 21698116520 : t01 = ( x01 + x09 );
5865 21698116520 : t03 = ( x01 - x09 );
5866 21698116520 : t04 = ( x02 + x10 );
5867 21698116520 : t06 = ( x02 - x10 );
5868 21698116520 : t05 = ( x03 + x11 );
5869 21698116520 : t07 = ( x03 - x11 );
5870 21698116520 : t08 = ( x04 + x12 );
5871 21698116520 : t10 = ( x04 - x12 );
5872 21698116520 : t09 = ( x05 + x13 );
5873 21698116520 : t11 = ( x05 - x13 );
5874 21698116520 : t12 = ( x06 + x14 );
5875 21698116520 : t14 = ( x06 - x14 );
5876 21698116520 : t13 = ( x07 + x15 );
5877 21698116520 : t15 = ( x07 - x15 );
5878 :
5879 21698116520 : s00 = ( t00 + t08 );
5880 21698116520 : s04 = ( t00 - t08 );
5881 21698116520 : s01 = ( t01 + t09 );
5882 21698116520 : s05 = ( t01 - t09 );
5883 21698116520 : s08 = ( t02 - t11 );
5884 21698116520 : s10 = ( t02 + t11 );
5885 21698116520 : s09 = ( t03 + t10 );
5886 21698116520 : s11 = ( t03 - t10 );
5887 21698116520 : s02 = ( t04 + t12 );
5888 21698116520 : s07 = ( t04 - t12 );
5889 21698116520 : s03 = ( t05 + t13 );
5890 21698116520 : s06 = ( t13 - t05 );
5891 :
5892 21698116520 : t01 = ( t06 + t14 );
5893 21698116520 : t02 = ( t06 - t14 );
5894 21698116520 : t00 = ( t07 + t15 );
5895 21698116520 : t03 = ( t07 - t15 );
5896 :
5897 21698116520 : s12 = ( ( t00 + t02 ) * FFT_C81 );
5898 21698116520 : s14 = ( ( t00 - t02 ) * FFT_C81 );
5899 21698116520 : s13 = ( ( t03 - t01 ) * FFT_C81 );
5900 21698116520 : s15 = ( ( t01 + t03 ) * FFT_C82 );
5901 :
5902 21698116520 : re[sx * i + sx * 0 * dim1] = ( s00 + s02 );
5903 21698116520 : im[sx * i + sx * 0 * dim1] = ( s01 + s03 );
5904 21698116520 : re[sx * i + sx * 1 * dim1] = ( s10 + s12 );
5905 21698116520 : im[sx * i + sx * 1 * dim1] = ( s11 + s13 );
5906 21698116520 : re[sx * i + sx * 2 * dim1] = ( s04 - s06 );
5907 21698116520 : im[sx * i + sx * 2 * dim1] = ( s05 - s07 );
5908 21698116520 : re[sx * i + sx * 3 * dim1] = ( s08 + s14 );
5909 21698116520 : im[sx * i + sx * 3 * dim1] = ( s09 + s15 );
5910 21698116520 : re[sx * i + sx * 4 * dim1] = ( s00 - s02 );
5911 21698116520 : im[sx * i + sx * 4 * dim1] = ( s01 - s03 );
5912 21698116520 : re[sx * i + sx * 5 * dim1] = ( s10 - s12 );
5913 21698116520 : im[sx * i + sx * 5 * dim1] = ( s11 - s13 );
5914 21698116520 : re[sx * i + sx * 6 * dim1] = ( s04 + s06 );
5915 21698116520 : im[sx * i + sx * 6 * dim1] = ( s05 + s07 );
5916 21698116520 : re[sx * i + sx * 7 * dim1] = ( s08 - s14 );
5917 21698116520 : im[sx * i + sx * 7 * dim1] = ( s09 - s15 );
5918 : }
5919 : }
5920 : else
5921 : {
5922 867369423 : for ( i = 0; i < dim1; i++ )
5923 : {
5924 : {
5925 832351704 : x00 = x[2 * i + 2 * 0 * dim1];
5926 832351704 : x01 = x[2 * i + 2 * 0 * dim1 + 1];
5927 : };
5928 832351704 : if ( i == 0 )
5929 : {
5930 : {
5931 35017719 : x02 = x[2 * i + 2 * 1 * dim1];
5932 35017719 : x03 = x[2 * i + 2 * 1 * dim1 + 1];
5933 : };
5934 : {
5935 35017719 : x04 = x[2 * i + 2 * 2 * dim1];
5936 35017719 : x05 = x[2 * i + 2 * 2 * dim1 + 1];
5937 : };
5938 : {
5939 35017719 : x06 = x[2 * i + 2 * 3 * dim1];
5940 35017719 : x07 = x[2 * i + 2 * 3 * dim1 + 1];
5941 : };
5942 : {
5943 35017719 : x08 = x[2 * i + 2 * 4 * dim1];
5944 35017719 : x09 = x[2 * i + 2 * 4 * dim1 + 1];
5945 : };
5946 : {
5947 35017719 : x10 = x[2 * i + 2 * 5 * dim1];
5948 35017719 : x11 = x[2 * i + 2 * 5 * dim1 + 1];
5949 : };
5950 : {
5951 35017719 : x12 = x[2 * i + 2 * 6 * dim1];
5952 35017719 : x13 = x[2 * i + 2 * 6 * dim1 + 1];
5953 : };
5954 : {
5955 35017719 : x14 = x[2 * i + 2 * 7 * dim1];
5956 35017719 : x15 = x[2 * i + 2 * 7 * dim1 + 1];
5957 : };
5958 : }
5959 : else
5960 : {
5961 : {
5962 797333985 : x02 = ( x[2 * i + 2 * 1 * dim1] * W[sc * i + sc * 1 * dim1 - Woff] ) - ( x[2 * i + 2 * 1 * dim1 + 1] * W[sc * i + sc * 1 * dim1 + 1 - Woff] );
5963 797333985 : x03 = ( x[2 * i + 2 * 1 * dim1] * W[sc * i + sc * 1 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 1 * dim1 + 1] * W[sc * i + sc * 1 * dim1 - Woff] );
5964 : };
5965 : {
5966 797333985 : x04 = ( x[2 * i + 2 * 2 * dim1] * W[sc * i + sc * 2 * dim1 - Woff] ) - ( x[2 * i + 2 * 2 * dim1 + 1] * W[sc * i + sc * 2 * dim1 + 1 - Woff] );
5967 797333985 : x05 = ( x[2 * i + 2 * 2 * dim1] * W[sc * i + sc * 2 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 2 * dim1 + 1] * W[sc * i + sc * 2 * dim1 - Woff] );
5968 : };
5969 : {
5970 797333985 : x06 = ( x[2 * i + 2 * 3 * dim1] * W[sc * i + sc * 3 * dim1 - Woff] ) - ( x[2 * i + 2 * 3 * dim1 + 1] * W[sc * i + sc * 3 * dim1 + 1 - Woff] );
5971 797333985 : x07 = ( x[2 * i + 2 * 3 * dim1] * W[sc * i + sc * 3 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 3 * dim1 + 1] * W[sc * i + sc * 3 * dim1 - Woff] );
5972 : };
5973 : {
5974 797333985 : x08 = ( x[2 * i + 2 * 4 * dim1] * W[sc * i + sc * 4 * dim1 - Woff] ) - ( x[2 * i + 2 * 4 * dim1 + 1] * W[sc * i + sc * 4 * dim1 + 1 - Woff] );
5975 797333985 : x09 = ( x[2 * i + 2 * 4 * dim1] * W[sc * i + sc * 4 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 4 * dim1 + 1] * W[sc * i + sc * 4 * dim1 - Woff] );
5976 : };
5977 : {
5978 797333985 : x10 = ( x[2 * i + 2 * 5 * dim1] * W[sc * i + sc * 5 * dim1 - Woff] ) - ( x[2 * i + 2 * 5 * dim1 + 1] * W[sc * i + sc * 5 * dim1 + 1 - Woff] );
5979 797333985 : x11 = ( x[2 * i + 2 * 5 * dim1] * W[sc * i + sc * 5 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 5 * dim1 + 1] * W[sc * i + sc * 5 * dim1 - Woff] );
5980 : };
5981 : {
5982 797333985 : x12 = ( x[2 * i + 2 * 6 * dim1] * W[sc * i + sc * 6 * dim1 - Woff] ) - ( x[2 * i + 2 * 6 * dim1 + 1] * W[sc * i + sc * 6 * dim1 + 1 - Woff] );
5983 797333985 : x13 = ( x[2 * i + 2 * 6 * dim1] * W[sc * i + sc * 6 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 6 * dim1 + 1] * W[sc * i + sc * 6 * dim1 - Woff] );
5984 : };
5985 : {
5986 797333985 : x14 = ( x[2 * i + 2 * 7 * dim1] * W[sc * i + sc * 7 * dim1 - Woff] ) - ( x[2 * i + 2 * 7 * dim1 + 1] * W[sc * i + sc * 7 * dim1 + 1 - Woff] );
5987 797333985 : x15 = ( x[2 * i + 2 * 7 * dim1] * W[sc * i + sc * 7 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * 7 * dim1 + 1] * W[sc * i + sc * 7 * dim1 - Woff] );
5988 : };
5989 : }
5990 :
5991 832351704 : t00 = ( x00 + x08 );
5992 832351704 : t02 = ( x00 - x08 );
5993 832351704 : t01 = ( x01 + x09 );
5994 832351704 : t03 = ( x01 - x09 );
5995 832351704 : t04 = ( x02 + x10 );
5996 832351704 : t06 = ( x02 - x10 );
5997 832351704 : t05 = ( x03 + x11 );
5998 832351704 : t07 = ( x03 - x11 );
5999 832351704 : t08 = ( x04 + x12 );
6000 832351704 : t10 = ( x04 - x12 );
6001 832351704 : t09 = ( x05 + x13 );
6002 832351704 : t11 = ( x05 - x13 );
6003 832351704 : t12 = ( x06 + x14 );
6004 832351704 : t14 = ( x06 - x14 );
6005 832351704 : t13 = ( x07 + x15 );
6006 832351704 : t15 = ( x07 - x15 );
6007 :
6008 832351704 : s00 = ( t00 + t08 );
6009 832351704 : s04 = ( t00 - t08 );
6010 832351704 : s01 = ( t01 + t09 );
6011 832351704 : s05 = ( t01 - t09 );
6012 832351704 : s08 = ( t02 - t11 );
6013 832351704 : s10 = ( t02 + t11 );
6014 832351704 : s09 = ( t03 + t10 );
6015 832351704 : s11 = ( t03 - t10 );
6016 832351704 : s02 = ( t04 + t12 );
6017 832351704 : s07 = ( t04 - t12 );
6018 832351704 : s03 = ( t05 + t13 );
6019 832351704 : s06 = ( t13 - t05 );
6020 :
6021 832351704 : t01 = ( t06 + t14 );
6022 832351704 : t02 = ( t06 - t14 );
6023 832351704 : t00 = ( t07 + t15 );
6024 832351704 : t03 = ( t07 - t15 );
6025 :
6026 832351704 : s12 = ( ( t00 + t02 ) * FFT_C81 );
6027 832351704 : s14 = ( ( t00 - t02 ) * FFT_C81 );
6028 832351704 : s13 = ( ( t03 - t01 ) * FFT_C81 );
6029 832351704 : s15 = ( ( t01 + t03 ) * FFT_C82 );
6030 :
6031 832351704 : re[sx * i + sx * 0 * dim1] = ( s00 + s02 );
6032 832351704 : im[sx * i + sx * 0 * dim1] = ( s01 + s03 );
6033 832351704 : re[sx * i + sx * 1 * dim1] = ( s10 + s12 );
6034 832351704 : im[sx * i + sx * 1 * dim1] = ( s11 + s13 );
6035 832351704 : re[sx * i + sx * 2 * dim1] = ( s04 - s06 );
6036 832351704 : im[sx * i + sx * 2 * dim1] = ( s05 - s07 );
6037 832351704 : re[sx * i + sx * 3 * dim1] = ( s08 + s14 );
6038 832351704 : im[sx * i + sx * 3 * dim1] = ( s09 + s15 );
6039 832351704 : re[sx * i + sx * 4 * dim1] = ( s00 - s02 );
6040 832351704 : im[sx * i + sx * 4 * dim1] = ( s01 - s03 );
6041 832351704 : re[sx * i + sx * 5 * dim1] = ( s10 - s12 );
6042 832351704 : im[sx * i + sx * 5 * dim1] = ( s11 - s13 );
6043 832351704 : re[sx * i + sx * 6 * dim1] = ( s04 + s06 );
6044 832351704 : im[sx * i + sx * 6 * dim1] = ( s05 + s07 );
6045 832351704 : re[sx * i + sx * 7 * dim1] = ( s08 - s14 );
6046 832351704 : im[sx * i + sx * 7 * dim1] = ( s09 - s15 );
6047 : }
6048 : }
6049 1053565392 : break;
6050 : }
6051 :
6052 584569 : case 10:
6053 : {
6054 : float y[2 * 10];
6055 6430259 : for ( j = 0; j < dim2; j++ )
6056 : {
6057 : {
6058 5845690 : y[2 * j] = x[2 * 0 + 2 * j * dim1];
6059 5845690 : y[2 * j + 1] = x[2 * 0 + 2 * j * dim1 + 1];
6060 : };
6061 : }
6062 584569 : fft_len10( &y[0], &y[1], 2 );
6063 6430259 : for ( j = 0; j < dim2; j++ )
6064 : {
6065 5845690 : re[sx * 0 + sx * j * dim1] = y[2 * j];
6066 5845690 : im[sx * 0 + sx * j * dim1] = y[2 * j + 1];
6067 : }
6068 :
6069 11691380 : for ( i = 1; i < dim1; i++ )
6070 : {
6071 : {
6072 11106811 : y[2 * ( 0 + 0 )] = x[2 * i + 2 * ( 0 + 0 ) * dim1];
6073 11106811 : y[2 * ( 0 + 0 ) + 1] = x[2 * i + 2 * ( 0 + 0 ) * dim1 + 1];
6074 : }
6075 :
6076 111068110 : for ( j = 1; j < dim2; j++ )
6077 : {
6078 : {
6079 99961299 : y[2 * ( j + 0 )] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + sc * j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + sc * j * dim1 + 1 - Woff] );
6080 99961299 : y[2 * ( j + 0 ) + 1] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + sc * j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + sc * j * dim1 - Woff] );
6081 : }
6082 : }
6083 11106811 : fft_len10( &y[0], &y[1], 2 );
6084 122174921 : for ( j = 0; j < dim2; j++ )
6085 : {
6086 111068110 : re[sx * i + sx * j * dim1] = y[2 * j];
6087 111068110 : im[sx * i + sx * j * dim1] = y[2 * j + 1];
6088 : }
6089 : }
6090 584569 : break;
6091 : }
6092 :
6093 103616672 : case 16:
6094 : {
6095 : float y[2 * 16];
6096 1761483424 : for ( j = 0; j < dim2; j++ )
6097 : {
6098 : {
6099 1657866752 : y[2 * j] = x[2 * 0 + 2 * j * dim1];
6100 1657866752 : y[2 * j + 1] = x[2 * 0 + 2 * j * dim1 + 1];
6101 : };
6102 : }
6103 103616672 : fft_len16( &y[0], &y[1], 2 );
6104 1761483424 : for ( j = 0; j < dim2; j++ )
6105 : {
6106 1657866752 : re[sx * 0 + sx * j * dim1] = y[2 * j];
6107 1657866752 : im[sx * 0 + sx * j * dim1] = y[2 * j + 1];
6108 : }
6109 :
6110 2666544160 : for ( i = 1; i < dim1; i++ )
6111 : {
6112 : {
6113 2562927488 : y[2 * ( 0 + 0 )] = x[2 * i + 2 * ( 0 + 0 ) * dim1];
6114 2562927488 : y[2 * ( 0 + 0 ) + 1] = x[2 * i + 2 * ( 0 + 0 ) * dim1 + 1];
6115 : }
6116 :
6117 41006839808 : for ( j = 1; j < dim2; j++ )
6118 : {
6119 : {
6120 38443912320 : y[2 * ( j + 0 )] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + sc * j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + sc * j * dim1 + 1 - Woff] );
6121 38443912320 : y[2 * ( j + 0 ) + 1] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + sc * j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + sc * j * dim1 - Woff] );
6122 : }
6123 : }
6124 2562927488 : fft_len16( &y[0], &y[1], 2 );
6125 43569767296 : for ( j = 0; j < dim2; j++ )
6126 : {
6127 41006839808 : re[sx * i + sx * j * dim1] = y[2 * j];
6128 41006839808 : im[sx * i + sx * j * dim1] = y[2 * j + 1];
6129 : }
6130 : }
6131 103616672 : break;
6132 : }
6133 :
6134 650942 : case 20:
6135 : {
6136 : float y[2 * 20];
6137 13669782 : for ( j = 0; j < dim2; j++ )
6138 : {
6139 : {
6140 13018840 : y[2 * j] = x[2 * 0 + 2 * j * dim1];
6141 13018840 : y[2 * j + 1] = x[2 * 0 + 2 * j * dim1 + 1];
6142 : };
6143 : }
6144 650942 : fft_len20( &y[0], &y[1], 2 );
6145 13669782 : for ( j = 0; j < dim2; j++ )
6146 : {
6147 13018840 : re[sx * 0 + sx * j * dim1] = y[2 * j];
6148 13018840 : im[sx * 0 + sx * j * dim1] = y[2 * j + 1];
6149 : }
6150 :
6151 17798130 : for ( i = 1; i < dim1; i++ )
6152 : {
6153 : {
6154 17147188 : y[2 * ( 0 + 0 )] = x[2 * i + 2 * ( 0 + 0 ) * dim1];
6155 17147188 : y[2 * ( 0 + 0 ) + 1] = x[2 * i + 2 * ( 0 + 0 ) * dim1 + 1];
6156 : }
6157 : {
6158 17147188 : y[2 * ( 0 + 1 )] = ( x[2 * i + 2 * ( 0 + 1 ) * dim1] * W[len + sc * i + 0 * dim1 - Woff] ) - ( x[2 * i + 2 * ( 0 + 1 ) * dim1 + 1] * W[len + sc * i + 0 * dim1 + 1 - Woff] );
6159 17147188 : y[2 * ( 0 + 1 ) + 1] = ( x[2 * i + 2 * ( 0 + 1 ) * dim1] * W[len + sc * i + 0 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( 0 + 1 ) * dim1 + 1] * W[len + sc * i + 0 * dim1 - Woff] );
6160 : }
6161 :
6162 171471880 : for ( j = 2; j < dim2; j = j + 2 )
6163 : {
6164 : {
6165 154324692 : y[2 * ( j + 0 )] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + j * dim1 + 1 - Woff] );
6166 154324692 : y[2 * ( j + 0 ) + 1] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + j * dim1 - Woff] );
6167 : }
6168 : {
6169 154324692 : y[2 * ( j + 1 )] = ( x[2 * i + 2 * ( j + 1 ) * dim1] * W[len + sc * i + j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 1 ) * dim1 + 1] * W[len + sc * i + j * dim1 + 1 - Woff] );
6170 154324692 : y[2 * ( j + 1 ) + 1] = ( x[2 * i + 2 * ( j + 1 ) * dim1] * W[len + sc * i + j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 1 ) * dim1 + 1] * W[len + sc * i + j * dim1 - Woff] );
6171 : }
6172 : }
6173 17147188 : fft_len20( &y[0], &y[1], 2 );
6174 360090948 : for ( j = 0; j < dim2; j++ )
6175 : {
6176 342943760 : re[sx * i + sx * j * dim1] = y[2 * j];
6177 342943760 : im[sx * i + sx * j * dim1] = y[2 * j + 1];
6178 : }
6179 : }
6180 650942 : break;
6181 : }
6182 :
6183 16358773 : case 32:
6184 : {
6185 : float y[2 * 32];
6186 539839509 : for ( j = 0; j < dim2; j++ )
6187 : {
6188 : {
6189 523480736 : y[2 * j] = x[2 * 0 + 2 * j * dim1];
6190 523480736 : y[2 * j + 1] = x[2 * 0 + 2 * j * dim1 + 1];
6191 : };
6192 : }
6193 16358773 : fft_len32( &y[0], &y[1], 2 );
6194 539839509 : for ( j = 0; j < dim2; j++ )
6195 : {
6196 523480736 : re[sx * 0 + sx * j * dim1] = y[2 * j];
6197 523480736 : im[sx * 0 + sx * j * dim1] = y[2 * j + 1];
6198 : }
6199 :
6200 413648180 : for ( i = 1; i < dim1; i++ )
6201 : {
6202 : {
6203 397289407 : y[2 * ( 0 + 0 )] = x[2 * i + 2 * ( 0 + 0 ) * dim1];
6204 397289407 : y[2 * ( 0 + 0 ) + 1] = x[2 * i + 2 * ( 0 + 0 ) * dim1 + 1];
6205 : }
6206 : {
6207 397289407 : y[2 * ( 0 + 1 )] = ( x[2 * i + 2 * ( 0 + 1 ) * dim1] * W[len + sc * i + 0 * dim1 - Woff] ) - ( x[2 * i + 2 * ( 0 + 1 ) * dim1 + 1] * W[len + sc * i + 0 * dim1 + 1 - Woff] );
6208 397289407 : y[2 * ( 0 + 1 ) + 1] = ( x[2 * i + 2 * ( 0 + 1 ) * dim1] * W[len + sc * i + 0 * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( 0 + 1 ) * dim1 + 1] * W[len + sc * i + 0 * dim1 - Woff] );
6209 : }
6210 :
6211 6356630512 : for ( j = 2; j < dim2; j = j + 2 )
6212 : {
6213 : {
6214 5959341105 : y[2 * ( j + 0 )] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + j * dim1 + 1 - Woff] );
6215 5959341105 : y[2 * ( j + 0 ) + 1] = ( x[2 * i + 2 * ( j + 0 ) * dim1] * W[sc * i + j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 0 ) * dim1 + 1] * W[sc * i + j * dim1 - Woff] );
6216 : }
6217 : {
6218 5959341105 : y[2 * ( j + 1 )] = ( x[2 * i + 2 * ( j + 1 ) * dim1] * W[len + sc * i + j * dim1 - Woff] ) - ( x[2 * i + 2 * ( j + 1 ) * dim1 + 1] * W[len + sc * i + j * dim1 + 1 - Woff] );
6219 5959341105 : y[2 * ( j + 1 ) + 1] = ( x[2 * i + 2 * ( j + 1 ) * dim1] * W[len + sc * i + j * dim1 + 1 - Woff] ) + ( x[2 * i + 2 * ( j + 1 ) * dim1 + 1] * W[len + sc * i + j * dim1 - Woff] );
6220 : }
6221 : }
6222 397289407 : fft_len32( &y[0], &y[1], 2 );
6223 13110550431 : for ( j = 0; j < dim2; j++ )
6224 : {
6225 12713261024 : re[sx * i + sx * j * dim1] = y[2 * j];
6226 12713261024 : im[sx * i + sx * j * dim1] = y[2 * j + 1];
6227 : }
6228 : }
6229 16358773 : break;
6230 : }
6231 : }
6232 :
6233 1174776348 : return;
6234 : }
6235 :
6236 :
6237 : /*-----------------------------------------------------------------*
6238 : * fft()
6239 : *
6240 : * Complex-value FFT
6241 : *-----------------------------------------------------------------*/
6242 :
6243 1174776348 : void fft(
6244 : float *re, /* i/o: real part */
6245 : float *im, /* i/o: imag part */
6246 : const int16_t length, /* i : length of fft */
6247 : const int16_t s /* i : sign */
6248 : )
6249 : {
6250 1174776348 : switch ( length )
6251 : {
6252 0 : case 20:
6253 0 : fft_len20( re, im, s );
6254 0 : break;
6255 921857 : case 40:
6256 921857 : fft_lenN( re, im, FFT_RotVector_640, 640, 5, 8, s, 8, 40 );
6257 921857 : break;
6258 1031167 : case 64:
6259 1031167 : fft_lenN( re, im, FFT_RotVector_256, 256, 8, 8, s, 8, 64 );
6260 1031167 : break;
6261 275986372 : case 80:
6262 275986372 : fft_lenN( re, im, FFT_RotVector_640, 640, 10, 8, s, 4, 40 );
6263 275986372 : break;
6264 0 : case 100:
6265 0 : fft_lenN( re, im, FFT_RotVector_400, 400, 10, 10, s, 4, 40 );
6266 0 : break;
6267 9614155 : case 120:
6268 9614155 : fft_lenN( re, im, FFT_RotVector_960, 960, 15, 8, s, 4, 60 );
6269 9614155 : break;
6270 16466706 : case 128:
6271 16466706 : fft_lenN( re, im, FFT_RotVector_256, 256, 16, 8, s, 4, 64 );
6272 16466706 : break;
6273 317132748 : case 160:
6274 317132748 : fft_lenN( re, im, FFT_RotVector_640, 640, 20, 8, s, 2, 40 );
6275 317132748 : break;
6276 584569 : case 200:
6277 584569 : fft_lenN( re, im, FFT_RotVector_400, 400, 20, 10, s, 2, 40 );
6278 584569 : break;
6279 414892541 : case 240:
6280 414892541 : fft_lenN( re, im, FFT_RotVector_960, 960, 30, 8, s, 2, 60 );
6281 414892541 : break;
6282 17519846 : case 256:
6283 17519846 : fft_lenN( re, im, FFT_RotVector_256, 256, 32, 8, s, 2, 64 );
6284 17519846 : break;
6285 44195600 : case 320:
6286 44195600 : fft_lenN( re, im, FFT_RotVector_640, 640, 20, 16, s, 2, 40 );
6287 44195600 : break;
6288 173013 : case 400:
6289 173013 : fft_lenN( re, im, FFT_RotVector_400, 400, 20, 20, s, 2, 40 );
6290 173013 : break;
6291 59421072 : case 480:
6292 59421072 : fft_lenN( re, im, FFT_RotVector_960, 960, 30, 16, s, 2, 60 );
6293 59421072 : break;
6294 477929 : case 600:
6295 477929 : fft_lenN( re, im, FFT_RotVector_600, 600, 30, 20, s, 2, 60 );
6296 477929 : break;
6297 7711501 : case 640:
6298 7711501 : fft_lenN( re, im, FFT_RotVector_640, 640, 20, 32, s, 2, 40 );
6299 7711501 : break;
6300 8647272 : case 960:
6301 8647272 : fft_lenN( re, im, FFT_RotVector_960, 960, 30, 32, s, 2, 60 );
6302 8647272 : break;
6303 0 : default:
6304 0 : assert( !"fft length is not supported!" );
6305 : }
6306 :
6307 1174776348 : return;
6308 : }
6309 :
6310 :
6311 : /*-----------------------------------------------------------------*
6312 : * rfft()
6313 : *
6314 : * Real-value FFT
6315 : *-----------------------------------------------------------------*/
6316 :
6317 27047633 : void rfft(
6318 : float *x, /* i/o: values */
6319 : const float *w, /* i : window */
6320 : const int16_t length, /* i : length of fft */
6321 : const int16_t isign /* i : sign */
6322 : )
6323 : {
6324 : int16_t i, sizeOfFft2, sizeOfFft4;
6325 : float tmp, t1, t2, t3, t4, s1, s2;
6326 :
6327 27047633 : sizeOfFft2 = length >> 1;
6328 27047633 : sizeOfFft4 = length >> 2;
6329 27047633 : s1 = 1.f / (float) sizeOfFft2;
6330 27047633 : s2 = -1.f / (float) sizeOfFft2;
6331 :
6332 27047633 : switch ( isign )
6333 : {
6334 :
6335 13483746 : case -1:
6336 :
6337 13483746 : fft( x, x + 1, sizeOfFft2, 2 );
6338 :
6339 13483746 : tmp = x[0] + x[1];
6340 13483746 : x[1] = x[0] - x[1];
6341 13483746 : x[0] = tmp;
6342 :
6343 1953990146 : for ( i = 1; i <= sizeOfFft4; i++ )
6344 : {
6345 1940506400 : t1 = x[2 * i] - x[length - 2 * i];
6346 1940506400 : t2 = x[2 * i + 1] + x[length - 2 * i + 1];
6347 1940506400 : t3 = w[i] * t1 - w[i + sizeOfFft4] * t2;
6348 1940506400 : t4 = w[i + sizeOfFft4] * t1 + w[i] * t2;
6349 1940506400 : t1 = x[2 * i] + x[length - 2 * i];
6350 1940506400 : t2 = x[2 * i + 1] - x[length - 2 * i + 1];
6351 :
6352 1940506400 : x[2 * i] = ( t1 - t3 ) * 0.5f;
6353 1940506400 : x[2 * i + 1] = ( t2 - t4 ) * 0.5f;
6354 1940506400 : x[length - 2 * i] = ( t1 + t3 ) * 0.5f;
6355 1940506400 : x[length - 2 * i + 1] = -( t2 + t4 ) * 0.5f;
6356 : }
6357 :
6358 13483746 : break;
6359 :
6360 13563887 : case +1:
6361 :
6362 13563887 : tmp = ( x[0] + x[1] ) * 0.5f;
6363 13563887 : x[1] = ( x[1] - x[0] ) * 0.5f;
6364 13563887 : x[0] = tmp;
6365 :
6366 2638558599 : for ( i = 1; i <= sizeOfFft4; i++ )
6367 : {
6368 2624994712 : t1 = x[2 * i] - x[length - 2 * i];
6369 2624994712 : t2 = x[2 * i + 1] + x[length - 2 * i + 1];
6370 2624994712 : t3 = w[i] * t1 + w[i + sizeOfFft4] * t2;
6371 2624994712 : t4 = -w[i + sizeOfFft4] * t1 + w[i] * t2;
6372 2624994712 : t1 = x[2 * i] + x[length - 2 * i];
6373 2624994712 : t2 = x[2 * i + 1] - x[length - 2 * i + 1];
6374 :
6375 2624994712 : x[2 * i] = ( t1 - t3 ) * 0.5f;
6376 2624994712 : x[2 * i + 1] = ( t4 - t2 ) * 0.5f;
6377 2624994712 : x[length - 2 * i] = ( t1 + t3 ) * 0.5f;
6378 2624994712 : x[length - 2 * i + 1] = ( t2 + t4 ) * 0.5f;
6379 : }
6380 :
6381 13563887 : fft( x, x + 1, sizeOfFft2, 2 );
6382 :
6383 5263553311 : for ( i = 0; i < length; i += 2 )
6384 : {
6385 5249989424 : x[i] *= s1;
6386 5249989424 : x[i + 1] *= s2;
6387 : }
6388 :
6389 13563887 : break;
6390 : }
6391 :
6392 27047633 : return;
6393 : }
6394 :
6395 :
6396 : #define WMC_TOOL_SKIP
6397 :
6398 : #define SCALEFACTOR8 ( 4 )
6399 : #define SCALEFACTOR64 ( 7 )
6400 : #define SCALEFACTORN2 ( 3 )
6401 :
6402 : #define SHC( x ) ( (Word16) x )
6403 : #define FFTC( x ) WORD322WORD16( (Word32) x )
6404 :
6405 : #define C81_FX ( FFTC( 0x5a82799a ) ) /* FL2WORD32( 7.071067811865475e-1) */
6406 : #define C82_FX ( FFTC( 0xa57d8666 ) ) /* FL2WORD32(-7.071067811865475e-1) */
6407 :
6408 : #define cplxMpy4_8_0( re, im, a, b, c, d ) \
6409 : re = L_shr( L_sub( Mpy_32_16( a, c ), Mpy_32_16( b, d ) ), 1 ); \
6410 : im = L_shr( L_add( Mpy_32_16( a, d ), Mpy_32_16( b, c ) ), 1 );
6411 :
6412 : #define cplxMpy4_8_1( re, im, a, b ) \
6413 : re = L_shr( a, 1 ); \
6414 : im = L_shr( b, 1 );
6415 :
6416 :
6417 : /**
6418 : * \brief Twiddle factors are unscaled
6419 : */
6420 : static const Word16 RotVector_256[2 * ( 256 - 32 )] = {
6421 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7ff6 ), SHC( 0xfcdc ), SHC( 0x7fd9 ), SHC( 0xf9b8 ), SHC( 0x7fa7 ), SHC( 0xf695 ),
6422 : SHC( 0x7f62 ), SHC( 0xf374 ), SHC( 0x7f0a ), SHC( 0xf055 ), SHC( 0x7e9d ), SHC( 0xed38 ), SHC( 0x7e1e ), SHC( 0xea1e ),
6423 : SHC( 0x7d8a ), SHC( 0xe707 ), SHC( 0x7ce4 ), SHC( 0xe3f4 ), SHC( 0x7c2a ), SHC( 0xe0e6 ), SHC( 0x7b5d ), SHC( 0xdddc ),
6424 : SHC( 0x7a7d ), SHC( 0xdad8 ), SHC( 0x798a ), SHC( 0xd7d9 ), SHC( 0x7885 ), SHC( 0xd4e1 ), SHC( 0x776c ), SHC( 0xd1ef ),
6425 : SHC( 0x7642 ), SHC( 0xcf04 ), SHC( 0x7505 ), SHC( 0xcc21 ), SHC( 0x73b6 ), SHC( 0xc946 ), SHC( 0x7255 ), SHC( 0xc673 ),
6426 : SHC( 0x70e3 ), SHC( 0xc3a9 ), SHC( 0x6f5f ), SHC( 0xc0e9 ), SHC( 0x6dca ), SHC( 0xbe32 ), SHC( 0x6c24 ), SHC( 0xbb85 ),
6427 : SHC( 0x6a6e ), SHC( 0xb8e3 ), SHC( 0x68a7 ), SHC( 0xb64c ), SHC( 0x66d0 ), SHC( 0xb3c0 ), SHC( 0x64e9 ), SHC( 0xb140 ),
6428 : SHC( 0x62f2 ), SHC( 0xaecc ), SHC( 0x60ec ), SHC( 0xac65 ), SHC( 0x5ed7 ), SHC( 0xaa0a ), SHC( 0x5cb4 ), SHC( 0xa7bd ),
6429 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7fd9 ), SHC( 0xf9b8 ), SHC( 0x7f62 ), SHC( 0xf374 ), SHC( 0x7e9d ), SHC( 0xed38 ),
6430 : SHC( 0x7d8a ), SHC( 0xe707 ), SHC( 0x7c2a ), SHC( 0xe0e6 ), SHC( 0x7a7d ), SHC( 0xdad8 ), SHC( 0x7885 ), SHC( 0xd4e1 ),
6431 : SHC( 0x7642 ), SHC( 0xcf04 ), SHC( 0x73b6 ), SHC( 0xc946 ), SHC( 0x70e3 ), SHC( 0xc3a9 ), SHC( 0x6dca ), SHC( 0xbe32 ),
6432 : SHC( 0x6a6e ), SHC( 0xb8e3 ), SHC( 0x66d0 ), SHC( 0xb3c0 ), SHC( 0x62f2 ), SHC( 0xaecc ), SHC( 0x5ed7 ), SHC( 0xaa0a ),
6433 : SHC( 0x5a82 ), SHC( 0xa57e ), SHC( 0x55f6 ), SHC( 0xa129 ), SHC( 0x5134 ), SHC( 0x9d0e ), SHC( 0x4c40 ), SHC( 0x9930 ),
6434 : SHC( 0x471d ), SHC( 0x9592 ), SHC( 0x41ce ), SHC( 0x9236 ), SHC( 0x3c57 ), SHC( 0x8f1d ), SHC( 0x36ba ), SHC( 0x8c4a ),
6435 : SHC( 0x30fc ), SHC( 0x89be ), SHC( 0x2b1f ), SHC( 0x877b ), SHC( 0x2528 ), SHC( 0x8583 ), SHC( 0x1f1a ), SHC( 0x83d6 ),
6436 : SHC( 0x18f9 ), SHC( 0x8276 ), SHC( 0x12c8 ), SHC( 0x8163 ), SHC( 0x0c8c ), SHC( 0x809e ), SHC( 0x0648 ), SHC( 0x8027 ),
6437 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7fa7 ), SHC( 0xf695 ), SHC( 0x7e9d ), SHC( 0xed38 ), SHC( 0x7ce4 ), SHC( 0xe3f4 ),
6438 : SHC( 0x7a7d ), SHC( 0xdad8 ), SHC( 0x776c ), SHC( 0xd1ef ), SHC( 0x73b6 ), SHC( 0xc946 ), SHC( 0x6f5f ), SHC( 0xc0e9 ),
6439 : SHC( 0x6a6e ), SHC( 0xb8e3 ), SHC( 0x64e9 ), SHC( 0xb140 ), SHC( 0x5ed7 ), SHC( 0xaa0a ), SHC( 0x5843 ), SHC( 0xa34c ),
6440 : SHC( 0x5134 ), SHC( 0x9d0e ), SHC( 0x49b4 ), SHC( 0x9759 ), SHC( 0x41ce ), SHC( 0x9236 ), SHC( 0x398d ), SHC( 0x8dab ),
6441 : SHC( 0x30fc ), SHC( 0x89be ), SHC( 0x2827 ), SHC( 0x8676 ), SHC( 0x1f1a ), SHC( 0x83d6 ), SHC( 0x15e2 ), SHC( 0x81e2 ),
6442 : SHC( 0x0c8c ), SHC( 0x809e ), SHC( 0x0324 ), SHC( 0x800a ), SHC( 0xf9b8 ), SHC( 0x8027 ), SHC( 0xf055 ), SHC( 0x80f6 ),
6443 : SHC( 0xe707 ), SHC( 0x8276 ), SHC( 0xdddc ), SHC( 0x84a3 ), SHC( 0xd4e1 ), SHC( 0x877b ), SHC( 0xcc21 ), SHC( 0x8afb ),
6444 : SHC( 0xc3a9 ), SHC( 0x8f1d ), SHC( 0xbb85 ), SHC( 0x93dc ), SHC( 0xb3c0 ), SHC( 0x9930 ), SHC( 0xac65 ), SHC( 0x9f14 ),
6445 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7f62 ), SHC( 0xf374 ), SHC( 0x7d8a ), SHC( 0xe707 ), SHC( 0x7a7d ), SHC( 0xdad8 ),
6446 : SHC( 0x7642 ), SHC( 0xcf04 ), SHC( 0x70e3 ), SHC( 0xc3a9 ), SHC( 0x6a6e ), SHC( 0xb8e3 ), SHC( 0x62f2 ), SHC( 0xaecc ),
6447 : SHC( 0x5a82 ), SHC( 0xa57e ), SHC( 0x5134 ), SHC( 0x9d0e ), SHC( 0x471d ), SHC( 0x9592 ), SHC( 0x3c57 ), SHC( 0x8f1d ),
6448 : SHC( 0x30fc ), SHC( 0x89be ), SHC( 0x2528 ), SHC( 0x8583 ), SHC( 0x18f9 ), SHC( 0x8276 ), SHC( 0x0c8c ), SHC( 0x809e ),
6449 : SHC( 0x0000 ), SHC( 0x8000 ), SHC( 0xf374 ), SHC( 0x809e ), SHC( 0xe707 ), SHC( 0x8276 ), SHC( 0xdad8 ), SHC( 0x8583 ),
6450 : SHC( 0xcf04 ), SHC( 0x89be ), SHC( 0xc3a9 ), SHC( 0x8f1d ), SHC( 0xb8e3 ), SHC( 0x9592 ), SHC( 0xaecc ), SHC( 0x9d0e ),
6451 : SHC( 0xa57e ), SHC( 0xa57e ), SHC( 0x9d0e ), SHC( 0xaecc ), SHC( 0x9592 ), SHC( 0xb8e3 ), SHC( 0x8f1d ), SHC( 0xc3a9 ),
6452 : SHC( 0x89be ), SHC( 0xcf04 ), SHC( 0x8583 ), SHC( 0xdad8 ), SHC( 0x8276 ), SHC( 0xe707 ), SHC( 0x809e ), SHC( 0xf374 ),
6453 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7f0a ), SHC( 0xf055 ), SHC( 0x7c2a ), SHC( 0xe0e6 ), SHC( 0x776c ), SHC( 0xd1ef ),
6454 : SHC( 0x70e3 ), SHC( 0xc3a9 ), SHC( 0x68a7 ), SHC( 0xb64c ), SHC( 0x5ed7 ), SHC( 0xaa0a ), SHC( 0x539b ), SHC( 0x9f14 ),
6455 : SHC( 0x471d ), SHC( 0x9592 ), SHC( 0x398d ), SHC( 0x8dab ), SHC( 0x2b1f ), SHC( 0x877b ), SHC( 0x1c0c ), SHC( 0x831c ),
6456 : SHC( 0x0c8c ), SHC( 0x809e ), SHC( 0xfcdc ), SHC( 0x800a ), SHC( 0xed38 ), SHC( 0x8163 ), SHC( 0xdddc ), SHC( 0x84a3 ),
6457 : SHC( 0xcf04 ), SHC( 0x89be ), SHC( 0xc0e9 ), SHC( 0x90a1 ), SHC( 0xb3c0 ), SHC( 0x9930 ), SHC( 0xa7bd ), SHC( 0xa34c ),
6458 : SHC( 0x9d0e ), SHC( 0xaecc ), SHC( 0x93dc ), SHC( 0xbb85 ), SHC( 0x8c4a ), SHC( 0xc946 ), SHC( 0x8676 ), SHC( 0xd7d9 ),
6459 : SHC( 0x8276 ), SHC( 0xe707 ), SHC( 0x8059 ), SHC( 0xf695 ), SHC( 0x8027 ), SHC( 0x0648 ), SHC( 0x81e2 ), SHC( 0x15e2 ),
6460 : SHC( 0x8583 ), SHC( 0x2528 ), SHC( 0x8afb ), SHC( 0x33df ), SHC( 0x9236 ), SHC( 0x41ce ), SHC( 0x9b17 ), SHC( 0x4ec0 ),
6461 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7e9d ), SHC( 0xed38 ), SHC( 0x7a7d ), SHC( 0xdad8 ), SHC( 0x73b6 ), SHC( 0xc946 ),
6462 : SHC( 0x6a6e ), SHC( 0xb8e3 ), SHC( 0x5ed7 ), SHC( 0xaa0a ), SHC( 0x5134 ), SHC( 0x9d0e ), SHC( 0x41ce ), SHC( 0x9236 ),
6463 : SHC( 0x30fc ), SHC( 0x89be ), SHC( 0x1f1a ), SHC( 0x83d6 ), SHC( 0x0c8c ), SHC( 0x809e ), SHC( 0xf9b8 ), SHC( 0x8027 ),
6464 : SHC( 0xe707 ), SHC( 0x8276 ), SHC( 0xd4e1 ), SHC( 0x877b ), SHC( 0xc3a9 ), SHC( 0x8f1d ), SHC( 0xb3c0 ), SHC( 0x9930 ),
6465 : SHC( 0xa57e ), SHC( 0xa57e ), SHC( 0x9930 ), SHC( 0xb3c0 ), SHC( 0x8f1d ), SHC( 0xc3a9 ), SHC( 0x877b ), SHC( 0xd4e1 ),
6466 : SHC( 0x8276 ), SHC( 0xe707 ), SHC( 0x8027 ), SHC( 0xf9b8 ), SHC( 0x809e ), SHC( 0x0c8c ), SHC( 0x83d6 ), SHC( 0x1f1a ),
6467 : SHC( 0x89be ), SHC( 0x30fc ), SHC( 0x9236 ), SHC( 0x41ce ), SHC( 0x9d0e ), SHC( 0x5134 ), SHC( 0xaa0a ), SHC( 0x5ed7 ),
6468 : SHC( 0xb8e3 ), SHC( 0x6a6e ), SHC( 0xc946 ), SHC( 0x73b6 ), SHC( 0xdad8 ), SHC( 0x7a7d ), SHC( 0xed38 ), SHC( 0x7e9d ),
6469 : SHC( 0x7fff ), SHC( 0x0000 ), SHC( 0x7e1e ), SHC( 0xea1e ), SHC( 0x7885 ), SHC( 0xd4e1 ), SHC( 0x6f5f ), SHC( 0xc0e9 ),
6470 : SHC( 0x62f2 ), SHC( 0xaecc ), SHC( 0x539b ), SHC( 0x9f14 ), SHC( 0x41ce ), SHC( 0x9236 ), SHC( 0x2e11 ), SHC( 0x8894 ),
6471 : SHC( 0x18f9 ), SHC( 0x8276 ), SHC( 0x0324 ), SHC( 0x800a ), SHC( 0xed38 ), SHC( 0x8163 ), SHC( 0xd7d9 ), SHC( 0x8676 ),
6472 : SHC( 0xc3a9 ), SHC( 0x8f1d ), SHC( 0xb140 ), SHC( 0x9b17 ), SHC( 0xa129 ), SHC( 0xaa0a ), SHC( 0x93dc ), SHC( 0xbb85 ),
6473 : SHC( 0x89be ), SHC( 0xcf04 ), SHC( 0x831c ), SHC( 0xe3f4 ), SHC( 0x8027 ), SHC( 0xf9b8 ), SHC( 0x80f6 ), SHC( 0x0fab ),
6474 : SHC( 0x8583 ), SHC( 0x2528 ), SHC( 0x8dab ), SHC( 0x398d ), SHC( 0x9930 ), SHC( 0x4c40 ), SHC( 0xa7bd ), SHC( 0x5cb4 ),
6475 : SHC( 0xb8e3 ), SHC( 0x6a6e ), SHC( 0xcc21 ), SHC( 0x7505 ), SHC( 0xe0e6 ), SHC( 0x7c2a ), SHC( 0xf695 ), SHC( 0x7fa7 ),
6476 : SHC( 0x0c8c ), SHC( 0x7f62 ), SHC( 0x2224 ), SHC( 0x7b5d ), SHC( 0x36ba ), SHC( 0x73b6 ), SHC( 0x49b4 ), SHC( 0x68a7 )
6477 : };
6478 :
6479 : /*-----------------------------------------------------------------*
6480 : * BASOP_fft8()
6481 : *
6482 : * Function performs a complex 8-point FFT
6483 : * The FFT is performed inplace. The result of the FFT
6484 : * is scaled by SCALEFACTOR8 bits.
6485 : *
6486 : * WOPS with 32x16 bit multiplications: 108 cycles
6487 : *-----------------------------------------------------------------*/
6488 :
6489 18625168 : static void BASOP_fft8(
6490 : Word32 *re,
6491 : Word32 *im,
6492 : Word16 s )
6493 : {
6494 : Word32 x00, x01, x02, x03, x04, x05, x06, x07;
6495 : Word32 x08, x09, x10, x11, x12, x13, x14, x15;
6496 : Word32 t00, t01, t02, t03, t04, t05, t06, t07;
6497 : Word32 t08, t09, t10, t11, t12, t13, t14, t15;
6498 : Word32 s00, s01, s02, s03, s04, s05, s06, s07;
6499 : Word32 s08, s09, s10, s11, s12, s13, s14, s15;
6500 :
6501 :
6502 : /* Pre-additions */
6503 :
6504 18625168 : x00 = L_shr( re[s * 0], SCALEFACTOR8 );
6505 18625168 : x01 = L_shr( im[s * 0], SCALEFACTOR8 );
6506 18625168 : x02 = L_shr( re[s * 1], SCALEFACTOR8 );
6507 18625168 : x03 = L_shr( im[s * 1], SCALEFACTOR8 );
6508 18625168 : x04 = L_shr( re[s * 2], SCALEFACTOR8 );
6509 18625168 : x05 = L_shr( im[s * 2], SCALEFACTOR8 );
6510 18625168 : x06 = L_shr( re[s * 3], SCALEFACTOR8 );
6511 18625168 : x07 = L_shr( im[s * 3], SCALEFACTOR8 );
6512 18625168 : x08 = L_shr( re[s * 4], SCALEFACTOR8 );
6513 18625168 : x09 = L_shr( im[s * 4], SCALEFACTOR8 );
6514 18625168 : x10 = L_shr( re[s * 5], SCALEFACTOR8 );
6515 18625168 : x11 = L_shr( im[s * 5], SCALEFACTOR8 );
6516 18625168 : x12 = L_shr( re[s * 6], SCALEFACTOR8 );
6517 18625168 : x13 = L_shr( im[s * 6], SCALEFACTOR8 );
6518 18625168 : x14 = L_shr( re[s * 7], SCALEFACTOR8 );
6519 18625168 : x15 = L_shr( im[s * 7], SCALEFACTOR8 );
6520 :
6521 18625168 : t00 = L_add( x00, x08 );
6522 18625168 : t02 = L_sub( x00, x08 );
6523 18625168 : t01 = L_add( x01, x09 );
6524 18625168 : t03 = L_sub( x01, x09 );
6525 18625168 : t04 = L_add( x02, x10 );
6526 18625168 : t06 = L_sub( x02, x10 );
6527 18625168 : t05 = L_add( x03, x11 );
6528 18625168 : t07 = L_sub( x03, x11 );
6529 18625168 : t08 = L_add( x04, x12 );
6530 18625168 : t10 = L_sub( x04, x12 );
6531 18625168 : t09 = L_add( x05, x13 );
6532 18625168 : t11 = L_sub( x05, x13 );
6533 18625168 : t12 = L_add( x06, x14 );
6534 18625168 : t14 = L_sub( x06, x14 );
6535 18625168 : t13 = L_add( x07, x15 );
6536 18625168 : t15 = L_sub( x07, x15 );
6537 :
6538 : /* Pre-additions and core multiplications */
6539 :
6540 18625168 : s00 = L_add( t00, t08 );
6541 18625168 : s04 = L_sub( t00, t08 );
6542 18625168 : s01 = L_add( t01, t09 );
6543 18625168 : s05 = L_sub( t01, t09 );
6544 18625168 : s08 = L_sub( t02, t11 );
6545 18625168 : s10 = L_add( t02, t11 );
6546 18625168 : s09 = L_add( t03, t10 );
6547 18625168 : s11 = L_sub( t03, t10 );
6548 18625168 : s02 = L_add( t04, t12 );
6549 18625168 : s07 = L_sub( t04, t12 );
6550 18625168 : s03 = L_add( t05, t13 );
6551 18625168 : s06 = L_sub( t13, t05 );
6552 :
6553 18625168 : t01 = L_add( t06, t14 );
6554 18625168 : t02 = L_sub( t06, t14 );
6555 18625168 : t00 = L_add( t07, t15 );
6556 18625168 : t03 = L_sub( t07, t15 );
6557 :
6558 18625168 : s12 = Mpy_32_16( L_add( t00, t02 ), C81_FX );
6559 18625168 : s14 = Mpy_32_16( L_sub( t00, t02 ), C81_FX );
6560 18625168 : s13 = Mpy_32_16( L_sub( t03, t01 ), C81_FX );
6561 18625168 : s15 = Mpy_32_16( L_add( t01, t03 ), C82_FX );
6562 :
6563 : /* Post-additions */
6564 :
6565 18625168 : re[s * 0] = L_add( s00, s02 );
6566 18625168 : move32();
6567 18625168 : re[s * 4] = L_sub( s00, s02 );
6568 18625168 : move32();
6569 18625168 : im[s * 0] = L_add( s01, s03 );
6570 18625168 : move32();
6571 18625168 : im[s * 4] = L_sub( s01, s03 );
6572 18625168 : move32();
6573 18625168 : re[s * 2] = L_sub( s04, s06 );
6574 18625168 : move32();
6575 18625168 : re[s * 6] = L_add( s04, s06 );
6576 18625168 : move32();
6577 18625168 : im[s * 2] = L_sub( s05, s07 );
6578 18625168 : move32();
6579 18625168 : im[s * 6] = L_add( s05, s07 );
6580 18625168 : move32();
6581 18625168 : re[s * 3] = L_add( s08, s14 );
6582 18625168 : move32();
6583 18625168 : re[s * 7] = L_sub( s08, s14 );
6584 18625168 : move32();
6585 18625168 : im[s * 3] = L_add( s09, s15 );
6586 18625168 : move32();
6587 18625168 : im[s * 7] = L_sub( s09, s15 );
6588 18625168 : move32();
6589 18625168 : re[s * 1] = L_add( s10, s12 );
6590 18625168 : move32();
6591 18625168 : re[s * 5] = L_sub( s10, s12 );
6592 18625168 : move32();
6593 18625168 : im[s * 1] = L_add( s11, s13 );
6594 18625168 : move32();
6595 18625168 : im[s * 5] = L_sub( s11, s13 );
6596 18625168 : move32();
6597 :
6598 18625168 : return;
6599 : }
6600 :
6601 :
6602 : /*-----------------------------------------------------------------*
6603 : * fftN2()
6604 : *
6605 : * Combined FFT
6606 : *-----------------------------------------------------------------*/
6607 :
6608 2328146 : static void BASOP_fftN2(
6609 : Word32 *re, /* i/o: real part */
6610 : Word32 *im, /* i/o: imag part */
6611 : const Word16 *W, /* i : rotation factor */
6612 : Word16 dim1, /* i : length of fft1 */
6613 : Word16 dim2, /* i : length of fft2 */
6614 : Word16 sx, /* i : stride real and imag part */
6615 : Word16 sc, /* i : stride phase rotation coefficients */
6616 : Word32 *x, /* tmp: 32-bit workbuffer */
6617 : Word16 Woff /* i : offset for addressing the rotation vector table */
6618 : )
6619 : {
6620 : Word16 i, j;
6621 : Word32 x00, x01, x02, x03, x04, x05, x06, x07, x08, x09, x10, x11, x12, x13, x14, x15;
6622 : Word32 t00, t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15;
6623 : Word32 s00, s01, s02, s03, s04, s05, s06, s07, s08, s09, s10, s11, s12, s13, s14, s15;
6624 :
6625 20953314 : FOR( i = 0; i < dim2; i++ )
6626 : {
6627 167626512 : FOR( j = 0; j < dim1; j++ )
6628 : {
6629 149001344 : x[2 * i * dim1 + 2 * j] = re[sx * i + sx * j * dim2];
6630 149001344 : move32();
6631 149001344 : x[2 * i * dim1 + 2 * j + 1] = im[sx * i + sx * j * dim2];
6632 149001344 : move32();
6633 : }
6634 : }
6635 :
6636 : /* dim1 == 8 */
6637 20953314 : FOR( i = 0; i < dim2; i++ )
6638 : {
6639 18625168 : BASOP_fft8( &x[i * 2 * dim1], &x[i * 2 * dim1 + 1], 2 );
6640 : }
6641 :
6642 : /* dim2 == 8 */
6643 20953314 : FOR( i = 0; i < dim1; i++ )
6644 : {
6645 18625168 : cplxMpy4_8_1( x00, x01, x[2 * i + 2 * 0 * dim1], x[2 * i + 2 * 0 * dim1 + 1] );
6646 :
6647 18625168 : IF( i == 0 )
6648 : {
6649 2328146 : cplxMpy4_8_1( x02, x03, x[2 * i + 2 * 1 * dim1], x[2 * i + 2 * 1 * dim1 + 1] );
6650 2328146 : cplxMpy4_8_1( x04, x05, x[2 * i + 2 * 2 * dim1], x[2 * i + 2 * 2 * dim1 + 1] );
6651 2328146 : cplxMpy4_8_1( x06, x07, x[2 * i + 2 * 3 * dim1], x[2 * i + 2 * 3 * dim1 + 1] );
6652 2328146 : cplxMpy4_8_1( x08, x09, x[2 * i + 2 * 4 * dim1], x[2 * i + 2 * 4 * dim1 + 1] );
6653 2328146 : cplxMpy4_8_1( x10, x11, x[2 * i + 2 * 5 * dim1], x[2 * i + 2 * 5 * dim1 + 1] );
6654 2328146 : cplxMpy4_8_1( x12, x13, x[2 * i + 2 * 6 * dim1], x[2 * i + 2 * 6 * dim1 + 1] );
6655 2328146 : cplxMpy4_8_1( x14, x15, x[2 * i + 2 * 7 * dim1], x[2 * i + 2 * 7 * dim1 + 1] );
6656 : }
6657 : ELSE
6658 : {
6659 16297022 : cplxMpy4_8_0( x02, x03, x[2 * i + 2 * 1 * dim1], x[2 * i + 2 * 1 * dim1 + 1], W[sc * i + sc * 1 * dim1 - Woff], W[sc * i + sc * 1 * dim1 + 1 - Woff] );
6660 16297022 : cplxMpy4_8_0( x04, x05, x[2 * i + 2 * 2 * dim1], x[2 * i + 2 * 2 * dim1 + 1], W[sc * i + sc * 2 * dim1 - Woff], W[sc * i + sc * 2 * dim1 + 1 - Woff] );
6661 16297022 : cplxMpy4_8_0( x06, x07, x[2 * i + 2 * 3 * dim1], x[2 * i + 2 * 3 * dim1 + 1], W[sc * i + sc * 3 * dim1 - Woff], W[sc * i + sc * 3 * dim1 + 1 - Woff] );
6662 16297022 : cplxMpy4_8_0( x08, x09, x[2 * i + 2 * 4 * dim1], x[2 * i + 2 * 4 * dim1 + 1], W[sc * i + sc * 4 * dim1 - Woff], W[sc * i + sc * 4 * dim1 + 1 - Woff] );
6663 16297022 : cplxMpy4_8_0( x10, x11, x[2 * i + 2 * 5 * dim1], x[2 * i + 2 * 5 * dim1 + 1], W[sc * i + sc * 5 * dim1 - Woff], W[sc * i + sc * 5 * dim1 + 1 - Woff] );
6664 16297022 : cplxMpy4_8_0( x12, x13, x[2 * i + 2 * 6 * dim1], x[2 * i + 2 * 6 * dim1 + 1], W[sc * i + sc * 6 * dim1 - Woff], W[sc * i + sc * 6 * dim1 + 1 - Woff] );
6665 16297022 : cplxMpy4_8_0( x14, x15, x[2 * i + 2 * 7 * dim1], x[2 * i + 2 * 7 * dim1 + 1], W[sc * i + sc * 7 * dim1 - Woff], W[sc * i + sc * 7 * dim1 + 1 - Woff] );
6666 : }
6667 18625168 : t00 = L_shr( L_add( x00, x08 ), SCALEFACTORN2 - 1 );
6668 18625168 : t02 = L_shr( L_sub( x00, x08 ), SCALEFACTORN2 - 1 );
6669 18625168 : t01 = L_shr( L_add( x01, x09 ), SCALEFACTORN2 - 1 );
6670 18625168 : t03 = L_shr( L_sub( x01, x09 ), SCALEFACTORN2 - 1 );
6671 18625168 : t04 = L_shr( L_add( x02, x10 ), SCALEFACTORN2 - 1 );
6672 18625168 : t06 = L_sub( x02, x10 );
6673 18625168 : t05 = L_shr( L_add( x03, x11 ), SCALEFACTORN2 - 1 );
6674 18625168 : t07 = L_sub( x03, x11 );
6675 18625168 : t08 = L_shr( L_add( x04, x12 ), SCALEFACTORN2 - 1 );
6676 18625168 : t10 = L_shr( L_sub( x04, x12 ), SCALEFACTORN2 - 1 );
6677 18625168 : t09 = L_shr( L_add( x05, x13 ), SCALEFACTORN2 - 1 );
6678 18625168 : t11 = L_shr( L_sub( x05, x13 ), SCALEFACTORN2 - 1 );
6679 18625168 : t12 = L_shr( L_add( x06, x14 ), SCALEFACTORN2 - 1 );
6680 18625168 : t14 = L_sub( x06, x14 );
6681 18625168 : t13 = L_shr( L_add( x07, x15 ), SCALEFACTORN2 - 1 );
6682 18625168 : t15 = L_sub( x07, x15 );
6683 :
6684 18625168 : s00 = L_add( t00, t08 );
6685 18625168 : s04 = L_sub( t00, t08 );
6686 18625168 : s01 = L_add( t01, t09 );
6687 18625168 : s05 = L_sub( t01, t09 );
6688 18625168 : s08 = L_sub( t02, t11 );
6689 18625168 : s10 = L_add( t02, t11 );
6690 18625168 : s09 = L_add( t03, t10 );
6691 18625168 : s11 = L_sub( t03, t10 );
6692 18625168 : s02 = L_add( t04, t12 );
6693 18625168 : s07 = L_sub( t04, t12 );
6694 18625168 : s03 = L_add( t05, t13 );
6695 18625168 : s06 = L_sub( t13, t05 );
6696 :
6697 18625168 : t01 = L_shr( L_add( t06, t14 ), SCALEFACTORN2 - 1 );
6698 18625168 : t02 = L_shr( L_sub( t06, t14 ), SCALEFACTORN2 - 1 );
6699 18625168 : t00 = L_shr( L_add( t07, t15 ), SCALEFACTORN2 - 1 );
6700 18625168 : t03 = L_shr( L_sub( t07, t15 ), SCALEFACTORN2 - 1 );
6701 :
6702 18625168 : s12 = Mpy_32_16( L_add( t00, t02 ), C81_FX );
6703 18625168 : s14 = Mpy_32_16( L_sub( t00, t02 ), C81_FX );
6704 18625168 : s13 = Mpy_32_16( L_sub( t03, t01 ), C81_FX );
6705 18625168 : s15 = Mpy_32_16( L_add( t01, t03 ), C82_FX );
6706 :
6707 18625168 : re[sx * i + sx * 0 * dim1] = L_add( s00, s02 );
6708 18625168 : move32();
6709 18625168 : im[sx * i + sx * 0 * dim1] = L_add( s01, s03 );
6710 18625168 : move32();
6711 18625168 : re[sx * i + sx * 1 * dim1] = L_add( s10, s12 );
6712 18625168 : move32();
6713 18625168 : im[sx * i + sx * 1 * dim1] = L_add( s11, s13 );
6714 18625168 : move32();
6715 18625168 : re[sx * i + sx * 2 * dim1] = L_sub( s04, s06 );
6716 18625168 : move32();
6717 18625168 : im[sx * i + sx * 2 * dim1] = L_sub( s05, s07 );
6718 18625168 : move32();
6719 18625168 : re[sx * i + sx * 3 * dim1] = L_add( s08, s14 );
6720 18625168 : move32();
6721 18625168 : im[sx * i + sx * 3 * dim1] = L_add( s09, s15 );
6722 18625168 : move32();
6723 18625168 : re[sx * i + sx * 4 * dim1] = L_sub( s00, s02 );
6724 18625168 : move32();
6725 18625168 : im[sx * i + sx * 4 * dim1] = L_sub( s01, s03 );
6726 18625168 : move32();
6727 18625168 : re[sx * i + sx * 5 * dim1] = L_sub( s10, s12 );
6728 18625168 : move32();
6729 18625168 : im[sx * i + sx * 5 * dim1] = L_sub( s11, s13 );
6730 18625168 : move32();
6731 18625168 : re[sx * i + sx * 6 * dim1] = L_add( s04, s06 );
6732 18625168 : move32();
6733 18625168 : im[sx * i + sx * 6 * dim1] = L_add( s05, s07 );
6734 18625168 : move32();
6735 18625168 : re[sx * i + sx * 7 * dim1] = L_sub( s08, s14 );
6736 18625168 : move32();
6737 18625168 : im[sx * i + sx * 7 * dim1] = L_sub( s09, s15 );
6738 18625168 : move32();
6739 : }
6740 :
6741 2328146 : return;
6742 : }
6743 :
6744 :
6745 : /*-----------------------------------------------------------------*
6746 : * BASOP_cfft()
6747 : *
6748 : * Complex valued FFT
6749 : *-----------------------------------------------------------------*/
6750 :
6751 2328146 : void BASOP_cfft(
6752 : Word32 *re, /* i/o: real part */
6753 : Word32 *im, /* i/o: imag part */
6754 : Word16 s, /* i : stride real and imag part */
6755 : Word16 *scale /* i : scalefactor */
6756 : )
6757 : {
6758 : Word32 x[2 * 64];
6759 :
6760 : /* FFT for len = FDNS_NPTS */
6761 2328146 : BASOP_fftN2( re, im, RotVector_256, 8, 8, s, 8, x, 64 );
6762 2328146 : s = add( *scale, SCALEFACTOR64 );
6763 :
6764 2328146 : *scale = s;
6765 2328146 : move16();
6766 :
6767 2328146 : return;
6768 : }
6769 :
6770 : #undef WMC_TOOL_SKIP
|
