Re-enable advanced blend with a blacklist

src/gpu/effects/GrCustomXfermode.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
@@ skipping 33 matching lines @@
     GR_STATIC_ASSERT(kDifference_GrBlendEquation == SkXfermode::kDifference_Mode + kOffset);
     GR_STATIC_ASSERT(kExclusion_GrBlendEquation == SkXfermode::kExclusion_Mode + kOffset);
     GR_STATIC_ASSERT(kMultiply_GrBlendEquation == SkXfermode::kMultiply_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == SkXfermode::kHue_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == SkXfermode::kSaturation_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == SkXfermode::kColor_Mode + kOffset);
     GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == SkXfermode::kLuminosity_Mode + kOffset);
     GR_STATIC_ASSERT(kGrBlendEquationCnt == SkXfermode::kLastMode + 1 + kOffset);
 }
 
+static bool can_use_hw_blend_equation(GrBlendEquation equation,
+                                      const GrProcOptInfo& coveragePOI,
+                                      const GrCaps& caps) {
+    if (!caps.advancedBlendEquationSupport()) {
+        return false;
+    }
+    if (coveragePOI.isFourChannelOutput()) {
+        return false; // LCD coverage must be applied after the blend equation.
+    }
+    if (caps.advancedBlendEquationIsBlacklist(equation)) {
+        return false;
+    }
+    return true;
+}
+
 static void hard_light(GrGLFragmentBuilder* fsBuilder,
                        const char* final,
                        const char* src,
                        const char* dst) {
     static const char kComponents[] = {'r', 'g', 'b'};
     for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) {
         char component = kComponents[i];
         fsBuilder->codeAppendf("if (2.0 * %s.%c <= %s.a) {", src, component, src);
         fsBuilder->codeAppendf("%s.%c = 2.0 * %s.%c * %s.%c;",
                                final, component, src, component, dst, component);
@@ skipping 437 matching lines @@
 
     return SkNEW_ARGS(GrCustomXferFP, (static_cast<SkXfermode::Mode>(mode), textures[0]));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Xfer Processor
 ///////////////////////////////////////////////////////////////////////////////
 
 class CustomXP : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(SkXfermode::Mode mode, const DstTexture* dstTexture,
-                                   bool willReadDstColor) {
-        if (!GrCustomXfermode::IsSupportedMode(mode)) {
-            return NULL;
-        } else {
-            return SkNEW_ARGS(CustomXP, (mode, dstTexture, willReadDstColor));
-        }
+    CustomXP(SkXfermode::Mode mode, GrBlendEquation hwBlendEquation)
+        : fMode(mode),
+          fHWBlendEquation(hwBlendEquation) {
+        this->initClassID<CustomXP>();
     }
 
-    ~CustomXP() override {};
+    CustomXP(SkXfermode::Mode mode, const DstTexture* dstTexture)
+        : INHERITED(dstTexture, true),
+          fMode(mode),
+          fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
+        this->initClassID<CustomXP>();
+    }
 
     const char* name() const override { return "Custom Xfermode"; }
 
     GrGLXferProcessor* createGLInstance() const override;
 
     bool hasSecondaryOutput() const override { return false; }
 
     SkXfermode::Mode mode() const { return fMode; }
     bool hasHWBlendEquation() const { return -1 != static_cast<int>(fHWBlendEquation); }
 
     GrBlendEquation hwBlendEquation() const {
         SkASSERT(this->hasHWBlendEquation());
         return fHWBlendEquation;
     }
 
 private:
-    CustomXP(SkXfermode::Mode mode, const DstTexture*, bool willReadDstColor);
-
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
                                                  const GrCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onWillNeedXferBarrier(const GrRenderTarget* rt,
                                const GrCaps& caps,
                                GrXferBarrierType* outBarrierType) const override;
 
     void onGetBlendInfo(BlendInfo*) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
-    SkXfermode::Mode fMode;
-    GrBlendEquation  fHWBlendEquation;
+    const SkXfermode::Mode fMode;
+    const GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return NULL;
     } else {
@@ skipping 52 matching lines @@
         }
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-CustomXP::CustomXP(SkXfermode::Mode mode, const DstTexture* dstTexture, bool willReadDstColor)
-    : INHERITED(dstTexture, willReadDstColor),
-      fMode(mode),
-      fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
-    this->initClassID<CustomXP>();
-}
-
 void CustomXP::onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
     GLCustomXP::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* CustomXP::createGLInstance() const {
     SkASSERT(this->willReadDstColor() != this->hasHWBlendEquation());
     return SkNEW_ARGS(GLCustomXP, (*this));
 }
 
 bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
@@ skipping 102 matching lines @@
         = blend(f*Sa, Da)
    */
 
     OptFlags flags = kNone_Opt;
     if (colorPOI.allStagesMultiplyInput()) {
         flags |= kCanTweakAlphaForCoverage_OptFlag;
     }
     if (coveragePOI.isSolidWhite()) {
         flags |= kIgnoreCoverage_OptFlag;
     }
-    if (caps.advancedBlendEquationSupport() && !coveragePOI.isFourChannelOutput()) {
-        // This blend mode can be implemented in hardware.
-        fHWBlendEquation = hw_blend_equation(fMode);
-    }
     return flags;
 }
 
 bool CustomXP::onWillNeedXferBarrier(const GrRenderTarget* rt,
                                      const GrCaps& caps,
                                      GrXferBarrierType* outBarrierType) const {
     if (this->hasHWBlendEquation() && !caps.advancedCoherentBlendEquationSupport()) {
         *outBarrierType = kBlend_GrXferBarrierType;
         return true;
     }
     return false;
 }
 
 void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const {
     if (this->hasHWBlendEquation()) {
         blendInfo->fEquation = this->hwBlendEquation();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrCustomXPFactory::GrCustomXPFactory(SkXfermode::Mode mode)
-    : fMode(mode) {
+    : fMode(mode),
+      fHWBlendEquation(hw_blend_equation(mode)) {
+    SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
     this->initClassID<GrCustomXPFactory>();
 }
 
 GrXferProcessor*
 GrCustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
                                          const DstTexture* dstTexture) const {
-    return CustomXP::Create(fMode, dstTexture, this->willReadDstColor(caps, colorPOI, coveragePOI));
+    if (can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps)) {
+        SkASSERT(!dstTexture || !dstTexture->texture());
+        return SkNEW_ARGS(CustomXP, (fMode, fHWBlendEquation));
+    }
+    return SkNEW_ARGS(CustomXP, (fMode, dstTexture));
 }
 
 bool GrCustomXPFactory::willReadDstColor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI) const {
-    if (!caps.advancedBlendEquationSupport()) {
-        // No hardware support for advanced blend equations; we will need to do it in the shader.
-        return true;
-    }
-    if (coveragePOI.isFourChannelOutput()) {
-        // Advanced blend equations can't tweak alpha for RGB coverage.
-        return true;
-    }
-    return false;
+    return !can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps);
 }
 
 void GrCustomXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                  InvariantBlendedColor* blendedColor) const {
     blendedColor->fWillBlendWithDst = true;
     blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }