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 -- AoS layout.
32 *
33 * AoS blending is in general much slower than SoA, but there are some cases
34 * where it might be faster. In particular, if a pixel is rendered only once
35 * then the overhead of tiling and untiling will dominate over the speedup that
36 * SoA gives. So we might want to detect such cases and fallback to AoS in the
37 * future, but for now this function is here for historical/benchmarking
38 * purposes.
39 *
40 * Run lp_blend_test after any change to this file.
41 *
42 * @author Jose Fonseca <jfonseca@vmware.com>
43 */
44
45
46 #include "pipe/p_state.h"
47 #include "util/u_debug.h"
48 #include "util/format/u_format.h"
49
50 #include "gallivm/lp_bld_type.h"
51 #include "gallivm/lp_bld_const.h"
52 #include "gallivm/lp_bld_arit.h"
53 #include "gallivm/lp_bld_logic.h"
54 #include "gallivm/lp_bld_swizzle.h"
55 #include "gallivm/lp_bld_bitarit.h"
56 #include "gallivm/lp_bld_debug.h"
57
58 #include "lp_bld_blend.h"
59
60
61 /**
62 * We may the same values several times, so we keep them here to avoid
63 * recomputing them. Also reusing the values allows us to do simplifications
64 * that LLVM optimization passes wouldn't normally be able to do.
65 */
66 struct lp_build_blend_aos_context
67 {
68 struct lp_build_context base;
69
70 LLVMValueRef src;
71 LLVMValueRef src_alpha;
72 LLVMValueRef src1;
73 LLVMValueRef src1_alpha;
74 LLVMValueRef dst;
75 LLVMValueRef const_;
76 LLVMValueRef const_alpha;
77 boolean has_dst_alpha;
78
79 LLVMValueRef inv_src;
80 LLVMValueRef inv_src_alpha;
81 LLVMValueRef inv_dst;
82 LLVMValueRef inv_const;
83 LLVMValueRef inv_const_alpha;
84 LLVMValueRef saturate;
85
86 LLVMValueRef rgb_src_factor;
87 LLVMValueRef alpha_src_factor;
88 LLVMValueRef rgb_dst_factor;
89 LLVMValueRef alpha_dst_factor;
90 };
91
92
93 static LLVMValueRef
lp_build_blend_factor_unswizzled(struct lp_build_blend_aos_context * bld,unsigned factor,boolean alpha)94 lp_build_blend_factor_unswizzled(struct lp_build_blend_aos_context *bld,
95 unsigned factor,
96 boolean alpha)
97 {
98 LLVMValueRef src_alpha = bld->src_alpha ? bld->src_alpha : bld->src;
99 LLVMValueRef src1_alpha = bld->src1_alpha ? bld->src1_alpha : bld->src1;
100 LLVMValueRef const_alpha = bld->const_alpha ? bld->const_alpha : bld->const_;
101
102 switch (factor) {
103 case PIPE_BLENDFACTOR_ZERO:
104 return bld->base.zero;
105 case PIPE_BLENDFACTOR_ONE:
106 return bld->base.one;
107 case PIPE_BLENDFACTOR_SRC_COLOR:
108 return bld->src;
109 case PIPE_BLENDFACTOR_SRC_ALPHA:
110 return src_alpha;
111 case PIPE_BLENDFACTOR_DST_COLOR:
112 case PIPE_BLENDFACTOR_DST_ALPHA:
113 return bld->dst;
114 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
115 if (alpha)
116 return bld->base.one;
117 else {
118 /*
119 * If there's no dst alpha the complement is zero but for unclamped
120 * float inputs (or snorm inputs) min can be non-zero (negative).
121 */
122 if (!bld->saturate) {
123 if (!bld->has_dst_alpha) {
124 bld->saturate = lp_build_min(&bld->base, src_alpha, bld->base.zero);
125 }
126 else if (bld->base.type.norm && bld->base.type.sign) {
127 /*
128 * The complement/min totally doesn't work, since
129 * the complement is in range [0,2] but the other
130 * min input is [-1,1]. However, we can just clamp to 0
131 * before doing the complement...
132 */
133 LLVMValueRef inv_dst;
134 inv_dst = lp_build_max(&bld->base, bld->base.zero, bld->dst);
135 inv_dst = lp_build_comp(&bld->base, inv_dst);
136 bld->saturate = lp_build_min(&bld->base, src_alpha, inv_dst);
137 } else {
138 if (!bld->inv_dst) {
139 bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
140 }
141 bld->saturate = lp_build_min(&bld->base, src_alpha, bld->inv_dst);
142 }
143 }
144 return bld->saturate;
145 }
146 case PIPE_BLENDFACTOR_CONST_COLOR:
147 return bld->const_;
148 case PIPE_BLENDFACTOR_CONST_ALPHA:
149 return const_alpha;
150 case PIPE_BLENDFACTOR_SRC1_COLOR:
151 return bld->src1;
152 case PIPE_BLENDFACTOR_SRC1_ALPHA:
153 return src1_alpha;
154 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
155 if (!bld->inv_src)
156 bld->inv_src = lp_build_comp(&bld->base, bld->src);
157 return bld->inv_src;
158 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
159 if (!bld->inv_src_alpha)
160 bld->inv_src_alpha = lp_build_comp(&bld->base, src_alpha);
161 return bld->inv_src_alpha;
162 case PIPE_BLENDFACTOR_INV_DST_COLOR:
163 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
164 if (!bld->inv_dst)
165 bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
166 return bld->inv_dst;
167 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
168 if (!bld->inv_const)
169 bld->inv_const = lp_build_comp(&bld->base, bld->const_);
170 return bld->inv_const;
171 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
172 if (!bld->inv_const_alpha)
173 bld->inv_const_alpha = lp_build_comp(&bld->base, const_alpha);
174 return bld->inv_const_alpha;
175 case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
176 return lp_build_comp(&bld->base, bld->src1);
177 case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
178 return lp_build_comp(&bld->base, src1_alpha);
179 default:
180 assert(0);
181 return bld->base.zero;
182 }
183 }
184
185
186 enum lp_build_blend_swizzle {
187 LP_BUILD_BLEND_SWIZZLE_RGBA = 0,
188 LP_BUILD_BLEND_SWIZZLE_AAAA = 1
189 };
190
191
192 /**
193 * How should we shuffle the base factor.
194 */
195 static enum lp_build_blend_swizzle
lp_build_blend_factor_swizzle(unsigned factor)196 lp_build_blend_factor_swizzle(unsigned factor)
197 {
198 switch (factor) {
199 case PIPE_BLENDFACTOR_ONE:
200 case PIPE_BLENDFACTOR_ZERO:
201 case PIPE_BLENDFACTOR_SRC_COLOR:
202 case PIPE_BLENDFACTOR_DST_COLOR:
203 case PIPE_BLENDFACTOR_CONST_COLOR:
204 case PIPE_BLENDFACTOR_SRC1_COLOR:
205 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
206 case PIPE_BLENDFACTOR_INV_DST_COLOR:
207 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
208 case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
209 return LP_BUILD_BLEND_SWIZZLE_RGBA;
210 case PIPE_BLENDFACTOR_SRC_ALPHA:
211 case PIPE_BLENDFACTOR_DST_ALPHA:
212 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
213 case PIPE_BLENDFACTOR_SRC1_ALPHA:
214 case PIPE_BLENDFACTOR_CONST_ALPHA:
215 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
216 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
217 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
218 case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
219 return LP_BUILD_BLEND_SWIZZLE_AAAA;
220 default:
221 assert(0);
222 return LP_BUILD_BLEND_SWIZZLE_RGBA;
223 }
224 }
225
226
227 static LLVMValueRef
lp_build_blend_swizzle(struct lp_build_blend_aos_context * bld,LLVMValueRef rgb,LLVMValueRef alpha,enum lp_build_blend_swizzle rgb_swizzle,unsigned alpha_swizzle,unsigned num_channels)228 lp_build_blend_swizzle(struct lp_build_blend_aos_context *bld,
229 LLVMValueRef rgb,
230 LLVMValueRef alpha,
231 enum lp_build_blend_swizzle rgb_swizzle,
232 unsigned alpha_swizzle,
233 unsigned num_channels)
234 {
235 LLVMValueRef swizzled_rgb;
236
237 switch (rgb_swizzle) {
238 case LP_BUILD_BLEND_SWIZZLE_RGBA:
239 swizzled_rgb = rgb;
240 break;
241 case LP_BUILD_BLEND_SWIZZLE_AAAA:
242 swizzled_rgb = lp_build_swizzle_scalar_aos(&bld->base, rgb, alpha_swizzle, num_channels);
243 break;
244 default:
245 assert(0);
246 swizzled_rgb = bld->base.undef;
247 }
248
249 if (rgb != alpha) {
250 swizzled_rgb = lp_build_select_aos(&bld->base, 1 << alpha_swizzle,
251 alpha, swizzled_rgb,
252 num_channels);
253 }
254
255 return swizzled_rgb;
256 }
257
258 /**
259 * @sa http://www.opengl.org/sdk/docs/man/xhtml/glBlendFuncSeparate.xml
260 */
261 static LLVMValueRef
lp_build_blend_factor(struct lp_build_blend_aos_context * bld,unsigned rgb_factor,unsigned alpha_factor,unsigned alpha_swizzle,unsigned num_channels)262 lp_build_blend_factor(struct lp_build_blend_aos_context *bld,
263 unsigned rgb_factor,
264 unsigned alpha_factor,
265 unsigned alpha_swizzle,
266 unsigned num_channels)
267 {
268 LLVMValueRef rgb_factor_, alpha_factor_;
269 enum lp_build_blend_swizzle rgb_swizzle;
270
271 if (alpha_swizzle == PIPE_SWIZZLE_X && num_channels == 1) {
272 return lp_build_blend_factor_unswizzled(bld, alpha_factor, TRUE);
273 }
274
275 rgb_factor_ = lp_build_blend_factor_unswizzled(bld, rgb_factor, FALSE);
276
277 if (alpha_swizzle != PIPE_SWIZZLE_NONE) {
278 rgb_swizzle = lp_build_blend_factor_swizzle(rgb_factor);
279 alpha_factor_ = lp_build_blend_factor_unswizzled(bld, alpha_factor, TRUE);
280 return lp_build_blend_swizzle(bld, rgb_factor_, alpha_factor_, rgb_swizzle,
281 alpha_swizzle, num_channels);
282 } else {
283 return rgb_factor_;
284 }
285 }
286
287
288 /**
289 * Performs blending of src and dst pixels
290 *
291 * @param blend the blend state of the shader variant
292 * @param cbuf_format format of the colour buffer
293 * @param type data type of the pixel vector
294 * @param rt render target index
295 * @param src blend src
296 * @param src_alpha blend src alpha (if not included in src)
297 * @param src1 second blend src (for dual source blend)
298 * @param src1_alpha second blend src alpha (if not included in src1)
299 * @param dst blend dst
300 * @param mask optional mask to apply to the blending result
301 * @param const_ const blend color
302 * @param const_alpha const blend color alpha (if not included in const_)
303 * @param swizzle swizzle values for RGBA
304 *
305 * @return the result of blending src and dst
306 */
307 LLVMValueRef
lp_build_blend_aos(struct gallivm_state * gallivm,const struct pipe_blend_state * blend,enum pipe_format cbuf_format,struct lp_type type,unsigned rt,LLVMValueRef src,LLVMValueRef src_alpha,LLVMValueRef src1,LLVMValueRef src1_alpha,LLVMValueRef dst,LLVMValueRef mask,LLVMValueRef const_,LLVMValueRef const_alpha,const unsigned char swizzle[4],int nr_channels)308 lp_build_blend_aos(struct gallivm_state *gallivm,
309 const struct pipe_blend_state *blend,
310 enum pipe_format cbuf_format,
311 struct lp_type type,
312 unsigned rt,
313 LLVMValueRef src,
314 LLVMValueRef src_alpha,
315 LLVMValueRef src1,
316 LLVMValueRef src1_alpha,
317 LLVMValueRef dst,
318 LLVMValueRef mask,
319 LLVMValueRef const_,
320 LLVMValueRef const_alpha,
321 const unsigned char swizzle[4],
322 int nr_channels)
323 {
324 const struct pipe_rt_blend_state * state = &blend->rt[rt];
325 const struct util_format_description * desc;
326 struct lp_build_blend_aos_context bld;
327 LLVMValueRef src_factor, dst_factor;
328 LLVMValueRef result;
329 unsigned alpha_swizzle = PIPE_SWIZZLE_NONE;
330 unsigned i;
331
332 desc = util_format_description(cbuf_format);
333
334 /* Setup build context */
335 memset(&bld, 0, sizeof bld);
336 lp_build_context_init(&bld.base, gallivm, type);
337 bld.src = src;
338 bld.src1 = src1;
339 bld.dst = dst;
340 bld.const_ = const_;
341 bld.src_alpha = src_alpha;
342 bld.src1_alpha = src1_alpha;
343 bld.const_alpha = const_alpha;
344 bld.has_dst_alpha = FALSE;
345
346 /* Find the alpha channel if not provided separately */
347 if (!src_alpha) {
348 for (i = 0; i < 4; ++i) {
349 if (swizzle[i] == 3) {
350 alpha_swizzle = i;
351 }
352 }
353 /*
354 * Note that we may get src_alpha included from source (and 4 channels)
355 * even if the destination doesn't have an alpha channel (for rgbx
356 * formats). Generally this shouldn't make much of a difference (we're
357 * relying on blend factors being sanitized already if there's no
358 * dst alpha).
359 */
360 bld.has_dst_alpha = desc->swizzle[3] <= PIPE_SWIZZLE_W;
361 }
362
363 if (blend->logicop_enable) {
364 if (!type.floating) {
365 result = lp_build_logicop(gallivm->builder, blend->logicop_func, src, dst);
366 }
367 else {
368 result = src;
369 }
370 } else if (!state->blend_enable) {
371 result = src;
372 } else {
373 boolean rgb_alpha_same = (state->rgb_src_factor == state->rgb_dst_factor &&
374 state->alpha_src_factor == state->alpha_dst_factor) ||
375 nr_channels == 1;
376 boolean alpha_only = nr_channels == 1 && alpha_swizzle == PIPE_SWIZZLE_X;
377
378 src_factor = lp_build_blend_factor(&bld, state->rgb_src_factor,
379 state->alpha_src_factor,
380 alpha_swizzle,
381 nr_channels);
382
383 dst_factor = lp_build_blend_factor(&bld, state->rgb_dst_factor,
384 state->alpha_dst_factor,
385 alpha_swizzle,
386 nr_channels);
387
388 result = lp_build_blend(&bld.base,
389 state->rgb_func,
390 alpha_only ? state->alpha_src_factor : state->rgb_src_factor,
391 alpha_only ? state->alpha_dst_factor : state->rgb_dst_factor,
392 src,
393 dst,
394 src_factor,
395 dst_factor,
396 rgb_alpha_same,
397 false);
398
399 if (state->rgb_func != state->alpha_func && nr_channels > 1 &&
400 alpha_swizzle != PIPE_SWIZZLE_NONE) {
401 LLVMValueRef alpha;
402
403 alpha = lp_build_blend(&bld.base,
404 state->alpha_func,
405 state->alpha_src_factor,
406 state->alpha_dst_factor,
407 src,
408 dst,
409 src_factor,
410 dst_factor,
411 rgb_alpha_same,
412 false);
413
414 result = lp_build_blend_swizzle(&bld,
415 result,
416 alpha,
417 LP_BUILD_BLEND_SWIZZLE_RGBA,
418 alpha_swizzle,
419 nr_channels);
420 }
421 }
422
423 /* Check if color mask is necessary */
424 if (!util_format_colormask_full(desc, state->colormask)) {
425 LLVMValueRef color_mask;
426
427 color_mask = lp_build_const_mask_aos_swizzled(gallivm, bld.base.type,
428 state->colormask, nr_channels, swizzle);
429 lp_build_name(color_mask, "color_mask");
430
431 /* Combine with input mask if necessary */
432 if (mask) {
433 /* We can be blending floating values but masks are always integer... */
434 unsigned floating = bld.base.type.floating;
435 bld.base.type.floating = 0;
436
437 mask = lp_build_and(&bld.base, color_mask, mask);
438
439 bld.base.type.floating = floating;
440 } else {
441 mask = color_mask;
442 }
443 }
444
445 /* Apply mask, if one exists */
446 if (mask) {
447 result = lp_build_select(&bld.base, mask, result, dst);
448 }
449
450 return result;
451 }
452