sk4px the rest of the easy xfermodes.

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 1214 matching lines @@
  *  SkPMFloat::isValid(), as that would fire sometimes, but not result in a bad pixel.
  */
 static inline SkPMFloat check_as_pmfloat(const Sk4f& value) {
     SkPMFloat pm = value;
 #ifdef SK_DEBUG
     (void)pm.round();
 #endif
     return pm;
 }
 
+#define XFERMODE(Name)                                                    \
+    struct Name {                                                         \
+        static Sk4px Xfer(const Sk4px&, const Sk4px&);                    \
+        static const SkXfermode::Mode kMode = SkXfermode::k##Name##_Mode; \
+    };                                                                    \
+    inline Sk4px Name::Xfer(const Sk4px& s, const Sk4px& d)
+
+XFERMODE(Clear) { return Sk4px((SkPMColor)0); }
+XFERMODE(Src)   { return s; }
+XFERMODE(Dst)   { return d; }
+XFERMODE(SrcIn)   { return     s.fastMulDiv255Round(d.alphas()      ); }
+XFERMODE(SrcOut)  { return     s.fastMulDiv255Round(d.alphas().inv()); }
+XFERMODE(SrcOver) { return s + d.fastMulDiv255Round(s.alphas().inv()); }
+XFERMODE(DstIn)   { return SrcIn  ::Xfer(d,s); }
+XFERMODE(DstOut)  { return SrcOut ::Xfer(d,s); }
+XFERMODE(DstOver) { return SrcOver::Xfer(d,s); }
+
+#undef XFERMODE
+
 //  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();
     }
@@ skipping 39 matching lines @@
     static const SkXfermode::Mode kMode = SkXfermode::kPlus_Mode;
 };
 
 //  kModulate_Mode   [Sa * Da, Sc * Dc]
 struct Modulate4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         return check_as_pmfloat(src * dst * inv255);
     }
     static Sk4px Xfer(const Sk4px& src, const Sk4px& dst) {
-        return src.mulWiden(dst).div255RoundNarrow();
+        return src.fastMulDiv255Round(dst);
     }
     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);
         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 inv() is cheap.
-        return src + src.inv().mulWiden(dst).div255RoundNarrow();
+        return src + dst.fastMulDiv255Round(src.inv());
     }
     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());
@@ skipping 39 matching lines @@
 struct Exclusion4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         Sk4f sc = src;
         Sk4f dc = dst;
         Sk4f prod = sc * dc * inv255;
         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();
+        auto p = src.fastMulDiv255Round(dst);
         // 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;
 };
 
 template <typename ProcType>
 class SkT4fXfermode : public SkProcCoeffXfermode {
 public:
@@ skipping 113 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::kClear_Mode:      return SkT4pxXfermode<Clear>::Create(rec);
+        case SkXfermode::kSrc_Mode:        return SkT4pxXfermode<Src>::Create(rec);
+        case SkXfermode::kDst_Mode:        return SkT4pxXfermode<Dst>::Create(rec);
+        case SkXfermode::kSrcOver_Mode:    return SkT4pxXfermode<SrcOver>::Create(rec);
+        case SkXfermode::kDstOver_Mode:    return SkT4pxXfermode<DstOver>::Create(rec);
+        case SkXfermode::kSrcIn_Mode:      return SkT4pxXfermode<SrcIn>::Create(rec);
+        case SkXfermode::kDstIn_Mode:      return SkT4pxXfermode<DstIn>::Create(rec);
+        case SkXfermode::kSrcOut_Mode:     return SkT4pxXfermode<SrcOut>::Create(rec);
+        case SkXfermode::kDstOut_Mode:     return SkT4pxXfermode<DstOut>::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;
@@ skipping 308 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