/*

  * Copyright © 2004 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

  */

 //Portions Copyright (c)  2008-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 #ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <liboil/liboil.h>

 #include <liboil/liboilfunction.h>

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

 typedef uint32_t CARD32;

 typedef uint16_t CARD16;

 typedef int16_t INT16;

 typedef uint8_t CARD8;

 typedef uint64_t ullong;

 typedef CARD32* PicturePtr;

 typedef CARD32* FbBits;

 typedef int FbStride;

 #include "fbmmx.h"

 #include "fbpict.h"

 #define CHECKPOINT()

 OIL_DECLARE_CLASS (composite_in_argb);

 OIL_DECLARE_CLASS (composite_in_argb_const_src);

 OIL_DECLARE_CLASS (composite_in_argb_const_mask);

 OIL_DECLARE_CLASS (composite_over_argb);

 OIL_DECLARE_CLASS (composite_over_argb_const_src);

 OIL_DECLARE_CLASS (composite_add_argb);

 OIL_DECLARE_CLASS (composite_add_argb_const_src);

 OIL_DECLARE_CLASS (composite_in_over_argb);

 OIL_DECLARE_CLASS (composite_in_over_argb_const_src);

 OIL_DECLARE_CLASS (composite_in_over_argb_const_mask);

 OIL_DECLARE_CLASS (composite_over_u8);

 OIL_DECLARE_CLASS (composite_add_u8);

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

 #if 0

 static void

 mmxCombineMaskU (uint32_t *dest, const uint32_t *src, const uint8_t *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const uint32_t *end = mask + width;

     while (mask < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         a = MmxAlpha(a);

         MmxMul(s, a);

         *dest = MmxFrom(s);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 #endif

 #ifdef ENABLE_BROKEN_IMPLS

 static void

 mmxCombineOverU (uint32_t *dest, const uint32_t *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const uint32_t *end = dest + width;

     while (dest < end) {

         __m64 x, y, a;

         x = MmxTo(*src);

         y = MmxTo(*dest);

         a = MmxAlpha(x);

         a = MmxNegate(a);

         MmxMulAdd(y, a, x);

         *dest = MmxFrom(y);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 OIL_DEFINE_IMPL_FULL(mmxCombineOverU, composite_over_argb, OIL_IMPL_FLAG_MMX);

 #endif

 #if 0

 static FASTCALL void

 mmxCombineOverReverseU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 x, y, a;

         x = MmxTo(*dest);

         y = MmxTo(*src);

         a = MmxAlpha(x);

         a = MmxNegate(a);

         MmxMulAdd(y, a, x);

         *dest = MmxFrom(y);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 #endif

 #if 0

 static void

 mmxCombineInU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 x, a;

         x = MmxTo(*src);

         a = MmxTo(*dest);

         a = MmxAlpha(a);

         MmxMul(x, a);

         *dest = MmxFrom(x);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 #endif

 #if 0

 static FASTCALL void

 mmxCombineInReverseU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 x, a;

         x = MmxTo(*dest);

         a = MmxTo(*src);

         a = MmxAlpha(a);

         MmxMul(x, a);

         *dest = MmxFrom(x);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 #endif

 #if 0

 static FASTCALL void

 mmxCombineOutU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 x, a;

         x = MmxTo(*src);

         a = MmxTo(*dest);

         a = MmxAlpha(a);

         a = MmxNegate(a);

         MmxMul(x, a);

         *dest = MmxFrom(x);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 #endif

 #if 0

 static FASTCALL void

 mmxCombineOutReverseU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 x, a;

         x = MmxTo(*dest);

         a = MmxTo(*src);

         a = MmxAlpha(a);

         a = MmxNegate(a);

         MmxMul(x, a);

         *dest = MmxFrom(x);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineAtopU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 s, da, d, sia;

         s = MmxTo(*src);

         d = MmxTo(*dest);

         sia = MmxAlpha(s);

         sia = MmxNegate(sia);

         da = MmxAlpha(d);

         MmxAddMul(s, da, d, sia);

         *dest = MmxFrom(s);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineAtopReverseU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end;

     end = dest + width;

     while (dest < end) {

         __m64 s, dia, d, sa;

         s = MmxTo(*src);

         d = MmxTo(*dest);

         sa = MmxAlpha(s);

         dia = MmxAlpha(d);

         dia = MmxNegate(dia);

         MmxAddMul(s, dia, d, sa);

         *dest = MmxFrom(s);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineXorU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         __m64 s, dia, d, sia;

         s = MmxTo(*src);

         d = MmxTo(*dest);

         sia = MmxAlpha(s);

         dia = MmxAlpha(d);

         sia = MmxNegate(sia);

         dia = MmxNegate(dia);

         MmxAddMul(s, dia, d, sia);

         *dest = MmxFrom(s);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 #endif

 static void

 mmxCombineAddU (uint32_t *dest, const uint32_t *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const uint32_t *end = dest + width;

     while (dest < end) {

         __m64 s, d;

         s = MmxTo(*src);

         d = MmxTo(*dest);

         s = MmxAdd(s, d);

         *dest = MmxFrom(s);

         ++dest;

         ++src;

     }

     _mm_empty();

 }

 OIL_DEFINE_IMPL_FULL(mmxCombineAddU, composite_add_argb, OIL_IMPL_FLAG_MMX | OIL_IMPL_FLAG_SSE);

 #if 0

 static FASTCALL void

 mmxCombineSaturateU (CARD32 *dest, const CARD32 *src, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = dest + width;

     while (dest < end) {

         CARD32 s = *src;

         CARD32 d = *dest;

         __m64 ms = MmxTo(s);

         __m64 md = MmxTo(d);

         CARD32 sa = s >> 24;

         CARD32 da = ~d >> 24;

         if (sa > da) {

             __m64 msa = MmxTo(FbIntDiv(da, sa));

             msa = MmxAlpha(msa);

             MmxMul(ms, msa);

         }

         MmxAdd(md, ms);

         *dest = MmxFrom(md);

         ++src;

         ++dest;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineSrcC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         MmxMul(s, a);

         *dest = MmxFrom(s);

         ++src;

         ++mask;

         ++dest;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineOverC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 sa = MmxAlpha(s);

         MmxMul(s, a);

         MmxMul(a, sa);

         a = MmxNegate(a);

         MmxMulAdd(d, a, s);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineOverReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         da = MmxNegate(da);

         MmxMul(s, a);

         MmxMulAdd(s, da, d);

         *dest = MmxFrom(s);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineInC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         MmxMul(s, a);

         MmxMul(s, da);

         *dest = MmxFrom(s);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineInReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 sa = MmxAlpha(s);

         MmxMul(a, sa);

         MmxMul(d, a);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineOutC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         da = MmxNegate(da);

         MmxMul(s, a);

         MmxMul(s, da);

         *dest = MmxFrom(s);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineOutReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 sa = MmxAlpha(s);

         MmxMul(a, sa);

         a = MmxNegate(a);

         MmxMul(d, a);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineAtopC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         __m64 sa = MmxAlpha(s); 

         MmxMul(s, a);

         MmxMul(a, sa);

         a = MmxNegate(a);

         MmxAddMul(d, a, s, da);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineAtopReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         __m64 sa = MmxAlpha(s)

         MmxMul(s, a);

         MmxMul(a, sa);

         da = MmxNegate(da);

         MmxAddMul(d, a, s, da);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineXorC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const __m64 mmx_4x00ff = (__m64) 0x00ff00ff00ff00ffULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         __m64 da = MmxAlpha(d);

         __m64 sa = MmxAlpha(s);

         MmxMul(s, a);

         MmxMul(a, sa);

         da = MmxNegate(da);

         a = MmxNegate(a);

         MmxAddMul(d, a, s, da);

         *dest = MmxFrom(d);

         ++src;

         ++dest;

         ++mask;

     }

     _mm_empty();

 }

 static FASTCALL void

 mmxCombineAddC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)

 {

     const __m64 mmx_0 = _mm_setzero_si64();

     const __m64 mmx_4x0080 = (__m64) 0x0080008000800080ULL;

     const CARD32 *end = src + width;

     while (src < end) {

         __m64 a = MmxTo(*mask);

         __m64 s = MmxTo(*src);

         __m64 d = MmxTo(*dest);

         MmxMul(s, a);

         d = MmxAdd(s, d);

         *dest = MmxFrom(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;

     } 

 }

 #endif

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

 typedef union {

   __m64 m64;

   uint64_t ull;

 } m64_ull;

 typedef struct

 {

     m64_ull mmx_4x00ff;

     m64_ull mmx_4x0080;

     m64_ull mmx_565_rgb;

     m64_ull mmx_565_unpack_multiplier;

     m64_ull mmx_565_r;

     m64_ull mmx_565_g;

     m64_ull mmx_565_b;

     m64_ull mmx_mask_0;

     m64_ull mmx_mask_1;

     m64_ull mmx_mask_2;

     m64_ull mmx_mask_3;

     m64_ull mmx_full_alpha;

     m64_ull mmx_ffff0000ffff0000;

     m64_ull mmx_0000ffff00000000;

     m64_ull mmx_000000000000ffff;

 } MMXData;

 static const MMXData c =

 {

     .mmx_4x00ff.ull =			0x00ff00ff00ff00ffULL,

     .mmx_4x0080.ull =			0x0080008000800080ULL,

     .mmx_565_rgb.ull =			0x000001f0003f001fULL,

     .mmx_565_r.ull =			0x000000f800000000ULL,

     .mmx_565_g.ull =			0x0000000000fc0000ULL,

     .mmx_565_b.ull =			0x00000000000000f8ULL,

     .mmx_mask_0.ull =			0xffffffffffff0000ULL,

     .mmx_mask_1.ull =			0xffffffff0000ffffULL,

     .mmx_mask_2.ull =			0xffff0000ffffffffULL,

     .mmx_mask_3.ull =			0x0000ffffffffffffULL,

     .mmx_full_alpha.ull =			0x00ff000000000000ULL,

     .mmx_565_unpack_multiplier.ull =	0x0000008404100840ULL,

     .mmx_ffff0000ffff0000.ull =		0xffff0000ffff0000ULL,

     .mmx_0000ffff00000000.ull =		0x0000ffff00000000ULL,

     .mmx_000000000000ffff.ull =		0x000000000000ffffULL,

 };

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

 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

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

 }

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

  */

 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)

 {

     __m64 r;

     r = _mm_packs_pu16 (lo, hi);

     return r;

 }

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

 }

 #ifdef ENABLE_BROKEN_IMPLS

 /* broken.  See Debian bug #340932 */

 static void

 fbCompositeSolid_nx8888mmx (uint32_t *dst, uint32_t *src, int w)

 {

     __m64	vsrc, vsrca;

     vsrc = load8888 (*src);

     vsrca = expand_alpha (vsrc);

     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;

     }

     while (w)

     {

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

         w--;

         dst++;

     }

     _mm_empty();

 }

 OIL_DEFINE_IMPL_FULL(fbCompositeSolid_nx8888mmx, composite_over_argb_const_src,

     OIL_IMPL_FLAG_MMX| OIL_IMPL_FLAG_MMXEXT);

 #endif

 #if 0

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

 }

 #endif

 #if 0

 static void

 fbCompositeSolidMask_nx8888x8888Cmmx (uint32_t *dst, uint32_t *src, uint8_t *mask, int w)

 {

     CARD32	src, srca;

     CARD32	*dstLine;

     CARD32	*maskLine;

     FbStride	dstStride, maskStride;

     __m64	vsrc, vsrca;

     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 = (ullong)pack8888(vdest, _mm_setzero_si64());

         }

         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 = (ullong)pack8888(vdest, _mm_setzero_si64());

         }

         twidth--;

         p++;

         q++;

     }

     _mm_empty();

 }

 #endif

 #if 0

 static void

 fbCompositeSrc_8888x8x8888mmx (uint32_t *dest, uint32_t *src, uint8_t *mask,

     int width)

 {

     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 = (ullong)pack8888 (in_over (s, srca, vmask, d), (__m64)_mm_setzero_si64());

 	    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 = (ullong)pack8888 (in_over (s, srca, vmask, d), (__m64)_mm_setzero_si64());

 	    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 = (ullong)pack8888 (over (s, expand_alpha (s), d), (__m64)_mm_setzero_si64());

 	    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 = (ullong)pack8888 (over (s, expand_alpha (s), d),

 				     (__m64)_mm_setzero_si64());

 	    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 = (ullong)pack8888(vdest, _mm_setzero_si64());

 	    }

 	    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 = (ullong)pack8888(vdest, _mm_setzero_si64());

 	    }

 	    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 = (ullong)pack8888 (over_rev_non_pre (s, d), _mm_setzero_si64());

 	    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 = (ullong)pack8888 (over_rev_non_pre (s, d), _mm_setzero_si64());

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

 }

 #endif

 static void

 fbCompositeSrcAdd_8000x8000mmx (uint8_t *dst, uint8_t *src, int w)

 {

     int s;

     int d;

     int t;

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

 }

 OIL_DEFINE_IMPL_FULL (fbCompositeSrcAdd_8000x8000mmx, composite_add_u8, OIL_IMPL_FLAG_MMX);

 static void

 fbCompositeSrcAdd_8888x8888mmx (uint32_t *dst, uint32_t *src, int w)

 {

     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)

     {

         *(__m64 *)dst = _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();

 }

 OIL_DEFINE_IMPL_FULL (fbCompositeSrcAdd_8888x8888mmx, composite_add_argb, OIL_IMPL_FLAG_MMX | OIL_IMPL_FLAG_SSE);

 #if 0

 #define GetStart(drw,x,y,type,stride,line,bpp) {\

     FbBits	*__bits__;									\

     FbStride	__stride__;									\

     int		__xoff__,__yoff__;								\

 												\

     fbGetDrawable((drw),__bits__,__stride__,bpp,__xoff__,__yoff__);				\

     (stride) = __stride__ * sizeof (FbBits) / sizeof (type);					\

     (line) = ((type *) __bits__) + (stride) * ((y) - __yoff__) + ((x) - __xoff__);		\

 }

 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 != 16 && src_bpp != 32)

 	return FALSE;

     if (dst_bpp != 16 && dst_bpp != 32)

 	return FALSE;

     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

     {

 	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;

     }

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

 }

 #if !defined(__amd64__) && !defined(__x86_64__)

 enum CPUFeatures {

     NoFeatures = 0,

     MMX = 0x1,

     MMX_Extensions = 0x2, 

     SSE = 0x6,

     SSE2 = 0x8,

     CMOV = 0x10

 };

 static unsigned int detectCPUFeatures(void) {

     unsigned int result;

     char vendor[13];

     vendor[0] = 0;

     vendor[12] = 0;

     /* see p. 118 of amd64 instruction set manual Vol3 */

     __asm__ ("push %%ebx\n"

              "pushf\n"

              "pop %%eax\n"

              "mov %%eax, %%ebx\n"

              "xor $0x00200000, %%eax\n"

              "push %%eax\n"

              "popf\n"

              "pushf\n"

              "pop %%eax\n"

              "mov $0x0, %%edx\n"

              "xor %%ebx, %%eax\n"

              "jz skip\n"

              "mov $0x00000000, %%eax\n"

              "cpuid\n"

              "mov %%ebx, %1\n"

              "mov %%edx, %2\n"

              "mov %%ecx, %3\n"

              "mov $0x00000001, %%eax\n"

              "cpuid\n"

              "skip:\n"

              "pop %%ebx\n"

              "mov %%edx, %0\n"

              : "=r" (result), 

                "=m" (vendor[0]), 

                "=m" (vendor[4]), 

                "=m" (vendor[8])

              :

              : "%eax", "%ecx", "%edx"

         );

     unsigned int features = 0;

     if (result) {

         /* result now contains the standard feature bits */

         if (result & (1 << 15))

             features |= CMOV;

         if (result & (1 << 23))

             features |= MMX;

         if (result & (1 << 25))

             features |= SSE;

         if (result & (1 << 26))

             features |= SSE2;

         if ((result & MMX) && !(result & SSE) && (strcmp(vendor, "AuthenticAMD") == 0)) {

             /* check for AMD MMX extensions */

             unsigned int result;            

             __asm__("push %%ebx\n"

                     "mov $0x80000000, %%eax\n"

                     "cpuid\n"

                     "xor %%edx, %%edx\n"

                     "cmp $0x1, %%eax\n"

                     "jge skip2\n"

                     "mov $0x80000001, %%eax\n"

                     "cpuid\n"

                     "skip2:\n"

                     "mov %%edx, %0\n"

                     "pop %%ebx\n"

                     : "=r" (result)

                     :

                     : "%eax", "%ecx", "%edx"

                 );

             if (result & (1<<22))

                 features |= MMX_Extensions;

         }

     }

     return features;

 }

 Bool

 fbHaveMMX (void)

 {

     static Bool initialized = FALSE;

     static Bool mmx_present;

     if (!initialized)

     {

         unsigned int features = detectCPUFeatures();

 	mmx_present = (features & (MMX|MMX_Extensions)) == (MMX|MMX_Extensions);

         initialized = TRUE;

     }

     return mmx_present;

 }

 #endif /* __amd64__ */

 #endif

 #ifdef	__SYMBIAN32__

 OilFunctionImpl* __oil_function_impl_mmxCombineOverU, composite_over_argb() {

 		return &_oil_function_impl_mmxCombineOverU, composite_over_argb;

 }

 #endif

 #ifdef	__SYMBIAN32__

 OilFunctionImpl* __oil_function_impl_mmxCombineAddU, composite_add_argb() {

 		return &_oil_function_impl_mmxCombineAddU, composite_add_argb;

 }

 #endif

 #ifdef	__SYMBIAN32__

 OilFunctionImpl* __oil_function_impl_fbCompositeSolid_nx8888mmx, composite_over_argb_const_src() {

 		return &_oil_function_impl_fbCompositeSolid_nx8888mmx, composite_over_argb_const_src;

 }

 #endif

 #ifdef	__SYMBIAN32__

 OilFunctionImpl* __oil_function_impl_fbCompositeSrcAdd_8000x8000mmx, composite_add_u8() {

 		return &_oil_function_impl_fbCompositeSrcAdd_8000x8000mmx, composite_add_u8;

 }

 #endif

 #ifdef	__SYMBIAN32__

 OilFunctionImpl* __oil_function_impl_fbCompositeSrcAdd_8888x8888mmx, composite_add_argb() {

 		return &_oil_function_impl_fbCompositeSrcAdd_8888x8888mmx, composite_add_argb;

 }

 #endif