Add xp optimization for RGB coverage.

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 103 matching lines @@
 void GrPorterDuffXferProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::getOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
                                             bool isCoverageDrawing,
                                             bool colorWriteDisabled,
                                             bool doesStencilWrite,
-                                            GrColor* color, uint8_t* coverage,
+                                            GrColor* overrideColor,
+                                            uint8_t* overrideCoverage,
                                             const GrDrawTargetCaps& caps) {
-    GrXferProcessor::OptFlags optFlags = this->internalGetOptimizations(colorPOI,
-                                                                        coveragePOI,
-                                                                        isCoverageDrawing,
-                                                                        colorWriteDisabled,
-                                                                        doesStencilWrite,
-                                                                        color,
-                                                                        coverage);
-
+    GrXferProcessor::OptFlags optFlags;
+    // Optimizations when doing RGB Coverage
+    if (coveragePOI.isFourChannelOutput()) {
+        // 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.
+        uint8_t alpha = GrColorUnpackA(fBlendConstant);
+        *overrideColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
+        optFlags = GrXferProcessor::kOverrideColor_OptFlag;
+    } else {
+        optFlags = this->internalGetOptimizations(colorPOI,
+                                                  coveragePOI,
+                                                  isCoverageDrawing,
+                                                  colorWriteDisabled,
+                                                  doesStencilWrite,
+                                                  overrideColor,
+                                                  overrideCoverage);
+    }
     this->calcOutputTypes(optFlags, caps, isCoverageDrawing || coveragePOI.isSolidWhite(),
                           colorPOI.readsDst() || coveragePOI.readsDst());
     return optFlags;
 }
 
 void GrPorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
                                                 const GrDrawTargetCaps& caps,
                                                 bool hasSolidCoverage, bool readsDst) {
     // 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
@@ skipping 21 matching lines @@
         }
     }
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
                                                     bool isCoverageDrawing,
                                                     bool colorWriteDisabled,
                                                     bool doesStencilWrite,
-                                                    GrColor* color, uint8_t* coverage) {
+                                                    GrColor* overrideColor,
+                                                    uint8_t* overrideCoverage) {
     if (colorWriteDisabled) {
         fSrcBlend = kZero_GrBlendCoeff;
         fDstBlend = kOne_GrBlendCoeff;
     }
 
     bool srcAIsOne;
     bool hasCoverage;
     if (isCoverageDrawing) {
         srcAIsOne = colorPOI.isOpaque() && coveragePOI.isOpaque();
         hasCoverage = false;
     } else {
         srcAIsOne = colorPOI.isOpaque();
         hasCoverage = !coveragePOI.isSolidWhite();
     }
 
     bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstBlend ||
                          (kSA_GrBlendCoeff == fDstBlend && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstBlend ||
                          (kISA_GrBlendCoeff == fDstBlend && srcAIsOne);
 
-    // Optimizations when doing RGB Coverage
-    if (coveragePOI.isFourChannelOutput()) {
-        // 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.
-        uint8_t alpha = GrColorUnpackA(fBlendConstant);
-        *color = GrColorPackRGBA(alpha, alpha, alpha, alpha);
-        return GrXferProcessor::kClearColorStages_OptFlag;
-    }
-
     // 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) {
-            *color = 0xffffffff;
+            *overrideColor = 0xffffffff;
             return GrXferProcessor::kClearColorStages_OptFlag |
                    GrXferProcessor::kSetCoverageDrawing_OptFlag;
         } else {
             fDstBlend = kOne_GrBlendCoeff;
             return GrXferProcessor::kSkipDraw_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;
             } 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;
-                *color = 0;
-                *coverage = 0xff;
+                *overrideColor = 0;
+                *overrideCoverage = 0xff;
                 return GrXferProcessor::kClearColorStages_OptFlag |
                        GrXferProcessor::kClearCoverageStages_OptFlag;
             }
         }
     } else if (isCoverageDrawing) {
         // we have coverage but we aren't distinguishing it from alpha by request.
         return GrXferProcessor::kSetCoverageDrawing_OptFlag;
     } else {
         // 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, isCoverageDrawing)) {
             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;
-                *color = 0xffffffff;
+                *overrideColor = 0xffffffff;
                 return GrXferProcessor::kClearColorStages_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;
                 return GrXferProcessor::kSetCoverageDrawing_OptFlag;
             }
@@ skipping 282 matching lines @@
     } while (GrBlendCoeffRefsSrc(src));
 
     GrBlendCoeff dst;
     do {
         dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsDst(dst));
 
     return GrPorterDuffXPFactory::Create(src, dst);
 }