Use special case for 0x00 and 0xFF alpha to go faster.

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 195 matching lines @@
                 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
-            while (count >= 4) {
-                Sk4f aa4 = SkNx_cast<float>(Sk4b::Load(aa)) * Sk4f(1/255.0f);
-
-                /*  If we ever natively support convert 255_linear -> 255_srgb, then perhaps
-                 *  it would be faster (and possibly allow more code sharing with kLinear) to
-                 *  stay in that space.
-                 */
-                Sk4f r0 = lerp(s4, load_dst<D>(dst[0]), Sk4f(aa4[0]));
-                Sk4f r1 = lerp(s4, load_dst<D>(dst[1]), Sk4f(aa4[1]));
-                Sk4f r2 = lerp(s4, load_dst<D>(dst[2]), Sk4f(aa4[2]));
-                Sk4f r3 = lerp(s4, load_dst<D>(dst[3]), Sk4f(aa4[3]));
-                Sk4f_ToBytes((uint8_t*)dst,
-                             linear_unit_to_srgb_255f(r0),
-                             linear_unit_to_srgb_255f(r1),
-                             linear_unit_to_srgb_255f(r2),
-                             linear_unit_to_srgb_255f(r3));
-
-                dst += 4;
-                aa += 4;
-                count -= 4;
+            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));

[mtklein, 2016/05/27 15:58:49]

lerp() takes 3 Sk4f arguments in range [0,1].  I think we've forgotten to scalar
cover to [0,1] here.

[mtklein_C, 2016/05/27 16:57:59]

Nevermind, it's the other lerp!

[herb_g, 2016/05/27 16:59:18]

There are two lerp calls:
static Sk4f lerp(const Sk4f& src, const Sk4f& dst, uint8_t srcCoverage) {
    return dst + (src - dst) * Sk4f(srcCoverage * (1/255.0f));
}

and

static Sk4f lerp(const Sk4f& src, const Sk4f& dst, const Sk4f& src_scale) {
    return dst + (src - dst) * src_scale;
}

This code is using the first one which I think is correct.

+                    }
+                }
             }
-        }
-        for (int i = 0; i < count; ++i) {
-            unsigned a = aa[i];
-            Sk4f d4 = load_dst<D>(dst[i]);
-            dst[i] = store_dst<D>(lerp(s4, d4, a));
-        }
+        }          // kSRGB
     } else {
         sk_memset32(dst, store_dst<D>(s4), count);
     }
 }
 
 const SkXfermode::D32Proc gProcs_Src[] = {
     src_n<kLinear_Dst>, src_n<kLinear_Dst>,
     src_1<kLinear_Dst>, src_1<kLinear_Dst>,
     src_n<kSRGB_Dst>,   src_n<kSRGB_Dst>,
     src_1<kSRGB_Dst>,   src_1<kSRGB_Dst>,
@@ skipping 273 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];
 }