← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/postprocess/pp_mlaa.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}