Implement Porter Duff XP with a blend table

src/gpu/effects/GrPorterDuffXferProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
 #include "GrProcessor.h"
 #include "GrProcOptInfo.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "gl/GrGLXferProcessor.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
-static bool can_tweak_alpha_for_coverage(GrBlendCoeff dstCoeff) {
-    /*
-     The fractional coverage is f.
-     The src and dst coeffs are Cs and Cd.
-     The dst and src colors are S and D.
-     We want the blend to compute: f*Cs*S + (f*Cd + (1-f))D. By tweaking the source color's alpha
-     we're replacing S with S'=fS. It's obvious that that first term will always be ok. The second
-     term can be rearranged as [1-(1-Cd)f]D. By substituting in the various possibilities for Cd we
-     find that only 1, ISA, and ISC produce the correct destination when applied to S' and D.
+/**
+ * Wraps the shader outputs and HW blend state that comprise a Porter Duff blend mode with coverage.
+ */
+struct BlendFormula {
+public:
+    /**
+     * Values the shader can write to primary and secondary outputs. These must all be modulated by
+     * coverage to support mixed samples. The XP will ignore the multiplies when not using coverage.
      */
-    return kOne_GrBlendCoeff == dstCoeff ||
-           kISA_GrBlendCoeff == dstCoeff ||
-           kISC_GrBlendCoeff == dstCoeff;
+    enum OutputType {
+        kNone_OutputType,        //<! 0
+        kCoverage_OutputType,    //<! inputCoverage
+        kModulate_OutputType,    //<! inputColor * inputCoverage
+        kISAModulate_OutputType, //<! (1 - inputColor.a) * inputCoverage
+        kISCModulate_OutputType, //<! (1 - inputColor) * inputCoverage
+
+        kLast_OutputType = kISCModulate_OutputType
+    };
+
+    enum Properties {
+        kModifiesDst_Property              = 1,
+        kUsesDstColor_Property             = 1 << 1,
+        kUsesGrPaintColor_Property         = 1 << 2,

[egdaniel, 2015/05/20 14:13:55]

It doesn't necessarily use GrPaint's color, it just uses the color passed to it
which could come from some color processor. Does kUsesInputColor make sense?

[Chris Dalton, 2015/05/20 16:11:22]

Yeah, I like that name better.

[Chris Dalton, 2015/05/21 10:00:47]

Done.

+        kCanTweakAlphaForCoverage_Property = 1 << 3,
+
+        kLast_Property = kCanTweakAlphaForCoverage_Property
+    };
+
+    bool hasSecondaryOutput() const { return kNone_OutputType != fSecondaryOutputType; }
+    bool modifiesDst() const { return fProps & kModifiesDst_Property; }
+    bool usesDstColor() const { return fProps & kUsesDstColor_Property; }
+    bool usesGrPaintColor() const { return fProps & kUsesGrPaintColor_Property; }
+    bool canTweakAlphaForCoverage() const { return fProps & kCanTweakAlphaForCoverage_Property; }
+
+    /**
+     * Deduce the properties of a compile-time constant BlendFormula.
+     */
+    template<OutputType PrimaryOut, OutputType SecondaryOut,
+             GrBlendEquation BlendEquation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
+    struct get_properties : SkTIntegralConstant<Properties, static_cast<Properties>(
+
+        (GR_BLEND_MODIFIES_DST(BlendEquation, SrcCoeff, DstCoeff) ?
+            kModifiesDst_Property : 0) |
+
+        (GR_BLEND_COEFFS_USE_DST_COLOR(SrcCoeff, DstCoeff) ?
+            kUsesDstColor_Property : 0) |
+
+        ((PrimaryOut >= kModulate_OutputType && GR_BLEND_COEFFS_USE_SRC_COLOR(SrcCoeff,DstCoeff)) ||
+         (SecondaryOut >= kModulate_OutputType && GR_BLEND_COEFF_REFS_SRC2(DstCoeff)) ?
+            kUsesGrPaintColor_Property : 0) |  // We assert later that SrcCoeff doesn't ref src2.
+
+        (kModulate_OutputType == PrimaryOut &&
+         kNone_OutputType == SecondaryOut &&
+         GR_BLEND_CAN_TWEAK_ALPHA_FOR_COVERAGE(BlendEquation, SrcCoeff, DstCoeff) ?
+            kCanTweakAlphaForCoverage_Property : 0))> {
+
+        // The provided formula should already be optimized.
+        GR_STATIC_ASSERT((kNone_OutputType == PrimaryOut) ==
+                         !GR_BLEND_COEFFS_USE_SRC_COLOR(SrcCoeff, DstCoeff));
+        GR_STATIC_ASSERT(!GR_BLEND_COEFF_REFS_SRC2(SrcCoeff));
+        GR_STATIC_ASSERT((kNone_OutputType == SecondaryOut) ==
+                         !GR_BLEND_COEFF_REFS_SRC2(DstCoeff));
+        GR_STATIC_ASSERT(PrimaryOut != SecondaryOut || kNone_OutputType == PrimaryOut);
+        GR_STATIC_ASSERT(kNone_OutputType != PrimaryOut || kNone_OutputType == SecondaryOut);
+    };
+
+    OutputType        fPrimaryOutputType    : 3;

[egdaniel, 2015/05/20 14:13:55]

should we have some static assert on the sizes here to make sure we fit.

[Chris Dalton, 2015/05/20 16:11:22]

My reasoning for not including static asserts was that gcc will already issue a
warning if you try to stuff an enum into a bitfield that's too small for it,
which in skia turns into an error. I can't speak for other compilers or the
future of Werror though. Do you think this is sufficient or would you rather
have the static asserts? (I'm kind of on the fence myself..)

[egdaniel, 2015/05/20 18:59:42]

I feel uneasy relying on an arbitrary compiler warning to pick this up. So I'm
leaning towards an Assert but I'm not against being convinced otherwise. 

[Chris Dalton, 2015/05/21 10:00:47]

Done.

+    OutputType        fSecondaryOutputType  : 3;
+    GrBlendEquation   fBlendEquation        : 5;
+    GrBlendCoeff      fSrcCoeff             : 5;
+    GrBlendCoeff      fDstCoeff             : 5;
+    Properties        fProps                : 4;
+};
+
+GR_MAKE_BITFIELD_OPS(BlendFormula::Properties);
+
+/**
+ * Initialize a compile-time constant BlendFormula and automatically deduce fProps.
+ */
+#define INIT_BLEND_FORMULA(PRIMARY_OUT, SECONDARY_OUT, BLEND_EQUATION, SRC_COEFF, DST_COEFF) \
+    {PRIMARY_OUT, \
+     SECONDARY_OUT, \
+     BLEND_EQUATION, SRC_COEFF, DST_COEFF, \
+     BlendFormula::get_properties<PRIMARY_OUT, SECONDARY_OUT, \
+                                  BLEND_EQUATION, SRC_COEFF, DST_COEFF>::value}
+
+/**
+ * When there is no coverage, or the blend mode can tweak alpha for coverage, we use the standard
+ * Porter Duff formula.
+ */
+#define COEFF_FORMULA(SRC_COEFF, DST_COEFF) \
+    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
+                       BlendFormula::kNone_OutputType, \
+                       kAdd_GrBlendEquation, SRC_COEFF, DST_COEFF)
+
+/**
+ * When the coeffs are (Zero, Zero), we clear the dst. This formula has its own macro so we can set
+ * the primary output type to none.
+ *
+ * Xfer modes: clear, dst-out (Sa=1)
+ */
+#define DST_CLEAR_FORMULA \
+    INIT_BLEND_FORMULA(BlendFormula::kNone_OutputType, \
+                       BlendFormula::kNone_OutputType, \
+                       kAdd_GrBlendEquation, kZero_GrBlendCoeff, kZero_GrBlendCoeff)
+
+/**
+ * When the coeffs are (Zero, One), we don't write to the dst at all. This formula has its own macro
+ * so we can set the primary output type to none.
+ *
+ * Xfer modes: dst, dst-in (Sa=1), modulate (Sc=1)
+ */
+#define NO_DST_WRITE_FORMULA \
+    INIT_BLEND_FORMULA(BlendFormula::kNone_OutputType, \
+                       BlendFormula::kNone_OutputType, \
+                       kAdd_GrBlendEquation, kZero_GrBlendCoeff, kOne_GrBlendCoeff)
+
+/**
+ * When there is coverage, the equation with f=coverage is:
+ *
+ *   D' = f * (S * srcCoeff + D * dstCoeff) + (1-f) * D
+ *
+ * This can be rewritten as:
+ *
+ *   D' = f * S * srcCoeff + D * (1 - [f * (1 - dstCoeff)])
+ *
+ * To implement this formula, we output [f * (1 - dstCoeff)] for the secondary color and replace the
+ * HW dst coeff with IS2C.
+ *
+ * Xfer modes: dst-atop (Sa!=1)
+ */
+#define COVERAGE_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, SRC_COEFF) \
+    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
+                       ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, \
+                       kAdd_GrBlendEquation, SRC_COEFF, kIS2C_GrBlendCoeff)
+
+/**
+ * When there is coverage and the src coeff is Zero, the equation with f=coverage becomes:
+ *
+ *   D' = f * D * dstCoeff + (1-f) * D
+ *
+ * This can be rewritten as:
+ *
+ *   D' = D - D * [f * (1 - dstCoeff)]
+ *
+ * To implement this formula, we output [f * (1 - dstCoeff)] for the primary color and use a reverse
+ * subtract HW blend equation with coeffs of (DC, One).
+ *
+ * Xfer modes: clear, dst-in (Sa!=1), modulate (Sc!=1)
+ */
+#define COVERAGE_SRC_COEFF_ZERO_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT) \
+    INIT_BLEND_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, \
+                       BlendFormula::kNone_OutputType, \
+                       kReverseSubtract_GrBlendEquation, kDC_GrBlendCoeff, kOne_GrBlendCoeff)
+
+/**
+ * When there is coverage and the dst coeff is Zero, the equation with f=coverage becomes:
+ *
+ *   D' = f * S * srcCoeff + (1-f) * D
+ *
+ * To implement this formula, we output [f] for the secondary color and replace the HW dst coeff
+ * with IS2A. (Note that we can avoid dual source blending when Sa=1 by using ISA.)
+ *
+ * Xfer modes (Sa!=1): src, src-in, src-out
+ */
+#define COVERAGE_DST_COEFF_ZERO_FORMULA(SRC_COEFF) \
+    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
+                       BlendFormula::kCoverage_OutputType, \
+                       kAdd_GrBlendEquation, SRC_COEFF, kIS2A_GrBlendCoeff)
+
+/**
+ * This table outlines the blend formulas we use with all combinations of color, coverage, and
+ * Xfermode. Optimization flags are deduced at compile so there is no need for run-time analysis.
+ * RGB coverage is not supported. Each entry is 32 bits so the entire table only takes up 360 bytes.
+ */
+static const BlendFormula gBlendTable[3][2][SkXfermode::kLastCoeffMode + 1] = {

[egdaniel, 2015/05/20 14:13:55]

I don't this we are gaining much at all by also branch on solid white color. It
seems like only 3 things change:
modulate & screen when no coverage
modulate when coverage

Screen and modulate are just not common enough to really justify the extra size
on complexity added by solidWhite. Also the philosophical question of why is
solidWhite optimized and not transparent black or other colors.

[Chris Dalton, 2015/05/20 16:11:22]

Right I hear what you're saying. I actually did try having just coverage in the
table, and then adding a runtime optimizer to figure in the colorPOI. It ended
up being more confusing in my mind than just laying it out in a table, not to
mention more lines of code and probably a larger compiled size...

I just had a thought though, we can do the opposite and only have a table for
(xfermode x colorPOI), and then apply coveragePOI at runtime. This will actually
work out really nicely because the coverage formulas are pretty canned, and the
one you use depends only on the coefficients. And since the coeffs will be layed
out in the table ahead of time, we can decide at compile-time which coverage
formula to use. This will also make it easier to add support for RGB coverage.

[egdaniel, 2015/05/20 18:59:42]

So in terms of dealing with coverage here I'm fine with either table or runtime
approach. If you feel like you've got a good way to do it a runtime (that you
like better than table) then go for it.

For color however, I really don't see much benefit in having anything besides
opaque and not opaque. My mentioning earlier of trans black wasn't about we
should really support it (it is so rare out in the wild). Solid white is
basically identical to opaque except for screen and modulate. There are probably
so little use cases of solid white in screen/modulate blend for us to actually
support that optimization.

As for the RGB coverage you mentioned, I would prefer that we just handle all
porter duffer RGB coverage in the PDLCDXferProcessor (maybe should be
PDRGBXferProcessor). The logic needed to handle that in this XP just added extra
complexity to all our normal PD blending. Now if you think that there is a very
clean way of doing all PD blending in on e XP and deleting PDLCD I'm fine with
that as well. But anyways I think any RGB changes should be done in a different
CL :)

[Chris Dalton, 2015/05/21 10:00:47]

Done. I reduced it to just opaque and not. I was also uneasy about including new
tables just to optimize modulate and screen in the solid white case.

+
+                     /*>> No coverage, input color unknown: <<*/ {{

[egdaniel, 2015/05/20 14:13:55]

Would this look any clearer if we reordered the table so that individual modes
were grouped together? So for example you can quickly see how we change src-over
depending on coverage/color.

[Chris Dalton, 2015/05/20 16:11:22]

This is another one of those things I was on the fence about. I can reorder it.

[egdaniel, 2015/05/20 18:59:41]

So IMO it comes down to how many optimization groupings we have (cov, color). If
it ends up being only 2 I say keep as is and group by optimizations. If it >=4 I
think it is clearer to group by xfer mode. If it is 3...well by mode? maybe?

[Chris Dalton, 2015/05/21 10:00:47]

Done.

+
+    /* clear */      DST_CLEAR_FORMULA,
+    /* src */        COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COEFF_FORMULA(   kDA_GrBlendCoeff,     kZero_GrBlendCoeff),
+    /* dst-in */     COEFF_FORMULA(   kZero_GrBlendCoeff,   kSA_GrBlendCoeff),
+    /* src-out */    COEFF_FORMULA(   kIDA_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst-out */    COEFF_FORMULA(   kZero_GrBlendCoeff,   kISA_GrBlendCoeff),
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-atop */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kSA_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   COEFF_FORMULA(   kZero_GrBlendCoeff,   kSC_GrBlendCoeff),
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kISC_GrBlendCoeff),
+
+                     }, /*>> Has coverage, input color unknown: <<*/ {
+
+    /* clear */      COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kCoverage_OutputType),
+    /* src */        COVERAGE_DST_COEFF_ZERO_FORMULA(kOne_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COVERAGE_DST_COEFF_ZERO_FORMULA(kDA_GrBlendCoeff),
+    /* dst-in */     COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kISAModulate_OutputType),
+    /* src-out */    COVERAGE_DST_COEFF_ZERO_FORMULA(kIDA_GrBlendCoeff),
+    /* dst-out */    COEFF_FORMULA(   kZero_GrBlendCoeff,   kISA_GrBlendCoeff),
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-atop */   COVERAGE_FORMULA(BlendFormula::kISAModulate_OutputType, kIDA_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kISCModulate_OutputType),
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kISC_GrBlendCoeff),
+
+                     }}, /*>> No coverage, input color opaque: <<*/ {{
+
+    /* clear */      DST_CLEAR_FORMULA,
+    /* src */        COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COEFF_FORMULA(   kDA_GrBlendCoeff,     kZero_GrBlendCoeff),
+    /* dst-in */     NO_DST_WRITE_FORMULA,
+    /* src-out */    COEFF_FORMULA(   kIDA_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst-out */    DST_CLEAR_FORMULA,
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kZero_GrBlendCoeff),
+    /* dst-atop */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   COEFF_FORMULA(   kZero_GrBlendCoeff,   kSC_GrBlendCoeff),
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kISC_GrBlendCoeff),
+
+                     }, /*>> Has coverage, input color opaque: <<*/ {
+
+    /* clear */      COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kCoverage_OutputType),
+    /* src */        COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-in */     NO_DST_WRITE_FORMULA,
+    /* src-out */    COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-out */    COEFF_FORMULA(   kZero_GrBlendCoeff,   kISA_GrBlendCoeff),
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-atop */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kISCModulate_OutputType),
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kISC_GrBlendCoeff),
+
+                     }}, /*>> No coverage, input solid white: <<*/ {{
+
+    /* clear */      DST_CLEAR_FORMULA,
+    /* src */        COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COEFF_FORMULA(   kDA_GrBlendCoeff,     kZero_GrBlendCoeff),
+    /* dst-in */     NO_DST_WRITE_FORMULA,
+    /* src-out */    COEFF_FORMULA(   kIDA_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* dst-out */    DST_CLEAR_FORMULA,
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kZero_GrBlendCoeff),
+    /* dst-atop */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kZero_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   NO_DST_WRITE_FORMULA,
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kZero_GrBlendCoeff),
+
+                     }, /*>> Has coverage, input solid white: <<*/ {
+
+    /* clear */      COVERAGE_SRC_COEFF_ZERO_FORMULA(BlendFormula::kCoverage_OutputType),
+    /* src */        COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst */        NO_DST_WRITE_FORMULA,
+    /* src-over */   COEFF_FORMULA(   kOne_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-over */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* src-in */     COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-in */     NO_DST_WRITE_FORMULA,
+    /* src-out */    COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* dst-out */    COEFF_FORMULA(   kZero_GrBlendCoeff,   kISA_GrBlendCoeff),
+    /* src-atop */   COEFF_FORMULA(   kDA_GrBlendCoeff,     kISA_GrBlendCoeff),
+    /* dst-atop */   COEFF_FORMULA(   kIDA_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* xor */        COEFF_FORMULA(   kIDA_GrBlendCoeff,    kISA_GrBlendCoeff),
+    /* plus */       COEFF_FORMULA(   kOne_GrBlendCoeff,    kOne_GrBlendCoeff),
+    /* modulate */   NO_DST_WRITE_FORMULA,
+    /* screen */     COEFF_FORMULA(   kOne_GrBlendCoeff,    kISC_GrBlendCoeff),
+}}};
+
+static const BlendFormula& get_blend_formula(const GrProcOptInfo& colorPOI,
+                                             const GrProcOptInfo& coveragePOI,
+                                             SkXfermode::Mode xfermode) {
+    SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
+    SkASSERT(!colorPOI.isSolidWhite() || colorPOI.isOpaque());

[egdaniel, 2015/05/20 14:13:55]

What is this assert trying to check? This will trivial always be true since if
!solidWhite() -> true
solidWhite() -> isOpaque() -> true

[Chris Dalton, 2015/05/20 16:11:22]

Right, this is verifying that we can do "colorPOI.isOpaque() +
colorPOI.isSolidWhite()" to get an index of 2 for the solid white case. Maybe
it's OCD, since the only reason it would fail is if there is a bug elsewhere?

[egdaniel, 2015/05/20 18:59:41]

Ahhh okay I get it.

+    // inputColorTraits: 0 - unknown, 1 - opaque, 2 - solid white.
+    int inputColorTraits = colorPOI.isOpaque() + colorPOI.isSolidWhite();
+    bool hasCoverage = !coveragePOI.isSolidWhite();
+    return gBlendTable[inputColorTraits][hasCoverage][xfermode];
 }
 
+GR_STATIC_ASSERT(0 == SkXfermode::kClear_Mode);
+GR_STATIC_ASSERT(1 == SkXfermode::kSrc_Mode);
+GR_STATIC_ASSERT(2 == SkXfermode::kDst_Mode);
+GR_STATIC_ASSERT(3 == SkXfermode::kSrcOver_Mode);
+GR_STATIC_ASSERT(4 == SkXfermode::kDstOver_Mode);
+GR_STATIC_ASSERT(5 == SkXfermode::kSrcIn_Mode);
+GR_STATIC_ASSERT(6 == SkXfermode::kDstIn_Mode);
+GR_STATIC_ASSERT(7 == SkXfermode::kSrcOut_Mode);
+GR_STATIC_ASSERT(8 == SkXfermode::kDstOut_Mode);
+GR_STATIC_ASSERT(9 == SkXfermode::kSrcATop_Mode);
+GR_STATIC_ASSERT(10 == SkXfermode::kDstATop_Mode);
+GR_STATIC_ASSERT(11 == SkXfermode::kXor_Mode);
+GR_STATIC_ASSERT(12 == SkXfermode::kPlus_Mode);
+GR_STATIC_ASSERT(13 == SkXfermode::kModulate_Mode);
+GR_STATIC_ASSERT(14 == SkXfermode::kScreen_Mode);
+GR_STATIC_ASSERT(15 * 2 * 3 * sizeof(BlendFormula) == sizeof(gBlendTable));
+
+///////////////////////////////////////////////////////////////////////////////
+
 class PorterDuffXferProcessor : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend,
-                                   GrColor constant, const GrDeviceCoordTexture* dstCopy,
+    static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrDeviceCoordTexture* dstCopy,
                                    bool willReadDstColor) {
-        return SkNEW_ARGS(PorterDuffXferProcessor, (srcBlend, dstBlend, constant, dstCopy,
-                                                    willReadDstColor));
+        return SkNEW_ARGS(PorterDuffXferProcessor, (xfermode, dstCopy, willReadDstColor));
     }
 
     ~PorterDuffXferProcessor() override;
 
     const char* name() const override { return "Porter Duff"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
-    bool hasSecondaryOutput() const override;
+    bool hasSecondaryOutput() const override {
+        return fBlendFormula && fBlendFormula->hasSecondaryOutput();
+    }
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Stage Output Types
-    ////
-
-    enum PrimaryOutputType {
-        kNone_PrimaryOutputType,
-        kColor_PrimaryOutputType,
-        kCoverage_PrimaryOutputType,
-        // Modulate color and coverage, write result as the color output.
-        kModulate_PrimaryOutputType,
-        // Custom Porter-Duff output, used for when we explictly are reading the dst and blending
-        // in the shader. Secondary Output must be none if you use this. The custom blend uses the
-        // equation: cov * (coeffS * S + coeffD * D) + (1 - cov) * D
-        kCustom_PrimaryOutputType
-    };
-
-    enum SecondaryOutputType {
-        // There is no secondary output
-        kNone_SecondaryOutputType,
-        // Writes coverage as the secondary output. Only set if dual source blending is supported
-        // and primary output is kModulate.
-        kCoverage_SecondaryOutputType,
-        // Writes coverage * (1 - colorA) as the secondary output. Only set if dual source blending
-        // is supported and primary output is kModulate.
-        kCoverageISA_SecondaryOutputType,
-        // Writes coverage * (1 - colorRGBA) as the secondary output. Only set if dual source
-        // blending is supported and primary output is kModulate.
-        kCoverageISC_SecondaryOutputType,
-
-        kSecondaryOutputTypeCnt,
-    };
-
-    PrimaryOutputType primaryOutputType() const { return fPrimaryOutputType; }
-    SecondaryOutputType secondaryOutputType() const { return fSecondaryOutputType; }
-
-    GrBlendCoeff getSrcBlend() const { return fSrcBlend; }
-    GrBlendCoeff getDstBlend() const { return fDstBlend; }
+    SkXfermode::Mode getXfermode() const { return fXfermode; }
+    const BlendFormula* getBlendFormula() const { return fBlendFormula; }
 
 private:
-    PorterDuffXferProcessor(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend, GrColor constant,
-                            const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
+    PorterDuffXferProcessor(SkXfermode::Mode, const GrDeviceCoordTexture* dstCopy,
+                            bool willReadDstColor);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
                                                  const GrDrawTargetCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
-        if (!this->willReadDstColor()) {
-            blendInfo->fSrcBlend = fSrcBlend;
-            blendInfo->fDstBlend = fDstBlend;
-        } else {
-            blendInfo->fSrcBlend = kOne_GrBlendCoeff;
-            blendInfo->fDstBlend = kZero_GrBlendCoeff;
+        if (fBlendFormula) {
+            blendInfo->fEquation = fBlendFormula->fBlendEquation;
+            blendInfo->fSrcBlend = fBlendFormula->fSrcCoeff;
+            blendInfo->fDstBlend = fBlendFormula->fDstCoeff;
+            blendInfo->fWriteColor = fBlendFormula->modifiesDst();
         }
-        blendInfo->fBlendConstant = fBlendConstant;
     }
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
         const PorterDuffXferProcessor& xp = xpBase.cast<PorterDuffXferProcessor>();
-        if (fSrcBlend != xp.fSrcBlend ||
-            fDstBlend != xp.fDstBlend ||
-            fBlendConstant != xp.fBlendConstant ||
-            fPrimaryOutputType != xp.fPrimaryOutputType || 
-            fSecondaryOutputType != xp.fSecondaryOutputType) {
-            return false;
-        }
-        return true;
+        return fXfermode == xp.fXfermode &&
+               fBlendFormula == xp.fBlendFormula;
     }
 
-    GrXferProcessor::OptFlags internalGetOptimizations(const GrProcOptInfo& colorPOI,
-                                                       const GrProcOptInfo& coveragePOI,
-                                                       bool doesStencilWrite);
-
-    void calcOutputTypes(GrXferProcessor::OptFlags blendOpts, const GrDrawTargetCaps& caps,
-                         bool hasSolidCoverage);
-
-    GrBlendCoeff fSrcBlend;
-    GrBlendCoeff fDstBlend;
-    GrColor      fBlendConstant;
-    PrimaryOutputType fPrimaryOutputType;
-    SecondaryOutputType fSecondaryOutputType;
+    SkXfermode::Mode    fXfermode;
+    const BlendFormula* fBlendFormula;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool append_porterduff_term(GrGLXPFragmentBuilder* fsBuilder, GrBlendCoeff coeff,
+void append_color_output(const PorterDuffXferProcessor& xp, GrGLXPFragmentBuilder* fsBuilder,
+                         BlendFormula::OutputType outputType, const char* output,
+                         const char* inColor, const char* inCoverage) {
+    switch (outputType) {
+        case BlendFormula::kNone_OutputType:
+            fsBuilder->codeAppendf("%s = vec4(0.0);", output);
+            break;
+        case BlendFormula::kCoverage_OutputType:
+            fsBuilder->codeAppendf("%s = %s;",
+                                   output, xp.readsCoverage() ? inCoverage : "vec4(1.0)");

[egdaniel, 2015/05/20 14:13:55]

can we even get into this state? how can we be setting that the xp will not read
coverage, but at the same time setting a coverage equation?

[Chris Dalton, 2015/05/20 16:11:22]

Mixed samples :)

(My motivation for this patch was actually to get Porter Duff ready for mixed
samples)

Shader outputs 1.0, which then gets modulated by HW-computed coverage in the ROP
before it reaches the blend hardware.

[egdaniel, 2015/05/20 18:59:41]

interesting

+            break;
+        case BlendFormula::kModulate_OutputType:
+            if (xp.readsCoverage()) {
+                fsBuilder->codeAppendf("%s = %s * %s;", output, inColor, inCoverage);
+            } else {
+                fsBuilder->codeAppendf("%s = %s;", output, inColor);
+            }
+            break;
+        case BlendFormula::kISAModulate_OutputType:
+            if (xp.readsCoverage()) {
+                fsBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage);
+            } else {
+                fsBuilder->codeAppendf("%s = vec4(1.0 - %s.a);", output, inColor);
+            }
+            break;
+        case BlendFormula::kISCModulate_OutputType:
+            if (xp.readsCoverage()) {
+                fsBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;", output, inColor, inCoverage);
+            } else {
+                fsBuilder->codeAppendf("%s = vec4(1.0) - %s;", output, inColor);
+            }
+            break;
+        default:
+            SkFAIL("Unsupported output type.");
+            break;
+    }
+}
+
+bool append_porterduff_term(GrGLXPFragmentBuilder* fsBuilder, SkXfermode::Coeff coeff,
                             const char* colorName, const char* srcColorName,
                             const char* dstColorName, bool hasPrevious) {
-    if (kZero_GrBlendCoeff == coeff) {
+    if (SkXfermode::kZero_Coeff == coeff) {
         return hasPrevious;
     } else {
         if (hasPrevious) {
             fsBuilder->codeAppend(" + ");
         }
         fsBuilder->codeAppendf("%s", colorName);
         switch (coeff) {
-            case kOne_GrBlendCoeff:
+            case SkXfermode::kOne_Coeff:
                 break;
-            case kSC_GrBlendCoeff:
+            case SkXfermode::kSC_Coeff:
                 fsBuilder->codeAppendf(" * %s", srcColorName); 
                 break;
-            case kISC_GrBlendCoeff:
+            case SkXfermode::kISC_Coeff:
                 fsBuilder->codeAppendf(" * (vec4(1.0) - %s)", srcColorName); 
                 break;
-            case kDC_GrBlendCoeff:
+            case SkXfermode::kDC_Coeff:
                 fsBuilder->codeAppendf(" * %s", dstColorName); 
                 break;
-            case kIDC_GrBlendCoeff:
+            case SkXfermode::kIDC_Coeff:
                 fsBuilder->codeAppendf(" * (vec4(1.0) - %s)", dstColorName); 
                 break;
-            case kSA_GrBlendCoeff:
+            case SkXfermode::kSA_Coeff:
                 fsBuilder->codeAppendf(" * %s.a", srcColorName); 
                 break;
-            case kISA_GrBlendCoeff:
+            case SkXfermode::kISA_Coeff:
                 fsBuilder->codeAppendf(" * (1.0 - %s.a)", srcColorName); 
                 break;
-            case kDA_GrBlendCoeff:
+            case SkXfermode::kDA_Coeff:
                 fsBuilder->codeAppendf(" * %s.a", dstColorName); 
                 break;
-            case kIDA_GrBlendCoeff:
+            case SkXfermode::kIDA_Coeff:
                 fsBuilder->codeAppendf(" * (1.0 - %s.a)", dstColorName); 
                 break;
             default:
                 SkFAIL("Unsupported Blend Coeff");
         }
         return true;
     }
 }
 
 class GLPorterDuffXferProcessor : public GrGLXferProcessor {
 public:
     GLPorterDuffXferProcessor(const GrProcessor&) {}
 
     virtual ~GLPorterDuffXferProcessor() {}
 
     static void GenKey(const GrProcessor& processor, const GrGLSLCaps& caps,
                        GrProcessorKeyBuilder* b) {
         const PorterDuffXferProcessor& xp = processor.cast<PorterDuffXferProcessor>();
-        b->add32(xp.primaryOutputType());
-        b->add32(xp.secondaryOutputType());
-        if (xp.willReadDstColor()) {
-            b->add32(xp.getSrcBlend());
-            b->add32(xp.getDstBlend());
+        uint32_t key = xp.willReadDstColor();
+        if (key) {
+            SkASSERT(!xp.getBlendFormula());
+            key |= xp.getXfermode() << 1;
+        } else {
+            const BlendFormula* blendFormula = xp.getBlendFormula();
+            SkASSERT(blendFormula);
+            GR_STATIC_ASSERT(BlendFormula::kLast_OutputType < 8);
+            key |= xp.readsCoverage() << 1;
+            key |= blendFormula->fSecondaryOutputType << 2;
+            key |= blendFormula->fPrimaryOutputType << 5;

[egdaniel, 2015/05/20 14:13:55]

add some assert on max value of Output type?

[Chris Dalton, 2015/05/20 16:11:22]

I think this already has what you are asking for? (line 489)

 GR_STATIC_ASSERT(BlendFormula::kLast_OutputType < 8);

I'll move it to this location in the code, I think that makes more sense.

[egdaniel, 2015/05/20 18:59:42]

oh yeah, woops

[Chris Dalton, 2015/05/21 10:00:48]

Done.

         }
+        b->add32(key);
     };
 
 private:
     void onEmitCode(const EmitArgs& args) override {
         const PorterDuffXferProcessor& xp = args.fXP.cast<PorterDuffXferProcessor>();
         GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
-        if (PorterDuffXferProcessor::kCustom_PrimaryOutputType != xp.primaryOutputType()) {
+        if (const BlendFormula* blendFormula = xp.getBlendFormula()) {
             SkASSERT(!xp.willReadDstColor());
-            switch(xp.secondaryOutputType()) {
-                case PorterDuffXferProcessor::kNone_SecondaryOutputType:
-                    break;
-                case PorterDuffXferProcessor::kCoverage_SecondaryOutputType:
-                    fsBuilder->codeAppendf("%s = %s;", args.fOutputSecondary,
-                                           args.fInputCoverage);
-                    break;
-                case PorterDuffXferProcessor::kCoverageISA_SecondaryOutputType:
-                    fsBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;",
-                                           args.fOutputSecondary, args.fInputColor,
-                                           args.fInputCoverage);
-                    break;
-                case PorterDuffXferProcessor::kCoverageISC_SecondaryOutputType:
-                    fsBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;",
-                                           args.fOutputSecondary, args.fInputColor,
-                                           args.fInputCoverage);
-                    break;
-                default:
-                    SkFAIL("Unexpected Secondary Output");
+            if (blendFormula->hasSecondaryOutput()) {
+                append_color_output(xp, fsBuilder, blendFormula->fSecondaryOutputType,
+                                    args.fOutputSecondary, args.fInputColor, args.fInputCoverage);
             }
-
-            switch (xp.primaryOutputType()) {
-                case PorterDuffXferProcessor::kNone_PrimaryOutputType:
-                    fsBuilder->codeAppendf("%s = vec4(0);", args.fOutputPrimary);
-                    break;
-                case PorterDuffXferProcessor::kColor_PrimaryOutputType:
-                    fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
-                    break;
-                case PorterDuffXferProcessor::kCoverage_PrimaryOutputType:
-                    fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
-                    break;
-                case PorterDuffXferProcessor::kModulate_PrimaryOutputType:
-                    fsBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
-                                           args.fInputCoverage);
-                    break;
-                default:
-                    SkFAIL("Unexpected Primary Output");
-            }
+            append_color_output(xp, fsBuilder, blendFormula->fPrimaryOutputType,
+                                args.fOutputPrimary, args.fInputColor, args.fInputCoverage);
         } else {
             SkASSERT(xp.willReadDstColor());
 
+            SkXfermode::Coeff srcCoeff, dstCoeff;
+            SkXfermode::ModeAsCoeff(xp.getXfermode(), &srcCoeff, &dstCoeff);
+
             const char* dstColor = fsBuilder->dstColor();
 
             fsBuilder->codeAppend("vec4 colorBlend =");
             // append src blend
-            bool didAppend = append_porterduff_term(fsBuilder, xp.getSrcBlend(),
+            bool didAppend = append_porterduff_term(fsBuilder, srcCoeff,
                                                     args.fInputColor, args.fInputColor,
                                                     dstColor, false);
             // append dst blend
-            SkAssertResult(append_porterduff_term(fsBuilder, xp.getDstBlend(),
+            SkAssertResult(append_porterduff_term(fsBuilder, dstCoeff,
                                                   dstColor, args.fInputColor,
                                                   dstColor, didAppend));
             fsBuilder->codeAppend(";");
 
             fsBuilder->codeAppendf("%s = %s * colorBlend + (vec4(1.0) - %s) * %s;",
                                    args.fOutputPrimary, args.fInputCoverage, args.fInputCoverage,
                                    dstColor);
         }
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {};
 
     typedef GrGLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-PorterDuffXferProcessor::PorterDuffXferProcessor(GrBlendCoeff srcBlend,
-                                                 GrBlendCoeff dstBlend,
-                                                 GrColor constant,
+PorterDuffXferProcessor::PorterDuffXferProcessor(SkXfermode::Mode xfermode,
                                                  const GrDeviceCoordTexture* dstCopy,
                                                  bool willReadDstColor)
     : INHERITED(dstCopy, willReadDstColor)
-    , fSrcBlend(srcBlend)
-    , fDstBlend(dstBlend)
-    , fBlendConstant(constant)
-    , fPrimaryOutputType(kModulate_PrimaryOutputType) 
-    , fSecondaryOutputType(kNone_SecondaryOutputType) {
+    , fXfermode(xfermode)
+    , fBlendFormula(NULL) {
     this->initClassID<PorterDuffXferProcessor>();
 }
 
 PorterDuffXferProcessor::~PorterDuffXferProcessor() {
 }
 
 void PorterDuffXferProcessor::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                   GrProcessorKeyBuilder* b) const {
     GLPorterDuffXferProcessor::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* PorterDuffXferProcessor::createGLInstance() const {
     return SkNEW_ARGS(GLPorterDuffXferProcessor, (*this));
 }
 
 GrXferProcessor::OptFlags
 PorterDuffXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
                                             const GrDrawTargetCaps& caps) {
-    GrXferProcessor::OptFlags optFlags = this->internalGetOptimizations(colorPOI,
-                                                                        coveragePOI,
-                                                                        doesStencilWrite);
-    this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite());
-    return optFlags;
-}
-
-void PorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
-                                              const GrDrawTargetCaps& caps,
-                                              bool hasSolidCoverage) {
-    if (this->willReadDstColor()) {
-        fPrimaryOutputType = kCustom_PrimaryOutputType;
-        return;
-    }
-
-    if (optFlags & kIgnoreColor_OptFlag) {
-        if (optFlags & kIgnoreCoverage_OptFlag) {
-            fPrimaryOutputType = kNone_PrimaryOutputType;
-            return;
-        } else {
-            fPrimaryOutputType = kCoverage_PrimaryOutputType;
-            return;
-        }
-    } else if (optFlags & kIgnoreCoverage_OptFlag) {
-        fPrimaryOutputType = kColor_PrimaryOutputType;
-        return;
-    }
-
-    // If we do have coverage determine whether it matters.  Dual source blending is expensive so
-    // we don't do it if we are doing coverage drawing.  If we aren't then We always do dual source
-    // blending if we have any effective coverage stages OR the geometry processor doesn't emits
-    // solid coverage.
-    if (!(optFlags & kSetCoverageDrawing_OptFlag) && !hasSolidCoverage) {
-        if (caps.shaderCaps()->dualSourceBlendingSupport()) {
-            if (kZero_GrBlendCoeff == fDstBlend) {
-                // write the coverage value to second color
-                fSecondaryOutputType = kCoverage_SecondaryOutputType;
-                fDstBlend = kIS2C_GrBlendCoeff;
-            } else if (kSA_GrBlendCoeff == fDstBlend) {
-                // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
-                fSecondaryOutputType = kCoverageISA_SecondaryOutputType;
-                fDstBlend = kIS2C_GrBlendCoeff;
-            } else if (kSC_GrBlendCoeff == fDstBlend) {
-                // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
-                fSecondaryOutputType = kCoverageISC_SecondaryOutputType;
-                fDstBlend = kIS2C_GrBlendCoeff;
-            }
-        }
-    }
-}
-
-GrXferProcessor::OptFlags
-PorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
-                                                  const GrProcOptInfo& coveragePOI,
-                                                  bool doesStencilWrite) {
     if (this->willReadDstColor()) {
         return GrXferProcessor::kNone_Opt;
     }
 
-    bool srcAIsOne = colorPOI.isOpaque();
-    bool hasCoverage = !coveragePOI.isSolidWhite();
+    fBlendFormula = &get_blend_formula(colorPOI, coveragePOI, fXfermode);
 
-    bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstBlend ||
-                         (kSA_GrBlendCoeff == fDstBlend && srcAIsOne);
-    bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstBlend ||
-                         (kISA_GrBlendCoeff == fDstBlend && srcAIsOne);
-
-    // When coeffs are (0,1) there is no reason to draw at all, unless
-    // stenciling is enabled. Having color writes disabled is effectively
-    // (0,1).
-    if ((kZero_GrBlendCoeff == fSrcBlend && dstCoeffIsOne)) {
-        if (doesStencilWrite) {
-            return GrXferProcessor::kIgnoreColor_OptFlag |
-                   GrXferProcessor::kSetCoverageDrawing_OptFlag;
-        } else {
-            fDstBlend = kOne_GrBlendCoeff;
-            return GrXferProcessor::kSkipDraw_OptFlag;
+    GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_Opt;
+    if (!fBlendFormula->modifiesDst()) {
+        if (!doesStencilWrite) {
+            optFlags |= GrXferProcessor::kSkipDraw_OptFlag;
+        }
+        optFlags |= (GrXferProcessor::kIgnoreColor_OptFlag |
+                     GrXferProcessor::kIgnoreCoverage_OptFlag |
+                     GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag);
+    } else {
+        if (!fBlendFormula->usesGrPaintColor()) {
+            optFlags |= GrXferProcessor::kIgnoreColor_OptFlag;
+        }
+        if (coveragePOI.isSolidWhite()) {
+            optFlags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
+        }
+        if (colorPOI.allStagesMultiplyInput() && fBlendFormula->canTweakAlphaForCoverage()) {
+            optFlags |= GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
         }
     }
 
-    // if we don't have coverage we can check whether the dst
-    // has to read at all. If not, we'll disable blending.
-    if (!hasCoverage) {
-        if (dstCoeffIsZero) {
-            if (kOne_GrBlendCoeff == fSrcBlend) {
-                // if there is no coverage and coeffs are (1,0) then we
-                // won't need to read the dst at all, it gets replaced by src
-                fDstBlend = kZero_GrBlendCoeff;
-                return GrXferProcessor::kNone_Opt |
-                       GrXferProcessor::kIgnoreCoverage_OptFlag;
-            } else if (kZero_GrBlendCoeff == fSrcBlend) {
-                // if the op is "clear" then we don't need to emit a color
-                // or blend, just write transparent black into the dst.
-                fSrcBlend = kOne_GrBlendCoeff;
-                fDstBlend = kZero_GrBlendCoeff;
-                return GrXferProcessor::kIgnoreColor_OptFlag |
-                       GrXferProcessor::kIgnoreCoverage_OptFlag;
-            }
-        }
-        return GrXferProcessor::kIgnoreCoverage_OptFlag;
-    }
-
-    // check whether coverage can be safely rolled into alpha
-    // of if we can skip color computation and just emit coverage
-    if (can_tweak_alpha_for_coverage(fDstBlend)) {
-        if (colorPOI.allStagesMultiplyInput()) {
-            return GrXferProcessor::kSetCoverageDrawing_OptFlag |
-                GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
-        } else {
-            return GrXferProcessor::kSetCoverageDrawing_OptFlag;
-
-        }
-    }
-    if (dstCoeffIsZero) {
-        if (kZero_GrBlendCoeff == fSrcBlend) {
-            // the source color is not included in the blend
-            // the dst coeff is effectively zero so blend works out to:
-            // (c)(0)D + (1-c)D = (1-c)D.
-            fDstBlend = kISA_GrBlendCoeff;
-            return GrXferProcessor::kIgnoreColor_OptFlag |
-                GrXferProcessor::kSetCoverageDrawing_OptFlag;
-        } else if (srcAIsOne) {
-            // the dst coeff is effectively zero so blend works out to:
-            // cS + (c)(0)D + (1-c)D = cS + (1-c)D.
-            // If Sa is 1 then we can replace Sa with c
-            // and set dst coeff to 1-Sa.
-            fDstBlend = kISA_GrBlendCoeff;
-            if (colorPOI.allStagesMultiplyInput()) {
-                return GrXferProcessor::kSetCoverageDrawing_OptFlag |
-                    GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
-            } else {
-                return GrXferProcessor::kSetCoverageDrawing_OptFlag;
-
-            }
-        }
-    } else if (dstCoeffIsOne) {
-        // the dst coeff is effectively one so blend works out to:
-        // cS + (c)(1)D + (1-c)D = cS + D.
-        fDstBlend = kOne_GrBlendCoeff;
-        if (colorPOI.allStagesMultiplyInput()) {
-            return GrXferProcessor::kSetCoverageDrawing_OptFlag |
-                GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
-        } else {
-            return GrXferProcessor::kSetCoverageDrawing_OptFlag;
-
-        }
-        return GrXferProcessor::kSetCoverageDrawing_OptFlag;
-    }
-
-    return GrXferProcessor::kNone_Opt;
-}
-
-bool PorterDuffXferProcessor::hasSecondaryOutput() const {
-    return kNone_SecondaryOutputType != fSecondaryOutputType;
+    return optFlags;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class PDLCDXferProcessor : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend,
-                                   const GrProcOptInfo& colorPOI);
+    static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI);
 
     ~PDLCDXferProcessor() override;
 
     const char* name() const override { return "Porter Duff LCD"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     bool hasSecondaryOutput() const override { return false; }
 
 private:
@@ skipping 53 matching lines @@
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha)
     : fBlendConstant(blendConstant)
     , fAlpha(alpha) {
     this->initClassID<PDLCDXferProcessor>();
 }
 
-GrXferProcessor* PDLCDXferProcessor::Create(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend,
+GrXferProcessor* PDLCDXferProcessor::Create(SkXfermode::Mode xfermode,
                                             const GrProcOptInfo& colorPOI) {
-    if (kOne_GrBlendCoeff != srcBlend || kISA_GrBlendCoeff != dstBlend) {
+    if (SkXfermode::kSrcOver_Mode != xfermode) {
         return NULL;
     }
 
     if (kRGBA_GrColorComponentFlags != colorPOI.validFlags()) {
         return NULL;
     }
 
     GrColor blendConstant = GrUnPreMulColor(colorPOI.color());
     uint8_t alpha = GrColorUnpackA(blendConstant);
     blendConstant |= (0xff << GrColor_SHIFT_A);
@@ skipping 21 matching lines @@
                                        const GrDrawTargetCaps& caps) {
         // We want to force our primary output to be alpha * Coverage, where alpha is the alpha
         // value of the blend the constant. We should already have valid blend coeff's if we are at
         // a point where we have RGB coverage. We don't need any color stages since the known color
         // output is already baked into the blendConstant.
         *overrideColor = GrColorPackRGBA(fAlpha, fAlpha, fAlpha, fAlpha);
         return GrXferProcessor::kOverrideColor_OptFlag;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-GrPorterDuffXPFactory::GrPorterDuffXPFactory(GrBlendCoeff src, GrBlendCoeff dst)
-    : fSrcCoeff(src), fDstCoeff(dst) {
+
+GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode)
+    : fXfermode(xfermode) {
     this->initClassID<GrPorterDuffXPFactory>();
 }
 
-GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode mode) {
-    switch (mode) {
-        case SkXfermode::kClear_Mode: {
-            static GrPorterDuffXPFactory gClearPDXPF(kZero_GrBlendCoeff, kZero_GrBlendCoeff);
-            return SkRef(&gClearPDXPF);
-            break;
-        }
-        case SkXfermode::kSrc_Mode: {
-            static GrPorterDuffXPFactory gSrcPDXPF(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
-            return SkRef(&gSrcPDXPF);
-            break;
-        }
-        case SkXfermode::kDst_Mode: {
-            static GrPorterDuffXPFactory gDstPDXPF(kZero_GrBlendCoeff, kOne_GrBlendCoeff);
-            return SkRef(&gDstPDXPF);
-            break;
-        }
-        case SkXfermode::kSrcOver_Mode: {
-            static GrPorterDuffXPFactory gSrcOverPDXPF(kOne_GrBlendCoeff, kISA_GrBlendCoeff);
-            return SkRef(&gSrcOverPDXPF);
-            break;
-        }
-        case SkXfermode::kDstOver_Mode: {
-            static GrPorterDuffXPFactory gDstOverPDXPF(kIDA_GrBlendCoeff, kOne_GrBlendCoeff);
-            return SkRef(&gDstOverPDXPF);
-            break;
-        }
-        case SkXfermode::kSrcIn_Mode: {
-            static GrPorterDuffXPFactory gSrcInPDXPF(kDA_GrBlendCoeff, kZero_GrBlendCoeff);
-            return SkRef(&gSrcInPDXPF);
-            break;
-        }
-        case SkXfermode::kDstIn_Mode: {
-            static GrPorterDuffXPFactory gDstInPDXPF(kZero_GrBlendCoeff, kSA_GrBlendCoeff);
-            return SkRef(&gDstInPDXPF);
-            break;
-        }
-        case SkXfermode::kSrcOut_Mode: {
-            static GrPorterDuffXPFactory gSrcOutPDXPF(kIDA_GrBlendCoeff, kZero_GrBlendCoeff);
-            return SkRef(&gSrcOutPDXPF);
-            break;
-        }
-        case SkXfermode::kDstOut_Mode: {
-            static GrPorterDuffXPFactory gDstOutPDXPF(kZero_GrBlendCoeff, kISA_GrBlendCoeff);
-            return SkRef(&gDstOutPDXPF);
-            break;
-        }
-        case SkXfermode::kSrcATop_Mode: {
-            static GrPorterDuffXPFactory gSrcATopPDXPF(kDA_GrBlendCoeff, kISA_GrBlendCoeff);
-            return SkRef(&gSrcATopPDXPF);
-            break;
-        }
-        case SkXfermode::kDstATop_Mode: {
-            static GrPorterDuffXPFactory gDstATopPDXPF(kIDA_GrBlendCoeff, kSA_GrBlendCoeff);
-            return SkRef(&gDstATopPDXPF);
-            break;
-        }
-        case SkXfermode::kXor_Mode: {
-            static GrPorterDuffXPFactory gXorPDXPF(kIDA_GrBlendCoeff, kISA_GrBlendCoeff);
-            return SkRef(&gXorPDXPF);
-            break;
-        }
-        case SkXfermode::kPlus_Mode: {
-            static GrPorterDuffXPFactory gPlusPDXPF(kOne_GrBlendCoeff, kOne_GrBlendCoeff);
-            return SkRef(&gPlusPDXPF);
-            break;
-        }
-        case SkXfermode::kModulate_Mode: {
-            static GrPorterDuffXPFactory gModulatePDXPF(kZero_GrBlendCoeff, kSC_GrBlendCoeff);
-            return SkRef(&gModulatePDXPF);
-            break;
-        }
-        case SkXfermode::kScreen_Mode: {
-            static GrPorterDuffXPFactory gScreenPDXPF(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
-            return SkRef(&gScreenPDXPF);
-            break;
-        }
-        default:
-            return NULL;
+GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode xfermode) {
+    static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
+    static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
+    static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
+    static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
+    static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
+    static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
+    static GrPorterDuffXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode);
+    static GrPorterDuffXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode);
+    static GrPorterDuffXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode);
+    static GrPorterDuffXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode);
+    static GrPorterDuffXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode);
+    static GrPorterDuffXPFactory gXorPDXPF(SkXfermode::kXor_Mode);
+    static GrPorterDuffXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode);
+    static GrPorterDuffXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode);
+    static GrPorterDuffXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode);
+
+    static GrPorterDuffXPFactory* gFactories[] = {
+        &gClearPDXPF, &gSrcPDXPF, &gDstPDXPF, &gSrcOverPDXPF, &gDstOverPDXPF, &gSrcInPDXPF,
+        &gDstInPDXPF, &gSrcOutPDXPF, &gDstOutPDXPF, &gSrcATopPDXPF, &gDstATopPDXPF, &gXorPDXPF,
+        &gPlusPDXPF, &gModulatePDXPF, &gScreenPDXPF
+    };
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == SkXfermode::kLastCoeffMode + 1);
+
+    if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) {
+        return NULL;
     }
+    return SkRef(gFactories[xfermode]);
 }
 
 GrXferProcessor*
 GrPorterDuffXPFactory::onCreateXferProcessor(const GrDrawTargetCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& covPOI,
                                              const GrDeviceCoordTexture* dstCopy) const {
     if (covPOI.isFourChannelOutput()) {
-        return PDLCDXferProcessor::Create(fSrcCoeff, fDstCoeff, colorPOI);
+        return PDLCDXferProcessor::Create(fXfermode, colorPOI);
     } else {
-        return PorterDuffXferProcessor::Create(fSrcCoeff, fDstCoeff, 0, dstCopy,
+        return PorterDuffXferProcessor::Create(fXfermode, dstCopy,
                                                this->willReadDstColor(caps, colorPOI, covPOI));
     }
 }
 
 bool GrPorterDuffXPFactory::supportsRGBCoverage(GrColor /*knownColor*/,
                                                 uint32_t knownColorFlags) const {
-    if (kOne_GrBlendCoeff == fSrcCoeff && kISA_GrBlendCoeff == fDstCoeff &&
+    if (SkXfermode::kSrcOver_Mode == fXfermode &&
         kRGBA_GrColorComponentFlags == knownColorFlags) {
         return true;
     }
     return false;
 }
 
 void GrPorterDuffXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                GrXPFactory::InvariantOutput* output) const {
-    if (!coveragePOI.isSolidWhite()) {
+    const BlendFormula& blendFormula = get_blend_formula(colorPOI, coveragePOI, fXfermode);
+
+    if (blendFormula.usesDstColor()) {
         output->fWillBlendWithDst = true;
         output->fBlendedColorFlags = 0;
         return;
     }
 
-    GrBlendCoeff srcCoeff = fSrcCoeff;
-    GrBlendCoeff dstCoeff = fDstCoeff;
+    SkASSERT(coveragePOI.isSolidWhite());
+    SkASSERT(kAdd_GrBlendEquation == blendFormula.fBlendEquation);
 
-    // TODO: figure out to merge this simplify with other current optimization code paths and
-    // eventually remove from GrBlend
-    GrSimplifyBlend(&srcCoeff, &dstCoeff, colorPOI.color(), colorPOI.validFlags(),
-                    0, 0, 0);
+    output->fWillBlendWithDst = false;
 
-    if (GrBlendCoeffRefsDst(srcCoeff)) {
-        output->fWillBlendWithDst = true;
-        output->fBlendedColorFlags = 0;
-        return;
-    }
-
-    if (kZero_GrBlendCoeff != dstCoeff) {
-        bool srcAIsOne = colorPOI.isOpaque();
-        if (kISA_GrBlendCoeff != dstCoeff || !srcAIsOne) {
-            output->fWillBlendWithDst = true;
-        }
-        output->fBlendedColorFlags = 0;
-        return;
-    }
-
-    switch (srcCoeff) {
+    switch (blendFormula.fSrcCoeff) {
         case kZero_GrBlendCoeff:
             output->fBlendedColor = 0;
             output->fBlendedColorFlags = kRGBA_GrColorComponentFlags;
-            break;
+            return;
 
         case kOne_GrBlendCoeff:
             output->fBlendedColor = colorPOI.color();
             output->fBlendedColorFlags = colorPOI.validFlags();
-            break;
+            return;
 
-            // The src coeff should never refer to the src and if it refers to dst then opaque
-            // should have been false.
-        case kSC_GrBlendCoeff:
-        case kISC_GrBlendCoeff:
-        case kDC_GrBlendCoeff:
-        case kIDC_GrBlendCoeff:
-        case kSA_GrBlendCoeff:
-        case kISA_GrBlendCoeff:
-        case kDA_GrBlendCoeff:
-        case kIDA_GrBlendCoeff:
+        // TODO: update if we ever use const color.
         default:
-            SkFAIL("srcCoeff should not refer to src or dst.");
-            break;
-
-            // TODO: update this once GrPaint actually has a const color.
-        case kConstC_GrBlendCoeff:
-        case kIConstC_GrBlendCoeff:
-        case kConstA_GrBlendCoeff:
-        case kIConstA_GrBlendCoeff:
             output->fBlendedColorFlags = 0;
-            break;
+            return;
     }
-
-    output->fWillBlendWithDst = false;
 }
 
 bool GrPorterDuffXPFactory::willReadDstColor(const GrDrawTargetCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI) const {
-    // We can always blend correctly if we have dual source blending.
-    if (caps.shaderCaps()->dualSourceBlendingSupport()) {
-        return false;
-    }
-
-    if (can_tweak_alpha_for_coverage(fDstCoeff)) {
-        return false;
-    }
-
-    bool srcAIsOne = colorPOI.isOpaque();
-
-    if (kZero_GrBlendCoeff == fDstCoeff) {
-        if (kZero_GrBlendCoeff == fSrcCoeff || srcAIsOne) {
-            return false;
-        }
-    }
-
-    // Reduces to: coeffS * (Cov*S) + D
-    if (kSA_GrBlendCoeff == fDstCoeff && srcAIsOne) {
-        return false;
-    }
-
-    // We can always blend correctly if we have solid coverage.
-    if (coveragePOI.isSolidWhite()) {
-        return false;
-    }
-
-    return true;
+    // Some formulas use dual source blending, so we fall back if it is required but not supported.
+    return !caps.shaderCaps()->dualSourceBlendingSupport() &&
+           get_blend_formula(colorPOI, coveragePOI, fXfermode).hasSecondaryOutput();
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps&,
                                                GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::Mode(random->nextULessThan(SkXfermode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Create(mode);
 }