2 * © Copyright 2018 Alyssa Rosenzweig
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 #include "pan_blending.h"
27 #include "pan_context.h"
28 #include "gallium/auxiliary/util/u_blend.h"
29 #include "util/format/u_format.h"
32 * Implements fixed-function blending on Midgard.
34 * Midgard splits blending into a fixed-function fast path and a programmable
35 * slow path. The fixed function blending architecture is based on "dominant"
36 * blend factors. Blending is encoded separately (but identically) between RGB
37 * and alpha functions.
39 * Essentially, for a given blending operation, there is a single dominant
40 * factor. The following dominant factors are possible:
49 * Further, a dominant factor's arithmetic compliment could be used. For
50 * instance, to encode GL_ONE_MINUS_SOURCE_ALPHA, the dominant factor would be
51 * MALI_DOMINANT_SRC_ALPHA with the complement_dominant bit set.
53 * A single constant float can be passed to the fixed-function hardware,
54 * allowing CONSTANT_ALPHA support. Further, if all components of the constant
55 * glBlendColor are identical, CONSTANT_COLOR can be implemented with the
56 * constant float mode. If the components differ, programmable blending is
59 * The nondominant factor can be either:
61 * - the same as the dominant factor (MALI_BLEND_NON_MIRROR)
62 * - zero (MALI_BLEND_NON_ZERO)
64 * Exactly one of the blend operation's source or destination can be used as
65 * the dominant factor; this is selected by the
66 * MALI_BLEND_DOM_SOURCE/DESTINATION flag.
68 * By default, all blending follows the standard OpenGL addition equation:
70 * out = source_value * source_factor + destination_value * destination_factor
72 * By setting the negate_source or negate_dest bits, other blend functions can
73 * be created. For instance, for SUBTRACT mode, set the "negate destination"
74 * flag, and similarly for REVERSE_SUBTRACT with "negate source".
76 * Finally, there is a "clip modifier" controlling the final blending
77 * behaviour, allowing for the following modes:
80 * - force source factor to one (MALI_BLEND_MODE_SOURCE_ONE)
81 * - force destination factor to one (MALI_BLEND_MODE_DEST_ONE)
83 * The clipping flags can be used to encode blend modes where the nondominant
86 * As an example putting it all together, to encode the following blend state:
88 * glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
89 * glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE);
91 * We need the following configuration:
93 * - negate source (for REVERSE_SUBTRACT)
94 * - dominant factor "source alpha"
95 * - complement dominant
97 * - force destination to ONE
99 * The following routines implement this fixed function blending encoding
102 /* Not all formats can be blended by fixed-function hardware */
105 panfrost_can_fixed_blend(enum pipe_format format
)
107 /* Fixed-function can handle sRGB */
108 format
= util_format_linear(format
);
110 /* Decompose the format */
111 const struct util_format_description
*desc
=
112 util_format_description(format
);
114 /* Any 8-bit unorm is supported */
115 if (util_format_is_unorm8(desc
))
118 /* Certain special formats are, too */
120 case PIPE_FORMAT_B5G6R5_UNORM
:
121 case PIPE_FORMAT_R10G10B10A2_UNORM
:
122 case PIPE_FORMAT_B10G10R10A2_UNORM
:
123 case PIPE_FORMAT_R10G10B10X2_UNORM
:
124 case PIPE_FORMAT_B10G10R10X2_UNORM
:
125 case PIPE_FORMAT_B4G4R4A4_UNORM
:
126 case PIPE_FORMAT_B4G4R4X4_UNORM
:
127 case PIPE_FORMAT_A4R4_UNORM
:
128 case PIPE_FORMAT_R4A4_UNORM
:
129 case PIPE_FORMAT_A4B4G4R4_UNORM
:
136 /* Helper to find the uncomplemented Gallium blend factor corresponding to a
137 * complemented Gallium blend factor */
140 complement_factor(int factor
)
143 case PIPE_BLENDFACTOR_INV_SRC_COLOR
:
144 return PIPE_BLENDFACTOR_SRC_COLOR
;
146 case PIPE_BLENDFACTOR_INV_SRC_ALPHA
:
147 return PIPE_BLENDFACTOR_SRC_ALPHA
;
149 case PIPE_BLENDFACTOR_INV_DST_ALPHA
:
150 return PIPE_BLENDFACTOR_DST_ALPHA
;
152 case PIPE_BLENDFACTOR_INV_DST_COLOR
:
153 return PIPE_BLENDFACTOR_DST_COLOR
;
155 case PIPE_BLENDFACTOR_INV_CONST_COLOR
:
156 return PIPE_BLENDFACTOR_CONST_COLOR
;
158 case PIPE_BLENDFACTOR_INV_CONST_ALPHA
:
159 return PIPE_BLENDFACTOR_CONST_ALPHA
;
166 /* Helper to strip the complement from any Gallium blend factor */
169 uncomplement_factor(int factor
)
171 int complement
= complement_factor(factor
);
172 return (complement
== -1) ? factor
: complement
;
176 /* Attempt to find the dominant factor given a particular factor, complementing
180 panfrost_make_dominant_factor(unsigned src_factor
, enum mali_dominant_factor
*factor
)
182 switch (src_factor
) {
183 case PIPE_BLENDFACTOR_SRC_COLOR
:
184 case PIPE_BLENDFACTOR_INV_SRC_COLOR
:
185 *factor
= MALI_DOMINANT_SRC_COLOR
;
188 case PIPE_BLENDFACTOR_SRC_ALPHA
:
189 case PIPE_BLENDFACTOR_INV_SRC_ALPHA
:
190 *factor
= MALI_DOMINANT_SRC_ALPHA
;
193 case PIPE_BLENDFACTOR_DST_COLOR
:
194 case PIPE_BLENDFACTOR_INV_DST_COLOR
:
195 *factor
= MALI_DOMINANT_DST_COLOR
;
198 case PIPE_BLENDFACTOR_DST_ALPHA
:
199 case PIPE_BLENDFACTOR_INV_DST_ALPHA
:
200 *factor
= MALI_DOMINANT_DST_ALPHA
;
203 case PIPE_BLENDFACTOR_ONE
:
204 case PIPE_BLENDFACTOR_ZERO
:
205 *factor
= MALI_DOMINANT_ZERO
;
208 case PIPE_BLENDFACTOR_CONST_ALPHA
:
209 case PIPE_BLENDFACTOR_INV_CONST_ALPHA
:
210 case PIPE_BLENDFACTOR_CONST_COLOR
:
211 case PIPE_BLENDFACTOR_INV_CONST_COLOR
:
212 *factor
= MALI_DOMINANT_CONSTANT
;
216 /* Fancy blend modes not supported */
223 /* Check if this is a special edge case blend factor, which may require the use
224 * of clip modifiers */
227 is_edge_blendfactor(unsigned factor
)
229 return factor
== PIPE_BLENDFACTOR_ONE
|| factor
== PIPE_BLENDFACTOR_ZERO
;
232 /* Perform the actual fixed function encoding. Encode the function with negate
233 * bits. Check for various cases to work out the dominant/nondominant split and
234 * accompanying flags. */
237 panfrost_make_fixed_blend_part(unsigned func
, unsigned src_factor
, unsigned dst_factor
, unsigned *out
)
239 struct mali_blend_mode part
= { 0 };
241 /* Make sure that the blend function is representible */
247 /* TODO: Reenable subtraction modes when those fixed */
248 case PIPE_BLEND_SUBTRACT
:
249 case PIPE_BLEND_REVERSE_SUBTRACT
:
254 part
.clip_modifier
= MALI_BLEND_MOD_NORMAL
;
256 /* Decide which is dominant, source or destination. If one is an edge
257 * case, use the other as a factor. If they're the same, it doesn't
258 * matter; we just mirror. If they're different non-edge-cases, you
259 * need a blend shader (don't do that). */
261 if (is_edge_blendfactor(dst_factor
)) {
262 part
.dominant
= MALI_BLEND_DOM_SOURCE
;
263 part
.nondominant_mode
= MALI_BLEND_NON_ZERO
;
265 if (dst_factor
== PIPE_BLENDFACTOR_ONE
)
266 part
.clip_modifier
= MALI_BLEND_MOD_DEST_ONE
;
267 } else if (is_edge_blendfactor(src_factor
)) {
268 part
.dominant
= MALI_BLEND_DOM_DESTINATION
;
269 part
.nondominant_mode
= MALI_BLEND_NON_ZERO
;
271 if (src_factor
== PIPE_BLENDFACTOR_ONE
)
272 part
.clip_modifier
= MALI_BLEND_MOD_SOURCE_ONE
;
273 } else if (src_factor
== dst_factor
) {
275 part
.dominant
= func
== PIPE_BLEND_ADD
?
276 MALI_BLEND_DOM_DESTINATION
: MALI_BLEND_DOM_SOURCE
;
278 part
.nondominant_mode
= MALI_BLEND_NON_MIRROR
;
279 } else if (src_factor
== complement_factor(dst_factor
)) {
280 /* TODO: How does this work exactly? */
281 part
.dominant
= MALI_BLEND_DOM_SOURCE
;
282 part
.nondominant_mode
= MALI_BLEND_NON_MIRROR
;
283 part
.clip_modifier
= MALI_BLEND_MOD_DEST_ONE
;
285 /* The complement is handled by the clip modifier, don't set a
288 dst_factor
= src_factor
;
289 } else if (dst_factor
== complement_factor(src_factor
)) {
290 part
.dominant
= MALI_BLEND_DOM_SOURCE
;
291 part
.nondominant_mode
= MALI_BLEND_NON_MIRROR
;
292 part
.clip_modifier
= MALI_BLEND_MOD_SOURCE_ONE
;
294 src_factor
= dst_factor
;
299 unsigned in_dominant_factor
=
300 part
.dominant
== MALI_BLEND_DOM_SOURCE
? src_factor
: dst_factor
;
302 if (part
.clip_modifier
== MALI_BLEND_MOD_NORMAL
&& in_dominant_factor
== PIPE_BLENDFACTOR_ONE
) {
303 part
.clip_modifier
= part
.dominant
== MALI_BLEND_DOM_SOURCE
? MALI_BLEND_MOD_SOURCE_ONE
: MALI_BLEND_MOD_DEST_ONE
;
304 in_dominant_factor
= PIPE_BLENDFACTOR_ZERO
;
307 enum mali_dominant_factor dominant_factor
;
309 if (!panfrost_make_dominant_factor(in_dominant_factor
, &dominant_factor
))
312 part
.dominant_factor
= dominant_factor
;
313 part
.complement_dominant
= util_blend_factor_is_inverted(in_dominant_factor
);
315 /* It's not clear what this does, but fixes some ADD blending tests.
316 * More research is needed XXX */
318 if ((part
.clip_modifier
== MALI_BLEND_MOD_SOURCE_ONE
) && (part
.dominant
== MALI_BLEND_DOM_SOURCE
))
319 part
.negate_dest
= true;
322 memcpy(out
, &part
, sizeof(part
));
327 /* We can upload a single constant for all of the factors. So, scan
328 * the factors for constants used to create a mask to check later. */
331 panfrost_constant_mask(unsigned *factors
, unsigned num_factors
)
335 for (unsigned i
= 0; i
< num_factors
; ++i
) {
336 unsigned factor
= uncomplement_factor(factors
[i
]);
338 if (factor
== PIPE_BLENDFACTOR_CONST_COLOR
)
339 mask
|= 0b0111; /* RGB */
340 else if (factor
== PIPE_BLENDFACTOR_CONST_ALPHA
)
341 mask
|= 0b1000; /* A */
347 /* Create the descriptor for a fixed blend mode given the corresponding Gallium
348 * state, if possible. Return true and write out the blend descriptor into
349 * blend_equation. If it is not possible with the fixed function
350 * representating, return false to handle degenerate cases with a blend shader
354 panfrost_make_fixed_blend_mode(
355 const struct pipe_rt_blend_state
*blend
,
356 struct mali_blend_equation
*out
,
357 unsigned *constant_mask
,
360 /* Gallium and Mali represent colour masks identically. XXX: Static
361 * assert for future proof */
363 out
->color_mask
= colormask
;
365 /* If no blending is enabled, default back on `replace` mode */
367 if (!blend
->blend_enable
) {
368 out
->rgb_mode
= 0x122;
369 out
->alpha_mode
= 0x122;
373 /* At draw-time, we'll need to analyze the blend constant, so
374 * precompute a mask for it -- even if we don't end up able to use
375 * fixed-function blending */
377 unsigned factors
[] = {
378 blend
->rgb_src_factor
, blend
->rgb_dst_factor
,
379 blend
->alpha_src_factor
, blend
->alpha_dst_factor
,
382 *constant_mask
= panfrost_constant_mask(factors
, ARRAY_SIZE(factors
));
384 /* Try to compile the actual fixed-function blend */
386 unsigned rgb_mode
= 0;
387 unsigned alpha_mode
= 0;
389 if (!panfrost_make_fixed_blend_part(
390 blend
->rgb_func
, blend
->rgb_src_factor
, blend
->rgb_dst_factor
,
394 if (!panfrost_make_fixed_blend_part(
395 blend
->alpha_func
, blend
->alpha_src_factor
, blend
->alpha_dst_factor
,
399 out
->rgb_mode
= rgb_mode
;
400 out
->alpha_mode
= alpha_mode
;