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 "postprocess/pp_private.h"
47
48#include "util/u_box.h"
49#include "util/u_sampler.h"
50#include "util/u_inlines.h"
51#include "util/u_memory.h"
52#include "util/u_string.h"
53#include "pipe/p_screen.h"
54
55#define IMM_SPACE 80
56
57static float constants[] = { 1, 1, 0, 0 };
58static unsigned int dimensions[2] = { 0, 0 };
59
60/** Run function of the MLAA filter. */
61static void
62pp_jimenezmlaa_run(struct pp_queue_t *ppq, struct pipe_resource *in,
63                   struct pipe_resource *out, unsigned int n, bool iscolor)
64{
65
66   struct pp_program *p = ppq->p;
67
68   struct pipe_depth_stencil_alpha_state mstencil;
69   struct pipe_sampler_view v_tmp, *arr[3];
70
71   unsigned int w = 0;
72   unsigned int h = 0;
73
74   const struct pipe_stencil_ref ref = { {1} };
75
76   /* Insufficient initialization checks. */
77   assert(p);
78   assert(ppq);
79   assert(ppq->areamaptex);
80   assert(ppq->inner_tmp);
81   assert(ppq->shaders[n]);
82
83   w = p->framebuffer.width;
84   h = p->framebuffer.height;
85
86   memset(&mstencil, 0, sizeof(mstencil));
87
88   cso_set_stencil_ref(p->cso, ref);
89
90   /* Init the pixel size constant */
91   if (dimensions[0] != p->framebuffer.width ||
92       dimensions[1] != p->framebuffer.height) {
93      constants[0] = 1.0f / p->framebuffer.width;
94      constants[1] = 1.0f / p->framebuffer.height;
95
96      dimensions[0] = p->framebuffer.width;
97      dimensions[1] = p->framebuffer.height;
98   }
99
100   struct pipe_constant_buffer cb;
101   cb.buffer = NULL;
102   cb.buffer_offset = 0;
103   cb.buffer_size = sizeof(constants);
104   cb.user_buffer = constants;
105
106   struct pipe_context *pipe = ppq->p->pipe;
107   pipe->set_constant_buffer(pipe, PIPE_SHADER_VERTEX, 0, false, &cb);
108   pipe->set_constant_buffer(pipe, PIPE_SHADER_FRAGMENT, 0, false, &cb);
109
110   mstencil.stencil[0].enabled = 1;
111   mstencil.stencil[0].valuemask = mstencil.stencil[0].writemask = ~0;
112   mstencil.stencil[0].func = PIPE_FUNC_ALWAYS;
113   mstencil.stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
114   mstencil.stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
115   mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
116
117   p->framebuffer.zsbuf = ppq->stencils;
118
119   /* First pass: depth edge detection */
120   if (iscolor)
121      pp_filter_setup_in(p, in);
122   else
123      pp_filter_setup_in(p, ppq->depth);
124
125   pp_filter_setup_out(p, ppq->inner_tmp[0]);
126
127   pp_filter_set_fb(p);
128   pp_filter_misc_state(p);
129   cso_set_depth_stencil_alpha(p->cso, &mstencil);
130   p->pipe->clear(p->pipe, PIPE_CLEAR_STENCIL | PIPE_CLEAR_COLOR0, NULL,
131                  &p->clear_color, 0, 0);
132
133   {
134      const struct pipe_sampler_state *samplers[] = {&p->sampler_point};
135      cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 1, samplers);
136   }
137   pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 1, 0, false, &p->view);
138
139   cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]);    /* offsetvs */
140   cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][2]);
141
142   pp_filter_draw(p);
143   pp_filter_end_pass(p);
144
145
146   /* Second pass: blend weights */
147   /* Sampler order: areamap, edgesmap, edgesmapL (reversed, thx compiler) */
148   mstencil.stencil[0].func = PIPE_FUNC_EQUAL;
149   mstencil.stencil[0].zpass_op = PIPE_STENCIL_OP_KEEP;
150   cso_set_depth_stencil_alpha(p->cso, &mstencil);
151
152   pp_filter_setup_in(p, ppq->areamaptex);
153   pp_filter_setup_out(p, ppq->inner_tmp[1]);
154
155   u_sampler_view_default_template(&v_tmp, ppq->inner_tmp[0],
156                                   ppq->inner_tmp[0]->format);
157   arr[1] = arr[2] = p->pipe->create_sampler_view(p->pipe,
158                                                  ppq->inner_tmp[0], &v_tmp);
159
160   pp_filter_set_clear_fb(p);
161
162   {
163      const struct pipe_sampler_state *samplers[] =
164         {&p->sampler_point, &p->sampler_point, &p->sampler};
165      cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 3, samplers);
166   }
167
168   arr[0] = p->view;
169   pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 3, 0, false, arr);
170
171   cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][0]);    /* passvs */
172   cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][3]);
173
174   pp_filter_draw(p);
175   pp_filter_end_pass(p);
176   pipe_sampler_view_reference(&arr[1], NULL);
177
178
179   /* Third pass: smoothed edges */
180   /* Sampler order: colormap, blendmap (wtf compiler) */
181   pp_filter_setup_in(p, ppq->inner_tmp[1]);
182   pp_filter_setup_out(p, out);
183
184   pp_filter_set_fb(p);
185
186   /* Blit the input to the output */
187   pp_blit(p->pipe, in, 0, 0,
188           w, h, 0, p->framebuffer.cbufs[0],
189           0, 0, w, h);
190
191   u_sampler_view_default_template(&v_tmp, in, in->format);
192   arr[0] = p->pipe->create_sampler_view(p->pipe, in, &v_tmp);
193
194   {
195      const struct pipe_sampler_state *samplers[] =
196         {&p->sampler_point, &p->sampler_point};
197      cso_set_samplers(p->cso, PIPE_SHADER_FRAGMENT, 2, samplers);
198   }
199
200   arr[1] = p->view;
201   pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 2, 0, false, arr);
202
203   cso_set_vertex_shader_handle(p->cso, ppq->shaders[n][1]);    /* offsetvs */
204   cso_set_fragment_shader_handle(p->cso, ppq->shaders[n][4]);
205
206   p->blend.rt[0].blend_enable = 1;
207   cso_set_blend(p->cso, &p->blend);
208
209   pp_filter_draw(p);
210   pp_filter_end_pass(p);
211   pipe_sampler_view_reference(&arr[0], NULL);
212
213   p->blend.rt[0].blend_enable = 0;
214   p->framebuffer.zsbuf = NULL;
215}
216
217/** The init function of the MLAA filter. */
218static bool
219pp_jimenezmlaa_init_run(struct pp_queue_t *ppq, unsigned int n,
220                        unsigned int val, bool iscolor)
221{
222
223   struct pipe_box box;
224   struct pipe_resource res;
225   char *tmp_text = NULL;
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 FALSE;
233   }
234
235   pp_debug("mlaa: using %u max search steps\n", val);
236
237   sprintf(tmp_text, "%s"
238                "IMM FLT32 {    %.8f,     0.0000,     0.0000,     0.0000}\n"
239                "%s\n", blend2fs_1, (float) val, blend2fs_2);
240
241   memset(&res, 0, sizeof(res));
242
243   res.target = PIPE_TEXTURE_2D;
244   res.format = PIPE_FORMAT_R8G8_UNORM;
245   res.width0 = res.height0 = 165;
246   res.bind = PIPE_BIND_SAMPLER_VIEW;
247   res.usage = PIPE_USAGE_DEFAULT;
248   res.depth0 = res.array_size = res.nr_samples = res.nr_storage_samples = 1;
249
250   if (!ppq->p->screen->is_format_supported(ppq->p->screen, res.format,
251                                            res.target, 1, 1, res.bind))
252      pp_debug("Areamap format not supported\n");
253
254   ppq->areamaptex = ppq->p->screen->resource_create(ppq->p->screen, &res);
255
256   if (ppq->areamaptex == NULL) {
257      pp_debug("Failed to allocate area map texture\n");
258      goto fail;
259   }
260
261   u_box_2d(0, 0, 165, 165, &box);
262
263   ppq->p->pipe->texture_subdata(ppq->p->pipe, ppq->areamaptex, 0,
264                                 PIPE_MAP_WRITE, &box,
265                                 areamap, 165 * 2, sizeof(areamap));
266
267   ppq->shaders[n][1] = pp_tgsi_to_state(ppq->p->pipe, offsetvs, true,
268                                         "offsetvs");
269   if (iscolor)
270      ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, color1fs,
271                                            false, "color1fs");
272   else
273      ppq->shaders[n][2] = pp_tgsi_to_state(ppq->p->pipe, depth1fs,
274                                            false, "depth1fs");
275   ppq->shaders[n][3] = pp_tgsi_to_state(ppq->p->pipe, tmp_text, false,
276                                         "blend2fs");
277   ppq->shaders[n][4] = pp_tgsi_to_state(ppq->p->pipe, neigh3fs, false,
278                                         "neigh3fs");
279
280   FREE(tmp_text);
281
282   return TRUE;
283
284 fail:
285
286   FREE(tmp_text);
287
288   /*
289    * Call the common free function for destruction of partially initialized
290    * resources.
291    */
292   pp_jimenezmlaa_free(ppq, n);
293
294   return FALSE;
295}
296
297/** Short wrapper to init the depth version. */
298bool
299pp_jimenezmlaa_init(struct pp_queue_t *ppq, unsigned int n, unsigned int val)
300{
301   return pp_jimenezmlaa_init_run(ppq, n, val, false);
302}
303
304/** Short wrapper to init the color version. */
305bool
306pp_jimenezmlaa_init_color(struct pp_queue_t *ppq, unsigned int n,
307                          unsigned int val)
308{
309   return pp_jimenezmlaa_init_run(ppq, n, val, true);
310}
311
312/** Short wrapper to run the depth version. */
313void
314pp_jimenezmlaa(struct pp_queue_t *ppq, struct pipe_resource *in,
315               struct pipe_resource *out, unsigned int n)
316{
317   if (!ppq->depth) {
318      return;
319   }
320   pp_jimenezmlaa_run(ppq, in, out, n, false);
321}
322
323/** Short wrapper to run the color version. */
324void
325pp_jimenezmlaa_color(struct pp_queue_t *ppq, struct pipe_resource *in,
326                     struct pipe_resource *out, unsigned int n)
327{
328   pp_jimenezmlaa_run(ppq, in, out, n, true);
329}
330
331
332/**
333 * Short wrapper to free the mlaa filter resources. Shaders are freed in
334 * the common code in pp_free.
335 */
336void
337pp_jimenezmlaa_free(struct pp_queue_t *ppq, unsigned int n)
338{
339   pipe_resource_reference(&ppq->areamaptex, NULL);
340}
341
342