Apply linear gradient premul in 4f

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkLinearGradient.h"
 #include "SkRefCnt.h"
@@ skipping 507 matching lines @@
     SkASSERT(rec[0].fPos <= rec[1].fPos);
     while (tiledX < rec->fPos || rec[1].fPosScale == 0) {
         rec -= 1;
         SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
         SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
         SkASSERT(rec[0].fPos <= rec[1].fPos);
     }
     return rec;
 }
 
-template <bool apply_alpha> SkPMColor trunc_from_255(const Sk4f& x) {
+template <bool apply_alpha> SkPMColor trunc_from_255(const Sk4f& x, const Sk4f& bias) {
     SkPMColor c;
+
+#ifdef SK_SUPPORT_LEGACY_GRADIENT_PREMUL
     SkNx_cast<uint8_t>(x).store(&c);
     if (apply_alpha) {
         c = SkPreMultiplyARGB(SkGetPackedA32(c), SkGetPackedR32(c),
                               SkGetPackedG32(c), SkGetPackedB32(c));
     }
+#else
+    Sk4f c4f255;
+    if (!apply_alpha) {
+        // when apply_alpha is false, the bias is preapplied.
+        c4f255 = x;
+    } else {
+        const float scale = x[SkPM4f::A] * 1.f / 255;

[reed1, 2016/10/11 16:31:39]

are we sure the 1 / 255 *always* gets resolved at compile time into a single
multiply?

[mtklein, 2016/10/11 16:38:15]

No, as written this will never be a single multiply.  It will multiply then
divide.

You should always write 1/255 as (1/255.0f).  That'll never go wrong.

[f(malita), 2016/10/11 19:19:06]

Done.

+        // apply the bias *after* premul
+        c4f255 = x * Sk4f(scale, scale, scale, 1) + bias;
+    }
+    SkNx_cast<uint8_t>(c4f255).store(&c);
+#endif
     return c;
 }
 
 template <bool apply_alpha> void fill(SkPMColor dst[], int count,
-                                      const Sk4f& c4, const Sk4f& c4other) {
-    sk_memset32_dither(dst, trunc_from_255<apply_alpha>(c4),
-                       trunc_from_255<apply_alpha>(c4other), count);
+                                      const Sk4f& c4, const Sk4f& bias0, const Sk4f& bias1) {
+#ifdef SK_SUPPORT_LEGACY_GRADIENT_PREMUL
+    const SkPMColor c0 = trunc_from_255<apply_alpha>(c4 + bias0, 0);
+    const SkPMColor c1 = trunc_from_255<apply_alpha>(c4 + bias1, 0);
+#else
+    const SkPMColor c0 = apply_alpha
+        ? trunc_from_255<apply_alpha>(c4, bias0)
+        : trunc_from_255<apply_alpha>(c4 + bias0, 0);
+    const SkPMColor c1 = apply_alpha
+        ? trunc_from_255<apply_alpha>(c4, bias1)
+        : trunc_from_255<apply_alpha>(c4 + bias1, 0);
+#endif
+    sk_memset32_dither(dst, c0, c1, count);
 }
 
 template <bool apply_alpha> void fill(SkPMColor dst[], int count, const Sk4f& c4) {
     // Assumes that c4 does not need to be dithered.
-    sk_memset32(dst, trunc_from_255<apply_alpha>(c4), count);
+    sk_memset32(dst, trunc_from_255<apply_alpha>(c4, 0), count);
 }
 
 /*
  *  TODOs
  *
  *  - tilemodes
  *  - interp before or after premul
  *  - perspective
  *  - optimizations
  *      - use fixed (32bit or 16bit) instead of floats?
  */
 
 static Sk4f lerp_color(float fx, const SkLinearGradient::LinearGradientContext::Rec* rec) {
     SkASSERT(fx >= rec[0].fPos);
     SkASSERT(fx <= rec[1].fPos);
 
     const float p0 = rec[0].fPos;
     const Sk4f c0 = rec[0].fColor;
     const Sk4f c1 = rec[1].fColor;
     const Sk4f diffc = c1 - c0;
     const float scale = rec[1].fPosScale;
     const float t = (fx - p0) * scale;
     return c0 + Sk4f(t) * diffc;
 }
 
 template <bool apply_alpha> void ramp(SkPMColor dstC[], int n, const Sk4f& c, const Sk4f& dc,
                                       const Sk4f& dither0, const Sk4f& dither1) {
     Sk4f dc2 = dc + dc;
     Sk4f dc4 = dc2 + dc2;
-    Sk4f cd0 = c + dither0;
-    Sk4f cd1 = c + dc + dither1;
+    Sk4f cd0 = c;
+    Sk4f cd1 = c + dc;
+#ifndef SK_SUPPORT_LEGACY_GRADIENT_PREMUL
+    // when apply_alpha is true, we defer dithering until after premul.
+    if (!apply_alpha) {
+#endif
+        cd0 += dither0;
+        cd1 += dither1;
+#ifndef SK_SUPPORT_LEGACY_GRADIENT_PREMUL
+    }
+#endif
     Sk4f cd2 = cd0 + dc2;
     Sk4f cd3 = cd1 + dc2;
     while (n >= 4) {
         if (!apply_alpha) {
             Sk4f_ToBytes((uint8_t*)dstC, cd0, cd1, cd2, cd3);
             dstC += 4;
         } else {
-            *dstC++ = trunc_from_255<apply_alpha>(cd0);
-            *dstC++ = trunc_from_255<apply_alpha>(cd1);
-            *dstC++ = trunc_from_255<apply_alpha>(cd2);
-            *dstC++ = trunc_from_255<apply_alpha>(cd3);
+            *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
+            *dstC++ = trunc_from_255<apply_alpha>(cd1, dither1);
+            *dstC++ = trunc_from_255<apply_alpha>(cd2, dither0);
+            *dstC++ = trunc_from_255<apply_alpha>(cd3, dither1);
         }
         cd0 = cd0 + dc4;
         cd1 = cd1 + dc4;
         cd2 = cd2 + dc4;
         cd3 = cd3 + dc4;
         n -= 4;
     }
     if (n & 2) {
-        *dstC++ = trunc_from_255<apply_alpha>(cd0);
-        *dstC++ = trunc_from_255<apply_alpha>(cd1);
+        *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
+        *dstC++ = trunc_from_255<apply_alpha>(cd1, dither1);
         cd0 = cd0 + dc2;
     }
     if (n & 1) {
-        *dstC++ = trunc_from_255<apply_alpha>(cd0);
+        *dstC++ = trunc_from_255<apply_alpha>(cd0, dither0);
     }
 }
 
 template <bool apply_alpha, bool dx_is_pos>
 void SkLinearGradient::LinearGradientContext::shade4_dx_clamp(SkPMColor dstC[], int count,
                                                               float fx, float dx, float invDx,
                                                               const float dither[2]) {
     Sk4f dither0(dither[0]);
     Sk4f dither1(dither[1]);
     const Rec* rec = fRecs.begin();
@@ skipping 126 matching lines @@
             SkTSwap(dither0, dither1);
         }
     }
     const float dither[2] = { dither0, dither1 };
     const float invDx = 1 / dx;
 
     if (SkScalarNearlyZero(dx * count)) { // gradient is vertical
         const float pinFx = SkTPin(fx, 0.0f, 1.0f);
         Sk4f c = lerp_color(pinFx, find_forward(fRecs.begin(), pinFx));
         if (fApplyAlphaAfterInterp) {
-            fill<true>(dstC, count, c + dither0, c + dither1);
+            fill<true>(dstC, count, c, dither0, dither1);
         } else {
-            fill<false>(dstC, count, c + dither0, c + dither1);
+            fill<false>(dstC, count, c, dither0, dither1);
         }
         return;
     }
 
     if (dx > 0) {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, true>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }