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
up_consts(struct pipe_context * pipe)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
pp_jimenezmlaa_run(struct pp_queue_t * ppq,struct pipe_resource * in,struct pipe_resource * out,unsigned int n,bool iscolor)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
pp_jimenezmlaa_init_run(struct pp_queue_t * ppq,unsigned int n,unsigned int val,bool iscolor)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
pp_jimenezmlaa_init(struct pp_queue_t * ppq,unsigned int n,unsigned int val)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
pp_jimenezmlaa_init_color(struct pp_queue_t * ppq,unsigned int n,unsigned int val)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
pp_jimenezmlaa(struct pp_queue_t * ppq,struct pipe_resource * in,struct pipe_resource * out,unsigned int n)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
pp_jimenezmlaa_color(struct pp_queue_t * ppq,struct pipe_resource * in,struct pipe_resource * out,unsigned int n)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