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 union gl_color_union 377 brw_meta_convert_fast_clear_color(const struct brw_context *brw, 378 const struct intel_mipmap_tree *mt, 379 const union gl_color_union *color) 380 { 381 union gl_color_union override_color = *color; 382 383 /* The sampler doesn't look at the format of the surface when the fast 384 * clear color is used so we need to implement luminance, intensity and 385 * missing components manually. 386 */ 387 switch (_mesa_get_format_base_format(mt->format)) { 388 case GL_INTENSITY: 389 override_color.ui[3] = override_color.ui[0]; 390 /* flow through */ 391 case GL_LUMINANCE: 392 case GL_LUMINANCE_ALPHA: 393 override_color.ui[1] = override_color.ui[0]; 394 override_color.ui[2] = override_color.ui[0]; 395 break; 396 default: 397 for (int i = 0; i < 3; i++) { 398 if (!_mesa_format_has_color_component(mt->format, i)) 399 override_color.ui[i] = 0; 400 } 401 break; 402 } 403 404 if (!_mesa_format_has_color_component(mt->format, 3)) { 405 if (_mesa_is_format_integer_color(mt->format)) 406 override_color.ui[3] = 1; 407 else 408 override_color.f[3] = 1.0f; 409 } 410 411 /* Handle linear to SRGB conversion */ 412 if (brw->ctx.Color.sRGBEnabled && 413 _mesa_get_srgb_format_linear(mt->format) != mt->format) { 414 for (int i = 0; i < 3; i++) { 415 override_color.f[i] = 416 util_format_linear_to_srgb_float(override_color.f[i]); 417 } 418 } 419 420 return override_color; 421 } 422 423 /* Returned boolean tells if the given color differs from the current. */ 424 bool 425 brw_meta_set_fast_clear_color(struct brw_context *brw, 426 union gl_color_union *curr_color, 427 const union gl_color_union *new_color) 428 { 429 bool updated; 430 431 if (brw->gen >= 9) { 432 updated = memcmp(curr_color, new_color, sizeof(*curr_color)); 433 *curr_color = *new_color; 434 } else { 435 const uint32_t old_color_value = *(uint32_t *)curr_color; 436 uint32_t adjusted = 0; 437 438 for (int i = 0; i < 4; i++) { 439 /* Testing for non-0 works for integer and float colors */ 440 if (new_color->f[i] != 0.0f) { 441 adjusted |= 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT + (3 - i)); 442 } 443 } 444 445 updated = (old_color_value != adjusted); 446 *(uint32_t *)curr_color = adjusted; 447 } 448 449 return updated; 450 } 451
