/*

 * Copyright © 2004, 2005 Red Hat, Inc.

 * Copyright © 2004 Nicholas Miell

 * Copyright © 2005 Trolltech AS

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of Red Hat not be used in advertising or

 * publicity pertaining to distribution of the software without specific,

 * written prior permission.  Red Hat makes no representations about the

 * suitability of this software for any purpose.  It is provided "as is"

 * without express or implied warranty.

 *

 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 *

 * Author:  Søren Sandmann (sandmann@redhat.com)

 * Minor Improvements: Nicholas Miell (nmiell@gmail.com)

 * MMX code paths for fbcompose.c by Lars Knoll (lars@trolltech.com)

 *

 * Based on work by Owen Taylor

 */

#ifdef HAVE_CONFIG_H

#include <pixman-config.h>

#endif

#if defined USE_X86_MMX || defined USE_LOONGSON_MMI

#ifdef USE_LOONGSON_MMI

#include <loongson-mmintrin.h>

#else

#include <mmintrin.h>

#endif

#include "pixman-private.h"

#include "pixman-combine32.h"

#include "pixman-inlines.h"

#ifdef VERBOSE

#define CHECKPOINT() error_f ("at %s %d\n", __FUNCTION__, __LINE__)

#else

#define CHECKPOINT()

#endif

#ifdef USE_X86_MMX

# if (defined(__SSE2__) || defined(__SUNPRO_C) || defined(_MSC_VER) || defined(_WIN64))

#  include <xmmintrin.h>

# else

/* We have to compile with -msse to use xmmintrin.h, but that causes SSE

 * instructions to be generated that we don't want. Just duplicate the

 * functions we want to use.  */

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))

_mm_movemask_pi8 (__m64 __A)

{

    int ret;

    asm ("pmovmskb %1, %0\n\t"

  : "=r" (ret)

  : "y" (__A)

    );

    return ret;

}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))

_mm_mulhi_pu16 (__m64 __A, __m64 __B)

{

    asm ("pmulhuw %1, %0\n\t"

  : "+y" (__A)

  : "y" (__B)

    );

    return __A;

}

# define _mm_shuffle_pi16(A, N)           \

    ({                  \

  __m64 ret;              \

                  \

  asm ("pshufw %2, %1, %0\n\t"          \

       : "=y" (ret)           \

       : "y" (A), "K" ((const int8_t)N)       \

  );                \

                  \

  ret;                \

    })

# endif

#endif

#ifndef _MM_SHUFFLE

#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \

 (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))

#endif

/* Notes about writing mmx code

 *

 * give memory operands as the second operand. If you give it as the

 * first, gcc will first load it into a register, then use that

 * register

 *

 *   ie. use

 *

 *         _mm_mullo_pi16 (x, mmx_constant);

 *

 *   not

 *

 *         _mm_mullo_pi16 (mmx_constant, x);

 *

 * Also try to minimize dependencies. i.e. when you need a value, try

 * to calculate it from a value that was calculated as early as

 * possible.

 */

/* --------------- MMX primitives ------------------------------------- */

/* If __m64 is defined as a struct or union, then define M64_MEMBER to be

 * the name of the member used to access the data.

 * If __m64 requires using mm_cvt* intrinsics functions to convert between

 * uint64_t and __m64 values, then define USE_CVT_INTRINSICS.

 * If __m64 and uint64_t values can just be cast to each other directly,

 * then define USE_M64_CASTS.

 * If __m64 is a double datatype, then define USE_M64_DOUBLE.

 */

#ifdef _MSC_VER

# ifdef __clang__

#  define USE_CVT_INTRINSICS

# else

#  define M64_MEMBER m64_u64

# endif

#elif defined(__ICC)

# define USE_CVT_INTRINSICS

#elif defined(USE_LOONGSON_MMI)

# define USE_M64_DOUBLE

#elif defined(__GNUC__)

# define USE_M64_CASTS

#elif defined(__SUNPRO_C)

# if (__SUNPRO_C >= 0x5120) && !defined(__NOVECTORSIZE__)

/* Solaris Studio 12.3 (Sun C 5.12) introduces __attribute__(__vector_size__)

 * support, and defaults to using it to define __m64, unless __NOVECTORSIZE__

 * is defined.   If it is used, then the mm_cvt* intrinsics must be used.

 */

#  define USE_CVT_INTRINSICS

# else

/* For Studio 12.2 or older, or when __attribute__(__vector_size__) is

 * disabled, __m64 is defined as a struct containing "unsigned long long l_".

 */

#  define M64_MEMBER l_

# endif

#endif

#if defined(USE_M64_CASTS) || defined(USE_CVT_INTRINSICS) || defined(USE_M64_DOUBLE)

typedef uint64_t mmxdatafield;

#else

typedef __m64 mmxdatafield;

#endif

typedef struct

{

    mmxdatafield mmx_4x00ff;

    mmxdatafield mmx_4x0080;

    mmxdatafield mmx_565_rgb;

    mmxdatafield mmx_565_unpack_multiplier;

    mmxdatafield mmx_565_pack_multiplier;

    mmxdatafield mmx_565_r;

    mmxdatafield mmx_565_g;

    mmxdatafield mmx_565_b;

    mmxdatafield mmx_packed_565_rb;

    mmxdatafield mmx_packed_565_g;

    mmxdatafield mmx_expand_565_g;

    mmxdatafield mmx_expand_565_b;

    mmxdatafield mmx_expand_565_r;

#ifndef USE_LOONGSON_MMI

    mmxdatafield mmx_mask_0;

    mmxdatafield mmx_mask_1;

    mmxdatafield mmx_mask_2;

    mmxdatafield mmx_mask_3;

#endif

    mmxdatafield mmx_full_alpha;

    mmxdatafield mmx_4x0101;

    mmxdatafield mmx_ff000000;

} mmx_data_t;

#if defined(_MSC_VER)

# define MMXDATA_INIT(field, val) { val ## UI64 }

#elif defined(M64_MEMBER)       /* __m64 is a struct, not an integral type */

# define MMXDATA_INIT(field, val) field =   { val ## ULL }

#else                           /* mmxdatafield is an integral type */

# define MMXDATA_INIT(field, val) field =   val ## ULL

#endif

static const mmx_data_t c =

{

    MMXDATA_INIT (.mmx_4x00ff,                   0x00ff00ff00ff00ff),

    MMXDATA_INIT (.mmx_4x0080,                   0x0080008000800080),

    MMXDATA_INIT (.mmx_565_rgb,                  0x000001f0003f001f),

    MMXDATA_INIT (.mmx_565_unpack_multiplier,    0x0000008404100840),

    MMXDATA_INIT (.mmx_565_pack_multiplier,      0x2000000420000004),

    MMXDATA_INIT (.mmx_565_r,                    0x000000f800000000),

    MMXDATA_INIT (.mmx_565_g,                    0x0000000000fc0000),

    MMXDATA_INIT (.mmx_565_b,                    0x00000000000000f8),

    MMXDATA_INIT (.mmx_packed_565_rb,            0x00f800f800f800f8),

    MMXDATA_INIT (.mmx_packed_565_g,             0x0000fc000000fc00),

    MMXDATA_INIT (.mmx_expand_565_g,             0x07e007e007e007e0),

    MMXDATA_INIT (.mmx_expand_565_b,             0x001f001f001f001f),

    MMXDATA_INIT (.mmx_expand_565_r,             0xf800f800f800f800),

#ifndef USE_LOONGSON_MMI

    MMXDATA_INIT (.mmx_mask_0,                   0xffffffffffff0000),

    MMXDATA_INIT (.mmx_mask_1,                   0xffffffff0000ffff),

    MMXDATA_INIT (.mmx_mask_2,                   0xffff0000ffffffff),

    MMXDATA_INIT (.mmx_mask_3,                   0x0000ffffffffffff),

#endif

    MMXDATA_INIT (.mmx_full_alpha,               0x00ff000000000000),

    MMXDATA_INIT (.mmx_4x0101,                   0x0101010101010101),

    MMXDATA_INIT (.mmx_ff000000,                 0xff000000ff000000),

};

#ifdef USE_CVT_INTRINSICS

#    define MC(x) to_m64 (c.mmx_ ## x)

#elif defined(USE_M64_CASTS)

#    define MC(x) ((__m64)c.mmx_ ## x)

#elif defined(USE_M64_DOUBLE)

#    define MC(x) (*(__m64 *)&c.mmx_ ## x)

#else

#    define MC(x) c.mmx_ ## x

#endif

static force_inline __m64

to_m64 (uint64_t x)

{

#ifdef USE_CVT_INTRINSICS

    return _mm_cvtsi64_m64 (x);

#elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */

    __m64 res;

    res.M64_MEMBER = x;

    return res;

#elif defined USE_M64_DOUBLE

    return *(__m64 *)&x;

#else /* USE_M64_CASTS */

    return (__m64)x;

#endif

}

static force_inline uint64_t

to_uint64 (__m64 x)

{

#ifdef USE_CVT_INTRINSICS

    return _mm_cvtm64_si64 (x);

#elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */

    uint64_t res = x.M64_MEMBER;

    return res;

#elif defined USE_M64_DOUBLE

    return *(uint64_t *)&x;

#else /* USE_M64_CASTS */

    return (uint64_t)x;

#endif

}

static force_inline __m64

shift (__m64 v,

       int   s)

{

    if (s > 0)

  return _mm_slli_si64 (v, s);

    else if (s < 0)

  return _mm_srli_si64 (v, -s);

    else

  return v;

}

static force_inline __m64

negate (__m64 mask)

{

    return _mm_xor_si64 (mask, MC (4x00ff));

}

/* Computes the product of two unsigned fixed-point 8-bit values from 0 to 1

 * and maps its result to the same range.

 *

 * Jim Blinn gives multiple ways to compute this in "Jim Blinn's Corner:

 * Notation, Notation, Notation", the first of which is

 *

 *   prod(a, b) = (a * b + 128) / 255.

 *

 * By approximating the division by 255 as 257/65536 it can be replaced by a

 * multiply and a right shift. This is the implementation that we use in

 * pix_multiply(), but we _mm_mulhi_pu16() by 257 (part of SSE1 or Extended

 * 3DNow!, and unavailable at the time of the book's publication) to perform

 * the multiplication and right shift in a single operation.

 *

 *   prod(a, b) = ((a * b + 128) * 257) >> 16.

 *

 * A third way (how pix_multiply() was implemented prior to 14208344) exists

 * also that performs the multiplication by 257 with adds and shifts.

 *

 * Where temp = a * b + 128

 *

 *   prod(a, b) = (temp + (temp >> 8)) >> 8.

 */

static force_inline __m64

pix_multiply (__m64 a, __m64 b)

{

    __m64 res;

    res = _mm_mullo_pi16 (a, b);

    res = _mm_adds_pu16 (res, MC (4x0080));

    res = _mm_mulhi_pu16 (res, MC (4x0101));

    return res;

}

static force_inline __m64

pix_add (__m64 a, __m64 b)

{

    return _mm_adds_pu8 (a, b);

}

static force_inline __m64

expand_alpha (__m64 pixel)

{

    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 3, 3, 3));

}

static force_inline __m64

expand_alpha_rev (__m64 pixel)

{

    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (0, 0, 0, 0));

}

static force_inline __m64

invert_colors (__m64 pixel)

{

    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 0, 1, 2));

}

static force_inline __m64

over (__m64 src,

      __m64 srca,

      __m64 dest)

{

    return _mm_adds_pu8 (src, pix_multiply (dest, negate (srca)));

}

static force_inline __m64

over_rev_non_pre (__m64 src, __m64 dest)

{

    __m64 srca = expand_alpha (src);

    __m64 srcfaaa = _mm_or_si64 (srca, MC (full_alpha));

    return over (pix_multiply (invert_colors (src), srcfaaa), srca, dest);

}

static force_inline __m64

in (__m64 src, __m64 mask)

{

    return pix_multiply (src, mask);

}

#ifndef _MSC_VER

static force_inline __m64

in_over (__m64 src, __m64 srca, __m64 mask, __m64 dest)

{

    return over (in (src, mask), pix_multiply (srca, mask), dest);

}

#else

#define in_over(src, srca, mask, dest)          \

    over (in (src, mask), pix_multiply (srca, mask), dest)

#endif

/* Elemental unaligned loads */

static force_inline __m64 ldq_u(__m64 *p)

{

#ifdef USE_X86_MMX

    /* x86's alignment restrictions are very relaxed, but that's no excuse */

    __m64 r;

    memcpy(&r, p, sizeof(__m64));

    return r;

#else

    struct __una_u64 { __m64 x __attribute__((packed)); };

    const struct __una_u64 *ptr = (const struct __una_u64 *) p;

    return (__m64) ptr->x;

#endif

}

static force_inline uint32_t ldl_u(const uint32_t *p)

{

#ifdef USE_X86_MMX

    /* x86's alignment restrictions are very relaxed. */

    uint32_t r;

    memcpy(&r, p, sizeof(uint32_t));

    return r;

#else

    struct __una_u32 { uint32_t x __attribute__((packed)); };

    const struct __una_u32 *ptr = (const struct __una_u32 *) p;

    return ptr->x;

#endif

}

static force_inline __m64

load (const uint32_t *v)

{

#ifdef USE_LOONGSON_MMI

    __m64 ret;

    asm ("lwc1 %0, %1\n\t"

  : "=f" (ret)

  : "m" (*v)

    );

    return ret;

#else

    return _mm_cvtsi32_si64 (*v);

#endif

}

static force_inline __m64

load8888 (const uint32_t *v)

{

#ifdef USE_LOONGSON_MMI

    return _mm_unpacklo_pi8_f (*(__m32 *)v, _mm_setzero_si64 ());

#else

    return _mm_unpacklo_pi8 (load (v), _mm_setzero_si64 ());

#endif

}

static force_inline __m64

load8888u (const uint32_t *v)

{

    uint32_t l = ldl_u (v);

    return load8888 (&l);

}

static force_inline __m64

pack8888 (__m64 lo, __m64 hi)

{

    return _mm_packs_pu16 (lo, hi);

}

static force_inline void

store (uint32_t *dest, __m64 v)

{

#ifdef USE_LOONGSON_MMI

    asm ("swc1 %1, %0\n\t"

  : "=m" (*dest)

  : "f" (v)

  : "memory"

    );

#else

    *dest = _mm_cvtsi64_si32 (v);

#endif

}

static force_inline void

store8888 (uint32_t *dest, __m64 v)

{

    v = pack8888 (v, _mm_setzero_si64 ());

    store (dest, v);

}

static force_inline pixman_bool_t

is_equal (__m64 a, __m64 b)

{

#ifdef USE_LOONGSON_MMI

    /* __m64 is double, we can compare directly. */

    return a == b;

#else

    return _mm_movemask_pi8 (_mm_cmpeq_pi8 (a, b)) == 0xff;

#endif

}

static force_inline pixman_bool_t

is_opaque (__m64 v)

{

#ifdef USE_LOONGSON_MMI

    return is_equal (_mm_and_si64 (v, MC (full_alpha)), MC (full_alpha));

#else

    __m64 ffs = _mm_cmpeq_pi8 (v, v);

    return (_mm_movemask_pi8 (_mm_cmpeq_pi8 (v, ffs)) & 0x40);

#endif

}

static force_inline pixman_bool_t

is_zero (__m64 v)

{

    return is_equal (v, _mm_setzero_si64 ());

}

/* Expand 16 bits positioned at @pos (0-3) of a mmx register into

 *

 *    00RR00GG00BB

 *

 * --- Expanding 565 in the low word ---

 *

 * m = (m << (32 - 3)) | (m << (16 - 5)) | m;

 * m = m & (01f0003f001f);

 * m = m * (008404100840);

 * m = m >> 8;

 *

 * Note the trick here - the top word is shifted by another nibble to

 * avoid it bumping into the middle word

 */

static force_inline __m64

expand565 (__m64 pixel, int pos)

{

    __m64 p = pixel;

    __m64 t1, t2;

    /* move pixel to low 16 bit and zero the rest */

#ifdef USE_LOONGSON_MMI

    p = loongson_extract_pi16 (p, pos);

#else

    p = shift (shift (p, (3 - pos) * 16), -48);

#endif

    t1 = shift (p, 36 - 11);

    t2 = shift (p, 16 - 5);

    p = _mm_or_si64 (t1, p);

    p = _mm_or_si64 (t2, p);

    p = _mm_and_si64 (p, MC (565_rgb));

    pixel = _mm_mullo_pi16 (p, MC (565_unpack_multiplier));

    return _mm_srli_pi16 (pixel, 8);

}

/* Expand 4 16 bit pixels in an mmx register into two mmx registers of

 *

 *    AARRGGBBRRGGBB

 */

static force_inline void

expand_4xpacked565 (__m64 vin, __m64 *vout0, __m64 *vout1, int full_alpha)

{

    __m64 t0, t1, alpha = _mm_setzero_si64 ();

    __m64 r = _mm_and_si64 (vin, MC (expand_565_r));

    __m64 g = _mm_and_si64 (vin, MC (expand_565_g));

    __m64 b = _mm_and_si64 (vin, MC (expand_565_b));

    if (full_alpha)

  alpha = _mm_cmpeq_pi32 (alpha, alpha);

    /* Replicate high bits into empty low bits. */

    r = _mm_or_si64 (_mm_srli_pi16 (r, 8), _mm_srli_pi16 (r, 13));

    g = _mm_or_si64 (_mm_srli_pi16 (g, 3), _mm_srli_pi16 (g, 9));

    b = _mm_or_si64 (_mm_slli_pi16 (b, 3), _mm_srli_pi16 (b, 2));

    r = _mm_packs_pu16 (r, _mm_setzero_si64 ());  /* 00 00 00 00 R3 R2 R1 R0 */

    g = _mm_packs_pu16 (g, _mm_setzero_si64 ());  /* 00 00 00 00 G3 G2 G1 G0 */

    b = _mm_packs_pu16 (b, _mm_setzero_si64 ());  /* 00 00 00 00 B3 B2 B1 B0 */

    t1 = _mm_unpacklo_pi8 (r, alpha);     /* A3 R3 A2 R2 A1 R1 A0 R0 */

    t0 = _mm_unpacklo_pi8 (b, g);     /* G3 B3 G2 B2 G1 B1 G0 B0 */

    *vout0 = _mm_unpacklo_pi16 (t0, t1);    /* A1 R1 G1 B1 A0 R0 G0 B0 */

    *vout1 = _mm_unpackhi_pi16 (t0, t1);    /* A3 R3 G3 B3 A2 R2 G2 B2 */

}

static force_inline __m64

expand8888 (__m64 in, int pos)

{

    if (pos == 0)

  return _mm_unpacklo_pi8 (in, _mm_setzero_si64 ());

    else

  return _mm_unpackhi_pi8 (in, _mm_setzero_si64 ());

}

static force_inline __m64

expandx888 (__m64 in, int pos)

{

    return _mm_or_si64 (expand8888 (in, pos), MC (full_alpha));

}

static force_inline void

expand_4x565 (__m64 vin, __m64 *vout0, __m64 *vout1, __m64 *vout2, __m64 *vout3, int full_alpha)

{

    __m64 v0, v1;

    expand_4xpacked565 (vin, &v0, &v1, full_alpha);

    *vout0 = expand8888 (v0, 0);

    *vout1 = expand8888 (v0, 1);

    *vout2 = expand8888 (v1, 0);

    *vout3 = expand8888 (v1, 1);

}

static force_inline __m64

pack_565 (__m64 pixel, __m64 target, int pos)

{

    __m64 p = pixel;

    __m64 t = target;

    __m64 r, g, b;

    r = _mm_and_si64 (p, MC (565_r));

    g = _mm_and_si64 (p, MC (565_g));

    b = _mm_and_si64 (p, MC (565_b));

#ifdef USE_LOONGSON_MMI

    r = shift (r, -(32 - 8));

    g = shift (g, -(16 - 3));

    b = shift (b, -(0  + 3));

    p = _mm_or_si64 (r, g);

    p = _mm_or_si64 (p, b);

    return loongson_insert_pi16 (t, p, pos);

#else

    r = shift (r, -(32 - 8) + pos * 16);

    g = shift (g, -(16 - 3) + pos * 16);

    b = shift (b, -(0  + 3) + pos * 16);

    if (pos == 0)

  t = _mm_and_si64 (t, MC (mask_0));

    else if (pos == 1)

  t = _mm_and_si64 (t, MC (mask_1));

    else if (pos == 2)

  t = _mm_and_si64 (t, MC (mask_2));

    else if (pos == 3)

  t = _mm_and_si64 (t, MC (mask_3));

    p = _mm_or_si64 (r, t);

    p = _mm_or_si64 (g, p);

    return _mm_or_si64 (b, p);

#endif

}

static force_inline __m64

pack_4xpacked565 (__m64 a, __m64 b)

{

    __m64 rb0 = _mm_and_si64 (a, MC (packed_565_rb));

    __m64 rb1 = _mm_and_si64 (b, MC (packed_565_rb));

    __m64 t0 = _mm_madd_pi16 (rb0, MC (565_pack_multiplier));

    __m64 t1 = _mm_madd_pi16 (rb1, MC (565_pack_multiplier));

    __m64 g0 = _mm_and_si64 (a, MC (packed_565_g));

    __m64 g1 = _mm_and_si64 (b, MC (packed_565_g));

    t0 = _mm_or_si64 (t0, g0);

    t1 = _mm_or_si64 (t1, g1);

    t0 = shift(t0, -5);

    t1 = shift(t1, -5 + 16);

    return _mm_shuffle_pi16 (_mm_or_si64 (t0, t1), _MM_SHUFFLE (3, 1, 2, 0));

}

#ifndef _MSC_VER

static force_inline __m64

pack_4x565 (__m64 v0, __m64 v1, __m64 v2, __m64 v3)

{

    return pack_4xpacked565 (pack8888 (v0, v1), pack8888 (v2, v3));

}

static force_inline __m64

pix_add_mul (__m64 x, __m64 a, __m64 y, __m64 b)

{

    x = pix_multiply (x, a);

    y = pix_multiply (y, b);

    return pix_add (x, y);

}

#else

/* MSVC only handles a "pass by register" of up to three SSE intrinsics */

#define pack_4x565(v0, v1, v2, v3) \

    pack_4xpacked565 (pack8888 (v0, v1), pack8888 (v2, v3))

#define pix_add_mul(x, a, y, b)  \

    ( x = pix_multiply (x, a),   \

      y = pix_multiply (y, b),   \

      pix_add (x, y) )

#endif

/* --------------- MMX code patch for fbcompose.c --------------------- */

static force_inline __m64

combine (const uint32_t *src, const uint32_t *mask)

{

    __m64 vsrc = load8888 (src);

    if (mask)

    {

  __m64 m = load8888 (mask);

  m = expand_alpha (m);

  vsrc = pix_multiply (vsrc, m);

    }

    return vsrc;

}

static force_inline __m64

core_combine_over_u_pixel_mmx (__m64 vsrc, __m64 vdst)

{

    vsrc = _mm_unpacklo_pi8 (vsrc, _mm_setzero_si64 ());

    if (is_opaque (vsrc))

    {

  return vsrc;

    }

    else if (!is_zero (vsrc))

    {

  return over (vsrc, expand_alpha (vsrc),

         _mm_unpacklo_pi8 (vdst, _mm_setzero_si64 ()));

    }

    return _mm_unpacklo_pi8 (vdst, _mm_setzero_si64 ());

}

static void

mmx_combine_over_u (pixman_implementation_t *imp,

                    pixman_op_t              op,

                    uint32_t *               dest,

                    const uint32_t *         src,

                    const uint32_t *         mask,

                    int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 vsrc = combine (src, mask);

  if (is_opaque (vsrc))

  {

      store8888 (dest, vsrc);

  }

  else if (!is_zero (vsrc))

  {

      __m64 sa = expand_alpha (vsrc);

      store8888 (dest, over (vsrc, sa, load8888 (dest)));

  }

  ++dest;

  ++src;

  if (mask)

      ++mask;

    }

    _mm_empty ();

}

static void

mmx_combine_over_reverse_u (pixman_implementation_t *imp,

                            pixman_op_t              op,

                            uint32_t *               dest,

                            const uint32_t *         src,

                            const uint32_t *         mask,

                            int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 d, da;

  __m64 s = combine (src, mask);

  d = load8888 (dest);

  da = expand_alpha (d);

  store8888 (dest, over (d, da, s));

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_in_u (pixman_implementation_t *imp,

                  pixman_op_t              op,

                  uint32_t *               dest,

                  const uint32_t *         src,

                  const uint32_t *         mask,

                  int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 a;

  __m64 x = combine (src, mask);

  a = load8888 (dest);

  a = expand_alpha (a);

  x = pix_multiply (x, a);

  store8888 (dest, x);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_in_reverse_u (pixman_implementation_t *imp,

                          pixman_op_t              op,

                          uint32_t *               dest,

                          const uint32_t *         src,

                          const uint32_t *         mask,

                          int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 a = combine (src, mask);

  __m64 x;

  x = load8888 (dest);

  a = expand_alpha (a);

  x = pix_multiply (x, a);

  store8888 (dest, x);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_out_u (pixman_implementation_t *imp,

                   pixman_op_t              op,

                   uint32_t *               dest,

                   const uint32_t *         src,

                   const uint32_t *         mask,

                   int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 a;

  __m64 x = combine (src, mask);

  a = load8888 (dest);

  a = expand_alpha (a);

  a = negate (a);

  x = pix_multiply (x, a);

  store8888 (dest, x);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_out_reverse_u (pixman_implementation_t *imp,

                           pixman_op_t              op,

                           uint32_t *               dest,

                           const uint32_t *         src,

                           const uint32_t *         mask,

                           int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 a = combine (src, mask);

  __m64 x;

  x = load8888 (dest);

  a = expand_alpha (a);

  a = negate (a);

  x = pix_multiply (x, a);

  store8888 (dest, x);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_atop_u (pixman_implementation_t *imp,

                    pixman_op_t              op,

                    uint32_t *               dest,

                    const uint32_t *         src,

                    const uint32_t *         mask,

                    int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 da, d, sia;

  __m64 s = combine (src, mask);

  d = load8888 (dest);

  sia = expand_alpha (s);

  sia = negate (sia);

  da = expand_alpha (d);

  s = pix_add_mul (s, da, d, sia);

  store8888 (dest, s);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_atop_reverse_u (pixman_implementation_t *imp,

                            pixman_op_t              op,

                            uint32_t *               dest,

                            const uint32_t *         src,

                            const uint32_t *         mask,

                            int                      width)

{

    const uint32_t *end;

    end = dest + width;

    while (dest < end)

    {

  __m64 dia, d, sa;

  __m64 s = combine (src, mask);

  d = load8888 (dest);

  sa = expand_alpha (s);

  dia = expand_alpha (d);

  dia = negate (dia);

  s = pix_add_mul (s, dia, d, sa);

  store8888 (dest, s);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_xor_u (pixman_implementation_t *imp,

                   pixman_op_t              op,

                   uint32_t *               dest,

                   const uint32_t *         src,

                   const uint32_t *         mask,

                   int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {

  __m64 dia, d, sia;

  __m64 s = combine (src, mask);

  d = load8888 (dest);

  sia = expand_alpha (s);

  dia = expand_alpha (d);

  sia = negate (sia);

  dia = negate (dia);

  s = pix_add_mul (s, dia, d, sia);

  store8888 (dest, s);

  ++dest;

  ++src;

  if (mask)

      mask++;

    }

    _mm_empty ();

}

static void

mmx_combine_add_u (pixman_implementation_t *imp,

                   pixman_op_t              op,

                   uint32_t *               dest,

                   const uint32_t *         src,

                   const uint32_t *         mask,

                   int                      width)

{

    const uint32_t *end = dest + width;

    while (dest < end)

    {