Sk4px: Difference and Exclusion

This will cause minor (off-by-one) diffs due to a little lost precision:
	colortype_xfermodes
	mixed_xfermodes
	xfermodes2
	xfermodeimagefilter
	xfermodes3
	xfermodes

Desktop:
Xfermode_Difference_aa	9.77ms -> 7.32ms	0.75x
 Xfermode_Exclusion_aa	8.49ms -> 6.21ms	0.73x
   Xfermode_Difference	  17ms -> 7.54ms	0.44x
    Xfermode_Exclusion	13.5ms -> 5.09ms	0.38x

N7:
Xfermode_Difference_aa	32.2ms -> 27.6ms	0.86x
   Xfermode_Difference	43.9ms ->   32ms	0.73x
 Xfermode_Exclusion_aa	40.5ms -> 26.7ms	0.66x
    Xfermode_Exclusion	71.5ms -> 23.9ms	0.33x

This wraps up the xfermodes implemented in Sk4f.

BUG=skia:

Review URL: https://codereview.chromium.org/1141213002

2 files changed, 31 insertions, 8 deletions

diff --git a/src/core/Sk4px.h b/src/core/Sk4px.h
index 5537b90230..028630d100 100644
--- a/src/core/Sk4px.h
+++ b/src/core/Sk4px.h
@@ -20,6 +20,10 @@ public:
 
     Sk4px alphas() const;  // ARGB argb XYZW xyzw -> AAAA aaaa XXXX xxxx
 
+    // Mask away color or alpha lanes.
+    Sk4px zeroColors() const;  // ARGB argb XYZW xyzw -> A000 a000 X000 x000
+    Sk4px zeroAlphas() const;  // ARGB argb XYZW xyzw -> 0RGB 0rgb 0YZW 0yzw
+
     Sk4px inv() const { return Sk16b(255) - *this; }
 
     // When loading or storing fewer than 4 SkPMColors, we use the low lanes.
@@ -56,6 +60,10 @@ public:
     Wide widenLo() const;               // ARGB -> 0A 0R 0G 0B
     Wide widenHi() const;               // ARGB -> A0 R0 G0 B0
     Wide mulWiden(const Sk16b&) const;  // 8-bit x 8-bit -> 16-bit components.
+    Wide mul255Widen() const {
+        // TODO: x*255 = x*256-x, so something like this->widenHi() - this->widenLo()?
+        return this->mulWiden(Sk16b(255));
+    }
 
     // A generic driver that maps fn over a src array into a dst array.
     // fn should take an Sk4px (4 src pixels) and return an Sk4px (4 dst pixels).
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 2abe55a8ca..8824a8875f 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -1333,6 +1333,7 @@ struct Multiply4f {
     static const SkXfermode::Mode kMode = SkXfermode::kMultiply_Mode;
 };
 
+// [ sa + da - sa*da, sc + dc - 2*min(sc*da, dc*sa) ]  (And notice sa*da == min(sa*da, da*sa).)
 struct Difference4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
@@ -1344,10 +1345,17 @@ struct Difference4f {
         Sk4f ra = sc + dc - min;
         return check_as_pmfloat(ra - min * SkPMFloat(0, 1, 1, 1));
     }
+    static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        auto m = Sk4px::Wide(Sk16h::Min(src.mulWiden(dst.alphas()), dst.mulWiden(src.alphas())))
+            .div255RoundNarrow();
+        // There's no chance of underflow, and if we subtract m before adding src+dst, no overflow.
+        return (src - m) + (dst - m.zeroAlphas());
+    }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kDifference_Mode;
 };
 
+// [ sa + da - sa*da, sc + dc - 2*sc*dc ]
 struct Exclusion4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
@@ -1357,6 +1365,11 @@ struct Exclusion4f {
         Sk4f ra = sc + dc - prod;
         return check_as_pmfloat(ra - prod * SkPMFloat(0, 1, 1, 1));
     }
+    static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        auto p = src.mulWiden(dst).div255RoundNarrow();
+        // There's no chance of underflow, and if we subtract p before adding src+dst, no overflow.
+        return (src - p) + (dst - p.zeroAlphas());
+    }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kExclusion_Mode;
 };
@@ -1413,7 +1426,7 @@ public:
                     [&](const Sk4px& dst4, const Sk4px& src4, const Sk16b& alpha) {
                 // We can't exploit kFoldCoverageIntoSrcAlpha. That requires >=24-bit intermediates.
                 Sk4px res4 = ProcType::Xfer(src4, dst4);
-                return Sk4px::Wide(res4.mulWiden(alpha) + dst4.mulWiden(Sk16b(255)-alpha))
+                return Sk4px::Wide(res4.mulWiden(alpha) + dst4.mulWiden(Sk4px(alpha).inv()))
                            .div255RoundNarrow();
             });
         }
@@ -1487,13 +1500,15 @@ SkXfermode* create_mode(int iMode) {
 
 #if defined(SK_4PX_XFERMODES_ARE_FAST) && !defined(SK_PREFER_LEGACY_FLOAT_XFERMODES)
     switch (mode) {
-        case SkXfermode::kSrcATop_Mode:  return SkT4pxXfermode<SrcATop4f>::Create(rec);
-        case SkXfermode::kDstATop_Mode:  return SkT4pxXfermode<DstATop4f>::Create(rec);
-        case SkXfermode::kXor_Mode:      return SkT4pxXfermode<Xor4f>::Create(rec);
-        case SkXfermode::kPlus_Mode:     return SkT4pxXfermode<Plus4f>::Create(rec);
-        case SkXfermode::kModulate_Mode: return SkT4pxXfermode<Modulate4f>::Create(rec);
-        case SkXfermode::kScreen_Mode:   return SkT4pxXfermode<Screen4f>::Create(rec);
-        case SkXfermode::kMultiply_Mode: return SkT4pxXfermode<Multiply4f>::Create(rec);
+        case SkXfermode::kSrcATop_Mode:    return SkT4pxXfermode<SrcATop4f>::Create(rec);
+        case SkXfermode::kDstATop_Mode:    return SkT4pxXfermode<DstATop4f>::Create(rec);
+        case SkXfermode::kXor_Mode:        return SkT4pxXfermode<Xor4f>::Create(rec);
+        case SkXfermode::kPlus_Mode:       return SkT4pxXfermode<Plus4f>::Create(rec);
+        case SkXfermode::kModulate_Mode:   return SkT4pxXfermode<Modulate4f>::Create(rec);
+        case SkXfermode::kScreen_Mode:     return SkT4pxXfermode<Screen4f>::Create(rec);
+        case SkXfermode::kMultiply_Mode:   return SkT4pxXfermode<Multiply4f>::Create(rec);
+        case SkXfermode::kDifference_Mode: return SkT4pxXfermode<Difference4f>::Create(rec);
+        case SkXfermode::kExclusion_Mode:  return SkT4pxXfermode<Exclusion4f>::Create(rec);
         default: break;
     }
 #endif