Clean up remaining users of SkPMFloat

src/opts/SkXfermode_opts.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef Sk4pxXfermode_DEFINED
 #define Sk4pxXfermode_DEFINED
 
 #include "Sk4px.h"
-#include "SkPMFloat.h"
+#include "SkNx.h"
 #include "SkXfermode_proccoeff.h"
 
 namespace {
 
 // Most xfermodes can be done most efficiently 4 pixels at a time in 8 or 16-bit fixed point.
 #define XFERMODE(Name) static Sk4px SK_VECTORCALL Name(Sk4px s, Sk4px d)
 
 XFERMODE(Clear) { return Sk4px::DupPMColor(0); }
 XFERMODE(Src)   { return s; }
 XFERMODE(Dst)   { return d; }
@@ skipping 80 matching lines @@
 
     auto srcover = s + (d * sa.inv()).div255(),
          dstover = d + (s * da.inv()).div255();
     auto alphas = srcover,
          colors = (dsa < sda).thenElse(srcover, dstover);
     return alphas.zeroColors() + colors.zeroAlphas();
 }
 #undef XFERMODE
 
 // Some xfermodes use math like divide or sqrt that's best done in floats 1 pixel at a time.
-#define XFERMODE(Name) static SkPMFloat SK_VECTORCALL Name(SkPMFloat d, SkPMFloat s)
+#define XFERMODE(Name) static Sk4f SK_VECTORCALL Name(Sk4f d, Sk4f s)
+
+static inline Sk4f a_rgb(const Sk4f& a, const Sk4f& rgb) {
+    static_assert(SK_A32_SHIFT == 24, "");
+    return a * Sk4f(0,0,0,1) + rgb * Sk4f(1,1,1,0);
+}
+static inline Sk4f alphas(const Sk4f& f) {
+    return Sk4f(f.kth<SK_A32_SHIFT/8>());
+}
 
 XFERMODE(ColorDodge) {
-    auto sa = s.alphas(),
-         da = d.alphas(),
+    auto sa = alphas(s),
+         da = alphas(d),
          isa = Sk4f(1)-sa,
          ida = Sk4f(1)-da;
 
     auto srcover = s + d*isa,
          dstover = d + s*ida,
          otherwise = sa * Sk4f::Min(da, (d*sa)*(sa-s).approxInvert()) + s*ida + d*isa;
 
     // Order matters here, preferring d==0 over s==sa.
     auto colors = (d == Sk4f(0)).thenElse(dstover,
                   (s ==      sa).thenElse(srcover,
                                           otherwise));
-    return srcover * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1);
+    return a_rgb(srcover, colors);
 }
 XFERMODE(ColorBurn) {
-    auto sa = s.alphas(),
-         da = d.alphas(),
+    auto sa = alphas(s),
+         da = alphas(d),
          isa = Sk4f(1)-sa,
          ida = Sk4f(1)-da;
 
     auto srcover = s + d*isa,
          dstover = d + s*ida,
          otherwise = sa*(da-Sk4f::Min(da, (da-d)*sa*s.approxInvert())) + s*ida + d*isa;
 
     // Order matters here, preferring d==da over s==0.
     auto colors = (d ==      da).thenElse(dstover,
                   (s == Sk4f(0)).thenElse(srcover,
                                           otherwise));
-    return srcover * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1);
+    return a_rgb(srcover, colors);
 }
 XFERMODE(SoftLight) {
-    auto sa = s.alphas(),
-         da = d.alphas(),
+    auto sa = alphas(s),
+         da = alphas(d),
          isa = Sk4f(1)-sa,
          ida = Sk4f(1)-da;
 
     // Some common terms.
     auto m  = (da > Sk4f(0)).thenElse(d / da, Sk4f(0)),
          s2 = Sk4f(2)*s,
          m4 = Sk4f(4)*m;
 
     // The logic forks three ways:
     //    1. dark src?
     //    2. light src, dark dst?
     //    3. light src, light dst?
     auto darkSrc = d*(sa + (s2 - sa)*(Sk4f(1) - m)),        // Used in case 1.
          darkDst = (m4*m4 + m4)*(m - Sk4f(1)) + Sk4f(7)*m,  // Used in case 2.
          liteDst = m.sqrt() - m,                            // Used in case 3.
          liteSrc = d*sa + da*(s2-sa)*(Sk4f(4)*d <= da).thenElse(darkDst, liteDst); // Case 2 or 3?
 
     auto alpha  = s + d*isa;
     auto colors = s*ida + d*isa + (s2 <= sa).thenElse(darkSrc, liteSrc);           // Case 1 or 2/3?
 
-    return alpha * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1);
+    return a_rgb(alpha, colors);
 }
 #undef XFERMODE
 
 // A reasonable fallback mode for doing AA is to simply apply the transfermode first,
 // then linearly interpolate the AA.
 template <Sk4px (SK_VECTORCALL *Mode)(Sk4px, Sk4px)>
 static Sk4px SK_VECTORCALL xfer_aa(Sk4px s, Sk4px d, Sk4px aa) {
     Sk4px bw = Mode(s, d);
     return (bw * aa + d * aa.inv()).div255();
 }
@@ skipping 44 matching lines @@
             });
         }
     }
 
 private:
     Proc4 fProc4;
     AAProc4 fAAProc4;
     typedef SkProcCoeffXfermode INHERITED;
 };
 
-class SkPMFloatXfermode : public SkProcCoeffXfermode {
+class Sk4fXfermode : public SkProcCoeffXfermode {
 public:
-    typedef SkPMFloat (SK_VECTORCALL *ProcF)(SkPMFloat, SkPMFloat);
-    SkPMFloatXfermode(const ProcCoeff& rec, SkXfermode::Mode mode, ProcF procf)
+    typedef Sk4f (SK_VECTORCALL *ProcF)(Sk4f, Sk4f);
+    Sk4fXfermode(const ProcCoeff& rec, SkXfermode::Mode mode, ProcF procf)
         : INHERITED(rec, mode)
         , fProcF(procf) {}
 
     void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
         for (int i = 0; i < n; i++) {
             dst[i] = aa ? this->xfer32(dst[i], src[i], aa[i])
                         : this->xfer32(dst[i], src[i]);
         }
     }
 
     void xfer16(uint16_t dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
         for (int i = 0; i < n; i++) {
             SkPMColor dst32 = SkPixel16ToPixel32(dst[i]);
             dst32 = aa ? this->xfer32(dst32, src[i], aa[i])
                        : this->xfer32(dst32, src[i]);
             dst[i] = SkPixel32ToPixel16(dst32);
         }
     }
 
 private:
+    static Sk4f Load(SkPMColor c) {
+        return Sk4f::FromBytes((uint8_t*)&c) * Sk4f(1.0f/255);
+    }
+    static SkPMColor Round(const Sk4f& f) {
+        SkPMColor c;
+        (f * Sk4f(255) + Sk4f(0.5f)).toBytes((uint8_t*)&c);
+        return c;
+    }
     inline SkPMColor xfer32(SkPMColor dst, SkPMColor src) const {
-        return fProcF(SkPMFloat(dst), SkPMFloat(src)).round();
+        return Round(fProcF(Load(dst), Load(src)));
     }
 
     inline SkPMColor xfer32(SkPMColor dst, SkPMColor src, SkAlpha aa) const {
-        SkPMFloat s(src),
-                  d(dst),
-                  b(fProcF(d,s));
+        Sk4f s(Load(src)),
+             d(Load(dst)),
+             b(fProcF(d,s));
         // We do aa in full float precision before going back down to bytes, because we can!
-        SkPMFloat a = Sk4f(aa) * Sk4f(1.0f/255);
+        Sk4f a = Sk4f(aa) * Sk4f(1.0f/255);
         b = b*a + d*(Sk4f(1)-a);
-        return b.round();
+        return Round(b);
     }
 
     ProcF fProcF;
     typedef SkProcCoeffXfermode INHERITED;
 };
 
 } // namespace
 
 namespace SK_OPTS_NS {
 
 static SkXfermode* create_xfermode(const ProcCoeff& rec, SkXfermode::Mode mode) {
     switch (mode) {
-#define CASE(Mode)                   \
-    case SkXfermode::k##Mode##_Mode: \
-        return new Sk4pxXfermode(rec, mode, &Mode, &xfer_aa<Mode>)
+#define CASE(Mode) \
+    case SkXfermode::k##Mode##_Mode: return new Sk4pxXfermode(rec, mode, &Mode, &xfer_aa<Mode>)
         CASE(Clear);
         CASE(Src);
         CASE(Dst);
         CASE(SrcOver);
         CASE(DstOver);
         CASE(SrcIn);
         CASE(DstIn);
         CASE(SrcOut);
         CASE(DstOut);
         CASE(SrcATop);
         CASE(DstATop);
         CASE(Xor);
         CASE(Plus);
         CASE(Modulate);
         CASE(Screen);
         CASE(Multiply);
         CASE(Difference);
         CASE(Exclusion);
         CASE(HardLight);
         CASE(Overlay);
         CASE(Darken);
         CASE(Lighten);
     #undef CASE
 
-#define CASE(Mode)                   \
-    case SkXfermode::k##Mode##_Mode: \
-        return new SkPMFloatXfermode(rec, mode, &Mode)
+#define CASE(Mode) \
+    case SkXfermode::k##Mode##_Mode: return new Sk4fXfermode(rec, mode, &Mode)
         CASE(ColorDodge);
         CASE(ColorBurn);
         CASE(SoftLight);
     #undef CASE
 
         default: break;
     }
     return nullptr;
 }
 
 } // namespace SK_OPTS_NS
 
 #endif//Sk4pxXfermode_DEFINED