In order to use CSS luminance masking, we need to be able to create an instance of SkLumaXfermode w…

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"
 #include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLEffectMatrix.h"
 #include "GrContext.h"
 #include "GrTBackendEffectFactory.h"
 #endif
 
-static inline SkPMColor luma_proc(const SkPMColor a, const SkPMColor b) {
+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) {
     return SkXfermode::kSrcIn_Mode == mode ? src : dst;
 }
 
 template <typename T>
 static inline const T* lumaOpB(SkXfermode::Mode mode,
                                const T* src, const 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, ());
+    }
+
     return NULL;
 }
 
 SkLumaMaskXfermode::SkLumaMaskXfermode(SkXfermode::Mode mode)
     : fMode(mode) {
-    SkASSERT(kSrcIn_Mode == mode || kDstIn_Mode == mode);
+    SkASSERT(kSrcIn_Mode == mode || kDstIn_Mode == mode || kSrcOver_Mode == mode);
 }
 
 SkLumaMaskXfermode::SkLumaMaskXfermode(SkFlattenableReadBuffer& buffer)
     : INHERITED(buffer)
     , fMode((SkXfermode::Mode)buffer.readUInt()) {
-    SkASSERT(kSrcIn_Mode == fMode || kDstIn_Mode == fMode);
+    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);
-    return luma_proc(*a, *b);
+    return 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);
 
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned cov = aa[i];
             if (cov) {
-                unsigned resC = luma_proc(a[i], b[i]);
+                unsigned resC = lumaProc(a[i], b[i]);
                 if (cov < 255) {
                     resC = SkFastFourByteInterp256(resC, dst[i],
                                                    SkAlpha255To256(cov));
                 }
                 dst[i] = resC;
             }
         }
     } else {
         for (int i = 0; i < count; ++i) {
-            dst[i] = luma_proc(a[i], b[i]);
+            dst[i] = lumaProc(a[i], b[i]);
         }
     }
 }
 
 #ifdef SK_DEVELOPER
 void SkLumaMaskXfermode::toString(SkString* str) const {
     str->printf("SkLumaMaskXfermode: mode: %s",
                 fMode == kSrcIn_Mode ? "SRC_IN" : "DST_IN");
 }
 #endif
 
+SkLumaMaskXfermodeSrcOver::SkLumaMaskXfermodeSrcOver() : SkLumaMaskXfermode(kSrcOver_Mode) {}
+
+SkPMColor SkLumaMaskXfermodeSrcOver::lumaProc(const SkPMColor a, const SkPMColor b) const {
+    unsigned luma = SkComputeLuminance(SkGetPackedR32(b),
+                                       SkGetPackedG32(b),
+                                       SkGetPackedB32(b));
+
+    unsigned oldAlpha = SkGetPackedA32(b);
+    unsigned oldR = 0, oldG = 0, oldB = 0;
+
+    if (oldAlpha > 0) {
+        oldR = SkGetPackedR32(b) * 255 / oldAlpha;
+        oldG = SkGetPackedG32(b) * 255 / oldAlpha;
+        oldB = SkGetPackedB32(b) * 255 / oldAlpha;
+    }
+
+    SkPMColor colorB = SkPremultiplyARGBInline(luma, oldR, oldG, oldB);
+
+    return SkPMSrcOver(colorB, a);
+}
+
 #if SK_SUPPORT_GPU
 //////////////////////////////////////////////////////////////////////////////
 
 class GrGLLumaMaskEffect : public GrGLEffect {
 public:
     GrGLLumaMaskEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
     virtual ~GrGLLumaMaskEffect();
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
@@ skipping 58 matching lines @@
     }
 
     const char *opA = lumaOpA<char>(lumaEffect.getMode(), inputColor, dstColor);
     const char *opB = lumaOpB<char>(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);
-    builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, opA);
+    if (SkXfermode::kSrcOver_Mode == lumaEffect.getMode()) {
+        builder->fsCodeAppendf("\t\tvec4 newB = %s;\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);
+    } else {
+        builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, opA);
+    }
 }
 
 GrGLEffect::EffectKey GrGLLumaMaskEffect::GenKey(const GrDrawEffect& drawEffect,
                                                  const GrGLCaps&) {
     const GrLumaMaskEffect& effect = drawEffect.castEffect<GrLumaMaskEffect>();
     return (EffectKey)effect.getMode();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ skipping 25 matching lines @@
     // No background texture support.
     if (effect && !background) {
         *effect = GrLumaMaskEffect::Create(fMode);
         return true;
     }
 
     return false;
 }
 
 #endif // SK_SUPPORT_GPU