2 * Copyright © 2014 Intel Corporation
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:
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
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
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"
34 * Helper function for handling mirror image blits.
36 * If coord0 > coord1, swap them and invert the "mirror" boolean.
39 fixup_mirroring(bool *mirror
, float *coord0
, float *coord1
)
41 if (*coord0
> *coord1
) {
50 * Compute the number of pixels to clip for each side of a rect
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
65 * \return false if we clip everything away, true otherwise
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
)
72 /* If we are going to clip everything away, stop. */
73 if (!(min_x
<= max_x
&&
85 *clipped_x0
= min_x
- x0
;
89 *clipped_x1
= x1
- max_x
;
94 *clipped_y0
= min_y
- y0
;
98 *clipped_y1
= y1
- max_y
;
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.
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
122 clip_coordinates(bool mirror
,
123 float *src
, float *dst0
, float *dst1
,
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
136 int mult
= isLeftOrBottom
? 1 : -1;
139 if (clipped_src0
>= clipped_dst0
* scale
) {
140 *src
+= clipped_src0
* mult
;
141 *dst0
+= clipped_src0
/ scale
* mult
;
143 *dst0
+= clipped_dst0
* mult
;
144 *src
+= clipped_dst0
* scale
* mult
;
147 if (clipped_src0
>= clipped_dst1
* scale
) {
148 *src
+= clipped_src0
* mult
;
149 *dst1
-= clipped_src0
/ scale
* mult
;
151 *dst1
-= clipped_dst1
* mult
;
152 *src
+= clipped_dst1
* scale
* mult
;
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
)
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
);
176 /* Compute number of pixels to clip for each side of both rects. Return
177 * early if we are going to clip everything away.
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
))
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
))
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.
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.
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.
223 if (*srcX0
== *srcX1
|| *srcY0
== *srcY1
224 || *dstX0
== *dstX1
|| *dstY0
== *dstY1
)
227 float scaleX
= (float) (*srcX1
- *srcX0
) / (*dstX1
- *dstX0
);
228 float scaleY
= (float) (*srcY1
- *srcY0
) / (*dstY1
- *dstY0
);
231 clip_coordinates(*mirror_x
,
233 clip_src_x0
, clip_dst_x0
, clip_dst_x1
,
236 /* Clip right side */
237 clip_coordinates(*mirror_x
,
239 clip_src_x1
, clip_dst_x1
, clip_dst_x0
,
242 /* Clip bottom side */
243 clip_coordinates(*mirror_y
,
245 clip_src_y0
, clip_dst_y0
, clip_dst_y1
,
249 clip_coordinates(*mirror_y
,
251 clip_src_y1
, clip_dst_y1
, clip_dst_y0
,
254 /* Account for the fact that in the system framebuffer, the origin is at
257 if (read_fb
->FlipY
) {
258 GLint tmp
= read_fb
->Height
- *srcY0
;
259 *srcY0
= read_fb
->Height
- *srcY1
;
261 *mirror_y
= !*mirror_y
;
263 if (draw_fb
->FlipY
) {
264 GLint tmp
= draw_fb
->Height
- *dstY0
;
265 *dstY0
= draw_fb
->Height
- *dstY1
;
267 *mirror_y
= !*mirror_y
;
270 /* Check for invalid bounds
271 * Can't blit for 0-dimensions
273 return *srcX0
== *srcX1
|| *srcY0
== *srcY1
274 || *dstX0
== *dstX1
|| *dstY0
== *dstY1
;
278 * Determine if fast color clear supports the given clear color.
280 * Fast color clear can only clear to color values of 1.0 or 0.0. At the
281 * moment we only support floating point, unorm, and snorm buffers.
284 brw_is_color_fast_clear_compatible(struct brw_context
*brw
,
285 const struct intel_mipmap_tree
*mt
,
286 const union gl_color_union
*color
)
288 const struct gen_device_info
*devinfo
= &brw
->screen
->devinfo
;
289 const struct gl_context
*ctx
= &brw
->ctx
;
291 /* If we're mapping the render format to a different format than the
292 * format we use for texturing then it is a bit questionable whether it
293 * should be possible to use a fast clear. Although we only actually
294 * render using a renderable format, without the override workaround it
295 * wouldn't be possible to have a non-renderable surface in a fast clear
296 * state so the hardware probably legitimately doesn't need to support
297 * this case. At least on Gen9 this really does seem to cause problems.
299 if (devinfo
->gen
>= 9 &&
300 brw_isl_format_for_mesa_format(mt
->format
) !=
301 brw
->mesa_to_isl_render_format
[mt
->format
])
304 const mesa_format format
= _mesa_get_render_format(ctx
, mt
->format
);
305 if (_mesa_is_format_integer_color(format
)) {
306 if (devinfo
->gen
>= 8) {
307 perf_debug("Integer fast clear not enabled for (%s)",
308 _mesa_get_format_name(format
));
313 for (int i
= 0; i
< 4; i
++) {
314 if (!_mesa_format_has_color_component(format
, i
)) {
318 if (devinfo
->gen
< 9 &&
319 color
->f
[i
] != 0.0f
&& color
->f
[i
] != 1.0f
) {
327 * Convert the given color to a bitfield suitable for ORing into DWORD 7 of
328 * SURFACE_STATE (DWORD 12-15 on SKL+).
330 union isl_color_value
331 brw_meta_convert_fast_clear_color(const struct brw_context
*brw
,
332 const struct intel_mipmap_tree
*mt
,
333 const union gl_color_union
*color
)
335 union isl_color_value override_color
= {
344 /* The sampler doesn't look at the format of the surface when the fast
345 * clear color is used so we need to implement luminance, intensity and
346 * missing components manually.
348 switch (_mesa_get_format_base_format(mt
->format
)) {
350 override_color
.u32
[3] = override_color
.u32
[0];
353 case GL_LUMINANCE_ALPHA
:
354 override_color
.u32
[1] = override_color
.u32
[0];
355 override_color
.u32
[2] = override_color
.u32
[0];
358 for (int i
= 0; i
< 3; i
++) {
359 if (!_mesa_format_has_color_component(mt
->format
, i
))
360 override_color
.u32
[i
] = 0;
365 switch (_mesa_get_format_datatype(mt
->format
)) {
366 case GL_UNSIGNED_NORMALIZED
:
367 for (int i
= 0; i
< 4; i
++)
368 override_color
.f32
[i
] = SATURATE(override_color
.f32
[i
]);
371 case GL_SIGNED_NORMALIZED
:
372 for (int i
= 0; i
< 4; i
++)
373 override_color
.f32
[i
] = CLAMP(override_color
.f32
[i
], -1.0f
, 1.0f
);
376 case GL_UNSIGNED_INT
:
377 for (int i
= 0; i
< 4; i
++) {
378 unsigned bits
= _mesa_get_format_bits(mt
->format
, GL_RED_BITS
+ i
);
380 uint32_t max
= (1u << bits
) - 1;
381 override_color
.u32
[i
] = MIN2(override_color
.u32
[i
], max
);
387 for (int i
= 0; i
< 4; i
++) {
388 unsigned bits
= _mesa_get_format_bits(mt
->format
, GL_RED_BITS
+ i
);
390 int32_t max
= (1 << (bits
- 1)) - 1;
391 int32_t min
= -(1 << (bits
- 1));
392 override_color
.i32
[i
] = CLAMP(override_color
.i32
[i
], min
, max
);
398 if (!_mesa_is_format_signed(mt
->format
)) {
399 for (int i
= 0; i
< 4; i
++)
400 override_color
.f32
[i
] = MAX2(override_color
.f32
[i
], 0.0f
);
405 if (!_mesa_format_has_color_component(mt
->format
, 3)) {
406 if (_mesa_is_format_integer_color(mt
->format
))
407 override_color
.u32
[3] = 1;
409 override_color
.f32
[3] = 1.0f
;
412 /* Handle linear to SRGB conversion */
413 if (brw
->ctx
.Color
.sRGBEnabled
&&
414 _mesa_get_srgb_format_linear(mt
->format
) != mt
->format
) {
415 for (int i
= 0; i
< 3; i
++) {
416 override_color
.f32
[i
] =
417 util_format_linear_to_srgb_float(override_color
.f32
[i
]);
421 return override_color
;