src/third_party/skia/src/opts/SkColor_opts_SSE2.h

   1 /*
   2  * Copyright 2014 The Android Open Source Project
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #ifndef SkColor_opts_SSE2_DEFINED
   9 #define SkColor_opts_SSE2_DEFINED
  10
  11 #include <emmintrin.h>
  12
  13 // Because no _mm_mul_epi32() in SSE2, we emulate it here.
  14 // Multiplies 4 32-bit integers from a by 4 32-bit intergers from b.
  15 // The 4 multiplication results should be represented within 32-bit
  16 // integers, otherwise they would be overflow.
  17 static inline  __m128i Multiply32_SSE2(const __m128i& a, const __m128i& b) {
  18     // Calculate results of a0 * b0 and a2 * b2.
  19     __m128i r1 = _mm_mul_epu32(a, b);
  20     // Calculate results of a1 * b1 and a3 * b3.
  21     __m128i r2 = _mm_mul_epu32(_mm_srli_si128(a, 4), _mm_srli_si128(b, 4));
  22     // Shuffle results to [63..0] and interleave the results.
  23     __m128i r = _mm_unpacklo_epi32(_mm_shuffle_epi32(r1, _MM_SHUFFLE(0,0,2,0)),
  24                                    _mm_shuffle_epi32(r2, _MM_SHUFFLE(0,0,2,0)));
  25     return r;
  26 }
  27
  28 static inline __m128i SkAlpha255To256_SSE2(const __m128i& alpha) {
  29     return _mm_add_epi32(alpha, _mm_set1_epi32(1));
  30 }
  31
  32 // See #define SkAlphaMulAlpha(a, b)  SkMulDiv255Round(a, b) in SkXfermode.cpp.
  33 static inline __m128i SkAlphaMulAlpha_SSE2(const __m128i& a,
  34                                            const __m128i& b) {
  35     __m128i prod = _mm_mullo_epi16(a, b);
  36     prod = _mm_add_epi32(prod, _mm_set1_epi32(128));
  37     prod = _mm_add_epi32(prod, _mm_srli_epi32(prod, 8));
  38     prod = _mm_srli_epi32(prod, 8);
  39
  40     return prod;
  41 }
  42
  43 // Portable version SkAlphaMulQ is in SkColorPriv.h.
  44 static inline __m128i SkAlphaMulQ_SSE2(const __m128i& c, const __m128i& scale) {
  45     __m128i mask = _mm_set1_epi32(gMask_00FF00FF);
  46     __m128i s = _mm_or_si128(_mm_slli_epi32(scale, 16), scale);
  47
  48     // uint32_t rb = ((c & mask) * scale) >> 8
  49     __m128i rb = _mm_and_si128(mask, c);
  50     rb = _mm_mullo_epi16(rb, s);
  51     rb = _mm_srli_epi16(rb, 8);
  52
  53     // uint32_t ag = ((c >> 8) & mask) * scale
  54     __m128i ag = _mm_srli_epi16(c, 8);
  55     ag = _mm_and_si128(ag, mask);
  56     ag = _mm_mullo_epi16(ag, s);
  57
  58     // (rb & mask) | (ag & ~mask)
  59     rb = _mm_and_si128(mask, rb);
  60     ag = _mm_andnot_si128(mask, ag);
  61     return _mm_or_si128(rb, ag);
  62 }
  63
  64 static inline __m128i SkGetPackedA32_SSE2(const __m128i& src) {
  65     __m128i a = _mm_slli_epi32(src, (24 - SK_A32_SHIFT));
  66     return _mm_srli_epi32(a, 24);
  67 }
  68
  69 static inline __m128i SkGetPackedR32_SSE2(const __m128i& src) {
  70     __m128i r = _mm_slli_epi32(src, (24 - SK_R32_SHIFT));
  71     return _mm_srli_epi32(r, 24);
  72 }
  73
  74 static inline __m128i SkGetPackedG32_SSE2(const __m128i& src) {
  75     __m128i g = _mm_slli_epi32(src, (24 - SK_G32_SHIFT));
  76     return _mm_srli_epi32(g, 24);
  77 }
  78
  79 static inline __m128i SkGetPackedB32_SSE2(const __m128i& src) {
  80     __m128i b = _mm_slli_epi32(src, (24 - SK_B32_SHIFT));
  81     return _mm_srli_epi32(b, 24);
  82 }
  83
  84 static inline __m128i SkMul16ShiftRound_SSE2(const __m128i& a,
  85                                              const __m128i& b, int shift) {
  86     __m128i prod = _mm_mullo_epi16(a, b);
  87     prod = _mm_add_epi16(prod, _mm_set1_epi16(1 << (shift - 1)));
  88     prod = _mm_add_epi16(prod, _mm_srli_epi16(prod, shift));
  89     prod = _mm_srli_epi16(prod, shift);
  90
  91     return prod;
  92 }
  93
  94 static inline __m128i SkPackRGB16_SSE2(const __m128i& r,
  95                                        const __m128i& g, const __m128i& b) {
  96     __m128i dr = _mm_slli_epi16(r, SK_R16_SHIFT);
  97     __m128i dg = _mm_slli_epi16(g, SK_G16_SHIFT);
  98     __m128i db = _mm_slli_epi16(b, SK_B16_SHIFT);
  99
 100     __m128i c = _mm_or_si128(dr, dg);
 101     return _mm_or_si128(c, db);
 102 }
 103
 104 static inline __m128i SkPackARGB32_SSE2(const __m128i& a, const __m128i& r,
 105                                         const __m128i& g, const __m128i& b) {
 106     __m128i da = _mm_slli_epi32(a, SK_A32_SHIFT);
 107     __m128i dr = _mm_slli_epi32(r, SK_R32_SHIFT);
 108     __m128i dg = _mm_slli_epi32(g, SK_G32_SHIFT);
 109     __m128i db = _mm_slli_epi32(b, SK_B32_SHIFT);
 110
 111     __m128i c = _mm_or_si128(da, dr);
 112     c = _mm_or_si128(c, dg);
 113     return _mm_or_si128(c, db);
 114 }
 115
 116 static inline __m128i SkPacked16ToR32_SSE2(const __m128i& src) {
 117     __m128i r = _mm_srli_epi32(src, SK_R16_SHIFT);
 118     r = _mm_and_si128(r, _mm_set1_epi32(SK_R16_MASK));
 119     r = _mm_or_si128(_mm_slli_epi32(r, (8 - SK_R16_BITS)),
 120                      _mm_srli_epi32(r, (2 * SK_R16_BITS - 8)));
 121
 122     return r;
 123 }
 124
 125 static inline __m128i SkPacked16ToG32_SSE2(const __m128i& src) {
 126     __m128i g = _mm_srli_epi32(src, SK_G16_SHIFT);
 127     g = _mm_and_si128(g, _mm_set1_epi32(SK_G16_MASK));
 128     g = _mm_or_si128(_mm_slli_epi32(g, (8 - SK_G16_BITS)),
 129                      _mm_srli_epi32(g, (2 * SK_G16_BITS - 8)));
 130
 131     return g;
 132 }
 133
 134 static inline __m128i SkPacked16ToB32_SSE2(const __m128i& src) {
 135     __m128i b = _mm_srli_epi32(src, SK_B16_SHIFT);
 136     b = _mm_and_si128(b, _mm_set1_epi32(SK_B16_MASK));
 137     b = _mm_or_si128(_mm_slli_epi32(b, (8 - SK_B16_BITS)),
 138                      _mm_srli_epi32(b, (2 * SK_B16_BITS - 8)));
 139
 140     return b;
 141 }
 142
 143 static inline __m128i SkPixel16ToPixel32_SSE2(const __m128i& src) {
 144     __m128i r = SkPacked16ToR32_SSE2(src);
 145     __m128i g = SkPacked16ToG32_SSE2(src);
 146     __m128i b = SkPacked16ToB32_SSE2(src);
 147
 148     return SkPackARGB32_SSE2(_mm_set1_epi32(0xFF), r, g, b);
 149 }
 150
 151 static inline __m128i SkPixel32ToPixel16_ToU16_SSE2(const __m128i& src_pixel1,
 152                                                     const __m128i& src_pixel2) {
 153     // Calculate result r.
 154     __m128i r1 = _mm_srli_epi32(src_pixel1,
 155                                 SK_R32_SHIFT + (8 - SK_R16_BITS));
 156     r1 = _mm_and_si128(r1, _mm_set1_epi32(SK_R16_MASK));
 157     __m128i r2 = _mm_srli_epi32(src_pixel2,
 158                                 SK_R32_SHIFT + (8 - SK_R16_BITS));
 159     r2 = _mm_and_si128(r2, _mm_set1_epi32(SK_R16_MASK));
 160     __m128i r = _mm_packs_epi32(r1, r2);
 161
 162     // Calculate result g.
 163     __m128i g1 = _mm_srli_epi32(src_pixel1,
 164                                 SK_G32_SHIFT + (8 - SK_G16_BITS));
 165     g1 = _mm_and_si128(g1, _mm_set1_epi32(SK_G16_MASK));
 166     __m128i g2 = _mm_srli_epi32(src_pixel2,
 167                                 SK_G32_SHIFT + (8 - SK_G16_BITS));
 168     g2 = _mm_and_si128(g2, _mm_set1_epi32(SK_G16_MASK));
 169     __m128i g = _mm_packs_epi32(g1, g2);
 170
 171     // Calculate result b.
 172     __m128i b1 = _mm_srli_epi32(src_pixel1,
 173                                 SK_B32_SHIFT + (8 - SK_B16_BITS));
 174     b1 = _mm_and_si128(b1, _mm_set1_epi32(SK_B16_MASK));
 175     __m128i b2 = _mm_srli_epi32(src_pixel2,
 176                                 SK_B32_SHIFT + (8 - SK_B16_BITS));
 177     b2 = _mm_and_si128(b2, _mm_set1_epi32(SK_B16_MASK));
 178     __m128i b = _mm_packs_epi32(b1, b2);
 179
 180     // Store 8 16-bit colors in dst.
 181     __m128i d_pixel = SkPackRGB16_SSE2(r, g, b);
 182
 183     return d_pixel;
 184 }
 185
 186 #endif // SkColor_opts_SSE2_DEFINED