void
XAAFillColor8x8PatternRects(
ScrnInfoPtr pScrn,
int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox,
int xorigin, int yorigin,
XAACacheInfoPtr pCache
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int xorg, yorg;
(*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,
rop, planemask, pCache->trans_color);
while(nBox--) {
xorg = (pBox->x1 - xorigin) & 0x07;
yorg = (pBox->y1 - yorigin) & 0x07;
if(!(infoRec->Color8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
int slot = (yorg << 3) + xorg;
yorg = pCache->y + pCache->offsets[slot].y;
xorg = pCache->x + pCache->offsets[slot].x;
}
(*infoRec->SubsequentColor8x8PatternFillRect)(pScrn,
xorg, yorg, pBox->x1, pBox->y1,
pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
static void
XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
register int x, y, e;
int yk, xk, ym, xm, dx, dy, xorg, yorg;
int slw;
miFillArcRec info;
(*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
pGC->planemask);
miFillArcSetup(arc, &info);
MIFILLARCSETUP();
if (pGC->miTranslate)
{
xorg += pDraw->x;
yorg += pDraw->y;
}
while (y > 0)
{
MIFILLARCSTEP(slw);
if (slw > 0) {
(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn, xorg - x,
yorg - y, slw, 1);
if (miFillArcLower(slw))
(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
xorg - x, yorg + y + dy, slw, 1);
}
}
SET_SYNC_FLAG(infoRec);
}
void
XAAFillMono8x8PatternSpans(
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth, int fSorted,
int pattern0, int pattern1,
int xorigin, int yorigin
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int patx = pattern0, paty = pattern1;
int xorg, yorg, slot;
XAACacheInfoPtr pCache = NULL;
if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){
pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
patx = pCache->x; paty = pCache->y;
}
(*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
fg, bg, rop, planemask);
if(infoRec->ClipBox)
(*infoRec->SetClippingRectangle)(infoRec->pScrn,
infoRec->ClipBox->x1, infoRec->ClipBox->y1,
infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
while(n--) {
xorg = (ppt->x - xorigin) & 0x07;
yorg = (ppt->y - yorigin) & 0x07;
if(!(infoRec->Mono8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
if(infoRec->Mono8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_BITS) {
patx = pattern0; paty = pattern1;
XAARotateMonoPattern(&patx, &paty, xorg, yorg,
(infoRec->Mono8x8PatternFillFlags &
BIT_ORDER_IN_BYTE_MSBFIRST));
xorg = patx; yorg = paty;
} else {
slot = (yorg << 3) + xorg;
xorg = patx + pCache->offsets[slot].x;
yorg = paty + pCache->offsets[slot].y;
}
}
(*infoRec->SubsequentMono8x8PatternFillRect)(pScrn,
xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
ppt++; pwidth++;
}
if(infoRec->ClipBox)
(*infoRec->DisableClipping)(infoRec->pScrn);
SET_SYNC_FLAG(infoRec);
}
/*
* ATIDGABlitTransRect --
*
* This function calls XAA screen-to-screen copy primitives to transparently
* copy a rectangle.
*/
static void
ATIDGABlitTransRect
(
ScrnInfoPtr pScreenInfo,
int xSrc,
int ySrc,
int w,
int h,
int xDst,
int yDst,
unsigned long colour
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
/*FIXME : use EXA if available */
#ifdef USE_XAA
XAAInfoRecPtr pXAAInfo = pATI->pXAAInfo;
int xdir = ((xSrc < xDst) && (ySrc == yDst)) ? -1 : 1;
int ydir = (ySrc < yDst) ? -1 : 1;
pATI->XAAForceTransBlit = TRUE;
(*pXAAInfo->SetupForScreenToScreenCopy)(pScreenInfo,
xdir, ydir, GXcopy, (CARD32)(~0), (int)colour);
pATI->XAAForceTransBlit = FALSE;
(*pXAAInfo->SubsequentScreenToScreenCopy)(pScreenInfo,
xSrc, ySrc, xDst, yDst, w, h);
if (pScreenInfo->bitsPerPixel == pATI->bitsPerPixel)
SET_SYNC_FLAG(pXAAInfo);
#endif
}
void
XAAFillSolidSpans(
ScrnInfoPtr pScrn,
int fg, int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth, int fSorted
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
(*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
if(infoRec->ClipBox)
(*infoRec->SetClippingRectangle)(infoRec->pScrn,
infoRec->ClipBox->x1, infoRec->ClipBox->y1,
infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
while(n--) {
if (*pwidth > 0)
(*infoRec->SubsequentSolidFillRect)(pScrn, ppt->x, ppt->y,
*pwidth, 1);
ppt++; pwidth++;
}
if(infoRec->ClipBox)
(*infoRec->DisableClipping)(infoRec->pScrn);
SET_SYNC_FLAG(infoRec);
}
void
XAAFillCacheExpandSpans(
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth,
int fSorted,
int xorg, int yorg,
PixmapPtr pPix
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int x, w, phaseX, phaseY, blit_w, cacheWidth;
XAACacheInfoPtr pCache;
pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);
cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
infoRec->CacheColorExpandDensity;
(*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop,
planemask);
if(infoRec->ClipBox)
(*infoRec->SetClippingRectangle)(infoRec->pScrn,
infoRec->ClipBox->x1, infoRec->ClipBox->y1,
infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
while(n--) {
x = ppt->x;
w = *pwidth;
phaseX = (x - xorg) % pCache->orig_w;
if(phaseX < 0) phaseX += pCache->orig_w;
phaseY = (ppt->y - yorg) % pCache->orig_h;
if(phaseY < 0) phaseY += pCache->orig_h;
while(1) {
blit_w = cacheWidth - phaseX;
if(blit_w > w) blit_w = w;
(*infoRec->SubsequentScreenToScreenColorExpandFill)(
pScrn, x, ppt->y, blit_w, 1,
pCache->x, pCache->y + phaseY, phaseX);
w -= blit_w;
if(!w) break;
x += blit_w;
phaseX = (phaseX + blit_w) % pCache->orig_w;
}
ppt++; pwidth++;
}
if(infoRec->ClipBox)
(*infoRec->DisableClipping)(infoRec->pScrn);
SET_SYNC_FLAG(infoRec);
}
void
XAAFillCacheExpandRects(
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox,
int xorg, int yorg,
PixmapPtr pPix
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
int cacheWidth;
XAACacheInfoPtr pCache;
pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);
cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
infoRec->CacheColorExpandDensity;
(*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop,
planemask);
while(nBox--) {
y = pBox->y1;
phaseY = (y - yorg) % pCache->orig_h;
if(phaseY < 0) phaseY += pCache->orig_h;
phaseX = (pBox->x1 - xorg) % pCache->orig_w;
if(phaseX < 0) phaseX += pCache->orig_w;
height = pBox->y2 - y;
width = pBox->x2 - pBox->x1;
while(1) {
w = width; skipleft = phaseX; x = pBox->x1;
blit_h = pCache->h - phaseY;
if(blit_h > height) blit_h = height;
while(1) {
blit_w = cacheWidth - skipleft;
if(blit_w > w) blit_w = w;
(*infoRec->SubsequentScreenToScreenColorExpandFill)(
pScrn, x, y, blit_w, blit_h,
pCache->x, pCache->y + phaseY, skipleft);
w -= blit_w;
if(!w) break;
x += blit_w;
skipleft = (skipleft + blit_w) % pCache->orig_w;
}
height -= blit_h;
if(!height) break;
y += blit_h;
phaseY = (phaseY + blit_h) % pCache->orig_h;
}
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
void
XAAFillMono8x8PatternRects(ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox,
int pattern0, int pattern1, int xorigin, int yorigin)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int patx = pattern0, paty = pattern1;
int xorg, yorg;
XAACacheInfoPtr pCache = NULL;
if (!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)) {
pCache = (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
patx = pCache->x;
paty = pCache->y;
}
(*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
fg, bg, rop, planemask);
while (nBox--) {
xorg = (pBox->x1 - xorigin) & 0x07;
yorg = (pBox->y1 - yorigin) & 0x07;
if (!(infoRec->Mono8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
if (infoRec->Mono8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_BITS) {
patx = pattern0;
paty = pattern1;
XAARotateMonoPattern(&patx, &paty, xorg, yorg,
(infoRec->Mono8x8PatternFillFlags &
BIT_ORDER_IN_BYTE_MSBFIRST));
xorg = patx;
yorg = paty;
}
else {
int slot = (yorg << 3) + xorg;
xorg = patx + pCache->offsets[slot].x;
yorg = paty + pCache->offsets[slot].y;
}
}
(*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
xorg, yorg, pBox->x1,
pBox->y1,
pBox->x2 - pBox->x1,
pBox->y2 - pBox->y1);
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
static void
I810_FillRect(ScrnInfoPtr pScrn,
int x, int y, int w, int h, unsigned long color)
{
I810Ptr pI810 = I810PTR(pScrn);
if (pI810->AccelInfoRec) {
(*pI810->AccelInfoRec->SetupForSolidFill) (pScrn, color, GXcopy, ~0);
(*pI810->AccelInfoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
SET_SYNC_FLAG(pI810->AccelInfoRec);
}
}
void
XAAFillCacheBltSpans(
ScrnInfoPtr pScrn,
int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth,
int fSorted,
XAACacheInfoPtr pCache,
int xorg, int yorg
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int x, w, phaseX, phaseY, blit_w;
(*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,
pCache->trans_color);
if(infoRec->ClipBox)
(*infoRec->SetClippingRectangle)(infoRec->pScrn,
infoRec->ClipBox->x1, infoRec->ClipBox->y1,
infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
while(n--) {
x = ppt->x;
w = *pwidth;
phaseX = (x - xorg) % pCache->orig_w;
if(phaseX < 0) phaseX += pCache->orig_w;
phaseY = (ppt->y - yorg) % pCache->orig_h;
if(phaseY < 0) phaseY += pCache->orig_h;
while(1) {
blit_w = pCache->w - phaseX;
if(blit_w > w) blit_w = w;
(*infoRec->SubsequentScreenToScreenCopy)(pScrn,
pCache->x + phaseX, pCache->y + phaseY,
x, ppt->y, blit_w, 1);
w -= blit_w;
if(!w) break;
x += blit_w;
phaseX = (phaseX + blit_w) % pCache->orig_w;
}
ppt++; pwidth++;
}
if(infoRec->ClipBox)
(*infoRec->DisableClipping)(infoRec->pScrn);
SET_SYNC_FLAG(infoRec);
}
void
XAAFillImageWriteRects(ScrnInfoPtr pScrn,
int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int x, phaseY, phaseX, height, width, blit_w;
int pHeight = pPix->drawable.height;
int pWidth = pPix->drawable.width;
int Bpp = pPix->drawable.bitsPerPixel >> 3;
int srcwidth = pPix->devKind;
(*infoRec->SetupForImageWrite) (pScrn, rop, planemask, -1,
pPix->drawable.bitsPerPixel,
pPix->drawable.depth);
while (nBox--) {
x = pBox->x1;
phaseY = (pBox->y1 - yorg) % pHeight;
if (phaseY < 0)
phaseY += pHeight;
phaseX = (x - xorg) % pWidth;
if (phaseX < 0)
phaseX += pWidth;
height = pBox->y2 - pBox->y1;
width = pBox->x2 - x;
while (1) {
blit_w = pWidth - phaseX;
if (blit_w > width)
blit_w = width;
WriteColumn(pScrn, pPix->devPrivate.ptr, x, pBox->y1,
blit_w, height, phaseX, phaseY, pHeight, srcwidth, Bpp);
width -= blit_w;
if (!width)
break;
x += blit_w;
phaseX = (phaseX + blit_w) % pWidth;
}
pBox++;
}
if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
(*infoRec->Sync) (pScrn);
else
SET_SYNC_FLAG(infoRec);
}
static void
XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
register int x, y, e;
miFillArcRec info;
miArcSliceRec slice;
int ya, xl, xr, xc;
(*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
pGC->planemask);
miFillArcSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC);
MIFILLARCSETUP();
slw = arc->height;
if (slice.flip_top || slice.flip_bot)
slw += (arc->height >> 1) + 1;
if (pGC->miTranslate)
{
xorg += pDraw->x;
yorg += pDraw->y;
slice.edge1.x += pDraw->x;
slice.edge2.x += pDraw->x;
}
while (y > 0)
{
MIFILLARCSTEP(slw);
MIARCSLICESTEP(slice.edge1);
MIARCSLICESTEP(slice.edge2);
if (miFillSliceUpper(slice))
{
ya = yorg - y;
MIARCSLICEUPPER(xl, xr, slice, slw);
ADDSLICESPANS(slice.flip_top);
}
if (miFillSliceLower(slice))
{
ya = yorg + y + dy;
MIARCSLICELOWER(xl, xr, slice, slw);
ADDSLICESPANS(slice.flip_bot);
}
}
SET_SYNC_FLAG(infoRec);
}
void
XAAFillSolidRects(ScrnInfoPtr pScrn, int fg, int rop, unsigned int planemask, int nBox, /* number of rectangles to fill */
BoxPtr pBox /* Pointer to first rectangle to fill */
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
(*infoRec->SetupForSolidFill) (pScrn, fg, rop, planemask);
while (nBox--) {
(*infoRec->SubsequentSolidFillRect) (pScrn, pBox->x1, pBox->y1,
pBox->x2 - pBox->x1,
pBox->y2 - pBox->y1);
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
static void
XAASetColorKey8_32(ScreenPtr pScreen, int nbox, BoxPtr pbox)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
ScrnInfoPtr pScrn = infoRec->pScrn;
/* I'm counting on writes being clipped away while switched away.
If this isn't going to be true then I need to be wrapping instead. */
if (!infoRec->pScrn->vtSema)
return;
(*infoRec->FillSolidRects) (pScrn, pScrn->colorKey << 24, GXcopy,
0xff000000, nbox, pbox);
SET_SYNC_FLAG(infoRec);
}
static void
XAASaveAreas (
PixmapPtr pPixmap,
RegionPtr prgnSave,
int xorg,
int yorg,
WindowPtr pWin
){
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
if(IS_OFFSCREEN_PIXMAP(pPixmap)) {
BoxPtr pbox = REGION_RECTS(prgnSave);
int nboxes = REGION_NUM_RECTS(prgnSave);
(*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, GXcopy, ~0, -1);
while(nboxes--) {
(*infoRec->SubsequentScreenToScreenCopy)(pScrn,
pbox->x1 + xorg, pbox->y1 + yorg,
pPixmap->drawable.x + pbox->x1,
pPixmap->drawable.y + pbox->y1,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
pbox++;
}
SET_SYNC_FLAG(infoRec);
return;
}
if(xf86Screens[pScreen->myNum]->vtSema && infoRec->ReadPixmap &&
(pWin->drawable.bitsPerPixel == pPixmap->drawable.bitsPerPixel)) {
BoxPtr pbox = REGION_RECTS(prgnSave);
int nboxes = REGION_NUM_RECTS(prgnSave);
int Bpp = pPixmap->drawable.bitsPerPixel >> 3;
unsigned char *dstp = (unsigned char*)pPixmap->devPrivate.ptr;
while(nboxes--) {
(*infoRec->ReadPixmap)(infoRec->pScrn,
pbox->x1 + xorg, pbox->y1 + yorg,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
dstp + (pPixmap->devKind * pbox->y1) + (pbox->x1 * Bpp),
pPixmap->devKind,
pPixmap->drawable.bitsPerPixel, pPixmap->drawable.depth);
pbox++;
}
return;
}
static void
I810_BlitRect(ScrnInfoPtr pScrn,
int srcx, int srcy, int w, int h, int dstx, int dsty)
{
I810Ptr pI810 = I810PTR(pScrn);
if (pI810->AccelInfoRec) {
int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
int ydir = (srcy < dsty) ? -1 : 1;
(*pI810->AccelInfoRec->SetupForScreenToScreenCopy) (pScrn, xdir, ydir,
GXcopy, ~0, -1);
(*pI810->AccelInfoRec->SubsequentScreenToScreenCopy) (pScrn, srcx, srcy,
dstx, dsty, w, h);
SET_SYNC_FLAG(pI810->AccelInfoRec);
}
}
void
XAAFillColor8x8PatternSpansScreenOrigin(
ScrnInfoPtr pScrn,
int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth, int fSorted,
XAACacheInfoPtr pCache,
int xorigin, int yorigin
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int patx = pCache->x, paty = pCache->y;
int xorg = (-xorigin) & 0x07;
int yorg = (-yorigin) & 0x07;
if(!(infoRec->Color8x8PatternFillFlags &
HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
int slot = (yorg << 3) + xorg;
paty += pCache->offsets[slot].y;
patx += pCache->offsets[slot].x;
xorg = patx; yorg = paty;
}
(*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,
rop, planemask, pCache->trans_color);
if(infoRec->ClipBox)
(*infoRec->SetClippingRectangle)(infoRec->pScrn,
infoRec->ClipBox->x1, infoRec->ClipBox->y1,
infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
while(n--) {
(*infoRec->SubsequentColor8x8PatternFillRect)(pScrn,
xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
ppt++; pwidth++;
}
if(infoRec->ClipBox)
(*infoRec->DisableClipping)(infoRec->pScrn);
SET_SYNC_FLAG(infoRec);
}
/*
* ATIDGAFillRect --
*
* This function calls XAA solid fill primitives to fill a rectangle.
*/
static void
ATIDGAFillRect
(
ScrnInfoPtr pScreenInfo,
int x,
int y,
int w,
int h,
unsigned long colour
)
{
ATIPtr pATI = ATIPTR(pScreenInfo);
/*FIXME : use EXA if available */
#ifdef USE_XAA
XAAInfoRecPtr pXAAInfo = pATI->pXAAInfo;
(*pXAAInfo->SetupForSolidFill)(pScreenInfo, (int)colour, GXcopy,
(CARD32)(~0));
(*pXAAInfo->SubsequentSolidFillRect)(pScreenInfo, x, y, w, h);
if (pScreenInfo->bitsPerPixel == pATI->bitsPerPixel)
SET_SYNC_FLAG(pXAAInfo);
#endif
}
void
XAAPolyRectangleThinSolid(
DrawablePtr pDrawable,
GCPtr pGC,
int nRectsInit,
xRectangle *pRectsInit )
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
int nClipRects; /* number of clip rectangles */
BoxPtr pClipRects; /* points to the list of clip rects */
int xOrigin; /* Drawables x origin */
int yOrigin; /* Drawables x origin */
xRectangle *pRect; /* list of rects */
int nRects; /* running count of number of rects */
int origX1, origY1; /* original rectangle's U/L corner */
int origX2, origY2; /* original rectangle's L/R corner */
int clippedX1; /* clipped rectangle's left x */
int clippedY1; /* clipped rectangle's top y */
int clippedX2; /* clipped rectangle's right x */
int clippedY2; /* clipped rectangle's bottom y */
int clipXMin; /* upper left corner of clip rect */
int clipYMin; /* upper left corner of clip rect */
int clipXMax; /* lower right corner of clip rect */
int clipYMax; /* lower right corner of clip rect */
int width, height; /* width and height of rect */
nClipRects = REGION_NUM_RECTS(pGC->pCompositeClip);
pClipRects = REGION_RECTS(pGC->pCompositeClip);
if(!nClipRects) return;
xOrigin = pDrawable->x;
yOrigin = pDrawable->y;
(*infoRec->SetupForSolidLine)(infoRec->pScrn,
pGC->fgPixel, pGC->alu, pGC->planemask);
for ( ; nClipRects > 0;
nClipRects--, pClipRects++ )
{
clipYMin = pClipRects->y1;
clipYMax = pClipRects->y2 - 1;
clipXMin = pClipRects->x1;
clipXMax = pClipRects->x2 - 1;
for (pRect = pRectsInit, nRects = nRectsInit;
nRects > 0;
nRects--, pRect++ )
{
/* translate rectangle data over to the drawable */
origX1 = pRect->x + xOrigin;
origY1 = pRect->y + yOrigin;
origX2 = origX1 + pRect->width;
origY2 = origY1 + pRect->height;
/* reject entire rectangle if completely outside clip rect */
if ((origX1 > clipXMax) || (origX2 < clipXMin) ||
(origY1 > clipYMax) || (origY2 < clipYMin))
continue;
/* clip the rectangle */
clippedX1 = max (origX1, clipXMin);
clippedX2 = min (origX2, clipXMax);
clippedY1 = max (origY1, clipYMin);
clippedY2 = min (origY2, clipYMax);
width = clippedX2 - clippedX1 + 1;
if (origY1 >= clipYMin) {
(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
clippedX1, clippedY1, width, DEGREES_0);
/* don't overwrite corner */
clippedY1++;
}
if ((origY2 <= clipYMax) && (origY1 != origY2)) {
(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
clippedX1, clippedY2, width, DEGREES_0);
/* don't overwrite corner */
clippedY2--;
}
if (clippedY2 < clippedY1) continue;
height = clippedY2 - clippedY1 + 1;
/* draw vertical edges using lines if not clipped out */
if (origX1 >= clipXMin)
(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
clippedX1, clippedY1, height, DEGREES_270);
if ((origX2 <= clipXMax) && (origX2 != origX1))
(*infoRec->SubsequentSolidHorVertLine)(infoRec->pScrn,
clippedX2, clippedY1, height, DEGREES_270);
}
}
SET_SYNC_FLAG(infoRec);
}
void
XAAFillCacheBltRects(ScrnInfoPtr pScrn,
int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox, int xorg, int yorg, XAACacheInfoPtr pCache)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
(*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, rop, planemask,
pCache->trans_color);
while (nBox--) {
y = pBox->y1;
phaseY = (y - yorg) % pCache->orig_h;
if (phaseY < 0)
phaseY += pCache->orig_h;
phaseX = (pBox->x1 - xorg) % pCache->orig_w;
if (phaseX < 0)
phaseX += pCache->orig_w;
height = pBox->y2 - y;
width = pBox->x2 - pBox->x1;
#if 0
if (rop == GXcopy) {
while (1) {
w = width;
skipleft = phaseX;
x = pBox->x1;
blit_h = pCache->h - phaseY;
if (blit_h > height)
blit_h = height;
while (1) {
blit_w = pCache->w - skipleft;
if (blit_w > w)
blit_w = w;
(*infoRec->SubsequentScreenToScreenCopy) (pScrn,
pCache->x +
skipleft,
pCache->y +
phaseY, x, y,
blit_w, blit_h);
w -= blit_w;
if (!w)
break;
x += blit_w;
skipleft = (skipleft + blit_w) % pCache->orig_w;
if (blit_w >= pCache->orig_w)
break;
}
/* Expand horizontally */
if (w) {
skipleft -= phaseX;
if (skipleft < 0)
skipleft += pCache->orig_w;
blit_w = x - pBox->x1 - skipleft;
while (w) {
if (blit_w > w)
blit_w = w;
(*infoRec->SubsequentScreenToScreenCopy) (pScrn,
pBox->x1 +
skipleft, y,
x, y, blit_w,
blit_h);
w -= blit_w;
x += blit_w;
blit_w <<= 1;
}
}
height -= blit_h;
if (!height)
break;
y += blit_h;
phaseY = (phaseY + blit_h) % pCache->orig_h;
if (blit_h >= pCache->orig_h)
break;
}
/* Expand vertically */
if (height) {
blit_w = pBox->x2 - pBox->x1;
phaseY -= (pBox->y1 - yorg) % pCache->orig_h;
if (phaseY < 0)
phaseY += pCache->orig_h;
blit_h = y - pBox->y1 - phaseY;
while (height) {
if (blit_h > height)
blit_h = height;
(*infoRec->SubsequentScreenToScreenCopy) (pScrn, pBox->x1,
pBox->y1 + phaseY,
pBox->x1, y,
blit_w, blit_h);
height -= blit_h;
y += blit_h;
blit_h <<= 1;
}
}
}
else
#endif
{
while (1) {
w = width;
skipleft = phaseX;
x = pBox->x1;
blit_h = pCache->h - phaseY;
if (blit_h > height)
blit_h = height;
while (1) {
blit_w = pCache->w - skipleft;
if (blit_w > w)
blit_w = w;
(*infoRec->SubsequentScreenToScreenCopy) (pScrn,
pCache->x +
skipleft,
pCache->y +
phaseY, x, y,
blit_w, blit_h);
w -= blit_w;
if (!w)
break;
x += blit_w;
skipleft = (skipleft + blit_w) % pCache->orig_w;
}
height -= blit_h;
if (!height)
break;
y += blit_h;
phaseY = (phaseY + blit_h) % pCache->orig_h;
}
}
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
EXPNAME(XAAWriteBitmapColorExpand)(
#endif
ScrnInfoPtr pScrn,
int x, int y, int w, int H,
unsigned char *src,
int srcwidth,
int skipleft,
int fg, int bg,
int rop,
unsigned int planemask
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32* base;
unsigned char *srcp = src;
int SecondPassColor = -1;
int shift = 0, dwords;
BitmapScanlineProcPtr firstFunc;
BitmapScanlineProcPtr secondFunc;
int flag;
int h = H;
#ifdef TRIPLE_BITS
if((bg != -1) &&
((infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) ||
((infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) &&
(!CHECK_RGB_EQUAL(bg))))) {
#else
if((bg != -1) &&
(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
#endif
if((rop == GXcopy) && infoRec->SetupForSolidFill) {
(*infoRec->SetupForSolidFill)(pScrn, bg, rop, planemask);
(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
} else SecondPassColor = bg;
bg = -1;
}
#ifdef TRIPLE_BITS
if(skipleft) {
#else
if(skipleft &&
(!(infoRec->CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING) ||
(!(infoRec->CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
(skipleft > x)))) {
#endif
if((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
/* don't read past the end */
firstFunc = BitmapScanline_Shifted_Careful;
secondFunc = BitmapScanline_Shifted_Inverted_Careful;
} else {
firstFunc = BitmapScanline_Shifted;
secondFunc = BitmapScanline_Shifted_Inverted;
}
shift = skipleft;
skipleft = 0;
} else {
firstFunc = BitmapScanline;
secondFunc = BitmapScanline_Inverted;
w += skipleft;
x -= skipleft;
}
#ifdef TRIPLE_BITS
dwords = (3 * w + 31) >> 5;
#else
dwords = (w + 31) >> 5;
#endif
SECOND_PASS:
flag = (infoRec->CPUToScreenColorExpandFillFlags
& CPU_TRANSFER_PAD_QWORD) && ((dwords * h) & 0x01);
(*infoRec->SetupForCPUToScreenColorExpandFill)(
pScrn, fg, bg, rop, planemask);
(*infoRec->SubsequentCPUToScreenColorExpandFill)(
pScrn, x, y, w, h, skipleft);
base = (CARD32*)infoRec->ColorExpandBase;
#ifndef FIXEDBASE
if((dwords * h) <= infoRec->ColorExpandRange)
while(h--) {
base = (*firstFunc)((CARD32*)srcp, base, dwords, shift);
srcp += srcwidth;
}
else
#endif
while(h--) {
(*firstFunc)((CARD32*)srcp, base, dwords, shift);
srcp += srcwidth;
}
if(flag){
base = (CARD32*)infoRec->ColorExpandBase;
base[0] = 0x00000000;
}
if(SecondPassColor != -1) {
h = H; /* Reset height */
fg = SecondPassColor;
SecondPassColor = -1;
firstFunc = secondFunc;
srcp = src;
goto SECOND_PASS;
}
if(infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
(*infoRec->Sync)(pScrn);
else SET_SYNC_FLAG(infoRec);
}
#ifndef FIXEDBASE
void
#ifdef TRIPLE_BITS
EXPNAME(XAAWriteBitmapScanlineColorExpand3)(
#else
EXPNAME(XAAWriteBitmapScanlineColorExpand)(
#endif
ScrnInfoPtr pScrn,
int x, int y, int w, int h,
unsigned char *src,
int srcwidth,
int skipleft,
int fg, int bg,
int rop,
unsigned int planemask
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32* base;
unsigned char *srcp = src;
int SecondPassColor = -1;
int shift = 0, dwords, bufferNo;
BitmapScanlineProcPtr firstFunc;
BitmapScanlineProcPtr secondFunc;
#ifdef TRIPLE_BITS
if((bg != -1) &&
((infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
|| ((infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) &&
(!CHECK_RGB_EQUAL(bg))))) {
#else
if((bg != -1) &&
(infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)){
#endif
if((rop == GXcopy) && infoRec->SetupForSolidFill) {
(*infoRec->SetupForSolidFill)(pScrn, bg, rop, planemask);
(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
} else SecondPassColor = bg;
bg = -1;
}
#ifdef TRIPLE_BITS
if(skipleft) {
#else
if(skipleft &&
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
LEFT_EDGE_CLIPPING) ||
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
LEFT_EDGE_CLIPPING_NEGATIVE_X) && (skipleft > x)))) {
#endif
if((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
/* don't read past the end */
firstFunc = BitmapScanline_Shifted_Careful;
secondFunc = BitmapScanline_Shifted_Inverted_Careful;
} else {
firstFunc = BitmapScanline_Shifted;
secondFunc = BitmapScanline_Shifted_Inverted;
}
shift = skipleft;
skipleft = 0;
} else {
firstFunc = BitmapScanline;
secondFunc = BitmapScanline_Inverted;
w += skipleft;
x -= skipleft;
}
#ifdef TRIPLE_BITS
dwords = (3 * w + 31) >> 5;
#else
dwords = (w + 31) >> 5;
#endif
SECOND_PASS:
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill)(pScrn, fg, bg, rop, planemask);
(*infoRec->SubsequentScanlineCPUToScreenColorExpandFill)(
pScrn, x, y, w, h, skipleft);
bufferNo = 0;
while(h--) {
base = (CARD32*)infoRec->ScanlineColorExpandBuffers[bufferNo];
(*firstFunc)((CARD32*)srcp, base, dwords, shift);
(*infoRec->SubsequentColorExpandScanline)(pScrn, bufferNo++);
srcp += srcwidth;
if(bufferNo >= infoRec->NumScanlineColorExpandBuffers)
bufferNo = 0;
}
if(SecondPassColor != -1) {
fg = SecondPassColor;
SecondPassColor = -1;
firstFunc = secondFunc;
srcp = src;
goto SECOND_PASS;
}
SET_SYNC_FLAG(infoRec);
}
static void
Permedia2WriteBitmap(ScrnInfoPtr pScrn,
int x, int y, int w, int h,
unsigned char *src,
int srcwidth,
int skipleft,
int fg, int bg,
int rop,
unsigned int planemask
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
GLINTPtr pGlint = GLINTPTR(pScrn);
unsigned char *srcpntr;
int dwords, height, mode;
Bool SecondPass = FALSE;
TRACE_ENTER("Permedia2WriteBitmap");
w += skipleft;
x -= skipleft;
dwords = (w + 31) >> 5;
Permedia2SetClippingRectangle(pScrn,x+skipleft,y,x+w,y+h);
if (pScrn->bitsPerPixel == 24) {
GLINT_WAIT(10);
} else {
GLINT_WAIT(11);
DO_PLANEMASK(planemask);
}
LOADROP(rop);
Permedia2LoadCoord(pScrn, x&0xFFFF, y, w, h);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
if ((pScrn->bitsPerPixel != 24) && (rop == GXcopy)) {
mode = FastFillEnable;
GLINT_WRITE_REG(UNIT_DISABLE, ColorDDAMode);
GLINT_WRITE_REG(pGlint->RasterizerSwap,RasterizerMode);
} else {
mode = 0;
GLINT_WRITE_REG(UNIT_ENABLE, ColorDDAMode);
GLINT_WRITE_REG(BitMaskPackingEachScanline|
pGlint->RasterizerSwap,RasterizerMode);
}
if(bg == -1) {
REPLICATE(fg);
if ((pScrn->bitsPerPixel != 24) && (rop == GXcopy)) {
GLINT_WRITE_REG(fg, FBBlockColor);
} else {
GLINT_WRITE_REG(fg, ConstantColor);
}
} else if((rop == GXcopy) && (pScrn->bitsPerPixel != 24)) {
REPLICATE(bg);
GLINT_WRITE_REG(bg, FBBlockColor);
GLINT_WRITE_REG(PrimitiveRectangle | XPositive |YPositive |mode,Render);
REPLICATE(fg);
GLINT_WRITE_REG(fg, FBBlockColor);
} else {
SecondPass = TRUE;
REPLICATE(fg);
if ((pScrn->bitsPerPixel != 24) && (rop == GXcopy)) {
GLINT_WRITE_REG(fg, FBBlockColor);
} else {
GLINT_WRITE_REG(fg, ConstantColor);
}
}
SECOND_PASS:
GLINT_WRITE_REG(PrimitiveRectangle | XPositive | YPositive | mode | SyncOnBitMask, Render);
height = h;
srcpntr = src;
while(height--) {
GLINT_WAIT(dwords + 1);
/* 0x0D is the TAG value for BitMaskPattern */
GLINT_WRITE_REG(((dwords - 1) << 16) | 0x0D, OutputFIFO);
GLINT_MoveDWORDS((CARD32*)((char*)pGlint->IOBase + OutputFIFO + 4),
(CARD32 *)srcpntr, dwords);
srcpntr += srcwidth;
}
if(SecondPass) {
SecondPass = FALSE;
REPLICATE(bg);
GLINT_WAIT(3);
if ((pScrn->bitsPerPixel != 24) && (rop == GXcopy)) {
GLINT_WRITE_REG(InvertBitMask|pGlint->RasterizerSwap,RasterizerMode);
GLINT_WRITE_REG(bg, FBBlockColor);
} else {
GLINT_WRITE_REG(InvertBitMask|BitMaskPackingEachScanline|
pGlint->RasterizerSwap, RasterizerMode);
GLINT_WRITE_REG(bg, ConstantColor);
}
goto SECOND_PASS;
}
GLINT_WAIT(1);
GLINT_WRITE_REG(pGlint->RasterizerSwap, RasterizerMode);
Permedia2DisableClipping(pScrn);
SET_SYNC_FLAG(infoRec);
TRACE_EXIT("Permedia2WriteBitmap");
}
