qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
95d684a05b
xenocara/xserver/hw/xfree86/xaa/xaaInitAccel.c

1501 lines
50 KiB
C
Raw Blame History

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <string.h>
#include "misc.h"
#include "xf86.h"
#include "xf86_OSproc.h"
#include <X11/X.h>
#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,
XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE
} 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 },
{XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE, "XaaOffscreenPixmaps",
OPTV_BOOLEAN, {0}, FALSE },
{ -1, NULL,
OPTV_NONE, {0}, FALSE }
};
static XF86ModuleVersionInfo xaaVersRec =
{
"xaa",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XORG_VERSION_CURRENT,
XAA_VERSION_MAJOR,
XAA_VERSION_MINOR,
XAA_VERSION_RELEASE,
ABI_CLASS_VIDEODRV, /* requires the video driver ABI */
ABI_VIDEODRV_VERSION,
MOD_CLASS_NONE,
{0,0,0,0}
};
_X_EXPORT XF86ModuleData xaaModuleData = { &xaaVersRec, NULL, NULL };
Bool
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 &&
!xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COPY, FALSE)) {
HaveScreenToScreenCopy = TRUE;
} else {
infoRec->ScreenToScreenCopyFlags = 0;
infoRec->SetupForScreenToScreenCopy = NULL;
infoRec->SubsequentScreenToScreenCopy = NULL;
}
/**** Solid Filled Rects ****/
if(infoRec->SetupForSolidFill && infoRec->SubsequentSolidFillRect &&
!xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_RECT, FALSE)) {
HaveSolidFillRect = TRUE;
if(infoRec->SubsequentSolidFillTrap &&
!xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_TRAP, FALSE))
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 &&
!xf86ReturnOptValBool(options,
XAAOPT_SOLID_TWO_POINT_LINE, FALSE))
HaveSolidTwoPointLine = TRUE;
if(infoRec->SubsequentSolidBresenhamLine &&
!xf86ReturnOptValBool(options, XAAOPT_SOLID_BRESENHAM_LINE, FALSE)) {
HaveSolidBresenhamLine = TRUE;
if(infoRec->SolidBresenhamLineErrorTermBits)
infoRec->SolidBresenhamLineErrorTermBits =
~((1 << infoRec->SolidBresenhamLineErrorTermBits) - 1);
}
if(infoRec->SubsequentSolidHorVertLine &&
!xf86ReturnOptValBool(options,
XAAOPT_SOLID_HORVERT_LINE, FALSE))
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 &&
!xf86ReturnOptValBool(options,
XAAOPT_MONO_8x8_PATTERN_FILL_RECT,
FALSE)) {
HaveMono8x8PatternFillRect = TRUE;
if(infoRec->SubsequentMono8x8PatternFillTrap &&
!xf86ReturnOptValBool(options,
XAAOPT_MONO_8x8_PATTERN_FILL_TRAP,
FALSE))
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 &&
!xf86ReturnOptValBool(options, XAAOPT_DASHED_TWO_POINT_LINE,
FALSE))
HaveDashedTwoPointLine = TRUE;
if(infoRec->SubsequentDashedBresenhamLine &&
!xf86ReturnOptValBool(options, XAAOPT_DASHED_BRESENHAM_LINE,
FALSE)) {
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 &&
!xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_RECT, FALSE)) {
HaveColor8x8PatternFillRect = TRUE;
if(infoRec->SubsequentColor8x8PatternFillTrap &&
!xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_TRAP,
FALSE))
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 &&
!xf86ReturnOptValBool(options, XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL,
FALSE)) {
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) &&
!xf86ReturnOptValBool(options,
XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
FALSE)) {
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 &&
!xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL,
FALSE)) {
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 &&
!xf86ReturnOptValBool(options, XAAOPT_IMAGE_WRITE_RECT, FALSE)) {
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) &&
!xf86ReturnOptValBool(options, XAAOPT_SCANLINE_IMAGE_WRITE_RECT,
FALSE)) {
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 &&
xf86ReturnOptValBool(options,
XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE,
FALSE))
{
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 &&
!xf86ReturnOptValBool(options, XAAOPT_WRITE_BITMAP, FALSE)) {
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 &&
!xf86ReturnOptValBool(options, XAAOPT_WRITE_PIXMAP, FALSE)) {
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 &&
infoRec->CPUToScreenTextureDstFormats &&
infoRec->SetupForCPUToScreenTexture2 &&
infoRec->SubsequentCPUToScreenTexture;
Bool haveAlphaTexture = infoRec->CPUToScreenAlphaTextureFormats &&
infoRec->CPUToScreenAlphaTextureDstFormats &&
infoRec->SetupForCPUToScreenAlphaTexture2 &&
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;
if (xf86ReturnOptValBool(options, XAAOPT_PIXMAP_CACHE, FALSE))
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;
}
Reference in New Issue View Git Blame Copy Permalink