Logo Search packages:      
Sourcecode: xulrunner-1.9 version File versions

pixman-mmx.c

/*
 * Copyright © 2004, 2005 Red Hat, Inc.
 * Copyright © 2004 Nicholas Miell
 * Copyright © 2005 Trolltech AS
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Red Hat not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  Red Hat makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 *
 * Author:  Søren Sandmann (sandmann@redhat.com)
 * Minor Improvements: Nicholas Miell (nmiell@gmail.com)
 * MMX code paths for fbcompose.c by Lars Knoll (lars@trolltech.com)
 *
 * Based on work by Owen Taylor
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef USE_MMX

#include <mmintrin.h>
#ifdef USE_SSE
#include <xmmintrin.h> /* for _mm_shuffle_pi16 and _MM_SHUFFLE */
#endif

#include "pixman-mmx.h"

#undef READ
#undef WRITE
#define READ(img,x) *(x)
#define WRITE(img,ptr,v) (*(ptr) = (v));

#define noVERBOSE

#ifdef VERBOSE
#define CHECKPOINT() ErrorF ("at %s %d\n", __FUNCTION__, __LINE__)
#else
#define CHECKPOINT()
#endif

/* Notes about writing mmx code
 *
 * give memory operands as the second operand. If you give it as the
 * first, gcc will first load it into a register, then use that
 * register
 *
 *   ie. use
 *
 *         _mm_mullo_pi16 (x, mmx_constant);
 *
 *   not
 *
 *         _mm_mullo_pi16 (mmx_constant, x);
 *
 * Also try to minimize dependencies. i.e. when you need a value, try
 * to calculate it from a value that was calculated as early as
 * possible.
 */

/* --------------- MMX primitivess ------------------------------------ */

#ifdef __GNUC__
typedef unsigned long long ullong;
typedef ullong mmxdatafield;
#endif
#ifdef _MSC_VER
typedef unsigned __int64 ullong;
typedef __m64 mmxdatafield;
#endif

typedef struct
{
    mmxdatafield mmx_4x00ff;
    mmxdatafield mmx_4x0080;
    mmxdatafield mmx_565_rgb;
    mmxdatafield mmx_565_unpack_multiplier;
    mmxdatafield mmx_565_r;
    mmxdatafield mmx_565_g;
    mmxdatafield mmx_565_b;
    mmxdatafield mmx_mask_0;
    mmxdatafield mmx_mask_1;
    mmxdatafield mmx_mask_2;
    mmxdatafield mmx_mask_3;
    mmxdatafield mmx_full_alpha;
    mmxdatafield mmx_ffff0000ffff0000;
    mmxdatafield mmx_0000ffff00000000;
    mmxdatafield mmx_000000000000ffff;
} MMXData;

static const MMXData c =
{
#ifdef __GNUC__
    .mmx_4x00ff =             0x00ff00ff00ff00ffULL,
    .mmx_4x0080 =             0x0080008000800080ULL,
    .mmx_565_rgb =                  0x000001f0003f001fULL,
    .mmx_565_unpack_multiplier =    0x0000008404100840ULL,
    .mmx_565_r =              0x000000f800000000ULL,
    .mmx_565_g =              0x0000000000fc0000ULL,
    .mmx_565_b =              0x00000000000000f8ULL,
    .mmx_mask_0 =             0xffffffffffff0000ULL,
    .mmx_mask_1 =             0xffffffff0000ffffULL,
    .mmx_mask_2 =             0xffff0000ffffffffULL,
    .mmx_mask_3 =             0x0000ffffffffffffULL,
    .mmx_full_alpha =               0x00ff000000000000ULL,
    .mmx_ffff0000ffff0000 =         0xffff0000ffff0000ULL,
    .mmx_0000ffff00000000 =         0x0000ffff00000000ULL,
    .mmx_000000000000ffff =         0x000000000000ffffULL,
#endif
#ifdef _MSC_VER
    { 0x00ff00ff00ff00ffUI64 },
    { 0x0080008000800080UI64 },
    { 0x000001f0003f001fUI64 },
    { 0x0000008404100840UI64 },
    { 0x000000f800000000UI64 },
    { 0x0000000000fc0000UI64 },
    { 0x00000000000000f8UI64 },
    { 0xffffffffffff0000UI64 },
    { 0xffffffff0000ffffUI64 },
    { 0xffff0000ffffffffUI64 },
    { 0x0000ffffffffffffUI64 },
    { 0x00ff000000000000UI64 },
    { 0xffff0000ffff0000UI64 },
    { 0x0000ffff00000000UI64 },
    { 0x000000000000ffffUI64 },
#endif
};

#ifdef _MSC_VER
#undef inline
#define inline __forceinline
#endif

#ifdef __GNUC__
#define MC(x) ((__m64) c.mmx_##x)
#endif
#ifdef _MSC_VER
#define MC(x) c.mmx_##x
#endif

static inline __m64
M64 (ullong x)
{
#ifdef __GNUC__
    return (__m64)x;
#endif

#ifdef _MSC_VER
    __m64 res;
    
    res.m64_u64 = x;
    return res;
#endif
}

static inline ullong
ULLONG (__m64 x)
{
#ifdef __GNUC__
    return (ullong)x;
#endif

#ifdef _MSC_VER
    ullong res;

    res = x.m64_u64;
    return res;
#endif
}

static inline __m64
shift (__m64 v, int s)
{
    if (s > 0)
      return _mm_slli_si64 (v, s);
    else if (s < 0)
      return _mm_srli_si64 (v, -s);
    else
      return v;
}

static inline __m64
negate (__m64 mask)
{
    return _mm_xor_si64 (mask, MC(4x00ff));
}

static inline __m64
pix_multiply (__m64 a, __m64 b)
{
    __m64 res;

    res = _mm_mullo_pi16 (a, b);
    res = _mm_adds_pu16 (res, MC(4x0080));
    res = _mm_adds_pu16 (res, _mm_srli_pi16 (res, 8));
    res = _mm_srli_pi16 (res, 8);

    return res;
}

static inline __m64
pix_add (__m64 a, __m64 b)
{
    return  _mm_adds_pu8 (a, b);
}

#ifdef USE_SSE

static inline __m64
expand_alpha (__m64 pixel)
{
    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE(3, 3, 3, 3));
}

static inline __m64
expand_alpha_rev (__m64 pixel)
{
    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE(0, 0, 0, 0));
}

static inline __m64
invert_colors (__m64 pixel)
{
    return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE(3, 0, 1, 2));
}

#else

static 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;
}

static inline __m64
expand_alpha_rev (__m64 pixel)
{
    __m64 t1, t2;

    /* 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;
}

static inline __m64
invert_colors (__m64 pixel)
{
    __m64 x, y, z;

    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);

    return x;
}

#endif

static inline __m64
over (__m64 src, __m64 srca, __m64 dest)
{
    return  _mm_adds_pu8 (src, pix_multiply(dest, negate(srca)));
}

static inline __m64
over_rev_non_pre (__m64 src, __m64 dest)
{
    __m64 srca = expand_alpha (src);
    __m64 srcfaaa = _mm_or_si64 (srca, MC(full_alpha));

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

static inline __m64
in (__m64 src,
    __m64 mask)
{
    return pix_multiply (src, mask);
}

static 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 inline __m64
in_over (__m64 src,
       __m64 srca,
       __m64 mask,
       __m64 dest)
{
    return over(in(src, mask), pix_multiply(srca, mask), dest);
}
#else
#define in_over(src, srca, mask, dest) over(in(src, mask), pix_multiply(srca, mask), dest)
#endif

static inline __m64
load8888 (uint32_t v)
{
    return _mm_unpacklo_pi8 (_mm_cvtsi32_si64 (v), _mm_setzero_si64());
}

static inline __m64
pack8888 (__m64 lo, __m64 hi)
{
    return _mm_packs_pu16 (lo, hi);
}

static inline uint32_t
store8888 (__m64 v)
{
    return _mm_cvtsi64_si32(pack8888(v, _mm_setzero_si64()));
}

/* Expand 16 bits positioned at @pos (0-3) of a mmx register into
 *
 *    00RR00GG00BB
 *
 * --- Expanding 565 in the low word ---
 *
 * m = (m << (32 - 3)) | (m << (16 - 5)) | m;
 * m = m & (01f0003f001f);
 * m = m * (008404100840);
 * m = m >> 8;
 *
 * Note the trick here - the top word is shifted by another nibble to
 * avoid it bumping into the middle word
 */
static inline __m64
expand565 (__m64 pixel, int pos)
{
    __m64 p = pixel;
    __m64 t1, t2;

    /* move pixel to low 16 bit and zero the rest */
    p = shift (shift (p, (3 - pos) * 16), -48);

    t1 = shift (p, 36 - 11);
    t2 = shift (p, 16 - 5);

    p = _mm_or_si64 (t1, p);
    p = _mm_or_si64 (t2, p);
    p = _mm_and_si64 (p, MC(565_rgb));

    pixel = _mm_mullo_pi16 (p, MC(565_unpack_multiplier));
    return _mm_srli_pi16 (pixel, 8);
}

static inline __m64
expand8888 (__m64 in, int pos)
{
    if (pos == 0)
      return _mm_unpacklo_pi8 (in, _mm_setzero_si64());
    else
      return _mm_unpackhi_pi8 (in, _mm_setzero_si64());
}

static inline __m64
pack565 (__m64 pixel, __m64 target, int pos)
{
    __m64 p = pixel;
    __m64 t = target;
    __m64 r, g, b;

    r = _mm_and_si64 (p, MC(565_r));
    g = _mm_and_si64 (p, MC(565_g));
    b = _mm_and_si64 (p, MC(565_b));

    r = shift (r, - (32 - 8) + pos * 16);
    g = shift (g, - (16 - 3) + pos * 16);
    b = shift (b, - (0  + 3) + pos * 16);

    if (pos == 0)
      t = _mm_and_si64 (t, MC(mask_0));
    else if (pos == 1)
      t = _mm_and_si64 (t, MC(mask_1));
    else if (pos == 2)
      t = _mm_and_si64 (t, MC(mask_2));
    else if (pos == 3)
      t = _mm_and_si64 (t, MC(mask_3));

    p = _mm_or_si64 (r, t);
    p = _mm_or_si64 (g, p);

    return _mm_or_si64 (b, p);
}

#ifndef _MSC_VER
static inline __m64
pix_add_mul (__m64 x, __m64 a, __m64 y, __m64 b)
{
    x = _mm_mullo_pi16 (x, a);
    y = _mm_mullo_pi16 (y, b);
    x = _mm_adds_pu16 (x, MC(4x0080));
    x = _mm_adds_pu16 (x, y);
    x = _mm_adds_pu16 (x, _mm_srli_pi16 (x, 8));
    x = _mm_srli_pi16 (x, 8);

    return x;
}
#else
#define pix_add_mul(x, a, y, b) \
( x = _mm_mullo_pi16 (x, a), \
  y = _mm_mullo_pi16 (y, b), \
  x = _mm_adds_pu16 (x, MC(4x0080)), \
  x = _mm_adds_pu16 (x, y), \
  x = _mm_adds_pu16 (x, _mm_srli_pi16 (x, 8)), \
  _mm_srli_pi16 (x, 8) )
#endif

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

static FASTCALL void
mmxCombineMaskU (uint32_t *src, const uint32_t *mask, int width)
{
    const uint32_t *end = mask + width;
    while (mask < end) {
        uint32_t mmask = *mask;
      uint32_t maska = mmask >> 24;
      if (maska == 0) {
          *src = 0;
      } else if (maska != 0xff) {
          __m64 a = load8888(mmask);
          __m64 s = load8888(*src);
          a = expand_alpha(a);
          s = pix_multiply(s, a);
          *src = store8888(s);
      }
      ++src;
      ++mask;
    }
    _mm_empty();
}


static FASTCALL void
mmxCombineOverU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
      uint32_t ssrc = *src;
      uint32_t a = ssrc >> 24;
      if (a == 0xff) {
          *dest = ssrc;
      } else if (a) {
          __m64 s, sa;
          s = load8888(ssrc);
          sa = expand_alpha(s);
          *dest = store8888(over(s, sa, load8888(*dest)));
      }
      ++dest;
      ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOverReverseU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
      __m64 d, da;
      d = load8888(*dest);
      da = expand_alpha(d);
      *dest = store8888(over (d, da, load8888(*src)));
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineInU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 x, a;
        x = load8888(*src);
        a = load8888(*dest);
        a = expand_alpha(a);
        x = pix_multiply(x, a);
        *dest = store8888(x);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineInReverseU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 x, a;
        x = load8888(*dest);
        a = load8888(*src);
        a = expand_alpha(a);
        x = pix_multiply(x, a);
        *dest = store8888(x);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOutU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 x, a;
        x = load8888(*src);
        a = load8888(*dest);
        a = expand_alpha(a);
        a = negate(a);
        x = pix_multiply(x, a);
        *dest = store8888(x);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOutReverseU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 x, a;
        x = load8888(*dest);
        a = load8888(*src);
        a = expand_alpha(a);
        a = negate(a);
        x = pix_multiply(x, a);
        *dest = store8888(x);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAtopU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 s, da, d, sia;
        s = load8888(*src);
        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);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAtopReverseU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end;

    end = dest + width;

    while (dest < end) {
        __m64 s, dia, d, sa;
        s = load8888(*src);
        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);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineXorU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;

    while (dest < end) {
        __m64 s, dia, d, sia;
        s = load8888(*src);
        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);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAddU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;
    while (dest < end) {
        __m64 s, d;
        s = load8888(*src);
        d = load8888(*dest);
        s = pix_add(s, d);
        *dest = store8888(s);
        ++dest;
        ++src;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineSaturateU (uint32_t *dest, const uint32_t *src, int width)
{
    const uint32_t *end = dest + width;
    while (dest < end) {
        uint32_t s = *src;
        uint32_t d = *dest;
        __m64 ms = load8888(s);
        __m64 md = load8888(d);
        uint32_t sa = s >> 24;
        uint32_t da = ~d >> 24;

        if (sa > da) {
            __m64 msa = load8888(FbIntDiv(da, sa) << 24);
            msa = expand_alpha(msa);
            ms = pix_multiply(ms, msa);
        }
        md = pix_add(md, ms);
        *dest = store8888(md);
        ++src;
        ++dest;
    }
    _mm_empty();
}


static FASTCALL void
mmxCombineSrcC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        s = pix_multiply(s, a);
        *dest = store8888(s);
        ++src;
        ++mask;
        ++dest;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOverC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __m64 d = load8888(*dest);
        __m64 sa = expand_alpha(s);

      *dest = store8888(in_over (s, sa, a, d));

        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOverReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __m64 d = load8888(*dest);
        __m64 da = expand_alpha(d);

      *dest = store8888(over (d, da, in (s, a)));

        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}


static FASTCALL void
mmxCombineInC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __m64 d = load8888(*dest);
        __m64 da = expand_alpha(d);
        s = pix_multiply(s, a);
        s = pix_multiply(s, da);
        *dest = store8888(s);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineInReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __m64 d = load8888(*dest);
        __m64 sa = expand_alpha(s);
        a = pix_multiply(a, sa);
        d = pix_multiply(d, a);
        *dest = store8888(d);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOutC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __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);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineOutReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __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);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAtopC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __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);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAtopReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __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);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineXorC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __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);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

static FASTCALL void
mmxCombineAddC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
    const uint32_t *end = src + width;
    while (src < end) {
        __m64 a = load8888(*mask);
        __m64 s = load8888(*src);
        __m64 d = load8888(*dest);
        s = pix_multiply(s, a);
        d = pix_add(s, d);
        *dest = store8888(d);
        ++src;
        ++dest;
        ++mask;
    }
    _mm_empty();
}

void
fbComposeSetupMMX(void)
{
    static pixman_bool_t initialized = FALSE;

    if (initialized)
      return;
    
    /* check if we have MMX support and initialize accordingly */
    if (pixman_have_mmx())
    {
        pixman_composeFunctions.combineU[PIXMAN_OP_OVER] = mmxCombineOverU;
        pixman_composeFunctions.combineU[PIXMAN_OP_OVER_REVERSE] = mmxCombineOverReverseU;
        pixman_composeFunctions.combineU[PIXMAN_OP_IN] = mmxCombineInU;
        pixman_composeFunctions.combineU[PIXMAN_OP_IN_REVERSE] = mmxCombineInReverseU;
        pixman_composeFunctions.combineU[PIXMAN_OP_OUT] = mmxCombineOutU;
        pixman_composeFunctions.combineU[PIXMAN_OP_OUT_REVERSE] = mmxCombineOutReverseU;
        pixman_composeFunctions.combineU[PIXMAN_OP_ATOP] = mmxCombineAtopU;
        pixman_composeFunctions.combineU[PIXMAN_OP_ATOP_REVERSE] = mmxCombineAtopReverseU;
        pixman_composeFunctions.combineU[PIXMAN_OP_XOR] = mmxCombineXorU;
        pixman_composeFunctions.combineU[PIXMAN_OP_ADD] = mmxCombineAddU;
        pixman_composeFunctions.combineU[PIXMAN_OP_SATURATE] = mmxCombineSaturateU;

        pixman_composeFunctions.combineC[PIXMAN_OP_SRC] = mmxCombineSrcC;
        pixman_composeFunctions.combineC[PIXMAN_OP_OVER] = mmxCombineOverC;
        pixman_composeFunctions.combineC[PIXMAN_OP_OVER_REVERSE] = mmxCombineOverReverseC;
        pixman_composeFunctions.combineC[PIXMAN_OP_IN] = mmxCombineInC;
        pixman_composeFunctions.combineC[PIXMAN_OP_IN_REVERSE] = mmxCombineInReverseC;
        pixman_composeFunctions.combineC[PIXMAN_OP_OUT] = mmxCombineOutC;
        pixman_composeFunctions.combineC[PIXMAN_OP_OUT_REVERSE] = mmxCombineOutReverseC;
        pixman_composeFunctions.combineC[PIXMAN_OP_ATOP] = mmxCombineAtopC;
        pixman_composeFunctions.combineC[PIXMAN_OP_ATOP_REVERSE] = mmxCombineAtopReverseC;
        pixman_composeFunctions.combineC[PIXMAN_OP_XOR] = mmxCombineXorC;
        pixman_composeFunctions.combineC[PIXMAN_OP_ADD] = mmxCombineAddC;

        pixman_composeFunctions.combineMaskU = mmxCombineMaskU;
    }

    initialized = TRUE;
}


/* ------------------ MMX code paths called from fbpict.c ----------------------- */

void
fbCompositeSolid_nx8888mmx (pixman_op_t op,
                      pixman_image_t * pSrc,
                      pixman_image_t * pMask,
                      pixman_image_t * pDst,
                      int16_t xSrc,
                      int16_t ySrc,
                      int16_t xMask,
                      int16_t yMask,
                      int16_t xDst,
                      int16_t yDst,
                      uint16_t      width,
                      uint16_t      height)
{
    uint32_t      src;
    uint32_t      *dstLine, *dst;
    uint16_t      w;
    int     dstStride;
    __m64   vsrc, vsrca;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    if (src >> 24 == 0)
      return;

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          *dst = store8888(over(vsrc, vsrca, load8888(*dst)));

          w--;
          dst++;
      }

      while (w >= 2)
      {
          __m64 vdest;
          __m64 dest0, dest1;

          vdest = *(__m64 *)dst;

          dest0 = over(vsrc, vsrca, expand8888(vdest, 0));
          dest1 = over(vsrc, vsrca, expand8888(vdest, 1));

          *(__m64 *)dst = pack8888(dest0, dest1);

          dst += 2;
          w -= 2;
      }

      CHECKPOINT();

      while (w)
      {
          *dst = store8888(over(vsrc, vsrca, load8888(*dst)));

          w--;
          dst++;
      }
    }

    _mm_empty();
}

void
fbCompositeSolid_nx0565mmx (pixman_op_t op,
                      pixman_image_t * pSrc,
                      pixman_image_t * pMask,
                      pixman_image_t * pDst,
                      int16_t xSrc,
                      int16_t ySrc,
                      int16_t xMask,
                      int16_t yMask,
                      int16_t xDst,
                      int16_t yDst,
                      uint16_t      width,
                      uint16_t      height)
{
    uint32_t      src;
    uint16_t      *dstLine, *dst;
    uint16_t      w;
    int     dstStride;
    __m64   vsrc, vsrca;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    if (src >> 24 == 0)
      return;

    fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);
          vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
          *dst = ULLONG(vdest);

          w--;
          dst++;
      }

      while (w >= 4)
      {
          __m64 vdest;

          vdest = *(__m64 *)dst;

          vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 0)), vdest, 0);
          vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 1)), vdest, 1);
          vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 2)), vdest, 2);
          vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 3)), vdest, 3);

          *(__m64 *)dst = vdest;

          dst += 4;
          w -= 4;
      }

      CHECKPOINT();

      while (w)
      {
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);
          vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
          *dst = ULLONG(vdest);

          w--;
          dst++;
      }
    }

    _mm_empty();
}

void
fbCompositeSolidMask_nx8888x8888Cmmx (pixman_op_t op,
                              pixman_image_t * pSrc,
                              pixman_image_t * pMask,
                              pixman_image_t * pDst,
                              int16_t     xSrc,
                              int16_t     ySrc,
                              int16_t     xMask,
                              int16_t     yMask,
                              int16_t     xDst,
                              int16_t     yDst,
                              uint16_t    width,
                              uint16_t    height)
{
    uint32_t      src, srca;
    uint32_t      *dstLine;
    uint32_t      *maskLine;
    int     dstStride, maskStride;
    __m64   vsrc, vsrca;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    srca = src >> 24;
    if (srca == 0)
      return;

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);

    vsrc = load8888(src);
    vsrca = expand_alpha(vsrc);

    while (height--)
    {
      int twidth = width;
      uint32_t *p = (uint32_t *)maskLine;
      uint32_t *q = (uint32_t *)dstLine;

      while (twidth && (unsigned long)q & 7)
      {
          uint32_t m = *(uint32_t *)p;

          if (m)
          {
            __m64 vdest = load8888(*q);
            vdest = in_over(vsrc, vsrca, load8888(m), vdest);
            *q = store8888(vdest);
          }

          twidth--;
          p++;
          q++;
      }

      while (twidth >= 2)
      {
          uint32_t m0, m1;
          m0 = *p;
          m1 = *(p + 1);

          if (m0 | m1)
          {
            __m64 dest0, dest1;
            __m64 vdest = *(__m64 *)q;

            dest0 = in_over(vsrc, vsrca, load8888(m0),
                        expand8888 (vdest, 0));
            dest1 = in_over(vsrc, vsrca, load8888(m1),
                        expand8888 (vdest, 1));

            *(__m64 *)q = pack8888(dest0, dest1);
          }

          p += 2;
          q += 2;
          twidth -= 2;
      }

      while (twidth)
      {
          uint32_t m = *(uint32_t *)p;

          if (m)
          {
            __m64 vdest = load8888(*q);
            vdest = in_over(vsrc, vsrca, load8888(m), vdest);
            *q = store8888(vdest);
          }

          twidth--;
          p++;
          q++;
      }

      dstLine += dstStride;
      maskLine += maskStride;
    }

    _mm_empty();
}

void
fbCompositeSrc_8888x8x8888mmx (pixman_op_t op,
                         pixman_image_t * pSrc,
                         pixman_image_t * pMask,
                         pixman_image_t * pDst,
                         int16_t    xSrc,
                         int16_t    ySrc,
                         int16_t      xMask,
                         int16_t      yMask,
                         int16_t      xDst,
                         int16_t      yDst,
                         uint16_t     width,
                         uint16_t     height)
{
    uint32_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    uint32_t      mask;
    __m64   vmask;
    int     dstStride, srcStride;
    uint16_t      w;
    __m64  srca;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

    fbComposeGetSolid (pMask, mask, pDst->bits.format);
    mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
    vmask = load8888 (mask);
    srca = MC(4x00ff);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w && (unsigned long)dst & 7)
      {
          __m64 s = load8888 (*src);
          __m64 d = load8888 (*dst);

          *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));

          w--;
          dst++;
          src++;
      }

      while (w >= 2)
      {
          __m64 vs = *(__m64 *)src;
          __m64 vd = *(__m64 *)dst;
          __m64 vsrc0 = expand8888 (vs, 0);
          __m64 vsrc1 = expand8888 (vs, 1);

          *(__m64 *)dst = pack8888 (
            in_over (vsrc0, expand_alpha (vsrc0), vmask, expand8888 (vd, 0)),
            in_over (vsrc1, expand_alpha (vsrc1), vmask, expand8888 (vd, 1)));

          w -= 2;
          dst += 2;
          src += 2;
      }

      while (w)
      {
          __m64 s = load8888 (*src);
          __m64 d = load8888 (*dst);

          *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));

          w--;
          dst++;
          src++;
      }
    }

    _mm_empty();
}

void
fbCompositeSrc_x888xnx8888mmx (pixman_op_t op,
                         pixman_image_t * pSrc,
                         pixman_image_t * pMask,
                         pixman_image_t * pDst,
                         int16_t    xSrc,
                         int16_t    ySrc,
                         int16_t      xMask,
                         int16_t      yMask,
                         int16_t      xDst,
                         int16_t      yDst,
                         uint16_t     width,
                         uint16_t     height)
{
    uint32_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    uint32_t      mask;
    __m64   vmask;
    int     dstStride, srcStride;
    uint16_t      w;
    __m64  srca;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
    fbComposeGetSolid (pMask, mask, pDst->bits.format);

    mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
    vmask = load8888 (mask);
    srca = MC(4x00ff);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w && (unsigned long)dst & 7)
      {
          __m64 s = load8888 (*src | 0xff000000);
          __m64 d = load8888 (*dst);

          *dst = store8888 (in_over (s, srca, vmask, d));

          w--;
          dst++;
          src++;
      }

      while (w >= 16)
      {
          __m64 vd0 = *(__m64 *)(dst + 0);
          __m64 vd1 = *(__m64 *)(dst + 2);
          __m64 vd2 = *(__m64 *)(dst + 4);
          __m64 vd3 = *(__m64 *)(dst + 6);
          __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 vs1 = *(__m64 *)(src + 2);
          __m64 vs2 = *(__m64 *)(src + 4);
          __m64 vs3 = *(__m64 *)(src + 6);
          __m64 vs4 = *(__m64 *)(src + 8);
          __m64 vs5 = *(__m64 *)(src + 10);
          __m64 vs6 = *(__m64 *)(src + 12);
          __m64 vs7 = *(__m64 *)(src + 14);

          vd0 = pack8888 (
            in_over (expand8888 (vs0, 0), srca, vmask, expand8888 (vd0, 0)),
            in_over (expand8888 (vs0, 1), srca, vmask, expand8888 (vd0, 1)));

          vd1 = pack8888 (
            in_over (expand8888 (vs1, 0), srca, vmask, expand8888 (vd1, 0)),
            in_over (expand8888 (vs1, 1), srca, vmask, expand8888 (vd1, 1)));

          vd2 = pack8888 (
            in_over (expand8888 (vs2, 0), srca, vmask, expand8888 (vd2, 0)),
            in_over (expand8888 (vs2, 1), srca, vmask, expand8888 (vd2, 1)));

          vd3 = pack8888 (
            in_over (expand8888 (vs3, 0), srca, vmask, expand8888 (vd3, 0)),
            in_over (expand8888 (vs3, 1), srca, vmask, expand8888 (vd3, 1)));

          vd4 = pack8888 (
            in_over (expand8888 (vs4, 0), srca, vmask, expand8888 (vd4, 0)),
            in_over (expand8888 (vs4, 1), srca, vmask, expand8888 (vd4, 1)));

          vd5 = pack8888 (
            in_over (expand8888 (vs5, 0), srca, vmask, expand8888 (vd5, 0)),
            in_over (expand8888 (vs5, 1), srca, vmask, expand8888 (vd5, 1)));

            vd6 = pack8888 (
            in_over (expand8888 (vs6, 0), srca, vmask, expand8888 (vd6, 0)),
            in_over (expand8888 (vs6, 1), srca, vmask, expand8888 (vd6, 1)));

          vd7 = pack8888 (
            in_over (expand8888 (vs7, 0), srca, vmask, expand8888 (vd7, 0)),
            in_over (expand8888 (vs7, 1), srca, vmask, expand8888 (vd7, 1)));

          *(__m64 *)(dst + 0) = vd0;
          *(__m64 *)(dst + 2) = vd1;
          *(__m64 *)(dst + 4) = vd2;
          *(__m64 *)(dst + 6) = vd3;
          *(__m64 *)(dst + 8) = vd4;
          *(__m64 *)(dst + 10) = vd5;
          *(__m64 *)(dst + 12) = vd6;
          *(__m64 *)(dst + 14) = vd7;

          w -= 16;
          dst += 16;
          src += 16;
      }

      while (w)
      {
          __m64 s = load8888 (*src | 0xff000000);
          __m64 d = load8888 (*dst);

          *dst = store8888 (in_over (s, srca, vmask, d));

          w--;
          dst++;
          src++;
      }
    }

    _mm_empty();
}

void
fbCompositeSrc_8888x8888mmx (pixman_op_t op,
                       pixman_image_t * pSrc,
                       pixman_image_t * pMask,
                       pixman_image_t * pDst,
                       int16_t      xSrc,
                       int16_t      ySrc,
                       int16_t      xMask,
                       int16_t      yMask,
                       int16_t      xDst,
                       int16_t      yDst,
                       uint16_t     width,
                       uint16_t     height)
{
    uint32_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    uint32_t    s;
    int     dstStride, srcStride;
    uint8_t     a;
    uint16_t      w;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w--)
      {
          s = *src++;
          a = s >> 24;
          if (a == 0xff)
            *dst = s;
          else if (a) {
            __m64 ms, sa;
            ms = load8888(s);
            sa = expand_alpha(ms);
            *dst = store8888(over(ms, sa, load8888(*dst)));
          }
          dst++;
      }
    }
    _mm_empty();
}

void
fbCompositeSrc_8888x0565mmx (pixman_op_t op,
                       pixman_image_t * pSrc,
                       pixman_image_t * pMask,
                       pixman_image_t * pDst,
                       int16_t      xSrc,
                       int16_t      ySrc,
                       int16_t      xMask,
                       int16_t      yMask,
                       int16_t      xDst,
                       int16_t      yDst,
                       uint16_t     width,
                       uint16_t     height)
{
    uint16_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    int     dstStride, srcStride;
    uint16_t      w;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

#if 0
    /* FIXME */
    assert (pSrc->pDrawable == pMask->pDrawable);
#endif

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          __m64 vsrc = load8888 (*src);
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);

          vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);

          *dst = ULLONG(vdest);

          w--;
          dst++;
          src++;
      }

      CHECKPOINT();

      while (w >= 4)
      {
          __m64 vsrc0, vsrc1, vsrc2, vsrc3;
          __m64 vdest;

          vsrc0 = load8888(*(src + 0));
          vsrc1 = load8888(*(src + 1));
          vsrc2 = load8888(*(src + 2));
          vsrc3 = load8888(*(src + 3));

          vdest = *(__m64 *)dst;

          vdest = pack565(over(vsrc0, expand_alpha(vsrc0), expand565(vdest, 0)), vdest, 0);
          vdest = pack565(over(vsrc1, expand_alpha(vsrc1), expand565(vdest, 1)), vdest, 1);
          vdest = pack565(over(vsrc2, expand_alpha(vsrc2), expand565(vdest, 2)), vdest, 2);
          vdest = pack565(over(vsrc3, expand_alpha(vsrc3), expand565(vdest, 3)), vdest, 3);

          *(__m64 *)dst = vdest;

          w -= 4;
          dst += 4;
          src += 4;
      }

      CHECKPOINT();

      while (w)
      {
          __m64 vsrc = load8888 (*src);
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);

          vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);

          *dst = ULLONG(vdest);

          w--;
          dst++;
          src++;
      }
    }

    _mm_empty();
}

void
fbCompositeSolidMask_nx8x8888mmx (pixman_op_t op,
                          pixman_image_t * pSrc,
                          pixman_image_t * pMask,
                          pixman_image_t * pDst,
                          int16_t      xSrc,
                          int16_t      ySrc,
                          int16_t      xMask,
                          int16_t      yMask,
                          int16_t      xDst,
                          int16_t      yDst,
                          uint16_t     width,
                          uint16_t     height)
{
    uint32_t      src, srca;
    uint32_t      *dstLine, *dst;
    uint8_t *maskLine, *mask;
    int     dstStride, maskStride;
    uint16_t      w;
    __m64   vsrc, vsrca;
    ullong  srcsrc;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    srca = src >> 24;
    if (srca == 0)
      return;

    srcsrc = (ullong)src << 32 | src;

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          ullong m = *mask;

          if (m)
          {
            __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), load8888(*dst));
            *dst = store8888(vdest);
          }

          w--;
          mask++;
          dst++;
      }

      CHECKPOINT();

      while (w >= 2)
      {
          ullong m0, m1;
          m0 = *mask;
          m1 = *(mask + 1);

          if (srca == 0xff && (m0 & m1) == 0xff)
          {
            *(ullong *)dst = srcsrc;
          }
          else if (m0 | m1)
          {
            __m64 vdest;
            __m64 dest0, dest1;

            vdest = *(__m64 *)dst;

            dest0 = in_over(vsrc, vsrca, expand_alpha_rev (M64(m0)), expand8888(vdest, 0));
            dest1 = in_over(vsrc, vsrca, expand_alpha_rev (M64(m1)), expand8888(vdest, 1));

            *(__m64 *)dst = pack8888(dest0, dest1);
          }

          mask += 2;
          dst += 2;
          w -= 2;
      }

      CHECKPOINT();

      while (w)
      {
          ullong m = *mask;

          if (m)
          {
            __m64 vdest = load8888(*dst);
            vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), vdest);
            *dst = store8888(vdest);
          }

          w--;
          mask++;
          dst++;
      }
    }

    _mm_empty();
}

pixman_bool_t
pixman_fill_mmx (uint32_t *bits,
             int stride,
             int bpp,
             int x,
             int y,
             int width,
             int height,
             uint32_t xor)
{
    ullong  fill;
    __m64   vfill;
    uint32_t      byte_width;
    uint8_t *byte_line;
#ifdef __GNUC__
    __m64   v1, v2, v3, v4, v5, v6, v7;
#endif

    if (bpp == 16 && (xor >> 16 != (xor & 0xffff)))
      return FALSE;

    if (bpp != 16 && bpp != 32)
      return FALSE;

    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;
    }
    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 = ((ullong)xor << 32) | xor;
    vfill = M64(fill);

#ifdef __GNUC__
    __asm__ (
      "movq       %7,   %0\n"
      "movq       %7,   %1\n"
      "movq       %7,   %2\n"
      "movq       %7,   %3\n"
      "movq       %7,   %4\n"
      "movq       %7,   %5\n"
      "movq       %7,   %6\n"
      : "=y" (v1), "=y" (v2), "=y" (v3),
        "=y" (v4), "=y" (v5), "=y" (v6), "=y" (v7)
      : "y" (vfill));
#endif

    while (height--)
    {
      int w;
      uint8_t *d = byte_line;
      byte_line += stride;
      w = byte_width;

      while (w >= 2 && ((unsigned long)d & 3))
      {
          *(uint16_t *)d = xor;
          w -= 2;
          d += 2;
      }

      while (w >= 4 && ((unsigned long)d & 7))
      {
          *(uint32_t *)d = xor;

          w -= 4;
          d += 4;
      }

      while (w >= 64)
      {
#ifdef __GNUC__
          __asm__ (
            "movq %1,     (%0)\n"
            "movq %2,    8(%0)\n"
            "movq %3,   16(%0)\n"
            "movq %4,   24(%0)\n"
            "movq %5,   32(%0)\n"
            "movq %6,   40(%0)\n"
            "movq %7,   48(%0)\n"
            "movq %8,   56(%0)\n"
            :
            : "r" (d),
              "y" (vfill), "y" (v1), "y" (v2), "y" (v3),
              "y" (v4), "y" (v5), "y" (v6), "y" (v7)
            : "memory");
#else
          *(__m64*) (d +  0) = vfill;
          *(__m64*) (d +  8) = vfill;
          *(__m64*) (d + 16) = vfill;
          *(__m64*) (d + 24) = vfill;
          *(__m64*) (d + 32) = vfill;
          *(__m64*) (d + 40) = vfill;
          *(__m64*) (d + 48) = vfill;
          *(__m64*) (d + 56) = vfill;
#endif
          w -= 64;
          d += 64;
      }

      while (w >= 4)
      {
          *(uint32_t *)d = xor;

          w -= 4;
          d += 4;
      }
      if (w >= 2)
      {
          *(uint16_t *)d = xor;
          w -= 2;
          d += 2;
      }
    }

    _mm_empty();
    return TRUE;
}

void
fbCompositeSolidMaskSrc_nx8x8888mmx (pixman_op_t op,
                             pixman_image_t * pSrc,
                             pixman_image_t * pMask,
                             pixman_image_t * pDst,
                             int16_t      xSrc,
                             int16_t      ySrc,
                             int16_t      xMask,
                             int16_t      yMask,
                             int16_t      xDst,
                             int16_t      yDst,
                             uint16_t     width,
                             uint16_t     height)
{
    uint32_t      src, srca;
    uint32_t      *dstLine, *dst;
    uint8_t *maskLine, *mask;
    int     dstStride, maskStride;
    uint16_t      w;
    __m64   vsrc, vsrca;
    ullong  srcsrc;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    srca = src >> 24;
    if (srca == 0)
    {
      pixman_fill_mmx (pDst->bits.bits, pDst->bits.rowstride, PIXMAN_FORMAT_BPP (pDst->bits.format),
                   xDst, yDst, width, height, 0);
      return;
    }

    srcsrc = (ullong)src << 32 | src;

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          ullong m = *mask;

          if (m)
          {
            __m64 vdest = in(vsrc, expand_alpha_rev (M64(m)));
            *dst = store8888(vdest);
          }
          else
          {
            *dst = 0;
          }

          w--;
          mask++;
          dst++;
      }

      CHECKPOINT();

      while (w >= 2)
      {
          ullong m0, m1;
          m0 = *mask;
          m1 = *(mask + 1);

          if (srca == 0xff && (m0 & m1) == 0xff)
          {
            *(ullong *)dst = srcsrc;
          }
          else if (m0 | m1)
          {
            __m64 vdest;
            __m64 dest0, dest1;

            vdest = *(__m64 *)dst;

            dest0 = in(vsrc, expand_alpha_rev (M64(m0)));
            dest1 = in(vsrc, expand_alpha_rev (M64(m1)));

            *(__m64 *)dst = pack8888(dest0, dest1);
          }
          else
          {
            *(ullong *)dst = 0;
          }

          mask += 2;
          dst += 2;
          w -= 2;
      }

      CHECKPOINT();

      while (w)
      {
          ullong m = *mask;

          if (m)
          {
            __m64 vdest = load8888(*dst);
            vdest = in(vsrc, expand_alpha_rev (M64(m)));
            *dst = store8888(vdest);
          }
          else
          {
            *dst = 0;
          }

          w--;
          mask++;
          dst++;
      }
    }

    _mm_empty();
}

void
fbCompositeSolidMask_nx8x0565mmx (pixman_op_t op,
                          pixman_image_t * pSrc,
                          pixman_image_t * pMask,
                          pixman_image_t * pDst,
                          int16_t      xSrc,
                          int16_t      ySrc,
                          int16_t      xMask,
                          int16_t      yMask,
                          int16_t      xDst,
                          int16_t      yDst,
                          uint16_t     width,
                          uint16_t     height)
{
    uint32_t      src, srca;
    uint16_t      *dstLine, *dst;
    uint8_t *maskLine, *mask;
    int     dstStride, maskStride;
    uint16_t      w;
    __m64   vsrc, vsrca, tmp;
    ullong srcsrcsrcsrc, src16;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    srca = src >> 24;
    if (srca == 0)
      return;

    fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    tmp = pack565(vsrc, _mm_setzero_si64(), 0);
    src16 = ULLONG(tmp);

    srcsrcsrcsrc = (ullong)src16 << 48 | (ullong)src16 << 32 |
      (ullong)src16 << 16 | (ullong)src16;

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          ullong m = *mask;

          if (m)
          {
            ullong d = *dst;
            __m64 vd = M64(d);
            __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64 (m)), expand565(vd, 0));
            vd = pack565(vdest, _mm_setzero_si64(), 0);
            *dst = ULLONG(vd);
          }

          w--;
          mask++;
          dst++;
      }

      CHECKPOINT();

      while (w >= 4)
      {
          ullong m0, m1, m2, m3;
          m0 = *mask;
          m1 = *(mask + 1);
          m2 = *(mask + 2);
          m3 = *(mask + 3);

          if (srca == 0xff && (m0 & m1 & m2 & m3) == 0xff)
          {
            *(ullong *)dst = srcsrcsrcsrc;
          }
          else if (m0 | m1 | m2 | m3)
          {
            __m64 vdest;
            __m64 vm0, vm1, vm2, vm3;

            vdest = *(__m64 *)dst;

            vm0 = M64(m0);
            vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm0), expand565(vdest, 0)), vdest, 0);
            vm1 = M64(m1);
            vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm1), expand565(vdest, 1)), vdest, 1);
            vm2 = M64(m2);
            vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm2), expand565(vdest, 2)), vdest, 2);
            vm3 = M64(m3);
            vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm3), expand565(vdest, 3)), vdest, 3);

            *(__m64 *)dst = vdest;
          }

          w -= 4;
          mask += 4;
          dst += 4;
      }

      CHECKPOINT();

      while (w)
      {
          ullong m = *mask;

          if (m)
          {
            ullong d = *dst;
            __m64 vd = M64(d);
            __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), expand565(vd, 0));
            vd = pack565(vdest, _mm_setzero_si64(), 0);
            *dst = ULLONG(vd);
          }

          w--;
          mask++;
          dst++;
      }
    }

    _mm_empty();
}

void
fbCompositeSrc_8888RevNPx0565mmx (pixman_op_t op,
                          pixman_image_t * pSrc,
                          pixman_image_t * pMask,
                          pixman_image_t * pDst,
                          int16_t      xSrc,
                          int16_t      ySrc,
                          int16_t      xMask,
                          int16_t      yMask,
                          int16_t      xDst,
                          int16_t      yDst,
                          uint16_t     width,
                          uint16_t     height)
{
    uint16_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    int     dstStride, srcStride;
    uint16_t      w;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

#if 0
    /* FIXME */
    assert (pSrc->pDrawable == pMask->pDrawable);
#endif

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      CHECKPOINT();

      while (w && (unsigned long)dst & 7)
      {
          __m64 vsrc = load8888 (*src);
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);

          vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);

          *dst = ULLONG(vdest);

          w--;
          dst++;
          src++;
      }

      CHECKPOINT();

      while (w >= 4)
      {
          uint32_t s0, s1, s2, s3;
          unsigned char a0, a1, a2, a3;

          s0 = *src;
          s1 = *(src + 1);
          s2 = *(src + 2);
          s3 = *(src + 3);

          a0 = (s0 >> 24);
          a1 = (s1 >> 24);
          a2 = (s2 >> 24);
          a3 = (s3 >> 24);

          if ((a0 & a1 & a2 & a3) == 0xFF)
          {
            __m64 vdest;
            vdest = pack565(invert_colors(load8888(s0)), _mm_setzero_si64(), 0);
            vdest = pack565(invert_colors(load8888(s1)), vdest, 1);
            vdest = pack565(invert_colors(load8888(s2)), vdest, 2);
            vdest = pack565(invert_colors(load8888(s3)), vdest, 3);

            *(__m64 *)dst = vdest;
          }
          else if (a0 | a1 | a2 | a3)
          {
            __m64 vdest = *(__m64 *)dst;

            vdest = pack565(over_rev_non_pre(load8888(s0), expand565(vdest, 0)), vdest, 0);
              vdest = pack565(over_rev_non_pre(load8888(s1), expand565(vdest, 1)), vdest, 1);
            vdest = pack565(over_rev_non_pre(load8888(s2), expand565(vdest, 2)), vdest, 2);
            vdest = pack565(over_rev_non_pre(load8888(s3), expand565(vdest, 3)), vdest, 3);

            *(__m64 *)dst = vdest;
          }

          w -= 4;
          dst += 4;
          src += 4;
      }

      CHECKPOINT();

      while (w)
      {
          __m64 vsrc = load8888 (*src);
          ullong d = *dst;
          __m64 vdest = expand565 (M64(d), 0);

          vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);

          *dst = ULLONG(vdest);

          w--;
          dst++;
          src++;
      }
    }

    _mm_empty();
}

/* "8888RevNP" is GdkPixbuf's format: ABGR, non premultiplied */

void
fbCompositeSrc_8888RevNPx8888mmx (pixman_op_t op,
                          pixman_image_t * pSrc,
                          pixman_image_t * pMask,
                          pixman_image_t * pDst,
                          int16_t      xSrc,
                          int16_t      ySrc,
                          int16_t      xMask,
                          int16_t      yMask,
                          int16_t      xDst,
                          int16_t      yDst,
                          uint16_t     width,
                          uint16_t     height)
{
    uint32_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    int     dstStride, srcStride;
    uint16_t      w;

    CHECKPOINT();

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

#if 0
    /* FIXME */
    assert (pSrc->pDrawable == pMask->pDrawable);
#endif

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w && (unsigned long)dst & 7)
      {
          __m64 s = load8888 (*src);
          __m64 d = load8888 (*dst);

          *dst = store8888 (over_rev_non_pre (s, d));

          w--;
          dst++;
          src++;
      }

      while (w >= 2)
      {
          ullong s0, s1;
          unsigned char a0, a1;
          __m64 d0, d1;

          s0 = *src;
          s1 = *(src + 1);

          a0 = (s0 >> 24);
          a1 = (s1 >> 24);

          if ((a0 & a1) == 0xFF)
          {
            d0 = invert_colors(load8888(s0));
            d1 = invert_colors(load8888(s1));

            *(__m64 *)dst = pack8888 (d0, d1);
          }
          else if (a0 | a1)
          {
            __m64 vdest = *(__m64 *)dst;

            d0 = over_rev_non_pre (load8888(s0), expand8888 (vdest, 0));
            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);

          *dst = store8888 (over_rev_non_pre (s, d));

          w--;
          dst++;
          src++;
      }
    }

    _mm_empty();
}

void
fbCompositeSolidMask_nx8888x0565Cmmx (pixman_op_t op,
                              pixman_image_t * pSrc,
                              pixman_image_t * pMask,
                              pixman_image_t * pDst,
                              int16_t      xSrc,
                              int16_t      ySrc,
                              int16_t      xMask,
                              int16_t      yMask,
                              int16_t      xDst,
                              int16_t      yDst,
                              uint16_t     width,
                              uint16_t     height)
{
    uint32_t      src, srca;
    uint16_t      *dstLine;
    uint32_t      *maskLine;
    int     dstStride, maskStride;
    __m64  vsrc, vsrca;

    CHECKPOINT();

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    srca = src >> 24;
    if (srca == 0)
      return;

    fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);

    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);

    while (height--)
    {
      int twidth = width;
      uint32_t *p = (uint32_t *)maskLine;
      uint16_t *q = (uint16_t *)dstLine;

      while (twidth && ((unsigned long)q & 7))
      {
          uint32_t m = *(uint32_t *)p;

          if (m)
          {
            ullong d = *q;
            __m64 vdest = expand565 (M64(d), 0);
            vdest = pack565 (in_over (vsrc, vsrca, load8888 (m), vdest), vdest, 0);
            *q = ULLONG(vdest);
          }

          twidth--;
          p++;
          q++;
      }

      while (twidth >= 4)
      {
          uint32_t m0, m1, m2, m3;

          m0 = *p;
          m1 = *(p + 1);
          m2 = *(p + 2);
          m3 = *(p + 3);

          if ((m0 | m1 | m2 | m3))
          {
            __m64 vdest = *(__m64 *)q;

            vdest = pack565(in_over(vsrc, vsrca, load8888(m0), expand565(vdest, 0)), vdest, 0);
            vdest = pack565(in_over(vsrc, vsrca, load8888(m1), expand565(vdest, 1)), vdest, 1);
            vdest = pack565(in_over(vsrc, vsrca, load8888(m2), expand565(vdest, 2)), vdest, 2);
            vdest = pack565(in_over(vsrc, vsrca, load8888(m3), expand565(vdest, 3)), vdest, 3);

            *(__m64 *)q = vdest;
          }
          twidth -= 4;
          p += 4;
          q += 4;
      }

      while (twidth)
      {
          uint32_t m;

          m = *(uint32_t *)p;
          if (m)
          {
            ullong d = *q;
            __m64 vdest = expand565(M64(d), 0);
            vdest = pack565 (in_over(vsrc, vsrca, load8888(m), vdest), vdest, 0);
            *q = ULLONG(vdest);
          }

          twidth--;
          p++;
          q++;
      }

      maskLine += maskStride;
      dstLine += dstStride;
    }

    _mm_empty ();
}

void
fbCompositeIn_nx8x8mmx (pixman_op_t op,
                  pixman_image_t * pSrc,
                  pixman_image_t * pMask,
                  pixman_image_t * pDst,
                  int16_t      xSrc,
                  int16_t      ySrc,
                  int16_t      xMask,
                  int16_t      yMask,
                  int16_t      xDst,
                  int16_t      yDst,
                  uint16_t     width,
                  uint16_t     height)
{
    uint8_t *dstLine, *dst;
    uint8_t *maskLine, *mask;
    int     dstStride, maskStride;
    uint16_t      w;
    uint32_t      src;
    uint8_t sa;
    __m64   vsrc, vsrca;

    fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    sa = src >> 24;
    if (sa == 0)
      return;

    vsrc = load8888(src);
    vsrca = expand_alpha(vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;
      w = width;

      if ((((unsigned long)pDst & 3) == 0) &&
          (((unsigned long)pSrc & 3) == 0))
      {
          while (w >= 4)
          {
            uint32_t m;
            __m64 vmask;
            __m64 vdest;

            m = 0;

            vmask = load8888 (*(uint32_t *)mask);
            vdest = load8888 (*(uint32_t *)dst);

            *(uint32_t *)dst = store8888 (in (in (vsrca, vmask), vdest));

            dst += 4;
            mask += 4;
            w -= 4;
          }
      }

      while (w--)
      {
          uint16_t      tmp;
          uint8_t a;
          uint32_t      m, d;
          uint32_t      r;

          a = *mask++;
          d = *dst;

          m = FbInU (sa, 0, a, tmp);
          r = FbInU (m, 0, d, tmp);

          *dst++ = r;
      }
    }

    _mm_empty();
}

void
fbCompositeIn_8x8mmx (pixman_op_t op,
                  pixman_image_t * pSrc,
                  pixman_image_t * pMask,
                  pixman_image_t * pDst,
                  int16_t      xSrc,
                  int16_t      ySrc,
                  int16_t      xMask,
                  int16_t      yMask,
                  int16_t      xDst,
                  int16_t      yDst,
                  uint16_t     width,
                  uint16_t     height)
{
    uint8_t *dstLine, *dst;
    uint8_t *srcLine, *src;
    int     srcStride, dstStride;
    uint16_t      w;

    fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint8_t, srcStride, srcLine, 1);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      if ((((unsigned long)pDst & 3) == 0) &&
          (((unsigned long)pSrc & 3) == 0))
      {
          while (w >= 4)
          {
            uint32_t *s = (uint32_t *)src;
            uint32_t *d = (uint32_t *)dst;

            *d = store8888 (in (load8888 (*s), load8888 (*d)));

            w -= 4;
            dst += 4;
            src += 4;
          }
      }

      while (w--)
      {
          uint8_t s, d;
          uint16_t tmp;

          s = *src;
          d = *dst;

          *dst = FbInU (s, 0, d, tmp);

          src++;
          dst++;
      }
    }

    _mm_empty ();
}

void
fbCompositeSrcAdd_8888x8x8mmx (pixman_op_t op,
                         pixman_image_t * pSrc,
                         pixman_image_t * pMask,
                         pixman_image_t * pDst,
                         int16_t      xSrc,
                         int16_t      ySrc,
                         int16_t      xMask,
                         int16_t      yMask,
                         int16_t      xDst,
                         int16_t      yDst,
                         uint16_t     width,
                         uint16_t     height)
{
    uint8_t *dstLine, *dst;
    uint8_t *maskLine, *mask;
    int     dstStride, maskStride;
    uint16_t      w;
    uint32_t      src;
    uint8_t sa;
    __m64   vsrc, vsrca;

    fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);

    fbComposeGetSolid(pSrc, src, pDst->bits.format);

    sa = src >> 24;
    if (sa == 0)
      return;

    vsrc = load8888(src);
    vsrca = expand_alpha(vsrc);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;
      w = width;

      if ((((unsigned long)pMask & 3) == 0) &&
          (((unsigned long)pDst  & 3) == 0))
      {
          while (w >= 4)
          {
            __m64 vmask = load8888 (*(uint32_t *)mask);
            __m64 vdest = load8888 (*(uint32_t *)dst);

            *(uint32_t *)dst = store8888 (_mm_adds_pu8 (in (vsrca, vmask), vdest));

            w -= 4;
            dst += 4;
            mask += 4;
          }
      }

      while (w--)
      {
          uint16_t      tmp;
          uint16_t      a;
          uint32_t      m, d;
          uint32_t      r;

          a = *mask++;
          d = *dst;

          m = FbInU (sa, 0, a, tmp);
          r = FbAdd (m, d, 0, tmp);

          *dst++ = r;
      }
    }

    _mm_empty();
}

void
fbCompositeSrcAdd_8000x8000mmx (pixman_op_t op,
                        pixman_image_t * pSrc,
                        pixman_image_t * pMask,
                        pixman_image_t * pDst,
                        int16_t      xSrc,
                        int16_t      ySrc,
                        int16_t      xMask,
                        int16_t      yMask,
                        int16_t      xDst,
                        int16_t      yDst,
                        uint16_t     width,
                        uint16_t     height)
{
    uint8_t *dstLine, *dst;
    uint8_t *srcLine, *src;
    int     dstStride, srcStride;
    uint16_t      w;
    uint8_t s, d;
    uint16_t      t;

    CHECKPOINT();

    fbComposeGetStart (pSrc, xSrc, ySrc, uint8_t, srcStride, srcLine, 1);
    fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w && (unsigned long)dst & 7)
      {
          s = *src;
          d = *dst;
          t = d + s;
          s = t | (0 - (t >> 8));
          *dst = s;

          dst++;
          src++;
          w--;
      }

      while (w >= 8)
      {
          *(__m64*)dst = _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
          dst += 8;
          src += 8;
          w -= 8;
      }

      while (w)
      {
          s = *src;
          d = *dst;
          t = d + s;
          s = t | (0 - (t >> 8));
          *dst = s;

          dst++;
          src++;
          w--;
      }
    }

    _mm_empty();
}

void
fbCompositeSrcAdd_8888x8888mmx (pixman_op_t     op,
                        pixman_image_t *  pSrc,
                        pixman_image_t *  pMask,
                        pixman_image_t *   pDst,
                        int16_t            xSrc,
                        int16_t      ySrc,
                        int16_t      xMask,
                        int16_t      yMask,
                        int16_t      xDst,
                        int16_t      yDst,
                        uint16_t     width,
                        uint16_t     height)
{
    __m64 dst64;
    uint32_t      *dstLine, *dst;
    uint32_t      *srcLine, *src;
    int     dstStride, srcStride;
    uint16_t      w;

    CHECKPOINT();

    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);

    while (height--)
    {
      dst = dstLine;
      dstLine += dstStride;
      src = srcLine;
      srcLine += srcStride;
      w = width;

      while (w && (unsigned long)dst & 7)
      {
          *dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
                                     _mm_cvtsi32_si64(*dst)));
          dst++;
          src++;
          w--;
      }

      while (w >= 2)
      {
          dst64 = _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
          *(ullong*)dst = ULLONG(dst64);
          dst += 2;
          src += 2;
          w -= 2;
      }

      if (w)
      {
          *dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
                                     _mm_cvtsi32_si64(*dst)));

      }
    }

    _mm_empty();
}

pixman_bool_t
pixman_blt_mmx (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)
{
    uint8_t *     src_bytes;
    uint8_t *     dst_bytes;
    int           byte_width;

    if (src_bpp != dst_bpp)
      return FALSE;

    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));
      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));
      byte_width = 4 * width;
      src_stride *= 4;
      dst_stride *= 4;
    } else {
      return FALSE;
    }

    while (height--)
    {
      int w;
      uint8_t *s = src_bytes;
      uint8_t *d = dst_bytes;
      src_bytes += src_stride;
      dst_bytes += dst_stride;
      w = byte_width;

      while (w >= 2 && ((unsigned long)d & 3))
      {
          *(uint16_t *)d = *(uint16_t *)s;
          w -= 2;
          s += 2;
          d += 2;
      }

      while (w >= 4 && ((unsigned long)d & 7))
      {
          *(uint32_t *)d = *(uint32_t *)s;

          w -= 4;
          s += 4;
          d += 4;
      }

      while (w >= 64)
      {
#ifdef __GNUC__
          __asm__ (
            "movq   (%1),       %%mm0\n"
            "movq  8(%1),       %%mm1\n"
            "movq 16(%1),       %%mm2\n"
            "movq 24(%1),       %%mm3\n"
            "movq 32(%1),       %%mm4\n"
            "movq 40(%1),       %%mm5\n"
            "movq 48(%1),       %%mm6\n"
            "movq 56(%1),       %%mm7\n"

            "movq %%mm0,        (%0)\n"
            "movq %%mm1,       8(%0)\n"
            "movq %%mm2,      16(%0)\n"
            "movq %%mm3,      24(%0)\n"
            "movq %%mm4,      32(%0)\n"
            "movq %%mm5,      40(%0)\n"
            "movq %%mm6,      48(%0)\n"
            "movq %%mm7,      56(%0)\n"
            :
            : "r" (d), "r" (s)
            : "memory",
              "%mm0", "%mm1", "%mm2", "%mm3",
              "%mm4", "%mm5", "%mm6", "%mm7");
#else
          __m64 v0 = *(__m64 *)(s + 0);
          __m64 v1 = *(__m64 *)(s + 8);
          __m64 v2 = *(__m64 *)(s + 16);
          __m64 v3 = *(__m64 *)(s + 24);
          __m64 v4 = *(__m64 *)(s + 32);
          __m64 v5 = *(__m64 *)(s + 40);
          __m64 v6 = *(__m64 *)(s + 48);
          __m64 v7 = *(__m64 *)(s + 56);
          *(__m64 *)(d + 0)  = v0;
          *(__m64 *)(d + 8)  = v1;
          *(__m64 *)(d + 16) = v2;
          *(__m64 *)(d + 24) = v3;
          *(__m64 *)(d + 32) = v4;
          *(__m64 *)(d + 40) = v5;
          *(__m64 *)(d + 48) = v6;
          *(__m64 *)(d + 56) = v7;
#endif

          w -= 64;
          s += 64;
          d += 64;
      }
      while (w >= 4)
      {
          *(uint32_t *)d = *(uint32_t *)s;

          w -= 4;
          s += 4;
          d += 4;
      }
      if (w >= 2)
      {
          *(uint16_t *)d = *(uint16_t *)s;
          w -= 2;
          s += 2;
          d += 2;
      }
    }

    _mm_empty();

    return TRUE;
}

void
fbCompositeCopyAreammx (pixman_op_t       op,
                  pixman_image_t *  pSrc,
                  pixman_image_t *  pMask,
                  pixman_image_t *  pDst,
                  int16_t           xSrc,
                  int16_t           ySrc,
                  int16_t           xMask,
                  int16_t           yMask,
                  int16_t           xDst,
                  int16_t           yDst,
                  uint16_t          width,
                  uint16_t          height)
{
    pixman_blt_mmx (pSrc->bits.bits,
                pDst->bits.bits,
                pSrc->bits.rowstride,
                pDst->bits.rowstride,
                PIXMAN_FORMAT_BPP (pSrc->bits.format),
                PIXMAN_FORMAT_BPP (pDst->bits.format),
                xSrc, ySrc, xDst, yDst, width, height);
}

void
fbCompositeOver_x888x8x8888mmx (pixman_op_t      op,
                        pixman_image_t * pSrc,
                        pixman_image_t * pMask,
                        pixman_image_t * pDst,
                        int16_t      xSrc,
                        int16_t      ySrc,
                        int16_t      xMask,
                        int16_t      yMask,
                        int16_t      xDst,
                        int16_t      yDst,
                        uint16_t     width,
                        uint16_t     height)
{
    uint32_t      *src, *srcLine;
    uint32_t    *dst, *dstLine;
    uint8_t *mask, *maskLine;
    int            srcStride, maskStride, dstStride;
    uint16_t w;

    fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);

    while (height--)
    {
      src = srcLine;
      srcLine += srcStride;
      dst = dstLine;
      dstLine += dstStride;
      mask = maskLine;
      maskLine += maskStride;

      w = width;

      while (w--)
      {
          ullong m = *mask;

          if (m)
          {
            __m64 s = load8888 (*src | 0xff000000);

            if (m == 0xff)
                *dst = store8888 (s);
            else
            {
                __m64 sa = expand_alpha (s);
                __m64 vm = expand_alpha_rev (M64(m));
                __m64 vdest = in_over(s, sa, vm, load8888 (*dst));

                *dst = store8888 (vdest);
            }
          }

          mask++;
          dst++;
          src++;
      }
    }

    _mm_empty();
}



#endif /* USE_MMX */

Generated by  Doxygen 1.6.0   Back to index