+++ /dev/null
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string.h>
-
-#include "pixman-private.h"
-
-/*
- * Helper macros.
- */
-
-#define FbGen(x,y,i,ax,ay,t,u,v) ((t) = (FbIntMult(FbGet8(y,i),ay,(u)) + \
- FbIntMult(FbGet8(x,i),ax,(v))), \
- (uint32_t) ((uint8_t) ((t) | \
- (0 - ((t) >> 8)))) << (i))
-
-
-/*
- The methods below use some tricks to be able to do two color
- components at the same time.
-*/
-
-/*
- x_c = (x_c * a) / 255
-*/
-#define FbByteMul(x, a) do { \
- uint32_t t = ((x & 0xff00ff) * a) + 0x800080; \
- t = (t + ((t >> 8) & 0xff00ff)) >> 8; \
- t &= 0xff00ff; \
- \
- x = (((x >> 8) & 0xff00ff) * a) + 0x800080; \
- x = (x + ((x >> 8) & 0xff00ff)); \
- x &= 0xff00ff00; \
- x += t; \
- } while (0)
-
-/*
- x_c = (x_c * a) / 255 + y
-*/
-#define FbByteMulAdd(x, a, y) do { \
- uint32_t t = ((x & 0xff00ff) * a) + 0x800080; \
- t = (t + ((t >> 8) & 0xff00ff)) >> 8; \
- t &= 0xff00ff; \
- t += y & 0xff00ff; \
- t |= 0x1000100 - ((t >> 8) & 0xff00ff); \
- t &= 0xff00ff; \
- \
- x = (((x >> 8) & 0xff00ff) * a) + 0x800080; \
- x = (x + ((x >> 8) & 0xff00ff)) >> 8; \
- x &= 0xff00ff; \
- x += (y >> 8) & 0xff00ff; \
- x |= 0x1000100 - ((x >> 8) & 0xff00ff); \
- x &= 0xff00ff; \
- x <<= 8; \
- x += t; \
- } while (0)
-
-/*
- x_c = (x_c * a + y_c * b) / 255
-*/
-#define FbByteAddMul(x, a, y, b) do { \
- uint32_t t; \
- uint32_t r = (x >> 24) * a + (y >> 24) * b + 0x80; \
- r += (r >> 8); \
- r >>= 8; \
- \
- t = (x & 0xff00) * a + (y & 0xff00) * b; \
- t += (t >> 8) + 0x8000; \
- t >>= 16; \
- \
- t |= r << 16; \
- t |= 0x1000100 - ((t >> 8) & 0xff00ff); \
- t &= 0xff00ff; \
- t <<= 8; \
- \
- r = ((x >> 16) & 0xff) * a + ((y >> 16) & 0xff) * b + 0x80; \
- r += (r >> 8); \
- r >>= 8; \
- \
- x = (x & 0xff) * a + (y & 0xff) * b + 0x80; \
- x += (x >> 8); \
- x >>= 8; \
- x |= r << 16; \
- x |= 0x1000100 - ((x >> 8) & 0xff00ff); \
- x &= 0xff00ff; \
- x |= t; \
- } while (0)
-
-/*
- x_c = (x_c * a + y_c *b) / 256
-*/
-#define FbByteAddMul_256(x, a, y, b) do { \
- uint32_t t = (x & 0xff00ff) * a + (y & 0xff00ff) * b; \
- t >>= 8; \
- t &= 0xff00ff; \
- \
- x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b; \
- x &= 0xff00ff00; \
- x += t; \
- } while (0)
-
-/*
- x_c = (x_c * a_c) / 255
-*/
-#define FbByteMulC(x, a) do { \
- uint32_t t; \
- uint32_t r = (x & 0xff) * (a & 0xff); \
- r |= (x & 0xff0000) * ((a >> 16) & 0xff); \
- r += 0x800080; \
- r = (r + ((r >> 8) & 0xff00ff)) >> 8; \
- r &= 0xff00ff; \
- \
- x >>= 8; \
- t = (x & 0xff) * ((a >> 8) & 0xff); \
- t |= (x & 0xff0000) * (a >> 24); \
- t += 0x800080; \
- t = t + ((t >> 8) & 0xff00ff); \
- x = r | (t & 0xff00ff00); \
- \
- } while (0)
-
-/*
- x_c = (x_c * a) / 255 + y
-*/
-#define FbByteMulAddC(x, a, y) do { \
- uint32_t t; \
- uint32_t r = (x & 0xff) * (a & 0xff); \
- r |= (x & 0xff0000) * ((a >> 16) & 0xff); \
- r += 0x800080; \
- r = (r + ((r >> 8) & 0xff00ff)) >> 8; \
- r &= 0xff00ff; \
- r += y & 0xff00ff; \
- r |= 0x1000100 - ((r >> 8) & 0xff00ff); \
- r &= 0xff00ff; \
- \
- x >>= 8; \
- t = (x & 0xff) * ((a >> 8) & 0xff); \
- t |= (x & 0xff0000) * (a >> 24); \
- t += 0x800080; \
- t = (t + ((t >> 8) & 0xff00ff)) >> 8; \
- t &= 0xff00ff; \
- t += (y >> 8) & 0xff00ff; \
- t |= 0x1000100 - ((t >> 8) & 0xff00ff); \
- t &= 0xff00ff; \
- x = r | (t << 8); \
- } while (0)
-
-/*
- x_c = (x_c * a_c + y_c * b) / 255
-*/
-#define FbByteAddMulC(x, a, y, b) do { \
- uint32_t t; \
- uint32_t r = (x >> 24) * (a >> 24) + (y >> 24) * b; \
- r += (r >> 8) + 0x80; \
- r >>= 8; \
- \
- t = (x & 0xff00) * ((a >> 8) & 0xff) + (y & 0xff00) * b; \
- t += (t >> 8) + 0x8000; \
- t >>= 16; \
- \
- t |= r << 16; \
- t |= 0x1000100 - ((t >> 8) & 0xff00ff); \
- t &= 0xff00ff; \
- t <<= 8; \
- \
- r = ((x >> 16) & 0xff) * ((a >> 16) & 0xff) + ((y >> 16) & 0xff) * b + 0x80; \
- r += (r >> 8); \
- r >>= 8; \
- \
- x = (x & 0xff) * (a & 0xff) + (y & 0xff) * b + 0x80; \
- x += (x >> 8); \
- x >>= 8; \
- x |= r << 16; \
- x |= 0x1000100 - ((x >> 8) & 0xff00ff); \
- x &= 0xff00ff; \
- x |= t; \
- } while (0)
-
-/*
- x_c = min(x_c + y_c, 255)
-*/
-#define FbByteAdd(x, y) do { \
- uint32_t t; \
- uint32_t r = (x & 0xff00ff) + (y & 0xff00ff); \
- r |= 0x1000100 - ((r >> 8) & 0xff00ff); \
- r &= 0xff00ff; \
- \
- t = ((x >> 8) & 0xff00ff) + ((y >> 8) & 0xff00ff); \
- t |= 0x1000100 - ((t >> 8) & 0xff00ff); \
- r |= (t & 0xff00ff) << 8; \
- x = r; \
- } while (0)
-
-
-/*
- * There are two ways of handling alpha -- either as a single unified value or
- * a separate value for each component, hence each macro must have two
- * versions. The unified alpha version has a 'U' at the end of the name,
- * the component version has a 'C'. Similarly, functions which deal with
- * this difference will have two versions using the same convention.
- */
-
-/*
- * Combine src and mask
- */
-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) >> 24;
- uint32_t s = *(src + i);
- FbByteMul(s, a);
- *(src + i) = s;
- }
-}
-
-/*
- * All of the composing functions
- */
-
-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));
-}
-
-/* if the Src is opaque, call fbCombineSrcU */
-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;
- }
-}
-
-/* if the Dst is opaque, this is a noop */
-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;
- }
-}
-
-/* if the Dst is opaque, call fbCombineSrcU */
-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;
- }
-}
-
-/* if the Src is opaque, this is a noop */
-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;
- }
-}
-
-/* if the Dst is opaque, call fbCombineClear */
-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;
- }
-}
-
-/* if the Src is opaque, call fbCombineClear */
-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;
- }
-}
-
-/* if the Src is opaque, call fbCombineInU */
-/* if the Dst is opaque, call fbCombineOverU */
-/* if both the Src and Dst are opaque, call fbCombineSrcU */
-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;
- }
-}
-
-/* if the Src is opaque, call fbCombineOverReverseU */
-/* if the Dst is opaque, call fbCombineInReverseU */
-/* if both the Src and Dst are opaque, call fbCombineDstU */
-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;
- }
-}
-
-/* if the Src is opaque, call fbCombineOverU */
-/* if the Dst is opaque, call fbCombineOverReverseU */
-/* if both the Src and Dst are opaque, call fbCombineClear */
-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;
- }
-}
-
-/* if the Src is opaque, call fbCombineAddU */
-/* if the Dst is opaque, call fbCombineAddU */
-/* if both the Src and Dst are opaque, call fbCombineAddU */
-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 >> 24;
- da = ~d >> 24;
- if (sa > da)
- {
- sa = FbIntDiv(da, sa);
- FbByteMul(s, sa);
- };
- FbByteAdd(d, s);
- *(dest + i) = d;
- }
-}
-
-
-/*
- * 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 */
-FASTCALL static uint8_t
-fbCombineDisjointOutPart (uint8_t a, uint8_t 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 */
-FASTCALL static uint8_t
-fbCombineDisjointInPart (uint8_t a, uint8_t 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 */
-}
-
-/* portion covered by a but not b */
-FASTCALL static uint8_t
-fbCombineConjointOutPart (uint8_t a, uint8_t 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 */
-FASTCALL static uint8_t
-fbCombineConjointInPart (uint8_t a, uint8_t b)
-{
- /* min (1,b/a) */
-
- if (b >= a) /* b >= a -> b/a >= 1 */
- return 0xff; /* 1 */
- return FbIntDiv(b,a); /* 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 >> 24;
- uint8_t 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;
- *(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 >> 24;
-
- if (a != 0x00)
- {
- if (a != 0xff)
- {
- uint32_t d = *(dest + i);
- a = fbCombineDisjointOutPart (d >> 24, 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 >> 24;
- uint8_t 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;
- *(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);
-}
-
-/********************************************************************************/
-/*************************** Per Channel functions ******************************/
-/********************************************************************************/
-
-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 == 0xffffffff)
- {
- x = x >> 24;
- x |= x << 8;
- x |= x << 16;
- *(mask) = x;
- return;
- }
-
- xa = x >> 24;
- 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 == 0xffffffff)
- 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) >> 24;
- if (x == 0xff)
- return;
- if (a == 0xffffffff)
- {
- x = x >> 24;
- x |= x << 8;
- x |= x << 16;
- *(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 != 0xffffffff)
- {
- 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 >> 24;
-
- if (a)
- {
- uint32_t s = *(src + i);
- uint32_t m = *(mask + i);
-
- fbCombineMaskValueC (&s, &m);
-
- if (a != 0xff)
- {
- 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 >> 24;
- uint32_t s = 0;
- if (a)
- {
- uint32_t m = *(mask + i);
-
- s = *(src + i);
- fbCombineMaskValueC (&s, &m);
- if (a != 0xff)
- {
- 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 != 0xffffffff)
- {
- 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 >> 24;
- uint32_t s = 0;
- if (a)
- {
- uint32_t m = *(mask + i);
-
- s = *(src + i);
- fbCombineMaskValueC (&s, &m);
-
- if (a != 0xff)
- {
- 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 != 0xffffffff)
- {
- 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 >> 24;
-
- 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 >> 24;
-
- 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 >> 24;
-
- 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 >> 24);
- sr = (m >> 16) & 0xff;
- sg = (m >> 8) & 0xff;
- sb = (m ) & 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);
-
- *(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 >> 24;
-
- fbCombineMaskC (&s, &m);
-
- sa = m;
-
- switch (combine & CombineA) {
- default:
- Fa = 0;
- break;
- case CombineAOut:
- m = fbCombineDisjointOutPart ((uint8_t) (sa >> 0), da);
- n = fbCombineDisjointOutPart ((uint8_t) (sa >> 8), da) << 8;
- o = fbCombineDisjointOutPart ((uint8_t) (sa >> 16), da) << 16;
- p = fbCombineDisjointOutPart ((uint8_t) (sa >> 24), da) << 24;
- Fa = m|n|o|p;
- break;
- case CombineAIn:
- m = fbCombineDisjointInPart ((uint8_t) (sa >> 0), da);
- n = fbCombineDisjointInPart ((uint8_t) (sa >> 8), da) << 8;
- o = fbCombineDisjointInPart ((uint8_t) (sa >> 16), da) << 16;
- p = fbCombineDisjointInPart ((uint8_t) (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, (uint8_t) (sa >> 0));
- n = fbCombineDisjointOutPart (da, (uint8_t) (sa >> 8)) << 8;
- o = fbCombineDisjointOutPart (da, (uint8_t) (sa >> 16)) << 16;
- p = fbCombineDisjointOutPart (da, (uint8_t) (sa >> 24)) << 24;
- Fb = m|n|o|p;
- break;
- case CombineBIn:
- m = fbCombineDisjointInPart (da, (uint8_t) (sa >> 0));
- n = fbCombineDisjointInPart (da, (uint8_t) (sa >> 8)) << 8;
- o = fbCombineDisjointInPart (da, (uint8_t) (sa >> 16)) << 16;
- p = fbCombineDisjointInPart (da, (uint8_t) (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;
- *(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 >> 24;
-
- fbCombineMaskC (&s, &m);
-
- sa = m;
-
- switch (combine & CombineA) {
- default:
- Fa = 0;
- break;
- case CombineAOut:
- m = fbCombineConjointOutPart ((uint8_t) (sa >> 0), da);
- n = fbCombineConjointOutPart ((uint8_t) (sa >> 8), da) << 8;
- o = fbCombineConjointOutPart ((uint8_t) (sa >> 16), da) << 16;
- p = fbCombineConjointOutPart ((uint8_t) (sa >> 24), da) << 24;
- Fa = m|n|o|p;
- break;
- case CombineAIn:
- m = fbCombineConjointInPart ((uint8_t) (sa >> 0), da);
- n = fbCombineConjointInPart ((uint8_t) (sa >> 8), da) << 8;
- o = fbCombineConjointInPart ((uint8_t) (sa >> 16), da) << 16;
- p = fbCombineConjointInPart ((uint8_t) (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, (uint8_t) (sa >> 0));
- n = fbCombineConjointOutPart (da, (uint8_t) (sa >> 8)) << 8;
- o = fbCombineConjointOutPart (da, (uint8_t) (sa >> 16)) << 16;
- p = fbCombineConjointOutPart (da, (uint8_t) (sa >> 24)) << 24;
- Fb = m|n|o|p;
- break;
- case CombineBIn:
- m = fbCombineConjointInPart (da, (uint8_t) (sa >> 0));
- n = fbCombineConjointInPart (da, (uint8_t) (sa >> 8)) << 8;
- o = fbCombineConjointInPart (da, (uint8_t) (sa >> 16)) << 16;
- p = fbCombineConjointInPart (da, (uint8_t) (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;
- *(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 CombineFuncU pixman_fbCombineFuncU[] = {
- fbCombineClear,
- fbCombineSrcU,
- NULL, /* CombineDst */
- fbCombineOverU,
- fbCombineOverReverseU,
- fbCombineInU,
- fbCombineInReverseU,
- fbCombineOutU,
- fbCombineOutReverseU,
- fbCombineAtopU,
- fbCombineAtopReverseU,
- fbCombineXorU,
- fbCombineAddU,
- fbCombineSaturateU,
- NULL,
- NULL,
- fbCombineClear,
- fbCombineSrcU,
- NULL, /* CombineDst */
- fbCombineDisjointOverU,
- fbCombineSaturateU, /* DisjointOverReverse */
- fbCombineDisjointInU,
- fbCombineDisjointInReverseU,
- fbCombineDisjointOutU,
- fbCombineDisjointOutReverseU,
- fbCombineDisjointAtopU,
- fbCombineDisjointAtopReverseU,
- fbCombineDisjointXorU,
- NULL,
- NULL,
- NULL,
- NULL,
- fbCombineClear,
- fbCombineSrcU,
- NULL, /* CombineDst */
- fbCombineConjointOverU,
- fbCombineConjointOverReverseU,
- fbCombineConjointInU,
- fbCombineConjointInReverseU,
- fbCombineConjointOutU,
- fbCombineConjointOutReverseU,
- fbCombineConjointAtopU,
- fbCombineConjointAtopReverseU,
- fbCombineConjointXorU,
- NULL /* Noop */
-};
-
-static CombineFuncC pixman_fbCombineFuncC[] = {
- fbCombineClearC,
- fbCombineSrcC,
- NULL, /* Dest */
- fbCombineOverC,
- fbCombineOverReverseC,
- fbCombineInC,
- fbCombineInReverseC,
- fbCombineOutC,
- fbCombineOutReverseC,
- fbCombineAtopC,
- fbCombineAtopReverseC,
- fbCombineXorC,
- fbCombineAddC,
- fbCombineSaturateC,
- NULL,
- NULL,
- fbCombineClearC, /* 0x10 */
- fbCombineSrcC,
- NULL, /* Dest */
- fbCombineDisjointOverC,
- fbCombineSaturateC, /* DisjointOverReverse */
- fbCombineDisjointInC,
- fbCombineDisjointInReverseC,
- fbCombineDisjointOutC,
- fbCombineDisjointOutReverseC,
- fbCombineDisjointAtopC,
- fbCombineDisjointAtopReverseC,
- fbCombineDisjointXorC, /* 0x1b */
- NULL,
- NULL,
- NULL,
- NULL,
- fbCombineClearC,
- fbCombineSrcC,
- NULL, /* Dest */
- fbCombineConjointOverC,
- fbCombineConjointOverReverseC,
- fbCombineConjointInC,
- fbCombineConjointInReverseC,
- fbCombineConjointOutC,
- fbCombineConjointOutReverseC,
- fbCombineConjointAtopC,
- fbCombineConjointAtopReverseC,
- fbCombineConjointXorC,
- NULL /* Noop */
-};
-
-FbComposeFunctions pixman_composeFunctions = {
- pixman_fbCombineFuncU,
- pixman_fbCombineFuncC,
- pixman_fbCombineMaskU
-};
projects / platform / upstream / pixman.git / commitdiff