X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fbrw_blorp_blit.cpp;h=fe75100d776caf1c30bfbdbdf61e6113139aac6e;hb=81b11bf0934d5387bd3741b6268501df3973a6a7;hp=fbda7b063f4fd180743f92d9c92e158a6435fd06;hpb=ff9313fac70fa85d051dd4d2b9d3402d39f67cea;p=mesa.git diff --git a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp index fbda7b063f4..fe75100d776 100644 --- a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp +++ b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp @@ -22,243 +22,198 @@ */ #include "main/teximage.h" - -#include "glsl/ralloc.h" +#include "main/fbobject.h" +#include "main/renderbuffer.h" #include "intel_fbo.h" #include "brw_blorp.h" #include "brw_context.h" -#include "brw_eu.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, GLint &coord0, GLint &coord1) +static struct intel_mipmap_tree * +find_miptree(GLbitfield buffer_bit, struct intel_renderbuffer *irb) { - if (coord0 > coord1) { - mirror = !mirror; - GLint tmp = coord0; - coord0 = coord1; - coord1 = tmp; - } + struct intel_mipmap_tree *mt = irb->mt; + if (buffer_bit == GL_STENCIL_BUFFER_BIT && mt->stencil_mt) + mt = mt->stencil_mt; + return mt; } /** - * 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. + * Note: if the src (or dst) is a 2D multisample array texture on Gen7+ using + * INTEL_MSAA_LAYOUT_UMS or INTEL_MSAA_LAYOUT_CMS, src_layer (dst_layer) is + * the physical layer holding sample 0. So, for example, if + * src_mt->num_samples == 4, then logical layer n corresponds to src_layer == + * 4*n. */ -static inline bool -clip_or_scissor(bool mirror, GLint &src_x0, GLint &src_x1, GLint &dst_x0, - GLint &dst_x1, GLint fb_xmin, GLint fb_xmax) +void +brw_blorp_blit_miptrees(struct brw_context *brw, + struct intel_mipmap_tree *src_mt, + unsigned src_level, unsigned src_layer, + struct intel_mipmap_tree *dst_mt, + unsigned dst_level, unsigned dst_layer, + float src_x0, float src_y0, + float src_x1, float src_y1, + float dst_x0, float dst_y0, + float dst_x1, float dst_y1, + GLenum filter, bool mirror_x, bool mirror_y) { - /* 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. + /* Get ready to blit. This includes depth resolving the src and dst + * buffers if necessary. Note: it's not necessary to do a color resolve on + * the destination buffer because we use the standard render path to render + * to destination color buffers, and the standard render path is + * fast-color-aware. */ - src_x0 += pixels_clipped_left; - src_x1 -= pixels_clipped_right; - - return true; -} - - -static struct intel_mipmap_tree * -find_miptree(GLbitfield buffer_bit, struct gl_renderbuffer *rb) -{ - struct intel_renderbuffer *irb = intel_renderbuffer(rb); - struct intel_mipmap_tree *mt = irb->mt; - if (buffer_bit == GL_STENCIL_BUFFER_BIT && mt->stencil_mt) - mt = mt->stencil_mt; - return mt; + intel_miptree_resolve_color(brw, src_mt); + intel_miptree_slice_resolve_depth(brw, src_mt, src_level, src_layer); + intel_miptree_slice_resolve_depth(brw, dst_mt, dst_level, dst_layer); + + 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__, + 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, + dst_level, dst_layer, dst_x0, dst_y0, dst_x1, dst_y1, + mirror_x, mirror_y); + + brw_blorp_blit_params params(brw, + src_mt, src_level, src_layer, + dst_mt, dst_level, dst_layer, + src_x0, src_y0, + src_x1, src_y1, + dst_x0, dst_y0, + dst_x1, dst_y1, + filter, mirror_x, mirror_y); + brw_blorp_exec(brw, ¶ms); + + intel_miptree_slice_set_needs_hiz_resolve(dst_mt, dst_level, dst_layer); } - static void -do_blorp_blit(struct intel_context *intel, GLbitfield buffer_bit, - struct gl_renderbuffer *src_rb, struct gl_renderbuffer *dst_rb, - GLint srcX0, GLint srcY0, - GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, - bool mirror_x, bool mirror_y) +do_blorp_blit(struct brw_context *brw, GLbitfield buffer_bit, + struct intel_renderbuffer *src_irb, + struct intel_renderbuffer *dst_irb, + GLfloat srcX0, GLfloat srcY0, GLfloat srcX1, GLfloat srcY1, + GLfloat dstX0, GLfloat dstY0, GLfloat dstX1, GLfloat dstY1, + GLenum filter, bool mirror_x, bool mirror_y) { - struct gl_context *ctx = &intel->ctx; - /* Find source/dst miptrees */ - struct intel_mipmap_tree *src_mt = find_miptree(buffer_bit, src_rb); - struct intel_mipmap_tree *dst_mt = find_miptree(buffer_bit, dst_rb); - - /* Get ready to blit. This includes depth resolving the src and dst - * buffers if necessary. - */ - intel_renderbuffer_resolve_depth(intel, intel_renderbuffer(src_rb)); - intel_renderbuffer_resolve_depth(intel, intel_renderbuffer(dst_rb)); + struct intel_mipmap_tree *src_mt = find_miptree(buffer_bit, src_irb); + struct intel_mipmap_tree *dst_mt = find_miptree(buffer_bit, dst_irb); /* Do the blit */ - brw_blorp_blit_params params(brw_context(ctx), src_mt, dst_mt, - srcX0, srcY0, dstX0, dstY0, dstX1, dstY1, - mirror_x, mirror_y); - brw_blorp_exec(intel, ¶ms); - - /* Mark the dst buffer as needing a HiZ resolve if necessary. */ - intel_renderbuffer_set_needs_hiz_resolve(intel_renderbuffer(dst_rb)); + brw_blorp_blit_miptrees(brw, + src_mt, src_irb->mt_level, src_irb->mt_layer, + dst_mt, dst_irb->mt_level, dst_irb->mt_layer, + 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 gl_renderbuffer *src_rb, - struct gl_renderbuffer *dst_rb) +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_X8_Z24 and MESA_FORMAT_S8_Z24), and we can blit + * example MESA_FORMAT_Z24_UNORM_X8_UINT and MESA_FORMAT_Z24_UNORM_S8_UINT), and we can blit * between those formats. */ - return find_miptree(buffer_bit, src_rb)->format == - find_miptree(buffer_bit, dst_rb)->format; -} + 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 intel_context *intel, - GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, - GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, +try_blorp_blit(struct brw_context *brw, + GLfloat srcX0, GLfloat srcY0, GLfloat srcX1, GLfloat srcY1, + GLfloat dstX0, GLfloat dstY0, GLfloat dstX1, GLfloat dstY1, GLenum filter, GLbitfield buffer_bit) { - struct gl_context *ctx = &intel->ctx; + struct gl_context *ctx = &brw->ctx; /* Sync up the state of window system buffers. We need to do this before * we go looking for the buffers. */ - intel_prepare_render(intel); + 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); - - /* Make sure width and height match */ - if (srcX1 - srcX0 != dstX1 - dstX0) return false; - if (srcY1 - srcY0 != dstY1 - dstY0) return false; - - /* 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, + &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 (read_fb->Name == 0) { - GLint tmp = read_fb->Height - srcY0; - srcY0 = read_fb->Height - srcY1; - srcY1 = tmp; - mirror_y = !mirror_y; - } - if (draw_fb->Name == 0) { - GLint tmp = draw_fb->Height - dstY0; - dstY0 = draw_fb->Height - dstY1; - dstY1 = tmp; - mirror_y = !mirror_y; - } /* Find buffers */ - struct gl_renderbuffer *src_rb; - struct gl_renderbuffer *dst_rb; + struct intel_renderbuffer *src_irb; + struct intel_renderbuffer *dst_irb; switch (buffer_bit) { case GL_COLOR_BUFFER_BIT: - src_rb = read_fb->_ColorReadBuffer; + src_irb = intel_renderbuffer(read_fb->_ColorReadBuffer); for (unsigned i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; ++i) { - dst_rb = ctx->DrawBuffer->_ColorDrawBuffers[i]; - if (dst_rb && !formats_match(buffer_bit, src_rb, dst_rb)) + 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_rb = ctx->DrawBuffer->_ColorDrawBuffers[i]; - do_blorp_blit(intel, buffer_bit, src_rb, dst_rb, srcX0, srcY0, - dstX0, dstY0, dstX1, dstY1, mirror_x, mirror_y); + dst_irb = intel_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[i]); + if (dst_irb) + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + filter, mirror_x, mirror_y); } break; case GL_DEPTH_BUFFER_BIT: - src_rb = read_fb->Attachment[BUFFER_DEPTH].Renderbuffer; - dst_rb = draw_fb->Attachment[BUFFER_DEPTH].Renderbuffer; - if (!formats_match(buffer_bit, src_rb, dst_rb)) + src_irb = + 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)) return false; - do_blorp_blit(intel, buffer_bit, src_rb, dst_rb, srcX0, srcY0, - dstX0, dstY0, dstX1, dstY1, mirror_x, mirror_y); + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + filter, mirror_x, mirror_y); break; case GL_STENCIL_BUFFER_BIT: - src_rb = read_fb->Attachment[BUFFER_STENCIL].Renderbuffer; - dst_rb = draw_fb->Attachment[BUFFER_STENCIL].Renderbuffer; - if (!formats_match(buffer_bit, src_rb, dst_rb)) + src_irb = + 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(intel, buffer_bit, src_rb, dst_rb, srcX0, srcY0, - dstX0, dstY0, dstX1, dstY1, mirror_x, mirror_y); + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + filter, mirror_x, mirror_y); break; default: assert(false); @@ -267,14 +222,122 @@ try_blorp_blit(struct intel_context *intel, return true; } +bool +brw_blorp_copytexsubimage(struct brw_context *brw, + struct gl_renderbuffer *src_rb, + struct gl_texture_image *dst_image, + int slice, + int srcX0, int srcY0, + int dstX0, int dstY0, + int width, int height) +{ + struct gl_context *ctx = &brw->ctx; + struct intel_renderbuffer *src_irb = intel_renderbuffer(src_rb); + struct intel_texture_image *intel_image = intel_texture_image(dst_image); + + /* Sync up the state of window system buffers. We need to do this before + * we go looking at the src renderbuffer's miptree. + */ + intel_prepare_render(brw); + + 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) + return false; + + if (_mesa_get_format_base_format(src_mt->format) != + _mesa_get_format_base_format(dst_mt->format)) { + return false; + } + + /* 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; + } + + if (!brw->format_supported_as_render_target[dst_mt->format]) + return false; + + /* Source clipping shouldn't be necessary, since copytexsubimage (in + * src/mesa/main/teximage.c) calls _mesa_clip_copytexsubimage() which + * takes care of it. + * + * Destination clipping shouldn't be necessary since the restrictions on + * glCopyTexSubImage prevent the user from specifying a destination rectangle + * that falls outside the bounds of the destination texture. + * See error_check_subtexture_dimensions(). + */ + + int srcY1 = srcY0 + height; + int srcX1 = srcX0 + width; + int dstX1 = dstX0 + width; + int dstY1 = dstY0 + height; + + /* Account for the fact that in the system framebuffer, the origin is at + * the lower left. + */ + bool mirror_y = false; + if (_mesa_is_winsys_fbo(ctx->ReadBuffer)) { + GLint tmp = src_rb->Height - srcY0; + srcY0 = src_rb->Height - srcY1; + srcY1 = tmp; + 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_level, dst_slice, + srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, + GL_NEAREST, false, mirror_y); + + /* If we're copying to a packed depth stencil texture and the source + * framebuffer has separate stencil, we need to also copy the stencil data + * over. + */ + src_rb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer; + if (_mesa_get_format_bits(dst_image->TexFormat, GL_STENCIL_BITS) > 0 && + src_rb != NULL) { + src_irb = intel_renderbuffer(src_rb); + src_mt = src_irb->mt; + + if (src_mt->stencil_mt) + src_mt = src_mt->stencil_mt; + if (dst_mt->stencil_mt) + dst_mt = dst_mt->stencil_mt; + + if (src_mt != dst_mt) { + brw_blorp_blit_miptrees(brw, + src_mt, src_irb->mt_level, src_irb->mt_layer, + dst_mt, dst_level, dst_slice, + srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, + GL_NEAREST, false, mirror_y); + } + } + + return true; +} + + GLbitfield -brw_blorp_framebuffer(struct intel_context *intel, +brw_blorp_framebuffer(struct brw_context *brw, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { /* BLORP is not supported before Gen6. */ - if (intel->gen < 6) + if (brw->gen < 6 || brw->gen >= 8) return mask; static GLbitfield buffer_bits[] = { @@ -285,7 +348,7 @@ brw_blorp_framebuffer(struct intel_context *intel, for (unsigned int i = 0; i < ARRAY_SIZE(buffer_bits); ++i) { if ((mask & buffer_bits[i]) && - try_blorp_blit(intel, + try_blorp_blit(brw, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, filter, buffer_bits[i])) { @@ -343,6 +406,18 @@ enum sampler_message_arg * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) * S = (Y & 0b10) | (X & 0b10) >> 1 * + * For an 8x multisampled surface using INTEL_MSAA_LAYOUT_IMS, encode_msaa() + * embeds the sample number into bits 1 and 2 of the X coordinate and bit 1 of + * the Y coordinate: + * + * encode_msaa(8, IMS, X, Y, S) = (X', Y', 0) + * where X' = (X & ~0b1) << 2 | (S & 0b100) | (S & 0b1) << 1 | (X & 0b1) + * Y' = (Y & ~0b1) << 1 | (S & 0b10) | (Y & 0b1) + * decode_msaa(8, IMS, X, Y, 0) = (X', Y', S) + * where X' = (X & ~0b111) >> 2 | (X & 0b1) + * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) + * S = (X & 0b100) | (Y & 0b10) | (X & 0b10) >> 1 + * * For X tiling, tile() combines together the low-order bits of the X and Y * coordinates in the pattern 0byyyxxxxxxxxx, creating 4k tiles that are 512 * bytes wide and 8 rows high: @@ -438,14 +513,14 @@ enum sampler_message_arg * (In these formulas, pitch is the number of bytes occupied by a single row * of samples). */ -class brw_blorp_blit_program +class brw_blorp_blit_program : public brw_blorp_eu_emitter { public: brw_blorp_blit_program(struct brw_context *brw, const brw_blorp_blit_prog_key *key); - ~brw_blorp_blit_program(); - const GLuint *compile(struct brw_context *brw, GLuint *program_size); + const GLuint *compile(struct brw_context *brw, GLuint *program_size, + FILE *dump_file = stderr); brw_blorp_prog_data prog_data; @@ -456,27 +531,27 @@ private: void translate_tiling(bool old_tiled_w, bool new_tiled_w); void encode_msaa(unsigned num_samples, intel_msaa_layout layout); void decode_msaa(unsigned num_samples, intel_msaa_layout layout); - void kill_if_outside_dst_rect(); void translate_dst_to_src(); + void clamp_tex_coords(struct brw_reg regX, struct brw_reg regY, + struct brw_reg clampX0, struct brw_reg clampY0, + struct brw_reg clampX1, struct brw_reg clampY1); void single_to_blend(); - void manual_blend(); + void manual_blend_average(unsigned num_samples); + void manual_blend_bilinear(unsigned num_samples); void sample(struct brw_reg dst); void texel_fetch(struct brw_reg dst); void mcs_fetch(); - void expand_to_32_bits(struct brw_reg src, struct brw_reg dst); - void texture_lookup(struct brw_reg dst, GLuint msg_type, + void texture_lookup(struct brw_reg dst, enum opcode op, const sampler_message_arg *args, int num_args); void render_target_write(); /** * Base-2 logarithm of the maximum number of samples that can be blended. */ - static const unsigned LOG2_MAX_BLEND_SAMPLES = 2; + static const unsigned LOG2_MAX_BLEND_SAMPLES = 3; - void *mem_ctx; struct brw_context *brw; const brw_blorp_blit_prog_key *key; - struct brw_compile func; /* Thread dispatch header */ struct brw_reg R0; @@ -489,6 +564,9 @@ private: struct brw_reg dst_x1; struct brw_reg dst_y0; struct brw_reg dst_y1; + /* Top right coordinates of the rectangular grid used for scaled blitting */ + struct brw_reg rect_grid_x1; + struct brw_reg rect_grid_y1; struct { struct brw_reg multiplier; struct brw_reg offset; @@ -514,6 +592,16 @@ private: */ struct brw_reg y_coords[2]; + /* X, Y coordinates of the pixel from which we need to fetch the specific + * sample. These are used for multisample scaled blitting. + */ + struct brw_reg x_sample_coords; + struct brw_reg y_sample_coords; + + /* Fractional parts of the x and y coordinates, used as bilinear interpolation coefficients */ + struct brw_reg x_frac; + struct brw_reg y_frac; + /* Which element of x_coords and y_coords is currently in use. */ int xy_coord_index; @@ -537,21 +625,16 @@ private: brw_blorp_blit_program::brw_blorp_blit_program( struct brw_context *brw, const brw_blorp_blit_prog_key *key) - : mem_ctx(ralloc_context(NULL)), + : brw_blorp_eu_emitter(brw), brw(brw), key(key) { - brw_init_compile(brw, &func, mem_ctx); -} - -brw_blorp_blit_program::~brw_blorp_blit_program() -{ - ralloc_free(mem_ctx); } const GLuint * brw_blorp_blit_program::compile(struct brw_context *brw, - GLuint *program_size) + GLuint *program_size, + FILE *dump_file) { /* Sanity checks */ if (key->dst_tiled_w && key->rt_samples > 0) { @@ -597,8 +680,6 @@ brw_blorp_blit_program::compile(struct brw_context *brw, memset(&prog_data, 0, sizeof(prog_data)); prog_data.persample_msaa_dispatch = key->persample_msaa_dispatch; - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); - alloc_regs(); compute_frag_coords(); @@ -637,7 +718,9 @@ brw_blorp_blit_program::compile(struct brw_context *brw, */ if (key->use_kill) - kill_if_outside_dst_rect(); + emit_kill_if_outside_rect(x_coords[xy_coord_index], + y_coords[xy_coord_index], + dst_x0, dst_x1, dst_y0, dst_y1); /* Next, apply a translation to obtain coordinates in the source image. */ translate_dst_to_src(); @@ -652,15 +735,17 @@ brw_blorp_blit_program::compile(struct brw_context *brw, * that we want to texture from. Exception: if we are blending, then S is * irrelevant, because we are going to fetch all samples. */ - if (key->blend) { - if (brw->intel.gen == 6) { + if (key->blend && !key->blit_scaled) { + if (brw->gen == 6) { /* Gen6 hardware an automatically blend using the SAMPLE message */ single_to_blend(); sample(texture_data[0]); } else { /* Gen7+ hardware doesn't automaticaly blend. */ - manual_blend(); + manual_blend_average(key->src_samples); } + } else if(key->blend && key->blit_scaled) { + manual_blend_bilinear(key->src_samples); } else { /* We aren't blending, which means we just want to fetch a single sample * from the source surface. The address that we want to fetch from is @@ -672,9 +757,10 @@ brw_blorp_blit_program::compile(struct brw_context *brw, * the same as the configuration of the texture, then we need to adjust * the coordinates to compensate for the difference. */ - if (tex_tiled_w != key->src_tiled_w || - key->tex_samples != key->src_samples || - key->tex_layout != key->src_layout) { + if ((tex_tiled_w != key->src_tiled_w || + key->tex_samples != key->src_samples || + key->tex_layout != key->src_layout) && + !key->bilinear_filter) { encode_msaa(key->src_samples, key->src_layout); /* Now (X, Y, S) = detile(src_tiling, offset) */ translate_tiling(key->src_tiled_w, tex_tiled_w); @@ -682,40 +768,50 @@ brw_blorp_blit_program::compile(struct brw_context *brw, decode_msaa(key->tex_samples, key->tex_layout); } - /* Now (X, Y, S) = decode_msaa(tex_samples, detile(tex_tiling, offset)). - * - * In other words: X, Y, and S now contain values which, when passed to - * the texturing unit, will cause data to be read from the correct - * memory location. So we can fetch the texel now. - */ - if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) - mcs_fetch(); - texel_fetch(texture_data[0]); + if (key->bilinear_filter) { + sample(texture_data[0]); + } + else { + /* Now (X, Y, S) = decode_msaa(tex_samples, detile(tex_tiling, offset)). + * + * In other words: X, Y, and S now contain values which, when passed to + * the texturing unit, will cause data to be read from the correct + * memory location. So we can fetch the texel now. + */ + if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) + mcs_fetch(); + texel_fetch(texture_data[0]); + } } /* Finally, write the fetched (or blended) value to the render target and * terminate the thread. */ render_target_write(); - return brw_get_program(&func, program_size); + + return get_program(program_size, dump_file); } void brw_blorp_blit_program::alloc_push_const_regs(int base_reg) { #define CONST_LOC(name) offsetof(brw_blorp_wm_push_constants, name) -#define ALLOC_REG(name) \ - this->name = \ - brw_uw1_reg(BRW_GENERAL_REGISTER_FILE, base_reg, CONST_LOC(name) / 2) - - ALLOC_REG(dst_x0); - ALLOC_REG(dst_x1); - ALLOC_REG(dst_y0); - ALLOC_REG(dst_y1); - ALLOC_REG(x_transform.multiplier); - ALLOC_REG(x_transform.offset); - ALLOC_REG(y_transform.multiplier); - ALLOC_REG(y_transform.offset); +#define ALLOC_REG(name, type) \ + this->name = \ + retype(brw_vec1_reg(BRW_GENERAL_REGISTER_FILE, \ + base_reg + CONST_LOC(name) / 32, \ + (CONST_LOC(name) % 32) / 4), type) + + ALLOC_REG(dst_x0, BRW_REGISTER_TYPE_UD); + ALLOC_REG(dst_x1, BRW_REGISTER_TYPE_UD); + ALLOC_REG(dst_y0, BRW_REGISTER_TYPE_UD); + ALLOC_REG(dst_y1, BRW_REGISTER_TYPE_UD); + ALLOC_REG(rect_grid_x1, BRW_REGISTER_TYPE_F); + ALLOC_REG(rect_grid_y1, BRW_REGISTER_TYPE_F); + ALLOC_REG(x_transform.multiplier, BRW_REGISTER_TYPE_F); + ALLOC_REG(x_transform.offset, BRW_REGISTER_TYPE_F); + ALLOC_REG(y_transform.multiplier, BRW_REGISTER_TYPE_F); + ALLOC_REG(y_transform.offset, BRW_REGISTER_TYPE_F); #undef CONST_LOC #undef ALLOC_REG } @@ -736,17 +832,35 @@ brw_blorp_blit_program::alloc_regs() } this->mcs_data = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); reg += 8; + for (int i = 0; i < 2; ++i) { this->x_coords[i] - = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); + = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); + reg += 2; this->y_coords[i] - = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); + = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); + reg += 2; } + + if (key->blit_scaled && key->blend) { + this->x_sample_coords = brw_vec8_grf(reg, 0); + reg += 2; + this->y_sample_coords = brw_vec8_grf(reg, 0); + reg += 2; + this->x_frac = brw_vec8_grf(reg, 0); + reg += 2; + this->y_frac = brw_vec8_grf(reg, 0); + reg += 2; + } + this->xy_coord_index = 0; this->sample_index - = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); - this->t1 = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); - this->t2 = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); + = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); + reg += 2; + this->t1 = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); + reg += 2; + this->t2 = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); + reg += 2; /* Make sure we didn't run out of registers */ assert(reg <= GEN7_MRF_HACK_START); @@ -803,7 +917,8 @@ brw_blorp_blit_program::compute_frag_coords() * Then, we need to add the repeating sequence (0, 1, 0, 1, ...) to the * result, since pixels n+1 and n+3 are in the right half of the subspan. */ - brw_ADD(&func, X, stride(suboffset(R1, 4), 2, 4, 0), brw_imm_v(0x10101010)); + emit_add(vec16(retype(X, BRW_REGISTER_TYPE_UW)), + stride(suboffset(R1, 4), 2, 4, 0), brw_imm_v(0x10101010)); /* Similarly, Y coordinates for subspans come from R1.2[31:16] through * R1.5[31:16], so to get pixel Y coordinates we need to start at the 5th @@ -813,22 +928,65 @@ brw_blorp_blit_program::compute_frag_coords() * And we need to add the repeating sequence (0, 0, 1, 1, ...), since * pixels n+2 and n+3 are in the bottom half of the subspan. */ - brw_ADD(&func, Y, stride(suboffset(R1, 5), 2, 4, 0), brw_imm_v(0x11001100)); + emit_add(vec16(retype(Y, BRW_REGISTER_TYPE_UW)), + stride(suboffset(R1, 5), 2, 4, 0), brw_imm_v(0x11001100)); + + /* Move the coordinates to UD registers. */ + emit_mov(vec16(Xp), retype(X, BRW_REGISTER_TYPE_UW)); + emit_mov(vec16(Yp), retype(Y, BRW_REGISTER_TYPE_UW)); + SWAP_XY_AND_XPYP(); if (key->persample_msaa_dispatch) { - /* The WM will be run in MSDISPMODE_PERSAMPLE with num_samples > 0. - * Therefore, subspan 0 will represent sample 0, subspan 1 will - * represent sample 1, and so on. - * - * So we need to populate S with the sequence (0, 0, 0, 0, 1, 1, 1, 1, - * 2, 2, 2, 2, 3, 3, 3, 3). The easiest way to do this is to populate a - * temporary variable with the sequence (0, 1, 2, 3), and then copy from - * it using vstride=1, width=4, hstride=0. - * - * TODO: implement the necessary calculation for 8x multisampling. - */ - brw_MOV(&func, t1, brw_imm_v(0x3210)); - brw_MOV(&func, S, stride(t1, 1, 4, 0)); + switch (key->rt_samples) { + case 4: { + /* The WM will be run in MSDISPMODE_PERSAMPLE with num_samples == 4. + * Therefore, subspan 0 will represent sample 0, subspan 1 will + * represent sample 1, and so on. + * + * So we need to populate S with the sequence (0, 0, 0, 0, 1, 1, 1, + * 1, 2, 2, 2, 2, 3, 3, 3, 3). The easiest way to do this is to + * populate a temporary variable with the sequence (0, 1, 2, 3), and + * then copy from it using vstride=1, width=4, hstride=0. + */ + struct brw_reg t1_uw1 = retype(t1, BRW_REGISTER_TYPE_UW); + emit_mov(vec16(t1_uw1), brw_imm_v(0x3210)); + /* Move to UD sample_index register. */ + emit_mov_8(S, stride(t1_uw1, 1, 4, 0)); + emit_mov_8(offset(S, 1), suboffset(stride(t1_uw1, 1, 4, 0), 2)); + break; + } + case 8: { + /* The WM will be run in MSDISPMODE_PERSAMPLE with num_samples == 8. + * Therefore, subspan 0 will represent sample N (where N is 0 or 4), + * subspan 1 will represent sample 1, and so on. We can find the + * value of N by looking at R0.0 bits 7:6 ("Starting Sample Pair + * Index") and multiplying by two (since samples are always delivered + * in pairs). That is, we compute 2*((R0.0 & 0xc0) >> 6) == (R0.0 & + * 0xc0) >> 5. + * + * Then we need to add N to the sequence (0, 0, 0, 0, 1, 1, 1, 1, 2, + * 2, 2, 2, 3, 3, 3, 3), which we compute by populating a temporary + * variable with the sequence (0, 1, 2, 3), and then reading from it + * using vstride=1, width=4, hstride=0. + */ + struct brw_reg t1_ud1 = vec1(retype(t1, BRW_REGISTER_TYPE_UD)); + struct brw_reg t2_uw1 = retype(t2, BRW_REGISTER_TYPE_UW); + struct brw_reg r0_ud1 = vec1(retype(R0, BRW_REGISTER_TYPE_UD)); + emit_and(t1_ud1, r0_ud1, brw_imm_ud(0xc0)); + emit_shr(t1_ud1, t1_ud1, brw_imm_ud(5)); + emit_mov(vec16(t2_uw1), brw_imm_v(0x3210)); + emit_add(vec16(S), retype(t1_ud1, BRW_REGISTER_TYPE_UW), + stride(t2_uw1, 1, 4, 0)); + emit_add_8(offset(S, 1), + retype(t1_ud1, BRW_REGISTER_TYPE_UW), + suboffset(stride(t2_uw1, 1, 4, 0), 2)); + break; + } + default: + assert(!"Unrecognized sample count in " + "brw_blorp_blit_program::compute_frag_coords()"); + break; + } s_is_zero = false; } else { /* Either the destination surface is single-sampled, or the WM will be @@ -891,21 +1049,21 @@ brw_blorp_blit_program::translate_tiling(bool old_tiled_w, bool new_tiled_w) * X' = (X & ~0b1011) >> 1 | (Y & 0b1) << 2 | X & 0b1 (4) * Y' = (Y & ~0b1) << 1 | (X & 0b1000) >> 2 | (X & 0b10) >> 1 */ - brw_AND(&func, t1, X, brw_imm_uw(0xfff4)); /* X & ~0b1011 */ - brw_SHR(&func, t1, t1, brw_imm_uw(1)); /* (X & ~0b1011) >> 1 */ - brw_AND(&func, t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ - brw_SHL(&func, t2, t2, brw_imm_uw(2)); /* (Y & 0b1) << 2 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b1011) >> 1 | (Y & 0b1) << 2 */ - brw_AND(&func, t2, X, brw_imm_uw(1)); /* X & 0b1 */ - brw_OR(&func, Xp, t1, t2); - brw_AND(&func, t1, Y, brw_imm_uw(0xfffe)); /* Y & ~0b1 */ - brw_SHL(&func, t1, t1, brw_imm_uw(1)); /* (Y & ~0b1) << 1 */ - brw_AND(&func, t2, X, brw_imm_uw(8)); /* X & 0b1000 */ - brw_SHR(&func, t2, t2, brw_imm_uw(2)); /* (X & 0b1000) >> 2 */ - brw_OR(&func, t1, t1, t2); /* (Y & ~0b1) << 1 | (X & 0b1000) >> 2 */ - brw_AND(&func, t2, X, brw_imm_uw(2)); /* X & 0b10 */ - brw_SHR(&func, t2, t2, brw_imm_uw(1)); /* (X & 0b10) >> 1 */ - brw_OR(&func, Yp, t1, t2); + emit_and(t1, X, brw_imm_uw(0xfff4)); /* X & ~0b1011 */ + emit_shr(t1, t1, brw_imm_uw(1)); /* (X & ~0b1011) >> 1 */ + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_shl(t2, t2, brw_imm_uw(2)); /* (Y & 0b1) << 2 */ + emit_or(t1, t1, t2); /* (X & ~0b1011) >> 1 | (Y & 0b1) << 2 */ + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffe)); /* Y & ~0b1 */ + emit_shl(t1, t1, brw_imm_uw(1)); /* (Y & ~0b1) << 1 */ + emit_and(t2, X, brw_imm_uw(8)); /* X & 0b1000 */ + emit_shr(t2, t2, brw_imm_uw(2)); /* (X & 0b1000) >> 2 */ + emit_or(t1, t1, t2); /* (Y & ~0b1) << 1 | (X & 0b1000) >> 2 */ + emit_and(t2, X, brw_imm_uw(2)); /* X & 0b10 */ + emit_shr(t2, t2, brw_imm_uw(1)); /* (X & 0b10) >> 1 */ + emit_or(Yp, t1, t2); SWAP_XY_AND_XPYP(); } else { /* Applying the same logic as above, but in reverse, we obtain the @@ -914,22 +1072,22 @@ brw_blorp_blit_program::translate_tiling(bool old_tiled_w, bool new_tiled_w) * X' = (X & ~0b101) << 1 | (Y & 0b10) << 2 | (Y & 0b1) << 1 | X & 0b1 * Y' = (Y & ~0b11) >> 1 | (X & 0b100) >> 2 */ - brw_AND(&func, t1, X, brw_imm_uw(0xfffa)); /* X & ~0b101 */ - brw_SHL(&func, t1, t1, brw_imm_uw(1)); /* (X & ~0b101) << 1 */ - brw_AND(&func, t2, Y, brw_imm_uw(2)); /* Y & 0b10 */ - brw_SHL(&func, t2, t2, brw_imm_uw(2)); /* (Y & 0b10) << 2 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b101) << 1 | (Y & 0b10) << 2 */ - brw_AND(&func, t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ - brw_SHL(&func, t2, t2, brw_imm_uw(1)); /* (Y & 0b1) << 1 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b101) << 1 | (Y & 0b10) << 2 + emit_and(t1, X, brw_imm_uw(0xfffa)); /* X & ~0b101 */ + emit_shl(t1, t1, brw_imm_uw(1)); /* (X & ~0b101) << 1 */ + emit_and(t2, Y, brw_imm_uw(2)); /* Y & 0b10 */ + emit_shl(t2, t2, brw_imm_uw(2)); /* (Y & 0b10) << 2 */ + emit_or(t1, t1, t2); /* (X & ~0b101) << 1 | (Y & 0b10) << 2 */ + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_shl(t2, t2, brw_imm_uw(1)); /* (Y & 0b1) << 1 */ + emit_or(t1, t1, t2); /* (X & ~0b101) << 1 | (Y & 0b10) << 2 | (Y & 0b1) << 1 */ - brw_AND(&func, t2, X, brw_imm_uw(1)); /* X & 0b1 */ - brw_OR(&func, Xp, t1, t2); - brw_AND(&func, t1, Y, brw_imm_uw(0xfffc)); /* Y & ~0b11 */ - brw_SHR(&func, t1, t1, brw_imm_uw(1)); /* (Y & ~0b11) >> 1 */ - brw_AND(&func, t2, X, brw_imm_uw(4)); /* X & 0b100 */ - brw_SHR(&func, t2, t2, brw_imm_uw(2)); /* (X & 0b100) >> 2 */ - brw_OR(&func, Yp, t1, t2); + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffc)); /* Y & ~0b11 */ + emit_shr(t1, t1, brw_imm_uw(1)); /* (Y & ~0b11) >> 1 */ + emit_and(t2, X, brw_imm_uw(4)); /* X & 0b100 */ + emit_shr(t2, t2, brw_imm_uw(2)); /* (X & 0b100) >> 2 */ + emit_or(Yp, t1, t2); SWAP_XY_AND_XPYP(); } } @@ -940,7 +1098,7 @@ brw_blorp_blit_program::translate_tiling(bool old_tiled_w, bool new_tiled_w) * * This code modifies the X and Y coordinates according to the formula: * - * (X', Y', S') = encode_msaa_4x(X, Y, S) + * (X', Y', S') = encode_msaa(num_samples, IMS, X, Y, S) * * (See brw_blorp_blit_program). */ @@ -963,27 +1121,58 @@ brw_blorp_blit_program::encode_msaa(unsigned num_samples, /* No translation necessary. */ break; case INTEL_MSAA_LAYOUT_IMS: - /* encode_msaa(4, IMS, X, Y, S) = (X', Y', 0) - * where X' = (X & ~0b1) << 1 | (S & 0b1) << 1 | (X & 0b1) - * Y' = (Y & ~0b1 ) << 1 | (S & 0b10) | (Y & 0b1) - */ - brw_AND(&func, t1, X, brw_imm_uw(0xfffe)); /* X & ~0b1 */ - if (!s_is_zero) { - brw_AND(&func, t2, S, brw_imm_uw(1)); /* S & 0b1 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b1) | (S & 0b1) */ - } - brw_SHL(&func, t1, t1, brw_imm_uw(1)); /* (X & ~0b1) << 1 - | (S & 0b1) << 1 */ - brw_AND(&func, t2, X, brw_imm_uw(1)); /* X & 0b1 */ - brw_OR(&func, Xp, t1, t2); - brw_AND(&func, t1, Y, brw_imm_uw(0xfffe)); /* Y & ~0b1 */ - brw_SHL(&func, t1, t1, brw_imm_uw(1)); /* (Y & ~0b1) << 1 */ - if (!s_is_zero) { - brw_AND(&func, t2, S, brw_imm_uw(2)); /* S & 0b10 */ - brw_OR(&func, t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ + switch (num_samples) { + case 4: + /* encode_msaa(4, IMS, X, Y, S) = (X', Y', 0) + * where X' = (X & ~0b1) << 1 | (S & 0b1) << 1 | (X & 0b1) + * Y' = (Y & ~0b1) << 1 | (S & 0b10) | (Y & 0b1) + */ + emit_and(t1, X, brw_imm_uw(0xfffe)); /* X & ~0b1 */ + if (!s_is_zero) { + emit_and(t2, S, brw_imm_uw(1)); /* S & 0b1 */ + emit_or(t1, t1, t2); /* (X & ~0b1) | (S & 0b1) */ + } + emit_shl(t1, t1, brw_imm_uw(1)); /* (X & ~0b1) << 1 + | (S & 0b1) << 1 */ + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffe)); /* Y & ~0b1 */ + emit_shl(t1, t1, brw_imm_uw(1)); /* (Y & ~0b1) << 1 */ + if (!s_is_zero) { + emit_and(t2, S, brw_imm_uw(2)); /* S & 0b10 */ + emit_or(t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ + } + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_or(Yp, t1, t2); + break; + case 8: + /* encode_msaa(8, IMS, X, Y, S) = (X', Y', 0) + * where X' = (X & ~0b1) << 2 | (S & 0b100) | (S & 0b1) << 1 + * | (X & 0b1) + * Y' = (Y & ~0b1) << 1 | (S & 0b10) | (Y & 0b1) + */ + emit_and(t1, X, brw_imm_uw(0xfffe)); /* X & ~0b1 */ + emit_shl(t1, t1, brw_imm_uw(2)); /* (X & ~0b1) << 2 */ + if (!s_is_zero) { + emit_and(t2, S, brw_imm_uw(4)); /* S & 0b100 */ + emit_or(t1, t1, t2); /* (X & ~0b1) << 2 | (S & 0b100) */ + emit_and(t2, S, brw_imm_uw(1)); /* S & 0b1 */ + emit_shl(t2, t2, brw_imm_uw(1)); /* (S & 0b1) << 1 */ + emit_or(t1, t1, t2); /* (X & ~0b1) << 2 | (S & 0b100) + | (S & 0b1) << 1 */ + } + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffe)); /* Y & ~0b1 */ + emit_shl(t1, t1, brw_imm_uw(1)); /* (Y & ~0b1) << 1 */ + if (!s_is_zero) { + emit_and(t2, S, brw_imm_uw(2)); /* S & 0b10 */ + emit_or(t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ + } + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_or(Yp, t1, t2); + break; } - brw_AND(&func, t2, Y, brw_imm_uw(1)); - brw_OR(&func, Yp, t1, t2); SWAP_XY_AND_XPYP(); s_is_zero = true; break; @@ -996,7 +1185,7 @@ brw_blorp_blit_program::encode_msaa(unsigned num_samples, * * This code modifies the X and Y coordinates according to the formula: * - * (X', Y', S) = decode_msaa(num_samples, X, Y, S) + * (X', Y', S) = decode_msaa(num_samples, IMS, X, Y, S) * * (See brw_blorp_blit_program). */ @@ -1019,24 +1208,49 @@ brw_blorp_blit_program::decode_msaa(unsigned num_samples, /* No translation necessary. */ break; case INTEL_MSAA_LAYOUT_IMS: - /* decode_msaa(4, IMS, X, Y, 0) = (X', Y', S) - * where X' = (X & ~0b11) >> 1 | (X & 0b1) - * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) - * S = (Y & 0b10) | (X & 0b10) >> 1 - */ assert(s_is_zero); - brw_AND(&func, t1, X, brw_imm_uw(0xfffc)); /* X & ~0b11 */ - brw_SHR(&func, t1, t1, brw_imm_uw(1)); /* (X & ~0b11) >> 1 */ - brw_AND(&func, t2, X, brw_imm_uw(1)); /* X & 0b1 */ - brw_OR(&func, Xp, t1, t2); - brw_AND(&func, t1, Y, brw_imm_uw(0xfffc)); /* Y & ~0b11 */ - brw_SHR(&func, t1, t1, brw_imm_uw(1)); /* (Y & ~0b11) >> 1 */ - brw_AND(&func, t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ - brw_OR(&func, Yp, t1, t2); - brw_AND(&func, t1, Y, brw_imm_uw(2)); /* Y & 0b10 */ - brw_AND(&func, t2, X, brw_imm_uw(2)); /* X & 0b10 */ - brw_SHR(&func, t2, t2, brw_imm_uw(1)); /* (X & 0b10) >> 1 */ - brw_OR(&func, S, t1, t2); + switch (num_samples) { + case 4: + /* decode_msaa(4, IMS, X, Y, 0) = (X', Y', S) + * where X' = (X & ~0b11) >> 1 | (X & 0b1) + * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) + * S = (Y & 0b10) | (X & 0b10) >> 1 + */ + emit_and(t1, X, brw_imm_uw(0xfffc)); /* X & ~0b11 */ + emit_shr(t1, t1, brw_imm_uw(1)); /* (X & ~0b11) >> 1 */ + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffc)); /* Y & ~0b11 */ + emit_shr(t1, t1, brw_imm_uw(1)); /* (Y & ~0b11) >> 1 */ + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_or(Yp, t1, t2); + emit_and(t1, Y, brw_imm_uw(2)); /* Y & 0b10 */ + emit_and(t2, X, brw_imm_uw(2)); /* X & 0b10 */ + emit_shr(t2, t2, brw_imm_uw(1)); /* (X & 0b10) >> 1 */ + emit_or(S, t1, t2); + break; + case 8: + /* decode_msaa(8, IMS, X, Y, 0) = (X', Y', S) + * where X' = (X & ~0b111) >> 2 | (X & 0b1) + * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) + * S = (X & 0b100) | (Y & 0b10) | (X & 0b10) >> 1 + */ + emit_and(t1, X, brw_imm_uw(0xfff8)); /* X & ~0b111 */ + emit_shr(t1, t1, brw_imm_uw(2)); /* (X & ~0b111) >> 2 */ + emit_and(t2, X, brw_imm_uw(1)); /* X & 0b1 */ + emit_or(Xp, t1, t2); + emit_and(t1, Y, brw_imm_uw(0xfffc)); /* Y & ~0b11 */ + emit_shr(t1, t1, brw_imm_uw(1)); /* (Y & ~0b11) >> 1 */ + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_or(Yp, t1, t2); + emit_and(t1, X, brw_imm_uw(4)); /* X & 0b100 */ + emit_and(t2, Y, brw_imm_uw(2)); /* Y & 0b10 */ + emit_or(t1, t1, t2); /* (X & 0b100) | (Y & 0b10) */ + emit_and(t2, X, brw_imm_uw(2)); /* X & 0b10 */ + emit_shr(t2, t2, brw_imm_uw(1)); /* (X & 0b10) >> 1 */ + emit_or(S, t1, t2); + break; + } s_is_zero = false; SWAP_XY_AND_XPYP(); break; @@ -1044,41 +1258,78 @@ brw_blorp_blit_program::decode_msaa(unsigned num_samples, } /** - * Emit code that kills pixels whose X and Y coordinates are outside the - * boundary of the rectangle defined by the push constants (dst_x0, dst_y0, - * dst_x1, dst_y1). + * Emit code to translate from destination (X, Y) coordinates to source (X, Y) + * coordinates. */ void -brw_blorp_blit_program::kill_if_outside_dst_rect() +brw_blorp_blit_program::translate_dst_to_src() { - struct brw_reg f0 = brw_flag_reg(); - struct brw_reg g1 = retype(brw_vec1_grf(1, 7), BRW_REGISTER_TYPE_UW); - struct brw_reg null16 = vec16(retype(brw_null_reg(), BRW_REGISTER_TYPE_UW)); - - brw_CMP(&func, null16, BRW_CONDITIONAL_GE, X, dst_x0); - brw_CMP(&func, null16, BRW_CONDITIONAL_GE, Y, dst_y0); - brw_CMP(&func, null16, BRW_CONDITIONAL_L, X, dst_x1); - brw_CMP(&func, null16, BRW_CONDITIONAL_L, Y, dst_y1); - - brw_set_predicate_control(&func, BRW_PREDICATE_NONE); - brw_push_insn_state(&func); - brw_set_mask_control(&func, BRW_MASK_DISABLE); - brw_AND(&func, g1, f0, g1); - brw_pop_insn_state(&func); + struct brw_reg X_f = retype(X, BRW_REGISTER_TYPE_F); + struct brw_reg Y_f = retype(Y, BRW_REGISTER_TYPE_F); + struct brw_reg Xp_f = retype(Xp, BRW_REGISTER_TYPE_F); + struct brw_reg Yp_f = retype(Yp, BRW_REGISTER_TYPE_F); + + /* Move the UD coordinates to float registers. */ + 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); + if (key->blit_scaled && key->blend) { + /* Translate coordinates to lay out the samples in a rectangular grid + * roughly corresponding to sample locations. + */ + emit_mul(X_f, X_f, brw_imm_f(key->x_scale)); + emit_mul(Y_f, Y_f, brw_imm_f(key->y_scale)); + /* Adjust coordinates so that integers represent pixel centers rather + * than pixel edges. + */ + emit_add(X_f, X_f, brw_imm_f(-0.5)); + emit_add(Y_f, Y_f, brw_imm_f(-0.5)); + + /* Clamp the X, Y texture coordinates to properly handle the sampling of + * texels on texture edges. + */ + clamp_tex_coords(X_f, Y_f, + brw_imm_f(0.0), brw_imm_f(0.0), + rect_grid_x1, rect_grid_y1); + + /* Store the fractional parts to be used as bilinear interpolation + * coefficients. + */ + emit_frc(x_frac, X_f); + emit_frc(y_frac, Y_f); + + /* 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)); + SWAP_XY_AND_XPYP(); + } else if (!key->bilinear_filter) { + /* Round the float coordinates down to nearest integer by moving to + * UD registers. + */ + emit_mov(Xp, X_f); + emit_mov(Yp, Y_f); + SWAP_XY_AND_XPYP(); + } } -/** - * Emit code to translate from destination (X, Y) coordinates to source (X, Y) - * coordinates. - */ void -brw_blorp_blit_program::translate_dst_to_src() +brw_blorp_blit_program::clamp_tex_coords(struct brw_reg regX, + struct brw_reg regY, + struct brw_reg clampX0, + struct brw_reg clampY0, + struct brw_reg clampX1, + struct brw_reg clampY1) { - brw_MUL(&func, Xp, X, x_transform.multiplier); - brw_MUL(&func, Yp, Y, y_transform.multiplier); - brw_ADD(&func, Xp, Xp, x_transform.offset); - brw_ADD(&func, Yp, Yp, y_transform.offset); - SWAP_XY_AND_XPYP(); + 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); } /** @@ -1094,10 +1345,10 @@ brw_blorp_blit_program::single_to_blend() * that maxe up a pixel). So we need to multiply our X and Y coordinates * each by 2 and then add 1. */ - brw_SHL(&func, t1, X, brw_imm_w(1)); - brw_SHL(&func, t2, Y, brw_imm_w(1)); - brw_ADD(&func, Xp, t1, brw_imm_w(1)); - brw_ADD(&func, Yp, t2, brw_imm_w(1)); + emit_shl(t1, X, brw_imm_w(1)); + emit_shl(t2, Y, brw_imm_w(1)); + emit_add(Xp, t1, brw_imm_w(1)); + emit_add(Yp, t2, brw_imm_w(1)); SWAP_XY_AND_XPYP(); } @@ -1120,11 +1371,8 @@ inline int count_trailing_one_bits(unsigned value) void -brw_blorp_blit_program::manual_blend() +brw_blorp_blit_program::manual_blend_average(unsigned num_samples) { - /* TODO: support num_samples != 4 */ - const int num_samples = 4; - if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) mcs_fetch(); @@ -1157,14 +1405,8 @@ brw_blorp_blit_program::manual_blend() * For integer formats, we replace the add operations with average * operations and skip the final division. */ - typedef struct brw_instruction *(*brw_op2_ptr)(struct brw_compile *, - struct brw_reg, - struct brw_reg, - struct brw_reg); - brw_op2_ptr combine_op = - key->texture_data_type == BRW_REGISTER_TYPE_F ? brw_ADD : brw_AVG; unsigned stack_depth = 0; - for (int i = 0; i < num_samples; ++i) { + for (unsigned i = 0; i < num_samples; ++i) { assert(stack_depth == _mesa_bitcount(i)); /* Loop invariant */ /* Push sample i onto the stack */ @@ -1173,7 +1415,7 @@ brw_blorp_blit_program::manual_blend() s_is_zero = true; } else { s_is_zero = false; - brw_MOV(&func, S, brw_imm_uw(i)); + emit_mov(vec16(S), brw_imm_ud(i)); } texel_fetch(texture_data[stack_depth++]); @@ -1192,9 +1434,7 @@ brw_blorp_blit_program::manual_blend() * Since we have already sampled from sample 0, all we need to do is * skip the remaining fetches and averaging if MCS is zero. */ - brw_CMP(&func, vec16(brw_null_reg()), BRW_CONDITIONAL_NZ, - mcs_data, brw_imm_ud(0)); - brw_IF(&func, BRW_EXECUTE_16); + emit_cmp_if(BRW_CONDITIONAL_NZ, mcs_data, brw_imm_ud(0)); } /* Do count_trailing_one_bits(i) times */ @@ -1204,9 +1444,11 @@ brw_blorp_blit_program::manual_blend() /* TODO: should use a smaller loop bound for non_RGBA formats */ for (int k = 0; k < 4; ++k) { - combine_op(&func, offset(texture_data[stack_depth - 1], 2*k), - offset(vec8(texture_data[stack_depth - 1]), 2*k), - offset(vec8(texture_data[stack_depth]), 2*k)); + emit_combine(key->texture_data_type == BRW_REGISTER_TYPE_F ? + BRW_OPCODE_ADD : BRW_OPCODE_AVG, + offset(texture_data[stack_depth - 1], 2*k), + offset(vec8(texture_data[stack_depth - 1]), 2*k), + offset(vec8(texture_data[stack_depth]), 2*k)); } } } @@ -1218,14 +1460,127 @@ brw_blorp_blit_program::manual_blend() /* Scale the result down by a factor of num_samples */ /* TODO: should use a smaller loop bound for non-RGBA formats */ for (int j = 0; j < 4; ++j) { - brw_MUL(&func, offset(texture_data[0], 2*j), + emit_mul(offset(texture_data[0], 2*j), offset(vec8(texture_data[0]), 2*j), brw_imm_f(1.0/num_samples)); } } if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) - brw_ENDIF(&func); + emit_endif(); +} + +void +brw_blorp_blit_program::manual_blend_bilinear(unsigned num_samples) +{ + /* We do this computation by performing the following operations: + * + * In case of 4x, 8x MSAA: + * - Compute the pixel coordinates and sample numbers (a, b, c, d) + * which are later used for interpolation + * - linearly interpolate samples a and b in X + * - linearly interpolate samples c and d in X + * - linearly interpolate the results of last two operations in Y + * + * result = lrp(lrp(a + b) + lrp(c + d)) + */ + struct brw_reg Xp_f = retype(Xp, BRW_REGISTER_TYPE_F); + struct brw_reg Yp_f = retype(Yp, BRW_REGISTER_TYPE_F); + struct brw_reg t1_f = retype(t1, BRW_REGISTER_TYPE_F); + struct brw_reg t2_f = retype(t2, BRW_REGISTER_TYPE_F); + + for (unsigned i = 0; i < 4; ++i) { + assert(i < ARRAY_SIZE(texture_data)); + s_is_zero = false; + + /* Compute pixel coordinates */ + emit_add(vec16(x_sample_coords), Xp_f, + brw_imm_f((float)(i & 0x1) * (1.0 / key->x_scale))); + emit_add(vec16(y_sample_coords), Yp_f, + brw_imm_f((float)((i >> 1) & 0x1) * (1.0 / key->y_scale))); + emit_mov(vec16(X), x_sample_coords); + emit_mov(vec16(Y), y_sample_coords); + + /* The MCS value we fetch has to match up with the pixel that we're + * sampling from. Since we sample from different pixels in each + * iteration of this "for" loop, the call to mcs_fetch() should be + * here inside the loop after computing the pixel coordinates. + */ + if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) + mcs_fetch(); + + /* Compute sample index and map the sample index to a sample number. + * Sample index layout shows the numbering of slots in a rectangular + * grid of samples with in a pixel. Sample number layout shows the + * rectangular grid of samples roughly corresponding to the real sample + * locations with in a pixel. + * In case of 4x MSAA, layout of sample indices matches the layout of + * sample numbers: + * --------- + * | 0 | 1 | + * --------- + * | 2 | 3 | + * --------- + * + * In case of 8x MSAA the two layouts don't match. + * sample index layout : --------- sample number layout : --------- + * | 0 | 1 | | 5 | 2 | + * --------- --------- + * | 2 | 3 | | 4 | 6 | + * --------- --------- + * | 4 | 5 | | 0 | 3 | + * --------- --------- + * | 6 | 7 | | 7 | 1 | + * --------- --------- + */ + emit_frc(vec16(t1_f), x_sample_coords); + emit_frc(vec16(t2_f), y_sample_coords); + emit_mul(vec16(t1_f), t1_f, brw_imm_f(key->x_scale)); + emit_mul(vec16(t2_f), t2_f, brw_imm_f(key->x_scale * key->y_scale)); + emit_add(vec16(t1_f), t1_f, t2_f); + emit_mov(vec16(S), t1_f); + + if (num_samples == 8) { + /* Map the sample index to a sample number */ + emit_cmp_if(BRW_CONDITIONAL_L, S, brw_imm_d(4)); + { + emit_mov(vec16(t2), brw_imm_d(5)); + emit_if_eq_mov(S, 1, vec16(t2), 2); + emit_if_eq_mov(S, 2, vec16(t2), 4); + emit_if_eq_mov(S, 3, vec16(t2), 6); + } + emit_else(); + { + emit_mov(vec16(t2), brw_imm_d(0)); + emit_if_eq_mov(S, 5, vec16(t2), 3); + emit_if_eq_mov(S, 6, vec16(t2), 7); + emit_if_eq_mov(S, 7, vec16(t2), 1); + } + emit_endif(); + emit_mov(vec16(S), t2); + } + texel_fetch(texture_data[i]); + } + +#define SAMPLE(x, y) offset(texture_data[x], y) + for (int index = 3; index > 0; ) { + /* Since we're doing SIMD16, 4 color channels fits in to 8 registers. + * Counter value of 8 in 'for' loop below is used to interpolate all + * the color components. + */ + for (int k = 0; k < 8; k += 2) + emit_lrp(vec8(SAMPLE(index - 1, k)), + x_frac, + vec8(SAMPLE(index, k)), + vec8(SAMPLE(index - 1, k))); + index -= 2; + } + for (int k = 0; k < 8; k += 2) + emit_lrp(vec8(SAMPLE(0, k)), + y_frac, + vec8(SAMPLE(2, k)), + vec8(SAMPLE(0, k))); +#undef SAMPLE } /** @@ -1240,7 +1595,7 @@ brw_blorp_blit_program::sample(struct brw_reg dst) SAMPLER_MESSAGE_ARG_V_FLOAT }; - texture_lookup(dst, GEN5_SAMPLER_MESSAGE_SAMPLE, args, ARRAY_SIZE(args)); + texture_lookup(dst, SHADER_OPCODE_TEX, args, ARRAY_SIZE(args)); } /** @@ -1274,10 +1629,9 @@ brw_blorp_blit_program::texel_fetch(struct brw_reg dst) SAMPLER_MESSAGE_ARG_V_INT }; - switch (brw->intel.gen) { + switch (brw->gen) { case 6: - texture_lookup(dst, GEN5_SAMPLER_MESSAGE_SAMPLE_LD, gen6_args, - s_is_zero ? 2 : 5); + texture_lookup(dst, SHADER_OPCODE_TXF, gen6_args, s_is_zero ? 2 : 5); break; case 7: switch (key->tex_layout) { @@ -1293,16 +1647,16 @@ brw_blorp_blit_program::texel_fetch(struct brw_reg dst) * INTEL_MSAA_LAYOUT_CMS. */ case INTEL_MSAA_LAYOUT_CMS: - texture_lookup(dst, GEN7_SAMPLER_MESSAGE_SAMPLE_LD2DMS, + texture_lookup(dst, SHADER_OPCODE_TXF_CMS, gen7_ld2dms_args, ARRAY_SIZE(gen7_ld2dms_args)); break; case INTEL_MSAA_LAYOUT_UMS: - texture_lookup(dst, GEN7_SAMPLER_MESSAGE_SAMPLE_LD2DSS, + texture_lookup(dst, SHADER_OPCODE_TXF_UMS, gen7_ld2dss_args, ARRAY_SIZE(gen7_ld2dss_args)); break; case INTEL_MSAA_LAYOUT_NONE: assert(s_is_zero); - texture_lookup(dst, GEN5_SAMPLER_MESSAGE_SAMPLE_LD, gen7_ld_args, + texture_lookup(dst, SHADER_OPCODE_TXF, gen7_ld_args, ARRAY_SIZE(gen7_ld_args)); break; } @@ -1320,23 +1674,13 @@ brw_blorp_blit_program::mcs_fetch() SAMPLER_MESSAGE_ARG_U_INT, SAMPLER_MESSAGE_ARG_V_INT }; - texture_lookup(vec16(mcs_data), GEN7_SAMPLER_MESSAGE_SAMPLE_LD_MCS, + texture_lookup(vec16(mcs_data), SHADER_OPCODE_TXF_MCS, gen7_ld_mcs_args, ARRAY_SIZE(gen7_ld_mcs_args)); } -void -brw_blorp_blit_program::expand_to_32_bits(struct brw_reg src, - struct brw_reg dst) -{ - brw_MOV(&func, vec8(dst), vec8(src)); - brw_set_compression_control(&func, BRW_COMPRESSION_2NDHALF); - brw_MOV(&func, offset(vec8(dst), 1), suboffset(vec8(src), 8)); - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); -} - void brw_blorp_blit_program::texture_lookup(struct brw_reg dst, - GLuint msg_type, + enum opcode op, const sampler_message_arg *args, int num_args) { @@ -1345,16 +1689,24 @@ brw_blorp_blit_program::texture_lookup(struct brw_reg dst, for (int arg = 0; arg < num_args; ++arg) { switch (args[arg]) { case SAMPLER_MESSAGE_ARG_U_FLOAT: - expand_to_32_bits(X, retype(mrf, BRW_REGISTER_TYPE_F)); + if (key->bilinear_filter) + emit_mov(retype(mrf, BRW_REGISTER_TYPE_F), + retype(X, BRW_REGISTER_TYPE_F)); + else + emit_mov(retype(mrf, BRW_REGISTER_TYPE_F), X); break; case SAMPLER_MESSAGE_ARG_V_FLOAT: - expand_to_32_bits(Y, retype(mrf, BRW_REGISTER_TYPE_F)); + if (key->bilinear_filter) + emit_mov(retype(mrf, BRW_REGISTER_TYPE_F), + retype(Y, BRW_REGISTER_TYPE_F)); + else + emit_mov(retype(mrf, BRW_REGISTER_TYPE_F), Y); break; case SAMPLER_MESSAGE_ARG_U_INT: - expand_to_32_bits(X, mrf); + emit_mov(mrf, X); break; case SAMPLER_MESSAGE_ARG_V_INT: - expand_to_32_bits(Y, mrf); + emit_mov(mrf, Y); break; case SAMPLER_MESSAGE_ARG_SI_INT: /* Note: on Gen7, this code may be reached with s_is_zero==true @@ -1363,14 +1715,14 @@ brw_blorp_blit_program::texture_lookup(struct brw_reg dst, * appropriate message register. */ if (s_is_zero) - brw_MOV(&func, mrf, brw_imm_ud(0)); + emit_mov(mrf, brw_imm_ud(0)); else - expand_to_32_bits(S, mrf); + emit_mov(mrf, S); break; case SAMPLER_MESSAGE_ARG_MCS_INT: switch (key->tex_layout) { case INTEL_MSAA_LAYOUT_CMS: - brw_MOV(&func, mrf, mcs_data); + emit_mov(mrf, mcs_data); break; case INTEL_MSAA_LAYOUT_IMS: /* When sampling from an IMS surface, MCS data is not relevant, @@ -1386,25 +1738,16 @@ brw_blorp_blit_program::texture_lookup(struct brw_reg dst, } break; case SAMPLER_MESSAGE_ARG_ZERO_INT: - brw_MOV(&func, mrf, brw_imm_ud(0)); + emit_mov(mrf, brw_imm_ud(0)); break; } mrf.nr += 2; } - brw_SAMPLE(&func, - retype(dst, BRW_REGISTER_TYPE_UW) /* dest */, - base_mrf /* msg_reg_nr */, - brw_message_reg(base_mrf) /* src0 */, - BRW_BLORP_TEXTURE_BINDING_TABLE_INDEX, - 0 /* sampler */, - WRITEMASK_XYZW, - msg_type, - 8 /* response_length. TODO: should be smaller for non-RGBA formats? */, - mrf.nr - base_mrf /* msg_length */, - 0 /* header_present */, - BRW_SAMPLER_SIMD_MODE_SIMD16, - BRW_SAMPLER_RETURN_FORMAT_FLOAT32); + emit_texture_lookup(retype(dst, BRW_REGISTER_TYPE_UW) /* dest */, + op, + base_mrf, + mrf.nr - base_mrf /* msg_length */); } #undef X @@ -1427,53 +1770,55 @@ brw_blorp_blit_program::render_target_write() bool use_header = key->use_kill; if (use_header) { /* Copy R0/1 to MRF */ - brw_MOV(&func, retype(mrf_rt_write, BRW_REGISTER_TYPE_UD), - retype(R0, BRW_REGISTER_TYPE_UD)); + emit_mov(retype(mrf_rt_write, BRW_REGISTER_TYPE_UD), + retype(R0, BRW_REGISTER_TYPE_UD)); mrf_offset += 2; } /* Copy texture data to MRFs */ for (int i = 0; i < 4; ++i) { /* E.g. mov(16) m2.0<1>:f r2.0<8;8,1>:f { Align1, H1 } */ - brw_MOV(&func, offset(mrf_rt_write, mrf_offset), - offset(vec8(texture_data[0]), 2*i)); + emit_mov(offset(mrf_rt_write, mrf_offset), + offset(vec8(texture_data[0]), 2*i)); mrf_offset += 2; } /* Now write to the render target and terminate the thread */ - brw_fb_WRITE(&func, - 16 /* dispatch_width */, - base_mrf /* msg_reg_nr */, - mrf_rt_write /* src0 */, - BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE, - BRW_BLORP_RENDERBUFFER_BINDING_TABLE_INDEX, - mrf_offset /* msg_length. TODO: Should be smaller for non-RGBA formats. */, - 0 /* response_length */, - true /* eot */, - use_header); + emit_render_target_write( + mrf_rt_write, + base_mrf, + mrf_offset /* msg_length. TODO: Should be smaller for non-RGBA formats. */, + use_header); } void -brw_blorp_coord_transform_params::setup(GLuint src0, GLuint dst0, GLuint dst1, +brw_blorp_coord_transform_params::setup(GLfloat src0, GLfloat src1, + GLfloat dst0, GLfloat dst1, bool mirror) { + float scale = (src1 - src0) / (dst1 - dst0); if (!mirror) { /* When not mirroring a coordinate (say, X), we need: - * x' - src_x0 = x - dst_x0 + * src_x - src_x0 = (dst_x - dst_x0 + 0.5) * scale * Therefore: - * x' = 1*x + (src_x0 - dst_x0) + * src_x = src_x0 + (dst_x - dst_x0 + 0.5) * scale + * + * blorp program uses "round toward zero" to convert the + * transformed floating point coordinates to integer coordinates, + * whereas the behaviour we actually want is "round to nearest", + * so 0.5 provides the necessary correction. */ - multiplier = 1; - offset = src0 - dst0; + multiplier = scale; + offset = src0 + (-dst0 + 0.5) * scale; } else { /* When mirroring X we need: - * x' - src_x0 = dst_x1 - x - 1 + * src_x - src_x0 = dst_x1 - dst_x - 0.5 * Therefore: - * x' = -1*x + (src_x0 + dst_x1 - 1) + * src_x = src_x0 + (dst_x1 -dst_x - 0.5) * scale */ - multiplier = -1; - offset = src0 + dst1 - 1; + multiplier = -scale; + offset = src0 + (dst1 - 0.5) * scale; } } @@ -1487,7 +1832,7 @@ inline intel_msaa_layout compute_msaa_layout_for_pipeline(struct brw_context *brw, unsigned num_samples, intel_msaa_layout true_layout) { - if (num_samples == 0) { + if (num_samples <= 1) { /* When configuring the GPU for non-MSAA, we can still accommodate IMS * format buffers, by transforming coordinates appropriately. */ @@ -1499,7 +1844,7 @@ compute_msaa_layout_for_pipeline(struct brw_context *brw, unsigned num_samples, } /* Prior to Gen7, all MSAA surfaces use IMS layout. */ - if (brw->intel.gen == 6) { + if (brw->gen == 6) { assert(true_layout == INTEL_MSAA_LAYOUT_IMS); } @@ -1509,14 +1854,56 @@ compute_msaa_layout_for_pipeline(struct brw_context *brw, unsigned num_samples, brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, struct intel_mipmap_tree *src_mt, + unsigned src_level, unsigned src_layer, struct intel_mipmap_tree *dst_mt, - GLuint src_x0, GLuint src_y0, - GLuint dst_x0, GLuint dst_y0, - GLuint dst_x1, GLuint dst_y1, + unsigned dst_level, unsigned dst_layer, + GLfloat src_x0, GLfloat src_y0, + GLfloat src_x1, GLfloat src_y1, + GLfloat dst_x0, GLfloat dst_y0, + GLfloat dst_x1, GLfloat dst_y1, + GLenum filter, bool mirror_x, bool mirror_y) { - src.set(brw, src_mt, 0, 0); - dst.set(brw, dst_mt, 0, 0); + src.set(brw, src_mt, src_level, src_layer, false); + dst.set(brw, dst_mt, dst_level, dst_layer, 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, + * which means that the type of averaging we do during the resolve should + * only depend on the source format; the destination format should be + * ignored. But, specification doesn't seem to be strict about it. + * + * It has been observed that mulitisample resolves produce slightly better + * looking images when averaging is done using destination format. NVIDIA's + * proprietary OpenGL driver also follow this approach. So, we choose to + * follow it in our driver. + * + * When multisampling, if the source and destination formats are equal + * (aside from the color space), we choose to blit in sRGB space to get + * this higher quality image. + */ + if (src.num_samples > 1 && + _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; + } + + /* When doing a multisample resolve of a GL_LUMINANCE32F or GL_INTENSITY32F + * texture, the above code configures the source format for L32_FLOAT or + * I32_FLOAT, and the destination format for R32_FLOAT. On Sandy Bridge, + * the SAMPLE message appears to handle multisampled L32_FLOAT and + * I32_FLOAT textures incorrectly, resulting in blocky artifacts. So work + * around the problem by using a source format of R32_FLOAT. This + * shouldn't affect rendering correctness, since the destination format is + * R32_FLOAT, so only the contents of the red channel matters. + */ + if (brw->gen == 6 && src.num_samples > 1 && dst.num_samples <= 1 && + src_mt->format == dst_mt->format && + dst.brw_surfaceformat == BRW_SURFACEFORMAT_R32_FLOAT) { + src.brw_surfaceformat = dst.brw_surfaceformat; + } use_wm_prog = true; memset(&wm_prog_key, 0, sizeof(wm_prog_key)); @@ -1531,7 +1918,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, wm_prog_key.texture_data_type = BRW_REGISTER_TYPE_F; break; case GL_UNSIGNED_INT: - if (src_mt->format == MESA_FORMAT_S8) { + if (src_mt->format == MESA_FORMAT_S_UINT8) { /* We process stencil as though it's an unsigned normalized color */ wm_prog_key.texture_data_type = BRW_REGISTER_TYPE_F; } else { @@ -1546,7 +1933,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, break; } - if (brw->intel.gen > 6) { + if (brw->gen > 6) { /* Gen7's rendering hardware only supports the IMS layout for depth and * stencil render targets. Blorp always maps its destination surface as * a color render target (even if it's actually a depth or stencil @@ -1557,7 +1944,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, dst.num_samples = 0; } - if (dst.map_stencil_as_y_tiled && dst.num_samples > 0) { + if (dst.map_stencil_as_y_tiled && dst.num_samples > 1) { /* If the destination surface is a W-tiled multisampled stencil buffer * that we're mapping as Y tiled, then we need to arrange for the WM * program to run once per sample rather than once per pixel, because @@ -1567,7 +1954,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, wm_prog_key.persample_msaa_dispatch = true; } - if (src.num_samples > 0 && dst.num_samples > 0) { + if (src.num_samples > 0 && dst.num_samples > 1) { /* We are blitting from a multisample buffer to a multisample buffer, so * we must preserve samples within a pixel. This means we have to * arrange for the WM program to run once per sample rather than once @@ -1576,15 +1963,24 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, wm_prog_key.persample_msaa_dispatch = true; } - /* The render path must be configured to use the same number of samples as - * the destination buffer. + /* Scaled blitting or not. */ + wm_prog_key.blit_scaled = + ((dst_x1 - dst_x0) == (src_x1 - src_x0) && + (dst_y1 - dst_y0) == (src_y1 - src_y0)) ? false : true; + + /* Scaling factors used for bilinear filtering in multisample scaled + * blits. */ - num_samples = dst.num_samples; + wm_prog_key.x_scale = 2.0; + wm_prog_key.y_scale = src_mt->num_samples / 2.0; + + if (filter == GL_LINEAR && src.num_samples <= 1 && dst.num_samples <= 1) + wm_prog_key.bilinear_filter = true; GLenum base_format = _mesa_get_format_base_format(src_mt->format); if (base_format != GL_DEPTH_COMPONENT && /* TODO: what about depth/stencil? */ base_format != GL_STENCIL_INDEX && - src_mt->num_samples > 0 && dst_mt->num_samples == 0) { + src_mt->num_samples > 1 && dst_mt->num_samples <= 1) { /* We are downsampling a color buffer, so blend. */ wm_prog_key.blend = true; } @@ -1619,10 +2015,15 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, y0 = wm_push_consts.dst_y0 = dst_y0; x1 = wm_push_consts.dst_x1 = dst_x1; y1 = wm_push_consts.dst_y1 = dst_y1; - wm_push_consts.x_transform.setup(src_x0, dst_x0, dst_x1, mirror_x); - wm_push_consts.y_transform.setup(src_y0, dst_y0, dst_y1, mirror_y); + wm_push_consts.rect_grid_x1 = (minify(src_mt->logical_width0, src_level) * + wm_prog_key.x_scale - 1.0); + wm_push_consts.rect_grid_y1 = (minify(src_mt->logical_height0, src_level) * + wm_prog_key.y_scale - 1.0); + + 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); - if (dst.num_samples == 0 && dst_mt->num_samples > 0) { + if (dst.num_samples <= 1 && dst_mt->num_samples > 1) { /* We must expand the rectangle we send through the rendering pipeline, * to account for the fact that we are mapping the destination region as * single-sampled when it is in fact multisampled. We must also align @@ -1636,51 +2037,114 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, * pipeline as multisampled. */ assert(dst_mt->msaa_layout == INTEL_MSAA_LAYOUT_IMS); - x0 = (x0 * 2) & ~3; - y0 = (y0 * 2) & ~3; - x1 = ALIGN(x1 * 2, 4); - y1 = ALIGN(y1 * 2, 4); + switch (dst_mt->num_samples) { + case 4: + x0 = ROUND_DOWN_TO(x0 * 2, 4); + y0 = ROUND_DOWN_TO(y0 * 2, 4); + x1 = ALIGN(x1 * 2, 4); + y1 = ALIGN(y1 * 2, 4); + break; + case 8: + x0 = ROUND_DOWN_TO(x0 * 4, 8); + y0 = ROUND_DOWN_TO(y0 * 2, 4); + x1 = ALIGN(x1 * 4, 8); + y1 = ALIGN(y1 * 2, 4); + break; + default: + assert(!"Unrecognized sample count in brw_blorp_blit_params ctor"); + break; + } wm_prog_key.use_kill = true; } if (dst.map_stencil_as_y_tiled) { - /* We must modify the rectangle we send through the rendering pipeline, - * to account for the fact that we are mapping it as Y-tiled when it is - * in fact W-tiled. Y tiles have dimensions 128x32 whereas W tiles have - * dimensions 64x64. We must also align it to a multiple of the tile - * size, because the differences between W and Y tiling formats will - * mean that pixels are scrambled within the tile. + /* We must modify the rectangle we send through the rendering pipeline + * (and the size and x/y offset of the destination surface), to account + * for the fact that we are mapping it as Y-tiled when it is in fact + * W-tiled. * - * Note: if the destination surface configured to use IMS layout, then - * the effective tile size we need to align it to is smaller, because - * each pixel covers a 2x2 or a 4x2 block of samples. + * Both Y tiling and W tiling can be understood as organizations of + * 32-byte sub-tiles; within each 32-byte sub-tile, the layout of pixels + * is different, but the layout of the 32-byte sub-tiles within the 4k + * tile is the same (8 sub-tiles across by 16 sub-tiles down, in + * column-major order). In Y tiling, the sub-tiles are 16 bytes wide + * and 2 rows high; in W tiling, they are 8 bytes wide and 4 rows high. * - * TODO: what if this makes the coordinates too large? + * Therefore, to account for the layout differences within the 32-byte + * sub-tiles, we must expand the rectangle so the X coordinates of its + * edges are multiples of 8 (the W sub-tile width), and its Y + * coordinates of its edges are multiples of 4 (the W sub-tile height). + * Then we need to scale the X and Y coordinates of the rectangle to + * account for the differences in aspect ratio between the Y and W + * sub-tiles. We need to modify the layer width and height similarly. + * + * A correction needs to be applied when MSAA is in use: since + * INTEL_MSAA_LAYOUT_IMS uses an interleaving pattern whose height is 4, + * we need to align the Y coordinates to multiples of 8, so that when + * they are divided by two they are still multiples of 4. + * + * Note: Since the x/y offset of the surface will be applied using the + * SURFACE_STATE command packet, it will be invisible to the swizzling + * code in the shader; therefore it needs to be in a multiple of the + * 32-byte sub-tile size. Fortunately it is, since the sub-tile is 8 + * pixels wide and 4 pixels high (when viewed as a W-tiled stencil + * buffer), and the miplevel alignment used for stencil buffers is 8 + * pixels horizontally and either 4 or 8 pixels vertically (see + * intel_horizontal_texture_alignment_unit() and + * intel_vertical_texture_alignment_unit()). + * + * Note: Also, since the SURFACE_STATE command packet can only apply + * offsets that are multiples of 4 pixels horizontally and 2 pixels + * vertically, it is important that the offsets will be multiples of + * these sizes after they are converted into Y-tiled coordinates. + * Fortunately they will be, since we know from above that the offsets + * are a multiple of the 32-byte sub-tile size, and in Y-tiled + * coordinates the sub-tile is 16 pixels wide and 2 pixels high. + * + * TODO: what if this makes the coordinates (or the texture size) too + * large? */ - unsigned x_align = 64, y_align = 64; - if (dst_mt->msaa_layout == INTEL_MSAA_LAYOUT_IMS) { - x_align /= (dst_mt->num_samples == 4 ? 2 : 4); - y_align /= 2; - } - x0 = (x0 & ~(x_align - 1)) * 2; - y0 = (y0 & ~(y_align - 1)) / 2; + const unsigned x_align = 8, y_align = dst.num_samples != 0 ? 8 : 4; + x0 = ROUND_DOWN_TO(x0, x_align) * 2; + y0 = ROUND_DOWN_TO(y0, y_align) / 2; x1 = ALIGN(x1, x_align) * 2; y1 = ALIGN(y1, y_align) / 2; + dst.width = ALIGN(dst.width, x_align) * 2; + dst.height = ALIGN(dst.height, y_align) / 2; + dst.x_offset *= 2; + dst.y_offset /= 2; wm_prog_key.use_kill = true; } + + if (src.map_stencil_as_y_tiled) { + /* We must modify the size and x/y offset of the source surface to + * account for the fact that we are mapping it as Y-tiled when it is in + * fact W tiled. + * + * See the comments above concerning x/y offset alignment for the + * destination surface. + * + * TODO: what if this makes the texture size too large? + */ + const unsigned x_align = 8, y_align = src.num_samples != 0 ? 8 : 4; + src.width = ALIGN(src.width, x_align) * 2; + src.height = ALIGN(src.height, y_align) / 2; + src.x_offset *= 2; + src.y_offset /= 2; + } } uint32_t brw_blorp_blit_params::get_wm_prog(struct brw_context *brw, brw_blorp_prog_data **prog_data) const { - uint32_t prog_offset; + uint32_t prog_offset = 0; if (!brw_search_cache(&brw->cache, BRW_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); GLuint program_size; - const GLuint *program = prog.compile(brw, &program_size); + const GLuint *program = prog.compile(brw, &program_size, stderr); brw_upload_cache(&brw->cache, BRW_BLORP_BLIT_PROG, &this->wm_prog_key, sizeof(this->wm_prog_key), program, program_size, @@ -1689,3 +2153,14 @@ brw_blorp_blit_params::get_wm_prog(struct brw_context *brw, } 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); +}