extend modecolorfilter to 4f

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_proccoeff.h"
 #include "SkColorPriv.h"
@@ skipping 29 matching lines @@
     if (prod <= 0) {
         return 0;
     } else if (prod >= 255*255) {
         return 255;
     } else {
         return SkDiv255Round(prod);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+#include "SkNx.h"
+
+static SkPM4f as_pm4f(const Sk4f& x) {
+    SkPM4f pm4;
+    x.store(pm4.fVec);
+    return pm4;
+}
+
+static Sk4f as_4f(const SkPM4f& pm4) {
+    return Sk4f::Load(pm4.fVec);
+}
+
+static SkPM4f not_implemented_yet_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return {{ 0.5f, 1.0f, 0.25f, 0.5f }};
+}
 
 //  kClear_Mode,    //!< [0, 0]
 static SkPMColor clear_modeproc(SkPMColor src, SkPMColor dst) {
     return 0;
 }
+static SkPM4f clear_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return{{ 0, 0, 0, 0 }};
+}
 
 //  kSrc_Mode,      //!< [Sa, Sc]
 static SkPMColor src_modeproc(SkPMColor src, SkPMColor dst) {
     return src;
 }
+static SkPM4f src_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return src;
+}
 
 //  kDst_Mode,      //!< [Da, Dc]
 static SkPMColor dst_modeproc(SkPMColor src, SkPMColor dst) {
     return dst;
 }
+static SkPM4f dst_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return dst;
+}
 
 //  kSrcOver_Mode,  //!< [Sa + Da - Sa*Da, Sc + (1 - Sa)*Dc]
 static SkPMColor srcover_modeproc(SkPMColor src, SkPMColor dst) {
 #if 0
     // this is the old, more-correct way, but it doesn't guarantee that dst==255
     // will always stay opaque
     return src + SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src)));
 #else
     // this is slightly faster, but more importantly guarantees that dst==255
     // will always stay opaque
     return src + SkAlphaMulQ(dst, 256 - SkGetPackedA32(src));
 #endif
 }
+static SkPM4f srcover_proc4f(const SkPM4f& src, const SkPM4f& dst) {

[mtklein, 2016/02/08 18:27:22]

Maybe we can make these easier to read with some little wrappers?

E.g.

template <Sk4f (*Proc)(const Sk4f&, const Sk4f&)>
SkPM4f proc_4f(const SkPM4f& src, const SkPM4f& dst) {
   return as_pm4f(Proc(as_4f(src), as_4f(dst));
}

static Sk4f alpha(const Sk4f& x) {
   return Sk4f(x.kth<SkPM4f::A>());
}

then write all these as

static Sk4f srcover_4f(const Sk4f& src, const Sk4f& dst) {
    return src + dst * (1 - alpha(src));
}
...
static Sk4f xor_4f(const Sk4f& src, const Sk4f& dst) {
    return src * (1 - alpha(dst)) + dst * (1-alpha(src));
}

and make the table as

    proc_4f<srcover_4f>,
    ...
    proc_4f<xor_4f>,

[reed1, 2016/02/08 19:52:49]

Done.

+    return as_pm4f(as_4f(src) + as_4f(dst) * Sk4f(1 - src.a()));
+}
 
 //  kDstOver_Mode,  //!< [Sa + Da - Sa*Da, Dc + (1 - Da)*Sc]
 static SkPMColor dstover_modeproc(SkPMColor src, SkPMColor dst) {
     // this is the reverse of srcover, just flipping src and dst
     // see srcover's comment about the 256 for opaqueness guarantees
     return dst + SkAlphaMulQ(src, 256 - SkGetPackedA32(dst));
 }
+static SkPM4f dstover_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(dst) + as_4f(src) * Sk4f(1 - dst.a()));

[mtklein, 2016/02/08 18:27:22]

return srcover_proc4f(dst, src);  etc ?

+}
 
 //  kSrcIn_Mode,    //!< [Sa * Da, Sc * Da]
 static SkPMColor srcin_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(src, SkAlpha255To256(SkGetPackedA32(dst)));
 }
+static SkPM4f srcin_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(src) * Sk4f(dst.a()));
+}
 
 //  kDstIn_Mode,    //!< [Sa * Da, Sa * Dc]
 static SkPMColor dstin_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(dst, SkAlpha255To256(SkGetPackedA32(src)));
 }
+static SkPM4f dstin_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(dst) * Sk4f(src.a()));
+}
 
 //  kSrcOut_Mode,   //!< [Sa * (1 - Da), Sc * (1 - Da)]
 static SkPMColor srcout_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(src, SkAlpha255To256(255 - SkGetPackedA32(dst)));
 }
+static SkPM4f srcout_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(src) * Sk4f(1 - dst.a()));
+}
 
 //  kDstOut_Mode,   //!< [Da * (1 - Sa), Dc * (1 - Sa)]
 static SkPMColor dstout_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src)));
 }
+static SkPM4f dstout_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(dst) * Sk4f(1 - src.a()));
+}
 
 //  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
 static SkPMColor srcatop_modeproc(SkPMColor src, SkPMColor dst) {
     unsigned sa = SkGetPackedA32(src);
     unsigned da = SkGetPackedA32(dst);
     unsigned isa = 255 - sa;
 
     return SkPackARGB32(da,
                         SkAlphaMulAlpha(da, SkGetPackedR32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedR32(dst)),
                         SkAlphaMulAlpha(da, SkGetPackedG32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedG32(dst)),
                         SkAlphaMulAlpha(da, SkGetPackedB32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedB32(dst)));
 }
+static SkPM4f srcatop_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(src) * Sk4f(dst.a()) + as_4f(dst) * Sk4f(1 - src.a()));
+}
 
 //  kDstATop_Mode,  //!< [Sa, Sa * Dc + Sc * (1 - Da)]
 static SkPMColor dstatop_modeproc(SkPMColor src, SkPMColor dst) {
     unsigned sa = SkGetPackedA32(src);
     unsigned da = SkGetPackedA32(dst);
     unsigned ida = 255 - da;
 
     return SkPackARGB32(sa,
                         SkAlphaMulAlpha(ida, SkGetPackedR32(src)) +
                             SkAlphaMulAlpha(sa, SkGetPackedR32(dst)),
                         SkAlphaMulAlpha(ida, SkGetPackedG32(src)) +
                             SkAlphaMulAlpha(sa, SkGetPackedG32(dst)),
                         SkAlphaMulAlpha(ida, SkGetPackedB32(src)) +
                             SkAlphaMulAlpha(sa, SkGetPackedB32(dst)));
 }
+static SkPM4f dstatop_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(dst) * Sk4f(src.a()) + as_4f(src) * Sk4f(1 - dst.a()));
+}
 
 //  kXor_Mode   [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
 static SkPMColor xor_modeproc(SkPMColor src, SkPMColor dst) {
     unsigned sa = SkGetPackedA32(src);
     unsigned da = SkGetPackedA32(dst);
     unsigned isa = 255 - sa;
     unsigned ida = 255 - da;
 
     return SkPackARGB32(sa + da - (SkAlphaMulAlpha(sa, da) << 1),
                         SkAlphaMulAlpha(ida, SkGetPackedR32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedR32(dst)),
                         SkAlphaMulAlpha(ida, SkGetPackedG32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedG32(dst)),
                         SkAlphaMulAlpha(ida, SkGetPackedB32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedB32(dst)));
 }
+static SkPM4f xor_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(src) * Sk4f(1 - dst.a()) + as_4f(dst) * Sk4f(1 - src.a()));
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // kPlus_Mode
 static SkPMColor plus_modeproc(SkPMColor src, SkPMColor dst) {
     unsigned b = saturated_add(SkGetPackedB32(src), SkGetPackedB32(dst));
     unsigned g = saturated_add(SkGetPackedG32(src), SkGetPackedG32(dst));
     unsigned r = saturated_add(SkGetPackedR32(src), SkGetPackedR32(dst));
     unsigned a = saturated_add(SkGetPackedA32(src), SkGetPackedA32(dst));
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f plus_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(Sk4f::Min(as_4f(src) + as_4f(dst), Sk4f(1)));
+}
 
 // kModulate_Mode
 static SkPMColor modulate_modeproc(SkPMColor src, SkPMColor dst) {
     int a = SkAlphaMulAlpha(SkGetPackedA32(src), SkGetPackedA32(dst));
     int r = SkAlphaMulAlpha(SkGetPackedR32(src), SkGetPackedR32(dst));
     int g = SkAlphaMulAlpha(SkGetPackedG32(src), SkGetPackedG32(dst));
     int b = SkAlphaMulAlpha(SkGetPackedB32(src), SkGetPackedB32(dst));
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f modulate_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return as_pm4f(as_4f(src) * as_4f(dst));
+}
 
 static inline int srcover_byte(int a, int b) {
     return a + b - SkAlphaMulAlpha(a, b);
 }
 
 // kMultiply_Mode
 // B(Cb, Cs) = Cb x Cs
 // multiply uses its own version of blendfunc_byte because sa and da are not needed
 static int blendfunc_multiply_byte(int sc, int dc, int sa, int da) {
     return clamp_div255round(sc * (255 - da)  + dc * (255 - sa)  + sc * dc);
 }
 
 static SkPMColor multiply_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = blendfunc_multiply_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = blendfunc_multiply_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = blendfunc_multiply_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f multiply_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    const Sk4f s4 = as_4f(src);
+    const Sk4f d4 = as_4f(dst);
+    const Sk4f r4 = s4 * Sk4f(1 - dst.a()) + d4 * Sk4f(1 - src.a()) + s4 * d4;
+    return as_pm4f(Sk4f::Min(r4, Sk4f(1)));
+}
 
 // kScreen_Mode
 static SkPMColor screen_modeproc(SkPMColor src, SkPMColor dst) {
     int a = srcover_byte(SkGetPackedA32(src), SkGetPackedA32(dst));
     int r = srcover_byte(SkGetPackedR32(src), SkGetPackedR32(dst));
     int g = srcover_byte(SkGetPackedG32(src), SkGetPackedG32(dst));
     int b = srcover_byte(SkGetPackedB32(src), SkGetPackedB32(dst));
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f screen_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    const Sk4f s4 = as_4f(src);
+    const Sk4f d4 = as_4f(dst);
+    return as_pm4f(s4 + d4 - s4 * d4);
+}
 
 // kOverlay_Mode
 static inline int overlay_byte(int sc, int dc, int sa, int da) {
     int tmp = sc * (255 - da) + dc * (255 - sa);
     int rc;
     if (2 * dc <= da) {
         rc = 2 * sc * dc;
     } else {
         rc = sa * da - 2 * (da - dc) * (sa - sc);
     }
     return clamp_div255round(rc + tmp);
 }
 static SkPMColor overlay_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = overlay_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = overlay_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = overlay_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f overlay_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kDarken_Mode
 static inline int darken_byte(int sc, int dc, int sa, int da) {
     int sd = sc * da;
     int ds = dc * sa;
     if (sd < ds) {
         // srcover
         return sc + dc - SkDiv255Round(ds);
     } else {
         // dstover
         return dc + sc - SkDiv255Round(sd);
     }
 }
 static SkPMColor darken_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = darken_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = darken_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = darken_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f darken_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kLighten_Mode
 static inline int lighten_byte(int sc, int dc, int sa, int da) {
     int sd = sc * da;
     int ds = dc * sa;
     if (sd > ds) {
         // srcover
         return sc + dc - SkDiv255Round(ds);
     } else {
         // dstover
         return dc + sc - SkDiv255Round(sd);
     }
 }
 static SkPMColor lighten_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = lighten_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = lighten_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = lighten_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f lighten_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kColorDodge_Mode
 static inline int colordodge_byte(int sc, int dc, int sa, int da) {
     int diff = sa - sc;
     int rc;
     if (0 == dc) {
         return SkAlphaMulAlpha(sc, 255 - da);
     } else if (0 == diff) {
         rc = sa * da + sc * (255 - da) + dc * (255 - sa);
     } else {
         diff = dc * sa / diff;
         rc = sa * ((da < diff) ? da : diff) + sc * (255 - da) + dc * (255 - sa);
     }
     return clamp_div255round(rc);
 }
 static SkPMColor colordodge_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = colordodge_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = colordodge_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = colordodge_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f colordodge_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kColorBurn_Mode
 static inline int colorburn_byte(int sc, int dc, int sa, int da) {
     int rc;
     if (dc == da) {
         rc = sa * da + sc * (255 - da) + dc * (255 - sa);
     } else if (0 == sc) {
         return SkAlphaMulAlpha(dc, 255 - sa);
     } else {
         int tmp = (da - dc) * sa / sc;
         rc = sa * (da - ((da < tmp) ? da : tmp))
             + sc * (255 - da) + dc * (255 - sa);
     }
     return clamp_div255round(rc);
 }
 static SkPMColor colorburn_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = colorburn_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = colorburn_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = colorburn_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f colorburn_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kHardLight_Mode
 static inline int hardlight_byte(int sc, int dc, int sa, int da) {
     int rc;
     if (2 * sc <= sa) {
         rc = 2 * sc * dc;
     } else {
         rc = sa * da - 2 * (da - dc) * (sa - sc);
     }
     return clamp_div255round(rc + sc * (255 - da) + dc * (255 - sa));
 }
 static SkPMColor hardlight_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = hardlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = hardlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = hardlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f hardlight_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // returns 255 * sqrt(n/255)
 static U8CPU sqrt_unit_byte(U8CPU n) {
     return SkSqrtBits(n, 15+4);
 }
 
 // kSoftLight_Mode
 static inline int softlight_byte(int sc, int dc, int sa, int da) {
     int m = da ? dc * 256 / da : 0;
     int rc;
@@ skipping 10 matching lines @@
 }
 static SkPMColor softlight_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = softlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = softlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = softlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f softlight_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kDifference_Mode
 static inline int difference_byte(int sc, int dc, int sa, int da) {
     int tmp = SkMin32(sc * da, dc * sa);
     return clamp_signed_byte(sc + dc - 2 * SkDiv255Round(tmp));
 }
 static SkPMColor difference_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = difference_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = difference_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = difference_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f difference_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kExclusion_Mode
 static inline int exclusion_byte(int sc, int dc, int, int) {
     // this equations is wacky, wait for SVG to confirm it
     //int r = sc * da + dc * sa - 2 * sc * dc + sc * (255 - da) + dc * (255 - sa);
 
     // The above equation can be simplified as follows
     int r = 255*(sc + dc) - 2 * sc * dc;
     return clamp_div255round(r);
 }
 static SkPMColor exclusion_modeproc(SkPMColor src, SkPMColor dst) {
     int sa = SkGetPackedA32(src);
     int da = SkGetPackedA32(dst);
     int a = srcover_byte(sa, da);
     int r = exclusion_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
     int g = exclusion_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
     int b = exclusion_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f exclusion_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // The CSS compositing spec introduces the following formulas:
 // (See https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blendingnonseparable)
 // SkComputeLuminance is similar to this formula but it uses the new definition from Rec. 709
 // while PDF and CG uses the one from Rec. Rec. 601
 // See http://www.glennchan.info/articles/technical/hd-versus-sd-color-space/hd-versus-sd-color-space.htm
 static inline int Lum(int r, int g, int b)
 {
     return SkDiv255Round(r * 77 + g * 150 + b * 28);
 }
@@ skipping 95 matching lines @@
         Sg = 0;
         Sb = 0;
     }
 
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f hue_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kSaturation_Mode
 // B(Cb, Cs) = SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb))
 // Create a color with the saturation of the source color and the hue and luminosity of the backdrop color.
 static SkPMColor saturation_modeproc(SkPMColor src, SkPMColor dst) {
     int sr = SkGetPackedR32(src);
     int sg = SkGetPackedG32(src);
     int sb = SkGetPackedB32(src);
     int sa = SkGetPackedA32(src);
 
@@ skipping 14 matching lines @@
         Dg = 0;
         Db = 0;
     }
 
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f saturation_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kColor_Mode
 // B(Cb, Cs) = SetLum(Cs, Lum(Cb))
 // Create a color with the hue and saturation of the source color and the luminosity of the backdrop color.
 static SkPMColor color_modeproc(SkPMColor src, SkPMColor dst) {
     int sr = SkGetPackedR32(src);
     int sg = SkGetPackedG32(src);
     int sb = SkGetPackedB32(src);
     int sa = SkGetPackedA32(src);
 
@@ skipping 13 matching lines @@
         Sg = 0;
         Sb = 0;
     }
 
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Sr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Sg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Sb);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f color_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 // kLuminosity_Mode
 // B(Cb, Cs) = SetLum(Cb, Lum(Cs))
 // Create a color with the luminosity of the source color and the hue and saturation of the backdrop color.
 static SkPMColor luminosity_modeproc(SkPMColor src, SkPMColor dst) {
     int sr = SkGetPackedR32(src);
     int sg = SkGetPackedG32(src);
     int sb = SkGetPackedB32(src);
     int sa = SkGetPackedA32(src);
 
@@ skipping 13 matching lines @@
         Dg = 0;
         Db = 0;
     }
 
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
     return SkPackARGB32(a, r, g, b);
 }
+static SkPM4f luminosity_proc4f(const SkPM4f& src, const SkPM4f& dst) {
+    return not_implemented_yet_proc4f(src, dst);
+}
 
 const ProcCoeff gProcCoeffs[] = {
-    { clear_modeproc,   SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
-    { src_modeproc,     SkXfermode::kOne_Coeff,     SkXfermode::kZero_Coeff },
-    { dst_modeproc,     SkXfermode::kZero_Coeff,    SkXfermode::kOne_Coeff },
-    { srcover_modeproc, SkXfermode::kOne_Coeff,     SkXfermode::kISA_Coeff },
-    { dstover_modeproc, SkXfermode::kIDA_Coeff,     SkXfermode::kOne_Coeff },
-    { srcin_modeproc,   SkXfermode::kDA_Coeff,      SkXfermode::kZero_Coeff },
-    { dstin_modeproc,   SkXfermode::kZero_Coeff,    SkXfermode::kSA_Coeff },
-    { srcout_modeproc,  SkXfermode::kIDA_Coeff,     SkXfermode::kZero_Coeff },
-    { dstout_modeproc,  SkXfermode::kZero_Coeff,    SkXfermode::kISA_Coeff },
-    { srcatop_modeproc, SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff },
-    { dstatop_modeproc, SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff },
-    { xor_modeproc,     SkXfermode::kIDA_Coeff,     SkXfermode::kISA_Coeff },
+    { clear_modeproc,       clear_proc4f,   SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
+    { src_modeproc,         src_proc4f,   SkXfermode::kOne_Coeff,     SkXfermode::kZero_Coeff },
+    { dst_modeproc,         dst_proc4f,   SkXfermode::kZero_Coeff,    SkXfermode::kOne_Coeff },
+    { srcover_modeproc,     srcover_proc4f,   SkXfermode::kOne_Coeff,     SkXfermode::kISA_Coeff },
+    { dstover_modeproc,     dstover_proc4f,   SkXfermode::kIDA_Coeff,     SkXfermode::kOne_Coeff },
+    { srcin_modeproc,       srcin_proc4f,   SkXfermode::kDA_Coeff,      SkXfermode::kZero_Coeff },
+    { dstin_modeproc,       dstin_proc4f,   SkXfermode::kZero_Coeff,    SkXfermode::kSA_Coeff },
+    { srcout_modeproc,      srcout_proc4f,   SkXfermode::kIDA_Coeff,     SkXfermode::kZero_Coeff },
+    { dstout_modeproc,      dstout_proc4f,   SkXfermode::kZero_Coeff,    SkXfermode::kISA_Coeff },
+    { srcatop_modeproc,     srcatop_proc4f,   SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff },
+    { dstatop_modeproc,     dstatop_proc4f,   SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff },
+    { xor_modeproc,         xor_proc4f,   SkXfermode::kIDA_Coeff,     SkXfermode::kISA_Coeff },
 
-    { plus_modeproc,    SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff },
-    { modulate_modeproc,SkXfermode::kZero_Coeff,    SkXfermode::kSC_Coeff },
-    { screen_modeproc,  SkXfermode::kOne_Coeff,     SkXfermode::kISC_Coeff },
-    { overlay_modeproc,     CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { darken_modeproc,      CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { lighten_modeproc,     CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { colordodge_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { colorburn_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { hardlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { softlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { difference_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { exclusion_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { multiply_modeproc,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { hue_modeproc,         CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { saturation_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { color_modeproc,       CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { luminosity_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { plus_modeproc,        plus_proc4f,   SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff },
+    { modulate_modeproc,    modulate_proc4f,   SkXfermode::kZero_Coeff,    SkXfermode::kSC_Coeff },
+    { screen_modeproc,      screen_proc4f,   SkXfermode::kOne_Coeff,     SkXfermode::kISC_Coeff },
+    { overlay_modeproc,     overlay_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { darken_modeproc,      darken_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { lighten_modeproc,     lighten_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { colordodge_modeproc,  colordodge_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { colorburn_modeproc,   colorburn_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { hardlight_modeproc,   hardlight_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { softlight_modeproc,   softlight_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { difference_modeproc,  difference_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { exclusion_modeproc,   exclusion_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { multiply_modeproc,    multiply_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { hue_modeproc,         hue_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { saturation_modeproc,  saturation_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { color_modeproc,       color_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { luminosity_modeproc,  luminosity_proc4f,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkXfermode::asMode(Mode* mode) const {
     return false;
 }
 
 bool SkXfermode::asFragmentProcessor(const GrFragmentProcessor**,
                                      const GrFragmentProcessor*) const {
@@ skipping 344 matching lines @@
 }
 
 SkXfermodeProc SkXfermode::GetProc(Mode mode) {
     SkXfermodeProc  proc = nullptr;
     if ((unsigned)mode < kModeCount) {
         proc = gProcCoeffs[mode].fProc;
     }
     return proc;
 }
 
+SkXfermodeProc4f SkXfermode::GetProc4f(Mode mode) {
+    SkXfermodeProc4f  proc = nullptr;
+    if ((unsigned)mode < kModeCount) {
+        proc = gProcCoeffs[mode].fProc4f;
+    }
+    return proc;
+}
+
 bool SkXfermode::ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst) {
     SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
 
     if ((unsigned)mode >= (unsigned)kModeCount) {
         // illegal mode parameter
         return false;
     }
 
     const ProcCoeff& rec = gProcCoeffs[mode];
 
@@ skipping 44 matching lines @@
     if (!xfer) {
         return SkXfermode::kOpaque_SrcColorOpacity == opacityType;
     }
 
     return xfer->isOpaque(opacityType);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END