2005-07-03 09:02:09 +02:00
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
|
|
#include <xorg-config.h>
|
|
|
|
#endif
|
|
|
|
|
2006-02-10 23:00:30 +01:00
|
|
|
#include <string.h>
|
|
|
|
|
2005-07-03 10:53:54 +02:00
|
|
|
#include "misc.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86.h"
|
|
|
|
#include "xf86_OSproc.h"
|
|
|
|
|
2005-04-20 14:25:48 +02:00
|
|
|
#include <X11/X.h>
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "scrnintstr.h"
|
|
|
|
#include "xf86str.h"
|
|
|
|
#include "xaa.h"
|
|
|
|
#include "xaalocal.h"
|
|
|
|
#include "xf86fbman.h"
|
|
|
|
#include "servermd.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XAA Config options
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
XAAOPT_SCREEN_TO_SCREEN_COPY,
|
|
|
|
XAAOPT_SOLID_FILL_RECT,
|
|
|
|
XAAOPT_SOLID_FILL_TRAP,
|
|
|
|
XAAOPT_SOLID_TWO_POINT_LINE,
|
|
|
|
XAAOPT_SOLID_BRESENHAM_LINE,
|
|
|
|
XAAOPT_SOLID_HORVERT_LINE,
|
|
|
|
XAAOPT_DASHED_TWO_POINT_LINE,
|
|
|
|
XAAOPT_DASHED_BRESENHAM_LINE,
|
|
|
|
XAAOPT_MONO_8x8_PATTERN_FILL_RECT,
|
|
|
|
XAAOPT_MONO_8x8_PATTERN_FILL_TRAP,
|
|
|
|
XAAOPT_COL_8x8_PATTERN_FILL_RECT,
|
|
|
|
XAAOPT_COL_8x8_PATTERN_FILL_TRAP,
|
|
|
|
XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
XAAOPT_IMAGE_WRITE_RECT,
|
|
|
|
XAAOPT_SCANLINE_IMAGE_WRITE_RECT,
|
|
|
|
XAAOPT_WRITE_BITMAP,
|
|
|
|
XAAOPT_WRITE_PIXMAP,
|
|
|
|
XAAOPT_PIXMAP_CACHE,
|
|
|
|
XAAOPT_OFFSCREEN_PIXMAPS
|
|
|
|
} XAAOpts;
|
|
|
|
|
|
|
|
static const OptionInfoRec XAAOptions[] = {
|
|
|
|
{XAAOPT_SCREEN_TO_SCREEN_COPY, "XaaNoScreenToScreenCopy",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SOLID_FILL_RECT, "XaaNoSolidFillRect",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SOLID_FILL_TRAP, "XaaNoSolidFillTrap",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SOLID_TWO_POINT_LINE, "XaaNoSolidTwoPointLine",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SOLID_BRESENHAM_LINE, "XaaNoSolidBresenhamLine",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SOLID_HORVERT_LINE, "XaaNoSolidHorVertLine",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_DASHED_TWO_POINT_LINE, "XaaNoDashedTwoPointLine",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_DASHED_BRESENHAM_LINE, "XaaNoDashedBresenhamLine",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_MONO_8x8_PATTERN_FILL_RECT, "XaaNoMono8x8PatternFillRect",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_MONO_8x8_PATTERN_FILL_TRAP, "XaaNoMono8x8PatternFillTrap",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_COL_8x8_PATTERN_FILL_RECT, "XaaNoColor8x8PatternFillRect",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_COL_8x8_PATTERN_FILL_TRAP, "XaaNoColor8x8PatternFillTrap",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL, "XaaNoCPUToScreenColorExpandFill",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,"XaaNoScanlineCPUToScreenColorExpandFill",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL, "XaaNoScreenToScreenColorExpandFill",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_IMAGE_WRITE_RECT, "XaaNoImageWriteRect",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_SCANLINE_IMAGE_WRITE_RECT, "XaaNoScanlineImageWriteRect",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_WRITE_BITMAP, "XaaNoWriteBitmap",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_WRITE_PIXMAP, "XaaNoWritePixmap",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_PIXMAP_CACHE, "XaaNoPixmapCache",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{XAAOPT_OFFSCREEN_PIXMAPS, "XaaNoOffscreenPixmaps",
|
|
|
|
OPTV_BOOLEAN, {0}, FALSE },
|
|
|
|
{ -1, NULL,
|
|
|
|
OPTV_NONE, {0}, FALSE }
|
|
|
|
};
|
|
|
|
|
|
|
|
static XF86ModuleVersionInfo xaaVersRec =
|
|
|
|
{
|
|
|
|
"xaa",
|
|
|
|
MODULEVENDORSTRING,
|
|
|
|
MODINFOSTRING1,
|
|
|
|
MODINFOSTRING2,
|
2004-04-23 21:54:30 +02:00
|
|
|
XORG_VERSION_CURRENT,
|
XAA PixmapOps: Sync before accessing unwrapped callbacks.
When using any XAAPixmapOps, we call into unknown but freshly
unwrapped callbacks (like fb ones). Unlike the XAA*Fallback calls,
we did so without syncing first, exposing us to all kinds of
synchronisation issues.
I believe that the rendering errors appeared now because *PaintWindow
vanished (e4d11e58), and we just use miPaintWindow instead. This
takes a less direct route to the hw and ends up at
PolyFillRectPixmap, which very often left drawing artifacts.
We now sync accordingly, and no longer get the rendering artifacts i
was methodically reproducing on radeonhd, radeon, unichrome...
Also, in order to allow driver authors to remove extensive syncing
or flushing to hide this issue, create XAA_VERSION_ defines, put
them in xaa.h and bump the patchlevel.
(novell bug #435791)
2008-11-07 19:11:11 +01:00
|
|
|
XAA_VERSION_MAJOR,
|
|
|
|
XAA_VERSION_MINOR,
|
|
|
|
XAA_VERSION_RELEASE,
|
2003-11-14 17:48:57 +01:00
|
|
|
ABI_CLASS_VIDEODRV, /* requires the video driver ABI */
|
|
|
|
ABI_VIDEODRV_VERSION,
|
|
|
|
MOD_CLASS_NONE,
|
|
|
|
{0,0,0,0}
|
|
|
|
};
|
|
|
|
|
2008-02-01 07:21:34 +01:00
|
|
|
_X_EXPORT XF86ModuleData xaaModuleData = { &xaaVersRec, NULL, NULL };
|
2003-11-14 17:48:57 +01:00
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
Bool
|
2003-11-14 17:48:57 +01:00
|
|
|
XAAInitAccel(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
|
|
|
|
{
|
|
|
|
int index = pScreen->myNum;
|
|
|
|
ScrnInfoPtr pScrn = xf86Screens[index];
|
|
|
|
Bool HaveScreenToScreenCopy = FALSE;
|
|
|
|
Bool HaveColorExpansion = FALSE;
|
|
|
|
Bool HaveScanlineColorExpansion = FALSE;
|
|
|
|
Bool HaveSolidFillRect = FALSE;
|
|
|
|
Bool HaveMono8x8PatternFillRect = FALSE;
|
|
|
|
Bool HaveColor8x8PatternFillRect = FALSE;
|
|
|
|
Bool HaveSolidFillTrap = FALSE;
|
|
|
|
Bool HaveMono8x8PatternFillTrap = FALSE;
|
|
|
|
Bool HaveColor8x8PatternFillTrap = FALSE;
|
|
|
|
Bool HaveSolidTwoPointLine = FALSE;
|
|
|
|
Bool HaveSolidBresenhamLine = FALSE;
|
|
|
|
Bool HaveSolidHorVertLine = FALSE;
|
|
|
|
Bool HaveDashedTwoPointLine = FALSE;
|
|
|
|
Bool HaveDashedBresenhamLine = FALSE;
|
|
|
|
Bool HaveImageWriteRect = FALSE;
|
|
|
|
Bool HaveScanlineImageWriteRect = FALSE;
|
|
|
|
Bool HaveScreenToScreenColorExpandFill = FALSE;
|
|
|
|
OptionInfoPtr options;
|
|
|
|
int is_shared = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
options = xnfalloc(sizeof(XAAOptions));
|
|
|
|
(void)memcpy(options, XAAOptions, sizeof(XAAOptions));
|
|
|
|
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
|
|
|
|
|
|
|
|
infoRec->pScrn = pScrn;
|
|
|
|
infoRec->NeedToSync = FALSE;
|
|
|
|
|
|
|
|
/* must have a Sync function */
|
|
|
|
if(!infoRec->Sync) return FALSE;
|
|
|
|
for(i = 0; i < pScrn->numEntities; i++) {
|
|
|
|
if(xf86IsEntityShared(pScrn->entityList[i])) is_shared = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If this PCI entity has IS_SHARED_ACCEL set in entityProp
|
|
|
|
* then a RestoreAccelState function is required
|
|
|
|
*/
|
|
|
|
if(!infoRec->RestoreAccelState && is_shared) return FALSE;
|
|
|
|
|
|
|
|
if(infoRec->RestoreAccelState) {
|
|
|
|
if(!XAAInitStateWrap(pScreen, infoRec)) return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (serverGeneration == 1)
|
|
|
|
xf86DrvMsg(index, X_INFO,
|
|
|
|
"Using XFree86 Acceleration Architecture (XAA)\n");
|
|
|
|
|
|
|
|
|
|
|
|
/************** Low Level *************/
|
|
|
|
|
|
|
|
if(!infoRec->SetClippingRectangle || !infoRec->DisableClipping) {
|
|
|
|
infoRec->ClippingFlags = 0;
|
|
|
|
infoRec->SetClippingRectangle = NULL;
|
|
|
|
infoRec->DisableClipping = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** CopyArea ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForScreenToScreenCopy &&
|
|
|
|
infoRec->SubsequentScreenToScreenCopy &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COPY, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveScreenToScreenCopy = TRUE;
|
|
|
|
} else {
|
|
|
|
infoRec->ScreenToScreenCopyFlags = 0;
|
|
|
|
infoRec->SetupForScreenToScreenCopy = NULL;
|
|
|
|
infoRec->SubsequentScreenToScreenCopy = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Solid Filled Rects ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForSolidFill && infoRec->SubsequentSolidFillRect &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_RECT, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveSolidFillRect = TRUE;
|
|
|
|
if(infoRec->SubsequentSolidFillTrap &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_TRAP, FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveSolidFillTrap = TRUE;
|
|
|
|
else
|
|
|
|
infoRec->SubsequentSolidFillTrap = NULL;
|
|
|
|
} else {
|
|
|
|
infoRec->SolidFillFlags = 0;
|
|
|
|
infoRec->SetupForSolidFill = NULL;
|
|
|
|
infoRec->SubsequentSolidFillRect = NULL;
|
|
|
|
infoRec->SubsequentSolidFillTrap = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Solid lines ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForSolidLine) {
|
|
|
|
if(infoRec->SubsequentSolidTwoPointLine &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options,
|
|
|
|
XAAOPT_SOLID_TWO_POINT_LINE, FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveSolidTwoPointLine = TRUE;
|
|
|
|
if(infoRec->SubsequentSolidBresenhamLine &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SOLID_BRESENHAM_LINE, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveSolidBresenhamLine = TRUE;
|
|
|
|
|
|
|
|
if(infoRec->SolidBresenhamLineErrorTermBits)
|
|
|
|
infoRec->SolidBresenhamLineErrorTermBits =
|
|
|
|
~((1 << infoRec->SolidBresenhamLineErrorTermBits) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->SubsequentSolidHorVertLine &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options,
|
|
|
|
XAAOPT_SOLID_HORVERT_LINE, FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveSolidHorVertLine = TRUE;
|
|
|
|
else if(HaveSolidTwoPointLine) {
|
|
|
|
infoRec->SubsequentSolidHorVertLine =
|
|
|
|
XAASolidHorVertLineAsTwoPoint;
|
|
|
|
HaveSolidHorVertLine = TRUE;
|
|
|
|
} else if(HaveSolidBresenhamLine) {
|
|
|
|
infoRec->SubsequentSolidHorVertLine =
|
|
|
|
XAASolidHorVertLineAsBresenham;
|
|
|
|
HaveSolidHorVertLine = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX Should this also check for XAAOPT_SOLID_HORVERT_LINE? */
|
|
|
|
if (!HaveSolidTwoPointLine &&
|
|
|
|
!HaveSolidBresenhamLine &&
|
|
|
|
!HaveSolidHorVertLine &&
|
|
|
|
HaveSolidFillRect) {
|
|
|
|
infoRec->SetupForSolidLine = infoRec->SetupForSolidFill;
|
|
|
|
infoRec->SubsequentSolidHorVertLine = XAASolidHorVertLineAsRects;
|
|
|
|
infoRec->SolidLineFlags = infoRec->SolidFillFlags;
|
|
|
|
HaveSolidHorVertLine = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!HaveSolidTwoPointLine)
|
|
|
|
infoRec->SubsequentSolidTwoPointLine = NULL;
|
|
|
|
if (!HaveSolidBresenhamLine)
|
|
|
|
infoRec->SubsequentSolidBresenhamLine = NULL;
|
|
|
|
if (!HaveSolidHorVertLine)
|
|
|
|
infoRec->SubsequentSolidHorVertLine = NULL;
|
|
|
|
|
|
|
|
/* Disable all if nothing left over */
|
|
|
|
if (!HaveSolidTwoPointLine &&
|
|
|
|
!HaveSolidBresenhamLine &&
|
|
|
|
!HaveSolidHorVertLine) {
|
|
|
|
infoRec->SolidLineFlags = 0;
|
|
|
|
infoRec->SetupForSolidLine = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** 8x8 Mono Pattern Filled Rects ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForMono8x8PatternFill &&
|
|
|
|
infoRec->SubsequentMono8x8PatternFillRect &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options,
|
|
|
|
XAAOPT_MONO_8x8_PATTERN_FILL_RECT,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveMono8x8PatternFillRect = TRUE;
|
|
|
|
if(infoRec->SubsequentMono8x8PatternFillTrap &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options,
|
|
|
|
XAAOPT_MONO_8x8_PATTERN_FILL_TRAP,
|
|
|
|
FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveMono8x8PatternFillTrap = TRUE;
|
|
|
|
|
|
|
|
if(infoRec->Mono8x8PatternFillFlags &
|
|
|
|
HARDWARE_PATTERN_PROGRAMMED_BITS) {
|
|
|
|
infoRec->CanDoMono8x8 = TRUE;
|
|
|
|
} else { /* others require caching */
|
|
|
|
int min_pitch;
|
|
|
|
infoRec->PixmapCacheFlags |= CACHE_MONO_8x8;
|
|
|
|
|
|
|
|
switch(pScrn->bitsPerPixel) {
|
|
|
|
case 32: min_pitch = 2; break;
|
|
|
|
case 24: min_pitch = 3; break;
|
|
|
|
case 16: min_pitch = 4; break;
|
|
|
|
default: min_pitch = 8; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(min_pitch > infoRec->MonoPatternPitch)
|
|
|
|
infoRec->MonoPatternPitch = min_pitch;
|
|
|
|
|
|
|
|
if(infoRec->Mono8x8PatternFillFlags &
|
|
|
|
HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
|
|
|
|
if(!infoRec->CacheWidthMono8x8Pattern ||
|
|
|
|
!infoRec->CacheHeightMono8x8Pattern) {
|
|
|
|
infoRec->CacheWidthMono8x8Pattern =
|
|
|
|
infoRec->MonoPatternPitch;
|
|
|
|
infoRec->CacheHeightMono8x8Pattern = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int numPerLine = 128/infoRec->MonoPatternPitch;
|
|
|
|
|
|
|
|
if(!infoRec->CacheWidthMono8x8Pattern ||
|
|
|
|
!infoRec->CacheHeightMono8x8Pattern) {
|
|
|
|
infoRec->CacheWidthMono8x8Pattern =
|
|
|
|
numPerLine * infoRec->MonoPatternPitch;
|
|
|
|
infoRec->CacheHeightMono8x8Pattern =
|
|
|
|
(64 + numPerLine - 1)/numPerLine;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
infoRec->Mono8x8PatternFillFlags = 0;
|
|
|
|
infoRec->SetupForMono8x8PatternFill = NULL;
|
|
|
|
infoRec->SubsequentMono8x8PatternFillRect = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Dashed lines ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForDashedLine && infoRec->DashPatternMaxLength) {
|
|
|
|
if(infoRec->SubsequentDashedTwoPointLine &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_DASHED_TWO_POINT_LINE,
|
|
|
|
FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveDashedTwoPointLine = TRUE;
|
|
|
|
if(infoRec->SubsequentDashedBresenhamLine &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_DASHED_BRESENHAM_LINE,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveDashedBresenhamLine = TRUE;
|
|
|
|
|
|
|
|
if(infoRec->DashedBresenhamLineErrorTermBits)
|
|
|
|
infoRec->DashedBresenhamLineErrorTermBits =
|
|
|
|
~((1 << infoRec->DashedBresenhamLineErrorTermBits) - 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!HaveDashedTwoPointLine)
|
|
|
|
infoRec->SubsequentDashedTwoPointLine = NULL;
|
|
|
|
if (!HaveDashedBresenhamLine)
|
|
|
|
infoRec->SubsequentDashedBresenhamLine = NULL;
|
|
|
|
|
|
|
|
/* Disable all if nothing left over */
|
|
|
|
if (!HaveDashedTwoPointLine && !HaveDashedBresenhamLine) {
|
|
|
|
infoRec->DashedLineFlags = 0;
|
|
|
|
infoRec->SetupForDashedLine = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** 8x8 Color Pattern Filled Rects ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForColor8x8PatternFill &&
|
|
|
|
infoRec->SubsequentColor8x8PatternFillRect &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_RECT, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveColor8x8PatternFillRect = TRUE;
|
|
|
|
if(infoRec->SubsequentColor8x8PatternFillTrap &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_TRAP,
|
|
|
|
FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveColor8x8PatternFillTrap = TRUE;
|
|
|
|
else
|
|
|
|
infoRec->SubsequentColor8x8PatternFillTrap = NULL;
|
|
|
|
|
|
|
|
infoRec->PixmapCacheFlags |= CACHE_COLOR_8x8;
|
|
|
|
|
|
|
|
if(infoRec->Color8x8PatternFillFlags &
|
|
|
|
HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
|
|
|
|
if(!infoRec->CacheWidthColor8x8Pattern ||
|
|
|
|
!infoRec->CacheHeightColor8x8Pattern) {
|
|
|
|
infoRec->CacheWidthColor8x8Pattern = 64;
|
|
|
|
infoRec->CacheHeightColor8x8Pattern = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(!infoRec->CacheWidthColor8x8Pattern ||
|
|
|
|
!infoRec->CacheHeightColor8x8Pattern) {
|
|
|
|
infoRec->CacheWidthColor8x8Pattern = 128;
|
|
|
|
infoRec->CacheHeightColor8x8Pattern = 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
infoRec->Color8x8PatternFillFlags = 0;
|
|
|
|
infoRec->SetupForColor8x8PatternFill = NULL;
|
|
|
|
infoRec->SubsequentColor8x8PatternFillRect = NULL;
|
|
|
|
infoRec->SubsequentColor8x8PatternFillTrap = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Color Expansion ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForCPUToScreenColorExpandFill &&
|
|
|
|
infoRec->ColorExpandBase &&
|
|
|
|
infoRec->SubsequentCPUToScreenColorExpandFill &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
int dwordsNeeded = pScrn->virtualX;
|
|
|
|
|
|
|
|
infoRec->ColorExpandRange >>= 2; /* convert to DWORDS */
|
|
|
|
HaveColorExpansion = TRUE;
|
|
|
|
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
LEFT_EDGE_CLIPPING_NEGATIVE_X)
|
|
|
|
dwordsNeeded += 31;
|
|
|
|
dwordsNeeded = (dwordsNeeded + 31) >> 5;
|
|
|
|
if(dwordsNeeded > infoRec->ColorExpandRange)
|
|
|
|
infoRec->CPUToScreenColorExpandFillFlags |= CPU_TRANSFER_BASE_FIXED;
|
|
|
|
} else {
|
|
|
|
infoRec->CPUToScreenColorExpandFillFlags = 0;
|
|
|
|
infoRec->SetupForCPUToScreenColorExpandFill = NULL;
|
|
|
|
infoRec->SubsequentCPUToScreenColorExpandFill = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Scanline Color Expansion ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForScanlineCPUToScreenColorExpandFill &&
|
|
|
|
infoRec->SubsequentScanlineCPUToScreenColorExpandFill &&
|
|
|
|
infoRec->SubsequentColorExpandScanline &&
|
|
|
|
infoRec->ScanlineColorExpandBuffers &&
|
|
|
|
(infoRec->NumScanlineColorExpandBuffers > 0) &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options,
|
|
|
|
XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveScanlineColorExpansion = TRUE;
|
|
|
|
} else {
|
|
|
|
infoRec->ScanlineCPUToScreenColorExpandFillFlags = 0;
|
|
|
|
infoRec->SetupForScanlineCPUToScreenColorExpandFill = NULL;
|
|
|
|
infoRec->SubsequentScanlineCPUToScreenColorExpandFill = NULL;
|
|
|
|
infoRec->SubsequentColorExpandScanline = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Screen to Screen Color Expansion ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForScreenToScreenColorExpandFill &&
|
|
|
|
infoRec->SubsequentScreenToScreenColorExpandFill &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveScreenToScreenColorExpandFill = TRUE;
|
|
|
|
if (!infoRec->CacheColorExpandDensity)
|
|
|
|
infoRec->CacheColorExpandDensity = 1;
|
|
|
|
} else {
|
|
|
|
infoRec->ScreenToScreenColorExpandFillFlags = 0;
|
|
|
|
infoRec->SetupForScreenToScreenColorExpandFill = NULL;
|
|
|
|
infoRec->SubsequentScreenToScreenColorExpandFill = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Image Writes ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForImageWrite && infoRec->ImageWriteBase &&
|
|
|
|
infoRec->SubsequentImageWriteRect &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_IMAGE_WRITE_RECT, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
infoRec->ImageWriteRange >>= 2; /* convert to DWORDS */
|
|
|
|
if(infoRec->ImageWriteFlags & CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->ImageWriteRange = 0;
|
|
|
|
HaveImageWriteRect = TRUE;
|
|
|
|
} else {
|
|
|
|
infoRec->ImageWriteFlags = 0;
|
|
|
|
infoRec->SetupForImageWrite = NULL;
|
|
|
|
infoRec->SubsequentImageWriteRect = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** Scanline Image Writes ****/
|
|
|
|
|
|
|
|
if(infoRec->SetupForScanlineImageWrite &&
|
|
|
|
infoRec->SubsequentScanlineImageWriteRect &&
|
|
|
|
infoRec->SubsequentImageWriteScanline &&
|
|
|
|
infoRec->ScanlineImageWriteBuffers &&
|
|
|
|
(infoRec->NumScanlineImageWriteBuffers > 0) &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_SCANLINE_IMAGE_WRITE_RECT,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
HaveScanlineImageWriteRect = TRUE;
|
|
|
|
} else {
|
|
|
|
infoRec->ScanlineImageWriteFlags = 0;
|
|
|
|
infoRec->SetupForScanlineImageWrite = NULL;
|
|
|
|
infoRec->SubsequentScanlineImageWriteRect = NULL;
|
|
|
|
infoRec->SubsequentImageWriteScanline = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef __i386__
|
|
|
|
/* XAA makes some unaligned accesses when clipping is not available */
|
|
|
|
# define CLIP_FLAGS (LEFT_EDGE_CLIPPING | LEFT_EDGE_CLIPPING_NEGATIVE_X)
|
|
|
|
if(HaveImageWriteRect &&
|
|
|
|
((infoRec->ImageWriteFlags & CLIP_FLAGS) != CLIP_FLAGS))
|
|
|
|
{
|
|
|
|
HaveImageWriteRect = FALSE;
|
|
|
|
}
|
|
|
|
if(HaveScanlineImageWriteRect &&
|
|
|
|
((infoRec->ScanlineImageWriteFlags & CLIP_FLAGS) != CLIP_FLAGS))
|
|
|
|
{
|
|
|
|
HaveScanlineImageWriteRect = FALSE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (serverGeneration == 1) {
|
|
|
|
if(HaveScreenToScreenCopy)
|
|
|
|
xf86ErrorF("\tScreen to screen bit blits\n");
|
|
|
|
if(HaveSolidFillRect)
|
|
|
|
xf86ErrorF("\tSolid filled rectangles\n");
|
|
|
|
if(HaveSolidFillTrap)
|
|
|
|
xf86ErrorF("\tSolid filled trapezoids\n");
|
|
|
|
if(HaveMono8x8PatternFillRect)
|
|
|
|
xf86ErrorF("\t8x8 mono pattern filled rectangles\n");
|
|
|
|
if(HaveMono8x8PatternFillTrap)
|
|
|
|
xf86ErrorF("\t8x8 mono pattern filled trapezoids\n");
|
|
|
|
if(HaveColor8x8PatternFillRect)
|
|
|
|
xf86ErrorF("\t8x8 color pattern filled rectangles\n");
|
|
|
|
if(HaveColor8x8PatternFillTrap)
|
|
|
|
xf86ErrorF("\t8x8 color pattern filled trapezoids\n");
|
|
|
|
|
|
|
|
if(HaveColorExpansion)
|
|
|
|
xf86ErrorF("\tCPU to Screen color expansion\n");
|
|
|
|
else if(HaveScanlineColorExpansion)
|
|
|
|
xf86ErrorF("\tIndirect CPU to Screen color expansion\n");
|
|
|
|
|
|
|
|
if(HaveScreenToScreenColorExpandFill)
|
|
|
|
xf86ErrorF("\tScreen to Screen color expansion\n");
|
|
|
|
|
|
|
|
if(HaveSolidTwoPointLine || HaveSolidBresenhamLine)
|
|
|
|
xf86ErrorF("\tSolid Lines\n");
|
|
|
|
else if(HaveSolidHorVertLine)
|
|
|
|
xf86ErrorF("\tSolid Horizontal and Vertical Lines\n");
|
|
|
|
|
|
|
|
if(HaveDashedTwoPointLine || HaveDashedBresenhamLine)
|
|
|
|
xf86ErrorF("\tDashed Lines\n");
|
|
|
|
|
|
|
|
if(HaveImageWriteRect)
|
|
|
|
xf86ErrorF("\tImage Writes\n");
|
|
|
|
else if(HaveScanlineImageWriteRect)
|
|
|
|
xf86ErrorF("\tScanline Image Writes\n");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#define XAAMSG(s) do { if (serverGeneration == 1) xf86ErrorF(s); } while (0)
|
|
|
|
|
|
|
|
if((infoRec->Flags & OFFSCREEN_PIXMAPS) && HaveScreenToScreenCopy &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_OFFSCREEN_PIXMAPS,
|
|
|
|
FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
XAAMSG("\tOffscreen Pixmaps\n");
|
|
|
|
} else {
|
|
|
|
infoRec->Flags &= ~OFFSCREEN_PIXMAPS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/************** Mid Level *************/
|
|
|
|
|
|
|
|
/**** ScreenToScreenBitBlt ****/
|
|
|
|
|
|
|
|
if(infoRec->ScreenToScreenBitBlt) {
|
|
|
|
XAAMSG("\tDriver provided ScreenToScreenBitBlt replacement\n");
|
|
|
|
} else if(HaveScreenToScreenCopy) {
|
|
|
|
infoRec->ScreenToScreenBitBlt = XAAScreenToScreenBitBlt;
|
|
|
|
infoRec->ScreenToScreenBitBltFlags = infoRec->ScreenToScreenCopyFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillSolidRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillSolidRects) {
|
|
|
|
XAAMSG("\tDriver provided FillSolidRects replacement\n");
|
|
|
|
} else if(HaveSolidFillRect) {
|
|
|
|
infoRec->FillSolidRects = XAAFillSolidRects;
|
|
|
|
infoRec->FillSolidRectsFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillSolidSpans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillSolidSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillSolidSpans replacement\n");
|
|
|
|
} else if(HaveSolidFillRect) {
|
|
|
|
infoRec->FillSolidSpans = XAAFillSolidSpans;
|
|
|
|
infoRec->FillSolidSpansFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillMono8x8PatternRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternRects) {
|
|
|
|
XAAMSG("\tDriver provided FillMono8x8PatternRects replacement\n");
|
|
|
|
} else if(HaveMono8x8PatternFillRect) {
|
|
|
|
infoRec->FillMono8x8PatternRects =
|
|
|
|
(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
|
|
|
|
XAAFillMono8x8PatternRectsScreenOrigin :
|
|
|
|
XAAFillMono8x8PatternRects;
|
|
|
|
|
|
|
|
infoRec->FillMono8x8PatternRectsFlags =
|
|
|
|
infoRec->Mono8x8PatternFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillMono8x8PatternSpans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillMono8x8PatternSpans replacement\n");
|
|
|
|
} else if(HaveMono8x8PatternFillRect) {
|
|
|
|
infoRec->FillMono8x8PatternSpans =
|
|
|
|
(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
|
|
|
|
XAAFillMono8x8PatternSpansScreenOrigin:
|
|
|
|
XAAFillMono8x8PatternSpans;
|
|
|
|
|
|
|
|
infoRec->FillMono8x8PatternSpansFlags =
|
|
|
|
infoRec->Mono8x8PatternFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillColor8x8Rects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillColor8x8PatternRects) {
|
|
|
|
XAAMSG("\tDriver provided FillColor8x8PatternRects replacement\n");
|
|
|
|
} else if(HaveColor8x8PatternFillRect) {
|
|
|
|
infoRec->FillColor8x8PatternRects =
|
|
|
|
(infoRec->Color8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
|
|
|
|
XAAFillColor8x8PatternRectsScreenOrigin :
|
|
|
|
XAAFillColor8x8PatternRects;
|
|
|
|
|
|
|
|
infoRec->FillColor8x8PatternRectsFlags =
|
|
|
|
infoRec->Color8x8PatternFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillColor8x8Spans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillColor8x8PatternSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillColor8x8PatternSpans replacement\n");
|
|
|
|
} else if(HaveColor8x8PatternFillRect) {
|
|
|
|
infoRec->FillColor8x8PatternSpans =
|
|
|
|
(infoRec->Color8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
|
|
|
|
XAAFillColor8x8PatternSpansScreenOrigin:
|
|
|
|
XAAFillColor8x8PatternSpans;
|
|
|
|
|
|
|
|
infoRec->FillColor8x8PatternSpansFlags =
|
|
|
|
infoRec->Color8x8PatternFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillCacheBltRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillCacheBltRects) {
|
|
|
|
XAAMSG("\tDriver provided FillCacheBltRects replacement\n");
|
|
|
|
} else if(HaveScreenToScreenCopy) {
|
|
|
|
infoRec->FillCacheBltRects = XAAFillCacheBltRects;
|
|
|
|
infoRec->FillCacheBltRectsFlags = infoRec->ScreenToScreenCopyFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillCacheBltSpans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillCacheBltSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillCacheBltSpans replacement\n");
|
|
|
|
} else if(HaveScreenToScreenCopy) {
|
|
|
|
infoRec->FillCacheBltSpans = XAAFillCacheBltSpans;
|
|
|
|
infoRec->FillCacheBltSpansFlags = infoRec->ScreenToScreenCopyFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillCacheExpandRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillCacheExpandRects) {
|
|
|
|
XAAMSG("\tDriver provided FillCacheExpandRects replacement\n");
|
|
|
|
} else if(HaveScreenToScreenColorExpandFill) {
|
|
|
|
infoRec->FillCacheExpandRects = XAAFillCacheExpandRects;
|
|
|
|
infoRec->FillCacheExpandRectsFlags =
|
|
|
|
infoRec->ScreenToScreenColorExpandFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillCacheExpandSpans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillCacheExpandSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillCacheExpandSpans replacement\n");
|
|
|
|
} else if(HaveScreenToScreenColorExpandFill) {
|
|
|
|
infoRec->FillCacheExpandSpans = XAAFillCacheExpandSpans;
|
|
|
|
infoRec->FillCacheExpandSpansFlags =
|
|
|
|
infoRec->ScreenToScreenColorExpandFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillColorExpandRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillColorExpandRects) {
|
|
|
|
XAAMSG("\tDriver provided FillColorExpandRects replacement\n");
|
|
|
|
} else if(HaveColorExpansion) {
|
|
|
|
if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRects3MSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRects3MSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRects3LSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRects3LSBFirst;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRectsMSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRectsMSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRectsLSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillColorExpandRectsLSBFirst;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
infoRec->FillColorExpandRectsFlags =
|
|
|
|
infoRec->CPUToScreenColorExpandFillFlags;
|
|
|
|
} else if(HaveScanlineColorExpansion) {
|
|
|
|
if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillScanlineColorExpandRects3MSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillScanlineColorExpandRects3LSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillScanlineColorExpandRectsMSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandRects =
|
|
|
|
XAAFillScanlineColorExpandRectsLSBFirst;
|
|
|
|
}
|
|
|
|
infoRec->FillColorExpandRectsFlags =
|
|
|
|
infoRec->ScanlineCPUToScreenColorExpandFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillColorExpandSpans ****/
|
|
|
|
|
|
|
|
if(infoRec->FillColorExpandSpans) {
|
|
|
|
XAAMSG("\tDriver provided FillColorExpandSpans replacement\n");
|
|
|
|
} else if(HaveColorExpansion) {
|
|
|
|
if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpans3MSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpans3MSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpans3LSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpans3LSBFirst;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpansMSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpansMSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpansLSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillColorExpandSpansLSBFirst;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
infoRec->FillColorExpandSpansFlags =
|
|
|
|
infoRec->CPUToScreenColorExpandFillFlags;
|
|
|
|
} else if(HaveScanlineColorExpansion) {
|
|
|
|
if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillScanlineColorExpandSpans3MSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillScanlineColorExpandSpans3LSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillScanlineColorExpandSpansMSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->FillColorExpandSpans =
|
|
|
|
XAAFillScanlineColorExpandSpansLSBFirst;
|
|
|
|
}
|
|
|
|
infoRec->FillColorExpandSpansFlags =
|
|
|
|
infoRec->ScanlineCPUToScreenColorExpandFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** FillImageWriteRects ****/
|
|
|
|
|
|
|
|
if(infoRec->FillImageWriteRects) {
|
|
|
|
XAAMSG("\tDriver provided FillImageWriteRects replacement\n");
|
|
|
|
} else if(HaveImageWriteRect &&
|
|
|
|
(infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
|
|
|
|
(infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING)) {
|
|
|
|
infoRec->FillImageWriteRects = XAAFillImageWriteRects;
|
|
|
|
infoRec->FillImageWriteRectsFlags = infoRec->ImageWriteFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** WriteBitmap ****/
|
|
|
|
|
|
|
|
if(infoRec->WriteBitmap &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_WRITE_BITMAP, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
XAAMSG("\tDriver provided WriteBitmap replacement\n");
|
|
|
|
} else if(HaveColorExpansion) {
|
|
|
|
if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapColorExpand3MSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap = XAAWriteBitmapColorExpand3MSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapColorExpand3LSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap = XAAWriteBitmapColorExpand3LSBFirst;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapColorExpandMSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap = XAAWriteBitmapColorExpandMSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->CPUToScreenColorExpandFillFlags &
|
|
|
|
CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapColorExpandLSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap = XAAWriteBitmapColorExpandLSBFirst;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
infoRec->WriteBitmapFlags = infoRec->CPUToScreenColorExpandFillFlags;
|
|
|
|
} else if(HaveScanlineColorExpansion) {
|
|
|
|
if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
TRIPLE_BITS_24BPP) {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapScanlineColorExpand3MSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapScanlineColorExpand3LSBFirst;
|
|
|
|
} else {
|
|
|
|
if(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
|
|
|
|
BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapScanlineColorExpandMSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->WriteBitmap =
|
|
|
|
XAAWriteBitmapScanlineColorExpandLSBFirst;
|
|
|
|
}
|
|
|
|
infoRec->WriteBitmapFlags =
|
|
|
|
infoRec->ScanlineCPUToScreenColorExpandFillFlags;
|
|
|
|
} else
|
|
|
|
infoRec->WriteBitmap = NULL;
|
|
|
|
|
|
|
|
/**** TE Glyphs ****/
|
|
|
|
|
|
|
|
if (infoRec->TEGlyphRenderer) {
|
|
|
|
XAAMSG("\tDriver provided TEGlyphRenderer replacement\n");
|
|
|
|
} else if (HaveColorExpansion) {
|
|
|
|
infoRec->TEGlyphRendererFlags =
|
|
|
|
infoRec->CPUToScreenColorExpandFillFlags;
|
|
|
|
|
|
|
|
if (infoRec->TEGlyphRendererFlags & TRIPLE_BITS_24BPP) {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->TEGlyphRenderer =
|
|
|
|
XAATEGlyphRenderer3MSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRenderer3MSBFirst;
|
|
|
|
} else {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->TEGlyphRenderer =
|
|
|
|
XAATEGlyphRenderer3LSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRenderer3LSBFirst;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!HaveSolidFillRect &&
|
|
|
|
(infoRec->TEGlyphRendererFlags & RGB_EQUAL)) {
|
|
|
|
infoRec->TEGlyphRendererFlags &= ~RGB_EQUAL;
|
|
|
|
XAAMSG("WARNING: TEGlyphRenderer cannot support RGB_EQUAL"
|
|
|
|
" without solid fills\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->TEGlyphRenderer =
|
|
|
|
XAATEGlyphRendererMSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererMSBFirst;
|
|
|
|
} else {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
|
|
|
|
infoRec->TEGlyphRenderer =
|
|
|
|
XAATEGlyphRendererLSBFirstFixedBase;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererLSBFirst;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!HaveSolidFillRect &&
|
|
|
|
(infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
|
|
|
|
infoRec->TEGlyphRendererFlags &= ~TRANSPARENCY_ONLY;
|
|
|
|
XAAMSG("WARNING: TEGlyphRenderer cannot support TRANPARENCY_ONLY"
|
|
|
|
" without solid fills\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (HaveScanlineColorExpansion) {
|
|
|
|
infoRec->TEGlyphRendererFlags =
|
|
|
|
infoRec->ScanlineCPUToScreenColorExpandFillFlags;
|
|
|
|
|
|
|
|
if (infoRec->TEGlyphRendererFlags & TRIPLE_BITS_24BPP) {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererScanline3MSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererScanline3LSBFirst;
|
|
|
|
|
|
|
|
if (!HaveSolidFillRect &&
|
|
|
|
(infoRec->TEGlyphRendererFlags & RGB_EQUAL)) {
|
|
|
|
infoRec->TEGlyphRendererFlags &= ~RGB_EQUAL;
|
|
|
|
XAAMSG("WARNING: TEGlyphRenderer cannot support RGB_EQUAL"
|
|
|
|
" without solid fills\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererScanlineMSBFirst;
|
|
|
|
else
|
|
|
|
infoRec->TEGlyphRenderer = XAATEGlyphRendererScanlineLSBFirst;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!HaveSolidFillRect &&
|
|
|
|
(infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
|
|
|
|
infoRec->TEGlyphRendererFlags &= ~TRANSPARENCY_ONLY;
|
|
|
|
XAAMSG("WARNING: TEGlyphRenderer cannot support TRANPARENCY_ONLY"
|
|
|
|
" without solid fills\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** NonTE Glyphs ****/
|
|
|
|
|
|
|
|
if(infoRec->NonTEGlyphRenderer) {
|
|
|
|
XAAMSG("\tDriver provided NonTEGlyphRenderer replacement\n");
|
|
|
|
} else if(infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & NO_TRANSPARENCY)) {
|
|
|
|
infoRec->NonTEGlyphRenderer = XAANonTEGlyphRenderer;
|
|
|
|
infoRec->NonTEGlyphRendererFlags = infoRec->WriteBitmapFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**** WritePixmap ****/
|
|
|
|
|
|
|
|
if(infoRec->WritePixmap &&
|
2008-03-22 17:31:08 +01:00
|
|
|
!xf86ReturnOptValBool(options, XAAOPT_WRITE_PIXMAP, FALSE)) {
|
2003-11-14 17:48:57 +01:00
|
|
|
XAAMSG("\tDriver provided WritePixmap replacement\n");
|
|
|
|
} else if(HaveImageWriteRect) {
|
|
|
|
infoRec->WritePixmap = XAAWritePixmap;
|
|
|
|
infoRec->WritePixmapFlags =
|
|
|
|
infoRec->ImageWriteFlags | CONVERT_32BPP_TO_24BPP;
|
|
|
|
} else if(HaveScanlineImageWriteRect) {
|
|
|
|
infoRec->WritePixmap = XAAWritePixmapScanline;
|
|
|
|
infoRec->WritePixmapFlags = infoRec->ScanlineImageWriteFlags;
|
|
|
|
} else
|
|
|
|
infoRec->WritePixmap = NULL;
|
|
|
|
|
|
|
|
/**** ReadPixmap ****/
|
|
|
|
|
|
|
|
if(infoRec->ReadPixmap) {
|
|
|
|
XAAMSG("\tDriver provided ReadPixmap replacement\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/************** GC Level *************/
|
|
|
|
|
|
|
|
/**** CopyArea ****/
|
|
|
|
|
|
|
|
if(infoRec->CopyArea) {
|
|
|
|
XAAMSG("\tDriver provided GC level CopyArea replacement\n");
|
|
|
|
} else if(infoRec->ScreenToScreenBitBlt) {
|
|
|
|
infoRec->CopyArea = XAACopyArea;
|
|
|
|
infoRec->CopyAreaFlags = infoRec->ScreenToScreenBitBltFlags;
|
|
|
|
|
|
|
|
/* most GC level primitives use one mid-level primitive so
|
|
|
|
the GC level primitive gets the mid-level primitive flag
|
|
|
|
and we use that at GC validation time. But CopyArea uses
|
|
|
|
more than one mid-level primitive so we have to essentially
|
|
|
|
do a GC validation every time that primitive is used.
|
|
|
|
The CopyAreaFlags would only be used for filtering out the
|
|
|
|
common denominators. Here we assume that if you don't do
|
|
|
|
ScreenToScreenBitBlt you aren't going to do the others.
|
|
|
|
We also assume that ScreenToScreenBitBlt has the least
|
|
|
|
restrictions. */
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->CopyPlane) {
|
|
|
|
XAAMSG("\tDriver provided GC level CopyPlane replacement\n");
|
|
|
|
} else if(infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)) {
|
|
|
|
infoRec->CopyPlane = XAACopyPlaneColorExpansion;
|
|
|
|
infoRec->CopyPlaneFlags = infoRec->WriteBitmapFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->PushPixelsSolid) {
|
|
|
|
XAAMSG("\tDriver provided GC level PushPixelsSolid replacement\n");
|
|
|
|
} else if(infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & NO_TRANSPARENCY)) {
|
|
|
|
infoRec->PushPixelsSolid = XAAPushPixelsSolidColorExpansion;
|
|
|
|
infoRec->PushPixelsFlags = infoRec->WriteBitmapFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillSolidRects) {
|
|
|
|
if(!infoRec->PolyFillRectSolid) {
|
|
|
|
infoRec->PolyFillRectSolid = XAAPolyFillRect;
|
|
|
|
infoRec->PolyFillRectSolidFlags = infoRec->FillSolidRectsFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(infoRec->FillSolidSpans) {
|
|
|
|
if(!infoRec->FillSpansSolid) {
|
|
|
|
infoRec->FillSpansSolid = XAAFillSpans;
|
|
|
|
infoRec->FillSpansSolidFlags = infoRec->FillSolidSpansFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
|
|
|
|
infoRec->FillCacheBltRects || infoRec->FillColorExpandRects ||
|
|
|
|
infoRec->FillCacheExpandRects) {
|
|
|
|
if(!infoRec->PolyFillRectStippled) {
|
|
|
|
|
|
|
|
infoRec->PolyFillRectStippled = XAAPolyFillRect;
|
|
|
|
infoRec->PolyFillRectStippledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
|
|
|
|
infoRec->FillCacheBltSpans || infoRec->FillColorExpandSpans ||
|
|
|
|
infoRec->FillCacheExpandSpans) {
|
|
|
|
if(!infoRec->FillSpansStippled) {
|
|
|
|
|
|
|
|
infoRec->FillSpansStippled = XAAFillSpans;
|
|
|
|
infoRec->FillSpansStippledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
|
|
|
|
infoRec->FillCacheBltRects || infoRec->FillColorExpandRects ||
|
|
|
|
infoRec->FillCacheExpandRects) {
|
|
|
|
if(!infoRec->PolyFillRectOpaqueStippled) {
|
|
|
|
|
|
|
|
infoRec->PolyFillRectOpaqueStippled = XAAPolyFillRect;
|
|
|
|
infoRec->PolyFillRectOpaqueStippledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
|
|
|
|
infoRec->FillCacheBltSpans || infoRec->FillColorExpandSpans ||
|
|
|
|
infoRec->FillCacheExpandSpans) {
|
|
|
|
if(!infoRec->FillSpansOpaqueStippled) {
|
|
|
|
|
|
|
|
infoRec->FillSpansOpaqueStippled = XAAFillSpans;
|
|
|
|
infoRec->FillSpansOpaqueStippledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
|
|
|
|
infoRec->FillCacheBltRects || infoRec->FillImageWriteRects) {
|
|
|
|
if(!infoRec->PolyFillRectTiled) {
|
|
|
|
|
|
|
|
infoRec->PolyFillRectTiled = XAAPolyFillRect;
|
|
|
|
infoRec->PolyFillRectTiledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
|
|
|
|
infoRec->FillCacheBltSpans) {
|
|
|
|
if(!infoRec->FillSpansTiled) {
|
|
|
|
|
|
|
|
infoRec->FillSpansTiled = XAAFillSpans;
|
|
|
|
infoRec->FillSpansTiledFlags = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->TEGlyphRenderer &&
|
|
|
|
!(infoRec->TEGlyphRendererFlags & NO_TRANSPARENCY)) {
|
|
|
|
|
|
|
|
if(!infoRec->PolyText8TE) {
|
|
|
|
infoRec->PolyText8TE = XAAPolyText8TEColorExpansion;
|
|
|
|
infoRec->PolyText8TEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PolyText16TE) {
|
|
|
|
infoRec->PolyText16TE = XAAPolyText16TEColorExpansion;
|
|
|
|
infoRec->PolyText16TEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PolyGlyphBltTE) {
|
|
|
|
infoRec->PolyGlyphBltTE = XAAPolyGlyphBltTEColorExpansion;
|
|
|
|
infoRec->PolyGlyphBltTEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->TEGlyphRenderer &&
|
|
|
|
!(infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
|
|
|
|
|
|
|
|
if(!infoRec->ImageText8TE) {
|
|
|
|
infoRec->ImageText8TE = XAAImageText8TEColorExpansion;
|
|
|
|
infoRec->ImageText8TEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ImageText16TE) {
|
|
|
|
infoRec->ImageText16TE = XAAImageText16TEColorExpansion;
|
|
|
|
infoRec->ImageText16TEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ImageGlyphBltTE) {
|
|
|
|
infoRec->ImageGlyphBltTE = XAAImageGlyphBltTEColorExpansion;
|
|
|
|
infoRec->ImageGlyphBltTEFlags = infoRec->TEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->NonTEGlyphRenderer) {
|
|
|
|
if(!infoRec->PolyText8NonTE) {
|
|
|
|
infoRec->PolyText8NonTE = XAAPolyText8NonTEColorExpansion;
|
|
|
|
infoRec->PolyText8NonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PolyText16NonTE) {
|
|
|
|
infoRec->PolyText16NonTE = XAAPolyText16NonTEColorExpansion;
|
|
|
|
infoRec->PolyText16NonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
if(!infoRec->PolyGlyphBltNonTE) {
|
|
|
|
infoRec->PolyGlyphBltNonTE = XAAPolyGlyphBltNonTEColorExpansion;
|
|
|
|
infoRec->PolyGlyphBltNonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->NonTEGlyphRenderer && HaveSolidFillRect) {
|
|
|
|
if(!infoRec->ImageText8NonTE) {
|
|
|
|
infoRec->ImageText8NonTE = XAAImageText8NonTEColorExpansion;
|
|
|
|
infoRec->ImageText8NonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ImageText16NonTE) {
|
|
|
|
infoRec->ImageText16NonTE = XAAImageText16NonTEColorExpansion;
|
|
|
|
infoRec->ImageText16NonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ImageGlyphBltNonTE) {
|
|
|
|
infoRec->ImageGlyphBltNonTE = XAAImageGlyphBltNonTEColorExpansion;
|
|
|
|
infoRec->ImageGlyphBltNonTEFlags = infoRec->NonTEGlyphRendererFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PolyRectangleThinSolid && HaveSolidHorVertLine) {
|
|
|
|
infoRec->PolyRectangleThinSolid = XAAPolyRectangleThinSolid;
|
|
|
|
infoRec->PolyRectangleThinSolidFlags = infoRec->SolidLineFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->FillPolygonSolid && HaveSolidFillRect) {
|
|
|
|
infoRec->FillPolygonSolid = XAAFillPolygonSolid;
|
|
|
|
infoRec->FillPolygonSolidFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->FillPolygonStippled && (HaveMono8x8PatternFillRect ||
|
|
|
|
HaveScreenToScreenColorExpandFill || HaveScreenToScreenCopy)) {
|
|
|
|
infoRec->FillPolygonStippled = XAAFillPolygonStippled;
|
|
|
|
infoRec->FillPolygonStippledFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->FillPolygonOpaqueStippled && (HaveMono8x8PatternFillRect ||
|
|
|
|
HaveScreenToScreenColorExpandFill || HaveScreenToScreenCopy)) {
|
|
|
|
infoRec->FillPolygonOpaqueStippled = XAAFillPolygonStippled;
|
|
|
|
infoRec->FillPolygonOpaqueStippledFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->FillPolygonTiled && (HaveMono8x8PatternFillRect ||
|
|
|
|
HaveScreenToScreenColorExpandFill || HaveScreenToScreenCopy)) {
|
|
|
|
infoRec->FillPolygonTiled = XAAFillPolygonTiled;
|
|
|
|
infoRec->FillPolygonTiledFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if(!infoRec->PolyFillArcSolid && HaveSolidFillRect) {
|
|
|
|
infoRec->PolyFillArcSolid = XAAPolyFillArcSolid;
|
|
|
|
infoRec->PolyFillArcSolidFlags = infoRec->SolidFillFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PolylinesWideSolid && HaveSolidFillRect) {
|
|
|
|
infoRec->PolylinesWideSolid = XAAPolylinesWideSolid;
|
|
|
|
infoRec->PolylinesWideSolidFlags =
|
|
|
|
infoRec->SolidFillFlags | GXCOPY_ONLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->PutImage && (infoRec->WritePixmap ||
|
|
|
|
(infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)))) {
|
|
|
|
infoRec->PutImage = XAAPutImage;
|
|
|
|
|
|
|
|
/* See comment for CopyArea above. But here we make fewer
|
|
|
|
assumptions. The driver can provide the PutImageFlags if
|
|
|
|
it wants too */
|
|
|
|
}
|
|
|
|
|
|
|
|
if(HaveSolidHorVertLine &&
|
|
|
|
(HaveSolidBresenhamLine || (HaveSolidTwoPointLine &&
|
|
|
|
(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_LINE)))){
|
|
|
|
if(!infoRec->PolylinesThinSolid) {
|
|
|
|
infoRec->PolylinesThinSolid = XAAPolyLines;
|
|
|
|
infoRec->PolylinesThinSolidFlags = infoRec->SolidLineFlags;
|
|
|
|
}
|
|
|
|
if(!infoRec->PolySegmentThinSolid) {
|
|
|
|
infoRec->PolySegmentThinSolid = XAAPolySegment;
|
|
|
|
infoRec->PolySegmentThinSolidFlags = infoRec->SolidLineFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(HaveDashedBresenhamLine || (HaveDashedTwoPointLine &&
|
|
|
|
(infoRec->ClippingFlags & HARDWARE_CLIP_DASHED_LINE))){
|
|
|
|
if(!infoRec->PolylinesThinDashed) {
|
|
|
|
infoRec->PolylinesThinDashed = XAAPolyLinesDashed;
|
|
|
|
infoRec->PolylinesThinDashedFlags = infoRec->DashedLineFlags;
|
|
|
|
}
|
|
|
|
if(!infoRec->PolySegmentThinDashed) {
|
|
|
|
infoRec->PolySegmentThinDashed = XAAPolySegmentDashed;
|
|
|
|
infoRec->PolySegmentThinDashedFlags = infoRec->DashedLineFlags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->PolylinesThinDashed || infoRec->PolySegmentThinDashed) {
|
|
|
|
if(!infoRec->ComputeDash)
|
|
|
|
infoRec->ComputeDash = XAAComputeDash;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef RENDER
|
|
|
|
{
|
|
|
|
Bool haveTexture = infoRec->CPUToScreenTextureFormats &&
|
2004-08-04 12:05:37 +02:00
|
|
|
infoRec->CPUToScreenTextureDstFormats &&
|
|
|
|
infoRec->SetupForCPUToScreenTexture2 &&
|
2003-11-14 17:48:57 +01:00
|
|
|
infoRec->SubsequentCPUToScreenTexture;
|
|
|
|
Bool haveAlphaTexture = infoRec->CPUToScreenAlphaTextureFormats &&
|
2004-08-04 12:05:37 +02:00
|
|
|
infoRec->CPUToScreenAlphaTextureDstFormats &&
|
|
|
|
infoRec->SetupForCPUToScreenAlphaTexture2 &&
|
2003-11-14 17:48:57 +01:00
|
|
|
infoRec->SubsequentCPUToScreenAlphaTexture;
|
|
|
|
|
|
|
|
if(!infoRec->Composite && (haveTexture || haveAlphaTexture))
|
|
|
|
infoRec->Composite = XAADoComposite;
|
|
|
|
|
|
|
|
if(!infoRec->Glyphs && infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & NO_TRANSPARENCY))
|
|
|
|
{
|
|
|
|
infoRec->Glyphs = XAADoGlyphs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/************ Validation Functions **************/
|
|
|
|
|
|
|
|
if(!infoRec->ValidateCopyArea && infoRec->CopyArea) {
|
|
|
|
infoRec->CopyAreaMask = GCWhenForced;
|
|
|
|
if((infoRec->CopyAreaFlags & GXCOPY_ONLY) ||
|
|
|
|
(infoRec->CopyAreaFlags & ROP_NEEDS_SOURCE))
|
|
|
|
infoRec->CopyAreaMask |= GCFunction;
|
|
|
|
if(infoRec->CopyAreaFlags & NO_PLANEMASK)
|
|
|
|
infoRec->CopyAreaMask |= GCPlaneMask;
|
|
|
|
infoRec->ValidateCopyArea = XAAValidateCopyArea;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ValidateCopyPlane && infoRec->CopyPlane) {
|
|
|
|
infoRec->CopyPlaneMask = GCWhenForced;
|
|
|
|
if((infoRec->CopyPlaneFlags & GXCOPY_ONLY) ||
|
|
|
|
(infoRec->CopyPlaneFlags & ROP_NEEDS_SOURCE))
|
|
|
|
infoRec->CopyPlaneMask |= GCFunction;
|
|
|
|
if(infoRec->CopyPlaneFlags & NO_PLANEMASK)
|
|
|
|
infoRec->CopyPlaneMask |= GCPlaneMask;
|
|
|
|
if(infoRec->CopyPlaneFlags & RGB_EQUAL)
|
|
|
|
infoRec->CopyPlaneMask |= GCForeground | GCBackground;
|
|
|
|
infoRec->ValidateCopyPlane = XAAValidateCopyPlane;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ValidatePutImage && infoRec->PutImage) {
|
|
|
|
infoRec->PutImageMask = GCWhenForced;
|
|
|
|
if((infoRec->PutImageFlags & GXCOPY_ONLY) ||
|
|
|
|
(infoRec->PutImageFlags & ROP_NEEDS_SOURCE))
|
|
|
|
infoRec->PutImageMask |= GCFunction;
|
|
|
|
if(infoRec->PutImageFlags & NO_PLANEMASK)
|
|
|
|
infoRec->PutImageMask |= GCPlaneMask;
|
|
|
|
if(infoRec->PutImageFlags & RGB_EQUAL)
|
|
|
|
infoRec->PutImageMask |= GCForeground | GCBackground;
|
|
|
|
infoRec->ValidatePutImage = XAAValidatePutImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if(!infoRec->ValidatePushPixels && infoRec->PushPixelsSolid) {
|
|
|
|
infoRec->PushPixelsMask = GCFillStyle;
|
|
|
|
if((infoRec->PushPixelsFlags & GXCOPY_ONLY) ||
|
|
|
|
(infoRec->PushPixelsFlags & ROP_NEEDS_SOURCE) ||
|
|
|
|
(infoRec->PushPixelsFlags & TRANSPARENCY_GXCOPY_ONLY))
|
|
|
|
infoRec->PushPixelsMask |= GCFunction;
|
|
|
|
if(infoRec->PushPixelsFlags & NO_PLANEMASK)
|
|
|
|
infoRec->PushPixelsMask |= GCPlaneMask;
|
|
|
|
if(infoRec->PushPixelsFlags & RGB_EQUAL)
|
|
|
|
infoRec->PushPixelsMask |= GCForeground;
|
|
|
|
infoRec->ValidatePushPixels = XAAValidatePushPixels;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* By default XAA assumes the FillSpans, PolyFillRects, FillPolygon
|
|
|
|
and PolyFillArcs have the same restrictions. If you supply GC
|
|
|
|
level replacements for any of these and alter this relationship
|
|
|
|
you may need to supply replacement validation routines */
|
|
|
|
|
|
|
|
if(!infoRec->ValidateFillSpans &&
|
|
|
|
(infoRec->FillSpansSolid || infoRec->FillSpansStippled ||
|
|
|
|
infoRec->FillSpansOpaqueStippled || infoRec->FillSpansTiled)) {
|
|
|
|
|
|
|
|
int compositeFlags = infoRec->FillSpansSolidFlags |
|
|
|
|
infoRec->FillSpansStippledFlags |
|
|
|
|
infoRec->FillSpansOpaqueStippledFlags |
|
|
|
|
infoRec->FillSpansTiledFlags;
|
|
|
|
|
|
|
|
infoRec->FillSpansMask = GCFillStyle | GCTile | GCStipple;
|
|
|
|
|
|
|
|
if((compositeFlags & GXCOPY_ONLY) ||
|
|
|
|
(compositeFlags & ROP_NEEDS_SOURCE))
|
|
|
|
infoRec->FillSpansMask |= GCFunction;
|
|
|
|
if(compositeFlags & NO_PLANEMASK)
|
|
|
|
infoRec->FillSpansMask |= GCPlaneMask;
|
|
|
|
if(compositeFlags & RGB_EQUAL)
|
|
|
|
infoRec->FillSpansMask |= GCForeground;
|
|
|
|
infoRec->ValidateFillSpans = XAAValidateFillSpans;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* By default XAA only provides Validations for the GlyphBlt
|
|
|
|
functions and not the text higher up. This is because the
|
|
|
|
Text8/16 and GlyphBlt are linked. If you break this linkage,
|
|
|
|
you may need to have the driver supply its own Validation
|
|
|
|
routines */
|
|
|
|
|
|
|
|
if(!infoRec->ValidatePolyGlyphBlt &&
|
|
|
|
(infoRec->PolyGlyphBltTE || infoRec->PolyGlyphBltNonTE)) {
|
|
|
|
int compositeFlags = infoRec->PolyGlyphBltTEFlags |
|
|
|
|
infoRec->PolyGlyphBltNonTEFlags;
|
|
|
|
|
|
|
|
infoRec->PolyGlyphBltMask = GCFillStyle | GCFont;
|
|
|
|
if((compositeFlags & GXCOPY_ONLY) ||
|
|
|
|
(compositeFlags & ROP_NEEDS_SOURCE) ||
|
|
|
|
(infoRec->PolyGlyphBltNonTEFlags & TRANSPARENCY_GXCOPY_ONLY))
|
|
|
|
infoRec->PolyGlyphBltMask |= GCFunction;
|
|
|
|
if(compositeFlags & NO_PLANEMASK)
|
|
|
|
infoRec->PolyGlyphBltMask |= GCPlaneMask;
|
|
|
|
if(compositeFlags & RGB_EQUAL)
|
|
|
|
infoRec->PolyGlyphBltMask |= GCForeground;
|
|
|
|
infoRec->ValidatePolyGlyphBlt = XAAValidatePolyGlyphBlt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!infoRec->ValidateImageGlyphBlt &&
|
|
|
|
(infoRec->ImageGlyphBltTE || infoRec->ImageGlyphBltNonTE)) {
|
|
|
|
int compositeFlags = infoRec->ImageGlyphBltTEFlags |
|
|
|
|
infoRec->ImageGlyphBltNonTEFlags;
|
|
|
|
|
|
|
|
if(infoRec->ImageGlyphBltNonTE)
|
|
|
|
compositeFlags |= infoRec->SolidFillFlags;
|
|
|
|
|
|
|
|
infoRec->ImageGlyphBltMask = GCFont;
|
|
|
|
if(compositeFlags & NO_PLANEMASK)
|
|
|
|
infoRec->ImageGlyphBltMask |= GCPlaneMask;
|
|
|
|
if(compositeFlags & RGB_EQUAL)
|
|
|
|
infoRec->ImageGlyphBltMask |= GCForeground | GCBackground;
|
|
|
|
infoRec->ValidateImageGlyphBlt = XAAValidateImageGlyphBlt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* By default XAA only provides a Validation function for the
|
|
|
|
Polylines and does segments and polylines at the same time */
|
|
|
|
|
|
|
|
if(!infoRec->ValidatePolylines && infoRec->ValidateFillSpans) {
|
|
|
|
int compositeFlags = infoRec->PolyRectangleThinSolidFlags |
|
|
|
|
infoRec->PolylinesWideSolidFlags |
|
|
|
|
infoRec->PolylinesThinSolidFlags |
|
|
|
|
infoRec->PolySegmentThinSolidFlags |
|
|
|
|
infoRec->PolySegmentThinDashedFlags |
|
|
|
|
infoRec->PolylinesThinDashedFlags;
|
|
|
|
|
|
|
|
infoRec->ValidatePolylines = XAAValidatePolylines;
|
|
|
|
infoRec->PolylinesMask =
|
|
|
|
infoRec->FillSpansMask | GCLineStyle | GCLineWidth;
|
|
|
|
|
|
|
|
if(infoRec->PolySegmentThinDashed || infoRec->PolylinesThinDashed)
|
|
|
|
infoRec->PolylinesMask |= GCDashList;
|
|
|
|
if(compositeFlags & NO_PLANEMASK)
|
|
|
|
infoRec->PolylinesMask |= GCPlaneMask;
|
|
|
|
if((compositeFlags & GXCOPY_ONLY) ||
|
|
|
|
(compositeFlags & ROP_NEEDS_SOURCE))
|
|
|
|
infoRec->PolylinesMask |= GCFunction;
|
|
|
|
if(compositeFlags & RGB_EQUAL)
|
|
|
|
infoRec->PolylinesMask |= GCForeground;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** Fill choosers ****/
|
|
|
|
|
|
|
|
if(!infoRec->StippledFillChooser)
|
|
|
|
infoRec->StippledFillChooser = XAAStippledFillChooser;
|
|
|
|
|
|
|
|
if(!infoRec->OpaqueStippledFillChooser)
|
|
|
|
infoRec->OpaqueStippledFillChooser = XAAOpaqueStippledFillChooser;
|
|
|
|
|
|
|
|
if(!infoRec->TiledFillChooser)
|
|
|
|
infoRec->TiledFillChooser = XAATiledFillChooser;
|
|
|
|
|
|
|
|
|
|
|
|
/**** Setup the pixmap cache ****/
|
|
|
|
|
|
|
|
if(infoRec->WriteBitmapToCache) {}
|
|
|
|
else if(infoRec->WriteBitmap &&
|
|
|
|
!(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))
|
|
|
|
infoRec->WriteBitmapToCache = XAAWriteBitmapToCache;
|
|
|
|
else if(infoRec->Flags & LINEAR_FRAMEBUFFER)
|
|
|
|
infoRec->WriteBitmapToCache = XAAWriteBitmapToCacheLinear;
|
|
|
|
else
|
|
|
|
infoRec->PixmapCacheFlags |= DO_NOT_BLIT_STIPPLES;
|
|
|
|
|
|
|
|
if(infoRec->WritePixmapToCache) {}
|
|
|
|
else if(infoRec->WritePixmap && !(infoRec->WritePixmapFlags & NO_GXCOPY))
|
|
|
|
infoRec->WritePixmapToCache = XAAWritePixmapToCache;
|
|
|
|
else if(infoRec->Flags & LINEAR_FRAMEBUFFER)
|
|
|
|
infoRec->WritePixmapToCache = XAAWritePixmapToCacheLinear;
|
|
|
|
else
|
|
|
|
infoRec->Flags &= ~PIXMAP_CACHE;
|
|
|
|
|
2008-03-22 17:31:08 +01:00
|
|
|
if (xf86ReturnOptValBool(options, XAAOPT_PIXMAP_CACHE, FALSE))
|
2003-11-14 17:48:57 +01:00
|
|
|
infoRec->Flags &= ~PIXMAP_CACHE;
|
|
|
|
|
|
|
|
if(infoRec->WriteMono8x8PatternToCache) {}
|
|
|
|
else if(infoRec->PixmapCacheFlags & CACHE_MONO_8x8) {
|
|
|
|
if(infoRec->WritePixmapToCache)
|
|
|
|
infoRec->WriteMono8x8PatternToCache = XAAWriteMono8x8PatternToCache;
|
|
|
|
else
|
|
|
|
infoRec->PixmapCacheFlags &= ~CACHE_MONO_8x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->WriteColor8x8PatternToCache) {}
|
|
|
|
else if(infoRec->PixmapCacheFlags & CACHE_COLOR_8x8) {
|
|
|
|
if(infoRec->WritePixmapToCache && infoRec->WriteBitmapToCache)
|
|
|
|
infoRec->WriteColor8x8PatternToCache = XAAWriteColor8x8PatternToCache;
|
|
|
|
else
|
|
|
|
infoRec->PixmapCacheFlags &= ~CACHE_COLOR_8x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(infoRec->CachePixelGranularity < 0) {
|
|
|
|
switch(pScrn->bitsPerPixel) {
|
|
|
|
case 24:
|
|
|
|
case 8: infoRec->CachePixelGranularity = 4; break;
|
|
|
|
case 16: infoRec->CachePixelGranularity = 2; break;
|
|
|
|
case 32: infoRec->CachePixelGranularity = 1; break;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(BITMAP_SCANLINE_PAD == 64)
|
|
|
|
infoRec->CachePixelGranularity *= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfree(options);
|
|
|
|
|
|
|
|
if(!infoRec->CacheTile && infoRec->WritePixmapToCache)
|
|
|
|
infoRec->CacheTile = XAACacheTile;
|
|
|
|
if(!infoRec->CacheMonoStipple && infoRec->WritePixmapToCache)
|
|
|
|
infoRec->CacheMonoStipple = XAACacheMonoStipple;
|
|
|
|
if(!infoRec->CacheStipple && infoRec->WriteBitmapToCache)
|
|
|
|
infoRec->CacheStipple = XAACacheStipple;
|
|
|
|
if(!infoRec->CacheMono8x8Pattern && infoRec->WriteMono8x8PatternToCache)
|
|
|
|
infoRec->CacheMono8x8Pattern = XAACacheMono8x8Pattern;
|
|
|
|
if(!infoRec->CacheColor8x8Pattern && infoRec->WriteColor8x8PatternToCache)
|
|
|
|
infoRec->CacheColor8x8Pattern = XAACacheColor8x8Pattern;
|
|
|
|
|
|
|
|
if((infoRec->Flags & PIXMAP_CACHE) && !infoRec->InitPixmapCache) {
|
|
|
|
infoRec->InitPixmapCache = XAAInitPixmapCache;
|
|
|
|
infoRec->ClosePixmapCache = XAAClosePixmapCache;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|