/*

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