diff options
Diffstat (limited to 'Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c')
| -rw-r--r-- | Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c | 255 |
1 files changed, 129 insertions, 126 deletions
diff --git a/Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c b/Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c index f7c52e959..7a1af1461 100644 --- a/Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c +++ b/Drivers/CMSIS/DSP/Source/TransformFunctions/arm_rfft_fast_f32.c @@ -3,13 +3,13 @@ * Title: arm_rfft_f32.c * Description: RFFT & RIFFT Floating point process function * - * $Date: 27. January 2017 - * $Revision: V.1.5.1 + * $Date: 18. March 2019 + * $Revision: V1.6.0 * * Target Processor: Cortex-M cores * -------------------------------------------------------------------- */ /* - * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved. + * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved. * * SPDX-License-Identifier: Apache-2.0 * @@ -29,17 +29,18 @@ #include "arm_math.h" void stage_rfft_f32( - arm_rfft_fast_instance_f32 * S, - float32_t * p, float32_t * pOut) + const arm_rfft_fast_instance_f32 * S, + float32_t * p, + float32_t * pOut) { - uint32_t k; /* Loop Counter */ - float32_t twR, twI; /* RFFT Twiddle coefficients */ - float32_t * pCoeff = S->pTwiddleRFFT; /* Points to RFFT Twiddle factors */ - float32_t *pA = p; /* increasing pointer */ - float32_t *pB = p; /* decreasing pointer */ - float32_t xAR, xAI, xBR, xBI; /* temporary variables */ - float32_t t1a, t1b; /* temporary variables */ - float32_t p0, p1, p2, p3; /* temporary variables */ + uint32_t k; /* Loop Counter */ + float32_t twR, twI; /* RFFT Twiddle coefficients */ + const float32_t * pCoeff = S->pTwiddleRFFT; /* Points to RFFT Twiddle factors */ + float32_t *pA = p; /* increasing pointer */ + float32_t *pB = p; /* decreasing pointer */ + float32_t xAR, xAI, xBR, xBI; /* temporary variables */ + float32_t t1a, t1b; /* temporary variables */ + float32_t p0, p1, p2, p3; /* temporary variables */ k = (S->Sint).fftLen - 1; @@ -115,16 +116,17 @@ void stage_rfft_f32( /* Prepares data for inverse cfft */ void merge_rfft_f32( -arm_rfft_fast_instance_f32 * S, -float32_t * p, float32_t * pOut) + const arm_rfft_fast_instance_f32 * S, + float32_t * p, + float32_t * pOut) { - uint32_t k; /* Loop Counter */ - float32_t twR, twI; /* RFFT Twiddle coefficients */ - float32_t *pCoeff = S->pTwiddleRFFT; /* Points to RFFT Twiddle factors */ - float32_t *pA = p; /* increasing pointer */ - float32_t *pB = p; /* decreasing pointer */ - float32_t xAR, xAI, xBR, xBI; /* temporary variables */ - float32_t t1a, t1b, r, s, t, u; /* temporary variables */ + uint32_t k; /* Loop Counter */ + float32_t twR, twI; /* RFFT Twiddle coefficients */ + const float32_t *pCoeff = S->pTwiddleRFFT; /* Points to RFFT Twiddle factors */ + float32_t *pA = p; /* increasing pointer */ + float32_t *pB = p; /* decreasing pointer */ + float32_t xAR, xAI, xBR, xBI; /* temporary variables */ + float32_t t1a, t1b, r, s, t, u; /* temporary variables */ k = (S->Sint).fftLen - 1; @@ -173,122 +175,123 @@ float32_t * p, float32_t * pOut) } /** -* @ingroup groupTransforms + @ingroup groupTransforms */ /** - * @defgroup RealFFT Real FFT Functions - * - * \par - * The CMSIS DSP library includes specialized algorithms for computing the - * FFT of real data sequences. The FFT is defined over complex data but - * in many applications the input is real. Real FFT algorithms take advantage - * of the symmetry properties of the FFT and have a speed advantage over complex - * algorithms of the same length. - * \par - * The Fast RFFT algorith relays on the mixed radix CFFT that save processor usage. - * \par - * The real length N forward FFT of a sequence is computed using the steps shown below. - * \par - * \image html RFFT.gif "Real Fast Fourier Transform" - * \par - * The real sequence is initially treated as if it were complex to perform a CFFT. - * Later, a processing stage reshapes the data to obtain half of the frequency spectrum - * in complex format. Except the first complex number that contains the two real numbers - * X[0] and X[N/2] all the data is complex. In other words, the first complex sample - * contains two real values packed. - * \par - * The input for the inverse RFFT should keep the same format as the output of the - * forward RFFT. A first processing stage pre-process the data to later perform an - * inverse CFFT. - * \par - * \image html RIFFT.gif "Real Inverse Fast Fourier Transform" - * \par - * The algorithms for floating-point, Q15, and Q31 data are slightly different - * and we describe each algorithm in turn. - * \par Floating-point - * The main functions are arm_rfft_fast_f32() and arm_rfft_fast_init_f32(). - * The older functions arm_rfft_f32() and arm_rfft_init_f32() have been - * deprecated but are still documented. - * \par - * The FFT of a real N-point sequence has even symmetry in the frequency - * domain. The second half of the data equals the conjugate of the first - * half flipped in frequency. Looking at the data, we see that we can - * uniquely represent the FFT using only N/2 complex numbers. These are - * packed into the output array in alternating real and imaginary - * components: - * \par - * X = { real[0], imag[0], real[1], imag[1], real[2], imag[2] ... - * real[(N/2)-1], imag[(N/2)-1 } - * \par - * It happens that the first complex number (real[0], imag[0]) is actually - * all real. real[0] represents the DC offset, and imag[0] should be 0. - * (real[1], imag[1]) is the fundamental frequency, (real[2], imag[2]) is - * the first harmonic and so on. - * \par - * The real FFT functions pack the frequency domain data in this fashion. - * The forward transform outputs the data in this form and the inverse - * transform expects input data in this form. The function always performs - * the needed bitreversal so that the input and output data is always in - * normal order. The functions support lengths of [32, 64, 128, ..., 4096] - * samples. - * \par Q15 and Q31 - * The real algorithms are defined in a similar manner and utilize N/2 complex - * transforms behind the scenes. - * \par - * The complex transforms used internally include scaling to prevent fixed-point - * overflows. The overall scaling equals 1/(fftLen/2). - * \par - * A separate instance structure must be defined for each transform used but - * twiddle factor and bit reversal tables can be reused. - * \par - * There is also an associated initialization function for each data type. - * The initialization function performs the following operations: - * - Sets the values of the internal structure fields. - * - Initializes twiddle factor table and bit reversal table pointers. - * - Initializes the internal complex FFT data structure. - * \par - * Use of the initialization function is optional. - * However, if the initialization function is used, then the instance structure - * cannot be placed into a const data section. To place an instance structure - * into a const data section, the instance structure should be manually - * initialized as follows: - * <pre> - *arm_rfft_instance_q31 S = {fftLenReal, fftLenBy2, ifftFlagR, bitReverseFlagR, twidCoefRModifier, pTwiddleAReal, pTwiddleBReal, pCfft}; - *arm_rfft_instance_q15 S = {fftLenReal, fftLenBy2, ifftFlagR, bitReverseFlagR, twidCoefRModifier, pTwiddleAReal, pTwiddleBReal, pCfft}; - * </pre> - * where <code>fftLenReal</code> is the length of the real transform; - * <code>fftLenBy2</code> length of the internal complex transform. - * <code>ifftFlagR</code> Selects forward (=0) or inverse (=1) transform. - * <code>bitReverseFlagR</code> Selects bit reversed output (=0) or normal order - * output (=1). - * <code>twidCoefRModifier</code> stride modifier for the twiddle factor table. - * The value is based on the FFT length; - * <code>pTwiddleAReal</code>points to the A array of twiddle coefficients; - * <code>pTwiddleBReal</code>points to the B array of twiddle coefficients; - * <code>pCfft</code> points to the CFFT Instance structure. The CFFT structure - * must also be initialized. Refer to arm_cfft_radix4_f32() for details regarding - * static initialization of the complex FFT instance structure. + @defgroup RealFFT Real FFT Functions + + @par + The CMSIS DSP library includes specialized algorithms for computing the + FFT of real data sequences. The FFT is defined over complex data but + in many applications the input is real. Real FFT algorithms take advantage + of the symmetry properties of the FFT and have a speed advantage over complex + algorithms of the same length. + @par + The Fast RFFT algorith relays on the mixed radix CFFT that save processor usage. + @par + The real length N forward FFT of a sequence is computed using the steps shown below. + @par + \image html RFFT.gif "Real Fast Fourier Transform" + @par + The real sequence is initially treated as if it were complex to perform a CFFT. + Later, a processing stage reshapes the data to obtain half of the frequency spectrum + in complex format. Except the first complex number that contains the two real numbers + X[0] and X[N/2] all the data is complex. In other words, the first complex sample + contains two real values packed. + @par + The input for the inverse RFFT should keep the same format as the output of the + forward RFFT. A first processing stage pre-process the data to later perform an + inverse CFFT. + @par + \image html RIFFT.gif "Real Inverse Fast Fourier Transform" + @par + The algorithms for floating-point, Q15, and Q31 data are slightly different + and we describe each algorithm in turn. + @par Floating-point + The main functions are \ref arm_rfft_fast_f32() and \ref arm_rfft_fast_init_f32(). + The older functions \ref arm_rfft_f32() and \ref arm_rfft_init_f32() have been deprecated + but are still documented. + @par + The FFT of a real N-point sequence has even symmetry in the frequency domain. + The second half of the data equals the conjugate of the first half flipped in frequency. + Looking at the data, we see that we can uniquely represent the FFT using only N/2 complex numbers. + These are packed into the output array in alternating real and imaginary components: + @par + X = { real[0], imag[0], real[1], imag[1], real[2], imag[2] ... + real[(N/2)-1], imag[(N/2)-1 } + @par + It happens that the first complex number (real[0], imag[0]) is actually + all real. real[0] represents the DC offset, and imag[0] should be 0. + (real[1], imag[1]) is the fundamental frequency, (real[2], imag[2]) is + the first harmonic and so on. + @par + The real FFT functions pack the frequency domain data in this fashion. + The forward transform outputs the data in this form and the inverse + transform expects input data in this form. The function always performs + the needed bitreversal so that the input and output data is always in + normal order. The functions support lengths of [32, 64, 128, ..., 4096] + samples. + @par Q15 and Q31 + The real algorithms are defined in a similar manner and utilize N/2 complex + transforms behind the scenes. + @par + The complex transforms used internally include scaling to prevent fixed-point + overflows. The overall scaling equals 1/(fftLen/2). + @par + A separate instance structure must be defined for each transform used but + twiddle factor and bit reversal tables can be reused. + @par + There is also an associated initialization function for each data type. + The initialization function performs the following operations: + - Sets the values of the internal structure fields. + - Initializes twiddle factor table and bit reversal table pointers. + - Initializes the internal complex FFT data structure. + @par + Use of the initialization function is optional. + However, if the initialization function is used, then the instance structure + cannot be placed into a const data section. To place an instance structure + into a const data section, the instance structure should be manually + initialized as follows: + <pre> + arm_rfft_instance_q31 S = {fftLenReal, fftLenBy2, ifftFlagR, bitReverseFlagR, twidCoefRModifier, pTwiddleAReal, pTwiddleBReal, pCfft}; + arm_rfft_instance_q15 S = {fftLenReal, fftLenBy2, ifftFlagR, bitReverseFlagR, twidCoefRModifier, pTwiddleAReal, pTwiddleBReal, pCfft}; + </pre> + where <code>fftLenReal</code> is the length of the real transform; + <code>fftLenBy2</code> length of the internal complex transform. + <code>ifftFlagR</code> Selects forward (=0) or inverse (=1) transform. + <code>bitReverseFlagR</code> Selects bit reversed output (=0) or normal order + output (=1). + <code>twidCoefRModifier</code> stride modifier for the twiddle factor table. + The value is based on the FFT length; + <code>pTwiddleAReal</code>points to the A array of twiddle coefficients; + <code>pTwiddleBReal</code>points to the B array of twiddle coefficients; + <code>pCfft</code> points to the CFFT Instance structure. The CFFT structure + must also be initialized. Refer to arm_cfft_radix4_f32() for details regarding + static initialization of the complex FFT instance structure. */ /** -* @addtogroup RealFFT -* @{ + @addtogroup RealFFT + @{ */ /** -* @brief Processing function for the floating-point real FFT. -* @param[in] *S points to an arm_rfft_fast_instance_f32 structure. -* @param[in] *p points to the input buffer. -* @param[in] *pOut points to the output buffer. -* @param[in] ifftFlag RFFT if flag is 0, RIFFT if flag is 1 -* @return none. + @brief Processing function for the floating-point real FFT. + @param[in] S points to an arm_rfft_fast_instance_f32 structure + @param[in] p points to input buffer + @param[in] pOut points to output buffer + @param[in] ifftFlag + - value = 0: RFFT + - value = 1: RIFFT + @return none */ void arm_rfft_fast_f32( -arm_rfft_fast_instance_f32 * S, -float32_t * p, float32_t * pOut, -uint8_t ifftFlag) + arm_rfft_fast_instance_f32 * S, + float32_t * p, + float32_t * pOut, + uint8_t ifftFlag) { arm_cfft_instance_f32 * Sint = &(S->Sint); Sint->fftLen = S->fftLenRFFT / 2; |