src/gallium/drivers/vc4/vc4_uniforms.c

   1 /*
   2  * Copyright © 2014-2015 Broadcom
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "util/u_pack_color.h"
  25 #include "util/format_srgb.h"
  26
  27 #include "vc4_context.h"
  28 #include "vc4_qir.h"
  29
  30 static void
  31 write_texture_p0(struct vc4_job *job,
  32                  struct vc4_cl_out **uniforms,
  33                  struct vc4_texture_stateobj *texstate,
  34                  uint32_t unit)
  35 {
  36         struct vc4_sampler_view *sview =
  37                 vc4_sampler_view(texstate->textures[unit]);
  38         struct vc4_resource *rsc = vc4_resource(sview->texture);
  39
  40         cl_reloc(job, &job->uniforms, uniforms, rsc->bo, sview->texture_p0);
  41 }
  42
  43 static void
  44 write_texture_p1(struct vc4_job *job,
  45                  struct vc4_cl_out **uniforms,
  46                  struct vc4_texture_stateobj *texstate,
  47                  uint32_t unit)
  48 {
  49         struct vc4_sampler_view *sview =
  50                 vc4_sampler_view(texstate->textures[unit]);
  51         struct vc4_sampler_state *sampler =
  52                 vc4_sampler_state(texstate->samplers[unit]);
  53
  54         cl_aligned_u32(uniforms, sview->texture_p1 | sampler->texture_p1);
  55 }
  56
  57 static void
  58 write_texture_p2(struct vc4_job *job,
  59                  struct vc4_cl_out **uniforms,
  60                  struct vc4_texture_stateobj *texstate,
  61                  uint32_t data)
  62 {
  63         uint32_t unit = data & 0xffff;
  64         struct pipe_sampler_view *texture = texstate->textures[unit];
  65         struct vc4_resource *rsc = vc4_resource(texture->texture);
  66
  67         cl_aligned_u32(uniforms,
  68                VC4_SET_FIELD(VC4_TEX_P2_PTYPE_CUBE_MAP_STRIDE,
  69                              VC4_TEX_P2_PTYPE) |
  70                VC4_SET_FIELD(rsc->cube_map_stride >> 12, VC4_TEX_P2_CMST) |
  71                VC4_SET_FIELD((data >> 16) & 1, VC4_TEX_P2_BSLOD));
  72 }
  73
  74 static void
  75 write_texture_first_level(struct vc4_job *job,
  76                           struct vc4_cl_out **uniforms,
  77                           struct vc4_texture_stateobj *texstate,
  78                           uint32_t data)
  79 {
  80         uint32_t unit = data & 0xffff;
  81         struct pipe_sampler_view *texture = texstate->textures[unit];
  82
  83         cl_aligned_f(uniforms, texture->u.tex.first_level);
  84 }
  85
  86 static void
  87 write_texture_msaa_addr(struct vc4_job *job,
  88                  struct vc4_cl_out **uniforms,
  89                         struct vc4_texture_stateobj *texstate,
  90                         uint32_t unit)
  91 {
  92         struct pipe_sampler_view *texture = texstate->textures[unit];
  93         struct vc4_resource *rsc = vc4_resource(texture->texture);
  94
  95         cl_aligned_reloc(job, &job->uniforms, uniforms, rsc->bo, 0);
  96 }
  97
  98
  99 #define SWIZ(x,y,z,w) {          \
 100         PIPE_SWIZZLE_##x, \
 101         PIPE_SWIZZLE_##y, \
 102         PIPE_SWIZZLE_##z, \
 103         PIPE_SWIZZLE_##w  \
 104 }
 105
 106 static void
 107 write_texture_border_color(struct vc4_job *job,
 108                            struct vc4_cl_out **uniforms,
 109                            struct vc4_texture_stateobj *texstate,
 110                            uint32_t unit)
 111 {
 112         struct pipe_sampler_state *sampler = texstate->samplers[unit];
 113         struct pipe_sampler_view *texture = texstate->textures[unit];
 114         struct vc4_resource *rsc = vc4_resource(texture->texture);
 115         union util_color uc;
 116
 117         const struct util_format_description *tex_format_desc =
 118                 util_format_description(texture->format);
 119
 120         float border_color[4];
 121         for (int i = 0; i < 4; i++)
 122                 border_color[i] = sampler->border_color.f[i];
 123         if (util_format_is_srgb(texture->format)) {
 124                 for (int i = 0; i < 3; i++)
 125                         border_color[i] =
 126                                 util_format_linear_to_srgb_float(border_color[i]);
 127         }
 128
 129         /* Turn the border color into the layout of channels that it would
 130          * have when stored as texture contents.
 131          */
 132         float storage_color[4];
 133         util_format_unswizzle_4f(storage_color,
 134                                  border_color,
 135                                  tex_format_desc->swizzle);
 136
 137         /* Now, pack so that when the vc4_format-sampled texture contents are
 138          * replaced with our border color, the vc4_get_format_swizzle()
 139          * swizzling will get the right channels.
 140          */
 141         if (util_format_is_depth_or_stencil(texture->format)) {
 142                 uc.ui[0] = util_pack_z(PIPE_FORMAT_Z24X8_UNORM,
 143                                        sampler->border_color.f[0]) << 8;
 144         } else {
 145                 switch (rsc->vc4_format) {
 146                 default:
 147                 case VC4_TEXTURE_TYPE_RGBA8888:
 148                         util_pack_color(storage_color,
 149                                         PIPE_FORMAT_R8G8B8A8_UNORM, &uc);
 150                         break;
 151                 case VC4_TEXTURE_TYPE_RGBA4444:
 152                 case VC4_TEXTURE_TYPE_RGBA5551:
 153                         util_pack_color(storage_color,
 154                                         PIPE_FORMAT_A8B8G8R8_UNORM, &uc);
 155                         break;
 156                 case VC4_TEXTURE_TYPE_RGB565:
 157                         util_pack_color(storage_color,
 158                                         PIPE_FORMAT_B8G8R8A8_UNORM, &uc);
 159                         break;
 160                 case VC4_TEXTURE_TYPE_ALPHA:
 161                         uc.ui[0] = float_to_ubyte(storage_color[0]) << 24;
 162                         break;
 163                 case VC4_TEXTURE_TYPE_LUMALPHA:
 164                         uc.ui[0] = ((float_to_ubyte(storage_color[1]) << 24) |
 165                                     (float_to_ubyte(storage_color[0]) << 0));
 166                         break;
 167                 }
 168         }
 169
 170         cl_aligned_u32(uniforms, uc.ui[0]);
 171 }
 172
 173 static uint32_t
 174 get_texrect_scale(struct vc4_texture_stateobj *texstate,
 175                   enum quniform_contents contents,
 176                   uint32_t data)
 177 {
 178         struct pipe_sampler_view *texture = texstate->textures[data];
 179         uint32_t dim;
 180
 181         if (contents == QUNIFORM_TEXRECT_SCALE_X)
 182                 dim = texture->texture->width0;
 183         else
 184                 dim = texture->texture->height0;
 185
 186         return fui(1.0f / dim);
 187 }
 188
 189 static struct vc4_bo *
 190 vc4_upload_ubo(struct vc4_context *vc4,
 191                struct vc4_compiled_shader *shader,
 192                const uint32_t *gallium_uniforms)
 193 {
 194         if (!shader->ubo_size)
 195                 return NULL;
 196
 197         struct vc4_bo *ubo = vc4_bo_alloc(vc4->screen, shader->ubo_size, "ubo");
 198         void *data = vc4_bo_map(ubo);
 199         for (uint32_t i = 0; i < shader->num_ubo_ranges; i++) {
 200                 memcpy(data + shader->ubo_ranges[i].dst_offset,
 201                        ((const void *)gallium_uniforms +
 202                         shader->ubo_ranges[i].src_offset),
 203                        shader->ubo_ranges[i].size);
 204         }
 205
 206         return ubo;
 207 }
 208
 209 void
 210 vc4_write_uniforms(struct vc4_context *vc4, struct vc4_compiled_shader *shader,
 211                    struct vc4_constbuf_stateobj *cb,
 212                    struct vc4_texture_stateobj *texstate)
 213 {
 214         struct vc4_shader_uniform_info *uinfo = &shader->uniforms;
 215         struct vc4_job *job = vc4->job;
 216         const uint32_t *gallium_uniforms = cb->cb[0].user_buffer;
 217         struct vc4_bo *ubo = vc4_upload_ubo(vc4, shader, gallium_uniforms);
 218
 219         cl_ensure_space(&job->uniforms, (uinfo->count +
 220                                          uinfo->num_texture_samples) * 4);
 221
 222         struct vc4_cl_out *uniforms =
 223                 cl_start_shader_reloc(&job->uniforms,
 224                                       uinfo->num_texture_samples);
 225
 226         for (int i = 0; i < uinfo->count; i++) {
 227                 enum quniform_contents contents = uinfo->contents[i];
 228                 uint32_t data = uinfo->data[i];
 229
 230                 switch (contents) {
 231                 case QUNIFORM_CONSTANT:
 232                         cl_aligned_u32(&uniforms, data);
 233                         break;
 234                 case QUNIFORM_UNIFORM:
 235                         cl_aligned_u32(&uniforms,
 236                                        gallium_uniforms[data]);
 237                         break;
 238                 case QUNIFORM_VIEWPORT_X_SCALE:
 239                         cl_aligned_f(&uniforms, vc4->viewport.scale[0] * 16.0f);
 240                         break;
 241                 case QUNIFORM_VIEWPORT_Y_SCALE:
 242                         cl_aligned_f(&uniforms, vc4->viewport.scale[1] * 16.0f);
 243                         break;
 244
 245                 case QUNIFORM_VIEWPORT_Z_OFFSET:
 246                         cl_aligned_f(&uniforms, vc4->viewport.translate[2]);
 247                         break;
 248                 case QUNIFORM_VIEWPORT_Z_SCALE:
 249                         cl_aligned_f(&uniforms, vc4->viewport.scale[2]);
 250                         break;
 251
 252                 case QUNIFORM_USER_CLIP_PLANE:
 253                         cl_aligned_f(&uniforms,
 254                                      vc4->clip.ucp[data / 4][data % 4]);
 255                         break;
 256
 257                 case QUNIFORM_TEXTURE_CONFIG_P0:
 258                         write_texture_p0(job, &uniforms, texstate, data);
 259                         break;
 260
 261                 case QUNIFORM_TEXTURE_CONFIG_P1:
 262                         write_texture_p1(job, &uniforms, texstate, data);
 263                         break;
 264
 265                 case QUNIFORM_TEXTURE_CONFIG_P2:
 266                         write_texture_p2(job, &uniforms, texstate, data);
 267                         break;
 268
 269                 case QUNIFORM_TEXTURE_FIRST_LEVEL:
 270                         write_texture_first_level(job, &uniforms, texstate,
 271                                                   data);
 272                         break;
 273
 274                 case QUNIFORM_UBO_ADDR:
 275                         if (data == 0) {
 276                                 cl_aligned_reloc(job, &job->uniforms,
 277                                                  &uniforms, ubo, 0);
 278                         } else {
 279                                 struct pipe_constant_buffer *c =
 280                                         &cb->cb[data];
 281                                 struct vc4_resource *rsc =
 282                                         vc4_resource(c->buffer);
 283
 284                                 cl_aligned_reloc(job, &job->uniforms,
 285                                                  &uniforms,
 286                                                  rsc->bo, c->buffer_offset);
 287                         }
 288                         break;
 289
 290                 case QUNIFORM_TEXTURE_MSAA_ADDR:
 291                         write_texture_msaa_addr(job, &uniforms, texstate, data);
 292                         break;
 293
 294                 case QUNIFORM_TEXTURE_BORDER_COLOR:
 295                         write_texture_border_color(job, &uniforms,
 296                                                    texstate, data);
 297                         break;
 298
 299                 case QUNIFORM_TEXRECT_SCALE_X:
 300                 case QUNIFORM_TEXRECT_SCALE_Y:
 301                         cl_aligned_u32(&uniforms,
 302                                        get_texrect_scale(texstate,
 303                                                          uinfo->contents[i],
 304                                                          data));
 305                         break;
 306
 307                 case QUNIFORM_BLEND_CONST_COLOR_X:
 308                 case QUNIFORM_BLEND_CONST_COLOR_Y:
 309                 case QUNIFORM_BLEND_CONST_COLOR_Z:
 310                 case QUNIFORM_BLEND_CONST_COLOR_W:
 311                         cl_aligned_f(&uniforms,
 312                                      CLAMP(vc4->blend_color.f.color[uinfo->contents[i] -
 313                                                                     QUNIFORM_BLEND_CONST_COLOR_X],
 314                                            0, 1));
 315                         break;
 316
 317                 case QUNIFORM_BLEND_CONST_COLOR_RGBA: {
 318                         const uint8_t *format_swiz =
 319                                 vc4_get_format_swizzle(vc4->framebuffer.cbufs[0]->format);
 320                         uint32_t color = 0;
 321                         for (int i = 0; i < 4; i++) {
 322                                 if (format_swiz[i] >= 4)
 323                                         continue;
 324
 325                                 color |= (vc4->blend_color.ub[format_swiz[i]] <<
 326                                           (i * 8));
 327                         }
 328                         cl_aligned_u32(&uniforms, color);
 329                         break;
 330                 }
 331
 332                 case QUNIFORM_BLEND_CONST_COLOR_AAAA: {
 333                         uint8_t a = vc4->blend_color.ub[3];
 334                         cl_aligned_u32(&uniforms, ((a) |
 335                                                    (a << 8) |
 336                                                    (a << 16) |
 337                                                    (a << 24)));
 338                         break;
 339                 }
 340
 341                 case QUNIFORM_STENCIL:
 342                         cl_aligned_u32(&uniforms,
 343                                        vc4->zsa->stencil_uniforms[data] |
 344                                        (data <= 1 ?
 345                                         (vc4->stencil_ref.ref_value[data] << 8) :
 346                                         0));
 347                         break;
 348
 349                 case QUNIFORM_ALPHA_REF:
 350                         cl_aligned_f(&uniforms,
 351                                      vc4->zsa->base.alpha.ref_value);
 352                         break;
 353
 354                 case QUNIFORM_SAMPLE_MASK:
 355                         cl_aligned_u32(&uniforms, vc4->sample_mask);
 356                         break;
 357
 358                 case QUNIFORM_UNIFORMS_ADDRESS:
 359                         /* This will be filled in by the kernel. */
 360                         cl_aligned_u32(&uniforms, 0xd0d0d0d0);
 361                         break;
 362                 }
 363
 364                 if (false) {
 365                         uint32_t written_val = *((uint32_t *)uniforms - 1);
 366                         char *desc = qir_describe_uniform(uinfo->contents[i],
 367                                                           uinfo->data[i],
 368                                                           gallium_uniforms);
 369
 370                         fprintf(stderr, "%p/%d: 0x%08x %s\n",
 371                                 shader, i, written_val, desc);
 372
 373                         ralloc_free(desc);
 374                 }
 375         }
 376
 377         cl_end(&job->uniforms, uniforms);
 378
 379         vc4_bo_unreference(&ubo);
 380 }
 381
 382 void
 383 vc4_set_shader_uniform_dirty_flags(struct vc4_compiled_shader *shader)
 384 {
 385         uint32_t dirty = 0;
 386
 387         for (int i = 0; i < shader->uniforms.count; i++) {
 388                 switch (shader->uniforms.contents[i]) {
 389                 case QUNIFORM_CONSTANT:
 390                 case QUNIFORM_UNIFORMS_ADDRESS:
 391                         break;
 392                 case QUNIFORM_UNIFORM:
 393                 case QUNIFORM_UBO_ADDR:
 394                         dirty |= VC4_DIRTY_CONSTBUF;
 395                         break;
 396
 397                 case QUNIFORM_VIEWPORT_X_SCALE:
 398                 case QUNIFORM_VIEWPORT_Y_SCALE:
 399                 case QUNIFORM_VIEWPORT_Z_OFFSET:
 400                 case QUNIFORM_VIEWPORT_Z_SCALE:
 401                         dirty |= VC4_DIRTY_VIEWPORT;
 402                         break;
 403
 404                 case QUNIFORM_USER_CLIP_PLANE:
 405                         dirty |= VC4_DIRTY_CLIP;
 406                         break;
 407
 408                 case QUNIFORM_TEXTURE_CONFIG_P0:
 409                 case QUNIFORM_TEXTURE_CONFIG_P1:
 410                 case QUNIFORM_TEXTURE_CONFIG_P2:
 411                 case QUNIFORM_TEXTURE_BORDER_COLOR:
 412                 case QUNIFORM_TEXTURE_FIRST_LEVEL:
 413                 case QUNIFORM_TEXTURE_MSAA_ADDR:
 414                 case QUNIFORM_TEXRECT_SCALE_X:
 415                 case QUNIFORM_TEXRECT_SCALE_Y:
 416                         /* We could flag this on just the stage we're
 417                          * compiling for, but it's not passed in.
 418                          */
 419                         dirty |= VC4_DIRTY_FRAGTEX | VC4_DIRTY_VERTTEX;
 420                         break;
 421
 422                 case QUNIFORM_BLEND_CONST_COLOR_X:
 423                 case QUNIFORM_BLEND_CONST_COLOR_Y:
 424                 case QUNIFORM_BLEND_CONST_COLOR_Z:
 425                 case QUNIFORM_BLEND_CONST_COLOR_W:
 426                 case QUNIFORM_BLEND_CONST_COLOR_RGBA:
 427                 case QUNIFORM_BLEND_CONST_COLOR_AAAA:
 428                         dirty |= VC4_DIRTY_BLEND_COLOR;
 429                         break;
 430
 431                 case QUNIFORM_STENCIL:
 432                 case QUNIFORM_ALPHA_REF:
 433                         dirty |= VC4_DIRTY_ZSA;
 434                         break;
 435
 436                 case QUNIFORM_SAMPLE_MASK:
 437                         dirty |= VC4_DIRTY_SAMPLE_MASK;
 438                         break;
 439                 }
 440         }
 441
 442         shader->uniform_dirty_bits = dirty;
 443 }