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