Correct sRGB <-> linear everywhere.

This trims the SkPM4fPriv methods down to just foolproof methods.
(Anything trying to build these itself is probably wrong.)

Things like Sk4f srgb_to_linear(Sk4f) can't really exist anymore,
at least not efficiently, so this refactor is somewhat more invasive
than you might think.  Generally this means things using to_4f() are
also making a misstep... that's gone too.

It also does not make sense to try to play games with linear floats
with 255 bias any more.  That hack can't work with real sRGB coding.

Rather than update them, I've removed a couple of L32 xfermode fast
paths.  I'd even rather drop it entirely...

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2163683002
CQ_INCLUDE_TRYBOTS=master.client.skia:Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Release-SKNX_NO_SIMD-Trybot

Review-Url: https://codereview.chromium.org/2163683002

9 files changed, 120 insertions, 264 deletions

diff --git a/src/core/SkColor.cpp b/src/core/SkColor.cpp
index a1404a27e3..39e9aafa92 100644
--- a/src/core/SkColor.cpp
+++ b/src/core/SkColor.cpp
@@ -106,10 +106,7 @@ SkColor SkHSVToColor(U8CPU a, const SkScalar hsv[3]) {
 #include "SkHalf.h"
 
 SkPM4f SkPM4f::FromPMColor(SkPMColor c) {
-    Sk4f value = to_4f_rgba(c);
-    SkPM4f c4;
-    (value * Sk4f(1.0f / 255)).store(&c4);
-    return c4;
+    return From4f(swizzle_rb_if_bgra(Sk4f_fromL32(c)));
 }
 
 SkColor4f SkPM4f::unpremul() const {
@@ -152,21 +149,14 @@ void SkPM4f::assertIsUnit() const {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkColor4f SkColor4f::FromColor(SkColor c) {
-    Sk4f value = SkNx_shuffle<2,1,0,3>(SkNx_cast<float>(Sk4b::Load(&c)));
-    SkColor4f c4;
-    (value * Sk4f(1.0f / 255)).store(&c4);
-    c4.fR = srgb_to_linear(c4.fR);
-    c4.fG = srgb_to_linear(c4.fG);
-    c4.fB = srgb_to_linear(c4.fB);
-    return c4;
+SkColor4f SkColor4f::FromColor(SkColor bgra) {
+    SkColor4f rgba;
+    swizzle_rb(Sk4f_fromS32(bgra)).store(rgba.vec());
+    return rgba;
 }
 
 SkColor SkColor4f::toSkColor() const {
-    SkColor result;
-    Sk4f value = Sk4f(linear_to_srgb(fB), linear_to_srgb(fG), linear_to_srgb(fR), fA);
-    SkNx_cast<uint8_t>(value * Sk4f(255) + Sk4f(0.5f)).store(&result);
-    return result;
+    return Sk4f_toS32(swizzle_rb(Sk4f::Load(this->vec())));
 }
 
 SkColor4f SkColor4f::Pin(float r, float g, float b, float a) {
diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index cdfd1df496..29a3f107b8 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -126,7 +126,7 @@ struct SkPMColorAdaptor {
         return round(swizzle_rb_if_bgra(c4));
     }
     static Sk4f To4f(SkPMColor c) {
-        return to_4f(c) * Sk4f(1.0f/255);
+        return Sk4f_fromL32(c);
     }
 };
 void SkColorMatrixFilterRowMajor255::filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const {
diff --git a/src/core/SkLinearBitmapPipeline_sample.h b/src/core/SkLinearBitmapPipeline_sample.h
index 86ad6e146f..759075b3e5 100644
--- a/src/core/SkLinearBitmapPipeline_sample.h
+++ b/src/core/SkLinearBitmapPipeline_sample.h
@@ -170,11 +170,10 @@ public:
     PixelConverter(const SkPixmap& srcPixmap) { }
 
     Sk4f toSk4f(Element pixel) const {
-        float gray = pixel * (1.0f/255.0f);
-        Sk4f result = Sk4f{gray, gray, gray, 1.0f};
-        return gammaType == kSRGB_SkGammaType
-               ? srgb_to_linear(result)
-               : result;
+        float gray = (gammaType == kSRGB_SkGammaType)
+            ? sk_linear_from_srgb[pixel]
+            : pixel * (1/255.0f);
+        return {gray, gray, gray, 1.0f};
     }
 };
 
diff --git a/src/core/SkPM4fPriv.h b/src/core/SkPM4fPriv.h
index 57a44c1cb2..89a0caeb70 100644
--- a/src/core/SkPM4fPriv.h
+++ b/src/core/SkPM4fPriv.h
@@ -10,142 +10,65 @@
 
 #include "SkColorPriv.h"
 #include "SkPM4f.h"
+#include "SkSRGB.h"
 
-static inline float get_alpha(const Sk4f& f4) {
-    return f4[SkPM4f::A];
+static inline Sk4f set_alpha(const Sk4f& px, float alpha) {
+    return { px[0], px[1], px[2], alpha };
 }
 
-static inline Sk4f set_alpha(const Sk4f& f4, float alpha) {
-    static_assert(3 == SkPM4f::A, "");
-    return Sk4f(f4[0], f4[1], f4[2], alpha);
+static inline float get_alpha(const Sk4f& px) {
+    return px[3];
 }
 
-static inline uint32_t to_4b(const Sk4f& f4) {
-    uint32_t b4;
-    SkNx_cast<uint8_t>(f4).store((uint8_t*)&b4);
-    return b4;
-}
-
-static inline Sk4f to_4f(uint32_t b4) {
-    return SkNx_cast<float>(Sk4b::Load((const uint8_t*)&b4));
-}
-
-static inline Sk4f to_4f_rgba(uint32_t b4) {
-    return swizzle_rb_if_bgra(to_4f(b4));
-}
-
-static inline Sk4f srgb_to_linear(const Sk4f& s4) {
-    return set_alpha(s4 * s4, get_alpha(s4));
-}
-
-static inline Sk4f linear_to_srgb(const Sk4f& l4) {
-    return set_alpha(l4.rsqrt().invert(), get_alpha(l4));
-}
-
-static inline float srgb_to_linear(float x) {
-    return x * x;
-}
-
-static inline float linear_to_srgb(float x) {
-    return sqrtf(x);
-}
-
-static void assert_unit(float x) {
-    SkASSERT(x >= 0 && x <= 1);
-}
-
-static inline float exact_srgb_to_linear(float x) {
-    assert_unit(x);
-    float linear;
-    if (x <= 0.04045) {
-        linear = x / 12.92f;
-    } else {
-        linear = powf((x + 0.055f) / 1.055f, 2.4f);
-    }
-    assert_unit(linear);
-    return linear;
-}
 
-static inline float exact_linear_to_srgb(float x) {
-    assert_unit(x);
-    float srgb;
-    if (x <= 0.0031308f) {
-        srgb = x * 12.92f;
-    } else {
-        srgb = 1.055f * powf(x, 0.41666667f) - 0.055f;
-    }
-    assert_unit(srgb);
-    return srgb;
+static inline Sk4f Sk4f_fromL32(uint32_t px) {
+    return SkNx_cast<float>(Sk4b::Load(&px)) * (1/255.0f);
 }
 
-static inline Sk4f exact_srgb_to_linear(const Sk4f& x) {
-    Sk4f linear(exact_srgb_to_linear(x[0]),
-                exact_srgb_to_linear(x[1]),
-                exact_srgb_to_linear(x[2]), 1);
-    return set_alpha(linear, get_alpha(x));
+static inline Sk4f Sk4f_fromS32(uint32_t px) {
+    return { sk_linear_from_srgb[(px >>  0) & 0xff],
+             sk_linear_from_srgb[(px >>  8) & 0xff],
+             sk_linear_from_srgb[(px >> 16) & 0xff],
+                    (1/255.0f) * (px >> 24)          };
 }
 
-static inline Sk4f exact_linear_to_srgb(const Sk4f& x) {
-    Sk4f srgb(exact_linear_to_srgb(x[0]),
-              exact_linear_to_srgb(x[1]),
-              exact_linear_to_srgb(x[2]), 1);
-    return set_alpha(srgb, get_alpha(x));
+static inline uint32_t Sk4f_toL32(const Sk4f& px) {
+    uint32_t l32;
+    SkNx_cast<uint8_t>(Sk4f_round(px * 255.0f)).store(&l32);
+    return l32;
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+static inline uint32_t Sk4f_toS32(const Sk4f& px) {
+    Sk4i  rgb = sk_linear_to_srgb(px),
+         srgb = { rgb[0], rgb[1], rgb[2], (int)(255.0f * px[3] + 0.5f) };
 
-static inline Sk4f Sk4f_fromL32(uint32_t src) {
-    return to_4f(src) * Sk4f(1.0f/255);
+    uint32_t s32;
+    SkNx_cast<uint8_t>(srgb).store(&s32);
+    return s32;
 }
 
-static inline Sk4f Sk4f_fromS32(uint32_t src) {
-    return srgb_to_linear(to_4f(src) * Sk4f(1.0f/255));
-}
 
-// Color handling:
+// SkColor handling:
 //   SkColor has an ordering of (b, g, r, a) if cast to an Sk4f, so the code swizzles r and b to
 // produce the needed (r, g, b, a) ordering.
 static inline Sk4f Sk4f_from_SkColor(SkColor color) {
     return swizzle_rb(Sk4f_fromS32(color));
 }
 
-static inline uint32_t Sk4f_toL32(const Sk4f& x4) {
-    return to_4b(x4 * Sk4f(255) + Sk4f(0.5f));
+static inline void assert_unit(float x) {
+    SkASSERT(0 <= x && x <= 1);
 }
 
-static inline uint32_t Sk4f_toS32(const Sk4f& x4) {
-    return to_4b(linear_to_srgb(x4) * Sk4f(255) + Sk4f(0.5f));
-}
-
-static inline Sk4f exact_Sk4f_fromS32(uint32_t src) {
-    return exact_srgb_to_linear(to_4f(src) * Sk4f(1.0f/255));
-}
-static inline uint32_t exact_Sk4f_toS32(const Sk4f& x4) {
-    return to_4b(exact_linear_to_srgb(x4) * Sk4f(255) + Sk4f(0.5f));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// An implementation of SrcOver from bytes to bytes in linear space that takes advantage of the
-// observation that the 255's cancel.
-//    invA = 1 - (As / 255);
-//
-//    R = 255 * sqrt((Rs/255)^2 + (Rd/255)^2 * invA)
-// => R = 255 * sqrt((Rs^2 + Rd^2 * invA)/255^2)
-// => R = sqrt(Rs^2 + Rd^2 * invA)
-// Note: src is assumed to be linear.
-static inline void srcover_blend_srgb8888_srgb_1(uint32_t* dst, const Sk4f& src) {
-    Sk4f d = srgb_to_linear(to_4f(*dst));
-    Sk4f invAlpha = 1.0f - Sk4f{src[SkPM4f::A]} * (1.0f / 255.0f);
-    Sk4f r = linear_to_srgb(src + d * invAlpha) + 0.5f;
-    *dst = to_4b(r);
-}
-
-static inline void srcover_srgb8888_srgb_1(uint32_t* dst, const uint32_t pixel) {
-    if ((~pixel & 0xFF000000) == 0) {
-        *dst = pixel;
-    } else if ((pixel & 0xFF000000) != 0) {
-        srcover_blend_srgb8888_srgb_1(dst, srgb_to_linear(to_4f(pixel)));
+static inline float exact_srgb_to_linear(float srgb) {
+    assert_unit(srgb);
+    float linear;
+    if (srgb <= 0.04045) {
+        linear = srgb / 12.92f;
+    } else {
+        linear = powf((srgb + 0.055f) / 1.055f, 2.4f);
     }
+    assert_unit(linear);
+    return linear;
 }
 
 #endif
diff --git a/src/core/SkSpanProcs.cpp b/src/core/SkSpanProcs.cpp
index 87dcbc0ee7..b2e9914a17 100644
--- a/src/core/SkSpanProcs.cpp
+++ b/src/core/SkSpanProcs.cpp
@@ -22,7 +22,7 @@ static void load_l32(const SkPixmap& src, int x, int y, SkPM4f span[], int count
     SkASSERT(src.addr32(x + count - 1, y));
 
     for (int i = 0; i < count; ++i) {
-        (to_4f_rgba(addr[i]) * Sk4f(1.0f/255)).store(span[i].fVec);
+        swizzle_rb_if_bgra(Sk4f_fromL32(addr[i])).store(span[i].fVec);
     }
 }
 
@@ -32,7 +32,7 @@ static void load_s32(const SkPixmap& src, int x, int y, SkPM4f span[], int count
     SkASSERT(src.addr32(x + count - 1, y));
 
     for (int i = 0; i < count; ++i) {
-        srgb_to_linear(to_4f_rgba(addr[i]) * Sk4f(1.0f/255)).store(span[i].fVec);
+        swizzle_rb_if_bgra(Sk4f_fromS32(addr[i])).store(span[i].fVec);
     }
 }
 
diff --git a/src/core/SkXfermode4f.cpp b/src/core/SkXfermode4f.cpp
index d861973dbf..87a12a7df6 100644
--- a/src/core/SkXfermode4f.cpp
+++ b/src/core/SkXfermode4f.cpp
@@ -35,44 +35,40 @@ template <DstType D> Sk4f load_dst(SkPMColor dstC) {
     return (D == kSRGB_Dst) ? Sk4f_fromS32(dstC) : Sk4f_fromL32(dstC);
 }
 
-static Sk4f srgb_4b_to_linear_unit(SkPMColor dstC) {
-    return Sk4f_fromS32(dstC);
-}
-
 template <DstType D> uint32_t store_dst(const Sk4f& x4) {
     return (D == kSRGB_Dst) ? Sk4f_toS32(x4) : Sk4f_toL32(x4);
 }
 
-static Sk4f linear_unit_to_srgb_255f(const Sk4f& l4) {
-    return linear_to_srgb(l4) * Sk4f(255) + Sk4f(0.5f);
-}
+static Sk4x4f load_4_srgb(const void* vptr) {
+    auto ptr = (const uint32_t*)vptr;
+
+    Sk4x4f rgba;
+
+    rgba.r = { sk_linear_from_srgb[(ptr[0] >>  0) & 0xff],
+               sk_linear_from_srgb[(ptr[1] >>  0) & 0xff],
+               sk_linear_from_srgb[(ptr[2] >>  0) & 0xff],
+               sk_linear_from_srgb[(ptr[3] >>  0) & 0xff] };
 
-// Load 4 interlaced 8888 sRGB pixels as an Sk4x4f, transposed and converted to float.
-static Sk4x4f load_4_srgb(const void* ptr) {
-    auto p = Sk4x4f::Transpose((const uint8_t*)ptr);
+    rgba.g = { sk_linear_from_srgb[(ptr[0] >>  8) & 0xff],
+               sk_linear_from_srgb[(ptr[1] >>  8) & 0xff],
+               sk_linear_from_srgb[(ptr[2] >>  8) & 0xff],
+               sk_linear_from_srgb[(ptr[3] >>  8) & 0xff] };
 
-    // Scale to [0,1].
-    p.r *= 1/255.0f;
-    p.g *= 1/255.0f;
-    p.b *= 1/255.0f;
-    p.a *= 1/255.0f;
+    rgba.b = { sk_linear_from_srgb[(ptr[0] >> 16) & 0xff],
+               sk_linear_from_srgb[(ptr[1] >> 16) & 0xff],
+               sk_linear_from_srgb[(ptr[2] >> 16) & 0xff],
+               sk_linear_from_srgb[(ptr[3] >> 16) & 0xff] };
 
-    // Apply approximate sRGB gamma correction to convert to linear (as if gamma were 2).
-    p.r *= p.r;
-    p.g *= p.g;
-    p.b *= p.b;
+    rgba.a = SkNx_cast<float>((Sk4i::Load(ptr) >> 24) & 0xff) * (1/255.0f);
 
-    return p;
+    return rgba;
 }
 
-// Store an Sk4x4f back to 4 interlaced 8888 sRGB pixels.
 static void store_4_srgb(void* ptr, const Sk4x4f& p) {
-    // Convert back to sRGB and [0,255], again approximating sRGB as gamma == 2.
-    auto r = p.r.rsqrt().invert() * 255.0f + 0.5f,
-         g = p.g.rsqrt().invert() * 255.0f + 0.5f,
-         b = p.b.rsqrt().invert() * 255.0f + 0.5f,
-         a = p.a                  * 255.0f + 0.5f;
-    Sk4x4f{r,g,b,a}.transpose((uint8_t*)ptr);
+    ( sk_linear_to_srgb(p.r) <<  0
+    | sk_linear_to_srgb(p.g) <<  8
+    | sk_linear_to_srgb(p.b) << 16
+    | Sk4f_round(255.0f*p.a) << 24).store(ptr);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -197,41 +193,24 @@ template <DstType D> void src_1(const SkXfermode*, uint32_t dst[],
     const Sk4f s4 = src->to4f_pmorder();
 
     if (aa) {
-        if (D == kLinear_Dst) {
-            // operate in bias-255 space for src and dst
-            const Sk4f& s4_255 = s4 * Sk4f(255);
-            while (count >= 4) {
-                Sk4f aa4 = SkNx_cast<float>(Sk4b::Load(aa)) * Sk4f(1/255.f);
-                Sk4f r0 = lerp(s4_255, to_4f(dst[0]), Sk4f(aa4[0])) + Sk4f(0.5f);
-                Sk4f r1 = lerp(s4_255, to_4f(dst[1]), Sk4f(aa4[1])) + Sk4f(0.5f);
-                Sk4f r2 = lerp(s4_255, to_4f(dst[2]), Sk4f(aa4[2])) + Sk4f(0.5f);
-                Sk4f r3 = lerp(s4_255, to_4f(dst[3]), Sk4f(aa4[3])) + Sk4f(0.5f);
-                Sk4f_ToBytes((uint8_t*)dst, r0, r1, r2, r3);
-
-                dst += 4;
-                aa += 4;
-                count -= 4;
-            }
-        } else {    // kSRGB
-            SkPMColor srcColor = store_dst<D>(s4);
-            while (count-- > 0) {
-                SkAlpha cover = *aa++;
-                switch (cover) {
-                    case 0xFF: {
-                        *dst++ = srcColor;
-                        break;
-                    }
-                    case 0x00: {
-                        dst++;
-                        break;
-                    }
-                    default: {
-                        Sk4f d4 = load_dst<D>(*dst);
-                        *dst++ = store_dst<D>(lerp(s4, d4, cover));
-                    }
+        SkPMColor srcColor = store_dst<D>(s4);
+        while (count-- > 0) {
+            SkAlpha cover = *aa++;
+            switch (cover) {
+                case 0xFF: {
+                    *dst++ = srcColor;
+                    break;
+                }
+                case 0x00: {
+                    dst++;
+                    break;
+                }
+                default: {
+                    Sk4f d4 = load_dst<D>(*dst);
+                    *dst++ = store_dst<D>(lerp(s4, d4, cover));
                 }
             }
-        }          // kSRGB
+        }
     } else {
         sk_memset32(dst, store_dst<D>(s4), count);
     }
@@ -274,18 +253,15 @@ template <DstType D> void srcover_n(const SkXfermode*, uint32_t dst[],
     } else {
         while (count >= 4 && D == kSRGB_Dst) {
             auto d = load_4_srgb(dst);
-
             auto s = Sk4x4f::Transpose(src->fVec);
         #if defined(SK_PMCOLOR_IS_BGRA)
             SkTSwap(s.r, s.b);
         #endif
-
             auto invSA = 1.0f - s.a;
             auto r = s.r + d.r * invSA,
                  g = s.g + d.g * invSA,
                  b = s.b + d.b * invSA,
                  a = s.a + d.a * invSA;
-
             store_4_srgb(dst, Sk4x4f{r,g,b,a});
             count -= 4;
             dst += 4;
@@ -322,23 +298,9 @@ static void srcover_linear_dst_1(const SkXfermode*, uint32_t dst[],
             dst[i] = Sk4f_toL32(r4);
         }
     } else {
-        const Sk4f s4_255 = s4 * Sk4f(255) + Sk4f(0.5f);   // +0.5 to pre-bias for rounding
-        while (count >= 4) {
-            Sk4f d0 = to_4f(dst[0]);
-            Sk4f d1 = to_4f(dst[1]);
-            Sk4f d2 = to_4f(dst[2]);
-            Sk4f d3 = to_4f(dst[3]);
-            Sk4f_ToBytes((uint8_t*)dst,
-                         s4_255 + d0 * dst_scale,
-                         s4_255 + d1 * dst_scale,
-                         s4_255 + d2 * dst_scale,
-                         s4_255 + d3 * dst_scale);
-            dst += 4;
-            count -= 4;
-        }
         for (int i = 0; i < count; ++i) {
-            Sk4f d4 = to_4f(dst[i]);
-            dst[i] = to_4b(s4_255 + d4 * dst_scale);
+            Sk4f d4 = Sk4f_fromL32(dst[i]);
+            dst[i] = Sk4f_toL32(s4 + d4 * dst_scale);
         }
     }
 }
@@ -354,7 +316,8 @@ static void srcover_srgb_dst_1(const SkXfermode*, uint32_t dst[],
             if (0 == a) {
                 continue;
             }
-            Sk4f d4 = srgb_4b_to_linear_unit(dst[i]);
+
+            Sk4f d4 = Sk4f_fromS32(dst[i]);
             Sk4f r4;
             if (a != 0xFF) {
                 const Sk4f s4_aa = scale_by_coverage(s4, a);
@@ -362,30 +325,27 @@ static void srcover_srgb_dst_1(const SkXfermode*, uint32_t dst[],
             } else {
                 r4 = s4 + d4 * dst_scale;
             }
-            dst[i] = to_4b(linear_unit_to_srgb_255f(r4));
+            dst[i] = Sk4f_toS32(r4);
         }
     } else {
         while (count >= 4) {
             auto d = load_4_srgb(dst);
-
             auto s = Sk4x4f{{ src->r() }, { src->g() }, { src->b() }, { src->a() }};
         #if defined(SK_PMCOLOR_IS_BGRA)
             SkTSwap(s.r, s.b);
         #endif
-
             auto invSA = 1.0f - s.a;
             auto r = s.r + d.r * invSA,
                  g = s.g + d.g * invSA,
                  b = s.b + d.b * invSA,
                  a = s.a + d.a * invSA;
-
             store_4_srgb(dst, Sk4x4f{r,g,b,a});
             count -= 4;
             dst += 4;
         }
         for (int i = 0; i < count; ++i) {
-            Sk4f d4 = srgb_4b_to_linear_unit(dst[i]);
-            dst[i] = to_4b(linear_unit_to_srgb_255f(s4 + d4 * dst_scale));
+            Sk4f d4 = Sk4f_fromS32(dst[i]);
+            dst[i] = Sk4f_toS32(s4 + d4 * dst_scale);
         }
     }
 }
@@ -443,26 +403,13 @@ template <DstType D>
 void src_1_lcd(uint32_t dst[], const SkPM4f* src, int count, const uint16_t lcd[]) {
     const Sk4f s4 = src->to4f_pmorder();
 
-    if (D == kLinear_Dst) {
-        // operate in bias-255 space for src and dst
-        const Sk4f s4bias = s4 * Sk4f(255);
-        for (int i = 0; i < count; ++i) {
-            uint16_t rgb = lcd[i];
-            if (0 == rgb) {
-                continue;
-            }
-            Sk4f d4bias = to_4f(dst[i]);
-            dst[i] = to_4b(lerp(s4bias, d4bias, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
-        }
-    } else {    // kSRGB
-        for (int i = 0; i < count; ++i) {
-            uint16_t rgb = lcd[i];
-            if (0 == rgb) {
-                continue;
-            }
-            Sk4f d4 = load_dst<D>(dst[i]);
-            dst[i] = store_dst<D>(lerp(s4, d4, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
+    for (int i = 0; i < count; ++i) {
+        uint16_t rgb = lcd[i];
+        if (0 == rgb) {
+            continue;
         }
+        Sk4f d4 = load_dst<D>(dst[i]);
+        dst[i] = store_dst<D>(lerp(s4, d4, lcd16_to_unit_4f(rgb))) | (SK_A32_MASK << SK_A32_SHIFT);
     }
 }
 
diff --git a/src/effects/gradients/Sk4fGradientPriv.h b/src/effects/gradients/Sk4fGradientPriv.h
index 9745119fd4..6542683eb0 100644
--- a/src/effects/gradients/Sk4fGradientPriv.h
+++ b/src/effects/gradients/Sk4fGradientPriv.h
@@ -109,18 +109,16 @@ struct DstTraits<DstType::S32, premul> {
     using Type = SkPMColor;
 
     static Sk4f load(const SkPM4f& c) {
-        // Prescaling by (255^2, 255^2, 255^2, 255) on load, to avoid a 255 multiply on
-        // each store (S32 conversion yields a uniform 255 factor).
-        return c.to4f_pmorder() * Sk4f(255 * 255, 255 * 255, 255 * 255, 255);
+        return c.to4f_pmorder();
     }
 
     static void store(const Sk4f& c, Type* dst) {
         // FIXME: this assumes opaque colors.  Handle unpremultiplication.
-        *dst = to_4b(linear_to_srgb(PM::apply(c)));
+        *dst = Sk4f_toS32(PM::apply(c));
     }
 
     static void store(const Sk4f& c, Type* dst, int n) {
-        sk_memset32(dst, to_4b(linear_to_srgb(PM::apply(c))), n);
+        sk_memset32(dst, Sk4f_toS32(PM::apply(c)), n);
     }
 
     static void store4x(const Sk4f& c0, const Sk4f& c1,
diff --git a/src/effects/gradients/Sk4fLinearGradient.cpp b/src/effects/gradients/Sk4fLinearGradient.cpp
index d22dbff8a1..dc6e530a0c 100644
--- a/src/effects/gradients/Sk4fLinearGradient.cpp
+++ b/src/effects/gradients/Sk4fLinearGradient.cpp
@@ -53,13 +53,10 @@ void ramp<DstType::S32, ApplyPremul::False>(const Sk4f& c, const Sk4f& dc, SkPMC
     Sk4x4f        c4x = Sk4x4f::Transpose(c, c + dc, c + dc * 2, c + dc * 3);
 
     while (n >= 4) {
-        const Sk4x4f cx4s32 = {
-            c4x.r.rsqrt().invert(),
-            c4x.g.rsqrt().invert(),
-            c4x.b.rsqrt().invert(),
-            c4x.a
-        };
-        cx4s32.transpose((uint8_t*)dst);
+        ( sk_linear_to_srgb(c4x.r) <<  0
+        | sk_linear_to_srgb(c4x.g) <<  8
+        | sk_linear_to_srgb(c4x.b) << 16
+        | Sk4f_round(255.0f*c4x.a) << 24).store(dst);
 
         c4x.r += dc4x.r;
         c4x.g += dc4x.g;
diff --git a/src/opts/SkBlend_opts.h b/src/opts/SkBlend_opts.h
index 4f6d1e9195..1da4c4fb04 100644
--- a/src/opts/SkBlend_opts.h
+++ b/src/opts/SkBlend_opts.h
@@ -21,19 +21,21 @@ ninja -C out/Release dm nanobench ; and ./out/Release/dm --match Blend_opts ; an
 
 namespace SK_OPTS_NS {
 
-static inline void srcover_srgb8888_srgb_1(uint32_t* dst, const uint32_t pixel) {
-    if ((~pixel & 0xFF000000) == 0) {
-        *dst = pixel;
-    } else if ((pixel & 0xFF000000) != 0) {
-        srcover_blend_srgb8888_srgb_1(dst, srgb_to_linear(to_4f(pixel)));
+static inline void srcover_srgb_srgb_1(uint32_t* dst, uint32_t src) {
+    if (src >= 0xFF000000) {
+        *dst = src;
+        return;
     }
+    auto d = Sk4f_fromS32(*dst),
+         s = Sk4f_fromS32( src);
+    *dst = Sk4f_toS32(s + d * (1.0f - s[3]));
 }
 
 static inline void srcover_srgb_srgb_4(uint32_t* dst, const uint32_t* src) {
-    srcover_srgb8888_srgb_1(dst++, *src++);
-    srcover_srgb8888_srgb_1(dst++, *src++);
-    srcover_srgb8888_srgb_1(dst++, *src++);
-    srcover_srgb8888_srgb_1(dst, *src);
+    srcover_srgb_srgb_1(dst++, *src++);
+    srcover_srgb_srgb_1(dst++, *src++);
+    srcover_srgb_srgb_1(dst++, *src++);
+    srcover_srgb_srgb_1(dst  , *src  );
 }
 
 #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
@@ -87,7 +89,7 @@ static inline void srcover_srgb_srgb_4(uint32_t* dst, const uint32_t* src) {
 
                 count = count & 3;
                 while (count-- > 0) {
-                    srcover_srgb8888_srgb_1(dst++, *src++);
+                    srcover_srgb_srgb_1(dst++, *src++);
                 }
             }
         }
@@ -159,7 +161,7 @@ static inline void srcover_srgb_srgb_4(uint32_t* dst, const uint32_t* src) {
 
                 count = count & 3;
                 while (count-- > 0) {
-                    srcover_srgb8888_srgb_1(dst++, *src++);
+                    srcover_srgb_srgb_1(dst++, *src++);
                 }
             }
         }
@@ -172,7 +174,7 @@ static inline void srcover_srgb_srgb_4(uint32_t* dst, const uint32_t* src) {
             int n = SkTMin(ndst, nsrc);
 
             for (int i = 0; i < n; i++) {
-                srcover_srgb8888_srgb_1(dst++, src[i]);
+                srcover_srgb_srgb_1(dst++, src[i]);
             }
             ndst -= n;
         }