frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/fb/fbcompose.c

2871 lines
68 KiB
C
Raw Blame History

/*
* $XdotOrg: xc/programs/Xserver/fb/fbcompose.c,v 1.3 2004/05/12 01:49:46 anholt Exp $
* $XFree86: xc/programs/Xserver/fb/fbcompose.c,v 1.17tsi Exp $
*
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
*
* 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 Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD 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.
*/
#include "fb.h"
#include "picturestr.h"
#include "mipict.h"
#include "fbpict.h"
/*
* General purpose compositing code optimized for minimal memory
* references
*
* All work is done on canonical ARGB values, functions for fetching
* and storing these exist for each format.
*/
/*
* Combine src and mask using IN
*/
CARD32
fbCombineMaskU (FbCompositeOperand *src,
FbCompositeOperand *msk)
{
CARD32 x;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
if (!msk)
return (*src->fetch) (src);
a = (*msk->fetch) (msk) >> 24;
if (!a)
return 0;
x = (*src->fetch) (src);
if (a == 0xff)
return x;
m = FbInU(x,0,a,t);
n = FbInU(x,8,a,t);
o = FbInU(x,16,a,t);
p = FbInU(x,24,a,t);
return m|n|o|p;
}
FbCompSrc
fbCombineMaskC (FbCompositeOperand *src,
FbCompositeOperand *msk)
{
FbCompSrc s;
CARD32 x;
CARD32 a;
CARD16 xa;
CARD16 t;
CARD32 m,n,o,p;
if (!msk)
{
x = (*src->fetch) (src);
s.value = x;
x = x >> 24;
x |= x << 8;
x |= x << 16;
s.alpha = x;
return s;
}
a = (*msk->fetcha) (msk);
if (!a)
{
s.value = 0;
s.alpha = 0;
return s;
}
x = (*src->fetch) (src);
if (a == 0xffffffff)
{
s.value = x;
x = x >> 24;
x |= x << 8;
x |= x << 16;
s.alpha = x;
return s;
}
m = FbInC(x,0,a,t);
n = FbInC(x,8,a,t);
o = FbInC(x,16,a,t);
p = FbInC(x,24,a,t);
s.value = m|n|o|p;
xa = x >> 24;
m = FbInU(a,0,xa,t);
n = FbInU(a,8,xa,t);
o = FbInU(a,16,xa,t);
p = FbInU(a,24,xa,t);
s.alpha = m|n|o|p;
return s;
}
CARD32
fbCombineMaskValueC (FbCompositeOperand *src,
FbCompositeOperand *msk)
{
CARD32 x;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
if (!msk)
{
return (*src->fetch) (src);
}
a = (*msk->fetcha) (msk);
if (!a)
return a;
x = (*src->fetch) (src);
if (a == 0xffffffff)
return x;
m = FbInC(x,0,a,t);
n = FbInC(x,8,a,t);
o = FbInC(x,16,a,t);
p = FbInC(x,24,a,t);
return m|n|o|p;
}
/*
* Combine src and mask using IN, generating only the alpha component
*/
CARD32
fbCombineMaskAlphaU (FbCompositeOperand *src,
FbCompositeOperand *msk)
{
CARD32 x;
CARD16 a;
CARD16 t;
if (!msk)
return (*src->fetch) (src);
a = (*msk->fetch) (msk) >> 24;
if (!a)
return 0;
x = (*src->fetch) (src);
if (a == 0xff)
return x;
return FbInU(x,24,a,t);
}
CARD32
fbCombineMaskAlphaC (FbCompositeOperand *src,
FbCompositeOperand *msk)
{
CARD32 x;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
if (!msk)
return (*src->fetch) (src);
a = (*msk->fetcha) (msk);
if (!a)
return 0;
x = (*src->fetch) (src) >> 24;
if (x == 0xff)
return a;
m = FbInU(a,0,x,t);
n = FbInU(a,8,x,t);
o = FbInU(a,16,x,t);
p = FbInU(a,24,x,t);
return m|n|o|p;
}
/*
* All of the composing functions
*/
void
fbCombineClear (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
(*dst->store) (dst, 0);
}
void
fbCombineSrcU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
(*dst->store) (dst, fbCombineMaskU (src, msk));
}
void
fbCombineSrcC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
(*dst->store) (dst, fbCombineMaskValueC (src, msk));
}
void
fbCombineDst (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
/* noop */
}
void
fbCombineOverU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
a = ~s >> 24;
if (a != 0xff)
{
if (a)
{
d = (*dst->fetch) (dst);
m = FbOverU(s,d,0,a,t);
n = FbOverU(s,d,8,a,t);
o = FbOverU(s,d,16,a,t);
p = FbOverU(s,d,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
}
void
fbCombineOverC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
FbCompSrc cs;
CARD32 s, d;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
cs = fbCombineMaskC (src, msk);
s = cs.value;
a = ~cs.alpha;
if (a != 0xffffffff)
{
if (a)
{
d = (*dst->fetch) (dst);
m = FbOverC(s,d,0,a,t);
n = FbOverC(s,d,8,a,t);
o = FbOverC(s,d,16,a,t);
p = FbOverC(s,d,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
}
void
fbCombineOverReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = ~d >> 24;
if (a)
{
s = fbCombineMaskU (src, msk);
if (a != 0xff)
{
m = FbOverU(d,s,0,a,t);
n = FbOverU(d,s,8,a,t);
o = FbOverU(d,s,16,a,t);
p = FbOverU(d,s,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
}
void
fbCombineOverReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = ~d >> 24;
if (a)
{
s = fbCombineMaskValueC (src, msk);
if (a != 0xff)
{
m = FbOverU(d,s,0,a,t);
n = FbOverU(d,s,8,a,t);
o = FbOverU(d,s,16,a,t);
p = FbOverU(d,s,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
}
void
fbCombineInU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = d >> 24;
s = 0;
if (a)
{
s = fbCombineMaskU (src, msk);
if (a != 0xff)
{
m = FbInU(s,0,a,t);
n = FbInU(s,8,a,t);
o = FbInU(s,16,a,t);
p = FbInU(s,24,a,t);
s = m|n|o|p;
}
}
(*dst->store) (dst, s);
}
void
fbCombineInC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = d >> 24;
s = 0;
if (a)
{
s = fbCombineMaskValueC (src, msk);
if (a != 0xff)
{
m = FbInU(s,0,a,t);
n = FbInU(s,8,a,t);
o = FbInU(s,16,a,t);
p = FbInU(s,24,a,t);
s = m|n|o|p;
}
}
(*dst->store) (dst, s);
}
void
fbCombineInReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskAlphaU (src, msk);
a = s >> 24;
if (a != 0xff)
{
d = 0;
if (a)
{
d = (*dst->fetch) (dst);
m = FbInU(d,0,a,t);
n = FbInU(d,8,a,t);
o = FbInU(d,16,a,t);
p = FbInU(d,24,a,t);
d = m|n|o|p;
}
(*dst->store) (dst, d);
}
}
void
fbCombineInReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskAlphaC (src, msk);
a = s;
if (a != 0xffffffff)
{
d = 0;
if (a)
{
d = (*dst->fetch) (dst);
m = FbInC(d,0,a,t);
n = FbInC(d,8,a,t);
o = FbInC(d,16,a,t);
p = FbInC(d,24,a,t);
d = m|n|o|p;
}
(*dst->store) (dst, d);
}
}
void
fbCombineOutU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = ~d >> 24;
s = 0;
if (a)
{
s = fbCombineMaskU (src, msk);
if (a != 0xff)
{
m = FbInU(s,0,a,t);
n = FbInU(s,8,a,t);
o = FbInU(s,16,a,t);
p = FbInU(s,24,a,t);
s = m|n|o|p;
}
}
(*dst->store) (dst, s);
}
void
fbCombineOutC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
a = ~d >> 24;
s = 0;
if (a)
{
s = fbCombineMaskValueC (src, msk);
if (a != 0xff)
{
m = FbInU(s,0,a,t);
n = FbInU(s,8,a,t);
o = FbInU(s,16,a,t);
p = FbInU(s,24,a,t);
s = m|n|o|p;
}
}
(*dst->store) (dst, s);
}
void
fbCombineOutReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskAlphaU (src, msk);
a = ~s >> 24;
if (a != 0xff)
{
d = 0;
if (a)
{
d = (*dst->fetch) (dst);
m = FbInU(d,0,a,t);
n = FbInU(d,8,a,t);
o = FbInU(d,16,a,t);
p = FbInU(d,24,a,t);
d = m|n|o|p;
}
(*dst->store) (dst, d);
}
}
void
fbCombineOutReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD32 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskAlphaC (src, msk);
a = ~s;
if (a != 0xffffffff)
{
d = 0;
if (a)
{
d = (*dst->fetch) (dst);
m = FbInC(d,0,a,t);
n = FbInC(d,8,a,t);
o = FbInC(d,16,a,t);
p = FbInC(d,24,a,t);
d = m|n|o|p;
}
(*dst->store) (dst, d);
}
}
void
fbCombineAtopU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 ad, as;
CARD16 t,u,v;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
d = (*dst->fetch) (dst);
ad = ~s >> 24;
as = d >> 24;
m = FbGen(s,d,0,as,ad,t,u,v);
n = FbGen(s,d,8,as,ad,t,u,v);
o = FbGen(s,d,16,as,ad,t,u,v);
p = FbGen(s,d,24,as,ad,t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineAtopC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
FbCompSrc cs;
CARD32 s, d;
CARD32 ad;
CARD16 as;
CARD16 t, u, v;
CARD32 m,n,o,p;
cs = fbCombineMaskC (src, msk);
d = (*dst->fetch) (dst);
s = cs.value;
ad = ~cs.alpha;
as = d >> 24;
m = FbGen(s,d,0,as,FbGet8(ad,0),t,u,v);
n = FbGen(s,d,8,as,FbGet8(ad,8),t,u,v);
o = FbGen(s,d,16,as,FbGet8(ad,16),t,u,v);
p = FbGen(s,d,24,as,FbGet8(ad,24),t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineAtopReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 ad, as;
CARD16 t, u, v;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
d = (*dst->fetch) (dst);
ad = s >> 24;
as = ~d >> 24;
m = FbGen(s,d,0,as,ad,t,u,v);
n = FbGen(s,d,8,as,ad,t,u,v);
o = FbGen(s,d,16,as,ad,t,u,v);
p = FbGen(s,d,24,as,ad,t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineAtopReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
FbCompSrc cs;
CARD32 s, d, ad;
CARD16 as;
CARD16 t, u, v;
CARD32 m,n,o,p;
cs = fbCombineMaskC (src, msk);
d = (*dst->fetch) (dst);
s = cs.value;
ad = cs.alpha;
as = ~d >> 24;
m = FbGen(s,d,0,as,FbGet8(ad,0),t,u,v);
n = FbGen(s,d,8,as,FbGet8(ad,8),t,u,v);
o = FbGen(s,d,16,as,FbGet8(ad,16),t,u,v);
p = FbGen(s,d,24,as,FbGet8(ad,24),t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineXorU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 ad, as;
CARD16 t, u, v;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
d = (*dst->fetch) (dst);
ad = ~s >> 24;
as = ~d >> 24;
m = FbGen(s,d,0,as,ad,t,u,v);
n = FbGen(s,d,8,as,ad,t,u,v);
o = FbGen(s,d,16,as,ad,t,u,v);
p = FbGen(s,d,24,as,ad,t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineXorC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
FbCompSrc cs;
CARD32 s, d, ad;
CARD16 as;
CARD16 t, u, v;
CARD32 m,n,o,p;
cs = fbCombineMaskC (src, msk);
d = (*dst->fetch) (dst);
s = cs.value;
ad = ~cs.alpha;
as = ~d >> 24;
m = FbGen(s,d,0,as,FbGet8(ad,0),t,u,v);
n = FbGen(s,d,8,as,FbGet8(ad,8),t,u,v);
o = FbGen(s,d,16,as,FbGet8(ad,16),t,u,v);
p = FbGen(s,d,24,as,FbGet8(ad,24),t,u,v);
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineAddU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
if (s == ~0)
(*dst->store) (dst, s);
else
{
d = (*dst->fetch) (dst);
if (s && d != ~0)
{
m = FbAdd(s,d,0,t);
n = FbAdd(s,d,8,t);
o = FbAdd(s,d,16,t);
p = FbAdd(s,d,24,t);
(*dst->store) (dst, m|n|o|p);
}
}
}
void
fbCombineAddC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskValueC (src, msk);
if (s == ~0)
(*dst->store) (dst, s);
else
{
d = (*dst->fetch) (dst);
if (s && d != ~0)
{
m = FbAdd(s,d,0,t);
n = FbAdd(s,d,8,t);
o = FbAdd(s,d,16,t);
p = FbAdd(s,d,24,t);
(*dst->store) (dst, m|n|o|p);
}
}
}
void
fbCombineSaturateU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s = fbCombineMaskU (src, msk), d;
CARD16 sa, da;
CARD16 ad, as;
CARD16 t, u, v;
CARD32 m,n,o,p;
d = (*dst->fetch) (dst);
sa = s >> 24;
da = ~d >> 24;
if (sa <= da)
{
m = FbAdd(s,d,0,t);
n = FbAdd(s,d,8,t);
o = FbAdd(s,d,16,t);
p = FbAdd(s,d,24,t);
}
else
{
as = (da << 8) / sa;
ad = 0xff;
m = FbGen(s,d,0,as,ad,t,u,v);
n = FbGen(s,d,8,as,ad,t,u,v);
o = FbGen(s,d,16,as,ad,t,u,v);
p = FbGen(s,d,24,as,ad,t,u,v);
}
(*dst->store) (dst, m|n|o|p);
}
void
fbCombineSaturateC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
FbCompSrc cs;
CARD32 s, d;
CARD16 sa, sr, sg, sb, da;
CARD16 t, u, v;
CARD32 m,n,o,p;
cs = fbCombineMaskC (src, msk);
d = (*dst->fetch) (dst);
s = cs.value;
sa = (cs.alpha >> 24) & 0xff;
sr = (cs.alpha >> 16) & 0xff;
sg = (cs.alpha >> 8) & 0xff;
sb = (cs.alpha ) & 0xff;
da = ~d >> 24;
if (sb <= da)
m = FbAdd(s,d,0,t);
else
m = FbGen (s, d, 0, (da << 8) / sb, 0xff, t, u, v);
if (sg <= da)
n = FbAdd(s,d,8,t);
else
n = FbGen (s, d, 8, (da << 8) / sg, 0xff, t, u, v);
if (sr <= da)
o = FbAdd(s,d,16,t);
else
o = FbGen (s, d, 16, (da << 8) / sr, 0xff, t, u, v);
if (sa <= da)
p = FbAdd(s,d,24,t);
else
p = FbGen (s, d, 24, (da << 8) / sa, 0xff, t, u, v);
(*dst->store) (dst, m|n|o|p);
}
/*
* All of the disjoint composing functions
The four entries in the first column indicate what source contributions
come from each of the four areas of the picture -- areas covered by neither
A nor B, areas covered only by A, areas covered only by B and finally
areas covered by both A and B.
Disjoint Conjoint
Fa Fb Fa Fb
(0,0,0,0) 0 0 0 0
(0,A,0,A) 1 0 1 0
(0,0,B,B) 0 1 0 1
(0,A,B,A) 1 min((1-a)/b,1) 1 max(1-a/b,0)
(0,A,B,B) min((1-b)/a,1) 1 max(1-b/a,0) 1
(0,0,0,A) max(1-(1-b)/a,0) 0 min(1,b/a) 0
(0,0,0,B) 0 max(1-(1-a)/b,0) 0 min(a/b,1)
(0,A,0,0) min(1,(1-b)/a) 0 max(1-b/a,0) 0
(0,0,B,0) 0 min(1,(1-a)/b) 0 max(1-a/b,0)
(0,0,B,A) max(1-(1-b)/a,0) min(1,(1-a)/b) min(1,b/a) max(1-a/b,0)
(0,A,0,B) min(1,(1-b)/a) max(1-(1-a)/b,0) max(1-b/a,0) min(1,a/b)
(0,A,B,0) min(1,(1-b)/a) min(1,(1-a)/b) max(1-b/a,0) max(1-a/b,0)
*/
#define CombineAOut 1
#define CombineAIn 2
#define CombineBOut 4
#define CombineBIn 8
#define CombineClear 0
#define CombineA (CombineAOut|CombineAIn)
#define CombineB (CombineBOut|CombineBIn)
#define CombineAOver (CombineAOut|CombineBOut|CombineAIn)
#define CombineBOver (CombineAOut|CombineBOut|CombineBIn)
#define CombineAAtop (CombineBOut|CombineAIn)
#define CombineBAtop (CombineAOut|CombineBIn)
#define CombineXor (CombineAOut|CombineBOut)
/* portion covered by a but not b */
CARD8
fbCombineDisjointOutPart (CARD8 a, CARD8 b)
{
/* min (1, (1-b) / a) */
b = ~b; /* 1 - b */
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
return 0xff; /* 1 */
return FbIntDiv(b,a); /* (1-b) / a */
}
/* portion covered by both a and b */
CARD8
fbCombineDisjointInPart (CARD8 a, CARD8 b)
{
/* max (1-(1-b)/a,0) */
/* = - min ((1-b)/a - 1, 0) */
/* = 1 - min (1, (1-b)/a) */
b = ~b; /* 1 - b */
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
return 0; /* 1 - 1 */
return ~FbIntDiv(b,a); /* 1 - (1-b) / a */
}
void
fbCombineDisjointGeneralU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst,
CARD8 combine)
{
CARD32 s, d;
CARD32 m,n,o,p;
CARD16 Fa, Fb, t, u, v;
CARD8 sa, da;
s = fbCombineMaskU (src, msk);
sa = s >> 24;
d = (*dst->fetch) (dst);
da = d >> 24;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
Fa = fbCombineDisjointOutPart (sa, da);
break;
case CombineAIn:
Fa = fbCombineDisjointInPart (sa, da);
break;
case CombineA:
Fa = 0xff;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
Fb = fbCombineDisjointOutPart (da, sa);
break;
case CombineBIn:
Fb = fbCombineDisjointInPart (da, sa);
break;
case CombineB:
Fb = 0xff;
break;
}
m = FbGen (s,d,0,Fa,Fb,t,u,v);
n = FbGen (s,d,8,Fa,Fb,t,u,v);
o = FbGen (s,d,16,Fa,Fb,t,u,v);
p = FbGen (s,d,24,Fa,Fb,t,u,v);
s = m|n|o|p;
(*dst->store) (dst, s);
}
void
fbCombineDisjointGeneralC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst,
CARD8 combine)
{
FbCompSrc cs;
CARD32 s, d;
CARD32 m,n,o,p;
CARD32 Fa, Fb;
CARD16 t, u, v;
CARD32 sa;
CARD8 da;
cs = fbCombineMaskC (src, msk);
s = cs.value;
sa = cs.alpha;
d = (*dst->fetch) (dst);
da = d >> 24;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
m = fbCombineDisjointOutPart ((CARD8) (sa >> 0), da);
n = fbCombineDisjointOutPart ((CARD8) (sa >> 8), da) << 8;
o = fbCombineDisjointOutPart ((CARD8) (sa >> 16), da) << 16;
p = fbCombineDisjointOutPart ((CARD8) (sa >> 24), da) << 24;
Fa = m|n|o|p;
break;
case CombineAIn:
m = fbCombineDisjointInPart ((CARD8) (sa >> 0), da);
n = fbCombineDisjointInPart ((CARD8) (sa >> 8), da) << 8;
o = fbCombineDisjointInPart ((CARD8) (sa >> 16), da) << 16;
p = fbCombineDisjointInPart ((CARD8) (sa >> 24), da) << 24;
Fa = m|n|o|p;
break;
case CombineA:
Fa = 0xffffffff;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
m = fbCombineDisjointOutPart (da, (CARD8) (sa >> 0));
n = fbCombineDisjointOutPart (da, (CARD8) (sa >> 8)) << 8;
o = fbCombineDisjointOutPart (da, (CARD8) (sa >> 16)) << 16;
p = fbCombineDisjointOutPart (da, (CARD8) (sa >> 24)) << 24;
Fb = m|n|o|p;
break;
case CombineBIn:
m = fbCombineDisjointInPart (da, (CARD8) (sa >> 0));
n = fbCombineDisjointInPart (da, (CARD8) (sa >> 8)) << 8;
o = fbCombineDisjointInPart (da, (CARD8) (sa >> 16)) << 16;
p = fbCombineDisjointInPart (da, (CARD8) (sa >> 24)) << 24;
Fb = m|n|o|p;
break;
case CombineB:
Fb = 0xffffffff;
break;
}
m = FbGen (s,d,0,FbGet8(Fa,0),FbGet8(Fb,0),t,u,v);
n = FbGen (s,d,8,FbGet8(Fa,8),FbGet8(Fb,8),t,u,v);
o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t,u,v);
p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t,u,v);
s = m|n|o|p;
(*dst->store) (dst, s);
}
void
fbCombineDisjointOverU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
a = s >> 24;
if (a != 0x00)
{
if (a != 0xff)
{
d = (*dst->fetch) (dst);
a = fbCombineDisjointOutPart (d >> 24, a);
m = FbOverU(s,d,0,a,t);
n = FbOverU(s,d,8,a,t);
o = FbOverU(s,d,16,a,t);
p = FbOverU(s,d,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
}
void
fbCombineDisjointOverC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineAOver);
}
void
fbCombineDisjointInU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineAIn);
}
void
fbCombineDisjointInC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineAIn);
}
void
fbCombineDisjointInReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineBIn);
}
void
fbCombineDisjointInReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineBIn);
}
void
fbCombineDisjointOutU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineAOut);
}
void
fbCombineDisjointOutC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineAOut);
}
void
fbCombineDisjointOutReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineBOut);
}
void
fbCombineDisjointOutReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineBOut);
}
void
fbCombineDisjointAtopU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineAAtop);
}
void
fbCombineDisjointAtopC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineAAtop);
}
void
fbCombineDisjointAtopReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineBAtop);
}
void
fbCombineDisjointAtopReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineBAtop);
}
void
fbCombineDisjointXorU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralU (src, msk, dst, CombineXor);
}
void
fbCombineDisjointXorC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineDisjointGeneralC (src, msk, dst, CombineXor);
}
/* portion covered by a but not b */
CARD8
fbCombineConjointOutPart (CARD8 a, CARD8 b)
{
/* max (1-b/a,0) */
/* = 1-min(b/a,1) */
/* min (1, (1-b) / a) */
if (b >= a) /* b >= a -> b/a >= 1 */
return 0x00; /* 0 */
return ~FbIntDiv(b,a); /* 1 - b/a */
}
/* portion covered by both a and b */
CARD8
fbCombineConjointInPart (CARD8 a, CARD8 b)
{
/* min (1,b/a) */
if (b >= a) /* b >= a -> b/a >= 1 */
return 0xff; /* 1 */
return FbIntDiv(b,a); /* b/a */
}
void
fbCombineConjointGeneralU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst,
CARD8 combine)
{
CARD32 s, d;
CARD32 m,n,o,p;
CARD16 Fa, Fb, t, u, v;
CARD8 sa, da;
s = fbCombineMaskU (src, msk);
sa = s >> 24;
d = (*dst->fetch) (dst);
da = d >> 24;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
Fa = fbCombineConjointOutPart (sa, da);
break;
case CombineAIn:
Fa = fbCombineConjointInPart (sa, da);
break;
case CombineA:
Fa = 0xff;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
Fb = fbCombineConjointOutPart (da, sa);
break;
case CombineBIn:
Fb = fbCombineConjointInPart (da, sa);
break;
case CombineB:
Fb = 0xff;
break;
}
m = FbGen (s,d,0,Fa,Fb,t,u,v);
n = FbGen (s,d,8,Fa,Fb,t,u,v);
o = FbGen (s,d,16,Fa,Fb,t,u,v);
p = FbGen (s,d,24,Fa,Fb,t,u,v);
s = m|n|o|p;
(*dst->store) (dst, s);
}
void
fbCombineConjointGeneralC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst,
CARD8 combine)
{
FbCompSrc cs;
CARD32 s, d;
CARD32 m,n,o,p;
CARD32 Fa, Fb;
CARD16 t, u, v;
CARD32 sa;
CARD8 da;
cs = fbCombineMaskC (src, msk);
s = cs.value;
sa = cs.alpha;
d = (*dst->fetch) (dst);
da = d >> 24;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
m = fbCombineConjointOutPart ((CARD8) (sa >> 0), da);
n = fbCombineConjointOutPart ((CARD8) (sa >> 8), da) << 8;
o = fbCombineConjointOutPart ((CARD8) (sa >> 16), da) << 16;
p = fbCombineConjointOutPart ((CARD8) (sa >> 24), da) << 24;
Fa = m|n|o|p;
break;
case CombineAIn:
m = fbCombineConjointInPart ((CARD8) (sa >> 0), da);
n = fbCombineConjointInPart ((CARD8) (sa >> 8), da) << 8;
o = fbCombineConjointInPart ((CARD8) (sa >> 16), da) << 16;
p = fbCombineConjointInPart ((CARD8) (sa >> 24), da) << 24;
Fa = m|n|o|p;
break;
case CombineA:
Fa = 0xffffffff;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
m = fbCombineConjointOutPart (da, (CARD8) (sa >> 0));
n = fbCombineConjointOutPart (da, (CARD8) (sa >> 8)) << 8;
o = fbCombineConjointOutPart (da, (CARD8) (sa >> 16)) << 16;
p = fbCombineConjointOutPart (da, (CARD8) (sa >> 24)) << 24;
Fb = m|n|o|p;
break;
case CombineBIn:
m = fbCombineConjointInPart (da, (CARD8) (sa >> 0));
n = fbCombineConjointInPart (da, (CARD8) (sa >> 8)) << 8;
o = fbCombineConjointInPart (da, (CARD8) (sa >> 16)) << 16;
p = fbCombineConjointInPart (da, (CARD8) (sa >> 24)) << 24;
Fb = m|n|o|p;
break;
case CombineB:
Fb = 0xffffffff;
break;
}
m = FbGen (s,d,0,FbGet8(Fa,0),FbGet8(Fb,0),t,u,v);
n = FbGen (s,d,8,FbGet8(Fa,8),FbGet8(Fb,8),t,u,v);
o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t,u,v);
p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t,u,v);
s = m|n|o|p;
(*dst->store) (dst, s);
}
void
fbCombineConjointOverU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineAOver);
/*
CARD32 s, d;
CARD16 a;
CARD16 t;
CARD32 m,n,o,p;
s = fbCombineMaskU (src, msk);
a = s >> 24;
if (a != 0x00)
{
if (a != 0xff)
{
d = (*dst->fetch) (dst);
a = fbCombineConjointOutPart (d >> 24, a);
m = FbOverU(s,d,0,a,t);
n = FbOverU(s,d,8,a,t);
o = FbOverU(s,d,16,a,t);
p = FbOverU(s,d,24,a,t);
s = m|n|o|p;
}
(*dst->store) (dst, s);
}
*/
}
void
fbCombineConjointOverC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineAOver);
}
void
fbCombineConjointOverReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineBOver);
}
void
fbCombineConjointOverReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineBOver);
}
void
fbCombineConjointInU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineAIn);
}
void
fbCombineConjointInC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineAIn);
}
void
fbCombineConjointInReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineBIn);
}
void
fbCombineConjointInReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineBIn);
}
void
fbCombineConjointOutU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineAOut);
}
void
fbCombineConjointOutC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineAOut);
}
void
fbCombineConjointOutReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineBOut);
}
void
fbCombineConjointOutReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineBOut);
}
void
fbCombineConjointAtopU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineAAtop);
}
void
fbCombineConjointAtopC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineAAtop);
}
void
fbCombineConjointAtopReverseU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineBAtop);
}
void
fbCombineConjointAtopReverseC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineBAtop);
}
void
fbCombineConjointXorU (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralU (src, msk, dst, CombineXor);
}
void
fbCombineConjointXorC (FbCompositeOperand *src,
FbCompositeOperand *msk,
FbCompositeOperand *dst)
{
fbCombineConjointGeneralC (src, msk, dst, CombineXor);
}
FbCombineFunc fbCombineFuncU[] = {
fbCombineClear,
fbCombineSrcU,
fbCombineDst,
fbCombineOverU,
fbCombineOverReverseU,
fbCombineInU,
fbCombineInReverseU,
fbCombineOutU,
fbCombineOutReverseU,
fbCombineAtopU,
fbCombineAtopReverseU,
fbCombineXorU,
fbCombineAddU,
fbCombineSaturateU,
0,
0,
fbCombineClear,
fbCombineSrcU,
fbCombineDst,
fbCombineDisjointOverU,
fbCombineSaturateU, /* DisjointOverReverse */
fbCombineDisjointInU,
fbCombineDisjointInReverseU,
fbCombineDisjointOutU,
fbCombineDisjointOutReverseU,
fbCombineDisjointAtopU,
fbCombineDisjointAtopReverseU,
fbCombineDisjointXorU,
0,
0,
0,
0,
fbCombineClear,
fbCombineSrcU,
fbCombineDst,
fbCombineConjointOverU,
fbCombineConjointOverReverseU,
fbCombineConjointInU,
fbCombineConjointInReverseU,
fbCombineConjointOutU,
fbCombineConjointOutReverseU,
fbCombineConjointAtopU,
fbCombineConjointAtopReverseU,
fbCombineConjointXorU,
};
FbCombineFunc fbCombineFuncC[] = {
fbCombineClear,
fbCombineSrcC,
fbCombineDst,
fbCombineOverC,
fbCombineOverReverseC,
fbCombineInC,
fbCombineInReverseC,
fbCombineOutC,
fbCombineOutReverseC,
fbCombineAtopC,
fbCombineAtopReverseC,
fbCombineXorC,
fbCombineAddC,
fbCombineSaturateC,
0,
0,
fbCombineClear, /* 0x10 */
fbCombineSrcC,
fbCombineDst,
fbCombineDisjointOverC,
fbCombineSaturateC, /* DisjointOverReverse */
fbCombineDisjointInC,
fbCombineDisjointInReverseC,
fbCombineDisjointOutC,
fbCombineDisjointOutReverseC,
fbCombineDisjointAtopC,
fbCombineDisjointAtopReverseC,
fbCombineDisjointXorC, /* 0x1b */
0,
0,
0,
0,
fbCombineClear,
fbCombineSrcC,
fbCombineDst,
fbCombineConjointOverC,
fbCombineConjointOverReverseC,
fbCombineConjointInC,
fbCombineConjointInReverseC,
fbCombineConjointOutC,
fbCombineConjointOutReverseC,
fbCombineConjointAtopC,
fbCombineConjointAtopReverseC,
fbCombineConjointXorC,
};
/*
* All of the fetch functions
*/
CARD32
fbFetch_a8r8g8b8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
return ((CARD32 *)line)[offset >> 5];
}
CARD32
fbFetch_x8r8g8b8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
return ((CARD32 *)line)[offset >> 5] | 0xff000000;
}
CARD32
fbFetch_a8b8g8r8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD32 *)line)[offset >> 5];
return ((pixel & 0xff000000) |
((pixel >> 16) & 0xff) |
(pixel & 0x0000ff00) |
((pixel & 0xff) << 16));
}
CARD32
fbFetch_x8b8g8r8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD32 *)line)[offset >> 5];
return ((0xff000000) |
((pixel >> 16) & 0xff) |
(pixel & 0x0000ff00) |
((pixel & 0xff) << 16));
}
CARD32
fbFetch_r8g8b8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
#if IMAGE_BYTE_ORDER == MSBFirst
return (0xff000000 |
(pixel[0] << 16) |
(pixel[1] << 8) |
(pixel[2]));
#else
return (0xff000000 |
(pixel[2] << 16) |
(pixel[1] << 8) |
(pixel[0]));
#endif
}
CARD32
fbFetch_b8g8r8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
#if IMAGE_BYTE_ORDER == MSBFirst
return (0xff000000 |
(pixel[2] << 16) |
(pixel[1] << 8) |
(pixel[0]));
#else
return (0xff000000 |
(pixel[0] << 16) |
(pixel[1] << 8) |
(pixel[2]));
#endif
}
CARD32
fbFetch_r5g6b5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
r = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) << 8;
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_b5g6r5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
b = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) >> 8;
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a1r5g5b5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 a,r,g,b;
a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
return (a | r | g | b);
}
CARD32
fbFetch_x1r5g5b5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a1b5g5r5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 a,r,g,b;
a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
return (a | r | g | b);
}
CARD32
fbFetch_x1b5g5r5 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a4r4g4b4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 a,r,g,b;
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
return (a | r | g | b);
}
CARD32
fbFetch_x4r4g4b4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a4b4g4r4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 a,r,g,b;
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
return (a | r | g | b);
}
CARD32
fbFetch_x4b4g4r4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD16 *) line)[offset >> 4];
CARD32 r,g,b;
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
return pixel << 24;
}
CARD32
fbFetcha_a8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
pixel |= pixel << 8;
pixel |= pixel << 16;
return pixel;
}
CARD32
fbFetch_r3g3b2 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
CARD32 r,g,b;
r = ((pixel & 0xe0) | ((pixel & 0xe0) >> 3) | ((pixel & 0xc0) >> 6)) << 16;
g = ((pixel & 0x1c) | ((pixel & 0x18) >> 3) | ((pixel & 0x1c) << 3)) << 8;
b = (((pixel & 0x03) ) |
((pixel & 0x03) << 2) |
((pixel & 0x03) << 4) |
((pixel & 0x03) << 6));
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_b2g3r3 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
CARD32 r,g,b;
b = (((pixel & 0xc0) ) |
((pixel & 0xc0) >> 2) |
((pixel & 0xc0) >> 4) |
((pixel & 0xc0) >> 6));
g = ((pixel & 0x38) | ((pixel & 0x38) >> 3) | ((pixel & 0x30) << 2)) << 8;
r = (((pixel & 0x07) ) |
((pixel & 0x07) << 3) |
((pixel & 0x06) << 6)) << 16;
return (0xff000000 | r | g | b);
}
CARD32
fbFetch_a2r2g2b2 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
CARD32 a,r,g,b;
a = ((pixel & 0xc0) * 0x55) << 18;
r = ((pixel & 0x30) * 0x55) << 12;
g = ((pixel & 0x0c) * 0x55) << 6;
b = ((pixel & 0x03) * 0x55);
return a|r|g|b;
}
CARD32
fbFetch_a2b2g2r2 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
CARD32 a,r,g,b;
a = ((pixel & 0xc0) * 0x55) << 18;
b = ((pixel & 0x30) * 0x55) >> 6;
g = ((pixel & 0x0c) * 0x55) << 6;
r = ((pixel & 0x03) * 0x55) << 16;
return a|r|g|b;
}
CARD32
fbFetch_c8 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD8 *) line)[offset>>3];
return op->indexed->rgba[pixel];
}
#define Fetch8(l,o) (((CARD8 *) (l))[(o) >> 3])
#if IMAGE_BYTE_ORDER == MSBFirst
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) & 0xf : Fetch8(l,o) >> 4)
#else
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
#endif
CARD32
fbFetch_a4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
pixel |= pixel << 4;
return pixel << 24;
}
CARD32
fbFetcha_a4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
pixel |= pixel << 4;
pixel |= pixel << 8;
pixel |= pixel << 16;
return pixel;
}
CARD32
fbFetch_r1g2b1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
CARD32 r,g,b;
r = ((pixel & 0x8) * 0xff) << 13;
g = ((pixel & 0x6) * 0x55) << 7;
b = ((pixel & 0x1) * 0xff);
return 0xff000000|r|g|b;
}
CARD32
fbFetch_b1g2r1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
CARD32 r,g,b;
b = ((pixel & 0x8) * 0xff) >> 3;
g = ((pixel & 0x6) * 0x55) << 7;
r = ((pixel & 0x1) * 0xff) << 16;
return 0xff000000|r|g|b;
}
CARD32
fbFetch_a1r1g1b1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
CARD32 a,r,g,b;
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) << 14;
g = ((pixel & 0x2) * 0xff) << 7;
b = ((pixel & 0x1) * 0xff);
return a|r|g|b;
}
CARD32
fbFetch_a1b1g1r1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
CARD32 a,r,g,b;
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) >> 3;
g = ((pixel & 0x2) * 0xff) << 7;
b = ((pixel & 0x1) * 0xff) << 16;
return a|r|g|b;
}
CARD32
fbFetch_c4 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = Fetch4(line, offset);
return op->indexed->rgba[pixel];
}
CARD32
fbFetcha_a1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD32 *)line)[offset >> 5];
CARD32 a;
#if BITMAP_BIT_ORDER == MSBFirst
a = pixel >> (0x1f - (offset & 0x1f));
#else
a = pixel >> (offset & 0x1f);
#endif
a = a & 1;
a |= a << 1;
a |= a << 2;
a |= a << 4;
a |= a << 8;
a |= a << 16;
return a;
}
CARD32
fbFetch_a1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD32 *)line)[offset >> 5];
CARD32 a;
#if BITMAP_BIT_ORDER == MSBFirst
a = pixel >> (0x1f - (offset & 0x1f));
#else
a = pixel >> (offset & 0x1f);
#endif
a = a & 1;
a |= a << 1;
a |= a << 2;
a |= a << 4;
return a << 24;
}
CARD32
fbFetch_g1 (FbCompositeOperand *op)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel = ((CARD32 *)line)[offset >> 5];
CARD32 a;
#if BITMAP_BIT_ORDER == MSBFirst
a = pixel >> (0x1f - (offset & 0x1f));
#else
a = pixel >> (offset & 0x1f);
#endif
a = a & 1;
return op->indexed->rgba[a];
}
/*
* All the store functions
*/
#define Splita(v) CARD32 a = ((v) >> 24), r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
#define Split(v) CARD32 r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
void
fbStore_a8r8g8b8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
((CARD32 *)line)[offset >> 5] = value;
}
void
fbStore_x8r8g8b8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
((CARD32 *)line)[offset >> 5] = value & 0xffffff;
}
void
fbStore_a8b8g8r8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
Splita(value);
((CARD32 *)line)[offset >> 5] = a << 24 | b << 16 | g << 8 | r;
}
void
fbStore_x8b8g8r8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
Split(value);
((CARD32 *)line)[offset >> 5] = b << 16 | g << 8 | r;
}
void
fbStore_r8g8b8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
Split(value);
#if IMAGE_BYTE_ORDER == MSBFirst
pixel[0] = r;
pixel[1] = g;
pixel[2] = b;
#else
pixel[0] = b;
pixel[1] = g;
pixel[2] = r;
#endif
}
void
fbStore_b8g8r8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
Split(value);
#if IMAGE_BYTE_ORDER == MSBFirst
pixel[0] = b;
pixel[1] = g;
pixel[2] = r;
#else
pixel[0] = r;
pixel[1] = g;
pixel[2] = b;
#endif
}
void
fbStore_r5g6b5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((r << 8) & 0xf800) |
((g << 3) & 0x07e0) |
((b >> 3) ));
}
void
fbStore_b5g6r5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((b << 8) & 0xf800) |
((g << 3) & 0x07e0) |
((r >> 3) ));
}
void
fbStore_a1r5g5b5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Splita(value);
*pixel = (((a << 8) & 0x8000) |
((r << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((b >> 3) ));
}
void
fbStore_x1r5g5b5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((r << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((b >> 3) ));
}
void
fbStore_a1b5g5r5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Splita(value);
*pixel = (((a << 8) & 0x8000) |
((b << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((r >> 3) ));
}
void
fbStore_x1b5g5r5 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((b << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((r >> 3) ));
}
void
fbStore_a4r4g4b4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Splita(value);
*pixel = (((a << 8) & 0xf000) |
((r << 4) & 0x0f00) |
((g ) & 0x00f0) |
((b >> 4) ));
}
void
fbStore_x4r4g4b4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((r << 4) & 0x0f00) |
((g ) & 0x00f0) |
((b >> 4) ));
}
void
fbStore_a4b4g4r4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Splita(value);
*pixel = (((a << 8) & 0xf000) |
((b << 4) & 0x0f00) |
((g ) & 0x00f0) |
((r >> 4) ));
}
void
fbStore_x4b4g4r4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD16 *pixel = ((CARD16 *) line) + (offset >> 4);
Split(value);
*pixel = (((b << 4) & 0x0f00) |
((g ) & 0x00f0) |
((r >> 4) ));
}
void
fbStore_a8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
*pixel = value >> 24;
}
void
fbStore_r3g3b2 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
Split(value);
*pixel = (((r ) & 0xe0) |
((g >> 3) & 0x1c) |
((b >> 6) ));
}
void
fbStore_b2g3r3 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
Split(value);
*pixel = (((b ) & 0xe0) |
((g >> 3) & 0x1c) |
((r >> 6) ));
}
void
fbStore_a2r2g2b2 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
Splita(value);
*pixel = (((a ) & 0xc0) |
((r >> 2) & 0x30) |
((g >> 4) & 0x0c) |
((b >> 6) ));
}
void
fbStore_c8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
*pixel = miIndexToEnt24(op->indexed,value);
}
void
fbStore_g8 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
*pixel = miIndexToEntY24(op->indexed,value);
}
#define Store8(l,o,v) (((CARD8 *) l)[(o) >> 3] = (v))
#if IMAGE_BYTE_ORDER == MSBFirst
#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
(Fetch8(l,o) & 0xf0) | (v) : \
(Fetch8(l,o) & 0x0f) | ((v) << 4)))
#else
#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
(Fetch8(l,o) & 0x0f) | ((v) << 4) : \
(Fetch8(l,o) & 0xf0) | (v)))
#endif
void
fbStore_a4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
Store4(line,offset,value>>28);
}
void
fbStore_r1g2b1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
Split(value);
pixel = (((r >> 4) & 0x8) |
((g >> 5) & 0x6) |
((b >> 7) ));
Store4(line,offset,pixel);
}
void
fbStore_b1g2r1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
Split(value);
pixel = (((b >> 4) & 0x8) |
((g >> 5) & 0x6) |
((r >> 7) ));
Store4(line,offset,pixel);
}
void
fbStore_a1r1g1b1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
Splita(value);
pixel = (((a >> 4) & 0x8) |
((r >> 5) & 0x4) |
((g >> 6) & 0x2) |
((b >> 7) ));
Store4(line,offset,pixel);
}
void
fbStore_a1b1g1r1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
Splita(value);
pixel = (((a >> 4) & 0x8) |
((b >> 5) & 0x4) |
((g >> 6) & 0x2) |
((r >> 7) ));
Store4(line,offset,pixel);
}
void
fbStore_c4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
pixel = miIndexToEnt24(op->indexed,value);
Store4(line,offset,pixel);
}
void
fbStore_g4 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 pixel;
pixel = miIndexToEntY24(op->indexed,value);
Store4(line,offset,pixel);
}
void
fbStore_a1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 *pixel = ((CARD32 *) line) + (offset >> 5);
CARD32 mask = FbStipMask(offset & 0x1f, 1);
value = value & 0x80000000 ? mask : 0;
*pixel = (*pixel & ~mask) | value;
}
void
fbStore_g1 (FbCompositeOperand *op, CARD32 value)
{
FbBits *line = op->u.drawable.line; CARD32 offset = op->u.drawable.offset;
CARD32 *pixel = ((CARD32 *) line) + (offset >> 5);
CARD32 mask = FbStipMask(offset & 0x1f, 1);
value = miIndexToEntY24(op->indexed,value) ? mask : 0;
*pixel = (*pixel & ~mask) | value;
}
CARD32
fbFetch_external (FbCompositeOperand *op)
{
CARD32 rgb = (*op[1].fetch) (&op[1]);
CARD32 a = (*op[2].fetch) (&op[2]);
return (rgb & 0xffffff) | (a & 0xff000000);
}
CARD32
fbFetcha_external (FbCompositeOperand *op)
{
return (*op[2].fetch) (&op[2]);
}
void
fbStore_external (FbCompositeOperand *op, CARD32 value)
{
(*op[1].store) (&op[1], value | 0xff000000);
(*op[2].store) (&op[2], value & 0xff000000);
}
#define dummyScreen screenInfo.screens[0]
CARD32
fbFetch_transform (FbCompositeOperand *op)
{
PictVector v;
int x, y;
int minx, maxx, miny, maxy;
int n;
BoxRec box;
CARD32 rtot, gtot, btot, atot;
CARD32 xerr, yerr;
CARD32 bits;
v.vector[0] = IntToxFixed(op->u.transform.x);
v.vector[1] = IntToxFixed(op->u.transform.y);
v.vector[2] = xFixed1;
if (!PictureTransformPoint (op->u.transform.transform, &v))
return 0;
switch (op->u.transform.filter) {
case PictFilterNearest:
y = xFixedToInt (v.vector[1]) + op->u.transform.top_y;
x = xFixedToInt (v.vector[0]) + op->u.transform.left_x;
if (POINT_IN_REGION (dummyScreen, op->clip, x, y, &box))
{
(*op[1].set) (&op[1], x, y);
bits = (*op[1].fetch) (&op[1]);
}
else
bits = 0;
break;
case PictFilterBilinear:
rtot = gtot = btot = atot = 0;
miny = xFixedToInt (v.vector[1]) + op->u.transform.top_y;
maxy = xFixedToInt (xFixedCeil (v.vector[1])) + op->u.transform.top_y;
minx = xFixedToInt (v.vector[0]) + op->u.transform.left_x;
maxx = xFixedToInt (xFixedCeil (v.vector[0])) + op->u.transform.left_x;
yerr = xFixed1 - xFixedFrac (v.vector[1]);
for (y = miny; y <= maxy; y++)
{
CARD32 lrtot = 0, lgtot = 0, lbtot = 0, latot = 0;
xerr = xFixed1 - xFixedFrac (v.vector[0]);
for (x = minx; x <= maxx; x++)
{
if (POINT_IN_REGION (dummyScreen, op->clip, x, y, &box))
{
(*op[1].set) (&op[1], x, y);
bits = (*op[1].fetch) (&op[1]);
{
Splita(bits);
lrtot += r * xerr;
lgtot += g * xerr;
lbtot += b * xerr;
latot += a * xerr;
n++;
}
}
xerr = xFixed1 - xerr;
}
rtot += (lrtot >> 10) * yerr;
gtot += (lgtot >> 10) * yerr;
btot += (lbtot >> 10) * yerr;
atot += (latot >> 10) * yerr;
yerr = xFixed1 - yerr;
}
if ((atot >>= 22) > 0xff) atot = 0xff;
if ((rtot >>= 22) > 0xff) rtot = 0xff;
if ((gtot >>= 22) > 0xff) gtot = 0xff;
if ((btot >>= 22) > 0xff) btot = 0xff;
bits = ((atot << 24) |
(rtot << 16) |
(gtot << 8) |
(btot ));
break;
default:
bits = 0;
break;
}
return bits;
}
CARD32
fbFetcha_transform (FbCompositeOperand *op)
{
PictVector v;
int x, y;
int minx, maxx, miny, maxy;
int n;
BoxRec box;
CARD32 rtot, gtot, btot, atot;
CARD32 xerr, yerr;
CARD32 bits;
v.vector[0] = IntToxFixed(op->u.transform.x);
v.vector[1] = IntToxFixed(op->u.transform.y);
v.vector[2] = xFixed1;
if (!PictureTransformPoint (op->u.transform.transform, &v))
return 0;
switch (op->u.transform.filter) {
case PictFilterNearest:
y = xFixedToInt (v.vector[1]) + op->u.transform.left_x;
x = xFixedToInt (v.vector[0]) + op->u.transform.top_y;
if (POINT_IN_REGION (dummyScreen, op->clip, x, y, &box))
{
(*op[1].set) (&op[1], x, y);
bits = (*op[1].fetcha) (&op[1]);
}
else
bits = 0;
break;
case PictFilterBilinear:
rtot = gtot = btot = atot = 0;
miny = xFixedToInt (v.vector[1]) + op->u.transform.top_y;
maxy = xFixedToInt (xFixedCeil (v.vector[1])) + op->u.transform.top_y;
minx = xFixedToInt (v.vector[0]) + op->u.transform.left_x;
maxx = xFixedToInt (xFixedCeil (v.vector[0])) + op->u.transform.left_x;
yerr = xFixed1 - xFixedFrac (v.vector[1]);
for (y = miny; y <= maxy; y++)
{
CARD32 lrtot = 0, lgtot = 0, lbtot = 0, latot = 0;
xerr = xFixed1 - xFixedFrac (v.vector[0]);
for (x = minx; x <= maxx; x++)
{
if (POINT_IN_REGION (dummyScreen, op->clip, x, y, &box))
{
(*op[1].set) (&op[1], x, y);
bits = (*op[1].fetcha) (&op[1]);
{
Splita(bits);
lrtot += r * xerr;
lgtot += g * xerr;
lbtot += b * xerr;
latot += a * xerr;
n++;
}
}
x++;
xerr = xFixed1 - xerr;
}
rtot += (lrtot >> 10) * yerr;
gtot += (lgtot >> 10) * yerr;
btot += (lbtot >> 10) * yerr;
atot += (latot >> 10) * yerr;
y++;
yerr = xFixed1 - yerr;
}
if ((atot >>= 22) > 0xff) atot = 0xff;
if ((rtot >>= 22) > 0xff) rtot = 0xff;
if ((gtot >>= 22) > 0xff) gtot = 0xff;
if ((btot >>= 22) > 0xff) btot = 0xff;
bits = ((atot << 24) |
(rtot << 16) |
(gtot << 8) |
(btot ));
break;
default:
bits = 0;
break;
}
return bits;
}
FbAccessMap fbAccessMap[] = {
/* 32bpp formats */
{ PICT_a8r8g8b8, fbFetch_a8r8g8b8, fbFetch_a8r8g8b8, fbStore_a8r8g8b8 },
{ PICT_x8r8g8b8, fbFetch_x8r8g8b8, fbFetch_x8r8g8b8, fbStore_x8r8g8b8 },
{ PICT_a8b8g8r8, fbFetch_a8b8g8r8, fbFetch_a8b8g8r8, fbStore_a8b8g8r8 },
{ PICT_x8b8g8r8, fbFetch_x8b8g8r8, fbFetch_x8b8g8r8, fbStore_x8b8g8r8 },
/* 24bpp formats */
{ PICT_r8g8b8, fbFetch_r8g8b8, fbFetch_r8g8b8, fbStore_r8g8b8 },
{ PICT_b8g8r8, fbFetch_b8g8r8, fbFetch_b8g8r8, fbStore_b8g8r8 },
/* 16bpp formats */
{ PICT_r5g6b5, fbFetch_r5g6b5, fbFetch_r5g6b5, fbStore_r5g6b5 },
{ PICT_b5g6r5, fbFetch_b5g6r5, fbFetch_b5g6r5, fbStore_b5g6r5 },
{ PICT_a1r5g5b5, fbFetch_a1r5g5b5, fbFetch_a1r5g5b5, fbStore_a1r5g5b5 },
{ PICT_x1r5g5b5, fbFetch_x1r5g5b5, fbFetch_x1r5g5b5, fbStore_x1r5g5b5 },
{ PICT_a1b5g5r5, fbFetch_a1b5g5r5, fbFetch_a1b5g5r5, fbStore_a1b5g5r5 },
{ PICT_x1b5g5r5, fbFetch_x1b5g5r5, fbFetch_x1b5g5r5, fbStore_x1b5g5r5 },
{ PICT_a4r4g4b4, fbFetch_a4r4g4b4, fbFetch_a4r4g4b4, fbStore_a4r4g4b4 },
{ PICT_x4r4g4b4, fbFetch_x4r4g4b4, fbFetch_x4r4g4b4, fbStore_x4r4g4b4 },
{ PICT_a4b4g4r4, fbFetch_a4b4g4r4, fbFetch_a4b4g4r4, fbStore_a4b4g4r4 },
{ PICT_x4b4g4r4, fbFetch_x4b4g4r4, fbFetch_x4b4g4r4, fbStore_x4b4g4r4 },
/* 8bpp formats */
{ PICT_a8, fbFetch_a8, fbFetcha_a8, fbStore_a8 },
{ PICT_r3g3b2, fbFetch_r3g3b2, fbFetch_r3g3b2, fbStore_r3g3b2 },
{ PICT_b2g3r3, fbFetch_b2g3r3, fbFetch_b2g3r3, fbStore_b2g3r3 },
{ PICT_a2r2g2b2, fbFetch_a2r2g2b2, fbFetch_a2r2g2b2, fbStore_a2r2g2b2 },
{ PICT_c8, fbFetch_c8, fbFetch_c8, fbStore_c8 },
{ PICT_g8, fbFetch_c8, fbFetch_c8, fbStore_g8 },
/* 4bpp formats */
{ PICT_a4, fbFetch_a4, fbFetcha_a4, fbStore_a4 },
{ PICT_r1g2b1, fbFetch_r1g2b1, fbFetch_r1g2b1, fbStore_r1g2b1 },
{ PICT_b1g2r1, fbFetch_b1g2r1, fbFetch_b1g2r1, fbStore_b1g2r1 },
{ PICT_a1r1g1b1, fbFetch_a1r1g1b1, fbFetch_a1r1g1b1, fbStore_a1r1g1b1 },
{ PICT_a1b1g1r1, fbFetch_a1b1g1r1, fbFetch_a1b1g1r1, fbStore_a1b1g1r1 },
{ PICT_c4, fbFetch_c4, fbFetch_c4, fbStore_c4 },
{ PICT_g4, fbFetch_c4, fbFetch_c4, fbStore_g4 },
/* 1bpp formats */
{ PICT_a1, fbFetch_a1, fbFetcha_a1, fbStore_a1 },
{ PICT_g1, fbFetch_g1, fbFetch_g1, fbStore_g1 },
};
#define NumAccessMap (sizeof fbAccessMap / sizeof fbAccessMap[0])
static void
fbStepOver (FbCompositeOperand *op)
{
op->u.drawable.offset += op->u.drawable.bpp;
}
static void
fbStepDown (FbCompositeOperand *op)
{
op->u.drawable.line += op->u.drawable.stride;
op->u.drawable.offset = op->u.drawable.start_offset;
}
static void
fbSet (FbCompositeOperand *op, int x, int y)
{
op->u.drawable.line = op->u.drawable.top_line + y * op->u.drawable.stride;
op->u.drawable.offset = op->u.drawable.left_offset + x * op->u.drawable.bpp;
}
static void
fbStepOver_external (FbCompositeOperand *op)
{
(*op[1].over) (&op[1]);
(*op[2].over) (&op[2]);
}
static void
fbStepDown_external (FbCompositeOperand *op)
{
(*op[1].down) (&op[1]);
(*op[2].down) (&op[2]);
}
static void
fbSet_external (FbCompositeOperand *op, int x, int y)
{
(*op[1].set) (&op[1], x, y);
(*op[2].set) (&op[2],
x - op->u.external.alpha_dx,
y - op->u.external.alpha_dy);
}
static void
fbStepOver_transform (FbCompositeOperand *op)
{
op->u.transform.x++;
}
static void
fbStepDown_transform (FbCompositeOperand *op)
{
op->u.transform.y++;
op->u.transform.x = op->u.transform.start_x;
}
static void
fbSet_transform (FbCompositeOperand *op, int x, int y)
{
op->u.transform.x = x - op->u.transform.left_x;
op->u.transform.y = y - op->u.transform.top_y;
}
Bool
fbBuildCompositeOperand (PicturePtr pPict,
FbCompositeOperand op[4],
INT16 x,
INT16 y,
Bool transform,
Bool alpha)
{
/* Check for transform */
if (transform && pPict->transform)
{
if (!fbBuildCompositeOperand (pPict, &op[1], 0, 0, FALSE, alpha))
return FALSE;
op->u.transform.top_y = pPict->pDrawable->y;
op->u.transform.left_x = pPict->pDrawable->x;
op->u.transform.start_x = x - op->u.transform.left_x;
op->u.transform.x = op->u.transform.start_x;
op->u.transform.y = y - op->u.transform.top_y;
op->u.transform.transform = pPict->transform;
op->u.transform.filter = pPict->filter;
op->fetch = fbFetch_transform;
op->fetcha = fbFetcha_transform;
op->store = 0;
op->over = fbStepOver_transform;
op->down = fbStepDown_transform;
op->set = fbSet_transform;
op->indexed = (miIndexedPtr) pPict->pFormat->index.devPrivate;
op->clip = op[1].clip;
return TRUE;
}
/* Check for external alpha */
else if (alpha && pPict->alphaMap)
{
if (!fbBuildCompositeOperand (pPict, &op[1], x, y, FALSE, FALSE))
return FALSE;
if (!fbBuildCompositeOperand (pPict->alphaMap, &op[2],
x - pPict->alphaOrigin.x,
y - pPict->alphaOrigin.y,
FALSE, FALSE))
return FALSE;
op->u.external.alpha_dx = pPict->alphaOrigin.x;
op->u.external.alpha_dy = pPict->alphaOrigin.y;
op->fetch = fbFetch_external;
op->fetcha = fbFetcha_external;
op->store = fbStore_external;
op->over = fbStepOver_external;
op->down = fbStepDown_external;
op->set = fbSet_external;
op->indexed = (miIndexedPtr) pPict->pFormat->index.devPrivate;
/* XXX doesn't handle external alpha clips yet */
op->clip = op[1].clip;
return TRUE;
}
/* Build simple operand */
else
{
int i;
int xoff, yoff;
for (i = 0; i < NumAccessMap; i++)
if (fbAccessMap[i].format == pPict->format)
{
FbBits *bits;
FbStride stride;
int bpp;
op->fetch = fbAccessMap[i].fetch;
op->fetcha = fbAccessMap[i].fetcha;
op->store = fbAccessMap[i].store;
op->over = fbStepOver;
op->down = fbStepDown;
op->set = fbSet;
op->indexed = (miIndexedPtr) pPict->pFormat->index.devPrivate;
op->clip = pPict->pCompositeClip;
fbGetDrawable (pPict->pDrawable, bits, stride, bpp,
xoff, yoff);
if (pPict->repeat && pPict->pDrawable->width == 1 &&
pPict->pDrawable->height == 1)
{
bpp = 0;
stride = 0;
}
/*
* Coordinates of upper left corner of drawable
*/
op->u.drawable.top_line = bits + yoff * stride;
op->u.drawable.left_offset = xoff * bpp;
/*
* Starting position within drawable
*/
op->u.drawable.start_offset = op->u.drawable.left_offset + x * bpp;
op->u.drawable.line = op->u.drawable.top_line + y * stride;
op->u.drawable.offset = op->u.drawable.start_offset;
op->u.drawable.stride = stride;
op->u.drawable.bpp = bpp;
return TRUE;
}
return FALSE;
}
}
void
fbCompositeGeneral (CARD8 op,
PicturePtr pSrc,
PicturePtr pMask,
PicturePtr pDst,
INT16 xSrc,
INT16 ySrc,
INT16 xMask,
INT16 yMask,
INT16 xDst,
INT16 yDst,
CARD16 width,
CARD16 height)
{
FbCompositeOperand src[4],msk[4],dst[4],*pmsk;
FbCombineFunc f;
int w;
#if 0
ErrorF ("op: %d\n"
"src format: %lx\n"
"msk format %lx\n"
"dst format %lx\n"
"width: %d\n"
"height %d\n",
op,
pSrc? pSrc->format : 0,
pMask? pMask->format : 0,
pDst? pDst->format : 0,
width, height);
ErrorF ("PICT_x8r8g8b8: %lx\n", PICT_x8r8g8b8);
#endif
if (!fbBuildCompositeOperand (pSrc, src, xSrc, ySrc, TRUE, TRUE))
return;
if (!fbBuildCompositeOperand (pDst, dst, xDst, yDst, FALSE, TRUE))
return;
f = fbCombineFuncU[op];
if (pMask)
{
if (!fbBuildCompositeOperand (pMask, msk, xMask, yMask, TRUE, TRUE))
return;
pmsk = msk;
if (pMask->componentAlpha)
f = fbCombineFuncC[op];
}
else
pmsk = 0;
while (height--)
{
w = width;
while (w--)
{
(*f) (src, pmsk, dst);
(*src->over) (src);
(*dst->over) (dst);
if (pmsk)
(*pmsk->over) (pmsk);
}
(*src->down) (src);
(*dst->down) (dst);
if (pmsk)
(*pmsk->down) (pmsk);
}
}
Reference in New Issue View Git Blame Copy Permalink