Logo Search packages:      
Sourcecode: xorg-server version File versions  Download package

fbmmx.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_DIX_CONFIG_H
#include <dix-config.h>
#endif

#ifdef USE_MMX

#if defined(__amd64__) || defined(__x86_64__)
#define USE_SSE
#endif

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

#ifdef RENDER

#include "fb.h"
#include "fbmmx.h"

#include "picturestr.h"
#include "mipict.h"
#include "fbpict.h"

#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 ------------------------------------ */

typedef unsigned long long ullong;

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

static const MMXData c =
{
    .mmx_4x00ff =             0x00ff00ff00ff00ffULL,
    .mmx_4x0080 =             0x0080008000800080ULL,
    .mmx_565_rgb =                  0x000001f0003f001fULL,
    .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_565_unpack_multiplier =    0x0000008404100840ULL,
    .mmx_ffff0000ffff0000 =         0xffff0000ffff0000ULL,
    .mmx_0000ffff00000000 =         0x0000ffff00000000ULL,
    .mmx_000000000000ffff =         0x000000000000ffffULL,
};

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

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 (__m64 src,
       __m64 srca,
       __m64 mask,
       __m64 dest)
{
    return over(in(src, mask), pix_multiply(srca, mask), dest);
}

static __inline__ __m64
load8888 (CARD32 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__ CARD32
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);
}

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_srli_pi16(x, 1);                    
    y = _mm_srli_pi16(y, 1);                    
    x = _mm_adds_pu16 (x, y);                    
    x = _mm_adds_pu16 (x, _mm_srli_pi16 (x, 8)); 
    x = _mm_adds_pu16 (x, MC(4x0080));
    x = _mm_srli_pi16 (x, 7);

    return x;
}

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

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


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

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

static FASTCALL void
mmxCombineOverReverseU (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *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 (CARD32 *dest, const CARD32 *src, int width)
{
    const CARD32 *end = dest + width;
    while (dest < end) {
        CARD32 s = *src;
        CARD32 d = *dest;
        __m64 ms = load8888(s);
        __m64 md = load8888(d);
        CARD32 sa = s >> 24;
        CARD32 da = ~d >> 24;

        if (sa > da) {
            __m64 msa = load8888(FbIntDiv(da, sa));
            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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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 (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
{
    const CARD32 *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();
}

extern FbComposeFunctions composeFunctions;

void fbComposeSetupMMX(void)
{
    /* check if we have MMX support and initialize accordingly */
    if (fbHaveMMX()) {
        composeFunctions.combineU[PictOpOver] = mmxCombineOverU;
        composeFunctions.combineU[PictOpOverReverse] = mmxCombineOverReverseU;
        composeFunctions.combineU[PictOpIn] = mmxCombineInU;
        composeFunctions.combineU[PictOpInReverse] = mmxCombineInReverseU;
        composeFunctions.combineU[PictOpOut] = mmxCombineOutU;
        composeFunctions.combineU[PictOpOutReverse] = mmxCombineOutReverseU;
        composeFunctions.combineU[PictOpAtop] = mmxCombineAtopU;
        composeFunctions.combineU[PictOpAtopReverse] = mmxCombineAtopReverseU;
        composeFunctions.combineU[PictOpXor] = mmxCombineXorU;
        composeFunctions.combineU[PictOpAdd] = mmxCombineAddU;
        composeFunctions.combineU[PictOpSaturate] = mmxCombineSaturateU;

        composeFunctions.combineC[PictOpSrc] = mmxCombineSrcC;
        composeFunctions.combineC[PictOpOver] = mmxCombineOverC;
        composeFunctions.combineC[PictOpOverReverse] = mmxCombineOverReverseC;
        composeFunctions.combineC[PictOpIn] = mmxCombineInC;
        composeFunctions.combineC[PictOpInReverse] = mmxCombineInReverseC;
        composeFunctions.combineC[PictOpOut] = mmxCombineOutC;
        composeFunctions.combineC[PictOpOutReverse] = mmxCombineOutReverseC;
        composeFunctions.combineC[PictOpAtop] = mmxCombineAtopC;
        composeFunctions.combineC[PictOpAtopReverse] = mmxCombineAtopReverseC;
        composeFunctions.combineC[PictOpXor] = mmxCombineXorC;
        composeFunctions.combineC[PictOpAdd] = mmxCombineAddC;

        composeFunctions.combineMaskU = mmxCombineMaskU;
    } 
}


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

void
fbCompositeSolid_nx8888mmx (CARD8   op,
                      PicturePtr pSrc,
                      PicturePtr pMask,
                      PicturePtr pDst,
                      INT16   xSrc,
                      INT16   ySrc,
                      INT16   xMask,
                      INT16   yMask,
                      INT16   xDst,
                      INT16   yDst,
                      CARD16  width,
                      CARD16  height)
{
    CARD32  src;
    CARD32  *dstLine, *dst;
    CARD16  w;
    FbStride      dstStride;
    __m64   vsrc, vsrca;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    if (src >> 24 == 0)
      return;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, 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 (CARD8   op,
                      PicturePtr pSrc,
                      PicturePtr pMask,
                      PicturePtr pDst,
                      INT16   xSrc,
                      INT16   ySrc,
                      INT16   xMask,
                      INT16   yMask,
                      INT16   xDst,
                      INT16   yDst,
                      CARD16  width,
                      CARD16  height)
{
    CARD32  src;
    CARD16  *dstLine, *dst;
    CARD16  w;
    FbStride      dstStride;
    __m64   vsrc, vsrca;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    if (src >> 24 == 0)
      return;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD16, 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 (CARD8     op,
                              PicturePtr pSrc,
                              PicturePtr pMask,
                              PicturePtr pDst,
                              INT16 xSrc,
                              INT16 ySrc,
                              INT16 xMask,
                              INT16 yMask,
                              INT16 xDst,
                              INT16 yDst,
                              CARD16      width,
                              CARD16      height)
{
    CARD32  src, srca;
    CARD32  *dstLine;
    CARD32  *maskLine;
    FbStride      dstStride, maskStride;
    __m64   vsrc, vsrca;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    srca = src >> 24;
    if (srca == 0)
      return;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, CARD32, maskStride, maskLine, 1);
    
    vsrc = load8888(src);
    vsrca = expand_alpha(vsrc);
    
    while (height--)
    {
      int twidth = width;
      CARD32 *p = (CARD32 *)maskLine;
      CARD32 *q = (CARD32 *)dstLine;
      
      while (twidth && (unsigned long)q & 7)
      {
          CARD32 m = *(CARD32 *)p;
          
          if (m)
          {
            __m64 vdest = load8888(*q);
            vdest = in_over(vsrc, vsrca, load8888(m), vdest);
            *q = store8888(vdest);
          }
          
          twidth--;
          p++;
          q++;
      }
      
      while (twidth >= 2)
      {
          CARD32 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)
      {
          CARD32 m = *(CARD32 *)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 (CARD8      op,
                         PicturePtr pSrc,
                         PicturePtr pMask,
                         PicturePtr pDst,
                         INT16      xSrc,
                         INT16      ySrc,
                         INT16      xMask,
                         INT16      yMask,
                         INT16      xDst,
                         INT16      yDst,
                         CARD16     width,
                         CARD16     height)
{
    CARD32  *dstLine, *dst;
    CARD32  *srcLine, *src;
    CARD8   *maskLine;
    CARD32  mask;
    __m64   vmask;
    FbStride      dstStride, srcStride, maskStride;
    CARD16  w;
    __m64  srca;
    
    CHECKPOINT();
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD32, srcStride, srcLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, CARD8, maskStride, maskLine, 1);

    mask = *maskLine << 24 | *maskLine << 16 | *maskLine << 8 | *maskLine;
    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, 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 = (__m64)pack8888 (
            in_over (expand8888 (vs0, 0), srca, vmask, expand8888 (vd0, 0)),
            in_over (expand8888 (vs0, 1), srca, vmask, expand8888 (vd0, 1)));
      
          vd1 = (__m64)pack8888 (
            in_over (expand8888 (vs1, 0), srca, vmask, expand8888 (vd1, 0)),
            in_over (expand8888 (vs1, 1), srca, vmask, expand8888 (vd1, 1)));
      
          vd2 = (__m64)pack8888 (
            in_over (expand8888 (vs2, 0), srca, vmask, expand8888 (vd2, 0)),
            in_over (expand8888 (vs2, 1), srca, vmask, expand8888 (vd2, 1)));
      
          vd3 = (__m64)pack8888 (
            in_over (expand8888 (vs3, 0), srca, vmask, expand8888 (vd3, 0)),
            in_over (expand8888 (vs3, 1), srca, vmask, expand8888 (vd3, 1)));
      
          vd4 = (__m64)pack8888 (
            in_over (expand8888 (vs4, 0), srca, vmask, expand8888 (vd4, 0)),
            in_over (expand8888 (vs4, 1), srca, vmask, expand8888 (vd4, 1)));
      
          vd5 = (__m64)pack8888 (
            in_over (expand8888 (vs5, 0), srca, vmask, expand8888 (vd5, 0)),
            in_over (expand8888 (vs5, 1), srca, vmask, expand8888 (vd5, 1)));
      
          vd6 = (__m64)pack8888 (
            in_over (expand8888 (vs6, 0), srca, vmask, expand8888 (vd6, 0)),
            in_over (expand8888 (vs6, 1), srca, vmask, expand8888 (vd6, 1)));
      
          vd7 = (__m64)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);
          __m64 d = load8888 (*dst);
          
          *dst = store8888 (in_over (s, srca, vmask, d));
          
          w--;
          dst++;
          src++;
      }
    }

    _mm_empty(); 
}

void
fbCompositeSrc_8888x8888mmx (CARD8  op,
                       PicturePtr pSrc,
                       PicturePtr pMask,
                       PicturePtr pDst,
                       INT16  xSrc,
                       INT16  ySrc,
                       INT16      xMask,
                       INT16      yMask,
                       INT16      xDst,
                       INT16      yDst,
                       CARD16     width,
                       CARD16     height)
{
    CARD32  *dstLine, *dst;
    CARD32  *srcLine, *src;
    FbStride      dstStride, srcStride;
    CARD16  w;
    __m64  srca;
    
    CHECKPOINT();
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD32, srcStride, srcLine, 1);

    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 (over (s, expand_alpha (s), d));
          
          w--;
          dst++;
          src++;
      }

      while (w >= 2)
      {
          __m64 vd = *(__m64 *)(dst + 0);
          __m64 vs = *(__m64 *)(src + 0);
          __m64 vs0 = expand8888 (vs, 0);
          __m64 vs1 = expand8888 (vs, 1);

          *(__m64 *)dst = (__m64)pack8888 (
            over (vs0, expand_alpha (vs0), expand8888 (vd, 0)),
            over (vs1, expand_alpha (vs1), expand8888 (vd, 1)));
          
          w -= 2;
          dst += 2;
          src += 2;
      }
      
      while (w)
      {
          __m64 s = load8888 (*src);
          __m64 d = load8888 (*dst);
          
          *dst = store8888 (over (s, expand_alpha (s), d));
          
          w--;
          dst++;
          src++;
      }
    }

    _mm_empty(); 
}

void
fbCompositeSolidMask_nx8x8888mmx (CARD8      op,
                          PicturePtr pSrc,
                          PicturePtr pMask,
                          PicturePtr pDst,
                          INT16      xSrc,
                          INT16      ySrc,
                          INT16      xMask,
                          INT16      yMask,
                          INT16      xDst,
                          INT16      yDst,
                          CARD16     width,
                          CARD16     height)
{
    CARD32  src, srca;
    CARD32  *dstLine, *dst;
    CARD8   *maskLine, *mask;
    FbStride      dstStride, maskStride;
    CARD16  w;
    __m64   vsrc, vsrca;
    ullong  srcsrc;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    srca = src >> 24;
    if (srca == 0)
      return;
    
    srcsrc = (unsigned long long)src << 32 | src;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, CARD8, 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)
          {
            *(unsigned long long *)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();
}


void
fbCompositeSolidMask_nx8x0565mmx (CARD8      op,
                          PicturePtr pSrc,
                          PicturePtr pMask,
                          PicturePtr pDst,
                          INT16      xSrc,
                          INT16      ySrc,
                          INT16      xMask,
                          INT16      yMask,
                          INT16      xDst,
                          INT16      yDst,
                          CARD16     width,
                          CARD16     height)
{
    CARD32  src, srca;
    CARD16  *dstLine, *dst;
    CARD8   *maskLine, *mask;
    FbStride      dstStride, maskStride;
    CARD16  w;
    __m64   vsrc, vsrca;
    unsigned long long srcsrcsrcsrc, src16;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    srca = src >> 24;
    if (srca == 0)
      return;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD16, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, CARD8, maskStride, maskLine, 1);
    
    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);
    
    src16 = (ullong)pack565(vsrc, _mm_setzero_si64(), 0);
    
    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));
            *dst = (ullong)pack565(vdest, _mm_setzero_si64(), 0);
          }
          
          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)
          {
            *(unsigned long long *)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));
            *dst = (ullong)pack565(vdest, _mm_setzero_si64(), 0);
          }
          
          w--;
          mask++;
          dst++;
      }
    }
    
    _mm_empty();
}

void
fbCompositeSrc_8888RevNPx0565mmx (CARD8      op,
                          PicturePtr pSrc,
                          PicturePtr pMask,
                          PicturePtr pDst,
                          INT16      xSrc,
                          INT16      ySrc,
                          INT16      xMask,
                          INT16      yMask,
                          INT16      xDst,
                          INT16      yDst,
                          CARD16     width,
                          CARD16     height)
{
    CARD16  *dstLine, *dst;
    CARD32  *srcLine, *src;
    FbStride      dstStride, srcStride;
    CARD16  w;
    
    CHECKPOINT();
    
    fbComposeGetStart (pDst, xDst, yDst, CARD16, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD32, srcStride, srcLine, 1);
    
    assert (pSrc->pDrawable == pMask->pDrawable);
    
    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)
      {
          CARD32 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 (CARD8      op,
                          PicturePtr pSrc,
                          PicturePtr pMask,
                          PicturePtr pDst,
                          INT16      xSrc,
                          INT16      ySrc,
                          INT16      xMask,
                          INT16      yMask,
                          INT16      xDst,
                          INT16      yDst,
                          CARD16     width,
                          CARD16     height)
{
    CARD32  *dstLine, *dst;
    CARD32  *srcLine, *src;
    FbStride      dstStride, srcStride;
    CARD16  w;
    
    CHECKPOINT();
    
    fbComposeGetStart (pDst, xDst, yDst, CARD32, dstStride, dstLine, 1);
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD32, srcStride, srcLine, 1);
    
    assert (pSrc->pDrawable == pMask->pDrawable);
    
    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 (CARD8      op,
                              PicturePtr pSrc,
                              PicturePtr pMask,
                              PicturePtr pDst,
                              INT16      xSrc,
                              INT16      ySrc,
                              INT16      xMask,
                              INT16      yMask,
                              INT16      xDst,
                              INT16      yDst,
                              CARD16     width,
                              CARD16     height)
{
    CARD32  src, srca;
    CARD16  *dstLine;
    CARD32  *maskLine;
    FbStride      dstStride, maskStride;
    __m64  vsrc, vsrca;
    
    CHECKPOINT();
    
    fbComposeGetSolid(pSrc, src, pDst->format);
    
    srca = src >> 24;
    if (srca == 0)
      return;
    
    fbComposeGetStart (pDst, xDst, yDst, CARD16, dstStride, dstLine, 1);
    fbComposeGetStart (pMask, xMask, yMask, CARD32, maskStride, maskLine, 1);
    
    vsrc = load8888 (src);
    vsrca = expand_alpha (vsrc);
    
    while (height--)
    {
      int twidth = width;
      CARD32 *p = (CARD32 *)maskLine;
      CARD16 *q = (CARD16 *)dstLine;
      
      while (twidth && ((unsigned long)q & 7))
      {
          CARD32 m = *(CARD32 *)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)
      {
          CARD32 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)
      {
          CARD32 m;
          
          m = *(CARD32 *)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
fbCompositeSrcAdd_8000x8000mmx (CARD8     op,
                        PicturePtr pSrc,
                        PicturePtr pMask,
                        PicturePtr pDst,
                        INT16      xSrc,
                        INT16      ySrc,
                        INT16      xMask,
                        INT16      yMask,
                        INT16      xDst,
                        INT16      yDst,
                        CARD16     width,
                        CARD16     height)
{
    CARD8   *dstLine, *dst;
    CARD8   *srcLine, *src;
    FbStride      dstStride, srcStride;
    CARD16  w;
    CARD8   s, d;
    CARD16  t;
    
    CHECKPOINT();
    
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD8, srcStride, srcLine, 1);
    fbComposeGetStart (pDst, xDst, yDst, CARD8, 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 (CARD8           op,
                        PicturePtr  pSrc,
                        PicturePtr  pMask,
                        PicturePtr   pDst,
                        INT16        xSrc,
                        INT16      ySrc,
                        INT16      xMask,
                        INT16      yMask,
                        INT16      xDst,
                        INT16      yDst,
                        CARD16     width,
                        CARD16     height)
{
    CARD32  *dstLine, *dst;
    CARD32  *srcLine, *src;
    FbStride      dstStride, srcStride;
    CARD16  w;
    
    CHECKPOINT();
    
    fbComposeGetStart (pSrc, xSrc, ySrc, CARD32, srcStride, srcLine, 1);
    fbComposeGetStart (pDst, xDst, yDst, CARD32, 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)
      {
          *(ullong*)dst = (ullong) _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
          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();
}

Bool
fbSolidFillmmx (DrawablePtr   pDraw,
            int         x,
            int         y,
            int         width,
            int         height,
            FbBits            xor)
{ 
    FbStride      stride;
    int           bpp;
    ullong  fill;
    __m64   vfill;
    CARD32  byte_width;
    CARD8   *byte_line;
    FbBits      *bits;
    int           xoff, yoff;
    
    CHECKPOINT();
    
    fbGetDrawable(pDraw, bits, stride, bpp, xoff, yoff);
    
    if (bpp == 16 && (xor >> 16 != (xor & 0xffff)))
      return FALSE;
    
    if (bpp != 16 && bpp != 32)
      return FALSE;
    
    if (bpp == 16)
    {
      stride = stride * sizeof (FbBits) / 2;
      byte_line = (CARD8 *)(((CARD16 *)bits) + stride * (y + yoff) + (x + xoff));
      byte_width = 2 * width;
      stride *= 2;
    }
    else
    {
      stride = stride * sizeof (FbBits) / 4;
      byte_line = (CARD8 *)(((CARD32 *)bits) + stride * (y + yoff) + (x + xoff));
      byte_width = 4 * width;
      stride *= 4;
    }
    
    fill = ((ullong)xor << 32) | xor;
    vfill = (__m64)fill;
    
    while (height--)
    {
      int w;
      CARD8 *d = byte_line;
      byte_line += stride;
      w = byte_width;
      
      while (w >= 2 && ((unsigned long)d & 3))
      {
          *(CARD16 *)d = xor;
          w -= 2;
          d += 2;
      }
      
      while (w >= 4 && ((unsigned long)d & 7))
      {
          *(CARD32 *)d = xor;
          
          w -= 4;
          d += 4;
      }
      
      while (w >= 64)
      {
          *(__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;
          
          w -= 64;
          d += 64;
      }
      while (w >= 4)
      {
          *(CARD32 *)d = xor;
          
          w -= 4;
          d += 4;
      }
      if (w >= 2)
      {
          *(CARD16 *)d = xor;
          w -= 2;
          d += 2;
      }
    }
    
    _mm_empty();
    return TRUE;
}

Bool
fbCopyAreammx (DrawablePtr    pSrc,
             DrawablePtr      pDst,
             int        src_x,
             int        src_y,
             int        dst_x,
             int        dst_y,
             int        width,
             int        height)
{
    FbBits *      src_bits;
    FbStride      src_stride;
    int           src_bpp;
    int           src_xoff;
    int           src_yoff;

    FbBits *      dst_bits;
    FbStride      dst_stride;
    int           dst_bpp;
    int           dst_xoff;
    int           dst_yoff;

    CARD8 * src_bytes;
    CARD8 * dst_bytes;
    int           byte_width;
    
    fbGetDrawable(pSrc, src_bits, src_stride, src_bpp, src_xoff, src_yoff);
    fbGetDrawable(pDst, dst_bits, dst_stride, dst_bpp, dst_xoff, dst_yoff);

    if (src_bpp != dst_bpp)
      return FALSE;
    
    if (src_bpp == 16)
    {
      src_stride = src_stride * sizeof (FbBits) / 2;
      dst_stride = dst_stride * sizeof (FbBits) / 2;
      src_bytes = (CARD8 *)(((CARD16 *)src_bits) + src_stride * (src_y + src_yoff) + (src_x + src_xoff));
      dst_bytes = (CARD8 *)(((CARD16 *)dst_bits) + dst_stride * (dst_y + dst_yoff) + (dst_x + dst_xoff));
      byte_width = 2 * width;
      src_stride *= 2;
      dst_stride *= 2;
    } else if (src_bpp == 32) {
      src_stride = src_stride * sizeof (FbBits) / 4;
      dst_stride = dst_stride * sizeof (FbBits) / 4;
      src_bytes = (CARD8 *)(((CARD32 *)src_bits) + src_stride * (src_y + src_yoff) + (src_x + src_xoff));
      dst_bytes = (CARD8 *)(((CARD32 *)dst_bits) + dst_stride * (dst_y + dst_yoff) + (dst_x + dst_xoff));
      byte_width = 4 * width;
      src_stride *= 4;
      dst_stride *= 4;
    } else {
      return FALSE;
    }

    while (height--)
    {
      int w;
      CARD8 *s = src_bytes;
      CARD8 *d = dst_bytes;
      src_bytes += src_stride;
      dst_bytes += dst_stride;
      w = byte_width;
      
      while (w >= 2 && ((unsigned long)d & 3))
      {
          *(CARD16 *)d = *(CARD16 *)s;
          w -= 2;
          s += 2;
          d += 2;
      }
      
      while (w >= 4 && ((unsigned long)d & 7))
      {
          *(CARD32 *)d = *(CARD32 *)s;
          
          w -= 4;
          s += 4;
          d += 4;
      }
      
      while (w >= 64)
      {
          *(__m64 *)(d + 0)  = *(__m64 *)(s + 0);
          *(__m64 *)(d + 8)  = *(__m64 *)(s + 8);
          *(__m64 *)(d + 16) = *(__m64 *)(s + 16);
          *(__m64 *)(d + 24) = *(__m64 *)(s + 24);
          *(__m64 *)(d + 32) = *(__m64 *)(s + 32);
          *(__m64 *)(d + 40) = *(__m64 *)(s + 40);
          *(__m64 *)(d + 48) = *(__m64 *)(s + 48);
          *(__m64 *)(d + 56) = *(__m64 *)(s + 56);
          w -= 64;
          s += 64;
          d += 64;
      }
      while (w >= 4)
      {
          *(CARD32 *)d = *(CARD32 *)s;

          w -= 4;
          s += 4;
          d += 4;
      }
      if (w >= 2)
      {
          *(CARD16 *)d = *(CARD16 *)s;
          w -= 2;
          s += 2;
          d += 2;
      }
    }
    
    _mm_empty();
    return TRUE;
}

void
fbCompositeCopyAreammx (CARD8       op,
                  PicturePtr  pSrc,
                  PicturePtr  pMask,
                  PicturePtr  pDst,
                  INT16       xSrc,
                  INT16       ySrc,
                  INT16       xMask,
                  INT16       yMask,
                  INT16       xDst,
                  INT16       yDst,
                  CARD16            width,
                  CARD16            height)
{
    fbCopyAreammx (pSrc->pDrawable,
               pDst->pDrawable,
               xSrc, ySrc,
               xDst, yDst,
               width, height);
}




#endif /* RENDER */
#endif /* USE_MMX */

Generated by  Doxygen 1.6.0   Back to index