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    line_aa = AA_NEVER;
 234
 235    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 236    if (brw->attribs.Line->SmoothFlag) {
 237       if (brw->intel.reduced_primitive == GL_LINES) {
 238          line_aa = AA_ALWAYS;
 239       }
 240       else if (brw->intel.reduced_primitive == GL_TRIANGLES) {
 241          if (brw->attribs.Polygon->FrontMode == GL_LINE) {
 242             line_aa = AA_SOMETIMES;
 243
 244             if (brw->attribs.Polygon->BackMode == GL_LINE ||
 245                 (brw->attribs.Polygon->CullFlag &&
 246                  brw->attribs.Polygon->CullFaceMode == GL_BACK))
 247                line_aa = AA_ALWAYS;
 248          }
 249          else if (brw->attribs.Polygon->BackMode == GL_LINE) {
 250             line_aa = AA_SOMETIMES;
 251
 252             if ((brw->attribs.Polygon->CullFlag &&
 253                  brw->attribs.Polygon->CullFaceMode == GL_FRONT))
 254                line_aa = AA_ALWAYS;
 255          }
 256       }
 257    }
 258
 259    brw_wm_lookup_iz(line_aa,
 260                     lookup,
 261                     key);
 262
 263
 264    /* BRW_NEW_WM_INPUT_DIMENSIONS */
 265    key->projtex_mask = brw->wm.input_size_masks[4-1] >> (FRAG_ATTRIB_TEX0 - FRAG_ATTRIB_WPOS);
 266
 267    /* _NEW_LIGHT */
 268    key->flat_shade = (brw->attribs.Light->ShadeModel == GL_FLAT);
 269
 270    /* _NEW_TEXTURE */
 271    for (i = 0; i < BRW_MAX_TEX_UNIT; i++) {
 272       const struct gl_texture_unit *unit = &brw->attribs.Texture->Unit[i];
 273       const struct gl_texture_object *t = unit->_Current;
 274
 275       if (unit->_ReallyEnabled) {
 276          if (t->Image[0][t->BaseLevel]->InternalFormat == GL_YCBCR_MESA) {
 277             key->yuvtex_mask |= 1<<i;
 278             if (t->Image[0][t->BaseLevel]->TexFormat->MesaFormat ==
 279                     MESA_FORMAT_YCBCR)
 280                 key->yuvtex_swap_mask |= 1<< i;
 281          }
 282       }
 283    }
 284
 285    /* Shadow */
 286    key->shadowtex_mask = fp->program.Base.ShadowSamplers;
 287
 288    /* _NEW_BUFFERS */
 289    /*
 290     * Include the draw buffer origin and height so that we can calculate
 291     * fragment position values relative to the bottom left of the drawable,
 292     * from the incoming screen origin relative position we get as part of our
 293     * payload.
 294     *
 295     * We could avoid recompiling by including this as a constant referenced by
 296     * our program, but if we were to do that it would also be nice to handle
 297     * getting that constant updated at batchbuffer submit time (when we
 298     * hold the lock and know where the buffer really is) rather than at emit
 299     * time when we don't hold the lock and are just guessing.  We could also
 300     * just avoid using this as key data if the program doesn't use
 301     * fragment.position.
 302     *
 303     * This pretty much becomes moot with DRI2 and redirected buffers anyway,
 304     * as our origins will always be zero then.
 305     */
 306    if (brw->intel.driDrawable != NULL) {
 307       key->origin_x = brw->intel.driDrawable->x;
 308       key->origin_y = brw->intel.driDrawable->y;
 309       key->drawable_height = brw->intel.driDrawable->h;
 310    }
 311
 312    /* Extra info:
 313     */
 314    key->program_string_id = fp->id;
 315
 316 }
 317
 318
 319 static void brw_prepare_wm_prog(struct brw_context *brw)
 320 {
 321    struct brw_wm_prog_key key;
 322    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 323       brw->fragment_program;
 324
 325    brw_wm_populate_key(brw, &key);
 326
 327    /* Make an early check for the key.
 328     */
 329    dri_bo_unreference(brw->wm.prog_bo);
 330    brw->wm.prog_bo = brw_search_cache(&brw->cache, BRW_WM_PROG,
 331                                       &key, sizeof(key),
 332                                       NULL, 0,
 333                                       &brw->wm.prog_data);
 334    if (brw->wm.prog_bo == NULL)
 335       do_wm_prog(brw, fp, &key);
 336 }
 337
 338
 339 /* See brw_wm.c:
 340  */
 341 const struct brw_tracked_state brw_wm_prog = {
 342    .dirty = {
 343       .mesa  = (_NEW_COLOR |
 344                 _NEW_DEPTH |
 345                 _NEW_STENCIL |
 346                 _NEW_POLYGON |
 347                 _NEW_LINE |
 348                 _NEW_LIGHT |
 349                 _NEW_BUFFERS |
 350                 _NEW_TEXTURE),
 351       .brw   = (BRW_NEW_FRAGMENT_PROGRAM |
 352                 BRW_NEW_WM_INPUT_DIMENSIONS |
 353                 BRW_NEW_REDUCED_PRIMITIVE),
 354       .cache = 0
 355    },
 356    .prepare = brw_prepare_wm_prog
 357 };
 358