src/gallium/drivers/panfrost/pan_blending.c

   1 /*
   2  * © Copyright 2018 Alyssa Rosenzweig
   3  *
   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:
  10  *
  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
  13  * Software.
  14  *
  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
  21  * SOFTWARE.
  22  *
  23  */
  24
  25 #include <stdio.h>
  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"
  30
  31 /*
  32  * Implements fixed-function blending on Midgard.
  33  *
  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.
  38  *
  39  * Essentially, for a given blending operation, there is a single dominant
  40  * factor. The following dominant factors are possible:
  41  *
  42  *      - zero
  43  *      - source color
  44  *      - destination color
  45  *      - source alpha
  46  *      - destination alpha
  47  *      - constant float
  48  *
  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.
  52  *
  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
  57  * required.
  58  *
  59  * The nondominant factor can be either:
  60  *
  61  *      - the same as the dominant factor (MALI_BLEND_NON_MIRROR)
  62  *      - zero (MALI_BLEND_NON_ZERO)
  63  *
  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.
  67  *
  68  * By default, all blending follows the standard OpenGL addition equation:
  69  *
  70  *      out = source_value * source_factor + destination_value * destination_factor
  71  *
  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".
  75  *
  76  * Finally, there is a "clip modifier" controlling the final blending
  77  * behaviour, allowing for the following modes:
  78  *
  79  *      - normal
  80  *      - force source factor to one (MALI_BLEND_MODE_SOURCE_ONE)
  81  *      - force destination factor to one (MALI_BLEND_MODE_DEST_ONE)
  82  *
  83  * The clipping flags can be used to encode blend modes where the nondominant
  84  * factor is ONE.
  85  *
  86  * As an example putting it all together, to encode the following blend state:
  87  *
  88  *      glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
  89  *      glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE);
  90  *
  91  * We need the following configuration:
  92  *
  93  *      - negate source (for REVERSE_SUBTRACT)
  94  *      - dominant factor "source alpha"
  95  *              - complement dominant
  96  *              - source dominant
  97  *      - force destination to ONE
  98  *
  99  * The following routines implement this fixed function blending encoding
 100  */
 101
 102 /* Not all formats can be blended by fixed-function hardware */
 103
 104 bool
 105 panfrost_can_fixed_blend(enum pipe_format format)
 106 {
 107         /* Fixed-function can handle sRGB */
 108         format = util_format_linear(format);
 109
 110         switch (panfrost_pipe_format_table[format].hw) {
 111         case MALI_RGB565:
 112         case MALI_RGB5_A1_UNORM:
 113         case MALI_RGB10_A2_UNORM:
 114         case MALI_RGBA4_UNORM:
 115         case MALI_R8_UNORM:
 116         case MALI_RG8_UNORM:
 117         case MALI_RGB8_UNORM:
 118         case MALI_RGBA8_UNORM:
 119                 return true;
 120         default:
 121                 return false;
 122         }
 123 }
 124
 125 /* Helper to find the uncomplemented Gallium blend factor corresponding to a
 126  * complemented Gallium blend factor */
 127
 128 static int
 129 complement_factor(int factor)
 130 {
 131         switch (factor) {
 132         case PIPE_BLENDFACTOR_INV_SRC_COLOR:
 133                 return PIPE_BLENDFACTOR_SRC_COLOR;
 134
 135         case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 136                 return PIPE_BLENDFACTOR_SRC_ALPHA;
 137
 138         case PIPE_BLENDFACTOR_INV_DST_ALPHA:
 139                 return PIPE_BLENDFACTOR_DST_ALPHA;
 140
 141         case PIPE_BLENDFACTOR_INV_DST_COLOR:
 142                 return PIPE_BLENDFACTOR_DST_COLOR;
 143
 144         case PIPE_BLENDFACTOR_INV_CONST_COLOR:
 145                 return PIPE_BLENDFACTOR_CONST_COLOR;
 146
 147         case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
 148                 return PIPE_BLENDFACTOR_CONST_ALPHA;
 149
 150         default:
 151                 return -1;
 152         }
 153 }
 154
 155 /* Helper to strip the complement from any Gallium blend factor */
 156
 157 static int
 158 uncomplement_factor(int factor)
 159 {
 160         int complement = complement_factor(factor);
 161         return (complement == -1) ? factor : complement;
 162 }
 163
 164
 165 /* Attempt to find the dominant factor given a particular factor, complementing
 166  * as necessary */
 167
 168 static bool
 169 panfrost_make_dominant_factor(unsigned src_factor, enum mali_dominant_factor *factor)
 170 {
 171         switch (src_factor) {
 172         case PIPE_BLENDFACTOR_SRC_COLOR:
 173         case PIPE_BLENDFACTOR_INV_SRC_COLOR:
 174                 *factor = MALI_DOMINANT_SRC_COLOR;
 175                 break;
 176
 177         case PIPE_BLENDFACTOR_SRC_ALPHA:
 178         case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 179                 *factor = MALI_DOMINANT_SRC_ALPHA;
 180                 break;
 181
 182         case PIPE_BLENDFACTOR_DST_COLOR:
 183         case PIPE_BLENDFACTOR_INV_DST_COLOR:
 184                 *factor = MALI_DOMINANT_DST_COLOR;
 185                 break;
 186
 187         case PIPE_BLENDFACTOR_DST_ALPHA:
 188         case PIPE_BLENDFACTOR_INV_DST_ALPHA:
 189                 *factor = MALI_DOMINANT_DST_ALPHA;
 190                 break;
 191
 192         case PIPE_BLENDFACTOR_ONE:
 193         case PIPE_BLENDFACTOR_ZERO:
 194                 *factor = MALI_DOMINANT_ZERO;
 195                 break;
 196
 197         case PIPE_BLENDFACTOR_CONST_ALPHA:
 198         case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
 199         case PIPE_BLENDFACTOR_CONST_COLOR:
 200         case PIPE_BLENDFACTOR_INV_CONST_COLOR:
 201                 *factor = MALI_DOMINANT_CONSTANT;
 202                 break;
 203
 204         default:
 205                 /* Fancy blend modes not supported */
 206                 return false;
 207         }
 208
 209         return true;
 210 }
 211
 212 /* Check if this is a special edge case blend factor, which may require the use
 213  * of clip modifiers */
 214
 215 static bool
 216 is_edge_blendfactor(unsigned factor)
 217 {
 218         return factor == PIPE_BLENDFACTOR_ONE || factor == PIPE_BLENDFACTOR_ZERO;
 219 }
 220
 221 /* Perform the actual fixed function encoding. Encode the function with negate
 222  * bits. Check for various cases to work out the dominant/nondominant split and
 223  * accompanying flags. */
 224
 225 static bool
 226 panfrost_make_fixed_blend_part(unsigned func, unsigned src_factor, unsigned dst_factor, unsigned *out)
 227 {
 228         struct mali_blend_mode part = { 0 };
 229
 230         /* Make sure that the blend function is representible */
 231
 232         switch (func) {
 233         case PIPE_BLEND_ADD:
 234                 break;
 235
 236         /* TODO: Reenable subtraction modes when those fixed */
 237         case PIPE_BLEND_SUBTRACT:
 238         case PIPE_BLEND_REVERSE_SUBTRACT:
 239         default:
 240                 return false;
 241         }
 242
 243         part.clip_modifier = MALI_BLEND_MOD_NORMAL;
 244
 245         /* Decide which is dominant, source or destination. If one is an edge
 246          * case, use the other as a factor. If they're the same, it doesn't
 247          * matter; we just mirror. If they're different non-edge-cases, you
 248          * need a blend shader (don't do that). */
 249
 250         if (is_edge_blendfactor(dst_factor)) {
 251                 part.dominant = MALI_BLEND_DOM_SOURCE;
 252                 part.nondominant_mode = MALI_BLEND_NON_ZERO;
 253
 254                 if (dst_factor == PIPE_BLENDFACTOR_ONE)
 255                         part.clip_modifier = MALI_BLEND_MOD_DEST_ONE;
 256         } else if (is_edge_blendfactor(src_factor)) {
 257                 part.dominant = MALI_BLEND_DOM_DESTINATION;
 258                 part.nondominant_mode = MALI_BLEND_NON_ZERO;
 259
 260                 if (src_factor == PIPE_BLENDFACTOR_ONE)
 261                         part.clip_modifier = MALI_BLEND_MOD_SOURCE_ONE;
 262         } else if (src_factor == dst_factor) {
 263                 /* XXX: Why? */
 264                 part.dominant = func == PIPE_BLEND_ADD ?
 265                                 MALI_BLEND_DOM_DESTINATION : MALI_BLEND_DOM_SOURCE;
 266
 267                 part.nondominant_mode = MALI_BLEND_NON_MIRROR;
 268         } else if (src_factor == complement_factor(dst_factor)) {
 269                 /* TODO: How does this work exactly? */
 270                 part.dominant = MALI_BLEND_DOM_SOURCE;
 271                 part.nondominant_mode = MALI_BLEND_NON_MIRROR;
 272                 part.clip_modifier = MALI_BLEND_MOD_DEST_ONE;
 273
 274                 /* The complement is handled by the clip modifier, don't set a
 275                  * complement flag */
 276
 277                 dst_factor = src_factor;
 278         } else if (dst_factor == complement_factor(src_factor)) {
 279                 part.dominant = MALI_BLEND_DOM_SOURCE;
 280                 part.nondominant_mode = MALI_BLEND_NON_MIRROR;
 281                 part.clip_modifier = MALI_BLEND_MOD_SOURCE_ONE;
 282
 283                 src_factor = dst_factor;
 284         } else {
 285                 return false;
 286         }
 287
 288         unsigned in_dominant_factor =
 289                 part.dominant == MALI_BLEND_DOM_SOURCE ? src_factor : dst_factor;
 290
 291         if (part.clip_modifier == MALI_BLEND_MOD_NORMAL && in_dominant_factor == PIPE_BLENDFACTOR_ONE) {
 292                 part.clip_modifier = part.dominant == MALI_BLEND_DOM_SOURCE ? MALI_BLEND_MOD_SOURCE_ONE : MALI_BLEND_MOD_DEST_ONE;
 293                 in_dominant_factor = PIPE_BLENDFACTOR_ZERO;
 294         }
 295
 296         enum mali_dominant_factor dominant_factor;
 297
 298         if (!panfrost_make_dominant_factor(in_dominant_factor, &dominant_factor))
 299                 return false;
 300
 301         part.dominant_factor = dominant_factor;
 302         part.complement_dominant = util_blend_factor_is_inverted(in_dominant_factor);
 303
 304         /* It's not clear what this does, but fixes some ADD blending tests.
 305          * More research is needed XXX */
 306
 307         if ((part.clip_modifier == MALI_BLEND_MOD_SOURCE_ONE) && (part.dominant == MALI_BLEND_DOM_SOURCE))
 308                 part.negate_dest = true;
 309
 310         /* Write out mode */
 311         memcpy(out, &part, sizeof(part));
 312
 313         return true;
 314 }
 315
 316 /* We can upload a single constant for all of the factors. So, scan
 317  * the factors for constants used to create a mask to check later. */
 318
 319 static unsigned
 320 panfrost_constant_mask(unsigned *factors, unsigned num_factors)
 321 {
 322         unsigned mask = 0;
 323
 324         for (unsigned i = 0; i < num_factors; ++i) {
 325                 unsigned factor = uncomplement_factor(factors[i]);
 326
 327                 if (factor == PIPE_BLENDFACTOR_CONST_COLOR)
 328                         mask |= 0b0111; /* RGB */
 329                 else if (factor == PIPE_BLENDFACTOR_CONST_ALPHA)
 330                         mask |= 0b1000; /* A */
 331         }
 332
 333         return mask;
 334 }
 335
 336 /* Create the descriptor for a fixed blend mode given the corresponding Gallium
 337  * state, if possible. Return true and write out the blend descriptor into
 338  * blend_equation. If it is not possible with the fixed function
 339  * representating, return false to handle degenerate cases with a blend shader
 340  */
 341
 342 bool
 343 panfrost_make_fixed_blend_mode(
 344         struct pipe_rt_blend_state blend,
 345         struct mali_blend_equation *out,
 346         unsigned *constant_mask)
 347 {
 348         /* Gallium and Mali represent colour masks identically. XXX: Static
 349          * assert for future proof */
 350
 351         out->color_mask = blend.colormask;
 352
 353         /* If no blending is enabled, default back on `replace` mode */
 354
 355         if (!blend.blend_enable) {
 356                 out->rgb_mode = 0x122;
 357                 out->alpha_mode = 0x122;
 358                 return true;
 359         }
 360
 361         /* At draw-time, we'll need to analyze the blend constant, so
 362          * precompute a mask for it -- even if we don't end up able to use
 363          * fixed-function blending */
 364
 365         unsigned factors[] = {
 366                 blend.rgb_src_factor, blend.rgb_dst_factor,
 367                 blend.alpha_src_factor, blend.alpha_dst_factor,
 368         };
 369
 370         *constant_mask = panfrost_constant_mask(factors, ARRAY_SIZE(factors));
 371
 372         /* Try to compile the actual fixed-function blend */
 373
 374         unsigned rgb_mode = 0;
 375         unsigned alpha_mode = 0;
 376
 377         if (!panfrost_make_fixed_blend_part(
 378                     blend.rgb_func, blend.rgb_src_factor, blend.rgb_dst_factor,
 379                     &rgb_mode))
 380                 return false;
 381
 382         if (!panfrost_make_fixed_blend_part(
 383                     blend.alpha_func, blend.alpha_src_factor, blend.alpha_dst_factor,
 384                     &alpha_mode))
 385                 return false;
 386
 387         out->rgb_mode = rgb_mode;
 388         out->alpha_mode = alpha_mode;
 389
 390         return true;
 391 }