Color dodge and burn with SkPMFloat.

src/core/Sk4pxXfermode.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"
 
 // This file is possibly included into multiple .cpp files.
 // Each gets its own independent instantiation by wrapping in an anonymous namespace.
 namespace {
 
+// Most xfermodes can be done most efficiently 4 pixels at a time in 8 or 16-bit fixed point.
 #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::DupPMColor(0); }
 XFERMODE(Src)   { return s; }
 XFERMODE(Dst)   { return d; }
@@ skipping 63 matching lines @@
 }
 XFERMODE(Lighten) {
     auto sda = s.approxMulDiv255(d.alphas()),
          dsa = d.approxMulDiv255(s.alphas());
     auto srcover = s + (d - dsa),
          dstover = d + (s - sda);
     auto alphas = srcover,
          colors = (sda < dsa).thenElse(dstover, srcover);
     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) \
+    struct Name {                                                         \
+        static SkPMFloat Xfer(const SkPMFloat&, const SkPMFloat&);        \
+        static const SkXfermode::Mode kMode = SkXfermode::k##Name##_Mode; \
+    };                                                                    \
+    inline SkPMFloat Name::Xfer(const SkPMFloat& s, const SkPMFloat& d)
+
+XFERMODE(ColorDodge) {
+    auto sa = s.alphas(),
+         da = d.alphas(),
+         isa = Sk4f(1)-sa,
+         ida = Sk4f(1)-da;
+
+    auto srcover = s + d*isa,
+         dstover = d + s*ida;
+
+    auto colors = (d == Sk4f(0)).thenElse(dstover,
+                  (s ==      sa).thenElse(srcover,
+        sa * Sk4f::Min(da, (d*sa)*(sa-s).approxInvert()) + s*ida + d*isa));
+
+    return srcover * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1);
+}
+XFERMODE(ColorBurn) {
+    auto sa = s.alphas(),
+         da = d.alphas(),
+         isa = Sk4f(1)-sa,
+         ida = Sk4f(1)-da;
+
+    auto srcover = s + d*isa,
+         dstover = d + s*ida;
+
+    auto colors = (d ==      da).thenElse(dstover,
+                  (s == Sk4f(0)).thenElse(srcover,
+        sa*(da-Sk4f::Min(da, (da-d)*sa*s.approxInvert())) + s*ida + d*isa));
+
+    return srcover * SkPMFloat(1,0,0,0) + colors * SkPMFloat(0,1,1,1);
+}
 #undef XFERMODE
 
 // A reasonable fallback mode for doing AA is to simply apply the transfermode first,
 // then linearly interpolate the AA.
 template <typename Mode>
 static Sk4px xfer_aa(const Sk4px& s, const Sk4px& d, const Sk4px& aa) {
     Sk4px bw = Mode::Xfer(s, d);
     return (bw * aa + d * aa.inv()).div255();
 }
 
@@ skipping 22 matching lines @@
             });
         } else {
             Sk4px::MapDstSrcAlpha(n, dst, src, aa,
                     [&](const Sk4px& dst4, const Sk4px& src4, const Sk4px& alpha) {
                 return xfer_aa<ProcType>(src4, dst4, alpha);
             });
         }
     }
 
 private:
-    SkT4pxXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, ProcType::kMode) {}
+    SkT4pxXfermode(const ProcCoeff& rec) : INHERITED(rec, ProcType::kMode) {}
 
     typedef SkProcCoeffXfermode INHERITED;
 };
+
+template <typename ProcType>
+class SkTPMFloatXfermode : public SkProcCoeffXfermode {
+public:
+    static SkProcCoeffXfermode* Create(const ProcCoeff& rec) {
+        return SkNEW_ARGS(SkTPMFloatXfermode, (rec));
+    }
+
+    void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
+        for (int i = 0; i < n; i++) {
+            SkPMFloat s(src[i]),
+                      d(dst[i]),
+                      b(ProcType::Xfer(s,d));
+            if (aa) {
+                SkPMFloat a = Sk4f(aa[i]) * Sk4f(1.0f/255);
+                b = b*a + d*(Sk4f(1)-a);
+            }
+            dst[i] = b.round();
+        }
+    }
+
+private:
+    SkTPMFloatXfermode(const ProcCoeff& rec) : INHERITED(rec, ProcType::kMode) {}
+
+    typedef SkProcCoeffXfermode INHERITED;
+};
 
 static SkProcCoeffXfermode* SkCreate4pxXfermode(const ProcCoeff& rec, SkXfermode::Mode mode) {
 #if !defined(SK_CPU_ARM32) || defined(SK_ARM_HAS_NEON)
     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<SrcATop>::Create(rec);
         case SkXfermode::kDstATop_Mode:    return SkT4pxXfermode<DstATop>::Create(rec);
         case SkXfermode::kXor_Mode:        return SkT4pxXfermode<Xor>::Create(rec);
         case SkXfermode::kPlus_Mode:       return SkT4pxXfermode<Plus>::Create(rec);
         case SkXfermode::kModulate_Mode:   return SkT4pxXfermode<Modulate>::Create(rec);
         case SkXfermode::kScreen_Mode:     return SkT4pxXfermode<Screen>::Create(rec);
         case SkXfermode::kMultiply_Mode:   return SkT4pxXfermode<Multiply>::Create(rec);
         case SkXfermode::kDifference_Mode: return SkT4pxXfermode<Difference>::Create(rec);
         case SkXfermode::kExclusion_Mode:  return SkT4pxXfermode<Exclusion>::Create(rec);
 #if !defined(SK_SUPPORT_LEGACY_XFERMODES)  // For staging in Chrome (layout tests).
         case SkXfermode::kHardLight_Mode:  return SkT4pxXfermode<HardLight>::Create(rec);
         case SkXfermode::kOverlay_Mode:    return SkT4pxXfermode<Overlay>::Create(rec);
         case SkXfermode::kDarken_Mode:     return SkT4pxXfermode<Darken>::Create(rec);
         case SkXfermode::kLighten_Mode:    return SkT4pxXfermode<Lighten>::Create(rec);
+
+        case SkXfermode::kColorDodge_Mode: return SkTPMFloatXfermode<ColorDodge>::Create(rec);
+        case SkXfermode::kColorBurn_Mode:  return SkTPMFloatXfermode<ColorBurn>::Create(rec);
 #endif
         default: break;
     }
 #endif
     return nullptr;
 }
 
 } // namespace
 
 #endif//Sk4pxXfermode_DEFINED