projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge remote branch 'vdpau/pipe-video' into pipe-video
[mesa.git] / src / gallium / drivers / softpipe / sp_quad_blend.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
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 TUNGSTEN GRAPHICS 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 * quad blending
30 * \author Brian Paul
31 */
32
33 #include "pipe/p_defines.h"
34 #include "util/u_math.h"
35 #include "util/u_memory.h"
36 #include "util/u_format.h"
37 #include "sp_context.h"
38 #include "sp_state.h"
39 #include "sp_quad.h"
40 #include "sp_tile_cache.h"
41 #include "sp_quad_pipe.h"
42
43
44 #define VEC4_COPY(DST, SRC) \
45 do { \
46 DST[0] = SRC[0]; \
47 DST[1] = SRC[1]; \
48 DST[2] = SRC[2]; \
49 DST[3] = SRC[3]; \
50 } while(0)
51
52 #define VEC4_SCALAR(DST, SRC) \
53 do { \
54 DST[0] = SRC; \
55 DST[1] = SRC; \
56 DST[2] = SRC; \
57 DST[3] = SRC; \
58 } while(0)
59
60 #define VEC4_ADD(R, A, B) \
61 do { \
62 R[0] = A[0] + B[0]; \
63 R[1] = A[1] + B[1]; \
64 R[2] = A[2] + B[2]; \
65 R[3] = A[3] + B[3]; \
66 } while (0)
67
68 #define VEC4_SUB(R, A, B) \
69 do { \
70 R[0] = A[0] - B[0]; \
71 R[1] = A[1] - B[1]; \
72 R[2] = A[2] - B[2]; \
73 R[3] = A[3] - B[3]; \
74 } while (0)
75
76 /** Add and limit result to ceiling of 1.0 */
77 #define VEC4_ADD_SAT(R, A, B) \
78 do { \
79 R[0] = A[0] + B[0]; if (R[0] > 1.0f) R[0] = 1.0f; \
80 R[1] = A[1] + B[1]; if (R[1] > 1.0f) R[1] = 1.0f; \
81 R[2] = A[2] + B[2]; if (R[2] > 1.0f) R[2] = 1.0f; \
82 R[3] = A[3] + B[3]; if (R[3] > 1.0f) R[3] = 1.0f; \
83 } while (0)
84
85 /** Subtract and limit result to floor of 0.0 */
86 #define VEC4_SUB_SAT(R, A, B) \
87 do { \
88 R[0] = A[0] - B[0]; if (R[0] < 0.0f) R[0] = 0.0f; \
89 R[1] = A[1] - B[1]; if (R[1] < 0.0f) R[1] = 0.0f; \
90 R[2] = A[2] - B[2]; if (R[2] < 0.0f) R[2] = 0.0f; \
91 R[3] = A[3] - B[3]; if (R[3] < 0.0f) R[3] = 0.0f; \
92 } while (0)
93
94 #define VEC4_MUL(R, A, B) \
95 do { \
96 R[0] = A[0] * B[0]; \
97 R[1] = A[1] * B[1]; \
98 R[2] = A[2] * B[2]; \
99 R[3] = A[3] * B[3]; \
100 } while (0)
101
102 #define VEC4_MIN(R, A, B) \
103 do { \
104 R[0] = (A[0] < B[0]) ? A[0] : B[0]; \
105 R[1] = (A[1] < B[1]) ? A[1] : B[1]; \
106 R[2] = (A[2] < B[2]) ? A[2] : B[2]; \
107 R[3] = (A[3] < B[3]) ? A[3] : B[3]; \
108 } while (0)
109
110 #define VEC4_MAX(R, A, B) \
111 do { \
112 R[0] = (A[0] > B[0]) ? A[0] : B[0]; \
113 R[1] = (A[1] > B[1]) ? A[1] : B[1]; \
114 R[2] = (A[2] > B[2]) ? A[2] : B[2]; \
115 R[3] = (A[3] > B[3]) ? A[3] : B[3]; \
116 } while (0)
117
118
119
120 static void
121 logicop_quad(struct quad_stage *qs,
122 float (*quadColor)[4],
123 float (*dest)[4])
124 {
125 struct softpipe_context *softpipe = qs->softpipe;
126 ubyte src[4][4], dst[4][4], res[4][4];
127 uint *src4 = (uint *) src;
128 uint *dst4 = (uint *) dst;
129 uint *res4 = (uint *) res;
130 uint j;
131
132
133 /* convert to ubyte */
134 for (j = 0; j < 4; j++) { /* loop over R,G,B,A channels */
135 dst[j][0] = float_to_ubyte(dest[j][0]); /* P0 */
136 dst[j][1] = float_to_ubyte(dest[j][1]); /* P1 */
137 dst[j][2] = float_to_ubyte(dest[j][2]); /* P2 */
138 dst[j][3] = float_to_ubyte(dest[j][3]); /* P3 */
139
140 src[j][0] = float_to_ubyte(quadColor[j][0]); /* P0 */
141 src[j][1] = float_to_ubyte(quadColor[j][1]); /* P1 */
142 src[j][2] = float_to_ubyte(quadColor[j][2]); /* P2 */
143 src[j][3] = float_to_ubyte(quadColor[j][3]); /* P3 */
144 }
145
146 switch (softpipe->blend->logicop_func) {
147 case PIPE_LOGICOP_CLEAR:
148 for (j = 0; j < 4; j++)
149 res4[j] = 0;
150 break;
151 case PIPE_LOGICOP_NOR:
152 for (j = 0; j < 4; j++)
153 res4[j] = ~(src4[j] | dst4[j]);
154 break;
155 case PIPE_LOGICOP_AND_INVERTED:
156 for (j = 0; j < 4; j++)
157 res4[j] = ~src4[j] & dst4[j];
158 break;
159 case PIPE_LOGICOP_COPY_INVERTED:
160 for (j = 0; j < 4; j++)
161 res4[j] = ~src4[j];
162 break;
163 case PIPE_LOGICOP_AND_REVERSE:
164 for (j = 0; j < 4; j++)
165 res4[j] = src4[j] & ~dst4[j];
166 break;
167 case PIPE_LOGICOP_INVERT:
168 for (j = 0; j < 4; j++)
169 res4[j] = ~dst4[j];
170 break;
171 case PIPE_LOGICOP_XOR:
172 for (j = 0; j < 4; j++)
173 res4[j] = dst4[j] ^ src4[j];
174 break;
175 case PIPE_LOGICOP_NAND:
176 for (j = 0; j < 4; j++)
177 res4[j] = ~(src4[j] & dst4[j]);
178 break;
179 case PIPE_LOGICOP_AND:
180 for (j = 0; j < 4; j++)
181 res4[j] = src4[j] & dst4[j];
182 break;
183 case PIPE_LOGICOP_EQUIV:
184 for (j = 0; j < 4; j++)
185 res4[j] = ~(src4[j] ^ dst4[j]);
186 break;
187 case PIPE_LOGICOP_NOOP:
188 for (j = 0; j < 4; j++)
189 res4[j] = dst4[j];
190 break;
191 case PIPE_LOGICOP_OR_INVERTED:
192 for (j = 0; j < 4; j++)
193 res4[j] = ~src4[j] | dst4[j];
194 break;
195 case PIPE_LOGICOP_COPY:
196 for (j = 0; j < 4; j++)
197 res4[j] = src4[j];
198 break;
199 case PIPE_LOGICOP_OR_REVERSE:
200 for (j = 0; j < 4; j++)
201 res4[j] = src4[j] | ~dst4[j];
202 break;
203 case PIPE_LOGICOP_OR:
204 for (j = 0; j < 4; j++)
205 res4[j] = src4[j] | dst4[j];
206 break;
207 case PIPE_LOGICOP_SET:
208 for (j = 0; j < 4; j++)
209 res4[j] = ~0;
210 break;
211 default:
212 assert(0 && "invalid logicop mode");
213 }
214
215 for (j = 0; j < 4; j++) {
216 quadColor[j][0] = ubyte_to_float(res[j][0]);
217 quadColor[j][1] = ubyte_to_float(res[j][1]);
218 quadColor[j][2] = ubyte_to_float(res[j][2]);
219 quadColor[j][3] = ubyte_to_float(res[j][3]);
220 }
221 }
222
223
224
225 /**
226 * Do blending for a 2x2 quad for one color buffer.
227 * \param quadColor the incoming quad colors
228 * \param dest the destination/framebuffer quad colors
229 * \param blend_index which set of blending terms to use
230 * \param has_dst_alpha does the dest color buffer have an alpha channel?
231 */
232 static void
233 blend_quad(struct quad_stage *qs,
234 float (*quadColor)[4],
235 float (*dest)[4],
236 unsigned blend_index,
237 boolean has_dst_alpha)
238 {
239 static const float zero[4] = { 0, 0, 0, 0 };
240 static const float one[4] = { 1, 1, 1, 1 };
241 struct softpipe_context *softpipe = qs->softpipe;
242 float source[4][QUAD_SIZE] = { { 0 } };
243
244 /*
245 * Compute src/first term RGB
246 */
247 switch (softpipe->blend->rt[blend_index].rgb_src_factor) {
248 case PIPE_BLENDFACTOR_ONE:
249 VEC4_COPY(source[0], quadColor[0]); /* R */
250 VEC4_COPY(source[1], quadColor[1]); /* G */
251 VEC4_COPY(source[2], quadColor[2]); /* B */
252 break;
253 case PIPE_BLENDFACTOR_SRC_COLOR:
254 VEC4_MUL(source[0], quadColor[0], quadColor[0]); /* R */
255 VEC4_MUL(source[1], quadColor[1], quadColor[1]); /* G */
256 VEC4_MUL(source[2], quadColor[2], quadColor[2]); /* B */
257 break;
258 case PIPE_BLENDFACTOR_SRC_ALPHA:
259 {
260 const float *alpha = quadColor[3];
261 VEC4_MUL(source[0], quadColor[0], alpha); /* R */
262 VEC4_MUL(source[1], quadColor[1], alpha); /* G */
263 VEC4_MUL(source[2], quadColor[2], alpha); /* B */
264 }
265 break;
266 case PIPE_BLENDFACTOR_DST_COLOR:
267 VEC4_MUL(source[0], quadColor[0], dest[0]); /* R */
268 VEC4_MUL(source[1], quadColor[1], dest[1]); /* G */
269 VEC4_MUL(source[2], quadColor[2], dest[2]); /* B */
270 break;
271 case PIPE_BLENDFACTOR_DST_ALPHA:
272 if (has_dst_alpha) {
273 const float *alpha = dest[3];
274 VEC4_MUL(source[0], quadColor[0], alpha); /* R */
275 VEC4_MUL(source[1], quadColor[1], alpha); /* G */
276 VEC4_MUL(source[2], quadColor[2], alpha); /* B */
277 }
278 else {
279 VEC4_COPY(source[0], quadColor[0]); /* R */
280 VEC4_COPY(source[1], quadColor[1]); /* G */
281 VEC4_COPY(source[2], quadColor[2]); /* B */
282 }
283 break;
284 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
285 if (has_dst_alpha) {
286 const float *alpha = quadColor[3];
287 float diff[4], temp[4];
288 VEC4_SUB(diff, one, dest[3]);
289 VEC4_MIN(temp, alpha, diff);
290 VEC4_MUL(source[0], quadColor[0], temp); /* R */
291 VEC4_MUL(source[1], quadColor[1], temp); /* G */
292 VEC4_MUL(source[2], quadColor[2], temp); /* B */
293 }
294 else {
295 VEC4_COPY(source[0], zero); /* R */
296 VEC4_COPY(source[1], zero); /* G */
297 VEC4_COPY(source[2], zero); /* B */
298 }
299 break;
300 case PIPE_BLENDFACTOR_CONST_COLOR:
301 {
302 float comp[4];
303 VEC4_SCALAR(comp, softpipe->blend_color.color[0]); /* R */
304 VEC4_MUL(source[0], quadColor[0], comp); /* R */
305 VEC4_SCALAR(comp, softpipe->blend_color.color[1]); /* G */
306 VEC4_MUL(source[1], quadColor[1], comp); /* G */
307 VEC4_SCALAR(comp, softpipe->blend_color.color[2]); /* B */
308 VEC4_MUL(source[2], quadColor[2], comp); /* B */
309 }
310 break;
311 case PIPE_BLENDFACTOR_CONST_ALPHA:
312 {
313 float alpha[4];
314 VEC4_SCALAR(alpha, softpipe->blend_color.color[3]);
315 VEC4_MUL(source[0], quadColor[0], alpha); /* R */
316 VEC4_MUL(source[1], quadColor[1], alpha); /* G */
317 VEC4_MUL(source[2], quadColor[2], alpha); /* B */
318 }
319 break;
320 case PIPE_BLENDFACTOR_SRC1_COLOR:
321 assert(0); /* to do */
322 break;
323 case PIPE_BLENDFACTOR_SRC1_ALPHA:
324 assert(0); /* to do */
325 break;
326 case PIPE_BLENDFACTOR_ZERO:
327 VEC4_COPY(source[0], zero); /* R */
328 VEC4_COPY(source[1], zero); /* G */
329 VEC4_COPY(source[2], zero); /* B */
330 break;
331 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
332 {
333 float inv_comp[4];
334 VEC4_SUB(inv_comp, one, quadColor[0]); /* R */
335 VEC4_MUL(source[0], quadColor[0], inv_comp); /* R */
336 VEC4_SUB(inv_comp, one, quadColor[1]); /* G */
337 VEC4_MUL(source[1], quadColor[1], inv_comp); /* G */
338 VEC4_SUB(inv_comp, one, quadColor[2]); /* B */
339 VEC4_MUL(source[2], quadColor[2], inv_comp); /* B */
340 }
341 break;
342 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
343 {
344 float inv_alpha[4];
345 VEC4_SUB(inv_alpha, one, quadColor[3]);
346 VEC4_MUL(source[0], quadColor[0], inv_alpha); /* R */
347 VEC4_MUL(source[1], quadColor[1], inv_alpha); /* G */
348 VEC4_MUL(source[2], quadColor[2], inv_alpha); /* B */
349 }
350 break;
351 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
352 if (has_dst_alpha) {
353 float inv_alpha[4];
354 VEC4_SUB(inv_alpha, one, dest[3]);
355 VEC4_MUL(source[0], quadColor[0], inv_alpha); /* R */
356 VEC4_MUL(source[1], quadColor[1], inv_alpha); /* G */
357 VEC4_MUL(source[2], quadColor[2], inv_alpha); /* B */
358 }
359 else {
360 VEC4_COPY(source[0], zero); /* R */
361 VEC4_COPY(source[1], zero); /* G */
362 VEC4_COPY(source[2], zero); /* B */
363 }
364 break;
365 case PIPE_BLENDFACTOR_INV_DST_COLOR:
366 {
367 float inv_comp[4];
368 VEC4_SUB(inv_comp, one, dest[0]); /* R */
369 VEC4_MUL(source[0], quadColor[0], inv_comp); /* R */
370 VEC4_SUB(inv_comp, one, dest[1]); /* G */
371 VEC4_MUL(source[1], quadColor[1], inv_comp); /* G */
372 VEC4_SUB(inv_comp, one, dest[2]); /* B */
373 VEC4_MUL(source[2], quadColor[2], inv_comp); /* B */
374 }
375 break;
376 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
377 {
378 float inv_comp[4];
379 /* R */
380 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[0]);
381 VEC4_MUL(source[0], quadColor[0], inv_comp);
382 /* G */
383 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[1]);
384 VEC4_MUL(source[1], quadColor[1], inv_comp);
385 /* B */
386 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[2]);
387 VEC4_MUL(source[2], quadColor[2], inv_comp);
388 }
389 break;
390 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
391 {
392 float inv_alpha[4];
393 VEC4_SCALAR(inv_alpha, 1.0f - softpipe->blend_color.color[3]);
394 VEC4_MUL(source[0], quadColor[0], inv_alpha); /* R */
395 VEC4_MUL(source[1], quadColor[1], inv_alpha); /* G */
396 VEC4_MUL(source[2], quadColor[2], inv_alpha); /* B */
397 }
398 break;
399 case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
400 assert(0); /* to do */
401 break;
402 case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
403 assert(0); /* to do */
404 break;
405 default:
406 assert(0 && "invalid rgb src factor");
407 }
408
409 /*
410 * Compute src/first term A
411 */
412 switch (softpipe->blend->rt[blend_index].alpha_src_factor) {
413 case PIPE_BLENDFACTOR_ONE:
414 VEC4_COPY(source[3], quadColor[3]); /* A */
415 break;
416 case PIPE_BLENDFACTOR_SRC_COLOR:
417 /* fall-through */
418 case PIPE_BLENDFACTOR_SRC_ALPHA:
419 {
420 const float *alpha = quadColor[3];
421 VEC4_MUL(source[3], quadColor[3], alpha); /* A */
422 }
423 break;
424 case PIPE_BLENDFACTOR_DST_COLOR:
425 /* fall-through */
426 case PIPE_BLENDFACTOR_DST_ALPHA:
427 if (has_dst_alpha)
428 VEC4_MUL(source[3], quadColor[3], dest[3]); /* A */
429 else
430 VEC4_COPY(source[3], quadColor[3]); /* A */
431 break;
432 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
433 /* multiply alpha by 1.0 */
434 VEC4_COPY(source[3], quadColor[3]); /* A */
435 break;
436 case PIPE_BLENDFACTOR_CONST_COLOR:
437 /* fall-through */
438 case PIPE_BLENDFACTOR_CONST_ALPHA:
439 {
440 float comp[4];
441 VEC4_SCALAR(comp, softpipe->blend_color.color[3]); /* A */
442 VEC4_MUL(source[3], quadColor[3], comp); /* A */
443 }
444 break;
445 case PIPE_BLENDFACTOR_ZERO:
446 VEC4_COPY(source[3], zero); /* A */
447 break;
448 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
449 /* fall-through */
450 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
451 {
452 float inv_alpha[4];
453 VEC4_SUB(inv_alpha, one, quadColor[3]);
454 VEC4_MUL(source[3], quadColor[3], inv_alpha); /* A */
455 }
456 break;
457 case PIPE_BLENDFACTOR_INV_DST_COLOR:
458 /* fall-through */
459 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
460 if (has_dst_alpha) {
461 float inv_alpha[4];
462 VEC4_SUB(inv_alpha, one, dest[3]);
463 VEC4_MUL(source[3], quadColor[3], inv_alpha); /* A */
464 }
465 else {
466 VEC4_COPY(source[3], zero); /* A */
467 }
468 break;
469 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
470 /* fall-through */
471 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
472 {
473 float inv_comp[4];
474 /* A */
475 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[3]);
476 VEC4_MUL(source[3], quadColor[3], inv_comp);
477 }
478 break;
479 default:
480 assert(0 && "invalid alpha src factor");
481 }
482
483
484 /*
485 * Compute dest/second term RGB
486 */
487 switch (softpipe->blend->rt[blend_index].rgb_dst_factor) {
488 case PIPE_BLENDFACTOR_ONE:
489 /* dest = dest * 1 NO-OP, leave dest as-is */
490 break;
491 case PIPE_BLENDFACTOR_SRC_COLOR:
492 VEC4_MUL(dest[0], dest[0], quadColor[0]); /* R */
493 VEC4_MUL(dest[1], dest[1], quadColor[1]); /* G */
494 VEC4_MUL(dest[2], dest[2], quadColor[2]); /* B */
495 break;
496 case PIPE_BLENDFACTOR_SRC_ALPHA:
497 VEC4_MUL(dest[0], dest[0], quadColor[3]); /* R * A */
498 VEC4_MUL(dest[1], dest[1], quadColor[3]); /* G * A */
499 VEC4_MUL(dest[2], dest[2], quadColor[3]); /* B * A */
500 break;
501 case PIPE_BLENDFACTOR_DST_ALPHA:
502 if (has_dst_alpha) {
503 VEC4_MUL(dest[0], dest[0], dest[3]); /* R * A */
504 VEC4_MUL(dest[1], dest[1], dest[3]); /* G * A */
505 VEC4_MUL(dest[2], dest[2], dest[3]); /* B * A */
506 }
507 else {
508 /* dest = dest * 1 NO-OP, leave dest as-is */
509 }
510 break;
511 case PIPE_BLENDFACTOR_DST_COLOR:
512 VEC4_MUL(dest[0], dest[0], dest[0]); /* R */
513 VEC4_MUL(dest[1], dest[1], dest[1]); /* G */
514 VEC4_MUL(dest[2], dest[2], dest[2]); /* B */
515 break;
516 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
517 if (has_dst_alpha) {
518 const float *alpha = quadColor[3];
519 float diff[4], temp[4];
520 VEC4_SUB(diff, one, dest[3]);
521 VEC4_MIN(temp, alpha, diff);
522 VEC4_MUL(dest[0], quadColor[0], temp); /* R */
523 VEC4_MUL(dest[1], quadColor[1], temp); /* G */
524 VEC4_MUL(dest[2], quadColor[2], temp); /* B */
525 }
526 else {
527 VEC4_COPY(dest[0], zero); /* R */
528 VEC4_COPY(dest[1], zero); /* G */
529 VEC4_COPY(dest[2], zero); /* B */
530 }
531 break;
532 case PIPE_BLENDFACTOR_CONST_COLOR:
533 {
534 float comp[4];
535 VEC4_SCALAR(comp, softpipe->blend_color.color[0]); /* R */
536 VEC4_MUL(dest[0], dest[0], comp); /* R */
537 VEC4_SCALAR(comp, softpipe->blend_color.color[1]); /* G */
538 VEC4_MUL(dest[1], dest[1], comp); /* G */
539 VEC4_SCALAR(comp, softpipe->blend_color.color[2]); /* B */
540 VEC4_MUL(dest[2], dest[2], comp); /* B */
541 }
542 break;
543 case PIPE_BLENDFACTOR_CONST_ALPHA:
544 {
545 float comp[4];
546 VEC4_SCALAR(comp, softpipe->blend_color.color[3]); /* A */
547 VEC4_MUL(dest[0], dest[0], comp); /* R */
548 VEC4_MUL(dest[1], dest[1], comp); /* G */
549 VEC4_MUL(dest[2], dest[2], comp); /* B */
550 }
551 break;
552 case PIPE_BLENDFACTOR_ZERO:
553 VEC4_COPY(dest[0], zero); /* R */
554 VEC4_COPY(dest[1], zero); /* G */
555 VEC4_COPY(dest[2], zero); /* B */
556 break;
557 case PIPE_BLENDFACTOR_SRC1_COLOR:
558 case PIPE_BLENDFACTOR_SRC1_ALPHA:
559 /* XXX what are these? */
560 assert(0);
561 break;
562 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
563 {
564 float inv_comp[4];
565 VEC4_SUB(inv_comp, one, quadColor[0]); /* R */
566 VEC4_MUL(dest[0], inv_comp, dest[0]); /* R */
567 VEC4_SUB(inv_comp, one, quadColor[1]); /* G */
568 VEC4_MUL(dest[1], inv_comp, dest[1]); /* G */
569 VEC4_SUB(inv_comp, one, quadColor[2]); /* B */
570 VEC4_MUL(dest[2], inv_comp, dest[2]); /* B */
571 }
572 break;
573 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
574 {
575 float one_minus_alpha[QUAD_SIZE];
576 VEC4_SUB(one_minus_alpha, one, quadColor[3]);
577 VEC4_MUL(dest[0], dest[0], one_minus_alpha); /* R */
578 VEC4_MUL(dest[1], dest[1], one_minus_alpha); /* G */
579 VEC4_MUL(dest[2], dest[2], one_minus_alpha); /* B */
580 }
581 break;
582 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
583 if (has_dst_alpha) {
584 float inv_comp[4];
585 VEC4_SUB(inv_comp, one, dest[3]); /* A */
586 VEC4_MUL(dest[0], inv_comp, dest[0]); /* R */
587 VEC4_MUL(dest[1], inv_comp, dest[1]); /* G */
588 VEC4_MUL(dest[2], inv_comp, dest[2]); /* B */
589 }
590 else {
591 VEC4_COPY(dest[0], zero); /* R */
592 VEC4_COPY(dest[1], zero); /* G */
593 VEC4_COPY(dest[2], zero); /* B */
594 }
595 break;
596 case PIPE_BLENDFACTOR_INV_DST_COLOR:
597 {
598 float inv_comp[4];
599 VEC4_SUB(inv_comp, one, dest[0]); /* R */
600 VEC4_MUL(dest[0], dest[0], inv_comp); /* R */
601 VEC4_SUB(inv_comp, one, dest[1]); /* G */
602 VEC4_MUL(dest[1], dest[1], inv_comp); /* G */
603 VEC4_SUB(inv_comp, one, dest[2]); /* B */
604 VEC4_MUL(dest[2], dest[2], inv_comp); /* B */
605 }
606 break;
607 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
608 {
609 float inv_comp[4];
610 /* R */
611 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[0]);
612 VEC4_MUL(dest[0], dest[0], inv_comp);
613 /* G */
614 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[1]);
615 VEC4_MUL(dest[1], dest[1], inv_comp);
616 /* B */
617 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[2]);
618 VEC4_MUL(dest[2], dest[2], inv_comp);
619 }
620 break;
621 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
622 {
623 float inv_comp[4];
624 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[3]);
625 VEC4_MUL(dest[0], dest[0], inv_comp);
626 VEC4_MUL(dest[1], dest[1], inv_comp);
627 VEC4_MUL(dest[2], dest[2], inv_comp);
628 }
629 break;
630 case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
631 case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
632 /* XXX what are these? */
633 assert(0);
634 break;
635 default:
636 assert(0 && "invalid rgb dst factor");
637 }
638
639 /*
640 * Compute dest/second term A
641 */
642 switch (softpipe->blend->rt[blend_index].alpha_dst_factor) {
643 case PIPE_BLENDFACTOR_ONE:
644 /* dest = dest * 1 NO-OP, leave dest as-is */
645 break;
646 case PIPE_BLENDFACTOR_SRC_COLOR:
647 /* fall-through */
648 case PIPE_BLENDFACTOR_SRC_ALPHA:
649 VEC4_MUL(dest[3], dest[3], quadColor[3]); /* A * A */
650 break;
651 case PIPE_BLENDFACTOR_DST_COLOR:
652 /* fall-through */
653 case PIPE_BLENDFACTOR_DST_ALPHA:
654 if (has_dst_alpha) {
655 VEC4_MUL(dest[3], dest[3], dest[3]); /* A */
656 }
657 else {
658 /* dest = dest * 1 NO-OP, leave dest as-is */
659 }
660 break;
661 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
662 /* dest = dest * 1 NO-OP, leave dest as-is */
663 break;
664 case PIPE_BLENDFACTOR_CONST_COLOR:
665 /* fall-through */
666 case PIPE_BLENDFACTOR_CONST_ALPHA:
667 {
668 float comp[4];
669 VEC4_SCALAR(comp, softpipe->blend_color.color[3]); /* A */
670 VEC4_MUL(dest[3], dest[3], comp); /* A */
671 }
672 break;
673 case PIPE_BLENDFACTOR_ZERO:
674 VEC4_COPY(dest[3], zero); /* A */
675 break;
676 case PIPE_BLENDFACTOR_INV_SRC_COLOR:
677 /* fall-through */
678 case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
679 {
680 float one_minus_alpha[QUAD_SIZE];
681 VEC4_SUB(one_minus_alpha, one, quadColor[3]);
682 VEC4_MUL(dest[3], dest[3], one_minus_alpha); /* A */
683 }
684 break;
685 case PIPE_BLENDFACTOR_INV_DST_COLOR:
686 /* fall-through */
687 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
688 if (has_dst_alpha) {
689 float inv_comp[4];
690 VEC4_SUB(inv_comp, one, dest[3]); /* A */
691 VEC4_MUL(dest[3], inv_comp, dest[3]); /* A */
692 }
693 else {
694 VEC4_COPY(dest[3], zero); /* A */
695 }
696 break;
697 case PIPE_BLENDFACTOR_INV_CONST_COLOR:
698 /* fall-through */
699 case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
700 {
701 float inv_comp[4];
702 VEC4_SCALAR(inv_comp, 1.0f - softpipe->blend_color.color[3]);
703 VEC4_MUL(dest[3], dest[3], inv_comp);
704 }
705 break;
706 default:
707 assert(0 && "invalid alpha dst factor");
708 }
709
710 /*
711 * Combine RGB terms
712 */
713 switch (softpipe->blend->rt[blend_index].rgb_func) {
714 case PIPE_BLEND_ADD:
715 VEC4_ADD_SAT(quadColor[0], source[0], dest[0]); /* R */
716 VEC4_ADD_SAT(quadColor[1], source[1], dest[1]); /* G */
717 VEC4_ADD_SAT(quadColor[2], source[2], dest[2]); /* B */
718 break;
719 case PIPE_BLEND_SUBTRACT:
720 VEC4_SUB_SAT(quadColor[0], source[0], dest[0]); /* R */
721 VEC4_SUB_SAT(quadColor[1], source[1], dest[1]); /* G */
722 VEC4_SUB_SAT(quadColor[2], source[2], dest[2]); /* B */
723 break;
724 case PIPE_BLEND_REVERSE_SUBTRACT:
725 VEC4_SUB_SAT(quadColor[0], dest[0], source[0]); /* R */
726 VEC4_SUB_SAT(quadColor[1], dest[1], source[1]); /* G */
727 VEC4_SUB_SAT(quadColor[2], dest[2], source[2]); /* B */
728 break;
729 case PIPE_BLEND_MIN:
730 VEC4_MIN(quadColor[0], source[0], dest[0]); /* R */
731 VEC4_MIN(quadColor[1], source[1], dest[1]); /* G */
732 VEC4_MIN(quadColor[2], source[2], dest[2]); /* B */
733 break;
734 case PIPE_BLEND_MAX:
735 VEC4_MAX(quadColor[0], source[0], dest[0]); /* R */
736 VEC4_MAX(quadColor[1], source[1], dest[1]); /* G */
737 VEC4_MAX(quadColor[2], source[2], dest[2]); /* B */
738 break;
739 default:
740 assert(0 && "invalid rgb blend func");
741 }
742
743 /*
744 * Combine A terms
745 */
746 switch (softpipe->blend->rt[blend_index].alpha_func) {
747 case PIPE_BLEND_ADD:
748 VEC4_ADD_SAT(quadColor[3], source[3], dest[3]); /* A */
749 break;
750 case PIPE_BLEND_SUBTRACT:
751 VEC4_SUB_SAT(quadColor[3], source[3], dest[3]); /* A */
752 break;
753 case PIPE_BLEND_REVERSE_SUBTRACT:
754 VEC4_SUB_SAT(quadColor[3], dest[3], source[3]); /* A */
755 break;
756 case PIPE_BLEND_MIN:
757 VEC4_MIN(quadColor[3], source[3], dest[3]); /* A */
758 break;
759 case PIPE_BLEND_MAX:
760 VEC4_MAX(quadColor[3], source[3], dest[3]); /* A */
761 break;
762 default:
763 assert(0 && "invalid alpha blend func");
764 }
765 }
766
767 static void
768 colormask_quad(unsigned colormask,
769 float (*quadColor)[4],
770 float (*dest)[4])
771 {
772 /* R */
773 if (!(colormask & PIPE_MASK_R))
774 COPY_4V(quadColor[0], dest[0]);
775
776 /* G */
777 if (!(colormask & PIPE_MASK_G))
778 COPY_4V(quadColor[1], dest[1]);
779
780 /* B */
781 if (!(colormask & PIPE_MASK_B))
782 COPY_4V(quadColor[2], dest[2]);
783
784 /* A */
785 if (!(colormask & PIPE_MASK_A))
786 COPY_4V(quadColor[3], dest[3]);
787 }
788
789
790 static void
791 blend_fallback(struct quad_stage *qs,
792 struct quad_header *quads[],
793 unsigned nr)
794 {
795 struct softpipe_context *softpipe = qs->softpipe;
796 const struct pipe_blend_state *blend = softpipe->blend;
797 unsigned cbuf;
798 boolean write_all;
799
800 write_all = softpipe->fs->color0_writes_all_cbufs;
801
802 for (cbuf = 0; cbuf < softpipe->framebuffer.nr_cbufs; cbuf++)
803 {
804 /* which blend/mask state index to use: */
805 const uint blend_buf = blend->independent_blend_enable ? cbuf : 0;
806 float dest[4][QUAD_SIZE];
807 struct softpipe_cached_tile *tile
808 = sp_get_cached_tile(softpipe->cbuf_cache[cbuf],
809 quads[0]->input.x0,
810 quads[0]->input.y0);
811 boolean has_dst_alpha
812 = util_format_has_alpha(softpipe->framebuffer.cbufs[cbuf]->format);
813 uint q, i, j, qbuf;
814
815 qbuf = write_all ? 0 : cbuf;
816
817 for (q = 0; q < nr; q++) {
818 struct quad_header *quad = quads[q];
819 float (*quadColor)[4];
820 const int itx = (quad->input.x0 & (TILE_SIZE-1));
821 const int ity = (quad->input.y0 & (TILE_SIZE-1));
822
823 quadColor = quad->output.color[qbuf];
824
825 /* get/swizzle dest colors
826 */
827 for (j = 0; j < QUAD_SIZE; j++) {
828 int x = itx + (j & 1);
829 int y = ity + (j >> 1);
830 for (i = 0; i < 4; i++) {
831 dest[i][j] = tile->data.color[y][x][i];
832 }
833 }
834
835
836 if (blend->logicop_enable) {
837 logicop_quad( qs, quadColor, dest );
838 }
839 else if (blend->rt[blend_buf].blend_enable) {
840 blend_quad( qs, quadColor, dest, blend_buf, has_dst_alpha );
841 }
842
843 if (blend->rt[blend_buf].colormask != 0xf)
844 colormask_quad( blend->rt[cbuf].colormask, quadColor, dest);
845
846 /* Output color values
847 */
848 for (j = 0; j < QUAD_SIZE; j++) {
849 if (quad->inout.mask & (1 << j)) {
850 int x = itx + (j & 1);
851 int y = ity + (j >> 1);
852 for (i = 0; i < 4; i++) { /* loop over color chans */
853 tile->data.color[y][x][i] = quadColor[i][j];
854 }
855 }
856 }
857 }
858 }
859 }
860
861
862 static void
863 blend_single_add_src_alpha_inv_src_alpha(struct quad_stage *qs,
864 struct quad_header *quads[],
865 unsigned nr)
866 {
867 static const float one[4] = { 1, 1, 1, 1 };
868 float one_minus_alpha[QUAD_SIZE];
869 float dest[4][QUAD_SIZE];
870 float source[4][QUAD_SIZE];
871 uint i, j, q;
872
873 struct softpipe_cached_tile *tile
874 = sp_get_cached_tile(qs->softpipe->cbuf_cache[0],
875 quads[0]->input.x0,
876 quads[0]->input.y0);
877
878 for (q = 0; q < nr; q++) {
879 struct quad_header *quad = quads[q];
880 float (*quadColor)[4] = quad->output.color[0];
881 const float *alpha = quadColor[3];
882 const int itx = (quad->input.x0 & (TILE_SIZE-1));
883 const int ity = (quad->input.y0 & (TILE_SIZE-1));
884
885 /* get/swizzle dest colors */
886 for (j = 0; j < QUAD_SIZE; j++) {
887 int x = itx + (j & 1);
888 int y = ity + (j >> 1);
889 for (i = 0; i < 4; i++) {
890 dest[i][j] = tile->data.color[y][x][i];
891 }
892 }
893
894 VEC4_MUL(source[0], quadColor[0], alpha); /* R */
895 VEC4_MUL(source[1], quadColor[1], alpha); /* G */
896 VEC4_MUL(source[2], quadColor[2], alpha); /* B */
897 VEC4_MUL(source[3], quadColor[3], alpha); /* A */
898
899 VEC4_SUB(one_minus_alpha, one, alpha);
900 VEC4_MUL(dest[0], dest[0], one_minus_alpha); /* R */
901 VEC4_MUL(dest[1], dest[1], one_minus_alpha); /* G */
902 VEC4_MUL(dest[2], dest[2], one_minus_alpha); /* B */
903 VEC4_MUL(dest[3], dest[3], one_minus_alpha); /* B */
904
905 VEC4_ADD_SAT(quadColor[0], source[0], dest[0]); /* R */
906 VEC4_ADD_SAT(quadColor[1], source[1], dest[1]); /* G */
907 VEC4_ADD_SAT(quadColor[2], source[2], dest[2]); /* B */
908 VEC4_ADD_SAT(quadColor[3], source[3], dest[3]); /* A */
909
910 for (j = 0; j < QUAD_SIZE; j++) {
911 if (quad->inout.mask & (1 << j)) {
912 int x = itx + (j & 1);
913 int y = ity + (j >> 1);
914 for (i = 0; i < 4; i++) { /* loop over color chans */
915 tile->data.color[y][x][i] = quadColor[i][j];
916 }
917 }
918 }
919 }
920 }
921
922 static void
923 blend_single_add_one_one(struct quad_stage *qs,
924 struct quad_header *quads[],
925 unsigned nr)
926 {
927 float dest[4][QUAD_SIZE];
928 uint i, j, q;
929
930 struct softpipe_cached_tile *tile
931 = sp_get_cached_tile(qs->softpipe->cbuf_cache[0],
932 quads[0]->input.x0,
933 quads[0]->input.y0);
934
935 for (q = 0; q < nr; q++) {
936 struct quad_header *quad = quads[q];
937 float (*quadColor)[4] = quad->output.color[0];
938 const int itx = (quad->input.x0 & (TILE_SIZE-1));
939 const int ity = (quad->input.y0 & (TILE_SIZE-1));
940
941 /* get/swizzle dest colors */
942 for (j = 0; j < QUAD_SIZE; j++) {
943 int x = itx + (j & 1);
944 int y = ity + (j >> 1);
945 for (i = 0; i < 4; i++) {
946 dest[i][j] = tile->data.color[y][x][i];
947 }
948 }
949
950 VEC4_ADD_SAT(quadColor[0], quadColor[0], dest[0]); /* R */
951 VEC4_ADD_SAT(quadColor[1], quadColor[1], dest[1]); /* G */
952 VEC4_ADD_SAT(quadColor[2], quadColor[2], dest[2]); /* B */
953 VEC4_ADD_SAT(quadColor[3], quadColor[3], dest[3]); /* A */
954
955 for (j = 0; j < QUAD_SIZE; j++) {
956 if (quad->inout.mask & (1 << j)) {
957 int x = itx + (j & 1);
958 int y = ity + (j >> 1);
959 for (i = 0; i < 4; i++) { /* loop over color chans */
960 tile->data.color[y][x][i] = quadColor[i][j];
961 }
962 }
963 }
964 }
965 }
966
967
968 static void
969 single_output_color(struct quad_stage *qs,
970 struct quad_header *quads[],
971 unsigned nr)
972 {
973 uint i, j, q;
974
975 struct softpipe_cached_tile *tile
976 = sp_get_cached_tile(qs->softpipe->cbuf_cache[0],
977 quads[0]->input.x0,
978 quads[0]->input.y0);
979
980 for (q = 0; q < nr; q++) {
981 struct quad_header *quad = quads[q];
982 float (*quadColor)[4] = quad->output.color[0];
983 const int itx = (quad->input.x0 & (TILE_SIZE-1));
984 const int ity = (quad->input.y0 & (TILE_SIZE-1));
985
986 for (j = 0; j < QUAD_SIZE; j++) {
987 if (quad->inout.mask & (1 << j)) {
988 int x = itx + (j & 1);
989 int y = ity + (j >> 1);
990 for (i = 0; i < 4; i++) { /* loop over color chans */
991 tile->data.color[y][x][i] = quadColor[i][j];
992 }
993 }
994 }
995 }
996 }
997
998 static void
999 blend_noop(struct quad_stage *qs,
1000 struct quad_header *quads[],
1001 unsigned nr)
1002 {
1003 }
1004
1005
1006 static void
1007 choose_blend_quad(struct quad_stage *qs,
1008 struct quad_header *quads[],
1009 unsigned nr)
1010 {
1011 struct softpipe_context *softpipe = qs->softpipe;
1012 const struct pipe_blend_state *blend = softpipe->blend;
1013
1014 qs->run = blend_fallback;
1015
1016 if (softpipe->framebuffer.nr_cbufs == 0) {
1017 qs->run = blend_noop;
1018 }
1019 else if (!softpipe->blend->logicop_enable &&
1020 softpipe->blend->rt[0].colormask == 0xf &&
1021 softpipe->framebuffer.nr_cbufs == 1)
1022 {
1023 if (!blend->rt[0].blend_enable) {
1024 qs->run = single_output_color;
1025 }
1026 else if (blend->rt[0].rgb_src_factor == blend->rt[0].alpha_src_factor &&
1027 blend->rt[0].rgb_dst_factor == blend->rt[0].alpha_dst_factor &&
1028 blend->rt[0].rgb_func == blend->rt[0].alpha_func)
1029 {
1030 if (blend->rt[0].alpha_func == PIPE_BLEND_ADD) {
1031 if (blend->rt[0].rgb_src_factor == PIPE_BLENDFACTOR_ONE &&
1032 blend->rt[0].rgb_dst_factor == PIPE_BLENDFACTOR_ONE) {
1033 qs->run = blend_single_add_one_one;
1034 }
1035 else if (blend->rt[0].rgb_src_factor == PIPE_BLENDFACTOR_SRC_ALPHA &&
1036 blend->rt[0].rgb_dst_factor == PIPE_BLENDFACTOR_INV_SRC_ALPHA)
1037 qs->run = blend_single_add_src_alpha_inv_src_alpha;
1038
1039 }
1040 }
1041 }
1042
1043 qs->run(qs, quads, nr);
1044 }
1045
1046
1047 static void blend_begin(struct quad_stage *qs)
1048 {
1049 qs->run = choose_blend_quad;
1050 }
1051
1052
1053 static void blend_destroy(struct quad_stage *qs)
1054 {
1055 FREE( qs );
1056 }
1057
1058
1059 struct quad_stage *sp_quad_blend_stage( struct softpipe_context *softpipe )
1060 {
1061 struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
1062
1063 stage->softpipe = softpipe;
1064 stage->begin = blend_begin;
1065 stage->run = choose_blend_quad;
1066 stage->destroy = blend_destroy;
1067
1068 return stage;
1069 }