impl Multiply mode using Sk4f

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkXfermode.h"
 #include "SkXfermode_opts_SSE2.h"
@@ skipping 1176 matching lines @@
 */
 
 #ifndef SK_SUPPORT_LEGACY_SCALAR_XFERMODES
 static const float gInv255 = 0.0039215683f; //  (1.0f / 255) - ULP == SkBits2Float(0x3B808080)
 
 static Sk4f ramp(const Sk4f& v0, const Sk4f& v1, const Sk4f& t) {
     return v0 + (v1 - v0) * t;
 }
 
 static Sk4f clamp_255(const Sk4f& value) {
-    return Sk4f::Min(value, Sk4f(255));
+    return Sk4f::Min(Sk4f(255), value);
+}
+
+static Sk4f clamp_0_255(const Sk4f& value) {
+    return Sk4f::Max(Sk4f(0), Sk4f::Min(Sk4f(255), value));
 }
 
 /**
  *  Some modes can, due to very slight numerical error, generate "invalid" pmcolors...
  *
  *  e.g.
  *      alpha = 100.9999
  *      red   = 101
  *
  *  or
@@ skipping 71 matching lines @@
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kModulate_Mode;
 };
 
 //  kScreen_Mode   [S + D - S * D]
 struct Screen4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         Sk4f s4 = src;
         Sk4f d4 = dst;
-        return check_as_pmfloat(check_as_pmfloat(s4 + d4 - s4 * d4 * inv255));
+        return check_as_pmfloat(s4 + d4 - s4 * d4 * inv255);
     }
     static const bool kFoldCoverageIntoSrcAlpha = true;
     static const SkXfermode::Mode kMode = SkXfermode::kScreen_Mode;
 };
 
+struct Multiply4f {
+    static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
+        const Sk4f inv255(gInv255);
+        Sk4f sa = Sk4f(src.a());
+        Sk4f da = Sk4f(dst.a());
+        Sk4f sc = src;
+        Sk4f dc = dst;
+        Sk4f rc = sc + dc + (sc * (dc - da) - dc * sa) * inv255;
+        // ra = srcover(sa, da), but the calc for rc happens to accomplish this for us
+        return check_as_pmfloat(clamp_0_255(rc));
+    }
+    static const bool kFoldCoverageIntoSrcAlpha = false;
+    static const SkXfermode::Mode kMode = SkXfermode::kMultiply_Mode;
+};
+
 template <typename ProcType>
 class SkT4fXfermode : public SkProcCoeffXfermode {
 public:
     static SkXfermode* Create(const ProcCoeff& rec) {
         return SkNEW_ARGS(SkT4fXfermode, (rec));
     }
     
     void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
         if (NULL == aa) {
             while (n & 3) {
@@ skipping 111 matching lines @@
             break;
         case SkXfermode::kPlus_Mode:
             xfer = SkT4fXfermode<Plus4f>::Create(rec);
             break;
         case SkXfermode::kModulate_Mode:
             xfer = SkT4fXfermode<Modulate4f>::Create(rec);
             break;
         case SkXfermode::kScreen_Mode:
             xfer = SkT4fXfermode<Screen4f>::Create(rec);
             break;
+        case SkXfermode::kMultiply_Mode:
+            xfer = SkT4fXfermode<Multiply4f>::Create(rec);
+            break;
         default:
             break;
     }
     if (xfer) {
         return xfer;
     }
 #endif
 
     // check if we have a platform optim for that
     SkProcCoeffXfermode* xfm = SkPlatformXfermodeFactory(rec, mode);
@@ skipping 286 matching lines @@
         } else {
             proc16 = rec.fProc16_General;
         }
     }
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END