Create a static instances of SrcOver XferProcessor

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"
@@ skipping 338 matching lines @@
     const char* name() const override { return "Porter Duff"; }
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
     BlendFormula getBlendFormula() const { return fBlendFormula; }
 
 private:
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
-                                                 const GrCaps& caps) override;
+                                                 const GrCaps& caps) const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onHasSecondaryOutput() const override { return fBlendFormula.hasSecondaryOutput(); }
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         blendInfo->fEquation = fBlendFormula.fBlendEquation;
         blendInfo->fSrcBlend = fBlendFormula.fSrcCoeff;
         blendInfo->fDstBlend = fBlendFormula.fDstCoeff;
         blendInfo->fWriteColor = fBlendFormula.modifiesDst();
@@ skipping 14 matching lines @@
 static void append_color_output(const PorterDuffXferProcessor& xp,
                                 GrGLSLXPFragmentBuilder* fragBuilder,
                                 BlendFormula::OutputType outputType, const char* output,
                                 const char* inColor, const char* inCoverage) {
     switch (outputType) {
         case BlendFormula::kNone_OutputType:
             fragBuilder->codeAppendf("%s = vec4(0.0);", output);
             break;
         case BlendFormula::kCoverage_OutputType:
             // We can have a coverage formula while not reading coverage if there are mixed samples.
-            fragBuilder->codeAppendf("%s = %s;",
-                                   output, xp.readsCoverage() ? inCoverage : "vec4(1.0)");
+            if (inCoverage) {
+                fragBuilder->codeAppendf("%s = %s;", output, inCoverage);
+            } else {
+                fragBuilder->codeAppendf("%s = vec4(1.0);", output);
+            }
             break;
         case BlendFormula::kModulate_OutputType:
-            if (xp.readsCoverage()) {
+            if (inCoverage) {
                 fragBuilder->codeAppendf("%s = %s * %s;", output, inColor, inCoverage);
             } else {
                 fragBuilder->codeAppendf("%s = %s;", output, inColor);
             }
             break;
         case BlendFormula::kSAModulate_OutputType:
-            if (xp.readsCoverage()) {
+            if (inCoverage) {
                 fragBuilder->codeAppendf("%s = %s.a * %s;", output, inColor, inCoverage);
             } else {
                 fragBuilder->codeAppendf("%s = %s;", output, inColor);
             }
             break;
         case BlendFormula::kISAModulate_OutputType:
-            if (xp.readsCoverage()) {
+            if (inCoverage) {
                 fragBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage);
             } else {
                 fragBuilder->codeAppendf("%s = vec4(1.0 - %s.a);", output, inColor);
             }
             break;
         case BlendFormula::kISCModulate_OutputType:
-            if (xp.readsCoverage()) {
+            if (inCoverage) {
                 fragBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;", output, inColor, inCoverage);
             } else {
                 fragBuilder->codeAppendf("%s = vec4(1.0) - %s;", output, inColor);
             }
             break;
         default:
             SkFAIL("Unsupported output type.");
             break;
     }
 }
 
 class GLPorterDuffXferProcessor : public GrGLSLXferProcessor {
 public:
     static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
         const PorterDuffXferProcessor& xp = processor.cast<PorterDuffXferProcessor>();
-        b->add32(SkToInt(xp.readsCoverage()) |
-                 (xp.getBlendFormula().fPrimaryOutputType << 1) |
-                 (xp.getBlendFormula().fSecondaryOutputType << 4));
+        b->add32(xp.getBlendFormula().fPrimaryOutputType |
+                 (xp.getBlendFormula().fSecondaryOutputType << 3));
         GR_STATIC_ASSERT(BlendFormula::kLast_OutputType < 8);
     };
 
 private:
     void emitOutputsForBlendState(const EmitArgs& args) override {
         const PorterDuffXferProcessor& xp = args.fXP.cast<PorterDuffXferProcessor>();
         GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
 
         BlendFormula blendFormula = xp.getBlendFormula();
         if (blendFormula.hasSecondaryOutput()) {
@@ skipping 17 matching lines @@
 }
 
 GrGLSLXferProcessor* PorterDuffXferProcessor::createGLSLInstance() const {
     return new GLPorterDuffXferProcessor;
 }
 
 GrXferProcessor::OptFlags
 PorterDuffXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
-                                            const GrCaps& caps) {
+                                            const GrCaps& caps) const {
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
     if (!fBlendFormula.modifiesDst()) {
         if (!doesStencilWrite) {
             optFlags |= GrXferProcessor::kSkipDraw_OptFlag;
         }
         optFlags |= (GrXferProcessor::kIgnoreColor_OptFlag |
                      GrXferProcessor::kIgnoreCoverage_OptFlag |
                      GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag);
     } else {
         if (!fBlendFormula.usesInputColor()) {
@@ skipping 24 matching lines @@
     }
 
     const char* name() const override { return "Porter Duff Shader"; }
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
     SkXfermode::Mode getXfermode() const { return fXfermode; }
 
 private:
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&, bool, GrColor*, 
-                                                 const GrCaps&) override {
+                                                 const GrCaps&) const override {
         return kNone_OptFlags;
     }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
         const ShaderPDXferProcessor& xp = xpBase.cast<ShaderPDXferProcessor>();
         return fXfermode == xp.fXfermode;
     }
 
@@ skipping 50 matching lines @@
     const char* name() const override { return "Porter Duff LCD"; }
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
 private:
     PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
-                                                 const GrCaps& caps) override;
+                                                 const GrCaps& caps) const override;
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         blendInfo->fSrcBlend = kConstC_GrBlendCoeff;
         blendInfo->fDstBlend = kISC_GrBlendCoeff;
         blendInfo->fBlendConstant = fBlendConstant;
     }
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
@@ skipping 18 matching lines @@
     GLPDLCDXferProcessor(const GrProcessor&) {}
 
     virtual ~GLPDLCDXferProcessor() {}
 
     static void GenKey(const GrProcessor& processor, const GrGLSLCaps& caps,
                        GrProcessorKeyBuilder* b) {}
 
 private:
     void emitOutputsForBlendState(const EmitArgs& args) override {
         GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
+        SkASSERT(args.fInputCoverage);
         fragBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
                                  args.fInputCoverage);
     }
 
     void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {};
 
     typedef GrGLSLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 30 matching lines @@
 }
 
 GrGLSLXferProcessor* PDLCDXferProcessor::createGLSLInstance() const {
     return new GLPDLCDXferProcessor(*this);
 }
 
 GrXferProcessor::OptFlags
 PDLCDXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizations,
                                        bool doesStencilWrite,
                                        GrColor* overrideColor,
-                                       const GrCaps& caps) {
+                                       const GrCaps& caps) const {
         // 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;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 140 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // SrcOver Global functions
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
         const GrCaps& caps,
         const GrPipelineOptimizations& optimizations,
         bool hasMixedSamples,
         const GrXferProcessor::DstTexture* dstTexture) {
+    if (!optimizations.fCoveragePOI.isFourChannelOutput() &&
+        !(optimizations.fCoveragePOI.isSolidWhite() &&
+          !hasMixedSamples &&
+          optimizations.fColorPOI.isOpaque())) {
+        static BlendFormula gSrcOverBlendFormula = COEFF_FORMULA(kOne_GrBlendCoeff,
+                                                                 kISA_GrBlendCoeff);
+        static PorterDuffXferProcessor gSrcOverXP(gSrcOverBlendFormula);
+        SkASSERT(!dstTexture || !dstTexture->texture());
+        gSrcOverXP.ref();
+        return &gSrcOverXP;
+    }
+
     BlendFormula blendFormula;
     if (optimizations.fCoveragePOI.isFourChannelOutput()) {
         if (kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
             !caps.shaderCaps()->dualSourceBlendingSupport() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
             // If we don't have dual source blending or in shader dst reads, we fall
             // back to this trick for rendering SrcOver LCD text instead of doing a
             // dst copy.
             SkASSERT(!dstTexture || !dstTexture->texture());
             return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, optimizations.fColorPOI);
@@ skipping 30 matching lines @@
         }
         return get_lcd_blend_formula(optimizations.fCoveragePOI, 
                                      SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
     }
     // We fallback on the shader XP when the blend formula would use dual source blending but we
     // don't have support for it.
     return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
                              hasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
 }