1 /** 2 * Copyright (C) 2010 Jorge Jimenez (jorge (at) iryoku.com) 3 * Copyright (C) 2010 Belen Masia (bmasia (at) unizar.es) 4 * Copyright (C) 2010 Jose I. Echevarria (joseignacioechevarria (at) gmail.com) 5 * Copyright (C) 2010 Fernando Navarro (fernandn (at) microsoft.com) 6 * Copyright (C) 2010 Diego Gutierrez (diegog (at) unizar.es) 7 * Copyright (C) 2011 Lauri Kasanen (cand (at) 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 pipe_set_constant_buffer(p->pipe, PIPE_SHADER_VERTEX, 0, constbuf); 103 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, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point); 129 cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT); 130 cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 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, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point); 156 cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->sampler_point); 157 cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 2, &p->sampler); 158 cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT); 159 160 arr[0] = p->view; 161 cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 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 TGSI_WRITEMASK_XYZW, 0); 183 184 u_sampler_view_default_template(&v_tmp, in, in->format); 185 arr[0] = p->pipe->create_sampler_view(p->pipe, in, &v_tmp); 186 187 cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 0, &p->sampler_point); 188 cso_single_sampler(p->cso, PIPE_SHADER_FRAGMENT, 1, &p->sampler_point); 189 cso_single_sampler_done(p->cso, PIPE_SHADER_FRAGMENT); 190 191 arr[1] = p->view; 192 cso_set_sampler_views(p->cso, PIPE_SHADER_FRAGMENT, 2, arr); 193 194 cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]); /* offsetvs */ 195 cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]); 196 197 p->blend.rt[0].blend_enable = 1; 198 cso_set_blend(p->cso, &p->blend); 199 200 pp_filter_draw(p); 201 pp_filter_end_pass(p); 202 pipe_sampler_view_reference(&arr[0], NULL); 203 204 p->blend.rt[0].blend_enable = 0; 205 p->framebuffer.zsbuf = NULL; 206 } 207 208 /** The init function of the MLAA filter. */ 209 static void 210 pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n, 211 unsigned int val, bool iscolor) 212 { 213 214 struct pipe_box box; 215 struct pipe_resource res; 216 char *tmp_text; 217 218 constbuf = pipe_buffer_create(ppq->p->screen, PIPE_BIND_CONSTANT_BUFFER, 219 PIPE_USAGE_STATIC, sizeof(constants)); 220 if (!constbuf) { 221 pp_debug("Failed to allocate constant buffer\n"); 222 return; 223 } 224 225 226 pp_debug("mlaa: using %u max search steps\n", val); 227 228 tmp_text = CALLOC(sizeof(blend2fs_1) + sizeof(blend2fs_2) + 229 IMM_SPACE, sizeof(char)); 230 231 if (!tmp_text) { 232 pp_debug("Failed to allocate shader space\n"); 233 return; 234 } 235 util_sprintf(tmp_text, "%s" 236 "IMM FLT32 { %.8f, 0.0000, 0.0000, 0.0000}\n" 237 "%s\n", blend2fs_1, (float) val, blend2fs_2); 238 239 memset(&res, 0, sizeof(res)); 240 241 res.target = PIPE_TEXTURE_2D; 242 res.format = PIPE_FORMAT_R8G8_UNORM; 243 res.width0 = res.height0 = 165; 244 res.bind = PIPE_BIND_SAMPLER_VIEW; 245 res.usage = PIPE_USAGE_STATIC; 246 res.depth0 = res.array_size = res.nr_samples = 1; 247 248 if (!ppq->p->screen->is_format_supported(ppq->p->screen, res.format, 249 res.target, 1, res.bind)) 250 pp_debug("Areamap format not supported\n"); 251 252 areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res); 253 u_box_2d(0, 0, 165, 165, &box); 254 255 ppq->p->pipe->transfer_inline_write(ppq->p->pipe, areamaptex, 0, 256 PIPE_TRANSFER_WRITE, &box, 257 areamap, 165 * 2, sizeof(areamap)); 258 259 260 261 ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true, 262 "offsetvs"); 263 if (iscolor) 264 ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, color1fs, 265 false, "color1fs"); 266 else 267 ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, depth1fs, 268 false, "depth1fs"); 269 ppq->shaders[n][3] = pp_tgsi_to_state(ppq->p->pipe, tmp_text, false, 270 "blend2fs"); 271 ppq->shaders[n][4] = pp_tgsi_to_state(ppq->p->pipe, neigh3fs, false, 272 "neigh3fs"); 273 274 FREE(tmp_text); 275 } 276 277 /** Short wrapper to init the depth version. */ 278 void 279 pp_jimenezmlaa_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val) 280 { 281 282 pp_jimenezmlaa_init_run(ppq, n, val, false); 283 } 284 285 /** Short wrapper to init the color version. */ 286 void 287 pp_jimenezmlaa_init_color(struct pp_queue_t *ppq, unsigned int n, 288 unsigned int val) 289 { 290 291 pp_jimenezmlaa_init_run(ppq, n, val, true); 292 } 293 294 /** Short wrapper to run the depth version. */ 295 void 296 pp_jimenezmlaa(struct pp_queue_t *ppq, struct pipe_resource *in, 297 struct pipe_resource *out, unsigned int n) 298 { 299 pp_jimenezmlaa_run(ppq, in, out, n, false); 300 } 301 302 /** Short wrapper to run the color version. */ 303 void 304 pp_jimenezmlaa_color(struct pp_queue_t *ppq, struct pipe_resource *in, 305 struct pipe_resource *out, unsigned int n) 306 { 307 pp_jimenezmlaa_run(ppq, in, out, n, true); 308 } 309
