From caeb3cdf2f6295b1b82ace2ad3ca6f7c9970fe17 Mon Sep 17 00:00:00 2001 From: Lauri Kasanen Date: Thu, 18 Aug 2011 10:23:11 +0300 Subject: pp: Add Jimenez' MLAA Signed-off-by: Lauri Kasanen Signed-off-by: Brian Paul --- src/gallium/auxiliary/postprocess/pp_mlaa.c | 304 ++++++++++++++++++++++++++++ 1 file changed, 304 insertions(+) create mode 100644 src/gallium/auxiliary/postprocess/pp_mlaa.c (limited to 'src/gallium/auxiliary/postprocess/pp_mlaa.c') diff --git a/src/gallium/auxiliary/postprocess/pp_mlaa.c b/src/gallium/auxiliary/postprocess/pp_mlaa.c new file mode 100644 index 00000000000..476502fca93 --- /dev/null +++ b/src/gallium/auxiliary/postprocess/pp_mlaa.c @@ -0,0 +1,304 @@ +/** + * Copyright (C) 2010 Jorge Jimenez (jorge@iryoku.com) + * Copyright (C) 2010 Belen Masia (bmasia@unizar.es) + * Copyright (C) 2010 Jose I. Echevarria (joseignacioechevarria@gmail.com) + * Copyright (C) 2010 Fernando Navarro (fernandn@microsoft.com) + * Copyright (C) 2010 Diego Gutierrez (diegog@unizar.es) + * Copyright (C) 2011 Lauri Kasanen (cand@gmx.com) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the following statement: + * + * "Uses Jimenez's MLAA. Copyright (C) 2010 by Jorge Jimenez, Belen Masia, + * Jose I. Echevarria, Fernando Navarro and Diego Gutierrez." + * + * Only for use in the Mesa project, this point 2 is filled by naming the + * technique Jimenez's MLAA in the Mesa config options. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS + * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are + * those of the authors and should not be interpreted as representing official + * policies, either expressed or implied, of the copyright holders. + */ + +#include +#include +#include "postprocess/postprocess.h" +#include "postprocess/pp_mlaa.h" +#include "postprocess/pp_filters.h" +#include "util/u_blit.h" +#include "util/u_box.h" +#include "util/u_sampler.h" +#include "util/u_inlines.h" +#include "pipe/p_screen.h" + +#define IMM_SPACE 80 + +static float constants[] = { 1, 1, 0, 0 }; +static unsigned int dimensions[2] = { 0, 0 }; + +static struct pipe_resource *constbuf, *areamaptex; + +/** Upload the constants. */ +static void +up_consts(struct pipe_context *pipe) +{ + struct pipe_box box; + + u_box_2d(0, 0, sizeof(constants), 1, &box); + pipe->transfer_inline_write(pipe, constbuf, 0, PIPE_TRANSFER_WRITE, + &box, constants, sizeof(constants), + sizeof(constants)); +} + +/** Run function of the MLAA filter. */ +static void +pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in, + struct pipe_resource *out, unsigned int n, bool iscolor) +{ + + struct program *p = ppq->p; + + struct pipe_depth_stencil_alpha_state mstencil; + struct pipe_sampler_view v_tmp, *arr[3]; + + unsigned int w = p->framebuffer.width; + unsigned int h = p->framebuffer.height; + + const struct pipe_stencil_ref ref = { {1} }; + memset(&mstencil, 0, sizeof(mstencil)); + cso_set_stencil_ref(p->cso, &ref); + + /* Init the pixel size constant */ + if (dimensions[0] != p->framebuffer.width || + dimensions[1] != p->framebuffer.height) { + constants[0] = 1.0 / p->framebuffer.width; + constants[1] = 1.0 / p->framebuffer.height; + + up_consts(p->pipe); + dimensions[0] = p->framebuffer.width; + dimensions[1] = p->framebuffer.height; + } + + p->pipe->set_constant_buffer(p->pipe, PIPE_SHADER_VERTEX, 0, constbuf); + p->pipe->set_constant_buffer(p->pipe, PIPE_SHADER_FRAGMENT, 0, constbuf); + + mstencil.stencil[0].enabled = 1; + mstencil.stencil[0].valuemask = mstencil.stencil[0].writemask = ~0; + mstencil.stencil[0].func = PIPE_FUNC_ALWAYS; + mstencil.stencil[0].fail_op = PIPE_STENCIL_OP_KEEP; + mstencil.stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP; + mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE; + + p->framebuffer.zsbuf = ppq->stencils; + + /* First pass: depth edge detection */ + if (iscolor) + pp_filter_setup_in(p, in); + else + pp_filter_setup_in(p, ppq->depth); + + pp_filter_setup_out(p, ppq->inner_tmp[0]); + + pp_filter_set_fb(p); + pp_filter_misc_state(p); + cso_set_depth_stencil_alpha(p->cso, &mstencil); + p->pipe->clear(p->pipe, PIPE_CLEAR_STENCIL | PIPE_CLEAR_COLOR, + p->clear_color, 0, 0); + + cso_single_sampler(p->cso, 0, &p->sampler_point); + cso_single_sampler_done(p->cso); + cso_set_fragment_sampler_views(p->cso, 1, &p->view); + + cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */ + cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][2]); + + pp_filter_draw(p); + pp_filter_end_pass(p); + + + /* Second pass: blend weights */ + /* Sampler order: areamap, edgesmap, edgesmapL (reversed, thx compiler) */ + mstencil.stencil[0].func = PIPE_FUNC_EQUAL; + mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_KEEP; + cso_set_depth_stencil_alpha(p->cso, &mstencil); + + pp_filter_setup_in(p, areamaptex); + pp_filter_setup_out(p, ppq->inner_tmp[1]); + + u_sampler_view_default_template(&v_tmp, ppq->inner_tmp[0], + ppq->inner_tmp[0]->format); + arr[1] = arr[2] = p->pipe->create_sampler_view(p->pipe, + ppq->inner_tmp[0], &v_tmp); + + pp_filter_set_clear_fb(p); + + cso_single_sampler(p->cso, 0, &p->sampler_point); + cso_single_sampler(p->cso, 1, &p->sampler_point); + cso_single_sampler(p->cso, 2, &p->sampler); + cso_single_sampler_done(p->cso); + + arr[0] = p->view; + cso_set_fragment_sampler_views(p->cso, 3, arr); + + cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]); /* passvs */ + cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][3]); + + pp_filter_draw(p); + pp_filter_end_pass(p); + pipe_sampler_view_reference(&arr[1], NULL); + + + /* Third pass: smoothed edges */ + /* Sampler order: colormap, blendmap (wtf compiler) */ + pp_filter_setup_in(p, ppq->inner_tmp[1]); + pp_filter_setup_out(p, out); + + pp_filter_set_fb(p); + + /* Blit the input to the output */ + util_blit_pixels(p->blitctx, in, 0, 0, 0, + w, h, 0, p->framebuffer.cbufs[0], + 0, 0, w, h, 0, PIPE_TEX_MIPFILTER_NEAREST); + + u_sampler_view_default_template(&v_tmp, in, in->format); + arr[0] = p->pipe->create_sampler_view(p->pipe, in, &v_tmp); + + cso_single_sampler(p->cso, 0, &p->sampler_point); + cso_single_sampler(p->cso, 1, &p->sampler_point); + cso_single_sampler_done(p->cso); + + arr[1] = p->view; + cso_set_fragment_sampler_views(p->cso, 2, arr); + + cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */ + cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]); + + p->blend.rt[0].blend_enable = 1; + cso_set_blend(p->cso, &p->blend); + + pp_filter_draw(p); + pp_filter_end_pass(p); + pipe_sampler_view_reference(&arr[0], NULL); + + p->blend.rt[0].blend_enable = 0; + p->framebuffer.zsbuf = NULL; +} + +/** The init function of the MLAA filter. */ +static void +pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n, + unsigned int val, bool iscolor) +{ + + struct pipe_box box; + struct pipe_resource res; + + char *tmp_text = calloc(sizeof(blend2fs_1) + sizeof(blend2fs_2) + + IMM_SPACE, sizeof(char)); + + constbuf = pipe_buffer_create(ppq->p->screen, PIPE_BIND_CONSTANT_BUFFER, + PIPE_USAGE_STATIC, sizeof(constants)); + if (!constbuf) { + pp_debug("Failed to allocate constant buffer\n"); + return; + } + + + pp_debug("mlaa: using %u max search steps\n", val); + + if (!tmp_text) { + pp_debug("Failed to allocate shader space\n"); + return; + } + sprintf(tmp_text, "%s" + "IMM FLT32 { %.8f, 0.0000, 0.0000, 0.0000}\n" + "%s\n", blend2fs_1, (float) val, blend2fs_2); + + memset(&res, 0, sizeof(res)); + + res.target = PIPE_TEXTURE_2D; + res.format = PIPE_FORMAT_R8G8_UNORM; + res.width0 = res.height0 = 165; + res.bind = PIPE_BIND_SAMPLER_VIEW; + res.usage = PIPE_USAGE_STATIC; + res.depth0 = res.array_size = res.nr_samples = 1; + + if (!ppq->p->screen->is_format_supported(ppq->p->screen, res.format, + res.target, 1, res.bind)) + pp_debug("Areamap format not supported\n"); + + areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res); + u_box_2d(0, 0, 165, 165, &box); + + ppq->p->pipe->transfer_inline_write(ppq->p->pipe, areamaptex, 0, + PIPE_TRANSFER_WRITE, &box, + areamap, 165 * 2, sizeof(areamap)); + + + + ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true, + "offsetvs"); + if (iscolor) + ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, color1fs, + false, "color1fs"); + else + ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, depth1fs, + false, "depth1fs"); + ppq->shaders[n][3] = pp_tgsi_to_state(ppq->p->pipe, tmp_text, false, + "blend2fs"); + ppq->shaders[n][4] = pp_tgsi_to_state(ppq->p->pipe, neigh3fs, false, + "neigh3fs"); + + free(tmp_text); +} + +/** Short wrapper to init the depth version. */ +void +pp_jimenezmlaa_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val) +{ + + pp_jimenezmlaa_init_run(ppq, n, val, false); +} + +/** Short wrapper to init the color version. */ +void +pp_jimenezmlaa_init_color(struct pp_queue_t *ppq, unsigned int n, + unsigned int val) +{ + + pp_jimenezmlaa_init_run(ppq, n, val, true); +} + +/** Short wrapper to run the depth version. */ +void +pp_jimenezmlaa(struct pp_queue_t *ppq, struct pipe_resource *in, + struct pipe_resource *out, unsigned int n) +{ + pp_jimenezmlaa_run(ppq, in, out, n, false); +} + +/** Short wrapper to run the color version. */ +void +pp_jimenezmlaa_color(struct pp_queue_t *ppq, struct pipe_resource *in, + struct pipe_resource *out, unsigned int n) +{ + pp_jimenezmlaa_run(ppq, in, out, n, true); +} -- cgit v1.2.3