implement more xfermodeproc4f and add GM

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 35 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #include "SkNx.h"
 
 static Sk4f     alpha(const Sk4f& color) { return Sk4f(color.kth<3>()); }
 static Sk4f inv_alpha(const Sk4f& color) { return Sk4f(1 - color.kth<3>()); }
 static Sk4f     pin_1(const Sk4f& value) { return Sk4f::Min(value, Sk4f(1)); }
 
+static Sk4f color_alpha(const Sk4f& color, float newAlpha) {
+    return Sk4f(color.kth<0>(), color.kth<1>(), color.kth<2>(), newAlpha);
+}
+static Sk4f color_alpha(const Sk4f& color, const Sk4f& newAlpha) {
+    return color_alpha(color, newAlpha.kth<3>());
+}
+
+static Sk4f set_argb(float a, float r, float g, float b) {
+    if (0 == SkPM4f::R) {
+        return Sk4f(r, g, b, a);
+    } else {
+        return Sk4f(b, g, r, a);
+    }
+}
+
 static Sk4f    clear_4f(const Sk4f& s, const Sk4f& d) { return Sk4f(0); }
 static Sk4f      src_4f(const Sk4f& s, const Sk4f& d) { return s; }
 static Sk4f      dst_4f(const Sk4f& s, const Sk4f& d) { return d; }
 static Sk4f  srcover_4f(const Sk4f& s, const Sk4f& d) { return s + inv_alpha(s) * d; }
 static Sk4f  dstover_4f(const Sk4f& s, const Sk4f& d) { return d + inv_alpha(d) * s; }
 static Sk4f    srcin_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d); }
 static Sk4f    dstin_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s); }
 static Sk4f   srcout_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d); }
 static Sk4f   dstout_4f(const Sk4f& s, const Sk4f& d) { return d * inv_alpha(s); }
 static Sk4f  srcatop_4f(const Sk4f& s, const Sk4f& d) { return s * alpha(d) + d * inv_alpha(s); }
 static Sk4f  dstatop_4f(const Sk4f& s, const Sk4f& d) { return d * alpha(s) + s * inv_alpha(d); }
 static Sk4f      xor_4f(const Sk4f& s, const Sk4f& d) { return s * inv_alpha(d) + d * inv_alpha(s);}
 static Sk4f     plus_4f(const Sk4f& s, const Sk4f& d) { return pin_1(s + d); }
 static Sk4f modulate_4f(const Sk4f& s, const Sk4f& d) { return s * d; }
 static Sk4f   screen_4f(const Sk4f& s, const Sk4f& d) { return s + d - s * d; }
 
 static Sk4f multiply_4f(const Sk4f& s, const Sk4f& d) {
     return s * inv_alpha(d) + d * inv_alpha(s) + s * d;
 }
 
+static Sk4f overlay_4f(const Sk4f& s, const Sk4f& d) {
+    Sk4f da = alpha(d);
+    Sk4f sa = alpha(s);
+    Sk4f two = Sk4f(2);
+    Sk4f rc = (two * d <= da).thenElse(two * s * d,
+                                       sa * da - two * (da - d) * (sa - s));
+    return color_alpha(s - s * da + d - d * sa + rc, sa + da - sa * da);

[mtklein, 2016/02/09 17:25:51]

I find things a little easier to read if you bind * more tightly than +/-:

S44f rc = (two*d <= da).thenElse(two*s*d,
                                 sa*da - two*(da - d)*(sa-s));
return color_alpha(s - s*da + d - d*sa + rc, 
                   sa + da - sa*da);

We can probably also pull terms out of color_alpha(), doing less redundant math:
   return s + d - s*da + color_alpha(rc - d*sa, 0);

[reed1, 2016/02/09 18:36:19]

I like the shared-expression refactor: done.
Not sure I agree that removing spaces around * helps yet.

+}
+
+static Sk4f darken_4f(const Sk4f& s, const Sk4f& d) {
+    Sk4f sa = alpha(s);
+    Sk4f da = alpha(d);
+    return color_alpha(s + d - Sk4f::Max(s * da, d * sa), sa + da - sa * da);

[mtklein, 2016/02/09 17:25:51]

Aren't color and alpha actually the same math?
    return s + d - Sk4f::Max(s*alpha(d), d*alpha(s));

[reed1, 2016/02/09 18:36:19]

Done.

+}
+
+static Sk4f lighten_4f(const Sk4f& s, const Sk4f& d) {
+    Sk4f sa = alpha(s);
+    Sk4f da = alpha(d);
+    return color_alpha(s + d - Sk4f::Min(s * da, d * sa), sa + da - sa * da);

[mtklein, 2016/02/09 17:25:51]

Same deal?
    return s + d - Sk4f::Min(s*alpha(d), d*alpha(s));

[reed1, 2016/02/09 18:36:19]

Done.

+}
+
+static inline float colordodge_f(float sc, float dc, float sa, float da) {

[mtklein, 2016/02/09 17:25:51]

Let's steal my Sk4f version of this from SkXfermode_opts.h?

[reed1, 2016/02/09 19:10:25]

Done.

+    if (0 == dc) {
+        return sc * (1 - da);
+    }
+    float exor = sc * (1 - da) + dc * (1 - sa);
+    float diff = sa - sc;
+    if (0 == diff) {
+        return sa * da + exor;
+    } else {
+        return sa * SkTMin(da, dc * sa / diff) + exor;
+    }
+}
+static Sk4f colordodge_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<3>();
+    float da = d.kth<3>();
+    return Sk4f(colordodge_f(s.kth<0>(), d.kth<0>(), sa, da),
+                colordodge_f(s.kth<1>(), d.kth<1>(), sa, da),
+                colordodge_f(s.kth<2>(), d.kth<2>(), sa, da),
+                sa + da - sa * da);
+}
+
+static inline float colorburn_f(float sc, float dc, float sa, float da) {
+    if (0 == sc) {
+        return dc * (1 - sa);
+    }
+    float exor = sc * (1 - da) + dc * (1 - sa);
+    float diff = da - dc;
+    if (0 == diff) {
+        return sa * da + exor;
+    } else {
+        return sa * (da - SkTMin(da, diff * sa / sc)) + exor;
+    }
+}
+static Sk4f colorburn_4f(const Sk4f& s, const Sk4f& d) {

[mtklein, 2016/02/09 17:25:52]

Ditto... also got an Sk4f version in SkXfermode_opts.h

[reed1, 2016/02/09 19:10:25]

Done.

+    float sa = s.kth<3>();
+    float da = d.kth<3>();
+    return Sk4f(colorburn_f(s.kth<0>(), d.kth<0>(), sa, da),
+                colorburn_f(s.kth<1>(), d.kth<1>(), sa, da),
+                colorburn_f(s.kth<2>(), d.kth<2>(), sa, da),
+                sa + da - sa * da);
+}
+
+static Sk4f hardlight_4f(const Sk4f& s, const Sk4f& d) {

[mtklein, 2016/02/09 17:25:51]

Let's put overlay and hardlight closer together?  It's not super obvious here
that they're the same function with s and d swapped.

[reed1, 2016/02/09 18:36:19]

Done.

+    Sk4f sa = alpha(s);
+    Sk4f da = alpha(d);
+    Sk4f one = Sk4f(1);
+    Sk4f two = Sk4f(2);
+    Sk4f rc = (two * s <= sa).thenElse(two * s * d,
+                                       sa * da - two * (da - d) * (sa - s));
+    return color_alpha(rc + s * (one - da) + d * (one - sa),
+                       sa + da - sa * da);
+}
+
+static inline float softlight_f(float sc, float dc, float sa, float da) {

[mtklein, 2016/02/09 17:25:52]

Also have a 4f version in SkXfermode_opts.h

[reed1, 2016/02/09 19:10:25]

Done.

+    float m = da ? dc / da : 0;
+    float rc;
+    if (2 * sc <= sa) {
+        rc = dc * (sa + (2 * sc - sa) * (1 - m));
+    } else if (4 * dc <= da) {
+        float tmp = (4 * m * (4 * m + 1) * (m - 1)) + 7 * m;
+        rc = dc * sa + da * (2 * sc - sa) * tmp;
+    } else {
+        float tmp = sqrtf(m) - m;
+        rc = dc * sa + da * (2 * sc - sa) * tmp;
+    }
+    return rc + sc * (1 - da) + dc * (1 - sa);
+}
+static Sk4f softlight_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<3>();
+    float da = d.kth<3>();
+    return Sk4f(softlight_f(s.kth<0>(), d.kth<0>(), sa, da),
+                softlight_f(s.kth<1>(), d.kth<1>(), sa, da),
+                softlight_f(s.kth<2>(), d.kth<2>(), sa, da),
+                sa + da - sa * da);
+}
+
+static Sk4f difference_4f(const Sk4f& s, const Sk4f& d) {
+    Sk4f sa = alpha(s);
+    Sk4f da = alpha(d);
+    return color_alpha(s + d - Sk4f(2) * Sk4f::Min(s * da, d * sa),

[mtklein, 2016/02/09 17:25:51]

I think this is clearer, and maybe cheaper, to pull shared work out of
color_alpha():

auto m = Sk4f::Min(s*alpha(d), d*alpha(s));
return s + d - m - color_alpha(m, 0);

[reed1, 2016/02/09 19:10:25]

Clever. done.

+                       sa + da - sa * da);
+}
+
+static Sk4f exclusion_4f(const Sk4f& s, const Sk4f& d) {
+    Sk4f tmp = s + d - s * d;
+    return color_alpha(tmp - s * d, tmp);

[mtklein, 2016/02/09 17:25:51]

Same sort of thing?

Sk4f screen = s + d - s*d;
return screen - color_alpha(s*d, 0);

[reed1, 2016/02/09 19:10:25]

Done.

+}
+
+////////////////////////////////////////////////////

[mtklein, 2016/02/09 17:25:51]

FYI, didn't pay much attention below here...

+
+// 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 float Lum(float r, float g, float b) {
+    return r * 0.2126f + g * 0.7152f + b * 0.0722f;
+}
+
+static inline float max(float a, float b, float c) {
+    return SkTMax(a, SkTMax(b, c));
+}
+
+static inline float min(float a, float b, float c) {
+    return SkTMin(a, SkTMin(b, c));
+}
+
+static inline float Sat(float r, float g, float b) {
+    return max(r, g, b) - min(r, g, b);
+}
+
+static inline void setSaturationComponents(float* Cmin, float* Cmid, float* Cmax, float s) {
+    if(*Cmax > *Cmin) {
+        *Cmid = (*Cmid - *Cmin) * s / (*Cmax - *Cmin);
+        *Cmax = s;
+    } else {
+        *Cmax = 0;
+        *Cmid = 0;
+    }
+    *Cmin = 0;
+}
+
+static inline void SetSat(float* r, float* g, float* b, float s) {
+    if(*r <= *g) {
+        if(*g <= *b) {
+            setSaturationComponents(r, g, b, s);
+        } else if(*r <= *b) {
+            setSaturationComponents(r, b, g, s);
+        } else {
+            setSaturationComponents(b, r, g, s);
+        }
+    } else if(*r <= *b) {
+        setSaturationComponents(g, r, b, s);
+    } else if(*g <= *b) {
+        setSaturationComponents(g, b, r, s);
+    } else {
+        setSaturationComponents(b, g, r, s);
+    }
+}
+
+static inline void clipColor(float* r, float* g, float* b, float a) {
+    float L = Lum(*r, *g, *b);
+    float n = min(*r, *g, *b);
+    float x = max(*r, *g, *b);
+    float denom;
+    if ((n < 0) && (denom = L - n)) { // Compute denom and make sure it's non zero
+        float scale = L / denom;
+        *r = L + (*r - L) * scale;
+        *g = L + (*g - L) * scale;
+        *b = L + (*b - L) * scale;
+    }
+    
+    if ((x > a) && (denom = x - L)) { // Compute denom and make sure it's non zero
+        float scale = (a - L) / denom;
+        *r = L + (*r - L) * scale;
+        *g = L + (*g - L) * scale;
+        *b = L + (*b - L) * scale;
+    }
+}
+
+static inline void SetLum(float* r, float* g, float* b, float a, float l) {
+    float d = l - Lum(*r, *g, *b);
+    *r += d;
+    *g += d;
+    *b += d;
+    clipColor(r, g, b, a);
+}
+
+static Sk4f hue_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<SkPM4f::A>();
+    float sr = s.kth<SkPM4f::R>();
+    float sg = s.kth<SkPM4f::G>();
+    float sb = s.kth<SkPM4f::B>();
+    
+    float da = d.kth<SkPM4f::A>();
+    float dr = d.kth<SkPM4f::R>();
+    float dg = d.kth<SkPM4f::G>();
+    float db = d.kth<SkPM4f::B>();
+
+    float Sr = sr;
+    float Sg = sg;
+    float Sb = sb;
+    SetSat(&Sr, &Sg, &Sb, Sat(dr, dg, db) * sa);
+    SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa);
+
+    return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg, Sb),
+                       sa + da - sa * da);
+}
+
+static Sk4f saturation_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<SkPM4f::A>();
+    float sr = s.kth<SkPM4f::R>();
+    float sg = s.kth<SkPM4f::G>();
+    float sb = s.kth<SkPM4f::B>();
+    
+    float da = d.kth<SkPM4f::A>();
+    float dr = d.kth<SkPM4f::R>();
+    float dg = d.kth<SkPM4f::G>();
+    float db = d.kth<SkPM4f::B>();
+    
+    float Dr = dr;
+    float Dg = dg;
+    float Db = db;
+    SetSat(&Dr, &Dg, &Db, Sat(sr, sg, sb) * da);
+    SetLum(&Dr, &Dg, &Db, sa * da, Lum(dr, dg, db) * sa);
+    
+    return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg, Db),
+                       sa + da - sa * da);
+}
+
+static Sk4f color_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<SkPM4f::A>();
+    float sr = s.kth<SkPM4f::R>();
+    float sg = s.kth<SkPM4f::G>();
+    float sb = s.kth<SkPM4f::B>();
+    
+    float da = d.kth<SkPM4f::A>();
+    float dr = d.kth<SkPM4f::R>();
+    float dg = d.kth<SkPM4f::G>();
+    float db = d.kth<SkPM4f::B>();
+
+    float Sr = sr;
+    float Sg = sg;
+    float Sb = sb;
+    SetLum(&Sr, &Sg, &Sb, sa * da, Lum(dr, dg, db) * sa);
+    
+    return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg, Sb),
+                       sa + da - sa * da);
+}
+
+static Sk4f luminosity_4f(const Sk4f& s, const Sk4f& d) {
+    float sa = s.kth<SkPM4f::A>();
+    float sr = s.kth<SkPM4f::R>();
+    float sg = s.kth<SkPM4f::G>();
+    float sb = s.kth<SkPM4f::B>();
+    
+    float da = d.kth<SkPM4f::A>();
+    float dr = d.kth<SkPM4f::R>();
+    float dg = d.kth<SkPM4f::G>();
+    float db = d.kth<SkPM4f::B>();
+    
+    float Dr = dr;
+    float Dg = dg;
+    float Db = db;
+    SetLum(&Dr, &Dg, &Db, sa * da, Lum(sr, sg, sb) * da);
+    
+    return color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg, Db),
+                       sa + da - sa * da);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
-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);
-}
-
-template <Sk4f (blend)(const Sk4f&, const Sk4f&)>
-SkPM4f proc_4f(const SkPM4f& src, const SkPM4f& dst) {
-    return as_pm4f(blend(as_4f(src), as_4f(dst)));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-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;
 }
 
 //  kSrc_Mode,      //!< [Sa, Sc]
 static SkPMColor src_modeproc(SkPMColor src, SkPMColor dst) {
     return src;
 }
 
@@ skipping 151 matching lines @@
 }
 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);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+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);
+}
+
+template <Sk4f (blend)(const Sk4f&, const Sk4f&)> SkPM4f proc_4f(const SkPM4f& s, const SkPM4f& d) {
+    SkPM4f r = as_pm4f(blend(as_4f(s), as_4f(d)));
+#ifdef SK_DEBUG
+    const float min = 0;
+    const float max = 1;
+    for (int i = 0; i < 4; ++i) {
+        SkASSERT(r.fVec[i] >= min && r.fVec[i] <= max);
+    }
+#endif
+    return r;
 }
 
 const ProcCoeff gProcCoeffs[] = {
     { clear_modeproc,       proc_4f<clear_4f>,      SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
     { src_modeproc,         proc_4f<src_4f>,        SkXfermode::kOne_Coeff,     SkXfermode::kZero_Coeff },
     { dst_modeproc,         proc_4f<dst_4f>,        SkXfermode::kZero_Coeff,    SkXfermode::kOne_Coeff  },
     { srcover_modeproc,     proc_4f<srcover_4f>,    SkXfermode::kOne_Coeff,     SkXfermode::kISA_Coeff  },
     { dstover_modeproc,     proc_4f<dstover_4f>,    SkXfermode::kIDA_Coeff,     SkXfermode::kOne_Coeff  },
     { srcin_modeproc,       proc_4f<srcin_4f>,      SkXfermode::kDA_Coeff,      SkXfermode::kZero_Coeff },
     { dstin_modeproc,       proc_4f<dstin_4f>,      SkXfermode::kZero_Coeff,    SkXfermode::kSA_Coeff   },
     { srcout_modeproc,      proc_4f<srcout_4f>,     SkXfermode::kIDA_Coeff,     SkXfermode::kZero_Coeff },
     { dstout_modeproc,      proc_4f<dstout_4f>,     SkXfermode::kZero_Coeff,    SkXfermode::kISA_Coeff  },
     { srcatop_modeproc,     proc_4f<srcatop_4f>,    SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff  },
     { dstatop_modeproc,     proc_4f<dstatop_4f>,    SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff   },
     { xor_modeproc,         proc_4f<xor_4f>,        SkXfermode::kIDA_Coeff,     SkXfermode::kISA_Coeff  },
 
     { plus_modeproc,        proc_4f<plus_4f>,       SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff  },
     { modulate_modeproc,    proc_4f<modulate_4f>,   SkXfermode::kZero_Coeff,    SkXfermode::kSC_Coeff   },
     { screen_modeproc,      proc_4f<screen_4f>,     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 },
+    { overlay_modeproc,     proc_4f<overlay_4f>,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { darken_modeproc,      proc_4f<darken_4f>,     CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { lighten_modeproc,     proc_4f<lighten_4f>,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { colordodge_modeproc,  proc_4f<colordodge_4f>, CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { colorburn_modeproc,   proc_4f<colorburn_4f>,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { hardlight_modeproc,   proc_4f<hardlight_4f>,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { softlight_modeproc,   proc_4f<softlight_4f>,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { difference_modeproc,  proc_4f<difference_4f>, CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { exclusion_modeproc,   proc_4f<exclusion_4f>,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { multiply_modeproc,    proc_4f<multiply_4f>,   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 },
+    { hue_modeproc,         proc_4f<hue_4f>,        CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { saturation_modeproc,  proc_4f<saturation_4f>, CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { color_modeproc,       proc_4f<color_4f>,      CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { luminosity_modeproc,  proc_4f<luminosity_4f>, CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkXfermode::asMode(Mode* mode) const {
     return false;
 }
 
 #if SK_SUPPORT_GPU
 const GrFragmentProcessor* SkXfermode::getFragmentProcessorForImageFilter(
@@ skipping 412 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