SSSE3 optimizations for gray -> RGBA (or BGRA)

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 434 matching lines @@
 }
 
 static void RGB_to_RGB1(uint32_t dst[], const void* src, int count) {
     insert_alpha_should_swaprb<false>(dst, src, count);
 }
 
 static void RGB_to_BGR1(uint32_t dst[], const void* src, int count) {
     insert_alpha_should_swaprb<true>(dst, src, count);
 }
 
-static void gray_to_RGB1(uint32_t dst[], const void* src, int count) {
+static void gray_to_RGB1(uint32_t dst[], const void* vsrc, int count) {

[msarett, 2016/02/02 20:22:36]

This performs almost identically to an *unpack* based approach.  It may be just
slightly faster, since it needs a couple less MOV instructions.

The *unpack* approach requires more MOVs because unpack is destructive to both
argument registers.

[mtklein, 2016/02/02 20:29:30]

Even on mobile x86 (Venue8)?

[mtklein, 2016/02/02 20:32:06]

(If so that makes me very happy.  I love,love,love pshufb.)

[msarett, 2016/02/02 20:41:44]

I only compared the two approaches on my desktop initially.  Unpack is wayyy
faster on mobile.

How did you know that?  Wow!

I'm switching to *unpack*.  Mobile is more important.

[mtklein, 2016/02/02 20:47:18]

:(  This is one of those times I hate to be right.
pshufb costs 5 cycles on mobile x86, but only 1 on normal x86.  unpacks are 1
everywhere.

I usually refer to https://software.intel.com/sites/landingpage/IntrinsicsGuide/
for a rough idea of how most desktop-class processors will work, but
http://www.agner.org/optimize/instruction_tables.pdf gives you details for many
more (including mobile, e.g. Silvermont).

[msarett, 2016/02/02 20:53:59]

Thanks for the extra reference!  Got an extra 5% on mobile!  Woohoo!

+    const uint8_t* src = (const uint8_t*) vsrc;
+
+    const __m128i alphaMask = _mm_set1_epi32(0xFF000000);
+    const uint8_t X = 0xFF; // Used a placeholder.  The value of X is irrelevant.
+    const __m128i expand0 = _mm_setr_epi8(0,0,0,X,    1,1,1,X,    2,2,2,X,    3,3,3,X);
+    const __m128i expand1 = _mm_setr_epi8(4,4,4,X,    5,5,5,X,    6,6,6,X,    7,7,7,X);
+    const __m128i expand2 = _mm_setr_epi8(8,8,8,X,    9,9,9,X,    10,10,10,X, 11,11,11,X);
+    const __m128i expand3 = _mm_setr_epi8(12,12,12,X, 13,13,13,X, 14,14,14,X, 15,15,15,X);
+    while (count >= 16) {
+        __m128i grays = _mm_loadu_si128((const __m128i*) src);
+
+        __m128i ggga0 = _mm_or_si128(_mm_shuffle_epi8(grays, expand0), alphaMask);
+        __m128i ggga1 = _mm_or_si128(_mm_shuffle_epi8(grays, expand1), alphaMask);
+        __m128i ggga2 = _mm_or_si128(_mm_shuffle_epi8(grays, expand2), alphaMask);
+        __m128i ggga3 = _mm_or_si128(_mm_shuffle_epi8(grays, expand3), alphaMask);
+
+        _mm_storeu_si128((__m128i*) (dst +  0), ggga0);
+        _mm_storeu_si128((__m128i*) (dst +  4), ggga1);
+        _mm_storeu_si128((__m128i*) (dst +  8), ggga2);
+        _mm_storeu_si128((__m128i*) (dst + 12), ggga3);
+
+        src += 16;
+        dst += 16;
+        count -= 16;
+    }
+
     gray_to_RGB1_portable(dst, src, count);
 }
 
 #else
 
 static void RGBA_to_rgbA(uint32_t* dst, const void* src, int count) {
     RGBA_to_rgbA_portable(dst, src, count);
 }
 
 static void RGBA_to_bgrA(uint32_t* dst, const void* src, int count) {
@@ skipping 14 matching lines @@
 
 static void gray_to_RGB1(uint32_t dst[], const void* src, int count) {
     gray_to_RGB1_portable(dst, src, count);
 }
 
 #endif
 
 }
 
 #endif // SkSwizzler_opts_DEFINED