Potentially optimize some GrGLEffects for known input color values

src/effects/SkLumaXfermode.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLumaXfermode.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
@@ skipping 21 matching lines @@
 };
 
 SkPMColor SkLumaMaskXfermode::lumaProc(const SkPMColor a, const SkPMColor b) const {
     unsigned luma = SkComputeLuminance(SkGetPackedR32(b),
                                        SkGetPackedG32(b),
                                        SkGetPackedB32(b));
     return SkAlphaMulQ(a, SkAlpha255To256(luma));
 }
 
 template <typename T>
-static inline const T* lumaOpA(SkXfermode::Mode mode,
-                               const T* src, const T* dst) {
+static inline T lumaOpA(SkXfermode::Mode mode, T src, T dst) {
     return SkXfermode::kSrcIn_Mode == mode ? src : dst;
 }
 
 template <typename T>
-static inline const T* lumaOpB(SkXfermode::Mode mode,
-                               const T* src, const T* dst) {
+static inline T lumaOpB(SkXfermode::Mode mode, T src, T dst) {
     return SkXfermode::kSrcIn_Mode == mode ? dst : src;
 }
 
 SkXfermode* SkLumaMaskXfermode::Create(SkXfermode::Mode mode) {
     if (kSrcIn_Mode == mode || kDstIn_Mode == mode) {
         return SkNEW_ARGS(SkLumaMaskXfermode, (mode));
     }
     if (kSrcOver_Mode == mode) {
         return SkNEW_ARGS(SkLumaMaskXfermodeSrcOver, ());
     }
@@ skipping 11 matching lines @@
     , fMode((SkXfermode::Mode)buffer.readUInt()) {
     SkASSERT(kSrcIn_Mode == fMode || kDstIn_Mode == fMode || kSrcOver_Mode == fMode);
 }
 
 void SkLumaMaskXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
     INHERITED::flatten(buffer);
     buffer.writeUInt(fMode);
 }
 
 SkPMColor SkLumaMaskXfermode::xferColor(SkPMColor src, SkPMColor dst) const {
-    const SkPMColor* a = lumaOpA<SkPMColor>(fMode, &src, &dst);
-    const SkPMColor* b = lumaOpB<SkPMColor>(fMode, &src, &dst);
+    const SkPMColor* a = lumaOpA<const SkPMColor*>(fMode, &src, &dst);
+    const SkPMColor* b = lumaOpB<const SkPMColor*>(fMode, &src, &dst);
     return this->lumaProc(*a, *b);
 }
 
 void SkLumaMaskXfermode::xfer32(SkPMColor dst[], const SkPMColor src[],
                                 int count, const SkAlpha aa[]) const {
-    const SkPMColor* a = lumaOpA<SkPMColor>(fMode, src, dst);
-    const SkPMColor* b = lumaOpB<SkPMColor>(fMode, src, dst);
+    const SkPMColor* a = lumaOpA<const SkPMColor*>(fMode, src, dst);
+    const SkPMColor* b = lumaOpB<const SkPMColor*>(fMode, src, dst);
 
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned cov = aa[i];
             if (cov) {
                 unsigned resC = this->lumaProc(a[i], b[i]);
                 if (cov < 255) {
                     resC = SkFastFourByteInterp256(resC, dst[i],
                                                    SkAlpha255To256(cov));
                 }
@@ skipping 50 matching lines @@
 
 class GrGLLumaMaskEffect : public GrGLEffect {
 public:
     GrGLLumaMaskEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
     virtual ~GrGLLumaMaskEffect();
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
-                          const char* inputColor,
+                          const GrGLSLExpr4& inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
 
 private:
     typedef GrGLEffect INHERITED;
 };
 
 class GrLumaMaskEffect : public GrEffect {
@@ skipping 28 matching lines @@
    : INHERITED(factory) {
 }
 
 GrGLLumaMaskEffect::~GrGLLumaMaskEffect() {
 }
 
 void GrGLLumaMaskEffect::emitCode(GrGLShaderBuilder* builder,
                                   const GrDrawEffect& effect,
                                   EffectKey key,
                                   const char* outputColor,
-                                  const char* inputColor,
+                                  const GrGLSLExpr4& inputColor,
                                   const TransformedCoordsArray&,
                                   const TextureSamplerArray& samplers) {
 
     const GrLumaMaskEffect& lumaEffect = effect.castEffect<GrLumaMaskEffect>();
-    const char* dstColor = builder->dstColor();
-    SkASSERT(NULL != dstColor);
-    if (NULL == inputColor) {
-        inputColor = "vec4(1)";
-    }
+    GrGLSLExpr4 dstColor(builder->dstColor());
 
-    const char *opA = lumaOpA<char>(lumaEffect.getMode(), inputColor, dstColor);
-    const char *opB = lumaOpB<char>(lumaEffect.getMode(), inputColor, dstColor);
+    const GrGLSLExpr4& opA = lumaOpA(lumaEffect.getMode(), inputColor, dstColor);
+    const GrGLSLExpr4& opB = lumaOpB(lumaEffect.getMode(), inputColor, dstColor);
 
     builder->fsCodeAppendf("\t\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb); \n",
                            SK_ITU_BT709_LUM_COEFF_R,
                            SK_ITU_BT709_LUM_COEFF_G,
                            SK_ITU_BT709_LUM_COEFF_B,
-                           opB);
+                           opB.c_str());
     if (SkXfermode::kSrcOver_Mode == lumaEffect.getMode()) {
-        builder->fsCodeAppendf("\t\tvec4 newB = %s;\n\t\tif (newB.a > 0.0) { newB *= luma / newB.a; }\n\t\tnewB.a = luma;\n", opB);
-        builder->fsCodeAppendf("\t\t%s = newB + %s * (1.0 - luma); \n", outputColor, opA);
+        builder->fsCodeAppendf("\t\tvec4 newB = %s;\n\t\tif (newB.a > 0.0) { newB *= luma / newB.a; }\n\t\tnewB.a = luma;\n", opB.c_str());
+        builder->fsCodeAppendf("\t\t%s = newB + %s * (1.0 - luma); \n", outputColor, opA.c_str());
     } else {
-        builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, opA);
+        builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, opA.c_str());
     }
 }
 
 GrGLEffect::EffectKey GrGLLumaMaskEffect::GenKey(const GrDrawEffect& drawEffect,
                                                  const GrGLCaps&) {
     const GrLumaMaskEffect& effect = drawEffect.castEffect<GrLumaMaskEffect>();
     return (EffectKey)effect.getMode();
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 26 matching lines @@
     // No background texture support.
     if (effect && !background) {
         *effect = GrLumaMaskEffect::Create(fMode);
         return true;
     }
 
     return false;
 }
 
 #endif // SK_SUPPORT_GPU