Merge "Sk4px: Difference and Exclusion" into master-skia

https://skia.googlesource.com/skia/+/0135a41e095a433414e21e37b277dab7dcbec373

Change-Id: If2bf13e3df0c18af31f4076dcd07e7469a935f20

5 files changed, 67 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
diff --git a/src/opts/Sk4px_NEON.h b/src/opts/Sk4px_NEON.h
index 368551949c..f0d9b56c71 100644
--- a/src/opts/Sk4px_NEON.h
+++ b/src/opts/Sk4px_NEON.h
@@ -78,3 +78,13 @@ inline Sk4px Sk4px::Load2Alphas(const SkAlpha a[2]) {
     a32 = vorrq_u32(a32, vshlq_n_u32(a32, 16));           // ____ ____ 1111 0000
     return Sk16b((uint8x16_t)a32);
 }
+
+inline Sk4px Sk4px::zeroColors() const {
+    return Sk16b(vandq_u8(this->fVec, (uint8x16_t)vdupq_n_u32(0xFF << SK_A32_SHIFT)));
+}
+
+inline Sk4px Sk4px::zeroAlphas() const {
+    // vbic(a,b) == a & ~b
+    return Sk16b(vbicq_u8(this->fVec, (uint8x16_t)vdupq_n_u32(0xFF << SK_A32_SHIFT)));
+}
+
diff --git a/src/opts/Sk4px_SSE2.h b/src/opts/Sk4px_SSE2.h
index 55e1a69135..9ba510347e 100644
--- a/src/opts/Sk4px_SSE2.h
+++ b/src/opts/Sk4px_SSE2.h
@@ -76,3 +76,12 @@ inline Sk4px Sk4px::Load2Alphas(const SkAlpha a[2]) {
     uint32_t as = *(const uint16_t*)a;   // Aa -> Aa00
     return Load4Alphas((const SkAlpha*)&as);
 }
+
+inline Sk4px Sk4px::zeroColors() const {
+    return Sk16b(_mm_and_si128(_mm_set1_epi32(0xFF << SK_A32_SHIFT), this->fVec));
+}
+
+inline Sk4px Sk4px::zeroAlphas() const {
+    // andnot(a,b) == ~a & b
+    return Sk16b(_mm_andnot_si128(_mm_set1_epi32(0xFF << SK_A32_SHIFT), this->fVec));
+}
diff --git a/src/opts/Sk4px_none.h b/src/opts/Sk4px_none.h
index 340a36fd14..541443d772 100644
--- a/src/opts/Sk4px_none.h
+++ b/src/opts/Sk4px_none.h
@@ -77,3 +77,20 @@ inline Sk4px Sk4px::Load2Alphas(const SkAlpha a[2]) {
                  0,0,0,0,
                  0,0,0,0);
 }
+
+inline Sk4px Sk4px::zeroAlphas() const {
+    static_assert(SK_A32_SHIFT == 24, "This method assumes little-endian.");
+    return Sk16b(this->kth< 0>(), this->kth< 1>(), this->kth< 2>(), 0,
+                 this->kth< 4>(), this->kth< 5>(), this->kth< 6>(), 0,
+                 this->kth< 8>(), this->kth< 9>(), this->kth<10>(), 0,
+                 this->kth<12>(), this->kth<13>(), this->kth<14>(), 0);
+}
+
+inline Sk4px Sk4px::zeroColors() const {
+    static_assert(SK_A32_SHIFT == 24, "This method assumes little-endian.");
+    return Sk16b(0,0,0, this->kth< 3>(),
+                 0,0,0, this->kth< 7>(),
+                 0,0,0, this->kth<11>(),
+                 0,0,0, this->kth<15>());
+}
+