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"); }