SkPx: new approach to fixed-point SIMD

SkPx is like Sk4px, except each platform implementation of SkPx can declare
a different sweet spot of N pixels, with extra loads and stores to handle the
ragged edge of 0<n<N pixels.

In this case, _sse's sweet spot remains 4 pixels.   _neon jumps up to 8 so
we can now use NEON's transposing loads and stores, and _none is just 1.
This makes operations involving alpha considerably more efficient on NEON,
as alpha is its own distinct 8x8 bit plane that's easy to toss around.

This incorporates a few other improvements I've been wanting:
  - no requirement that we're dealing with SkPMColor.  SkColor works too.
  - no anonymous namespace hack to differentiate implementations.

Codegen and perf look good on Clang/x86-64 and GCC/ARMv7.
The NEON code looks very similar to the old NEON code, as intended.
No .skp or GM diffs on my laptop.  Don't expect any.

I intend this to replace Sk4px.  Plan after landing:
  - port SkXfermode_opts.h
  - port Color32 in SkBlitRow_D32.cpp (and move to SkBlitRow_opts.h like other
    SkOpts code)
  - delete all Sk4px-related code
  - clean up evolutionary dead ends in SkNx (Sk16b, Sk16h, Sk4i, Sk4d, etc.)
    leaving Sk2f, Sk4f (and Sk2s, Sk4s).
  - find a machine with AVX2 to work on, write SkPx_avx2.h handling 8 pixels
    at a time.

In the end we'll have Sk4f for float pixels, SkPx for fixed-point pixels.

BUG=skia:4117

Committed: https://skia.googlesource.com/skia/+/82c93b45ed6ac0b628adb8375389c202d1f586f9

CQ_EXTRA_TRYBOTS=client.skia:Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Release-SKNX_NO_SIMD-Trybot;client.skia.compile:Build-Mac10.8-Clang-Arm7-Debug-Android-Trybot

Review URL: https://codereview.chromium.org/1317233005

1 files changed, 40 insertions, 173 deletions

diff --git a/src/opts/SkBlitMask_opts.h b/src/opts/SkBlitMask_opts.h
index 2f4fe6ffb8..f4d7e7973f 100644
--- a/src/opts/SkBlitMask_opts.h
+++ b/src/opts/SkBlitMask_opts.h
@@ -9,195 +9,62 @@
 #define SkBlitMask_opts_DEFINED
 
 #include "Sk4px.h"
+#include "SkPx.h"
 
 namespace SK_OPTS_NS {
 
-#if defined(SK_ARM_HAS_NEON)
-    // The Sk4px versions below will work fine with NEON, but we have had many indications
-    // that it doesn't perform as well as this NEON-specific code.  TODO(mtklein): why?
-    #include "SkColor_opts_neon.h"
-
-    template <bool isColor>
-    static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB,
-                                         const void* SK_RESTRICT maskPtr, size_t maskRB,
-                                         SkColor color, int width, int height) {
-        SkPMColor pmc = SkPreMultiplyColor(color);
-        SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
-        const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
-        uint8x8x4_t vpmc;
-
-        maskRB -= width;
-        dstRB -= (width << 2);
-
-        if (width >= 8) {
-            vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc));
-            vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc));
-            vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc));
-            vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc));
+template <typename Fn>
+static void blit_mask_d32_a8(const Fn& fn, SkPMColor* dst, size_t dstRB,
+                                           const SkAlpha* mask, size_t maskRB,
+                                           int w, int h) {
+    while (h --> 0) {
+        int n = w;
+        while (n >= SkPx::N) {
+            fn(SkPx::Load(dst), SkPx::Alpha::Load(mask)).store(dst);
+            dst += SkPx::N; mask += SkPx::N; n -= SkPx::N;
         }
-        do {
-            int w = width;
-            while (w >= 8) {
-                uint8x8_t vmask = vld1_u8(mask);
-                uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask);
-                if (isColor) {
-                    vscale = vsubw_u8(vdupq_n_u16(256),
-                            SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256));
-                } else {
-                    vscale = vsubw_u8(vdupq_n_u16(256), vmask);
-                }
-                uint8x8x4_t vdev = vld4_u8((uint8_t*)device);
-
-                vdev.val[NEON_A] =   SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)
-                    + SkAlphaMul_neon8(vdev.val[NEON_A], vscale);
-                vdev.val[NEON_R] =   SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256)
-                    + SkAlphaMul_neon8(vdev.val[NEON_R], vscale);
-                vdev.val[NEON_G] =   SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256)
-                    + SkAlphaMul_neon8(vdev.val[NEON_G], vscale);
-                vdev.val[NEON_B] =   SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256)
-                    + SkAlphaMul_neon8(vdev.val[NEON_B], vscale);
-
-                vst4_u8((uint8_t*)device, vdev);
-
-                mask += 8;
-                device += 8;
-                w -= 8;
-            }
-
-            while (w--) {
-                unsigned aa = *mask++;
-                if (isColor) {
-                    *device = SkBlendARGB32(pmc, *device, aa);
-                } else {
-                    *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa))
-                        + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
-                }
-                device += 1;
-            };
-
-            device = (uint32_t*)((char*)device + dstRB);
-            mask += maskRB;
-
-        } while (--height != 0);
-    }
-
-    static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
-                                         const SkAlpha* mask, size_t maskRB,
-                                         SkColor color, int w, int h) {
-        D32_A8_Opaque_Color_neon<true>(dst, dstRB, mask, maskRB, color, w, h);
-    }
-
-    // As above, but made slightly simpler by requiring that color is opaque.
-    static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
-                                        const SkAlpha* mask, size_t maskRB,
-                                        SkColor color, int w, int h) {
-        D32_A8_Opaque_Color_neon<false>(dst, dstRB, mask, maskRB, color, w, h);
-    }
-
-    // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
-    static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
-                                       const SkAlpha* maskPtr, size_t maskRB,
-                                       int width, int height) {
-        SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
-        const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
-
-        maskRB -= width;
-        dstRB -= (width << 2);
-        do {
-            int w = width;
-            while (w >= 8) {
-                uint8x8_t vmask = vld1_u8(mask);
-                uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask);
-                uint8x8x4_t vdevice = vld4_u8((uint8_t*)device);
-
-                vdevice = SkAlphaMulQ_neon8(vdevice, vscale);
-                vdevice.val[NEON_A] += vmask;
-
-                vst4_u8((uint8_t*)device, vdevice);
-
-                mask += 8;
-                device += 8;
-                w -= 8;
-            }
-            while (w-- > 0) {
-                unsigned aa = *mask++;
-                *device = (aa << SK_A32_SHIFT)
-                            + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
-                device += 1;
-            };
-            device = (uint32_t*)((char*)device + dstRB);
-            mask += maskRB;
-        } while (--height != 0);
-    }
-
-#else
-    static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
-                                         const SkAlpha* mask, size_t maskRB,
-                                         SkColor color, int w, int h) {
-        auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
-        auto fn = [&](const Sk4px& d, const Sk4px& aa) {
-            //  = (s + d(1-sa))aa + d(1-aa)
-            //  = s*aa + d(1-sa*aa)
-            auto left  = s.approxMulDiv255(aa),
-                 right = d.approxMulDiv255(left.alphas().inv());
-            return left + right;  // This does not overflow (exhaustively checked).
-        };
-        while (h --> 0) {
-            Sk4px::MapDstAlpha(w, dst, mask, fn);
-            dst  +=  dstRB / sizeof(*dst);
-            mask += maskRB / sizeof(*mask);
+        if (n > 0) {
+            fn(SkPx::Load(dst, n), SkPx::Alpha::Load(mask, n)).store(dst, n);
+            dst += n; mask += n;
         }
+        dst  +=  dstRB / sizeof(*dst)  - w;
+        mask += maskRB / sizeof(*mask) - w;
     }
+}
 
-    // As above, but made slightly simpler by requiring that color is opaque.
-    static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
-                                        const SkAlpha* mask, size_t maskRB,
-                                        SkColor color, int w, int h) {
-        SkASSERT(SkColorGetA(color) == 0xFF);
-        auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
-        auto fn = [&](const Sk4px& d, const Sk4px& aa) {
-            //  = (s + d(1-sa))aa + d(1-aa)
-            //  = s*aa + d(1-sa*aa)
-            //   ~~~>
-            //  = s*aa + d(1-aa)
-            return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
-        };
-        while (h --> 0) {
-            Sk4px::MapDstAlpha(w, dst, mask, fn);
-            dst  +=  dstRB / sizeof(*dst);
-            mask += maskRB / sizeof(*mask);
-        }
-    }
+static void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB,
+                             const SkAlpha* mask, size_t maskRB,
+                             SkColor color, int w, int h) {
+    auto s = SkPx::Dup(SkPreMultiplyColor(color));
 
-    // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
-    static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
-                                       const SkAlpha* mask, size_t maskRB,
-                                       int w, int h) {
-        auto fn = [](const Sk4px& d, const Sk4px& aa) {
+    if (color == SK_ColorBLACK) {
+        auto fn = [](const SkPx& d, const SkPx::Alpha& aa) {
             //   = (s + d(1-sa))aa + d(1-aa)
             //   = s*aa + d(1-sa*aa)
             //   ~~~>
             // a = 1*aa + d(1-1*aa) = aa + d(1-aa)
             // c = 0*aa + d(1-1*aa) =      d(1-aa)
-            return aa.zeroColors() + d.approxMulDiv255(aa.inv());
+            return d.approxMulDiv255(aa.inv()).addAlpha(aa);
         };
-        while (h --> 0) {
-            Sk4px::MapDstAlpha(w, dst, mask, fn);
-            dst  +=  dstRB / sizeof(*dst);
-            mask += maskRB / sizeof(*mask);
-        }
-    }
-#endif
-
-static void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB,
-                             const SkAlpha* mask, size_t maskRB,
-                             SkColor color, int w, int h) {
-    if (color == SK_ColorBLACK) {
-        blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
+        blit_mask_d32_a8(fn, dst, dstRB, mask, maskRB, w, h);
     } else if (SkColorGetA(color) == 0xFF) {
-        blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
+        auto fn = [&](const SkPx& d, const SkPx::Alpha& aa) {
+            //  = (s + d(1-sa))aa + d(1-aa)
+            //  = s*aa + d(1-sa*aa)
+            //   ~~~>
+            //  = s*aa + d(1-aa)
+            return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
+        };
+        blit_mask_d32_a8(fn, dst, dstRB, mask, maskRB, w, h);
     } else {
-        blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
+        auto fn = [&](const SkPx& d, const SkPx::Alpha& aa) {
+            //  = (s + d(1-sa))aa + d(1-aa)
+            //  = s*aa + d(1-sa*aa)
+            auto left  = s.approxMulDiv255(aa),
+                 right = d.approxMulDiv255(left.alpha().inv());
+            return left + right;  // This does not overflow (exhaustively checked).
+        };
+        blit_mask_d32_a8(fn, dst, dstRB, mask, maskRB, w, h);
     }
 }