Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse3/graphics.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_SSE3_GRAPHICS_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE3_GRAPHICS_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE3_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE3_IMPL */
28
29 namespace lsp
30 {
31 namespace sse3
32 {
33 IF_ARCH_X86(
34 static const uint32_t LOG_IARGS[] __lsp_aligned16 =
35 {
36 LSP_DSP_VEC4(0x7fffffff), // X_SIGN
37 LSP_DSP_VEC4(0x322bcc77), // X_AMP = 1e-8
38 LSP_DSP_VEC4(0x007fffff), // X_MANT
39 LSP_DSP_VEC4(0x0000007f), // X_MMASK
40 LSP_DSP_VEC4(0x3f000000), // X_HALF = 0.5
41 LSP_DSP_VEC4(0x3f3504f3), // SQRT1_2
42 LSP_DSP_VEC4(0x3f800000), // ONE
43 LSP_DSP_VEC4(0x3d9021bb), // C0
44 LSP_DSP_VEC4(0xbdebd1b8), // C1
45 LSP_DSP_VEC4(0x3def251a), // C2
46 LSP_DSP_VEC4(0xbdfe5d4f), // C3
47 LSP_DSP_VEC4(0x3e11e9bf), // C4
48 LSP_DSP_VEC4(0xbe2aae50), // C5
49 LSP_DSP_VEC4(0x3e4cceac), // C6
50 LSP_DSP_VEC4(0xbe7ffffc), // C7
51 LSP_DSP_VEC4(0x3eaaaaaa), // C8
52 LSP_DSP_VEC4(0xbf000000), // C9
53 LSP_DSP_VEC4(0x3f316430) // LXE + LN2
54 };
55 )
56
57 void x64_axis_apply_log1(float *x, const float *v, float zero, float norm_x, size_t count)
58 {
59 //---------------------------------------------------------------
60 // Prepare constants
61 ARCH_X86_64_ASM
62 (
63 __ASM_EMIT("movss %[zero], %%xmm0")
64 __ASM_EMIT("movss %[norm_x], %%xmm1")
65 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 == zero
66 __ASM_EMIT("shufps $0x00, %%xmm1, %%xmm1") // xmm1 == norm_x
67
68 __ASM_EMIT("sub $8, %[count]")
69 __ASM_EMIT("jb 2f")
70 __ASM_EMIT("movaps %%xmm0, %%xmm8")
71 __ASM_EMIT("movaps %%xmm1, %%xmm9")
72 __ASM_EMIT("movaps %%xmm2, %%xmm10")
73
74 // Do x8 blocks
75 __ASM_EMIT("1:")
76 __ASM_EMIT("movups 0x00(%[v]), %%xmm3") // xmm3 = v
77 __ASM_EMIT("movups 0x10(%[v]), %%xmm11")
78 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
79 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm11")
80 __ASM_EMIT("add $0x20, %[v]") // v += 4
81 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
82 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm11")
83 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
84 __ASM_EMIT("mulps %%xmm8, %%xmm11")
85 // Step 2: parse float value
86 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
87 __ASM_EMIT("movdqa %%xmm11, %%xmm12")
88 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
89 __ASM_EMIT("psrld $23, %%xmm12")
90 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
91 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm11")
92 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
93 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm12")
94 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
95 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm11")
96 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
97 __ASM_EMIT("cvtdq2ps %%xmm12, %%xmm12")
98 // Prepare logarithm approximation calculations
99 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
100 __ASM_EMIT("movaps %%xmm11, %%xmm13")
101 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
102 __ASM_EMIT("movaps %%xmm11, %%xmm14")
103 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
104 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm13")
105 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
106 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm15")
107 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
108 __ASM_EMIT("andps %%xmm13, %%xmm14")
109 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
110 __ASM_EMIT("addps %%xmm14, %%xmm11")
111 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
112 __ASM_EMIT("andnps %%xmm15, %%xmm13")
113 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
114 __ASM_EMIT("addps %%xmm13, %%xmm12")
115 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
116 __ASM_EMIT("subps %%xmm15, %%xmm11")
117 // Calculate logarithmic values
118 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
119 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm13")
120 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = L0*A
121 __ASM_EMIT("mulps %%xmm11, %%xmm13")
122 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
123 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm13")
124 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
125 __ASM_EMIT("mulps %%xmm11, %%xmm13")
126 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
127 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm13")
128 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
129 __ASM_EMIT("mulps %%xmm11, %%xmm13")
130 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
131 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm13")
132 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
133 __ASM_EMIT("mulps %%xmm11, %%xmm13")
134 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
135 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm13")
136 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
137 __ASM_EMIT("mulps %%xmm11, %%xmm13")
138 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
139 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm13")
140 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
141 __ASM_EMIT("mulps %%xmm11, %%xmm13")
142 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
143 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm13")
144 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
145 __ASM_EMIT("mulps %%xmm11, %%xmm13")
146 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
147 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm13")
148 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
149 __ASM_EMIT("mulps %%xmm11, %%xmm13")
150 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
151 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm13")
152 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
153 __ASM_EMIT("mulps %%xmm11, %%xmm13")
154 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
155 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm13")
156 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
157 __ASM_EMIT("mulps %%xmm11, %%xmm13")
158 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
159 __ASM_EMIT("mulps %%xmm11, %%xmm13")
160 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
161 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm12")
162 __ASM_EMIT("addps %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
163 __ASM_EMIT("addps %%xmm12, %%xmm13")
164 __ASM_EMIT("addps %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
165 __ASM_EMIT("addps %%xmm11, %%xmm13")
166 // Apply values to axes
167 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
168 __ASM_EMIT("movaps %%xmm13, %%xmm11")
169 __ASM_EMIT("movups 0x00(%[x]), %%xmm4") // xmm4 = x
170 __ASM_EMIT("movups 0x10(%[x]), %%xmm12")
171 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
172 __ASM_EMIT("mulps %%xmm9, %%xmm11")
173 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
174 __ASM_EMIT("addps %%xmm11, %%xmm12")
175 __ASM_EMIT("movups %%xmm4, 0x00(%[x])")
176 __ASM_EMIT("movups %%xmm12, 0x10(%[x])")
177 __ASM_EMIT("add $0x20, %[x]")
178 __ASM_EMIT("sub $8, %[count]")
179 __ASM_EMIT("jae 1b")
180
181 __ASM_EMIT("2:")
182 __ASM_EMIT("add $4, %[count]")
183 __ASM_EMIT("jl 4f")
184 // Do x4 block
185 __ASM_EMIT("movups (%[v]), %%xmm3") // xmm3 = v
186 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
187 __ASM_EMIT("add $0x10, %[v]") // v += 4
188 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
189 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
190 // Step 2: parse float value
191 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
192 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
193 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
194 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
195 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
196 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
197 // Prepare logarithm approximation calculations
198 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
199 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
200 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
201 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
202 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
203 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
204 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
205 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
206 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
207 // Calculate logarithmic values
208 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
209 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = L0*A
210 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
211 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
212 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
213 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
214 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
215 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
216 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
217 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
218 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
219 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
220 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
221 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
222 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
223 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
224 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
225 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
226 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
227 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
228 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
229 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
230 __ASM_EMIT("addps %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
231 __ASM_EMIT("addps %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
232 // Apply values to axes
233 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
234 __ASM_EMIT("movups (%[x]), %%xmm4") // xmm4 = x
235 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
236 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
237 __ASM_EMIT("movups %%xmm4, (%[x])")
238 __ASM_EMIT("add $0x10, %[x]")
239 __ASM_EMIT("sub $4, %[count]")
240
241 __ASM_EMIT("4:")
242 __ASM_EMIT("add $3, %[count]")
243 __ASM_EMIT("jl 6f")
244 // Do x1 blocks
245 __ASM_EMIT("5:")
246 __ASM_EMIT("movss (%[v]), %%xmm3") // xmm3 = v
247 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
248 __ASM_EMIT("add $0x04, %[v]") // v += 4
249 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
250 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
251 // Step 2: parse float value
252 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
253 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
254 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
255 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
256 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
257 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
258 // Prepare logarithm approximation calculations
259 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
260 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
261 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
262 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
263 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
264 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
265 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
266 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
267 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
268 // Calculate logarithmic values
269 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
270 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = L0*A
271 __ASM_EMIT("addss 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
272 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
273 __ASM_EMIT("addss 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
274 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
275 __ASM_EMIT("addss 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
276 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
277 __ASM_EMIT("addss 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
278 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
279 __ASM_EMIT("addss 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
280 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
281 __ASM_EMIT("addss 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
282 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
283 __ASM_EMIT("addss 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
284 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
285 __ASM_EMIT("addss 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
286 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
287 __ASM_EMIT("addss 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
288 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
289 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
290 __ASM_EMIT("mulss 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
291 __ASM_EMIT("addss %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
292 __ASM_EMIT("addss %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
293 // Apply values to axes
294 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
295 __ASM_EMIT("movss (%[x]), %%xmm4") // xmm4 = x
296 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
297 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
298 __ASM_EMIT("movss %%xmm4, (%[x])")
299 __ASM_EMIT("add $0x04, %[x]")
300 __ASM_EMIT("dec %[count]")
301 __ASM_EMIT("jge 5b")
302
303 __ASM_EMIT("6:")
304 : [v] "+r" (v), [x] "+r" (x) ,
305 [count] "+r" (count)
306 : [zero] "m" (zero), [norm_x] "m" (norm_x),
307 [ILOG] "r" (LOG_IARGS)
308 :
309 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
310 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
311 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
312 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
313 );
314 }
315
316 void x64_axis_apply_log2(float *x, float *y, const float *v, float zero, float norm_x, float norm_y, size_t count)
317 {
318 //---------------------------------------------------------------
319 // Prepare constants
320 ARCH_X86_64_ASM
321 (
322 __ASM_EMIT("movss %[zero], %%xmm0")
323 __ASM_EMIT("movss %[norm_x], %%xmm1")
324 __ASM_EMIT("movss %[norm_y], %%xmm2")
325 __ASM_EMIT("shufps $0x00, %%xmm0, %%xmm0") // xmm0 == zero
326 __ASM_EMIT("shufps $0x00, %%xmm1, %%xmm1") // xmm1 == norm_x
327 __ASM_EMIT("shufps $0x00, %%xmm2, %%xmm2") // xmm2 == norm_y
328
329 __ASM_EMIT("sub $8, %[count]")
330 __ASM_EMIT("jb 2f")
331 __ASM_EMIT("movaps %%xmm0, %%xmm8")
332 __ASM_EMIT("movaps %%xmm1, %%xmm9")
333 __ASM_EMIT("movaps %%xmm2, %%xmm10")
334
335 // Do x8 blocks
336 __ASM_EMIT("1:")
337 __ASM_EMIT("movups 0x00(%[v]), %%xmm3") // xmm3 = v
338 __ASM_EMIT("movups 0x10(%[v]), %%xmm11")
339 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
340 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm11")
341 __ASM_EMIT("add $0x20, %[v]") // v += 4
342 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
343 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm11")
344 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
345 __ASM_EMIT("mulps %%xmm8, %%xmm11")
346 // Step 2: parse float value
347 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
348 __ASM_EMIT("movdqa %%xmm11, %%xmm12")
349 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
350 __ASM_EMIT("psrld $23, %%xmm12")
351 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
352 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm11")
353 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
354 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm12")
355 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
356 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm11")
357 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
358 __ASM_EMIT("cvtdq2ps %%xmm12, %%xmm12")
359 // Prepare logarithm approximation calculations
360 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
361 __ASM_EMIT("movaps %%xmm11, %%xmm13")
362 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
363 __ASM_EMIT("movaps %%xmm11, %%xmm14")
364 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
365 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm13")
366 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
367 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm15")
368 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
369 __ASM_EMIT("andps %%xmm13, %%xmm14")
370 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
371 __ASM_EMIT("addps %%xmm14, %%xmm11")
372 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
373 __ASM_EMIT("andnps %%xmm15, %%xmm13")
374 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
375 __ASM_EMIT("addps %%xmm13, %%xmm12")
376 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
377 __ASM_EMIT("subps %%xmm15, %%xmm11")
378 // Calculate logarithmic values
379 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
380 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm13")
381 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = L0*A
382 __ASM_EMIT("mulps %%xmm11, %%xmm13")
383 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
384 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm13")
385 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
386 __ASM_EMIT("mulps %%xmm11, %%xmm13")
387 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
388 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm13")
389 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
390 __ASM_EMIT("mulps %%xmm11, %%xmm13")
391 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
392 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm13")
393 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
394 __ASM_EMIT("mulps %%xmm11, %%xmm13")
395 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
396 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm13")
397 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
398 __ASM_EMIT("mulps %%xmm11, %%xmm13")
399 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
400 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm13")
401 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
402 __ASM_EMIT("mulps %%xmm11, %%xmm13")
403 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
404 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm13")
405 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
406 __ASM_EMIT("mulps %%xmm11, %%xmm13")
407 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
408 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm13")
409 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
410 __ASM_EMIT("mulps %%xmm11, %%xmm13")
411 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
412 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm13")
413 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
414 __ASM_EMIT("mulps %%xmm11, %%xmm13")
415 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
416 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm13")
417 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
418 __ASM_EMIT("mulps %%xmm11, %%xmm13")
419 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
420 __ASM_EMIT("mulps %%xmm11, %%xmm13")
421 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
422 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm12")
423 __ASM_EMIT("addps %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
424 __ASM_EMIT("addps %%xmm12, %%xmm13")
425 __ASM_EMIT("addps %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
426 __ASM_EMIT("addps %%xmm11, %%xmm13")
427 // Apply values to axes
428 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
429 __ASM_EMIT("movaps %%xmm13, %%xmm11")
430 __ASM_EMIT("movups 0x00(%[x]), %%xmm4") // xmm4 = x
431 __ASM_EMIT("movups 0x10(%[x]), %%xmm12")
432 __ASM_EMIT("movups 0x00(%[y]), %%xmm6") // xmm6 = y
433 __ASM_EMIT("movups 0x10(%[y]), %%xmm14")
434 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
435 __ASM_EMIT("mulps %%xmm9, %%xmm11")
436 __ASM_EMIT("mulps %%xmm2, %%xmm5") // xmm5 = log(abs(v*zero)) * norm_y
437 __ASM_EMIT("mulps %%xmm10, %%xmm13")
438 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
439 __ASM_EMIT("addps %%xmm11, %%xmm12")
440 __ASM_EMIT("addps %%xmm5, %%xmm6") // xmm6 = y + log(abs(v*zero)) * norm_y
441 __ASM_EMIT("addps %%xmm13, %%xmm14")
442 __ASM_EMIT("movups %%xmm4, 0x00(%[x])")
443 __ASM_EMIT("movups %%xmm12, 0x10(%[x])")
444 __ASM_EMIT("movups %%xmm6, 0x00(%[y])")
445 __ASM_EMIT("movups %%xmm14, 0x10(%[y])")
446 __ASM_EMIT("add $0x20, %[x]")
447 __ASM_EMIT("add $0x20, %[y]")
448 __ASM_EMIT("sub $8, %[count]")
449 __ASM_EMIT("jae 1b")
450
451 __ASM_EMIT("2:")
452 __ASM_EMIT("add $4, %[count]")
453 __ASM_EMIT("jl 4f")
454 // Do x4 block
455 __ASM_EMIT("movups (%[v]), %%xmm3") // xmm3 = v
456 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
457 __ASM_EMIT("add $0x10, %[v]") // v += 4
458 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
459 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
460 // Step 2: parse float value
461 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
462 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
463 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
464 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
465 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
466 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
467 // Prepare logarithm approximation calculations
468 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
469 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
470 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
471 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
472 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
473 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
474 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
475 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
476 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
477 // Calculate logarithmic values
478 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
479 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = L0*A
480 __ASM_EMIT("addps 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
481 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
482 __ASM_EMIT("addps 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
483 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
484 __ASM_EMIT("addps 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
485 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
486 __ASM_EMIT("addps 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
487 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
488 __ASM_EMIT("addps 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
489 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
490 __ASM_EMIT("addps 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
491 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
492 __ASM_EMIT("addps 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
493 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
494 __ASM_EMIT("addps 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
495 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
496 __ASM_EMIT("addps 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
497 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
498 __ASM_EMIT("mulps %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
499 __ASM_EMIT("mulps 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
500 __ASM_EMIT("addps %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
501 __ASM_EMIT("addps %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
502 // Apply values to axes
503 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
504 __ASM_EMIT("movups (%[x]), %%xmm4") // xmm4 = x
505 __ASM_EMIT("movups (%[y]), %%xmm6") // xmm6 = y
506 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
507 __ASM_EMIT("mulps %%xmm2, %%xmm5") // xmm5 = log(abs(v*zero)) * norm_y
508 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
509 __ASM_EMIT("addps %%xmm5, %%xmm6") // xmm6 = y + log(abs(v*zero)) * norm_y
510 __ASM_EMIT("movups %%xmm4, (%[x])")
511 __ASM_EMIT("movups %%xmm6, (%[y])")
512 __ASM_EMIT("add $0x10, %[x]")
513 __ASM_EMIT("add $0x10, %[y]")
514 __ASM_EMIT("sub $4, %[count]")
515
516 __ASM_EMIT("4:")
517 __ASM_EMIT("add $3, %[count]")
518 __ASM_EMIT("jl 6f")
519 // Do x1 blocks
520 __ASM_EMIT("5:")
521 __ASM_EMIT("movss (%[v]), %%xmm3") // xmm3 = v
522 __ASM_EMIT("andps 0x00(%[ILOG]), %%xmm3") // xmm3 = abs(v)
523 __ASM_EMIT("add $0x04, %[v]") // v += 4
524 __ASM_EMIT("maxps 0x10(%[ILOG]), %%xmm3") // xmm3 = max(X_AMP, abs(v)), ignores denormalized values
525 __ASM_EMIT("mulps %%xmm0, %%xmm3") // xmm5 = max(X_AMP, abs(v)) * zero
526 // Step 2: parse float value
527 __ASM_EMIT("movdqa %%xmm3, %%xmm4") // xmm4 = v
528 __ASM_EMIT("psrld $23, %%xmm4") // xmm4 = frac(v)
529 __ASM_EMIT("andps 0x20(%[ILOG]), %%xmm3") // xmm3 = mant(v)
530 __ASM_EMIT("psubd 0x30(%[ILOG]), %%xmm4") // xmm4 = frac(v) - 127
531 __ASM_EMIT("orps 0x40(%[ILOG]), %%xmm3") // xmm3 = V = mant(v)+0.5
532 __ASM_EMIT("cvtdq2ps %%xmm4, %%xmm4") // xmm4 = E = float(frac(v)-127)
533 // Prepare logarithm approximation calculations
534 __ASM_EMIT("movaps %%xmm3, %%xmm5") // xmm5 = V
535 __ASM_EMIT("movaps %%xmm3, %%xmm6") // xmm6 = V
536 __ASM_EMIT("cmpltps 0x50(%[ILOG]), %%xmm5") // xmm5 = [ V < sqrt(1/2) ]
537 __ASM_EMIT("movaps 0x60(%[ILOG]), %%xmm7") // xmm7 = 1.0
538 __ASM_EMIT("andps %%xmm5, %%xmm6") // xmm6 = V * [ V < sqrt(1/2) ]
539 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm6 = V + V * [ V < sqrt(1/2) ]
540 __ASM_EMIT("andnps %%xmm7, %%xmm5") // xmm5 = 1.0 * [ V >= sqrt(1/2) ]
541 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = E + 1.0 * [ V >= sqrt(1/2) ] = B
542 __ASM_EMIT("subps %%xmm7, %%xmm3") // xmm3 = V + V * [ V < sqrt(1/2) ] - 1.0 = A
543 // Calculate logarithmic values
544 __ASM_EMIT("movaps 0x70(%[ILOG]), %%xmm5") // xmm5 = L0
545 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = L0*A
546 __ASM_EMIT("addss 0x80(%[ILOG]), %%xmm5") // xmm5 = L1+L0*A
547 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L1+L0*A)
548 __ASM_EMIT("addss 0x90(%[ILOG]), %%xmm5") // xmm5 = L2+A*(L1+L0*A)
549 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L2+A*(L1+L0*A))
550 __ASM_EMIT("addss 0xa0(%[ILOG]), %%xmm5") // xmm5 = L3+A*L2+A*(L1+L0*A)
551 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L3+A*L2+A*(L1+L0*A))
552 __ASM_EMIT("addss 0xb0(%[ILOG]), %%xmm5") // xmm5 = L4+A*(L3+A*L2+A*(L1+L0*A))
553 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
554 __ASM_EMIT("addss 0xc0(%[ILOG]), %%xmm5") // xmm5 = L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))
555 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
556 __ASM_EMIT("addss 0xd0(%[ILOG]), %%xmm5") // xmm5 = L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))
557 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
558 __ASM_EMIT("addss 0xe0(%[ILOG]), %%xmm5") // xmm5 = L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))
559 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
560 __ASM_EMIT("addss 0xf0(%[ILOG]), %%xmm5") // xmm5 = L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))
561 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
562 __ASM_EMIT("addss 0x100(%[ILOG]), %%xmm5") // xmm5 = A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9
563 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
564 __ASM_EMIT("mulss %%xmm3, %%xmm5") // xmm5 = A*A*(A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + L9)
565 __ASM_EMIT("mulss 0x110(%[ILOG]), %%xmm4") // xmm4 = B*(LXE + LN2)
566 __ASM_EMIT("addss %%xmm4, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A)))))))
567 __ASM_EMIT("addss %%xmm3, %%xmm5") // xmm5 = B*(LXE + LN2) + A*A*A*(L8+A*(L7+A*(L6+A*(L5+A*(L4+A*(L3+A*L2+A*(L1+L0*A))))))) + A
568 // Apply values to axes
569 __ASM_EMIT("movaps %%xmm5, %%xmm3") // xmm3 = log(abs(v*zero)), xmm5=log(abs(v*zero))
570 __ASM_EMIT("movss (%[x]), %%xmm4") // xmm4 = x
571 __ASM_EMIT("movss (%[y]), %%xmm6") // xmm6 = y
572 __ASM_EMIT("mulps %%xmm1, %%xmm3") // xmm3 = log(abs(v*zero)) * norm_x
573 __ASM_EMIT("mulps %%xmm2, %%xmm5") // xmm5 = log(abs(v*zero)) * norm_y
574 __ASM_EMIT("addps %%xmm3, %%xmm4") // xmm4 = x + log(abs(v*zero)) * norm_x
575 __ASM_EMIT("addps %%xmm5, %%xmm6") // xmm6 = y + log(abs(v*zero)) * norm_y
576 __ASM_EMIT("movss %%xmm4, (%[x])")
577 __ASM_EMIT("movss %%xmm6, (%[y])")
578 __ASM_EMIT("add $0x04, %[x]")
579 __ASM_EMIT("add $0x04, %[y]")
580 __ASM_EMIT("dec %[count]")
581 __ASM_EMIT("jge 5b")
582
583 __ASM_EMIT("6:")
584 : [v] "+r" (v), [x] "+r" (x) , [y] "+r" (y),
585 [count] "+r" (count)
586 : [zero] "m" (zero), [norm_x] "m" (norm_x), [norm_y] "m" (norm_y),
587 [ILOG] "r" (LOG_IARGS)
588 :
589 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
590 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
591 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
592 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
593 );
594 }
595
596 IF_ARCH_X86(
597 static const uint32_t rgba_const[] __lsp_aligned16 =
598 {
599 LSP_DSP_VEC4(0x00ff00ff)
600 };
601 )
602
603 void x64_rgba32_to_bgra32(void *dst, const void *src, size_t count)
604 {
605 IF_ARCH_X86_64(size_t off);
606
607 ARCH_X86_64_ASM
608 (
609 __ASM_EMIT("movdqa %[MASK], %%xmm6") // xmm6 = 00 ff 00 ff
610 __ASM_EMIT("xor %[off], %[off]") // off = 0
611 __ASM_EMIT("movdqa %%xmm6, %%xmm7") // xmm7 = 00 ff 00 ff
612 __ASM_EMIT("pslld $8, %%xmm6") // xmm6 = ff 00 ff 00
613
614 // 16-element blocks
615 __ASM_EMIT("sub $16, %[count]")
616 __ASM_EMIT("jb 2f")
617 __ASM_EMIT("1:")
618 __ASM_EMIT("prefetcht0 0x40(%[src], %[off])")
619 __ASM_EMIT("prefetcht0 0x60(%[src], %[off])")
620 __ASM_EMIT("movdqu 0x00(%[src], %[off]), %%xmm0") // xmm0 = A1 R1 G1 B1
621 __ASM_EMIT("movdqu 0x10(%[src], %[off]), %%xmm1")
622 __ASM_EMIT("movdqu 0x20(%[src], %[off]), %%xmm2")
623 __ASM_EMIT("movdqu 0x30(%[src], %[off]), %%xmm3")
624 __ASM_EMIT("movdqa %%xmm0, %%xmm8") // xmm8 = A1 R1 G1 B1
625 __ASM_EMIT("movdqa %%xmm1, %%xmm10")
626 __ASM_EMIT("movdqa %%xmm2, %%xmm12")
627 __ASM_EMIT("movdqa %%xmm3, %%xmm14")
628 __ASM_EMIT("pand %%xmm7, %%xmm0") // xmm0 = 00 R1 00 B1
629 __ASM_EMIT("pand %%xmm7, %%xmm1")
630 __ASM_EMIT("pand %%xmm7, %%xmm2")
631 __ASM_EMIT("pand %%xmm7, %%xmm3")
632 __ASM_EMIT("pand %%xmm6, %%xmm8") // xmm8 = A1 00 G1 00
633 __ASM_EMIT("pand %%xmm6, %%xmm10")
634 __ASM_EMIT("pand %%xmm6, %%xmm12")
635 __ASM_EMIT("pand %%xmm6, %%xmm14")
636 __ASM_EMIT("movdqa %%xmm0, %%xmm9") // xmm9 = A1 00 G1 00
637 __ASM_EMIT("movdqa %%xmm1, %%xmm11")
638 __ASM_EMIT("movdqa %%xmm2, %%xmm13")
639 __ASM_EMIT("movdqa %%xmm3, %%xmm15")
640 __ASM_EMIT("pslld $16, %%xmm0") // xmm0 = 00 B1 00 00
641 __ASM_EMIT("pslld $16, %%xmm1")
642 __ASM_EMIT("pslld $16, %%xmm2")
643 __ASM_EMIT("pslld $16, %%xmm3")
644 __ASM_EMIT("psrld $16, %%xmm9") // xmm9 = 00 00 00 R1
645 __ASM_EMIT("psrld $16, %%xmm11")
646 __ASM_EMIT("psrld $16, %%xmm13")
647 __ASM_EMIT("psrld $16, %%xmm15")
648 __ASM_EMIT("orpd %%xmm8, %%xmm0") // xmm0 = A1 B1 G1 00
649 __ASM_EMIT("orpd %%xmm10, %%xmm1")
650 __ASM_EMIT("orpd %%xmm12, %%xmm2")
651 __ASM_EMIT("orpd %%xmm14, %%xmm3")
652 __ASM_EMIT("orpd %%xmm9, %%xmm0") // xmm0 = A1 B1 G1 R1
653 __ASM_EMIT("orpd %%xmm11, %%xmm1")
654 __ASM_EMIT("orpd %%xmm13, %%xmm2")
655 __ASM_EMIT("orpd %%xmm15, %%xmm3")
656 __ASM_EMIT("movdqu %%xmm0, 0x00(%[dst], %[off])")
657 __ASM_EMIT("movdqu %%xmm1, 0x10(%[dst], %[off])")
658 __ASM_EMIT("movdqu %%xmm2, 0x20(%[dst], %[off])")
659 __ASM_EMIT("movdqu %%xmm3, 0x30(%[dst], %[off])")
660 __ASM_EMIT("add $0x40, %[off]")
661 __ASM_EMIT("sub $16, %[count]")
662 __ASM_EMIT("jae 1b")
663
664 // 8-element blocks
665 __ASM_EMIT("2:")
666 __ASM_EMIT("add $8, %[count]")
667 __ASM_EMIT("jl 4f")
668 __ASM_EMIT("movdqu 0x00(%[src], %[off]), %%xmm0") // xmm0 = A1 R1 G1 B1
669 __ASM_EMIT("movdqu 0x10(%[src], %[off]), %%xmm1")
670 __ASM_EMIT("movdqa %%xmm0, %%xmm2") // xmm2 = A1 R1 G1 B1
671 __ASM_EMIT("movdqa %%xmm1, %%xmm3")
672 __ASM_EMIT("pand %%xmm7, %%xmm0") // xmm0 = 00 R1 00 B1
673 __ASM_EMIT("pand %%xmm6, %%xmm2") // xmm2 = A1 00 G1 00
674 __ASM_EMIT("pand %%xmm7, %%xmm1")
675 __ASM_EMIT("pand %%xmm6, %%xmm3")
676 __ASM_EMIT("movdqa %%xmm0, %%xmm4") // xmm4 = A1 00 G1 00
677 __ASM_EMIT("movdqa %%xmm1, %%xmm5")
678 __ASM_EMIT("pslld $16, %%xmm0") // xmm0 = 00 B1 00 00
679 __ASM_EMIT("pslld $16, %%xmm1")
680 __ASM_EMIT("psrld $16, %%xmm4") // xmm4 = 00 00 00 R1
681 __ASM_EMIT("psrld $16, %%xmm5")
682 __ASM_EMIT("orpd %%xmm2, %%xmm0") // xmm0 = A1 B1 G1 00
683 __ASM_EMIT("orpd %%xmm3, %%xmm1")
684 __ASM_EMIT("orpd %%xmm4, %%xmm0") // xmm0 = A1 B1 G1 R1
685 __ASM_EMIT("orpd %%xmm5, %%xmm1")
686 __ASM_EMIT("movdqu %%xmm0, 0x00(%[dst], %[off])")
687 __ASM_EMIT("movdqu %%xmm1, 0x10(%[dst], %[off])")
688 __ASM_EMIT("add $0x20, %[off]")
689 __ASM_EMIT("sub $8, %[count]")
690
691 // 4-element block
692 __ASM_EMIT("4:")
693 __ASM_EMIT("add $4, %[count]")
694 __ASM_EMIT("jl 6f")
695 __ASM_EMIT("movdqu 0x00(%[src], %[off]), %%xmm0") // xmm0 = A1 R1 G1 B1
696 __ASM_EMIT("movdqa %%xmm0, %%xmm2") // xmm2 = A1 R1 G1 B1
697 __ASM_EMIT("pand %%xmm7, %%xmm0") // xmm0 = 00 R1 00 B1
698 __ASM_EMIT("pand %%xmm6, %%xmm2") // xmm2 = A1 00 G1 00
699 __ASM_EMIT("movdqa %%xmm0, %%xmm4") // xmm4 = A1 00 G1 00
700 __ASM_EMIT("pslld $16, %%xmm0") // xmm0 = 00 B1 00 00
701 __ASM_EMIT("psrld $16, %%xmm4") // xmm4 = 00 00 00 R1
702 __ASM_EMIT("orpd %%xmm2, %%xmm0") // xmm0 = A1 B1 G1 00
703 __ASM_EMIT("orpd %%xmm4, %%xmm0") // xmm0 = A1 B1 G1 R1
704 __ASM_EMIT("movdqu %%xmm0, 0x00(%[dst], %[off])")
705 __ASM_EMIT("add $0x10, %[off]")
706 __ASM_EMIT("sub $4, %[count]")
707
708 // Tail
709 __ASM_EMIT("6:")
710 __ASM_EMIT("add $3, %[count]")
711 __ASM_EMIT("jl 8f")
712 __ASM_EMIT("7:")
713 __ASM_EMIT("movd 0x00(%[src], %[off]), %%xmm0") // xmm0 = AA RR GG BB
714 __ASM_EMIT("movdqa %%xmm0, %%xmm1") // xmm1 = AA RR GG BB
715 __ASM_EMIT("pand %%xmm7, %%xmm0") // xmm0 = 00 RR 00 BB
716 __ASM_EMIT("pand %%xmm6, %%xmm1") // xmm1 = AA 00 GG 00
717 __ASM_EMIT("movdqa %%xmm0, %%xmm2") // xmm2 = 00 RR 00 BB
718 __ASM_EMIT("pslld $16, %%xmm0") // xmm0 = 00 BB 00 00
719 __ASM_EMIT("psrld $16, %%xmm2") // xmm2 = 00 00 00 RR
720 __ASM_EMIT("orpd %%xmm1, %%xmm0") // xmm0 = AA 00 GG RR
721 __ASM_EMIT("orpd %%xmm2, %%xmm0") // xmm0 = AA BB GG RR
722 __ASM_EMIT("movd %%xmm0, 0x00(%[dst], %[off])")
723 __ASM_EMIT("add $4, %[off]")
724 __ASM_EMIT("dec %[count]")
725 __ASM_EMIT("jge 7b")
726
727 // End
728 __ASM_EMIT("8:")
729
730 : [dst] "+r"(dst), [src] "+r"(src), [count] "+r" (count),
731 [off] "=&r" (off)
732 : [MASK] "m" (rgba_const)
733 : "cc", "memory",
734 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
735 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
736 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
737 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
738 );
739 }
740 }
741 }
742
743 #endif /* PRIVATE_DSP_ARCH_X86_SSE3_GRAPHICS_H_ */