Use Sk4x4f in srcover_srgb_dst_1.

src/core/SkXfermode4f.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPM4fPriv.h"
 #include "SkUtils.h"
 #include "SkXfermode.h"
@@ skipping 29 matching lines @@
 }
 
 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);
 }
 
+// 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);
+
+    // Scale to [0,1].
+    p.r *= 1/255.0f;
+    p.g *= 1/255.0f;
+    p.b *= 1/255.0f;
+    p.a *= 1/255.0f;
+
+    // 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;
+
+    return p;
+}
+
+// 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.sqrt() * 255.0f + 0.5f,
+         g = p.g.sqrt() * 255.0f + 0.5f,
+         b = p.b.sqrt() * 255.0f + 0.5f,
+         a = p.a        * 255.0f + 0.5f;
+    Sk4x4f{r,g,b,a}.transpose((uint8_t*)ptr);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 template <DstType D> void general_1(const SkXfermode* xfer, uint32_t dst[],
                                     const SkPM4f* src, int count, const SkAlpha aa[]) {
     const SkPM4f s = rgba_to_pmcolor_order(*src);
     SkXfermodeProc4f proc = xfer->getProc4f();
     SkPM4f d;
     if (aa) {
         for (int i = 0; i < count; ++i) {
             Sk4f d4 = load_dst<D>(dst[i]);
@@ skipping 168 matching lines @@
 
 static void dst(const SkXfermode*, uint32_t dst[], const SkPM4f[], int count, const SkAlpha aa[]) {}
 
 const SkXfermode::D32Proc gProcs_Dst[] = {
     dst, dst, dst, dst, dst, dst, dst, dst,
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-static void srcover_n_srgb_bw(uint32_t dst[], const SkPM4f src[], int count) {
-    while (count >= 4) {
-        // Load 4 sRGB RGBA/BGRA 8888 dst pixels.
-        // We'll write most of this as if they're RGBA, and just swizzle the src pixels to match.
-        auto d = Sk4x4f::Transpose((const uint8_t*)dst);
-
-        // Scale to [0,1].
-        d.r *= 1/255.0f;
-        d.g *= 1/255.0f;
-        d.b *= 1/255.0f;
-        d.a *= 1/255.0f;
-
-        // Apply approximate sRGB gamma correction to convert to linear (as if gamma were 2).
-        d.r *= d.r;
-        d.g *= d.g;
-        d.b *= d.b;
-
-        // Load 4 linear float src pixels.
-        auto s = Sk4x4f::Transpose(src->fVec);
-
-        // Match color order with destination, if necessary.
-    #if defined(SK_PMCOLOR_IS_BGRA)
-        SkTSwap(s.r, s.b);
-    #endif
-
-        // Now, the meat of what we wanted to do... perform the srcover blend.
-        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;
-
-        // Convert back to sRGB and [0,255], again approximating sRGB as gamma == 2.
-        r = r.sqrt() * 255.0f + 0.5f;
-        g = g.sqrt() * 255.0f + 0.5f;
-        b = b.sqrt() * 255.0f + 0.5f;
-        a = a        * 255.0f + 0.5f;
-
-        Sk4x4f{r,g,b,a}.transpose((uint8_t*)dst);
-
-        count -= 4;
-        dst += 4;
-        src += 4;
-    }
-
-    // This should look just like the non-specialized case in srcover_n.
-    for (int i = 0; i < count; ++i) {
-        Sk4f s4 = src[i].to4f_pmorder();
-        Sk4f d4 = load_dst<kSRGB_Dst>(dst[i]);
-        Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
-        dst[i] = store_dst<kSRGB_Dst>(r4);
-    }
-}
-
 template <DstType D> void srcover_n(const SkXfermode*, uint32_t dst[],
                                     const SkPM4f src[], int count, const SkAlpha aa[]) {
     if (aa) {
         for (int i = 0; i < count; ++i) {
             unsigned a = aa[i];
             if (0 == a) {
                 continue;
             }
             Sk4f s4 = src[i].to4f_pmorder();
             Sk4f d4 = load_dst<D>(dst[i]);
             if (a != 0xFF) {
                 s4 = scale_by_coverage(s4, a);
             }
             Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
             dst[i] = store_dst<D>(r4);
         }
     } else {
-        if (D == kSRGB_Dst) {
-            srcover_n_srgb_bw(dst, src, count);
-        } else {
-            for (int i = 0; i < count; ++i) {
-                Sk4f s4 = src[i].to4f_pmorder();
-                Sk4f d4 = load_dst<D>(dst[i]);
-                Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
-                dst[i] = store_dst<D>(r4);
-            }
+        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;
+            src += 4;
+        }
+        for (int i = 0; i < count; ++i) {
+            Sk4f s4 = src[i].to4f_pmorder();
+            Sk4f d4 = load_dst<D>(dst[i]);
+            Sk4f r4 = s4 + d4 * Sk4f(1 - get_alpha(s4));
+            dst[i] = store_dst<D>(r4);
         }
     }
 }
 
 static void srcover_linear_dst_1(const SkXfermode*, uint32_t dst[],
                                  const SkPM4f* src, int count, const SkAlpha aa[]) {
     const Sk4f s4 = src->to4f_pmorder();
     const Sk4f dst_scale = Sk4f(1 - get_alpha(s4));
 
     if (aa) {
@@ skipping 50 matching lines @@
             if (a != 0xFF) {
                 const Sk4f s4_aa = scale_by_coverage(s4, a);
                 r4 = s4_aa + d4 * Sk4f(1 - get_alpha(s4_aa));
             } else {
                 r4 = s4 + d4 * dst_scale;
             }
             dst[i] = to_4b(linear_unit_to_srgb_255f(r4));
         }
     } else {
         while (count >= 4) {
-            Sk4f d0 = srgb_4b_to_linear_unit(dst[0]);
-            Sk4f d1 = srgb_4b_to_linear_unit(dst[1]);
-            Sk4f d2 = srgb_4b_to_linear_unit(dst[2]);
-            Sk4f d3 = srgb_4b_to_linear_unit(dst[3]);
-            Sk4f_ToBytes((uint8_t*)dst,
-                         linear_unit_to_srgb_255f(s4 + d0 * dst_scale),
-                         linear_unit_to_srgb_255f(s4 + d1 * dst_scale),
-                         linear_unit_to_srgb_255f(s4 + d2 * dst_scale),
-                         linear_unit_to_srgb_255f(s4 + d3 * dst_scale));
+            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;
-            count -= 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));
         }
     }
 }
 
 const SkXfermode::D32Proc gProcs_SrcOver[] = {
     srcover_n<kLinear_Dst>, src_n<kLinear_Dst>,
@@ skipping 123 matching lines @@
 
     const LCD32Proc procs[] = {
         srcover_n_lcd<kSRGB_Dst>,   src_n_lcd<kSRGB_Dst>,
         srcover_1_lcd<kSRGB_Dst>,   src_1_lcd<kSRGB_Dst>,
 
         srcover_n_lcd<kLinear_Dst>, src_n_lcd<kLinear_Dst>,
         srcover_1_lcd<kLinear_Dst>, src_1_lcd<kLinear_Dst>,
     };
     return procs[flags];
 }