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 <stdint.h>
38 : #include "options.h"
39 : #include <assert.h>
40 : #include "prot.h"
41 : #include "ivas_cnst.h"
42 : #include "wmc_auto.h"
43 :
44 : #if __STDC_VERSION__ >= 199901L
45 : #if defined __ICL
46 : #define restrict __restrict
47 : #endif
48 : #else
49 : #define restrict
50 : #endif
51 :
52 :
53 : static void fft8( float *vec );
54 : static void fft10( float *vec );
55 : static void fft16( float *vec );
56 : static void fft20( float *vec );
57 : static void fft30( float *vec );
58 : static void fft5s( float *x, const int16_t stride );
59 :
60 :
61 : #define COS_PI_DIV8 9.238795325112867e-1f
62 : #define COS_3PI_DIV8 3.826834323650898e-1f
63 : #define SQRT2PLUS1 2.414213562373095f
64 : #define SQRT2MINUS1 4.142135623730952e-1f
65 :
66 :
67 : /*******************************************************************************
68 : Functionname: fft8
69 : *******************************************************************************
70 :
71 : Description: 8-point FFT. Complex-valued input takes 52 real additions
72 : and 4 real multiplications.
73 :
74 : Arguments: vec - pointer to data (interleaved real / imaginary parts)
75 :
76 : Return: none
77 :
78 : *******************************************************************************/
79 230454174 : static void fft8( float *restrict vec )
80 : {
81 : float temp1[16];
82 : float temp2[16];
83 :
84 :
85 : /* Pre-additions */
86 230454174 : temp1[0] = vec[0] + vec[8];
87 230454174 : temp1[2] = vec[0] - vec[8];
88 230454174 : temp1[1] = vec[1] + vec[9];
89 230454174 : temp1[3] = vec[1] - vec[9];
90 230454174 : temp1[4] = vec[2] + vec[10];
91 230454174 : temp1[6] = vec[2] - vec[10];
92 230454174 : temp1[5] = vec[3] + vec[11];
93 230454174 : temp1[7] = vec[3] - vec[11];
94 230454174 : temp1[8] = vec[4] + vec[12];
95 230454174 : temp1[10] = vec[4] - vec[12];
96 230454174 : temp1[9] = vec[5] + vec[13];
97 230454174 : temp1[11] = vec[5] - vec[13];
98 230454174 : temp1[12] = vec[6] + vec[14];
99 230454174 : temp1[14] = vec[6] - vec[14];
100 230454174 : temp1[13] = vec[7] + vec[15];
101 230454174 : temp1[15] = vec[7] - vec[15];
102 :
103 : /* Pre-additions and core multiplications */
104 230454174 : temp2[0] = temp1[0] + temp1[8];
105 230454174 : temp2[4] = temp1[0] - temp1[8];
106 230454174 : temp2[1] = temp1[1] + temp1[9];
107 230454174 : temp2[5] = temp1[1] - temp1[9];
108 230454174 : temp2[8] = temp1[2] - temp1[11];
109 230454174 : temp2[10] = temp1[2] + temp1[11];
110 230454174 : temp2[9] = temp1[3] + temp1[10];
111 230454174 : temp2[11] = temp1[3] - temp1[10];
112 230454174 : temp2[2] = temp1[4] + temp1[12];
113 230454174 : temp2[7] = temp1[4] - temp1[12];
114 230454174 : temp2[3] = temp1[5] + temp1[13];
115 230454174 : temp2[6] = temp1[13] - temp1[5];
116 :
117 230454174 : temp1[1] = temp1[6] + temp1[14];
118 230454174 : temp1[2] = temp1[6] - temp1[14];
119 230454174 : temp1[0] = temp1[7] + temp1[15];
120 230454174 : temp1[3] = temp1[7] - temp1[15];
121 :
122 230454174 : temp2[12] = ( temp1[0] + temp1[2] ) * INV_SQRT2;
123 230454174 : temp2[14] = ( temp1[0] - temp1[2] ) * INV_SQRT2;
124 230454174 : temp2[13] = ( temp1[3] - temp1[1] ) * INV_SQRT2;
125 230454174 : temp2[15] = ( temp1[1] + temp1[3] ) * -INV_SQRT2;
126 :
127 : /* Post-additions */
128 230454174 : vec[0] = temp2[0] + temp2[2];
129 230454174 : vec[8] = temp2[0] - temp2[2];
130 230454174 : vec[1] = temp2[1] + temp2[3];
131 230454174 : vec[9] = temp2[1] - temp2[3];
132 230454174 : vec[4] = temp2[4] - temp2[6];
133 230454174 : vec[12] = temp2[4] + temp2[6];
134 230454174 : vec[5] = temp2[5] - temp2[7];
135 230454174 : vec[13] = temp2[5] + temp2[7];
136 230454174 : vec[6] = temp2[8] + temp2[14];
137 230454174 : vec[14] = temp2[8] - temp2[14];
138 230454174 : vec[7] = temp2[9] + temp2[15];
139 230454174 : vec[15] = temp2[9] - temp2[15];
140 230454174 : vec[2] = temp2[10] + temp2[12];
141 230454174 : vec[10] = temp2[10] - temp2[12];
142 230454174 : vec[3] = temp2[11] + temp2[13];
143 230454174 : vec[11] = temp2[11] - temp2[13];
144 :
145 230454174 : return;
146 : }
147 :
148 :
149 : /*******************************************************************************
150 : Functionname: fft16
151 : *******************************************************************************
152 :
153 : Description: 16-point FFT. Complex-valued input takes 144 real additions and
154 : 24 real multiplications.
155 :
156 : Arguments: vec - pointer to data (interleaved real / imaginary parts)
157 :
158 : Return: none
159 :
160 : *******************************************************************************/
161 : /* fast implementation, completely unrolled and inlined */
162 303716 : static void fft16( float *restrict vec )
163 : {
164 : float temp10, temp11, temp12, temp13, temp14, temp15, temp16, temp17,
165 : temp18, temp19, temp110, temp111, temp112, temp113, temp114, temp115;
166 : float temp20, temp21, temp22, temp23, temp24, temp25, temp26, temp27,
167 : temp28, temp29, temp210, temp211, temp212, temp213, temp214, temp215;
168 : float vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7,
169 : vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
170 :
171 :
172 : /* even */
173 303716 : vec0 = vec[0] + vec[16];
174 303716 : vec1 = vec[1] + vec[17];
175 303716 : vec2 = vec[2] + vec[18];
176 303716 : vec3 = vec[3] + vec[19];
177 303716 : vec4 = vec[4] + vec[20];
178 303716 : vec5 = vec[5] + vec[21];
179 303716 : vec6 = vec[6] + vec[22];
180 303716 : vec7 = vec[7] + vec[23];
181 303716 : vec8 = vec[8] + vec[24];
182 303716 : vec9 = vec[9] + vec[25];
183 303716 : vec10 = vec[10] + vec[26];
184 303716 : vec11 = vec[11] + vec[27];
185 303716 : vec12 = vec[12] + vec[28];
186 303716 : vec13 = vec[13] + vec[29];
187 303716 : vec14 = vec[14] + vec[30];
188 303716 : vec15 = vec[15] + vec[31];
189 :
190 : /* Pre-additions */
191 303716 : temp10 = vec0 + vec8;
192 303716 : temp12 = vec0 - vec8;
193 303716 : temp11 = vec1 + vec9;
194 303716 : temp13 = vec1 - vec9;
195 303716 : temp14 = vec2 + vec10;
196 303716 : temp16 = vec2 - vec10;
197 303716 : temp15 = vec3 + vec11;
198 303716 : temp17 = vec3 - vec11;
199 303716 : temp18 = vec4 + vec12;
200 303716 : temp110 = vec4 - vec12;
201 303716 : temp19 = vec5 + vec13;
202 303716 : temp111 = vec5 - vec13;
203 303716 : temp112 = vec6 + vec14;
204 303716 : temp114 = vec6 - vec14;
205 303716 : temp113 = vec7 + vec15;
206 303716 : temp115 = vec7 - vec15;
207 :
208 : /* Pre-additions and core multiplications */
209 303716 : temp20 = temp10 + temp18;
210 303716 : temp24 = temp10 - temp18;
211 303716 : temp21 = temp11 + temp19;
212 303716 : temp25 = temp11 - temp19;
213 303716 : temp28 = temp12 - temp111;
214 303716 : temp210 = temp12 + temp111;
215 303716 : temp29 = temp13 + temp110;
216 303716 : temp211 = temp13 - temp110;
217 303716 : temp22 = temp14 + temp112;
218 303716 : temp27 = temp14 - temp112;
219 303716 : temp23 = temp15 + temp113;
220 303716 : temp26 = temp113 - temp15;
221 :
222 303716 : temp11 = temp16 + temp114;
223 303716 : temp12 = temp16 - temp114;
224 303716 : temp10 = temp17 + temp115;
225 303716 : temp13 = temp17 - temp115;
226 :
227 303716 : temp212 = ( temp10 + temp12 ) * INV_SQRT2;
228 303716 : temp214 = ( temp10 - temp12 ) * INV_SQRT2;
229 303716 : temp213 = ( temp13 - temp11 ) * INV_SQRT2;
230 303716 : temp215 = ( temp11 + temp13 ) * -INV_SQRT2;
231 :
232 :
233 : /* odd */
234 303716 : vec0 = vec[0] - vec[16];
235 303716 : vec1 = vec[1] - vec[17];
236 303716 : vec2 = vec[2] - vec[18];
237 303716 : vec3 = vec[3] - vec[19];
238 303716 : vec4 = vec[4] - vec[20];
239 303716 : vec5 = vec[5] - vec[21];
240 303716 : vec6 = vec[6] - vec[22];
241 303716 : vec7 = vec[7] - vec[23];
242 303716 : vec8 = vec[8] - vec[24];
243 303716 : vec9 = vec[9] - vec[25];
244 303716 : vec10 = vec[10] - vec[26];
245 303716 : vec11 = vec[11] - vec[27];
246 303716 : vec12 = vec[12] - vec[28];
247 303716 : vec13 = vec[13] - vec[29];
248 303716 : vec14 = vec[14] - vec[30];
249 303716 : vec15 = vec[15] - vec[31];
250 :
251 : /* Pre-additions and core multiplications */
252 303716 : temp19 = ( vec2 + vec14 ) * -COS_3PI_DIV8;
253 303716 : temp110 = ( vec2 - vec14 ) * COS_PI_DIV8;
254 303716 : temp18 = ( vec3 + vec15 ) * COS_3PI_DIV8;
255 303716 : temp111 = ( vec3 - vec15 ) * COS_PI_DIV8;
256 303716 : temp15 = ( vec4 + vec12 ) * -INV_SQRT2;
257 303716 : temp16 = ( vec4 - vec12 ) * INV_SQRT2;
258 303716 : temp14 = ( vec5 + vec13 ) * INV_SQRT2;
259 303716 : temp17 = ( vec5 - vec13 ) * INV_SQRT2;
260 303716 : temp113 = ( vec6 + vec10 ) * -COS_PI_DIV8;
261 303716 : temp114 = ( vec6 - vec10 ) * COS_3PI_DIV8;
262 303716 : temp112 = ( vec7 + vec11 ) * COS_PI_DIV8;
263 303716 : temp115 = ( vec7 - vec11 ) * COS_3PI_DIV8;
264 :
265 : /* Core multiplications */
266 303716 : vec2 = temp18 * SQRT2PLUS1 - temp112 * SQRT2MINUS1;
267 303716 : vec3 = temp19 * SQRT2PLUS1 - temp113 * SQRT2MINUS1;
268 303716 : vec4 = temp110 * SQRT2MINUS1 - temp114 * SQRT2PLUS1;
269 303716 : vec5 = temp111 * SQRT2MINUS1 - temp115 * SQRT2PLUS1;
270 :
271 : /* Post-additions */
272 303716 : temp18 += temp112;
273 303716 : temp19 += temp113;
274 303716 : temp110 += temp114;
275 303716 : temp111 += temp115;
276 :
277 303716 : vec6 = vec0 + temp14;
278 303716 : vec10 = vec0 - temp14;
279 303716 : vec7 = vec1 + temp15;
280 303716 : vec11 = vec1 - temp15;
281 :
282 303716 : vec12 = temp16 - vec9;
283 303716 : vec14 = temp16 + vec9;
284 303716 : vec13 = vec8 + temp17;
285 303716 : vec15 = vec8 - temp17;
286 :
287 303716 : temp10 = vec6 - vec14;
288 303716 : temp12 = vec6 + vec14;
289 303716 : temp11 = vec7 + vec15;
290 303716 : temp13 = vec7 - vec15;
291 303716 : temp14 = vec10 + vec12;
292 303716 : temp16 = vec10 - vec12;
293 303716 : temp15 = vec11 + vec13;
294 303716 : temp17 = vec11 - vec13;
295 :
296 303716 : vec10 = temp18 + temp110;
297 303716 : temp110 = temp18 - temp110;
298 303716 : vec11 = temp19 + temp111;
299 303716 : temp111 = temp19 - temp111;
300 :
301 303716 : temp112 = vec2 + vec4;
302 303716 : temp114 = vec2 - vec4;
303 303716 : temp113 = vec3 + vec5;
304 303716 : temp115 = vec3 - vec5;
305 :
306 :
307 : /* Post-additions */
308 303716 : *vec++ = temp20 + temp22;
309 303716 : *vec++ = temp21 + temp23;
310 303716 : *vec++ = temp12 + vec10;
311 303716 : *vec++ = temp13 + vec11;
312 303716 : *vec++ = temp210 + temp212;
313 303716 : *vec++ = temp211 + temp213;
314 303716 : *vec++ = temp10 + temp112;
315 303716 : *vec++ = temp11 + temp113;
316 303716 : *vec++ = temp24 - temp26;
317 303716 : *vec++ = temp25 - temp27;
318 303716 : *vec++ = temp16 + temp114;
319 303716 : *vec++ = temp17 + temp115;
320 303716 : *vec++ = temp28 + temp214;
321 303716 : *vec++ = temp29 + temp215;
322 303716 : *vec++ = temp14 + temp110;
323 303716 : *vec++ = temp15 + temp111;
324 303716 : *vec++ = temp20 - temp22;
325 303716 : *vec++ = temp21 - temp23;
326 303716 : *vec++ = temp12 - vec10;
327 303716 : *vec++ = temp13 - vec11;
328 303716 : *vec++ = temp210 - temp212;
329 303716 : *vec++ = temp211 - temp213;
330 303716 : *vec++ = temp10 - temp112;
331 303716 : *vec++ = temp11 - temp113;
332 303716 : *vec++ = temp24 + temp26;
333 303716 : *vec++ = temp25 + temp27;
334 303716 : *vec++ = temp16 - temp114;
335 303716 : *vec++ = temp17 - temp115;
336 303716 : *vec++ = temp28 - temp214;
337 303716 : *vec++ = temp29 - temp215;
338 303716 : *vec++ = temp14 - temp110;
339 303716 : *vec++ = temp15 - temp111;
340 :
341 303716 : return;
342 : }
343 :
344 :
345 : /*******************************************************************************
346 : Functionname: fft15
347 : *******************************************************************************
348 :
349 : Description: 15-point FFT. Complex-valued input takes 176 real additions
350 : and 34 real multiplications.
351 :
352 : Arguments: vec - pointer to data (interleaved real / imaginary parts)
353 :
354 : Return: none
355 :
356 : *******************************************************************************/
357 5799750584 : static void fft15( float *restrict vec )
358 : {
359 :
360 : float r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17;
361 : float i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17;
362 : float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9,
363 : tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17, tmp18, tmp19,
364 : tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27, tmp28, tmp29;
365 :
366 :
367 : /* Pre-additions real part */
368 5799750584 : r1 = vec[2] + vec[8];
369 5799750584 : r2 = vec[2] - vec[8];
370 5799750584 : r3 = vec[4] + vec[16];
371 5799750584 : r4 = vec[4] - vec[16];
372 5799750584 : r5 = vec[6] + vec[24];
373 5799750584 : r6 = vec[6] - vec[24];
374 5799750584 : r7 = vec[10] + vec[20];
375 5799750584 : r8 = vec[10] - vec[20];
376 5799750584 : r9 = vec[12] + vec[18];
377 5799750584 : r10 = vec[12] - vec[18];
378 5799750584 : r11 = vec[14] + vec[26];
379 5799750584 : r12 = vec[14] - vec[26];
380 5799750584 : r13 = vec[22] + vec[28];
381 5799750584 : r14 = vec[22] - vec[28];
382 :
383 5799750584 : tmp2 = r1 + r3;
384 5799750584 : tmp4 = r1 - r3;
385 5799750584 : tmp6 = r2 + r14;
386 5799750584 : tmp8 = r2 - r14;
387 5799750584 : tmp10 = r4 + r12;
388 5799750584 : tmp12 = r4 - r12;
389 5799750584 : tmp14 = r5 + r9;
390 5799750584 : tmp16 = r5 - r9;
391 5799750584 : tmp18 = r11 + r13;
392 5799750584 : tmp20 = r11 - r13;
393 :
394 : /* Pre-additions imaginary part */
395 5799750584 : i1 = vec[3] + vec[9];
396 5799750584 : i2 = vec[3] - vec[9];
397 5799750584 : i3 = vec[5] + vec[17];
398 5799750584 : i4 = vec[5] - vec[17];
399 5799750584 : i5 = vec[7] + vec[25];
400 5799750584 : i6 = vec[7] - vec[25];
401 5799750584 : i7 = vec[11] + vec[21];
402 5799750584 : i8 = vec[11] - vec[21];
403 5799750584 : i9 = vec[13] + vec[19];
404 5799750584 : i10 = vec[13] - vec[19];
405 5799750584 : i11 = vec[15] + vec[27];
406 5799750584 : i12 = vec[15] - vec[27];
407 5799750584 : i13 = vec[23] + vec[29];
408 5799750584 : i14 = vec[23] - vec[29];
409 :
410 5799750584 : tmp3 = i1 + i3;
411 5799750584 : tmp5 = i1 - i3;
412 5799750584 : tmp7 = i2 + i14;
413 5799750584 : tmp9 = i2 - i14;
414 5799750584 : tmp11 = i4 + i12;
415 5799750584 : tmp13 = i4 - i12;
416 5799750584 : tmp15 = i5 + i9;
417 5799750584 : tmp17 = i5 - i9;
418 5799750584 : tmp19 = i11 + i13;
419 5799750584 : tmp21 = i11 - i13;
420 :
421 :
422 : /* Pre-additions and core multiplications */
423 5799750584 : tmp28 = tmp4 + tmp20;
424 5799750584 : tmp29 = tmp5 + tmp21;
425 5799750584 : r4 = tmp2 + tmp18;
426 5799750584 : i4 = tmp3 + tmp19;
427 5799750584 : r3 = ( r4 + tmp14 ) * -1.25f;
428 5799750584 : i3 = ( i4 + tmp15 ) * -1.25f;
429 5799750584 : r2 = ( tmp29 - i8 ) * -8.660254037844387e-1f;
430 5799750584 : i2 = ( tmp28 - r8 ) * 8.660254037844387e-1f;
431 5799750584 : r1 = r4 + r7;
432 5799750584 : i1 = i4 + i7;
433 5799750584 : r0 = r1 + vec[0] + tmp14;
434 5799750584 : i0 = i1 + vec[1] + tmp15;
435 5799750584 : r7 = tmp4 - tmp20;
436 5799750584 : i7 = tmp5 - tmp21;
437 5799750584 : r8 = ( tmp3 - tmp19 ) * -4.841229182759272e-1f;
438 5799750584 : i8 = ( tmp2 - tmp18 ) * 4.841229182759272e-1f;
439 5799750584 : tmp0 = tmp6 + r10;
440 5799750584 : tmp1 = tmp7 + i10;
441 5799750584 : tmp2 = r6 - tmp10;
442 5799750584 : tmp3 = i6 - tmp11;
443 5799750584 : r10 = tmp7 * -2.308262652881440f;
444 5799750584 : i10 = tmp6 * 2.308262652881440f;
445 5799750584 : r11 = tmp8 * 1.332676064001459f;
446 5799750584 : i11 = tmp9 * 1.332676064001459f;
447 5799750584 : r6 = ( r7 - tmp16 ) * 5.590169943749475e-1f;
448 5799750584 : i6 = ( i7 - tmp17 ) * 5.590169943749475e-1f;
449 5799750584 : r12 = ( tmp1 + tmp3 ) * 5.877852522924733e-1f;
450 5799750584 : i12 = ( tmp0 + tmp2 ) * -5.877852522924733e-1f;
451 5799750584 : r13 = ( tmp7 - tmp11 ) * -8.816778784387098e-1f;
452 5799750584 : i13 = ( tmp6 - tmp10 ) * 8.816778784387098e-1f;
453 5799750584 : r14 = ( tmp8 + tmp12 ) * 5.090369604551274e-1f;
454 5799750584 : i14 = ( tmp9 + tmp13 ) * 5.090369604551274e-1f;
455 5799750584 : r16 = tmp11 * 5.449068960040204e-1f;
456 5799750584 : i16 = tmp10 * -5.449068960040204e-1f;
457 5799750584 : r17 = tmp12 * 3.146021430912046e-1f;
458 5799750584 : i17 = tmp13 * 3.146021430912046e-1f;
459 :
460 5799750584 : r4 *= 1.875f;
461 5799750584 : i4 *= 1.875f;
462 5799750584 : r1 *= -1.5f;
463 5799750584 : i1 *= -1.5f;
464 5799750584 : r7 *= -8.385254915624212e-1f;
465 5799750584 : i7 *= -8.385254915624212e-1f;
466 5799750584 : r5 = tmp29 * 1.082531754730548f;
467 5799750584 : i5 = tmp28 * -1.082531754730548f;
468 5799750584 : r9 = tmp1 * 1.538841768587627f;
469 5799750584 : i9 = tmp0 * -1.538841768587627f;
470 5799750584 : r15 = tmp3 * 3.632712640026803e-1f;
471 5799750584 : i15 = tmp2 * -3.632712640026803e-1f;
472 :
473 :
474 : /* Post-additions real part */
475 5799750584 : tmp2 = r0 + r1;
476 5799750584 : tmp4 = r3 + r6;
477 5799750584 : tmp6 = r3 - r6;
478 5799750584 : tmp8 = r4 + r5;
479 5799750584 : tmp10 = r4 - r5;
480 5799750584 : tmp12 = r7 + r8;
481 5799750584 : tmp14 = r7 - r8;
482 5799750584 : tmp16 = r13 + r16;
483 5799750584 : tmp18 = r14 + r17;
484 5799750584 : tmp20 = r10 - r13;
485 5799750584 : tmp22 = r11 - r14;
486 5799750584 : tmp24 = r12 + r15;
487 5799750584 : tmp26 = r12 - r9;
488 :
489 5799750584 : r1 = tmp2 + r2;
490 5799750584 : r2 = tmp2 - r2;
491 5799750584 : r3 = tmp4 + tmp26;
492 5799750584 : r4 = tmp4 - tmp26;
493 5799750584 : r5 = tmp6 + tmp24;
494 5799750584 : r6 = tmp6 - tmp24;
495 5799750584 : r7 = tmp16 + tmp18;
496 5799750584 : r8 = tmp16 - tmp18;
497 5799750584 : r9 = tmp20 - tmp22;
498 5799750584 : r10 = tmp20 + tmp22;
499 5799750584 : r11 = r1 + tmp8;
500 5799750584 : r12 = r2 + tmp10;
501 5799750584 : r13 = r11 - tmp12;
502 5799750584 : r14 = r12 - tmp14;
503 5799750584 : r15 = r12 + tmp14;
504 5799750584 : r16 = r11 + tmp12;
505 :
506 : /* Post-additions imaginary part */
507 5799750584 : tmp3 = i0 + i1;
508 5799750584 : tmp5 = i3 + i6;
509 5799750584 : tmp7 = i3 - i6;
510 5799750584 : tmp9 = i4 + i5;
511 5799750584 : tmp11 = i4 - i5;
512 5799750584 : tmp13 = i7 + i8;
513 5799750584 : tmp15 = i7 - i8;
514 5799750584 : tmp17 = i13 + i16;
515 5799750584 : tmp19 = i14 + i17;
516 5799750584 : tmp21 = i10 - i13;
517 5799750584 : tmp23 = i11 - i14;
518 5799750584 : tmp25 = i12 + i15;
519 5799750584 : tmp27 = i12 - i9;
520 :
521 5799750584 : i1 = tmp3 + i2;
522 5799750584 : i2 = tmp3 - i2;
523 5799750584 : i3 = tmp5 + tmp27;
524 5799750584 : i4 = tmp5 - tmp27;
525 5799750584 : i5 = tmp7 + tmp25;
526 5799750584 : i6 = tmp7 - tmp25;
527 5799750584 : i7 = tmp17 + tmp19;
528 5799750584 : i8 = tmp17 - tmp19;
529 5799750584 : i9 = tmp21 - tmp23;
530 5799750584 : i10 = tmp21 + tmp23;
531 5799750584 : i11 = i1 + tmp9;
532 5799750584 : i12 = i2 + tmp11;
533 5799750584 : i13 = i11 - tmp13;
534 5799750584 : i14 = i12 - tmp15;
535 5799750584 : i15 = i12 + tmp15;
536 5799750584 : i16 = i11 + tmp13;
537 :
538 5799750584 : *vec++ = r0;
539 5799750584 : *vec++ = i0;
540 5799750584 : *vec++ = r13 + r5 + r7;
541 5799750584 : *vec++ = i13 + i5 + i7;
542 5799750584 : *vec++ = r15 + r3 - r9;
543 5799750584 : *vec++ = i15 + i3 - i9;
544 5799750584 : *vec++ = r0 + r4;
545 5799750584 : *vec++ = i0 + i4;
546 5799750584 : *vec++ = r13 + r6 - r7;
547 5799750584 : *vec++ = i13 + i6 - i7;
548 5799750584 : *vec++ = r2;
549 5799750584 : *vec++ = i2;
550 5799750584 : *vec++ = r0 + r5;
551 5799750584 : *vec++ = i0 + i5;
552 5799750584 : *vec++ = r16 + r3 - r10;
553 5799750584 : *vec++ = i16 + i3 - i10;
554 5799750584 : *vec++ = r15 + r4 + r9;
555 5799750584 : *vec++ = i15 + i4 + i9;
556 5799750584 : *vec++ = r0 + r6;
557 5799750584 : *vec++ = i0 + i6;
558 5799750584 : *vec++ = r1;
559 5799750584 : *vec++ = i1;
560 5799750584 : *vec++ = r14 + r5 + r8;
561 5799750584 : *vec++ = i14 + i5 + i8;
562 5799750584 : *vec++ = r0 + r3;
563 5799750584 : *vec++ = i0 + i3;
564 5799750584 : *vec++ = r16 + r4 + r10;
565 5799750584 : *vec++ = i16 + i4 + i10;
566 5799750584 : *vec++ = r14 + r6 - r8;
567 5799750584 : *vec++ = i14 + i6 - i8;
568 :
569 5799750584 : return;
570 : }
571 :
572 : /*******************************************************************************
573 : Functionname: fft5s
574 : *******************************************************************************
575 :
576 : Description: 5-point FFT.
577 :
578 : Arguments: x - pointer to input data (interleaved real / imaginary parts)
579 : stride - stride for input data
580 :
581 : Return: none
582 :
583 : *******************************************************************************/
584 : static const float C51 = 0.9510565162951535f;
585 : static const float C52 = -1.5388417685876270f;
586 : static const float C53 = -0.3632712640026803f;
587 : static const float C54 = 0.5590169943749475f;
588 : static const float C55 = -1.25f;
589 :
590 533276 : static void fft5s( float *x, const int16_t stride )
591 : {
592 : float r1, r2, r3, r4;
593 : float s1, s2, s3, s4;
594 : float t;
595 : /* real part */
596 533276 : r1 = x[1 * stride] + x[4 * stride];
597 533276 : r4 = x[1 * stride] - x[4 * stride];
598 533276 : r3 = x[2 * stride] + x[3 * stride];
599 533276 : r2 = x[2 * stride] - x[3 * stride];
600 533276 : t = ( r1 - r3 ) * C54;
601 533276 : r1 = r1 + r3;
602 533276 : x[0] = x[0] + r1;
603 533276 : r1 = x[0] + ( r1 * C55 );
604 533276 : r3 = r1 - t;
605 533276 : r1 = r1 + t;
606 533276 : t = ( r4 + r2 ) * C51;
607 533276 : r4 = t + ( r4 * C52 );
608 533276 : r2 = t + ( r2 * C53 );
609 :
610 : /* imaginary part */
611 533276 : s1 = x[1 * stride + 1] + x[4 * stride + 1];
612 533276 : s4 = x[1 * stride + 1] - x[4 * stride + 1];
613 533276 : s3 = x[2 * stride + 1] + x[3 * stride + 1];
614 533276 : s2 = x[2 * stride + 1] - x[3 * stride + 1];
615 533276 : t = ( s1 - s3 ) * C54;
616 533276 : s1 = s1 + s3;
617 533276 : x[1] = x[1] + s1;
618 533276 : s1 = x[1] + ( s1 * C55 );
619 533276 : s3 = s1 - t;
620 533276 : s1 = s1 + t;
621 533276 : t = ( s4 + s2 ) * C51;
622 533276 : s4 = t + ( s4 * C52 );
623 533276 : s2 = t + ( s2 * C53 );
624 :
625 : /* combination */
626 533276 : x[1 * stride] = r1 + s2;
627 533276 : x[4 * stride] = r1 - s2;
628 533276 : x[2 * stride] = r3 - s4;
629 533276 : x[3 * stride] = r3 + s4;
630 :
631 533276 : x[1 * stride + 1] = s1 - r2;
632 533276 : x[4 * stride + 1] = s1 + r2;
633 533276 : x[2 * stride + 1] = s3 + r4;
634 533276 : x[3 * stride + 1] = s3 - r4;
635 533276 : }
636 :
637 :
638 : /**
639 : * \brief Function performs a complex 10-point FFT
640 : * The FFT is performed inplace. The result of the FFT
641 : * is scaled by SCALEFACTOR10 bits.
642 : *
643 : * WOPS FLC version: 1093 cycles
644 : * WOPS with 32x16 bit multiplications: 196 cycles
645 : *
646 : * \param [i/o] re real input / output
647 : * \param [i/o] im imag input / output
648 : * \param [i ] s stride real and imag input / output
649 : *
650 : * \return void
651 : */
652 1408088548 : static void fft10( float *restrict vec )
653 : {
654 : float t;
655 : float r1, r2, r3, r4;
656 : float s1, s2, s3, s4;
657 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
658 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
659 :
660 : /* 2 fft5 stages */
661 :
662 : /* real part */
663 1408088548 : r1 = vec[12] + vec[8];
664 1408088548 : r4 = vec[12] - vec[8];
665 1408088548 : r3 = vec[4] + vec[16];
666 1408088548 : r2 = vec[4] - vec[16];
667 1408088548 : t = ( r1 - r3 ) * C54;
668 1408088548 : r1 = r1 + r3;
669 1408088548 : y00 = vec[0] + r1;
670 1408088548 : r1 = y00 + ( r1 * C55 );
671 1408088548 : r3 = r1 - t;
672 1408088548 : r1 = r1 + t;
673 1408088548 : t = ( r4 + r2 ) * C51;
674 1408088548 : r4 = t + ( r4 * C52 );
675 1408088548 : r2 = t + ( r2 * C53 );
676 :
677 : /* imaginary part */
678 1408088548 : s1 = vec[13] + vec[9];
679 1408088548 : s4 = vec[13] - vec[9];
680 1408088548 : s3 = vec[5] + vec[17];
681 1408088548 : s2 = vec[5] - vec[17];
682 1408088548 : t = ( s1 - s3 ) * C54;
683 1408088548 : s1 = s1 + s3;
684 1408088548 : y01 = vec[1] + s1;
685 1408088548 : s1 = y01 + ( s1 * C55 );
686 1408088548 : s3 = s1 - t;
687 1408088548 : s1 = s1 + t;
688 1408088548 : t = ( s4 + s2 ) * C51;
689 1408088548 : s4 = t + ( s4 * C52 );
690 1408088548 : s2 = t + ( s2 * C53 );
691 :
692 : /* combination */
693 1408088548 : y04 = r1 + s2;
694 1408088548 : y16 = r1 - s2;
695 1408088548 : y08 = r3 - s4;
696 1408088548 : y12 = r3 + s4;
697 1408088548 : y05 = s1 - r2;
698 1408088548 : y17 = s1 + r2;
699 1408088548 : y09 = s3 + r4;
700 1408088548 : y13 = s3 - r4;
701 :
702 : /* real part */
703 1408088548 : r1 = vec[2] + vec[18];
704 1408088548 : r4 = vec[2] - vec[18];
705 1408088548 : r3 = vec[14] + vec[6];
706 1408088548 : r2 = vec[14] - vec[6];
707 1408088548 : t = ( r1 - r3 ) * C54;
708 1408088548 : r1 = r1 + r3;
709 1408088548 : y02 = vec[10] + r1;
710 1408088548 : r1 = y02 + ( r1 * C55 );
711 1408088548 : r3 = r1 - t;
712 1408088548 : r1 = r1 + t;
713 1408088548 : t = ( r4 + r2 ) * C51;
714 1408088548 : r4 = t + ( r4 * C52 );
715 1408088548 : r2 = t + ( r2 * C53 );
716 :
717 : /* imaginary part */
718 1408088548 : s1 = vec[3] + vec[19];
719 1408088548 : s4 = vec[3] - vec[19];
720 1408088548 : s3 = vec[15] + vec[7];
721 1408088548 : s2 = vec[15] - vec[7];
722 1408088548 : t = ( s1 - s3 ) * C54;
723 1408088548 : s1 = s1 + s3;
724 1408088548 : y03 = vec[11] + s1;
725 1408088548 : s1 = y03 + ( s1 * C55 );
726 1408088548 : s3 = s1 - t;
727 1408088548 : s1 = s1 + t;
728 1408088548 : t = ( s4 + s2 ) * C51;
729 1408088548 : s4 = t + ( s4 * C52 );
730 1408088548 : s2 = t + ( s2 * C53 );
731 :
732 : /* combination */
733 1408088548 : y06 = r1 + s2;
734 1408088548 : y18 = r1 - s2;
735 1408088548 : y10 = r3 - s4;
736 1408088548 : y14 = r3 + s4;
737 1408088548 : y07 = s1 - r2;
738 1408088548 : y19 = s1 + r2;
739 1408088548 : y11 = s3 + r4;
740 1408088548 : y15 = s3 - r4;
741 :
742 : /* 5 fft2 stages */
743 1408088548 : vec[0] = y00 + y02;
744 1408088548 : vec[1] = y01 + y03;
745 1408088548 : vec[2] = y12 - y14;
746 1408088548 : vec[3] = y13 - y15;
747 1408088548 : vec[4] = y04 + y06;
748 1408088548 : vec[5] = y05 + y07;
749 1408088548 : vec[6] = y16 - y18;
750 1408088548 : vec[7] = y17 - y19;
751 1408088548 : vec[8] = y08 + y10;
752 1408088548 : vec[9] = y09 + y11;
753 1408088548 : vec[10] = y00 - y02;
754 1408088548 : vec[11] = y01 - y03;
755 1408088548 : vec[12] = y12 + y14;
756 1408088548 : vec[13] = y13 + y15;
757 1408088548 : vec[14] = y04 - y06;
758 1408088548 : vec[15] = y05 - y07;
759 1408088548 : vec[16] = y16 + y18;
760 1408088548 : vec[17] = y17 + y19;
761 1408088548 : vec[18] = y08 - y10;
762 1408088548 : vec[19] = y09 - y11;
763 :
764 1408088548 : return;
765 : }
766 :
767 : /**
768 : * \brief Function performs a complex 20-point FFT
769 : * The FFT is performed inplace. The result of the FFT
770 : * is scaled by SCALEFACTOR20 bits.
771 : *
772 : * WOPS FLC version: 1509 cycles
773 : * WOPS with 32x16 bit multiplications: 432 cycles
774 : *
775 : * \param [i/o] re real input / output
776 : * \param [i/o] im imag input / output
777 : * \param [i ] s stride real and imag input / output
778 : *
779 : * \return void
780 : */
781 1613475746 : static void fft20( float *signal )
782 : {
783 1613475746 : const int16_t s = 2;
784 1613475746 : float *re = signal, *im = signal + 1;
785 : float r1, r2, r3, r4;
786 : float s1, s2, s3, s4;
787 : float x0, x1, x2, x3, x4;
788 : float t, t0, t1, t2, t3, t4, t5, t6, t7;
789 : float y00, y01, y02, y03, y04, y05, y06, y07, y08, y09;
790 : float y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
791 : float y20, y21, y22, y23, y24, y25, y26, y27, y28, y29;
792 : float y30, y31, y32, y33, y34, y35, y36, y37, y38, y39;
793 :
794 : /* 1. FFT5 stage */
795 :
796 : /* real part */
797 1613475746 : x0 = re[s * 0];
798 1613475746 : x1 = re[s * 16];
799 1613475746 : x2 = re[s * 12];
800 1613475746 : x3 = re[s * 8];
801 1613475746 : x4 = re[s * 4];
802 1613475746 : r1 = x1 + x4;
803 1613475746 : r4 = x1 - x4;
804 1613475746 : r3 = x2 + x3;
805 1613475746 : r2 = x2 - x3;
806 1613475746 : t = ( r1 - r3 ) * C54;
807 1613475746 : r1 = r1 + r3;
808 1613475746 : y00 = x0 + r1;
809 1613475746 : r1 = y00 + ( r1 * C55 );
810 1613475746 : r3 = r1 - t;
811 1613475746 : r1 = r1 + t;
812 1613475746 : t = ( r4 + r2 ) * C51;
813 1613475746 : r4 = t + ( r4 * C52 );
814 1613475746 : r2 = t + ( r2 * C53 );
815 :
816 : /* imaginary part */
817 1613475746 : x0 = im[s * 0];
818 1613475746 : x1 = im[s * 16];
819 1613475746 : x2 = im[s * 12];
820 1613475746 : x3 = im[s * 8];
821 1613475746 : x4 = im[s * 4];
822 1613475746 : s1 = x1 + x4;
823 1613475746 : s4 = x1 - x4;
824 1613475746 : s3 = x2 + x3;
825 1613475746 : s2 = x2 - x3;
826 1613475746 : t = ( s1 - s3 ) * C54;
827 1613475746 : s1 = ( s1 + s3 );
828 1613475746 : y01 = ( x0 + s1 );
829 1613475746 : s1 = y01 + ( s1 * C55 );
830 1613475746 : s3 = ( s1 - t );
831 1613475746 : s1 = ( s1 + t );
832 1613475746 : t = ( s4 + s2 ) * C51;
833 1613475746 : s4 = t + ( s4 * C52 );
834 1613475746 : s2 = t + ( s2 * C53 );
835 :
836 : /* combination */
837 1613475746 : y08 = ( r1 + s2 );
838 1613475746 : y32 = ( r1 - s2 );
839 1613475746 : y16 = ( r3 - s4 );
840 1613475746 : y24 = ( r3 + s4 );
841 :
842 1613475746 : y09 = ( s1 - r2 );
843 1613475746 : y33 = ( s1 + r2 );
844 1613475746 : y17 = ( s3 + r4 );
845 1613475746 : y25 = ( s3 - r4 );
846 :
847 : /* 2. FFT5 stage */
848 :
849 : /* real part */
850 1613475746 : x0 = re[s * 5];
851 1613475746 : x1 = re[s * 1];
852 1613475746 : x2 = re[s * 17];
853 1613475746 : x3 = re[s * 13];
854 1613475746 : x4 = re[s * 9];
855 1613475746 : r1 = ( x1 + x4 );
856 1613475746 : r4 = ( x1 - x4 );
857 1613475746 : r3 = ( x2 + x3 );
858 1613475746 : r2 = ( x2 - x3 );
859 1613475746 : t = ( r1 - r3 ) * C54;
860 1613475746 : r1 = ( r1 + r3 );
861 1613475746 : y02 = ( x0 + r1 );
862 1613475746 : r1 = y02 + ( r1 * C55 );
863 1613475746 : r3 = ( r1 - t );
864 1613475746 : r1 = ( r1 + t );
865 1613475746 : t = ( r4 + r2 ) * C51;
866 1613475746 : r4 = t + ( r4 * C52 );
867 1613475746 : r2 = t + ( r2 * C53 );
868 :
869 : /* imaginary part */
870 1613475746 : x0 = im[s * 5];
871 1613475746 : x1 = im[s * 1];
872 1613475746 : x2 = im[s * 17];
873 1613475746 : x3 = im[s * 13];
874 1613475746 : x4 = im[s * 9];
875 1613475746 : s1 = ( x1 + x4 );
876 1613475746 : s4 = ( x1 - x4 );
877 1613475746 : s3 = ( x2 + x3 );
878 1613475746 : s2 = ( x2 - x3 );
879 1613475746 : t = ( s1 - s3 ) * C54;
880 1613475746 : s1 = ( s1 + s3 );
881 1613475746 : y03 = ( x0 + s1 );
882 1613475746 : s1 = y03 + ( s1 * C55 );
883 1613475746 : s3 = ( s1 - t );
884 1613475746 : s1 = ( s1 + t );
885 1613475746 : t = ( s4 + s2 ) * C51;
886 1613475746 : s4 = t + ( s4 * C52 );
887 1613475746 : s2 = t + ( s2 * C53 );
888 :
889 : /* combination */
890 1613475746 : y10 = ( r1 + s2 );
891 1613475746 : y34 = ( r1 - s2 );
892 1613475746 : y18 = ( r3 - s4 );
893 1613475746 : y26 = ( r3 + s4 );
894 :
895 1613475746 : y11 = ( s1 - r2 );
896 1613475746 : y35 = ( s1 + r2 );
897 1613475746 : y19 = ( s3 + r4 );
898 1613475746 : y27 = ( s3 - r4 );
899 :
900 : /* 3. FFT5 stage */
901 :
902 : /* real part */
903 1613475746 : x0 = re[s * 10];
904 1613475746 : x1 = re[s * 6];
905 1613475746 : x2 = re[s * 2];
906 1613475746 : x3 = re[s * 18];
907 1613475746 : x4 = re[s * 14];
908 1613475746 : r1 = ( x1 + x4 );
909 1613475746 : r4 = ( x1 - x4 );
910 1613475746 : r3 = ( x2 + x3 );
911 1613475746 : r2 = ( x2 - x3 );
912 1613475746 : t = ( r1 - r3 ) * C54;
913 1613475746 : r1 = ( r1 + r3 );
914 1613475746 : y04 = ( x0 + r1 );
915 1613475746 : r1 = y04 + ( r1 * C55 );
916 1613475746 : r3 = ( r1 - t );
917 1613475746 : r1 = ( r1 + t );
918 1613475746 : t = ( r4 + r2 ) * C51;
919 1613475746 : r4 = t + ( r4 * C52 );
920 1613475746 : r2 = t + ( r2 * C53 );
921 :
922 : /* imaginary part */
923 1613475746 : x0 = im[s * 10];
924 1613475746 : x1 = im[s * 6];
925 1613475746 : x2 = im[s * 2];
926 1613475746 : x3 = im[s * 18];
927 1613475746 : x4 = im[s * 14];
928 1613475746 : s1 = ( x1 + x4 );
929 1613475746 : s4 = ( x1 - x4 );
930 1613475746 : s3 = ( x2 + x3 );
931 1613475746 : s2 = ( x2 - x3 );
932 1613475746 : t = ( s1 - s3 ) * C54;
933 1613475746 : s1 = ( s1 + s3 );
934 1613475746 : y05 = ( x0 + s1 );
935 1613475746 : s1 = y05 + ( s1 * C55 );
936 1613475746 : s3 = ( s1 - t );
937 1613475746 : s1 = ( s1 + t );
938 1613475746 : t = ( s4 + s2 ) * C51;
939 1613475746 : s4 = t + ( s4 * C52 );
940 1613475746 : s2 = t + ( s2 * C53 );
941 :
942 : /* combination */
943 1613475746 : y12 = ( r1 + s2 );
944 1613475746 : y36 = ( r1 - s2 );
945 1613475746 : y20 = ( r3 - s4 );
946 1613475746 : y28 = ( r3 + s4 );
947 :
948 1613475746 : y13 = ( s1 - r2 );
949 1613475746 : y37 = ( s1 + r2 );
950 1613475746 : y21 = ( s3 + r4 );
951 1613475746 : y29 = ( s3 - r4 );
952 :
953 : /* 4. FFT5 stage */
954 :
955 : /* real part */
956 1613475746 : x0 = re[s * 15];
957 1613475746 : x1 = re[s * 11];
958 1613475746 : x2 = re[s * 7];
959 1613475746 : x3 = re[s * 3];
960 1613475746 : x4 = re[s * 19];
961 1613475746 : r1 = ( x1 + x4 );
962 1613475746 : r4 = ( x1 - x4 );
963 1613475746 : r3 = ( x2 + x3 );
964 1613475746 : r2 = ( x2 - x3 );
965 1613475746 : t = ( r1 - r3 ) * C54;
966 1613475746 : r1 = ( r1 + r3 );
967 1613475746 : y06 = ( x0 + r1 );
968 1613475746 : r1 = y06 + ( r1 * C55 );
969 1613475746 : r3 = ( r1 - t );
970 1613475746 : r1 = ( r1 + t );
971 1613475746 : t = ( r4 + r2 ) * C51;
972 1613475746 : r4 = t + ( r4 * C52 );
973 1613475746 : r2 = t + ( r2 * C53 );
974 :
975 : /* imaginary part */
976 1613475746 : x0 = im[s * 15];
977 1613475746 : x1 = im[s * 11];
978 1613475746 : x2 = im[s * 7];
979 1613475746 : x3 = im[s * 3];
980 1613475746 : x4 = im[s * 19];
981 1613475746 : s1 = ( x1 + x4 );
982 1613475746 : s4 = ( x1 - x4 );
983 1613475746 : s3 = ( x2 + x3 );
984 1613475746 : s2 = ( x2 - x3 );
985 1613475746 : t = ( s1 - s3 ) * C54;
986 1613475746 : s1 = ( s1 + s3 );
987 1613475746 : y07 = ( x0 + s1 );
988 1613475746 : s1 = y07 + ( s1 * C55 );
989 1613475746 : s3 = ( s1 - t );
990 1613475746 : s1 = ( s1 + t );
991 1613475746 : t = ( s4 + s2 ) * C51;
992 1613475746 : s4 = t + ( s4 * C52 );
993 1613475746 : s2 = t + ( s2 * C53 );
994 :
995 : /* combination */
996 1613475746 : y14 = ( r1 + s2 );
997 1613475746 : y38 = ( r1 - s2 );
998 1613475746 : y22 = ( r3 - s4 );
999 1613475746 : y30 = ( r3 + s4 );
1000 :
1001 1613475746 : y15 = ( s1 - r2 );
1002 1613475746 : y39 = ( s1 + r2 );
1003 1613475746 : y23 = ( s3 + r4 );
1004 1613475746 : y31 = ( s3 - r4 );
1005 :
1006 :
1007 : /* 1. FFT4 stage */
1008 :
1009 : /* Pre-additions */
1010 1613475746 : t0 = ( y00 + y04 );
1011 1613475746 : t2 = ( y00 - y04 );
1012 1613475746 : t1 = ( y01 + y05 );
1013 1613475746 : t3 = ( y01 - y05 );
1014 1613475746 : t4 = ( y02 + y06 );
1015 1613475746 : t7 = ( y02 - y06 );
1016 1613475746 : t5 = ( y07 + y03 );
1017 1613475746 : t6 = ( y07 - y03 );
1018 :
1019 : /* Post-additions */
1020 1613475746 : re[s * 0] = ( t0 + t4 );
1021 1613475746 : im[s * 0] = ( t1 + t5 );
1022 1613475746 : re[s * 5] = ( t2 - t6 );
1023 1613475746 : im[s * 5] = ( t3 - t7 );
1024 1613475746 : re[s * 10] = ( t0 - t4 );
1025 1613475746 : im[s * 10] = ( t1 - t5 );
1026 1613475746 : re[s * 15] = ( t2 + t6 );
1027 1613475746 : im[s * 15] = ( t3 + t7 );
1028 :
1029 : /* 2. FFT4 stage */
1030 :
1031 : /* Pre-additions */
1032 1613475746 : t0 = ( y08 + y12 );
1033 1613475746 : t2 = ( y08 - y12 );
1034 1613475746 : t1 = ( y09 + y13 );
1035 1613475746 : t3 = ( y09 - y13 );
1036 1613475746 : t4 = ( y10 + y14 );
1037 1613475746 : t7 = ( y10 - y14 );
1038 1613475746 : t5 = ( y15 + y11 );
1039 1613475746 : t6 = ( y15 - y11 );
1040 :
1041 : /* Post-additions */
1042 1613475746 : re[s * 4] = ( t0 + t4 );
1043 1613475746 : im[s * 4] = ( t1 + t5 );
1044 1613475746 : re[s * 9] = ( t2 - t6 );
1045 1613475746 : im[s * 9] = ( t3 - t7 );
1046 1613475746 : re[s * 14] = ( t0 - t4 );
1047 1613475746 : im[s * 14] = ( t1 - t5 );
1048 1613475746 : re[s * 19] = ( t2 + t6 );
1049 1613475746 : im[s * 19] = ( t3 + t7 );
1050 :
1051 :
1052 : /* 3. FFT4 stage */
1053 :
1054 : /* Pre-additions */
1055 1613475746 : t0 = ( y16 + y20 );
1056 1613475746 : t2 = ( y16 - y20 );
1057 1613475746 : t1 = ( y17 + y21 );
1058 1613475746 : t3 = ( y17 - y21 );
1059 1613475746 : t4 = ( y18 + y22 );
1060 1613475746 : t7 = ( y18 - y22 );
1061 1613475746 : t5 = ( y23 + y19 );
1062 1613475746 : t6 = ( y23 - y19 );
1063 :
1064 : /* Post-additions */
1065 1613475746 : re[s * 8] = ( t0 + t4 );
1066 1613475746 : im[s * 8] = ( t1 + t5 );
1067 1613475746 : re[s * 13] = ( t2 - t6 );
1068 1613475746 : im[s * 13] = ( t3 - t7 );
1069 1613475746 : re[s * 18] = ( t0 - t4 );
1070 1613475746 : im[s * 18] = ( t1 - t5 );
1071 1613475746 : re[s * 3] = ( t2 + t6 );
1072 1613475746 : im[s * 3] = ( t3 + t7 );
1073 :
1074 : /* 4. FFT4 stage */
1075 :
1076 : /* Pre-additions */
1077 1613475746 : t0 = ( y24 + y28 );
1078 1613475746 : t2 = ( y24 - y28 );
1079 1613475746 : t1 = ( y25 + y29 );
1080 1613475746 : t3 = ( y25 - y29 );
1081 1613475746 : t4 = ( y26 + y30 );
1082 1613475746 : t7 = ( y26 - y30 );
1083 1613475746 : t5 = ( y31 + y27 );
1084 1613475746 : t6 = ( y31 - y27 );
1085 :
1086 : /* Post-additions */
1087 1613475746 : re[s * 12] = ( t0 + t4 );
1088 1613475746 : im[s * 12] = ( t1 + t5 );
1089 1613475746 : re[s * 17] = ( t2 - t6 );
1090 1613475746 : im[s * 17] = ( t3 - t7 );
1091 1613475746 : re[s * 2] = ( t0 - t4 );
1092 1613475746 : im[s * 2] = ( t1 - t5 );
1093 1613475746 : re[s * 7] = ( t2 + t6 );
1094 1613475746 : im[s * 7] = ( t3 + t7 );
1095 :
1096 : /* 5. FFT4 stage */
1097 :
1098 : /* Pre-additions */
1099 1613475746 : t0 = ( y32 + y36 );
1100 1613475746 : t2 = ( y32 - y36 );
1101 1613475746 : t1 = ( y33 + y37 );
1102 1613475746 : t3 = ( y33 - y37 );
1103 1613475746 : t4 = ( y34 + y38 );
1104 1613475746 : t7 = ( y34 - y38 );
1105 1613475746 : t5 = ( y39 + y35 );
1106 1613475746 : t6 = ( y39 - y35 );
1107 :
1108 : /* Post-additions */
1109 1613475746 : re[s * 16] = ( t0 + t4 );
1110 1613475746 : im[s * 16] = ( t1 + t5 );
1111 1613475746 : re[s * 1] = ( t2 - t6 );
1112 1613475746 : im[s * 1] = ( t3 - t7 );
1113 1613475746 : re[s * 6] = ( t0 - t4 );
1114 1613475746 : im[s * 6] = ( t1 - t5 );
1115 1613475746 : re[s * 11] = ( t2 + t6 );
1116 1613475746 : im[s * 11] = ( t3 + t7 );
1117 :
1118 1613475746 : return;
1119 : }
1120 :
1121 : /*******************************************************************************
1122 : Functionname: fft30
1123 : *******************************************************************************
1124 :
1125 : Description: 30-point FFT.
1126 :
1127 : Arguments: in - pointer to data (interleaved real / imaginary parts)
1128 :
1129 : Return: none
1130 :
1131 : *******************************************************************************/
1132 :
1133 2899875292 : static void fft30( float *restrict in )
1134 : {
1135 : int16_t i;
1136 : float temp[60];
1137 2899875292 : float *temp_l = temp;
1138 2899875292 : float *temp_lu = temp + 2 * 8;
1139 2899875292 : float *temp_h = temp + 2 * 15;
1140 2899875292 : float *temp_hu = temp + 2 * 15 + 2 * 8;
1141 2899875292 : float *in_l = in + 2 * 0;
1142 2899875292 : float *in_h = in + 2 * 15;
1143 23199002336 : for ( i = 0; i < 7; i++ )
1144 : {
1145 20299127044 : *temp_l++ = *in_l++;
1146 20299127044 : *temp_l++ = *in_l++;
1147 20299127044 : *temp_h++ = *in_h++;
1148 20299127044 : *temp_h++ = *in_h++;
1149 20299127044 : *temp_l++ = *in_h++;
1150 20299127044 : *temp_l++ = *in_h++;
1151 20299127044 : *temp_h++ = *in_l++;
1152 20299127044 : *temp_h++ = *in_l++;
1153 : }
1154 2899875292 : *temp_l++ = *in_l++;
1155 2899875292 : *temp_l++ = *in_l++;
1156 2899875292 : *temp_h++ = *in_h++;
1157 2899875292 : *temp_h++ = *in_h++;
1158 2899875292 : temp_l = temp;
1159 2899875292 : temp_h = temp + 30;
1160 2899875292 : fft15( temp_l );
1161 2899875292 : fft15( temp_h );
1162 :
1163 2899875292 : in_l = in + 2 * 0;
1164 2899875292 : in_h = in + 2 * 15;
1165 23199002336 : for ( i = 0; i < 7; i++ )
1166 : {
1167 20299127044 : *in_l++ = *temp_l + *temp_h;
1168 20299127044 : *in_h++ = *temp_l++ - *temp_h++;
1169 20299127044 : *in_l++ = *temp_l + *temp_h;
1170 20299127044 : *in_h++ = *temp_l++ - *temp_h++;
1171 :
1172 20299127044 : *in_h++ = *temp_lu + *temp_hu;
1173 20299127044 : *in_l++ = *temp_lu++ - *temp_hu++;
1174 20299127044 : *in_h++ = *temp_lu + *temp_hu;
1175 20299127044 : *in_l++ = *temp_lu++ - *temp_hu++;
1176 : }
1177 2899875292 : *in_l++ = *temp_l + *temp_h;
1178 2899875292 : *in_h++ = *temp_l++ - *temp_h++;
1179 2899875292 : *in_l++ = *temp_l + *temp_h;
1180 2899875292 : *in_h++ = *temp_l++ - *temp_h++;
1181 :
1182 2899875292 : return;
1183 : }
1184 :
1185 : /*-------------------------------------------------------------------*
1186 : * fft_cldfb()
1187 : *
1188 : * Interface functions FFT subroutines
1189 : *--------------------------------------------------------------------*/
1190 6152730752 : void fft_cldfb(
1191 : float *data, /* i/o: input/output vector */
1192 : const int16_t size /* size of fft operation */
1193 : )
1194 : {
1195 :
1196 6152730752 : switch ( size )
1197 : {
1198 533276 : case 5:
1199 533276 : fft5s( data, 2 );
1200 533276 : break;
1201 230454174 : case 8:
1202 230454174 : fft8( data );
1203 230454174 : break;
1204 1408088548 : case 10:
1205 1408088548 : fft10( data );
1206 1408088548 : break;
1207 303716 : case 16:
1208 303716 : fft16( data );
1209 303716 : break;
1210 1613475746 : case 20:
1211 1613475746 : fft20( data );
1212 1613475746 : break;
1213 2899875292 : case 30:
1214 2899875292 : fft30( data );
1215 2899875292 : break;
1216 :
1217 0 : default:
1218 0 : assert( 0 );
1219 : break;
1220 : }
1221 :
1222 6152730752 : return;
1223 : }
|
