Subversion Repositories AFRtranscoder

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* ----------------------------------------------------------------------
  2.  * Project:      CMSIS DSP Library
  3.  * Title:        arm_bitreversal.c
  4.  * Description:  Bitreversal functions
  5.  *
  6.  * $Date:        27. January 2017
  7.  * $Revision:    V.1.5.1
  8.  *
  9.  * Target Processor: Cortex-M cores
  10.  * -------------------------------------------------------------------- */
  11. /*
  12.  * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved.
  13.  *
  14.  * SPDX-License-Identifier: Apache-2.0
  15.  *
  16.  * Licensed under the Apache License, Version 2.0 (the License); you may
  17.  * not use this file except in compliance with the License.
  18.  * You may obtain a copy of the License at
  19.  *
  20.  * www.apache.org/licenses/LICENSE-2.0
  21.  *
  22.  * Unless required by applicable law or agreed to in writing, software
  23.  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
  24.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  25.  * See the License for the specific language governing permissions and
  26.  * limitations under the License.
  27.  */
  28.  
  29. #include "arm_math.h"
  30. #include "arm_common_tables.h"
  31.  
  32. /*
  33. * @brief  In-place bit reversal function.
  34. * @param[in, out] *pSrc        points to the in-place buffer of floating-point data type.
  35. * @param[in]      fftSize      length of the FFT.
  36. * @param[in]      bitRevFactor bit reversal modifier that supports different size FFTs with the same bit reversal table.
  37. * @param[in]      *pBitRevTab  points to the bit reversal table.
  38. * @return none.
  39. */
  40.  
  41. void arm_bitreversal_f32(
  42. float32_t * pSrc,
  43. uint16_t fftSize,
  44. uint16_t bitRevFactor,
  45. uint16_t * pBitRevTab)
  46. {
  47.    uint16_t fftLenBy2, fftLenBy2p1;
  48.    uint16_t i, j;
  49.    float32_t in;
  50.  
  51.    /*  Initializations */
  52.    j = 0U;
  53.    fftLenBy2 = fftSize >> 1U;
  54.    fftLenBy2p1 = (fftSize >> 1U) + 1U;
  55.  
  56.    /* Bit Reversal Implementation */
  57.    for (i = 0U; i <= (fftLenBy2 - 2U); i += 2U)
  58.    {
  59.       if (i < j)
  60.       {
  61.          /*  pSrc[i] <-> pSrc[j]; */
  62.          in = pSrc[2U * i];
  63.          pSrc[2U * i] = pSrc[2U * j];
  64.          pSrc[2U * j] = in;
  65.  
  66.          /*  pSrc[i+1U] <-> pSrc[j+1U] */
  67.          in = pSrc[(2U * i) + 1U];
  68.          pSrc[(2U * i) + 1U] = pSrc[(2U * j) + 1U];
  69.          pSrc[(2U * j) + 1U] = in;
  70.  
  71.          /*  pSrc[i+fftLenBy2p1] <-> pSrc[j+fftLenBy2p1] */
  72.          in = pSrc[2U * (i + fftLenBy2p1)];
  73.          pSrc[2U * (i + fftLenBy2p1)] = pSrc[2U * (j + fftLenBy2p1)];
  74.          pSrc[2U * (j + fftLenBy2p1)] = in;
  75.  
  76.          /*  pSrc[i+fftLenBy2p1+1U] <-> pSrc[j+fftLenBy2p1+1U] */
  77.          in = pSrc[(2U * (i + fftLenBy2p1)) + 1U];
  78.          pSrc[(2U * (i + fftLenBy2p1)) + 1U] =
  79.          pSrc[(2U * (j + fftLenBy2p1)) + 1U];
  80.          pSrc[(2U * (j + fftLenBy2p1)) + 1U] = in;
  81.  
  82.       }
  83.  
  84.       /*  pSrc[i+1U] <-> pSrc[j+1U] */
  85.       in = pSrc[2U * (i + 1U)];
  86.       pSrc[2U * (i + 1U)] = pSrc[2U * (j + fftLenBy2)];
  87.       pSrc[2U * (j + fftLenBy2)] = in;
  88.  
  89.       /*  pSrc[i+2U] <-> pSrc[j+2U] */
  90.       in = pSrc[(2U * (i + 1U)) + 1U];
  91.       pSrc[(2U * (i + 1U)) + 1U] = pSrc[(2U * (j + fftLenBy2)) + 1U];
  92.       pSrc[(2U * (j + fftLenBy2)) + 1U] = in;
  93.  
  94.       /*  Reading the index for the bit reversal */
  95.       j = *pBitRevTab;
  96.  
  97.       /*  Updating the bit reversal index depending on the fft length  */
  98.       pBitRevTab += bitRevFactor;
  99.    }
  100. }
  101.  
  102.  
  103.  
  104. /*
  105. * @brief  In-place bit reversal function.
  106. * @param[in, out] *pSrc        points to the in-place buffer of Q31 data type.
  107. * @param[in]      fftLen       length of the FFT.
  108. * @param[in]      bitRevFactor bit reversal modifier that supports different size FFTs with the same bit reversal table
  109. * @param[in]      *pBitRevTab  points to bit reversal table.
  110. * @return none.
  111. */
  112.  
  113. void arm_bitreversal_q31(
  114. q31_t * pSrc,
  115. uint32_t fftLen,
  116. uint16_t bitRevFactor,
  117. uint16_t * pBitRevTable)
  118. {
  119.    uint32_t fftLenBy2, fftLenBy2p1, i, j;
  120.    q31_t in;
  121.  
  122.    /*  Initializations      */
  123.    j = 0U;
  124.    fftLenBy2 = fftLen / 2U;
  125.    fftLenBy2p1 = (fftLen / 2U) + 1U;
  126.  
  127.    /* Bit Reversal Implementation */
  128.    for (i = 0U; i <= (fftLenBy2 - 2U); i += 2U)
  129.    {
  130.       if (i < j)
  131.       {
  132.          /*  pSrc[i] <-> pSrc[j]; */
  133.          in = pSrc[2U * i];
  134.          pSrc[2U * i] = pSrc[2U * j];
  135.          pSrc[2U * j] = in;
  136.  
  137.          /*  pSrc[i+1U] <-> pSrc[j+1U] */
  138.          in = pSrc[(2U * i) + 1U];
  139.          pSrc[(2U * i) + 1U] = pSrc[(2U * j) + 1U];
  140.          pSrc[(2U * j) + 1U] = in;
  141.  
  142.          /*  pSrc[i+fftLenBy2p1] <-> pSrc[j+fftLenBy2p1] */
  143.          in = pSrc[2U * (i + fftLenBy2p1)];
  144.          pSrc[2U * (i + fftLenBy2p1)] = pSrc[2U * (j + fftLenBy2p1)];
  145.          pSrc[2U * (j + fftLenBy2p1)] = in;
  146.  
  147.          /*  pSrc[i+fftLenBy2p1+1U] <-> pSrc[j+fftLenBy2p1+1U] */
  148.          in = pSrc[(2U * (i + fftLenBy2p1)) + 1U];
  149.          pSrc[(2U * (i + fftLenBy2p1)) + 1U] =
  150.          pSrc[(2U * (j + fftLenBy2p1)) + 1U];
  151.          pSrc[(2U * (j + fftLenBy2p1)) + 1U] = in;
  152.  
  153.       }
  154.  
  155.       /*  pSrc[i+1U] <-> pSrc[j+1U] */
  156.       in = pSrc[2U * (i + 1U)];
  157.       pSrc[2U * (i + 1U)] = pSrc[2U * (j + fftLenBy2)];
  158.       pSrc[2U * (j + fftLenBy2)] = in;
  159.  
  160.       /*  pSrc[i+2U] <-> pSrc[j+2U] */
  161.       in = pSrc[(2U * (i + 1U)) + 1U];
  162.       pSrc[(2U * (i + 1U)) + 1U] = pSrc[(2U * (j + fftLenBy2)) + 1U];
  163.       pSrc[(2U * (j + fftLenBy2)) + 1U] = in;
  164.  
  165.       /*  Reading the index for the bit reversal */
  166.       j = *pBitRevTable;
  167.  
  168.       /*  Updating the bit reversal index depending on the fft length */
  169.       pBitRevTable += bitRevFactor;
  170.    }
  171. }
  172.  
  173.  
  174.  
  175. /*
  176.    * @brief  In-place bit reversal function.
  177.    * @param[in, out] *pSrc        points to the in-place buffer of Q15 data type.
  178.    * @param[in]      fftLen       length of the FFT.
  179.    * @param[in]      bitRevFactor bit reversal modifier that supports different size FFTs with the same bit reversal table
  180.    * @param[in]      *pBitRevTab  points to bit reversal table.
  181.    * @return none.
  182. */
  183.  
  184. void arm_bitreversal_q15(
  185. q15_t * pSrc16,
  186. uint32_t fftLen,
  187. uint16_t bitRevFactor,
  188. uint16_t * pBitRevTab)
  189. {
  190.    q31_t *pSrc = (q31_t *) pSrc16;
  191.    q31_t in;
  192.    uint32_t fftLenBy2, fftLenBy2p1;
  193.    uint32_t i, j;
  194.  
  195.    /*  Initializations */
  196.    j = 0U;
  197.    fftLenBy2 = fftLen / 2U;
  198.    fftLenBy2p1 = (fftLen / 2U) + 1U;
  199.  
  200.    /* Bit Reversal Implementation */
  201.    for (i = 0U; i <= (fftLenBy2 - 2U); i += 2U)
  202.    {
  203.       if (i < j)
  204.       {
  205.          /*  pSrc[i] <-> pSrc[j]; */
  206.          /*  pSrc[i+1U] <-> pSrc[j+1U] */
  207.          in = pSrc[i];
  208.          pSrc[i] = pSrc[j];
  209.          pSrc[j] = in;
  210.  
  211.          /*  pSrc[i + fftLenBy2p1] <-> pSrc[j + fftLenBy2p1];  */
  212.          /*  pSrc[i + fftLenBy2p1+1U] <-> pSrc[j + fftLenBy2p1+1U] */
  213.          in = pSrc[i + fftLenBy2p1];
  214.          pSrc[i + fftLenBy2p1] = pSrc[j + fftLenBy2p1];
  215.          pSrc[j + fftLenBy2p1] = in;
  216.       }
  217.  
  218.       /*  pSrc[i+1U] <-> pSrc[j+fftLenBy2];         */
  219.       /*  pSrc[i+2] <-> pSrc[j+fftLenBy2+1U]  */
  220.       in = pSrc[i + 1U];
  221.       pSrc[i + 1U] = pSrc[j + fftLenBy2];
  222.       pSrc[j + fftLenBy2] = in;
  223.  
  224.       /*  Reading the index for the bit reversal */
  225.       j = *pBitRevTab;
  226.  
  227.       /*  Updating the bit reversal index depending on the fft length  */
  228.       pBitRevTab += bitRevFactor;
  229.    }
  230. }
  231.