reactos/dll/opengl/mesa/src/gallium/auxiliary/postprocess/pp_mlaa.c

   1 /**
   2  * Copyright (C) 2010 Jorge Jimenez (jorge@iryoku.com)
   3  * Copyright (C) 2010 Belen Masia (bmasia@unizar.es)
   4  * Copyright (C) 2010 Jose I. Echevarria (joseignacioechevarria@gmail.com)
   5  * Copyright (C) 2010 Fernando Navarro (fernandn@microsoft.com)
   6  * Copyright (C) 2010 Diego Gutierrez (diegog@unizar.es)
   7  * Copyright (C) 2011 Lauri Kasanen (cand@gmx.com)
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  *
  13  *    1. Redistributions of source code must retain the above copyright notice,
  14  *       this list of conditions and the following disclaimer.
  15  *
  16  *    2. Redistributions in binary form must reproduce the following statement:
  17  *
  18  *       "Uses Jimenez's MLAA. Copyright (C) 2010 by Jorge Jimenez, Belen Masia,
  19  *        Jose I. Echevarria, Fernando Navarro and Diego Gutierrez."
  20  *
  21  *       Only for use in the Mesa project, this point 2 is filled by naming the
  22  *       technique Jimenez's MLAA in the Mesa config options.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
  25  * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  26  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  27  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS OR CONTRIBUTORS
  28  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * The views and conclusions contained in the software and documentation are
  37  * those of the authors and should not be interpreted as representing official
  38  * policies, either expressed or implied, of the copyright holders.
  39  */
  40
  41 #include "pipe/p_compiler.h"
  42
  43 #include "postprocess/postprocess.h"
  44 #include "postprocess/pp_mlaa.h"
  45 #include "postprocess/pp_filters.h"
  46 #include "util/u_blit.h"
  47 #include "util/u_box.h"
  48 #include "util/u_sampler.h"
  49 #include "util/u_inlines.h"
  50 #include "util/u_memory.h"
  51 #include "util/u_string.h"
  52 #include "pipe/p_screen.h"
  53
  54 #define IMM_SPACE 80
  55
  56 static float constants[] = { 1, 1, 0, 0 };
  57 static unsigned int dimensions[2] = { 0, 0 };
  58
  59 static struct pipe_resource *constbuf, *areamaptex;
  60
  61 /** Upload the constants. */
  62 static void
  63 up_consts(struct pipe_context *pipe)
  64 {
  65    struct pipe_box box;
  66
  67    u_box_2d(0, 0, sizeof(constants), 1, &box);
  68    pipe->transfer_inline_write(pipe, constbuf, 0, PIPE_TRANSFER_WRITE,
  69                                &box, constants, sizeof(constants),
  70                                sizeof(constants));
  71 }
  72
  73 /** Run function of the MLAA filter. */
  74 static void
  75 pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
  76                    struct pipe_resource *out, unsigned int n, bool iscolor)
  77 {
  78
  79    struct program *p = ppq->p;
  80
  81    struct pipe_depth_stencil_alpha_state mstencil;
  82    struct pipe_sampler_view v_tmp, *arr[3];
  83
  84    unsigned int w = p->framebuffer.width;
  85    unsigned int h = p->framebuffer.height;
  86
  87    const struct pipe_stencil_ref ref = { {1} };
  88    memset(&mstencil, 0, sizeof(mstencil));
  89    cso_set_stencil_ref(p->cso, &ref);
  90
  91    /* Init the pixel size constant */
  92    if (dimensions[0] != p->framebuffer.width ||
  93        dimensions[1] != p->framebuffer.height) {
  94       constants[0] = 1.0 / p->framebuffer.width;
  95       constants[1] = 1.0 / p->framebuffer.height;
  96
  97       up_consts(p->pipe);
  98       dimensions[0] = p->framebuffer.width;
  99       dimensions[1] = p->framebuffer.height;
 100    }
 101
 102    p->pipe->set_constant_buffer(p->pipe, PIPE_SHADER_VERTEX, 0, constbuf);
 103    p->pipe->set_constant_buffer(p->pipe, PIPE_SHADER_FRAGMENT, 0, constbuf);
 104
 105    mstencil.stencil[0].enabled = 1;
 106    mstencil.stencil[0].valuemask = mstencil.stencil[0].writemask = ~0;
 107    mstencil.stencil[0].func = PIPE_FUNC_ALWAYS;
 108    mstencil.stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
 109    mstencil.stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
 110    mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
 111
 112    p->framebuffer.zsbuf = ppq->stencils;
 113
 114    /* First pass: depth edge detection */
 115    if (iscolor)
 116       pp_filter_setup_in(p, in);
 117    else
 118       pp_filter_setup_in(p, ppq->depth);
 119
 120    pp_filter_setup_out(p, ppq->inner_tmp[0]);
 121
 122    pp_filter_set_fb(p);
 123    pp_filter_misc_state(p);
 124    cso_set_depth_stencil_alpha(p->cso, &mstencil);
 125    p->pipe->clear(p->pipe, PIPE_CLEAR_STENCIL | PIPE_CLEAR_COLOR,
 126                   &p->clear_color, 0, 0);
 127
 128    cso_single_sampler(p->cso, 0, &p->sampler_point);
 129    cso_single_sampler_done(p->cso);
 130    cso_set_fragment_sampler_views(p->cso, 1, &p->view);
 131
 132    cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]);    /* offsetvs */
 133    cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][2]);
 134
 135    pp_filter_draw(p);
 136    pp_filter_end_pass(p);
 137
 138
 139    /* Second pass: blend weights */
 140    /* Sampler order: areamap, edgesmap, edgesmapL (reversed, thx compiler) */
 141    mstencil.stencil[0].func = PIPE_FUNC_EQUAL;
 142    mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_KEEP;
 143    cso_set_depth_stencil_alpha(p->cso, &mstencil);
 144
 145    pp_filter_setup_in(p, areamaptex);
 146    pp_filter_setup_out(p, ppq->inner_tmp[1]);
 147
 148    u_sampler_view_default_template(&v_tmp, ppq->inner_tmp[0],
 149                                    ppq->inner_tmp[0]->format);
 150    arr[1] = arr[2] = p->pipe->create_sampler_view(p->pipe,
 151                                                   ppq->inner_tmp[0], &v_tmp);
 152
 153    pp_filter_set_clear_fb(p);
 154
 155    cso_single_sampler(p->cso, 0, &p->sampler_point);
 156    cso_single_sampler(p->cso, 1, &p->sampler_point);
 157    cso_single_sampler(p->cso, 2, &p->sampler);
 158    cso_single_sampler_done(p->cso);
 159
 160    arr[0] = p->view;
 161    cso_set_fragment_sampler_views(p->cso, 3, arr);
 162
 163    cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]);    /* passvs */
 164    cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][3]);
 165
 166    pp_filter_draw(p);
 167    pp_filter_end_pass(p);
 168    pipe_sampler_view_reference(&arr[1], NULL);
 169
 170
 171    /* Third pass: smoothed edges */
 172    /* Sampler order: colormap, blendmap (wtf compiler) */
 173    pp_filter_setup_in(p, ppq->inner_tmp[1]);
 174    pp_filter_setup_out(p, out);
 175
 176    pp_filter_set_fb(p);
 177
 178    /* Blit the input to the output */
 179    util_blit_pixels(p->blitctx, in, 0, 0, 0,
 180                     w, h, 0, p->framebuffer.cbufs[0],
 181                     0, 0, w, h, 0, PIPE_TEX_MIPFILTER_NEAREST);
 182
 183    u_sampler_view_default_template(&v_tmp, in, in->format);
 184    arr[0] = p->pipe->create_sampler_view(p->pipe, in, &v_tmp);
 185
 186    cso_single_sampler(p->cso, 0, &p->sampler_point);
 187    cso_single_sampler(p->cso, 1, &p->sampler_point);
 188    cso_single_sampler_done(p->cso);
 189
 190    arr[1] = p->view;
 191    cso_set_fragment_sampler_views(p->cso, 2, arr);
 192
 193    cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]);    /* offsetvs */
 194    cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]);
 195
 196    p->blend.rt[0].blend_enable = 1;
 197    cso_set_blend(p->cso, &p->blend);
 198
 199    pp_filter_draw(p);
 200    pp_filter_end_pass(p);
 201    pipe_sampler_view_reference(&arr[0], NULL);
 202
 203    p->blend.rt[0].blend_enable = 0;
 204    p->framebuffer.zsbuf = NULL;
 205 }
 206
 207 /** The init function of the MLAA filter. */
 208 static void
 209 pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n,
 210                         unsigned int val, bool iscolor)
 211 {
 212
 213    struct pipe_box box;
 214    struct pipe_resource res;
 215    char *tmp_text;
 216
 217    constbuf = pipe_buffer_create(ppq->p->screen, PIPE_BIND_CONSTANT_BUFFER,
 218                                  PIPE_USAGE_STATIC, sizeof(constants));
 219    if (!constbuf) {
 220       pp_debug("Failed to allocate constant buffer\n");
 221       return;
 222    }
 223
 224
 225    pp_debug("mlaa: using %u max search steps\n", val);
 226
 227    tmp_text = CALLOC(sizeof(blend2fs_1) + sizeof(blend2fs_2) +
 228                      IMM_SPACE, sizeof(char));
 229
 230    if (!tmp_text) {
 231       pp_debug("Failed to allocate shader space\n");
 232       return;
 233    }
 234    util_sprintf(tmp_text, "%s"
 235                 "IMM FLT32 {    %.8f,     0.0000,     0.0000,     0.0000}\n"
 236                 "%s\n", blend2fs_1, (float) val, blend2fs_2);
 237
 238    memset(&res, 0, sizeof(res));
 239
 240    res.target = PIPE_TEXTURE_2D;
 241    res.format = PIPE_FORMAT_R8G8_UNORM;
 242    res.width0 = res.height0 = 165;
 243    res.bind = PIPE_BIND_SAMPLER_VIEW;
 244    res.usage = PIPE_USAGE_STATIC;
 245    res.depth0 = res.array_size = res.nr_samples = 1;
 246
 247    if (!ppq->p->screen->is_format_supported(ppq->p->screen, res.format,
 248                                             res.target, 1, res.bind))
 249       pp_debug("Areamap format not supported\n");
 250
 251    areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res);
 252    u_box_2d(0, 0, 165, 165, &box);
 253
 254    ppq->p->pipe->transfer_inline_write(ppq->p->pipe, areamaptex, 0,
 255                                        PIPE_TRANSFER_WRITE, &box,
 256                                        areamap, 165 * 2, sizeof(areamap));
 257
 258
 259
 260    ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true,
 261                                          "offsetvs");
 262    if (iscolor)
 263       ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, color1fs,
 264                                             false, "color1fs");
 265    else
 266       ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, depth1fs,
 267                                             false, "depth1fs");
 268    ppq->shaders[n][3] = pp_tgsi_to_state(ppq->p->pipe, tmp_text, false,
 269                                          "blend2fs");
 270    ppq->shaders[n][4] = pp_tgsi_to_state(ppq->p->pipe, neigh3fs, false,
 271                                          "neigh3fs");
 272
 273    FREE(tmp_text);
 274 }
 275
 276 /** Short wrapper to init the depth version. */
 277 void
 278 pp_jimenezmlaa_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
 279 {
 280
 281    pp_jimenezmlaa_init_run(ppq, n, val, false);
 282 }
 283
 284 /** Short wrapper to init the color version. */
 285 void
 286 pp_jimenezmlaa_init_color(struct pp_queue_t *ppq, unsigned int n,
 287                           unsigned int val)
 288 {
 289
 290    pp_jimenezmlaa_init_run(ppq, n, val, true);
 291 }
 292
 293 /** Short wrapper to run the depth version. */
 294 void
 295 pp_jimenezmlaa(struct pp_queue_t *ppq, struct pipe_resource *in,
 296                struct pipe_resource *out, unsigned int n)
 297 {
 298    pp_jimenezmlaa_run(ppq, in, out, n, false);
 299 }
 300
 301 /** Short wrapper to run the color version. */
 302 void
 303 pp_jimenezmlaa_color(struct pp_queue_t *ppq, struct pipe_resource *in,
 304                      struct pipe_resource *out, unsigned int n)
 305 {
 306    pp_jimenezmlaa_run(ppq, in, out, n, true);
 307 }