#include "brw_context.h"
#include "brw_blorp_blit_eu.h"
#include "brw_state.h"
+#include "brw_meta_util.h"
#define FILE_DEBUG_FLAG DEBUG_BLORP
-/**
- * Helper function for handling mirror image blits.
- *
- * If coord0 > coord1, swap them and invert the "mirror" boolean.
- */
-static inline void
-fixup_mirroring(bool &mirror, GLfloat &coord0, GLfloat &coord1)
-{
- if (coord0 > coord1) {
- mirror = !mirror;
- GLfloat tmp = coord0;
- coord0 = coord1;
- coord1 = tmp;
- }
-}
-
-
-/**
- * Adjust {src,dst}_x{0,1} to account for clipping and scissoring of
- * destination coordinates.
- *
- * Return true if there is still blitting to do, false if all pixels got
- * rejected by the clip and/or scissor.
- *
- * For clarity, the nomenclature of this function assumes we are clipping and
- * scissoring the X coordinate; the exact same logic applies for Y
- * coordinates.
- *
- * Note: this function may also be used to account for clipping of source
- * coordinates, by swapping the roles of src and dst.
- */
-static inline bool
-clip_or_scissor(bool mirror, GLfloat &src_x0, GLfloat &src_x1, GLfloat &dst_x0,
- GLfloat &dst_x1, GLfloat fb_xmin, GLfloat fb_xmax)
-{
- float scale = (float) (src_x1 - src_x0) / (dst_x1 - dst_x0);
- /* If we are going to scissor everything away, stop. */
- if (!(fb_xmin < fb_xmax &&
- dst_x0 < fb_xmax &&
- fb_xmin < dst_x1 &&
- dst_x0 < dst_x1)) {
- return false;
- }
-
- /* Clip the destination rectangle, and keep track of how many pixels we
- * clipped off of the left and right sides of it.
- */
- GLint pixels_clipped_left = 0;
- GLint pixels_clipped_right = 0;
- if (dst_x0 < fb_xmin) {
- pixels_clipped_left = fb_xmin - dst_x0;
- dst_x0 = fb_xmin;
- }
- if (fb_xmax < dst_x1) {
- pixels_clipped_right = dst_x1 - fb_xmax;
- dst_x1 = fb_xmax;
- }
-
- /* If we are mirrored, then before applying pixels_clipped_{left,right} to
- * the source coordinates, we need to flip them to account for the
- * mirroring.
- */
- if (mirror) {
- GLint tmp = pixels_clipped_left;
- pixels_clipped_left = pixels_clipped_right;
- pixels_clipped_right = tmp;
- }
-
- /* Adjust the source rectangle to remove the pixels corresponding to those
- * that were clipped/scissored out of the destination rectangle.
- */
- src_x0 += pixels_clipped_left * scale;
- src_x1 -= pixels_clipped_right * scale;
-
- return true;
-}
-
-
static struct intel_mipmap_tree *
find_miptree(GLbitfield buffer_bit, struct intel_renderbuffer *irb)
{
brw_blorp_blit_miptrees(struct brw_context *brw,
struct intel_mipmap_tree *src_mt,
unsigned src_level, unsigned src_layer,
+ mesa_format src_format,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
+ mesa_format dst_format,
float src_x0, float src_y0,
float src_x1, float src_y1,
float dst_x0, float dst_y0,
DBG("%s from %dx %s mt %p %d %d (%f,%f) (%f,%f)"
"to %dx %s mt %p %d %d (%f,%f) (%f,%f) (flip %d,%d)\n",
- __FUNCTION__,
+ __func__,
src_mt->num_samples, _mesa_get_format_name(src_mt->format), src_mt,
src_level, src_layer, src_x0, src_y0, src_x1, src_y1,
dst_mt->num_samples, _mesa_get_format_name(dst_mt->format), dst_mt,
mirror_x, mirror_y);
brw_blorp_blit_params params(brw,
- src_mt, src_level, src_layer,
- dst_mt, dst_level, dst_layer,
+ src_mt, src_level, src_layer, src_format,
+ dst_mt, dst_level, dst_layer, dst_format,
src_x0, src_y0,
src_x1, src_y1,
dst_x0, dst_y0,
static void
do_blorp_blit(struct brw_context *brw, GLbitfield buffer_bit,
- struct intel_renderbuffer *src_irb,
- struct intel_renderbuffer *dst_irb,
+ struct intel_renderbuffer *src_irb, mesa_format src_format,
+ struct intel_renderbuffer *dst_irb, mesa_format dst_format,
GLfloat srcX0, GLfloat srcY0, GLfloat srcX1, GLfloat srcY1,
GLfloat dstX0, GLfloat dstY0, GLfloat dstX1, GLfloat dstY1,
GLenum filter, bool mirror_x, bool mirror_y)
/* Do the blit */
brw_blorp_blit_miptrees(brw,
src_mt, src_irb->mt_level, src_irb->mt_layer,
+ src_format,
dst_mt, dst_irb->mt_level, dst_irb->mt_layer,
+ dst_format,
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
filter, mirror_x, mirror_y);
dst_irb->need_downsample = true;
}
-static bool
-color_formats_match(mesa_format src_format, mesa_format dst_format)
-{
- mesa_format linear_src_format = _mesa_get_srgb_format_linear(src_format);
- mesa_format linear_dst_format = _mesa_get_srgb_format_linear(dst_format);
-
- /* Normally, we require the formats to be equal. However, we also support
- * blitting from ARGB to XRGB (discarding alpha), and from XRGB to ARGB
- * (overriding alpha to 1.0 via blending).
- */
- return linear_src_format == linear_dst_format ||
- (linear_src_format == MESA_FORMAT_B8G8R8X8_UNORM &&
- linear_dst_format == MESA_FORMAT_B8G8R8A8_UNORM) ||
- (linear_src_format == MESA_FORMAT_B8G8R8A8_UNORM &&
- linear_dst_format == MESA_FORMAT_B8G8R8X8_UNORM);
-}
-
-static bool
-formats_match(GLbitfield buffer_bit, struct intel_renderbuffer *src_irb,
- struct intel_renderbuffer *dst_irb)
-{
- /* Note: don't just check gl_renderbuffer::Format, because in some cases
- * multiple gl_formats resolve to the same native type in the miptree (for
- * example MESA_FORMAT_Z24_UNORM_X8_UINT and MESA_FORMAT_Z24_UNORM_S8_UINT), and we can blit
- * between those formats.
- */
- mesa_format src_format = find_miptree(buffer_bit, src_irb)->format;
- mesa_format dst_format = find_miptree(buffer_bit, dst_irb)->format;
-
- return color_formats_match(src_format, dst_format);
-}
-
static bool
try_blorp_blit(struct brw_context *brw,
+ 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,
GLenum filter, GLbitfield buffer_bit)
*/
intel_prepare_render(brw);
- const struct gl_framebuffer *read_fb = ctx->ReadBuffer;
- const struct gl_framebuffer *draw_fb = ctx->DrawBuffer;
-
- /* Detect if the blit needs to be mirrored */
- bool mirror_x = false, mirror_y = false;
- fixup_mirroring(mirror_x, srcX0, srcX1);
- fixup_mirroring(mirror_x, dstX0, dstX1);
- fixup_mirroring(mirror_y, srcY0, srcY1);
- fixup_mirroring(mirror_y, dstY0, dstY1);
-
- /* If the destination rectangle needs to be clipped or scissored, do so.
- */
- if (!(clip_or_scissor(mirror_x, srcX0, srcX1, dstX0, dstX1,
- draw_fb->_Xmin, draw_fb->_Xmax) &&
- clip_or_scissor(mirror_y, srcY0, srcY1, dstY0, dstY1,
- draw_fb->_Ymin, draw_fb->_Ymax))) {
- /* Everything got clipped/scissored away, so the blit was successful. */
+ bool mirror_x, mirror_y;
+ if (brw_meta_mirror_clip_and_scissor(ctx, read_fb, draw_fb,
+ &srcX0, &srcY0, &srcX1, &srcY1,
+ &dstX0, &dstY0, &dstX1, &dstY1,
+ &mirror_x, &mirror_y))
return true;
- }
-
- /* If the source rectangle needs to be clipped or scissored, do so. */
- if (!(clip_or_scissor(mirror_x, dstX0, dstX1, srcX0, srcX1,
- 0, read_fb->Width) &&
- clip_or_scissor(mirror_y, dstY0, dstY1, srcY0, srcY1,
- 0, read_fb->Height))) {
- /* Everything got clipped/scissored away, so the blit was successful. */
- return true;
- }
-
- /* 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;
- }
/* Find buffers */
struct intel_renderbuffer *src_irb;
struct intel_renderbuffer *dst_irb;
+ struct intel_mipmap_tree *src_mt;
+ struct intel_mipmap_tree *dst_mt;
switch (buffer_bit) {
case GL_COLOR_BUFFER_BIT:
src_irb = intel_renderbuffer(read_fb->_ColorReadBuffer);
- for (unsigned i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; ++i) {
- dst_irb = intel_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[i]);
- if (dst_irb && !formats_match(buffer_bit, src_irb, dst_irb))
- return false;
- }
- for (unsigned i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; ++i) {
- dst_irb = intel_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[i]);
+ for (unsigned i = 0; i < draw_fb->_NumColorDrawBuffers; ++i) {
+ dst_irb = intel_renderbuffer(draw_fb->_ColorDrawBuffers[i]);
if (dst_irb)
- do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0,
- srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
+ do_blorp_blit(brw, buffer_bit,
+ src_irb, src_irb->Base.Base.Format,
+ dst_irb, dst_irb->Base.Base.Format,
+ srcX0, srcY0, srcX1, srcY1,
+ dstX0, dstY0, dstX1, dstY1,
filter, mirror_x, mirror_y);
}
break;
intel_renderbuffer(read_fb->Attachment[BUFFER_DEPTH].Renderbuffer);
dst_irb =
intel_renderbuffer(draw_fb->Attachment[BUFFER_DEPTH].Renderbuffer);
- if (!formats_match(buffer_bit, src_irb, dst_irb))
+ src_mt = find_miptree(buffer_bit, src_irb);
+ dst_mt = find_miptree(buffer_bit, dst_irb);
+
+ /* We can't handle format conversions between Z24 and other formats
+ * since we have to lie about the surface format. See the comments in
+ * brw_blorp_surface_info::set().
+ */
+ if ((src_mt->format == MESA_FORMAT_Z24_UNORM_X8_UINT) !=
+ (dst_mt->format == MESA_FORMAT_Z24_UNORM_X8_UINT))
return false;
- do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0,
+
+ do_blorp_blit(brw, buffer_bit, src_irb, MESA_FORMAT_NONE,
+ dst_irb, MESA_FORMAT_NONE, srcX0, srcY0,
srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
filter, mirror_x, mirror_y);
break;
intel_renderbuffer(read_fb->Attachment[BUFFER_STENCIL].Renderbuffer);
dst_irb =
intel_renderbuffer(draw_fb->Attachment[BUFFER_STENCIL].Renderbuffer);
- if (!formats_match(buffer_bit, src_irb, dst_irb))
- return false;
- do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0,
+ do_blorp_blit(brw, buffer_bit, src_irb, MESA_FORMAT_NONE,
+ dst_irb, MESA_FORMAT_NONE, srcX0, srcY0,
srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
filter, mirror_x, mirror_y);
break;
default:
- assert(false);
+ unreachable("not reached");
}
return true;
struct intel_renderbuffer *src_irb = intel_renderbuffer(src_rb);
struct intel_texture_image *intel_image = intel_texture_image(dst_image);
+ /* No pixel transfer operations (zoom, bias, mapping), just a blit */
+ if (brw->ctx._ImageTransferState)
+ return false;
+
/* Sync up the state of window system buffers. We need to do this before
* we go looking at the src renderbuffer's miptree.
*/
struct intel_mipmap_tree *src_mt = src_irb->mt;
struct intel_mipmap_tree *dst_mt = intel_image->mt;
- /* BLORP is not supported before Gen6. */
- if (brw->gen < 6 || brw->gen >= 8)
+ /* BLORP is only supported for Gen6-7. */
+ if (brw->gen < 6 || brw->gen > 7)
return false;
- if (_mesa_get_format_base_format(src_mt->format) !=
- _mesa_get_format_base_format(dst_mt->format)) {
+ if (_mesa_get_format_base_format(src_rb->Format) !=
+ _mesa_get_format_base_format(dst_image->TexFormat)) {
return false;
}
return false;
}
- if (!brw->format_supported_as_render_target[dst_mt->format])
+ if (!brw->format_supported_as_render_target[dst_image->TexFormat])
return false;
/* Source clipping shouldn't be necessary, since copytexsubimage (in
mirror_y = true;
}
+ /* Account for face selection and texture view MinLayer */
+ int dst_slice = slice + dst_image->TexObject->MinLayer + dst_image->Face;
+ int dst_level = dst_image->Level + dst_image->TexObject->MinLevel;
+
brw_blorp_blit_miptrees(brw,
src_mt, src_irb->mt_level, src_irb->mt_layer,
- dst_mt, dst_image->Level, dst_image->Face + slice,
+ src_rb->Format,
+ dst_mt, dst_level, dst_slice,
+ dst_image->TexFormat,
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
GL_NEAREST, false, mirror_y);
if (src_mt != dst_mt) {
brw_blorp_blit_miptrees(brw,
src_mt, src_irb->mt_level, src_irb->mt_layer,
- dst_mt, dst_image->Level,
- dst_image->Face + slice,
+ src_mt->format,
+ dst_mt, dst_level, dst_slice,
+ dst_mt->format,
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
GL_NEAREST, false, mirror_y);
GLbitfield
brw_blorp_framebuffer(struct brw_context *brw,
+ struct gl_framebuffer *readFb,
+ struct gl_framebuffer *drawFb,
GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
GLbitfield mask, GLenum filter)
for (unsigned int i = 0; i < ARRAY_SIZE(buffer_bits); ++i) {
if ((mask & buffer_bits[i]) &&
- try_blorp_blit(brw,
+ try_blorp_blit(brw, readFb, drawFb,
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
filter, buffer_bits[i])) {
{
public:
brw_blorp_blit_program(struct brw_context *brw,
- const brw_blorp_blit_prog_key *key);
+ const brw_blorp_blit_prog_key *key, bool debug_flag);
- const GLuint *compile(struct brw_context *brw, GLuint *program_size,
- FILE *dump_file = stderr);
+ const GLuint *compile(struct brw_context *brw, GLuint *program_size);
brw_blorp_prog_data prog_data;
brw_blorp_blit_program::brw_blorp_blit_program(
struct brw_context *brw,
- const brw_blorp_blit_prog_key *key)
- : brw_blorp_eu_emitter(brw),
+ const brw_blorp_blit_prog_key *key,
+ bool debug_flag)
+ : brw_blorp_eu_emitter(brw, debug_flag),
brw(brw),
key(key)
{
const GLuint *
brw_blorp_blit_program::compile(struct brw_context *brw,
- GLuint *program_size,
- FILE *dump_file)
+ GLuint *program_size)
{
/* Sanity checks */
if (key->dst_tiled_w && key->rt_samples > 0) {
*/
render_target_write();
- return get_program(program_size, dump_file);
+ return get_program(program_size);
}
void
break;
}
default:
- assert(!"Unrecognized sample count in "
- "brw_blorp_blit_program::compute_frag_coords()");
- break;
+ unreachable("Unrecognized sample count in "
+ "brw_blorp_blit_program::compute_frag_coords()");
}
s_is_zero = false;
} else {
/* We can't compensate for compressed layout since at this point in the
* program we haven't read from the MCS buffer.
*/
- assert(!"Bad layout in encode_msaa");
- break;
+ unreachable("Bad layout in encode_msaa");
case INTEL_MSAA_LAYOUT_UMS:
/* No translation necessary. */
break;
/* We can't compensate for compressed layout since at this point in the
* program we don't have access to the MCS buffer.
*/
- assert(!"Bad layout in encode_msaa");
- break;
+ unreachable("Bad layout in encode_msaa");
case INTEL_MSAA_LAYOUT_UMS:
/* No translation necessary. */
break;
emit_mov(Xp_f, X);
emit_mov(Yp_f, Y);
/* Scale and offset */
- emit_mul(X_f, Xp_f, x_transform.multiplier);
- emit_mul(Y_f, Yp_f, y_transform.multiplier);
- emit_add(X_f, X_f, x_transform.offset);
- emit_add(Y_f, Y_f, y_transform.offset);
+ emit_mad(X_f, x_transform.offset, Xp_f, x_transform.multiplier);
+ emit_mad(Y_f, y_transform.offset, Yp_f, y_transform.multiplier);
if (key->blit_scaled && key->blend) {
/* Translate coordinates to lay out the samples in a rectangular grid
* roughly corresponding to sample locations.
/* Round the float coordinates down to nearest integer */
emit_rndd(Xp_f, X_f);
emit_rndd(Yp_f, Y_f);
- emit_mul(X_f, Xp_f, brw_imm_f(1 / key->x_scale));
- emit_mul(Y_f, Yp_f, brw_imm_f(1 / key->y_scale));
+ emit_mul(X_f, Xp_f, brw_imm_f(1.0f / key->x_scale));
+ emit_mul(Y_f, Yp_f, brw_imm_f(1.0f / key->y_scale));
SWAP_XY_AND_XPYP();
} else if (!key->bilinear_filter) {
/* Round the float coordinates down to nearest integer by moving to
struct brw_reg clampX1,
struct brw_reg clampY1)
{
- emit_cond_mov(regX, clampX0, BRW_CONDITIONAL_L, regX, clampX0);
- emit_cond_mov(regX, clampX1, BRW_CONDITIONAL_G, regX, clampX1);
- emit_cond_mov(regY, clampY0, BRW_CONDITIONAL_L, regY, clampY0);
- emit_cond_mov(regY, clampY1, BRW_CONDITIONAL_G, regY, clampY1);
+ emit_max(regX, regX, clampX0);
+ emit_max(regY, regY, clampY0);
+ emit_min(regX, regX, clampX1);
+ emit_min(regY, regY, clampY1);
}
/**
*/
inline int count_trailing_one_bits(unsigned value)
{
-#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */
+#ifdef HAVE___BUILTIN_CTZ
return __builtin_ctz(~value);
#else
return _mesa_bitcount(value & ~(value + 1));
for (int j = 0; j < 4; ++j) {
emit_mul(offset(texture_data[0], 2*j),
offset(vec8(texture_data[0]), 2*j),
- brw_imm_f(1.0/num_samples));
+ brw_imm_f(1.0f / num_samples));
}
}
/* Compute pixel coordinates */
emit_add(vec16(x_sample_coords), Xp_f,
- brw_imm_f((float)(i & 0x1) * (1.0 / key->x_scale)));
+ brw_imm_f((float)(i & 0x1) * (1.0f / key->x_scale)));
emit_add(vec16(y_sample_coords), Yp_f,
- brw_imm_f((float)((i >> 1) & 0x1) * (1.0 / key->y_scale)));
+ brw_imm_f((float)((i >> 1) & 0x1) * (1.0f / key->y_scale)));
emit_mov(vec16(X), x_sample_coords);
emit_mov(vec16(Y), y_sample_coords);
}
break;
default:
- assert(!"Should not get here.");
- break;
+ unreachable("Should not get here.");
};
}
* so 0.5 provides the necessary correction.
*/
multiplier = scale;
- offset = src0 + (-dst0 + 0.5) * scale;
+ offset = src0 + (-dst0 + 0.5f) * scale;
} else {
/* When mirroring X we need:
* src_x - src_x0 = dst_x1 - dst_x - 0.5
* src_x = src_x0 + (dst_x1 -dst_x - 0.5) * scale
*/
multiplier = -scale;
- offset = src0 + (dst1 - 0.5) * scale;
+ offset = src0 + (dst1 - 0.5f) * scale;
}
}
brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
struct intel_mipmap_tree *src_mt,
unsigned src_level, unsigned src_layer,
+ mesa_format src_format,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
+ mesa_format dst_format,
GLfloat src_x0, GLfloat src_y0,
GLfloat src_x1, GLfloat src_y1,
GLfloat dst_x0, GLfloat dst_y0,
GLenum filter,
bool mirror_x, bool mirror_y)
{
- src.set(brw, src_mt, src_level, src_layer, false);
- dst.set(brw, dst_mt, dst_level, dst_layer, true);
+ src.set(brw, src_mt, src_level, src_layer, src_format, false);
+ dst.set(brw, dst_mt, dst_level, dst_layer, dst_format, true);
/* Even though we do multisample resolves at the time of the blit, OpenGL
* specification defines them as if they happen at the time of rendering,
_mesa_get_format_color_encoding(dst_mt->format) == GL_SRGB &&
_mesa_get_srgb_format_linear(src_mt->format) ==
_mesa_get_srgb_format_linear(dst_mt->format)) {
- dst.brw_surfaceformat = brw_format_for_mesa_format(dst_mt->format);
- src.brw_surfaceformat = dst.brw_surfaceformat;
+ assert(brw->format_supported_as_render_target[dst_mt->format]);
+ dst.brw_surfaceformat = brw->render_target_format[dst_mt->format];
+ src.brw_surfaceformat = brw_format_for_mesa_format(dst_mt->format);
}
/* When doing a multisample resolve of a GL_LUMINANCE32F or GL_INTENSITY32F
wm_prog_key.texture_data_type = BRW_REGISTER_TYPE_D;
break;
default:
- assert(!"Unrecognized blorp format");
- break;
+ unreachable("Unrecognized blorp format");
}
if (brw->gen > 6) {
/* Scaling factors used for bilinear filtering in multisample scaled
* blits.
*/
- wm_prog_key.x_scale = 2.0;
- wm_prog_key.y_scale = src_mt->num_samples / 2.0;
+ wm_prog_key.x_scale = 2.0f;
+ wm_prog_key.y_scale = src_mt->num_samples / 2.0f;
if (filter == GL_LINEAR && src.num_samples <= 1 && dst.num_samples <= 1)
wm_prog_key.bilinear_filter = true;
wm_prog_key.src_tiled_w = src.map_stencil_as_y_tiled;
wm_prog_key.dst_tiled_w = dst.map_stencil_as_y_tiled;
- x0 = wm_push_consts.dst_x0 = dst_x0;
- y0 = wm_push_consts.dst_y0 = dst_y0;
- x1 = wm_push_consts.dst_x1 = dst_x1;
- y1 = wm_push_consts.dst_y1 = dst_y1;
+ /* Round floating point values to nearest integer to avoid "off by one texel"
+ * kind of errors when blitting.
+ */
+ x0 = wm_push_consts.dst_x0 = roundf(dst_x0);
+ y0 = wm_push_consts.dst_y0 = roundf(dst_y0);
+ x1 = wm_push_consts.dst_x1 = roundf(dst_x1);
+ y1 = wm_push_consts.dst_y1 = roundf(dst_y1);
wm_push_consts.rect_grid_x1 = (minify(src_mt->logical_width0, src_level) *
- wm_prog_key.x_scale - 1.0);
+ wm_prog_key.x_scale - 1.0f);
wm_push_consts.rect_grid_y1 = (minify(src_mt->logical_height0, src_level) *
- wm_prog_key.y_scale - 1.0);
+ wm_prog_key.y_scale - 1.0f);
wm_push_consts.x_transform.setup(src_x0, src_x1, dst_x0, dst_x1, mirror_x);
wm_push_consts.y_transform.setup(src_y0, src_y1, dst_y0, dst_y1, mirror_y);
y1 = ALIGN(y1 * 2, 4);
break;
default:
- assert(!"Unrecognized sample count in brw_blorp_blit_params ctor");
- break;
+ unreachable("Unrecognized sample count in brw_blorp_blit_params ctor");
}
wm_prog_key.use_kill = true;
}
brw_blorp_prog_data **prog_data) const
{
uint32_t prog_offset = 0;
- if (!brw_search_cache(&brw->cache, BRW_BLORP_BLIT_PROG,
+ if (!brw_search_cache(&brw->cache, BRW_CACHE_BLORP_BLIT_PROG,
&this->wm_prog_key, sizeof(this->wm_prog_key),
&prog_offset, prog_data)) {
- brw_blorp_blit_program prog(brw, &this->wm_prog_key);
+ brw_blorp_blit_program prog(brw, &this->wm_prog_key,
+ INTEL_DEBUG & DEBUG_BLORP);
GLuint program_size;
- const GLuint *program = prog.compile(brw, &program_size, stderr);
- brw_upload_cache(&brw->cache, BRW_BLORP_BLIT_PROG,
+ const GLuint *program = prog.compile(brw, &program_size);
+ brw_upload_cache(&brw->cache, BRW_CACHE_BLORP_BLIT_PROG,
&this->wm_prog_key, sizeof(this->wm_prog_key),
program, program_size,
&prog.prog_data, sizeof(prog.prog_data),
}
return prog_offset;
}
-
-void
-brw_blorp_blit_test_compile(struct brw_context *brw,
- const brw_blorp_blit_prog_key *key,
- FILE *out)
-{
- GLuint program_size;
- brw_blorp_blit_program prog(brw, key);
- INTEL_DEBUG |= DEBUG_BLORP;
- prog.compile(brw, &program_size, out);
-}
projects / mesa.git / blobdiff