src/gallium/auxiliary/translate/translate_generic.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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 <keith@tungstengraphics.com>
  31   */
  32
  33 #include "util/u_memory.h"
  34 #include "util/u_format.h"
  35 #include "util/u_math.h"
  36 #include "pipe/p_state.h"
  37 #include "translate.h"
  38
  39
  40 #define DRAW_DBG 0
  41
  42 typedef void (*fetch_func)(float *dst,
  43                            const uint8_t *src,
  44                            unsigned i, unsigned j);
  45 typedef void (*emit_func)(const float *attrib, void *ptr);
  46
  47
  48
  49 struct translate_generic {
  50    struct translate translate;
  51
  52    struct {
  53       enum translate_element_type type;
  54
  55       fetch_func fetch;
  56       unsigned buffer;
  57       unsigned input_offset;
  58       unsigned instance_divisor;
  59
  60       emit_func emit;
  61       unsigned output_offset;
  62
  63       const uint8_t *input_ptr;
  64       unsigned input_stride;
  65       unsigned max_index;
  66
  67       /* this value is set to -1 if this is a normal element with output_format != input_format:
  68        * in this case, u_format is used to do a full conversion
  69        *
  70        * this value is set to the format size in bytes if 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[PIPE_MAX_ATTRIBS];
  76
  77    unsigned nr_attrib;
  78 };
  79
  80
  81 static struct translate_generic *translate_generic( struct translate *translate )
  82 {
  83    return (struct translate_generic *)translate;
  84 }
  85
  86 /**
  87  * Fetch a float[4] vertex attribute from memory, doing format/type
  88  * conversion as needed.
  89  *
  90  * This is probably needed/dupliocated elsewhere, eg format
  91  * conversion, texture sampling etc.
  92  */
  93 #define ATTRIB( NAME, SZ, TYPE, TO )                    \
  94 static void                                             \
  95 emit_##NAME(const float *attrib, void *ptr)             \
  96 {  \
  97    unsigned i;                                          \
  98    TYPE *out = (TYPE *)ptr;                             \
  99                                                         \
 100    for (i = 0; i < SZ; i++) {                           \
 101       out[i] = TO(attrib[i]);                           \
 102    }                                                    \
 103 }
 104
 105
 106 #define TO_64_FLOAT(x)   ((double) x)
 107 #define TO_32_FLOAT(x)   (x)
 108
 109 #define TO_8_USCALED(x)  ((unsigned char) x)
 110 #define TO_16_USCALED(x) ((unsigned short) x)
 111 #define TO_32_USCALED(x) ((unsigned int) x)
 112
 113 #define TO_8_SSCALED(x)  ((char) x)
 114 #define TO_16_SSCALED(x) ((short) x)
 115 #define TO_32_SSCALED(x) ((int) x)
 116
 117 #define TO_8_UNORM(x)    ((unsigned char) (x * 255.0f))
 118 #define TO_16_UNORM(x)   ((unsigned short) (x * 65535.0f))
 119 #define TO_32_UNORM(x)   ((unsigned int) (x * 4294967295.0f))
 120
 121 #define TO_8_SNORM(x)    ((char) (x * 127.0f))
 122 #define TO_16_SNORM(x)   ((short) (x * 32767.0f))
 123 #define TO_32_SNORM(x)   ((int) (x * 2147483647.0f))
 124
 125 #define TO_32_FIXED(x)   ((int) (x * 65536.0f))
 126
 127
 128 ATTRIB( R64G64B64A64_FLOAT,   4, double, TO_64_FLOAT )
 129 ATTRIB( R64G64B64_FLOAT,      3, double, TO_64_FLOAT )
 130 ATTRIB( R64G64_FLOAT,         2, double, TO_64_FLOAT )
 131 ATTRIB( R64_FLOAT,            1, double, TO_64_FLOAT )
 132
 133 ATTRIB( R32G32B32A32_FLOAT,   4, float, TO_32_FLOAT )
 134 ATTRIB( R32G32B32_FLOAT,      3, float, TO_32_FLOAT )
 135 ATTRIB( R32G32_FLOAT,         2, float, TO_32_FLOAT )
 136 ATTRIB( R32_FLOAT,            1, float, TO_32_FLOAT )
 137
 138 ATTRIB( R32G32B32A32_USCALED, 4, unsigned, TO_32_USCALED )
 139 ATTRIB( R32G32B32_USCALED,    3, unsigned, TO_32_USCALED )
 140 ATTRIB( R32G32_USCALED,       2, unsigned, TO_32_USCALED )
 141 ATTRIB( R32_USCALED,          1, unsigned, TO_32_USCALED )
 142
 143 ATTRIB( R32G32B32A32_SSCALED, 4, int, TO_32_SSCALED )
 144 ATTRIB( R32G32B32_SSCALED,    3, int, TO_32_SSCALED )
 145 ATTRIB( R32G32_SSCALED,       2, int, TO_32_SSCALED )
 146 ATTRIB( R32_SSCALED,          1, int, TO_32_SSCALED )
 147
 148 ATTRIB( R32G32B32A32_UNORM, 4, unsigned, TO_32_UNORM )
 149 ATTRIB( R32G32B32_UNORM,    3, unsigned, TO_32_UNORM )
 150 ATTRIB( R32G32_UNORM,       2, unsigned, TO_32_UNORM )
 151 ATTRIB( R32_UNORM,          1, unsigned, TO_32_UNORM )
 152
 153 ATTRIB( R32G32B32A32_SNORM, 4, int, TO_32_SNORM )
 154 ATTRIB( R32G32B32_SNORM,    3, int, TO_32_SNORM )
 155 ATTRIB( R32G32_SNORM,       2, int, TO_32_SNORM )
 156 ATTRIB( R32_SNORM,          1, int, TO_32_SNORM )
 157
 158 ATTRIB( R16G16B16A16_USCALED, 4, ushort, TO_16_USCALED )
 159 ATTRIB( R16G16B16_USCALED,    3, ushort, TO_16_USCALED )
 160 ATTRIB( R16G16_USCALED,       2, ushort, TO_16_USCALED )
 161 ATTRIB( R16_USCALED,          1, ushort, TO_16_USCALED )
 162
 163 ATTRIB( R16G16B16A16_SSCALED, 4, short, TO_16_SSCALED )
 164 ATTRIB( R16G16B16_SSCALED,    3, short, TO_16_SSCALED )
 165 ATTRIB( R16G16_SSCALED,       2, short, TO_16_SSCALED )
 166 ATTRIB( R16_SSCALED,          1, short, TO_16_SSCALED )
 167
 168 ATTRIB( R16G16B16A16_UNORM, 4, ushort, TO_16_UNORM )
 169 ATTRIB( R16G16B16_UNORM,    3, ushort, TO_16_UNORM )
 170 ATTRIB( R16G16_UNORM,       2, ushort, TO_16_UNORM )
 171 ATTRIB( R16_UNORM,          1, ushort, TO_16_UNORM )
 172
 173 ATTRIB( R16G16B16A16_SNORM, 4, short, TO_16_SNORM )
 174 ATTRIB( R16G16B16_SNORM,    3, short, TO_16_SNORM )
 175 ATTRIB( R16G16_SNORM,       2, short, TO_16_SNORM )
 176 ATTRIB( R16_SNORM,          1, short, TO_16_SNORM )
 177
 178 ATTRIB( R8G8B8A8_USCALED,   4, ubyte, TO_8_USCALED )
 179 ATTRIB( R8G8B8_USCALED,     3, ubyte, TO_8_USCALED )
 180 ATTRIB( R8G8_USCALED,       2, ubyte, TO_8_USCALED )
 181 ATTRIB( R8_USCALED,         1, ubyte, TO_8_USCALED )
 182
 183 ATTRIB( R8G8B8A8_SSCALED,  4, char, TO_8_SSCALED )
 184 ATTRIB( R8G8B8_SSCALED,    3, char, TO_8_SSCALED )
 185 ATTRIB( R8G8_SSCALED,      2, char, TO_8_SSCALED )
 186 ATTRIB( R8_SSCALED,        1, char, TO_8_SSCALED )
 187
 188 ATTRIB( R8G8B8A8_UNORM,  4, ubyte, TO_8_UNORM )
 189 ATTRIB( R8G8B8_UNORM,    3, ubyte, TO_8_UNORM )
 190 ATTRIB( R8G8_UNORM,      2, ubyte, TO_8_UNORM )
 191 ATTRIB( R8_UNORM,        1, ubyte, TO_8_UNORM )
 192
 193 ATTRIB( R8G8B8A8_SNORM,  4, char, TO_8_SNORM )
 194 ATTRIB( R8G8B8_SNORM,    3, char, TO_8_SNORM )
 195 ATTRIB( R8G8_SNORM,      2, char, TO_8_SNORM )
 196 ATTRIB( R8_SNORM,        1, char, TO_8_SNORM )
 197
 198 static void
 199 emit_A8R8G8B8_UNORM( const float *attrib, void *ptr)
 200 {
 201    ubyte *out = (ubyte *)ptr;
 202    out[0] = TO_8_UNORM(attrib[3]);
 203    out[1] = TO_8_UNORM(attrib[0]);
 204    out[2] = TO_8_UNORM(attrib[1]);
 205    out[3] = TO_8_UNORM(attrib[2]);
 206 }
 207
 208 static void
 209 emit_B8G8R8A8_UNORM( const float *attrib, void *ptr)
 210 {
 211    ubyte *out = (ubyte *)ptr;
 212    out[2] = TO_8_UNORM(attrib[0]);
 213    out[1] = TO_8_UNORM(attrib[1]);
 214    out[0] = TO_8_UNORM(attrib[2]);
 215    out[3] = TO_8_UNORM(attrib[3]);
 216 }
 217
 218 static void
 219 emit_NULL( const float *attrib, void *ptr )
 220 {
 221    /* do nothing is the only sensible option */
 222 }
 223
 224 static emit_func get_emit_func( enum pipe_format format )
 225 {
 226    switch (format) {
 227    case PIPE_FORMAT_R64_FLOAT:
 228       return &emit_R64_FLOAT;
 229    case PIPE_FORMAT_R64G64_FLOAT:
 230       return &emit_R64G64_FLOAT;
 231    case PIPE_FORMAT_R64G64B64_FLOAT:
 232       return &emit_R64G64B64_FLOAT;
 233    case PIPE_FORMAT_R64G64B64A64_FLOAT:
 234       return &emit_R64G64B64A64_FLOAT;
 235
 236    case PIPE_FORMAT_R32_FLOAT:
 237       return &emit_R32_FLOAT;
 238    case PIPE_FORMAT_R32G32_FLOAT:
 239       return &emit_R32G32_FLOAT;
 240    case PIPE_FORMAT_R32G32B32_FLOAT:
 241       return &emit_R32G32B32_FLOAT;
 242    case PIPE_FORMAT_R32G32B32A32_FLOAT:
 243       return &emit_R32G32B32A32_FLOAT;
 244
 245    case PIPE_FORMAT_R32_UNORM:
 246       return &emit_R32_UNORM;
 247    case PIPE_FORMAT_R32G32_UNORM:
 248       return &emit_R32G32_UNORM;
 249    case PIPE_FORMAT_R32G32B32_UNORM:
 250       return &emit_R32G32B32_UNORM;
 251    case PIPE_FORMAT_R32G32B32A32_UNORM:
 252       return &emit_R32G32B32A32_UNORM;
 253
 254    case PIPE_FORMAT_R32_USCALED:
 255       return &emit_R32_USCALED;
 256    case PIPE_FORMAT_R32G32_USCALED:
 257       return &emit_R32G32_USCALED;
 258    case PIPE_FORMAT_R32G32B32_USCALED:
 259       return &emit_R32G32B32_USCALED;
 260    case PIPE_FORMAT_R32G32B32A32_USCALED:
 261       return &emit_R32G32B32A32_USCALED;
 262
 263    case PIPE_FORMAT_R32_SNORM:
 264       return &emit_R32_SNORM;
 265    case PIPE_FORMAT_R32G32_SNORM:
 266       return &emit_R32G32_SNORM;
 267    case PIPE_FORMAT_R32G32B32_SNORM:
 268       return &emit_R32G32B32_SNORM;
 269    case PIPE_FORMAT_R32G32B32A32_SNORM:
 270       return &emit_R32G32B32A32_SNORM;
 271
 272    case PIPE_FORMAT_R32_SSCALED:
 273       return &emit_R32_SSCALED;
 274    case PIPE_FORMAT_R32G32_SSCALED:
 275       return &emit_R32G32_SSCALED;
 276    case PIPE_FORMAT_R32G32B32_SSCALED:
 277       return &emit_R32G32B32_SSCALED;
 278    case PIPE_FORMAT_R32G32B32A32_SSCALED:
 279       return &emit_R32G32B32A32_SSCALED;
 280
 281    case PIPE_FORMAT_R16_UNORM:
 282       return &emit_R16_UNORM;
 283    case PIPE_FORMAT_R16G16_UNORM:
 284       return &emit_R16G16_UNORM;
 285    case PIPE_FORMAT_R16G16B16_UNORM:
 286       return &emit_R16G16B16_UNORM;
 287    case PIPE_FORMAT_R16G16B16A16_UNORM:
 288       return &emit_R16G16B16A16_UNORM;
 289
 290    case PIPE_FORMAT_R16_USCALED:
 291       return &emit_R16_USCALED;
 292    case PIPE_FORMAT_R16G16_USCALED:
 293       return &emit_R16G16_USCALED;
 294    case PIPE_FORMAT_R16G16B16_USCALED:
 295       return &emit_R16G16B16_USCALED;
 296    case PIPE_FORMAT_R16G16B16A16_USCALED:
 297       return &emit_R16G16B16A16_USCALED;
 298
 299    case PIPE_FORMAT_R16_SNORM:
 300       return &emit_R16_SNORM;
 301    case PIPE_FORMAT_R16G16_SNORM:
 302       return &emit_R16G16_SNORM;
 303    case PIPE_FORMAT_R16G16B16_SNORM:
 304       return &emit_R16G16B16_SNORM;
 305    case PIPE_FORMAT_R16G16B16A16_SNORM:
 306       return &emit_R16G16B16A16_SNORM;
 307
 308    case PIPE_FORMAT_R16_SSCALED:
 309       return &emit_R16_SSCALED;
 310    case PIPE_FORMAT_R16G16_SSCALED:
 311       return &emit_R16G16_SSCALED;
 312    case PIPE_FORMAT_R16G16B16_SSCALED:
 313       return &emit_R16G16B16_SSCALED;
 314    case PIPE_FORMAT_R16G16B16A16_SSCALED:
 315       return &emit_R16G16B16A16_SSCALED;
 316
 317    case PIPE_FORMAT_R8_UNORM:
 318       return &emit_R8_UNORM;
 319    case PIPE_FORMAT_R8G8_UNORM:
 320       return &emit_R8G8_UNORM;
 321    case PIPE_FORMAT_R8G8B8_UNORM:
 322       return &emit_R8G8B8_UNORM;
 323    case PIPE_FORMAT_R8G8B8A8_UNORM:
 324       return &emit_R8G8B8A8_UNORM;
 325
 326    case PIPE_FORMAT_R8_USCALED:
 327       return &emit_R8_USCALED;
 328    case PIPE_FORMAT_R8G8_USCALED:
 329       return &emit_R8G8_USCALED;
 330    case PIPE_FORMAT_R8G8B8_USCALED:
 331       return &emit_R8G8B8_USCALED;
 332    case PIPE_FORMAT_R8G8B8A8_USCALED:
 333       return &emit_R8G8B8A8_USCALED;
 334
 335    case PIPE_FORMAT_R8_SNORM:
 336       return &emit_R8_SNORM;
 337    case PIPE_FORMAT_R8G8_SNORM:
 338       return &emit_R8G8_SNORM;
 339    case PIPE_FORMAT_R8G8B8_SNORM:
 340       return &emit_R8G8B8_SNORM;
 341    case PIPE_FORMAT_R8G8B8A8_SNORM:
 342       return &emit_R8G8B8A8_SNORM;
 343
 344    case PIPE_FORMAT_R8_SSCALED:
 345       return &emit_R8_SSCALED;
 346    case PIPE_FORMAT_R8G8_SSCALED:
 347       return &emit_R8G8_SSCALED;
 348    case PIPE_FORMAT_R8G8B8_SSCALED:
 349       return &emit_R8G8B8_SSCALED;
 350    case PIPE_FORMAT_R8G8B8A8_SSCALED:
 351       return &emit_R8G8B8A8_SSCALED;
 352
 353    case PIPE_FORMAT_B8G8R8A8_UNORM:
 354       return &emit_B8G8R8A8_UNORM;
 355
 356    case PIPE_FORMAT_A8R8G8B8_UNORM:
 357       return &emit_A8R8G8B8_UNORM;
 358
 359    default:
 360       assert(0);
 361       return &emit_NULL;
 362    }
 363 }
 364
 365 static ALWAYS_INLINE void PIPE_CDECL generic_run_one( struct translate_generic *tg,
 366                                          unsigned elt,
 367                                          unsigned instance_id,
 368                                          void *vert )
 369 {
 370    unsigned nr_attrs = tg->nr_attrib;
 371    unsigned attr;
 372
 373    for (attr = 0; attr < nr_attrs; attr++) {
 374       float data[4];
 375       uint8_t *dst = (uint8_t *)vert + tg->attrib[attr].output_offset;
 376
 377       if (tg->attrib[attr].type == TRANSLATE_ELEMENT_NORMAL) {
 378          const uint8_t *src;
 379          unsigned index;
 380          int copy_size;
 381
 382          if (tg->attrib[attr].instance_divisor) {
 383             index = instance_id / tg->attrib[attr].instance_divisor;
 384          }
 385          else {
 386             index = elt;
 387          }
 388
 389          /* clamp to void going out of bounds */
 390          index = MIN2(index, tg->attrib[attr].max_index);
 391
 392          src = tg->attrib[attr].input_ptr +
 393                tg->attrib[attr].input_stride * index;
 394
 395          copy_size = tg->attrib[attr].copy_size;
 396          if(likely(copy_size >= 0))
 397             memcpy(dst, src, copy_size);
 398          else
 399          {
 400             tg->attrib[attr].fetch( data, src, 0, 0 );
 401
 402             if (0)
 403                debug_printf("Fetch linear attr %d  from %p  stride %d  index %d: "
 404                          " %f, %f, %f, %f \n",
 405                          attr,
 406                          tg->attrib[attr].input_ptr,
 407                          tg->attrib[attr].input_stride,
 408                          index,
 409                          data[0], data[1],data[2], data[3]);
 410
 411             tg->attrib[attr].emit( data, dst );
 412          }
 413       } else {
 414          if(likely(tg->attrib[attr].copy_size >= 0))
 415             memcpy(data, &instance_id, 4);
 416          else
 417          {
 418             data[0] = (float)instance_id;
 419             tg->attrib[attr].emit( data, dst );
 420          }
 421       }
 422    }
 423 }
 424
 425 /**
 426  * Fetch vertex attributes for 'count' vertices.
 427  */
 428 static void PIPE_CDECL generic_run_elts( struct translate *translate,
 429                                          const unsigned *elts,
 430                                          unsigned count,
 431                                          unsigned instance_id,
 432                                          void *output_buffer )
 433 {
 434    struct translate_generic *tg = translate_generic(translate);
 435    char *vert = output_buffer;
 436    unsigned i;
 437
 438    for (i = 0; i < count; i++) {
 439       generic_run_one(tg, *elts++, instance_id, vert);
 440       vert += tg->translate.key.output_stride;
 441    }
 442 }
 443
 444 static void PIPE_CDECL generic_run_elts16( struct translate *translate,
 445                                          const uint16_t *elts,
 446                                          unsigned count,
 447                                          unsigned instance_id,
 448                                          void *output_buffer )
 449 {
 450    struct translate_generic *tg = translate_generic(translate);
 451    char *vert = output_buffer;
 452    unsigned i;
 453
 454    for (i = 0; i < count; i++) {
 455       generic_run_one(tg, *elts++, instance_id, vert);
 456       vert += tg->translate.key.output_stride;
 457    }
 458 }
 459
 460 static void PIPE_CDECL generic_run_elts8( struct translate *translate,
 461                                          const uint8_t *elts,
 462                                          unsigned count,
 463                                          unsigned instance_id,
 464                                          void *output_buffer )
 465 {
 466    struct translate_generic *tg = translate_generic(translate);
 467    char *vert = output_buffer;
 468    unsigned i;
 469
 470    for (i = 0; i < count; i++) {
 471       generic_run_one(tg, *elts++, instance_id, vert);
 472       vert += tg->translate.key.output_stride;
 473    }
 474 }
 475
 476 static void PIPE_CDECL generic_run( struct translate *translate,
 477                                     unsigned start,
 478                                     unsigned count,
 479                                     unsigned instance_id,
 480                                     void *output_buffer )
 481 {
 482    struct translate_generic *tg = translate_generic(translate);
 483    char *vert = output_buffer;
 484    unsigned i;
 485
 486    for (i = 0; i < count; i++) {
 487       generic_run_one(tg, start + i, instance_id, vert);
 488       vert += tg->translate.key.output_stride;
 489    }
 490 }
 491
 492
 493
 494 static void generic_set_buffer( struct translate *translate,
 495                                 unsigned buf,
 496                                 const void *ptr,
 497                                 unsigned stride,
 498                                 unsigned max_index )
 499 {
 500    struct translate_generic *tg = translate_generic(translate);
 501    unsigned i;
 502
 503    for (i = 0; i < tg->nr_attrib; i++) {
 504       if (tg->attrib[i].buffer == buf) {
 505          tg->attrib[i].input_ptr = ((const uint8_t *)ptr +
 506                                     tg->attrib[i].input_offset);
 507          tg->attrib[i].input_stride = stride;
 508          tg->attrib[i].max_index = max_index;
 509       }
 510    }
 511 }
 512
 513
 514 static void generic_release( struct translate *translate )
 515 {
 516    /* Refcount?
 517     */
 518    FREE(translate);
 519 }
 520
 521 struct translate *translate_generic_create( const struct translate_key *key )
 522 {
 523    struct translate_generic *tg = CALLOC_STRUCT(translate_generic);
 524    unsigned i;
 525
 526    if (tg == NULL)
 527       return NULL;
 528
 529    tg->translate.key = *key;
 530    tg->translate.release = generic_release;
 531    tg->translate.set_buffer = generic_set_buffer;
 532    tg->translate.run_elts = generic_run_elts;
 533    tg->translate.run_elts16 = generic_run_elts16;
 534    tg->translate.run_elts8 = generic_run_elts8;
 535    tg->translate.run = generic_run;
 536
 537    for (i = 0; i < key->nr_elements; i++) {
 538       const struct util_format_description *format_desc =
 539             util_format_description(key->element[i].input_format);
 540
 541       assert(format_desc);
 542       assert(format_desc->fetch_rgba_float);
 543
 544       tg->attrib[i].type = key->element[i].type;
 545
 546       tg->attrib[i].fetch = format_desc->fetch_rgba_float;
 547       tg->attrib[i].buffer = key->element[i].input_buffer;
 548       tg->attrib[i].input_offset = key->element[i].input_offset;
 549       tg->attrib[i].instance_divisor = key->element[i].instance_divisor;
 550
 551       tg->attrib[i].output_offset = key->element[i].output_offset;
 552
 553       tg->attrib[i].copy_size = -1;
 554       if (tg->attrib[i].type == TRANSLATE_ELEMENT_INSTANCE_ID)
 555       {
 556             if(key->element[i].output_format == PIPE_FORMAT_R32_USCALED
 557                   || key->element[i].output_format == PIPE_FORMAT_R32_SSCALED)
 558                tg->attrib[i].copy_size = 4;
 559       }
 560       else
 561       {
 562          if(key->element[i].input_format == key->element[i].output_format
 563                && format_desc->block.width == 1
 564                && format_desc->block.height == 1
 565                && !(format_desc->block.bits & 7))
 566             tg->attrib[i].copy_size = format_desc->block.bits >> 3;
 567       }
 568
 569       if(tg->attrib[i].copy_size < 0)
 570               tg->attrib[i].emit = get_emit_func(key->element[i].output_format);
 571       else
 572               tg->attrib[i].emit  = NULL;
 573    }
 574
 575    tg->nr_attrib = key->nr_elements;
 576
 577
 578    return &tg->translate;
 579 }
 580
 581 boolean translate_generic_is_output_format_supported(enum pipe_format format)
 582 {
 583    switch(format)
 584    {
 585    case PIPE_FORMAT_R64G64B64A64_FLOAT: return TRUE;
 586    case PIPE_FORMAT_R64G64B64_FLOAT: return TRUE;
 587    case PIPE_FORMAT_R64G64_FLOAT: return TRUE;
 588    case PIPE_FORMAT_R64_FLOAT: return TRUE;
 589
 590    case PIPE_FORMAT_R32G32B32A32_FLOAT: return TRUE;
 591    case PIPE_FORMAT_R32G32B32_FLOAT: return TRUE;
 592    case PIPE_FORMAT_R32G32_FLOAT: return TRUE;
 593    case PIPE_FORMAT_R32_FLOAT: return TRUE;
 594
 595    case PIPE_FORMAT_R32G32B32A32_USCALED: return TRUE;
 596    case PIPE_FORMAT_R32G32B32_USCALED: return TRUE;
 597    case PIPE_FORMAT_R32G32_USCALED: return TRUE;
 598    case PIPE_FORMAT_R32_USCALED: return TRUE;
 599
 600    case PIPE_FORMAT_R32G32B32A32_SSCALED: return TRUE;
 601    case PIPE_FORMAT_R32G32B32_SSCALED: return TRUE;
 602    case PIPE_FORMAT_R32G32_SSCALED: return TRUE;
 603    case PIPE_FORMAT_R32_SSCALED: return TRUE;
 604
 605    case PIPE_FORMAT_R32G32B32A32_UNORM: return TRUE;
 606    case PIPE_FORMAT_R32G32B32_UNORM: return TRUE;
 607    case PIPE_FORMAT_R32G32_UNORM: return TRUE;
 608    case PIPE_FORMAT_R32_UNORM: return TRUE;
 609
 610    case PIPE_FORMAT_R32G32B32A32_SNORM: return TRUE;
 611    case PIPE_FORMAT_R32G32B32_SNORM: return TRUE;
 612    case PIPE_FORMAT_R32G32_SNORM: return TRUE;
 613    case PIPE_FORMAT_R32_SNORM: return TRUE;
 614
 615    case PIPE_FORMAT_R16G16B16A16_USCALED: return TRUE;
 616    case PIPE_FORMAT_R16G16B16_USCALED: return TRUE;
 617    case PIPE_FORMAT_R16G16_USCALED: return TRUE;
 618    case PIPE_FORMAT_R16_USCALED: return TRUE;
 619
 620    case PIPE_FORMAT_R16G16B16A16_SSCALED: return TRUE;
 621    case PIPE_FORMAT_R16G16B16_SSCALED: return TRUE;
 622    case PIPE_FORMAT_R16G16_SSCALED: return TRUE;
 623    case PIPE_FORMAT_R16_SSCALED: return TRUE;
 624
 625    case PIPE_FORMAT_R16G16B16A16_UNORM: return TRUE;
 626    case PIPE_FORMAT_R16G16B16_UNORM: return TRUE;
 627    case PIPE_FORMAT_R16G16_UNORM: return TRUE;
 628    case PIPE_FORMAT_R16_UNORM: return TRUE;
 629
 630    case PIPE_FORMAT_R16G16B16A16_SNORM: return TRUE;
 631    case PIPE_FORMAT_R16G16B16_SNORM: return TRUE;
 632    case PIPE_FORMAT_R16G16_SNORM: return TRUE;
 633    case PIPE_FORMAT_R16_SNORM: return TRUE;
 634
 635    case PIPE_FORMAT_R8G8B8A8_USCALED: return TRUE;
 636    case PIPE_FORMAT_R8G8B8_USCALED: return TRUE;
 637    case PIPE_FORMAT_R8G8_USCALED: return TRUE;
 638    case PIPE_FORMAT_R8_USCALED: return TRUE;
 639
 640    case PIPE_FORMAT_R8G8B8A8_SSCALED: return TRUE;
 641    case PIPE_FORMAT_R8G8B8_SSCALED: return TRUE;
 642    case PIPE_FORMAT_R8G8_SSCALED: return TRUE;
 643    case PIPE_FORMAT_R8_SSCALED: return TRUE;
 644
 645    case PIPE_FORMAT_R8G8B8A8_UNORM: return TRUE;
 646    case PIPE_FORMAT_R8G8B8_UNORM: return TRUE;
 647    case PIPE_FORMAT_R8G8_UNORM: return TRUE;
 648    case PIPE_FORMAT_R8_UNORM: return TRUE;
 649
 650    case PIPE_FORMAT_R8G8B8A8_SNORM: return TRUE;
 651    case PIPE_FORMAT_R8G8B8_SNORM: return TRUE;
 652    case PIPE_FORMAT_R8G8_SNORM: return TRUE;
 653    case PIPE_FORMAT_R8_SNORM: return TRUE;
 654
 655    case PIPE_FORMAT_A8R8G8B8_UNORM: return TRUE;
 656    case PIPE_FORMAT_B8G8R8A8_UNORM: return TRUE;
 657    default: return FALSE;
 658    }
 659 }