1#include "SkBlitRow_opts_SSE4.h"
2
3// Some compilers can't compile SSSE3 or SSE4 intrinsics.  We give them stub methods.
4// The stubs should never be called, so we make them crash just to confirm that.
5#if SK_CPU_SSE_LEVEL < SK_CPU_SSE_LEVEL_SSE41
6void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT, const SkPMColor* SK_RESTRICT, int, U8CPU) {
7    sk_throw();
8}
9
10#else
11
12#include <smmintrin.h>      // SSE4.1 intrinsics
13#include "SkColorPriv.h"
14#include "SkColor_opts_SSE2.h"
15
16void S32A_Opaque_BlitRow32_SSE4(SkPMColor* SK_RESTRICT dst,
17                                const SkPMColor* SK_RESTRICT src,
18                                int count,
19                                U8CPU alpha) {
20    SkASSERT(alpha == 255);
21    // As long as we can, we'll work on 16 pixel pairs at once.
22    int count16 = count / 16;
23    __m128i* dst4 = (__m128i*)dst;
24    const __m128i* src4 = (const __m128i*)src;
25
26    for (int i = 0; i < count16 * 4; i += 4) {
27        // Load 16 source pixels.
28        __m128i s0 = _mm_loadu_si128(src4+i+0),
29                s1 = _mm_loadu_si128(src4+i+1),
30                s2 = _mm_loadu_si128(src4+i+2),
31                s3 = _mm_loadu_si128(src4+i+3);
32
33        const __m128i alphaMask = _mm_set1_epi32(0xFF << SK_A32_SHIFT);
34        const __m128i ORed = _mm_or_si128(s3, _mm_or_si128(s2, _mm_or_si128(s1, s0)));
35        if (_mm_testz_si128(ORed, alphaMask)) {
36            // All 16 source pixels are fully transparent.  There's nothing to do!
37            continue;
38        }
39        const __m128i ANDed = _mm_and_si128(s3, _mm_and_si128(s2, _mm_and_si128(s1, s0)));
40        if (_mm_testc_si128(ANDed, alphaMask)) {
41            // All 16 source pixels are fully opaque.  There's no need to read dst or blend it.
42            _mm_storeu_si128(dst4+i+0, s0);
43            _mm_storeu_si128(dst4+i+1, s1);
44            _mm_storeu_si128(dst4+i+2, s2);
45            _mm_storeu_si128(dst4+i+3, s3);
46            continue;
47        }
48        // The general slow case: do the blend for all 16 pixels.
49        _mm_storeu_si128(dst4+i+0, SkPMSrcOver_SSE2(s0, _mm_loadu_si128(dst4+i+0)));
50        _mm_storeu_si128(dst4+i+1, SkPMSrcOver_SSE2(s1, _mm_loadu_si128(dst4+i+1)));
51        _mm_storeu_si128(dst4+i+2, SkPMSrcOver_SSE2(s2, _mm_loadu_si128(dst4+i+2)));
52        _mm_storeu_si128(dst4+i+3, SkPMSrcOver_SSE2(s3, _mm_loadu_si128(dst4+i+3)));
53    }
54
55    // Wrap up the last <= 15 pixels.
56    for (int i = count16*16; i < count; i++) {
57        // This check is not really necessarily, but it prevents pointless autovectorization.
58        if (src[i] & 0xFF000000) {
59            dst[i] = SkPMSrcOver(src[i], dst[i]);
60        }
61    }
62}
63
64#endif
65