1 /* ----------------------------------------------------------------------
2 * Copyright (C) 2010-2014 ARM Limited. All rights reserved.
3 *
4 * $Date: 31. July 2014
5 * $Revision: V1.4.4
6 *
7 * Project: CMSIS DSP Library
8 * Title: arm_cfft_f32.c
9 *
10 * Description: Combined Radix Decimation in Frequency CFFT Floating point processing function
11 *
12 * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * - Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * - Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
22 * distribution.
23 * - Neither the name of ARM LIMITED nor the names of its contributors
24 * may be used to endorse or promote products derived from this
25 * software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
31 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
37 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38 * POSSIBILITY OF SUCH DAMAGE.
39 * -------------------------------------------------------------------- */
40
41 #include "arm_math.h"
42 #include "arm_common_tables.h"
43
44 extern void arm_radix8_butterfly_f32(
45 float32_t * pSrc,
46 uint16_t fftLen,
47 const float32_t * pCoef,
48 uint16_t twidCoefModifier);
49
50 extern void arm_bitreversal_32(
51 uint32_t * pSrc,
52 const uint16_t bitRevLen,
53 const uint16_t * pBitRevTable);
54
55 /**
56 * @ingroup groupTransforms
57 */
58
59 /**
60 * @defgroup ComplexFFT Complex FFT Functions
61 *
62 * \par
63 * The Fast Fourier Transform (FFT) is an efficient algorithm for computing the
64 * Discrete Fourier Transform (DFT). The FFT can be orders of magnitude faster
65 * than the DFT, especially for long lengths.
66 * The algorithms described in this section
67 * operate on complex data. A separate set of functions is devoted to handling
68 * of real sequences.
69 * \par
70 * There are separate algorithms for handling floating-point, Q15, and Q31 data
71 * types. The algorithms available for each data type are described next.
72 * \par
73 * The FFT functions operate in-place. That is, the array holding the input data
74 * will also be used to hold the corresponding result. The input data is complex
75 * and contains <code>2*fftLen</code> interleaved values as shown below.
76 * <pre> {real[0], imag[0], real[1], imag[1],..} </pre>
77 * The FFT result will be contained in the same array and the frequency domain
78 * values will have the same interleaving.
79 *
80 * \par Floating-point
81 * The floating-point complex FFT uses a mixed-radix algorithm. Multiple radix-8
82 * stages are performed along with a single radix-2 or radix-4 stage, as needed.
83 * The algorithm supports lengths of [16, 32, 64, ..., 4096] and each length uses
84 * a different twiddle factor table.
85 * \par
86 * The function uses the standard FFT definition and output values may grow by a
87 * factor of <code>fftLen</code> when computing the forward transform. The
88 * inverse transform includes a scale of <code>1/fftLen</code> as part of the
89 * calculation and this matches the textbook definition of the inverse FFT.
90 * \par
91 * Pre-initialized data structures containing twiddle factors and bit reversal
92 * tables are provided and defined in <code>arm_const_structs.h</code>. Include
93 * this header in your function and then pass one of the constant structures as
94 * an argument to arm_cfft_f32. For example:
95 * \par
96 * <code>arm_cfft_f32(arm_cfft_sR_f32_len64, pSrc, 1, 1)</code>
97 * \par
98 * computes a 64-point inverse complex FFT including bit reversal.
99 * The data structures are treated as constant data and not modified during the
100 * calculation. The same data structure can be reused for multiple transforms
101 * including mixing forward and inverse transforms.
102 * \par
103 * Earlier releases of the library provided separate radix-2 and radix-4
104 * algorithms that operated on floating-point data. These functions are still
105 * provided but are deprecated. The older functions are slower and less general
106 * than the new functions.
107 * \par
108 * An example of initialization of the constants for the arm_cfft_f32 function follows:
109 * \code
110 * const static arm_cfft_instance_f32 *S;
111 * ...
112 * switch (length) {
113 * case 16:
114 * S = &arm_cfft_sR_f32_len16;
115 * break;
116 * case 32:
117 * S = &arm_cfft_sR_f32_len32;
118 * break;
119 * case 64:
120 * S = &arm_cfft_sR_f32_len64;
121 * break;
122 * case 128:
123 * S = &arm_cfft_sR_f32_len128;
124 * break;
125 * case 256:
126 * S = &arm_cfft_sR_f32_len256;
127 * break;
128 * case 512:
129 * S = &arm_cfft_sR_f32_len512;
130 * break;
131 * case 1024:
132 * S = &arm_cfft_sR_f32_len1024;
133 * break;
134 * case 2048:
135 * S = &arm_cfft_sR_f32_len2048;
136 * break;
137 * case 4096:
138 * S = &arm_cfft_sR_f32_len4096;
139 * break;
140 * }
141 * \endcode
142 * \par Q15 and Q31
143 * The floating-point complex FFT uses a mixed-radix algorithm. Multiple radix-4
144 * stages are performed along with a single radix-2 stage, as needed.
145 * The algorithm supports lengths of [16, 32, 64, ..., 4096] and each length uses
146 * a different twiddle factor table.
147 * \par
148 * The function uses the standard FFT definition and output values may grow by a
149 * factor of <code>fftLen</code> when computing the forward transform. The
150 * inverse transform includes a scale of <code>1/fftLen</code> as part of the
151 * calculation and this matches the textbook definition of the inverse FFT.
152 * \par
153 * Pre-initialized data structures containing twiddle factors and bit reversal
154 * tables are provided and defined in <code>arm_const_structs.h</code>. Include
155 * this header in your function and then pass one of the constant structures as
156 * an argument to arm_cfft_q31. For example:
157 * \par
158 * <code>arm_cfft_q31(arm_cfft_sR_q31_len64, pSrc, 1, 1)</code>
159 * \par
160 * computes a 64-point inverse complex FFT including bit reversal.
161 * The data structures are treated as constant data and not modified during the
162 * calculation. The same data structure can be reused for multiple transforms
163 * including mixing forward and inverse transforms.
164 * \par
165 * Earlier releases of the library provided separate radix-2 and radix-4
166 * algorithms that operated on floating-point data. These functions are still
167 * provided but are deprecated. The older functions are slower and less general
168 * than the new functions.
169 * \par
170 * An example of initialization of the constants for the arm_cfft_q31 function follows:
171 * \code
172 * const static arm_cfft_instance_q31 *S;
173 * ...
174 * switch (length) {
175 * case 16:
176 * S = &arm_cfft_sR_q31_len16;
177 * break;
178 * case 32:
179 * S = &arm_cfft_sR_q31_len32;
180 * break;
181 * case 64:
182 * S = &arm_cfft_sR_q31_len64;
183 * break;
184 * case 128:
185 * S = &arm_cfft_sR_q31_len128;
186 * break;
187 * case 256:
188 * S = &arm_cfft_sR_q31_len256;
189 * break;
190 * case 512:
191 * S = &arm_cfft_sR_q31_len512;
192 * break;
193 * case 1024:
194 * S = &arm_cfft_sR_q31_len1024;
195 * break;
196 * case 2048:
197 * S = &arm_cfft_sR_q31_len2048;
198 * break;
199 * case 4096:
200 * S = &arm_cfft_sR_q31_len4096;
201 * break;
202 * }
203 * \endcode
204 *
205 */
206
arm_cfft_radix8by2_f32(arm_cfft_instance_f32 * S,float32_t * p1)207 void arm_cfft_radix8by2_f32( arm_cfft_instance_f32 * S, float32_t * p1)
208 {
209 uint32_t L = S->fftLen;
210 float32_t * pCol1, * pCol2, * pMid1, * pMid2;
211 float32_t * p2 = p1 + L;
212 const float32_t * tw = (float32_t *) S->pTwiddle;
213 float32_t t1[4], t2[4], t3[4], t4[4], twR, twI;
214 float32_t m0, m1, m2, m3;
215 uint32_t l;
216
217 pCol1 = p1;
218 pCol2 = p2;
219
220 // Define new length
221 L >>= 1;
222 // Initialize mid pointers
223 pMid1 = p1 + L;
224 pMid2 = p2 + L;
225
226 // do two dot Fourier transform
227 for ( l = L >> 2; l > 0; l-- )
228 {
229 t1[0] = p1[0];
230 t1[1] = p1[1];
231 t1[2] = p1[2];
232 t1[3] = p1[3];
233
234 t2[0] = p2[0];
235 t2[1] = p2[1];
236 t2[2] = p2[2];
237 t2[3] = p2[3];
238
239 t3[0] = pMid1[0];
240 t3[1] = pMid1[1];
241 t3[2] = pMid1[2];
242 t3[3] = pMid1[3];
243
244 t4[0] = pMid2[0];
245 t4[1] = pMid2[1];
246 t4[2] = pMid2[2];
247 t4[3] = pMid2[3];
248
249 *p1++ = t1[0] + t2[0];
250 *p1++ = t1[1] + t2[1];
251 *p1++ = t1[2] + t2[2];
252 *p1++ = t1[3] + t2[3]; // col 1
253
254 t2[0] = t1[0] - t2[0];
255 t2[1] = t1[1] - t2[1];
256 t2[2] = t1[2] - t2[2];
257 t2[3] = t1[3] - t2[3]; // for col 2
258
259 *pMid1++ = t3[0] + t4[0];
260 *pMid1++ = t3[1] + t4[1];
261 *pMid1++ = t3[2] + t4[2];
262 *pMid1++ = t3[3] + t4[3]; // col 1
263
264 t4[0] = t4[0] - t3[0];
265 t4[1] = t4[1] - t3[1];
266 t4[2] = t4[2] - t3[2];
267 t4[3] = t4[3] - t3[3]; // for col 2
268
269 twR = *tw++;
270 twI = *tw++;
271
272 // multiply by twiddle factors
273 m0 = t2[0] * twR;
274 m1 = t2[1] * twI;
275 m2 = t2[1] * twR;
276 m3 = t2[0] * twI;
277
278 // R = R * Tr - I * Ti
279 *p2++ = m0 + m1;
280 // I = I * Tr + R * Ti
281 *p2++ = m2 - m3;
282
283 // use vertical symmetry
284 // 0.9988 - 0.0491i <==> -0.0491 - 0.9988i
285 m0 = t4[0] * twI;
286 m1 = t4[1] * twR;
287 m2 = t4[1] * twI;
288 m3 = t4[0] * twR;
289
290 *pMid2++ = m0 - m1;
291 *pMid2++ = m2 + m3;
292
293 twR = *tw++;
294 twI = *tw++;
295
296 m0 = t2[2] * twR;
297 m1 = t2[3] * twI;
298 m2 = t2[3] * twR;
299 m3 = t2[2] * twI;
300
301 *p2++ = m0 + m1;
302 *p2++ = m2 - m3;
303
304 m0 = t4[2] * twI;
305 m1 = t4[3] * twR;
306 m2 = t4[3] * twI;
307 m3 = t4[2] * twR;
308
309 *pMid2++ = m0 - m1;
310 *pMid2++ = m2 + m3;
311 }
312
313 // first col
314 arm_radix8_butterfly_f32( pCol1, L, (float32_t *) S->pTwiddle, 2u);
315 // second col
316 arm_radix8_butterfly_f32( pCol2, L, (float32_t *) S->pTwiddle, 2u);
317 }
318
arm_cfft_radix8by4_f32(arm_cfft_instance_f32 * S,float32_t * p1)319 void arm_cfft_radix8by4_f32( arm_cfft_instance_f32 * S, float32_t * p1)
320 {
321 uint32_t L = S->fftLen >> 1;
322 float32_t * pCol1, *pCol2, *pCol3, *pCol4, *pEnd1, *pEnd2, *pEnd3, *pEnd4;
323 const float32_t *tw2, *tw3, *tw4;
324 float32_t * p2 = p1 + L;
325 float32_t * p3 = p2 + L;
326 float32_t * p4 = p3 + L;
327 float32_t t2[4], t3[4], t4[4], twR, twI;
328 float32_t p1ap3_0, p1sp3_0, p1ap3_1, p1sp3_1;
329 float32_t m0, m1, m2, m3;
330 uint32_t l, twMod2, twMod3, twMod4;
331
332 pCol1 = p1; // points to real values by default
333 pCol2 = p2;
334 pCol3 = p3;
335 pCol4 = p4;
336 pEnd1 = p2 - 1; // points to imaginary values by default
337 pEnd2 = p3 - 1;
338 pEnd3 = p4 - 1;
339 pEnd4 = pEnd3 + L;
340
341 tw2 = tw3 = tw4 = (float32_t *) S->pTwiddle;
342
343 L >>= 1;
344
345 // do four dot Fourier transform
346
347 twMod2 = 2;
348 twMod3 = 4;
349 twMod4 = 6;
350
351 // TOP
352 p1ap3_0 = p1[0] + p3[0];
353 p1sp3_0 = p1[0] - p3[0];
354 p1ap3_1 = p1[1] + p3[1];
355 p1sp3_1 = p1[1] - p3[1];
356
357 // col 2
358 t2[0] = p1sp3_0 + p2[1] - p4[1];
359 t2[1] = p1sp3_1 - p2[0] + p4[0];
360 // col 3
361 t3[0] = p1ap3_0 - p2[0] - p4[0];
362 t3[1] = p1ap3_1 - p2[1] - p4[1];
363 // col 4
364 t4[0] = p1sp3_0 - p2[1] + p4[1];
365 t4[1] = p1sp3_1 + p2[0] - p4[0];
366 // col 1
367 *p1++ = p1ap3_0 + p2[0] + p4[0];
368 *p1++ = p1ap3_1 + p2[1] + p4[1];
369
370 // Twiddle factors are ones
371 *p2++ = t2[0];
372 *p2++ = t2[1];
373 *p3++ = t3[0];
374 *p3++ = t3[1];
375 *p4++ = t4[0];
376 *p4++ = t4[1];
377
378 tw2 += twMod2;
379 tw3 += twMod3;
380 tw4 += twMod4;
381
382 for (l = (L - 2) >> 1; l > 0; l-- )
383 {
384 // TOP
385 p1ap3_0 = p1[0] + p3[0];
386 p1sp3_0 = p1[0] - p3[0];
387 p1ap3_1 = p1[1] + p3[1];
388 p1sp3_1 = p1[1] - p3[1];
389 // col 2
390 t2[0] = p1sp3_0 + p2[1] - p4[1];
391 t2[1] = p1sp3_1 - p2[0] + p4[0];
392 // col 3
393 t3[0] = p1ap3_0 - p2[0] - p4[0];
394 t3[1] = p1ap3_1 - p2[1] - p4[1];
395 // col 4
396 t4[0] = p1sp3_0 - p2[1] + p4[1];
397 t4[1] = p1sp3_1 + p2[0] - p4[0];
398 // col 1 - top
399 *p1++ = p1ap3_0 + p2[0] + p4[0];
400 *p1++ = p1ap3_1 + p2[1] + p4[1];
401
402 // BOTTOM
403 p1ap3_1 = pEnd1[-1] + pEnd3[-1];
404 p1sp3_1 = pEnd1[-1] - pEnd3[-1];
405 p1ap3_0 = pEnd1[0] + pEnd3[0];
406 p1sp3_0 = pEnd1[0] - pEnd3[0];
407 // col 2
408 t2[2] = pEnd2[0] - pEnd4[0] + p1sp3_1;
409 t2[3] = pEnd1[0] - pEnd3[0] - pEnd2[-1] + pEnd4[-1];
410 // col 3
411 t3[2] = p1ap3_1 - pEnd2[-1] - pEnd4[-1];
412 t3[3] = p1ap3_0 - pEnd2[0] - pEnd4[0];
413 // col 4
414 t4[2] = pEnd2[0] - pEnd4[0] - p1sp3_1;
415 t4[3] = pEnd4[-1] - pEnd2[-1] - p1sp3_0;
416 // col 1 - Bottom
417 *pEnd1-- = p1ap3_0 + pEnd2[0] + pEnd4[0];
418 *pEnd1-- = p1ap3_1 + pEnd2[-1] + pEnd4[-1];
419
420 // COL 2
421 // read twiddle factors
422 twR = *tw2++;
423 twI = *tw2++;
424 // multiply by twiddle factors
425 // let Z1 = a + i(b), Z2 = c + i(d)
426 // => Z1 * Z2 = (a*c - b*d) + i(b*c + a*d)
427
428 // Top
429 m0 = t2[0] * twR;
430 m1 = t2[1] * twI;
431 m2 = t2[1] * twR;
432 m3 = t2[0] * twI;
433
434 *p2++ = m0 + m1;
435 *p2++ = m2 - m3;
436 // use vertical symmetry col 2
437 // 0.9997 - 0.0245i <==> 0.0245 - 0.9997i
438 // Bottom
439 m0 = t2[3] * twI;
440 m1 = t2[2] * twR;
441 m2 = t2[2] * twI;
442 m3 = t2[3] * twR;
443
444 *pEnd2-- = m0 - m1;
445 *pEnd2-- = m2 + m3;
446
447 // COL 3
448 twR = tw3[0];
449 twI = tw3[1];
450 tw3 += twMod3;
451 // Top
452 m0 = t3[0] * twR;
453 m1 = t3[1] * twI;
454 m2 = t3[1] * twR;
455 m3 = t3[0] * twI;
456
457 *p3++ = m0 + m1;
458 *p3++ = m2 - m3;
459 // use vertical symmetry col 3
460 // 0.9988 - 0.0491i <==> -0.9988 - 0.0491i
461 // Bottom
462 m0 = -t3[3] * twR;
463 m1 = t3[2] * twI;
464 m2 = t3[2] * twR;
465 m3 = t3[3] * twI;
466
467 *pEnd3-- = m0 - m1;
468 *pEnd3-- = m3 - m2;
469
470 // COL 4
471 twR = tw4[0];
472 twI = tw4[1];
473 tw4 += twMod4;
474 // Top
475 m0 = t4[0] * twR;
476 m1 = t4[1] * twI;
477 m2 = t4[1] * twR;
478 m3 = t4[0] * twI;
479
480 *p4++ = m0 + m1;
481 *p4++ = m2 - m3;
482 // use vertical symmetry col 4
483 // 0.9973 - 0.0736i <==> -0.0736 + 0.9973i
484 // Bottom
485 m0 = t4[3] * twI;
486 m1 = t4[2] * twR;
487 m2 = t4[2] * twI;
488 m3 = t4[3] * twR;
489
490 *pEnd4-- = m0 - m1;
491 *pEnd4-- = m2 + m3;
492 }
493
494 //MIDDLE
495 // Twiddle factors are
496 // 1.0000 0.7071-0.7071i -1.0000i -0.7071-0.7071i
497 p1ap3_0 = p1[0] + p3[0];
498 p1sp3_0 = p1[0] - p3[0];
499 p1ap3_1 = p1[1] + p3[1];
500 p1sp3_1 = p1[1] - p3[1];
501
502 // col 2
503 t2[0] = p1sp3_0 + p2[1] - p4[1];
504 t2[1] = p1sp3_1 - p2[0] + p4[0];
505 // col 3
506 t3[0] = p1ap3_0 - p2[0] - p4[0];
507 t3[1] = p1ap3_1 - p2[1] - p4[1];
508 // col 4
509 t4[0] = p1sp3_0 - p2[1] + p4[1];
510 t4[1] = p1sp3_1 + p2[0] - p4[0];
511 // col 1 - Top
512 *p1++ = p1ap3_0 + p2[0] + p4[0];
513 *p1++ = p1ap3_1 + p2[1] + p4[1];
514
515 // COL 2
516 twR = tw2[0];
517 twI = tw2[1];
518
519 m0 = t2[0] * twR;
520 m1 = t2[1] * twI;
521 m2 = t2[1] * twR;
522 m3 = t2[0] * twI;
523
524 *p2++ = m0 + m1;
525 *p2++ = m2 - m3;
526 // COL 3
527 twR = tw3[0];
528 twI = tw3[1];
529
530 m0 = t3[0] * twR;
531 m1 = t3[1] * twI;
532 m2 = t3[1] * twR;
533 m3 = t3[0] * twI;
534
535 *p3++ = m0 + m1;
536 *p3++ = m2 - m3;
537 // COL 4
538 twR = tw4[0];
539 twI = tw4[1];
540
541 m0 = t4[0] * twR;
542 m1 = t4[1] * twI;
543 m2 = t4[1] * twR;
544 m3 = t4[0] * twI;
545
546 *p4++ = m0 + m1;
547 *p4++ = m2 - m3;
548
549 // first col
550 arm_radix8_butterfly_f32( pCol1, L, (float32_t *) S->pTwiddle, 4u);
551 // second col
552 arm_radix8_butterfly_f32( pCol2, L, (float32_t *) S->pTwiddle, 4u);
553 // third col
554 arm_radix8_butterfly_f32( pCol3, L, (float32_t *) S->pTwiddle, 4u);
555 // fourth col
556 arm_radix8_butterfly_f32( pCol4, L, (float32_t *) S->pTwiddle, 4u);
557 }
558
559 /**
560 * @addtogroup ComplexFFT
561 * @{
562 */
563
564 /**
565 * @details
566 * @brief Processing function for the floating-point complex FFT.
567 * @param[in] *S points to an instance of the floating-point CFFT structure.
568 * @param[in, out] *p1 points to the complex data buffer of size <code>2*fftLen</code>. Processing occurs in-place.
569 * @param[in] ifftFlag flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform.
570 * @param[in] bitReverseFlag flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output.
571 * @return none.
572 */
573
arm_cfft_f32(const arm_cfft_instance_f32 * S,float32_t * p1,uint8_t ifftFlag,uint8_t bitReverseFlag)574 void arm_cfft_f32(
575 const arm_cfft_instance_f32 * S,
576 float32_t * p1,
577 uint8_t ifftFlag,
578 uint8_t bitReverseFlag)
579 {
580 uint32_t L = S->fftLen, l;
581 float32_t invL, * pSrc;
582
583 if(ifftFlag == 1u)
584 {
585 /* Conjugate input data */
586 pSrc = p1 + 1;
587 for(l=0; l<L; l++)
588 {
589 *pSrc = -*pSrc;
590 pSrc += 2;
591 }
592 }
593
594 switch (L)
595 {
596 case 16:
597 case 128:
598 case 1024:
599 arm_cfft_radix8by2_f32 ( (arm_cfft_instance_f32 *) S, p1);
600 break;
601 case 32:
602 case 256:
603 case 2048:
604 arm_cfft_radix8by4_f32 ( (arm_cfft_instance_f32 *) S, p1);
605 break;
606 case 64:
607 case 512:
608 case 4096:
609 arm_radix8_butterfly_f32( p1, L, (float32_t *) S->pTwiddle, 1);
610 break;
611 }
612
613 if( bitReverseFlag )
614 arm_bitreversal_32((uint32_t*)p1,S->bitRevLength,S->pBitRevTable);
615
616 if(ifftFlag == 1u)
617 {
618 invL = 1.0f/(float32_t)L;
619 /* Conjugate and scale output data */
620 pSrc = p1;
621 for(l=0; l<L; l++)
622 {
623 *pSrc++ *= invL ;
624 *pSrc = -(*pSrc) * invL;
625 pSrc++;
626 }
627 }
628 }
629
630 /**
631 * @} end of ComplexFFT group
632 */
633