← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/llvmpipe/lp_bld_blend_soa.c
 
1
/**************************************************************************
 
2
 *
 
3
 * Copyright 2009 VMware, Inc.
 
4
 * All Rights Reserved.
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a
 
7
 * copy of this software and associated documentation files (the
 
8
 * "Software"), to deal in the Software without restriction, including
 
9
 * without limitation the rights to use, copy, modify, merge, publish,
 
10
 * distribute, sub license, and/or sell copies of the Software, and to
 
11
 * permit persons to whom the Software is furnished to do so, subject to
 
12
 * the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice (including the
 
15
 * next paragraph) shall be included in all copies or substantial portions
 
16
 * of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
19
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
20
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 
21
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
 
22
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
23
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
24
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
25
 *
 
26
 **************************************************************************/
 
27
 
 
28
 
 
29
/**
 
30
 * @file
 
31
 * Blend LLVM IR generation -- SoA layout.
 
32
 *
 
33
 * Blending in SoA is much faster than AoS, especially when separate rgb/alpha
 
34
 * factors/functions are used, since no channel masking/shuffling is necessary
 
35
 * and we can achieve the full throughput of the SIMD operations. Furthermore
 
36
 * the fragment shader output is also in SoA, so it fits nicely with the rest
 
37
 * of the fragment pipeline.
 
38
 *
 
39
 * The drawback is that to be displayed the color buffer needs to be in AoS
 
40
 * layout, so we need to tile/untile the color buffer before/after rendering.
 
41
 * A color buffer like
 
42
 *
 
43
 *  R11 G11 B11 A11 R12 G12 B12 A12  R13 G13 B13 A13 R14 G14 B14 A14  ...
 
44
 *  R21 G21 B21 A21 R22 G22 B22 A22  R23 G23 B23 A23 R24 G24 B24 A24  ...
 
45
 *
 
46
 *  R31 G31 B31 A31 R32 G32 B32 A32  R33 G33 B33 A33 R34 G34 B34 A34  ...
 
47
 *  R41 G41 B41 A41 R42 G42 B42 A42  R43 G43 B43 A43 R44 G44 B44 A44  ...
 
48
 *
 
49
 *  ... ... ... ... ... ... ... ...  ... ... ... ... ... ... ... ...  ...
 
50
 *
 
51
 * will actually be stored in memory as
 
52
 *
 
53
 *  R11 R12 R21 R22 R13 R14 R23 R24 ... G11 G12 G21 G22 G13 G14 G23 G24 ... B11 B12 B21 B22 B13 B14 B23 B24 ... A11 A12 A21 A22 A13 A14 A23 A24 ...
 
54
 *  R31 R32 R41 R42 R33 R34 R43 R44 ... G31 G32 G41 G42 G33 G34 G43 G44 ... B31 B32 B41 B42 B33 B34 B43 B44 ... A31 A32 A41 A42 A33 A34 A43 A44 ...
 
55
 *  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
 
56
 *
 
57
 * NOTE: Run lp_blend_test after any change to this file.
 
58
 *
 
59
 * You can also run lp_blend_test to obtain AoS vs SoA benchmarks. Invoking it
 
60
 * as:
 
61
 *
 
62
 *  lp_blend_test -o blend.tsv
 
63
 *
 
64
 * will generate a tab-seperated-file with the test results and performance
 
65
 * measurements.
 
66
 *
 
67
 * @author Jose Fonseca <jfonseca@vmware.com>
 
68
 */
 
69
 
 
70
 
 
71
#include "pipe/p_state.h"
 
72
#include "util/u_debug.h"
 
73
 
 
74
#include "gallivm/lp_bld_type.h"
 
75
#include "gallivm/lp_bld_arit.h"
 
76
#include "lp_bld_blend.h"
 
77
 
 
78
 
 
79
/**
 
80
 * We may use the same values several times, so we keep them here to avoid
 
81
 * recomputing them. Also reusing the values allows us to do simplifications
 
82
 * that LLVM optimization passes wouldn't normally be able to do.
 
83
 */
 
84
struct lp_build_blend_soa_context
 
85
{
 
86
   struct lp_build_context base;
 
87
 
 
88
   LLVMValueRef src[4];
 
89
   LLVMValueRef dst[4];
 
90
   LLVMValueRef con[4];
 
91
 
 
92
   LLVMValueRef inv_src[4];
 
93
   LLVMValueRef inv_dst[4];
 
94
   LLVMValueRef inv_con[4];
 
95
 
 
96
   LLVMValueRef src_alpha_saturate;
 
97
 
 
98
   /**
 
99
    * We store all factors in a table in order to eliminate redundant
 
100
    * multiplications later.
 
101
    * Indexes are: factor[src,dst][color,term][r,g,b,a]
 
102
    */
 
103
   LLVMValueRef factor[2][2][4];
 
104
 
 
105
   /**
 
106
    * Table with all terms.
 
107
    * Indexes are: term[src,dst][r,g,b,a]
 
108
    */
 
109
   LLVMValueRef term[2][4];
 
110
};
 
111
 
 
112
 
 
113
/**
 
114
 * Build a single SOA blend factor for a color channel.
 
115
 * \param i  the color channel in [0,3]
 
116
 */
 
117
static LLVMValueRef
 
118
lp_build_blend_soa_factor(struct lp_build_blend_soa_context *bld,
 
119
                          unsigned factor, unsigned i)
 
120
{
 
121
   /*
 
122
    * Compute src/first term RGB
 
123
    */
 
124
   switch (factor) {
 
125
   case PIPE_BLENDFACTOR_ONE:
 
126
      return bld->base.one;
 
127
   case PIPE_BLENDFACTOR_SRC_COLOR:
 
128
      return bld->src[i];
 
129
   case PIPE_BLENDFACTOR_SRC_ALPHA:
 
130
      return bld->src[3];
 
131
   case PIPE_BLENDFACTOR_DST_COLOR:
 
132
      return bld->dst[i];
 
133
   case PIPE_BLENDFACTOR_DST_ALPHA:
 
134
      return bld->dst[3];
 
135
   case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
 
136
      if(i == 3)
 
137
         return bld->base.one;
 
138
      else {
 
139
         if(!bld->inv_dst[3])
 
140
            bld->inv_dst[3] = lp_build_comp(&bld->base, bld->dst[3]);
 
141
         if(!bld->src_alpha_saturate)
 
142
            bld->src_alpha_saturate = lp_build_min(&bld->base, bld->src[3], bld->inv_dst[3]);
 
143
         return bld->src_alpha_saturate;
 
144
      }
 
145
   case PIPE_BLENDFACTOR_CONST_COLOR:
 
146
      return bld->con[i];
 
147
   case PIPE_BLENDFACTOR_CONST_ALPHA:
 
148
      return bld->con[3];
 
149
   case PIPE_BLENDFACTOR_SRC1_COLOR:
 
150
      /* TODO */
 
151
      assert(0);
 
152
      return bld->base.zero;
 
153
   case PIPE_BLENDFACTOR_SRC1_ALPHA:
 
154
      /* TODO */
 
155
      assert(0);
 
156
      return bld->base.zero;
 
157
   case PIPE_BLENDFACTOR_ZERO:
 
158
      return bld->base.zero;
 
159
   case PIPE_BLENDFACTOR_INV_SRC_COLOR:
 
160
      if(!bld->inv_src[i])
 
161
         bld->inv_src[i] = lp_build_comp(&bld->base, bld->src[i]);
 
162
      return bld->inv_src[i];
 
163
   case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 
164
      if(!bld->inv_src[3])
 
165
         bld->inv_src[3] = lp_build_comp(&bld->base, bld->src[3]);
 
166
      return bld->inv_src[3];
 
167
   case PIPE_BLENDFACTOR_INV_DST_COLOR:
 
168
      if(!bld->inv_dst[i])
 
169
         bld->inv_dst[i] = lp_build_comp(&bld->base, bld->dst[i]);
 
170
      return bld->inv_dst[i];
 
171
   case PIPE_BLENDFACTOR_INV_DST_ALPHA:
 
172
      if(!bld->inv_dst[3])
 
173
         bld->inv_dst[3] = lp_build_comp(&bld->base, bld->dst[3]);
 
174
      return bld->inv_dst[3];
 
175
   case PIPE_BLENDFACTOR_INV_CONST_COLOR:
 
176
      if(!bld->inv_con[i])
 
177
         bld->inv_con[i] = lp_build_comp(&bld->base, bld->con[i]);
 
178
      return bld->inv_con[i];
 
179
   case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
 
180
      if(!bld->inv_con[3])
 
181
         bld->inv_con[3] = lp_build_comp(&bld->base, bld->con[3]);
 
182
      return bld->inv_con[3];
 
183
   case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
 
184
      /* TODO */
 
185
      assert(0);
 
186
      return bld->base.zero;
 
187
   case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
 
188
      /* TODO */
 
189
      assert(0);
 
190
      return bld->base.zero;
 
191
   default:
 
192
      assert(0);
 
193
      return bld->base.zero;
 
194
   }
 
195
}
 
196
 
 
197
 
 
198
/**
 
199
 * Generate blend code in SOA mode.
 
200
 * \param rt  render target index (to index the blend / colormask state)
 
201
 * \param src  src/fragment color
 
202
 * \param dst  dst/framebuffer color
 
203
 * \param con  constant blend color
 
204
 * \param res  the result/output
 
205
 */
 
206
void
 
207
lp_build_blend_soa(LLVMBuilderRef builder,
 
208
                   const struct pipe_blend_state *blend,
 
209
                   struct lp_type type,
 
210
                   unsigned rt,
 
211
                   LLVMValueRef src[4],
 
212
                   LLVMValueRef dst[4],
 
213
                   LLVMValueRef con[4],
 
214
                   LLVMValueRef res[4])
 
215
{
 
216
   struct lp_build_blend_soa_context bld;
 
217
   unsigned i, j, k;
 
218
 
 
219
   assert(rt < PIPE_MAX_COLOR_BUFS);
 
220
 
 
221
   /* Setup build context */
 
222
   memset(&bld, 0, sizeof bld);
 
223
   lp_build_context_init(&bld.base, builder, type);
 
224
   for (i = 0; i < 4; ++i) {
 
225
      bld.src[i] = src[i];
 
226
      bld.dst[i] = dst[i];
 
227
      bld.con[i] = con[i];
 
228
   }
 
229
 
 
230
   for (i = 0; i < 4; ++i) {
 
231
      /* only compute blending for the color channels enabled for writing */
 
232
      if (blend->rt[rt].colormask & (1 << i)) {
 
233
         if (blend->logicop_enable) {
 
234
            if(!type.floating) {
 
235
               res[i] = lp_build_logicop(builder, blend->logicop_func, src[i], dst[i]);
 
236
            }
 
237
            else
 
238
               res[i] = dst[i];
 
239
         }
 
240
         else if (blend->rt[rt].blend_enable) {
 
241
            unsigned src_factor = i < 3 ? blend->rt[rt].rgb_src_factor : blend->rt[rt].alpha_src_factor;
 
242
            unsigned dst_factor = i < 3 ? blend->rt[rt].rgb_dst_factor : blend->rt[rt].alpha_dst_factor;
 
243
            unsigned func = i < 3 ? blend->rt[rt].rgb_func : blend->rt[rt].alpha_func;
 
244
            boolean func_commutative = lp_build_blend_func_commutative(func);
 
245
 
 
246
            /* It makes no sense to blend unless values are normalized */
 
247
            assert(type.norm);
 
248
 
 
249
            /*
 
250
             * Compute src/dst factors.
 
251
             */
 
252
 
 
253
            bld.factor[0][0][i] = src[i];
 
254
            bld.factor[0][1][i] = lp_build_blend_soa_factor(&bld, src_factor, i);
 
255
            bld.factor[1][0][i] = dst[i];
 
256
            bld.factor[1][1][i] = lp_build_blend_soa_factor(&bld, dst_factor, i);
 
257
 
 
258
            /*
 
259
             * Compute src/dst terms
 
260
             */
 
261
 
 
262
            for(k = 0; k < 2; ++k) {
 
263
               /* See if this multiplication has been previously computed */
 
264
               for(j = 0; j < i; ++j) {
 
265
                  if((bld.factor[k][0][j] == bld.factor[k][0][i] &&
 
266
                      bld.factor[k][1][j] == bld.factor[k][1][i]) ||
 
267
                     (bld.factor[k][0][j] == bld.factor[k][1][i] &&
 
268
                      bld.factor[k][1][j] == bld.factor[k][0][i]))
 
269
                     break;
 
270
               }
 
271
 
 
272
               if(j < i)
 
273
                  bld.term[k][i] = bld.term[k][j];
 
274
               else
 
275
                  bld.term[k][i] = lp_build_mul(&bld.base, bld.factor[k][0][i], bld.factor[k][1][i]);
 
276
 
 
277
               if (src_factor == PIPE_BLENDFACTOR_ZERO &&
 
278
                   (dst_factor == PIPE_BLENDFACTOR_DST_ALPHA ||
 
279
                    dst_factor == PIPE_BLENDFACTOR_INV_DST_ALPHA)) {
 
280
                  /* XXX special case these combos to work around an apparent
 
281
                   * bug in LLVM.
 
282
                   * This hack disables the check for multiplication by zero
 
283
                   * in lp_bld_mul().  When we optimize away the
 
284
                   * multiplication, something goes wrong during code
 
285
                   * generation and we segfault at runtime.
 
286
                   */
 
287
                  LLVMValueRef zeroSave = bld.base.zero;
 
288
                  bld.base.zero = NULL;
 
289
                  bld.term[k][i] = lp_build_mul(&bld.base, bld.factor[k][0][i],
 
290
                                                bld.factor[k][1][i]);
 
291
                  bld.base.zero = zeroSave;
 
292
               }
 
293
            }
 
294
 
 
295
            /*
 
296
             * Combine terms
 
297
             */
 
298
 
 
299
            /* See if this function has been previously applied */
 
300
            for(j = 0; j < i; ++j) {
 
301
               unsigned prev_func = j < 3 ? blend->rt[rt].rgb_func : blend->rt[rt].alpha_func;
 
302
               unsigned func_reverse = lp_build_blend_func_reverse(func, prev_func);
 
303
 
 
304
               if((!func_reverse &&
 
305
                   bld.term[0][j] == bld.term[0][i] &&
 
306
                   bld.term[1][j] == bld.term[1][i]) ||
 
307
                  ((func_commutative || func_reverse) &&
 
308
                   bld.term[0][j] == bld.term[1][i] &&
 
309
                   bld.term[1][j] == bld.term[0][i]))
 
310
                  break;
 
311
            }
 
312
 
 
313
            if(j < i)
 
314
               res[i] = res[j];
 
315
            else
 
316
               res[i] = lp_build_blend_func(&bld.base, func, bld.term[0][i], bld.term[1][i]);
 
317
         }
 
318
         else {
 
319
            res[i] = src[i];
 
320
         }
 
321
      }
 
322
      else {
 
323
         res[i] = dst[i];
 
324
      }
 
325
   }
 
326
}