implement more blendmodes for skvm

Change-Id: Ib7286235249f9b4027c1c59c9fae268a9dffefcd
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/278096
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Mike Reed <reed@google.com>

Author: reed-at-google

src/core/SkBlendModePriv.h

@@ -11,7 +11,6 @@
 #include "include/core/SkBlendMode.h"
 #include "include/core/SkColor.h"
 #include "include/private/SkColorData.h"
-#include "src/core/SkVM.h"
 
 class SkRasterPipeline;
 
@@ -31,9 +30,4 @@ SkPMColor4f SkBlendMode_Apply(SkBlendMode, const SkPMColor4f& src, const SkPMCol
 const GrXPFactory* SkBlendMode_AsXPFactory(SkBlendMode);
 #endif
 
-namespace skvm {
-    bool BlendModeSupported(SkBlendMode);
-    Color BlendModeProgram(Builder*, SkBlendMode, Color src, Color dst);
-}
-
 #endif

src/core/SkVM.h

@@ -8,7 +8,7 @@
 #ifndef SkVM_DEFINED
 #define SkVM_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/core/SkBlendMode.h"
 #include "include/private/SkMacros.h"
 #include "include/private/SkTHash.h"
 #include "src/core/SkVM_fwd.h"
@@ -566,6 +566,7 @@ namespace skvm {
         Color   premul(Color c) {   this->premul(&c.r, &c.g, &c.b, c.a); return c; }
         Color unpremul(Color c) { this->unpremul(&c.r, &c.g, &c.b, c.a); return c; }
         Color lerp(Color lo, Color hi, F32 t);
+        Color blend(SkBlendMode, Color src, Color dst);
 
         void dump(SkWStream* = nullptr) const;
         void dot (SkWStream* = nullptr, bool for_jit=false) const;
@@ -689,6 +690,8 @@ namespace skvm {
         std::unique_ptr<Impl> fImpl;
     };
 
+    bool BlendModeSupported(SkBlendMode);
+
     // TODO: control flow
     // TODO: 64-bit values?
     // TODO: SSE2/SSE4.1, AVX-512F, ARMv8.2 JITs?

src/core/SkVMBlitter.cpp

@@ -332,7 +332,7 @@ namespace {
                 premul(&dst.r, &dst.g, &dst.b, dst.a);
             }
 
-            src = skvm::BlendModeProgram(this, params.blendMode, src, dst);
+            src = this->blend(params.blendMode, src, dst);
 
             // Lerp with coverage post-blend if needed.
             if (skvm::Color cov; lerp_coverage_post_blend && load_coverage(&cov)) {
@@ -729,93 +729,193 @@ namespace {
 }  // namespace
 
 bool skvm::BlendModeSupported(SkBlendMode mode) {
-    return mode <= SkBlendMode::kScreen;
+    switch (mode) {
+        default: break;
+        // our todo list
+        case SkBlendMode::kHue:
+        case SkBlendMode::kSaturation:
+        case SkBlendMode::kColor:
+        case SkBlendMode::kLuminosity:
+            return false;
+    }
+    return true;
 }
 
-skvm::Color skvm::BlendModeProgram(skvm::Builder* p,
-                                   SkBlendMode mode, skvm::Color src, skvm::Color dst) {
-    auto mma = [&](skvm::F32 x, skvm::F32 y, skvm::F32 z, skvm::F32 w) {
-        return p->mad(x,y, p->mul(z,w));
+skvm::Color skvm::Builder::blend(SkBlendMode mode, Color src, Color dst) {
+    auto mma = [this](skvm::F32 x, skvm::F32 y, skvm::F32 z, skvm::F32 w) {
+        return mad(x,y, mul(z,w));
+    };
+
+    auto inv = [this](skvm::F32 x) { return sub(splat(1.0f), x); };
+
+    auto two = [this](skvm::F32 x) { return add(x, x); };
+
+    auto apply_rgba = [&](auto fn) {
+        return Color {
+            fn(src.r, dst.r),
+            fn(src.g, dst.g),
+            fn(src.b, dst.b),
+            fn(src.a, dst.a),
+        };
     };
 
-    auto inv = [&](skvm::F32 x) {
-        return p->sub(p->splat(1.0f), x);
+    auto apply_rgb_srcover_a = [&](auto fn) {
+        return Color {
+            fn(src.r, dst.r),
+            fn(src.g, dst.g),
+            fn(src.b, dst.b),
+            mad(dst.a, inv(src.a), src.a),   // srcover for alpha
+        };
     };
 
     switch (mode) {
         default: SkASSERT(false); /*but also, for safety, fallthrough*/
 
         case SkBlendMode::kClear: return {
-            p->splat(0.0f),
-            p->splat(0.0f),
-            p->splat(0.0f),
-            p->splat(0.0f),
+            splat(0.0f),
+            splat(0.0f),
+            splat(0.0f),
+            splat(0.0f),
         };
 
         case SkBlendMode::kSrc: return src;
         case SkBlendMode::kDst: return dst;
 
         case SkBlendMode::kDstOver: std::swap(src, dst); // fall-through
-        case SkBlendMode::kSrcOver: return {
-            p->mad(dst.r, inv(src.a), src.r),
-            p->mad(dst.g, inv(src.a), src.g),
-            p->mad(dst.b, inv(src.a), src.b),
-            p->mad(dst.a, inv(src.a), src.a),
-        };
+        case SkBlendMode::kSrcOver:
+            return apply_rgba([&](auto s, auto d) {
+                return mad(d, inv(src.a), s);
+            });
 
         case SkBlendMode::kDstIn: std::swap(src, dst); // fall-through
-        case SkBlendMode::kSrcIn: return {
-            p->mul(src.r, dst.a),
-            p->mul(src.g, dst.a),
-            p->mul(src.b, dst.a),
-            p->mul(src.a, dst.a),
-        };
+        case SkBlendMode::kSrcIn:
+            return apply_rgba([&](auto s, auto d) {
+                return mul(s, dst.a);
+            });
 
         case SkBlendMode::kDstOut: std::swap(src, dst); // fall-through
-        case SkBlendMode::kSrcOut: return {
-            p->mul(src.r, inv(dst.a)),
-            p->mul(src.g, inv(dst.a)),
-            p->mul(src.b, inv(dst.a)),
-            p->mul(src.a, inv(dst.a)),
-        };
+        case SkBlendMode::kSrcOut:
+            return apply_rgba([&](auto s, auto d) {
+                return mul(s, inv(dst.a));
+            });
 
         case SkBlendMode::kDstATop: std::swap(src, dst); // fall-through
-        case SkBlendMode::kSrcATop: return {
-            mma(src.r, dst.a,  dst.r, inv(src.a)),
-            mma(src.g, dst.a,  dst.g, inv(src.a)),
-            mma(src.b, dst.a,  dst.b, inv(src.a)),
-            mma(src.a, dst.a,  dst.a, inv(src.a)),
-        };
-
-        case SkBlendMode::kXor: return {
-            mma(src.r, inv(dst.a),  dst.r, inv(src.a)),
-            mma(src.g, inv(dst.a),  dst.g, inv(src.a)),
-            mma(src.b, inv(dst.a),  dst.b, inv(src.a)),
-            mma(src.a, inv(dst.a),  dst.a, inv(src.a)),
-        };
-
-        case SkBlendMode::kPlus: return {
-            p->min(p->add(src.r, dst.r), p->splat(1.0f)),
-            p->min(p->add(src.g, dst.g), p->splat(1.0f)),
-            p->min(p->add(src.b, dst.b), p->splat(1.0f)),
-            p->min(p->add(src.a, dst.a), p->splat(1.0f)),
-        };
-
-        case SkBlendMode::kModulate: return {
-            p->mul(src.r, dst.r),
-            p->mul(src.g, dst.g),
-            p->mul(src.b, dst.b),
-            p->mul(src.a, dst.a),
-        };
-
-        case SkBlendMode::kScreen: return {
+        case SkBlendMode::kSrcATop:
+            return apply_rgba([&](auto s, auto d) {
+                return mma(s, dst.a,  d, inv(src.a));
+            });
+
+        case SkBlendMode::kXor:
+            return apply_rgba([&](auto s, auto d) {
+                return mma(s, inv(dst.a),  d, inv(src.a));
+            });
+
+        case SkBlendMode::kPlus:
+            return apply_rgba([&](auto s, auto d) {
+                return min(add(s, d), splat(1.0f));
+            });
+
+        case SkBlendMode::kModulate:
+            return apply_rgba([&](auto s, auto d) {
+                return mul(s, d);
+            });
+
+        case SkBlendMode::kScreen:
             // (s+d)-(s*d) gave us trouble with our "r,g,b <= after blending" asserts.
             // It's kind of plausible that s + (d - sd) keeps more precision?
-            p->add(src.r, p->sub(dst.r, p->mul(src.r, dst.r))),
-            p->add(src.g, p->sub(dst.g, p->mul(src.g, dst.g))),
-            p->add(src.b, p->sub(dst.b, p->mul(src.b, dst.b))),
-            p->add(src.a, p->sub(dst.a, p->mul(src.a, dst.a))),
-        };
+            return apply_rgba([&](auto s, auto d) {
+                return add(s, sub(d, mul(s, d)));
+            });
+
+        case SkBlendMode::kDarken:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(s, sub(d, max(mul(s, dst.a),
+                                         mul(d, src.a))));
+            });
+
+        case SkBlendMode::kLighten:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(s, sub(d, min(mul(s, dst.a),
+                                         mul(d, src.a))));
+            });
+
+        case SkBlendMode::kDifference:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(s, sub(d, two(min(mul(s, dst.a),
+                                             mul(d, src.a)))));
+            });
+
+        case SkBlendMode::kExclusion:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(s, sub(d, two(mul(s, d))));
+            });
+
+        case SkBlendMode::kColorBurn:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                auto mn   = min(dst.a,
+                                div(mul(sub(dst.a, d), src.a), s)),
+                     burn = mad(src.a, sub(dst.a, mn), mma(s, inv(dst.a), d, inv(src.a)));
+                return select(eq(d, dst.a),       mad(s, inv(dst.a), d),
+                       select(eq(s, splat(0.0f)), mul(d, inv(src.a)), burn));
+            });
+
+        case SkBlendMode::kColorDodge:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                auto tmp = mad(src.a, min(dst.a,
+                                          div(mul(d, src.a), sub(src.a, s))),
+                               mma(s, inv(dst.a), d, inv(src.a)));
+                return select(eq(d, splat(0.0f)), mul(s, inv(dst.a)),
+                       select(eq(s, src.a),       mad(d, inv(src.a), s), tmp));
+            });
+
+        case SkBlendMode::kHardLight:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(mma(s, inv(dst.a), d, inv(src.a)),
+                           select(lte(two(s), src.a),
+                                  two(mul(s, d)),
+                                  sub(mul(src.a, dst.a), two(mul(sub(dst.a, d), sub(src.a, s))))));
+            });
+
+        case SkBlendMode::kOverlay:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                return add(mma(s, inv(dst.a), d, inv(src.a)),
+                           select(lte(two(d), dst.a),
+                                  two(mul(s, d)),
+                                  sub(mul(src.a, dst.a), two(mul(sub(dst.a, d), sub(src.a, s))))));
+            });
+
+        case SkBlendMode::kMultiply:
+            return apply_rgba([&](auto s, auto d) {
+                return add(mma(s, inv(dst.a), d, inv(src.a)), mul(s, d));
+            });
+
+        case SkBlendMode::kSoftLight:
+            return apply_rgb_srcover_a([&](auto s, auto d) {
+                auto  m = select(gt(dst.a, splat(0.0f)), div(d, dst.a), splat(0.0f)),
+                     s2 = two(s),
+                     m4 = two(two(m));
+
+                     // The logic forks three ways:
+                     //    1. dark src?
+                     //    2. light src, dark dst?
+                     //    3. light src, light dst?
+
+                     // Used in case 1
+                auto darkSrc = mul(d, mad(sub(s2, src.a), inv(m), src.a)),
+                     // Used in case 2
+                     darkDst = mad(mad(m4, m4, m4), sub(m, splat(1.0f)), mul(splat(7.0f), m)),
+                     // Used in case 3.
+                     liteDst = sub(sqrt(m), m),
+                     // Used in 2 or 3?
+                     liteSrc = mad(mul(dst.a, sub(s2, src.a)),
+                                   select(lte(two(two(d)), dst.a), darkDst, liteDst),
+                                   mul(d, src.a));
+                return mad(s, inv(dst.a), mad(d,
+                                              inv(src.a),
+                                              select(lte(s2, src.a), darkSrc, liteSrc)));
+
+
+            });
     }
 }
 

src/shaders/SkComposeShader.cpp

@@ -142,7 +142,7 @@ skvm::Color SkShader_Blend::onProgram(skvm::Builder* p, skvm::F32 x, skvm::F32 y
         (dst = as_SB(fDst)->program(p, x,y, ctm,localM, q, cs, uniforms, alloc)) &&
         (src = as_SB(fSrc)->program(p, x,y, ctm,localM, q, cs, uniforms, alloc)))
     {
-        return skvm::BlendModeProgram(p, fMode, src, dst);
+        return p->blend(fMode, src, dst);
     }
     return {};
 }