Xfermode: SSE2 implementation of a number of simple transfer modes

src/opts/SkColor_opts_SSE2.h

 /*
  * Copyright 2014 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkColor_opts_SSE2_DEFINED
 #define SkColor_opts_SSE2_DEFINED
 
 #include <emmintrin.h>
 
+static inline __m128i SkAlpha255To256_SSE2(const __m128i& alpha) {
+    return _mm_add_epi32(alpha, _mm_set1_epi32(1));
+}
+
 // See #define SkAlphaMulAlpha(a, b)  SkMulDiv255Round(a, b) in SkXfermode.cpp.
 static inline __m128i SkAlphaMulAlpha_SSE2(const __m128i& a,
                                            const __m128i& b) {
     __m128i prod = _mm_mullo_epi16(a, b);
     prod = _mm_add_epi32(prod, _mm_set1_epi32(128));
     prod = _mm_add_epi32(prod, _mm_srli_epi32(prod, 8));
     prod = _mm_srli_epi32(prod, 8);
 
     return prod;
 }
 
+// Portable version SkAlphaMulQ is in SkColorPriv.h.
+static inline __m128i SkAlphaMulQ_SSE2(const __m128i& c, const __m128i& scale) {

[mtklein, 2014/04/11 18:41:54]

Is this still the best way to do this with SSE2?   You see we're doing a sort of
4x8-bit SIMD in 32-bit ints, but we have to split them in two because the 8*8
bit multiply results in 16 bits.  Any way to perhaps just do this directly in on
SSE register instead of splitting into rb and ag?  Or I guess that would need a
non-existent _mm_mullo_epi8?

[qiankun, 2014/04/14 02:33:01]

Unfortunately, there is no 8-bits multiply funciton in SSE2 intrinsics. So keep
the current SSE2 implementation now.

+    __m128i mask = _mm_set1_epi32(gMask_00FF00FF);
+    __m128i s = _mm_or_si128(_mm_slli_epi32(scale, 16), scale);
+
+    // uint32_t rb = ((c & mask) * scale) >> 8
+    __m128i rb = _mm_and_si128(mask, c);
+    rb = _mm_mullo_epi16(rb, s);
+    rb = _mm_srli_epi16(rb, 8);
+
+    // uint32_t ag = ((c >> 8) & mask) * scale
+    __m128i ag = _mm_srli_epi16(c, 8);
+    ag = _mm_and_si128(ag, mask);
+    ag = _mm_mullo_epi16(ag, s);
+
+    // (rb & mask) | (ag & ~mask)
+    rb = _mm_and_si128(mask, rb);
+    ag = _mm_andnot_si128(mask, ag);
+    return _mm_or_si128(rb, ag);
+}
+
 static inline __m128i SkGetPackedA32_SSE2(const __m128i& src) {
     __m128i a = _mm_slli_epi32(src, (24 - SK_A32_SHIFT));
     return _mm_srli_epi32(a, 24);
 }
 
 static inline __m128i SkGetPackedR32_SSE2(const __m128i& src) {
     __m128i r = _mm_slli_epi32(src, (24 - SK_R32_SHIFT));
     return _mm_srli_epi32(r, 24);
 }
 
@@ skipping 103 matching lines @@
     b2 = _mm_and_si128(b2, _mm_set1_epi32(SK_B16_MASK));
     __m128i b = _mm_packs_epi32(b1, b2);
 
     // Store 8 16-bit colors in dst.
     __m128i d_pixel = SkPackRGB16_SSE2(r, g, b);
 
     return d_pixel;
 }
 
 #endif // SkColor_opts_SSE2_DEFINED