arm_cfft_radix2_q31.c

00001 /* ----------------------------------------------------------------------
00002  * Project:      CMSIS DSP Library
00003  * Title:        arm_cfft_radix2_q31.c
00004  * Description:  Radix-2 Decimation in Frequency CFFT & CIFFT Fixed point processing function
00005  *
00006  * $Date:        27. January 2017
00007  * $Revision:    V.1.5.1
00008  *
00009  * Target Processor: Cortex-M cores
00010  * -------------------------------------------------------------------- */
00011 /*
00012  * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved.
00013  *
00014  * SPDX-License-Identifier: Apache-2.0
00015  *
00016  * Licensed under the Apache License, Version 2.0 (the License); you may
00017  * not use this file except in compliance with the License.
00018  * You may obtain a copy of the License at
00019  *
00020  * www.apache.org/licenses/LICENSE-2.0
00021  *
00022  * Unless required by applicable law or agreed to in writing, software
00023  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00024  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00025  * See the License for the specific language governing permissions and
00026  * limitations under the License.
00027  */
00028 
00029 #include "arm_math.h"
00030 
00031 void arm_radix2_butterfly_q31(
00032   q31_t * pSrc,
00033   uint32_t fftLen,
00034   q31_t * pCoef,
00035   uint16_t twidCoefModifier);
00036 
00037 void arm_radix2_butterfly_inverse_q31(
00038   q31_t * pSrc,
00039   uint32_t fftLen,
00040   q31_t * pCoef,
00041   uint16_t twidCoefModifier);
00042 
00043 void arm_bitreversal_q31(
00044   q31_t * pSrc,
00045   uint32_t fftLen,
00046   uint16_t bitRevFactor,
00047   uint16_t * pBitRevTab);
00048 
00049 /**
00050 * @ingroup groupTransforms
00051 */
00052 
00053 /**
00054 * @addtogroup ComplexFFT
00055 * @{
00056 */
00057 
00058 /**
00059 * @details
00060 * @brief Processing function for the fixed-point CFFT/CIFFT.
00061 * @deprecated Do not use this function.  It has been superseded by \ref arm_cfft_q31 and will be removed
00062 * @param[in]      *S    points to an instance of the fixed-point CFFT/CIFFT structure.
00063 * @param[in, out] *pSrc points to the complex data buffer of size <code>2*fftLen</code>. Processing occurs in-place.
00064 * @return none.
00065 */
00066 
00067 void arm_cfft_radix2_q31(
00068 const arm_cfft_radix2_instance_q31 * S,
00069 q31_t * pSrc)
00070 {
00071 
00072    if (S->ifftFlag == 1U)
00073    {
00074       arm_radix2_butterfly_inverse_q31(pSrc, S->fftLen,
00075       S->pTwiddle, S->twidCoefModifier);
00076    }
00077    else
00078    {
00079       arm_radix2_butterfly_q31(pSrc, S->fftLen,
00080       S->pTwiddle, S->twidCoefModifier);
00081    }
00082 
00083    arm_bitreversal_q31(pSrc, S->fftLen, S->bitRevFactor, S->pBitRevTable);
00084 }
00085 
00086 /**
00087 * @} end of ComplexFFT group
00088 */
00089 
00090 void arm_radix2_butterfly_q31(
00091 q31_t * pSrc,
00092 uint32_t fftLen,
00093 q31_t * pCoef,
00094 uint16_t twidCoefModifier)
00095 {
00096 
00097    unsigned i, j, k, l, m;
00098    unsigned n1, n2, ia;
00099    q31_t xt, yt, cosVal, sinVal;
00100    q31_t p0, p1;
00101 
00102    //N = fftLen;
00103    n2 = fftLen;
00104 
00105    n1 = n2;
00106    n2 = n2 >> 1;
00107    ia = 0;
00108 
00109    // loop for groups
00110    for (i = 0; i < n2; i++)
00111    {
00112       cosVal = pCoef[ia * 2];
00113       sinVal = pCoef[(ia * 2) + 1];
00114       ia = ia + twidCoefModifier;
00115 
00116       l = i + n2;
00117       xt = (pSrc[2 * i] >> 1U) - (pSrc[2 * l] >> 1U);
00118       pSrc[2 * i] = ((pSrc[2 * i] >> 1U) + (pSrc[2 * l] >> 1U)) >> 1U;
00119 
00120       yt = (pSrc[2 * i + 1] >> 1U) - (pSrc[2 * l + 1] >> 1U);
00121       pSrc[2 * i + 1] =
00122         ((pSrc[2 * l + 1] >> 1U) + (pSrc[2 * i + 1] >> 1U)) >> 1U;
00123 
00124       mult_32x32_keep32_R(p0, xt, cosVal);
00125       mult_32x32_keep32_R(p1, yt, cosVal);
00126       multAcc_32x32_keep32_R(p0, yt, sinVal);
00127       multSub_32x32_keep32_R(p1, xt, sinVal);
00128 
00129       pSrc[2U * l] = p0;
00130       pSrc[2U * l + 1U] = p1;
00131 
00132    }                             // groups loop end
00133 
00134    twidCoefModifier <<= 1U;
00135 
00136    // loop for stage
00137    for (k = fftLen / 2; k > 2; k = k >> 1)
00138    {
00139       n1 = n2;
00140       n2 = n2 >> 1;
00141       ia = 0;
00142 
00143       // loop for groups
00144       for (j = 0; j < n2; j++)
00145       {
00146          cosVal = pCoef[ia * 2];
00147          sinVal = pCoef[(ia * 2) + 1];
00148          ia = ia + twidCoefModifier;
00149 
00150          // loop for butterfly
00151          i = j;
00152          m = fftLen / n1;
00153          do
00154          {
00155             l = i + n2;
00156             xt = pSrc[2 * i] - pSrc[2 * l];
00157             pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]) >> 1U;
00158 
00159             yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00160             pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]) >> 1U;
00161 
00162             mult_32x32_keep32_R(p0, xt, cosVal);
00163             mult_32x32_keep32_R(p1, yt, cosVal);
00164             multAcc_32x32_keep32_R(p0, yt, sinVal);
00165             multSub_32x32_keep32_R(p1, xt, sinVal);
00166 
00167             pSrc[2U * l] = p0;
00168             pSrc[2U * l + 1U] = p1;
00169             i += n1;
00170             m--;
00171          } while ( m > 0);                   // butterfly loop end
00172 
00173       }                           // groups loop end
00174 
00175       twidCoefModifier <<= 1U;
00176    }                             // stages loop end
00177 
00178    n1 = n2;
00179    n2 = n2 >> 1;
00180    ia = 0;
00181 
00182    cosVal = pCoef[ia * 2];
00183    sinVal = pCoef[(ia * 2) + 1];
00184    ia = ia + twidCoefModifier;
00185 
00186    // loop for butterfly
00187    for (i = 0; i < fftLen; i += n1)
00188    {
00189       l = i + n2;
00190       xt = pSrc[2 * i] - pSrc[2 * l];
00191       pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]);
00192 
00193       yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00194       pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]);
00195 
00196       pSrc[2U * l] = xt;
00197 
00198       pSrc[2U * l + 1U] = yt;
00199 
00200       i += n1;
00201       l = i + n2;
00202 
00203       xt = pSrc[2 * i] - pSrc[2 * l];
00204       pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]);
00205 
00206       yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00207       pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]);
00208 
00209       pSrc[2U * l] = xt;
00210 
00211       pSrc[2U * l + 1U] = yt;
00212 
00213    }                             // butterfly loop end
00214 
00215 }
00216 
00217 
00218 void arm_radix2_butterfly_inverse_q31(
00219 q31_t * pSrc,
00220 uint32_t fftLen,
00221 q31_t * pCoef,
00222 uint16_t twidCoefModifier)
00223 {
00224 
00225    unsigned i, j, k, l;
00226    unsigned n1, n2, ia;
00227    q31_t xt, yt, cosVal, sinVal;
00228    q31_t p0, p1;
00229 
00230    //N = fftLen;
00231    n2 = fftLen;
00232 
00233    n1 = n2;
00234    n2 = n2 >> 1;
00235    ia = 0;
00236 
00237    // loop for groups
00238    for (i = 0; i < n2; i++)
00239    {
00240       cosVal = pCoef[ia * 2];
00241       sinVal = pCoef[(ia * 2) + 1];
00242       ia = ia + twidCoefModifier;
00243 
00244       l = i + n2;
00245       xt = (pSrc[2 * i] >> 1U) - (pSrc[2 * l] >> 1U);
00246       pSrc[2 * i] = ((pSrc[2 * i] >> 1U) + (pSrc[2 * l] >> 1U)) >> 1U;
00247 
00248       yt = (pSrc[2 * i + 1] >> 1U) - (pSrc[2 * l + 1] >> 1U);
00249       pSrc[2 * i + 1] =
00250         ((pSrc[2 * l + 1] >> 1U) + (pSrc[2 * i + 1] >> 1U)) >> 1U;
00251 
00252       mult_32x32_keep32_R(p0, xt, cosVal);
00253       mult_32x32_keep32_R(p1, yt, cosVal);
00254       multSub_32x32_keep32_R(p0, yt, sinVal);
00255       multAcc_32x32_keep32_R(p1, xt, sinVal);
00256 
00257       pSrc[2U * l] = p0;
00258       pSrc[2U * l + 1U] = p1;
00259    }                             // groups loop end
00260 
00261    twidCoefModifier = twidCoefModifier << 1U;
00262 
00263    // loop for stage
00264    for (k = fftLen / 2; k > 2; k = k >> 1)
00265    {
00266       n1 = n2;
00267       n2 = n2 >> 1;
00268       ia = 0;
00269 
00270       // loop for groups
00271       for (j = 0; j < n2; j++)
00272       {
00273          cosVal = pCoef[ia * 2];
00274          sinVal = pCoef[(ia * 2) + 1];
00275          ia = ia + twidCoefModifier;
00276 
00277          // loop for butterfly
00278          for (i = j; i < fftLen; i += n1)
00279          {
00280             l = i + n2;
00281             xt = pSrc[2 * i] - pSrc[2 * l];
00282             pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]) >> 1U;
00283 
00284             yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00285             pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]) >> 1U;
00286 
00287             mult_32x32_keep32_R(p0, xt, cosVal);
00288             mult_32x32_keep32_R(p1, yt, cosVal);
00289             multSub_32x32_keep32_R(p0, yt, sinVal);
00290             multAcc_32x32_keep32_R(p1, xt, sinVal);
00291 
00292             pSrc[2U * l] = p0;
00293             pSrc[2U * l + 1U] = p1;
00294          }                         // butterfly loop end
00295 
00296       }                           // groups loop end
00297 
00298       twidCoefModifier = twidCoefModifier << 1U;
00299    }                             // stages loop end
00300 
00301    n1 = n2;
00302    n2 = n2 >> 1;
00303    ia = 0;
00304 
00305    cosVal = pCoef[ia * 2];
00306    sinVal = pCoef[(ia * 2) + 1];
00307    ia = ia + twidCoefModifier;
00308 
00309    // loop for butterfly
00310    for (i = 0; i < fftLen; i += n1)
00311    {
00312       l = i + n2;
00313       xt = pSrc[2 * i] - pSrc[2 * l];
00314       pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]);
00315 
00316       yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00317       pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]);
00318 
00319       pSrc[2U * l] = xt;
00320 
00321       pSrc[2U * l + 1U] = yt;
00322 
00323       i += n1;
00324       l = i + n2;
00325 
00326       xt = pSrc[2 * i] - pSrc[2 * l];
00327       pSrc[2 * i] = (pSrc[2 * i] + pSrc[2 * l]);
00328 
00329       yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
00330       pSrc[2 * i + 1] = (pSrc[2 * l + 1] + pSrc[2 * i + 1]);
00331 
00332       pSrc[2U * l] = xt;
00333 
00334       pSrc[2U * l + 1U] = yt;
00335 
00336    }                             // butterfly loop end
00337 
00338 }
00339