projects / mesa.git / blob
? search:


14631da33cd93285463c64dcb7e31de8182664c8
[mesa.git] / src / gallium / auxiliary / translate / translate_generic.c
1 /**************************************************************************
2 *
3 * Copyright 2007 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 above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /*
29 * Authors:
30 * Keith Whitwell <keithw@vmware.com>
31 */
32
33 #include "util/u_memory.h"
34 #include "util/format/u_format.h"
35 #include "util/u_half.h"
36 #include "util/u_math.h"
37 #include "pipe/p_state.h"
38 #include "translate.h"
39
40
41 #define DRAW_DBG 0
42
43 typedef void (*emit_func)(const void *attrib, void *ptr);
44
45
46
47 struct translate_generic {
48 struct translate translate;
49
50 struct {
51 enum translate_element_type type;
52
53 util_format_fetch_rgba_func_ptr fetch;
54 unsigned buffer;
55 unsigned input_offset;
56 unsigned instance_divisor;
57
58 emit_func emit;
59 unsigned output_offset;
60
61 const uint8_t *input_ptr;
62 unsigned input_stride;
63 unsigned max_index;
64
65 /* this value is set to -1 if this is a normal element with
66 * output_format != input_format: in this case, u_format is used
67 * to do a full conversion
68 *
69 * this value is set to the format size in bytes if
70 * output_format == input_format or for 32-bit instance ids:
71 * in this case, memcpy is used to copy this amount of bytes
72 */
73 int copy_size;
74
75 } attrib[TRANSLATE_MAX_ATTRIBS];
76
77 unsigned nr_attrib;
78 };
79
80
81 static struct translate_generic *
82 translate_generic(struct translate *translate)
83 {
84 return (struct translate_generic *)translate;
85 }
86
87
88 /**
89 * Fetch a dword[4] vertex attribute from memory, doing format/type
90 * conversion as needed.
91 *
92 * This is probably needed/dupliocated elsewhere, eg format
93 * conversion, texture sampling etc.
94 */
95 #define ATTRIB(NAME, SZ, SRCTYPE, DSTTYPE, TO) \
96 static void \
97 emit_##NAME(const void *attrib, void *ptr) \
98 { \
99 unsigned i; \
100 SRCTYPE *in = (SRCTYPE *)attrib; \
101 DSTTYPE *out = (DSTTYPE *)ptr; \
102 \
103 for (i = 0; i < SZ; i++) { \
104 out[i] = TO(in[i]); \
105 } \
106 }
107
108
109 #define TO_64_FLOAT(x) ((double) x)
110 #define TO_32_FLOAT(x) (x)
111 #define TO_16_FLOAT(x) util_float_to_half(x)
112
113 #define TO_8_USCALED(x) ((unsigned char) x)
114 #define TO_16_USCALED(x) ((unsigned short) x)
115 #define TO_32_USCALED(x) ((unsigned int) x)
116
117 #define TO_8_SSCALED(x) ((char) x)
118 #define TO_16_SSCALED(x) ((short) x)
119 #define TO_32_SSCALED(x) ((int) x)
120
121 #define TO_8_UNORM(x) ((unsigned char) (x * 255.0f))
122 #define TO_16_UNORM(x) ((unsigned short) (x * 65535.0f))
123 #define TO_32_UNORM(x) ((unsigned int) (x * 4294967295.0f))
124
125 #define TO_8_SNORM(x) ((char) (x * 127.0f))
126 #define TO_16_SNORM(x) ((short) (x * 32767.0f))
127 #define TO_32_SNORM(x) ((int) (x * 2147483647.0f))
128
129 #define TO_32_FIXED(x) ((int) (x * 65536.0f))
130
131 #define TO_INT(x) (x)
132
133
134 ATTRIB(R64G64B64A64_FLOAT, 4, float, double, TO_64_FLOAT)
135 ATTRIB(R64G64B64_FLOAT, 3, float, double, TO_64_FLOAT)
136 ATTRIB(R64G64_FLOAT, 2, float, double, TO_64_FLOAT)
137 ATTRIB(R64_FLOAT, 1, float, double, TO_64_FLOAT)
138
139 ATTRIB(R32G32B32A32_FLOAT, 4, float, float, TO_32_FLOAT)
140 ATTRIB(R32G32B32_FLOAT, 3, float, float, TO_32_FLOAT)
141 ATTRIB(R32G32_FLOAT, 2, float, float, TO_32_FLOAT)
142 ATTRIB(R32_FLOAT, 1, float, float, TO_32_FLOAT)
143
144 ATTRIB(R16G16B16A16_FLOAT, 4, float, ushort, TO_16_FLOAT)
145 ATTRIB(R16G16B16_FLOAT, 3, float, ushort, TO_16_FLOAT)
146 ATTRIB(R16G16_FLOAT, 2, float, ushort, TO_16_FLOAT)
147 ATTRIB(R16_FLOAT, 1, float, ushort, TO_16_FLOAT)
148
149 ATTRIB(R32G32B32A32_USCALED, 4, float, unsigned, TO_32_USCALED)
150 ATTRIB(R32G32B32_USCALED, 3, float, unsigned, TO_32_USCALED)
151 ATTRIB(R32G32_USCALED, 2, float, unsigned, TO_32_USCALED)
152 ATTRIB(R32_USCALED, 1, float, unsigned, TO_32_USCALED)
153
154 ATTRIB(R32G32B32A32_SSCALED, 4, float, int, TO_32_SSCALED)
155 ATTRIB(R32G32B32_SSCALED, 3, float, int, TO_32_SSCALED)
156 ATTRIB(R32G32_SSCALED, 2, float, int, TO_32_SSCALED)
157 ATTRIB(R32_SSCALED, 1, float, int, TO_32_SSCALED)
158
159 ATTRIB(R32G32B32A32_UNORM, 4, float, unsigned, TO_32_UNORM)
160 ATTRIB(R32G32B32_UNORM, 3, float, unsigned, TO_32_UNORM)
161 ATTRIB(R32G32_UNORM, 2, float, unsigned, TO_32_UNORM)
162 ATTRIB(R32_UNORM, 1, float, unsigned, TO_32_UNORM)
163
164 ATTRIB(R32G32B32A32_SNORM, 4, float, int, TO_32_SNORM)
165 ATTRIB(R32G32B32_SNORM, 3, float, int, TO_32_SNORM)
166 ATTRIB(R32G32_SNORM, 2, float, int, TO_32_SNORM)
167 ATTRIB(R32_SNORM, 1, float, int, TO_32_SNORM)
168
169 ATTRIB(R16G16B16A16_USCALED, 4, float, ushort, TO_16_USCALED)
170 ATTRIB(R16G16B16_USCALED, 3, float, ushort, TO_16_USCALED)
171 ATTRIB(R16G16_USCALED, 2, float, ushort, TO_16_USCALED)
172 ATTRIB(R16_USCALED, 1, float, ushort, TO_16_USCALED)
173
174 ATTRIB(R16G16B16A16_SSCALED, 4, float, short, TO_16_SSCALED)
175 ATTRIB(R16G16B16_SSCALED, 3, float, short, TO_16_SSCALED)
176 ATTRIB(R16G16_SSCALED, 2, float, short, TO_16_SSCALED)
177 ATTRIB(R16_SSCALED, 1, float, short, TO_16_SSCALED)
178
179 ATTRIB(R16G16B16A16_UNORM, 4, float, ushort, TO_16_UNORM)
180 ATTRIB(R16G16B16_UNORM, 3, float, ushort, TO_16_UNORM)
181 ATTRIB(R16G16_UNORM, 2, float, ushort, TO_16_UNORM)
182 ATTRIB(R16_UNORM, 1, float, ushort, TO_16_UNORM)
183
184 ATTRIB(R16G16B16A16_SNORM, 4, float, short, TO_16_SNORM)
185 ATTRIB(R16G16B16_SNORM, 3, float, short, TO_16_SNORM)
186 ATTRIB(R16G16_SNORM, 2, float, short, TO_16_SNORM)
187 ATTRIB(R16_SNORM, 1, float, short, TO_16_SNORM)
188
189 ATTRIB(R8G8B8A8_USCALED, 4, float, ubyte, TO_8_USCALED)
190 ATTRIB(R8G8B8_USCALED, 3, float, ubyte, TO_8_USCALED)
191 ATTRIB(R8G8_USCALED, 2, float, ubyte, TO_8_USCALED)
192 ATTRIB(R8_USCALED, 1, float, ubyte, TO_8_USCALED)
193
194 ATTRIB(R8G8B8A8_SSCALED, 4, float, char, TO_8_SSCALED)
195 ATTRIB(R8G8B8_SSCALED, 3, float, char, TO_8_SSCALED)
196 ATTRIB(R8G8_SSCALED, 2, float, char, TO_8_SSCALED)
197 ATTRIB(R8_SSCALED, 1, float, char, TO_8_SSCALED)
198
199 ATTRIB(R8G8B8A8_UNORM, 4, float, ubyte, TO_8_UNORM)
200 ATTRIB(R8G8B8_UNORM, 3, float, ubyte, TO_8_UNORM)
201 ATTRIB(R8G8_UNORM, 2, float, ubyte, TO_8_UNORM)
202 ATTRIB(R8_UNORM, 1, float, ubyte, TO_8_UNORM)
203
204 ATTRIB(R8G8B8A8_SNORM, 4, float, char, TO_8_SNORM)
205 ATTRIB(R8G8B8_SNORM, 3, float, char, TO_8_SNORM)
206 ATTRIB(R8G8_SNORM, 2, float, char, TO_8_SNORM)
207 ATTRIB(R8_SNORM, 1, float, char, TO_8_SNORM)
208
209 ATTRIB(R32G32B32A32_UINT, 4, uint32_t, unsigned, TO_INT)
210 ATTRIB(R32G32B32_UINT, 3, uint32_t, unsigned, TO_INT)
211 ATTRIB(R32G32_UINT, 2, uint32_t, unsigned, TO_INT)
212 ATTRIB(R32_UINT, 1, uint32_t, unsigned, TO_INT)
213
214 ATTRIB(R16G16B16A16_UINT, 4, uint32_t, ushort, TO_INT)
215 ATTRIB(R16G16B16_UINT, 3, uint32_t, ushort, TO_INT)
216 ATTRIB(R16G16_UINT, 2, uint32_t, ushort, TO_INT)
217 ATTRIB(R16_UINT, 1, uint32_t, ushort, TO_INT)
218
219 ATTRIB(R8G8B8A8_UINT, 4, uint32_t, ubyte, TO_INT)
220 ATTRIB(R8G8B8_UINT, 3, uint32_t, ubyte, TO_INT)
221 ATTRIB(R8G8_UINT, 2, uint32_t, ubyte, TO_INT)
222 ATTRIB(R8_UINT, 1, uint32_t, ubyte, TO_INT)
223
224 ATTRIB(R32G32B32A32_SINT, 4, int32_t, int, TO_INT)
225 ATTRIB(R32G32B32_SINT, 3, int32_t, int, TO_INT)
226 ATTRIB(R32G32_SINT, 2, int32_t, int, TO_INT)
227 ATTRIB(R32_SINT, 1, int32_t, int, TO_INT)
228
229 ATTRIB(R16G16B16A16_SINT, 4, int32_t, short, TO_INT)
230 ATTRIB(R16G16B16_SINT, 3, int32_t, short, TO_INT)
231 ATTRIB(R16G16_SINT, 2, int32_t, short, TO_INT)
232 ATTRIB(R16_SINT, 1, int32_t, short, TO_INT)
233
234 ATTRIB(R8G8B8A8_SINT, 4, int32_t, char, TO_INT)
235 ATTRIB(R8G8B8_SINT, 3, int32_t, char, TO_INT)
236 ATTRIB(R8G8_SINT, 2, int32_t, char, TO_INT)
237 ATTRIB(R8_SINT, 1, int32_t, char, TO_INT)
238
239 static void
240 emit_A8R8G8B8_UNORM(const void *attrib, void *ptr)
241 {
242 float *in = (float *)attrib;
243 ubyte *out = (ubyte *)ptr;
244 out[0] = TO_8_UNORM(in[3]);
245 out[1] = TO_8_UNORM(in[0]);
246 out[2] = TO_8_UNORM(in[1]);
247 out[3] = TO_8_UNORM(in[2]);
248 }
249
250 static void
251 emit_B8G8R8A8_UNORM(const void *attrib, void *ptr)
252 {
253 float *in = (float *)attrib;
254 ubyte *out = (ubyte *)ptr;
255 out[2] = TO_8_UNORM(in[0]);
256 out[1] = TO_8_UNORM(in[1]);
257 out[0] = TO_8_UNORM(in[2]);
258 out[3] = TO_8_UNORM(in[3]);
259 }
260
261 static void
262 emit_B10G10R10A2_UNORM(const void *attrib, void *ptr)
263 {
264 float *src = (float *)ptr;
265 uint32_t value = 0;
266 value |= ((uint32_t)(CLAMP(src[2], 0, 1) * 0x3ff)) & 0x3ff;
267 value |= (((uint32_t)(CLAMP(src[1], 0, 1) * 0x3ff)) & 0x3ff) << 10;
268 value |= (((uint32_t)(CLAMP(src[0], 0, 1) * 0x3ff)) & 0x3ff) << 20;
269 value |= ((uint32_t)(CLAMP(src[3], 0, 1) * 0x3)) << 30;
270 *(uint32_t *)attrib = util_le32_to_cpu(value);
271 }
272
273 static void
274 emit_B10G10R10A2_USCALED(const void *attrib, void *ptr)
275 {
276 float *src = (float *)ptr;
277 uint32_t value = 0;
278 value |= ((uint32_t)CLAMP(src[2], 0, 1023)) & 0x3ff;
279 value |= (((uint32_t)CLAMP(src[1], 0, 1023)) & 0x3ff) << 10;
280 value |= (((uint32_t)CLAMP(src[0], 0, 1023)) & 0x3ff) << 20;
281 value |= ((uint32_t)CLAMP(src[3], 0, 3)) << 30;
282 *(uint32_t *)attrib = util_le32_to_cpu(value);
283 }
284
285 static void
286 emit_B10G10R10A2_SNORM(const void *attrib, void *ptr)
287 {
288 float *src = (float *)ptr;
289 uint32_t value = 0;
290 value |= (uint32_t)(((uint32_t)(CLAMP(src[2], -1, 1) * 0x1ff)) & 0x3ff) ;
291 value |= (uint32_t)((((uint32_t)(CLAMP(src[1], -1, 1) * 0x1ff)) & 0x3ff) << 10) ;
292 value |= (uint32_t)((((uint32_t)(CLAMP(src[0], -1, 1) * 0x1ff)) & 0x3ff) << 20) ;
293 value |= (uint32_t)(((uint32_t)(CLAMP(src[3], -1, 1) * 0x1)) << 30) ;
294 *(uint32_t *)attrib = util_le32_to_cpu(value);
295 }
296
297 static void
298 emit_B10G10R10A2_SSCALED(const void *attrib, void *ptr)
299 {
300 float *src = (float *)ptr;
301 uint32_t value = 0;
302 value |= (uint32_t)(((uint32_t)CLAMP(src[2], -512, 511)) & 0x3ff) ;
303 value |= (uint32_t)((((uint32_t)CLAMP(src[1], -512, 511)) & 0x3ff) << 10) ;
304 value |= (uint32_t)((((uint32_t)CLAMP(src[0], -512, 511)) & 0x3ff) << 20) ;
305 value |= (uint32_t)(((uint32_t)CLAMP(src[3], -2, 1)) << 30) ;
306 *(uint32_t *)attrib = util_le32_to_cpu(value);
307 }
308
309 static void
310 emit_R10G10B10A2_UNORM(const void *attrib, void *ptr)
311 {
312 float *src = (float *)ptr;
313 uint32_t value = 0;
314 value |= ((uint32_t)(CLAMP(src[0], 0, 1) * 0x3ff)) & 0x3ff;
315 value |= (((uint32_t)(CLAMP(src[1], 0, 1) * 0x3ff)) & 0x3ff) << 10;
316 value |= (((uint32_t)(CLAMP(src[2], 0, 1) * 0x3ff)) & 0x3ff) << 20;
317 value |= ((uint32_t)(CLAMP(src[3], 0, 1) * 0x3)) << 30;
318 *(uint32_t *)attrib = util_le32_to_cpu(value);
319 }
320
321 static void
322 emit_R10G10B10A2_USCALED(const void *attrib, void *ptr)
323 {
324 float *src = (float *)ptr;
325 uint32_t value = 0;
326 value |= ((uint32_t)CLAMP(src[0], 0, 1023)) & 0x3ff;
327 value |= (((uint32_t)CLAMP(src[1], 0, 1023)) & 0x3ff) << 10;
328 value |= (((uint32_t)CLAMP(src[2], 0, 1023)) & 0x3ff) << 20;
329 value |= ((uint32_t)CLAMP(src[3], 0, 3)) << 30;
330 *(uint32_t *)attrib = util_le32_to_cpu(value);
331 }
332
333 static void
334 emit_R10G10B10A2_SNORM(const void *attrib, void *ptr)
335 {
336 float *src = (float *)ptr;
337 uint32_t value = 0;
338 value |= (uint32_t)(((uint32_t)(CLAMP(src[0], -1, 1) * 0x1ff)) & 0x3ff) ;
339 value |= (uint32_t)((((uint32_t)(CLAMP(src[1], -1, 1) * 0x1ff)) & 0x3ff) << 10) ;
340 value |= (uint32_t)((((uint32_t)(CLAMP(src[2], -1, 1) * 0x1ff)) & 0x3ff) << 20) ;
341 value |= (uint32_t)(((uint32_t)(CLAMP(src[3], -1, 1) * 0x1)) << 30) ;
342 *(uint32_t *)attrib = util_le32_to_cpu(value);
343 }
344
345 static void
346 emit_R10G10B10A2_SSCALED(const void *attrib, void *ptr)
347 {
348 float *src = (float *)ptr;
349 uint32_t value = 0;
350 value |= (uint32_t)(((uint32_t)CLAMP(src[0], -512, 511)) & 0x3ff) ;
351 value |= (uint32_t)((((uint32_t)CLAMP(src[1], -512, 511)) & 0x3ff) << 10) ;
352 value |= (uint32_t)((((uint32_t)CLAMP(src[2], -512, 511)) & 0x3ff) << 20) ;
353 value |= (uint32_t)(((uint32_t)CLAMP(src[3], -2, 1)) << 30) ;
354 *(uint32_t *)attrib = util_le32_to_cpu(value);
355 }
356
357 static void
358 emit_NULL(const void *attrib, void *ptr)
359 {
360 /* do nothing is the only sensible option */
361 }
362
363 static emit_func
364 get_emit_func(enum pipe_format format)
365 {
366 switch (format) {
367 case PIPE_FORMAT_R64_FLOAT:
368 return &emit_R64_FLOAT;
369 case PIPE_FORMAT_R64G64_FLOAT:
370 return &emit_R64G64_FLOAT;
371 case PIPE_FORMAT_R64G64B64_FLOAT:
372 return &emit_R64G64B64_FLOAT;
373 case PIPE_FORMAT_R64G64B64A64_FLOAT:
374 return &emit_R64G64B64A64_FLOAT;
375
376 case PIPE_FORMAT_R32_FLOAT:
377 return &emit_R32_FLOAT;
378 case PIPE_FORMAT_R32G32_FLOAT:
379 return &emit_R32G32_FLOAT;
380 case PIPE_FORMAT_R32G32B32_FLOAT:
381 return &emit_R32G32B32_FLOAT;
382 case PIPE_FORMAT_R32G32B32A32_FLOAT:
383 return &emit_R32G32B32A32_FLOAT;
384
385 case PIPE_FORMAT_R16_FLOAT:
386 return &emit_R16_FLOAT;
387 case PIPE_FORMAT_R16G16_FLOAT:
388 return &emit_R16G16_FLOAT;
389 case PIPE_FORMAT_R16G16B16_FLOAT:
390 return &emit_R16G16B16_FLOAT;
391 case PIPE_FORMAT_R16G16B16A16_FLOAT:
392 return &emit_R16G16B16A16_FLOAT;
393
394 case PIPE_FORMAT_R32_UNORM:
395 return &emit_R32_UNORM;
396 case PIPE_FORMAT_R32G32_UNORM:
397 return &emit_R32G32_UNORM;
398 case PIPE_FORMAT_R32G32B32_UNORM:
399 return &emit_R32G32B32_UNORM;
400 case PIPE_FORMAT_R32G32B32A32_UNORM:
401 return &emit_R32G32B32A32_UNORM;
402
403 case PIPE_FORMAT_R32_USCALED:
404 return &emit_R32_USCALED;
405 case PIPE_FORMAT_R32G32_USCALED:
406 return &emit_R32G32_USCALED;
407 case PIPE_FORMAT_R32G32B32_USCALED:
408 return &emit_R32G32B32_USCALED;
409 case PIPE_FORMAT_R32G32B32A32_USCALED:
410 return &emit_R32G32B32A32_USCALED;
411
412 case PIPE_FORMAT_R32_SNORM:
413 return &emit_R32_SNORM;
414 case PIPE_FORMAT_R32G32_SNORM:
415 return &emit_R32G32_SNORM;
416 case PIPE_FORMAT_R32G32B32_SNORM:
417 return &emit_R32G32B32_SNORM;
418 case PIPE_FORMAT_R32G32B32A32_SNORM:
419 return &emit_R32G32B32A32_SNORM;
420
421 case PIPE_FORMAT_R32_SSCALED:
422 return &emit_R32_SSCALED;
423 case PIPE_FORMAT_R32G32_SSCALED:
424 return &emit_R32G32_SSCALED;
425 case PIPE_FORMAT_R32G32B32_SSCALED:
426 return &emit_R32G32B32_SSCALED;
427 case PIPE_FORMAT_R32G32B32A32_SSCALED:
428 return &emit_R32G32B32A32_SSCALED;
429
430 case PIPE_FORMAT_R16_UNORM:
431 return &emit_R16_UNORM;
432 case PIPE_FORMAT_R16G16_UNORM:
433 return &emit_R16G16_UNORM;
434 case PIPE_FORMAT_R16G16B16_UNORM:
435 return &emit_R16G16B16_UNORM;
436 case PIPE_FORMAT_R16G16B16A16_UNORM:
437 return &emit_R16G16B16A16_UNORM;
438
439 case PIPE_FORMAT_R16_USCALED:
440 return &emit_R16_USCALED;
441 case PIPE_FORMAT_R16G16_USCALED:
442 return &emit_R16G16_USCALED;
443 case PIPE_FORMAT_R16G16B16_USCALED:
444 return &emit_R16G16B16_USCALED;
445 case PIPE_FORMAT_R16G16B16A16_USCALED:
446 return &emit_R16G16B16A16_USCALED;
447
448 case PIPE_FORMAT_R16_SNORM:
449 return &emit_R16_SNORM;
450 case PIPE_FORMAT_R16G16_SNORM:
451 return &emit_R16G16_SNORM;
452 case PIPE_FORMAT_R16G16B16_SNORM:
453 return &emit_R16G16B16_SNORM;
454 case PIPE_FORMAT_R16G16B16A16_SNORM:
455 return &emit_R16G16B16A16_SNORM;
456
457 case PIPE_FORMAT_R16_SSCALED:
458 return &emit_R16_SSCALED;
459 case PIPE_FORMAT_R16G16_SSCALED:
460 return &emit_R16G16_SSCALED;
461 case PIPE_FORMAT_R16G16B16_SSCALED:
462 return &emit_R16G16B16_SSCALED;
463 case PIPE_FORMAT_R16G16B16A16_SSCALED:
464 return &emit_R16G16B16A16_SSCALED;
465
466 case PIPE_FORMAT_R8_UNORM:
467 return &emit_R8_UNORM;
468 case PIPE_FORMAT_R8G8_UNORM:
469 return &emit_R8G8_UNORM;
470 case PIPE_FORMAT_R8G8B8_UNORM:
471 return &emit_R8G8B8_UNORM;
472 case PIPE_FORMAT_R8G8B8A8_UNORM:
473 return &emit_R8G8B8A8_UNORM;
474
475 case PIPE_FORMAT_R8_USCALED:
476 return &emit_R8_USCALED;
477 case PIPE_FORMAT_R8G8_USCALED:
478 return &emit_R8G8_USCALED;
479 case PIPE_FORMAT_R8G8B8_USCALED:
480 return &emit_R8G8B8_USCALED;
481 case PIPE_FORMAT_R8G8B8A8_USCALED:
482 return &emit_R8G8B8A8_USCALED;
483
484 case PIPE_FORMAT_R8_SNORM:
485 return &emit_R8_SNORM;
486 case PIPE_FORMAT_R8G8_SNORM:
487 return &emit_R8G8_SNORM;
488 case PIPE_FORMAT_R8G8B8_SNORM:
489 return &emit_R8G8B8_SNORM;
490 case PIPE_FORMAT_R8G8B8A8_SNORM:
491 return &emit_R8G8B8A8_SNORM;
492
493 case PIPE_FORMAT_R8_SSCALED:
494 return &emit_R8_SSCALED;
495 case PIPE_FORMAT_R8G8_SSCALED:
496 return &emit_R8G8_SSCALED;
497 case PIPE_FORMAT_R8G8B8_SSCALED:
498 return &emit_R8G8B8_SSCALED;
499 case PIPE_FORMAT_R8G8B8A8_SSCALED:
500 return &emit_R8G8B8A8_SSCALED;
501
502 case PIPE_FORMAT_B8G8R8A8_UNORM:
503 return &emit_B8G8R8A8_UNORM;
504
505 case PIPE_FORMAT_A8R8G8B8_UNORM:
506 return &emit_A8R8G8B8_UNORM;
507
508 case PIPE_FORMAT_R32_UINT:
509 return &emit_R32_UINT;
510 case PIPE_FORMAT_R32G32_UINT:
511 return &emit_R32G32_UINT;
512 case PIPE_FORMAT_R32G32B32_UINT:
513 return &emit_R32G32B32_UINT;
514 case PIPE_FORMAT_R32G32B32A32_UINT:
515 return &emit_R32G32B32A32_UINT;
516
517 case PIPE_FORMAT_R16_UINT:
518 return &emit_R16_UINT;
519 case PIPE_FORMAT_R16G16_UINT:
520 return &emit_R16G16_UINT;
521 case PIPE_FORMAT_R16G16B16_UINT:
522 return &emit_R16G16B16_UINT;
523 case PIPE_FORMAT_R16G16B16A16_UINT:
524 return &emit_R16G16B16A16_UINT;
525
526 case PIPE_FORMAT_R8_UINT:
527 return &emit_R8_UINT;
528 case PIPE_FORMAT_R8G8_UINT:
529 return &emit_R8G8_UINT;
530 case PIPE_FORMAT_R8G8B8_UINT:
531 return &emit_R8G8B8_UINT;
532 case PIPE_FORMAT_R8G8B8A8_UINT:
533 return &emit_R8G8B8A8_UINT;
534
535 case PIPE_FORMAT_R32_SINT:
536 return &emit_R32_SINT;
537 case PIPE_FORMAT_R32G32_SINT:
538 return &emit_R32G32_SINT;
539 case PIPE_FORMAT_R32G32B32_SINT:
540 return &emit_R32G32B32_SINT;
541 case PIPE_FORMAT_R32G32B32A32_SINT:
542 return &emit_R32G32B32A32_SINT;
543
544 case PIPE_FORMAT_R16_SINT:
545 return &emit_R16_SINT;
546 case PIPE_FORMAT_R16G16_SINT:
547 return &emit_R16G16_SINT;
548 case PIPE_FORMAT_R16G16B16_SINT:
549 return &emit_R16G16B16_SINT;
550 case PIPE_FORMAT_R16G16B16A16_SINT:
551 return &emit_R16G16B16A16_SINT;
552
553 case PIPE_FORMAT_R8_SINT:
554 return &emit_R8_SINT;
555 case PIPE_FORMAT_R8G8_SINT:
556 return &emit_R8G8_SINT;
557 case PIPE_FORMAT_R8G8B8_SINT:
558 return &emit_R8G8B8_SINT;
559 case PIPE_FORMAT_R8G8B8A8_SINT:
560 return &emit_R8G8B8A8_SINT;
561
562 case PIPE_FORMAT_B10G10R10A2_UNORM:
563 return &emit_B10G10R10A2_UNORM;
564 case PIPE_FORMAT_B10G10R10A2_USCALED:
565 return &emit_B10G10R10A2_USCALED;
566 case PIPE_FORMAT_B10G10R10A2_SNORM:
567 return &emit_B10G10R10A2_SNORM;
568 case PIPE_FORMAT_B10G10R10A2_SSCALED:
569 return &emit_B10G10R10A2_SSCALED;
570
571 case PIPE_FORMAT_R10G10B10A2_UNORM:
572 return &emit_R10G10B10A2_UNORM;
573 case PIPE_FORMAT_R10G10B10A2_USCALED:
574 return &emit_R10G10B10A2_USCALED;
575 case PIPE_FORMAT_R10G10B10A2_SNORM:
576 return &emit_R10G10B10A2_SNORM;
577 case PIPE_FORMAT_R10G10B10A2_SSCALED:
578 return &emit_R10G10B10A2_SSCALED;
579
580 default:
581 assert(0);
582 return &emit_NULL;
583 }
584 }
585
586 static ALWAYS_INLINE void PIPE_CDECL
587 generic_run_one(struct translate_generic *tg,
588 unsigned elt,
589 unsigned start_instance,
590 unsigned instance_id,
591 void *vert)
592 {
593 unsigned nr_attrs = tg->nr_attrib;
594 unsigned attr;
595
596 for (attr = 0; attr < nr_attrs; attr++) {
597 float data[4];
598 uint8_t *dst = (uint8_t *)vert + tg->attrib[attr].output_offset;
599
600 if (tg->attrib[attr].type == TRANSLATE_ELEMENT_NORMAL) {
601 const uint8_t *src;
602 unsigned index;
603 int copy_size;
604
605 if (tg->attrib[attr].instance_divisor) {
606 index = start_instance;
607 index += (instance_id / tg->attrib[attr].instance_divisor);
608 /* XXX we need to clamp the index here too, but to a
609 * per-array max value, not the draw->pt.max_index value
610 * that's being given to us via translate->set_buffer().
611 */
612 }
613 else {
614 index = elt;
615 /* clamp to avoid going out of bounds */
616 index = MIN2(index, tg->attrib[attr].max_index);
617 }
618
619 src = tg->attrib[attr].input_ptr +
620 (ptrdiff_t)tg->attrib[attr].input_stride * index;
621
622 copy_size = tg->attrib[attr].copy_size;
623 if (likely(copy_size >= 0)) {
624 memcpy(dst, src, copy_size);
625 } else {
626 tg->attrib[attr].fetch(data, src, 0, 0);
627
628 if (0)
629 debug_printf("Fetch linear attr %d from %p stride %d index %d: "
630 " %f, %f, %f, %f \n",
631 attr,
632 tg->attrib[attr].input_ptr,
633 tg->attrib[attr].input_stride,
634 index,
635 data[0], data[1],data[2], data[3]);
636
637 tg->attrib[attr].emit(data, dst);
638 }
639 } else {
640 if (likely(tg->attrib[attr].copy_size >= 0)) {
641 memcpy(data, &instance_id, 4);
642 } else {
643 data[0] = (float)instance_id;
644 tg->attrib[attr].emit(data, dst);
645 }
646 }
647 }
648 }
649
650 /**
651 * Fetch vertex attributes for 'count' vertices.
652 */
653 static void PIPE_CDECL
654 generic_run_elts(struct translate *translate,
655 const unsigned *elts,
656 unsigned count,
657 unsigned start_instance,
658 unsigned instance_id,
659 void *output_buffer)
660 {
661 struct translate_generic *tg = translate_generic(translate);
662 char *vert = output_buffer;
663 unsigned i;
664
665 for (i = 0; i < count; i++) {
666 generic_run_one(tg, *elts++, start_instance, instance_id, vert);
667 vert += tg->translate.key.output_stride;
668 }
669 }
670
671 static void PIPE_CDECL
672 generic_run_elts16(struct translate *translate,
673 const uint16_t *elts,
674 unsigned count,
675 unsigned start_instance,
676 unsigned instance_id,
677 void *output_buffer)
678 {
679 struct translate_generic *tg = translate_generic(translate);
680 char *vert = output_buffer;
681 unsigned i;
682
683 for (i = 0; i < count; i++) {
684 generic_run_one(tg, *elts++, start_instance, instance_id, vert);
685 vert += tg->translate.key.output_stride;
686 }
687 }
688
689 static void PIPE_CDECL
690 generic_run_elts8(struct translate *translate,
691 const uint8_t *elts,
692 unsigned count,
693 unsigned start_instance,
694 unsigned instance_id,
695 void *output_buffer)
696 {
697 struct translate_generic *tg = translate_generic(translate);
698 char *vert = output_buffer;
699 unsigned i;
700
701 for (i = 0; i < count; i++) {
702 generic_run_one(tg, *elts++, start_instance, instance_id, vert);
703 vert += tg->translate.key.output_stride;
704 }
705 }
706
707 static void PIPE_CDECL
708 generic_run(struct translate *translate,
709 unsigned start,
710 unsigned count,
711 unsigned start_instance,
712 unsigned instance_id,
713 void *output_buffer)
714 {
715 struct translate_generic *tg = translate_generic(translate);
716 char *vert = output_buffer;
717 unsigned i;
718
719 for (i = 0; i < count; i++) {
720 generic_run_one(tg, start + i, start_instance, instance_id, vert);
721 vert += tg->translate.key.output_stride;
722 }
723 }
724
725
726
727 static void
728 generic_set_buffer(struct translate *translate,
729 unsigned buf,
730 const void *ptr,
731 unsigned stride,
732 unsigned max_index)
733 {
734 struct translate_generic *tg = translate_generic(translate);
735 unsigned i;
736
737 for (i = 0; i < tg->nr_attrib; i++) {
738 if (tg->attrib[i].buffer == buf) {
739 tg->attrib[i].input_ptr = ((const uint8_t *)ptr +
740 tg->attrib[i].input_offset);
741 tg->attrib[i].input_stride = stride;
742 tg->attrib[i].max_index = max_index;
743 }
744 }
745 }
746
747
748 static void
749 generic_release(struct translate *translate)
750 {
751 /* Refcount?
752 */
753 FREE(translate);
754 }
755
756 static boolean
757 is_legal_int_format_combo(const struct util_format_description *src,
758 const struct util_format_description *dst)
759 {
760 unsigned i;
761 unsigned nr = MIN2(src->nr_channels, dst->nr_channels);
762
763 for (i = 0; i < nr; i++) {
764 /* The signs must match. */
765 if (src->channel[i].type != dst->channel[i].type) {
766 return FALSE;
767 }
768
769 /* Integers must not lose precision at any point in the pipeline. */
770 if (src->channel[i].size > dst->channel[i].size) {
771 return FALSE;
772 }
773 }
774 return TRUE;
775 }
776
777 struct translate *
778 translate_generic_create(const struct translate_key *key)
779 {
780 struct translate_generic *tg = CALLOC_STRUCT(translate_generic);
781 unsigned i;
782
783 if (!tg)
784 return NULL;
785
786 assert(key->nr_elements <= TRANSLATE_MAX_ATTRIBS);
787
788 tg->translate.key = *key;
789 tg->translate.release = generic_release;
790 tg->translate.set_buffer = generic_set_buffer;
791 tg->translate.run_elts = generic_run_elts;
792 tg->translate.run_elts16 = generic_run_elts16;
793 tg->translate.run_elts8 = generic_run_elts8;
794 tg->translate.run = generic_run;
795
796 for (i = 0; i < key->nr_elements; i++) {
797 const struct util_format_description *format_desc =
798 util_format_description(key->element[i].input_format);
799
800 assert(format_desc);
801
802 tg->attrib[i].type = key->element[i].type;
803
804 if (format_desc->channel[0].pure_integer) {
805 const struct util_format_description *out_format_desc =
806 util_format_description(key->element[i].output_format);
807
808 if (!is_legal_int_format_combo(format_desc, out_format_desc)) {
809 FREE(tg);
810 return NULL;
811 }
812 }
813
814 tg->attrib[i].fetch =
815 util_format_fetch_rgba_func(key->element[i].input_format);
816 tg->attrib[i].buffer = key->element[i].input_buffer;
817 tg->attrib[i].input_offset = key->element[i].input_offset;
818 tg->attrib[i].instance_divisor = key->element[i].instance_divisor;
819
820 tg->attrib[i].output_offset = key->element[i].output_offset;
821
822 tg->attrib[i].copy_size = -1;
823 if (tg->attrib[i].type == TRANSLATE_ELEMENT_INSTANCE_ID) {
824 if (key->element[i].output_format == PIPE_FORMAT_R32_USCALED
825 || key->element[i].output_format == PIPE_FORMAT_R32_SSCALED)
826 tg->attrib[i].copy_size = 4;
827 } else {
828 if (key->element[i].input_format == key->element[i].output_format
829 && format_desc->block.width == 1
830 && format_desc->block.height == 1
831 && !(format_desc->block.bits & 7))
832 tg->attrib[i].copy_size = format_desc->block.bits >> 3;
833 }
834
835 if (tg->attrib[i].copy_size < 0)
836 tg->attrib[i].emit = get_emit_func(key->element[i].output_format);
837 else
838 tg->attrib[i].emit = NULL;
839 }
840
841 tg->nr_attrib = key->nr_elements;
842
843 return &tg->translate;
844 }
845
846 boolean
847 translate_generic_is_output_format_supported(enum pipe_format format)
848 {
849 switch(format) {
850 case PIPE_FORMAT_R64G64B64A64_FLOAT: return TRUE;
851 case PIPE_FORMAT_R64G64B64_FLOAT: return TRUE;
852 case PIPE_FORMAT_R64G64_FLOAT: return TRUE;
853 case PIPE_FORMAT_R64_FLOAT: return TRUE;
854
855 case PIPE_FORMAT_R32G32B32A32_FLOAT: return TRUE;
856 case PIPE_FORMAT_R32G32B32_FLOAT: return TRUE;
857 case PIPE_FORMAT_R32G32_FLOAT: return TRUE;
858 case PIPE_FORMAT_R32_FLOAT: return TRUE;
859
860 case PIPE_FORMAT_R16G16B16A16_FLOAT: return TRUE;
861 case PIPE_FORMAT_R16G16B16_FLOAT: return TRUE;
862 case PIPE_FORMAT_R16G16_FLOAT: return TRUE;
863 case PIPE_FORMAT_R16_FLOAT: return TRUE;
864
865 case PIPE_FORMAT_R32G32B32A32_USCALED: return TRUE;
866 case PIPE_FORMAT_R32G32B32_USCALED: return TRUE;
867 case PIPE_FORMAT_R32G32_USCALED: return TRUE;
868 case PIPE_FORMAT_R32_USCALED: return TRUE;
869
870 case PIPE_FORMAT_R32G32B32A32_SSCALED: return TRUE;
871 case PIPE_FORMAT_R32G32B32_SSCALED: return TRUE;
872 case PIPE_FORMAT_R32G32_SSCALED: return TRUE;
873 case PIPE_FORMAT_R32_SSCALED: return TRUE;
874
875 case PIPE_FORMAT_R32G32B32A32_UNORM: return TRUE;
876 case PIPE_FORMAT_R32G32B32_UNORM: return TRUE;
877 case PIPE_FORMAT_R32G32_UNORM: return TRUE;
878 case PIPE_FORMAT_R32_UNORM: return TRUE;
879
880 case PIPE_FORMAT_R32G32B32A32_SNORM: return TRUE;
881 case PIPE_FORMAT_R32G32B32_SNORM: return TRUE;
882 case PIPE_FORMAT_R32G32_SNORM: return TRUE;
883 case PIPE_FORMAT_R32_SNORM: return TRUE;
884
885 case PIPE_FORMAT_R16G16B16A16_USCALED: return TRUE;
886 case PIPE_FORMAT_R16G16B16_USCALED: return TRUE;
887 case PIPE_FORMAT_R16G16_USCALED: return TRUE;
888 case PIPE_FORMAT_R16_USCALED: return TRUE;
889
890 case PIPE_FORMAT_R16G16B16A16_SSCALED: return TRUE;
891 case PIPE_FORMAT_R16G16B16_SSCALED: return TRUE;
892 case PIPE_FORMAT_R16G16_SSCALED: return TRUE;
893 case PIPE_FORMAT_R16_SSCALED: return TRUE;
894
895 case PIPE_FORMAT_R16G16B16A16_UNORM: return TRUE;
896 case PIPE_FORMAT_R16G16B16_UNORM: return TRUE;
897 case PIPE_FORMAT_R16G16_UNORM: return TRUE;
898 case PIPE_FORMAT_R16_UNORM: return TRUE;
899
900 case PIPE_FORMAT_R16G16B16A16_SNORM: return TRUE;
901 case PIPE_FORMAT_R16G16B16_SNORM: return TRUE;
902 case PIPE_FORMAT_R16G16_SNORM: return TRUE;
903 case PIPE_FORMAT_R16_SNORM: return TRUE;
904
905 case PIPE_FORMAT_R8G8B8A8_USCALED: return TRUE;
906 case PIPE_FORMAT_R8G8B8_USCALED: return TRUE;
907 case PIPE_FORMAT_R8G8_USCALED: return TRUE;
908 case PIPE_FORMAT_R8_USCALED: return TRUE;
909
910 case PIPE_FORMAT_R8G8B8A8_SSCALED: return TRUE;
911 case PIPE_FORMAT_R8G8B8_SSCALED: return TRUE;
912 case PIPE_FORMAT_R8G8_SSCALED: return TRUE;
913 case PIPE_FORMAT_R8_SSCALED: return TRUE;
914
915 case PIPE_FORMAT_R8G8B8A8_UNORM: return TRUE;
916 case PIPE_FORMAT_R8G8B8_UNORM: return TRUE;
917 case PIPE_FORMAT_R8G8_UNORM: return TRUE;
918 case PIPE_FORMAT_R8_UNORM: return TRUE;
919
920 case PIPE_FORMAT_R8G8B8A8_SNORM: return TRUE;
921 case PIPE_FORMAT_R8G8B8_SNORM: return TRUE;
922 case PIPE_FORMAT_R8G8_SNORM: return TRUE;
923 case PIPE_FORMAT_R8_SNORM: return TRUE;
924
925 case PIPE_FORMAT_A8R8G8B8_UNORM: return TRUE;
926 case PIPE_FORMAT_B8G8R8A8_UNORM: return TRUE;
927
928 case PIPE_FORMAT_R32G32B32A32_UINT: return TRUE;
929 case PIPE_FORMAT_R32G32B32_UINT: return TRUE;
930 case PIPE_FORMAT_R32G32_UINT: return TRUE;
931 case PIPE_FORMAT_R32_UINT: return TRUE;
932
933 case PIPE_FORMAT_R16G16B16A16_UINT: return TRUE;
934 case PIPE_FORMAT_R16G16B16_UINT: return TRUE;
935 case PIPE_FORMAT_R16G16_UINT: return TRUE;
936 case PIPE_FORMAT_R16_UINT: return TRUE;
937
938 case PIPE_FORMAT_R8G8B8A8_UINT: return TRUE;
939 case PIPE_FORMAT_R8G8B8_UINT: return TRUE;
940 case PIPE_FORMAT_R8G8_UINT: return TRUE;
941 case PIPE_FORMAT_R8_UINT: return TRUE;
942
943 case PIPE_FORMAT_R32G32B32A32_SINT: return TRUE;
944 case PIPE_FORMAT_R32G32B32_SINT: return TRUE;
945 case PIPE_FORMAT_R32G32_SINT: return TRUE;
946 case PIPE_FORMAT_R32_SINT: return TRUE;
947
948 case PIPE_FORMAT_R16G16B16A16_SINT: return TRUE;
949 case PIPE_FORMAT_R16G16B16_SINT: return TRUE;
950 case PIPE_FORMAT_R16G16_SINT: return TRUE;
951 case PIPE_FORMAT_R16_SINT: return TRUE;
952
953 case PIPE_FORMAT_R8G8B8A8_SINT: return TRUE;
954 case PIPE_FORMAT_R8G8B8_SINT: return TRUE;
955 case PIPE_FORMAT_R8G8_SINT: return TRUE;
956 case PIPE_FORMAT_R8_SINT: return TRUE;
957
958 case PIPE_FORMAT_B10G10R10A2_UNORM: return TRUE;
959 case PIPE_FORMAT_B10G10R10A2_USCALED: return TRUE;
960 case PIPE_FORMAT_B10G10R10A2_SNORM: return TRUE;
961 case PIPE_FORMAT_B10G10R10A2_SSCALED: return TRUE;
962
963 case PIPE_FORMAT_R10G10B10A2_UNORM: return TRUE;
964 case PIPE_FORMAT_R10G10B10A2_USCALED: return TRUE;
965 case PIPE_FORMAT_R10G10B10A2_SNORM: return TRUE;
966 case PIPE_FORMAT_R10G10B10A2_SSCALED: return TRUE;
967
968 default: return FALSE;
969 }
970 }