src/mesa/drivers/dri/i965/brw_wm.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 #include "main/texformat.h"
  33 #include "brw_context.h"
  34 #include "brw_util.h"
  35 #include "brw_wm.h"
  36 #include "brw_state.h"
  37
  38
  39 GLuint brw_wm_nr_args( GLuint opcode )
  40 {
  41    switch (opcode) {
  42
  43    case WM_PIXELXY:
  44    case OPCODE_ABS:
  45    case OPCODE_FLR:
  46    case OPCODE_FRC:
  47    case OPCODE_SWZ:
  48    case OPCODE_MOV:
  49    case OPCODE_COS:
  50    case OPCODE_EX2:
  51    case OPCODE_LG2:
  52    case OPCODE_RCP:
  53    case OPCODE_RSQ:
  54    case OPCODE_SIN:
  55    case OPCODE_SCS:
  56    case OPCODE_TEX:
  57    case OPCODE_TXB:
  58    case OPCODE_TXP:
  59    case OPCODE_KIL:
  60    case OPCODE_LIT:
  61    case WM_CINTERP:
  62    case WM_WPOSXY:
  63       return 1;
  64
  65    case OPCODE_POW:
  66    case OPCODE_SUB:
  67    case OPCODE_SGE:
  68    case OPCODE_SGT:
  69    case OPCODE_SLE:
  70    case OPCODE_SLT:
  71    case OPCODE_SEQ:
  72    case OPCODE_SNE:
  73    case OPCODE_ADD:
  74    case OPCODE_MAX:
  75    case OPCODE_MIN:
  76    case OPCODE_MUL:
  77    case OPCODE_XPD:
  78    case OPCODE_DP3:
  79    case OPCODE_DP4:
  80    case OPCODE_DPH:
  81    case OPCODE_DST:
  82    case WM_LINTERP:
  83    case WM_DELTAXY:
  84    case WM_PIXELW:
  85       return 2;
  86
  87    case WM_FB_WRITE:
  88    case WM_PINTERP:
  89    case OPCODE_MAD:
  90    case OPCODE_CMP:
  91    case OPCODE_LRP:
  92       return 3;
  93
  94    default:
  95       return 0;
  96    }
  97 }
  98
  99
 100 GLuint brw_wm_is_scalar_result( GLuint opcode )
 101 {
 102    switch (opcode) {
 103    case OPCODE_COS:
 104    case OPCODE_EX2:
 105    case OPCODE_LG2:
 106    case OPCODE_POW:
 107    case OPCODE_RCP:
 108    case OPCODE_RSQ:
 109    case OPCODE_SIN:
 110    case OPCODE_DP3:
 111    case OPCODE_DP4:
 112    case OPCODE_DPH:
 113    case OPCODE_DST:
 114       return 1;
 115
 116    default:
 117       return 0;
 118    }
 119 }
 120
 121
 122 static void do_wm_prog( struct brw_context *brw,
 123                         struct brw_fragment_program *fp,
 124                         struct brw_wm_prog_key *key)
 125 {
 126    struct brw_wm_compile *c;
 127    const GLuint *program;
 128    GLuint program_size;
 129
 130    c = brw->wm.compile_data;
 131    if (c == NULL) {
 132      brw->wm.compile_data = calloc(1, sizeof(*brw->wm.compile_data));
 133      c = brw->wm.compile_data;
 134    } else {
 135      memset(c, 0, sizeof(*brw->wm.compile_data));
 136    }
 137    memcpy(&c->key, key, sizeof(*key));
 138
 139    c->fp = fp;
 140    c->env_param = brw->intel.ctx.FragmentProgram.Parameters;
 141
 142     brw_init_compile(brw, &c->func);
 143    if (brw_wm_is_glsl(&c->fp->program)) {
 144        brw_wm_glsl_emit(brw, c);
 145    } else {
 146        /* Augment fragment program.  Add instructions for pre- and
 147         * post-fragment-program tasks such as interpolation and fogging.
 148         */
 149        brw_wm_pass_fp(c);
 150
 151        /* Translate to intermediate representation.  Build register usage
 152         * chains.
 153         */
 154        brw_wm_pass0(c);
 155
 156        /* Dead code removal.
 157         */
 158        brw_wm_pass1(c);
 159
 160        /* Register allocation.
 161         */
 162        c->grf_limit = BRW_WM_MAX_GRF/2;
 163
 164        brw_wm_pass2(c);
 165
 166        c->prog_data.total_grf = c->max_wm_grf;
 167        if (c->last_scratch) {
 168            c->prog_data.total_scratch =
 169                c->last_scratch + 0x40;
 170        } else {
 171            c->prog_data.total_scratch = 0;
 172        }
 173
 174        /* Emit GEN4 code.
 175         */
 176        brw_wm_emit(c);
 177    }
 178    /* get the program
 179     */
 180    program = brw_get_program(&c->func, &program_size);
 181
 182    dri_bo_unreference(brw->wm.prog_bo);
 183    brw->wm.prog_bo = brw_upload_cache( &brw->cache, BRW_WM_PROG,
 184                                        &c->key, sizeof(c->key),
 185                                        NULL, 0,
 186                                        program, program_size,
 187                                        &c->prog_data,
 188                                        &brw->wm.prog_data );
 189 }
 190
 191
 192
 193 static void brw_wm_populate_key( struct brw_context *brw,
 194                                  struct brw_wm_prog_key *key )
 195 {
 196    /* BRW_NEW_FRAGMENT_PROGRAM */
 197    struct brw_fragment_program *fp =
 198       (struct brw_fragment_program *)brw->fragment_program;
 199    GLuint lookup = 0;
 200    GLuint line_aa;
 201    GLuint i;
 202
 203    memset(key, 0, sizeof(*key));
 204
 205    /* Build the index for table lookup
 206     */
 207    /* _NEW_COLOR */
 208    if (fp->program.UsesKill ||
 209        brw->attribs.Color->AlphaEnabled)
 210       lookup |= IZ_PS_KILL_ALPHATEST_BIT;
 211
 212    if (fp->program.Base.OutputsWritten & (1<<FRAG_RESULT_DEPR))
 213       lookup |= IZ_PS_COMPUTES_DEPTH_BIT;
 214
 215    /* _NEW_DEPTH */
 216    if (brw->attribs.Depth->Test)
 217       lookup |= IZ_DEPTH_TEST_ENABLE_BIT;
 218
 219    if (brw->attribs.Depth->Test &&
 220        brw->attribs.Depth->Mask) /* ?? */
 221       lookup |= IZ_DEPTH_WRITE_ENABLE_BIT;
 222
 223    /* _NEW_STENCIL */
 224    if (brw->attribs.Stencil->Enabled) {
 225       lookup |= IZ_STENCIL_TEST_ENABLE_BIT;
 226
 227       if (brw->attribs.Stencil->WriteMask[0] ||
 228           (brw->attribs.Stencil->_TestTwoSide &&
 229            brw->attribs.Stencil->WriteMask[1]))
 230          lookup |= IZ_STENCIL_WRITE_ENABLE_BIT;
 231    }
 232
 233    /* XXX: when should this be disabled?
 234     */
 235    if (1)
 236       lookup |= IZ_EARLY_DEPTH_TEST_BIT;
 237
 238
 239    line_aa = AA_NEVER;
 240
 241    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 242    if (brw->attribs.Line->SmoothFlag) {
 243       if (brw->intel.reduced_primitive == GL_LINES) {
 244          line_aa = AA_ALWAYS;
 245       }
 246       else if (brw->intel.reduced_primitive == GL_TRIANGLES) {
 247          if (brw->attribs.Polygon->FrontMode == GL_LINE) {
 248             line_aa = AA_SOMETIMES;
 249
 250             if (brw->attribs.Polygon->BackMode == GL_LINE ||
 251                 (brw->attribs.Polygon->CullFlag &&
 252                  brw->attribs.Polygon->CullFaceMode == GL_BACK))
 253                line_aa = AA_ALWAYS;
 254          }
 255          else if (brw->attribs.Polygon->BackMode == GL_LINE) {
 256             line_aa = AA_SOMETIMES;
 257
 258             if ((brw->attribs.Polygon->CullFlag &&
 259                  brw->attribs.Polygon->CullFaceMode == GL_FRONT))
 260                line_aa = AA_ALWAYS;
 261          }
 262       }
 263    }
 264
 265    brw_wm_lookup_iz(line_aa,
 266                     lookup,
 267                     key);
 268
 269
 270    /* BRW_NEW_WM_INPUT_DIMENSIONS */
 271    key->projtex_mask = brw->wm.input_size_masks[4-1] >> (FRAG_ATTRIB_TEX0 - FRAG_ATTRIB_WPOS);
 272
 273    /* _NEW_LIGHT */
 274    key->flat_shade = (brw->attribs.Light->ShadeModel == GL_FLAT);
 275
 276    /* _NEW_TEXTURE */
 277    for (i = 0; i < BRW_MAX_TEX_UNIT; i++) {
 278       const struct gl_texture_unit *unit = &brw->attribs.Texture->Unit[i];
 279       const struct gl_texture_object *t = unit->_Current;
 280
 281       if (unit->_ReallyEnabled) {
 282          if (t->Image[0][t->BaseLevel]->InternalFormat == GL_YCBCR_MESA) {
 283             key->yuvtex_mask |= 1<<i;
 284             if (t->Image[0][t->BaseLevel]->TexFormat->MesaFormat ==
 285                     MESA_FORMAT_YCBCR)
 286                 key->yuvtex_swap_mask |= 1<< i;
 287          }
 288       }
 289    }
 290
 291    /* Shadow */
 292    key->shadowtex_mask = fp->program.Base.ShadowSamplers;
 293
 294    /* _NEW_BUFFERS */
 295    /*
 296     * Include the draw buffer origin and height so that we can calculate
 297     * fragment position values relative to the bottom left of the drawable,
 298     * from the incoming screen origin relative position we get as part of our
 299     * payload.
 300     *
 301     * We could avoid recompiling by including this as a constant referenced by
 302     * our program, but if we were to do that it would also be nice to handle
 303     * getting that constant updated at batchbuffer submit time (when we
 304     * hold the lock and know where the buffer really is) rather than at emit
 305     * time when we don't hold the lock and are just guessing.  We could also
 306     * just avoid using this as key data if the program doesn't use
 307     * fragment.position.
 308     *
 309     * This pretty much becomes moot with DRI2 and redirected buffers anyway,
 310     * as our origins will always be zero then.
 311     */
 312    if (brw->intel.driDrawable != NULL) {
 313       key->origin_x = brw->intel.driDrawable->x;
 314       key->origin_y = brw->intel.driDrawable->y;
 315       key->drawable_height = brw->intel.driDrawable->h;
 316    }
 317
 318    /* Extra info:
 319     */
 320    key->program_string_id = fp->id;
 321
 322 }
 323
 324
 325 static void brw_prepare_wm_prog(struct brw_context *brw)
 326 {
 327    struct brw_wm_prog_key key;
 328    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 329       brw->fragment_program;
 330
 331    brw_wm_populate_key(brw, &key);
 332
 333    /* Make an early check for the key.
 334     */
 335    dri_bo_unreference(brw->wm.prog_bo);
 336    brw->wm.prog_bo = brw_search_cache(&brw->cache, BRW_WM_PROG,
 337                                       &key, sizeof(key),
 338                                       NULL, 0,
 339                                       &brw->wm.prog_data);
 340    if (brw->wm.prog_bo == NULL)
 341       do_wm_prog(brw, fp, &key);
 342 }
 343
 344
 345 /* See brw_wm.c:
 346  */
 347 const struct brw_tracked_state brw_wm_prog = {
 348    .dirty = {
 349       .mesa  = (_NEW_COLOR |
 350                 _NEW_DEPTH |
 351                 _NEW_STENCIL |
 352                 _NEW_POLYGON |
 353                 _NEW_LINE |
 354                 _NEW_LIGHT |
 355                 _NEW_BUFFERS |
 356                 _NEW_TEXTURE),
 357       .brw   = (BRW_NEW_FRAGMENT_PROGRAM |
 358                 BRW_NEW_WM_INPUT_DIMENSIONS |
 359                 BRW_NEW_REDUCED_PRIMITIVE),
 360       .cache = 0
 361    },
 362    .prepare = brw_prepare_wm_prog
 363 };
 364