Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse/resampling.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_RESAMPLING_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE_RESAMPLING_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 namespace lsp
30 {
31 namespace sse
32 {
33 IF_ARCH_X86(
34 static const float lanczos_2x2[] __lsp_aligned16 =
35 {
36 +0.5731591682507563f, // k0
37 -0.0636843520278618f // k1
38 };
39 )
40
41 void lanczos_resample_2x2(float *dst, const float *src, size_t count)
42 {
43 ARCH_X86_ASM
44 (
45 __ASM_EMIT("movss 0x00(%[k]), %%xmm6") // xmm6 = k0
46 __ASM_EMIT("movss 0x04(%[k]), %%xmm7") // xmm7 = k1
47 __ASM_EMIT("sub $2, %[count]")
48 __ASM_EMIT("jb 2f")
49
50 // Load samples
51 __ASM_EMIT(".align 16")
52 __ASM_EMIT("1:")
53 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
54 __ASM_EMIT("movss 0x04(%[src]), %%xmm1") // xmm1 = s1
55
56 // Do convolution
57 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
58 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s1
59 __ASM_EMIT("mulss %%xmm7, %%xmm2") // xmm2 = k1*s0
60 __ASM_EMIT("mulss %%xmm7, %%xmm3") // xmm3 = k1*s1
61 __ASM_EMIT("movaps %%xmm2, %%xmm4") // xmm4 = k1*s0
62 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = k1*s1
63 __ASM_EMIT("addss 0x04(%[dst]), %%xmm4") // xmm4 = k1*s0 + d1
64 __ASM_EMIT("addss 0x24(%[dst]), %%xmm5") // xmm5 = k1*s1 + d9
65 __ASM_EMIT("movss %%xmm4, 0x04(%[dst])") // d1 += k1*s0
66 __ASM_EMIT("movss %%xmm5, 0x24(%[dst])") // d9 += k1*s1
67
68 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
69 __ASM_EMIT("movaps %%xmm1, %%xmm5") // xmm5 = s1
70 __ASM_EMIT("mulss %%xmm6, %%xmm4") // xmm4 = k0*s0
71 __ASM_EMIT("mulss %%xmm6, %%xmm5") // xmm5 = k0*s1
72 __ASM_EMIT("addss %%xmm4, %%xmm3") // xmm3 = k1*s1 + k0*s0
73 __ASM_EMIT("addss %%xmm5, %%xmm2") // xmm2 = k1*s0 + k0*s1
74 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm3") // xmm3 = k1*s1 + k0*s0 + d3
75 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm2") // xmm2 = k1*s0 + k0*s1 + d7
76 __ASM_EMIT("movss %%xmm3, 0x0c(%[dst])") // d3 += k1*s1 + k0*s0
77 __ASM_EMIT("movss %%xmm2, 0x1c(%[dst])") // d7 += k1*s0 + k0*s1
78
79 __ASM_EMIT("addss %%xmm5, %%xmm4") // xmm4 = k0*s0 + k0*s1
80 __ASM_EMIT("addss 0x10(%[dst]), %%xmm0") // xmm0 = s0 + d4
81 __ASM_EMIT("addss 0x18(%[dst]), %%xmm1") // xmm1 = s1 + d6
82 __ASM_EMIT("addss 0x14(%[dst]), %%xmm4") // xmm4 = k0*s0 + k0*s1 + d5
83 __ASM_EMIT("movss %%xmm0, 0x10(%[dst])") // d4 += s0
84 __ASM_EMIT("movss %%xmm4, 0x14(%[dst])") // d5 += k0*s0 + k0*s1
85 __ASM_EMIT("movss %%xmm1, 0x18(%[dst])") // d6 += s1
86
87 // Update pointers
88 __ASM_EMIT("add $0x08, %[src]")
89 __ASM_EMIT("add $0x10, %[dst]")
90 __ASM_EMIT("sub $2, %[count]")
91 __ASM_EMIT("jae 1b")
92
93 // Complete loop
94 __ASM_EMIT("2:")
95 __ASM_EMIT("add $1, %[count]")
96 __ASM_EMIT("jl 3f")
97
98 // Load sample
99 __ASM_EMIT("movss (%[src]), %%xmm0") // xmm0 = s0
100
101 // Do convolution
102 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
103 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
104 __ASM_EMIT("mulss %%xmm6, %%xmm1") // xmm1 = k0*s0
105 __ASM_EMIT("mulss %%xmm7, %%xmm2") // xmm2 = k1*s0
106 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = k0*s0
107 __ASM_EMIT("movaps %%xmm2, %%xmm4") // xmm4 = k1*s0
108
109 __ASM_EMIT("addss 0x04(%[dst]), %%xmm2") // xmm2 = k1*s0 + d1
110 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm1") // xmm1 = k0*s0 + d3
111 __ASM_EMIT("addss 0x10(%[dst]), %%xmm0") // xmm0 = s0 + d4
112 __ASM_EMIT("addss 0x14(%[dst]), %%xmm3") // xmm3 = k0*s0 + d5
113 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm4") // xmm4 = k1*s0 + d7
114
115 __ASM_EMIT("movss %%xmm2, 0x04(%[dst])") // d1 += k1*s0
116 __ASM_EMIT("movss %%xmm1, 0x0c(%[dst])") // d3 += k0*s0
117 __ASM_EMIT("movss %%xmm0, 0x10(%[dst])") // d4 += s0
118 __ASM_EMIT("movss %%xmm3, 0x14(%[dst])") // d5 += k0*s0
119 __ASM_EMIT("movss %%xmm4, 0x1c(%[dst])") // d7 += k1*s0
120
121 __ASM_EMIT("3:")
122
123 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
124 : [k] "r" (lanczos_2x2)
125 : "cc", "memory",
126 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
127 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
128 );
129 }
130
131 IF_ARCH_X86(
132 // Lanczos kernel 2x3: 3 SSE registers
133 static const float lanczos_2x3[] __lsp_aligned16 =
134 {
135 +0.6079271018540265f, // k0
136 -0.1350949115231170f, // k1
137 +0.0243170840741611f // k2
138 };
139 )
140
141 void lanczos_resample_2x3(float *dst, const float *src, size_t count)
142 {
143 ARCH_X86_ASM
144 (
145 __ASM_EMIT("movss 0x00(%[k]), %%xmm6") // xmm6 = k0
146 __ASM_EMIT("movss 0x04(%[k]), %%xmm7") // xmm7 = k1
147 __ASM_EMIT("sub $2, %[count]")
148 __ASM_EMIT("jb 2f")
149
150 // Load samples
151 __ASM_EMIT(".align 16")
152 __ASM_EMIT("1:")
153 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
154 __ASM_EMIT("movss 0x04(%[src]), %%xmm1") // xmm1 = s1
155
156 // Do convolution
157 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
158 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s1
159 __ASM_EMIT("mulss 0x08(%[k]), %%xmm2") // xmm2 = k2*s0
160 __ASM_EMIT("mulss 0x08(%[k]), %%xmm3") // xmm3 = k2*s1
161 __ASM_EMIT("movaps %%xmm2, %%xmm4") // xmm4 = k2*s0
162 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = k2*s1
163 __ASM_EMIT("addss 0x04(%[dst]), %%xmm4") // xmm4 = k2*s0 + d1
164 __ASM_EMIT("addss 0x34(%[dst]), %%xmm5") // xmm5 = k2*s1 + d13
165 __ASM_EMIT("movss %%xmm4, 0x04(%[dst])") // d1 += k2*s0
166 __ASM_EMIT("movss %%xmm5, 0x34(%[dst])") // d13 += k2*s1
167
168 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
169 __ASM_EMIT("movaps %%xmm1, %%xmm5") // xmm5 = s1
170 __ASM_EMIT("mulss %%xmm7, %%xmm4") // xmm4 = k1*s0
171 __ASM_EMIT("mulss %%xmm7, %%xmm5") // xmm5 = k1*s1
172 __ASM_EMIT("addss %%xmm4, %%xmm3") // xmm3 = k2*s1 + k1*s0
173 __ASM_EMIT("addss %%xmm5, %%xmm2") // xmm2 = k2*s0 + k1*s1
174 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm3") // xmm3 = k2*s1 + k1*s0 + d3
175 __ASM_EMIT("addss 0x2c(%[dst]), %%xmm2") // xmm2 = k2*s0 + k1*s1 + d11
176 __ASM_EMIT("movss %%xmm3, 0x0c(%[dst])") // d3 += k2*s1 + k1*s0
177 __ASM_EMIT("movss %%xmm2, 0x2c(%[dst])") // d11 += k2*s0 + k1*s1
178
179 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
180 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s1
181 __ASM_EMIT("mulss %%xmm6, %%xmm2") // xmm2 = k0*s0
182 __ASM_EMIT("mulss %%xmm6, %%xmm3") // xmm3 = k0*s1
183 __ASM_EMIT("addss %%xmm2, %%xmm5") // xmm5 = k1*s1 + k0*s0
184 __ASM_EMIT("addss %%xmm3, %%xmm4") // xmm4 = k1*s0 + k0*s1
185 __ASM_EMIT("addss 0x14(%[dst]), %%xmm5") // xmm5 = k1*s1 + k0*s0 + d5
186 __ASM_EMIT("addss 0x24(%[dst]), %%xmm4") // xmm4 = k1*s0 + k0*s1 + d9
187 __ASM_EMIT("movss %%xmm5, 0x14(%[dst])") // d5 += k1*s1 + k0*s0
188 __ASM_EMIT("movss %%xmm4, 0x24(%[dst])") // d9 += k1*s0 + k0*s1
189
190 __ASM_EMIT("addss %%xmm3, %%xmm2") // xmm2 = k0*s0 + k0*s1
191 __ASM_EMIT("addss 0x18(%[dst]), %%xmm0") // xmm0 = s0 + d6
192 __ASM_EMIT("addss 0x20(%[dst]), %%xmm1") // xmm1 = s1 + d8
193 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm2") // xmm2 = k0*s0 + k0*s1 + d7
194 __ASM_EMIT("movss %%xmm0, 0x18(%[dst])") // d6 += s0
195 __ASM_EMIT("movss %%xmm2, 0x1c(%[dst])") // d7 += k0*s0 + k0*s1
196 __ASM_EMIT("movss %%xmm1, 0x20(%[dst])") // d8 += s1
197
198 // Update pointers
199 __ASM_EMIT("add $0x08, %[src]")
200 __ASM_EMIT("add $0x10, %[dst]")
201 __ASM_EMIT("sub $2, %[count]")
202 __ASM_EMIT("jae 1b")
203
204 // Complete loop
205 __ASM_EMIT("2:")
206 __ASM_EMIT("add $1, %[count]")
207 __ASM_EMIT("jl 3f")
208
209 // Load sample
210 __ASM_EMIT("movss (%[src]), %%xmm0") // xmm0 = s0
211
212 // Do convolution
213 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
214 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
215 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
216 __ASM_EMIT("mulss %%xmm6, %%xmm1") // xmm1 = k0*s0
217 __ASM_EMIT("mulss %%xmm7, %%xmm2") // xmm2 = k1*s0
218 __ASM_EMIT("mulss 0x08(%[k]), %%xmm3") // xmm3 = k2*s0
219 __ASM_EMIT("movaps %%xmm1, %%xmm4") // xmm4 = k0*s0
220 __ASM_EMIT("movaps %%xmm2, %%xmm5") // xmm5 = k1*s0
221 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = k2*s0
222
223 __ASM_EMIT("addss 0x04(%[dst]), %%xmm3") // xmm3 = k2*s0 + d1
224 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm2") // xmm2 = k1*s0 + d3
225 __ASM_EMIT("addss 0x14(%[dst]), %%xmm1") // xmm1 = k0*s0 + d5
226 __ASM_EMIT("addss 0x18(%[dst]), %%xmm0") // xmm0 = s0 + d6
227 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm4") // xmm4 = k0*s0 + d7
228 __ASM_EMIT("addss 0x24(%[dst]), %%xmm5") // xmm5 = k1*s0 + d9
229 __ASM_EMIT("addss 0x2c(%[dst]), %%xmm6") // xmm6 = k2*s0 + d11
230
231 __ASM_EMIT("movss %%xmm3, 0x04(%[dst])") // d1 += k2*s0
232 __ASM_EMIT("movss %%xmm2, 0x0c(%[dst])") // d3 += k1*s0
233 __ASM_EMIT("movss %%xmm1, 0x14(%[dst])") // d5 += k0*s0
234 __ASM_EMIT("movss %%xmm0, 0x18(%[dst])") // d6 += s0
235 __ASM_EMIT("movss %%xmm4, 0x1c(%[dst])") // d7 += k0*s0
236 __ASM_EMIT("movss %%xmm5, 0x24(%[dst])") // d9 += k1*s0
237 __ASM_EMIT("movss %%xmm6, 0x2c(%[dst])") // d11 += k2*s0
238
239 __ASM_EMIT("3:")
240
241 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
242 : [k] "r" (lanczos_2x3)
243 : "cc", "memory",
244 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
245 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
246 );
247 }
248
249 IF_ARCH_X86(
250 // Lanczos kernel 2x4: 4 SSE registers
251 static const float lanczos_2x4[] __lsp_aligned16 =
252 {
253 +0.6203830132406946f, // k0
254 -0.1664152316035080f, // k1
255 +0.0599094833772629f, // k2
256 -0.0126608778212387f // k3
257 };
258 )
259
260 void lanczos_resample_2x4(float *dst, const float *src, size_t count)
261 {
262 ARCH_X86_ASM
263 (
264 __ASM_EMIT("sub $2, %[count]")
265 __ASM_EMIT("jb 2f")
266
267 // Load samples
268 __ASM_EMIT(".align 16")
269 __ASM_EMIT("1:")
270 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
271 __ASM_EMIT("movss 0x04(%[src]), %%xmm1") // xmm1 = s1
272
273 // Do convolution
274 __ASM_EMIT("movss 0x08(%[k]), %%xmm6") // xmm6 = k2
275 __ASM_EMIT("movss 0x0c(%[k]), %%xmm7") // xmm7 = k3
276 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
277 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s1
278 __ASM_EMIT("mulss %%xmm7, %%xmm2") // xmm2 = k3*s0
279 __ASM_EMIT("mulss %%xmm7, %%xmm3") // xmm3 = k3*s1
280 __ASM_EMIT("movaps %%xmm2, %%xmm4") // xmm4 = k3*s0
281 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = k3*s1
282 __ASM_EMIT("addss 0x04(%[dst]), %%xmm4") // xmm4 = k3*s0 + d1
283 __ASM_EMIT("addss 0x44(%[dst]), %%xmm5") // xmm5 = k3*s1 + d17
284 __ASM_EMIT("movss %%xmm4, 0x04(%[dst])") // d1 += k2*s0
285 __ASM_EMIT("movss %%xmm5, 0x44(%[dst])") // d17 += k2*s1
286
287 __ASM_EMIT("movss 0x04(%[k]), %%xmm7") // xmm7 = k1
288 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
289 __ASM_EMIT("movaps %%xmm1, %%xmm5") // xmm5 = s1
290 __ASM_EMIT("mulss %%xmm6, %%xmm4") // xmm4 = k2*s0
291 __ASM_EMIT("mulss %%xmm6, %%xmm5") // xmm5 = k2*s1
292 __ASM_EMIT("addss %%xmm4, %%xmm3") // xmm3 = k3*s1 + k2*s0
293 __ASM_EMIT("addss %%xmm5, %%xmm2") // xmm2 = k2*s1 + k3*s0
294 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm3") // xmm3 = k3*s1 + k2*s0 + d3
295 __ASM_EMIT("addss 0x3c(%[dst]), %%xmm2") // xmm2 = k2*s1 + k3*s0 + d15
296 __ASM_EMIT("movss %%xmm3, 0x0c(%[dst])") // d3 += k2*s1 + k1*s0
297 __ASM_EMIT("movss %%xmm2, 0x3c(%[dst])") // d15 += k2*s0 + k1*s1
298
299 __ASM_EMIT("movss 0x00(%[k]), %%xmm6") // xmm6 = k0
300 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
301 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s1
302 __ASM_EMIT("mulss %%xmm7, %%xmm2") // xmm2 = k1*s0
303 __ASM_EMIT("mulss %%xmm7, %%xmm3") // xmm3 = k1*s1
304 __ASM_EMIT("addss %%xmm2, %%xmm5") // xmm5 = k2*s1 + k1*s0
305 __ASM_EMIT("addss %%xmm3, %%xmm4") // xmm4 = k2*s0 + k1*s1
306 __ASM_EMIT("addss 0x14(%[dst]), %%xmm5") // xmm5 = k2*s1 + k1*s0 + d5
307 __ASM_EMIT("addss 0x34(%[dst]), %%xmm4") // xmm4 = k2*s0 + k1*s1 + d13
308 __ASM_EMIT("movss %%xmm5, 0x14(%[dst])") // d5 += k1*s1 + k0*s0
309 __ASM_EMIT("movss %%xmm4, 0x34(%[dst])") // d13 += k1*s0 + k0*s1
310
311 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
312 __ASM_EMIT("movaps %%xmm1, %%xmm5") // xmm5 = s1
313 __ASM_EMIT("mulss %%xmm6, %%xmm4") // xmm4 = k0*s0
314 __ASM_EMIT("mulss %%xmm6, %%xmm5") // xmm5 = k0*s1
315 __ASM_EMIT("addss %%xmm4, %%xmm3") // xmm3 = k1*s1 + k0*s0
316 __ASM_EMIT("addss %%xmm5, %%xmm2") // xmm2 = k1*s0 + k0*s1
317 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm3") // xmm3 = k3*s1 + k2*s0 + d7
318 __ASM_EMIT("addss 0x2c(%[dst]), %%xmm2") // xmm2 = k2*s1 + k3*s0 + d11
319 __ASM_EMIT("movss %%xmm3, 0x1c(%[dst])") // d7 += k2*s1 + k1*s0
320 __ASM_EMIT("movss %%xmm2, 0x2c(%[dst])") // d11 += k2*s0 + k1*s1
321
322 __ASM_EMIT("addss %%xmm5, %%xmm4") // xmm4 = k0*s0 + k0*s1
323 __ASM_EMIT("addss 0x20(%[dst]), %%xmm0") // xmm0 = s0 + d8
324 __ASM_EMIT("addss 0x28(%[dst]), %%xmm1") // xmm1 = s1 + d10
325 __ASM_EMIT("addss 0x24(%[dst]), %%xmm4") // xmm4 = k0*s0 + k0*s1 + d9
326 __ASM_EMIT("movss %%xmm0, 0x20(%[dst])") // d8 += s0
327 __ASM_EMIT("movss %%xmm4, 0x24(%[dst])") // d9 += k0*s0 + k0*s1
328 __ASM_EMIT("movss %%xmm1, 0x28(%[dst])") // d10 += s1
329
330 // Update pointers
331 __ASM_EMIT("add $0x08, %[src]")
332 __ASM_EMIT("add $0x10, %[dst]")
333 __ASM_EMIT("sub $2, %[count]")
334 __ASM_EMIT("jae 1b")
335
336 // Complete loop
337 __ASM_EMIT("2:")
338 __ASM_EMIT("add $1, %[count]")
339 __ASM_EMIT("jl 3f")
340
341 // Load sample
342 __ASM_EMIT("movss (%[src]), %%xmm0") // xmm0 = s0
343
344 // Do convolution
345 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
346 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
347 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
348 __ASM_EMIT("mulss 0x00(%[k]), %%xmm1") // xmm1 = k0*s0
349 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm3 = s0
350 __ASM_EMIT("mulss 0x04(%[k]), %%xmm2") // xmm2 = k1*s0
351 __ASM_EMIT("mulss 0x08(%[k]), %%xmm3") // xmm3 = k2*s0
352 __ASM_EMIT("movaps %%xmm2, %%xmm5") // xmm5 = k1*s0
353 __ASM_EMIT("mulss 0x0c(%[k]), %%xmm4") // xmm4 = k3*s0
354 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = k2*s0
355 __ASM_EMIT("movaps %%xmm4, %%xmm7") // xmm7 = k3*s0
356
357 __ASM_EMIT("addss 0x04(%[dst]), %%xmm4") // xmm4 = k3*s0 + d1
358 __ASM_EMIT("addss 0x0c(%[dst]), %%xmm3") // xmm3 = k2*s0 + d3
359 __ASM_EMIT("addss 0x14(%[dst]), %%xmm2") // xmm2 = k1*s0 + d5
360 __ASM_EMIT("movss %%xmm4, 0x04(%[dst])") // d1 += k3*s0
361 __ASM_EMIT("movss %%xmm3, 0x0c(%[dst])") // d3 += k2*s0
362 __ASM_EMIT("movss %%xmm2, 0x14(%[dst])") // d5 += k1*s0
363 __ASM_EMIT("movaps %%xmm1, %%xmm4") // xmm4 = k0*s0
364
365 __ASM_EMIT("addss 0x1c(%[dst]), %%xmm1") // xmm1 = k0*s0 + d7
366 __ASM_EMIT("addss 0x20(%[dst]), %%xmm0") // xmm0 = s0 + d8
367 __ASM_EMIT("addss 0x24(%[dst]), %%xmm4") // xmm4 = k0*s0 + d9
368 __ASM_EMIT("addss 0x2c(%[dst]), %%xmm5") // xmm5 = k1*s0 + d11
369 __ASM_EMIT("addss 0x34(%[dst]), %%xmm6") // xmm6 = k2*s0 + d13
370 __ASM_EMIT("addss 0x3c(%[dst]), %%xmm7") // xmm7 = k3*s0 + d15
371
372 __ASM_EMIT("movss %%xmm1, 0x1c(%[dst])") // d7 += k0*s0
373 __ASM_EMIT("movss %%xmm0, 0x20(%[dst])") // d8 += s0
374 __ASM_EMIT("movss %%xmm4, 0x24(%[dst])") // d9 += k0*s0
375 __ASM_EMIT("movss %%xmm5, 0x2c(%[dst])") // d11 += k1*s0
376 __ASM_EMIT("movss %%xmm6, 0x34(%[dst])") // d13 += k2*s0
377 __ASM_EMIT("movss %%xmm7, 0x3c(%[dst])") // d15 += k3*s0
378
379 __ASM_EMIT("3:")
380
381 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
382 : [k] "r" (lanczos_2x4)
383 : "cc", "memory",
384 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
385 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
386 );
387 }
388
389 IF_ARCH_X86(
390 // Lanczos kernel 3x2: 6 SSE registers
391 static const float lanczos_kernel_3x2[] __lsp_aligned16 =
392 {
393 +0.0000000000000000f,
394 -0.0315888188312782f,
395 -0.0854897486982225f,
396 +0.0000000000000000f,
397
398 +0.3419589947928900f,
399 +0.7897204707819555f,
400 +1.0000000000000000f,
401 +0.7897204707819555f,
402
403 +0.3419589947928900f,
404 +0.0000000000000000f,
405 -0.0854897486982225f,
406 -0.0315888188312782f,
407
408 // Shifted by 1 left
409 -0.0315888188312782f,
410 -0.0854897486982225f,
411 +0.0000000000000000f,
412 +0.3419589947928900f,
413
414 +0.7897204707819555f,
415 +1.0000000000000000f,
416 +0.7897204707819555f,
417 +0.3419589947928900f,
418
419 +0.0000000000000000f,
420 -0.0854897486982225f,
421 -0.0315888188312782f,
422 +0.0000000000000000f
423 };
424 )
425
426 void lanczos_resample_3x2(float *dst, const float *src, size_t count)
427 {
428 ARCH_X86_ASM
429 (
430 __ASM_EMIT("sub $2, %[count]")
431 __ASM_EMIT("jb 2f")
432
433 // Load samples
434 __ASM_EMIT("1:")
435 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
436 __ASM_EMIT("movss 0x04(%[src]), %%xmm4") // xmm4 = s1
437 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
438 __ASM_EMIT("shufps $0x00, %%xmm4, %%xmm4") // xmm4 = s1
439 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
440 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
441 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
442 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
443
444 // Do convolution
445 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*m0
446 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*m1
447 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*m2
448 __ASM_EMIT("mulps 0x30(%[k]), %%xmm4") // xmm4 = s1*m3
449 __ASM_EMIT("mulps 0x40(%[k]), %%xmm5") // xmm5 = s1*m4
450 __ASM_EMIT("mulps 0x50(%[k]), %%xmm6") // xmm6 = s1*m5
451 __ASM_EMIT("addps %%xmm4, %%xmm1") // xmm1 = s0*m1 + s1*m3
452 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = s0*m2 + s1*m4
453 __ASM_EMIT("movups 0x00(%[dst]), %%xmm3") // xmm3 = d0
454 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4") // xmm4 = d1
455 __ASM_EMIT("movups 0x20(%[dst]), %%xmm5") // xmm5 = d2
456 __ASM_EMIT("movups 0x30(%[dst]), %%xmm7") // xmm7 = d3
457 __ASM_EMIT("addps %%xmm0, %%xmm3") // xmm3 = d0 + s0*m0
458 __ASM_EMIT("addps %%xmm1, %%xmm4") // xmm4 = d1 + s0*m1 + s1*m3
459 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d2 + s0*m2 + s1*m4
460 __ASM_EMIT("addps %%xmm6, %%xmm7") // xmm6 = d3 + s1*m5
461 __ASM_EMIT("movups %%xmm3, 0x00(%[dst])") // d0 += s0*m0
462 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])") // d1 += s0*m1 + s1*m3
463 __ASM_EMIT("movups %%xmm5, 0x20(%[dst])") // d2 += s0*m2 + s1*m4
464 __ASM_EMIT("movups %%xmm7, 0x30(%[dst])") // d3 += s1*m5
465
466 // Update pointers
467 __ASM_EMIT("add $0x08, %[src]")
468 __ASM_EMIT("add $0x18, %[dst]")
469 __ASM_EMIT("sub $2, %[count]")
470 __ASM_EMIT("jae 1b")
471
472 // Complete loop
473 __ASM_EMIT("2:")
474 __ASM_EMIT("add $1, %[count]")
475 __ASM_EMIT("jl 3f")
476
477 // Load sample
478 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
479 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
480 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
481 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
482
483 // Do convolution
484 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*m0
485 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*m1
486 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*m2
487
488 __ASM_EMIT("movups 0x00(%[dst]), %%xmm3") // xmm3 = d0
489 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4") // xmm4 = d1
490 __ASM_EMIT("movups 0x20(%[dst]), %%xmm5") // xmm5 = d2
491 __ASM_EMIT("addps %%xmm0, %%xmm3") // xmm3 = d0 + s0*m0
492 __ASM_EMIT("addps %%xmm1, %%xmm4") // xmm4 = d1 + s0*m1
493 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d2 + s0*m2
494 __ASM_EMIT("movups %%xmm3, 0x00(%[dst])") // d0 += s0*m0
495 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])") // d1 += s0*m1
496 __ASM_EMIT("movups %%xmm5, 0x20(%[dst])") // d2 += s0*m2
497
498 __ASM_EMIT("3:")
499
500 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
501 : [k] "r" (lanczos_kernel_3x2)
502 : "cc", "memory",
503 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
504 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
505 );
506 }
507
508 IF_ARCH_X86(
509 // Lanczos kernel 3x3: 9 SSE registers
510 static const float lanczos_kernel_3x3[] __lsp_aligned16 =
511 {
512 +0.0000000000000000f,
513 +0.0126609519658153f,
514 +0.0310789306368038f,
515 +0.0000000000000000f,
516
517 -0.0933267410806225f,
518 -0.1458230329384726f,
519 +0.0000000000000000f,
520 +0.3807169003008463f,
521
522 +0.8103009258121772f,
523 +1.0000000000000000f,
524 +0.8103009258121772f,
525 +0.3807169003008463f,
526
527 +0.0000000000000000f,
528 -0.1458230329384726f,
529 -0.0933267410806225f,
530 +0.0000000000000000f,
531
532 +0.0310789306368038f,
533 +0.0126609519658153f,
534 +0.0000000000000000f,
535 +0.0000000000000000f,
536
537 // Shifted by 1 left
538 +0.0126609519658153f,
539 +0.0310789306368038f,
540 +0.0000000000000000f,
541 -0.0933267410806225f,
542
543 -0.1458230329384726f,
544 +0.0000000000000000f,
545 +0.3807169003008463f,
546 +0.8103009258121772f,
547
548 +1.0000000000000000f,
549 +0.8103009258121772f,
550 +0.3807169003008463f,
551 +0.0000000000000000f,
552
553 -0.1458230329384726f,
554 -0.0933267410806225f,
555 +0.0000000000000000f,
556 +0.0310789306368038f,
557
558 +0.0126609519658153f,
559 +0.0000000000000000f,
560 +0.0000000000000000f,
561 +0.0000000000000000f
562 };
563 )
564
565 void lanczos_resample_3x3(float *dst, const float *src, size_t count)
566 {
567 ARCH_X86_ASM
568 (
569 __ASM_EMIT("sub $2, %[count]")
570 __ASM_EMIT("jb 2f")
571
572 // Load samples
573 __ASM_EMIT(".align 16")
574 __ASM_EMIT("1:")
575 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
576 __ASM_EMIT("movss 0x04(%[src]), %%xmm4") // xmm4 = s1
577 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
578 __ASM_EMIT("shufps $0x00, %%xmm4, %%xmm4") // xmm4 = s1
579 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
580 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
581 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
582 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
583 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
584
585 // Do convolution
586 __ASM_EMIT("mulps 0x00(%[k]), %%xmm1") // xmm1 = s0*m0
587 __ASM_EMIT("mulps 0x10(%[k]), %%xmm2") // xmm2 = s0*m1
588 __ASM_EMIT("mulps 0x20(%[k]), %%xmm3") // xmm3 = s0*m2
589 __ASM_EMIT("mulps 0x50(%[k]), %%xmm5") // xmm5 = s1*m5
590 __ASM_EMIT("mulps 0x60(%[k]), %%xmm6") // xmm6 = s1*m6
591 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = s0*m1 + s1*m5
592 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = s0*m2 + s1*m6
593 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
594 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
595 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
596 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d0 + s0*m0
597 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d1 + s0*m1 + s1*m5
598 __ASM_EMIT("addps %%xmm3, %%xmm7") // xmm7 = d2 + s0*m2 + s1*m6
599 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*m0
600 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*m1 + s1*m5
601 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*m2 + s1*m6
602
603 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm4 = s1
604 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
605 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
606 __ASM_EMIT("mulps 0x30(%[k]), %%xmm0") // xmm0 = s0*m3
607 __ASM_EMIT("mulps 0x40(%[k]), %%xmm1") // xmm1 = s0*m4
608 __ASM_EMIT("mulps 0x70(%[k]), %%xmm4") // xmm4 = s1*m7
609 __ASM_EMIT("mulps 0x80(%[k]), %%xmm5") // xmm5 = s1*m8
610 __ASM_EMIT("mulss 0x90(%[k]), %%xmm6") // xmm6 = s1*m9
611 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = s0*m3 + s1*m7
612 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = s0*m4 + s1*m8
613 __ASM_EMIT("movups 0x30(%[dst]), %%xmm2") // xmm2 = d3
614 __ASM_EMIT("movups 0x40(%[dst]), %%xmm3") // xmm3 = d4
615 __ASM_EMIT("addss 0x50(%[dst]), %%xmm6") // xmm6 = d5 + s1*m9
616 __ASM_EMIT("addps %%xmm2, %%xmm0") // xmm0 = d3 + s0*m3 + s1*m7
617 __ASM_EMIT("addps %%xmm3, %%xmm1") // xmm1 = d1 + s0*m4 + s1*m8
618 __ASM_EMIT("movups %%xmm0, 0x30(%[dst])") // d3 += s0*m3 + s1*m7
619 __ASM_EMIT("movups %%xmm1, 0x40(%[dst])") // d4 += s0*m4 + s1*m8
620 __ASM_EMIT("movss %%xmm6, 0x50(%[dst])") // d5 += s1*m9
621
622 // Update pointers
623 __ASM_EMIT("add $0x08, %[src]")
624 __ASM_EMIT("add $0x18, %[dst]")
625 __ASM_EMIT("sub $2, %[count]")
626 __ASM_EMIT("jae 1b")
627
628 // Complete loop
629 __ASM_EMIT("2:")
630 __ASM_EMIT("add $1, %[count]")
631 __ASM_EMIT("jl 3f")
632
633 // Load samples
634 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
635 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
636 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
637 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
638 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
639 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
640 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
641 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
642 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
643
644 // Do convolution
645 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*m0
646 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*m1
647 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*m2
648 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*m3
649 __ASM_EMIT("mulps 0x40(%[k]), %%xmm4") // xmm4 = s0*m4
650
651 __ASM_EMIT("addps %%xmm5, %%xmm0") // xmm0 = d0 + s0*m0
652 __ASM_EMIT("addps %%xmm6, %%xmm1") // xmm1 = d1 + s0*m1
653 __ASM_EMIT("addps %%xmm7, %%xmm2") // xmm2 = d2 + s0*m2
654 __ASM_EMIT("movups 0x30(%[dst]), %%xmm5") // xmm5 = d3
655 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
656 __ASM_EMIT("addps %%xmm5, %%xmm3") // xmm1 = d1 + s0*m1
657 __ASM_EMIT("addps %%xmm6, %%xmm4") // xmm2 = d2 + s0*m2
658 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])") // d0 += s0*m0
659 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])") // d1 += s0*m1
660 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])") // d2 += s0*m2
661 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*m3
662 __ASM_EMIT("movups %%xmm4, 0x40(%[dst])") // d4 += s0*m4
663
664 // End of loop
665 __ASM_EMIT("3:")
666
667 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
668 : [k] "r" (lanczos_kernel_3x3)
669 : "cc", "memory",
670 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
671 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
672 );
673 }
674
675 IF_ARCH_X86(
676 // Lanczos kernel 3x4: 12 SSE registers
677 static const float lanczos_kernel_3x4[] __lsp_aligned16 =
678 {
679 +0.0000000000000000f,
680 -0.0067568495254777f,
681 -0.0157944094156391f,
682 +0.0000000000000000f,
683
684 +0.0427448743491113f,
685 +0.0622703182267308f,
686 +0.0000000000000000f,
687 -0.1220498237243924f,
688
689 -0.1709794973964449f,
690 +0.0000000000000000f,
691 +0.3948602353909778f,
692 +0.8175787925827955f,
693
694 +1.0000000000000000f,
695 +0.8175787925827955f,
696 +0.3948602353909778f,
697 +0.0000000000000000f,
698
699 -0.1709794973964449f,
700 -0.1220498237243924f,
701 +0.0000000000000000f,
702 +0.0622703182267308f,
703
704 +0.0427448743491113f,
705 +0.0000000000000000f,
706 -0.0157944094156391f,
707 -0.0067568495254777f,
708
709 // Shifted by 1 left
710 -0.0067568495254777f,
711 -0.0157944094156391f,
712 +0.0000000000000000f,
713 +0.0427448743491113f,
714
715 +0.0622703182267308f,
716 +0.0000000000000000f,
717 -0.1220498237243924f,
718 -0.1709794973964449f,
719
720 +0.0000000000000000f,
721 +0.3948602353909778f,
722 +0.8175787925827955f,
723 +1.0000000000000000f,
724
725 +0.8175787925827955f,
726 +0.3948602353909778f,
727 +0.0000000000000000f,
728 -0.1709794973964449f,
729
730 -0.1220498237243924f,
731 +0.0000000000000000f,
732 +0.0622703182267308f,
733 +0.0427448743491113f,
734
735 +0.0000000000000000f,
736 -0.0157944094156391f,
737 -0.0067568495254777f,
738 +0.0000000000000000f
739 };
740 )
741
742 void lanczos_resample_3x4(float *dst, const float *src, size_t count)
743 {
744 ARCH_X86_ASM
745 (
746 __ASM_EMIT("sub $2, %[count]")
747 __ASM_EMIT("jb 2f")
748
749 // Load samples
750 __ASM_EMIT(".align 16")
751 __ASM_EMIT("1:")
752 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
753 __ASM_EMIT("movss 0x04(%[src]), %%xmm4") // xmm4 = s1
754 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
755 __ASM_EMIT("shufps $0x00, %%xmm4, %%xmm4") // xmm4 = s1
756
757 // Do convolution
758 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
759 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
760 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
761 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
762 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
763
764 __ASM_EMIT("mulps 0x00(%[k]), %%xmm1") // xmm1 = s0*m0
765 __ASM_EMIT("mulps 0x10(%[k]), %%xmm2") // xmm2 = s0*m1
766 __ASM_EMIT("mulps 0x20(%[k]), %%xmm3") // xmm3 = s0*m2
767 __ASM_EMIT("mulps 0x60(%[k]), %%xmm5") // xmm5 = s1*m6
768 __ASM_EMIT("mulps 0x70(%[k]), %%xmm6") // xmm6 = s1*m7
769 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = s0*m1 + s1*m6
770 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = s0*m2 + s1*m7
771 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
772 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
773 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
774 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d0 + s0*m0
775 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d1 + s0*m1 + s1*m6
776 __ASM_EMIT("addps %%xmm3, %%xmm7") // xmm7 = d2 + s0*m2 + s1*m7
777 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*m0
778 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*m1 + s1*m6
779 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*m2 + s1*m7
780
781 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
782 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
783 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
784 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
785 __ASM_EMIT("movaps %%xmm4, %%xmm7") // xmm7 = s1
786 __ASM_EMIT("mulps 0x30(%[k]), %%xmm0") // xmm0 = s0*m3
787 __ASM_EMIT("mulps 0x40(%[k]), %%xmm1") // xmm1 = s0*m4
788 __ASM_EMIT("mulps 0x50(%[k]), %%xmm2") // xmm2 = s0*m5
789 __ASM_EMIT("mulps 0x80(%[k]), %%xmm4") // xmm4 = s1*m8
790 __ASM_EMIT("mulps 0x90(%[k]), %%xmm5") // xmm5 = s1*m9
791 __ASM_EMIT("mulps 0xa0(%[k]), %%xmm6") // xmm6 = s1*m10
792 __ASM_EMIT("mulps 0xb0(%[k]), %%xmm7") // xmm7 = s1*m11
793 __ASM_EMIT("addps %%xmm0, %%xmm4") // xmm4 = s0*m3 + s1*m8
794 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = s0*m4 + s1*m9
795 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = s0*m5 + s1*m10
796
797 __ASM_EMIT("movups 0x30(%[dst]), %%xmm0") // xmm0 = d3
798 __ASM_EMIT("movups 0x40(%[dst]), %%xmm1") // xmm1 = d4
799 __ASM_EMIT("movups 0x50(%[dst]), %%xmm2") // xmm2 = d5
800 __ASM_EMIT("movups 0x60(%[dst]), %%xmm3") // xmm3 = d6
801
802 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = d3 + s0*m3 + s1*m8
803 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = d4 + s0*m4 + s1*m9
804 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d5 + s0*m5 + s1*m10
805 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d6 + s1*m11
806
807 __ASM_EMIT("movups %%xmm0, 0x30(%[dst])") // d3 += s0*m3 + s1*m8
808 __ASM_EMIT("movups %%xmm1, 0x40(%[dst])") // d4 += s0*m4 + s1*m9
809 __ASM_EMIT("movups %%xmm2, 0x50(%[dst])") // d5 += s0*m3 + s1*m10
810 __ASM_EMIT("movups %%xmm3, 0x60(%[dst])") // d6 += s1*m11
811
812 // Update pointers
813 __ASM_EMIT("add $0x08, %[src]")
814 __ASM_EMIT("add $0x18, %[dst]")
815 __ASM_EMIT("sub $2, %[count]")
816 __ASM_EMIT("jae 1b")
817
818 // Complete loop
819 __ASM_EMIT("2:")
820 __ASM_EMIT("add $1, %[count]")
821 __ASM_EMIT("jl 3f")
822
823 // Load samples
824 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
825 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
826 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
827 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
828 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
829 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
830 __ASM_EMIT("movaps %%xmm1, %%xmm5") // xmm5 = s0
831
832 // Do convolution
833 __ASM_EMIT("movups 0x00(%[dst]), %%xmm6") // xmm6 = d0
834 __ASM_EMIT("movups 0x10(%[dst]), %%xmm7") // xmm7 = d1
835 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*m0
836 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*m1
837 __ASM_EMIT("addps %%xmm6, %%xmm0") // xmm0 = d0 + s0*m0
838 __ASM_EMIT("addps %%xmm7, %%xmm1") // xmm1 = d1 + s0*m1
839 __ASM_EMIT("movups 0x20(%[dst]), %%xmm6") // xmm6 = d2
840 __ASM_EMIT("movups 0x30(%[dst]), %%xmm7") // xmm7 = d3
841 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*m2
842 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*m3
843 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d2 + s0*m2
844 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d3 + s0*m3
845 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
846 __ASM_EMIT("movups 0x50(%[dst]), %%xmm7") // xmm7 = d5
847 __ASM_EMIT("mulps 0x40(%[k]), %%xmm4") // xmm4 = s0*m4
848 __ASM_EMIT("mulps 0x50(%[k]), %%xmm5") // xmm5 = s0*m5
849 __ASM_EMIT("addps %%xmm6, %%xmm4") // xmm4 = d4 + s0*m4
850 __ASM_EMIT("addps %%xmm7, %%xmm5") // xmm5 = d5 + s0*m5
851
852 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])") // d0 += s0*m0
853 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])") // d1 += s0*m1
854 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])") // d2 += s0*m2
855 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*m3
856 __ASM_EMIT("movups %%xmm4, 0x40(%[dst])") // d4 += s0*m4
857 __ASM_EMIT("movups %%xmm5, 0x50(%[dst])") // d5 += s0*m5
858
859 // End of loop
860 __ASM_EMIT("3:")
861
862 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
863 : [k] "r" (lanczos_kernel_3x4)
864 : "cc", "memory",
865 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
866 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
867 );
868 }
869
870 IF_ARCH_X86(
871 // Lanczos kernel 4x2: 4 SSE registers
872 static const float lanczos_kernel_4x2[] __lsp_aligned16 =
873 {
874 +0.0000000000000000f,
875 -0.0179051851263444f,
876 -0.0636843520278618f,
877 -0.0847248039068907f,
878
879 +0.0000000000000000f,
880 +0.2353466775191407f,
881 +0.5731591682507563f,
882 +0.8773540711908775f,
883
884 +1.0000000000000000f,
885 +0.8773540711908775f,
886 +0.5731591682507563f,
887 +0.2353466775191407f,
888
889 +0.0000000000000000f,
890 -0.0847248039068907f,
891 -0.0636843520278618f,
892 -0.0179051851263444f
893 };
894 )
895
896 void lanczos_resample_4x2(float *dst, const float *src, size_t count)
897 {
898 ARCH_X86_ASM
899 (
900 __ASM_EMIT("sub $2, %[count]")
901 __ASM_EMIT("jb 2f")
902
903 // Load samples
904 __ASM_EMIT(".align 16")
905 __ASM_EMIT("1:")
906 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
907 __ASM_EMIT("movss 0x04(%[src]), %%xmm4") // xmm4 = s1
908 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
909 __ASM_EMIT("shufps $0x00, %%xmm4, %%xmm4") // xmm4 = s1
910 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
911 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
912 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
913 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
914 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
915 __ASM_EMIT("movaps %%xmm4, %%xmm7") // xmm7 = s1
916
917 // Do convolution
918 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*k0
919 __ASM_EMIT("mulps 0x00(%[k]), %%xmm4") // xmm4 = s1*k0
920 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*k1
921 __ASM_EMIT("mulps 0x10(%[k]), %%xmm5") // xmm5 = s1*k1
922 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*k2
923 __ASM_EMIT("mulps 0x20(%[k]), %%xmm6") // xmm6 = s1*k2
924 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*k3
925 __ASM_EMIT("mulps 0x30(%[k]), %%xmm7") // xmm7 = s1*k3
926 __ASM_EMIT("addps %%xmm4, %%xmm1") // xmm1 = s0*k1 + s1*k0
927 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = s0*k2 + s1*k1
928 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = s0*k3 + s1*k2
929 __ASM_EMIT("movups 0x00(%[dst]), %%xmm4") // xmm4 = d0
930 __ASM_EMIT("movups 0x10(%[dst]), %%xmm5") // xmm5 = d1
931 __ASM_EMIT("movups 0x20(%[dst]), %%xmm6") // xmm6 = d2
932 __ASM_EMIT("addps %%xmm0, %%xmm4") // xmm4 = d0 + s0*k0
933 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d1 + s0*k1 + s1*k0
934 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d2 + s0*k2 + s1*k1
935 __ASM_EMIT("movups 0x30(%[dst]), %%xmm0") // xmm0 = d3
936 __ASM_EMIT("movups 0x40(%[dst]), %%xmm1") // xmm1 = d4
937 __ASM_EMIT("addps %%xmm3, %%xmm0") // xmm3 = d3 + s0*k3 + s1*k2
938 __ASM_EMIT("addps %%xmm7, %%xmm1") // xmm7 = d4 + s1*k3
939 __ASM_EMIT("movups %%xmm4, 0x00(%[dst])") // d0 += s0*k0
940 __ASM_EMIT("movups %%xmm5, 0x10(%[dst])") // d1 += s0*k1 + s1*k0
941 __ASM_EMIT("movups %%xmm6, 0x20(%[dst])") // d2 += s0*k2 + s1*k1
942 __ASM_EMIT("movups %%xmm0, 0x30(%[dst])") // d3 += s0*k3 + s1*k2
943 __ASM_EMIT("movups %%xmm1, 0x40(%[dst])") // d4 += s1*k3
944
945 // Update pointers
946 __ASM_EMIT("add $0x08, %[src]")
947 __ASM_EMIT("add $0x20, %[dst]")
948 __ASM_EMIT("sub $2, %[count]")
949 __ASM_EMIT("jae 1b")
950
951 // Complete loop
952 __ASM_EMIT("2:")
953 __ASM_EMIT("add $1, %[count]")
954 __ASM_EMIT("jl 3f")
955
956 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
957 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
958 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
959 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
960 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
961
962 // Do convolution
963 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*k0
964 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*k1
965 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*k2
966 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*k3
967 __ASM_EMIT("movups 0x00(%[dst]), %%xmm4") // xmm4 = d0
968 __ASM_EMIT("movups 0x10(%[dst]), %%xmm5") // xmm5 = d1
969 __ASM_EMIT("movups 0x20(%[dst]), %%xmm6") // xmm6 = d2
970 __ASM_EMIT("movups 0x30(%[dst]), %%xmm7") // xmm7 = d3
971 __ASM_EMIT("addps %%xmm0, %%xmm4") // xmm4 = d0 + s0*k0
972 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d1 + s0*k1
973 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d2 + s0*k2
974 __ASM_EMIT("addps %%xmm3, %%xmm7") // xmm7 = d3 + s0*k3
975 __ASM_EMIT("movups %%xmm4, 0x00(%[dst])") // d0 += s0*k0
976 __ASM_EMIT("movups %%xmm5, 0x10(%[dst])") // d1 += s0*k1
977 __ASM_EMIT("movups %%xmm6, 0x20(%[dst])") // d2 += s0*k2
978 __ASM_EMIT("movups %%xmm7, 0x30(%[dst])") // d2 += s0*k2
979
980 // End of loop
981 __ASM_EMIT("3:")
982
983 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
984 : [k] "r" (lanczos_kernel_4x2)
985 : "cc", "memory",
986 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
987 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
988 );
989 }
990
991 IF_ARCH_X86(
992 // Lanczos kernel 4x3: 6 SSE registers
993 static const float lanczos_kernel_4x3[] __lsp_aligned16 =
994 {
995 +0.0000000000000000f,
996 +0.0073559260471942f,
997 +0.0243170840741611f,
998 +0.0300210914495816f,
999
1000 +0.0000000000000000f,
1001 -0.0677913359005429f,
1002 -0.1350949115231170f,
1003 -0.1328710183650640f,
1004
1005 +0.0000000000000000f,
1006 +0.2701898230462341f,
1007 +0.6079271018540265f,
1008 +0.8900670517104946f,
1009
1010 +1.0000000000000000f,
1011 +0.8900670517104946f,
1012 +0.6079271018540265f,
1013 +0.2701898230462341f,
1014
1015 +0.0000000000000000f,
1016 -0.1328710183650640f,
1017 -0.1350949115231170f,
1018 -0.0677913359005429f,
1019
1020 +0.0000000000000000f,
1021 +0.0300210914495816f,
1022 +0.0243170840741611f,
1023 +0.0073559260471942f
1024 };
1025 )
1026
1027 void lanczos_resample_4x3(float *dst, const float *src, size_t count)
1028 {
1029 ARCH_X86_ASM
1030 (
1031 __ASM_EMIT("sub $2, %[count]")
1032 __ASM_EMIT("jb 2f")
1033
1034 // Load samples
1035 __ASM_EMIT(".align 16")
1036 __ASM_EMIT("1:")
1037 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1038 __ASM_EMIT("movss 0x04(%[src]), %%xmm4") // xmm4 = s1
1039 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1040 __ASM_EMIT("shufps $0x00, %%xmm4, %%xmm4") // xmm4 = s1
1041 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1042 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
1043 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1044 __ASM_EMIT("movaps %%xmm4, %%xmm6") // xmm6 = s1
1045 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
1046 __ASM_EMIT("movaps %%xmm4, %%xmm7") // xmm7 = s1
1047
1048 // Do convolution
1049 __ASM_EMIT("mulps 0x00(%[k]), %%xmm1") // xmm1 = s0*k0
1050 __ASM_EMIT("mulps 0x00(%[k]), %%xmm5") // xmm5 = s1*k0
1051 __ASM_EMIT("mulps 0x10(%[k]), %%xmm2") // xmm2 = s0*k1
1052 __ASM_EMIT("mulps 0x10(%[k]), %%xmm6") // xmm6 = s1*k1
1053 __ASM_EMIT("mulps 0x20(%[k]), %%xmm3") // xmm3 = s0*k2
1054 __ASM_EMIT("mulps 0x20(%[k]), %%xmm7") // xmm7 = s1*k2
1055 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = s0*k1 + s1*k0
1056 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = s0*k2 + s1*k1
1057 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
1058 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
1059 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d0 + s0*k0
1060 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d1 + s0*k1 + s1*k0
1061 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*k0
1062 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*k1 + s1*k0
1063 __ASM_EMIT("movups 0x20(%[dst]), %%xmm5") // xmm5 = d2
1064 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1065 __ASM_EMIT("addps %%xmm3, %%xmm5") // xmm5 = d2 + s0*k2 + s1*k1
1066 __ASM_EMIT("movaps %%xmm4, %%xmm3") // xmm3 = s1
1067 __ASM_EMIT("movups %%xmm5, 0x20(%[dst])") // d2 += s0*k2 + s1*k1
1068 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1069 __ASM_EMIT("movaps %%xmm4, %%xmm5") // xmm5 = s1
1070 __ASM_EMIT("mulps 0x30(%[k]), %%xmm0") // xmm0 = s0*k3
1071 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s1*k3
1072 __ASM_EMIT("mulps 0x40(%[k]), %%xmm1") // xmm1 = s0*k4
1073 __ASM_EMIT("mulps 0x40(%[k]), %%xmm4") // xmm4 = s1*k4
1074 __ASM_EMIT("mulps 0x50(%[k]), %%xmm2") // xmm2 = s0*k5
1075 __ASM_EMIT("mulps 0x50(%[k]), %%xmm5") // xmm5 = s1*k5
1076 __ASM_EMIT("addps %%xmm7, %%xmm0") // xmm0 = s0*k3 + s1*k2
1077 __ASM_EMIT("addps %%xmm3, %%xmm1") // xmm1 = s0*k4 + s1*k3
1078 __ASM_EMIT("addps %%xmm4, %%xmm2") // xmm2 = s0*k5 + s1*k4
1079
1080 __ASM_EMIT("movups 0x30(%[dst]), %%xmm3") // xmm3 = d3
1081 __ASM_EMIT("movups 0x40(%[dst]), %%xmm4") // xmm4 = d4
1082 __ASM_EMIT("movups 0x50(%[dst]), %%xmm6") // xmm6 = d5
1083 __ASM_EMIT("movups 0x60(%[dst]), %%xmm7") // xmm7 = d6
1084 __ASM_EMIT("addps %%xmm0, %%xmm3") // xmm3 = d3 + s0*k3 + s1*k2
1085 __ASM_EMIT("addps %%xmm1, %%xmm4") // xmm4 = d4 + s0*k4 + s1*k3
1086 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d5 + s0*k5 + s1*k4
1087 __ASM_EMIT("addps %%xmm5, %%xmm7") // xmm7 = d6 + s1*k5
1088 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*k3 + s1*k2
1089 __ASM_EMIT("movups %%xmm4, 0x40(%[dst])") // d4 += s0*k4 + s1*k3
1090 __ASM_EMIT("movups %%xmm6, 0x50(%[dst])") // d5 += s0*k5 + s1*k4
1091 __ASM_EMIT("movups %%xmm7, 0x60(%[dst])") // d6 += s1*k5
1092
1093 // Update pointers
1094 __ASM_EMIT("add $0x08, %[src]")
1095 __ASM_EMIT("add $0x20, %[dst]")
1096 __ASM_EMIT("sub $2, %[count]")
1097 __ASM_EMIT("jae 1b")
1098
1099 // Complete loop
1100 __ASM_EMIT("2:")
1101 __ASM_EMIT("add $1, %[count]")
1102 __ASM_EMIT("jl 3f")
1103
1104 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1105 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1106 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1107 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1108 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1109 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1110 __ASM_EMIT("movaps %%xmm2, %%xmm5") // xmm5 = s0
1111
1112 // Do convolution
1113 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*k0
1114 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*k1
1115 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*k2
1116 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*k3
1117 __ASM_EMIT("mulps 0x40(%[k]), %%xmm4") // xmm2 = s0*k4
1118 __ASM_EMIT("mulps 0x50(%[k]), %%xmm5") // xmm3 = s0*k5
1119 __ASM_EMIT("movups 0x00(%[dst]), %%xmm6") // xmm6 = d0
1120 __ASM_EMIT("movups 0x10(%[dst]), %%xmm7") // xmm7 = d1
1121 __ASM_EMIT("addps %%xmm0, %%xmm6") // xmm4 = d0 + s0*k0
1122 __ASM_EMIT("addps %%xmm1, %%xmm7") // xmm5 = d1 + s0*k1
1123 __ASM_EMIT("movups %%xmm6, 0x00(%[dst])") // d0 += s0*k0
1124 __ASM_EMIT("movups %%xmm7, 0x10(%[dst])") // d1 += s0*k1
1125 __ASM_EMIT("movups 0x20(%[dst]), %%xmm0") // xmm0 = d2
1126 __ASM_EMIT("movups 0x30(%[dst]), %%xmm1") // xmm1 = d3
1127 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
1128 __ASM_EMIT("movups 0x50(%[dst]), %%xmm7") // xmm7 = d5
1129 __ASM_EMIT("addps %%xmm2, %%xmm0") // xmm0 = d2 + s0*k2
1130 __ASM_EMIT("addps %%xmm3, %%xmm1") // xmm1 = d3 + s0*k3
1131 __ASM_EMIT("addps %%xmm4, %%xmm6") // xmm6 = d4 + s0*k4
1132 __ASM_EMIT("addps %%xmm5, %%xmm7") // xmm7 = d5 + s0*k5
1133 __ASM_EMIT("movups %%xmm0, 0x20(%[dst])") // d2 += s0*k2
1134 __ASM_EMIT("movups %%xmm1, 0x30(%[dst])") // d3 += s0*k3
1135 __ASM_EMIT("movups %%xmm6, 0x40(%[dst])") // d4 += s0*k4
1136 __ASM_EMIT("movups %%xmm7, 0x50(%[dst])") // d5 += s0*k5
1137
1138 // End of loop
1139 __ASM_EMIT("3:")
1140
1141 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1142 : [k] "r" (lanczos_kernel_4x3)
1143 : "cc", "memory",
1144 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1145 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1146 );
1147 }
1148
1149 IF_ARCH_X86(
1150 // Lanczos kernel 4x4: 8 SSE registers
1151 static const float lanczos_kernel_4x4[] __lsp_aligned16 =
1152 {
1153 +0.0000000000000000f,
1154 -0.0039757442382413f,
1155 -0.0126608778212387f,
1156 -0.0150736176408234f,
1157
1158 +0.0000000000000000f,
1159 +0.0315083921595442f,
1160 +0.0599094833772629f,
1161 +0.0555206000541729f,
1162
1163 +0.0000000000000000f,
1164 -0.0917789511099593f,
1165 -0.1664152316035080f,
1166 -0.1525006180521938f,
1167
1168 +0.0000000000000000f,
1169 +0.2830490423665725f,
1170 +0.6203830132406946f,
1171 +0.8945424536042901f,
1172
1173 +1.0000000000000000f,
1174 +0.8945424536042901f,
1175 +0.6203830132406946f,
1176 +0.2830490423665725f,
1177
1178 +0.0000000000000000f,
1179 -0.1525006180521938f,
1180 -0.1664152316035080f,
1181 -0.0917789511099593f,
1182
1183 +0.0000000000000000f,
1184 +0.0555206000541729f,
1185 +0.0599094833772629f,
1186 +0.0315083921595442f,
1187
1188 +0.0000000000000000f,
1189 -0.0150736176408234f,
1190 -0.0126608778212387f,
1191 -0.0039757442382413f
1192 };
1193 )
1194
1195 void lanczos_resample_4x4(float *dst, const float *src, size_t count)
1196 {
1197 ARCH_X86_ASM
1198 (
1199 __ASM_EMIT("test %[count], %[count]")
1200 __ASM_EMIT("jz 2f")
1201
1202 // Load samples
1203 __ASM_EMIT(".align 16")
1204 __ASM_EMIT("1:")
1205
1206 // Do convolution (part 1)
1207 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1208 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1209 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1210 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1211 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1212
1213 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*k0
1214 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*k1
1215 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*k2
1216 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*k3
1217 __ASM_EMIT("movups 0x00(%[dst]), %%xmm4") // xmm4 = d0
1218 __ASM_EMIT("movups 0x10(%[dst]), %%xmm5") // xmm5 = d1
1219 __ASM_EMIT("movups 0x20(%[dst]), %%xmm6") // xmm6 = d2
1220 __ASM_EMIT("movups 0x30(%[dst]), %%xmm7") // xmm7 = d3
1221 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = d0 + s0*k0
1222 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = d1 + s0*k1
1223 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d2 + s0*k2
1224 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d3 + s0*k3
1225 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])") // d0 += s0*k0
1226 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])") // d1 += s0*k1
1227 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])") // d2 += s0*k2
1228 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*k3
1229
1230 // Do convolution (part 2)
1231 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1232 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1233 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1234 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1235 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1236
1237 __ASM_EMIT("mulps 0x40(%[k]), %%xmm0") // xmm0 = s0*k4
1238 __ASM_EMIT("mulps 0x50(%[k]), %%xmm1") // xmm1 = s0*k5
1239 __ASM_EMIT("mulps 0x60(%[k]), %%xmm2") // xmm2 = s0*k6
1240 __ASM_EMIT("mulps 0x70(%[k]), %%xmm3") // xmm3 = s0*k7
1241 __ASM_EMIT("movups 0x40(%[dst]), %%xmm4") // xmm4 = d4
1242 __ASM_EMIT("movups 0x50(%[dst]), %%xmm5") // xmm5 = d5
1243 __ASM_EMIT("movups 0x60(%[dst]), %%xmm6") // xmm6 = d6
1244 __ASM_EMIT("movups 0x70(%[dst]), %%xmm7") // xmm7 = d7
1245 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = d4 + s0*k4
1246 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = d5 + s0*k5
1247 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d6 + s0*k6
1248 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d7 + s0*k7
1249 __ASM_EMIT("movups %%xmm0, 0x40(%[dst])") // d4 += s0*k4
1250 __ASM_EMIT("movups %%xmm1, 0x50(%[dst])") // d5 += s0*k5
1251 __ASM_EMIT("movups %%xmm2, 0x60(%[dst])") // d6 += s0*k6
1252 __ASM_EMIT("movups %%xmm3, 0x70(%[dst])") // d7 += s0*k7
1253
1254 // Update pointers
1255 __ASM_EMIT("add $0x04, %[src]")
1256 __ASM_EMIT("add $0x10, %[dst]")
1257 __ASM_EMIT("dec %[count]")
1258 __ASM_EMIT("jnz 1b")
1259
1260 // Complete loop
1261 __ASM_EMIT("2:")
1262
1263 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1264 : [k] "r" (lanczos_kernel_4x4)
1265 : "cc", "memory",
1266 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1267 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1268 );
1269 }
1270
1271 IF_ARCH_X86(
1272 // Lanczos kernel 6x2: 6 SSE registers
1273 static const float lanczos_kernel_6x2[] __lsp_aligned16 =
1274 {
1275 +0.0000000000000000f,
1276 -0.0078021377848166f,
1277 -0.0315888188312782f,
1278 -0.0636843520278618f,
1279
1280 -0.0854897486982225f,
1281 -0.0719035699814534f,
1282 +0.0000000000000000f,
1283 +0.1409309971636486f,
1284
1285 +0.3419589947928900f,
1286 +0.5731591682507563f,
1287 +0.7897204707819555f,
1288 +0.9440586719628122f,
1289
1290 +1.0000000000000000f,
1291 +0.9440586719628122f,
1292 +0.7897204707819555f,
1293 +0.5731591682507563f,
1294
1295 +0.3419589947928900f,
1296 +0.1409309971636486f,
1297 +0.0000000000000000f,
1298 -0.0719035699814534f,
1299
1300 -0.0854897486982225f,
1301 -0.0636843520278618f,
1302 -0.0315888188312782f,
1303 -0.0078021377848166f
1304 };
1305 )
1306
1307 void lanczos_resample_6x2(float *dst, const float *src, size_t count)
1308 {
1309 ARCH_X86_ASM
1310 (
1311 __ASM_EMIT("test %[count], %[count]")
1312 __ASM_EMIT("jz 2f")
1313
1314 // Load samples
1315 __ASM_EMIT(".align 16")
1316 __ASM_EMIT("1:")
1317 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1318 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1319 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1320 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1321 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1322 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1323
1324 // Do convolution (part 1)
1325 __ASM_EMIT("mulps 0x00(%[k]), %%xmm2") // xmm2 = s0*k0
1326 __ASM_EMIT("mulps 0x10(%[k]), %%xmm3") // xmm3 = s0*k1
1327 __ASM_EMIT("mulps 0x20(%[k]), %%xmm4") // xmm4 = s0*k2
1328 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
1329 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
1330 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
1331 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d0 + s0*k0
1332 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d1 + s0*k1
1333 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d2 + s0*k2
1334 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*k0
1335 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*k1
1336 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*k2
1337
1338 // Do convolution (part 2)
1339 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1340 __ASM_EMIT("mulps 0x30(%[k]), %%xmm0") // xmm0 = s0*k3
1341 __ASM_EMIT("mulps 0x40(%[k]), %%xmm1") // xmm1 = s0*k4
1342 __ASM_EMIT("mulps 0x50(%[k]), %%xmm2") // xmm2 = s0*k5
1343 __ASM_EMIT("movups 0x30(%[dst]), %%xmm3") // xmm3 = d3
1344 __ASM_EMIT("movups 0x40(%[dst]), %%xmm4") // xmm4 = d4
1345 __ASM_EMIT("movups 0x50(%[dst]), %%xmm5") // xmm5 = d5
1346 __ASM_EMIT("addps %%xmm0, %%xmm3") // xmm3 = d3 + s0*k3
1347 __ASM_EMIT("addps %%xmm1, %%xmm4") // xmm4 = d4 + s0*k4
1348 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d5 + s0*k5
1349 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*k3
1350 __ASM_EMIT("movups %%xmm4, 0x40(%[dst])") // d4 += s0*k4
1351 __ASM_EMIT("movups %%xmm5, 0x50(%[dst])") // d5 += s0*k5
1352
1353 // Update pointers
1354 __ASM_EMIT("add $0x04, %[src]")
1355 __ASM_EMIT("add $0x18, %[dst]")
1356 __ASM_EMIT("dec %[count]")
1357 __ASM_EMIT("jnz 1b")
1358
1359 // Complete loop
1360 __ASM_EMIT("2:")
1361
1362 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1363 : [k] "r" (lanczos_kernel_6x2)
1364 : "cc", "memory",
1365 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1366 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1367 );
1368 }
1369
1370 IF_ARCH_X86(
1371 // Lanczos kernel 6x3: 9 SSE registers
1372 static const float lanczos_kernel_6x3[] __lsp_aligned16 =
1373 {
1374 +0.0000000000000000f,
1375 +0.0032875048460955f,
1376 +0.0126609519658153f,
1377 +0.0243170840741611f,
1378
1379 +0.0310789306368038f,
1380 +0.0248005479513036f,
1381 +0.0000000000000000f,
1382 -0.0424907562338176f,
1383
1384 -0.0933267410806225f,
1385 -0.1350949115231170f,
1386 -0.1458230329384726f,
1387 -0.1049261531488149f,
1388
1389 +0.0000000000000000f,
1390 +0.1676517041508127f,
1391 +0.3807169003008463f,
1392 +0.6079271018540265f,
1393
1394 +0.8103009258121772f,
1395 +0.9500889005216107f,
1396 +1.0000000000000000f,
1397 +0.9500889005216107f,
1398
1399 +0.8103009258121772f,
1400 +0.6079271018540265f,
1401 +0.3807169003008463f,
1402 +0.1676517041508127f,
1403
1404 +0.0000000000000000f,
1405 -0.1049261531488149f,
1406 -0.1458230329384726f,
1407 -0.1350949115231170f,
1408
1409 -0.0933267410806225f,
1410 -0.0424907562338176f,
1411 +0.0000000000000000f,
1412 +0.0248005479513036f,
1413
1414 +0.0310789306368038f,
1415 +0.0243170840741611f,
1416 +0.0126609519658153f,
1417 +0.0032875048460955f
1418 };
1419 )
1420 void lanczos_resample_6x3(float *dst, const float *src, size_t count)
1421 {
1422 ARCH_X86_ASM
1423 (
1424 __ASM_EMIT("test %[count], %[count]")
1425 __ASM_EMIT("jz 2f")
1426
1427 // Load samples
1428 __ASM_EMIT(".align 16")
1429 __ASM_EMIT("1:")
1430 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1431 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1432 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1433 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1434 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1435 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1436
1437 // Do convolution (part 1)
1438 __ASM_EMIT("mulps 0x00(%[k]), %%xmm2") // xmm2 = s0*k0
1439 __ASM_EMIT("mulps 0x10(%[k]), %%xmm3") // xmm3 = s0*k1
1440 __ASM_EMIT("mulps 0x20(%[k]), %%xmm4") // xmm4 = s0*k2
1441 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
1442 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
1443 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
1444 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d0 + s0*k0
1445 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d1 + s0*k1
1446 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d2 + s0*k2
1447 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*k0
1448 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*k1
1449 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*k2
1450
1451 // Do convolution (part 2)
1452 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1453 __ASM_EMIT("movaps %%xmm0, %%xmm6") // xmm6 = s0
1454 __ASM_EMIT("movaps %%xmm1, %%xmm7") // xmm7 = s0
1455 __ASM_EMIT("mulps 0x30(%[k]), %%xmm0") // xmm0 = s0*k3
1456 __ASM_EMIT("mulps 0x40(%[k]), %%xmm1") // xmm1 = s0*k4
1457 __ASM_EMIT("mulps 0x50(%[k]), %%xmm2") // xmm2 = s0*k5
1458 __ASM_EMIT("movups 0x30(%[dst]), %%xmm3") // xmm3 = d3
1459 __ASM_EMIT("movups 0x40(%[dst]), %%xmm4") // xmm4 = d4
1460 __ASM_EMIT("movups 0x50(%[dst]), %%xmm5") // xmm5 = d5
1461 __ASM_EMIT("addps %%xmm0, %%xmm3") // xmm3 = d3 + s0*k3
1462 __ASM_EMIT("addps %%xmm1, %%xmm4") // xmm4 = d4 + s0*k4
1463 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d5 + s0*k5
1464 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*k3
1465 __ASM_EMIT("movups %%xmm4, 0x40(%[dst])") // d4 += s0*k4
1466 __ASM_EMIT("movups %%xmm5, 0x50(%[dst])") // d5 += s0*k5
1467
1468 // Do convolution (part 3)
1469 __ASM_EMIT("movaps %%xmm7, %%xmm5") // xmm5 = s0
1470 __ASM_EMIT("mulps 0x60(%[k]), %%xmm6") // xmm6 = s0*k6
1471 __ASM_EMIT("mulps 0x70(%[k]), %%xmm7") // xmm7 = s0*k7
1472 __ASM_EMIT("mulps 0x80(%[k]), %%xmm5") // xmm5 = s0*k8
1473 __ASM_EMIT("movups 0x60(%[dst]), %%xmm0") // xmm0 = d6
1474 __ASM_EMIT("movups 0x70(%[dst]), %%xmm1") // xmm1 = d7
1475 __ASM_EMIT("movups 0x80(%[dst]), %%xmm2") // xmm2 = d8
1476 __ASM_EMIT("addps %%xmm6, %%xmm0") // xmm0 = d6 + s0*k6
1477 __ASM_EMIT("addps %%xmm7, %%xmm1") // xmm1 = d7 + s0*k7
1478 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = d8 + s0*k8
1479 __ASM_EMIT("movups %%xmm0, 0x60(%[dst])") // d6 += s0*k3
1480 __ASM_EMIT("movups %%xmm1, 0x70(%[dst])") // d7 += s0*k4
1481 __ASM_EMIT("movups %%xmm2, 0x80(%[dst])") // d8 += s0*k5
1482
1483 // Update pointers
1484 __ASM_EMIT("add $0x04, %[src]")
1485 __ASM_EMIT("add $0x18, %[dst]")
1486 __ASM_EMIT("dec %[count]")
1487 __ASM_EMIT("jnz 1b")
1488
1489 // Complete loop
1490 __ASM_EMIT("2:")
1491
1492 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1493 : [k] "r" (lanczos_kernel_6x3)
1494 : "cc", "memory",
1495 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1496 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1497 );
1498 }
1499
1500 IF_ARCH_X86(
1501 // Lanczos kernel 6x4: 12 SSE registers
1502 static const float lanczos_kernel_6x4[] __lsp_aligned16 =
1503 {
1504 +0.0000000000000000f,
1505 -0.0018000092949500f,
1506 -0.0067568495254777f,
1507 -0.0126608778212387f,
1508
1509 -0.0157944094156391f,
1510 -0.0123019137260206f,
1511 +0.0000000000000000f,
1512 +0.0200263389720192f,
1513
1514 +0.0427448743491113f,
1515 +0.0599094833772629f,
1516 +0.0622703182267308f,
1517 +0.0427971267140625f,
1518
1519 +0.0000000000000000f,
1520 -0.0597744992948478f,
1521 -0.1220498237243924f,
1522 -0.1664152316035080f,
1523
1524 -0.1709794973964449f,
1525 -0.1181145298553785f,
1526 +0.0000000000000000f,
1527 +0.1776396342037379f,
1528
1529 +0.3948602353909778f,
1530 +0.6203830132406946f,
1531 +0.8175787925827955f,
1532 +0.9522049170285306f,
1533
1534 +1.0000000000000000f,
1535 +0.9522049170285306f,
1536 +0.8175787925827955f,
1537 +0.6203830132406946f,
1538
1539 +0.3948602353909778f,
1540 +0.1776396342037379f,
1541 +0.0000000000000000f,
1542 -0.1181145298553785f,
1543
1544 -0.1709794973964449f,
1545 -0.1664152316035080f,
1546 -0.1220498237243924f,
1547 -0.0597744992948478f,
1548
1549 +0.0000000000000000f,
1550 +0.0427971267140625f,
1551 +0.0622703182267308f,
1552 +0.0599094833772629f,
1553
1554 +0.0427448743491113f,
1555 +0.0200263389720192f,
1556 +0.0000000000000000f,
1557 -0.0123019137260206f,
1558
1559 -0.0157944094156391f,
1560 -0.0126608778212387f,
1561 -0.0067568495254777f,
1562 -0.0018000092949500f
1563 };
1564 )
1565 void lanczos_resample_6x4(float *dst, const float *src, size_t count)
1566 {
1567 ARCH_X86_ASM
1568 (
1569 __ASM_EMIT("test %[count], %[count]")
1570 __ASM_EMIT("jz 2f")
1571
1572 // Load samples
1573 __ASM_EMIT(".align 16")
1574 __ASM_EMIT("1:")
1575 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1576 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1577 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1578 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1579 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1580 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1581
1582 // Do convolution (part 1)
1583 __ASM_EMIT("mulps 0x00(%[k]), %%xmm2") // xmm2 = s0*k0
1584 __ASM_EMIT("mulps 0x10(%[k]), %%xmm3") // xmm3 = s0*k1
1585 __ASM_EMIT("mulps 0x20(%[k]), %%xmm4") // xmm4 = s0*k2
1586 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
1587 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
1588 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
1589 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d0 + s0*k0
1590 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d1 + s0*k1
1591 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d2 + s0*k2
1592 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*k0
1593 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*k1
1594 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*k2
1595
1596 // Do convolution (part 2)
1597 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1598 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
1599 __ASM_EMIT("movaps %%xmm1, %%xmm4") // xmm4 = s0
1600 __ASM_EMIT("mulps 0x30(%[k]), %%xmm2") // xmm2 = s0*k3
1601 __ASM_EMIT("mulps 0x40(%[k]), %%xmm3") // xmm3 = s0*k4
1602 __ASM_EMIT("mulps 0x50(%[k]), %%xmm4") // xmm4 = s0*k5
1603 __ASM_EMIT("movups 0x30(%[dst]), %%xmm5") // xmm5 = d3
1604 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
1605 __ASM_EMIT("movups 0x50(%[dst]), %%xmm7") // xmm7 = d5
1606 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d3 + s0*k3
1607 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d4 + s0*k4
1608 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d5 + s0*k5
1609 __ASM_EMIT("movups %%xmm5, 0x30(%[dst])") // d3 += s0*k3
1610 __ASM_EMIT("movups %%xmm6, 0x40(%[dst])") // d4 += s0*k4
1611 __ASM_EMIT("movups %%xmm7, 0x50(%[dst])") // d5 += s0*k5
1612
1613 // Do convolution (part 3)
1614 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1615 __ASM_EMIT("movaps %%xmm0, %%xmm3") // xmm3 = s0
1616 __ASM_EMIT("movaps %%xmm1, %%xmm4") // xmm4 = s0
1617 __ASM_EMIT("mulps 0x60(%[k]), %%xmm2") // xmm2 = s0*k6
1618 __ASM_EMIT("mulps 0x70(%[k]), %%xmm3") // xmm3 = s0*k7
1619 __ASM_EMIT("mulps 0x80(%[k]), %%xmm4") // xmm4 = s0*k8
1620 __ASM_EMIT("movups 0x60(%[dst]), %%xmm5") // xmm5 = d6
1621 __ASM_EMIT("movups 0x70(%[dst]), %%xmm6") // xmm6 = d7
1622 __ASM_EMIT("movups 0x80(%[dst]), %%xmm7") // xmm7 = d8
1623 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d6 + s0*k6
1624 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d7 + s0*k7
1625 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d8 + s0*k8
1626 __ASM_EMIT("movups %%xmm5, 0x60(%[dst])") // d6 += s0*k6
1627 __ASM_EMIT("movups %%xmm6, 0x70(%[dst])") // d7 += s0*k7
1628 __ASM_EMIT("movups %%xmm7, 0x80(%[dst])") // d8 += s0*k8
1629
1630 // Do convolution (part 4)
1631 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1632 __ASM_EMIT("mulps 0x90(%[k]), %%xmm0") // xmm0 = s0*k9
1633 __ASM_EMIT("mulps 0xa0(%[k]), %%xmm1") // xmm1 = s0*k10
1634 __ASM_EMIT("mulps 0xb0(%[k]), %%xmm2") // xmm2 = s0*k11
1635 __ASM_EMIT("movups 0x90(%[dst]), %%xmm5") // xmm5 = d9
1636 __ASM_EMIT("movups 0xa0(%[dst]), %%xmm6") // xmm6 = d10
1637 __ASM_EMIT("movups 0xb0(%[dst]), %%xmm7") // xmm7 = d11
1638 __ASM_EMIT("addps %%xmm0, %%xmm5") // xmm5 = d9 + s0*k9
1639 __ASM_EMIT("addps %%xmm1, %%xmm6") // xmm6 = d10 + s0*k10
1640 __ASM_EMIT("addps %%xmm2, %%xmm7") // xmm7 = d11 + s0*k11
1641 __ASM_EMIT("movups %%xmm5, 0x90(%[dst])") // d9 += s0*k6
1642 __ASM_EMIT("movups %%xmm6, 0xa0(%[dst])") // d10 += s0*k7
1643 __ASM_EMIT("movups %%xmm7, 0xb0(%[dst])") // d11 += s0*k8
1644
1645 // Update pointers
1646 __ASM_EMIT("add $0x04, %[src]")
1647 __ASM_EMIT("add $0x18, %[dst]")
1648 __ASM_EMIT("dec %[count]")
1649 __ASM_EMIT("jnz 1b")
1650
1651 // Complete loop
1652 __ASM_EMIT("2:")
1653
1654 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1655 : [k] "r" (lanczos_kernel_6x4)
1656 : "cc", "memory",
1657 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1658 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1659 );
1660 }
1661
1662 IF_ARCH_X86(
1663 // Lanczos kernel 8x2: 8 SSE registers
1664 static const float lanczos_kernel_8x2[] __lsp_aligned16 =
1665 {
1666 +0.0000000000000000f,
1667 -0.0043033145538298f,
1668 -0.0179051851263444f,
1669 -0.0393892611124141f,
1670
1671 -0.0636843520278618f,
1672 -0.0823353965569232f,
1673 -0.0847248039068907f,
1674 -0.0600950644541902f,
1675
1676 +0.0000000000000000f,
1677 +0.0993408208324369f,
1678 +0.2353466775191407f,
1679 +0.3985033193355084f,
1680
1681 +0.5731591682507563f,
1682 +0.7396427919997760f,
1683 +0.8773540711908775f,
1684 +0.9682457746117045f,
1685
1686 +1.0000000000000000f,
1687 +0.9682457746117045f,
1688 +0.8773540711908775f,
1689 +0.7396427919997760f,
1690
1691 +0.5731591682507563f,
1692 +0.3985033193355084f,
1693 +0.2353466775191407f,
1694 +0.0993408208324369f,
1695
1696 +0.0000000000000000f,
1697 -0.0600950644541902f,
1698 -0.0847248039068907f,
1699 -0.0823353965569232f,
1700
1701 -0.0636843520278618f,
1702 -0.0393892611124141f,
1703 -0.0179051851263444f,
1704 -0.0043033145538298f
1705 };
1706 )
1707
1708 void lanczos_resample_8x2(float *dst, const float *src, size_t count)
1709 {
1710 ARCH_X86_ASM
1711 (
1712 __ASM_EMIT("test %[count], %[count]")
1713 __ASM_EMIT("jz 2f")
1714
1715 // Load samples
1716 __ASM_EMIT(".align 16")
1717 __ASM_EMIT("1:")
1718
1719 // Do convolution (part 1)
1720 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1721 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1722 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1723 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1724 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1725
1726 __ASM_EMIT("mulps 0x00(%[k]), %%xmm0") // xmm0 = s0*k0
1727 __ASM_EMIT("mulps 0x10(%[k]), %%xmm1") // xmm1 = s0*k1
1728 __ASM_EMIT("mulps 0x20(%[k]), %%xmm2") // xmm2 = s0*k2
1729 __ASM_EMIT("mulps 0x30(%[k]), %%xmm3") // xmm3 = s0*k3
1730 __ASM_EMIT("movups 0x00(%[dst]), %%xmm4") // xmm4 = d0
1731 __ASM_EMIT("movups 0x10(%[dst]), %%xmm5") // xmm5 = d1
1732 __ASM_EMIT("movups 0x20(%[dst]), %%xmm6") // xmm6 = d2
1733 __ASM_EMIT("movups 0x30(%[dst]), %%xmm7") // xmm7 = d3
1734 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = d0 + s0*k0
1735 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = d1 + s0*k1
1736 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d2 + s0*k2
1737 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d3 + s0*k3
1738 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])") // d0 += s0*k0
1739 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])") // d1 += s0*k1
1740 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])") // d2 += s0*k2
1741 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])") // d3 += s0*k3
1742
1743 // Do convolution (part 2)
1744 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1745 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1746 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1747 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1748 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1749
1750 __ASM_EMIT("mulps 0x40(%[k]), %%xmm0") // xmm0 = s0*k4
1751 __ASM_EMIT("mulps 0x50(%[k]), %%xmm1") // xmm1 = s0*k5
1752 __ASM_EMIT("mulps 0x60(%[k]), %%xmm2") // xmm2 = s0*k6
1753 __ASM_EMIT("mulps 0x70(%[k]), %%xmm3") // xmm3 = s0*k7
1754 __ASM_EMIT("movups 0x40(%[dst]), %%xmm4") // xmm4 = d4
1755 __ASM_EMIT("movups 0x50(%[dst]), %%xmm5") // xmm5 = d5
1756 __ASM_EMIT("movups 0x60(%[dst]), %%xmm6") // xmm6 = d6
1757 __ASM_EMIT("movups 0x70(%[dst]), %%xmm7") // xmm7 = d7
1758 __ASM_EMIT("addps %%xmm4, %%xmm0") // xmm0 = d4 + s0*k4
1759 __ASM_EMIT("addps %%xmm5, %%xmm1") // xmm1 = d5 + s0*k5
1760 __ASM_EMIT("addps %%xmm6, %%xmm2") // xmm2 = d6 + s0*k6
1761 __ASM_EMIT("addps %%xmm7, %%xmm3") // xmm3 = d7 + s0*k7
1762 __ASM_EMIT("movups %%xmm0, 0x40(%[dst])") // d4 += s0*k4
1763 __ASM_EMIT("movups %%xmm1, 0x50(%[dst])") // d5 += s0*k5
1764 __ASM_EMIT("movups %%xmm2, 0x60(%[dst])") // d6 += s0*k6
1765 __ASM_EMIT("movups %%xmm3, 0x70(%[dst])") // d7 += s0*k7
1766
1767 // Update pointers
1768 __ASM_EMIT("add $0x04, %[src]")
1769 __ASM_EMIT("add $0x20, %[dst]")
1770 __ASM_EMIT("dec %[count]")
1771 __ASM_EMIT("jnz 1b")
1772
1773 // Complete loop
1774 __ASM_EMIT("2:")
1775
1776 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1777 : [k] "r" (lanczos_kernel_8x2)
1778 : "cc", "memory",
1779 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1780 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1781 );
1782 }
1783
1784 IF_ARCH_X86(
1785 // Lanczos kernel 8x3: 12 SSE registers
1786 static const float lanczos_kernel_8x3[] __lsp_aligned16 =
1787 {
1788 +0.0000000000000000f,
1789 +0.0018368899607481f,
1790 +0.0073559260471942f,
1791 +0.0155961678435580f,
1792
1793 +0.0243170840741611f,
1794 +0.0303079634725070f,
1795 +0.0300210914495816f,
1796 +0.0204366616947175f,
1797
1798 +0.0000000000000000f,
1799 -0.0305684889733737f,
1800 -0.0677913359005429f,
1801 -0.1054383717904384f,
1802
1803 -0.1350949115231170f,
1804 -0.1472651639056537f,
1805 -0.1328710183650640f,
1806 -0.0849124693704824f,
1807
1808 +0.0000000000000000f,
1809 +0.1205345965259870f,
1810 +0.2701898230462341f,
1811 +0.4376469925430009f,
1812
1813 +0.6079271018540265f,
1814 +0.7642122243343417f,
1815 +0.8900670517104946f,
1816 +0.9717147892357163f,
1817
1818 +1.0000000000000000f,
1819 +0.9717147892357163f,
1820 +0.8900670517104946f,
1821 +0.7642122243343417f,
1822
1823 +0.6079271018540265f,
1824 +0.4376469925430009f,
1825 +0.2701898230462341f,
1826 +0.1205345965259870f,
1827
1828 +0.0000000000000000f,
1829 -0.0849124693704824f,
1830 -0.1328710183650640f,
1831 -0.1472651639056537f,
1832
1833 -0.1350949115231170f,
1834 -0.1054383717904384f,
1835 -0.0677913359005429f,
1836 -0.0305684889733737f,
1837
1838 +0.0000000000000000f,
1839 +0.0204366616947175f,
1840 +0.0300210914495816f,
1841 +0.0303079634725070f,
1842
1843 +0.0243170840741611f,
1844 +0.0155961678435580f,
1845 +0.0073559260471942f,
1846 +0.0018368899607481f
1847 };
1848 )
1849
1850 void lanczos_resample_8x3(float *dst, const float *src, size_t count)
1851 {
1852 ARCH_X86_ASM
1853 (
1854 __ASM_EMIT("test %[count], %[count]")
1855 __ASM_EMIT("jz 2f")
1856
1857 // Load samples
1858 __ASM_EMIT(".align 16")
1859 __ASM_EMIT("1:")
1860 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
1861 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
1862 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
1863
1864 // Do convolution (part 1)
1865 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1866 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1867 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1868 __ASM_EMIT("mulps 0x00(%[k]), %%xmm2") // xmm2 = s0*k0
1869 __ASM_EMIT("mulps 0x10(%[k]), %%xmm3") // xmm3 = s0*k1
1870 __ASM_EMIT("mulps 0x20(%[k]), %%xmm4") // xmm4 = s0*k2
1871 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
1872 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
1873 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
1874 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = d0 + s0*k0
1875 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = d1 + s0*k1
1876 __ASM_EMIT("addps %%xmm7, %%xmm4") // xmm4 = d2 + s0*k2
1877 __ASM_EMIT("movups %%xmm2, 0x00(%[dst])") // d0 += s0*k0
1878 __ASM_EMIT("movups %%xmm3, 0x10(%[dst])") // d1 += s0*k1
1879 __ASM_EMIT("movups %%xmm4, 0x20(%[dst])") // d2 += s0*k2
1880
1881 // Do convolution (part 2)
1882 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1883 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1884 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
1885 __ASM_EMIT("mulps 0x30(%[k]), %%xmm2") // xmm2 = s0*k3
1886 __ASM_EMIT("mulps 0x40(%[k]), %%xmm3") // xmm3 = s0*k4
1887 __ASM_EMIT("mulps 0x50(%[k]), %%xmm4") // xmm4 = s0*k5
1888 __ASM_EMIT("movups 0x30(%[dst]), %%xmm5") // xmm5 = d3
1889 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
1890 __ASM_EMIT("movups 0x50(%[dst]), %%xmm7") // xmm7 = d5
1891 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = d3 + s0*k3
1892 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = d4 + s0*k4
1893 __ASM_EMIT("addps %%xmm7, %%xmm4") // xmm4 = d5 + s0*k5
1894 __ASM_EMIT("movups %%xmm2, 0x30(%[dst])") // d3 += s0*k3
1895 __ASM_EMIT("movups %%xmm3, 0x40(%[dst])") // d4 += s0*k4
1896 __ASM_EMIT("movups %%xmm4, 0x50(%[dst])") // d5 += s0*k5
1897
1898 // Do convolution (part 3)
1899 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
1900 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
1901 __ASM_EMIT("movaps %%xmm2, %%xmm4") // xmm4 = s0
1902 __ASM_EMIT("mulps 0x60(%[k]), %%xmm2") // xmm2 = s0*k6
1903 __ASM_EMIT("mulps 0x70(%[k]), %%xmm3") // xmm3 = s0*k7
1904 __ASM_EMIT("mulps 0x80(%[k]), %%xmm4") // xmm4 = s0*k8
1905 __ASM_EMIT("movups 0x60(%[dst]), %%xmm5") // xmm5 = d6
1906 __ASM_EMIT("movups 0x70(%[dst]), %%xmm6") // xmm6 = d7
1907 __ASM_EMIT("movups 0x80(%[dst]), %%xmm7") // xmm7 = d8
1908 __ASM_EMIT("addps %%xmm5, %%xmm2") // xmm2 = d6 + s0*k6
1909 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = d7 + s0*k7
1910 __ASM_EMIT("addps %%xmm7, %%xmm4") // xmm4 = d8 + s0*k8
1911 __ASM_EMIT("movups %%xmm2, 0x60(%[dst])") // d6 += s0*k6
1912 __ASM_EMIT("movups %%xmm3, 0x70(%[dst])") // d7 += s0*k7
1913 __ASM_EMIT("movups %%xmm4, 0x80(%[dst])") // d8 += s0*k8
1914
1915 // Do convolution (part 4)
1916 __ASM_EMIT("movaps %%xmm1, %%xmm2") // xmm2 = s0
1917 __ASM_EMIT("mulps 0x90(%[k]), %%xmm0") // xmm0 = s0*k9
1918 __ASM_EMIT("mulps 0xa0(%[k]), %%xmm1") // xmm1 = s0*k10
1919 __ASM_EMIT("mulps 0xb0(%[k]), %%xmm2") // xmm2 = s0*k11
1920 __ASM_EMIT("movups 0x90(%[dst]), %%xmm5") // xmm5 = d9
1921 __ASM_EMIT("movups 0xa0(%[dst]), %%xmm6") // xmm6 = d10
1922 __ASM_EMIT("movups 0xb0(%[dst]), %%xmm7") // xmm7 = d11
1923 __ASM_EMIT("addps %%xmm5, %%xmm0") // xmm0 = d9 + s0*k9
1924 __ASM_EMIT("addps %%xmm6, %%xmm1") // xmm1 = d10 + s0*k10
1925 __ASM_EMIT("addps %%xmm7, %%xmm2") // xmm2 = d11 + s0*k11
1926 __ASM_EMIT("movups %%xmm0, 0x90(%[dst])") // d9 += s0*k9
1927 __ASM_EMIT("movups %%xmm1, 0xa0(%[dst])") // d10 += s0*k10
1928 __ASM_EMIT("movups %%xmm2, 0xb0(%[dst])") // d11 += s0*k11
1929
1930 // Update pointers
1931 __ASM_EMIT("add $0x04, %[src]")
1932 __ASM_EMIT("add $0x20, %[dst]")
1933 __ASM_EMIT("dec %[count]")
1934 __ASM_EMIT("jnz 1b")
1935
1936 // Complete loop
1937 __ASM_EMIT("2:")
1938
1939 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
1940 : [k] "r" (lanczos_kernel_8x3)
1941 : "cc", "memory",
1942 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
1943 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
1944 );
1945 }
1946
1947 IF_ARCH_X86(
1948 // Lanczos kernel 8x4: 16 SSE registers
1949 static const float lanczos_kernel_8x4[] __lsp_aligned16 =
1950 {
1951 +0.0000000000000000f,
1952 -0.0010124148822791f,
1953 -0.0039757442382413f,
1954 -0.0082714887261119f,
1955
1956 -0.0126608778212387f,
1957 -0.0154958216565010f,
1958 -0.0150736176408234f,
1959 -0.0100753105205530f,
1960
1961 +0.0000000000000000f,
1962 +0.0145047275409824f,
1963 +0.0315083921595442f,
1964 +0.0479233082326825f,
1965
1966 +0.0599094833772629f,
1967 +0.0635233253590927f,
1968 +0.0555206000541729f,
1969 +0.0341810767869351f,
1970
1971 +0.0000000000000000f,
1972 -0.0439036941841078f,
1973 -0.0917789511099593f,
1974 -0.1356918370096595f,
1975
1976 -0.1664152316035080f,
1977 -0.1746626357901899f,
1978 -0.1525006180521938f,
1979 -0.0947284057923417f,
1980
1981 +0.0000000000000000f,
1982 +0.1285116137825641f,
1983 +0.2830490423665725f,
1984 +0.4518581595035692f,
1985
1986 +0.6203830132406946f,
1987 +0.7729246687400148f,
1988 +0.8945424536042901f,
1989 +0.9729307018702211f,
1990
1991 +1.0000000000000000f,
1992 +0.9729307018702211f,
1993 +0.8945424536042901f,
1994 +0.7729246687400148f,
1995
1996 +0.6203830132406946f,
1997 +0.4518581595035692f,
1998 +0.2830490423665725f,
1999 +0.1285116137825641f,
2000
2001 +0.0000000000000000f,
2002 -0.0947284057923417f,
2003 -0.1525006180521938f,
2004 -0.1746626357901899f,
2005
2006 -0.1664152316035080f,
2007 -0.1356918370096595f,
2008 -0.0917789511099593f,
2009 -0.0439036941841078f,
2010
2011 +0.0000000000000000f,
2012 +0.0341810767869351f,
2013 +0.0555206000541729f,
2014 +0.0635233253590927f,
2015
2016 +0.0599094833772629f,
2017 +0.0479233082326825f,
2018 +0.0315083921595442f,
2019 +0.0145047275409824f,
2020
2021 +0.0000000000000000f,
2022 -0.0100753105205530f,
2023 -0.0150736176408234f,
2024 -0.0154958216565010f,
2025
2026 -0.0126608778212387f,
2027 -0.0082714887261119f,
2028 -0.0039757442382413f,
2029 -0.0010124148822791f
2030 };
2031 )
2032
2033 void lanczos_resample_8x4(float *dst, const float *src, size_t count)
2034 {
2035 ARCH_X86_ASM
2036 (
2037 __ASM_EMIT("test %[count], %[count]")
2038 __ASM_EMIT("jz 2f")
2039
2040 // Load samples
2041 __ASM_EMIT(".align 16")
2042 __ASM_EMIT("1:")
2043 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
2044 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 = s0
2045 __ASM_EMIT("movaps %%xmm0, %%xmm1") // xmm1 = s0
2046
2047 // Do convolution (part 1)
2048 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
2049 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
2050 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
2051 __ASM_EMIT("mulps 0x00(%[k]), %%xmm2") // xmm2 = s0*k0
2052 __ASM_EMIT("mulps 0x10(%[k]), %%xmm3") // xmm3 = s0*k1
2053 __ASM_EMIT("mulps 0x20(%[k]), %%xmm4") // xmm4 = s0*k2
2054 __ASM_EMIT("movups 0x00(%[dst]), %%xmm5") // xmm5 = d0
2055 __ASM_EMIT("movups 0x10(%[dst]), %%xmm6") // xmm6 = d1
2056 __ASM_EMIT("movups 0x20(%[dst]), %%xmm7") // xmm7 = d2
2057 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d0 + s0*k0
2058 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d1 + s0*k1
2059 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d2 + s0*k2
2060 __ASM_EMIT("movups %%xmm5, 0x00(%[dst])") // d0 += s0*k0
2061 __ASM_EMIT("movups %%xmm6, 0x10(%[dst])") // d1 += s0*k1
2062 __ASM_EMIT("movups %%xmm7, 0x20(%[dst])") // d2 += s0*k2
2063
2064 // Do convolution (part 2)
2065 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
2066 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
2067 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
2068 __ASM_EMIT("mulps 0x30(%[k]), %%xmm2") // xmm2 = s0*k3
2069 __ASM_EMIT("mulps 0x40(%[k]), %%xmm3") // xmm3 = s0*k4
2070 __ASM_EMIT("mulps 0x50(%[k]), %%xmm4") // xmm4 = s0*k5
2071 __ASM_EMIT("movups 0x30(%[dst]), %%xmm5") // xmm5 = d3
2072 __ASM_EMIT("movups 0x40(%[dst]), %%xmm6") // xmm6 = d4
2073 __ASM_EMIT("movups 0x50(%[dst]), %%xmm7") // xmm7 = d5
2074 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d3 + s0*k3
2075 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d4 + s0*k4
2076 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d5 + s0*k5
2077 __ASM_EMIT("movups %%xmm5, 0x30(%[dst])") // d3 += s0*k3
2078 __ASM_EMIT("movups %%xmm6, 0x40(%[dst])") // d4 += s0*k4
2079 __ASM_EMIT("movups %%xmm7, 0x50(%[dst])") // d5 += s0*k5
2080
2081 // Do convolution (part 3)
2082 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
2083 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
2084 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
2085 __ASM_EMIT("mulps 0x60(%[k]), %%xmm2") // xmm2 = s0*k6
2086 __ASM_EMIT("mulps 0x70(%[k]), %%xmm3") // xmm3 = s0*k7
2087 __ASM_EMIT("mulps 0x80(%[k]), %%xmm4") // xmm4 = s0*k8
2088 __ASM_EMIT("movups 0x60(%[dst]), %%xmm5") // xmm5 = d6
2089 __ASM_EMIT("movups 0x70(%[dst]), %%xmm6") // xmm6 = d7
2090 __ASM_EMIT("movups 0x80(%[dst]), %%xmm7") // xmm7 = d8
2091 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d6 + s0*k6
2092 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d7 + s0*k7
2093 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d8 + s0*k8
2094 __ASM_EMIT("movups %%xmm5, 0x60(%[dst])") // d6 += s0*k6
2095 __ASM_EMIT("movups %%xmm6, 0x70(%[dst])") // d7 += s0*k7
2096 __ASM_EMIT("movups %%xmm7, 0x80(%[dst])") // d8 += s0*k8
2097
2098 // Do convolution (part 4)
2099 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
2100 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
2101 __ASM_EMIT("movaps %%xmm0, %%xmm4") // xmm4 = s0
2102 __ASM_EMIT("mulps 0x90(%[k]), %%xmm2") // xmm2 = s0*k9
2103 __ASM_EMIT("mulps 0xa0(%[k]), %%xmm3") // xmm3 = s0*k10
2104 __ASM_EMIT("mulps 0xb0(%[k]), %%xmm4") // xmm4 = s0*k11
2105 __ASM_EMIT("movups 0x90(%[dst]), %%xmm5") // xmm5 = d9
2106 __ASM_EMIT("movups 0xa0(%[dst]), %%xmm6") // xmm6 = d10
2107 __ASM_EMIT("movups 0xb0(%[dst]), %%xmm7") // xmm7 = d11
2108 __ASM_EMIT("addps %%xmm2, %%xmm5") // xmm5 = d9 + s0*k9
2109 __ASM_EMIT("addps %%xmm3, %%xmm6") // xmm6 = d10 + s0*k10
2110 __ASM_EMIT("addps %%xmm4, %%xmm7") // xmm7 = d11 + s0*k11
2111 __ASM_EMIT("movups %%xmm5, 0x90(%[dst])") // d9 += s0*k9
2112 __ASM_EMIT("movups %%xmm6, 0xa0(%[dst])") // d10 += s0*k10
2113 __ASM_EMIT("movups %%xmm7, 0xb0(%[dst])") // d11 += s0*k11
2114
2115 // Do convolution (part 5)
2116 __ASM_EMIT("movaps %%xmm0, %%xmm2") // xmm2 = s0
2117 __ASM_EMIT("movaps %%xmm1, %%xmm3") // xmm3 = s0
2118 __ASM_EMIT("mulps 0xc0(%[k]), %%xmm0") // xmm0 = s0*k12
2119 __ASM_EMIT("mulps 0xd0(%[k]), %%xmm1") // xmm1 = s0*k13
2120 __ASM_EMIT("mulps 0xe0(%[k]), %%xmm2") // xmm2 = s0*k14
2121 __ASM_EMIT("mulps 0xf0(%[k]), %%xmm3") // xmm3 = s0*k15
2122 __ASM_EMIT("movups 0xc0(%[dst]), %%xmm4") // xmm4 = d12
2123 __ASM_EMIT("movups 0xd0(%[dst]), %%xmm5") // xmm5 = d13
2124 __ASM_EMIT("movups 0xe0(%[dst]), %%xmm6") // xmm6 = d14
2125 __ASM_EMIT("movups 0xf0(%[dst]), %%xmm7") // xmm7 = d15
2126 __ASM_EMIT("addps %%xmm0, %%xmm4") // xmm4 = d12 + s0*k12
2127 __ASM_EMIT("addps %%xmm1, %%xmm5") // xmm5 = d13 + s0*k13
2128 __ASM_EMIT("addps %%xmm2, %%xmm6") // xmm6 = d14 + s0*k14
2129 __ASM_EMIT("addps %%xmm3, %%xmm7") // xmm7 = d15 + s0*k15
2130 __ASM_EMIT("movups %%xmm4, 0xc0(%[dst])") // d12 += s0*k12
2131 __ASM_EMIT("movups %%xmm5, 0xd0(%[dst])") // d13 += s0*k13
2132 __ASM_EMIT("movups %%xmm6, 0xe0(%[dst])") // d14 += s0*k14
2133 __ASM_EMIT("movups %%xmm7, 0xf0(%[dst])") // d15 += s0*k15
2134
2135 // Update pointers
2136 __ASM_EMIT("add $0x04, %[src]")
2137 __ASM_EMIT("add $0x20, %[dst]")
2138 __ASM_EMIT("dec %[count]")
2139 __ASM_EMIT("jnz 1b")
2140
2141 // Complete loop
2142 __ASM_EMIT("2:")
2143
2144 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2145 : [k] "r" (lanczos_kernel_8x4)
2146 : "cc", "memory",
2147 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2148 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2149 );
2150 }
2151
2152 void downsample_2x(float *dst, const float *src, size_t count)
2153 {
2154 ARCH_X86_ASM
2155 (
2156 __ASM_EMIT("sub $16, %[count]")
2157 __ASM_EMIT("jb 2f")
2158
2159 // 16 x sample loop
2160 __ASM_EMIT(".align 16")
2161 __ASM_EMIT("1:")
2162 __ASM_EMIT("movups 0x00(%[src]), %%xmm0") // xmm0 = s0 ? s1 ?
2163 __ASM_EMIT("movups 0x10(%[src]), %%xmm4") // xmm4 = s2 ? s3 ?
2164 __ASM_EMIT("movups 0x20(%[src]), %%xmm1") // xmm1 = s4 x s5 ?
2165 __ASM_EMIT("movups 0x30(%[src]), %%xmm5") // xmm5 = s6 ? s7 ?
2166 __ASM_EMIT("movups 0x40(%[src]), %%xmm2") // xmm2 = s8 ? s9 ?
2167 __ASM_EMIT("movups 0x50(%[src]), %%xmm6") // xmm6 = s10 ? s11 ?
2168 __ASM_EMIT("movups 0x60(%[src]), %%xmm3") // xmm3 = s12 ? s13 ?
2169 __ASM_EMIT("movups 0x70(%[src]), %%xmm7") // xmm7 = s14 ? s15 ?
2170
2171 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2172 __ASM_EMIT("shufps $0x88, %%xmm5, %%xmm1") // xmm1 = s4 s5 s6 s7
2173 __ASM_EMIT("shufps $0x88, %%xmm6, %%xmm2") // xmm2 = s8 s9 s10 s11
2174 __ASM_EMIT("shufps $0x88, %%xmm7, %%xmm3") // xmm3 = s12 s13 s14 s15
2175
2176 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2177 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])")
2178 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])")
2179 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])")
2180
2181 // Repeat loop
2182 __ASM_EMIT("add $0x80, %[src]")
2183 __ASM_EMIT("add $0x40, %[dst]")
2184 __ASM_EMIT("sub $16, %[count]")
2185 __ASM_EMIT("jae 1b")
2186
2187 // 4x iterations
2188 __ASM_EMIT("2:")
2189 __ASM_EMIT("add $12, %[count]")
2190 __ASM_EMIT("jl 4f")
2191
2192 __ASM_EMIT("3:")
2193 __ASM_EMIT("movups 0x00(%[src]), %%xmm0") // xmm0 = s0 ? s1 ?
2194 __ASM_EMIT("movups 0x10(%[src]), %%xmm4") // xmm4 = s2 ? s3 ?
2195 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2196 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2197
2198 __ASM_EMIT("add $0x20, %[src]")
2199 __ASM_EMIT("add $0x10, %[dst]")
2200 __ASM_EMIT("sub $4, %[count]")
2201 __ASM_EMIT("jae 3b")
2202
2203 // 1x iterations
2204 __ASM_EMIT("4:")
2205 __ASM_EMIT("add $4, %[count]")
2206 __ASM_EMIT("jle 6f")
2207
2208 __ASM_EMIT("5:")
2209 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
2210 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
2211 __ASM_EMIT("add $0x8, %[src]")
2212 __ASM_EMIT("add $0x4, %[dst]")
2213 __ASM_EMIT("dec %[count]")
2214 __ASM_EMIT("jnz 5b")
2215
2216 // End of routine
2217 __ASM_EMIT("6:")
2218
2219 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2220 :
2221 : "cc", "memory",
2222 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2223 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2224 );
2225 }
2226
2227 void downsample_3x(float *dst, const float *src, size_t count)
2228 {
2229 ARCH_X86_ASM
2230 (
2231 __ASM_EMIT("sub $16, %[count]")
2232 __ASM_EMIT("jb 2f")
2233
2234 // 16 x sample loop
2235 __ASM_EMIT(".align 16")
2236 __ASM_EMIT("1:")
2237 __ASM_EMIT("movups 0x00(%[src]), %%xmm0") // xmm0 = s0 ? ? s1
2238 __ASM_EMIT("movss 0x18(%[src]), %%xmm1") // xmm1 = s2 ? ? ?
2239 __ASM_EMIT("movss 0x24(%[src]), %%xmm6") // xmm6 = s3 ? ? ?
2240 __ASM_EMIT("movups 0x30(%[src]), %%xmm2") // xmm2 = s4 ? ? s5
2241 __ASM_EMIT("movss 0x48(%[src]), %%xmm3") // xmm3 = s6 ? ? ?
2242 __ASM_EMIT("movss 0x54(%[src]), %%xmm7") // xmm7 = s7 ? ? ?
2243 __ASM_EMIT("movlhps %%xmm6, %%xmm1") // xmm1 = s2 ? s3 ?
2244 __ASM_EMIT("movlhps %%xmm7, %%xmm3") // xmm3 = s6 ? s7 ?
2245 __ASM_EMIT("shufps $0x8c, %%xmm1, %%xmm0") // xmm0 = s0 s1 s2 s3
2246 __ASM_EMIT("shufps $0x8c, %%xmm3, %%xmm2") // xmm2 = s4 s5 s6 s7
2247
2248 __ASM_EMIT("movups 0x60(%[src]), %%xmm4") // xmm4 = s8 ? ? s9
2249 __ASM_EMIT("movss 0x78(%[src]), %%xmm5") // xmm5 = s10 ? ? ?
2250 __ASM_EMIT("movss 0x84(%[src]), %%xmm1") // xmm1 = s11 ? ? ?
2251 __ASM_EMIT("movups 0x90(%[src]), %%xmm6") // xmm6 = s12 ? ? s13
2252 __ASM_EMIT("movss 0xa8(%[src]), %%xmm7") // xmm7 = s14 ? ? ?
2253 __ASM_EMIT("movss 0xb4(%[src]), %%xmm3") // xmm3 = s15 ? ? ?
2254 __ASM_EMIT("movlhps %%xmm1, %%xmm5") // xmm5 = s10 ? s11 ?
2255 __ASM_EMIT("movlhps %%xmm3, %%xmm7") // xmm7 = s14 ? s15 ?
2256 __ASM_EMIT("shufps $0x8c, %%xmm5, %%xmm4") // xmm4 = s8 s9 s10 s11
2257 __ASM_EMIT("shufps $0x8c, %%xmm7, %%xmm6") // xmm6 = s12 s13 s14 s15
2258
2259 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2260 __ASM_EMIT("movups %%xmm2, 0x10(%[dst])")
2261 __ASM_EMIT("movups %%xmm4, 0x20(%[dst])")
2262 __ASM_EMIT("movups %%xmm6, 0x30(%[dst])")
2263
2264 // Repeat loop
2265 __ASM_EMIT("sub $16, %[count]")
2266 __ASM_EMIT("add $0xc0, %[src]")
2267 __ASM_EMIT("add $0x40, %[dst]")
2268 __ASM_EMIT("cmp $16, %[count]")
2269 __ASM_EMIT("jae 1b")
2270
2271 // 4x iterations
2272 __ASM_EMIT("2:")
2273 __ASM_EMIT("add $12, %[count]")
2274 __ASM_EMIT("jl 4f")
2275
2276 __ASM_EMIT("3:")
2277 __ASM_EMIT("movups 0x00(%[src]), %%xmm0") // xmm0 = s0 ? s1 ?
2278 __ASM_EMIT("movups 0x18(%[src]), %%xmm1") // xmm1 = s2 ? ? ?
2279 __ASM_EMIT("movups 0x24(%[src]), %%xmm2") // xmm2 = s3 ? ? ?
2280 __ASM_EMIT("movlhps %%xmm2, %%xmm1") // xmm1 = s2 ? s3 ?
2281 __ASM_EMIT("shufps $0x8c, %%xmm1, %%xmm0") // xmm0 = s0 s1 s2 s3
2282 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2283
2284 __ASM_EMIT("add $0x30, %[src]")
2285 __ASM_EMIT("add $0x10, %[dst]")
2286 __ASM_EMIT("sub $4, %[count]")
2287 __ASM_EMIT("jae 3b")
2288
2289 // 1x iterations
2290 __ASM_EMIT("4:")
2291 __ASM_EMIT("add $4, %[count]")
2292 __ASM_EMIT("jle 6f")
2293
2294 __ASM_EMIT("5:")
2295 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
2296 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
2297 __ASM_EMIT("add $0xc, %[src]")
2298 __ASM_EMIT("add $0x4, %[dst]")
2299 __ASM_EMIT("dec %[count]")
2300 __ASM_EMIT("jnz 5b")
2301
2302 // End of routine
2303 __ASM_EMIT("6:")
2304
2305 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2306 :
2307 : "cc", "memory",
2308 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2309 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2310 );
2311 }
2312
2313 void downsample_4x(float *dst, const float *src, size_t count)
2314 {
2315 ARCH_X86_ASM
2316 (
2317 __ASM_EMIT("sub $16, %[count]")
2318 __ASM_EMIT("jb 2f")
2319
2320 // 16 x sample loop
2321 __ASM_EMIT(".align 16")
2322 __ASM_EMIT("1:")
2323 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2324 __ASM_EMIT("movss 0x10(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2325 __ASM_EMIT("movss 0x20(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2326 __ASM_EMIT("movss 0x30(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2327 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2328 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2329
2330 __ASM_EMIT("movss 0x40(%[src]), %%xmm1") // xmm1 = s4 ? ? ?
2331 __ASM_EMIT("movss 0x50(%[src]), %%xmm2") // xmm2 = s5 ? ? ?
2332 __ASM_EMIT("movss 0x60(%[src]), %%xmm5") // xmm3 = s6 ? ? ?
2333 __ASM_EMIT("movss 0x70(%[src]), %%xmm3") // xmm5 = s7 ? ? ?
2334 __ASM_EMIT("movlhps %%xmm2, %%xmm1") // xmm1 = s4 ? s5 ?
2335 __ASM_EMIT("movlhps %%xmm3, %%xmm5") // xmm4 = s6 ? s7 ?
2336 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2337
2338 __ASM_EMIT("movss 0x80(%[src]), %%xmm2") // xmm2 = s8 ? ? ?
2339 __ASM_EMIT("movss 0x90(%[src]), %%xmm3") // xmm3 = s9 ? ? ?
2340 __ASM_EMIT("movss 0xa0(%[src]), %%xmm6") // xmm6 = s10 ? ? ?
2341 __ASM_EMIT("movss 0xb0(%[src]), %%xmm7") // xmm7 = s11 ? ? ?
2342 __ASM_EMIT("movlhps %%xmm3, %%xmm2") // xmm2 = s8 ? s9 ?
2343 __ASM_EMIT("movlhps %%xmm7, %%xmm6") // xmm6 = s10 ? s11 ?
2344 __ASM_EMIT("shufps $0x88, %%xmm5, %%xmm1") // xmm1 = s4 s5 s6 s7
2345
2346 __ASM_EMIT("movss 0xc0(%[src]), %%xmm3") // xmm3 = s12 ? ? ?
2347 __ASM_EMIT("movss 0xd0(%[src]), %%xmm4") // xmm4 = s13 ? ? ?
2348 __ASM_EMIT("movss 0xe0(%[src]), %%xmm7") // xmm7 = s14 ? ? ?
2349 __ASM_EMIT("movss 0xf0(%[src]), %%xmm5") // xmm5 = s15 ? ? ?
2350 __ASM_EMIT("movlhps %%xmm4, %%xmm3") // xmm3 = s12 ? s13 ?
2351 __ASM_EMIT("movlhps %%xmm5, %%xmm7") // xmm7 = s14 ? s15 ?
2352 __ASM_EMIT("shufps $0x88, %%xmm6, %%xmm2") // xmm2 = s8 s9 s10 s11
2353 __ASM_EMIT("shufps $0x88, %%xmm7, %%xmm3") // xmm3 = s12 s13 s14 s15
2354
2355 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2356 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])")
2357 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])")
2358 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])")
2359
2360 // Repeat loop
2361 __ASM_EMIT("add $0x100, %[src]")
2362 __ASM_EMIT("add $0x40, %[dst]")
2363 __ASM_EMIT("sub $16, %[count]")
2364 __ASM_EMIT("jae 1b")
2365
2366 // 4x iterations
2367 __ASM_EMIT("2:")
2368 __ASM_EMIT("add $12, %[count]")
2369 __ASM_EMIT("jl 4f")
2370
2371 __ASM_EMIT("3:")
2372 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2373 __ASM_EMIT("movss 0x10(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2374 __ASM_EMIT("movss 0x20(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2375 __ASM_EMIT("movss 0x30(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2376 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2377 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2378 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2379 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2380
2381 __ASM_EMIT("add $0x40, %[src]")
2382 __ASM_EMIT("add $0x10, %[dst]")
2383 __ASM_EMIT("sub $4, %[count]")
2384 __ASM_EMIT("jae 3b")
2385
2386 // 1x iterations
2387 __ASM_EMIT("4:")
2388 __ASM_EMIT("add $4, %[count]")
2389 __ASM_EMIT("jle 6f")
2390
2391 __ASM_EMIT("5:")
2392 __ASM_EMIT("movss 0x00(%[src]), %%xmm0") // xmm0 = s0
2393 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
2394 __ASM_EMIT("add $0x10, %[src]")
2395 __ASM_EMIT("add $0x4, %[dst]")
2396 __ASM_EMIT("dec %[count]")
2397 __ASM_EMIT("jnz 5b")
2398
2399 // End of routine
2400 __ASM_EMIT("6:")
2401
2402 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2403 :
2404 : "cc", "memory",
2405 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2406 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2407 );
2408 }
2409
2410 void downsample_6x(float *dst, const float *src, size_t count)
2411 {
2412 ARCH_X86_ASM
2413 (
2414 __ASM_EMIT("sub $16, %[count]")
2415 __ASM_EMIT("jb 2f")
2416
2417 // 16 x sample loop
2418 __ASM_EMIT(".align 16")
2419 __ASM_EMIT("1:")
2420 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2421 __ASM_EMIT("movss 0x018(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2422 __ASM_EMIT("movss 0x030(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2423 __ASM_EMIT("movss 0x048(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2424 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2425 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2426
2427 __ASM_EMIT("movss 0x060(%[src]), %%xmm1") // xmm1 = s4 ? ? ?
2428 __ASM_EMIT("movss 0x078(%[src]), %%xmm2") // xmm2 = s5 ? ? ?
2429 __ASM_EMIT("movss 0x090(%[src]), %%xmm5") // xmm3 = s6 ? ? ?
2430 __ASM_EMIT("movss 0x0a8(%[src]), %%xmm3") // xmm5 = s7 ? ? ?
2431 __ASM_EMIT("movlhps %%xmm2, %%xmm1") // xmm1 = s4 ? s5 ?
2432 __ASM_EMIT("movlhps %%xmm3, %%xmm5") // xmm4 = s6 ? s7 ?
2433 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2434
2435 __ASM_EMIT("movss 0x0c0(%[src]), %%xmm2") // xmm2 = s8 ? ? ?
2436 __ASM_EMIT("movss 0x0d8(%[src]), %%xmm3") // xmm3 = s9 ? ? ?
2437 __ASM_EMIT("movss 0x0f0(%[src]), %%xmm6") // xmm6 = s10 ? ? ?
2438 __ASM_EMIT("movss 0x108(%[src]), %%xmm7") // xmm7 = s11 ? ? ?
2439 __ASM_EMIT("movlhps %%xmm3, %%xmm2") // xmm2 = s8 ? s9 ?
2440 __ASM_EMIT("movlhps %%xmm7, %%xmm6") // xmm6 = s10 ? s11 ?
2441 __ASM_EMIT("shufps $0x88, %%xmm5, %%xmm1") // xmm1 = s4 s5 s6 s7
2442
2443 __ASM_EMIT("movss 0x120(%[src]), %%xmm3") // xmm3 = s12 ? ? ?
2444 __ASM_EMIT("movss 0x138(%[src]), %%xmm4") // xmm4 = s13 ? ? ?
2445 __ASM_EMIT("movss 0x150(%[src]), %%xmm7") // xmm7 = s14 ? ? ?
2446 __ASM_EMIT("movss 0x168(%[src]), %%xmm5") // xmm5 = s15 ? ? ?
2447 __ASM_EMIT("movlhps %%xmm4, %%xmm3") // xmm3 = s12 ? s13 ?
2448 __ASM_EMIT("movlhps %%xmm5, %%xmm7") // xmm7 = s14 ? s15 ?
2449 __ASM_EMIT("shufps $0x88, %%xmm6, %%xmm2") // xmm2 = s8 s9 s10 s11
2450 __ASM_EMIT("shufps $0x88, %%xmm7, %%xmm3") // xmm3 = s12 s13 s14 s15
2451
2452 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2453 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])")
2454 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])")
2455 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])")
2456
2457 // Repeat loop
2458 __ASM_EMIT("add $0x180, %[src]")
2459 __ASM_EMIT("add $0x40, %[dst]")
2460 __ASM_EMIT("sub $16, %[count]")
2461 __ASM_EMIT("jae 1b")
2462
2463 // 4x iterations
2464 __ASM_EMIT("2:")
2465 __ASM_EMIT("add $12, %[count]")
2466 __ASM_EMIT("jl 4f")
2467
2468 __ASM_EMIT("3:")
2469 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2470 __ASM_EMIT("movss 0x018(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2471 __ASM_EMIT("movss 0x030(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2472 __ASM_EMIT("movss 0x048(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2473 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2474 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2475 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2476 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2477
2478 __ASM_EMIT("add $0x60, %[src]")
2479 __ASM_EMIT("add $0x10, %[dst]")
2480 __ASM_EMIT("sub $4, %[count]")
2481 __ASM_EMIT("jae 3b")
2482
2483 // 1x iterations
2484 __ASM_EMIT("4:")
2485 __ASM_EMIT("add $4, %[count]")
2486 __ASM_EMIT("jle 6f")
2487
2488 __ASM_EMIT("5:")
2489 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0
2490 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
2491 __ASM_EMIT("add $0x18, %[src]")
2492 __ASM_EMIT("add $0x4, %[dst]")
2493 __ASM_EMIT("dec %[count]")
2494 __ASM_EMIT("jnz 5b")
2495
2496 // End of routine
2497 __ASM_EMIT("6:")
2498
2499 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2500 :
2501 : "cc", "memory",
2502 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2503 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2504 );
2505 }
2506
2507 void downsample_8x(float *dst, const float *src, size_t count)
2508 {
2509 ARCH_X86_ASM
2510 (
2511 __ASM_EMIT("sub $16, %[count]")
2512 __ASM_EMIT("jb 2f")
2513
2514 // 16 x sample loop
2515 __ASM_EMIT(".align 16")
2516 __ASM_EMIT("1:")
2517 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2518 __ASM_EMIT("movss 0x020(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2519 __ASM_EMIT("movss 0x040(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2520 __ASM_EMIT("movss 0x060(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2521 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2522 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2523
2524 __ASM_EMIT("movss 0x080(%[src]), %%xmm1") // xmm1 = s4 ? ? ?
2525 __ASM_EMIT("movss 0x0a0(%[src]), %%xmm2") // xmm2 = s5 ? ? ?
2526 __ASM_EMIT("movss 0x0c0(%[src]), %%xmm5") // xmm3 = s6 ? ? ?
2527 __ASM_EMIT("movss 0x0e0(%[src]), %%xmm3") // xmm5 = s7 ? ? ?
2528 __ASM_EMIT("movlhps %%xmm2, %%xmm1") // xmm1 = s4 ? s5 ?
2529 __ASM_EMIT("movlhps %%xmm3, %%xmm5") // xmm4 = s6 ? s7 ?
2530 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2531
2532 __ASM_EMIT("movss 0x100(%[src]), %%xmm2") // xmm2 = s8 ? ? ?
2533 __ASM_EMIT("movss 0x120(%[src]), %%xmm3") // xmm3 = s9 ? ? ?
2534 __ASM_EMIT("movss 0x140(%[src]), %%xmm6") // xmm6 = s10 ? ? ?
2535 __ASM_EMIT("movss 0x160(%[src]), %%xmm7") // xmm7 = s11 ? ? ?
2536 __ASM_EMIT("movlhps %%xmm3, %%xmm2") // xmm2 = s8 ? s9 ?
2537 __ASM_EMIT("movlhps %%xmm7, %%xmm6") // xmm6 = s10 ? s11 ?
2538 __ASM_EMIT("shufps $0x88, %%xmm5, %%xmm1") // xmm1 = s4 s5 s6 s7
2539
2540 __ASM_EMIT("movss 0x180(%[src]), %%xmm3") // xmm3 = s12 ? ? ?
2541 __ASM_EMIT("movss 0x1a0(%[src]), %%xmm4") // xmm4 = s13 ? ? ?
2542 __ASM_EMIT("movss 0x1c0(%[src]), %%xmm7") // xmm7 = s14 ? ? ?
2543 __ASM_EMIT("movss 0x1e0(%[src]), %%xmm5") // xmm5 = s15 ? ? ?
2544 __ASM_EMIT("movlhps %%xmm4, %%xmm3") // xmm3 = s12 ? s13 ?
2545 __ASM_EMIT("movlhps %%xmm5, %%xmm7") // xmm7 = s14 ? s15 ?
2546 __ASM_EMIT("shufps $0x88, %%xmm6, %%xmm2") // xmm2 = s8 s9 s10 s11
2547 __ASM_EMIT("shufps $0x88, %%xmm7, %%xmm3") // xmm3 = s12 s13 s14 s15
2548
2549 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2550 __ASM_EMIT("movups %%xmm1, 0x10(%[dst])")
2551 __ASM_EMIT("movups %%xmm2, 0x20(%[dst])")
2552 __ASM_EMIT("movups %%xmm3, 0x30(%[dst])")
2553
2554 // Repeat loop
2555 __ASM_EMIT("add $0x200, %[src]")
2556 __ASM_EMIT("add $0x40, %[dst]")
2557 __ASM_EMIT("sub $16, %[count]")
2558 __ASM_EMIT("jae 1b")
2559
2560 // 4x iterations
2561 __ASM_EMIT("2:")
2562 __ASM_EMIT("add $12, %[count]")
2563 __ASM_EMIT("jl 4f")
2564
2565 __ASM_EMIT("3:")
2566 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0 ? ? ?
2567 __ASM_EMIT("movss 0x020(%[src]), %%xmm2") // xmm2 = s1 ? ? ?
2568 __ASM_EMIT("movss 0x040(%[src]), %%xmm4") // xmm4 = s2 ? ? ?
2569 __ASM_EMIT("movss 0x060(%[src]), %%xmm3") // xmm3 = s3 ? ? ?
2570 __ASM_EMIT("movlhps %%xmm2, %%xmm0") // xmm0 = s0 ? s1 ?
2571 __ASM_EMIT("movlhps %%xmm3, %%xmm4") // xmm4 = s2 ? s3 ?
2572 __ASM_EMIT("shufps $0x88, %%xmm4, %%xmm0") // xmm0 = s0 s1 s2 s3
2573 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
2574
2575 __ASM_EMIT("add $0x80, %[src]")
2576 __ASM_EMIT("add $0x10, %[dst]")
2577 __ASM_EMIT("sub $4, %[count]")
2578 __ASM_EMIT("jae 3b")
2579
2580 // 1x iterations
2581 __ASM_EMIT("4:")
2582 __ASM_EMIT("add $4, %[count]")
2583 __ASM_EMIT("jle 6f")
2584
2585 __ASM_EMIT("5:")
2586 __ASM_EMIT("movss 0x000(%[src]), %%xmm0") // xmm0 = s0
2587 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
2588 __ASM_EMIT("add $0x20, %[src]")
2589 __ASM_EMIT("add $0x4, %[dst]")
2590 __ASM_EMIT("dec %[count]")
2591 __ASM_EMIT("jnz 5b")
2592
2593 // End of routine
2594 __ASM_EMIT("6:")
2595
2596 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
2597 :
2598 : "cc", "memory",
2599 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2600 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2601 );
2602 }
2603 }
2604 }
2605
2606 #endif /* PRIVATE_DSP_ARCH_X86_SSE_RESAMPLING_H_ */