Correct sRGB <-> linear everywhere.

src/opts/SkBlend_opts.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
 ninja -C out/Release dm nanobench ; and ./out/Release/dm --match Blend_opts ; and ./out/Release/nanobench  --samples 300 --nompd --match LinearSrcOver -q
  */
 
 #ifndef SkBlend_opts_DEFINED
 #define SkBlend_opts_DEFINED
 
 #include "SkNx.h"
 #include "SkPM4fPriv.h"
 
 #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
     #include <immintrin.h>
 #endif
 
 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
 
     static inline __m128i load(const uint32_t* p) {
         return _mm_loadu_si128(reinterpret_cast<const __m128i*>(p));
     }
 
     static inline void store(uint32_t* p, __m128i v) {
         _mm_storeu_si128(reinterpret_cast<__m128i*>(p), v);
@@ skipping 33 matching lines @@
                             srcover_srgb_srgb_4(dst, dst + delta);
                             dst += 4;
                         } while (dst < end
                                  && _mm_testnzc_si128(pixels = load(dst + delta), alphaMask));
                         src += dst - start;
                     }
                 }
 
                 count = count & 3;
                 while (count-- > 0) {
-                    srcover_srgb8888_srgb_1(dst++, *src++);
+                    srcover_srgb_srgb_1(dst++, *src++);
                 }
             }
         }
     #else
     // SSE2 versions
 
         // Note: In the next three comparisons a group of 4 pixels is converted to a group of
         // "signed" pixels because the sse2 does not have an unsigned comparison.
         // Make it so that we can use the signed comparison operators by biasing
         // 0x00xxxxxx to 0x80xxxxxxx which is the smallest values and biasing 0xffxxxxxx to
@@ skipping 51 matching lines @@
                         do {
                             srcover_srgb_srgb_4(dst, dst + delta);
                             dst += 4;
                         } while (dst < end && check_partial_alphas(pixels = load(dst + delta)));
                         src += dst - start;
                     }
                 } while (dst < end);
 
                 count = count & 3;
                 while (count-- > 0) {
-                    srcover_srgb8888_srgb_1(dst++, *src++);
+                    srcover_srgb_srgb_1(dst++, *src++);
                 }
             }
         }
     #endif
 #else
 
     static void srcover_srgb_srgb(
         uint32_t* dst, const uint32_t* const src, int ndst, const int nsrc) {
         while (ndst > 0) {
             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;
         }
     }
 
 #endif
 
 }  // namespace SK_OPTS_NS
 
 #endif//SkBlend_opts_DEFINED