src/mesa/drivers/dri/i965/brw_wm_fp.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/macros.h"
  35 #include "main/enums.h"
  36 #include "brw_context.h"
  37 #include "brw_wm.h"
  38 #include "brw_util.h"
  39
  40 #include "shader/prog_parameter.h"
  41 #include "shader/prog_print.h"
  42 #include "shader/prog_statevars.h"
  43
  44
  45 #define FIRST_INTERNAL_TEMP MAX_NV_FRAGMENT_PROGRAM_TEMPS
  46
  47 #define X    0
  48 #define Y    1
  49 #define Z    2
  50 #define W    3
  51
  52
  53 static const char *wm_opcode_strings[] = {
  54    "PIXELXY",
  55    "DELTAXY",
  56    "PIXELW",
  57    "LINTERP",
  58    "PINTERP",
  59    "CINTERP",
  60    "WPOSXY",
  61    "FB_WRITE"
  62 };
  63
  64 #if 0
  65 static const char *wm_file_strings[] = {
  66    "PAYLOAD"
  67 };
  68 #endif
  69
  70
  71 /***********************************************************************
  72  * Source regs
  73  */
  74
  75 static struct prog_src_register src_reg(GLuint file, GLuint idx)
  76 {
  77    struct prog_src_register reg;
  78    reg.File = file;
  79    reg.Index = idx;
  80    reg.Swizzle = SWIZZLE_NOOP;
  81    reg.RelAddr = 0;
  82    reg.NegateBase = 0;
  83    reg.Abs = 0;
  84    reg.NegateAbs = 0;
  85    return reg;
  86 }
  87
  88 static struct prog_src_register src_reg_from_dst(struct prog_dst_register dst)
  89 {
  90    return src_reg(dst.File, dst.Index);
  91 }
  92
  93 static struct prog_src_register src_undef( void )
  94 {
  95    return src_reg(PROGRAM_UNDEFINED, 0);
  96 }
  97
  98 static GLboolean src_is_undef(struct prog_src_register src)
  99 {
 100    return src.File == PROGRAM_UNDEFINED;
 101 }
 102
 103 static struct prog_src_register src_swizzle( struct prog_src_register reg, int x, int y, int z, int w )
 104 {
 105    reg.Swizzle = MAKE_SWIZZLE4(x,y,z,w);
 106    return reg;
 107 }
 108
 109 static struct prog_src_register src_swizzle1( struct prog_src_register reg, int x )
 110 {
 111    return src_swizzle(reg, x, x, x, x);
 112 }
 113
 114 static struct prog_src_register src_swizzle4( struct prog_src_register reg, uint swizzle )
 115 {
 116    reg.Swizzle = swizzle;
 117    return reg;
 118 }
 119
 120
 121 /***********************************************************************
 122  * Dest regs
 123  */
 124
 125 static struct prog_dst_register dst_reg(GLuint file, GLuint idx)
 126 {
 127    struct prog_dst_register reg;
 128    reg.File = file;
 129    reg.Index = idx;
 130    reg.WriteMask = WRITEMASK_XYZW;
 131    reg.RelAddr = 0;
 132    reg.CondMask = COND_TR;
 133    reg.CondSwizzle = 0;
 134    reg.CondSrc = 0;
 135    reg.pad = 0;
 136    return reg;
 137 }
 138
 139 static struct prog_dst_register dst_mask( struct prog_dst_register reg, int mask )
 140 {
 141    reg.WriteMask &= mask;
 142    return reg;
 143 }
 144
 145 static struct prog_dst_register dst_undef( void )
 146 {
 147    return dst_reg(PROGRAM_UNDEFINED, 0);
 148 }
 149
 150
 151
 152 static struct prog_dst_register get_temp( struct brw_wm_compile *c )
 153 {
 154    int bit = _mesa_ffs( ~c->fp_temp );
 155
 156    if (!bit) {
 157       _mesa_printf("%s: out of temporaries\n", __FILE__);
 158       exit(1);
 159    }
 160
 161    c->fp_temp |= 1<<(bit-1);
 162    return dst_reg(PROGRAM_TEMPORARY, FIRST_INTERNAL_TEMP+(bit-1));
 163 }
 164
 165
 166 static void release_temp( struct brw_wm_compile *c, struct prog_dst_register temp )
 167 {
 168    c->fp_temp &= ~(1 << (temp.Index - FIRST_INTERNAL_TEMP));
 169 }
 170
 171
 172 /***********************************************************************
 173  * Instructions
 174  */
 175
 176 static struct prog_instruction *get_fp_inst(struct brw_wm_compile *c)
 177 {
 178    return &c->prog_instructions[c->nr_fp_insns++];
 179 }
 180
 181 static struct prog_instruction *emit_insn(struct brw_wm_compile *c,
 182                                         const struct prog_instruction *inst0)
 183 {
 184    struct prog_instruction *inst = get_fp_inst(c);
 185    *inst = *inst0;
 186    return inst;
 187 }
 188
 189 static struct prog_instruction * emit_tex_op(struct brw_wm_compile *c,
 190                                        GLuint op,
 191                                        struct prog_dst_register dest,
 192                                        GLuint saturate,
 193                                        GLuint tex_src_unit,
 194                                        GLuint tex_src_target,
 195                                        GLuint tex_shadow,
 196                                        struct prog_src_register src0,
 197                                        struct prog_src_register src1,
 198                                        struct prog_src_register src2 )
 199 {
 200    struct prog_instruction *inst = get_fp_inst(c);
 201
 202    memset(inst, 0, sizeof(*inst));
 203
 204    inst->Opcode = op;
 205    inst->DstReg = dest;
 206    inst->SaturateMode = saturate;
 207    inst->TexSrcUnit = tex_src_unit;
 208    inst->TexSrcTarget = tex_src_target;
 209    inst->TexShadow = tex_shadow;
 210    inst->SrcReg[0] = src0;
 211    inst->SrcReg[1] = src1;
 212    inst->SrcReg[2] = src2;
 213    return inst;
 214 }
 215
 216
 217 static struct prog_instruction * emit_op(struct brw_wm_compile *c,
 218                                        GLuint op,
 219                                        struct prog_dst_register dest,
 220                                        GLuint saturate,
 221                                        struct prog_src_register src0,
 222                                        struct prog_src_register src1,
 223                                        struct prog_src_register src2 )
 224 {
 225    return emit_tex_op(c, op, dest, saturate,
 226                       0, 0, 0,  /* tex unit, target, shadow */
 227                       src0, src1, src2);
 228 }
 229
 230
 231
 232
 233 /***********************************************************************
 234  * Special instructions for interpolation and other tasks
 235  */
 236
 237 static struct prog_src_register get_pixel_xy( struct brw_wm_compile *c )
 238 {
 239    if (src_is_undef(c->pixel_xy)) {
 240       struct prog_dst_register pixel_xy = get_temp(c);
 241       struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 242
 243
 244       /* Emit the out calculations, and hold onto the results.  Use
 245        * two instructions as a temporary is required.
 246        */
 247       /* pixel_xy.xy = PIXELXY payload[0];
 248        */
 249       emit_op(c,
 250               WM_PIXELXY,
 251               dst_mask(pixel_xy, WRITEMASK_XY),
 252               0,
 253               payload_r0_depth,
 254               src_undef(),
 255               src_undef());
 256
 257       c->pixel_xy = src_reg_from_dst(pixel_xy);
 258    }
 259
 260    return c->pixel_xy;
 261 }
 262
 263 static struct prog_src_register get_delta_xy( struct brw_wm_compile *c )
 264 {
 265    if (src_is_undef(c->delta_xy)) {
 266       struct prog_dst_register delta_xy = get_temp(c);
 267       struct prog_src_register pixel_xy = get_pixel_xy(c);
 268       struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 269
 270       /* deltas.xy = DELTAXY pixel_xy, payload[0]
 271        */
 272       emit_op(c,
 273               WM_DELTAXY,
 274               dst_mask(delta_xy, WRITEMASK_XY),
 275               0,
 276               pixel_xy,
 277               payload_r0_depth,
 278               src_undef());
 279
 280       c->delta_xy = src_reg_from_dst(delta_xy);
 281    }
 282
 283    return c->delta_xy;
 284 }
 285
 286 static struct prog_src_register get_pixel_w( struct brw_wm_compile *c )
 287 {
 288    if (src_is_undef(c->pixel_w)) {
 289       struct prog_dst_register pixel_w = get_temp(c);
 290       struct prog_src_register deltas = get_delta_xy(c);
 291       struct prog_src_register interp_wpos = src_reg(PROGRAM_PAYLOAD, FRAG_ATTRIB_WPOS);
 292
 293       /* deltas.xyw = DELTAS2 deltas.xy, payload.interp_wpos.x
 294        */
 295       emit_op(c,
 296               WM_PIXELW,
 297               dst_mask(pixel_w, WRITEMASK_W),
 298               0,
 299               interp_wpos,
 300               deltas,
 301               src_undef());
 302
 303
 304       c->pixel_w = src_reg_from_dst(pixel_w);
 305    }
 306
 307    return c->pixel_w;
 308 }
 309
 310 static void emit_interp( struct brw_wm_compile *c,
 311                          GLuint idx )
 312 {
 313    struct prog_dst_register dst = dst_reg(PROGRAM_INPUT, idx);
 314    struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
 315    struct prog_src_register deltas = get_delta_xy(c);
 316
 317    /* Need to use PINTERP on attributes which have been
 318     * multiplied by 1/W in the SF program, and LINTERP on those
 319     * which have not:
 320     */
 321    switch (idx) {
 322    case FRAG_ATTRIB_WPOS:
 323       /* Have to treat wpos.xy specially:
 324        */
 325       emit_op(c,
 326               WM_WPOSXY,
 327               dst_mask(dst, WRITEMASK_XY),
 328               0,
 329               get_pixel_xy(c),
 330               src_undef(),
 331               src_undef());
 332
 333       dst = dst_mask(dst, WRITEMASK_ZW);
 334
 335       /* PROGRAM_INPUT.attr.xyzw = INTERP payload.interp[attr].x, deltas.xyw
 336        */
 337       emit_op(c,
 338               WM_LINTERP,
 339               dst,
 340               0,
 341               interp,
 342               deltas,
 343               src_undef());
 344       break;
 345    case FRAG_ATTRIB_COL0:
 346    case FRAG_ATTRIB_COL1:
 347       if (c->key.flat_shade) {
 348          emit_op(c,
 349                  WM_CINTERP,
 350                  dst,
 351                  0,
 352                  interp,
 353                  src_undef(),
 354                  src_undef());
 355       }
 356       else {
 357          emit_op(c,
 358                  WM_LINTERP,
 359                  dst,
 360                  0,
 361                  interp,
 362                  deltas,
 363                  src_undef());
 364       }
 365       break;
 366    case FRAG_ATTRIB_FOGC:
 367       /* The FOGC input is really special.  When a program uses glFogFragCoord,
 368        * the results returned are supposed to be (f,0,0,1).  But for Mesa GLSL,
 369        * the glFrontFacing and glPointCoord values are also stashed in FOGC.
 370        * So, write the interpolated fog value to X, then either 0, 1, or the
 371        * stashed values to Y, Z, W.  Note that this means that
 372        * glFogFragCoord.yzw can be wrong in those cases!
 373        */
 374
 375       /* Interpolate the fog coordinate */
 376       emit_op(c,
 377               WM_PINTERP,
 378               dst_mask(dst, WRITEMASK_X),
 379               0,
 380               interp,
 381               deltas,
 382               get_pixel_w(c));
 383
 384       /* Move the front facing value into FOGC.y if it's needed. */
 385       if (c->fp->program.UsesFrontFacing) {
 386          emit_op(c,
 387                  WM_PINTERP,
 388                  dst_mask(dst, WRITEMASK_Y),
 389                  0,
 390                  interp,
 391                  deltas,
 392                  get_pixel_w(c));
 393       } else {
 394          emit_op(c,
 395                  OPCODE_MOV,
 396                  dst_mask(dst, WRITEMASK_Y),
 397                  0,
 398                  src_swizzle1(interp, SWIZZLE_ZERO),
 399                  src_undef(),
 400                  src_undef());
 401       }
 402
 403       /* Should do the PointCoord thing here. */
 404       emit_op(c,
 405               OPCODE_MOV,
 406               dst_mask(dst, WRITEMASK_ZW),
 407               0,
 408               src_swizzle(interp,
 409                           SWIZZLE_ZERO,
 410                           SWIZZLE_ZERO,
 411                           SWIZZLE_ZERO,
 412                           SWIZZLE_ONE),
 413               src_undef(),
 414               src_undef());
 415       break;
 416    default:
 417       emit_op(c,
 418               WM_PINTERP,
 419               dst,
 420               0,
 421               interp,
 422               deltas,
 423               get_pixel_w(c));
 424       break;
 425    }
 426
 427    c->fp_interp_emitted |= 1<<idx;
 428 }
 429
 430 static void emit_ddx( struct brw_wm_compile *c,
 431         const struct prog_instruction *inst )
 432 {
 433     GLuint idx = inst->SrcReg[0].Index;
 434     struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
 435
 436     c->fp_deriv_emitted |= 1<<idx;
 437     emit_op(c,
 438             OPCODE_DDX,
 439             inst->DstReg,
 440             0,
 441             interp,
 442             get_pixel_w(c),
 443             src_undef());
 444 }
 445
 446 static void emit_ddy( struct brw_wm_compile *c,
 447         const struct prog_instruction *inst )
 448 {
 449     GLuint idx = inst->SrcReg[0].Index;
 450     struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
 451
 452     c->fp_deriv_emitted |= 1<<idx;
 453     emit_op(c,
 454             OPCODE_DDY,
 455             inst->DstReg,
 456             0,
 457             interp,
 458             get_pixel_w(c),
 459             src_undef());
 460 }
 461
 462 /***********************************************************************
 463  * Hacks to extend the program parameter and constant lists.
 464  */
 465
 466 /* Add the fog parameters to the parameter list of the original
 467  * program, rather than creating a new list.  Doesn't really do any
 468  * harm and it's not as if the parameter handling isn't a big hack
 469  * anyway.
 470  */
 471 static struct prog_src_register search_or_add_param5(struct brw_wm_compile *c,
 472                                                      GLint s0,
 473                                                      GLint s1,
 474                                                      GLint s2,
 475                                                      GLint s3,
 476                                                      GLint s4)
 477 {
 478    struct gl_program_parameter_list *paramList = c->fp->program.Base.Parameters;
 479    gl_state_index tokens[STATE_LENGTH];
 480    GLuint idx;
 481    tokens[0] = s0;
 482    tokens[1] = s1;
 483    tokens[2] = s2;
 484    tokens[3] = s3;
 485    tokens[4] = s4;
 486
 487    for (idx = 0; idx < paramList->NumParameters; idx++) {
 488       if (paramList->Parameters[idx].Type == PROGRAM_STATE_VAR &&
 489           memcmp(paramList->Parameters[idx].StateIndexes, tokens, sizeof(tokens)) == 0)
 490          return src_reg(PROGRAM_STATE_VAR, idx);
 491    }
 492
 493    idx = _mesa_add_state_reference( paramList, tokens );
 494
 495    return src_reg(PROGRAM_STATE_VAR, idx);
 496 }
 497
 498
 499 static struct prog_src_register search_or_add_const4f( struct brw_wm_compile *c,
 500                                                      GLfloat s0,
 501                                                      GLfloat s1,
 502                                                      GLfloat s2,
 503                                                      GLfloat s3)
 504 {
 505    struct gl_program_parameter_list *paramList = c->fp->program.Base.Parameters;
 506    GLfloat values[4];
 507    GLuint idx;
 508    GLuint swizzle;
 509
 510    values[0] = s0;
 511    values[1] = s1;
 512    values[2] = s2;
 513    values[3] = s3;
 514
 515    /* Have to search, otherwise multiple compilations will each grow
 516     * the parameter list.
 517     */
 518    for (idx = 0; idx < paramList->NumParameters; idx++) {
 519       if (paramList->Parameters[idx].Type == PROGRAM_CONSTANT &&
 520           memcmp(paramList->ParameterValues[idx], values, sizeof(values)) == 0)
 521
 522          /* XXX: this mimics the mesa bug which puts all constants and
 523           * parameters into the "PROGRAM_STATE_VAR" category:
 524           */
 525          return src_reg(PROGRAM_STATE_VAR, idx);
 526    }
 527
 528    idx = _mesa_add_unnamed_constant( paramList, values, 4, &swizzle );
 529    assert(swizzle == SWIZZLE_NOOP); /* Need to handle swizzle in reg setup */
 530    return src_reg(PROGRAM_STATE_VAR, idx);
 531 }
 532
 533
 534
 535 /***********************************************************************
 536  * Expand various instructions here to simpler forms.
 537  */
 538 static void precalc_dst( struct brw_wm_compile *c,
 539                                const struct prog_instruction *inst )
 540 {
 541    struct prog_src_register src0 = inst->SrcReg[0];
 542    struct prog_src_register src1 = inst->SrcReg[1];
 543    struct prog_dst_register dst = inst->DstReg;
 544
 545    if (dst.WriteMask & WRITEMASK_Y) {
 546       /* dst.y = mul src0.y, src1.y
 547        */
 548       emit_op(c,
 549               OPCODE_MUL,
 550               dst_mask(dst, WRITEMASK_Y),
 551               inst->SaturateMode,
 552               src0,
 553               src1,
 554               src_undef());
 555    }
 556
 557    if (dst.WriteMask & WRITEMASK_XZ) {
 558       struct prog_instruction *swz;
 559       GLuint z = GET_SWZ(src0.Swizzle, Z);
 560
 561       /* dst.xz = swz src0.1zzz
 562        */
 563       swz = emit_op(c,
 564                     OPCODE_SWZ,
 565                     dst_mask(dst, WRITEMASK_XZ),
 566                     inst->SaturateMode,
 567                     src_swizzle(src0, SWIZZLE_ONE, z, z, z),
 568                     src_undef(),
 569                     src_undef());
 570       /* Avoid letting negation flag of src0 affect our 1 constant. */
 571       swz->SrcReg[0].NegateBase &= ~NEGATE_X;
 572    }
 573    if (dst.WriteMask & WRITEMASK_W) {
 574       /* dst.w = mov src1.w
 575        */
 576       emit_op(c,
 577               OPCODE_MOV,
 578               dst_mask(dst, WRITEMASK_W),
 579               inst->SaturateMode,
 580               src1,
 581               src_undef(),
 582               src_undef());
 583    }
 584 }
 585
 586
 587 static void precalc_lit( struct brw_wm_compile *c,
 588                          const struct prog_instruction *inst )
 589 {
 590    struct prog_src_register src0 = inst->SrcReg[0];
 591    struct prog_dst_register dst = inst->DstReg;
 592
 593    if (dst.WriteMask & WRITEMASK_XW) {
 594       struct prog_instruction *swz;
 595
 596       /* dst.xw = swz src0.1111
 597        */
 598       swz = emit_op(c,
 599                     OPCODE_SWZ,
 600                     dst_mask(dst, WRITEMASK_XW),
 601                     0,
 602                     src_swizzle1(src0, SWIZZLE_ONE),
 603                     src_undef(),
 604                     src_undef());
 605       /* Avoid letting the negation flag of src0 affect our 1 constant. */
 606       swz->SrcReg[0].NegateBase = 0;
 607    }
 608
 609    if (dst.WriteMask & WRITEMASK_YZ) {
 610       emit_op(c,
 611               OPCODE_LIT,
 612               dst_mask(dst, WRITEMASK_YZ),
 613               inst->SaturateMode,
 614               src0,
 615               src_undef(),
 616               src_undef());
 617    }
 618 }
 619
 620
 621 /**
 622  * Some TEX instructions require extra code, cube map coordinate
 623  * normalization, or coordinate scaling for RECT textures, etc.
 624  * This function emits those extra instructions and the TEX
 625  * instruction itself.
 626  */
 627 static void precalc_tex( struct brw_wm_compile *c,
 628                          const struct prog_instruction *inst )
 629 {
 630    struct prog_src_register coord;
 631    struct prog_dst_register tmpcoord;
 632    const GLuint unit = c->fp->program.Base.SamplerUnits[inst->TexSrcUnit];
 633
 634    if (inst->TexSrcTarget == TEXTURE_CUBE_INDEX) {
 635        struct prog_instruction *out;
 636        struct prog_dst_register tmp0 = get_temp(c);
 637        struct prog_src_register tmp0src = src_reg_from_dst(tmp0);
 638        struct prog_dst_register tmp1 = get_temp(c);
 639        struct prog_src_register tmp1src = src_reg_from_dst(tmp1);
 640        struct prog_src_register src0 = inst->SrcReg[0];
 641
 642        /* find longest component of coord vector and normalize it */
 643        tmpcoord = get_temp(c);
 644        coord = src_reg_from_dst(tmpcoord);
 645
 646        /* tmpcoord = src0 (i.e.: coord = src0) */
 647        out = emit_op(c, OPCODE_MOV,
 648                      tmpcoord,
 649                      0,
 650                      src0,
 651                      src_undef(),
 652                      src_undef());
 653        out->SrcReg[0].NegateBase = 0;
 654        out->SrcReg[0].Abs = 1;
 655
 656        /* tmp0 = MAX(coord.X, coord.Y) */
 657        emit_op(c, OPCODE_MAX,
 658                tmp0,
 659                0,
 660                src_swizzle1(coord, X),
 661                src_swizzle1(coord, Y),
 662                src_undef());
 663
 664        /* tmp1 = MAX(tmp0, coord.Z) */
 665        emit_op(c, OPCODE_MAX,
 666                tmp1,
 667                0,
 668                tmp0src,
 669                src_swizzle1(coord, Z),
 670                src_undef());
 671
 672        /* tmp0 = 1 / tmp1 */
 673        emit_op(c, OPCODE_RCP,
 674                tmp0,
 675                0,
 676                tmp1src,
 677                src_undef(),
 678                src_undef());
 679
 680        /* tmpCoord = src0 * tmp0 */
 681        emit_op(c, OPCODE_MUL,
 682                tmpcoord,
 683                0,
 684                src0,
 685                tmp0src,
 686                src_undef());
 687
 688        release_temp(c, tmp0);
 689        release_temp(c, tmp1);
 690    }
 691    else if (inst->TexSrcTarget == TEXTURE_RECT_INDEX) {
 692       struct prog_src_register scale =
 693          search_or_add_param5( c,
 694                                STATE_INTERNAL,
 695                                STATE_TEXRECT_SCALE,
 696                                unit,
 697                                0,0 );
 698
 699       tmpcoord = get_temp(c);
 700
 701       /* coord.xy   = MUL inst->SrcReg[0], { 1/width, 1/height }
 702        */
 703       emit_op(c,
 704               OPCODE_MUL,
 705               tmpcoord,
 706               0,
 707               inst->SrcReg[0],
 708               scale,
 709               src_undef());
 710
 711       coord = src_reg_from_dst(tmpcoord);
 712    }
 713    else {
 714       coord = inst->SrcReg[0];
 715    }
 716
 717    /* Need to emit YUV texture conversions by hand.  Probably need to
 718     * do this here - the alternative is in brw_wm_emit.c, but the
 719     * conversion requires allocating a temporary variable which we
 720     * don't have the facility to do that late in the compilation.
 721     */
 722    if (c->key.yuvtex_mask & (1 << unit)) {
 723       /* convert ycbcr to RGBA */
 724       GLboolean  swap_uv = c->key.yuvtex_swap_mask & (1<<unit);
 725
 726       /*
 727          CONST C0 = { -.5, -.0625,  -.5, 1.164 }
 728          CONST C1 = { 1.596, -0.813, 2.018, -.391 }
 729          UYV     = TEX ...
 730          UYV.xyz = ADD UYV,     C0
 731          UYV.y   = MUL UYV.y,   C0.w
 732          if (UV swaped)
 733             RGB.xyz = MAD UYV.zzx, C1,   UYV.y
 734          else
 735             RGB.xyz = MAD UYV.xxz, C1,   UYV.y
 736          RGB.y   = MAD UYV.z,   C1.w, RGB.y
 737       */
 738       struct prog_dst_register dst = inst->DstReg;
 739       struct prog_dst_register tmp = get_temp(c);
 740       struct prog_src_register tmpsrc = src_reg_from_dst(tmp);
 741       struct prog_src_register C0 = search_or_add_const4f( c,  -.5, -.0625, -.5, 1.164 );
 742       struct prog_src_register C1 = search_or_add_const4f( c, 1.596, -0.813, 2.018, -.391 );
 743
 744       /* tmp     = TEX ...
 745        */
 746       emit_tex_op(c,
 747                   OPCODE_TEX,
 748                   tmp,
 749                   inst->SaturateMode,
 750                   unit,
 751                   inst->TexSrcTarget,
 752                   inst->TexShadow,
 753                   coord,
 754                   src_undef(),
 755                   src_undef());
 756
 757       /* tmp.xyz =  ADD TMP, C0
 758        */
 759       emit_op(c,
 760               OPCODE_ADD,
 761               dst_mask(tmp, WRITEMASK_XYZ),
 762               0,
 763               tmpsrc,
 764               C0,
 765               src_undef());
 766
 767       /* YUV.y   = MUL YUV.y, C0.w
 768        */
 769
 770       emit_op(c,
 771               OPCODE_MUL,
 772               dst_mask(tmp, WRITEMASK_Y),
 773               0,
 774               tmpsrc,
 775               src_swizzle1(C0, W),
 776               src_undef());
 777
 778       /*
 779        * if (UV swaped)
 780        *     RGB.xyz = MAD YUV.zzx, C1, YUV.y
 781        * else
 782        *     RGB.xyz = MAD YUV.xxz, C1, YUV.y
 783        */
 784
 785       emit_op(c,
 786               OPCODE_MAD,
 787               dst_mask(dst, WRITEMASK_XYZ),
 788               0,
 789               swap_uv?src_swizzle(tmpsrc, Z,Z,X,X):src_swizzle(tmpsrc, X,X,Z,Z),
 790               C1,
 791               src_swizzle1(tmpsrc, Y));
 792
 793       /*  RGB.y   = MAD YUV.z, C1.w, RGB.y
 794        */
 795       emit_op(c,
 796               OPCODE_MAD,
 797               dst_mask(dst, WRITEMASK_Y),
 798               0,
 799               src_swizzle1(tmpsrc, Z),
 800               src_swizzle1(C1, W),
 801               src_swizzle1(src_reg_from_dst(dst), Y));
 802
 803       release_temp(c, tmp);
 804    }
 805    else {
 806       /* ordinary RGBA tex instruction */
 807       emit_tex_op(c,
 808                   OPCODE_TEX,
 809                   inst->DstReg,
 810                   inst->SaturateMode,
 811                   unit,
 812                   inst->TexSrcTarget,
 813                   inst->TexShadow,
 814                   coord,
 815                   src_undef(),
 816                   src_undef());
 817    }
 818
 819    /* For GL_EXT_texture_swizzle: */
 820    if (c->key.tex_swizzles[unit] != SWIZZLE_NOOP) {
 821       /* swizzle the result of the TEX instruction */
 822       struct prog_src_register tmpsrc = src_reg_from_dst(inst->DstReg);
 823       emit_op(c, OPCODE_SWZ,
 824               inst->DstReg,
 825               SATURATE_OFF, /* saturate already done above */
 826               src_swizzle4(tmpsrc, c->key.tex_swizzles[unit]),
 827               src_undef(),
 828               src_undef());
 829    }
 830
 831    if ((inst->TexSrcTarget == TEXTURE_RECT_INDEX) ||
 832        (inst->TexSrcTarget == TEXTURE_CUBE_INDEX))
 833       release_temp(c, tmpcoord);
 834 }
 835
 836
 837 static GLboolean projtex( struct brw_wm_compile *c,
 838                           const struct prog_instruction *inst )
 839 {
 840    struct prog_src_register src = inst->SrcReg[0];
 841
 842    /* Only try to detect the simplest cases.  Could detect (later)
 843     * cases where we are trying to emit code like RCP {1.0}, MUL x,
 844     * {1.0}, and so on.
 845     *
 846     * More complex cases than this typically only arise from
 847     * user-provided fragment programs anyway:
 848     */
 849    if (inst->TexSrcTarget == TEXTURE_CUBE_INDEX)
 850       return 0;  /* ut2004 gun rendering !?! */
 851    else if (src.File == PROGRAM_INPUT &&
 852             GET_SWZ(src.Swizzle, W) == W &&
 853            (c->key.projtex_mask & (1<<(src.Index + FRAG_ATTRIB_WPOS - FRAG_ATTRIB_TEX0))) == 0)
 854       return 0;
 855    else
 856       return 1;
 857 }
 858
 859
 860 static void precalc_txp( struct brw_wm_compile *c,
 861                                const struct prog_instruction *inst )
 862 {
 863    struct prog_src_register src0 = inst->SrcReg[0];
 864
 865    if (projtex(c, inst)) {
 866       struct prog_dst_register tmp = get_temp(c);
 867       struct prog_instruction tmp_inst;
 868
 869       /* tmp0.w = RCP inst.arg[0][3]
 870        */
 871       emit_op(c,
 872               OPCODE_RCP,
 873               dst_mask(tmp, WRITEMASK_W),
 874               0,
 875               src_swizzle1(src0, GET_SWZ(src0.Swizzle, W)),
 876               src_undef(),
 877               src_undef());
 878
 879       /* tmp0.xyz =  MUL inst.arg[0], tmp0.wwww
 880        */
 881       emit_op(c,
 882               OPCODE_MUL,
 883               dst_mask(tmp, WRITEMASK_XYZ),
 884               0,
 885               src0,
 886               src_swizzle1(src_reg_from_dst(tmp), W),
 887               src_undef());
 888
 889       /* dst = precalc(TEX tmp0)
 890        */
 891       tmp_inst = *inst;
 892       tmp_inst.SrcReg[0] = src_reg_from_dst(tmp);
 893       precalc_tex(c, &tmp_inst);
 894
 895       release_temp(c, tmp);
 896    }
 897    else
 898    {
 899       /* dst = precalc(TEX src0)
 900        */
 901       precalc_tex(c, inst);
 902    }
 903 }
 904
 905
 906
 907 static void emit_fb_write( struct brw_wm_compile *c )
 908 {
 909    struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 910    struct prog_src_register outdepth = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_DEPTH);
 911    struct prog_src_register outcolor;
 912    GLuint i;
 913
 914    struct prog_instruction *inst, *last_inst;
 915    struct brw_context *brw = c->func.brw;
 916
 917    /* The inst->Aux field is used for FB write target and the EOT marker */
 918
 919    if (brw->state.nr_color_regions > 1) {
 920       for (i = 0 ; i < brw->state.nr_color_regions; i++) {
 921          outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i);
 922          last_inst = inst = emit_op(c,
 923                                     WM_FB_WRITE, dst_mask(dst_undef(),0), 0,
 924                                     outcolor, payload_r0_depth, outdepth);
 925          inst->Aux = (i<<1);
 926          if (c->fp_fragcolor_emitted) {
 927             outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
 928             last_inst = inst = emit_op(c, WM_FB_WRITE, dst_mask(dst_undef(),0),
 929                                        0, outcolor, payload_r0_depth, outdepth);
 930             inst->Aux = (i<<1);
 931          }
 932       }
 933       last_inst->Aux |= 1; //eot
 934    }
 935    else {
 936       /* if gl_FragData[0] is written, use it, else use gl_FragColor */
 937       if (c->fp->program.Base.OutputsWritten & (1 << FRAG_RESULT_DATA0))
 938          outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_DATA0);
 939       else
 940          outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
 941
 942       inst = emit_op(c, WM_FB_WRITE, dst_mask(dst_undef(),0),
 943                      0, outcolor, payload_r0_depth, outdepth);
 944       inst->Aux = 1|(0<<1);
 945    }
 946 }
 947
 948
 949
 950
 951 /***********************************************************************
 952  * Emit INTERP instructions ahead of first use of each attrib.
 953  */
 954
 955 static void validate_src_regs( struct brw_wm_compile *c,
 956                                const struct prog_instruction *inst )
 957 {
 958    GLuint nr_args = brw_wm_nr_args( inst->Opcode );
 959    GLuint i;
 960
 961    for (i = 0; i < nr_args; i++) {
 962       if (inst->SrcReg[i].File == PROGRAM_INPUT) {
 963          GLuint idx = inst->SrcReg[i].Index;
 964          if (!(c->fp_interp_emitted & (1<<idx))) {
 965             emit_interp(c, idx);
 966          }
 967       }
 968    }
 969 }
 970
 971 static void validate_dst_regs( struct brw_wm_compile *c,
 972                                const struct prog_instruction *inst )
 973 {
 974    if (inst->DstReg.File == PROGRAM_OUTPUT) {
 975       GLuint idx = inst->DstReg.Index;
 976       if (idx == FRAG_RESULT_COLOR)
 977          c->fp_fragcolor_emitted = 1;
 978    }
 979 }
 980
 981 static void print_insns( const struct prog_instruction *insn,
 982                          GLuint nr )
 983 {
 984    GLuint i;
 985    for (i = 0; i < nr; i++, insn++) {
 986       _mesa_printf("%3d: ", i);
 987       if (insn->Opcode < MAX_OPCODE)
 988          _mesa_print_instruction(insn);
 989       else if (insn->Opcode < MAX_WM_OPCODE) {
 990          GLuint idx = insn->Opcode - MAX_OPCODE;
 991
 992          _mesa_print_alu_instruction(insn,
 993                                      wm_opcode_strings[idx],
 994                                      3);
 995       }
 996       else
 997          _mesa_printf("965 Opcode %d\n", insn->Opcode);
 998    }
 999 }
1000
1001
1002 /**
1003  * Initial pass for fragment program code generation.
1004  * This function is used by both the GLSL and non-GLSL paths.
1005  */
1006 void brw_wm_pass_fp( struct brw_wm_compile *c )
1007 {
1008    struct brw_fragment_program *fp = c->fp;
1009    GLuint insn;
1010
1011    if (INTEL_DEBUG & DEBUG_WM) {
1012       _mesa_printf("pre-fp:\n");
1013       _mesa_print_program(&fp->program.Base);
1014       _mesa_printf("\n");
1015    }
1016
1017    c->pixel_xy = src_undef();
1018    c->delta_xy = src_undef();
1019    c->pixel_w = src_undef();
1020    c->nr_fp_insns = 0;
1021
1022    /* Emit preamble instructions.  This is where special instructions such as
1023     * WM_CINTERP, WM_LINTERP, WM_PINTERP and WM_WPOSXY are emitted to
1024     * compute shader inputs from varying vars.
1025     */
1026    for (insn = 0; insn < fp->program.Base.NumInstructions; insn++) {
1027       const struct prog_instruction *inst = &fp->program.Base.Instructions[insn];
1028       validate_src_regs(c, inst);
1029       validate_dst_regs(c, inst);
1030    }
1031
1032    /* Loop over all instructions doing assorted simplifications and
1033     * transformations.
1034     */
1035    for (insn = 0; insn < fp->program.Base.NumInstructions; insn++) {
1036       const struct prog_instruction *inst = &fp->program.Base.Instructions[insn];
1037       struct prog_instruction *out;
1038
1039       /* Check for INPUT values, emit INTERP instructions where
1040        * necessary:
1041        */
1042
1043       switch (inst->Opcode) {
1044       case OPCODE_SWZ:
1045          out = emit_insn(c, inst);
1046          out->Opcode = OPCODE_MOV;
1047          break;
1048
1049       case OPCODE_ABS:
1050          out = emit_insn(c, inst);
1051          out->Opcode = OPCODE_MOV;
1052          out->SrcReg[0].NegateBase = 0;
1053          out->SrcReg[0].Abs = 1;
1054          break;
1055
1056       case OPCODE_SUB:
1057          out = emit_insn(c, inst);
1058          out->Opcode = OPCODE_ADD;
1059          out->SrcReg[1].NegateBase ^= 0xf;
1060          break;
1061
1062       case OPCODE_SCS:
1063          out = emit_insn(c, inst);
1064          /* This should probably be done in the parser.
1065           */
1066          out->DstReg.WriteMask &= WRITEMASK_XY;
1067          break;
1068
1069       case OPCODE_DST:
1070          precalc_dst(c, inst);
1071          break;
1072
1073       case OPCODE_LIT:
1074          precalc_lit(c, inst);
1075          break;
1076
1077       case OPCODE_TEX:
1078          precalc_tex(c, inst);
1079          break;
1080
1081       case OPCODE_TXP:
1082          precalc_txp(c, inst);
1083          break;
1084
1085       case OPCODE_TXB:
1086          out = emit_insn(c, inst);
1087          out->TexSrcUnit = fp->program.Base.SamplerUnits[inst->TexSrcUnit];
1088          break;
1089
1090       case OPCODE_XPD:
1091          out = emit_insn(c, inst);
1092          /* This should probably be done in the parser.
1093           */
1094          out->DstReg.WriteMask &= WRITEMASK_XYZ;
1095          break;
1096
1097       case OPCODE_KIL:
1098          out = emit_insn(c, inst);
1099          /* This should probably be done in the parser.
1100           */
1101          out->DstReg.WriteMask = 0;
1102          break;
1103       case OPCODE_DDX:
1104          emit_ddx(c, inst);
1105          break;
1106       case OPCODE_DDY:
1107          emit_ddy(c, inst);
1108         break;
1109       case OPCODE_END:
1110          emit_fb_write(c);
1111          break;
1112       case OPCODE_PRINT:
1113          break;
1114
1115       default:
1116          emit_insn(c, inst);
1117          break;
1118       }
1119    }
1120
1121    if (INTEL_DEBUG & DEBUG_WM) {
1122       _mesa_printf("pass_fp:\n");
1123       print_insns( c->prog_instructions, c->nr_fp_insns );
1124       _mesa_printf("\n");
1125    }
1126 }
1127