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
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);
}
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);
}
int
XAAHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
int ret = 0;
pm &= infoRec->FullPlanemasks[pScrn->depth - 1];
if(pm == infoRec->FullPlanemasks[pScrn->depth - 1]) {
if(!NO_SRC_ROP(*rop))
ret |= ROP_PAT;
*rop = XAAPatternROP[*rop];
} else {
switch(*rop) {
case GXnoop:
break;
case GXset:
case GXclear:
case GXinvert:
ret |= ROP_PAT;
*fg = pm;
if(*bg != -1)
*bg = pm;
break;
default:
ret |= ROP_PAT | ROP_SRC;
break;
}
*rop = XAAPatternROP_PM[*rop];
}
return ret;
}
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);
}
void
EXPNAME(XAATEGlyphRenderer)(
ScrnInfoPtr pScrn,
int x, int y, int w, int h, int skipleft, int startline,
unsigned int **glyphs, int glyphWidth,
int fg, int bg, int rop, unsigned planemask
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32* base;
GlyphScanlineFuncPtr GlyphFunc = glyph_scanline_func[glyphWidth - 1];
int dwords = 0;
if((bg != -1) && (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
(*infoRec->SetupForSolidFill)(pScrn, bg, rop, planemask);
(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h);
bg = -1;
}
(*infoRec->SetupForCPUToScreenColorExpandFill)(
pScrn, fg, bg, rop, planemask);
if(skipleft &&
(!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING) ||
(!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
(skipleft > x)))) {
/* draw the first character only */
int count = h, line = startline;
int width = glyphWidth - skipleft;
if(width > w) width = w;
(*infoRec->SubsequentCPUToScreenColorExpandFill)(
pScrn, x, y, width, h, 0);
base = (CARD32*)infoRec->ColorExpandBase;
while(count--) {
register CARD32 tmp = SHIFT_R(glyphs[0][line++],skipleft);
WRITE_BITS(tmp);
}
w -= width;
if((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
((((width + 31) >> 5) * h) & 1)) {
base = (CARD32*)infoRec->ColorExpandBase;
base[0] = 0x00000000;
}
if(!w) goto THE_END;
glyphs++;
x += width;
skipleft = 0; /* nicely aligned again */
}
void
XAASolidHorVertLineAsRects(
ScrnInfoPtr pScrn,
int x, int y, int len, int dir
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
if(dir == DEGREES_0)
(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, len, 1);
else
(*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, len);
}
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);
}
void
XAASolidHorVertLineAsBresenham(
ScrnInfoPtr pScrn,
int x, int y, int len, int dir
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
if(dir == DEGREES_0)
(*infoRec->SubsequentSolidBresenhamLine)(
pScrn, x, y, len << 1, 0, -len, len, 0);
else
(*infoRec->SubsequentSolidBresenhamLine)(
pScrn, x, y, len << 1, 0, -len, len, YMAJOR);
}
void
XAASolidHorVertLineAsTwoPoint(
ScrnInfoPtr pScrn,
int x, int y, int len, int dir
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
len--;
if(dir == DEGREES_0)
(*infoRec->SubsequentSolidTwoPointLine)(pScrn, x, y, x + len, y, 0);
else
(*infoRec->SubsequentSolidTwoPointLine)(pScrn, x, y, x, y + len, 0);
}
static void
XPSubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
{
TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
XAAInfoRecPtr infoRec;
infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
MoveDWORDS_FixedBase((CARD32 *)pTrident->IOBase + 0x2160,
(CARD32 *)pTrident->XAAScanlineColorExpandBuffers[0],
pTrident->dwords);
pTrident->h--;
if (pTrident->h)
XPSync(pScrn);
}
static void
Permedia2WritePixmap8bpp(
ScrnInfoPtr pScrn,
int x, int y, int w, int h,
unsigned char *src,
int srcwidth,
int rop,
unsigned int planemask,
int transparency_color,
int bpp, int depth
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
GLINTPtr pGlint = GLINTPTR(pScrn);
int skipleft, dwords, count;
CARD32* srcp;
unsigned char *srcpbyte;
Bool FastTexLoad = FALSE;
TRACE_ENTER("Permedia2SubsequentMono8x8PatternFillRect24bpp");
GLINT_WAIT(3);
DO_PLANEMASK(planemask);
GLINT_WRITE_REG(pGlint->RasterizerSwap,RasterizerMode);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod | FBRM_Packed, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
dwords = (w + 3) >> 2;
#if X_BYTE_ORDER == X_LITTLE_ENDIAN
if((!(x&3)) && (!(w&3))) FastTexLoad = TRUE;
#endif
if((rop != GXcopy) || (planemask != ~0))
FastTexLoad = FALSE;
if (rop == GXcopy) {
skipleft = 0;
} else {
if((skipleft = (long)src & 0x03)) {
skipleft /= (bpp>>3);
x -= skipleft;
w += skipleft;
src = (unsigned char*)((long)src & ~0x03);
}
}
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);
}
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);
}
static void
TridentSubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
{
TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
XAAInfoRecPtr infoRec;
infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
MoveDWORDS((CARD32 *)pTrident->FbBase,
(CARD32 *)pTrident->XAAScanlineColorExpandBuffers[0],
pTrident->dwords);
pTrident->h--;
TridentSync(pScrn);
if (pTrident->h) {
TGUI_DEST_XY(pTrident->x,pTrident->y++);
TGUI_DIM_XY(pTrident->w,1);
TGUI_COMMAND(GE_BLT);
}
}
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");
}
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);
}
static void
WriteColumn(ScrnInfoPtr pScrn,
unsigned char *pSrc,
int x, int y, int w, int h,
int xoff, int yoff, int pHeight, int srcwidth, int Bpp)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
unsigned char *src;
Bool PlusOne = FALSE;
int skipleft, dwords;
pSrc += (Bpp * xoff);
if ((skipleft = (long) pSrc & 0x03L)) {
if (Bpp == 3)
skipleft = 4 - skipleft;
else
skipleft /= Bpp;
x -= skipleft;
w += skipleft;
if (Bpp == 3)
pSrc -= 3 * skipleft;
else /* is this Alpha friendly ? */
pSrc = (unsigned char *) ((long) pSrc & ~0x03L);
}
src = pSrc + (yoff * srcwidth);
dwords = bytes_to_int32(w * Bpp);
if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
((dwords * h) & 0x01)) {
PlusOne = TRUE;
}
(*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, skipleft);
if (dwords > infoRec->ImageWriteRange) {
while (h--) {
XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
(CARD32 *) src, dwords);
src += srcwidth;
yoff++;
if (yoff >= pHeight) {
yoff = 0;
src = pSrc;
}
}
}
else {
if (srcwidth == (dwords << 2)) {
int maxLines = infoRec->ImageWriteRange / dwords;
int step;
while (h) {
step = pHeight - yoff;
if (step > maxLines)
step = maxLines;
if (step > h)
step = h;
XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
(CARD32 *) src, dwords * step);
src += (srcwidth * step);
yoff += step;
if (yoff >= pHeight) {
yoff = 0;
src = pSrc;
}
h -= step;
}
}
else {
while (h--) {
XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
(CARD32 *) src, dwords);
src += srcwidth;
yoff++;
if (yoff >= pHeight) {
yoff = 0;
src = pSrc;
}
}
}
}
if (PlusOne) {
CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
*base = 0x00000000;
}
}
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);
}
