Use NEON optimizations for RGB -> RGB(FF) or BGR(FF) 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 42 matching lines @@
                 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;
     }
 }
 
+static void xxx_xxxa_portable(uint32_t dst[], const uint32_t src[], int count) {
+    int i8 = 0;
+    const uint8_t* src8 = (uint8_t*) src;

[msarett, 2016/01/21 22:09:07]

It's a little strange that we pass in src as a pointer uint32_t.

+    for (int i32 = 0; i32 < count; i32++) {
+        uint8_t b = src8[i8++],
+                g = src8[i8++],
+                r = src8[i8++];
+        dst[i32] = (uint32_t)   b <<  0
+                 | (uint32_t)   g <<  8
+                 | (uint32_t)   r << 16
+                 | (uint32_t)0xFF << 24;
+    }
+}
+
+static void xxx_swaprb_xxxa_portable(uint32_t dst[], const uint32_t src[], int count) {
+    int i8 = 0;
+    const uint8_t* src8 = (uint8_t*) src;
+    for (int i32 = 0; i32 < count; i32++) {
+        uint8_t b = src8[i8++],
+                g = src8[i8++],
+                r = src8[i8++];
+        dst[i32] = (uint32_t)   r <<  0
+                 | (uint32_t)   g <<  8
+                 | (uint32_t)   b << 16
+                 | (uint32_t)0xFF << 24;
+    }
+}
+
 #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 88 matching lines @@
         // Store 8 pixels.
         vst4_u8((uint8_t*) dst, bgra);
         src += 8;
         dst += 8;
         count -= 8;
     }
 
     swaprb_xxxa_portable(dst, src, count);
 }
 
+static void xxx_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    const uint8_t* src8 = (const uint8_t*) src;
+    while (count >= 16) {
+        // Load 16 pixels.
+        uint8x16x3_t bgr = vld3q_u8(src8);
+
+        // Insert an opaque alpha channel.
+        uint8x16x4_t bgra;
+        bgra.val[0] = bgr.val[0];
+        bgra.val[1] = bgr.val[1];
+        bgra.val[2] = bgr.val[2];
+        bgra.val[3] = vdupq_n_u8(0xFF);
+
+        // Store 16 pixels.
+        vst4q_u8((uint8_t*) dst, bgra);
+        src8 += 48;
+        dst += 16;
+        count -= 16;
+    }
+
+    if (count >= 8) {
+        // Load 8 pixels.
+        uint8x8x3_t bgr = vld3_u8(src8);
+
+        // Insert an opaque alpha channel.
+        uint8x8x4_t bgra;
+        bgra.val[0] = bgr.val[0];
+        bgra.val[1] = bgr.val[1];
+        bgra.val[2] = bgr.val[2];
+        bgra.val[3] = vdup_n_u8(0xFF);
+
+        // Store 8 pixels.
+        vst4_u8((uint8_t*) dst, bgra);
+        src8 += 24;
+        dst += 8;
+        count -= 8;
+    }
+
+    xxx_xxxa_portable(dst, src, count);
+}
+
+static void xxx_swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    const uint8_t* src8 = (const uint8_t*) src;
+    while (count >= 16) {
+        // Load 16 pixels.
+        uint8x16x3_t bgr = vld3q_u8(src8);
+
+        // Swap r and b and insert an opaque alpha channel.
+        uint8x16x4_t rgba;
+        rgba.val[0] = bgr.val[2];
+        rgba.val[1] = bgr.val[1];
+        rgba.val[2] = bgr.val[0];
+        rgba.val[3] = vdupq_n_u8(0xFF);
+
+        // Store 16 pixels.
+        vst4q_u8((uint8_t*) dst, rgba);
+        src8 += 48;
+        dst += 16;
+        count -= 16;
+    }
+
+    if (count >= 8) {
+        // Load 8 pixels.
+        uint8x8x3_t bgr = vld3_u8(src8);
+
+        // Swap r and b and insert an opaque alpha channel.
+        uint8x8x4_t rgba;
+        rgba.val[0] = bgr.val[2];
+        rgba.val[1] = bgr.val[1];
+        rgba.val[2] = bgr.val[0];
+        rgba.val[3] = vdup_n_u8(0xFF);
+
+        // Store 8 pixels.
+        vst4_u8((uint8_t*) dst, rgba);
+        src8 += 24;
+        dst += 8;
+        count -= 8;
+    }
+
+    xxx_swaprb_xxxa_portable(dst, src, count);
+}
+
 #elif SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSSE3
 
 template <bool kSwapRB>
 static void premul_xxxa_should_swaprb(uint32_t dst[], const uint32_t src[], int count) {
 
     auto premul8 = [](__m128i* lo, __m128i* hi) {
         const __m128i zeros = _mm_setzero_si128();
         const __m128i _128 = _mm_set1_epi16(128);
         const __m128i _257 = _mm_set1_epi16(257);
         __m128i planar;
@@ skipping 76 matching lines @@
         _mm_storeu_si128((__m128i*) dst, rgba);
 
         src += 4;
         dst += 4;
         count -= 4;
     }
 
     swaprb_xxxa_portable(dst, src, count);
 }
 
+static void xxx_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    xxx_xxxa_portable(dst, src, count);
+}
+
+static void xxx_swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    xxx_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);
 }
 
+static void xxx_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    xxx_xxxa_portable(dst, src, count);
+}
+
+static void xxx_swaprb_xxxa(uint32_t dst[], const uint32_t src[], int count) {
+    xxx_swaprb_xxxa_portable(dst, src, count);
+}
+
 #endif
 
 }
 
 #endif // SkSwizzler_opts_DEFINED