fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 02:58:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

i965/blorp: Get rid of the blorp_blit_params class

Browse source 
It was really just a wrapper around the function that constructed it.

Reviewed-by: Topi Pohjolainen <topi.pohjolainen@intel.com>
Reviewed-by: Matt Turner <mattst88@gmail.com>
This commit is contained in:
Jason Ekstrand 2016-04-22 14:06:08 -07:00
parent 8096ed7e27
commit 3839936497
2 changed files with 128 additions and 164 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/mesa/drivers/dri/i965/brw_blorp.h
View file

@ -351,26 +351,6 @@ struct brw_blorp_blit_prog_key
bool bilinear_filter;
};
class brw_blorp_blit_params : public brw_blorp_params
{
public:
brw_blorp_blit_params(struct brw_context *brw,
struct intel_mipmap_tree *src_mt,
unsigned src_level, unsigned src_layer,
mesa_format src_format,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
mesa_format dst_format,
GLfloat src_x0, GLfloat src_y0,
GLfloat src_x1, GLfloat src_y1,
GLfloat dst_x0, GLfloat dst_y0,
GLfloat dst_x1, GLfloat dst_y1,
GLenum filter, bool mirror_x, bool mirror_y);
private:
brw_blorp_blit_prog_key wm_prog_key;
};
/**
* \name BLORP internals
* \{

272
src/mesa/drivers/dri/i965/brw_blorp_blit.cpp
View file

@ -44,74 +44,6 @@ 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 brw_context *brw,
struct intel_mipmap_tree *src_mt,
unsigned src_level, unsigned src_layer,
mesa_format src_format, int src_swizzle,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
mesa_format dst_format,
float src_x0, float src_y0,
float src_x1, float src_y1,
float dst_x0, float dst_y0,
float dst_x1, float dst_y1,
GLenum filter, bool mirror_x, bool mirror_y,
bool decode_srgb, bool encode_srgb)
{
/* 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.
* Lossless compression is only introduced for gen9 onwards whereas
* blorp is not supported even for gen8. Therefore it should be impossible
* to end up here with single sampled compressed surfaces.
*/
assert(!intel_miptree_is_lossless_compressed(brw, src_mt));
assert(!intel_miptree_is_lossless_compressed(brw, dst_mt));
intel_miptree_resolve_color(brw, src_mt, 0);
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",
__func__,
src_mt->num_samples, _mesa_get_format_name(src_mt->format), src_mt,
src_level, src_layer, src_x0, src_y0, src_x1, src_y1,
dst_mt->num_samples, _mesa_get_format_name(dst_mt->format), dst_mt,
dst_level, dst_layer, dst_x0, dst_y0, dst_x1, dst_y1,
mirror_x, mirror_y);
if (!decode_srgb && _mesa_get_format_color_encoding(src_format) == GL_SRGB)
src_format = _mesa_get_srgb_format_linear(src_format);
if (!encode_srgb && _mesa_get_format_color_encoding(dst_format) == GL_SRGB)
dst_format = _mesa_get_srgb_format_linear(dst_format);
brw_blorp_blit_params params(brw,
src_mt, src_level, src_layer, src_format,
dst_mt, dst_level, dst_layer, dst_format,
src_x0, src_y0,
src_x1, src_y1,
dst_x0, dst_y0,
dst_x1, dst_y1,
filter, mirror_x, mirror_y);
params.src.swizzle = src_swizzle;
brw_blorp_exec(brw, &params);
intel_miptree_slice_set_needs_hiz_resolve(dst_mt, dst_level, dst_layer);
}
static int
blorp_get_texture_swizzle(const struct intel_renderbuffer *irb)
{
@ -1911,22 +1843,62 @@ 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,
mesa_format src_format,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
mesa_format dst_format,
GLfloat src_x0, GLfloat src_y0,
GLfloat src_x1, GLfloat src_y1,
GLfloat dst_x0, GLfloat dst_y0,
GLfloat dst_x1, GLfloat dst_y1,
GLenum filter,
bool mirror_x, bool mirror_y)
/**
* 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 brw_context *brw,
struct intel_mipmap_tree *src_mt,
unsigned src_level, unsigned src_layer,
mesa_format src_format, int src_swizzle,
struct intel_mipmap_tree *dst_mt,
unsigned dst_level, unsigned dst_layer,
mesa_format dst_format,
float src_x0, float src_y0,
float src_x1, float src_y1,
float dst_x0, float dst_y0,
float dst_x1, float dst_y1,
GLenum filter, bool mirror_x, bool mirror_y,
bool decode_srgb, bool encode_srgb)
{
src.set(brw, src_mt, src_level, src_layer, src_format, false);
dst.set(brw, dst_mt, dst_level, dst_layer, dst_format, true);
/* 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.
* Lossless compression is only introduced for gen9 onwards whereas
* blorp is not supported even for gen8. Therefore it should be impossible
* to end up here with single sampled compressed surfaces.
*/
assert(!intel_miptree_is_lossless_compressed(brw, src_mt));
assert(!intel_miptree_is_lossless_compressed(brw, dst_mt));
intel_miptree_resolve_color(brw, src_mt, 0);
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",
__func__,
src_mt->num_samples, _mesa_get_format_name(src_mt->format), src_mt,
src_level, src_layer, src_x0, src_y0, src_x1, src_y1,
dst_mt->num_samples, _mesa_get_format_name(dst_mt->format), dst_mt,
dst_level, dst_layer, dst_x0, dst_y0, dst_x1, dst_y1,
mirror_x, mirror_y);
if (!decode_srgb && _mesa_get_format_color_encoding(src_format) == GL_SRGB)
src_format = _mesa_get_srgb_format_linear(src_format);
if (!encode_srgb && _mesa_get_format_color_encoding(dst_format) == GL_SRGB)
dst_format = _mesa_get_srgb_format_linear(dst_format);
brw_blorp_params params;
params.src.set(brw, src_mt, src_level, src_layer, src_format, false);
params.dst.set(brw, dst_mt, dst_level, dst_layer, dst_format, true);
/* Even though we do multisample resolves at the time of the blit, OpenGL
* specification defines them as if they happen at the time of rendering,
@ -1943,13 +1915,13 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
* (aside from the color space), we choose to blit in sRGB space to get
* this higher quality image.
*/
if (src.num_samples > 1 &&
if (params.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)) {
assert(brw->format_supported_as_render_target[dst_mt->format]);
dst.brw_surfaceformat = brw->render_target_format[dst_mt->format];
src.brw_surfaceformat = brw_format_for_mesa_format(dst_mt->format);
params.dst.brw_surfaceformat = brw->render_target_format[dst_mt->format];
params.src.brw_surfaceformat = brw_format_for_mesa_format(dst_mt->format);
}
/* When doing a multisample resolve of a GL_LUMINANCE32F or GL_INTENSITY32F
@ -1961,12 +1933,14 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
* 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 &&
if (brw->gen == 6 &&
params.src.num_samples > 1 && params.dst.num_samples <= 1 &&
src_mt->format == dst_mt->format &&
dst.brw_surfaceformat == BRW_SURFACEFORMAT_R32_FLOAT) {
src.brw_surfaceformat = dst.brw_surfaceformat;
params.dst.brw_surfaceformat == BRW_SURFACEFORMAT_R32_FLOAT) {
params.src.brw_surfaceformat = params.dst.brw_surfaceformat;
}
struct brw_blorp_blit_prog_key wm_prog_key;
memset(&wm_prog_key, 0, sizeof(wm_prog_key));
/* texture_data_type indicates the register type that should be used to
@ -2001,10 +1975,10 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
* single-sampled texture and interleave the samples ourselves.
*/
if (dst_mt->msaa_layout == INTEL_MSAA_LAYOUT_IMS)
dst.num_samples = 0;
params.dst.num_samples = 0;
}
if (dst.map_stencil_as_y_tiled && dst.num_samples > 1) {
if (params.dst.map_stencil_as_y_tiled && params.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
@ -2014,7 +1988,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 > 1) {
if (params.src.num_samples > 0 && params.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
@ -2034,7 +2008,8 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
wm_prog_key.x_scale = 2.0f;
wm_prog_key.y_scale = src_mt->num_samples / 2.0f;
if (filter == GL_LINEAR && src.num_samples <= 1 && dst.num_samples <= 1)
if (filter == GL_LINEAR &&
params.src.num_samples <= 1 && params.dst.num_samples <= 1)
wm_prog_key.bilinear_filter = true;
GLenum base_format = _mesa_get_format_base_format(src_mt->format);
@ -2052,16 +2027,18 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
/* tex_samples and rt_samples are the sample counts that are set up in
* SURFACE_STATE.
*/
wm_prog_key.tex_samples = src.num_samples;
wm_prog_key.rt_samples = dst.num_samples;
wm_prog_key.tex_samples = params.src.num_samples;
wm_prog_key.rt_samples = params.dst.num_samples;
/* tex_layout and rt_layout indicate the MSAA layout the GPU pipeline will
* use to access the source and destination surfaces.
*/
wm_prog_key.tex_layout =
compute_msaa_layout_for_pipeline(brw, src.num_samples, src.msaa_layout);
compute_msaa_layout_for_pipeline(brw, params.src.num_samples,
params.src.msaa_layout);
wm_prog_key.rt_layout =
compute_msaa_layout_for_pipeline(brw, dst.num_samples, dst.msaa_layout);
compute_msaa_layout_for_pipeline(brw, params.dst.num_samples,
params.dst.msaa_layout);
/* src_layout and dst_layout indicate the true MSAA layout used by src and
* dst.
@ -2069,26 +2046,27 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
wm_prog_key.src_layout = src_mt->msaa_layout;
wm_prog_key.dst_layout = dst_mt->msaa_layout;
wm_prog_key.src_tiled_w = src.map_stencil_as_y_tiled;
wm_prog_key.dst_tiled_w = dst.map_stencil_as_y_tiled;
wm_prog_key.src_tiled_w = params.src.map_stencil_as_y_tiled;
wm_prog_key.dst_tiled_w = params.dst.map_stencil_as_y_tiled;
/* Round floating point values to nearest integer to avoid "off by one texel"
* kind of errors when blitting.
*/
x0 = wm_push_consts.dst_x0 = roundf(dst_x0);
y0 = wm_push_consts.dst_y0 = roundf(dst_y0);
x1 = wm_push_consts.dst_x1 = roundf(dst_x1);
y1 = wm_push_consts.dst_y1 = roundf(dst_y1);
wm_push_consts.rect_grid_x1 = (minify(src_mt->logical_width0, src_level) *
wm_prog_key.x_scale - 1.0f);
wm_push_consts.rect_grid_y1 = (minify(src_mt->logical_height0, src_level) *
wm_prog_key.y_scale - 1.0f);
params.x0 = params.wm_push_consts.dst_x0 = roundf(dst_x0);
params.y0 = params.wm_push_consts.dst_y0 = roundf(dst_y0);
params.x1 = params.wm_push_consts.dst_x1 = roundf(dst_x1);
params.y1 = params.wm_push_consts.dst_y1 = roundf(dst_y1);
params.wm_push_consts.rect_grid_x1 =
minify(src_mt->logical_width0, src_level) * wm_prog_key.x_scale - 1.0f;
params.wm_push_consts.rect_grid_y1 =
minify(src_mt->logical_height0, src_level) * wm_prog_key.y_scale - 1.0f;
wm_push_consts.x_transform.setup(src_x0, src_x1, dst_x0, dst_x1, mirror_x);
wm_push_consts.y_transform.setup(src_y0, src_y1, dst_y0, dst_y1, mirror_y);
params.wm_push_consts.x_transform.setup(src_x0, src_x1, dst_x0, dst_x1, mirror_x);
params.wm_push_consts.y_transform.setup(src_y0, src_y1, dst_y0, dst_y1, mirror_y);
wm_push_consts.src_z = src.mt->target == GL_TEXTURE_3D ? src.layer : 0;
params.wm_push_consts.src_z =
params.src.mt->target == GL_TEXTURE_3D ? params.src.layer : 0;
if (dst.num_samples <= 1 && dst_mt->num_samples > 1) {
if (params.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
@ -2104,22 +2082,22 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
assert(dst_mt->msaa_layout == INTEL_MSAA_LAYOUT_IMS);
switch (dst_mt->num_samples) {
case 2:
x0 = ROUND_DOWN_TO(x0 * 2, 4);
y0 = ROUND_DOWN_TO(y0, 4);
x1 = ALIGN(x1 * 2, 4);
y1 = ALIGN(y1, 4);
params.x0 = ROUND_DOWN_TO(params.x0 * 2, 4);
params.y0 = ROUND_DOWN_TO(params.y0, 4);
params.x1 = ALIGN(params.x1 * 2, 4);
params.y1 = ALIGN(params.y1, 4);
break;
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);
params.x0 = ROUND_DOWN_TO(params.x0 * 2, 4);
params.y0 = ROUND_DOWN_TO(params.y0 * 2, 4);
params.x1 = ALIGN(params.x1 * 2, 4);
params.y1 = ALIGN(params.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);
params.x0 = ROUND_DOWN_TO(params.x0 * 4, 8);
params.y0 = ROUND_DOWN_TO(params.y0 * 2, 4);
params.x1 = ALIGN(params.x1 * 4, 8);
params.y1 = ALIGN(params.y1 * 2, 4);
break;
default:
unreachable("Unrecognized sample count in brw_blorp_blit_params ctor");
@ -2127,7 +2105,7 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
wm_prog_key.use_kill = true;
}
if (dst.map_stencil_as_y_tiled) {
if (params.dst.map_stencil_as_y_tiled) {
/* 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
@ -2174,19 +2152,19 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
* TODO: what if this makes the coordinates (or the texture size) too
* large?
*/
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;
const unsigned x_align = 8, y_align = params.dst.num_samples != 0 ? 8 : 4;
params.x0 = ROUND_DOWN_TO(params.x0, x_align) * 2;
params.y0 = ROUND_DOWN_TO(params.y0, y_align) / 2;
params.x1 = ALIGN(params.x1, x_align) * 2;
params.y1 = ALIGN(params.y1, y_align) / 2;
params.dst.width = ALIGN(params.dst.width, x_align) * 2;
params.dst.height = ALIGN(params.dst.height, y_align) / 2;
params.dst.x_offset *= 2;
params.dst.y_offset /= 2;
wm_prog_key.use_kill = true;
}
if (src.map_stencil_as_y_tiled) {
if (params.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.
@ -2196,24 +2174,30 @@ brw_blorp_blit_params::brw_blorp_blit_params(struct brw_context *brw,
*
* 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;
const unsigned x_align = 8, y_align = params.src.num_samples != 0 ? 8 : 4;
params.src.width = ALIGN(params.src.width, x_align) * 2;
params.src.height = ALIGN(params.src.height, y_align) / 2;
params.src.x_offset *= 2;
params.src.y_offset /= 2;
}
if (!brw_search_cache(&brw->cache, BRW_CACHE_BLORP_PROG,
&this->wm_prog_key, sizeof(this->wm_prog_key),
&this->wm_prog_kernel, &this->wm_prog_data)) {
brw_blorp_blit_program prog(brw, &this->wm_prog_key);
&wm_prog_key, sizeof(wm_prog_key),
&params.wm_prog_kernel, &params.wm_prog_data)) {
brw_blorp_blit_program prog(brw, &wm_prog_key);
GLuint program_size;
const GLuint *program = prog.compile(brw, INTEL_DEBUG & DEBUG_BLORP,
&program_size);
brw_upload_cache(&brw->cache, BRW_CACHE_BLORP_PROG,
&this->wm_prog_key, sizeof(this->wm_prog_key),
&wm_prog_key, sizeof(wm_prog_key),
program, program_size,
&prog.prog_data, sizeof(prog.prog_data),
&this->wm_prog_kernel, &this->wm_prog_data);
&params.wm_prog_kernel, &params.wm_prog_data);
}
params.src.swizzle = src_swizzle;
brw_blorp_exec(brw, &params);
intel_miptree_slice_set_needs_hiz_resolve(dst_mt, dst_level, dst_layer);
}