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

   1 /*
   2  * Copyright © 2014 Intel Corporation
   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 "brw_context.h"
  25 #include "brw_defines.h"
  26 #include "intel_fbo.h"
  27 #include "brw_meta_util.h"
  28 #include "brw_state.h"
  29 #include "main/blend.h"
  30 #include "main/fbobject.h"
  31 #include "util/format_srgb.h"
  32
  33 /**
  34  * Helper function for handling mirror image blits.
  35  *
  36  * If coord0 > coord1, swap them and invert the "mirror" boolean.
  37  */
  38 static inline void
  39 fixup_mirroring(bool *mirror, float *coord0, float *coord1)
  40 {
  41    if (*coord0 > *coord1) {
  42       *mirror = !*mirror;
  43       float tmp = *coord0;
  44       *coord0 = *coord1;
  45       *coord1 = tmp;
  46    }
  47 }
  48
  49 /**
  50  * Compute the number of pixels to clip for each side of a rect
  51  *
  52  * \param x0 The rect's left coordinate
  53  * \param y0 The rect's bottom coordinate
  54  * \param x1 The rect's right coordinate
  55  * \param y1 The rect's top coordinate
  56  * \param min_x The clipping region's left coordinate
  57  * \param min_y The clipping region's bottom coordinate
  58  * \param max_x The clipping region's right coordinate
  59  * \param max_y The clipping region's top coordinate
  60  * \param clipped_x0 The number of pixels to clip from the left side
  61  * \param clipped_y0 The number of pixels to clip from the bottom side
  62  * \param clipped_x1 The number of pixels to clip from the right side
  63  * \param clipped_y1 The number of pixels to clip from the top side
  64  *
  65  * \return false if we clip everything away, true otherwise
  66  */
  67 static inline bool
  68 compute_pixels_clipped(float x0, float y0, float x1, float y1,
  69                        float min_x, float min_y, float max_x, float max_y,
  70                        float *clipped_x0, float *clipped_y0, float *clipped_x1, float *clipped_y1)
  71 {
  72    /* If we are going to clip everything away, stop. */
  73    if (!(min_x <= max_x &&
  74          min_y <= max_y &&
  75          x0 <= max_x &&
  76          y0 <= max_y &&
  77          min_x <= x1 &&
  78          min_y <= y1 &&
  79          x0 <= x1 &&
  80          y0 <= y1)) {
  81       return false;
  82    }
  83
  84    if (x0 < min_x)
  85       *clipped_x0 = min_x - x0;
  86    else
  87       *clipped_x0 = 0;
  88    if (max_x < x1)
  89       *clipped_x1 = x1 - max_x;
  90    else
  91       *clipped_x1 = 0;
  92
  93    if (y0 < min_y)
  94       *clipped_y0 = min_y - y0;
  95    else
  96       *clipped_y0 = 0;
  97    if (max_y < y1)
  98       *clipped_y1 = y1 - max_y;
  99    else
 100       *clipped_y1 = 0;
 101
 102    return true;
 103 }
 104
 105 /**
 106  * Clips a coordinate (left, right, top or bottom) for the src or dst rect
 107  * (whichever requires the largest clip) and adjusts the coordinate
 108  * for the other rect accordingly.
 109  *
 110  * \param mirror true if mirroring is required
 111  * \param src the source rect coordinate (for example srcX0)
 112  * \param dst0 the dst rect coordinate (for example dstX0)
 113  * \param dst1 the opposite dst rect coordinate (for example dstX1)
 114  * \param clipped_src0 number of pixels to clip from the src coordinate
 115  * \param clipped_dst0 number of pixels to clip from the dst coordinate
 116  * \param clipped_dst1 number of pixels to clip from the opposite dst coordinate
 117  * \param scale the src vs dst scale involved for that coordinate
 118  * \param isLeftOrBottom true if we are clipping the left or bottom sides
 119  *        of the rect.
 120  */
 121 static inline void
 122 clip_coordinates(bool mirror,
 123                  float *src, float *dst0, float *dst1,
 124                  float clipped_src0,
 125                  float clipped_dst0,
 126                  float clipped_dst1,
 127                  float scale,
 128                  bool isLeftOrBottom)
 129 {
 130    /* When clipping we need to add or subtract pixels from the original
 131     * coordinates depending on whether we are acting on the left/bottom
 132     * or right/top sides of the rect respectively. We assume we have to
 133     * add them in the code below, and multiply by -1 when we should
 134     * subtract.
 135     */
 136    int mult = isLeftOrBottom ? 1 : -1;
 137
 138    if (!mirror) {
 139       if (clipped_src0 >= clipped_dst0 * scale) {
 140          *src += clipped_src0 * mult;
 141          *dst0 += clipped_src0 / scale * mult;
 142       } else {
 143          *dst0 += clipped_dst0 * mult;
 144          *src += clipped_dst0 * scale * mult;
 145       }
 146    } else {
 147       if (clipped_src0 >= clipped_dst1 * scale) {
 148          *src += clipped_src0 * mult;
 149          *dst1 -= clipped_src0 / scale * mult;
 150       } else {
 151          *dst1 -= clipped_dst1 * mult;
 152          *src += clipped_dst1 * scale * mult;
 153       }
 154    }
 155 }
 156
 157 bool
 158 brw_meta_mirror_clip_and_scissor(const struct gl_context *ctx,
 159                                  const struct gl_framebuffer *read_fb,
 160                                  const struct gl_framebuffer *draw_fb,
 161                                  GLfloat *srcX0, GLfloat *srcY0,
 162                                  GLfloat *srcX1, GLfloat *srcY1,
 163                                  GLfloat *dstX0, GLfloat *dstY0,
 164                                  GLfloat *dstX1, GLfloat *dstY1,
 165                                  bool *mirror_x, bool *mirror_y)
 166 {
 167    *mirror_x = false;
 168    *mirror_y = false;
 169
 170    /* Detect if the blit needs to be mirrored */
 171    fixup_mirroring(mirror_x, srcX0, srcX1);
 172    fixup_mirroring(mirror_x, dstX0, dstX1);
 173    fixup_mirroring(mirror_y, srcY0, srcY1);
 174    fixup_mirroring(mirror_y, dstY0, dstY1);
 175
 176    /* Compute number of pixels to clip for each side of both rects. Return
 177     * early if we are going to clip everything away.
 178     */
 179    float clip_src_x0;
 180    float clip_src_x1;
 181    float clip_src_y0;
 182    float clip_src_y1;
 183    float clip_dst_x0;
 184    float clip_dst_x1;
 185    float clip_dst_y0;
 186    float clip_dst_y1;
 187
 188    if (!compute_pixels_clipped(*srcX0, *srcY0, *srcX1, *srcY1,
 189                                0, 0, read_fb->Width, read_fb->Height,
 190                                &clip_src_x0, &clip_src_y0, &clip_src_x1, &clip_src_y1))
 191       return true;
 192
 193    if (!compute_pixels_clipped(*dstX0, *dstY0, *dstX1, *dstY1,
 194                                draw_fb->_Xmin, draw_fb->_Ymin, draw_fb->_Xmax, draw_fb->_Ymax,
 195                                &clip_dst_x0, &clip_dst_y0, &clip_dst_x1, &clip_dst_y1))
 196       return true;
 197
 198    /* When clipping any of the two rects we need to adjust the coordinates in
 199     * the other rect considering the scaling factor involved. To obtain the best
 200     * precision we want to make sure that we only clip once per side to avoid
 201     * accumulating errors due to the scaling adjustment.
 202     *
 203     * For example, if srcX0 and dstX0 need both to be clipped we want to avoid
 204     * the situation where we clip srcX0 first, then adjust dstX0 accordingly
 205     * but then we realize that the resulting dstX0 still needs to be clipped,
 206     * so we clip dstX0 and adjust srcX0 again. Because we are applying scaling
 207     * factors to adjust the coordinates in each clipping pass we lose some
 208     * precision and that can affect the results of the blorp blit operation
 209     * slightly. What we want to do here is detect the rect that we should
 210     * clip first for each side so that when we adjust the other rect we ensure
 211     * the resulting coordinate does not need to be clipped again.
 212     *
 213     * The code below implements this by comparing the number of pixels that
 214     * we need to clip for each side of both rects  considering the scales
 215     * involved. For example, clip_src_x0 represents the number of pixels to be
 216     * clipped for the src rect's left side, so if clip_src_x0 = 5,
 217     * clip_dst_x0 = 4 and scaleX = 2 it means that we are clipping more from
 218     * the dst rect so we should clip dstX0 only and adjust srcX0. This is
 219     * because clipping 4 pixels in the dst is equivalent to clipping
 220     * 4 * 2 = 8 > 5 in the src.
 221     */
 222
 223    float scaleX = (float) (*srcX1 - *srcX0) / (*dstX1 - *dstX0);
 224    float scaleY = (float) (*srcY1 - *srcY0) / (*dstY1 - *dstY0);
 225
 226    /* Clip left side */
 227    clip_coordinates(*mirror_x,
 228                     srcX0, dstX0, dstX1,
 229                     clip_src_x0, clip_dst_x0, clip_dst_x1,
 230                     scaleX, true);
 231
 232    /* Clip right side */
 233    clip_coordinates(*mirror_x,
 234                     srcX1, dstX1, dstX0,
 235                     clip_src_x1, clip_dst_x1, clip_dst_x0,
 236                     scaleX, false);
 237
 238    /* Clip bottom side */
 239    clip_coordinates(*mirror_y,
 240                     srcY0, dstY0, dstY1,
 241                     clip_src_y0, clip_dst_y0, clip_dst_y1,
 242                     scaleY, true);
 243
 244    /* Clip top side */
 245    clip_coordinates(*mirror_y,
 246                     srcY1, dstY1, dstY0,
 247                     clip_src_y1, clip_dst_y1, clip_dst_y0,
 248                     scaleY, false);
 249
 250    /* Account for the fact that in the system framebuffer, the origin is at
 251     * the lower left.
 252     */
 253    if (_mesa_is_winsys_fbo(read_fb)) {
 254       GLint tmp = read_fb->Height - *srcY0;
 255       *srcY0 = read_fb->Height - *srcY1;
 256       *srcY1 = tmp;
 257       *mirror_y = !*mirror_y;
 258    }
 259    if (_mesa_is_winsys_fbo(draw_fb)) {
 260       GLint tmp = draw_fb->Height - *dstY0;
 261       *dstY0 = draw_fb->Height - *dstY1;
 262       *dstY1 = tmp;
 263       *mirror_y = !*mirror_y;
 264    }
 265
 266    return false;
 267 }
 268
 269 /**
 270  * Creates a new named renderbuffer that wraps the first slice
 271  * of an existing miptree.
 272  *
 273  * Clobbers the current renderbuffer binding (ctx->CurrentRenderbuffer).
 274  */
 275 struct gl_renderbuffer *
 276 brw_get_rb_for_slice(struct brw_context *brw,
 277                      struct intel_mipmap_tree *mt,
 278                      unsigned level, unsigned layer, bool flat)
 279 {
 280    struct gl_context *ctx = &brw->ctx;
 281    struct gl_renderbuffer *rb = ctx->Driver.NewRenderbuffer(ctx, 0xDEADBEEF);
 282    struct intel_renderbuffer *irb = intel_renderbuffer(rb);
 283
 284    rb->RefCount = 1;
 285    rb->Format = mt->format;
 286    rb->_BaseFormat = _mesa_get_format_base_format(mt->format);
 287
 288    /* Program takes care of msaa and mip-level access manually for stencil.
 289     * The surface is also treated as Y-tiled instead of as W-tiled calling for
 290     * twice the width and half the height in dimensions.
 291     */
 292    if (flat) {
 293       const unsigned halign_stencil = 8;
 294
 295       rb->NumSamples = 0;
 296       rb->Width = ALIGN(mt->total_width, halign_stencil) * 2;
 297       rb->Height = (mt->total_height / mt->physical_depth0) / 2;
 298       irb->mt_level = 0;
 299    } else {
 300       rb->NumSamples = mt->num_samples;
 301       rb->Width = mt->logical_width0;
 302       rb->Height = mt->logical_height0;
 303       irb->mt_level = level;
 304    }
 305
 306    irb->mt_layer = layer;
 307
 308    intel_miptree_reference(&irb->mt, mt);
 309
 310    return rb;
 311 }
 312
 313 /**
 314  * Determine if fast color clear supports the given clear color.
 315  *
 316  * Fast color clear can only clear to color values of 1.0 or 0.0.  At the
 317  * moment we only support floating point, unorm, and snorm buffers.
 318  */
 319 bool
 320 brw_is_color_fast_clear_compatible(struct brw_context *brw,
 321                                    const struct intel_mipmap_tree *mt,
 322                                    const union gl_color_union *color)
 323 {
 324    const struct gl_context *ctx = &brw->ctx;
 325
 326    /* If we're mapping the render format to a different format than the
 327     * format we use for texturing then it is a bit questionable whether it
 328     * should be possible to use a fast clear. Although we only actually
 329     * render using a renderable format, without the override workaround it
 330     * wouldn't be possible to have a non-renderable surface in a fast clear
 331     * state so the hardware probably legitimately doesn't need to support
 332     * this case. At least on Gen9 this really does seem to cause problems.
 333     */
 334    if (brw->gen >= 9 &&
 335        brw_format_for_mesa_format(mt->format) !=
 336        brw->render_target_format[mt->format])
 337       return false;
 338
 339    /* Gen9 doesn't support fast clear on single-sampled SRGB buffers. When
 340     * GL_FRAMEBUFFER_SRGB is enabled any color renderbuffers will be
 341     * resolved in intel_update_state. In that case it's pointless to do a
 342     * fast clear because it's very likely to be immediately resolved.
 343     */
 344    if (brw->gen >= 9 &&
 345        mt->num_samples <= 1 &&
 346        ctx->Color.sRGBEnabled &&
 347        _mesa_get_srgb_format_linear(mt->format) != mt->format)
 348       return false;
 349
 350    const mesa_format format = _mesa_get_render_format(ctx, mt->format);
 351    if (_mesa_is_format_integer_color(format)) {
 352       if (brw->gen >= 8) {
 353          perf_debug("Integer fast clear not enabled for (%s)",
 354                     _mesa_get_format_name(format));
 355       }
 356       return false;
 357    }
 358
 359    for (int i = 0; i < 4; i++) {
 360       if (!_mesa_format_has_color_component(format, i)) {
 361          continue;
 362       }
 363
 364       if (brw->gen < 9 &&
 365           color->f[i] != 0.0f && color->f[i] != 1.0f) {
 366          return false;
 367       }
 368    }
 369    return true;
 370 }
 371
 372 /**
 373  * Convert the given color to a bitfield suitable for ORing into DWORD 7 of
 374  * SURFACE_STATE (DWORD 12-15 on SKL+).
 375  *
 376  * Returned boolean tells if the given color differs from the stored.
 377  */
 378 bool
 379 brw_meta_set_fast_clear_color(struct brw_context *brw,
 380                               struct intel_mipmap_tree *mt,
 381                               const union gl_color_union *color)
 382 {
 383    union gl_color_union override_color = *color;
 384
 385    /* The sampler doesn't look at the format of the surface when the fast
 386     * clear color is used so we need to implement luminance, intensity and
 387     * missing components manually.
 388     */
 389    switch (_mesa_get_format_base_format(mt->format)) {
 390    case GL_INTENSITY:
 391       override_color.ui[3] = override_color.ui[0];
 392       /* flow through */
 393    case GL_LUMINANCE:
 394    case GL_LUMINANCE_ALPHA:
 395       override_color.ui[1] = override_color.ui[0];
 396       override_color.ui[2] = override_color.ui[0];
 397       break;
 398    default:
 399       for (int i = 0; i < 3; i++) {
 400          if (!_mesa_format_has_color_component(mt->format, i))
 401             override_color.ui[i] = 0;
 402       }
 403       break;
 404    }
 405
 406    if (!_mesa_format_has_color_component(mt->format, 3)) {
 407       if (_mesa_is_format_integer_color(mt->format))
 408          override_color.ui[3] = 1;
 409       else
 410          override_color.f[3] = 1.0f;
 411    }
 412
 413    /* Handle linear→SRGB conversion */
 414    if (brw->ctx.Color.sRGBEnabled &&
 415        _mesa_get_srgb_format_linear(mt->format) != mt->format) {
 416       for (int i = 0; i < 3; i++) {
 417          override_color.f[i] =
 418             util_format_linear_to_srgb_float(override_color.f[i]);
 419       }
 420    }
 421
 422    bool updated;
 423    if (brw->gen >= 9) {
 424       updated = memcmp(&mt->gen9_fast_clear_color, &override_color,
 425                        sizeof(mt->gen9_fast_clear_color));
 426       mt->gen9_fast_clear_color = override_color;
 427    } else {
 428       const uint32_t old_color_value = mt->fast_clear_color_value;
 429
 430       mt->fast_clear_color_value = 0;
 431       for (int i = 0; i < 4; i++) {
 432          /* Testing for non-0 works for integer and float colors */
 433          if (override_color.f[i] != 0.0f) {
 434              mt->fast_clear_color_value |=
 435                 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT + (3 - i));
 436          }
 437       }
 438
 439       updated = (old_color_value != mt->fast_clear_color_value);
 440    }
 441
 442    return updated;
 443 }