1 /**************************************************************************
2 *
3 * Copyright 2010-2021 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
18 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
24 * of the Software.
25 *
26 **************************************************************************/
27
28
29 #include "pipe/p_config.h"
30
31 #include "util/u_math.h"
32 #include "util/u_cpu_detect.h"
33 #include "util/u_pack_color.h"
34 #include "util/u_rect.h"
35 #include "util/u_sse.h"
36
37 #include "lp_jit.h"
38 #include "lp_rast.h"
39 #include "lp_debug.h"
40 #include "lp_state_fs.h"
41 #include "lp_linear_priv.h"
42
43
44 #if defined(PIPE_ARCH_SSE)
45
46 #define FIXED15_ONE 0x7fff
47
48 /* Translate floating point value to 1.15 unsigned fixed-point.
49 */
50 static inline ushort
float_to_ufixed_1_15(float f)51 float_to_ufixed_1_15(float f)
52 {
53 return CLAMP((unsigned)(f * (float)FIXED15_ONE), 0, FIXED15_ONE);
54 }
55
56
57 /* Translate floating point value to 1.15 signed fixed-point.
58 */
59 static inline int16_t
float_to_sfixed_1_15(float f)60 float_to_sfixed_1_15(float f)
61 {
62 return CLAMP((signed)(f * (float)FIXED15_ONE), -FIXED15_ONE, FIXED15_ONE);
63 }
64
65
66 /* Interpolate in 1.15 space, but produce a packed row of 0.8 values.
67 */
68 static const uint32_t *
interp_0_8(struct lp_linear_elem * elem)69 interp_0_8(struct lp_linear_elem *elem)
70 {
71 struct lp_linear_interp *interp = (struct lp_linear_interp *)elem;
72 uint32_t *row = interp->row;
73 __m128i a0 = interp->a0;
74 const __m128i dadx = interp->dadx;
75 const int width = (interp->width + 3) & ~3;
76
77 for (int i = 0; i < width; i += 4) {
78 __m128i l = _mm_srai_epi16(a0, 7); // l = a0 >> 7
79 a0 = _mm_add_epi16(a0, dadx); // a0 += dadx
80
81 __m128i h = _mm_srai_epi16(a0, 7); // h = a0 >> 7
82 a0 = _mm_add_epi16(a0, dadx); // a0 += dadx
83
84 // pack l[0..7] and h[0..7] as 16 bytes
85 *(__m128i *)&row[i] = _mm_packus_epi16(l, h);
86 }
87
88 // advance to next row
89 interp->a0 = _mm_add_epi16(interp->a0, interp->dady);
90 return interp->row;
91 }
92
93 static const uint32_t *
interp_noop(struct lp_linear_elem * elem)94 interp_noop(struct lp_linear_elem *elem)
95 {
96 struct lp_linear_interp *interp = (struct lp_linear_interp *)elem;
97 return interp->row;
98 }
99
100
101 static const uint32_t *
interp_check(struct lp_linear_elem * elem)102 interp_check(struct lp_linear_elem *elem)
103 {
104 struct lp_linear_interp *interp = (struct lp_linear_interp *)elem;
105 interp->row[0] = 1;
106 return interp->row;
107 }
108
109 /* Not quite a noop - we use row[0] to track whether this gets called
110 * or not, so we can optimize which interpolants we care about.
111 */
112 void
lp_linear_init_noop_interp(struct lp_linear_interp * interp)113 lp_linear_init_noop_interp(struct lp_linear_interp *interp)
114 {
115 interp->row[0] = 0;
116 interp->base.fetch = interp_check;
117 }
118
119 boolean
lp_linear_init_interp(struct lp_linear_interp * interp,int x,int y,int width,int height,unsigned usage_mask,boolean perspective,float oow,const float * a0,const float * dadx,const float * dady)120 lp_linear_init_interp(struct lp_linear_interp *interp,
121 int x, int y, int width, int height,
122 unsigned usage_mask,
123 boolean perspective,
124 float oow,
125 const float *a0,
126 const float *dadx,
127 const float *dady)
128 {
129 float s0[4];
130 float dsdx[4];
131 float dsdy[4];
132 int16_t s0_fp[8];
133 int16_t dsdx_fp[4];
134 int16_t dsdy_fp[4];
135
136 /* Zero coefficients to avoid using uninitialised values */
137 memset(s0, 0, sizeof(s0));
138 memset(dsdx, 0, sizeof(dsdx));
139 memset(dsdy, 0, sizeof(dsdy));
140 memset(s0_fp, 0, sizeof(s0_fp));
141 memset(dsdx_fp, 0, sizeof(dsdx_fp));
142 memset(dsdy_fp, 0, sizeof(dsdy_fp));
143
144 if (perspective && oow != 1.0f) {
145 for (unsigned j = 0; j < 4; j++) {
146 if (usage_mask & (1<<j)) {
147 s0[j] = a0[j] * oow;
148 dsdx[j] = dadx[j] * oow;
149 dsdy[j] = dady[j] * oow;
150 }
151 }
152 } else {
153 for (unsigned j = 0; j < 4; j++) {
154 if (usage_mask & (1<<j)) {
155 s0[j] = a0[j];
156 dsdx[j] = dadx[j];
157 dsdy[j] = dady[j];
158 }
159 }
160 }
161
162 s0[0] += x * dsdx[0] + y * dsdy[0];
163 s0[1] += x * dsdx[1] + y * dsdy[1];
164 s0[2] += x * dsdx[2] + y * dsdy[2];
165 s0[3] += x * dsdx[3] + y * dsdy[3];
166
167 /* XXX: lift all of this into the rectangle setup code.
168 *
169 * For rectangles with linear shaders, at setup time:
170 * - if w is constant (else mark as non-fastpath)
171 * - premultiply perspective interpolants by w
172 * - set w = 1 in position
173 * - check all interpolants for min/max 0..1 (else mark as
174 * non-fastpath)
175 */
176 for (unsigned j = 0; j < 4; j++) {
177 if (usage_mask & (1<<j)) {
178 // compute texcoords at rect corners
179 float a = s0[j];
180 float b = s0[j] + (width - 1) * dsdx[j];
181 float c = s0[j] + (height - 1) * dsdy[j];
182 float d = s0[j] + (height - 1) * dsdy[j] + (width - 1) * dsdx[j];
183
184 if (MIN4(a,b,c,d) < 0.0)
185 FAIL("min < 0.0"); // out of bounds
186
187 if (MAX4(a,b,c,d) > 1.0)
188 FAIL("max > 1.0"); // out of bounds
189
190 dsdx_fp[j] = float_to_sfixed_1_15(dsdx[j]);
191 dsdy_fp[j] = float_to_sfixed_1_15(dsdy[j]);
192
193 s0_fp[j] = float_to_ufixed_1_15(s0[j]); // first pixel
194 s0_fp[j + 4] = s0_fp[j] + dsdx_fp[j]; // second pixel
195
196 dsdx_fp[j] *= 2;
197 }
198 }
199
200 interp->width = align(width, 4);
201 /* RGBA->BGRA swizzle here */
202 interp->a0 = _mm_setr_epi16(s0_fp[2], s0_fp[1], s0_fp[0], s0_fp[3],
203 s0_fp[6], s0_fp[5], s0_fp[4], s0_fp[7]);
204
205 interp->dadx = _mm_setr_epi16(dsdx_fp[2], dsdx_fp[1], dsdx_fp[0], dsdx_fp[3],
206 dsdx_fp[2], dsdx_fp[1], dsdx_fp[0], dsdx_fp[3]);
207
208 interp->dady = _mm_setr_epi16(dsdy_fp[2], dsdy_fp[1], dsdy_fp[0], dsdy_fp[3],
209 dsdy_fp[2], dsdy_fp[1], dsdy_fp[0], dsdy_fp[3]);
210
211 /* If the value is y-invariant, eagerly calculate it here and then
212 * always return the precalculated value.
213 */
214 if (dsdy[0] == 0 &&
215 dsdy[1] == 0 &&
216 dsdy[2] == 0 &&
217 dsdy[3] == 0) {
218 interp_0_8(&interp->base);
219 interp->base.fetch = interp_noop;
220 } else {
221 interp->base.fetch = interp_0_8;
222 }
223
224 return TRUE;
225 }
226
227 #else
228 boolean
lp_linear_init_interp(struct lp_linear_interp * interp,int x,int y,int width,int height,unsigned usage_mask,boolean perspective,float oow,const float * a0,const float * dadx,const float * dady)229 lp_linear_init_interp(struct lp_linear_interp *interp,
230 int x, int y, int width, int height,
231 unsigned usage_mask,
232 boolean perspective,
233 float oow,
234 const float *a0,
235 const float *dadx,
236 const float *dady)
237 {
238 return FALSE;
239 }
240 #endif
241