Subversion Repositories testOled

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 mjames 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 
}