X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fbrw_blorp_blit.cpp;h=1cf2d186462ebe6fa61bef942cdc9f66e402e34a;hb=2f28a0dc23165123cf1e8b5942acad37878edd8a;hp=a6b2bbf1a65021a1643e6f9b879b00005bfdb699;hpb=2fd785d12602103a1c05fd52903bdb4ffefadaad;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 a6b2bbf1a65..1cf2d186462 100644 --- a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp +++ b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp @@ -25,93 +25,15 @@ #include "main/fbobject.h" #include "main/renderbuffer.h" -#include "glsl/ralloc.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" - -/** - * 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; -} - +#define FILE_DEBUG_FLAG DEBUG_BLORP static struct intel_mipmap_tree * find_miptree(GLbitfield buffer_bit, struct intel_renderbuffer *irb) @@ -122,8 +44,16 @@ find_miptree(GLbitfield buffer_bit, struct intel_renderbuffer *irb) return mt; } + +/** + * 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. + */ void -brw_blorp_blit_miptrees(struct intel_context *intel, +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, @@ -132,162 +62,100 @@ brw_blorp_blit_miptrees(struct intel_context *intel, float src_x1, float src_y1, float dst_x0, float dst_y0, float dst_x1, float dst_y1, - bool mirror_x, bool mirror_y) + GLenum filter, bool mirror_x, bool mirror_y) { - intel_miptree_slice_resolve_depth(intel, src_mt, src_level, src_layer); - intel_miptree_slice_resolve_depth(intel, dst_mt, dst_level, dst_layer); - - brw_blorp_blit_params params(brw_context(&intel->ctx), + /* 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. + */ + 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, - mirror_x, mirror_y); - brw_blorp_exec(intel, ¶ms); + 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, +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, - bool mirror_x, bool mirror_y) + GLenum filter, bool mirror_x, bool mirror_y) { /* Find source/dst miptrees */ 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_miptrees(intel, + 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, - mirror_x, mirror_y); + filter, mirror_x, mirror_y); - intel_renderbuffer_set_needs_downsample(dst_irb); + dst_irb->need_downsample = true; } static bool -color_formats_match(gl_format src_format, gl_format dst_format) -{ - gl_format linear_src_format = _mesa_get_srgb_format_linear(src_format); - gl_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_XRGB8888 && - linear_dst_format == MESA_FORMAT_ARGB8888) || - (linear_src_format == MESA_FORMAT_ARGB8888 && - linear_dst_format == MESA_FORMAT_XRGB8888); -} - -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_X8_Z24 and MESA_FORMAT_S8_Z24), and we can blit - * between those formats. - */ - gl_format src_format = find_miptree(buffer_bit, src_irb)->format; - gl_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, +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); - - /* Linear filtering is not yet implemented in blorp engine. So, fallback - * to other blit paths. - */ - if ((srcX1 - srcX0 != dstX1 - dstX0 || - srcY1 - srcY0 != dstY1 - dstY0) && - filter == GL_LINEAR) - 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. */ - 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. */ + 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; - } - - /* 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]); if (dst_irb) - do_blorp_blit(intel, buffer_bit, src_irb, dst_irb, srcX0, srcY0, + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - mirror_x, mirror_y); + filter, mirror_x, mirror_y); } break; case GL_DEPTH_BUFFER_BIT: @@ -295,62 +163,77 @@ try_blorp_blit(struct intel_context *intel, 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(intel, buffer_bit, src_irb, dst_irb, srcX0, srcY0, + + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - mirror_x, mirror_y); + filter, mirror_x, mirror_y); break; case GL_STENCIL_BUFFER_BIT: 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_irb, dst_irb, srcX0, srcY0, + do_blorp_blit(brw, buffer_bit, src_irb, dst_irb, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - mirror_x, mirror_y); + filter, mirror_x, mirror_y); break; default: - assert(false); + unreachable("not reached"); } return true; } bool -brw_blorp_copytexsubimage(struct intel_context *intel, +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 = &intel->ctx; + 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(intel); + 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 (intel->gen < 6) + if (brw->gen < 6 || brw->gen >= 8) return false; - if (!color_formats_match(src_mt->format, dst_mt->format)) { + if (_mesa_get_format_base_format(src_mt->format) != + _mesa_get_format_base_format(dst_mt->format)) { return false; } - /* We can't use blorp to copy to a 1D array texture, since it can only - * write to one layer of the texture at a time. + /* 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 (dst_mt->target == GL_TEXTURE_1D_ARRAY) + 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 @@ -379,12 +262,20 @@ brw_blorp_copytexsubimage(struct intel_context *intel, mirror_y = true; } - brw_blorp_blit_miptrees(intel, + /* 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; + + _mesa_unlock_texture(ctx, dst_image->TexObject); + + brw_blorp_blit_miptrees(brw, src_mt, src_irb->mt_level, src_irb->mt_layer, - dst_mt, dst_image->Level, dst_image->Face, + dst_mt, dst_level, dst_slice, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - false, mirror_y); + GL_NEAREST, false, mirror_y); + + _mesa_lock_texture(ctx, dst_image->TexObject); /* 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 @@ -402,12 +293,12 @@ brw_blorp_copytexsubimage(struct intel_context *intel, dst_mt = dst_mt->stencil_mt; if (src_mt != dst_mt) { - brw_blorp_blit_miptrees(intel, + brw_blorp_blit_miptrees(brw, src_mt, src_irb->mt_level, src_irb->mt_layer, - dst_mt, dst_image->Level, dst_image->Face, + dst_mt, dst_level, dst_slice, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - false, mirror_y); + GL_NEAREST, false, mirror_y); } } @@ -416,13 +307,13 @@ brw_blorp_copytexsubimage(struct intel_context *intel, 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[] = { @@ -433,7 +324,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])) { @@ -598,12 +489,11 @@ 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 brw_blorp_blit_prog_key *key, bool debug_flag); const GLuint *compile(struct brw_context *brw, GLuint *program_size); @@ -616,14 +506,17 @@ 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(unsigned num_samples); + 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 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(); @@ -632,10 +525,8 @@ private: */ 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; @@ -648,6 +539,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; @@ -673,6 +567,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; @@ -695,17 +599,12 @@ 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)), + const brw_blorp_blit_prog_key *key, + bool debug_flag) + : brw_blorp_eu_emitter(brw, debug_flag), 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 * @@ -756,8 +655,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(); @@ -796,7 +693,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(); @@ -811,15 +710,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(key->src_samples); + 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 @@ -831,9 +732,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); @@ -841,15 +743,20 @@ 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 @@ -857,30 +764,29 @@ brw_blorp_blit_program::compile(struct brw_context *brw, */ render_target_write(); - if (unlikely(INTEL_DEBUG & DEBUG_BLORP)) { - printf("Native code for BLORP blit:\n"); - brw_dump_compile(&func, stdout, 0, func.next_insn_offset); - printf("\n"); - } - return brw_get_program(&func, program_size); + return get_program(program_size); } 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_vec1_reg(BRW_GENERAL_REGISTER_FILE, base_reg, CONST_LOC(name) / 4) - - 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 } @@ -910,6 +816,18 @@ brw_blorp_blit_program::alloc_regs() = 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 = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); @@ -974,7 +892,7 @@ 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, vec16(retype(X, BRW_REGISTER_TYPE_UW)), + 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 @@ -985,12 +903,12 @@ 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, vec16(retype(Y, BRW_REGISTER_TYPE_UW)), + 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. */ - brw_MOV(&func, vec16(Xp), retype(X, BRW_REGISTER_TYPE_UW)); - brw_MOV(&func, vec16(Yp), retype(Y, BRW_REGISTER_TYPE_UW)); + 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) { @@ -1006,10 +924,10 @@ brw_blorp_blit_program::compute_frag_coords() * then copy from it using vstride=1, width=4, hstride=0. */ struct brw_reg t1_uw1 = retype(t1, BRW_REGISTER_TYPE_UW); - brw_MOV(&func, vec16(t1_uw1), brw_imm_v(0x3210)); + emit_mov(vec16(t1_uw1), brw_imm_v(0x3210)); /* Move to UD sample_index register. */ - brw_MOV(&func, S, stride(t1_uw1, 1, 4, 0)); - brw_MOV(&func, offset(S, 1), suboffset(stride(t1_uw1, 1, 4, 0), 2)); + 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: { @@ -1029,20 +947,19 @@ brw_blorp_blit_program::compute_frag_coords() 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)); - brw_AND(&func, t1_ud1, r0_ud1, brw_imm_ud(0xc0)); - brw_SHR(&func, t1_ud1, t1_ud1, brw_imm_ud(5)); - brw_MOV(&func, vec16(t2_uw1), brw_imm_v(0x3210)); - brw_ADD(&func, vec16(S), retype(t1_ud1, BRW_REGISTER_TYPE_UW), - stride(t2_uw1, 1, 4, 0)); - brw_ADD(&func, offset(S, 1), - retype(t1_ud1, BRW_REGISTER_TYPE_UW), - suboffset(stride(t2_uw1, 1, 4, 0), 2)); + 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; + unreachable("Unrecognized sample count in " + "brw_blorp_blit_program::compute_frag_coords()"); } s_is_zero = false; } else { @@ -1078,7 +995,6 @@ brw_blorp_blit_program::translate_tiling(bool old_tiled_w, bool new_tiled_w) */ assert(s_is_zero); - brw_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED); if (new_tiled_w) { /* Given X and Y coordinates that describe an address using Y tiling, * translate to the X and Y coordinates that describe the same address @@ -1107,21 +1023,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 @@ -1130,25 +1046,24 @@ 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(); } - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); } /** @@ -1165,7 +1080,6 @@ void brw_blorp_blit_program::encode_msaa(unsigned num_samples, intel_msaa_layout layout) { - brw_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED); switch (layout) { case INTEL_MSAA_LAYOUT_NONE: /* No translation necessary, and S should already be zero. */ @@ -1175,8 +1089,7 @@ brw_blorp_blit_program::encode_msaa(unsigned num_samples, /* 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; @@ -1187,23 +1100,23 @@ brw_blorp_blit_program::encode_msaa(unsigned num_samples, * 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 */ + emit_and(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) */ + emit_and(t2, S, brw_imm_uw(1)); /* S & 0b1 */ + emit_or(t1, t1, t2); /* (X & ~0b1) | (S & 0b1) */ } - brw_SHL(&func, t1, t1, brw_imm_uw(1)); /* (X & ~0b1) << 1 + emit_shl(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 */ + 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) { - brw_AND(&func, t2, S, brw_imm_uw(2)); /* S & 0b10 */ - brw_OR(&func, t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ + emit_and(t2, S, brw_imm_uw(2)); /* S & 0b10 */ + emit_or(t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ } - brw_AND(&func, t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ - brw_OR(&func, Yp, t1, t2); + 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) @@ -1211,33 +1124,32 @@ brw_blorp_blit_program::encode_msaa(unsigned num_samples, * | (X & 0b1) * Y' = (Y & ~0b1) << 1 | (S & 0b10) | (Y & 0b1) */ - brw_AND(&func, t1, X, brw_imm_uw(0xfffe)); /* X & ~0b1 */ - brw_SHL(&func, t1, t1, brw_imm_uw(2)); /* (X & ~0b1) << 2 */ + 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) { - brw_AND(&func, t2, S, brw_imm_uw(4)); /* S & 0b100 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b1) << 2 | (S & 0b100) */ - brw_AND(&func, t2, S, brw_imm_uw(1)); /* S & 0b1 */ - brw_SHL(&func, t2, t2, brw_imm_uw(1)); /* (S & 0b1) << 1 */ - brw_OR(&func, t1, t1, t2); /* (X & ~0b1) << 2 | (S & 0b100) + 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 */ } - 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 */ + 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) { - brw_AND(&func, t2, S, brw_imm_uw(2)); /* S & 0b10 */ - brw_OR(&func, t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ + emit_and(t2, S, brw_imm_uw(2)); /* S & 0b10 */ + emit_or(t1, t1, t2); /* (Y & ~0b1) << 1 | (S & 0b10) */ } - brw_AND(&func, t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ - brw_OR(&func, Yp, t1, t2); + emit_and(t2, Y, brw_imm_uw(1)); /* Y & 0b1 */ + emit_or(Yp, t1, t2); break; } SWAP_XY_AND_XPYP(); s_is_zero = true; break; } - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); } /** @@ -1254,7 +1166,6 @@ void brw_blorp_blit_program::decode_msaa(unsigned num_samples, intel_msaa_layout layout) { - brw_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED); switch (layout) { case INTEL_MSAA_LAYOUT_NONE: /* No translation necessary, and S should already be zero. */ @@ -1264,8 +1175,7 @@ brw_blorp_blit_program::decode_msaa(unsigned num_samples, /* 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; @@ -1278,18 +1188,18 @@ brw_blorp_blit_program::decode_msaa(unsigned num_samples, * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) * S = (Y & 0b10) | (X & 0b10) >> 1 */ - 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); + 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) @@ -1297,51 +1207,26 @@ brw_blorp_blit_program::decode_msaa(unsigned num_samples, * Y' = (Y & ~0b11) >> 1 | (Y & 0b1) * S = (X & 0b100) | (Y & 0b10) | (X & 0b10) >> 1 */ - brw_AND(&func, t1, X, brw_imm_uw(0xfff8)); /* X & ~0b111 */ - brw_SHR(&func, t1, t1, brw_imm_uw(2)); /* (X & ~0b111) >> 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(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, X, brw_imm_uw(4)); /* X & 0b100 */ - brw_AND(&func, t2, Y, brw_imm_uw(2)); /* Y & 0b10 */ - brw_OR(&func, t1, t1, t2); /* (X & 0b100) | (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); + 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; } - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); -} - -/** - * 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). - */ -void -brw_blorp_blit_program::kill_if_outside_dst_rect() -{ - struct brw_reg f0 = brw_flag_reg(0, 0); - struct brw_reg g1 = retype(brw_vec1_grf(1, 7), BRW_REGISTER_TYPE_UW); - struct brw_reg null32 = vec16(retype(brw_null_reg(), BRW_REGISTER_TYPE_UD)); - - brw_CMP(&func, null32, BRW_CONDITIONAL_GE, X, dst_x0); - brw_CMP(&func, null32, BRW_CONDITIONAL_GE, Y, dst_y0); - brw_CMP(&func, null32, BRW_CONDITIONAL_L, X, dst_x1); - brw_CMP(&func, null32, 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); } /** @@ -1356,22 +1241,67 @@ brw_blorp_blit_program::translate_dst_to_src() struct brw_reg Xp_f = retype(Xp, BRW_REGISTER_TYPE_F); struct brw_reg Yp_f = retype(Yp, BRW_REGISTER_TYPE_F); - brw_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED); /* Move the UD coordinates to float registers. */ - brw_MOV(&func, Xp_f, X); - brw_MOV(&func, Yp_f, Y); + emit_mov(Xp_f, X); + emit_mov(Yp_f, Y); /* Scale and offset */ - brw_MUL(&func, X_f, Xp_f, x_transform.multiplier); - brw_MUL(&func, Y_f, Yp_f, y_transform.multiplier); - brw_ADD(&func, X_f, X_f, x_transform.offset); - brw_ADD(&func, Y_f, Y_f, y_transform.offset); - /* Round the float coordinates down to nearest integer by moving to - * UD registers. - */ - brw_MOV(&func, Xp, X_f); - brw_MOV(&func, Yp, Y_f); - SWAP_XY_AND_XPYP(); - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); + 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(); + } +} + +void +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) +{ + 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); } /** @@ -1387,12 +1317,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_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED); - 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)); - brw_set_compression_control(&func, BRW_COMPRESSION_NONE); + 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(); } @@ -1415,7 +1343,7 @@ inline int count_trailing_one_bits(unsigned value) void -brw_blorp_blit_program::manual_blend(unsigned num_samples) +brw_blorp_blit_program::manual_blend_average(unsigned num_samples) { if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) mcs_fetch(); @@ -1449,12 +1377,6 @@ brw_blorp_blit_program::manual_blend(unsigned num_samples) * 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 (unsigned i = 0; i < num_samples; ++i) { assert(stack_depth == _mesa_bitcount(i)); /* Loop invariant */ @@ -1465,7 +1387,7 @@ brw_blorp_blit_program::manual_blend(unsigned num_samples) s_is_zero = true; } else { s_is_zero = false; - brw_MOV(&func, vec16(S), brw_imm_ud(i)); + emit_mov(vec16(S), brw_imm_ud(i)); } texel_fetch(texture_data[stack_depth++]); @@ -1484,9 +1406,7 @@ brw_blorp_blit_program::manual_blend(unsigned num_samples) * 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 */ @@ -1496,9 +1416,11 @@ brw_blorp_blit_program::manual_blend(unsigned num_samples) /* 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)); } } } @@ -1510,14 +1432,127 @@ brw_blorp_blit_program::manual_blend(unsigned num_samples) /* 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 } /** @@ -1532,7 +1567,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)); } /** @@ -1566,10 +1601,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) { @@ -1585,23 +1619,22 @@ 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; } break; default: - assert(!"Should not get here."); - break; + unreachable("Should not get here."); }; } @@ -1612,13 +1645,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::texture_lookup(struct brw_reg dst, - GLuint msg_type, + enum opcode op, const sampler_message_arg *args, int num_args) { @@ -1627,16 +1660,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: - brw_MOV(&func, retype(mrf, BRW_REGISTER_TYPE_F), X); + 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: - brw_MOV(&func, retype(mrf, BRW_REGISTER_TYPE_F), Y); + 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: - brw_MOV(&func, mrf, X); + emit_mov(mrf, X); break; case SAMPLER_MESSAGE_ARG_V_INT: - brw_MOV(&func, mrf, Y); + emit_mov(mrf, Y); break; case SAMPLER_MESSAGE_ARG_SI_INT: /* Note: on Gen7, this code may be reached with s_is_zero==true @@ -1645,14 +1686,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 - brw_MOV(&func, mrf, S); + 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, @@ -1668,24 +1709,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_F) /* dest */, - base_mrf /* msg_reg_nr */, - brw_message_reg(base_mrf) /* src0 */, - BRW_BLORP_TEXTURE_BINDING_TABLE_INDEX, - 0 /* sampler */, - 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 @@ -1708,30 +1741,25 @@ 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); } @@ -1787,7 +1815,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); } @@ -1804,12 +1832,49 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, 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, src_level, src_layer); - dst.set(brw, dst_mt, dst_level, dst_layer); + 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; + } - 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)); @@ -1824,7 +1889,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 { @@ -1835,11 +1900,10 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, wm_prog_key.texture_data_type = BRW_REGISTER_TYPE_D; break; default: - assert(!"Unrecognized blorp format"); - break; + unreachable("Unrecognized blorp format"); } - 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 @@ -1869,10 +1933,19 @@ 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? */ @@ -1912,6 +1985,11 @@ 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.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); @@ -1943,8 +2021,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw, 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; } @@ -2030,11 +2107,12 @@ 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); + 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); brw_upload_cache(&brw->cache, BRW_BLORP_BLIT_PROG,