src/gallium/drivers/svga/svga_state_constants.c

   1 /**********************************************************
   2  * Copyright 2008-2009 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
  26 #include "util/u_inlines.h"
  27 #include "pipe/p_defines.h"
  28
  29 #include "svga_screen.h"
  30 #include "svga_context.h"
  31 #include "svga_state.h"
  32 #include "svga_cmd.h"
  33 #include "svga_tgsi.h"
  34 #include "svga_debug.h"
  35
  36 #include "svga_hw_reg.h"
  37
  38
  39 /*
  40  * Don't try to send more than 4k of successive constants.
  41  */
  42 #define MAX_CONST_REG_COUNT 256 /* 4k */
  43
  44
  45 /***********************************************************************
  46  * Hardware update
  47  */
  48
  49 /* Convert from PIPE_SHADER_* to SVGA3D_SHADERTYPE_*
  50  */
  51 static int svga_shader_type( unsigned shader )
  52 {
  53    assert(PIPE_SHADER_VERTEX + 1 == SVGA3D_SHADERTYPE_VS);
  54    assert(PIPE_SHADER_FRAGMENT + 1 == SVGA3D_SHADERTYPE_PS);
  55    assert(shader <= PIPE_SHADER_FRAGMENT);
  56    return shader + 1;
  57 }
  58
  59 /*
  60  * Check and emit one shader constant register.
  61  * \param shader  PIPE_SHADER_FRAGMENT or PIPE_SHADER_VERTEX
  62  * \param i  which float[4] constant to change
  63  * \param value  the new float[4] value
  64  */
  65 static enum pipe_error
  66 emit_const(struct svga_context *svga, unsigned shader, unsigned i,
  67            const float *value)
  68 {
  69    enum pipe_error ret = PIPE_OK;
  70
  71    assert(i < CB_MAX);
  72
  73    assert(shader < PIPE_SHADER_TYPES);
  74
  75    if (memcmp(svga->state.hw_draw.cb[shader][i], value, 4 * sizeof(float)) != 0) {
  76       if (SVGA_DEBUG & DEBUG_CONSTS)
  77          debug_printf("%s %s %u: %f %f %f %f\n",
  78                       __FUNCTION__,
  79                       shader == PIPE_SHADER_VERTEX ? "VERT" : "FRAG",
  80                       i,
  81                       value[0],
  82                       value[1],
  83                       value[2],
  84                       value[3]);
  85
  86       ret = SVGA3D_SetShaderConst( svga->swc,
  87                                    i,
  88                                    svga_shader_type(shader),
  89                                    SVGA3D_CONST_TYPE_FLOAT,
  90                                    value );
  91       if (ret != PIPE_OK)
  92          return ret;
  93
  94       memcpy(svga->state.hw_draw.cb[shader][i], value, 4 * sizeof(float));
  95    }
  96
  97    return ret;
  98 }
  99
 100 /*
 101  * Check and emit a range of shader constant registers, trying to coalesce
 102  * successive shader constant updates in a single command in order to save
 103  * space on the command buffer.  This is a HWv8 feature.
 104  */
 105 static enum pipe_error emit_const_range( struct svga_context *svga,
 106                                          unsigned shader,
 107                                          unsigned offset,
 108                                          unsigned count,
 109                                          const float (*values)[4] )
 110 {
 111    unsigned i, j;
 112    enum pipe_error ret;
 113
 114 #ifdef DEBUG
 115    if (offset + count > CB_MAX) {
 116       debug_printf("svga: too many constants (offset + count = %u)\n",
 117                    offset + count);
 118    }
 119 #endif
 120
 121    if (offset > CB_MAX) {
 122       /* This isn't OK, but if we propagate an error all the way up we'll
 123        * just get into more trouble.
 124        * XXX note that offset is always zero at this time so this is moot.
 125        */
 126       return PIPE_OK;
 127    }
 128
 129    if (offset + count > CB_MAX) {
 130       /* Just drop the extra constants for now.
 131        * Ideally we should not have allowed the app to create a shader
 132        * that exceeds our constant buffer size but there's no way to
 133        * express that in gallium at this time.
 134        */
 135       count = CB_MAX - offset;
 136    }
 137
 138    i = 0;
 139    while (i < count) {
 140       if (memcmp(svga->state.hw_draw.cb[shader][offset + i],
 141                  values[i],
 142                  4 * sizeof(float)) != 0) {
 143
 144          /*
 145           * Found one dirty constant
 146           */
 147
 148          if (SVGA_DEBUG & DEBUG_CONSTS)
 149             debug_printf("%s %s %d: %f %f %f %f\n",
 150                          __FUNCTION__,
 151                          shader == PIPE_SHADER_VERTEX ? "VERT" : "FRAG",
 152                          offset + i,
 153                          values[i][0],
 154                          values[i][1],
 155                          values[i][2],
 156                          values[i][3]);
 157
 158          /*
 159           * Look for more consecutive dirty constants.
 160           */
 161
 162          j = i + 1;
 163          while (j < count &&
 164                 j < i + MAX_CONST_REG_COUNT &&
 165                 memcmp(svga->state.hw_draw.cb[shader][offset + j],
 166                        values[j],
 167                        4 * sizeof(float)) != 0) {
 168
 169             if (SVGA_DEBUG & DEBUG_CONSTS)
 170                debug_printf("%s %s %d: %f %f %f %f\n",
 171                             __FUNCTION__,
 172                             shader == PIPE_SHADER_VERTEX ? "VERT" : "FRAG",
 173                             offset + j,
 174                             values[j][0],
 175                             values[j][1],
 176                             values[j][2],
 177                             values[j][3]);
 178
 179             ++j;
 180          }
 181
 182          assert(j >= i + 1);
 183
 184          /*
 185           * Send them all together.
 186           */
 187
 188          ret = SVGA3D_SetShaderConsts(svga->swc,
 189                                       offset + i, j - i,
 190                                       svga_shader_type(shader),
 191                                       SVGA3D_CONST_TYPE_FLOAT,
 192                                       values + i);
 193          if (ret != PIPE_OK) {
 194             return ret;
 195          }
 196
 197          /*
 198           * Local copy of the hardware state.
 199           */
 200
 201          memcpy(svga->state.hw_draw.cb[shader][offset + i],
 202                 values[i],
 203                 (j - i) * 4 * sizeof(float));
 204
 205          i = j + 1;
 206       } else {
 207          ++i;
 208       }
 209    }
 210
 211    return PIPE_OK;
 212 }
 213
 214
 215 static enum pipe_error
 216 emit_consts(struct svga_context *svga, unsigned offset, unsigned shader)
 217 {
 218    struct svga_screen *ss = svga_screen(svga->pipe.screen);
 219    struct pipe_transfer *transfer = NULL;
 220    unsigned count;
 221    const float (*data)[4] = NULL;
 222    unsigned i;
 223    enum pipe_error ret = PIPE_OK;
 224
 225    assert(shader < PIPE_SHADER_TYPES);
 226
 227    if (svga->curr.cb[shader] == NULL)
 228       goto done;
 229
 230    count = svga->curr.cb[shader]->width0 / (4 * sizeof(float));
 231
 232    data = (const float (*)[4])pipe_buffer_map(&svga->pipe,
 233                                               svga->curr.cb[shader],
 234                                               PIPE_TRANSFER_READ,
 235                                               &transfer);
 236    if (data == NULL) {
 237       ret = PIPE_ERROR_OUT_OF_MEMORY;
 238       goto done;
 239    }
 240
 241    if (ss->hw_version >= SVGA3D_HWVERSION_WS8_B1) {
 242       ret = emit_const_range( svga, shader, offset, count, data );
 243       if (ret != PIPE_OK) {
 244          goto done;
 245       }
 246    } else {
 247       for (i = 0; i < count; i++) {
 248          ret = emit_const( svga, shader, offset + i, data[i] );
 249          if (ret != PIPE_OK) {
 250             goto done;
 251          }
 252       }
 253    }
 254
 255 done:
 256    if (data)
 257       pipe_buffer_unmap(&svga->pipe, transfer);
 258
 259    return ret;
 260 }
 261
 262
 263 static enum pipe_error
 264 emit_fs_consts(struct svga_context *svga, unsigned dirty)
 265 {
 266    const struct svga_shader_result *result = svga->state.hw_draw.fs;
 267    const struct svga_fs_compile_key *key = &result->key.fkey;
 268    enum pipe_error ret = PIPE_OK;
 269
 270    ret = emit_consts( svga, 0, PIPE_SHADER_FRAGMENT );
 271    if (ret != PIPE_OK)
 272       return ret;
 273
 274    /* The internally generated fragment shader for xor blending
 275     * doesn't have a 'result' struct.  It should be fixed to avoid
 276     * this special case, but work around it with a NULL check:
 277     */
 278    if (result != NULL &&
 279        key->num_unnormalized_coords)
 280    {
 281       unsigned offset = result->shader->info.file_max[TGSI_FILE_CONSTANT] + 1;
 282       int i;
 283
 284       for (i = 0; i < key->num_textures; i++) {
 285          if (key->tex[i].unnormalized) {
 286             struct pipe_resource *tex = svga->curr.sampler_views[i]->texture;
 287             float data[4];
 288
 289             data[0] = 1.0 / (float)tex->width0;
 290             data[1] = 1.0 / (float)tex->height0;
 291             data[2] = 1.0;
 292             data[3] = 1.0;
 293
 294             ret = emit_const( svga,
 295                               PIPE_SHADER_FRAGMENT,
 296                               key->tex[i].width_height_idx + offset,
 297                               data );
 298             if (ret != PIPE_OK)
 299                return ret;
 300          }
 301       }
 302
 303       offset += key->num_unnormalized_coords;
 304    }
 305
 306    return 0;
 307 }
 308
 309
 310 struct svga_tracked_state svga_hw_fs_parameters =
 311 {
 312    "hw fs params",
 313    (SVGA_NEW_FS_CONST_BUFFER |
 314     SVGA_NEW_FS_RESULT |
 315     SVGA_NEW_TEXTURE_BINDING),
 316    emit_fs_consts
 317 };
 318
 319 /***********************************************************************
 320  */
 321
 322 static enum pipe_error
 323 emit_vs_consts(struct svga_context *svga, unsigned dirty)
 324 {
 325    const struct svga_shader_result *result = svga->state.hw_draw.vs;
 326    const struct svga_vs_compile_key *key = &result->key.vkey;
 327    enum pipe_error ret = PIPE_OK;
 328    unsigned offset;
 329
 330    /* SVGA_NEW_VS_RESULT
 331     */
 332    if (result == NULL)
 333       return PIPE_OK;
 334
 335    /* SVGA_NEW_VS_CONST_BUFFER
 336     */
 337    ret = emit_consts( svga, 0, PIPE_SHADER_VERTEX );
 338    if (ret != PIPE_OK)
 339       return ret;
 340
 341    offset = result->shader->info.file_max[TGSI_FILE_CONSTANT] + 1;
 342
 343    /* SVGA_NEW_VS_RESULT
 344     */
 345    if (key->need_prescale) {
 346       ret = emit_const( svga, PIPE_SHADER_VERTEX, offset++,
 347                         svga->state.hw_clear.prescale.scale );
 348       if (ret != PIPE_OK)
 349          return ret;
 350
 351       ret = emit_const( svga, PIPE_SHADER_VERTEX, offset++,
 352                         svga->state.hw_clear.prescale.translate );
 353       if (ret != PIPE_OK)
 354          return ret;
 355    }
 356
 357    /* SVGA_NEW_ZERO_STRIDE
 358     */
 359    if (key->zero_stride_vertex_elements) {
 360       unsigned i, curr_zero_stride = 0;
 361       for (i = 0; i < PIPE_MAX_ATTRIBS; ++i) {
 362          if (key->zero_stride_vertex_elements & (1 << i)) {
 363             ret = emit_const( svga, PIPE_SHADER_VERTEX, offset++,
 364                               svga->curr.zero_stride_constants +
 365                               4 * curr_zero_stride );
 366             if (ret != PIPE_OK)
 367                return ret;
 368             ++curr_zero_stride;
 369          }
 370       }
 371    }
 372
 373    return PIPE_OK;
 374 }
 375
 376
 377 struct svga_tracked_state svga_hw_vs_parameters =
 378 {
 379    "hw vs params",
 380    (SVGA_NEW_PRESCALE |
 381     SVGA_NEW_VS_CONST_BUFFER |
 382     SVGA_NEW_ZERO_STRIDE |
 383     SVGA_NEW_VS_RESULT),
 384    emit_vs_consts
 385 };
 386