Sk4px: SrcATop, DstATop, Xor, Multiply

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 1220 matching lines @@
 #endif
     return pm;
 }
 
 //  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
 struct SrcATop4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         return check_as_pmfloat(dst + (src * Sk4f(dst.a()) - dst * Sk4f(src.a())) * inv255);
     }
+    static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        return Sk4px::Wide(src.mulWiden(dst.alphas()) + dst.mulWiden(src.alphas().inv()))
+            .div255RoundNarrow();
+    }
     static const bool kFoldCoverageIntoSrcAlpha = true;
     static const SkXfermode::Mode kMode = SkXfermode::kSrcATop_Mode;
 };
 
 //  kDstATop_Mode,  //!< [Sa, Sa * Dc + Sc * (1 - Da)]
 struct DstATop4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
-        const Sk4f inv255(gInv255);
-        return check_as_pmfloat(src + (dst * Sk4f(src.a()) - src * Sk4f(dst.a())) * inv255);
+        return SrcATop4f::Xfer(dst, src);
+    }
+    static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        return SrcATop4f::Xfer(dst, src);
     }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kDstATop_Mode;
 };
 
 //  kXor_Mode   [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
 struct Xor4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         return check_as_pmfloat(src + dst - (src * Sk4f(dst.a()) + dst * Sk4f(src.a())) * inv255);
     }
+    static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        return Sk4px::Wide(src.mulWiden(dst.alphas().inv()) + dst.mulWiden(src.alphas().inv()))
+            .div255RoundNarrow();
+    }
     static const bool kFoldCoverageIntoSrcAlpha = true;
     static const SkXfermode::Mode kMode = SkXfermode::kXor_Mode;
 };
 
 //  kPlus_Mode   [Sa + Da, Sc + Dc]
 struct Plus4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         return check_as_pmfloat(clamp_255(src + dst));
     }
     static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
@@ skipping 17 matching lines @@
 };
 
 //  kScreen_Mode   [S + D - S * D]
 struct Screen4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         return check_as_pmfloat(src + dst - src * dst * inv255);
     }
     static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
         // Doing the math as S + (1-S)*D or S + (D - S*D) means the add and subtract can be done
-        // in 8-bit space without overflow.  S + (1-S)*D is a touch faster because 255-x is an xor.
-        // TODO: do we need to explicitly implement / call Sk16b(255) ^ src ?
-        return src + Sk4px(Sk16b(255) - src).mulWiden(dst).div255RoundNarrow();
+        // in 8-bit space without overflow.  S + (1-S)*D is a touch faster because inv() is cheap.
+        return src + src.inv().mulWiden(dst).div255RoundNarrow();
     }
     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 Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
+        return Sk4px::Wide(src.mulWiden(dst.alphas().inv()) +
+                           dst.mulWiden(src.alphas().inv()) +
+                           src.mulWiden(dst))
+            .div255RoundNarrow();
+    }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kMultiply_Mode;
 };
 
 struct Difference4f {
     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;
@@ skipping 138 matching lines @@
     SkXfermode::Mode mode = (SkXfermode::Mode)iMode;
 
     ProcCoeff rec = gProcCoeffs[mode];
     SkXfermodeProc pp = SkPlatformXfermodeProcFactory(mode);
     if (pp != NULL) {
         rec.fProc = pp;
     }
 
 #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);
         default: break;
     }
 #endif
 
 #if defined(SK_4F_XFERMODES_ARE_FAST)
     switch (mode) {
         case SkXfermode::kSrcATop_Mode:    return SkT4fXfermode<SrcATop4f>::Create(rec);
         case SkXfermode::kDstATop_Mode:    return SkT4fXfermode<DstATop4f>::Create(rec);
         case SkXfermode::kXor_Mode:        return SkT4fXfermode<Xor4f>::Create(rec);
         case SkXfermode::kPlus_Mode:       return SkT4fXfermode<Plus4f>::Create(rec);
@@ skipping 299 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