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

Revert "Optimize out computing a gradient pixel if the mask value is 0." 

This reverts cf46242e33 commit.  It wasn't meant
to be pushed to master yet, and doesn't work.
This commit is contained in:
Eric Anholt 2006-07-03 12:52:27 -07:00
parent 002e28c12c
commit 12563db59d
1 changed files with 76 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
fb/fbcompose.c
View File

@ -2635,8 +2635,7 @@ FbComposeFunctions composeFunctions = {
}; };
static void fbFetchSolid(PicturePtr pict, int x, int y, int width, static void fbFetchSolid(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
CARD32 *buffer, CARD32 *mask, CARD32 maskBits)
{ {
FbBits *bits; FbBits *bits;
FbStride stride; FbStride stride;
@ -2657,8 +2656,7 @@ static void fbFetchSolid(PicturePtr pict, int x, int y, int width,
*buffer++ = color; *buffer++ = color;
} }
static void fbFetch(PicturePtr pict, int x, int y, int width, CARD32 *buffer, static void fbFetch(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
CARD32 *mask, CARD32 maskBits)
{ {
FbBits *bits; FbBits *bits;
FbStride stride; FbStride stride;
@ -2713,8 +2711,7 @@ static CARD32 gradientPixel(const SourcePictPtr pGradient, xFixed_48_16 pos, uns
return pGradient->linear.colorTable[ipos]; return pGradient->linear.colorTable[ipos];
} }
static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
CARD32 *buffer, CARD32 *mask, CARD32 maskBits)
{ {
SourcePictPtr pGradient = pict->pSourcePict; SourcePictPtr pGradient = pict->pSourcePict;
CARD32 *end = buffer + width; CARD32 *end = buffer + width;
@ -2764,17 +2761,12 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16; inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16;
} }
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
*buffer++ = gradientPixel(pGradient, t, pict->repeatType); *buffer++ = gradientPixel(pGradient, t, pict->repeatType);
} else {
*buffer++ = 0; /* Set it to a value for valgrind */
}
t += inc; t += inc;
} }
} else { } else {
/* projective transformation */ /* projective transformation */
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
xFixed_48_16 t; xFixed_48_16 t;
if (v.vector[2] == 0) { if (v.vector[2] == 0) {
t = 0; t = 0;
@ -2785,9 +2777,6 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
t = ((a*x + b*y) >> 16) + off; t = ((a*x + b*y) >> 16) + off;
} }
*buffer++ = gradientPixel(pGradient, t, pict->repeatType); *buffer++ = gradientPixel(pGradient, t, pict->repeatType);
} else {
*buffer++ = 0; /* Set it to a value for valgrind */
}
v.vector[0] += unit.vector[0]; v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1]; v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2]; v.vector[2] += unit.vector[2];
@ -2827,24 +2816,19 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
ry -= pGradient->radial.fy; ry -= pGradient->radial.fy;
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
double b = 2*(rx*pGradient->radial.dx + ry*pGradient->radial.dy); double b = 2*(rx*pGradient->radial.dx + ry*pGradient->radial.dy);
double c = -(rx*rx + ry*ry); double c = -(rx*rx + ry*ry);
double det = (b * b) - (4 * pGradient->radial.a * c); double det = (b * b) - (4 * pGradient->radial.a * c);
double s = (-b + sqrt(det))/(2. * pGradient->radial.a); double s = (-b + sqrt(det))/(2. * pGradient->radial.a);
*buffer++ = gradientPixel(pGradient, *buffer = gradientPixel(pGradient,
(xFixed_48_16)((s * pGradient->radial.m + (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
pGradient->radial.b) * 65536),
pict->repeatType); pict->repeatType);
} else { ++buffer;
*buffer++ = 0;
}
rx += cx; rx += cx;
ry += cy; ry += cy;
} }
} else { } else {
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
double x, y; double x, y;
double b, c, det, s; double b, c, det, s;
if (rz != 0) { if (rz != 0) {
@ -2859,13 +2843,10 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
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, *buffer = gradientPixel(pGradient,
(xFixed_48_16)((s * pGradient->radial.m + (xFixed_48_16)((s*pGradient->radial.m + pGradient->radial.b)*65536),
pGradient->radial.b) * 65536),
pict->repeatType); pict->repeatType);
} else { ++buffer;
*buffer++ = 0;
}
rx += cx; rx += cx;
ry += cy; ry += cy;
rz += cz; rz += cz;
@ -2878,21 +2859,16 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
ry -= pGradient->conical.center.y/65536.; ry -= pGradient->conical.center.y/65536.;
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
double angle = atan2(ry, rx) + a; double angle = atan2(ry, rx) + a;
*buffer++ = gradientPixel(pGradient, *buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
(xFixed_48_16) (angle * (65536. / (2*M_PI))),
pict->repeatType); pict->repeatType);
} else { ++buffer;
*buffer++ = 0;
}
rx += cx; rx += cx;
ry += cy; ry += cy;
} }
} else { } else {
while (buffer < end) { while (buffer < end) {
if (mask == NULL || (*mask++ & maskBits) != 0) {
double x, y, angle; double x, y, angle;
if (rz != 0) { if (rz != 0) {
x = rx/rz; x = rx/rz;
@ -2903,12 +2879,9 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
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) *buffer = gradientPixel(pGradient, (xFixed_48_16) (angle * (65536. / (2*M_PI))),
(angle * (65536. / (2*M_PI))),
pict->repeatType); pict->repeatType);
} else { ++buffer;
*buffer++ = 0;
}
rx += cx; rx += cx;
ry += cy; ry += cy;
rz += cz; rz += cz;
@ -2920,8 +2893,7 @@ static void fbFetchSourcePict(PicturePtr pict, int x, int y, int width,
static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
CARD32 *buffer, CARD32 *mask, CARD32 maskBits)
{ {
FbBits *bits; FbBits *bits;
FbStride stride; FbStride stride;
@ -3385,24 +3357,21 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width,
} }
static void fbFetchExternalAlpha(PicturePtr pict, int x, int y, int width, static void fbFetchExternalAlpha(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
CARD32 *buffer, CARD32 *mask, CARD32 maskBits)
{ {
int i; int i;
CARD32 _alpha_buffer[SCANLINE_BUFFER_LENGTH]; CARD32 _alpha_buffer[SCANLINE_BUFFER_LENGTH];
CARD32 *alpha_buffer = _alpha_buffer; CARD32 *alpha_buffer = _alpha_buffer;
if (!pict->alphaMap) { if (!pict->alphaMap) {
fbFetchTransformed(pict, x, y, width, buffer, mask, maskBits); fbFetchTransformed(pict, x, y, width, buffer);
return; return;
} }
if (width > SCANLINE_BUFFER_LENGTH) if (width > SCANLINE_BUFFER_LENGTH)
alpha_buffer = (CARD32 *) malloc(width*sizeof(CARD32)); alpha_buffer = (CARD32 *) malloc(width*sizeof(CARD32));
fbFetchTransformed(pict, x, y, width, buffer, mask, maskBits); fbFetchTransformed(pict, x, y, width, buffer);
fbFetchTransformed(pict->alphaMap, x - pict->alphaOrigin.x, fbFetchTransformed(pict->alphaMap, x - pict->alphaOrigin.x, y - pict->alphaOrigin.y, width, alpha_buffer);
y - pict->alphaOrigin.y, width, alpha_buffer,
mask, maskBits);
for (i = 0; i < width; ++i) { for (i = 0; i < width; ++i) {
int a = alpha_buffer[i]>>24; int a = alpha_buffer[i]>>24;
buffer[i] = (a << 24) buffer[i] = (a << 24)
@ -3472,8 +3441,7 @@ static void fbStoreExternalAlpha(PicturePtr pict, int x, int y, int width, CARD3
} }
typedef void (*scanStoreProc)(PicturePtr , int , int , int , CARD32 *); typedef void (*scanStoreProc)(PicturePtr , int , int , int , CARD32 *);
typedef void (*scanFetchProc)(PicturePtr , int , int , int , CARD32 *, typedef void (*scanFetchProc)(PicturePtr , int , int , int , CARD32 *);
CARD32 *, CARD32);
static void static void
fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer) fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer)
@ -3535,16 +3503,12 @@ fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer)
for (i = 0; i < data->height; ++i) for (i = 0; i < data->height; ++i)
{ {
/* fill first half of scanline with source */ /* fill first half of scanline with source */
fetchMask(data->mask, data->xMask, data->yMask + i, data->width, fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width, src_buffer);
mask_buffer, NULL, 0); fetchMask(data->mask, data->xMask, data->yMask + i, data->width, mask_buffer);
fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width,
src_buffer, mask_buffer, 0);
/* fill dest into second half of scanline */ /* fill dest into second half of scanline */
if (fetchDest) { if (fetchDest)
fetchDest(data->dest, data->xDest, data->yDest + i, data->width, fetchDest(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);
dest_buffer, NULL, 0);
}
/* blend */ /* blend */
compose(dest_buffer, src_buffer, mask_buffer, data->width); compose(dest_buffer, src_buffer, mask_buffer, data->width);
@ -3553,26 +3517,16 @@ fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer)
store(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer); store(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);
} }
} else { } else {
CARD32 *mask_buffer;
CombineFuncU compose = composeFunctions.combineU[data->op]; CombineFuncU compose = composeFunctions.combineU[data->op];
if (!compose) if (!compose)
return; return;
if (fetchMask)
mask_buffer = dest_buffer + data->width;
else
mask_buffer = NULL;
if (fetchSrc == fbFetchSolid && (!fetchMask || fetchMask == fbFetchSolid)) { if (fetchSrc == fbFetchSolid && (!fetchMask || fetchMask == fbFetchSolid)) {
fetchSrc(data->src, data->xSrc, data->ySrc, data->width, src_buffer);
if (fetchMask) { if (fetchMask) {
fetchMask(data->mask, data->xMask, data->yMask, data->width, fetchMask(data->mask, data->xMask, data->yMask, data->width, dest_buffer);
dest_buffer, NULL, 0); composeFunctions.combineMaskU(src_buffer, dest_buffer, data->width);
}
fetchSrc(data->src, data->xSrc, data->ySrc, data->width,
src_buffer, mask_buffer, 0xff000000);
if (mask_buffer != NULL) {
composeFunctions.combineMaskU(src_buffer, dest_buffer,
data->width);
} }
fetchSrc = NULL; fetchSrc = NULL;
fetchMask = NULL; fetchMask = NULL;
@ -3582,27 +3536,18 @@ fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer)
{ {
/* fill first half of scanline with source */ /* fill first half of scanline with source */
if (fetchSrc) { if (fetchSrc) {
/* Fetch mask before source so that fetching of source can be fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width, src_buffer);
* optimized out if possible.
*/
if (fetchMask) {
fetchMask(data->mask, data->xMask, data->yMask + i,
data->width, dest_buffer, NULL, 0);
}
fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width,
src_buffer, mask_buffer, 0xff000000);
/* add in mask */ /* add in mask */
if (mask_buffer != NULL) { if (fetchMask) {
fetchMask(data->mask, data->xMask, data->yMask + i, data->width, dest_buffer);
composeFunctions.combineMaskU(src_buffer, dest_buffer, data->width); composeFunctions.combineMaskU(src_buffer, dest_buffer, data->width);
} }
} }
/* fill dest into second half of scanline */ /* fill dest into second half of scanline */
if (fetchDest != NULL) { if (fetchDest)
fetchDest(data->dest, data->xDest, data->yDest + i, data->width, fetchDest(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);
dest_buffer, NULL, 0);
}
/* blend */ /* blend */
compose(dest_buffer, src_buffer, data->width); compose(dest_buffer, src_buffer, data->width);