2313 lines
49 KiB
C
2313 lines
49 KiB
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;
|
|
__m64 v1, v2, v3, v4, v5, v6, v7;
|
|
|
|
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;
|
|
|
|
__asm__ (
|
|
"movq %7, %0\n"
|
|
"movq %7, %1\n"
|
|
"movq %7, %2\n"
|
|
"movq %7, %3\n"
|
|
"movq %7, %4\n"
|
|
"movq %7, %5\n"
|
|
"movq %7, %6\n"
|
|
: "=y" (v1), "=y" (v2), "=y" (v3),
|
|
"=y" (v4), "=y" (v5), "=y" (v6), "=y" (v7)
|
|
: "y" (vfill));
|
|
|
|
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)
|
|
{
|
|
__asm__ (
|
|
"movq %1, (%0)\n"
|
|
"movq %2, 8(%0)\n"
|
|
"movq %3, 16(%0)\n"
|
|
"movq %4, 24(%0)\n"
|
|
"movq %5, 32(%0)\n"
|
|
"movq %6, 40(%0)\n"
|
|
"movq %7, 48(%0)\n"
|
|
"movq %8, 56(%0)\n"
|
|
:
|
|
: "r" (d),
|
|
"y" (vfill), "y" (v1), "y" (v2), "y" (v3),
|
|
"y" (v4), "y" (v5), "y" (v6), "y" (v7)
|
|
: "memory");
|
|
|
|
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)
|
|
{
|
|
__asm__ (
|
|
"movq (%1), %%mm0\n"
|
|
"movq 8(%1), %%mm1\n"
|
|
"movq 16(%1), %%mm2\n"
|
|
"movq 24(%1), %%mm3\n"
|
|
"movq 32(%1), %%mm4\n"
|
|
"movq 40(%1), %%mm5\n"
|
|
"movq 48(%1), %%mm6\n"
|
|
"movq 56(%1), %%mm7\n"
|
|
|
|
"movq %%mm0, (%0)\n"
|
|
"movq %%mm1, 8(%0)\n"
|
|
"movq %%mm2, 16(%0)\n"
|
|
"movq %%mm3, 24(%0)\n"
|
|
"movq %%mm4, 32(%0)\n"
|
|
"movq %%mm5, 40(%0)\n"
|
|
"movq %%mm6, 48(%0)\n"
|
|
"movq %%mm7, 56(%0)\n"
|
|
:
|
|
: "r" (d), "r" (s)
|
|
: "memory",
|
|
"%mm0", "%mm1", "%mm2", "%mm3",
|
|
"%mm4", "%mm5", "%mm6", "%mm7");
|
|
|
|
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 */
|