WebSVN – Kolibri OS – Diff – /programs/develop/libraries/pixman/pixman-mmx.c

 #ifdef HAVE_CONFIG_H
 #include
 #endif
+#if defined USE_X86_MMX || defined USE_ARM_IWMMXT || defined USE_LOONGSON_MMI
 #ifdef USE_LOONGSON_MMI
+#include
-#ifdef USE_MMX
+#else
 #include
-#include
-#include "pixman-private.h"
+#endif
-#include "pixman-combine32.h"
+#include "pixman-private.h"
 #include "pixman-combine32.h"
-#define no_vERBOSE
+#include "pixman-inlines.h"
 #ifdef VERBOSE
+#define CHECKPOINT() error_f ("at %s %d\n", __FUNCTION__, __LINE__)
+#else
+#define CHECKPOINT()
+#endif
+#if defined USE_ARM_IWMMXT && __GNUC__ == 4 && __GNUC_MINOR__ < 8
+/* Empty the multimedia state. For some reason, ARM's mmintrin.h doesn't provide this.  */
+extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_empty (void)
+{
+}
+#endif
+#ifdef USE_X86_MMX
+# if (defined(__SUNPRO_C) || defined(_MSC_VER) || defined(_WIN64))
+#  include
+# 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;
+}
+#  ifdef __OPTIMIZE__
+extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_shuffle_pi16 (__m64 __A, int8_t const __N)
+{
+    __m64 ret;
+    asm ("pshufw %2, %1, %0\n\t"
+	: "=y" (ret)
+	: "y" (__A), "K" (__N)
+    );
+    return ret;
+}
+#  else
+#   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
+#endif
-#define CHECKPOINT() error_f ("at %s %d\n", __FUNCTION__, __LINE__)
+#ifndef _MSC_VER
-#else
+#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
-#define CHECKPOINT()
+ (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
 #endif
  * possible.
  */
 /* --------------- MMX primitives ------------------------------------- */
-#ifdef __GNUC__
+/* If __m64 is defined as a struct or union, then define M64_MEMBER to be
-typedef uint64_t mmxdatafield;
+ * the name of the member used to access the data.
-#else
+ * If __m64 requires using mm_cvt* intrinsics functions to convert between
+ * uint64_t and __m64 values, then define USE_CVT_INTRINSICS.
-typedef __m64 mmxdatafield;
+ * If __m64 and uint64_t values can just be cast to each other directly,
+ * then define USE_M64_CASTS.
-/* If __m64 is defined as a struct or union, define M64_MEMBER to be the
+ * If __m64 is a double datatype, then define USE_M64_DOUBLE.
-   name of the member used to access the data */
+ */
+#ifdef _MSC_VER
+# define M64_MEMBER m64_u64
+#elif defined(__ICC)
+# define USE_CVT_INTRINSICS
+#elif defined(USE_LOONGSON_MMI)
+# define USE_M64_DOUBLE
-# ifdef _MSC_VER
+#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
-#  define M64_MEMBER m64_u64
+ * disabled, __m64 is defined as a struct containing "unsigned long long l_".
-# elif defined(__SUNPRO_C)
+ */
 #  define M64_MEMBER l_
+# endif
+#endif
+#if defined(USE_M64_CASTS) || defined(USE_CVT_INTRINSICS) || defined(USE_M64_DOUBLE)
+typedef uint64_t mmxdatafield;
+#else
-# endif
+typedef __m64 mmxdatafield;
 #endif
 typedef struct
+{
     mmxdatafield mmx_4x00ff;
+    mmxdatafield mmx_4x0080;
-    mmxdatafield mmx_4x0080;
+    mmxdatafield mmx_565_rgb;
-    mmxdatafield mmx_565_rgb;
+    mmxdatafield mmx_565_unpack_multiplier;
-    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_565_r;
+    mmxdatafield mmx_expand_565_b;
-    mmxdatafield mmx_565_g;
+    mmxdatafield mmx_expand_565_r;
-    mmxdatafield mmx_565_b;
+#ifndef USE_LOONGSON_MMI
     mmxdatafield mmx_mask_0;
+    mmxdatafield mmx_mask_1;
-    mmxdatafield mmx_mask_1;
+    mmxdatafield mmx_mask_2;
-    mmxdatafield mmx_mask_2;
+    mmxdatafield mmx_mask_3;
-    mmxdatafield mmx_mask_3;
+#endif
-    mmxdatafield mmx_full_alpha;
-    mmxdatafield mmx_ffff0000ffff0000;
+    mmxdatafield mmx_full_alpha;
-    mmxdatafield mmx_0000ffff00000000;
+    mmxdatafield mmx_4x0101;
-    mmxdatafield mmx_000000000000ffff;
+    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                           /* __m64 is an integral type */
+#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_4x00ff,                   0x00ff00ff00ff00ff),
+    MMXDATA_INIT (.mmx_4x0080,                   0x0080008000800080),
-    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_565_rgb,                  0x000001f0003f001f),
+    MMXDATA_INIT (.mmx_packed_565_g,             0x0000fc000000fc00),
-    MMXDATA_INIT (.mmx_565_unpack_multiplier,    0x0000008404100840),
+    MMXDATA_INIT (.mmx_expand_565_g,             0x07e007e007e007e0),
-    MMXDATA_INIT (.mmx_565_r,                    0x000000f800000000),
+    MMXDATA_INIT (.mmx_expand_565_b,             0x001f001f001f001f),
-    MMXDATA_INIT (.mmx_565_g,                    0x0000000000fc0000),
+    MMXDATA_INIT (.mmx_expand_565_r,             0xf800f800f800f800),
+#ifndef USE_LOONGSON_MMI
-    MMXDATA_INIT (.mmx_565_b,                    0x00000000000000f8),
+    MMXDATA_INIT (.mmx_mask_0,                   0xffffffffffff0000),
-    MMXDATA_INIT (.mmx_mask_0,                   0xffffffffffff0000),
     MMXDATA_INIT (.mmx_mask_1,                   0xffffffff0000ffff),
     MMXDATA_INIT (.mmx_mask_2,                   0xffff0000ffffffff),
     MMXDATA_INIT (.mmx_mask_3,                   0x0000ffffffffffff),
-    MMXDATA_INIT (.mmx_full_alpha,               0x00ff000000000000),
+#endif
-    MMXDATA_INIT (.mmx_ffff0000ffff0000,         0xffff0000ffff0000),
-    MMXDATA_INIT (.mmx_0000ffff00000000,         0x0000ffff00000000),
+    MMXDATA_INIT (.mmx_full_alpha,               0x00ff000000000000),
-    MMXDATA_INIT (.mmx_000000000000ffff,         0x000000000000ffff),
+    MMXDATA_INIT (.mmx_4x0101,                   0x0101010101010101),
-};
+    MMXDATA_INIT (.mmx_ff000000,                 0xff000000ff000000),
+};
-#ifdef __GNUC__
+#ifdef USE_CVT_INTRINSICS
-#    ifdef __ICC
+#    define MC(x) to_m64 (c.mmx_ ## x)
-#        define MC(x) to_m64 (c.mmx_ ## x)
+#elif defined(USE_M64_CASTS)
-#    else
+#    define MC(x) ((__m64)c.mmx_ ## x)
-#        define MC(x) ((__m64)c.mmx_ ## x)
+#elif defined(USE_M64_DOUBLE)
-#    endif
+#    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);
-#ifdef __ICC
+#elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */
-    return _mm_cvtsi64_m64 (x);
+    __m64 res;
 #elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */
-    __m64 res;
+    res.M64_MEMBER = x;
     return res;
-    res.M64_MEMBER = x;
+#elif defined USE_M64_DOUBLE
-    return res;
+    return *(__m64 *)&x;
-#else                           /* __m64 is an integral type */
+#else /* USE_M64_CASTS */
     return (__m64)x;
 #endif
+}
+static force_inline uint64_t
+to_uint64 (__m64 x)
 static force_inline uint64_t
-to_uint64 (__m64 x)
+#ifdef USE_CVT_INTRINSICS
     return _mm_cvtm64_si64 (x);
-#ifdef __ICC
+#elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */
+{
     __m64 res;
     res = _mm_mullo_pi16 (a, b);
-    res = _mm_adds_pu16 (res, MC (4x0080));
-    res = _mm_adds_pu16 (res, _mm_srli_pi16 (res, 8));
+    res = _mm_adds_pu16 (res, MC (4x0080));
-    res = _mm_srli_pi16 (res, 8);
+    res = _mm_mulhi_pu16 (res, MC (4x0101));
     return res;
+}
 static force_inline __m64
 expand_alpha (__m64 pixel)
-{
-    __m64 t1, t2;
+{
-    t1 = shift (pixel, -48);
-    t2 = shift (t1, 16);
-    t1 = _mm_or_si64 (t1, t2);
-    t2 = shift (t1, 32);
-    t1 = _mm_or_si64 (t1, t2);
-    return t1;
+    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 3, 3, 3));
+}
 static force_inline __m64
-expand_alpha_rev (__m64 pixel)
-{
-    __m64 t1, t2;
+expand_alpha_rev (__m64 pixel)
-    /* move alpha to low 16 bits and zero the rest */
-    t1 = shift (pixel,  48);
-    t1 = shift (t1, -48);
-    t2 = shift (t1, 16);
-    t1 = _mm_or_si64 (t1, t2);
-    t2 = shift (t1, 32);
-    t1 = _mm_or_si64 (t1, t2);
+{
-    return t1;
+    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (0, 0, 0, 0));
+}
-static force_inline __m64
-invert_colors (__m64 pixel)
-{
-    __m64 x, y, z;
+static force_inline __m64
-    x = y = z = pixel;
-    x = _mm_and_si64 (x, MC (ffff0000ffff0000));
-    y = _mm_and_si64 (y, MC (000000000000ffff));
-    z = _mm_and_si64 (z, MC (0000ffff00000000));
-    y = shift (y, 32);
-    z = shift (z, -32);
-    x = _mm_or_si64 (x, y);
-    x = _mm_or_si64 (x, z);
+invert_colors (__m64 pixel)
+{
-    return x;
+    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 0, 1, 2));
+}
 in (__m64 src, __m64 mask)
+{
     return pix_multiply (src, mask);
+}
-static force_inline __m64
-in_over_full_src_alpha (__m64 src, __m64 mask, __m64 dest)
-{
-    src = _mm_or_si64 (src, MC (full_alpha));
-    return over (in (src, mask), mask, dest);
-}
 #ifndef _MSC_VER
 static force_inline __m64
 in_over (__m64 src, __m64 srca, __m64 mask, __m64 dest)
+{
 #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. */
+    return *(__m64 *)p;
+#elif defined USE_ARM_IWMMXT
+    int align = (uintptr_t)p & 7;
+    __m64 *aligned_p;
+    if (align == 0)
+	return *p;
+    aligned_p = (__m64 *)((uintptr_t)p & ~7);
+    return (__m64) _mm_align_si64 (aligned_p[0], aligned_p[1], align);
+#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. */
+    return *p;
+#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
 #endif
 static force_inline __m64
+load8888 (const uint32_t *v)
+{
+#ifdef USE_LOONGSON_MMI
-load8888 (uint32_t v)
+    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 _mm_unpacklo_pi8 (_mm_cvtsi32_si64 (v), _mm_setzero_si64 ());
+    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;
-    return _mm_packs_pu16 (lo, hi);
+#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 uint32_t
+static force_inline pixman_bool_t
-store8888 (__m64 v)
+is_zero (__m64 v)
+{
-    return _mm_cvtsi64_si32 (pack8888 (v, _mm_setzero_si64 ()));
+    return is_equal (v, _mm_setzero_si64 ());
+{
     __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);
-    /* move pixel to low 16 bit and zero the rest */
+#else
+    p = shift (shift (p, (3 - pos) * 16), -48);
-    p = shift (shift (p, (3 - pos) * 16), -48);
+#endif
     t1 = shift (p, 36 - 11);
     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)
+{
 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;
     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);
-    b = _mm_and_si64 (p, MC (565_b));
+    return loongson_insert_pi16 (t, p, pos);
 #else
     r = shift (r, -(32 - 8) + pos * 16);
     g = shift (g, -(16 - 3) + pos * 16);
     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);
+#ifdef USE_ARM_IWMMXT
+    t1 = shift(t1, -5);
+    return _mm_packs_pu32 (t0, t1);
+#else
+    t1 = shift(t1, -5 + 16);
     return _mm_shuffle_pi16 (_mm_or_si64 (t0, t1), _MM_SHUFFLE (3, 1, 2, 0));
-    return _mm_or_si64 (b, p);
+#endif
+}
+#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));
 #ifndef _MSC_VER
 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);
+}
-    y = pix_multiply (y, b);
+#else
-    return pix_add (x, y);
+/* MSVC only handles a "pass by register" of up to three SSE intrinsics */
 #define pack_4x565(v0, v1, v2, v3) \
-#else
+    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, a),	 \
+      y = pix_multiply (y, b),	 \
       pix_add (x, y) )
 #endif
 /* --------------- MMX code patch for fbcompose.c --------------------- */
+/* --------------- 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);
-static force_inline uint32_t
+	m = expand_alpha (m);
+	vsrc = pix_multiply (vsrc, m);
+    }
+    return vsrc;
+}
-combine (const uint32_t *src, const uint32_t *mask)
+static force_inline __m64
-{
+core_combine_over_u_pixel_mmx (__m64 vsrc, __m64 vdst)
     uint32_t ssrc = *src;
     vsrc = _mm_unpacklo_pi8 (vsrc, _mm_setzero_si64 ());
     if (mask)
     if (is_opaque (vsrc))
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
-	uint32_t ssrc = combine (src, mask);
-	uint32_t a = ssrc >> 24;
+	__m64 vsrc = combine (src, mask);
-	if (a == 0xff)
+	if (is_opaque (vsrc))
+	{
-	    *dest = ssrc;
+	    store8888 (dest, vsrc);
+	}
-	else if (ssrc)
-	{
-	    __m64 s, sa;
+	else if (!is_zero (vsrc))
-	    s = load8888 (ssrc);
+	{
-	    sa = expand_alpha (s);
+	    __m64 sa = expand_alpha (vsrc);
-	    *dest = store8888 (over (s, sa, load8888 (*dest)));
+	    store8888 (dest, over (vsrc, sa, load8888 (dest)));
+	}
     const uint32_t *end = dest + width;
     while (dest < end)
+    {
 	__m64 d, da;
-	uint32_t s = combine (src, mask);
+	__m64 s = combine (src, mask);
-	d = load8888 (*dest);
+	d = load8888 (dest);
 	da = expand_alpha (d);
-	*dest = store8888 (over (d, da, load8888 (s)));
+	store8888 (dest, over (d, da, s));
 	++dest;
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
+	__m64 a;
-	__m64 x, a;
+	__m64 x = combine (src, mask);
 	x = load8888 (combine (src, mask));
-	a = load8888 (*dest);
+	a = load8888 (dest);
 	a = expand_alpha (a);
 	x = pix_multiply (x, a);
-	*dest = store8888 (x);
+	store8888 (dest, x);
+{
     const uint32_t *end = dest + width;
     while (dest < end)
+    {
-    {
+	__m64 a = combine (src, mask);
-	__m64 x, a;
+	__m64 x;
 	x = load8888 (*dest);
-	a = load8888 (combine (src, mask));
+	x = load8888 (dest);
 	a = expand_alpha (a);
 	x = pix_multiply (x, a);
-	*dest = store8888 (x);
+	store8888 (dest, x);
 	++dest;
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
+	__m64 a;
-	__m64 x, a;
+	__m64 x = combine (src, mask);
 	x = load8888 (combine (src, mask));
-	a = load8888 (*dest);
+	a = load8888 (dest);
 	a = expand_alpha (a);
 	a = negate (a);
 	x = pix_multiply (x, a);
-	*dest = store8888 (x);
+	store8888 (dest, x);
 	++dest;
+{
     const uint32_t *end = dest + width;
     while (dest < end)
+    {
-    {
+	__m64 a = combine (src, mask);
-	__m64 x, a;
+	__m64 x;
 	x = load8888 (*dest);
-	a = load8888 (combine (src, mask));
+	x = load8888 (dest);
 	a = expand_alpha (a);
 	a = negate (a);
 	x = pix_multiply (x, a);
-	*dest = store8888 (x);
+	store8888 (dest, x);
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
+	__m64 da, d, sia;
-	__m64 s, da, d, sia;
+	__m64 s = combine (src, mask);
 	s = load8888 (combine (src, mask));
-	d = load8888 (*dest);
+	d = load8888 (dest);
 	sia = expand_alpha (s);
 	sia = negate (sia);
 	da = expand_alpha (d);
 	s = pix_add_mul (s, da, d, sia);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++dest;
     end = dest + width;
     while (dest < end)
+    {
-    {
-	__m64 s, dia, d, sa;
+	__m64 dia, d, sa;
 	__m64 s = combine (src, mask);
 	s = load8888 (combine (src, mask));
-	d = load8888 (*dest);
+	d = load8888 (dest);
 	sa = expand_alpha (s);
 	dia = expand_alpha (d);
 	dia = negate (dia);
 	s = pix_add_mul (s, dia, d, sa);
-	*dest = store8888 (s);
+	store8888 (dest, s);
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
+	__m64 dia, d, sia;
-	__m64 s, dia, d, sia;
+	__m64 s = combine (src, mask);
 	s = load8888 (combine (src, mask));
-	d = load8888 (*dest);
+	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);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++dest;
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
+	__m64 d;
-	__m64 s, d;
+	__m64 s = combine (src, mask);
 	s = load8888 (combine (src, mask));
-	d = load8888 (*dest);
+	d = load8888 (dest);
 	s = pix_add (s, d);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++dest;
+{
     const uint32_t *end = dest + width;
     while (dest < end)
     {
-	uint32_t s = combine (src, mask);
+	uint32_t s, sa, da;
 	uint32_t d = *dest;
-	__m64 ms = load8888 (s);
+	__m64 ms = combine (src, mask);
+	__m64 md = load8888 (dest);
-	__m64 md = load8888 (d);
+	store8888(&s, ms);
-	uint32_t sa = s >> 24;
+	da = ~d >> 24;
-	uint32_t da = ~d >> 24;
+	sa = s >> 24;
 	if (sa > da)
+	{
 	    uint32_t quot = DIV_UN8 (da, sa) << 24;
-	    __m64 msa = load8888 (DIV_UN8 (da, sa) << 24);
+	    __m64 msa = load8888 (");
 	    msa = expand_alpha (msa);
 	    ms = pix_multiply (ms, msa);
 	}
 	md = pix_add (md, ms);
-	*dest = store8888 (md);
+	store8888 (dest, md);
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
 	s = pix_multiply (s, a);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 sa = expand_alpha (s);
-	*dest = store8888 (in_over (s, sa, a, d));
+	store8888 (dest, in_over (s, sa, a, d));
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
-	*dest = store8888 (over (d, da, in (s, a)));
+	store8888 (dest, over (d, da, in (s, a)));
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
 	s = pix_multiply (s, a);
 	s = pix_multiply (s, da);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 sa = expand_alpha (s);
 	a = pix_multiply (a, sa);
 	d = pix_multiply (d, a);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
 	da = negate (da);
 	s = pix_multiply (s, a);
 	s = pix_multiply (s, da);
-	*dest = store8888 (s);
+	store8888 (dest, s);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 sa = expand_alpha (s);
 	a = pix_multiply (a, sa);
 	a = negate (a);
 	d = pix_multiply (d, a);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
 	__m64 sa = expand_alpha (s);
 	s = pix_multiply (s, a);
 	a = pix_multiply (a, sa);
 	a = negate (a);
 	d = pix_add_mul (d, a, s, da);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
 	__m64 sa = expand_alpha (s);
 	s = pix_multiply (s, a);
 	a = pix_multiply (a, sa);
 	da = negate (da);
 	d = pix_add_mul (d, a, s, da);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	__m64 da = expand_alpha (d);
 	__m64 sa = expand_alpha (s);
 	s = pix_multiply (s, a);
 	a = pix_multiply (a, sa);
 	da = negate (da);
 	a = negate (a);
 	d = pix_add_mul (d, a, s, da);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
+{
     const uint32_t *end = src + width;
     while (src < end)
     {
-	__m64 a = load8888 (*mask);
+	__m64 a = load8888 (mask);
-	__m64 s = load8888 (*src);
+	__m64 s = load8888 (src);
-	__m64 d = load8888 (*dest);
+	__m64 d = load8888 (dest);
 	s = pix_multiply (s, a);
 	d = pix_add (s, d);
-	*dest = store8888 (d);
+	store8888 (dest, d);
 	++src;
 /* ------------- MMX code paths called from fbpict.c -------------------- */
 static void
-mmx_composite_over_n_8888 (pixman_implementation_t *imp,
-                           pixman_op_t              op,
-                           pixman_image_t *         src_image,
-                           pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
-                           int32_t                  src_x,
-                           int32_t                  src_y,
-                           int32_t                  mask_x,
-                           int32_t                  mask_y,
-                           int32_t                  dest_x,
-                           int32_t                  dest_y,
-                           int32_t                  width,
+mmx_composite_over_n_8888 (pixman_implementation_t *imp,
+                           pixman_composite_info_t *info)
                            int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t src;
     uint32_t    *dst_line, *dst;
     int32_t w;
     int dst_stride;
     __m64 vsrc, vsrca;
     CHECKPOINT ();
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     if (src == 0)
 	return;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
     while (height--)
+    {
 	dst = dst_line;
 	dst_line += dst_stride;
 	    w -= 2;
+	}
 	CHECKPOINT ();
-	while (w)
+	if (w)
-	{
-	    *dst = store8888 (over (vsrc, vsrca, load8888 (*dst)));
 	    w--;
-	    dst++;
+	    store8888 (dst, over (vsrc, vsrca, load8888 (dst)));
+	}
+    }
     _mm_empty ();
 }
-static void
-mmx_composite_over_n_0565 (pixman_implementation_t *imp,
-                           pixman_op_t              op,
-                           pixman_image_t *         src_image,
-                           pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
-                           int32_t                  src_x,
-                           int32_t                  src_y,
-                           int32_t                  mask_x,
-                           int32_t                  mask_y,
                            int32_t                  dest_x,
+static void
-                           int32_t                  dest_y,
+mmx_composite_over_n_0565 (pixman_implementation_t *imp,
-                           int32_t                  width,
+                           pixman_composite_info_t *info)
                            int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t src;
     uint16_t    *dst_line, *dst;
     int32_t w;
     int dst_stride;
     __m64 vsrc, vsrca;
     CHECKPOINT ();
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     if (src == 0)
 	return;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
     while (height--)
 	    dst++;
+	}
 	while (w >= 4)
+	{
-	{
+	    __m64 vdest = *(__m64 *)dst;
-	    __m64 vdest;
+	    __m64 v0, v1, v2, v3;
-	    vdest = *(__m64 *)dst;
+	    expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
-	    vdest = pack_565 (over (vsrc, vsrca, expand565 (vdest, 0)), vdest, 0);
+	    v0 = over (vsrc, vsrca, v0);
-	    vdest = pack_565 (over (vsrc, vsrca, expand565 (vdest, 1)), vdest, 1);
+	    v1 = over (vsrc, vsrca, v1);
-	    vdest = pack_565 (over (vsrc, vsrca, expand565 (vdest, 2)), vdest, 2);
+	    v2 = over (vsrc, vsrca, v2);
-	    vdest = pack_565 (over (vsrc, vsrca, expand565 (vdest, 3)), vdest, 3);
+	    v3 = over (vsrc, vsrca, v3);
     _mm_empty ();
+}
 static void
 mmx_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   pixman_image_t *         src_image,
-                                   pixman_image_t *         mask_image,
-                                   pixman_image_t *         dst_image,
-                                   int32_t                  src_x,
-                                   int32_t                  src_y,
-                                   int32_t                  mask_x,
-                                   int32_t                  mask_y,
-                                   int32_t                  dest_x,
-                                   int32_t                  dest_y,
-                                   int32_t                  width,
-                                   int32_t                  height)
+                                   pixman_composite_info_t *info)
+{
-{
+    PIXMAN_COMPOSITE_ARGS (info);
-    uint32_t src, srca;
+    uint32_t src;
     uint32_t    *dst_line;
     uint32_t    *mask_line;
     int dst_stride, mask_stride;
     __m64 vsrc, vsrca;
-    CHECKPOINT ();
     CHECKPOINT ();
     src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     srca = src >> 24;
     if (src == 0)
 	return;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
     while (height--)
+    {
 	int twidth = width;
 	uint32_t *p = (uint32_t *)mask_line;
 	uint32_t *q = (uint32_t *)dst_line;
-	while (twidth && (unsigned long)q & 7)
+	while (twidth && (uintptr_t)q & 7)
+	{
 	    uint32_t m = *(uint32_t *)p;
 	    if (m0 | m1)
+	    {
 		__m64 dest0, dest1;
 		__m64 vdest = *(__m64 *)q;
-		dest0 = in_over (vsrc, vsrca, load8888 (m0),
+		dest0 = in_over (vsrc, vsrca, load8888 (&m0),
 		                 expand8888 (vdest, 0));
-		dest1 = in_over (vsrc, vsrca, load8888 (m1),
+		dest1 = in_over (vsrc, vsrca, load8888 (&m1),
 		                 expand8888 (vdest, 1));
 		*(__m64 *)q = pack8888 (dest0, dest1);
+	    }
 	    p += 2;
 	    q += 2;
 	    twidth -= 2;
+	}
-	while (twidth)
+	if (twidth)
 	{
 	    uint32_t m = *(uint32_t *)p;
 	    if (m)
+	    {
-		__m64 vdest = load8888 (*q);
+		__m64 vdest = load8888 (q);
-		vdest = in_over (vsrc, vsrca, load8888 (m), vdest);
+		vdest = in_over (vsrc, vsrca, load8888 (&m), vdest);
     _mm_empty ();
+}
 static void
 mmx_composite_over_8888_n_8888 (pixman_implementation_t *imp,
-                                pixman_op_t              op,
-                                pixman_image_t *         src_image,
-                                pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
-                                int32_t                  src_x,
-                                int32_t                  src_y,
-                                int32_t                  mask_x,
-                                int32_t                  mask_y,
-                                int32_t                  dest_x,
-                                int32_t                  dest_y,
-                                int32_t                  width,
-                                int32_t                  height)
+                                pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t    *dst_line, *dst;
     uint32_t    *src_line, *src;
     uint32_t mask;
     __m64 vmask;
     int dst_stride, src_stride;
-    int32_t w;
-    __m64 srca;
+    int32_t w;
     CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    mask = _pixman_image_get_solid (mask_image, dst_image->bits.format);
-    mask &= 0xff000000;
+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
-    vmask = load8888 (mask);
+    mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
-    srca = MC (4x00ff);
+    vmask = expand_alpha (load8888 (&mask));
     while (height--)
+    {
 	dst = dst_line;
 	dst_line += dst_stride;
 	src = src_line;
 	src_line += src_stride;
 	w = width;
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
-	    __m64 s = load8888 (*src);
+	    __m64 s = load8888 (src);
-	    __m64 d = load8888 (*dst);
+	    __m64 d = load8888 (dst);
-	    *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));
+	    store8888 (dst, in_over (s, expand_alpha (s), vmask, d));
 	    w--;
 	    dst++;
 	    src++;
 	    w -= 2;
 	    dst += 2;
 	    src += 2;
+	}
-	while (w)
+	if (w)
 	{
-	    __m64 s = load8888 (*src);
+	    __m64 s = load8888 (src);
-	    __m64 d = load8888 (*dst);
-	    *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));
+	    __m64 d = load8888 (dst);
-	    w--;
 	    dst++;
-	    src++;
+	    store8888 (dst, in_over (s, expand_alpha (s), vmask, d));
+	}
+    }
     _mm_empty ();
 }
-static void
-mmx_composite_over_x888_n_8888 (pixman_implementation_t *imp,
-                                pixman_op_t              op,
-                                pixman_image_t *         src_image,
-                                pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
-                                int32_t                  src_x,
-                                int32_t                  src_y,
-                                int32_t                  mask_x,
-                                int32_t                  mask_y,
                                 int32_t                  dest_x,
+static void
-                                int32_t                  dest_y,
+mmx_composite_over_x888_n_8888 (pixman_implementation_t *imp,
-                                int32_t                  width,
+                                pixman_composite_info_t *info)
                                 int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t *dst_line, *dst;
     uint32_t *src_line, *src;
     uint32_t mask;
     __m64 vmask;
     int dst_stride, src_stride;
     int32_t w;
     __m64 srca;
-    CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    CHECKPOINT ();
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    mask = _pixman_image_get_solid (mask_image, dst_image->bits.format);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    mask &= 0xff000000;
+    mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
-    vmask = load8888 (mask);
+    vmask = expand_alpha (load8888 (&mask));
     srca = MC (4x00ff);
     while (height--)
+    {
-    {
+	dst = dst_line;
-	dst = dst_line;
+	dst_line += dst_stride;
-	dst_line += dst_stride;
+	src = src_line;
-	src = src_line;
+	src_line += src_stride;
-	src_line += src_stride;
+	w = width;
 	w = width;
 	while (w && (uintptr_t)dst & 7)
 	    __m64 vd4 = *(__m64 *)(dst + 8);
 	    __m64 vd5 = *(__m64 *)(dst + 10);
 	    __m64 vd6 = *(__m64 *)(dst + 12);
 	    __m64 vd7 = *(__m64 *)(dst + 14);
-	    __m64 vs0 = *(__m64 *)(src + 0);
+	    __m64 vs0 = ldq_u ((__m64 *)(src + 0));
-	    __m64 vs1 = *(__m64 *)(src + 2);
+	    __m64 vs1 = ldq_u ((__m64 *)(src + 2));
-	    __m64 vs2 = *(__m64 *)(src + 4);
+	    __m64 vs2 = ldq_u ((__m64 *)(src + 4));
-	    __m64 vs3 = *(__m64 *)(src + 6);
+	    __m64 vs3 = ldq_u ((__m64 *)(src + 6));
-	    __m64 vs4 = *(__m64 *)(src + 8);
+	    __m64 vs4 = ldq_u ((__m64 *)(src + 8));
-	    __m64 vs5 = *(__m64 *)(src + 10);
+	    __m64 vs5 = ldq_u ((__m64 *)(src + 10));
-	    __m64 vs6 = *(__m64 *)(src + 12);
+	    __m64 vs6 = ldq_u ((__m64 *)(src + 12));
-	    __m64 vs7 = *(__m64 *)(src + 14);
+	    __m64 vs7 = ldq_u ((__m64 *)(src + 14));
 	    vd0 = pack8888 (
 	    src += 16;
+	}
 	while (w)
+	{
-	{
+	    uint32_t ssrc = *src | 0xff000000;
-	    __m64 s = load8888 (*src | 0xff000000);
+	    __m64 s = load8888 (&ssrc);
-	    __m64 d = load8888 (*dst);
+	    __m64 d = load8888 (dst);
-	    *dst = store8888 (in_over (s, srca, vmask, d));
+	    store8888 (dst, in_over (s, srca, vmask, d));
 	    w--;
     _mm_empty ();
+}
 static void
 mmx_composite_over_8888_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
+                              pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t *dst_line, *dst;
     uint32_t *src_line, *src;
     uint32_t s;
     int dst_stride, src_stride;
     uint8_t a;
     int32_t w;
     CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 		*dst = s;
+	    }
 	    else if (s)
+	    {
 		__m64 ms, sa;
-		ms = load8888 (s);
+		ms = load8888 (&s);
 		sa = expand_alpha (ms);
-		*dst = store8888 (over (ms, sa, load8888 (*dst)));
+		store8888 (dst, over (ms, sa, load8888 (dst)));
+	    }
 	    dst++;
+	}
+    }
     _mm_empty ();
+}
 static void
-mmx_composite_over_8888_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
+mmx_composite_over_8888_0565 (pixman_implementation_t *imp,
+                              pixman_composite_info_t *info)
                               int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint16_t    *dst_line, *dst;
     uint32_t    *src_line, *src;
     int dst_stride, src_stride;
     int32_t w;
     CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
 	src_line += src_stride;
 	w = width;
 	CHECKPOINT ();
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
-	    __m64 vsrc = load8888 (*src);
+	    __m64 vsrc = load8888 (src);
 	    uint64_t d = *dst;
 	    __m64 vdest = expand565 (to_m64 (d), 0);
 	CHECKPOINT ();
+	while (w >= 4)
+	{
-	while (w >= 4)
+	    __m64 vdest = *(__m64 *)dst;
-	{
-	    __m64 vsrc0, vsrc1, vsrc2, vsrc3;
-	    __m64 vdest;
-	    vsrc0 = load8888 (*(src + 0));
+	    __m64 v0, v1, v2, v3;
-	    vsrc1 = load8888 (*(src + 1));
-	    vsrc2 = load8888 (*(src + 2));
+	    __m64 vsrc0, vsrc1, vsrc2, vsrc3;
+	    expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
+	    vsrc0 = load8888 ((src + 0));
-	    vsrc3 = load8888 (*(src + 3));
+	    vsrc1 = load8888 ((src + 1));
+	    vsrc2 = load8888 ((src + 2));
-	    vdest = *(__m64 *)dst;
+	    vsrc3 = load8888 ((src + 3));
-	    vdest = pack_565 (over (vsrc0, expand_alpha (vsrc0), expand565 (vdest, 0)), vdest, 0);
+	    v0 = over (vsrc0, expand_alpha (vsrc0), v0);
-	    vdest = pack_565 (over (vsrc1, expand_alpha (vsrc1), expand565 (vdest, 1)), vdest, 1);
+	    v1 = over (vsrc1, expand_alpha (vsrc1), v1);
-	    vdest = pack_565 (over (vsrc2, expand_alpha (vsrc2), expand565 (vdest, 2)), vdest, 2);
+	    v2 = over (vsrc2, expand_alpha (vsrc2), v2);
-	    vdest = pack_565 (over (vsrc3, expand_alpha (vsrc3), expand565 (vdest, 3)), vdest, 3);
+	    v3 = over (vsrc3, expand_alpha (vsrc3), v3);
-	    *(__m64 *)dst = vdest;
+	    *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
 	    w -= 4;
 	    dst += 4;
 	    src += 4;
+	}
     _mm_empty ();
+}
 static void
 mmx_composite_over_n_8_8888 (pixman_implementation_t *imp,
-                             pixman_op_t              op,
-                             pixman_image_t *         src_image,
-                             pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
-                             int32_t                  src_x,
-                             int32_t                  src_y,
-                             int32_t                  mask_x,
-                             int32_t                  mask_y,
-                             int32_t                  dest_x,
-                             int32_t                  dest_y,
-                             int32_t                  width,
-                             int32_t                  height)
+                             pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t src, srca;
     uint32_t *dst_line, *dst;
     uint8_t *mask_line, *mask;
     int dst_stride, mask_stride;
     int32_t w;
     __m64 vsrc, vsrca;
     uint64_t srcsrc;
     CHECKPOINT ();
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     srca = src >> 24;
     if (src == 0)
 	return;
     srcsrc = (uint64_t)src << 32 | src;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 	mask_line += mask_stride;
 	w = width;
 	CHECKPOINT ();
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
 	    uint64_t m = *mask;
 	    if (m)
 	    {
 		__m64 vdest = in_over (vsrc, vsrca,
 				       expand_alpha_rev (to_m64 (m)),
-				       load8888 (*dst));
+				       load8888 (dst));
-		*dst = store8888 (vdest);
+		store8888 (dst, vdest);
 	    w -= 2;
+	}
 	CHECKPOINT ();
-	while (w)
+	if (w)
+	{
 	    uint64_t m = *mask;
 	    if (m)
+	    {
-		__m64 vdest = load8888 (*dst);
+		__m64 vdest = load8888 (dst);
-		vdest = in_over (
-		    vsrc, vsrca, expand_alpha_rev (to_m64 (m)), vdest);
-		*dst = store8888 (vdest);
-	    }
 		vdest = in_over (
-	    w--;
+		    vsrc, vsrca, expand_alpha_rev (to_m64 (m)), vdest);
-	    mask++;
+		store8888 (dst, vdest);
 	    dst++;
 	}
     }
     _mm_empty ();
     _mm_empty ();
 static pixman_bool_t
-pixman_bool_t
+mmx_fill (pixman_implementation_t *imp,
-pixman_fill_mmx (uint32_t *bits,
+          uint32_t *               bits,
-                 int       stride,
+          int                      stride,
-                 int       bpp,
+          int                      bpp,
-                 int       x,
+          int                      x,
-                 int       y,
+          int                      y,
-                 int       width,
+          int                      width,
-                 int       height,
+          int                      height,
-                 uint32_t xor)
+          uint32_t		   filler)
+{
     uint64_t fill;
     __m64 vfill;
     uint32_t byte_width;
+    {
 	stride = stride * (int) sizeof (uint32_t) / 1;
 	byte_line = (uint8_t *)(((uint8_t *)bits) + stride * y + x);
 	byte_width = width;
 	stride *= 1;
-        xor = (xor & 0xff) * 0x01010101;
+        filler = (filler & 0xff) * 0x01010101;
+    }
     else if (bpp == 16)
+    {
 	stride = stride * (int) sizeof (uint32_t) / 2;
 	byte_line = (uint8_t *)(((uint16_t *)bits) + stride * y + x);
 	byte_width = 2 * width;
 	stride *= 2;
-        xor = (xor & 0xffff) * 0x00010001;
+        filler = (filler & 0xffff) * 0x00010001;
+    }
     else
+    {
 	stride = stride * (int) sizeof (uint32_t) / 4;
 	byte_line = (uint8_t *)(((uint32_t *)bits) + stride * y + x);
 	byte_width = 4 * width;
 	stride *= 4;
+    }
-    fill = ((uint64_t)xor << 32) | xor;
+    fill = ((uint64_t)filler << 32) | filler;
     vfill = to_m64 (fill);
-#ifdef __GNUC__
+#if defined __GNUC__ && defined USE_X86_MMX
     __asm__ (
         "movq		%7,	%0\n"
         "movq		%7,	%1\n"
 	uint8_t *d = byte_line;
 	byte_line += stride;
 	w = byte_width;
-	while (w >= 1 && ((unsigned long)d & 1))
+	if (w >= 1 && ((uintptr_t)d & 1))
+	{
-	    *(uint8_t *)d = (xor & 0xff);
+	    *(uint8_t *)d = (filler & 0xff);
 	    w--;
 	    d++;
+	}
-	while (w >= 2 && ((unsigned long)d & 3))
+	if (w >= 2 && ((uintptr_t)d & 3))
+	{
-	    *(uint16_t *)d = xor;
+	    *(uint16_t *)d = filler;
 	    w -= 2;
 	    d += 2;
 	}
-	while (w >= 4 && ((unsigned long)d & 7))
+	while (w >= 4 && ((uintptr_t)d & 7))
+	{
-	    *(uint32_t *)d = xor;
+	    *(uint32_t *)d = filler;
 	    w -= 4;
 	    d += 4;
+	}
 	while (w >= 64)
+	{
 	    d += 64;
+	}
 	while (w >= 4)
 	{
-	    *(uint32_t *)d = xor;
+	    *(uint32_t *)d = filler;
 	    w -= 4;
 	    d += 4;
+	}
-	while (w >= 2)
+	if (w >= 2)
+	{
-	    *(uint16_t *)d = xor;
+	    *(uint16_t *)d = filler;
 	    w -= 2;
 	    d += 2;
+	}
-	while (w >= 1)
+	if (w >= 1)
+	{
-	    *(uint8_t *)d = (xor & 0xff);
+	    *(uint8_t *)d = (filler & 0xff);
 	    w--;
 	    d++;
     _mm_empty ();
     return TRUE;
+}
+static void
+mmx_composite_src_x888_0565 (pixman_implementation_t *imp,
+                             pixman_composite_info_t *info)
+{
+    PIXMAN_COMPOSITE_ARGS (info);
+    uint16_t    *dst_line, *dst;
+    uint32_t    *src_line, *src, s;
+    int dst_stride, src_stride;
+    int32_t w;
+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    while (height--)
+    {
+	dst = dst_line;
+	dst_line += dst_stride;
+	src = src_line;
+	src_line += src_stride;
+	w = width;
+	while (w && (uintptr_t)dst & 7)
+	{
+	    s = *src++;
+	    *dst = convert_8888_to_0565 (s);
+	    dst++;
+	    w--;
+	}
+	while (w >= 4)
+	{
+	    __m64 vdest;
+	    __m64 vsrc0 = ldq_u ((__m64 *)(src + 0));
+	    __m64 vsrc1 = ldq_u ((__m64 *)(src + 2));
+	    vdest = pack_4xpacked565 (vsrc0, vsrc1);
+	    *(__m64 *)dst = vdest;
+	    w -= 4;
+	    src += 4;
+	    dst += 4;
+	}
+	while (w)
+	{
+	    s = *src++;
+	    *dst = convert_8888_to_0565 (s);
+	    dst++;
+	    w--;
+	}
+    }
+    _mm_empty ();
+}
 static void
 mmx_composite_src_n_8_8888 (pixman_implementation_t *imp,
-                            pixman_op_t              op,
-                            pixman_image_t *         src_image,
-                            pixman_image_t *         mask_image,
-                            pixman_image_t *         dst_image,
-                            int32_t                  src_x,
-                            int32_t                  src_y,
-                            int32_t                  mask_x,
-                            int32_t                  mask_y,
-                            int32_t                  dest_x,
-                            int32_t                  dest_y,
-                            int32_t                  width,
-                            int32_t                  height)
+                            pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t src, srca;
     uint32_t    *dst_line, *dst;
     uint8_t     *mask_line, *mask;
     int dst_stride, mask_stride;
     int32_t w;
-    __m64 vsrc, vsrca;
+    __m64 vsrc;
     uint64_t srcsrc;
     CHECKPOINT ();
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     srca = src >> 24;
     if (src == 0)
+    {
-	pixman_fill_mmx (dst_image->bits.bits, dst_image->bits.rowstride,
+	mmx_fill (imp, dest_image->bits.bits, dest_image->bits.rowstride,
-			 PIXMAN_FORMAT_BPP (dst_image->bits.format),
+		  PIXMAN_FORMAT_BPP (dest_image->bits.format),
-	                 dest_x, dest_y, width, height, 0);
+		  dest_x, dest_y, width, height, 0);
 	return;
     }
     srcsrc = (uint64_t)src << 32 | src;
     srcsrc = (uint64_t)src << 32 | src;
     PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 	mask_line += mask_stride;
 	w = width;
 	CHECKPOINT ();
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
 	    uint64_t m = *mask;
 	    if (m)
+	    {
 		__m64 vdest = in (vsrc, expand_alpha_rev (to_m64 (m)));
-		*dst = store8888 (vdest);
+		store8888 (dst, vdest);
+	    }
+	    {
 		*(uint64_t *)dst = srcsrc;
+	    }
 	    else if (m0 | m1)
+	    {
-		__m64 vdest;
 		__m64 dest0, dest1;
-		vdest = *(__m64 *)dst;
 		dest0 = in (vsrc, expand_alpha_rev (to_m64 (m0)));
 		dest1 = in (vsrc, expand_alpha_rev (to_m64 (m1)));
 	    w -= 2;
+	}
 	CHECKPOINT ();
-	while (w)
+	if (w)
+	{
 	    uint64_t m = *mask;
 	    if (m)
 	    {
-		__m64 vdest = load8888 (*dst);
+		__m64 vdest = load8888 (dst);
 		vdest = in (vsrc, expand_alpha_rev (to_m64 (m)));
-		*dst = store8888 (vdest);
+		store8888 (dst, vdest);
+	    }
-	    else
-	    {
-		*dst = 0;
-	    }
 	    else
 	    w--;
-	    mask++;
+		*dst = 0;
 	    dst++;
+	}
+    }
-    _mm_empty ();
-}
-static void
-mmx_composite_over_n_8_0565 (pixman_implementation_t *imp,
-                             pixman_op_t              op,
-                             pixman_image_t *         src_image,
-                             pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
-                             int32_t                  src_x,
-                             int32_t                  src_y,
-                             int32_t                  mask_x,
+    _mm_empty ();
+}
                              int32_t                  mask_y,
-                             int32_t                  dest_x,
+static void
-                             int32_t                  dest_y,
+mmx_composite_over_n_8_0565 (pixman_implementation_t *imp,
-                             int32_t                  width,
+                             pixman_composite_info_t *info)
                              int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t src, srca;
     uint16_t *dst_line, *dst;
     uint8_t *mask_line, *mask;
     int dst_stride, mask_stride;
     int32_t w;
     __m64 vsrc, vsrca, tmp;
-    uint64_t srcsrcsrcsrc, src16;
+    __m64 srcsrcsrcsrc;
     CHECKPOINT ();
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
-    srca = src >> 24;
-    if (src == 0)
-	return;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    srca = src >> 24;
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
+    if (src == 0)
 	return;
     vsrc = load8888 (src);
 	mask_line += mask_stride;
 	w = width;
 	CHECKPOINT ();
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
 	    uint64_t m = *mask;
 	    m2 = *(mask + 2);
 	    m3 = *(mask + 3);
 	    if (srca == 0xff && (m0 & m1 & m2 & m3) == 0xff)
 	    {
-		*(uint64_t *)dst = srcsrcsrcsrc;
+		*(__m64 *)dst = srcsrcsrcsrc;
+	    }
 	    else if (m0 | m1 | m2 | m3)
+	    {
-	    {
+		__m64 vdest = *(__m64 *)dst;
-		__m64 vdest;
+		__m64 v0, v1, v2, v3;
 		__m64 vm0, vm1, vm2, vm3;
-		vdest = *(__m64 *)dst;
+		expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
 		vm0 = to_m64 (m0);
-		vdest = pack_565 (in_over (vsrc, vsrca, expand_alpha_rev (vm0),
+		v0 = in_over (vsrc, vsrca, expand_alpha_rev (vm0), v0);
-					   expand565 (vdest, 0)), vdest, 0);
 		vm1 = to_m64 (m1);
-		vdest = pack_565 (in_over (vsrc, vsrca, expand_alpha_rev (vm1),
+		v1 = in_over (vsrc, vsrca, expand_alpha_rev (vm1), v1);
-					   expand565 (vdest, 1)), vdest, 1);
 		vm2 = to_m64 (m2);
-		vdest = pack_565 (in_over (vsrc, vsrca, expand_alpha_rev (vm2),
+		v2 = in_over (vsrc, vsrca, expand_alpha_rev (vm2), v2);
-					   expand565 (vdest, 2)), vdest, 2);
-		vm3 = to_m64 (m3);
-		vdest = pack_565 (in_over (vsrc, vsrca, expand_alpha_rev (vm3),
+		vm3 = to_m64 (m3);
-					   expand565 (vdest, 3)), vdest, 3);
+		v3 = in_over (vsrc, vsrca, expand_alpha_rev (vm3), v3);
-		*(__m64 *)dst = vdest;
+		*(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);;
     _mm_empty ();
+}
 static void
 mmx_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
-                                pixman_op_t              op,
-                                pixman_image_t *         src_image,
-                                pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
-                                int32_t                  src_x,
-                                int32_t                  src_y,
-                                int32_t                  mask_x,
-                                int32_t                  mask_y,
-                                int32_t                  dest_x,
-                                int32_t                  dest_y,
-                                int32_t                  width,
-                                int32_t                  height)
+                                pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint16_t    *dst_line, *dst;
     uint32_t    *src_line, *src;
     int dst_stride, src_stride;
     int32_t w;
     CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 	src_line += src_stride;
 	w = width;
 	CHECKPOINT ();
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
-	    __m64 vsrc = load8888 (*src);
+	    __m64 vsrc = load8888 (src);
 	    uint64_t d = *dst;
 	    a2 = (s2 >> 24);
 	    a3 = (s3 >> 24);
 	    if ((a0 & a1 & a2 & a3) == 0xFF)
-	    {
-		__m64 vdest;
+	    {
-		vdest = pack_565 (invert_colors (load8888 (s0)), _mm_setzero_si64 (), 0);
+		__m64 v0 = invert_colors (load8888 (&s0));
-		vdest = pack_565 (invert_colors (load8888 (s1)), vdest, 1);
+		__m64 v1 = invert_colors (load8888 (&s1));
-		vdest = pack_565 (invert_colors (load8888 (s2)), vdest, 2);
+		__m64 v2 = invert_colors (load8888 (&s2));
-		vdest = pack_565 (invert_colors (load8888 (s3)), vdest, 3);
+		__m64 v3 = invert_colors (load8888 (&s3));
-		*(__m64 *)dst = vdest;
+		*(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
+	    }
 	    else if (s0 | s1 | s2 | s3)
+	    {
-	    {
+		__m64 vdest = *(__m64 *)dst;
-		__m64 vdest = *(__m64 *)dst;
+		__m64 v0, v1, v2, v3;
-		vdest = pack_565 (over_rev_non_pre (load8888 (s0), expand565 (vdest, 0)), vdest, 0);
+		__m64 vsrc0 = load8888 (&s0);
+		__m64 vsrc1 = load8888 (&s1);
+		__m64 vsrc2 = load8888 (&s2);
+		__m64 vsrc3 = load8888 (&s3);
+		expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
+		v0 = over_rev_non_pre (vsrc0, v0);
-		vdest = pack_565 (over_rev_non_pre (load8888 (s1), expand565 (vdest, 1)), vdest, 1);
+		v1 = over_rev_non_pre (vsrc1, v1);
-		vdest = pack_565 (over_rev_non_pre (load8888 (s2), expand565 (vdest, 2)), vdest, 2);
+		v2 = over_rev_non_pre (vsrc2, v2);
-		vdest = pack_565 (over_rev_non_pre (load8888 (s3), expand565 (vdest, 3)), vdest, 3);
+		v3 = over_rev_non_pre (vsrc3, v3);
-		*(__m64 *)dst = vdest;
+		*(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
 	CHECKPOINT ();
 	while (w)
+	{
-	    __m64 vsrc = load8888 (*src);
+	    __m64 vsrc = load8888 (src);
 	    uint64_t d = *dst;
     _mm_empty ();
+}
 static void
 mmx_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
-                                pixman_op_t              op,
-                                pixman_image_t *         src_image,
-                                pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
-                                int32_t                  src_x,
-                                int32_t                  src_y,
-                                int32_t                  mask_x,
-                                int32_t                  mask_y,
-                                int32_t                  dest_x,
-                                int32_t                  dest_y,
-                                int32_t                  width,
-                                int32_t                  height)
+                                pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t    *dst_line, *dst;
     uint32_t    *src_line, *src;
     int dst_stride, src_stride;
     int32_t w;
     CHECKPOINT ();
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 	dst_line += dst_stride;
 	src = src_line;
 	src_line += src_stride;
 	w = width;
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
 	{
-	    __m64 s = load8888 (*src);
+	    __m64 s = load8888 (src);
-	    __m64 d = load8888 (*dst);
+	    __m64 d = load8888 (dst);
-	    *dst = store8888 (over_rev_non_pre (s, d));
+	    store8888 (dst, over_rev_non_pre (s, d));
 	    w--;
 	    dst++;
 	    src++;
 	}
 	while (w >= 2)
+	{
-	    uint64_t s0, s1;
+	    uint32_t s0, s1;
 	    a0 = (s0 >> 24);
 	    a1 = (s1 >> 24);
 	    if ((a0 & a1) == 0xFF)
 	    {
-		d0 = invert_colors (load8888 (s0));
+		d0 = invert_colors (load8888 (&s0));
-		d1 = invert_colors (load8888 (s1));
+		d1 = invert_colors (load8888 (&s1));
 		*(__m64 *)dst = pack8888 (d0, d1);
+	    }
 	    else if (s0 | s1)
 	    {
 		__m64 vdest = *(__m64 *)dst;
-		d0 = over_rev_non_pre (load8888 (s0), expand8888 (vdest, 0));
+		d0 = over_rev_non_pre (load8888 (&s0), expand8888 (vdest, 0));
-		d1 = over_rev_non_pre (load8888 (s1), expand8888 (vdest, 1));
+		d1 = over_rev_non_pre (load8888 (&s1), expand8888 (vdest, 1));
 		*(__m64 *)dst = pack8888 (d0, d1);
+	    }
 	    w -= 2;
 	    dst += 2;
 	    src += 2;
 	}
-	while (w)
-	{
-	    __m64 s = load8888 (*src);
 	    __m64 d = load8888 (*dst);
 	if (w)
 	    *dst = store8888 (over_rev_non_pre (s, d));
 	    __m64 s = load8888 (src);
-	    w--;
+	    __m64 d = load8888 (dst);
 	    dst++;
-	    src++;
+	    store8888 (dst, over_rev_non_pre (s, d));
-	}
-    }
-    _mm_empty ();
-}
-static void
-mmx_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   pixman_image_t *         src_image,
-                                   pixman_image_t *         mask_image,
                                    pixman_image_t *         dst_image,
+    }
-                                   int32_t                  src_x,
-                                   int32_t                  src_y,
+    _mm_empty ();
                                    int32_t                  mask_x,
                                    int32_t                  mask_y,
-                                   int32_t                  dest_x,
+static void
-                                   int32_t                  dest_y,
+mmx_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
-                                   int32_t                  width,
+                                   pixman_composite_info_t *info)
-                                   int32_t                  height)
+{
-    uint32_t src, srca;
+    PIXMAN_COMPOSITE_ARGS (info);
-    uint16_t    *dst_line;
+    uint32_t src;
-    uint32_t    *mask_line;
+    uint16_t    *dst_line;
-    int dst_stride, mask_stride;
+    uint32_t    *mask_line;
-    __m64 vsrc, vsrca;
+    int dst_stride, mask_stride;
     __m64 vsrc, vsrca;
     CHECKPOINT ();
     CHECKPOINT ();
     src = _pixman_image_get_solid (src_image, dst_image->bits.format);
     src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
-    srca = src >> 24;
     if (src == 0)
 	return;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
     while (height--)
+    {
 	    m3 = *(p + 3);
 	    if ((m0 | m1 | m2 | m3))
+	    {
+		__m64 vdest = *(__m64 *)q;
+		__m64 v0, v1, v2, v3;
-		__m64 vdest = *(__m64 *)q;
+		expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
-		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (m0), expand565 (vdest, 0)), vdest, 0);
+		v0 = in_over (vsrc, vsrca, load8888 (&m0), v0);
-		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (m1), expand565 (vdest, 1)), vdest, 1);
+		v1 = in_over (vsrc, vsrca, load8888 (&m1), v1);
-		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (m2), expand565 (vdest, 2)), vdest, 2);
+		v2 = in_over (vsrc, vsrca, load8888 (&m2), v2);
-		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (m3), expand565 (vdest, 3)), vdest, 3);
+		v3 = in_over (vsrc, vsrca, load8888 (&m3), v3);
-		*(__m64 *)q = vdest;
+		*(__m64 *)q = pack_4x565 (v0, v1, v2, v3);
+	    }
 	    twidth -= 4;
 	    m = *(uint32_t *)p;
 	    if (m)
+	    {
 		uint64_t d = *q;
 		__m64 vdest = expand565 (to_m64 (d), 0);
-		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (m), vdest), vdest, 0);
+		vdest = pack_565 (in_over (vsrc, vsrca, load8888 (&m), vdest), vdest, 0);
 		*q = to_uint64 (vdest);
+	    }
 	    twidth--;
     _mm_empty ();
+}
 static void
 mmx_composite_in_n_8_8 (pixman_implementation_t *imp,
-                        pixman_op_t              op,
-                        pixman_image_t *         src_image,
-                        pixman_image_t *         mask_image,
-                        pixman_image_t *         dst_image,
-                        int32_t                  src_x,
-                        int32_t                  src_y,
-                        int32_t                  mask_x,
-                        int32_t                  mask_y,
-                        int32_t                  dest_x,
-                        int32_t                  dest_y,
-                        int32_t                  width,
-                        int32_t                  height)
+                        pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint8_t *dst_line, *dst;
     uint8_t *mask_line, *mask;
     int dst_stride, mask_stride;
     int32_t w;
     uint32_t src;
     uint8_t sa;
     __m64 vsrc, vsrca;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     sa = src >> 24;
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
     while (height--)
-    {
-	dst = dst_line;
+    {
-	dst_line += dst_stride;
+	dst = dst_line;
+	dst_line += dst_stride;
+	mask = mask_line;
+	mask_line += mask_stride;
+	w = width;
+	while (w && (uintptr_t)dst & 7)
+	{
+	    uint16_t tmp;
+	    uint8_t a;
+	    uint32_t m, d;
+	    a = *mask++;
+	    d = *dst;
-	mask = mask_line;
+	    m = MUL_UN8 (sa, a, tmp);
-	mask_line += mask_stride;
+	    d = MUL_UN8 (m, d, tmp);
-	w = width;
-	if ((((unsigned long)dst_image & 3) == 0) &&
+	    *dst++ = d;
-	    (((unsigned long)src_image & 3) == 0))
+	    w--;
+	}
-	{
-	    while (w >= 4)
-	    {
-		uint32_t m;
-		__m64 vmask;
+	while (w >= 4)
 		__m64 vdest;
 	    __m64 vmask;
-		m = 0;
+	    __m64 vdest;
 		vmask = load8888 (*(uint32_t *)mask);
-		vdest = load8888 (*(uint32_t *)dst);
+	    vmask = load8888u ((uint32_t *)mask);
 	    vdest = load8888 ((uint32_t *)dst);
 		*(uint32_t *)dst = store8888 (in (in (vsrca, vmask), vdest));
     _mm_empty ();
+}
 static void
 mmx_composite_in_8_8 (pixman_implementation_t *imp,
-                      pixman_op_t              op,
-                      pixman_image_t *         src_image,
-                      pixman_image_t *         mask_image,
-                      pixman_image_t *         dst_image,
-                      int32_t                  src_x,
-                      int32_t                  src_y,
-                      int32_t                  mask_x,
-                      int32_t                  mask_y,
-                      int32_t                  dest_x,
-                      int32_t                  dest_y,
-                      int32_t                  width,
-                      int32_t                  height)
+                      pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint8_t     *dst_line, *dst;
     uint8_t     *src_line, *src;
     int src_stride, dst_stride;
     int32_t w;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
     while (height--)
+    {
 	dst = dst_line;
 	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
+	src = src_line;
-	w = width;
+	src_line += src_stride;
+	w = width;
+	while (w && (uintptr_t)dst & 3)
+	{
+	    uint8_t s, d;
+	    uint16_t tmp;
+	    s = *src;
+	    d = *dst;
+	    *dst = MUL_UN8 (s, d, tmp);
+	    src++;
 	    dst++;
-	if ((((unsigned long)dst_image & 3) == 0) &&
+	    w--;
 	    (((unsigned long)src_image & 3) == 0))
-	    while (w >= 4)
+	while (w >= 4)
+	{
-		uint32_t *s = (uint32_t *)src;
+	    uint32_t *s = (uint32_t *)src;
-		uint32_t *d = (uint32_t *)dst;
+	    uint32_t *d = (uint32_t *)dst;
-		*d = store8888 (in (load8888 (*s), load8888 (*d)));
 	    store8888 (d, in (load8888u (s), load8888 (d)));
 		w -= 4;
-		dst += 4;
+	    w -= 4;
-		src += 4;
+	    dst += 4;
     _mm_empty ();
+}
 static void
 mmx_composite_add_n_8_8 (pixman_implementation_t *imp,
-			 pixman_op_t              op,
-			 pixman_image_t *         src_image,
-			 pixman_image_t *         mask_image,
-			 pixman_image_t *         dst_image,
-			 int32_t                  src_x,
-			 int32_t                  src_y,
-			 int32_t                  mask_x,
-			 int32_t                  mask_y,
-			 int32_t                  dest_x,
-			 int32_t                  dest_y,
-			 int32_t                  width,
-			 int32_t                  height)
+			 pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint8_t     *dst_line, *dst;
     uint8_t     *mask_line, *mask;
     int dst_stride, mask_stride;
     int32_t w;
     uint32_t src;
     uint8_t sa;
     __m64 vsrc, vsrca;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    src = _pixman_image_get_solid (src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     sa = src >> 24;
     if (src == 0)
 	return;
-    vsrc = load8888 (src);
+    vsrc = load8888 (&src);
     vsrca = expand_alpha (vsrc);
-    while (height--)
-    {
+    while (height--)
 	dst = dst_line;
+	dst = dst_line;
+	dst_line += dst_stride;
+	mask = mask_line;
+	mask_line += mask_stride;
+	w = width;
+	while (w && (uintptr_t)dst & 3)
+	{
+	    uint16_t tmp;
+	    uint16_t a;
+	    uint32_t m, d;
+	    uint32_t r;
+	    a = *mask++;
+	    d = *dst;
 	dst_line += dst_stride;
-	mask = mask_line;
+	    m = MUL_UN8 (sa, a, tmp);
-	mask_line += mask_stride;
+	    r = ADD_UN8 (m, d, tmp);
-	w = width;
+	    *dst++ = r;
+	    w--;
+	}
-	if ((((unsigned long)mask_image & 3) == 0) &&
-	    (((unsigned long)dst_image  & 3) == 0))
+	while (w >= 4)
+	{
-	    while (w >= 4)
+	    __m64 vmask;
 	    __m64 vdest;
 		__m64 vmask = load8888 (*(uint32_t *)mask);
-		__m64 vdest = load8888 (*(uint32_t *)dst);
+	    vmask = load8888u ((uint32_t *)mask);
 	    vdest = load8888 ((uint32_t *)dst);
     _mm_empty ();
+}
 static void
 mmx_composite_add_8_8 (pixman_implementation_t *imp,
-		       pixman_op_t              op,
-		       pixman_image_t *         src_image,
-		       pixman_image_t *         mask_image,
-		       pixman_image_t *         dst_image,
-		       int32_t                  src_x,
-		       int32_t                  src_y,
-		       int32_t                  mask_x,
-		       int32_t                  mask_y,
-		       int32_t                  dest_x,
-		       int32_t                  dest_y,
-		       int32_t                  width,
-		       int32_t                  height)
+		       pixman_composite_info_t *info)
+{
     PIXMAN_COMPOSITE_ARGS (info);
     uint8_t *dst_line, *dst;
     uint8_t *src_line, *src;
     int dst_stride, src_stride;
     int32_t w;
     uint8_t s, d;
     uint16_t t;
     CHECKPOINT ();
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     while (height--)
+    {
 	dst = dst_line;
 	dst_line += dst_stride;
 	src = src_line;
 	src_line += src_stride;
 	w = width;
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
 	    w--;
+	}
 	while (w >= 8)
 	{
-	    *(__m64*)dst = _mm_adds_pu8 (*(__m64*)src, *(__m64*)dst);
+	    *(__m64*)dst = _mm_adds_pu8 (ldq_u ((__m64 *)src), *(__m64*)dst);
 	    dst += 8;
 	    src += 8;
 	    w -= 8;
     _mm_empty ();
+}
+static void
+mmx_composite_add_0565_0565 (pixman_implementation_t *imp,
+                             pixman_composite_info_t *info)
+{
+    PIXMAN_COMPOSITE_ARGS (info);
+    uint16_t    *dst_line, *dst;
+    uint32_t	d;
+    uint16_t    *src_line, *src;
+    uint32_t	s;
+    int dst_stride, src_stride;
+    int32_t w;
+    CHECKPOINT ();
+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint16_t, src_stride, src_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    while (height--)
+    {
+	dst = dst_line;
+	dst_line += dst_stride;
+	src = src_line;
+	src_line += src_stride;
+	w = width;
+	while (w && (uintptr_t)dst & 7)
+	{
+	    s = *src++;
+	    if (s)
+	    {
+		d = *dst;
+		s = convert_0565_to_8888 (s);
+		if (d)
+		{
+		    d = convert_0565_to_8888 (d);
+		    UN8x4_ADD_UN8x4 (s, d);
+		}
+		*dst = convert_8888_to_0565 (s);
+	    }
+	    dst++;
+	    w--;
+	}
+	while (w >= 4)
+	{
+	    __m64 vdest = *(__m64 *)dst;
+	    __m64 vsrc = ldq_u ((__m64 *)src);
+	    __m64 vd0, vd1;
+	    __m64 vs0, vs1;
+	    expand_4xpacked565 (vdest, &vd0, &vd1, 0);
+	    expand_4xpacked565 (vsrc, &vs0, &vs1, 0);
+	    vd0 = _mm_adds_pu8 (vd0, vs0);
+	    vd1 = _mm_adds_pu8 (vd1, vs1);
+	    *(__m64 *)dst = pack_4xpacked565 (vd0, vd1);
+	    dst += 4;
+	    src += 4;
+	    w -= 4;
+	}
+	while (w--)
+	{
+	    s = *src++;
+	    if (s)
+	    {
+		d = *dst;
+		s = convert_0565_to_8888 (s);
+		if (d)
+		{
+		    d = convert_0565_to_8888 (d);
+		    UN8x4_ADD_UN8x4 (s, d);
+		}
+		*dst = convert_8888_to_0565 (s);
+	    }
+	    dst++;
+	}
+    }
+    _mm_empty ();
+}
 static void
-mmx_composite_add_8888_8888 (pixman_implementation_t *imp,
-                             pixman_op_t              op,
-                             pixman_image_t *         src_image,
-                             pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
-                             int32_t                  src_x,
-                             int32_t                  src_y,
-                             int32_t                  mask_x,
-                             int32_t                  mask_y,
-                             int32_t                  dest_x,
-                             int32_t                  dest_y,
-                             int32_t                  width,
+mmx_composite_add_8888_8888 (pixman_implementation_t *imp,
-                             int32_t                  height)
+                             pixman_composite_info_t *info)
+{
-    __m64 dst64;
+    PIXMAN_COMPOSITE_ARGS (info);
     uint32_t    *dst_line, *dst;
     uint32_t    *src_line, *src;
     int dst_stride, src_stride;
     int32_t w;
     CHECKPOINT ();
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     while (height--)
+    {
 	dst = dst_line;
 	dst_line += dst_stride;
 	src = src_line;
 	src_line += src_stride;
 	w = width;
-	while (w && (unsigned long)dst & 7)
+	while (w && (uintptr_t)dst & 7)
+	{
-	    *dst = _mm_cvtsi64_si32 (_mm_adds_pu8 (_mm_cvtsi32_si64 (*src),
+	    store (dst, _mm_adds_pu8 (load ((const uint32_t *)src),
-	                                           _mm_cvtsi32_si64 (*dst)));
+	                              load ((const uint32_t *)dst)));
 	    dst++;
-	    src++;
-	    w--;
+	    src++;
 	    w--;
+	}
 	while (w >= 2)
 	while (w >= 2)
 	    dst64 = _mm_adds_pu8 (*(__m64*)src, *(__m64*)dst);
-	    *(uint64_t*)dst = to_uint64 (dst64);
+	    *(__m64 *)dst = _mm_adds_pu8 (ldq_u ((__m64 *)src), *(__m64*)dst);
 	    dst += 2;
 	    src += 2;
 	    w -= 2;
+	}
 	if (w)
+	{
-	{
+	    store (dst, _mm_adds_pu8 (load ((const uint32_t *)src),
-	    *dst = _mm_cvtsi64_si32 (_mm_adds_pu8 (_mm_cvtsi32_si64 (*src),
+	                              load ((const uint32_t *)dst)));
 	                                           _mm_cvtsi32_si64 (*dst)));
+	}
+    }
     _mm_empty ();
     _mm_empty ();
-}
+static pixman_bool_t
-static pixman_bool_t
+mmx_blt (pixman_implementation_t *imp,
-pixman_blt_mmx (uint32_t *src_bits,
+         uint32_t *               src_bits,
-                uint32_t *dst_bits,
+         uint32_t *               dst_bits,
-                int       src_stride,
+         int                      src_stride,
-                int       dst_stride,
+         int                      dst_stride,
     if (src_bpp == 16)
+    {
 	src_stride = src_stride * (int) sizeof (uint32_t) / 2;
 	dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
 	src_bytes = (uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
-	dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+	dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
 	byte_width = 2 * width;
 	src_stride *= 2;
 	dst_stride *= 2;
+    }
     else if (src_bpp == 32)
+    {
 	src_stride = src_stride * (int) sizeof (uint32_t) / 4;
 	dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
 	src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
-	dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+	dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
 	byte_width = 4 * width;
 	src_stride *= 4;
 	dst_stride *= 4;
+    }
     else
 	uint8_t *d = dst_bytes;
 	src_bytes += src_stride;
 	dst_bytes += dst_stride;
 	w = byte_width;
+	if (w >= 1 && ((uintptr_t)d & 1))
+	{
+	    *(uint8_t *)d = *(uint8_t *)s;
+	    w -= 1;
+	    s += 1;
+	    d += 1;
+	}
-	while (w >= 2 && ((unsigned long)d & 3))
+	if (w >= 2 && ((uintptr_t)d & 3))
+	{
 	    *(uint16_t *)d = *(uint16_t *)s;
 	    w -= 2;
 	    s += 2;
 	    d += 2;
 	}
-	while (w >= 4 && ((unsigned long)d & 7))
+	while (w >= 4 && ((uintptr_t)d & 7))
+	{
-	    *(uint32_t *)d = *(uint32_t *)s;
+	    *(uint32_t *)d = ldl_u ((uint32_t *)s);
 	    w -= 4;
 	    s += 4;
 	    d += 4;
 	}
 	while (w >= 64)
+	{
-#if defined (__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#if (defined (__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))) && defined USE_X86_MMX
 	    __asm__ (
 		: "r" (d), "r" (s)
 		: "memory",
 		  "%mm0", "%mm1", "%mm2", "%mm3",
 		  "%mm4", "%mm5", "%mm6", "%mm7");
 #else
-	    __m64 v0 = *(__m64 *)(s + 0);
+	    __m64 v0 = ldq_u ((__m64 *)(s + 0));
-	    __m64 v1 = *(__m64 *)(s + 8);
+	    __m64 v1 = ldq_u ((__m64 *)(s + 8));
-	    __m64 v2 = *(__m64 *)(s + 16);
+	    __m64 v2 = ldq_u ((__m64 *)(s + 16));
-	    __m64 v3 = *(__m64 *)(s + 24);
+	    __m64 v3 = ldq_u ((__m64 *)(s + 24));
-	    __m64 v4 = *(__m64 *)(s + 32);
+	    __m64 v4 = ldq_u ((__m64 *)(s + 32));
-	    __m64 v5 = *(__m64 *)(s + 40);
+	    __m64 v5 = ldq_u ((__m64 *)(s + 40));
-	    __m64 v6 = *(__m64 *)(s + 48);
+	    __m64 v6 = ldq_u ((__m64 *)(s + 48));
-	    __m64 v7 = *(__m64 *)(s + 56);
+	    __m64 v7 = ldq_u ((__m64 *)(s + 56));
 	    *(__m64 *)(d + 0)  = v0;
 	    *(__m64 *)(d + 8)  = v1;
 	    *(__m64 *)(d + 16) = v2;
 	    *(__m64 *)(d + 24) = v3;
 	    *(__m64 *)(d + 32) = v4;
 	    s += 64;
 	    d += 64;
+	}
 	while (w >= 4)
+	{
-	    *(uint32_t *)d = *(uint32_t *)s;
+	    *(uint32_t *)d = ldl_u ((uint32_t *)s);
 	    w -= 4;
 	    s += 4;
 	    d += 4;
     return TRUE;
+}
 static void
 mmx_composite_copy_area (pixman_implementation_t *imp,
-                         pixman_op_t              op,
-                         pixman_image_t *         src_image,
-                         pixman_image_t *         mask_image,
-                         pixman_image_t *         dst_image,
-                         int32_t                  src_x,
-                         int32_t                  src_y,
-                         int32_t                  mask_x,
-                         int32_t                  mask_y,
-                         int32_t                  dest_x,
-                         int32_t                  dest_y,
-                         int32_t                  width,
-                         int32_t                  height)
+                         pixman_composite_info_t *info)
+{
+    PIXMAN_COMPOSITE_ARGS (info);
-{
-    pixman_blt_mmx (src_image->bits.bits,
+    mmx_blt (imp, src_image->bits.bits,
-                    dst_image->bits.bits,
+	     dest_image->bits.bits,
-                    src_image->bits.rowstride,
+	     src_image->bits.rowstride,
-                    dst_image->bits.rowstride,
+	     dest_image->bits.rowstride,
-                    PIXMAN_FORMAT_BPP (src_image->bits.format),
+	     PIXMAN_FORMAT_BPP (src_image->bits.format),
-                    PIXMAN_FORMAT_BPP (dst_image->bits.format),
+	     PIXMAN_FORMAT_BPP (dest_image->bits.format),
-                    src_x, src_y, dest_x, dest_y, width, height);
+	     src_x, src_y, dest_x, dest_y, width, height);
-}
+}
 #if 0
 static void
-mmx_composite_over_x888_8_8888 (pixman_implementation_t *imp,
-                                pixman_op_t              op,
-                                pixman_image_t *         src_image,
-                                pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
-                                int32_t                  src_x,
-                                int32_t                  src_y,
-                                int32_t                  mask_x,
-                                int32_t                  mask_y,
-                                int32_t                  dest_x,
-                                int32_t                  dest_y,
-                                int32_t                  width,
+mmx_composite_over_x888_8_8888 (pixman_implementation_t *imp,
+                                pixman_composite_info_t *info)
                                 int32_t                  height)
     PIXMAN_COMPOSITE_ARGS (info);
     uint32_t  *src, *src_line;
     uint32_t  *dst, *dst_line;
     uint8_t  *mask, *mask_line;
     int src_stride, mask_stride, dst_stride;
     int32_t w;
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
+	{
 	    uint64_t m = *mask;
 	    if (m)
+	    {
-	    {
+		uint32_t ssrc = *src | 0xff000000;
-		__m64 s = load8888 (*src | 0xff000000);
+		__m64 s = load8888 (&ssrc);
 		if (m == 0xff)
+		{
-		    *dst = store8888 (s);
+		    store8888 (dst, s);
+		}
 		else
+		{
 		    __m64 sa = expand_alpha (s);
 		    __m64 vm = expand_alpha_rev (to_m64 (m));
-		    __m64 vdest = in_over (s, sa, vm, load8888 (*dst));
+		    __m64 vdest = in_over (s, sa, vm, load8888 (dst));
-		    *dst = store8888 (vdest);
+		    store8888 (dst, vdest);
+		}
+	}
+    }
     _mm_empty ();
+}
+static void
+mmx_composite_over_reverse_n_8888 (pixman_implementation_t *imp,
+                                   pixman_composite_info_t *info)
+{
+    PIXMAN_COMPOSITE_ARGS (info);
+    uint32_t src;
+    uint32_t    *dst_line, *dst;
+    int32_t w;
+    int dst_stride;
+    __m64 vsrc;
+    CHECKPOINT ();
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
+    if (src == 0)
+	return;
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    vsrc = load8888 (&src);
+    while (height--)
+    {
+	dst = dst_line;
+	dst_line += dst_stride;
+	w = width;
+	CHECKPOINT ();
+	while (w && (uintptr_t)dst & 7)
+	{
+	    __m64 vdest = load8888 (dst);
+	    store8888 (dst, over (vdest, expand_alpha (vdest), vsrc));
+	    w--;
+	    dst++;
+	}
+	while (w >= 2)
+	{
+	    __m64 vdest = *(__m64 *)dst;
+	    __m64 dest0 = expand8888 (vdest, 0);
+	    __m64 dest1 = expand8888 (vdest, 1);
+	    dest0 = over (dest0, expand_alpha (dest0), vsrc);
+	    dest1 = over (dest1, expand_alpha (dest1), vsrc);
+	    *(__m64 *)dst = pack8888 (dest0, dest1);
+	    dst += 2;
+	    w -= 2;
+	}
+	CHECKPOINT ();
+	if (w)
+	{
+	    __m64 vdest = load8888 (dst);
+	    store8888 (dst, over (vdest, expand_alpha (vdest), vsrc));
+	}
+    }
+    _mm_empty ();
+}
+#define BSHIFT ((1 << BILINEAR_INTERPOLATION_BITS))
+#define BMSK (BSHIFT - 1)
+#define BILINEAR_DECLARE_VARIABLES						\
+    const __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt);				\
+    const __m64 mm_wb = _mm_set_pi16 (wb, wb, wb, wb);				\
+    const __m64 mm_BSHIFT = _mm_set_pi16 (BSHIFT, BSHIFT, BSHIFT, BSHIFT);	\
+    const __m64 mm_addc7 = _mm_set_pi16 (0, 1, 0, 1);				\
+    const __m64 mm_xorc7 = _mm_set_pi16 (0, BMSK, 0, BMSK);			\
+    const __m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);		\
+    const __m64 mm_zero = _mm_setzero_si64 ();					\
+    __m64 mm_x = _mm_set_pi16 (vx, vx, vx, vx)
+#define BILINEAR_INTERPOLATE_ONE_PIXEL(pix)					\
+do {										\
+    /* fetch 2x2 pixel block into 2 mmx registers */				\
+    __m64 t = ldq_u ((__m64 *)&src_top [pixman_fixed_to_int (vx)]);		\
+    __m64 b = ldq_u ((__m64 *)&src_bottom [pixman_fixed_to_int (vx)]);		\
+    /* vertical interpolation */						\
+    __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8 (t, mm_zero), mm_wt);		\
+    __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8 (t, mm_zero), mm_wt);		\
+    __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8 (b, mm_zero), mm_wb);		\
+    __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8 (b, mm_zero), mm_wb);		\
+    __m64 hi = _mm_add_pi16 (t_hi, b_hi);					\
+    __m64 lo = _mm_add_pi16 (t_lo, b_lo);					\
+    vx += unit_x;								\
+    if (BILINEAR_INTERPOLATION_BITS < 8)					\
+    {										\
+	/* calculate horizontal weights */					\
+	__m64 mm_wh = _mm_add_pi16 (mm_addc7, _mm_xor_si64 (mm_xorc7,		\
+			  _mm_srli_pi16 (mm_x,					\
+- BILINEAR_INTERPOLATION_BITS)));	\
+	/* horizontal interpolation */						\
+	__m64 p = _mm_unpacklo_pi16 (lo, hi);					\
+	__m64 q = _mm_unpackhi_pi16 (lo, hi);					\
+	lo = _mm_madd_pi16 (p, mm_wh);						\
+	hi = _mm_madd_pi16 (q, mm_wh);						\
+    }										\
+    else									\
+    {										\
+	/* calculate horizontal weights */					\
+	__m64 mm_wh_lo = _mm_sub_pi16 (mm_BSHIFT, _mm_srli_pi16 (mm_x,		\
+- BILINEAR_INTERPOLATION_BITS));	\
+	__m64 mm_wh_hi = _mm_srli_pi16 (mm_x,					\
+- BILINEAR_INTERPOLATION_BITS);	\
+	/* horizontal interpolation */						\
+	__m64 mm_lo_lo = _mm_mullo_pi16 (lo, mm_wh_lo);				\
+	__m64 mm_lo_hi = _mm_mullo_pi16 (hi, mm_wh_hi);				\
+	__m64 mm_hi_lo = _mm_mulhi_pu16 (lo, mm_wh_lo);				\
+	__m64 mm_hi_hi = _mm_mulhi_pu16 (hi, mm_wh_hi);				\
+	lo = _mm_add_pi32 (_mm_unpacklo_pi16 (mm_lo_lo, mm_hi_lo),		\
+			   _mm_unpacklo_pi16 (mm_lo_hi, mm_hi_hi));		\
+	hi = _mm_add_pi32 (_mm_unpackhi_pi16 (mm_lo_lo, mm_hi_lo),		\
+			   _mm_unpackhi_pi16 (mm_lo_hi, mm_hi_hi));		\
+    }										\
+    mm_x = _mm_add_pi16 (mm_x, mm_ux);						\
+    /* shift and pack the result */						\
+    hi = _mm_srli_pi32 (hi, BILINEAR_INTERPOLATION_BITS * 2);			\
+    lo = _mm_srli_pi32 (lo, BILINEAR_INTERPOLATION_BITS * 2);			\
+    lo = _mm_packs_pi32 (lo, hi);						\
+    lo = _mm_packs_pu16 (lo, lo);						\
+    pix = lo;									\
+} while (0)
+#define BILINEAR_SKIP_ONE_PIXEL()						\
+do {										\
+    vx += unit_x;								\
+    mm_x = _mm_add_pi16 (mm_x, mm_ux);						\
+} while(0)
+static force_inline void
+scaled_bilinear_scanline_mmx_8888_8888_SRC (uint32_t *       dst,
+					    const uint32_t * mask,
+					    const uint32_t * src_top,
+					    const uint32_t * src_bottom,
+					    int32_t          w,
+					    int              wt,
+					    int              wb,
+					    pixman_fixed_t   vx,
+					    pixman_fixed_t   unit_x,
+					    pixman_fixed_t   max_vx,
+					    pixman_bool_t    zero_src)
+{
+    BILINEAR_DECLARE_VARIABLES;
+    __m64 pix;
+    while (w--)
+    {
+	BILINEAR_INTERPOLATE_ONE_PIXEL (pix);
+	store (dst, pix);
+	dst++;
+    }
+    _mm_empty ();
+}
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_cover_SRC,
+			       scaled_bilinear_scanline_mmx_8888_8888_SRC,
+			       uint32_t, uint32_t, uint32_t,
+			       COVER, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_pad_SRC,
+			       scaled_bilinear_scanline_mmx_8888_8888_SRC,
+			       uint32_t, uint32_t, uint32_t,
+			       PAD, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_none_SRC,
+			       scaled_bilinear_scanline_mmx_8888_8888_SRC,
+			       uint32_t, uint32_t, uint32_t,
+			       NONE, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_normal_SRC,
+			       scaled_bilinear_scanline_mmx_8888_8888_SRC,
+			       uint32_t, uint32_t, uint32_t,
+			       NORMAL, FLAG_NONE)
+static force_inline void
+scaled_bilinear_scanline_mmx_8888_8888_OVER (uint32_t *       dst,
+					     const uint32_t * mask,
+					     const uint32_t * src_top,
+					     const uint32_t * src_bottom,
+					     int32_t          w,
+					     int              wt,
+					     int              wb,
+					     pixman_fixed_t   vx,
+					     pixman_fixed_t   unit_x,
+					     pixman_fixed_t   max_vx,
+					     pixman_bool_t    zero_src)
+{
+    BILINEAR_DECLARE_VARIABLES;
+    __m64 pix1, pix2;
+    while (w)
+    {
+	BILINEAR_INTERPOLATE_ONE_PIXEL (pix1);
+	if (!is_zero (pix1))
+	{
+	    pix2 = load (dst);
+	    store8888 (dst, core_combine_over_u_pixel_mmx (pix1, pix2));
+	}
+	w--;
+	dst++;
+    }
+    _mm_empty ();
+}
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_cover_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8888_OVER,
+			       uint32_t, uint32_t, uint32_t,
+			       COVER, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_pad_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8888_OVER,
+			       uint32_t, uint32_t, uint32_t,
+			       PAD, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_none_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8888_OVER,
+			       uint32_t, uint32_t, uint32_t,
+			       NONE, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_normal_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8888_OVER,
+			       uint32_t, uint32_t, uint32_t,
+			       NORMAL, FLAG_NONE)
+static force_inline void
+scaled_bilinear_scanline_mmx_8888_8_8888_OVER (uint32_t *       dst,
+					       const uint8_t  * mask,
+					       const uint32_t * src_top,
+					       const uint32_t * src_bottom,
+					       int32_t          w,
+					       int              wt,
+					       int              wb,
+					       pixman_fixed_t   vx,
+					       pixman_fixed_t   unit_x,
+					       pixman_fixed_t   max_vx,
+					       pixman_bool_t    zero_src)
+{
+    BILINEAR_DECLARE_VARIABLES;
+    __m64 pix1, pix2;
+    uint32_t m;
+    while (w)
+    {
+	m = (uint32_t) *mask++;
+	if (m)
+	{
+	    BILINEAR_INTERPOLATE_ONE_PIXEL (pix1);
+	    if (m == 0xff && is_opaque (pix1))
+	    {
+		store (dst, pix1);
+	    }
+	    else
+	    {
+		__m64 ms, md, ma, msa;
+		pix2 = load (dst);
+		ma = expand_alpha_rev (to_m64 (m));
+		ms = _mm_unpacklo_pi8 (pix1, _mm_setzero_si64 ());
+		md = _mm_unpacklo_pi8 (pix2, _mm_setzero_si64 ());
+		msa = expand_alpha (ms);
+		store8888 (dst, (in_over (ms, msa, ma, md)));
+	    }
-}
+	}
+	else
+	{
+	    BILINEAR_SKIP_ONE_PIXEL ();
+	}
+	w--;
+	dst++;
+    }
+    _mm_empty ();
+}
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_cover_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8_8888_OVER,
+			       uint32_t, uint8_t, uint32_t,
+			       COVER, FLAG_HAVE_NON_SOLID_MASK)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_pad_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8_8888_OVER,
+			       uint32_t, uint8_t, uint32_t,
+			       PAD, FLAG_HAVE_NON_SOLID_MASK)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_none_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8_8888_OVER,
+			       uint32_t, uint8_t, uint32_t,
+			       NONE, FLAG_HAVE_NON_SOLID_MASK)
+FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_normal_OVER,
+			       scaled_bilinear_scanline_mmx_8888_8_8888_OVER,
+			       uint32_t, uint8_t, uint32_t,
+			       NORMAL, FLAG_HAVE_NON_SOLID_MASK)
+static uint32_t *
+mmx_fetch_x8r8g8b8 (pixman_iter_t *iter, const uint32_t *mask)
+{
+    int w = iter->width;
+    uint32_t *dst = iter->buffer;
+    uint32_t *src = (uint32_t *)iter->bits;
+    iter->bits += iter->stride;
+    while (w && ((uintptr_t)dst) & 7)
+    {
+	*dst++ = (*src++) | 0xff000000;
+	w--;
+    }
+    while (w >= 8)
+    {
+	__m64 vsrc1 = ldq_u ((__m64 *)(src + 0));
+	__m64 vsrc2 = ldq_u ((__m64 *)(src + 2));
+	__m64 vsrc3 = ldq_u ((__m64 *)(src + 4));
+	__m64 vsrc4 = ldq_u ((__m64 *)(src + 6));
+	*(__m64 *)(dst + 0) = _mm_or_si64 (vsrc1, MC (ff000000));
+	*(__m64 *)(dst + 2) = _mm_or_si64 (vsrc2, MC (ff000000));
+	*(__m64 *)(dst + 4) = _mm_or_si64 (vsrc3, MC (ff000000));
+	*(__m64 *)(dst + 6) = _mm_or_si64 (vsrc4, MC (ff000000));
+	dst += 8;
+	src += 8;
+	w -= 8;
+    }
+    while (w)
+    {
+	*dst++ = (*src++) | 0xff000000;
+	w--;
+    }
+    _mm_empty ();
+    return iter->buffer;
+}
+static uint32_t *
+mmx_fetch_r5g6b5 (pixman_iter_t *iter, const uint32_t *mask)
+{
+    int w = iter->width;
+    uint32_t *dst = iter->buffer;
+    uint16_t *src = (uint16_t *)iter->bits;
+    iter->bits += iter->stride;
+    while (w && ((uintptr_t)dst) & 0x0f)
+    {
+	uint16_t s = *src++;
+	*dst++ = convert_0565_to_8888 (s);
+	w--;
+    }
+    while (w >= 4)
+    {
+	__m64 vsrc = ldq_u ((__m64 *)src);
+	__m64 mm0, mm1;
+	expand_4xpacked565 (vsrc, &mm0, &mm1, 1);
+	*(__m64 *)(dst + 0) = mm0;
+	*(__m64 *)(dst + 2) = mm1;
+	dst += 4;
+	src += 4;
+	w -= 4;
+    }
+    while (w)
+    {
+	uint16_t s = *src++;
+	*dst++ = convert_0565_to_8888 (s);
+	w--;
+    }
+    _mm_empty ();
+    return iter->buffer;
+}
+static uint32_t *
+mmx_fetch_a8 (pixman_iter_t *iter, const uint32_t *mask)
+{
+    int w = iter->width;
+    uint32_t *dst = iter->buffer;
+    uint8_t *src = iter->bits;
+    iter->bits += iter->stride;
+    while (w && (((uintptr_t)dst) & 15))
+    {
+        *dst++ = *(src++) << 24;
+        w--;
+    }
+    while (w >= 8)
+    {
+	__m64 mm0 = ldq_u ((__m64 *)src);
+	__m64 mm1 = _mm_unpacklo_pi8  (_mm_setzero_si64(), mm0);
+	__m64 mm2 = _mm_unpackhi_pi8  (_mm_setzero_si64(), mm0);
+	__m64 mm3 = _mm_unpacklo_pi16 (_mm_setzero_si64(), mm1);
+	__m64 mm4 = _mm_unpackhi_pi16 (_mm_setzero_si64(), mm1);
+	__m64 mm5 = _mm_unpacklo_pi16 (_mm_setzero_si64(), mm2);
+	__m64 mm6 = _mm_unpackhi_pi16 (_mm_setzero_si64(), mm2);
+	*(__m64 *)(dst + 0) = mm3;
+	*(__m64 *)(dst + 2) = mm4;
+	*(__m64 *)(dst + 4) = mm5;
+	*(__m64 *)(dst + 6) = mm6;
+	dst += 8;
+	src += 8;
+	w -= 8;
+    }
+    while (w)
+    {
+	*dst++ = *(src++) << 24;
+	w--;
+    }
+    _mm_empty ();
+    return iter->buffer;
+}
+typedef struct
+{
+    pixman_format_code_t	format;
+    pixman_iter_get_scanline_t	get_scanline;
+} fetcher_info_t;
+static const fetcher_info_t fetchers[] =
+{
+    { PIXMAN_x8r8g8b8,		mmx_fetch_x8r8g8b8 },
+    { PIXMAN_r5g6b5,		mmx_fetch_r5g6b5 },
+    { PIXMAN_a8,		mmx_fetch_a8 },
+    { PIXMAN_null }
+};
+static pixman_bool_t
+mmx_src_iter_init (pixman_implementation_t *imp, pixman_iter_t *iter)
+{
+    pixman_image_t *image = iter->image;
+#define FLAGS								\
+    (FAST_PATH_STANDARD_FLAGS | FAST_PATH_ID_TRANSFORM |		\
+     FAST_PATH_BITS_IMAGE | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST)
+    if ((iter->iter_flags & ITER_NARROW)			&&
+	(iter->image_flags & FLAGS) == FLAGS)
+    {
+	const fetcher_info_t *f;
+	for (f = &fetchers[0]; f->format != PIXMAN_null; f++)
+	{
+	    if (image->common.extended_format_code == f->format)
+	    {
+		uint8_t *b = (uint8_t *)image->bits.bits;
+		int s = image->bits.rowstride * 4;
+		iter->bits = b + s * iter->y + iter->x * PIXMAN_FORMAT_BPP (f->format) / 8;
+		iter->stride = s;
+		iter->get_scanline = f->get_scanline;
+		return TRUE;
+	    }
+	}
+    }
+    return FALSE;
 #endif
 static const pixman_fast_path_t mmx_fast_paths[] =
+{
     PIXMAN_STD_FAST_PATH    (OVER, x8b8g8r8, solid,    x8b8g8r8, mmx_composite_over_x888_n_8888    ),
     PIXMAN_STD_FAST_PATH    (OVER, a8r8g8b8, solid,    a8r8g8b8, mmx_composite_over_8888_n_8888    ),
     PIXMAN_STD_FAST_PATH    (OVER, a8r8g8b8, solid,    x8r8g8b8, mmx_composite_over_8888_n_8888    ),
     PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, solid,    a8b8g8r8, mmx_composite_over_8888_n_8888    ),
     PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, solid,    x8b8g8r8, mmx_composite_over_8888_n_8888    ),
-#if 0
-    /* FIXME: This code is commented out since it's apparently
-     * not actually faster than the generic code.
-     */
     PIXMAN_STD_FAST_PATH    (OVER, x8r8g8b8, a8,       x8r8g8b8, mmx_composite_over_x888_8_8888    ),
     PIXMAN_STD_FAST_PATH    (OVER, x8r8g8b8, a8,       a8r8g8b8, mmx_composite_over_x888_8_8888    ),
-    PIXMAN_STD_FAST_PATH    (OVER, x8b8r8g8, a8,       x8b8g8r8, mmx_composite_over_x888_8_8888    ),
+    PIXMAN_STD_FAST_PATH    (OVER, x8b8g8r8, a8,       x8b8g8r8, mmx_composite_over_x888_8_8888    ),
-    PIXMAN_STD_FAST_PATH    (OVER, x8b8r8g8, a8,       a8r8g8b8, mmx_composite_over_x888_8_8888    ),
+    PIXMAN_STD_FAST_PATH    (OVER, x8b8g8r8, a8,       a8b8g8r8, mmx_composite_over_x888_8_8888    ),
-#endif
     PIXMAN_STD_FAST_PATH    (OVER, solid,    null,     a8r8g8b8, mmx_composite_over_n_8888         ),
     PIXMAN_STD_FAST_PATH    (OVER, solid,    null,     x8r8g8b8, mmx_composite_over_n_8888         ),
     PIXMAN_STD_FAST_PATH    (OVER, solid,    null,     r5g6b5,   mmx_composite_over_n_0565         ),
+    PIXMAN_STD_FAST_PATH    (OVER, solid,    null,     b5g6r5,   mmx_composite_over_n_0565         ),
     PIXMAN_STD_FAST_PATH    (OVER, x8r8g8b8, null,     x8r8g8b8, mmx_composite_copy_area           ),
     PIXMAN_STD_FAST_PATH    (OVER, x8b8g8r8, null,     x8b8g8r8, mmx_composite_copy_area           ),
     PIXMAN_STD_FAST_PATH    (OVER, a8r8g8b8, null,     a8r8g8b8, mmx_composite_over_8888_8888      ),
     PIXMAN_STD_FAST_PATH    (OVER, a8r8g8b8, null,     x8r8g8b8, mmx_composite_over_8888_8888      ),
     PIXMAN_STD_FAST_PATH    (OVER, a8r8g8b8, null,     r5g6b5,   mmx_composite_over_8888_0565      ),
     PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, null,     a8b8g8r8, mmx_composite_over_8888_8888      ),
     PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, null,     x8b8g8r8, mmx_composite_over_8888_8888      ),
+    PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, null,     b5g6r5,   mmx_composite_over_8888_0565      ),
+    PIXMAN_STD_FAST_PATH    (OVER_REVERSE, solid, null, a8r8g8b8, mmx_composite_over_reverse_n_8888),
+    PIXMAN_STD_FAST_PATH    (OVER_REVERSE, solid, null, a8b8g8r8, mmx_composite_over_reverse_n_8888),
-    PIXMAN_STD_FAST_PATH    (OVER, a8b8g8r8, null,     b5g6r5,   mmx_composite_over_8888_0565      ),
+    PIXMAN_STD_FAST_PATH    (ADD,  r5g6b5,   null,     r5g6b5,   mmx_composite_add_0565_0565       ),
     PIXMAN_STD_FAST_PATH    (ADD,  b5g6r5,   null,     b5g6r5,   mmx_composite_add_0565_0565       ),
     PIXMAN_STD_FAST_PATH    (ADD,  a8r8g8b8, null,     a8r8g8b8, mmx_composite_add_8888_8888       ),
     PIXMAN_STD_FAST_PATH    (ADD,  a8b8g8r8, null,     a8b8g8r8, mmx_composite_add_8888_8888       ),
+    PIXMAN_STD_FAST_PATH    (ADD,  a8,       null,     a8,       mmx_composite_add_8_8		   ),
+    PIXMAN_STD_FAST_PATH    (ADD,  solid,    a8,       a8,       mmx_composite_add_n_8_8           ),
+    PIXMAN_STD_FAST_PATH    (SRC,  a8r8g8b8, null,     r5g6b5,   mmx_composite_src_x888_0565       ),
-    PIXMAN_STD_FAST_PATH    (ADD,  a8,       null,     a8,       mmx_composite_add_8_8		   ),
+    PIXMAN_STD_FAST_PATH    (SRC,  a8b8g8r8, null,     b5g6r5,   mmx_composite_src_x888_0565       ),
-    PIXMAN_STD_FAST_PATH    (ADD,  solid,    a8,       a8,       mmx_composite_add_n_8_8           ),
+    PIXMAN_STD_FAST_PATH    (SRC,  x8r8g8b8, null,     r5g6b5,   mmx_composite_src_x888_0565       ),
     PIXMAN_STD_FAST_PATH    (SRC,  x8b8g8r8, null,     b5g6r5,   mmx_composite_src_x888_0565       ),
     PIXMAN_STD_FAST_PATH    (SRC,  solid,    a8,       a8r8g8b8, mmx_composite_src_n_8_8888        ),
     PIXMAN_STD_FAST_PATH    (SRC,  solid,    a8,       x8r8g8b8, mmx_composite_src_n_8_8888        ),
     PIXMAN_STD_FAST_PATH    (SRC,  b5g6r5,   null,     b5g6r5,   mmx_composite_copy_area           ),
     PIXMAN_STD_FAST_PATH    (IN,   a8,       null,     a8,       mmx_composite_in_8_8              ),
+    PIXMAN_STD_FAST_PATH    (IN,   solid,    a8,       a8,       mmx_composite_in_n_8_8            ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8,          a8r8g8b8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8,          x8r8g8b8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, x8r8g8b8,          x8r8g8b8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8b8g8r8,          a8b8g8r8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8b8g8r8,          x8b8g8r8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (SRC, x8b8g8r8,          x8b8g8r8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8,         x8r8g8b8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8,         x8b8g8r8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8,         a8r8g8b8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8,         a8b8g8r8, mmx_8888_8888                     ),
+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, mmx_8888_8_8888                   ),
+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, mmx_8888_8_8888                   ),
+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, mmx_8888_8_8888                   ),
-    PIXMAN_STD_FAST_PATH    (IN,   solid,    a8,       a8,       mmx_composite_in_n_8_8            ),
+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, mmx_8888_8_8888                   ),
-    { PIXMAN_OP_NONE },
-};
-static pixman_bool_t
-mmx_blt (pixman_implementation_t *imp,
-         uint32_t *               src_bits,
-         uint32_t *               dst_bits,
-         int                      src_stride,
-         int                      dst_stride,
-         int                      src_bpp,
-         int                      dst_bpp,
-         int                      src_x,
-         int                      src_y,
-         int                      dst_x,
-         int                      dst_y,
-         int                      width,
-         int                      height)
-{
-    if (!pixman_blt_mmx (
-            src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-            src_x, src_y, dst_x, dst_y, width, height))
-    {
-	return _pixman_implementation_blt (
-	    imp->delegate,
-	    src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-	    src_x, src_y, dst_x, dst_y, width, height);
-    }
-    return TRUE;
-}
-static pixman_bool_t
-mmx_fill (pixman_implementation_t *imp,
-          uint32_t *               bits,
-          int                      stride,
-          int                      bpp,
-          int                      x,
-          int                      y,
-          int                      width,
-          int                      height,
-          uint32_t xor)
-{
-    if (!pixman_fill_mmx (bits, stride, bpp, x, y, width, height, xor))
-    {
-	return _pixman_implementation_fill (
-	    imp->delegate, bits, stride, bpp, x, y, width, height, xor);
-    }
-    return TRUE;
+    { PIXMAN_OP_NONE },
-}
+};
-pixman_implementation_t *
-_pixman_implementation_create_mmx (void)
+pixman_implementation_t *
 _pixman_implementation_create_mmx (pixman_implementation_t *fallback)
     pixman_implementation_t *general = _pixman_implementation_create_fast_path ();
-    pixman_implementation_t *imp = _pixman_implementation_create (general, mmx_fast_paths);
+    pixman_implementation_t *imp = _pixman_implementation_create (fallback, mmx_fast_paths);
     imp->combine_32_ca[PIXMAN_OP_ADD] = mmx_combine_add_ca;
     imp->blt = mmx_blt;
+    imp->fill = mmx_fill;
-    imp->fill = mmx_fill;
+    imp->src_iter_init = mmx_src_iter_init;
     return imp;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman-mmx.c – Rev 1891 → 3931