SSSE3 opts for RGB -> RGB(FF) or BGR(FF)

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 340 matching lines @@
         _mm_storeu_si128((__m128i*) dst, bgra);
 
         src += 4;
         dst += 4;
         count -= 4;
     }
 
     RGBA_to_BGRA_portable(dst, src, count);
 }
 
+template <bool kSwapRB>
+static void insert_alpha_should_swaprb(uint32_t dst[], const void* vsrc, int count) {
+    const uint8_t* src = (const uint8_t*) vsrc;
+
+    const __m128i alphaMask = _mm_set1_epi32(0xFF000000);
+    __m128i expand;
+    const uint8_t X = 0xFF; // Used a placeholder.  The value of X is irrelevant.

[mtklein, 2016/01/22 17:51:50]

Because X > 127, this actually sets those lanes to zero.  Shame we can't exploit
that.

[msarett, 2016/01/22 18:20:08]

Agreed.  I was hoping there was something that would automatically set them to
0xFF :(.

+    if (kSwapRB) {
+        expand = _mm_setr_epi8(2,1,0,X, 5,4,3,X, 8,7,6,X, 11,10,9,X);
+    } else {
+        expand = _mm_setr_epi8(0,1,2,X, 3,4,5,X, 6,7,8,X, 9,10,11,X);
+    }
+
+    while (count >= 4) {
+        // Load a vector.  While this actually contains 5 pixels plus an

[mtklein, 2016/01/22 17:51:50]

So isn't this only safe while (count >= 6) ?

[mtklein, 2016/01/22 18:00:30]

Alternatively, since only the load is weird and the store is quite ordinary, we
might want to try looping while (count >= 4) and loading exactly the 12 bytes of
4 pixels using some combination of an 8 byte load and a 4 byte load?

We can load the bytes anywhere into the register that's convenient, as we'll be
_mm_shuffle_epi8'ing anyway.

E.g.
    __m128i rgb = _mm_cvtsi32_si128(*(const uint32_t*)src);   // load 4 bytes
into low 4 bytes
   rgb = _mm_castpd_si128(_mm_loadh_pd(_mm_castsi128_pd(rgb), (const
double*)(src+4)));  // load next 8 bytes into high 8 bytes, keeping the original
4 in the low lane
   _mm_shuffle_epi8(rgb, TBD)

[msarett, 2016/01/22 18:20:08]

I don't understand why it's not always safe?

At the very end of image we will load outside of our pixel memory, but we will
never use those values.  Is that not ok?

If it's not, maybe we should use this approach up until >= 6 and then your
approach for >= 4?

+        // extra component, we will discard all but the first four pixels on
+        // this iteration.
+        __m128i rgb = _mm_loadu_si128((const __m128i*) src);
+
+        // Expand the first four pixels to RGBX and then mask to RGB(FF).
+        __m128i rgba = _mm_or_si128(_mm_shuffle_epi8(rgb, expand), alphaMask);
+
+        // Store 4 pixels.
+        _mm_storeu_si128((__m128i*) dst, rgba);
+
+        src += 4*3;
+        dst += 4;
+        count -= 4;
+    }
+
+    // Call portable code to finish up the tail of [0,4) pixels.
+    auto proc = kSwapRB ? RGB_to_BGR1_portable : RGB_to_RGB1_portable;
+    proc(dst, src, count);
+}
+
 static void RGB_to_RGB1(uint32_t dst[], const void* src, int count) {
-    RGB_to_RGB1_portable(dst, src, count);
+    insert_alpha_should_swaprb<false>(dst, src, count);
 }
 
 static void RGB_to_BGR1(uint32_t dst[], const void* src, int count) {
-    RGB_to_BGR1_portable(dst, src, count);
+    insert_alpha_should_swaprb<true>(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) {
     RGBA_to_bgrA_portable(dst, src, count);
 }
 
 static void RGBA_to_BGRA(uint32_t* dst, const void* src, int count) {
     RGBA_to_BGRA_portable(dst, src, count);
 }
 
 static void RGB_to_RGB1(uint32_t dst[], const void* src, int count) {
     RGB_to_RGB1_portable(dst, src, count);
 }
 
 static void RGB_to_BGR1(uint32_t dst[], const void* src, int count) {
     RGB_to_BGR1_portable(dst, src, count);
 }
 
 #endif
 
 }
 
 #endif // SkSwizzler_opts_DEFINED