Add NEON swap opts and use opts in SkSwizzler

src/opts/SkSwizzler_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.
  */
 
 #ifndef SkSwizzler_opts_DEFINED
 #define SkSwizzler_opts_DEFINED
 
@@ skipping 29 matching lines @@
         r = (r*a+127)/255;
         g = (g*a+127)/255;
         b = (b*a+127)/255;
         dst[i] = (uint32_t)a << 24
                | (uint32_t)b << 16
                | (uint32_t)g <<  8
                | (uint32_t)r <<  0;
     }
 }
 
+static void swaprb_xxxa_portable(uint32_t dst[], const uint32_t src[], int count) {
+    for (int i = 0; i < count; i++) {
+        uint8_t a = src[i] >> 24,
+                r = src[i] >> 16,
+                g = src[i] >>  8,
+                b = src[i] >>  0;
+        dst[i] = (uint32_t)a << 24
+               | (uint32_t)b << 16
+               | (uint32_t)g <<  8
+               | (uint32_t)r <<  0;
+    }
+}
+
 #if defined(SK_ARM_HAS_NEON)
 
 // Rounded divide by 255, (x + 127) / 255
 static uint8x8_t div255_round(uint16x8_t x) {
     // result = (x + 127) / 255
     // result = (x + 127) / 256 + error1
     //
     // error1 = (x + 127) / (255 * 256)
     // error1 = (x + 127) / (256 * 256) + error2
     //
@@ skipping 56 matching lines @@
 }
 
 static void premul_xxxa(uint32_t dst[], const uint32_t src[], int count) {
     premul_xxxa_should_swaprb<false>(dst, src, count);
 }
 
 static void premul_swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
     premul_xxxa_should_swaprb<true>(dst, src, count);
 }
 
+static void swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    while (count >= 16) {
+        // Load 16 pixels.
+        uint8x16x4_t bgra = vld4q_u8((const uint8_t*) src);
+
+        // Swap r and b.
+        uint8x16_t r = bgra.val[2],

[msarett, 2016/01/14 17:08:25]

No matter how I write this code, clang really wants to do it in 4 moves (though
it seems like it should be possible in 3).

Maybe there is a limitation on which registers can load and which can store?  Or
maybe clang is dumb?

+                   b = bgra.val[0];
+        bgra.val[2] = b;
+        bgra.val[0] = r;
+
+        // Store 16 pixels.
+        vst4q_u8((uint8_t*) dst, bgra);
+        src += 16;
+        dst += 16;
+        count -= 16;
+    }
+
+    while (count >= 8) {
+        // Load 8 pixels.
+        uint8x8x4_t bgra = vld4_u8((const uint8_t*) src);
+
+        // Swap r and b.
+        uint8x8_t r = bgra.val[2],
+                  b = bgra.val[0];
+        bgra.val[2] = b;
+        bgra.val[0] = r;
+
+        // Store 8 pixels.
+        vst4_u8((uint8_t*) dst, bgra);
+        src += 8;
+        dst += 8;
+        count -= 8;
+    }
+
+    swaprb_xxxa_portable(dst, src, count);
+}
+
 #else
 
 static void premul_xxxa(uint32_t dst[], const uint32_t src[], int count) {
     premul_xxxa_portable(dst, src, count);
 }
 
 static void premul_swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
     premul_swaprb_xxxa_portable(dst, src, count);
 }
 
+static void swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    swaprb_xxxa_portable(dst, src, count);
+}
+
 #endif
 
-static void swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
-    for (int i = 0; i < count; i++) {
-        uint8_t a = src[i] >> 24,
-                r = src[i] >> 16,
-                g = src[i] >>  8,
-                b = src[i] >>  0;
-        dst[i] = (uint32_t)a << 24
-               | (uint32_t)b << 16
-               | (uint32_t)g <<  8
-               | (uint32_t)r <<  0;
-    }
-}
-
 }
 
 #endif // SkSwizzler_opts_DEFINED