Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse/fft.h

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 31 мар. 2020 г.
7 *
8 * lsp-dsp-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-dsp-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-dsp-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #ifndef PRIVATE_DSP_ARCH_X86_SSE_FFT_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE_FFT_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE_IMPL */
28
29 #include <private/dsp/arch/x86/sse/fft/const.h>
30 #include <private/dsp/arch/x86/sse/fft/butterfly.h>
31 #include <private/dsp/arch/x86/sse/fft/p_butterfly.h>
32 #include <private/dsp/arch/x86/sse/fft/normalize.h>
33
34 // Use 8-bit-reverse algorithm
35 #define FFT_SCRAMBLE_SELF_DIRECT_NAME scramble_self_direct8
36 #define FFT_SCRAMBLE_SELF_REVERSE_NAME scramble_self_reverse8
37 #define FFT_SCRAMBLE_COPY_DIRECT_NAME scramble_copy_direct8
38 #define FFT_SCRAMBLE_COPY_REVERSE_NAME scramble_copy_reverse8
39 #define FFT_TYPE uint8_t
40 #include <private/dsp/arch/x86/sse/fft/scramble.h>
41
42 #define FFT_SCRAMBLE_SELF_DIRECT_NAME packed_scramble_self_direct8
43 #define FFT_SCRAMBLE_SELF_REVERSE_NAME packed_scramble_self_reverse8
44 #define FFT_SCRAMBLE_COPY_DIRECT_NAME packed_scramble_copy_direct8
45 #define FFT_SCRAMBLE_COPY_REVERSE_NAME packed_scramble_copy_reverse8
46 #define FFT_TYPE uint8_t
47 #include <private/dsp/arch/x86/sse/fft/p_scramble.h>
48
49 // Use 16-bit-reverse algorithm
50 #define FFT_SCRAMBLE_SELF_DIRECT_NAME scramble_self_direct16
51 #define FFT_SCRAMBLE_SELF_REVERSE_NAME scramble_self_reverse16
52 #define FFT_SCRAMBLE_COPY_DIRECT_NAME scramble_copy_direct16
53 #define FFT_SCRAMBLE_COPY_REVERSE_NAME scramble_copy_reverse16
54 #define FFT_TYPE uint16_t
55 #include <private/dsp/arch/x86/sse/fft/scramble.h>
56
57 #define FFT_SCRAMBLE_SELF_DIRECT_NAME packed_scramble_self_direct16
58 #define FFT_SCRAMBLE_SELF_REVERSE_NAME packed_scramble_self_reverse16
59 #define FFT_SCRAMBLE_COPY_DIRECT_NAME packed_scramble_copy_direct16
60 #define FFT_SCRAMBLE_COPY_REVERSE_NAME packed_scramble_copy_reverse16
61 #define FFT_TYPE uint16_t
62 #include <private/dsp/arch/x86/sse/fft/p_scramble.h>
63
64 // Make set of scramble-switch implementations
65 #define FFT_SCRAMBLE_SELF_DIRECT_NAME scramble_self_direct
66 #define FFT_SCRAMBLE_COPY_DIRECT_NAME scramble_copy_direct
67 #define FFT_SCRAMBLE_SELF_REVERSE_NAME scramble_self_reverse
68 #define FFT_SCRAMBLE_COPY_REVERSE_NAME scramble_copy_reverse
69 #define FFT_SCRAMBLE_DIRECT_NAME scramble_direct
70 #define FFT_SCRAMBLE_REVERSE_NAME scramble_reverse
71 #include <private/dsp/arch/x86/sse/fft/switch.h>
72
73 #define FFT_SCRAMBLE_SELF_DIRECT_NAME packed_scramble_self_direct
74 #define FFT_SCRAMBLE_COPY_DIRECT_NAME packed_scramble_copy_direct
75 #define FFT_SCRAMBLE_SELF_REVERSE_NAME packed_scramble_self_reverse
76 #define FFT_SCRAMBLE_COPY_REVERSE_NAME packed_scramble_copy_reverse
77 #define FFT_SCRAMBLE_DIRECT_NAME packed_scramble_direct
78 #define FFT_SCRAMBLE_REVERSE_NAME packed_scramble_reverse
79 #define FFT_REPACK packed_fft_repack
80 #define FFT_REPACK_NORMALIZE packed_fft_repack_normalize
81 #include <private/dsp/arch/x86/sse/fft/p_switch.h>
82
83 namespace lsp
84 {
85 namespace sse
86 {
87 // Make set of scramble implementations
88 void direct_fft(float *dst_re, float *dst_im, const float *src_re, const float *src_im, size_t rank)
89 {
90 // Check bounds
91 if (rank <= 2)
92 {
93 if (rank == 2)
94 {
95 float s0_re = src_re[0] + src_re[2];
96 float s1_re = src_re[0] - src_re[2];
97 float s2_re = src_re[1] + src_re[3];
98 float s3_re = src_re[1] - src_re[3];
99
100 float s0_im = src_im[0] + src_im[2];
101 float s1_im = src_im[0] - src_im[2];
102 float s2_im = src_im[1] + src_im[3];
103 float s3_im = src_im[1] - src_im[3];
104
105 dst_re[0] = s0_re + s2_re;
106 dst_re[1] = s1_re + s3_im;
107 dst_re[2] = s0_re - s2_re;
108 dst_re[3] = s1_re - s3_im;
109
110 dst_im[0] = s0_im + s2_im;
111 dst_im[1] = s1_im - s3_re;
112 dst_im[2] = s0_im - s2_im;
113 dst_im[3] = s1_im + s3_re;
114 }
115 else if (rank == 1)
116 {
117 // s0' = s0 + s1
118 // s1' = s0 - s1
119 float s1_re = src_re[1];
120 float s1_im = src_im[1];
121 dst_re[1] = src_re[0] - s1_re;
122 dst_im[1] = src_im[0] - s1_im;
123 dst_re[0] = src_re[0] + s1_re;
124 dst_im[0] = src_im[0] + s1_im;
125 }
126 else
127 {
128 dst_re[0] = src_re[0];
129 dst_im[0] = src_im[0];
130 }
131 return;
132 }
133
134 scramble_direct(dst_re, dst_im, src_re, src_im, rank);
135
136 for (size_t i=2; i < rank; ++i)
137 butterfly_direct(dst_re, dst_im, i, 1 << (rank - i - 1));
138 }
139
140 void packed_direct_fft(float *dst, const float *src, size_t rank)
141 {
142 // Check bounds
143 if (rank <= 2)
144 {
145 if (rank == 2)
146 {
147 float s0_re = src[0] + src[4];
148 float s1_re = src[0] - src[4];
149 float s0_im = src[1] + src[5];
150 float s1_im = src[1] - src[5];
151
152 float s2_re = src[2] + src[6];
153 float s3_re = src[2] - src[6];
154 float s2_im = src[3] + src[7];
155 float s3_im = src[3] - src[7];
156
157 dst[0] = s0_re + s2_re;
158 dst[1] = s0_im + s2_im;
159 dst[2] = s1_re + s3_im;
160 dst[3] = s1_im - s3_re;
161
162 dst[4] = s0_re - s2_re;
163 dst[5] = s0_im - s2_im;
164 dst[6] = s1_re - s3_im;
165 dst[7] = s1_im + s3_re;
166 }
167 else if (rank == 1)
168 {
169 // s0' = s0 + s1
170 // s1' = s0 - s1
171 float s1_re = src[2];
172 float s1_im = src[3];
173 dst[2] = src[0] - s1_re;
174 dst[3] = src[1] - s1_im;
175 dst[0] = src[0] + s1_re;
176 dst[1] = src[1] + s1_im;
177 }
178 else
179 {
180 dst[0] = src[0];
181 dst[1] = src[1];
182 }
183 return;
184 }
185
186 // Iterate butterflies
187 packed_scramble_direct(dst, src, rank);
188
189 for (size_t i=2; i < rank; ++i)
190 packed_butterfly_direct(dst, i, 1 << (rank - i - 1));
191
192 packed_fft_repack(dst, rank);
193 }
194
195 void reverse_fft(float *dst_re, float *dst_im, const float *src_re, const float *src_im, size_t rank)
196 {
197 // Check bounds
198 if (rank <= 2)
199 {
200 if (rank == 2)
201 {
202 float s0_re = src_re[0] + src_re[2];
203 float s1_re = src_re[0] - src_re[2];
204 float s2_re = src_re[1] + src_re[3];
205 float s3_re = src_re[1] - src_re[3];
206
207 float s0_im = src_im[0] + src_im[2];
208 float s1_im = src_im[0] - src_im[2];
209 float s2_im = src_im[1] + src_im[3];
210 float s3_im = src_im[1] - src_im[3];
211
212 dst_re[0] = (s0_re + s2_re)*0.25f;
213 dst_re[1] = (s1_re - s3_im)*0.25f;
214 dst_re[2] = (s0_re - s2_re)*0.25f;
215 dst_re[3] = (s1_re + s3_im)*0.25f;
216
217 dst_im[0] = (s0_im + s2_im)*0.25f;
218 dst_im[1] = (s1_im + s3_re)*0.25f;
219 dst_im[2] = (s0_im - s2_im)*0.25f;
220 dst_im[3] = (s1_im - s3_re)*0.25f;
221 }
222 else if (rank == 1)
223 {
224 // s0' = s0 + s1
225 // s1' = s0 - s1
226 float s1_re = src_re[1];
227 float s1_im = src_im[1];
228 dst_re[1] = (src_re[0] - s1_re) * 0.5f;
229 dst_im[1] = (src_im[0] - s1_im) * 0.5f;
230 dst_re[0] = (src_re[0] + s1_re) * 0.5f;
231 dst_im[0] = (src_im[0] + s1_im) * 0.5f;
232 }
233 else
234 {
235 dst_re[0] = src_re[0];
236 dst_im[0] = src_im[0];
237 }
238 return;
239 }
240
241 // Iterate butterflies
242 scramble_reverse(dst_re, dst_im, src_re, src_im, rank);
243
244 for (size_t i=2; i < rank; ++i)
245 butterfly_reverse(dst_re, dst_im, i, 1 << (rank - i - 1));
246
247 dsp::normalize_fft2(dst_re, dst_im, rank);
248 }
249
250 void packed_reverse_fft(float *dst, const float *src, size_t rank)
251 {
252 // Check bounds
253 if (rank <= 2)
254 {
255 if (rank == 2)
256 {
257 float s0_re = src[0] + src[4];
258 float s1_re = src[0] - src[4];
259 float s0_im = src[1] + src[5];
260 float s1_im = src[1] - src[5];
261
262 float s2_re = src[2] + src[6];
263 float s3_re = src[2] - src[6];
264 float s2_im = src[3] + src[7];
265 float s3_im = src[3] - src[7];
266
267 dst[0] = (s0_re + s2_re)*0.25f;
268 dst[1] = (s0_im + s2_im)*0.25f;
269 dst[2] = (s1_re - s3_im)*0.25f;
270 dst[3] = (s1_im + s3_re)*0.25f;
271
272 dst[4] = (s0_re - s2_re)*0.25f;
273 dst[5] = (s0_im - s2_im)*0.25f;
274 dst[6] = (s1_re + s3_im)*0.25f;
275 dst[7] = (s1_im - s3_re)*0.25f;
276 }
277 else if (rank == 1)
278 {
279 // s0' = s0 + s1
280 // s1' = s0 - s1
281 float s1_re = src[2];
282 float s1_im = src[3];
283 dst[2] = src[0] - s1_re;
284 dst[3] = src[1] - s1_im;
285 dst[0] = src[0] + s1_re;
286 dst[1] = src[1] + s1_im;
287 }
288 else
289 {
290 dst[0] = src[0];
291 dst[1] = src[1];
292 }
293 return;
294 }
295
296 // Iterate butterflies
297 packed_scramble_reverse(dst, src, rank);
298
299 for (size_t i=2; i < rank; ++i)
300 packed_butterfly_reverse(dst, i, 1 << (rank - i - 1));
301
302 packed_fft_repack_normalize(dst, rank);
303 }
304 }
305 }
306
307 #endif /* PRIVATE_DSP_ARCH_X86_SSE_FFT_H_ */