src/gallium/state_trackers/xa/xa_tgsi.c

   1 /**********************************************************
   2  * Copyright 2009-2011 VMware, Inc. All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  *********************************************************
  25  * Authors:
  26  * Zack Rusin <zackr-at-vmware-dot-com>
  27  */
  28 #include "xa_priv.h"
  29
  30 #include "pipe/p_format.h"
  31 #include "pipe/p_context.h"
  32 #include "pipe/p_state.h"
  33 #include "pipe/p_shader_tokens.h"
  34
  35 #include "util/u_memory.h"
  36
  37 #include "tgsi/tgsi_ureg.h"
  38
  39 #include "cso_cache/cso_context.h"
  40 #include "cso_cache/cso_hash.h"
  41
  42 /* Vertex shader:
  43  * IN[0]    = vertex pos
  44  * IN[1]    = src tex coord | solid fill color
  45  * IN[2]    = mask tex coord
  46  * IN[3]    = dst tex coord
  47  * CONST[0] = (2/dst_width, 2/dst_height, 1, 1)
  48  * CONST[1] = (-1, -1, 0, 0)
  49  *
  50  * OUT[0]   = vertex pos
  51  * OUT[1]   = src tex coord | solid fill color
  52  * OUT[2]   = mask tex coord
  53  * OUT[3]   = dst tex coord
  54  */
  55
  56 /* Fragment shader:
  57  * SAMP[0]  = src
  58  * SAMP[1]  = mask
  59  * SAMP[2]  = dst
  60  * IN[0]    = pos src | solid fill color
  61  * IN[1]    = pos mask
  62  * IN[2]    = pos dst
  63  * CONST[0] = (0, 0, 0, 1)
  64  *
  65  * OUT[0] = color
  66  */
  67
  68 static void
  69 print_fs_traits(int fs_traits)
  70 {
  71     const char *strings[] = {
  72         "FS_COMPOSITE",         /* = 1 << 0, */
  73         "FS_MASK",              /* = 1 << 1, */
  74         "FS_SOLID_FILL",        /* = 1 << 2, */
  75         "FS_LINGRAD_FILL",      /* = 1 << 3, */
  76         "FS_RADGRAD_FILL",      /* = 1 << 4, */
  77         "FS_CA_FULL",           /* = 1 << 5, *//* src.rgba * mask.rgba */
  78         "FS_CA_SRCALPHA",       /* = 1 << 6, *//* src.aaaa * mask.rgba */
  79         "FS_YUV",               /* = 1 << 7, */
  80         "FS_SRC_REPEAT_NONE",   /* = 1 << 8, */
  81         "FS_MASK_REPEAT_NONE",  /* = 1 << 9, */
  82         "FS_SRC_SWIZZLE_RGB",   /* = 1 << 10, */
  83         "FS_MASK_SWIZZLE_RGB",  /* = 1 << 11, */
  84         "FS_SRC_SET_ALPHA",     /* = 1 << 12, */
  85         "FS_MASK_SET_ALPHA",    /* = 1 << 13, */
  86         "FS_SRC_LUMINANCE",     /* = 1 << 14, */
  87         "FS_MASK_LUMINANCE",    /* = 1 << 15, */
  88         "FS_DST_LUMINANCE",     /* = 1 << 15, */
  89     };
  90     int i, k;
  91
  92     debug_printf("%s: ", __func__);
  93
  94     for (i = 0, k = 1; k < (1 << 16); i++, k <<= 1) {
  95         if (fs_traits & k)
  96             debug_printf("%s, ", strings[i]);
  97     }
  98
  99     debug_printf("\n");
 100 }
 101
 102 struct xa_shaders {
 103     struct xa_context *r;
 104
 105     struct cso_hash *vs_hash;
 106     struct cso_hash *fs_hash;
 107 };
 108
 109 static inline void
 110 src_in_mask(struct ureg_program *ureg,
 111             struct ureg_dst dst,
 112             struct ureg_src src,
 113             struct ureg_src mask,
 114             unsigned component_alpha, unsigned mask_luminance)
 115 {
 116     if (component_alpha == FS_CA_FULL) {
 117         ureg_MUL(ureg, dst, src, mask);
 118     } else if (component_alpha == FS_CA_SRCALPHA) {
 119         ureg_MUL(ureg, dst, ureg_scalar(src, TGSI_SWIZZLE_W), mask);
 120     } else {
 121         if (mask_luminance)
 122             ureg_MUL(ureg, dst, src, ureg_scalar(mask, TGSI_SWIZZLE_X));
 123         else
 124             ureg_MUL(ureg, dst, src, ureg_scalar(mask, TGSI_SWIZZLE_W));
 125     }
 126 }
 127
 128 static struct ureg_src
 129 vs_normalize_coords(struct ureg_program *ureg,
 130                     struct ureg_src coords,
 131                     struct ureg_src const0, struct ureg_src const1)
 132 {
 133     struct ureg_dst tmp = ureg_DECL_temporary(ureg);
 134     struct ureg_src ret;
 135
 136     ureg_MAD(ureg, tmp, coords, const0, const1);
 137     ret = ureg_src(tmp);
 138     ureg_release_temporary(ureg, tmp);
 139     return ret;
 140 }
 141
 142 static void
 143 linear_gradient(struct ureg_program *ureg,
 144                 struct ureg_dst out,
 145                 struct ureg_src pos,
 146                 struct ureg_src sampler,
 147                 struct ureg_src coords,
 148                 struct ureg_src const0124,
 149                 struct ureg_src matrow0,
 150                 struct ureg_src matrow1, struct ureg_src matrow2)
 151 {
 152     struct ureg_dst temp0 = ureg_DECL_temporary(ureg);
 153     struct ureg_dst temp1 = ureg_DECL_temporary(ureg);
 154     struct ureg_dst temp2 = ureg_DECL_temporary(ureg);
 155     struct ureg_dst temp3 = ureg_DECL_temporary(ureg);
 156     struct ureg_dst temp4 = ureg_DECL_temporary(ureg);
 157     struct ureg_dst temp5 = ureg_DECL_temporary(ureg);
 158
 159     ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY), pos);
 160     ureg_MOV(ureg,
 161              ureg_writemask(temp0, TGSI_WRITEMASK_Z),
 162              ureg_scalar(const0124, TGSI_SWIZZLE_Y));
 163
 164     ureg_DP3(ureg, temp1, matrow0, ureg_src(temp0));
 165     ureg_DP3(ureg, temp2, matrow1, ureg_src(temp0));
 166     ureg_DP3(ureg, temp3, matrow2, ureg_src(temp0));
 167     ureg_RCP(ureg, temp3, ureg_src(temp3));
 168     ureg_MUL(ureg, temp1, ureg_src(temp1), ureg_src(temp3));
 169     ureg_MUL(ureg, temp2, ureg_src(temp2), ureg_src(temp3));
 170
 171     ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_X), ureg_src(temp1));
 172     ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_Y), ureg_src(temp2));
 173
 174     ureg_MUL(ureg, temp0,
 175              ureg_scalar(coords, TGSI_SWIZZLE_Y),
 176              ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_Y));
 177     ureg_MAD(ureg, temp1,
 178              ureg_scalar(coords, TGSI_SWIZZLE_X),
 179              ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_X), ureg_src(temp0));
 180
 181     ureg_MUL(ureg, temp2, ureg_src(temp1), ureg_scalar(coords, TGSI_SWIZZLE_Z));
 182
 183     ureg_TEX(ureg, out, TGSI_TEXTURE_1D, ureg_src(temp2), sampler);
 184
 185     ureg_release_temporary(ureg, temp0);
 186     ureg_release_temporary(ureg, temp1);
 187     ureg_release_temporary(ureg, temp2);
 188     ureg_release_temporary(ureg, temp3);
 189     ureg_release_temporary(ureg, temp4);
 190     ureg_release_temporary(ureg, temp5);
 191 }
 192
 193 static void
 194 radial_gradient(struct ureg_program *ureg,
 195                 struct ureg_dst out,
 196                 struct ureg_src pos,
 197                 struct ureg_src sampler,
 198                 struct ureg_src coords,
 199                 struct ureg_src const0124,
 200                 struct ureg_src matrow0,
 201                 struct ureg_src matrow1, struct ureg_src matrow2)
 202 {
 203     struct ureg_dst temp0 = ureg_DECL_temporary(ureg);
 204     struct ureg_dst temp1 = ureg_DECL_temporary(ureg);
 205     struct ureg_dst temp2 = ureg_DECL_temporary(ureg);
 206     struct ureg_dst temp3 = ureg_DECL_temporary(ureg);
 207     struct ureg_dst temp4 = ureg_DECL_temporary(ureg);
 208     struct ureg_dst temp5 = ureg_DECL_temporary(ureg);
 209
 210     ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY), pos);
 211     ureg_MOV(ureg,
 212              ureg_writemask(temp0, TGSI_WRITEMASK_Z),
 213              ureg_scalar(const0124, TGSI_SWIZZLE_Y));
 214
 215     ureg_DP3(ureg, temp1, matrow0, ureg_src(temp0));
 216     ureg_DP3(ureg, temp2, matrow1, ureg_src(temp0));
 217     ureg_DP3(ureg, temp3, matrow2, ureg_src(temp0));
 218     ureg_RCP(ureg, temp3, ureg_src(temp3));
 219     ureg_MUL(ureg, temp1, ureg_src(temp1), ureg_src(temp3));
 220     ureg_MUL(ureg, temp2, ureg_src(temp2), ureg_src(temp3));
 221
 222     ureg_MOV(ureg, ureg_writemask(temp5, TGSI_WRITEMASK_X), ureg_src(temp1));
 223     ureg_MOV(ureg, ureg_writemask(temp5, TGSI_WRITEMASK_Y), ureg_src(temp2));
 224
 225     ureg_MUL(ureg, temp0, ureg_scalar(coords, TGSI_SWIZZLE_Y),
 226              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y));
 227     ureg_MAD(ureg, temp1,
 228              ureg_scalar(coords, TGSI_SWIZZLE_X),
 229              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X), ureg_src(temp0));
 230     ureg_ADD(ureg, temp1, ureg_src(temp1), ureg_src(temp1));
 231     ureg_MUL(ureg, temp3,
 232              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y),
 233              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y));
 234     ureg_MAD(ureg, temp4,
 235              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X),
 236              ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X), ureg_src(temp3));
 237     ureg_MOV(ureg, temp4, ureg_negate(ureg_src(temp4)));
 238     ureg_MUL(ureg, temp2, ureg_scalar(coords, TGSI_SWIZZLE_Z), ureg_src(temp4));
 239     ureg_MUL(ureg, temp0,
 240              ureg_scalar(const0124, TGSI_SWIZZLE_W), ureg_src(temp2));
 241     ureg_MUL(ureg, temp3, ureg_src(temp1), ureg_src(temp1));
 242     ureg_ADD(ureg, temp2, ureg_src(temp3), ureg_negate(ureg_src(temp0)));
 243     ureg_RSQ(ureg, temp2, ureg_abs(ureg_src(temp2)));
 244     ureg_RCP(ureg, temp2, ureg_src(temp2));
 245     ureg_ADD(ureg, temp1, ureg_src(temp2), ureg_negate(ureg_src(temp1)));
 246     ureg_ADD(ureg, temp0,
 247              ureg_scalar(coords, TGSI_SWIZZLE_Z),
 248              ureg_scalar(coords, TGSI_SWIZZLE_Z));
 249     ureg_RCP(ureg, temp0, ureg_src(temp0));
 250     ureg_MUL(ureg, temp2, ureg_src(temp1), ureg_src(temp0));
 251     ureg_TEX(ureg, out, TGSI_TEXTURE_1D, ureg_src(temp2), sampler);
 252
 253     ureg_release_temporary(ureg, temp0);
 254     ureg_release_temporary(ureg, temp1);
 255     ureg_release_temporary(ureg, temp2);
 256     ureg_release_temporary(ureg, temp3);
 257     ureg_release_temporary(ureg, temp4);
 258     ureg_release_temporary(ureg, temp5);
 259 }
 260
 261 static void *
 262 create_vs(struct pipe_context *pipe, unsigned vs_traits)
 263 {
 264     struct ureg_program *ureg;
 265     struct ureg_src src;
 266     struct ureg_dst dst;
 267     struct ureg_src const0, const1;
 268     boolean is_fill = (vs_traits & VS_FILL) != 0;
 269     boolean is_composite = (vs_traits & VS_COMPOSITE) != 0;
 270     boolean has_mask = (vs_traits & VS_MASK) != 0;
 271     boolean is_yuv = (vs_traits & VS_YUV) != 0;
 272     unsigned input_slot = 0;
 273
 274     ureg = ureg_create(PIPE_SHADER_VERTEX);
 275     if (ureg == NULL)
 276         return 0;
 277
 278     const0 = ureg_DECL_constant(ureg, 0);
 279     const1 = ureg_DECL_constant(ureg, 1);
 280
 281     /* it has to be either a fill or a composite op */
 282     debug_assert((is_fill ^ is_composite) ^ is_yuv);
 283
 284     src = ureg_DECL_vs_input(ureg, input_slot++);
 285     dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
 286     src = vs_normalize_coords(ureg, src, const0, const1);
 287     ureg_MOV(ureg, dst, src);
 288
 289     if (is_yuv) {
 290         src = ureg_DECL_vs_input(ureg, input_slot++);
 291         dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);
 292         ureg_MOV(ureg, dst, src);
 293     }
 294
 295     if (is_composite) {
 296         src = ureg_DECL_vs_input(ureg, input_slot++);
 297         dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);
 298         ureg_MOV(ureg, dst, src);
 299     }
 300
 301     if (is_fill) {
 302         src = ureg_DECL_vs_input(ureg, input_slot++);
 303         dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
 304         ureg_MOV(ureg, dst, src);
 305     }
 306
 307     if (has_mask) {
 308         src = ureg_DECL_vs_input(ureg, input_slot++);
 309         dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 1);
 310         ureg_MOV(ureg, dst, src);
 311     }
 312
 313     ureg_END(ureg);
 314
 315     return ureg_create_shader_and_destroy(ureg, pipe);
 316 }
 317
 318 static void *
 319 create_yuv_shader(struct pipe_context *pipe, struct ureg_program *ureg)
 320 {
 321     struct ureg_src y_sampler, u_sampler, v_sampler;
 322     struct ureg_src pos;
 323     struct ureg_src matrow0, matrow1, matrow2, matrow3;
 324     struct ureg_dst y, u, v, rgb;
 325     struct ureg_dst out = ureg_DECL_output(ureg,
 326                                            TGSI_SEMANTIC_COLOR,
 327                                            0);
 328
 329     pos = ureg_DECL_fs_input(ureg,
 330                              TGSI_SEMANTIC_GENERIC, 0,
 331                              TGSI_INTERPOLATE_PERSPECTIVE);
 332
 333     rgb = ureg_DECL_temporary(ureg);
 334     y = ureg_DECL_temporary(ureg);
 335     u = ureg_DECL_temporary(ureg);
 336     v = ureg_DECL_temporary(ureg);
 337
 338     y_sampler = ureg_DECL_sampler(ureg, 0);
 339     u_sampler = ureg_DECL_sampler(ureg, 1);
 340     v_sampler = ureg_DECL_sampler(ureg, 2);
 341
 342     ureg_DECL_sampler_view(ureg, 0, TGSI_TEXTURE_2D,
 343                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 344                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 345     ureg_DECL_sampler_view(ureg, 1, TGSI_TEXTURE_2D,
 346                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 347                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 348     ureg_DECL_sampler_view(ureg, 2, TGSI_TEXTURE_2D,
 349                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 350                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 351
 352     matrow0 = ureg_DECL_constant(ureg, 0);
 353     matrow1 = ureg_DECL_constant(ureg, 1);
 354     matrow2 = ureg_DECL_constant(ureg, 2);
 355     matrow3 = ureg_DECL_constant(ureg, 3);
 356
 357     ureg_TEX(ureg, y, TGSI_TEXTURE_2D, pos, y_sampler);
 358     ureg_TEX(ureg, u, TGSI_TEXTURE_2D, pos, u_sampler);
 359     ureg_TEX(ureg, v, TGSI_TEXTURE_2D, pos, v_sampler);
 360
 361     ureg_MOV(ureg, rgb, matrow3);
 362     ureg_MAD(ureg, rgb,
 363              ureg_scalar(ureg_src(y), TGSI_SWIZZLE_X), matrow0, ureg_src(rgb));
 364     ureg_MAD(ureg, rgb,
 365              ureg_scalar(ureg_src(u), TGSI_SWIZZLE_X), matrow1, ureg_src(rgb));
 366     ureg_MAD(ureg, rgb,
 367              ureg_scalar(ureg_src(v), TGSI_SWIZZLE_X), matrow2, ureg_src(rgb));
 368
 369     ureg_MOV(ureg, out, ureg_src(rgb));
 370
 371     ureg_release_temporary(ureg, rgb);
 372     ureg_release_temporary(ureg, y);
 373     ureg_release_temporary(ureg, u);
 374     ureg_release_temporary(ureg, v);
 375
 376     ureg_END(ureg);
 377
 378     return ureg_create_shader_and_destroy(ureg, pipe);
 379 }
 380
 381 static inline void
 382 xrender_tex(struct ureg_program *ureg,
 383             struct ureg_dst dst,
 384             struct ureg_src coords,
 385             struct ureg_src sampler,
 386             struct ureg_src imm0,
 387             boolean repeat_none, boolean swizzle, boolean set_alpha)
 388 {
 389     if (repeat_none) {
 390         struct ureg_dst tmp0 = ureg_DECL_temporary(ureg);
 391         struct ureg_dst tmp1 = ureg_DECL_temporary(ureg);
 392
 393         ureg_SGT(ureg, tmp1, ureg_swizzle(coords,
 394                                           TGSI_SWIZZLE_X,
 395                                           TGSI_SWIZZLE_Y,
 396                                           TGSI_SWIZZLE_X,
 397                                           TGSI_SWIZZLE_Y), ureg_scalar(imm0,
 398                                                                        TGSI_SWIZZLE_X));
 399         ureg_SLT(ureg, tmp0,
 400                  ureg_swizzle(coords, TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
 401                               TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y), ureg_scalar(imm0,
 402                                                                            TGSI_SWIZZLE_W));
 403         ureg_MIN(ureg, tmp0, ureg_src(tmp0), ureg_src(tmp1));
 404         ureg_MIN(ureg, tmp0, ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_X),
 405                  ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_Y));
 406         ureg_TEX(ureg, tmp1, TGSI_TEXTURE_2D, coords, sampler);
 407         if (swizzle)
 408             ureg_MOV(ureg, tmp1, ureg_swizzle(ureg_src(tmp1),
 409                                               TGSI_SWIZZLE_Z,
 410                                               TGSI_SWIZZLE_Y, TGSI_SWIZZLE_X,
 411                                               TGSI_SWIZZLE_W));
 412         if (set_alpha)
 413             ureg_MOV(ureg,
 414                      ureg_writemask(tmp1, TGSI_WRITEMASK_W),
 415                      ureg_scalar(imm0, TGSI_SWIZZLE_W));
 416         ureg_MUL(ureg, dst, ureg_src(tmp1), ureg_src(tmp0));
 417         ureg_release_temporary(ureg, tmp0);
 418         ureg_release_temporary(ureg, tmp1);
 419     } else {
 420         if (swizzle) {
 421             struct ureg_dst tmp = ureg_DECL_temporary(ureg);
 422
 423             ureg_TEX(ureg, tmp, TGSI_TEXTURE_2D, coords, sampler);
 424             ureg_MOV(ureg, dst, ureg_swizzle(ureg_src(tmp),
 425                                              TGSI_SWIZZLE_Z,
 426                                              TGSI_SWIZZLE_Y, TGSI_SWIZZLE_X,
 427                                              TGSI_SWIZZLE_W));
 428             ureg_release_temporary(ureg, tmp);
 429         } else {
 430             ureg_TEX(ureg, dst, TGSI_TEXTURE_2D, coords, sampler);
 431         }
 432         if (set_alpha)
 433             ureg_MOV(ureg,
 434                      ureg_writemask(dst, TGSI_WRITEMASK_W),
 435                      ureg_scalar(imm0, TGSI_SWIZZLE_W));
 436     }
 437 }
 438
 439 static void *
 440 create_fs(struct pipe_context *pipe, unsigned fs_traits)
 441 {
 442     struct ureg_program *ureg;
 443     struct ureg_src /*dst_sampler, */ src_sampler, mask_sampler;
 444     struct ureg_src /*dst_pos, */ src_input, mask_pos;
 445     struct ureg_dst src, mask;
 446     struct ureg_dst out;
 447     struct ureg_src imm0 = { 0 };
 448     unsigned has_mask = (fs_traits & FS_MASK) != 0;
 449     unsigned is_fill = (fs_traits & FS_FILL) != 0;
 450     unsigned is_composite = (fs_traits & FS_COMPOSITE) != 0;
 451     unsigned is_solid = (fs_traits & FS_SOLID_FILL) != 0;
 452     unsigned is_lingrad = (fs_traits & FS_LINGRAD_FILL) != 0;
 453     unsigned is_radgrad = (fs_traits & FS_RADGRAD_FILL) != 0;
 454     unsigned comp_alpha_mask = fs_traits & FS_COMPONENT_ALPHA;
 455     unsigned is_yuv = (fs_traits & FS_YUV) != 0;
 456     unsigned src_repeat_none = (fs_traits & FS_SRC_REPEAT_NONE) != 0;
 457     unsigned mask_repeat_none = (fs_traits & FS_MASK_REPEAT_NONE) != 0;
 458     unsigned src_swizzle = (fs_traits & FS_SRC_SWIZZLE_RGB) != 0;
 459     unsigned mask_swizzle = (fs_traits & FS_MASK_SWIZZLE_RGB) != 0;
 460     unsigned src_set_alpha = (fs_traits & FS_SRC_SET_ALPHA) != 0;
 461     unsigned mask_set_alpha = (fs_traits & FS_MASK_SET_ALPHA) != 0;
 462     unsigned src_luminance = (fs_traits & FS_SRC_LUMINANCE) != 0;
 463     unsigned mask_luminance = (fs_traits & FS_MASK_LUMINANCE) != 0;
 464     unsigned dst_luminance = (fs_traits & FS_DST_LUMINANCE) != 0;
 465
 466 #if 0
 467     print_fs_traits(fs_traits);
 468 #else
 469     (void)print_fs_traits;
 470 #endif
 471
 472     ureg = ureg_create(PIPE_SHADER_FRAGMENT);
 473     if (ureg == NULL)
 474         return 0;
 475
 476     /* it has to be either a fill, a composite op or a yuv conversion */
 477     debug_assert((is_fill ^ is_composite) ^ is_yuv);
 478     (void)is_yuv;
 479
 480     out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
 481
 482     if (src_repeat_none || mask_repeat_none ||
 483         src_set_alpha || mask_set_alpha || src_luminance) {
 484         imm0 = ureg_imm4f(ureg, 0, 0, 0, 1);
 485     }
 486     if (is_composite) {
 487         src_sampler = ureg_DECL_sampler(ureg, 0);
 488         ureg_DECL_sampler_view(ureg, 0, TGSI_TEXTURE_2D,
 489                                TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 490                                TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 491         src_input = ureg_DECL_fs_input(ureg,
 492                                        TGSI_SEMANTIC_GENERIC, 0,
 493                                        TGSI_INTERPOLATE_PERSPECTIVE);
 494     } else if (is_fill) {
 495         if (is_solid)
 496             src_input = ureg_DECL_fs_input(ureg,
 497                                            TGSI_SEMANTIC_COLOR, 0,
 498                                            TGSI_INTERPOLATE_PERSPECTIVE);
 499         else
 500             src_input = ureg_DECL_fs_input(ureg,
 501                                            TGSI_SEMANTIC_POSITION, 0,
 502                                            TGSI_INTERPOLATE_PERSPECTIVE);
 503     } else {
 504         debug_assert(is_yuv);
 505         return create_yuv_shader(pipe, ureg);
 506     }
 507
 508     if (has_mask) {
 509         mask_sampler = ureg_DECL_sampler(ureg, 1);
 510         ureg_DECL_sampler_view(ureg, 1, TGSI_TEXTURE_2D,
 511                                TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 512                                TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 513         mask_pos = ureg_DECL_fs_input(ureg,
 514                                       TGSI_SEMANTIC_GENERIC, 1,
 515                                       TGSI_INTERPOLATE_PERSPECTIVE);
 516     }
 517 #if 0                           /* unused right now */
 518     dst_sampler = ureg_DECL_sampler(ureg, 2);
 519     ureg_DECL_sampler_view(ureg, 2, TGSI_TEXTURE_2D,
 520                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT,
 521                            TGSI_RETURN_TYPE_FLOAT, TGSI_RETURN_TYPE_FLOAT);
 522     dst_pos = ureg_DECL_fs_input(ureg,
 523                                  TGSI_SEMANTIC_POSITION, 2,
 524                                  TGSI_INTERPOLATE_PERSPECTIVE);
 525 #endif
 526
 527     if (is_composite) {
 528         if (has_mask || src_luminance || dst_luminance)
 529             src = ureg_DECL_temporary(ureg);
 530         else
 531             src = out;
 532         xrender_tex(ureg, src, src_input, src_sampler, imm0,
 533                     src_repeat_none, src_swizzle, src_set_alpha);
 534     } else if (is_fill) {
 535         if (is_solid) {
 536             if (has_mask || src_luminance || dst_luminance)
 537                 src = ureg_dst(src_input);
 538             else
 539                 ureg_MOV(ureg, out, src_input);
 540         } else if (is_lingrad || is_radgrad) {
 541             struct ureg_src coords, const0124, matrow0, matrow1, matrow2;
 542
 543             if (has_mask || src_luminance || dst_luminance)
 544                 src = ureg_DECL_temporary(ureg);
 545             else
 546                 src = out;
 547
 548             coords = ureg_DECL_constant(ureg, 0);
 549             const0124 = ureg_DECL_constant(ureg, 1);
 550             matrow0 = ureg_DECL_constant(ureg, 2);
 551             matrow1 = ureg_DECL_constant(ureg, 3);
 552             matrow2 = ureg_DECL_constant(ureg, 4);
 553
 554             if (is_lingrad) {
 555                 linear_gradient(ureg, src,
 556                                 src_input, src_sampler,
 557                                 coords, const0124, matrow0, matrow1, matrow2);
 558             } else if (is_radgrad) {
 559                 radial_gradient(ureg, src,
 560                                 src_input, src_sampler,
 561                                 coords, const0124, matrow0, matrow1, matrow2);
 562             }
 563         } else
 564             debug_assert(!"Unknown fill type!");
 565     }
 566     if (src_luminance) {
 567         ureg_MOV(ureg, src, ureg_scalar(ureg_src(src), TGSI_SWIZZLE_X));
 568         ureg_MOV(ureg, ureg_writemask(src, TGSI_WRITEMASK_XYZ),
 569                  ureg_scalar(imm0, TGSI_SWIZZLE_X));
 570         if (!has_mask && !dst_luminance)
 571             ureg_MOV(ureg, out, ureg_src(src));
 572     }
 573
 574     if (has_mask) {
 575         mask = ureg_DECL_temporary(ureg);
 576         xrender_tex(ureg, mask, mask_pos, mask_sampler, imm0,
 577                     mask_repeat_none, mask_swizzle, mask_set_alpha);
 578         /* src IN mask */
 579
 580         src_in_mask(ureg, (dst_luminance) ? src : out, ureg_src(src),
 581                     ureg_src(mask),
 582                     comp_alpha_mask, mask_luminance);
 583
 584         ureg_release_temporary(ureg, mask);
 585     }
 586
 587     if (dst_luminance) {
 588         /*
 589          * Make sure the alpha channel goes into the output L8 surface.
 590          */
 591         ureg_MOV(ureg, out, ureg_scalar(ureg_src(src), TGSI_SWIZZLE_W));
 592     }
 593
 594     ureg_END(ureg);
 595
 596     return ureg_create_shader_and_destroy(ureg, pipe);
 597 }
 598
 599 struct xa_shaders *
 600 xa_shaders_create(struct xa_context *r)
 601 {
 602     struct xa_shaders *sc = CALLOC_STRUCT(xa_shaders);
 603
 604     sc->r = r;
 605     sc->vs_hash = cso_hash_create();
 606     sc->fs_hash = cso_hash_create();
 607
 608     return sc;
 609 }
 610
 611 static void
 612 cache_destroy(struct cso_context *cso,
 613               struct cso_hash *hash, unsigned processor)
 614 {
 615     struct cso_hash_iter iter = cso_hash_first_node(hash);
 616
 617     while (!cso_hash_iter_is_null(iter)) {
 618         void *shader = (void *)cso_hash_iter_data(iter);
 619
 620         if (processor == PIPE_SHADER_FRAGMENT) {
 621             cso_delete_fragment_shader(cso, shader);
 622         } else if (processor == PIPE_SHADER_VERTEX) {
 623             cso_delete_vertex_shader(cso, shader);
 624         }
 625         iter = cso_hash_erase(hash, iter);
 626     }
 627     cso_hash_delete(hash);
 628 }
 629
 630 void
 631 xa_shaders_destroy(struct xa_shaders *sc)
 632 {
 633     cache_destroy(sc->r->cso, sc->vs_hash, PIPE_SHADER_VERTEX);
 634     cache_destroy(sc->r->cso, sc->fs_hash, PIPE_SHADER_FRAGMENT);
 635
 636     FREE(sc);
 637 }
 638
 639 static inline void *
 640 shader_from_cache(struct pipe_context *pipe,
 641                   unsigned type, struct cso_hash *hash, unsigned key)
 642 {
 643     void *shader = 0;
 644
 645     struct cso_hash_iter iter = cso_hash_find(hash, key);
 646
 647     if (cso_hash_iter_is_null(iter)) {
 648         if (type == PIPE_SHADER_VERTEX)
 649             shader = create_vs(pipe, key);
 650         else
 651             shader = create_fs(pipe, key);
 652         cso_hash_insert(hash, key, shader);
 653     } else
 654         shader = (void *)cso_hash_iter_data(iter);
 655
 656     return shader;
 657 }
 658
 659 struct xa_shader
 660 xa_shaders_get(struct xa_shaders *sc, unsigned vs_traits, unsigned fs_traits)
 661 {
 662     struct xa_shader shader = { NULL, NULL };
 663     void *vs, *fs;
 664
 665     vs = shader_from_cache(sc->r->pipe, PIPE_SHADER_VERTEX,
 666                            sc->vs_hash, vs_traits);
 667     fs = shader_from_cache(sc->r->pipe, PIPE_SHADER_FRAGMENT,
 668                            sc->fs_hash, fs_traits);
 669
 670     debug_assert(vs && fs);
 671     if (!vs || !fs)
 672         return shader;
 673
 674     shader.vs = vs;
 675     shader.fs = fs;
 676
 677     return shader;
 678 }