| /* |
| * Copyright © 2014 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| |
| #include "brw_context.h" |
| #include "brw_defines.h" |
| #include "intel_fbo.h" |
| #include "brw_meta_util.h" |
| #include "brw_state.h" |
| #include "main/blend.h" |
| #include "main/fbobject.h" |
| #include "util/format_srgb.h" |
| |
| /** |
| * Helper function for handling mirror image blits. |
| * |
| * If coord0 > coord1, swap them and invert the "mirror" boolean. |
| */ |
| static inline void |
| fixup_mirroring(bool *mirror, float *coord0, float *coord1) |
| { |
| if (*coord0 > *coord1) { |
| *mirror = !*mirror; |
| float tmp = *coord0; |
| *coord0 = *coord1; |
| *coord1 = tmp; |
| } |
| } |
| |
| /** |
| * Compute the number of pixels to clip for each side of a rect |
| * |
| * \param x0 The rect's left coordinate |
| * \param y0 The rect's bottom coordinate |
| * \param x1 The rect's right coordinate |
| * \param y1 The rect's top coordinate |
| * \param min_x The clipping region's left coordinate |
| * \param min_y The clipping region's bottom coordinate |
| * \param max_x The clipping region's right coordinate |
| * \param max_y The clipping region's top coordinate |
| * \param clipped_x0 The number of pixels to clip from the left side |
| * \param clipped_y0 The number of pixels to clip from the bottom side |
| * \param clipped_x1 The number of pixels to clip from the right side |
| * \param clipped_y1 The number of pixels to clip from the top side |
| * |
| * \return false if we clip everything away, true otherwise |
| */ |
| static inline bool |
| compute_pixels_clipped(float x0, float y0, float x1, float y1, |
| float min_x, float min_y, float max_x, float max_y, |
| float *clipped_x0, float *clipped_y0, float *clipped_x1, float *clipped_y1) |
| { |
| /* If we are going to clip everything away, stop. */ |
| if (!(min_x <= max_x && |
| min_y <= max_y && |
| x0 <= max_x && |
| y0 <= max_y && |
| min_x <= x1 && |
| min_y <= y1 && |
| x0 <= x1 && |
| y0 <= y1)) { |
| return false; |
| } |
| |
| if (x0 < min_x) |
| *clipped_x0 = min_x - x0; |
| else |
| *clipped_x0 = 0; |
| if (max_x < x1) |
| *clipped_x1 = x1 - max_x; |
| else |
| *clipped_x1 = 0; |
| |
| if (y0 < min_y) |
| *clipped_y0 = min_y - y0; |
| else |
| *clipped_y0 = 0; |
| if (max_y < y1) |
| *clipped_y1 = y1 - max_y; |
| else |
| *clipped_y1 = 0; |
| |
| return true; |
| } |
| |
| /** |
| * Clips a coordinate (left, right, top or bottom) for the src or dst rect |
| * (whichever requires the largest clip) and adjusts the coordinate |
| * for the other rect accordingly. |
| * |
| * \param mirror true if mirroring is required |
| * \param src the source rect coordinate (for example srcX0) |
| * \param dst0 the dst rect coordinate (for example dstX0) |
| * \param dst1 the opposite dst rect coordinate (for example dstX1) |
| * \param clipped_src0 number of pixels to clip from the src coordinate |
| * \param clipped_dst0 number of pixels to clip from the dst coordinate |
| * \param clipped_dst1 number of pixels to clip from the opposite dst coordinate |
| * \param scale the src vs dst scale involved for that coordinate |
| * \param isLeftOrBottom true if we are clipping the left or bottom sides |
| * of the rect. |
| */ |
| static inline void |
| clip_coordinates(bool mirror, |
| float *src, float *dst0, float *dst1, |
| float clipped_src0, |
| float clipped_dst0, |
| float clipped_dst1, |
| float scale, |
| bool isLeftOrBottom) |
| { |
| /* When clipping we need to add or subtract pixels from the original |
| * coordinates depending on whether we are acting on the left/bottom |
| * or right/top sides of the rect respectively. We assume we have to |
| * add them in the code below, and multiply by -1 when we should |
| * subtract. |
| */ |
| int mult = isLeftOrBottom ? 1 : -1; |
| |
| if (!mirror) { |
| if (clipped_src0 >= clipped_dst0 * scale) { |
| *src += clipped_src0 * mult; |
| *dst0 += clipped_src0 / scale * mult; |
| } else { |
| *dst0 += clipped_dst0 * mult; |
| *src += clipped_dst0 * scale * mult; |
| } |
| } else { |
| if (clipped_src0 >= clipped_dst1 * scale) { |
| *src += clipped_src0 * mult; |
| *dst1 -= clipped_src0 / scale * mult; |
| } else { |
| *dst1 -= clipped_dst1 * mult; |
| *src += clipped_dst1 * scale * mult; |
| } |
| } |
| } |
| |
| bool |
| brw_meta_mirror_clip_and_scissor(const struct gl_context *ctx, |
| const struct gl_framebuffer *read_fb, |
| const struct gl_framebuffer *draw_fb, |
| GLfloat *srcX0, GLfloat *srcY0, |
| GLfloat *srcX1, GLfloat *srcY1, |
| GLfloat *dstX0, GLfloat *dstY0, |
| GLfloat *dstX1, GLfloat *dstY1, |
| bool *mirror_x, bool *mirror_y) |
| { |
| *mirror_x = false; |
| *mirror_y = false; |
| |
| /* Detect if the blit needs to be mirrored */ |
| fixup_mirroring(mirror_x, srcX0, srcX1); |
| fixup_mirroring(mirror_x, dstX0, dstX1); |
| fixup_mirroring(mirror_y, srcY0, srcY1); |
| fixup_mirroring(mirror_y, dstY0, dstY1); |
| |
| /* Compute number of pixels to clip for each side of both rects. Return |
| * early if we are going to clip everything away. |
| */ |
| float clip_src_x0; |
| float clip_src_x1; |
| float clip_src_y0; |
| float clip_src_y1; |
| float clip_dst_x0; |
| float clip_dst_x1; |
| float clip_dst_y0; |
| float clip_dst_y1; |
| |
| if (!compute_pixels_clipped(*srcX0, *srcY0, *srcX1, *srcY1, |
| 0, 0, read_fb->Width, read_fb->Height, |
| &clip_src_x0, &clip_src_y0, &clip_src_x1, &clip_src_y1)) |
| return true; |
| |
| if (!compute_pixels_clipped(*dstX0, *dstY0, *dstX1, *dstY1, |
| draw_fb->_Xmin, draw_fb->_Ymin, draw_fb->_Xmax, draw_fb->_Ymax, |
| &clip_dst_x0, &clip_dst_y0, &clip_dst_x1, &clip_dst_y1)) |
| return true; |
| |
| /* When clipping any of the two rects we need to adjust the coordinates in |
| * the other rect considering the scaling factor involved. To obtain the best |
| * precision we want to make sure that we only clip once per side to avoid |
| * accumulating errors due to the scaling adjustment. |
| * |
| * For example, if srcX0 and dstX0 need both to be clipped we want to avoid |
| * the situation where we clip srcX0 first, then adjust dstX0 accordingly |
| * but then we realize that the resulting dstX0 still needs to be clipped, |
| * so we clip dstX0 and adjust srcX0 again. Because we are applying scaling |
| * factors to adjust the coordinates in each clipping pass we lose some |
| * precision and that can affect the results of the blorp blit operation |
| * slightly. What we want to do here is detect the rect that we should |
| * clip first for each side so that when we adjust the other rect we ensure |
| * the resulting coordinate does not need to be clipped again. |
| * |
| * The code below implements this by comparing the number of pixels that |
| * we need to clip for each side of both rects considering the scales |
| * involved. For example, clip_src_x0 represents the number of pixels to be |
| * clipped for the src rect's left side, so if clip_src_x0 = 5, |
| * clip_dst_x0 = 4 and scaleX = 2 it means that we are clipping more from |
| * the dst rect so we should clip dstX0 only and adjust srcX0. This is |
| * because clipping 4 pixels in the dst is equivalent to clipping |
| * 4 * 2 = 8 > 5 in the src. |
| */ |
| |
| float scaleX = (float) (*srcX1 - *srcX0) / (*dstX1 - *dstX0); |
| float scaleY = (float) (*srcY1 - *srcY0) / (*dstY1 - *dstY0); |
| |
| /* Clip left side */ |
| clip_coordinates(*mirror_x, |
| srcX0, dstX0, dstX1, |
| clip_src_x0, clip_dst_x0, clip_dst_x1, |
| scaleX, true); |
| |
| /* Clip right side */ |
| clip_coordinates(*mirror_x, |
| srcX1, dstX1, dstX0, |
| clip_src_x1, clip_dst_x1, clip_dst_x0, |
| scaleX, false); |
| |
| /* Clip bottom side */ |
| clip_coordinates(*mirror_y, |
| srcY0, dstY0, dstY1, |
| clip_src_y0, clip_dst_y0, clip_dst_y1, |
| scaleY, true); |
| |
| /* Clip top side */ |
| clip_coordinates(*mirror_y, |
| srcY1, dstY1, dstY0, |
| clip_src_y1, clip_dst_y1, clip_dst_y0, |
| scaleY, false); |
| |
| /* Account for the fact that in the system framebuffer, the origin is at |
| * the lower left. |
| */ |
| if (_mesa_is_winsys_fbo(read_fb)) { |
| GLint tmp = read_fb->Height - *srcY0; |
| *srcY0 = read_fb->Height - *srcY1; |
| *srcY1 = tmp; |
| *mirror_y = !*mirror_y; |
| } |
| if (_mesa_is_winsys_fbo(draw_fb)) { |
| GLint tmp = draw_fb->Height - *dstY0; |
| *dstY0 = draw_fb->Height - *dstY1; |
| *dstY1 = tmp; |
| *mirror_y = !*mirror_y; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Creates a new named renderbuffer that wraps the first slice |
| * of an existing miptree. |
| * |
| * Clobbers the current renderbuffer binding (ctx->CurrentRenderbuffer). |
| */ |
| struct gl_renderbuffer * |
| brw_get_rb_for_slice(struct brw_context *brw, |
| struct intel_mipmap_tree *mt, |
| unsigned level, unsigned layer, bool flat) |
| { |
| struct gl_context *ctx = &brw->ctx; |
| struct gl_renderbuffer *rb = ctx->Driver.NewRenderbuffer(ctx, 0xDEADBEEF); |
| struct intel_renderbuffer *irb = intel_renderbuffer(rb); |
| |
| rb->RefCount = 1; |
| rb->Format = mt->format; |
| rb->_BaseFormat = _mesa_get_format_base_format(mt->format); |
| |
| /* Program takes care of msaa and mip-level access manually for stencil. |
| * The surface is also treated as Y-tiled instead of as W-tiled calling for |
| * twice the width and half the height in dimensions. |
| */ |
| if (flat) { |
| const unsigned halign_stencil = 8; |
| |
| rb->NumSamples = 0; |
| rb->Width = ALIGN(mt->total_width, halign_stencil) * 2; |
| rb->Height = (mt->total_height / mt->physical_depth0) / 2; |
| irb->mt_level = 0; |
| } else { |
| rb->NumSamples = mt->num_samples; |
| rb->Width = mt->logical_width0; |
| rb->Height = mt->logical_height0; |
| irb->mt_level = level; |
| } |
| |
| irb->mt_layer = layer; |
| |
| intel_miptree_reference(&irb->mt, mt); |
| |
| return rb; |
| } |
| |
| /** |
| * Determine if fast color clear supports the given clear color. |
| * |
| * Fast color clear can only clear to color values of 1.0 or 0.0. At the |
| * moment we only support floating point, unorm, and snorm buffers. |
| */ |
| bool |
| brw_is_color_fast_clear_compatible(struct brw_context *brw, |
| const struct intel_mipmap_tree *mt, |
| const union gl_color_union *color) |
| { |
| const struct gl_context *ctx = &brw->ctx; |
| |
| /* If we're mapping the render format to a different format than the |
| * format we use for texturing then it is a bit questionable whether it |
| * should be possible to use a fast clear. Although we only actually |
| * render using a renderable format, without the override workaround it |
| * wouldn't be possible to have a non-renderable surface in a fast clear |
| * state so the hardware probably legitimately doesn't need to support |
| * this case. At least on Gen9 this really does seem to cause problems. |
| */ |
| if (brw->gen >= 9 && |
| brw_format_for_mesa_format(mt->format) != |
| brw->render_target_format[mt->format]) |
| return false; |
| |
| /* Gen9 doesn't support fast clear on single-sampled SRGB buffers. When |
| * GL_FRAMEBUFFER_SRGB is enabled any color renderbuffers will be |
| * resolved in intel_update_state. In that case it's pointless to do a |
| * fast clear because it's very likely to be immediately resolved. |
| */ |
| if (brw->gen >= 9 && |
| mt->num_samples <= 1 && |
| ctx->Color.sRGBEnabled && |
| _mesa_get_srgb_format_linear(mt->format) != mt->format) |
| return false; |
| |
| const mesa_format format = _mesa_get_render_format(ctx, mt->format); |
| if (_mesa_is_format_integer_color(format)) { |
| if (brw->gen >= 8) { |
| perf_debug("Integer fast clear not enabled for (%s)", |
| _mesa_get_format_name(format)); |
| } |
| return false; |
| } |
| |
| for (int i = 0; i < 4; i++) { |
| if (!_mesa_format_has_color_component(format, i)) { |
| continue; |
| } |
| |
| if (brw->gen < 9 && |
| color->f[i] != 0.0f && color->f[i] != 1.0f) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Convert the given color to a bitfield suitable for ORing into DWORD 7 of |
| * SURFACE_STATE (DWORD 12-15 on SKL+). |
| */ |
| union gl_color_union |
| brw_meta_convert_fast_clear_color(const struct brw_context *brw, |
| const struct intel_mipmap_tree *mt, |
| const union gl_color_union *color) |
| { |
| union gl_color_union override_color = *color; |
| |
| /* The sampler doesn't look at the format of the surface when the fast |
| * clear color is used so we need to implement luminance, intensity and |
| * missing components manually. |
| */ |
| switch (_mesa_get_format_base_format(mt->format)) { |
| case GL_INTENSITY: |
| override_color.ui[3] = override_color.ui[0]; |
| /* flow through */ |
| case GL_LUMINANCE: |
| case GL_LUMINANCE_ALPHA: |
| override_color.ui[1] = override_color.ui[0]; |
| override_color.ui[2] = override_color.ui[0]; |
| break; |
| default: |
| for (int i = 0; i < 3; i++) { |
| if (!_mesa_format_has_color_component(mt->format, i)) |
| override_color.ui[i] = 0; |
| } |
| break; |
| } |
| |
| if (!_mesa_format_has_color_component(mt->format, 3)) { |
| if (_mesa_is_format_integer_color(mt->format)) |
| override_color.ui[3] = 1; |
| else |
| override_color.f[3] = 1.0f; |
| } |
| |
| /* Handle linear to SRGB conversion */ |
| if (brw->ctx.Color.sRGBEnabled && |
| _mesa_get_srgb_format_linear(mt->format) != mt->format) { |
| for (int i = 0; i < 3; i++) { |
| override_color.f[i] = |
| util_format_linear_to_srgb_float(override_color.f[i]); |
| } |
| } |
| |
| return override_color; |
| } |
| |
| /* Returned boolean tells if the given color differs from the current. */ |
| bool |
| brw_meta_set_fast_clear_color(struct brw_context *brw, |
| union gl_color_union *curr_color, |
| const union gl_color_union *new_color) |
| { |
| bool updated; |
| |
| if (brw->gen >= 9) { |
| updated = memcmp(curr_color, new_color, sizeof(*curr_color)); |
| *curr_color = *new_color; |
| } else { |
| const uint32_t old_color_value = *(uint32_t *)curr_color; |
| uint32_t adjusted = 0; |
| |
| for (int i = 0; i < 4; i++) { |
| /* Testing for non-0 works for integer and float colors */ |
| if (new_color->f[i] != 0.0f) { |
| adjusted |= 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT + (3 - i)); |
| } |
| } |
| |
| updated = (old_color_value != adjusted); |
| *(uint32_t *)curr_color = adjusted; |
| } |
| |
| return updated; |
| } |
