src/gallium/drivers/r300/r300_state_inlines.h

   1 /*
   2  * Copyright 2009 Joakim Sindholt <opensource@zhasha.com>
   3  *                Corbin Simpson <MostAwesomeDude@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #ifndef R300_STATE_INLINES_H
  25 #define R300_STATE_INLINES_H
  26
  27 #include "draw/draw_vertex.h"
  28
  29 #include "pipe/p_format.h"
  30
  31 #include "util/u_format.h"
  32
  33 #include "r300_reg.h"
  34
  35 /* Some maths. These should probably find their way to u_math, if needed. */
  36
  37 static INLINE int pack_float_16_6x(float f) {
  38     return ((int)(f * 6.0) & 0xffff);
  39 }
  40
  41 /* Blend state. */
  42
  43 static INLINE uint32_t r300_translate_blend_function(int blend_func)
  44 {
  45     switch (blend_func) {
  46         case PIPE_BLEND_ADD:
  47             return R300_COMB_FCN_ADD_CLAMP;
  48         case PIPE_BLEND_SUBTRACT:
  49             return R300_COMB_FCN_SUB_CLAMP;
  50         case PIPE_BLEND_REVERSE_SUBTRACT:
  51             return R300_COMB_FCN_RSUB_CLAMP;
  52         case PIPE_BLEND_MIN:
  53             return R300_COMB_FCN_MIN;
  54         case PIPE_BLEND_MAX:
  55             return R300_COMB_FCN_MAX;
  56         default:
  57             debug_printf("r300: Unknown blend function %d\n", blend_func);
  58             assert(0);
  59             break;
  60     }
  61     return 0;
  62 }
  63
  64 /* XXX we can also offer the D3D versions of some of these... */
  65 static INLINE uint32_t r300_translate_blend_factor(int blend_fact)
  66 {
  67     switch (blend_fact) {
  68         case PIPE_BLENDFACTOR_ONE:
  69             return R300_BLEND_GL_ONE;
  70         case PIPE_BLENDFACTOR_SRC_COLOR:
  71             return R300_BLEND_GL_SRC_COLOR;
  72         case PIPE_BLENDFACTOR_SRC_ALPHA:
  73             return R300_BLEND_GL_SRC_ALPHA;
  74         case PIPE_BLENDFACTOR_DST_ALPHA:
  75             return R300_BLEND_GL_DST_ALPHA;
  76         case PIPE_BLENDFACTOR_DST_COLOR:
  77             return R300_BLEND_GL_DST_COLOR;
  78         case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
  79             return R300_BLEND_GL_SRC_ALPHA_SATURATE;
  80         case PIPE_BLENDFACTOR_CONST_COLOR:
  81             return R300_BLEND_GL_CONST_COLOR;
  82         case PIPE_BLENDFACTOR_CONST_ALPHA:
  83             return R300_BLEND_GL_CONST_ALPHA;
  84         case PIPE_BLENDFACTOR_ZERO:
  85             return R300_BLEND_GL_ZERO;
  86         case PIPE_BLENDFACTOR_INV_SRC_COLOR:
  87             return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
  88         case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
  89             return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
  90         case PIPE_BLENDFACTOR_INV_DST_ALPHA:
  91             return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
  92         case PIPE_BLENDFACTOR_INV_DST_COLOR:
  93             return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
  94         case PIPE_BLENDFACTOR_INV_CONST_COLOR:
  95             return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
  96         case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
  97             return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
  98
  99         case PIPE_BLENDFACTOR_SRC1_COLOR:
 100         case PIPE_BLENDFACTOR_SRC1_ALPHA:
 101         case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
 102         case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
 103             debug_printf("r300: Implementation error: "
 104                 "Bad blend factor %d not supported!\n", blend_fact);
 105             assert(0);
 106             break;
 107
 108         default:
 109             debug_printf("r300: Unknown blend factor %d\n", blend_fact);
 110             assert(0);
 111             break;
 112     }
 113     return 0;
 114 }
 115
 116 /* DSA state. */
 117
 118 static INLINE uint32_t r300_translate_depth_stencil_function(int zs_func)
 119 {
 120     switch (zs_func) {
 121         case PIPE_FUNC_NEVER:
 122             return R300_ZS_NEVER;
 123         case PIPE_FUNC_LESS:
 124             return R300_ZS_LESS;
 125         case PIPE_FUNC_EQUAL:
 126             return R300_ZS_EQUAL;
 127         case PIPE_FUNC_LEQUAL:
 128             return R300_ZS_LEQUAL;
 129         case PIPE_FUNC_GREATER:
 130             return R300_ZS_GREATER;
 131         case PIPE_FUNC_NOTEQUAL:
 132             return R300_ZS_NOTEQUAL;
 133         case PIPE_FUNC_GEQUAL:
 134             return R300_ZS_GEQUAL;
 135         case PIPE_FUNC_ALWAYS:
 136             return R300_ZS_ALWAYS;
 137         default:
 138             debug_printf("r300: Unknown depth/stencil function %d\n",
 139                 zs_func);
 140             assert(0);
 141             break;
 142     }
 143     return 0;
 144 }
 145
 146 static INLINE uint32_t r300_translate_stencil_op(int s_op)
 147 {
 148     switch (s_op) {
 149         case PIPE_STENCIL_OP_KEEP:
 150             return R300_ZS_KEEP;
 151         case PIPE_STENCIL_OP_ZERO:
 152             return R300_ZS_ZERO;
 153         case PIPE_STENCIL_OP_REPLACE:
 154             return R300_ZS_REPLACE;
 155         case PIPE_STENCIL_OP_INCR:
 156             return R300_ZS_INCR;
 157         case PIPE_STENCIL_OP_DECR:
 158             return R300_ZS_DECR;
 159         case PIPE_STENCIL_OP_INCR_WRAP:
 160             return R300_ZS_INCR_WRAP;
 161         case PIPE_STENCIL_OP_DECR_WRAP:
 162             return R300_ZS_DECR_WRAP;
 163         case PIPE_STENCIL_OP_INVERT:
 164             return R300_ZS_INVERT;
 165         default:
 166             debug_printf("r300: Unknown stencil op %d", s_op);
 167             assert(0);
 168             break;
 169     }
 170     return 0;
 171 }
 172
 173 static INLINE uint32_t r300_translate_alpha_function(int alpha_func)
 174 {
 175     switch (alpha_func) {
 176         case PIPE_FUNC_NEVER:
 177             return R300_FG_ALPHA_FUNC_NEVER;
 178         case PIPE_FUNC_LESS:
 179             return R300_FG_ALPHA_FUNC_LESS;
 180         case PIPE_FUNC_EQUAL:
 181             return R300_FG_ALPHA_FUNC_EQUAL;
 182         case PIPE_FUNC_LEQUAL:
 183             return R300_FG_ALPHA_FUNC_LE;
 184         case PIPE_FUNC_GREATER:
 185             return R300_FG_ALPHA_FUNC_GREATER;
 186         case PIPE_FUNC_NOTEQUAL:
 187             return R300_FG_ALPHA_FUNC_NOTEQUAL;
 188         case PIPE_FUNC_GEQUAL:
 189             return R300_FG_ALPHA_FUNC_GE;
 190         case PIPE_FUNC_ALWAYS:
 191             return R300_FG_ALPHA_FUNC_ALWAYS;
 192         default:
 193             debug_printf("r300: Unknown alpha function %d", alpha_func);
 194             assert(0);
 195             break;
 196     }
 197     return 0;
 198 }
 199
 200 static INLINE uint32_t
 201 r300_translate_polygon_mode_front(unsigned mode) {
 202     switch (mode)
 203     {
 204         case PIPE_POLYGON_MODE_FILL:
 205             return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
 206         case PIPE_POLYGON_MODE_LINE:
 207             return R300_GA_POLY_MODE_FRONT_PTYPE_LINE;
 208         case PIPE_POLYGON_MODE_POINT:
 209             return R300_GA_POLY_MODE_FRONT_PTYPE_POINT;
 210
 211         default:
 212             debug_printf("r300: Bad polygon mode %i in %s\n", mode,
 213                 __FUNCTION__);
 214             return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
 215     }
 216 }
 217
 218 static INLINE uint32_t
 219 r300_translate_polygon_mode_back(unsigned mode) {
 220     switch (mode)
 221     {
 222         case PIPE_POLYGON_MODE_FILL:
 223             return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
 224         case PIPE_POLYGON_MODE_LINE:
 225             return R300_GA_POLY_MODE_BACK_PTYPE_LINE;
 226         case PIPE_POLYGON_MODE_POINT:
 227             return R300_GA_POLY_MODE_BACK_PTYPE_POINT;
 228
 229         default:
 230             debug_printf("r300: Bad polygon mode %i in %s\n", mode,
 231                 __FUNCTION__);
 232             return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
 233     }
 234 }
 235
 236 /* Texture sampler state. */
 237
 238 static INLINE uint32_t r300_translate_wrap(int wrap)
 239 {
 240     switch (wrap) {
 241         case PIPE_TEX_WRAP_REPEAT:
 242             return R300_TX_REPEAT;
 243         case PIPE_TEX_WRAP_CLAMP:
 244             return R300_TX_CLAMP;
 245         case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
 246             return R300_TX_CLAMP_TO_EDGE;
 247         case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
 248             return R300_TX_CLAMP_TO_BORDER;
 249         case PIPE_TEX_WRAP_MIRROR_REPEAT:
 250             return R300_TX_REPEAT | R300_TX_MIRRORED;
 251         case PIPE_TEX_WRAP_MIRROR_CLAMP:
 252             return R300_TX_CLAMP | R300_TX_MIRRORED;
 253         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
 254             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 255         case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
 256             return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
 257         default:
 258             debug_printf("r300: Unknown texture wrap %d", wrap);
 259             assert(0);
 260             return 0;
 261     }
 262 }
 263
 264 static INLINE uint32_t r300_translate_tex_filters(int min, int mag, int mip,
 265                                                   int is_anisotropic)
 266 {
 267     uint32_t retval = 0;
 268     if (is_anisotropic)
 269         retval |= R300_TX_MIN_FILTER_ANISO | R300_TX_MAG_FILTER_ANISO;
 270     else {
 271         switch (min) {
 272         case PIPE_TEX_FILTER_NEAREST:
 273             retval |= R300_TX_MIN_FILTER_NEAREST;
 274             break;
 275         case PIPE_TEX_FILTER_LINEAR:
 276             retval |= R300_TX_MIN_FILTER_LINEAR;
 277             break;
 278         default:
 279             debug_printf("r300: Unknown texture filter %d\n", min);
 280             assert(0);
 281             break;
 282         }
 283         switch (mag) {
 284         case PIPE_TEX_FILTER_NEAREST:
 285             retval |= R300_TX_MAG_FILTER_NEAREST;
 286             break;
 287         case PIPE_TEX_FILTER_LINEAR:
 288             retval |= R300_TX_MAG_FILTER_LINEAR;
 289             break;
 290         default:
 291             debug_printf("r300: Unknown texture filter %d\n", mag);
 292             assert(0);
 293             break;
 294         }
 295     }
 296     switch (mip) {
 297         case PIPE_TEX_MIPFILTER_NONE:
 298             retval |= R300_TX_MIN_FILTER_MIP_NONE;
 299             break;
 300         case PIPE_TEX_MIPFILTER_NEAREST:
 301             retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
 302             break;
 303         case PIPE_TEX_MIPFILTER_LINEAR:
 304             retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
 305             break;
 306         default:
 307             debug_printf("r300: Unknown texture filter %d\n", mip);
 308             assert(0);
 309             break;
 310     }
 311
 312     return retval;
 313 }
 314
 315 static INLINE uint32_t r300_anisotropy(unsigned max_aniso)
 316 {
 317     if (max_aniso >= 16) {
 318         return R300_TX_MAX_ANISO_16_TO_1;
 319     } else if (max_aniso >= 8) {
 320         return R300_TX_MAX_ANISO_8_TO_1;
 321     } else if (max_aniso >= 4) {
 322         return R300_TX_MAX_ANISO_4_TO_1;
 323     } else if (max_aniso >= 2) {
 324         return R300_TX_MAX_ANISO_2_TO_1;
 325     } else {
 326         return R300_TX_MAX_ANISO_1_TO_1;
 327     }
 328 }
 329
 330 /* Buffer formats. */
 331
 332 /* Colorbuffer formats. This is the unswizzled format of the RB3D block's
 333  * output. For the swizzling of the targets, check the shader's format. */
 334 static INLINE uint32_t r300_translate_colorformat(enum pipe_format format)
 335 {
 336     switch (format) {
 337         /* 8-bit buffers. */
 338         case PIPE_FORMAT_A8_UNORM:
 339         case PIPE_FORMAT_I8_UNORM:
 340         case PIPE_FORMAT_L8_UNORM:
 341         case PIPE_FORMAT_L8_SRGB:
 342         case PIPE_FORMAT_R8_UNORM:
 343         case PIPE_FORMAT_R8_SNORM:
 344             return R300_COLOR_FORMAT_I8;
 345
 346         /* 16-bit buffers. */
 347         case PIPE_FORMAT_R5G6B5_UNORM:
 348             return R300_COLOR_FORMAT_RGB565;
 349         case PIPE_FORMAT_A1R5G5B5_UNORM:
 350             return R300_COLOR_FORMAT_ARGB1555;
 351         case PIPE_FORMAT_A4R4G4B4_UNORM:
 352             return R300_COLOR_FORMAT_ARGB4444;
 353
 354         /* 32-bit buffers. */
 355         case PIPE_FORMAT_A8R8G8B8_UNORM:
 356         case PIPE_FORMAT_A8R8G8B8_SRGB:
 357         case PIPE_FORMAT_X8R8G8B8_UNORM:
 358         case PIPE_FORMAT_X8R8G8B8_SRGB:
 359         case PIPE_FORMAT_B8G8R8A8_UNORM:
 360         case PIPE_FORMAT_B8G8R8A8_SRGB:
 361         case PIPE_FORMAT_B8G8R8X8_UNORM:
 362         case PIPE_FORMAT_B8G8R8X8_SRGB:
 363         case PIPE_FORMAT_R8G8B8A8_UNORM:
 364         case PIPE_FORMAT_R8G8B8A8_SNORM:
 365         case PIPE_FORMAT_R8G8B8A8_SRGB:
 366         case PIPE_FORMAT_R8G8B8X8_UNORM:
 367         case PIPE_FORMAT_R8G8B8X8_SRGB:
 368         case PIPE_FORMAT_R8G8B8X8_SNORM:
 369         case PIPE_FORMAT_A8B8G8R8_SNORM:
 370         case PIPE_FORMAT_X8B8G8R8_SNORM:
 371         case PIPE_FORMAT_X8UB8UG8SR8S_NORM:
 372             return R300_COLOR_FORMAT_ARGB8888;
 373         case PIPE_FORMAT_A2B10G10R10_UNORM:
 374             return R500_COLOR_FORMAT_ARGB2101010;  /* R5xx-only? */
 375
 376         /* 64-bit buffers. */
 377         case PIPE_FORMAT_R16G16B16A16_UNORM:
 378         case PIPE_FORMAT_R16G16B16A16_SNORM:
 379         //case PIPE_FORMAT_R16G16B16A16_FLOAT: /* not in pipe_format */
 380             return R300_COLOR_FORMAT_ARGB16161616;
 381
 382 /* XXX Enable float textures here. */
 383 #if 0
 384         /* 128-bit buffers. */
 385         case PIPE_FORMAT_R32G32B32A32_FLOAT:
 386             return R300_COLOR_FORMAT_ARGB32323232;
 387 #endif
 388
 389         /* YUV buffers. */
 390         case PIPE_FORMAT_YCBCR:
 391             return R300_COLOR_FORMAT_YVYU;
 392         case PIPE_FORMAT_YCBCR_REV:
 393             return R300_COLOR_FORMAT_VYUY;
 394         default:
 395             return ~0; /* Unsupported. */
 396     }
 397 }
 398
 399 /* Depthbuffer and stencilbuffer. Thankfully, we only support two flavors. */
 400 static INLINE uint32_t r300_translate_zsformat(enum pipe_format format)
 401 {
 402     switch (format) {
 403         /* 16-bit depth, no stencil */
 404         case PIPE_FORMAT_Z16_UNORM:
 405             return R300_DEPTHFORMAT_16BIT_INT_Z;
 406         /* 24-bit depth, ignored stencil */
 407         case PIPE_FORMAT_Z24X8_UNORM:
 408         /* 24-bit depth, 8-bit stencil */
 409         case PIPE_FORMAT_Z24S8_UNORM:
 410             return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
 411         default:
 412             return ~0; /* Unsupported. */
 413     }
 414 }
 415
 416 /* Shader output formats. This is essentially the swizzle from the shader
 417  * to the RB3D block.
 418  *
 419  * Note that formats are stored from C3 to C0. */
 420 static INLINE uint32_t r300_translate_out_fmt(enum pipe_format format)
 421 {
 422     uint32_t modifier = 0;
 423     unsigned i;
 424     const struct util_format_description *desc;
 425     static const uint32_t sign_bit[4] = {
 426         R300_OUT_SIGN(0x1),
 427         R300_OUT_SIGN(0x2),
 428         R300_OUT_SIGN(0x4),
 429         R300_OUT_SIGN(0x8),
 430     };
 431
 432     desc = util_format_description(format);
 433
 434     /* Specifies how the shader output is written to the fog unit. */
 435     if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
 436         /* The gamma correction causes precision loss so we need
 437          * higher precision to maintain reasonable quality.
 438          * It has nothing to do with the colorbuffer format. */
 439         modifier |= R300_US_OUT_FMT_C4_10_GAMMA;
 440     } else if (desc->channel[0].type == UTIL_FORMAT_TYPE_FLOAT) {
 441         if (desc->channel[0].size == 32) {
 442             modifier |= R300_US_OUT_FMT_C4_32_FP;
 443         } else {
 444             modifier |= R300_US_OUT_FMT_C4_16_FP;
 445         }
 446     } else {
 447         if (desc->channel[0].size == 16) {
 448             modifier |= R300_US_OUT_FMT_C4_16;
 449         } else {
 450             /* C4_8 seems to be used for the formats whose pixel size
 451              * is <= 32 bits. */
 452             modifier |= R300_US_OUT_FMT_C4_8;
 453         }
 454     }
 455
 456     /* Add sign. */
 457     for (i = 0; i < 4; i++)
 458         if (desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED) {
 459             modifier |= sign_bit[i];
 460         }
 461
 462     /* Add swizzles and return. */
 463     switch (format) {
 464         /* 8-bit outputs.
 465          * COLORFORMAT_I8 stores the C2 component. */
 466         case PIPE_FORMAT_A8_UNORM:
 467             return modifier | R300_C2_SEL_A;
 468         case PIPE_FORMAT_I8_UNORM:
 469         case PIPE_FORMAT_L8_UNORM:
 470         case PIPE_FORMAT_L8_SRGB:
 471         case PIPE_FORMAT_R8_UNORM:
 472         case PIPE_FORMAT_R8_SNORM:
 473             return modifier | R300_C2_SEL_R;
 474
 475         /* ARGB 32-bit outputs. */
 476         case PIPE_FORMAT_R5G6B5_UNORM:
 477         case PIPE_FORMAT_A1R5G5B5_UNORM:
 478         case PIPE_FORMAT_A4R4G4B4_UNORM:
 479         case PIPE_FORMAT_A8R8G8B8_UNORM:
 480         case PIPE_FORMAT_A8R8G8B8_SRGB:
 481         case PIPE_FORMAT_X8R8G8B8_UNORM:
 482         case PIPE_FORMAT_X8R8G8B8_SRGB:
 483             return modifier |
 484                 R300_C0_SEL_B | R300_C1_SEL_G |
 485                 R300_C2_SEL_R | R300_C3_SEL_A;
 486
 487         /* BGRA 32-bit outputs. */
 488         case PIPE_FORMAT_B8G8R8A8_UNORM:
 489         case PIPE_FORMAT_B8G8R8A8_SRGB:
 490         case PIPE_FORMAT_B8G8R8X8_UNORM:
 491         case PIPE_FORMAT_B8G8R8X8_SRGB:
 492             return modifier |
 493                 R300_C0_SEL_A | R300_C1_SEL_R |
 494                 R300_C2_SEL_G | R300_C3_SEL_B;
 495
 496         /* RGBA 32-bit outputs. */
 497         case PIPE_FORMAT_R8G8B8A8_UNORM:
 498         case PIPE_FORMAT_R8G8B8A8_SNORM:
 499         case PIPE_FORMAT_R8G8B8A8_SRGB:
 500         case PIPE_FORMAT_R8G8B8X8_UNORM:
 501         case PIPE_FORMAT_R8G8B8X8_SRGB:
 502         case PIPE_FORMAT_R8G8B8X8_SNORM:
 503             return modifier |
 504                 R300_C0_SEL_A | R300_C1_SEL_B |
 505                 R300_C2_SEL_G | R300_C3_SEL_R;
 506
 507         /* ABGR 32-bit outputs. */
 508         case PIPE_FORMAT_A8B8G8R8_SNORM:
 509         case PIPE_FORMAT_X8B8G8R8_SNORM:
 510         case PIPE_FORMAT_X8UB8UG8SR8S_NORM:
 511         case PIPE_FORMAT_A2B10G10R10_UNORM:
 512         /* RGBA high precision outputs (same swizzles as ABGR low precision) */
 513         case PIPE_FORMAT_R16G16B16A16_UNORM:
 514         case PIPE_FORMAT_R16G16B16A16_SNORM:
 515         //case PIPE_FORMAT_R16G16B16A16_FLOAT: /* not in pipe_format */
 516         case PIPE_FORMAT_R32G32B32A32_FLOAT:
 517             return modifier |
 518                 R300_C0_SEL_R | R300_C1_SEL_G |
 519                 R300_C2_SEL_B | R300_C3_SEL_A;
 520
 521         default:
 522             return ~0; /* Unsupported. */
 523     }
 524 }
 525
 526 static INLINE
 527 boolean r300_is_zs_format_supported(enum pipe_format format)
 528 {
 529     return r300_translate_zsformat(format) != ~0;
 530 }
 531
 532 static INLINE
 533 boolean r300_is_colorbuffer_format_supported(enum pipe_format format)
 534 {
 535     return r300_translate_colorformat(format) != ~0 &&
 536            r300_translate_out_fmt(format) != ~0;
 537 }
 538
 539 /* Non-CSO state. (For now.) */
 540
 541 static INLINE uint32_t r300_translate_gb_pipes(int pipe_count)
 542 {
 543     switch (pipe_count) {
 544         case 1:
 545             return R300_GB_TILE_PIPE_COUNT_RV300;
 546             break;
 547         case 2:
 548             return R300_GB_TILE_PIPE_COUNT_R300;
 549             break;
 550         case 3:
 551             return R300_GB_TILE_PIPE_COUNT_R420_3P;
 552             break;
 553         case 4:
 554             return R300_GB_TILE_PIPE_COUNT_R420;
 555             break;
 556     }
 557     return 0;
 558 }
 559
 560 /* Utility function to count the number of components in RGBAZS formats.
 561  * XXX should go to util or p_format.h */
 562 static INLINE unsigned pf_component_count(enum pipe_format format) {
 563     unsigned count = 0;
 564
 565     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0)) {
 566         count++;
 567     }
 568     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1)) {
 569         count++;
 570     }
 571     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2)) {
 572         count++;
 573     }
 574     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3)) {
 575         count++;
 576     }
 577     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0)) {
 578         count++;
 579     }
 580     if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1)) {
 581         count++;
 582     }
 583
 584     return count;
 585 }
 586
 587 /* Translate pipe_formats into PSC vertex types. */
 588 static INLINE uint16_t
 589 r300_translate_vertex_data_type(enum pipe_format format) {
 590     uint32_t result = 0;
 591     const struct util_format_description *desc;
 592     unsigned components = pf_component_count(format);
 593
 594     desc = util_format_description(format);
 595
 596     if (desc->layout != UTIL_FORMAT_LAYOUT_ARITH &&
 597         desc->layout != UTIL_FORMAT_LAYOUT_ARRAY) {
 598         debug_printf("r300: Bad format %s in %s:%d\n", util_format_name(format),
 599             __FUNCTION__, __LINE__);
 600         assert(0);
 601     }
 602
 603     switch (desc->channel[0].type) {
 604         /* Half-floats, floats, doubles */
 605         case UTIL_FORMAT_TYPE_FLOAT:
 606             switch (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0)) {
 607                 case 16:
 608                     /* XXX Supported only on RV350 and later. */
 609                     if (components > 2) {
 610                         result = R300_DATA_TYPE_FLT16_4;
 611                     } else {
 612                         result = R300_DATA_TYPE_FLT16_2;
 613                     }
 614                     break;
 615                 case 32:
 616                     result = R300_DATA_TYPE_FLOAT_1 + (components - 1);
 617                     break;
 618                 default:
 619                     debug_printf("r300: Bad format %s in %s:%d\n",
 620                         util_format_name(format), __FUNCTION__, __LINE__);
 621                     assert(0);
 622             }
 623             break;
 624         /* Unsigned ints */
 625         case UTIL_FORMAT_TYPE_UNSIGNED:
 626         /* Signed ints */
 627         case UTIL_FORMAT_TYPE_SIGNED:
 628             switch (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0)) {
 629                 case 8:
 630                     result = R300_DATA_TYPE_BYTE;
 631                     break;
 632                 case 16:
 633                     if (components > 2) {
 634                         result = R300_DATA_TYPE_SHORT_4;
 635                     } else {
 636                         result = R300_DATA_TYPE_SHORT_2;
 637                     }
 638                     break;
 639                 default:
 640                     debug_printf("r300: Bad format %s in %s:%d\n",
 641                         util_format_name(format), __FUNCTION__, __LINE__);
 642                     debug_printf("r300: util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0) == %d\n",
 643                         util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0));
 644                     assert(0);
 645             }
 646             break;
 647         default:
 648             debug_printf("r300: Bad format %s in %s:%d\n",
 649                 util_format_name(format), __FUNCTION__, __LINE__);
 650             assert(0);
 651     }
 652
 653     if (desc->channel[0].type == UTIL_FORMAT_TYPE_SIGNED) {
 654         result |= R300_SIGNED;
 655     }
 656     if (desc->channel[0].normalized) {
 657         result |= R300_NORMALIZE;
 658     }
 659
 660     return result;
 661 }
 662
 663 static INLINE uint16_t
 664 r300_translate_vertex_data_swizzle(enum pipe_format format) {
 665     const struct util_format_description *desc = util_format_description(format);
 666     unsigned swizzle[4], i;
 667
 668     assert(format);
 669
 670     if (desc->layout != UTIL_FORMAT_LAYOUT_ARITH &&
 671         desc->layout != UTIL_FORMAT_LAYOUT_ARRAY) {
 672         debug_printf("r300: Bad format %s in %s:%d\n",
 673             util_format_name(format), __FUNCTION__, __LINE__);
 674         return 0;
 675     }
 676
 677     /* Swizzles for 8bits formats are in the reversed order, not sure why. */
 678     if (desc->channel[0].size == 8) {
 679         for (i = 0; i < 4; i++) {
 680             if (desc->swizzle[i] <= 3) {
 681                 swizzle[i] = 3 - desc->swizzle[i];
 682             } else {
 683                 swizzle[i] = desc->swizzle[i];
 684             }
 685         }
 686     } else {
 687         for (i = 0; i < 4; i++) {
 688             swizzle[i] = desc->swizzle[i];
 689         }
 690     }
 691
 692     return ((swizzle[0] << R300_SWIZZLE_SELECT_X_SHIFT) |
 693             (swizzle[1] << R300_SWIZZLE_SELECT_Y_SHIFT) |
 694             (swizzle[2] << R300_SWIZZLE_SELECT_Z_SHIFT) |
 695             (swizzle[3] << R300_SWIZZLE_SELECT_W_SHIFT) |
 696             (0xf << R300_WRITE_ENA_SHIFT));
 697 }
 698
 699 #endif /* R300_STATE_INLINES_H */