pixman-combine32.c [plain text]
#line 1 "combine.inc"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include "pixman-private.h"
#include "pixman-combine32.h"
FASTCALL static void
pixman_fbCombineMaskU (uint32_t *src, const uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t a = *(mask + i) >> A_SHIFT;
uint32_t s = *(src + i);
FbByteMul(s, a);
*(src + i) = s;
}
}
FASTCALL static void
fbCombineClear (uint32_t *dest, const uint32_t *src, int width)
{
memset(dest, 0, width*sizeof(uint32_t));
}
FASTCALL static void
fbCombineSrcU (uint32_t *dest, const uint32_t *src, int width)
{
memcpy(dest, src, width*sizeof(uint32_t));
}
FASTCALL static void
fbCombineOverU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t ia = Alpha(~s);
FbByteMulAdd(d, ia, s);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineOverReverseU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t ia = Alpha(~*(dest + i));
FbByteMulAdd(s, ia, d);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineInU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t a = Alpha(*(dest + i));
FbByteMul(s, a);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineInReverseU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t a = Alpha(*(src + i));
FbByteMul(d, a);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineOutU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t a = Alpha(~*(dest + i));
FbByteMul(s, a);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineOutReverseU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t a = Alpha(~*(src + i));
FbByteMul(d, a);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineAtopU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t dest_a = Alpha(d);
uint32_t src_ia = Alpha(~s);
FbByteAddMul(s, dest_a, d, src_ia);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineAtopReverseU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t src_a = Alpha(s);
uint32_t dest_ia = Alpha(~d);
FbByteAddMul(s, dest_ia, d, src_a);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineXorU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t src_ia = Alpha(~s);
uint32_t dest_ia = Alpha(~d);
FbByteAddMul(s, dest_ia, d, src_ia);
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineAddU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
FbByteAdd(d, s);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineSaturateU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint16_t sa, da;
sa = s >> A_SHIFT;
da = ~d >> A_SHIFT;
if (sa > da)
{
sa = IntDiv(da, sa);
FbByteMul(s, sa);
};
FbByteAdd(d, s);
*(dest + i) = d;
}
}
#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)
FASTCALL static uint8_t
fbCombineDisjointOutPart (uint8_t a, uint8_t b)
{
b = ~b;
if (b >= a)
return MASK;
return IntDiv(b,a);
}
FASTCALL static uint8_t
fbCombineDisjointInPart (uint8_t a, uint8_t b)
{
b = ~b;
if (b >= a)
return 0;
return ~IntDiv(b,a);
}
FASTCALL static uint8_t
fbCombineConjointOutPart (uint8_t a, uint8_t b)
{
if (b >= a)
return 0x00;
return ~IntDiv(b,a);
}
FASTCALL static uint8_t
fbCombineConjointInPart (uint8_t a, uint8_t b)
{
if (b >= a)
return MASK;
return IntDiv(b,a);
}
FASTCALL static void
fbCombineDisjointGeneralU (uint32_t *dest, const uint32_t *src, int width, uint8_t combine)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t m,n,o,p;
uint16_t Fa, Fb, t, u, v;
uint8_t sa = s >> A_SHIFT;
uint8_t da = d >> A_SHIFT;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
Fa = fbCombineDisjointOutPart (sa, da);
break;
case CombineAIn:
Fa = fbCombineDisjointInPart (sa, da);
break;
case CombineA:
Fa = MASK;
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 = MASK;
break;
}
m = FbGen (s,d,0,Fa,Fb,t, u, v);
n = FbGen (s,d,G_SHIFT,Fa,Fb,t, u, v);
o = FbGen (s,d,R_SHIFT,Fa,Fb,t, u, v);
p = FbGen (s,d,A_SHIFT,Fa,Fb,t, u, v);
s = m|n|o|p;
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineDisjointOverU (uint32_t *dest, const uint32_t *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint16_t a = s >> A_SHIFT;
if (a != 0x00)
{
if (a != MASK)
{
uint32_t d = *(dest + i);
a = fbCombineDisjointOutPart (d >> A_SHIFT, a);
FbByteMulAdd(d, a, s);
s = d;
}
*(dest + i) = s;
}
}
}
FASTCALL static void
fbCombineDisjointInU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineAIn);
}
FASTCALL static void
fbCombineDisjointInReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineBIn);
}
FASTCALL static void
fbCombineDisjointOutU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineAOut);
}
FASTCALL static void
fbCombineDisjointOutReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineBOut);
}
FASTCALL static void
fbCombineDisjointAtopU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineAAtop);
}
FASTCALL static void
fbCombineDisjointAtopReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineBAtop);
}
FASTCALL static void
fbCombineDisjointXorU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineDisjointGeneralU (dest, src, width, CombineXor);
}
FASTCALL static void
fbCombineConjointGeneralU (uint32_t *dest, const uint32_t *src, int width, uint8_t combine)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t m,n,o,p;
uint16_t Fa, Fb, t, u, v;
uint8_t sa = s >> A_SHIFT;
uint8_t da = d >> A_SHIFT;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
Fa = fbCombineConjointOutPart (sa, da);
break;
case CombineAIn:
Fa = fbCombineConjointInPart (sa, da);
break;
case CombineA:
Fa = MASK;
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 = MASK;
break;
}
m = FbGen (s,d,0,Fa,Fb,t, u, v);
n = FbGen (s,d,G_SHIFT,Fa,Fb,t, u, v);
o = FbGen (s,d,R_SHIFT,Fa,Fb,t, u, v);
p = FbGen (s,d,A_SHIFT,Fa,Fb,t, u, v);
s = m|n|o|p;
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineConjointOverU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineAOver);
}
FASTCALL static void
fbCombineConjointOverReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineBOver);
}
FASTCALL static void
fbCombineConjointInU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineAIn);
}
FASTCALL static void
fbCombineConjointInReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineBIn);
}
FASTCALL static void
fbCombineConjointOutU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineAOut);
}
FASTCALL static void
fbCombineConjointOutReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineBOut);
}
FASTCALL static void
fbCombineConjointAtopU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineAAtop);
}
FASTCALL static void
fbCombineConjointAtopReverseU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineBAtop);
}
FASTCALL static void
fbCombineConjointXorU (uint32_t *dest, const uint32_t *src, int width)
{
fbCombineConjointGeneralU (dest, src, width, CombineXor);
}
FASTCALL static void
fbCombineMaskC (uint32_t *src, uint32_t *mask)
{
uint32_t a = *mask;
uint32_t x;
uint16_t xa;
if (!a)
{
*(src) = 0;
return;
}
x = *(src);
if (a == ~0)
{
x = x >> A_SHIFT;
x |= x << G_SHIFT;
x |= x << R_SHIFT;
*(mask) = x;
return;
}
xa = x >> A_SHIFT;
FbByteMulC(x, a);
*(src) = x;
FbByteMul(a, xa);
*(mask) = a;
}
FASTCALL static void
fbCombineMaskValueC (uint32_t *src, const uint32_t *mask)
{
uint32_t a = *mask;
uint32_t x;
if (!a)
{
*(src) = 0;
return;
}
if (a == ~0)
return;
x = *(src);
FbByteMulC(x, a);
*(src) =x;
}
FASTCALL static void
fbCombineMaskAlphaC (const uint32_t *src, uint32_t *mask)
{
uint32_t a = *(mask);
uint32_t x;
if (!a)
return;
x = *(src) >> A_SHIFT;
if (x == MASK)
return;
if (a == ~0)
{
x = x >> A_SHIFT;
x |= x << G_SHIFT;
x |= x << R_SHIFT;
*(mask) = x;
return;
}
FbByteMul(a, x);
*(mask) = a;
}
FASTCALL static void
fbCombineClearC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
memset(dest, 0, width*sizeof(uint32_t));
}
FASTCALL static void
fbCombineSrcC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
fbCombineMaskValueC (&s, &m);
*(dest) = s;
}
}
FASTCALL static void
fbCombineOverC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
fbCombineMaskC (&s, &m);
a = ~m;
if (a != ~0)
{
if (a)
{
uint32_t d = *(dest + i);
FbByteMulAddC(d, a, s);
s = d;
}
*(dest + i) = s;
}
}
}
FASTCALL static void
fbCombineOverReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t a = ~d >> A_SHIFT;
if (a)
{
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
fbCombineMaskValueC (&s, &m);
if (a != MASK)
{
FbByteMulAdd(s, a, d);
}
*(dest + i) = s;
}
}
}
FASTCALL static void
fbCombineInC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint16_t a = d >> A_SHIFT;
uint32_t s = 0;
if (a)
{
uint32_t m = *(mask + i);
s = *(src + i);
fbCombineMaskValueC (&s, &m);
if (a != MASK)
{
FbByteMul(s, a);
}
}
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineInReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
fbCombineMaskAlphaC (&s, &m);
a = m;
if (a != ~0)
{
uint32_t d = 0;
if (a)
{
d = *(dest + i);
FbByteMulC(d, a);
}
*(dest + i) = d;
}
}
}
FASTCALL static void
fbCombineOutC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint16_t a = ~d >> A_SHIFT;
uint32_t s = 0;
if (a)
{
uint32_t m = *(mask + i);
s = *(src + i);
fbCombineMaskValueC (&s, &m);
if (a != MASK)
{
FbByteMul(s, a);
}
}
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineOutReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
fbCombineMaskAlphaC (&s, &m);
a = ~m;
if (a != ~0)
{
uint32_t d = 0;
if (a)
{
d = *(dest + i);
FbByteMulC(d, a);
}
*(dest + i) = d;
}
}
}
FASTCALL static void
fbCombineAtopC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = d >> A_SHIFT;
fbCombineMaskC (&s, &m);
ad = ~m;
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineAtopReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = ~d >> A_SHIFT;
fbCombineMaskC (&s, &m);
ad = m;
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineXorC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = ~d >> A_SHIFT;
fbCombineMaskC (&s, &m);
ad = ~m;
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineAddC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t d = *(dest + i);
fbCombineMaskValueC (&s, &m);
FbByteAdd(d, s);
*(dest + i) = d;
}
}
FASTCALL static void
fbCombineSaturateC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint16_t sa, sr, sg, sb, da;
uint16_t t, u, v;
uint32_t m,n,o,p;
d = *(dest + i);
s = *(src + i);
m = *(mask + i);
fbCombineMaskC (&s, &m);
sa = (m >> A_SHIFT);
sr = (m >> R_SHIFT) & MASK;
sg = (m >> G_SHIFT) & MASK;
sb = m & MASK;
da = ~d >> A_SHIFT;
if (sb <= da)
m = Add(s,d,0,t);
else
m = FbGen (s, d, 0, (da << G_SHIFT) / sb, MASK, t, u, v);
if (sg <= da)
n = Add(s,d,G_SHIFT,t);
else
n = FbGen (s, d, G_SHIFT, (da << G_SHIFT) / sg, MASK, t, u, v);
if (sr <= da)
o = Add(s,d,R_SHIFT,t);
else
o = FbGen (s, d, R_SHIFT, (da << G_SHIFT) / sr, MASK, t, u, v);
if (sa <= da)
p = Add(s,d,A_SHIFT,t);
else
p = FbGen (s, d, A_SHIFT, (da << G_SHIFT) / sa, MASK, t, u, v);
*(dest + i) = m|n|o|p;
}
}
FASTCALL static void
fbCombineDisjointGeneralC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width, uint8_t combine)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint32_t m,n,o,p;
uint32_t Fa, Fb;
uint16_t t, u, v;
uint32_t sa;
uint8_t da;
s = *(src + i);
m = *(mask + i);
d = *(dest + i);
da = d >> A_SHIFT;
fbCombineMaskC (&s, &m);
sa = m;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
m = (uint32_t)fbCombineDisjointOutPart ((uint8_t) (sa >> 0), da);
n = (uint32_t)fbCombineDisjointOutPart ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
o = (uint32_t)fbCombineDisjointOutPart ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
p = (uint32_t)fbCombineDisjointOutPart ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
Fa = m|n|o|p;
break;
case CombineAIn:
m = (uint32_t)fbCombineDisjointInPart ((uint8_t) (sa >> 0), da);
n = (uint32_t)fbCombineDisjointInPart ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
o = (uint32_t)fbCombineDisjointInPart ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
p = (uint32_t)fbCombineDisjointInPart ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
Fa = m|n|o|p;
break;
case CombineA:
Fa = ~0;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
m = (uint32_t)fbCombineDisjointOutPart (da, (uint8_t) (sa >> 0));
n = (uint32_t)fbCombineDisjointOutPart (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
o = (uint32_t)fbCombineDisjointOutPart (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
p = (uint32_t)fbCombineDisjointOutPart (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
Fb = m|n|o|p;
break;
case CombineBIn:
m = (uint32_t)fbCombineDisjointInPart (da, (uint8_t) (sa >> 0));
n = (uint32_t)fbCombineDisjointInPart (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
o = (uint32_t)fbCombineDisjointInPart (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
p = (uint32_t)fbCombineDisjointInPart (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
Fb = m|n|o|p;
break;
case CombineB:
Fb = ~0;
break;
}
m = FbGen (s,d,0,GetComp(Fa,0),GetComp(Fb,0),t, u, v);
n = FbGen (s,d,G_SHIFT,GetComp(Fa,G_SHIFT),GetComp(Fb,G_SHIFT),t, u, v);
o = FbGen (s,d,R_SHIFT,GetComp(Fa,R_SHIFT),GetComp(Fb,R_SHIFT),t, u, v);
p = FbGen (s,d,A_SHIFT,GetComp(Fa,A_SHIFT),GetComp(Fb,A_SHIFT),t, u, v);
s = m|n|o|p;
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineDisjointOverC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineAOver);
}
FASTCALL static void
fbCombineDisjointInC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineAIn);
}
FASTCALL static void
fbCombineDisjointInReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineBIn);
}
FASTCALL static void
fbCombineDisjointOutC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineAOut);
}
FASTCALL static void
fbCombineDisjointOutReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineBOut);
}
FASTCALL static void
fbCombineDisjointAtopC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineAAtop);
}
FASTCALL static void
fbCombineDisjointAtopReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineBAtop);
}
FASTCALL static void
fbCombineDisjointXorC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineDisjointGeneralC (dest, src, mask, width, CombineXor);
}
FASTCALL static void
fbCombineConjointGeneralC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width, uint8_t combine)
{
int i;
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint32_t m,n,o,p;
uint32_t Fa, Fb;
uint16_t t, u, v;
uint32_t sa;
uint8_t da;
s = *(src + i);
m = *(mask + i);
d = *(dest + i);
da = d >> A_SHIFT;
fbCombineMaskC (&s, &m);
sa = m;
switch (combine & CombineA) {
default:
Fa = 0;
break;
case CombineAOut:
m = (uint32_t)fbCombineConjointOutPart ((uint8_t) (sa >> 0), da);
n = (uint32_t)fbCombineConjointOutPart ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
o = (uint32_t)fbCombineConjointOutPart ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
p = (uint32_t)fbCombineConjointOutPart ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
Fa = m|n|o|p;
break;
case CombineAIn:
m = (uint32_t)fbCombineConjointInPart ((uint8_t) (sa >> 0), da);
n = (uint32_t)fbCombineConjointInPart ((uint8_t) (sa >> G_SHIFT), da) << G_SHIFT;
o = (uint32_t)fbCombineConjointInPart ((uint8_t) (sa >> R_SHIFT), da) << R_SHIFT;
p = (uint32_t)fbCombineConjointInPart ((uint8_t) (sa >> A_SHIFT), da) << A_SHIFT;
Fa = m|n|o|p;
break;
case CombineA:
Fa = ~0;
break;
}
switch (combine & CombineB) {
default:
Fb = 0;
break;
case CombineBOut:
m = (uint32_t)fbCombineConjointOutPart (da, (uint8_t) (sa >> 0));
n = (uint32_t)fbCombineConjointOutPart (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
o = (uint32_t)fbCombineConjointOutPart (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
p = (uint32_t)fbCombineConjointOutPart (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
Fb = m|n|o|p;
break;
case CombineBIn:
m = (uint32_t)fbCombineConjointInPart (da, (uint8_t) (sa >> 0));
n = (uint32_t)fbCombineConjointInPart (da, (uint8_t) (sa >> G_SHIFT)) << G_SHIFT;
o = (uint32_t)fbCombineConjointInPart (da, (uint8_t) (sa >> R_SHIFT)) << R_SHIFT;
p = (uint32_t)fbCombineConjointInPart (da, (uint8_t) (sa >> A_SHIFT)) << A_SHIFT;
Fb = m|n|o|p;
break;
case CombineB:
Fb = ~0;
break;
}
m = FbGen (s,d,0,GetComp(Fa,0),GetComp(Fb,0),t, u, v);
n = FbGen (s,d,G_SHIFT,GetComp(Fa,G_SHIFT),GetComp(Fb,G_SHIFT),t, u, v);
o = FbGen (s,d,R_SHIFT,GetComp(Fa,R_SHIFT),GetComp(Fb,R_SHIFT),t, u, v);
p = FbGen (s,d,A_SHIFT,GetComp(Fa,A_SHIFT),GetComp(Fb,A_SHIFT),t, u, v);
s = m|n|o|p;
*(dest + i) = s;
}
}
FASTCALL static void
fbCombineConjointOverC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineAOver);
}
FASTCALL static void
fbCombineConjointOverReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineBOver);
}
FASTCALL static void
fbCombineConjointInC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineAIn);
}
FASTCALL static void
fbCombineConjointInReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineBIn);
}
FASTCALL static void
fbCombineConjointOutC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineAOut);
}
FASTCALL static void
fbCombineConjointOutReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineBOut);
}
FASTCALL static void
fbCombineConjointAtopC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineAAtop);
}
FASTCALL static void
fbCombineConjointAtopReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineBAtop);
}
FASTCALL static void
fbCombineConjointXorC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
fbCombineConjointGeneralC (dest, src, mask, width, CombineXor);
}
static CombineFuncU32 pixman_fbCombineFuncU[] = {
fbCombineClear,
fbCombineSrcU,
NULL,
fbCombineOverU,
fbCombineOverReverseU,
fbCombineInU,
fbCombineInReverseU,
fbCombineOutU,
fbCombineOutReverseU,
fbCombineAtopU,
fbCombineAtopReverseU,
fbCombineXorU,
fbCombineAddU,
fbCombineSaturateU,
NULL,
NULL,
fbCombineClear,
fbCombineSrcU,
NULL,
fbCombineDisjointOverU,
fbCombineSaturateU,
fbCombineDisjointInU,
fbCombineDisjointInReverseU,
fbCombineDisjointOutU,
fbCombineDisjointOutReverseU,
fbCombineDisjointAtopU,
fbCombineDisjointAtopReverseU,
fbCombineDisjointXorU,
NULL,
NULL,
NULL,
NULL,
fbCombineClear,
fbCombineSrcU,
NULL,
fbCombineConjointOverU,
fbCombineConjointOverReverseU,
fbCombineConjointInU,
fbCombineConjointInReverseU,
fbCombineConjointOutU,
fbCombineConjointOutReverseU,
fbCombineConjointAtopU,
fbCombineConjointAtopReverseU,
fbCombineConjointXorU,
};
static CombineFuncC32 pixman_fbCombineFuncC[] = {
fbCombineClearC,
fbCombineSrcC,
NULL,
fbCombineOverC,
fbCombineOverReverseC,
fbCombineInC,
fbCombineInReverseC,
fbCombineOutC,
fbCombineOutReverseC,
fbCombineAtopC,
fbCombineAtopReverseC,
fbCombineXorC,
fbCombineAddC,
fbCombineSaturateC,
NULL,
NULL,
fbCombineClearC,
fbCombineSrcC,
NULL,
fbCombineDisjointOverC,
fbCombineSaturateC,
fbCombineDisjointInC,
fbCombineDisjointInReverseC,
fbCombineDisjointOutC,
fbCombineDisjointOutReverseC,
fbCombineDisjointAtopC,
fbCombineDisjointAtopReverseC,
fbCombineDisjointXorC,
NULL,
NULL,
NULL,
NULL,
fbCombineClearC,
fbCombineSrcC,
NULL,
fbCombineConjointOverC,
fbCombineConjointOverReverseC,
fbCombineConjointInC,
fbCombineConjointInReverseC,
fbCombineConjointOutC,
fbCombineConjointOutReverseC,
fbCombineConjointAtopC,
fbCombineConjointAtopReverseC,
fbCombineConjointXorC,
};
FbComposeFunctions32 pixman_composeFunctions = {
pixman_fbCombineFuncU,
pixman_fbCombineFuncC,
pixman_fbCombineMaskU
};