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

Integrate David Turner's gradient optimizations from pixman

This commit is contained in:
Soren Sandmann Pedersen 2007-04-20 13:23:58 -04:00
parent cd2c1714eb
commit 9c4b14d4f6
1 changed files with 261 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
fb/fbcompose.c
View File

@ -2795,78 +2795,233 @@ static void fbFetch(PicturePtr pict, int x, int y, int width, CARD32 *buffer, CA
#define DIV(a,b) ((((a) < 0) == ((b) < 0)) ? (a) / (b) : \ #define DIV(a,b) ((((a) < 0) == ((b) < 0)) ? (a) / (b) : \
((a) - (b) + 1 - (((b) < 0) << 1)) / (b)) ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
static CARD32 typedef struct
xRenderColorMultToCard32 (xRenderColor *c)
{ {
return CARD32 left_ag;
((((CARD32) c->red * c->alpha) >> 24) << 16) | CARD32 left_rb;
((((CARD32) c->green * c->alpha) >> 24) << 8) | CARD32 right_ag;
((((CARD32) c->blue * c->alpha) >> 24) << 0) | CARD32 right_rb;
((((CARD32) c->alpha ) >> 8) << 24); int32_t left_x;
int32_t right_x;
int32_t width_x;
int32_t stepper;
PictGradientStopPtr stops;
int num_stops;
unsigned int spread;
} GradientWalker;
static void
_gradient_walker_init (GradientWalker *walker,
SourcePictPtr pGradient,
unsigned int spread)
{
walker->num_stops = pGradient->gradient.nstops;
walker->stops = pGradient->gradient.stops;
walker->left_x = 0;
walker->right_x = 0x10000;
walker->width_x = 0; /* will force a reset */
walker->stepper = 0;
walker->left_ag = 0;
walker->left_rb = 0;
walker->right_ag = 0;
walker->right_rb = 0;
walker->spread = spread;
} }
static CARD32 gradientPixel(const SourcePictPtr pGradient, xFixed_48_16 pos, unsigned int spread) static void
_gradient_walker_reset (GradientWalker *walker,
xFixed_32_32 pos)
{ {
int ipos = (pos * pGradient->gradient.stopRange - 1) >> 16; int32_t x, left_x, right_x;
xRenderColor *left_c, *right_c;
int n, count = walker->num_stops;
PictGradientStopPtr stops = walker->stops;
/* calculate the actual offset. */ static const xRenderColor transparent_black = { 0, 0, 0, 0 };
if (ipos < 0 || ipos >= pGradient->gradient.stopRange)
switch (walker->spread)
{ {
if (pGradient->type == SourcePictTypeConical || spread == RepeatNormal) case RepeatNormal:
{ x = (int32_t)pos & 0xFFFF;
ipos = ipos % pGradient->gradient.stopRange; for (n = 0; n < count; n++)
ipos = ipos < 0 ? pGradient->gradient.stopRange + ipos : ipos; if (x < stops[n].x)
break;
if (n == 0) {
left_x = stops[count-1].x - 0x10000;
left_c = &stops[count-1].color;
} else {
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
} }
else if (spread == RepeatReflect)
{
const int limit = pGradient->gradient.stopRange * 2 - 1;
ipos = ipos % limit; if (n == count) {
ipos = ipos < 0 ? limit + ipos : ipos; right_x = stops[0].x + 0x10000;
ipos = ipos >= pGradient->gradient.stopRange ? limit - ipos : ipos; right_c = &stops[0].color;
} else {
right_x = stops[n].x;
right_c = &stops[n].color;
}
left_x += (pos - x);
right_x += (pos - x);
break;
case RepeatPad:
for (n = 0; n < count; n++)
if (pos < stops[n].x)
break;
if (n == 0) {
left_x = INT_MIN;
left_c = &stops[0].color;
} else {
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
} }
else if (spread == RepeatPad)
{ if (n == count) {
if (ipos < 0) right_x = INT_MAX;
ipos = 0; right_c = &stops[n-1].color;
else } else {
ipos = pGradient->gradient.stopRange - 1; right_x = stops[n].x;
right_c = &stops[n].color;
} }
else /* RepeatNone */ break;
case RepeatReflect:
x = (int32_t)pos & 0xFFFF;
if ((int32_t)pos & 0x10000)
x = 0x10000 - x;
for (n = 0; n < count; n++)
if (x < stops[n].x)
break;
if (n == 0) {
left_x = -stops[0].x;
left_c = &stops[0].color;
} else {
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
}
if (n == count) {
right_x = 0x20000 - stops[n-1].x;
right_c = &stops[n-1].color;
} else {
right_x = stops[n].x;
right_c = &stops[n].color;
}
if ((int32_t)pos & 0x10000) {
xRenderColor *tmp_c;
int32_t tmp_x;
tmp_x = 0x20000 - right_x;
right_x = 0x20000 - left_x;
left_x = tmp_x;
tmp_c = right_c;
right_c = left_c;
left_c = tmp_c;
}
left_x += (pos - x);
right_x += (pos - x);
break;
default: /* RepeatNone */
for (n = 0; n < count; n++)
if (pos < stops[n].x)
break;
if (n == 0)
{ {
return 0; left_x = INT_MIN;
right_x = stops[0].x;
left_c = right_c = (xRenderColor*) &transparent_black;
}
else if (n == count)
{
left_x = stops[n-1].x;
right_x = INT_MAX;
left_c = right_c = (xRenderColor*) &transparent_black;
}
else
{
left_x = stops[n-1].x;
right_x = stops[n].x;
left_c = &stops[n-1].color;
right_c = &stops[n].color;
} }
} }
if (pGradient->gradient.colorTableSize) walker->left_x = left_x;
walker->right_x = right_x;
walker->width_x = right_x - left_x;
walker->left_ag = ((left_c->alpha >> 8) << 16) | (left_c->green >> 8);
walker->left_rb = ((left_c->red & 0xff00) << 8) | (left_c->blue >> 8);
walker->right_ag = ((right_c->alpha >> 8) << 16) | (right_c->green >> 8);
walker->right_rb = ((right_c->red & 0xff00) << 8) | (right_c->blue >> 8);
if ( walker->width_x == 0 ||
( walker->left_ag == walker->right_ag &&
walker->left_rb == walker->right_rb ) )
{ {
return pGradient->gradient.colorTable[ipos]; walker->width_x = 1;
walker->stepper = 0;
} }
else else
{ {
int i; walker->stepper = ((1 << 24) + walker->width_x/2)/walker->width_x;
if (ipos <= pGradient->gradient.stops->x)
return xRenderColorMultToCard32 (&pGradient->gradient.stops->color);
for (i = 1; i < pGradient->gradient.nstops; i++)
{
if (pGradient->gradient.stops[i].x >= ipos)
return PictureGradientColor (&pGradient->gradient.stops[i - 1],
&pGradient->gradient.stops[i],
ipos);
}
return xRenderColorMultToCard32 (&pGradient->gradient.stops[--i].color);
} }
} }
#define GRADIENT_WALKER_NEED_RESET(w,x) \
( (x) < (w)->left_x || (x) - (w)->left_x >= (w)->width_x )
/* the following assumes that GRADIENT_WALKER_NEED_RESET(w,x) is FALSE */
static CARD32
_gradient_walker_pixel (GradientWalker *walker,
xFixed_32_32 x)
{
int dist, idist;
CARD32 t1, t2, a, color;
if (GRADIENT_WALKER_NEED_RESET (walker, x))
_gradient_walker_reset (walker, x);
dist = ((int)(x - walker->left_x)*walker->stepper) >> 16;
idist = 256 - dist;
/* combined INTERPOLATE and premultiply */
t1 = walker->left_rb*idist + walker->right_rb*dist;
t1 = (t1 >> 8) & 0xff00ff;
t2 = walker->left_ag*idist + walker->right_ag*dist;
t2 &= 0xff00ff00;
color = t2 & 0xff000000;
a = t2 >> 24;
t1 = t1*a + 0x800080;
t1 = (t1 + ((t1 >> 8) & 0xff00ff)) >> 8;
t2 = (t2 >> 8)*a + 0x800080;
t2 = (t2 + ((t2 >> 8) & 0xff00ff));
return (color | (t1 & 0xff00ff) | (t2 & 0xff00));
}
static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *buffer, CARD32 *mask, CARD32 maskBits) static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *buffer, CARD32 *mask, CARD32 maskBits)
{ {
#if 0
SourcePictPtr pGradient = pict->pSourcePict; SourcePictPtr pGradient = pict->pSourcePict;
CARD32 *end = buffer + width; CARD32 *end = buffer + width;
#endif
SourcePictPtr pGradient = pict->pSourcePict;
GradientWalker walker;
CARD32 *end = buffer + width;
_gradient_walker_init (&walker, pGradient, pict->repeat);
if (pGradient->type == SourcePictTypeSolidFill) { if (pGradient->type == SourcePictTypeSolidFill) {
register CARD32 color = pGradient->solidFill.color; register CARD32 color = pGradient->solidFill.color;
@ -2917,20 +3072,29 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
{ {
register CARD32 color; register CARD32 color;
color = gradientPixel (pGradient, t, pict->repeat); color = _gradient_walker_pixel( &walker, t );
while (buffer < end) while (buffer < end)
*buffer++ = color; *buffer++ = color;
} }
else else
{ {
while (buffer < end) { if (!mask) {
if (!mask || *mask++ & maskBits) while (buffer < end)
{ {
*buffer = gradientPixel (pGradient, t, pict->repeat); *buffer = _gradient_walker_pixel (&walker, t);
} buffer += 1;
++buffer; t += inc;
t += inc; }
} } else {
while (buffer < end) {
if (*mask++ & maskBits)
{
*buffer = _gradient_walker_pixel (&walker, t);
}
buffer += 1;
t += inc;
}
}
} }
} }
else /* projective transformation */ else /* projective transformation */
@ -2954,7 +3118,10 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
t = ((a * x + b * y) >> 16) + off; t = ((a * x + b * y) >> 16) + off;
} }
#if 0
color = gradientPixel (pGradient, t, pict->repeat); color = gradientPixel (pGradient, t, pict->repeat);
#endif
color = _gradient_walker_pixel( &walker, t );
while (buffer < end) while (buffer < end)
*buffer++ = color; *buffer++ = color;
} }
@ -2972,7 +3139,7 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
y = ((xFixed_48_16)v.vector[1] << 16) / v.vector[2]; y = ((xFixed_48_16)v.vector[1] << 16) / v.vector[2];
t = ((a*x + b*y) >> 16) + off; t = ((a*x + b*y) >> 16) + off;
} }
*buffer = gradientPixel(pGradient, t, pict->repeat); *buffer = _gradient_walker_pixel (&walker, t);
} }
++buffer; ++buffer;
v.vector[0] += unit.vector[0]; v.vector[0] += unit.vector[0];
@ -3019,13 +3186,16 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
if (!mask || *mask++ & maskBits) if (!mask || *mask++ & maskBits)
{ {
xFixed_48_16 t;
b = 2*(rx*pGradient->radial.dx + ry*pGradient->radial.dy); b = 2*(rx*pGradient->radial.dx + ry*pGradient->radial.dy);
c = -(rx*rx + ry*ry); c = -(rx*rx + ry*ry);
det = (b * b) - (4 * pGradient->radial.a * c); det = (b * b) - (4 * pGradient->radial.a * c);
s = (-b + sqrt(det))/(2. * pGradient->radial.a); s = (-b + sqrt(det))/(2. * pGradient->radial.a);
WRITE(buffer, gradientPixel(pGradient,
(xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536), t = (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536);
pict->repeatType));
*buffer = _gradient_walker_pixel (&walker, t);
} }
++buffer; ++buffer;
@ -3039,6 +3209,8 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
if (!mask || *mask++ & maskBits) if (!mask || *mask++ & maskBits)
{ {
xFixed_48_16 t;
if (rz != 0) { if (rz != 0) {
x = rx/rz; x = rx/rz;
y = ry/rz; y = ry/rz;
@ -3051,9 +3223,9 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
c = -(x*x + y*y); c = -(x*x + y*y);
det = (b * b) - (4 * pGradient->radial.a * c); det = (b * b) - (4 * pGradient->radial.a * c);
s = (-b + sqrt(det))/(2. * pGradient->radial.a); s = (-b + sqrt(det))/(2. * pGradient->radial.a);
*buffer = gradientPixel(pGradient, t = (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536);
(xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
pict->repeat); *buffer = _gradient_walker_pixel (&walker, t);
} }
++buffer; ++buffer;
@ -3071,12 +3243,14 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
while (buffer < end) { while (buffer < end) {
double angle; double angle;
if (!mask || *mask++ & maskBits) if (!mask || *mask++ & maskBits)
{ {
angle = atan2(ry, rx) + a; xFixed_48_16 t;
*buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))), angle = atan2(ry, rx) + a;
pict->repeat); t = (xFixed_48_16) (angle * (65536. / (2*M_PI)));
*buffer = _gradient_walker_pixel (&walker, t);
} }
++buffer; ++buffer;
@ -3085,9 +3259,13 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
} }
} else { } else {
while (buffer < end) { while (buffer < end) {
double x, y, angle; double x, y;
if (!mask || *mask++ & maskBits) double angle;
{
if (!mask || *mask++ & maskBits)
{
xFixed_48_16 t;
if (rz != 0) { if (rz != 0) {
x = rx/rz; x = rx/rz;
y = ry/rz; y = ry/rz;
@ -3097,9 +3275,11 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *
x -= pGradient->conical.center.x/65536.; x -= pGradient->conical.center.x/65536.;
y -= pGradient->conical.center.y/65536.; y -= pGradient->conical.center.y/65536.;
angle = atan2(y, x) + a; angle = atan2(y, x) + a;
*buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))), t = (xFixed_48_16) (angle * (65536. / (2*M_PI)));
pict->repeat);
*buffer = _gradient_walker_pixel (&walker, t);
} }
++buffer; ++buffer;
rx += cx; rx += cx;
ry += cy; ry += cy;