some modes need clamping due to numerical imprecision

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 302 matching lines @@
     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);
+    Sk4f res = color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Sr, Sg, Sb),
+                           sa + da - sa * da);
+    // Can return tiny negative values ...
+    return Sk4f::Max(res, Sk4f(0));
 }
 
 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);
+    Sk4f res = color_alpha(s * inv_alpha(d) + d * inv_alpha(s) + set_argb(0, Dr, Dg, Db),
+                           sa + da - sa * da);
+    // Can return tiny negative values ...
+    return Sk4f::Max(res, Sk4f(0));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 //  kClear_Mode,    //!< [0, 0]
 static SkPMColor clear_modeproc(SkPMColor src, SkPMColor dst) {
     return 0;
 }
 
 //  kSrc_Mode,      //!< [Sa, Sc]
@@ skipping 559 matching lines @@
 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)));
+static void assert_unit(const SkPM4f& r) {
 #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
+}
+
+template <Sk4f (blend)(const Sk4f&, const Sk4f&)> SkPM4f proc_4f(const SkPM4f& s, const SkPM4f& d) {
+    assert_unit(s);
+    assert_unit(d);
+    SkPM4f r = as_pm4f(blend(as_4f(s), as_4f(d)));
+    assert_unit(r);
     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 },
@@ skipping 446 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