int
XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
{
XvMCScreenPtr pScreenPriv;
if(XvMCGeneration != serverGeneration) {
if((XvMCScreenIndex = AllocateScreenPrivateIndex()) < 0)
return BadAlloc;
XvMCGeneration = serverGeneration;
}
if(!(pScreenPriv = (XvMCScreenPtr)xalloc(sizeof(XvMCScreenRec))))
return BadAlloc;
pScreen->devPrivates[XvMCScreenIndex].ptr = (pointer)pScreenPriv;
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = XvMCCloseScreen;
pScreenPriv->num_adaptors = num;
pScreenPriv->adaptors = pAdapt;
pScreenPriv->clientDriverName[0] = 0;
pScreenPriv->busID[0] = 0;
pScreenPriv->major = 0;
pScreenPriv->minor = 0;
pScreenPriv->patchLevel = 0;
return Success;
}
Bool
DRIExtensionInit(void)
{
static unsigned long DRIGeneration = 0;
if (DRIGeneration != serverGeneration) {
if ((DRIScreenPrivIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
DRIGeneration = serverGeneration;
}
/*
* Allocate a window private index with a zero sized private area for
* each window, then should a window become a DRI window, we'll hang
* a DRIWindowPrivateRec off of this private index. Do same for pixmaps.
*/
if ((DRIWindowPrivIndex = AllocateWindowPrivateIndex()) < 0)
return FALSE;
if ((DRIPixmapPrivIndex = AllocatePixmapPrivateIndex()) < 0)
return FALSE;
DRIDrawablePrivResType = CreateNewResourceType(DRIDrawablePrivDelete);
return TRUE;
}
static Bool
RootlessAllocatePrivates(ScreenPtr pScreen)
{
RootlessScreenRec *s;
static unsigned long rootlessGeneration = 0;
if (rootlessGeneration != serverGeneration) {
rootlessScreenPrivateIndex = AllocateScreenPrivateIndex();
if (rootlessScreenPrivateIndex == -1) return FALSE;
rootlessGCPrivateIndex = AllocateGCPrivateIndex();
if (rootlessGCPrivateIndex == -1) return FALSE;
rootlessWindowPrivateIndex = AllocateWindowPrivateIndex();
if (rootlessWindowPrivateIndex == -1) return FALSE;
rootlessGeneration = serverGeneration;
}
// no allocation needed for screen privates
if (!AllocateGCPrivate(pScreen, rootlessGCPrivateIndex,
sizeof(RootlessGCRec)))
return FALSE;
if (!AllocateWindowPrivate(pScreen, rootlessWindowPrivateIndex, 0))
return FALSE;
s = xalloc(sizeof(RootlessScreenRec));
if (! s) return FALSE;
SCREENREC(pScreen) = s;
return TRUE;
}
Bool
AnimCurInit (ScreenPtr pScreen)
{
AnimCurScreenPtr as;
if (AnimCurGeneration != serverGeneration)
{
AnimCurScreenPrivateIndex = AllocateScreenPrivateIndex ();
if (AnimCurScreenPrivateIndex < 0)
return FALSE;
AnimCurGeneration = serverGeneration;
animCurState.pCursor = 0;
animCurState.pScreen = 0;
animCurState.elt = 0;
animCurState.time = 0;
}
as = (AnimCurScreenPtr) xalloc (sizeof (AnimCurScreenRec));
if (!as)
return FALSE;
Wrap(as, pScreen, CloseScreen, AnimCurCloseScreen);
Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
Wrap(as, pScreen, CursorLimits, AnimCurCursorLimits);
Wrap(as, pScreen, DisplayCursor, AnimCurDisplayCursor);
Wrap(as, pScreen, SetCursorPosition, AnimCurSetCursorPosition);
Wrap(as, pScreen, RealizeCursor, AnimCurRealizeCursor);
Wrap(as, pScreen, UnrealizeCursor, AnimCurUnrealizeCursor);
Wrap(as, pScreen, RecolorCursor, AnimCurRecolorCursor);
SetAnimCurScreen(pScreen,as);
return TRUE;
}
static Bool
cfb8_32WidAllocatePrivates(ScreenPtr pScreen)
{
cfb8_32WidScreenPtr pScreenPriv;
if (cfb8_32WidGeneration != serverGeneration) {
if ((cfb8_32WidScreenPrivateIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
cfb8_32WidGeneration = serverGeneration;
}
if (!(pScreenPriv = xalloc(sizeof(cfb8_32WidScreenRec))))
return FALSE;
pScreen->devPrivates[cfb8_32WidScreenPrivateIndex].ptr = (pointer)pScreenPriv;
/* All cfb will have the same GC and Window private indicies */
if (!mfbAllocatePrivates(pScreen, &cfbWindowPrivateIndex, &cfbGCPrivateIndex))
return FALSE;
/* The cfb indicies are the mfb indicies. Reallocating them resizes them */
if (!AllocateWindowPrivate(pScreen, cfbWindowPrivateIndex, sizeof(cfbPrivWin)))
return FALSE;
if (!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
return FALSE;
return TRUE;
}
Bool
xf86RandR12Init (ScreenPtr pScreen)
{
rrScrPrivPtr rp;
XF86RandRInfoPtr randrp;
#ifdef PANORAMIX
/* XXX disable RandR when using Xinerama */
if (!noPanoramiXExtension)
return TRUE;
#endif
if (xf86RandR12Generation != serverGeneration)
xf86RandR12Generation = serverGeneration;
#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
xf86RandR12Key = &xf86RandR12KeyIndex;
#else
xf86RandR12Index = AllocateScreenPrivateIndex();
#endif
randrp = xalloc (sizeof (XF86RandRInfoRec));
if (!randrp)
return FALSE;
if (!RRScreenInit(pScreen))
{
xfree (randrp);
return FALSE;
}
rp = rrGetScrPriv(pScreen);
rp->rrGetInfo = xf86RandR12GetInfo;
rp->rrSetConfig = xf86RandR12SetConfig;
randrp->virtualX = -1;
randrp->virtualY = -1;
randrp->mmWidth = pScreen->mmWidth;
randrp->mmHeight = pScreen->mmHeight;
randrp->rotation = RR_Rotate_0; /* initial rotated mode */
randrp->supported_rotations = RR_Rotate_0;
randrp->maxX = randrp->maxY = 0;
#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
dixSetPrivate(&pScreen->devPrivates, xf86RandR12Key, randrp);
#else
pScreen->devPrivates[xf86RandR12Index].ptr = randrp;
#endif
#if RANDR_12_INTERFACE
if (!xf86RandR12Init12 (pScreen))
return FALSE;
#endif
return TRUE;
}
Bool LeoAccelInit (ScreenPtr pScreen, LeoPtr pLeo)
{
LeoCommand0 *lc0;
LeoDraw *ld0;
if (serverGeneration != LeoGeneration) {
LeoScreenPrivateIndex = AllocateScreenPrivateIndex ();
if (LeoScreenPrivateIndex == -1) return FALSE;
LeoGCPrivateIndex = AllocateGCPrivateIndex ();
LeoWindowPrivateIndex = AllocateWindowPrivateIndex ();
LeoGeneration = serverGeneration;
}
/* Allocate private structures holding pointer to both videoRAM and control registers.
We do not have to map these by ourselves, because the XServer did it for us; we
only copy the pointers to out structures. */
if (!AllocateGCPrivate(pScreen, LeoGCPrivateIndex, sizeof(LeoPrivGCRec))) return FALSE;
if (!AllocateWindowPrivate(pScreen, LeoWindowPrivateIndex, 0)) return FALSE;
pScreen->devPrivates[LeoScreenPrivateIndex].ptr = pLeo;
pLeo->lc0 = lc0 = (LeoCommand0 *) ((char *)pLeo->fb + LEO_LC0_VOFF);
pLeo->ld0 = ld0 = (LeoDraw *) ((char *)pLeo->fb + LEO_LD0_VOFF);
if (!pLeo->NoAccel) {
/* Replace various screen functions. */
pScreen->CreateGC = LeoCreateGC;
pScreen->CopyWindow = LeoCopyWindow;
}
/* We will now clear the screen: we'll draw a rectangle covering all the
* viewscreen, using a 'blackness' ROP.
*/
ld0->wid = 1;
ld0->widclip = 0;
ld0->wmask = 0xffff;
ld0->planemask = 0xffffff;
ld0->rop = LEO_ATTR_WE_ENABLE|LEO_ATTR_RGBE_ENABLE|LEO_ATTR_FORCE_WID;
ld0->fg = 0;
ld0->vclipmin = 0;
ld0->vclipmax = (pLeo->psdp->width - 1) | ((pLeo->psdp->height - 1) << 16);
pLeo->vclipmax = (pLeo->psdp->width - 1) | ((pLeo->psdp->height - 1) << 16);
pLeo->width = pLeo->psdp->width;
pLeo->height = pLeo->psdp->height;
while (lc0->csr & LEO_CSR_BLT_BUSY);
lc0->extent = (pLeo->psdp->width - 1) | ((pLeo->psdp->height - 1) << 11);
lc0->fill = 0;
while (lc0->csr & LEO_CSR_BLT_BUSY);
lc0->addrspace = LEO_ADDRSPC_OBGR;
ld0->rop = LEO_ATTR_RGBE_ENABLE|LEO_ROP_NEW;
/* Success */
return TRUE;
}
Bool
LayerStartInit (ScreenPtr pScreen)
{
LayerScreenPtr pScrPriv;
if (layerGeneration != serverGeneration)
{
layerScrPrivateIndex = AllocateScreenPrivateIndex ();
if (layerScrPrivateIndex == -1)
return FALSE;
layerGCPrivateIndex = AllocateGCPrivateIndex ();
if (layerGCPrivateIndex == -1)
return FALSE;
layerWinPrivateIndex = AllocateWindowPrivateIndex ();
if (layerWinPrivateIndex == -1)
return FALSE;
layerGeneration = serverGeneration;
}
if (!AllocateGCPrivate (pScreen, layerGCPrivateIndex, sizeof (LayerGCRec)))
return FALSE;
if (!AllocateWindowPrivate (pScreen, layerWinPrivateIndex, sizeof (LayerWinRec)))
return FALSE;
pScrPriv = (LayerScreenPtr) xalloc (sizeof (LayerScreenRec));
if (!pScrPriv)
return FALSE;
pScrPriv->nkinds = 0;
pScrPriv->kinds = 0;
pScrPriv->pLayers = 0;
pScreen->devPrivates[layerScrPrivateIndex].ptr = (pointer) pScrPriv;
/*
* Add fb kind -- always 0
*/
if (LayerNewKind (pScreen) < 0)
{
pScreen->devPrivates[layerScrPrivateIndex].ptr = 0;
xfree (pScrPriv);
return FALSE;
}
/*
* Add shadow kind -- always 1
*/
if (!shadowSetup (pScreen))
return FALSE;
if (LayerNewKind (pScreen) < 0)
{
pScreen->devPrivates[layerScrPrivateIndex].ptr = 0;
xfree (pScrPriv->kinds);
xfree (pScrPriv);
return FALSE;
}
return TRUE;
}
int
XvScreenInit(ScreenPtr pScreen)
{
XvScreenPtr pxvs;
if (XvScreenGeneration != serverGeneration)
{
if (!CreateResourceTypes())
{
ErrorF("XvScreenInit: Unable to allocate resource types\n");
return BadAlloc;
}
XvScreenIndex = AllocateScreenPrivateIndex ();
if (XvScreenIndex < 0)
{
ErrorF("XvScreenInit: Unable to allocate screen private index\n");
return BadAlloc;
}
#ifdef PANORAMIX
XineramaRegisterConnectionBlockCallback(XineramifyXv);
#endif
XvScreenGeneration = serverGeneration;
}
if (pScreen->devPrivates[XvScreenIndex].ptr)
{
ErrorF("XvScreenInit: screen devPrivates ptr non-NULL before init\n");
}
/* ALLOCATE SCREEN PRIVATE RECORD */
pxvs = (XvScreenPtr) xalloc (sizeof (XvScreenRec));
if (!pxvs)
{
ErrorF("XvScreenInit: Unable to allocate screen private structure\n");
return BadAlloc;
}
pScreen->devPrivates[XvScreenIndex].ptr = (pointer)pxvs;
pxvs->DestroyPixmap = pScreen->DestroyPixmap;
pxvs->DestroyWindow = pScreen->DestroyWindow;
pxvs->CloseScreen = pScreen->CloseScreen;
pScreen->DestroyPixmap = XvDestroyPixmap;
pScreen->DestroyWindow = XvDestroyWindow;
pScreen->CloseScreen = XvCloseScreen;
return Success;
}
void
XvExtensionInit()
{
ExtensionEntry *extEntry;
/* LOOK TO SEE IF ANY SCREENS WERE INITIALIZED; IF NOT THEN
INIT GLOBAL VARIABLES SO THE EXTENSION CAN FUNCTION */
if (XvScreenGeneration != serverGeneration)
{
if (!CreateResourceTypes())
{
ErrorF("XvExtensionInit: Unable to allocate resource types\n");
return;
}
XvScreenIndex = AllocateScreenPrivateIndex ();
if (XvScreenIndex < 0)
{
ErrorF("XvExtensionInit: Unable to allocate screen private index\n");
return;
}
#ifdef PANORAMIX
XineramaRegisterConnectionBlockCallback(XineramifyXv);
#endif
XvScreenGeneration = serverGeneration;
}
if (XvExtensionGeneration != serverGeneration)
{
XvExtensionGeneration = serverGeneration;
extEntry = AddExtension(XvName, XvNumEvents, XvNumErrors,
ProcXvDispatch, SProcXvDispatch,
XvResetProc, StandardMinorOpcode);
if (!extEntry)
{
FatalError("XvExtensionInit: AddExtensions failed\n");
}
XvReqCode = extEntry->base;
XvEventBase = extEntry->eventBase;
XvErrorBase = extEntry->errorBase;
EventSwapVector[XvEventBase+XvVideoNotify] =
(EventSwapPtr)WriteSwappedVideoNotifyEvent;
EventSwapVector[XvEventBase+XvPortNotify] =
(EventSwapPtr)WriteSwappedPortNotifyEvent;
(void)MakeAtom(XvName, strlen(XvName), xTrue);
}
}
/* Screen initialization/teardown */
void
miInitializeCompositeWrapper(ScreenPtr pScreen)
{
cwScreenPtr pScreenPriv;
if (cwDisabled[pScreen->myNum])
return;
if (cwGeneration != serverGeneration)
{
cwScreenIndex = AllocateScreenPrivateIndex();
if (cwScreenIndex < 0)
return;
cwGCIndex = AllocateGCPrivateIndex();
cwWindowIndex = AllocateWindowPrivateIndex();
#ifdef RENDER
cwPictureIndex = AllocatePicturePrivateIndex();
#endif
cwGeneration = serverGeneration;
}
if (!AllocateGCPrivate(pScreen, cwGCIndex, sizeof(cwGCRec)))
return;
if (!AllocateWindowPrivate(pScreen, cwWindowIndex, 0))
return;
#ifdef RENDER
if (!AllocatePicturePrivate(pScreen, cwPictureIndex, 0))
return;
#endif
pScreenPriv = (cwScreenPtr)xalloc(sizeof(cwScreenRec));
if (!pScreenPriv)
return;
pScreen->devPrivates[cwScreenIndex].ptr = (pointer)pScreenPriv;
SCREEN_EPILOGUE(pScreen, CloseScreen, cwCloseScreen);
SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage);
SCREEN_EPILOGUE(pScreen, GetSpans, cwGetSpans);
SCREEN_EPILOGUE(pScreen, CreateGC, cwCreateGC);
SCREEN_EPILOGUE(pScreen, PaintWindowBackground, cwPaintWindowBackground);
SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder);
SCREEN_EPILOGUE(pScreen, CopyWindow, cwCopyWindow);
SCREEN_EPILOGUE(pScreen, SetWindowPixmap, cwSetWindowPixmap);
SCREEN_EPILOGUE(pScreen, GetWindowPixmap, cwGetWindowPixmap);
#ifdef RENDER
if (GetPictureScreen (pScreen))
cwInitializeRender(pScreen);
#endif
}
Bool
shadowSetup(ScreenPtr pScreen)
{
shadowBufPtr pBuf;
if (!DamageSetup(pScreen))
return FALSE;
if (shadowGeneration != serverGeneration) {
shadowScrPrivateIndex = AllocateScreenPrivateIndex();
if (shadowScrPrivateIndex == -1)
return FALSE;
shadowGeneration = serverGeneration;
}
pBuf = (shadowBufPtr) xalloc(sizeof(shadowBufRec));
if (!pBuf)
return FALSE;
#ifdef BACKWARDS_COMPATIBILITY
pBuf->pDamage = DamageCreate((DamageReportFunc)shadowReportFunc,
(DamageDestroyFunc)NULL,
DamageReportRawRegion,
TRUE, pScreen, pScreen);
#else
pBuf->pDamage = DamageCreate((DamageReportFunc)NULL,
(DamageDestroyFunc)NULL,
DamageReportNone,
TRUE, pScreen, pScreen);
#endif
if (!pBuf->pDamage) {
xfree(pBuf);
return FALSE;
}
wrap(pBuf, pScreen, CloseScreen);
wrap(pBuf, pScreen, GetImage);
pBuf->update = NULL;
pBuf->window = NULL;
pBuf->pPixmap = 0;
pBuf->closure = 0;
pBuf->randr = 0;
pBuf->ready_to_update = NULL;
#ifdef BACKWARDS_COMPATIBILITY
REGION_NULL(pScreen, &pBuf->damage); /* bc */
#endif
pScreen->devPrivates[shadowScrPrivateIndex].ptr = (pointer) pBuf;
return TRUE;
}
Bool xf86RegisterOffscreenManager(
ScreenPtr pScreen,
FBManagerFuncsPtr funcs
){
if(xf86ManagerGeneration != serverGeneration) {
if((xf86FBMangerIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
xf86ManagerGeneration = serverGeneration;
}
pScreen->devPrivates[xf86FBMangerIndex].ptr = (pointer)funcs;
return TRUE;
}
Bool
xf86RandRInit (ScreenPtr pScreen)
{
rrScrPrivPtr rp;
XF86RandRInfoPtr randrp;
ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
#ifdef PANORAMIX
/* XXX disable RandR when using Xinerama */
if (!noPanoramiXExtension)
return TRUE;
#endif
if (xf86RandRGeneration != serverGeneration)
{
xf86RandRIndex = AllocateScreenPrivateIndex();
xf86RandRGeneration = serverGeneration;
}
randrp = xalloc (sizeof (XF86RandRInfoRec));
if (!randrp)
return FALSE;
if (!RRScreenInit (pScreen))
{
xfree (randrp);
return FALSE;
}
rp = rrGetScrPriv(pScreen);
rp->rrGetInfo = xf86RandRGetInfo;
rp->rrSetConfig = xf86RandRSetConfig;
randrp->virtualX = scrp->virtualX;
randrp->virtualY = scrp->virtualY;
randrp->mmWidth = pScreen->mmWidth;
randrp->mmHeight = pScreen->mmHeight;
randrp->CreateScreenResources = pScreen->CreateScreenResources;
pScreen->CreateScreenResources = xf86RandRCreateScreenResources;
randrp->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = xf86RandRCloseScreen;
randrp->rotation = RR_Rotate_0;
pScreen->devPrivates[xf86RandRIndex].ptr = randrp;
return TRUE;
}
Bool
KdAllocatePrivates (ScreenPtr pScreen)
{
KdPrivScreenPtr pScreenPriv;
if (kdGeneration != serverGeneration)
{
kdScreenPrivateIndex = AllocateScreenPrivateIndex();
kdGeneration = serverGeneration;
}
pScreenPriv = (KdPrivScreenPtr) xalloc(sizeof (*pScreenPriv));
if (!pScreenPriv)
return FALSE;
memset (pScreenPriv, '\0', sizeof (KdPrivScreenRec));
KdSetScreenPriv (pScreen, pScreenPriv);
return TRUE;
}
Bool
xf86InitFBManagerRegion(
ScreenPtr pScreen,
RegionPtr FullRegion
){
FBManagerPtr offman;
if(REGION_NIL(FullRegion))
return FALSE;
if(xf86FBGeneration != serverGeneration) {
if((xf86FBScreenIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
xf86FBGeneration = serverGeneration;
}
if(!xf86RegisterOffscreenManager(pScreen, &xf86FBManFuncs))
return FALSE;
offman = xalloc(sizeof(FBManager));
if(!offman) return FALSE;
pScreen->devPrivates[xf86FBScreenIndex].ptr = (pointer)offman;
offman->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = xf86FBCloseScreen;
offman->InitialBoxes = REGION_CREATE(pScreen, NULL, 1);
offman->FreeBoxes = REGION_CREATE(pScreen, NULL, 1);
REGION_COPY(pScreen, offman->InitialBoxes, FullRegion);
REGION_COPY(pScreen, offman->FreeBoxes, FullRegion);
offman->pScreen = pScreen;
offman->UsedAreas = NULL;
offman->LinearAreas = NULL;
offman->NumUsedAreas = 0;
offman->NumCallbacks = 0;
offman->FreeBoxesUpdateCallback = NULL;
offman->devPrivates = NULL;
return TRUE;
}
Bool
xf86SbusHandleColormaps(ScreenPtr pScreen, sbusDevicePtr psdp)
{
sbusCmapPtr cmap;
struct fbcmap fbcmap;
unsigned char data[2];
if(sbusPaletteGeneration != serverGeneration) {
if((sbusPaletteIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
sbusPaletteGeneration = serverGeneration;
}
cmap = xnfcalloc(1, sizeof(sbusCmapRec));
pScreen->devPrivates[sbusPaletteIndex].ptr = cmap;
cmap->psdp = psdp;
fbcmap.index = 0;
fbcmap.count = 16;
fbcmap.red = cmap->origRed;
fbcmap.green = cmap->origGreen;
fbcmap.blue = cmap->origBlue;
if (ioctl (psdp->fd, FBIOGETCMAP, &fbcmap) >= 0)
cmap->origCmapValid = TRUE;
fbcmap.index = 0;
fbcmap.count = 2;
fbcmap.red = data;
fbcmap.green = data;
fbcmap.blue = data;
if (pScreen->whitePixel == 0) {
data[0] = 255;
data[1] = 0;
} else {
data[0] = 0;
data[1] = 255;
}
ioctl (psdp->fd, FBIOPUTCMAP, &fbcmap);
cmap->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = xf86SbusCmapCloseScreen;
return xf86HandleColormaps(pScreen, 256, 8,
xf86SbusCmapLoadPalette, NULL, 0);
}
Bool
afbAllocatePrivates(ScreenPtr pScreen, int *pWinIndex, int *pGCIndex)
{
if (afbGeneration != serverGeneration) {
#ifdef PIXMAP_PER_WINDOW
frameWindowPrivateIndex = AllocateWindowPrivateIndex();
#endif
afbWindowPrivateIndex = AllocateWindowPrivateIndex();
afbGCPrivateIndex = AllocateGCPrivateIndex();
afbGeneration = serverGeneration;
}
if (pWinIndex)
*pWinIndex = afbWindowPrivateIndex;
if (pGCIndex)
*pGCIndex = afbGCPrivateIndex;
afbScreenPrivateIndex = AllocateScreenPrivateIndex();
pScreen->GetWindowPixmap = afbGetWindowPixmap;
pScreen->SetWindowPixmap = afbSetWindowPixmap;
return(AllocateWindowPrivate(pScreen, afbWindowPrivateIndex, sizeof(afbPrivWin)) &&
AllocateGCPrivate(pScreen, afbGCPrivateIndex, sizeof(afbPrivGC)));
}
static Bool
xeglAllocatePrivates (ScreenPtr pScreen)
{
xeglScreenPtr pScreenPriv;
if (xeglScreenGeneration != serverGeneration)
{
xeglScreenPrivateIndex = AllocateScreenPrivateIndex ();
if (xeglScreenPrivateIndex < 0)
return FALSE;
xeglScreenGeneration = serverGeneration;
}
pScreenPriv = xalloc (sizeof (xeglScreenRec));
if (!pScreenPriv)
return FALSE;
XEGL_SET_SCREEN_PRIV (pScreen, pScreenPriv);
return TRUE;
}
_X_EXPORT Bool
VidModeExtensionInit(ScreenPtr pScreen)
{
#ifdef XF86VIDMODE
VidModePtr pVidMode;
DEBUG_P("VidModeExtensionInit");
if (!xf86GetVidModeEnabled()) {
DEBUG_P("!xf86GetVidModeEnabled()");
return FALSE;
}
if (serverGeneration != VidModeGeneration) {
if ((VidModeIndex = AllocateScreenPrivateIndex()) < 0) {
DEBUG_P("AllocateScreenPrivateIndex() failed");
return FALSE;
}
VidModeGeneration = serverGeneration;
}
if (!(pScreen->devPrivates[VidModeIndex].ptr = xcalloc(sizeof(VidModeRec), 1))) {
DEBUG_P("xcalloc failed");
return FALSE;
}
pVidMode = VMPTR(pScreen);
pVidMode->Flags = 0;
pVidMode->Next = NULL;
pVidMode->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = VidModeClose;
VidModeCount++;
return TRUE;
#else
DEBUG_P("no vidmode extension");
return FALSE;
#endif
}
Bool
XAAInitDualFramebufferOverlay(
ScreenPtr pScreen,
DepthChangeFuncPtr callback
){
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
XAAOverlayPtr pOverPriv;
if (XAAOverlayGeneration != serverGeneration) {
if((XAAOverlayIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
XAAOverlayGeneration = serverGeneration;
}
if(!(pOverPriv = xalloc(sizeof(XAAOverlayRec))))
return FALSE;
pScreen->devPrivates[XAAOverlayIndex].ptr = (pointer)pOverPriv;
pOverPriv->pScrn = pScrn;
pOverPriv->callback = callback;
pOverPriv->currentDepth = -1;
/* Overwrite key screen functions. The XAA core will clean up */
pScreen->CopyWindow = XAAOverCopyWindow;
pScreen->PaintWindowBackground = XAAOverPaintWindow;
pScreen->PaintWindowBorder = XAAOverPaintWindow;
pScreen->WindowExposures = XAAOverWindowExposures;
pScreen->BackingStoreFuncs.SaveAreas = XAAOverSaveAreas;
pScreen->BackingStoreFuncs.RestoreAreas = XAAOverRestoreAreas;
pOverPriv->StippledFillChooser = infoRec->StippledFillChooser;
pOverPriv->OpaqueStippledFillChooser = infoRec->OpaqueStippledFillChooser;
pOverPriv->TiledFillChooser = infoRec->TiledFillChooser;
infoRec->StippledFillChooser = XAAOverStippledFillChooser;
infoRec->OpaqueStippledFillChooser = XAAOverOpaqueStippledFillChooser;
infoRec->TiledFillChooser = XAAOverTiledFillChooser;
/* wrap all XAA GC rendering */
pOverPriv->CopyArea = infoRec->CopyArea;
pOverPriv->CopyPlane = infoRec->CopyPlane;
pOverPriv->PushPixelsSolid = infoRec->PushPixelsSolid;
pOverPriv->PolyFillRectSolid = infoRec->PolyFillRectSolid;
pOverPriv->PolyFillRectStippled = infoRec->PolyFillRectStippled;
pOverPriv->PolyFillRectOpaqueStippled = infoRec->PolyFillRectOpaqueStippled;
pOverPriv->PolyFillRectTiled = infoRec->PolyFillRectTiled;
pOverPriv->FillSpansSolid = infoRec->FillSpansSolid;
pOverPriv->FillSpansStippled = infoRec->FillSpansStippled;
pOverPriv->FillSpansOpaqueStippled = infoRec->FillSpansOpaqueStippled;
pOverPriv->FillSpansTiled = infoRec->FillSpansTiled;
pOverPriv->PolyText8TE = infoRec->PolyText8TE;
pOverPriv->PolyText16TE = infoRec->PolyText16TE;
pOverPriv->ImageText8TE = infoRec->ImageText8TE;
pOverPriv->ImageText16TE = infoRec->ImageText16TE;
pOverPriv->ImageGlyphBltTE = infoRec->ImageGlyphBltTE;
pOverPriv->PolyGlyphBltTE = infoRec->PolyGlyphBltTE;
pOverPriv->PolyText8NonTE = infoRec->PolyText8NonTE;
pOverPriv->PolyText16NonTE = infoRec->PolyText16NonTE;
pOverPriv->ImageText8NonTE = infoRec->ImageText8NonTE;
pOverPriv->ImageText16NonTE = infoRec->ImageText16NonTE;
pOverPriv->ImageGlyphBltNonTE = infoRec->ImageGlyphBltNonTE;
pOverPriv->PolyGlyphBltNonTE = infoRec->PolyGlyphBltNonTE;
pOverPriv->PolyRectangleThinSolid = infoRec->PolyRectangleThinSolid;
pOverPriv->PolylinesWideSolid = infoRec->PolylinesWideSolid;
pOverPriv->PolylinesThinSolid = infoRec->PolylinesThinSolid;
pOverPriv->PolySegmentThinSolid = infoRec->PolySegmentThinSolid;
pOverPriv->PolylinesThinDashed = infoRec->PolylinesThinDashed;
pOverPriv->PolySegmentThinDashed = infoRec->PolySegmentThinDashed;
pOverPriv->FillPolygonSolid = infoRec->FillPolygonSolid;
pOverPriv->FillPolygonStippled = infoRec->FillPolygonStippled;
pOverPriv->FillPolygonOpaqueStippled = infoRec->FillPolygonOpaqueStippled;
pOverPriv->FillPolygonTiled = infoRec->FillPolygonTiled;
pOverPriv->PolyFillArcSolid = infoRec->PolyFillArcSolid;
pOverPriv->PutImage = infoRec->PutImage;
if(infoRec->CopyArea)
infoRec->CopyArea = XAAOverCopyArea;
if(infoRec->CopyPlane)
infoRec->CopyPlane = XAAOverCopyPlane;
if(infoRec->PushPixelsSolid)
infoRec->PushPixelsSolid = XAAOverPushPixelsSolid;
if(infoRec->PolyFillRectSolid)
infoRec->PolyFillRectSolid = XAAOverPolyFillRectSolid;
if(infoRec->PolyFillRectStippled)
infoRec->PolyFillRectStippled = XAAOverPolyFillRectStippled;
if(infoRec->PolyFillRectOpaqueStippled)
infoRec->PolyFillRectOpaqueStippled = XAAOverPolyFillRectOpaqueStippled;
if(infoRec->PolyFillRectTiled)
infoRec->PolyFillRectTiled = XAAOverPolyFillRectTiled;
if(infoRec->FillSpansSolid)
infoRec->FillSpansSolid = XAAOverFillSpansSolid;
if(infoRec->FillSpansStippled)
infoRec->FillSpansStippled = XAAOverFillSpansStippled;
if(infoRec->FillSpansOpaqueStippled)
infoRec->FillSpansOpaqueStippled = XAAOverFillSpansOpaqueStippled;
if(infoRec->FillSpansTiled)
infoRec->FillSpansTiled = XAAOverFillSpansTiled;
if(infoRec->PolyText8TE)
infoRec->PolyText8TE = XAAOverPolyText8TE;
if(infoRec->PolyText16TE)
infoRec->PolyText16TE = XAAOverPolyText16TE;
if(infoRec->ImageText8TE)
infoRec->ImageText8TE = XAAOverImageText8TE;
if(infoRec->ImageText16TE)
infoRec->ImageText16TE = XAAOverImageText16TE;
if(infoRec->ImageGlyphBltTE)
infoRec->ImageGlyphBltTE = XAAOverImageGlyphBltTE;
if(infoRec->PolyGlyphBltTE)
infoRec->PolyGlyphBltTE = XAAOverPolyGlyphBltTE;
if(infoRec->PolyText8NonTE)
infoRec->PolyText8NonTE = XAAOverPolyText8NonTE;
if(infoRec->PolyText16NonTE)
infoRec->PolyText16NonTE = XAAOverPolyText16NonTE;
if(infoRec->ImageText8NonTE)
infoRec->ImageText8NonTE = XAAOverImageText8NonTE;
if(infoRec->ImageText16NonTE)
infoRec->ImageText16NonTE = XAAOverImageText16NonTE;
if(infoRec->ImageGlyphBltNonTE)
infoRec->ImageGlyphBltNonTE = XAAOverImageGlyphBltNonTE;
if(infoRec->PolyGlyphBltNonTE)
infoRec->PolyGlyphBltNonTE = XAAOverPolyGlyphBltNonTE;
if(infoRec->PolyRectangleThinSolid)
infoRec->PolyRectangleThinSolid = XAAOverPolyRectangleThinSolid;
if(infoRec->PolylinesWideSolid)
infoRec->PolylinesWideSolid = XAAOverPolylinesWideSolid;
if(infoRec->PolylinesThinSolid)
infoRec->PolylinesThinSolid = XAAOverPolylinesThinSolid;
if(infoRec->PolySegmentThinSolid)
infoRec->PolySegmentThinSolid = XAAOverPolySegmentThinSolid;
if(infoRec->PolylinesThinDashed)
infoRec->PolylinesThinDashed = XAAOverPolylinesThinDashed;
if(infoRec->PolySegmentThinDashed)
infoRec->PolySegmentThinDashed = XAAOverPolySegmentThinDashed;
if(infoRec->FillPolygonSolid)
infoRec->FillPolygonSolid = XAAOverFillPolygonSolid;
if(infoRec->FillPolygonStippled)
infoRec->FillPolygonStippled = XAAOverFillPolygonStippled;
if(infoRec->FillPolygonOpaqueStippled)
infoRec->FillPolygonOpaqueStippled = XAAOverFillPolygonOpaqueStippled;
if(infoRec->FillPolygonTiled)
infoRec->FillPolygonTiled = XAAOverFillPolygonTiled;
if(infoRec->PolyFillArcSolid)
infoRec->PolyFillArcSolid = XAAOverPolyFillArcSolid;
if(infoRec->PutImage)
infoRec->PutImage = XAAOverPutImage;
return TRUE;
}
Bool
kaaDrawInit (ScreenPtr pScreen,
KaaScreenInfoPtr pScreenInfo)
{
KaaScreenPrivPtr pKaaScr;
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
if (kaaGeneration != serverGeneration)
{
kaaScreenPrivateIndex = AllocateScreenPrivateIndex();
kaaPixmapPrivateIndex = AllocatePixmapPrivateIndex();
kaaGeneration = serverGeneration;
}
pKaaScr = xalloc (sizeof (KaaScreenPrivRec));
if (!pKaaScr)
return FALSE;
pKaaScr->info = pScreenInfo;
pScreen->devPrivates[kaaScreenPrivateIndex].ptr = (pointer) pKaaScr;
/*
* Hook up asynchronous drawing
*/
KdScreenInitAsync (pScreen);
/*
* Replace various fb screen functions
*/
pScreen->CreateGC = kaaCreateGC;
pScreen->CopyWindow = kaaCopyWindow;
pScreen->PaintWindowBackground = kaaPaintWindow;
pScreen->PaintWindowBorder = kaaPaintWindow;
#ifdef RENDER
if (ps) {
ps->Composite = kaaComposite;
ps->RasterizeTrapezoid = kaaRasterizeTrapezoid;
}
#endif
/*
* Hookup offscreen pixmaps
*/
if ((pKaaScr->info->flags & KAA_OFFSCREEN_PIXMAPS) &&
screen->off_screen_base < screen->memory_size)
{
if (!AllocatePixmapPrivate(pScreen, kaaPixmapPrivateIndex,
sizeof (KaaPixmapPrivRec)))
return FALSE;
pScreen->CreatePixmap = kaaCreatePixmap;
pScreen->DestroyPixmap = kaaDestroyPixmap;
}
else
{
if (!AllocatePixmapPrivate(pScreen, kaaPixmapPrivateIndex, 0))
return FALSE;
}
return TRUE;
}
Bool xf86XvMCScreenInit(
ScreenPtr pScreen,
int num_adaptors,
XF86MCAdaptorPtr *adaptors
)
{
XvMCAdaptorPtr pAdapt;
xf86XvMCScreenPtr pScreenPriv;
XvScreenPtr pxvs =
(XvScreenPtr)(pScreen->devPrivates[XF86XvScreenIndex].ptr);
int i, j;
if(!XvMCScreenInitProc) return FALSE;
if(XF86XvMCGeneration != serverGeneration) {
if((XF86XvMCScreenIndex = AllocateScreenPrivateIndex()) < 0)
return FALSE;
XF86XvMCGeneration = serverGeneration;
}
if(!(pAdapt = xalloc(sizeof(XvMCAdaptorRec) * num_adaptors)))
return FALSE;
if(!(pScreenPriv = xalloc(sizeof(xf86XvMCScreenRec)))) {
xfree(pAdapt);
return FALSE;
}
pScreen->devPrivates[XF86XvMCScreenIndex].ptr = (pointer)pScreenPriv;
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = xf86XvMCCloseScreen;
pScreenPriv->num_adaptors = num_adaptors;
pScreenPriv->adaptors = adaptors;
pScreenPriv->dixinfo = pAdapt;
for(i = 0; i < num_adaptors; i++) {
pAdapt[i].xv_adaptor = NULL;
for(j = 0; j < pxvs->nAdaptors; j++) {
if(!strcmp((*adaptors)->name, pxvs->pAdaptors[j].name)) {
pAdapt[i].xv_adaptor = &(pxvs->pAdaptors[j]);
break;
}
}
if(!pAdapt[i].xv_adaptor) {
/* no adaptor by that name */
xfree(pAdapt);
return FALSE;
}
pAdapt[i].num_surfaces = (*adaptors)->num_surfaces;
pAdapt[i].surfaces = (XvMCSurfaceInfoPtr*)((*adaptors)->surfaces);
pAdapt[i].num_subpictures = (*adaptors)->num_subpictures;
pAdapt[i].subpictures = (XvImagePtr*)((*adaptors)->subpictures);
pAdapt[i].CreateContext = xf86XvMCCreateContext;
pAdapt[i].DestroyContext = xf86XvMCDestroyContext;
pAdapt[i].CreateSurface = xf86XvMCCreateSurface;
pAdapt[i].DestroySurface = xf86XvMCDestroySurface;
pAdapt[i].CreateSubpicture = xf86XvMCCreateSubpicture;
pAdapt[i].DestroySubpicture = xf86XvMCDestroySubpicture;
adaptors++;
}
if(Success != (*XvMCScreenInitProc)(pScreen, num_adaptors, pAdapt))
return FALSE;
return TRUE;
}
Bool
XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
XAAScreenPtr pScreenPriv;
int i;
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
/* Return successfully if no acceleration wanted */
if (!infoRec)
return TRUE;
if (XAAGeneration != serverGeneration) {
if ( ((XAAScreenIndex = AllocateScreenPrivateIndex()) < 0) ||
((XAAGCIndex = AllocateGCPrivateIndex()) < 0) ||
((XAAPixmapIndex = AllocatePixmapPrivateIndex()) < 0))
return FALSE;
XAAGeneration = serverGeneration;
}
if (!AllocateGCPrivate(pScreen, XAAGCIndex, sizeof(XAAGCRec)))
return FALSE;
if (!AllocatePixmapPrivate(pScreen, XAAPixmapIndex, sizeof(XAAPixmapRec)))
return FALSE;
if (!(pScreenPriv = xalloc(sizeof(XAAScreenRec))))
return FALSE;
pScreen->devPrivates[XAAScreenIndex].ptr = (pointer)pScreenPriv;
if(!xf86FBManagerRunning(pScreen))
infoRec->Flags &= ~(PIXMAP_CACHE | OFFSCREEN_PIXMAPS);
if(!(infoRec->Flags & LINEAR_FRAMEBUFFER))
infoRec->Flags &= ~OFFSCREEN_PIXMAPS;
if(!infoRec->FullPlanemask) { /* for backwards compatibility */
infoRec->FullPlanemask = (1 << pScrn->depth) - 1;
infoRec->FullPlanemasks[pScrn->depth - 1] = infoRec->FullPlanemask;
}
for(i = 0; i < 32; i++) {
if(!infoRec->FullPlanemasks[i]) /* keep any set by caller */
infoRec->FullPlanemasks[i] = (1 << (i+1)) - 1;
}
if(!XAAInitAccel(pScreen, infoRec)) return FALSE;
pScreenPriv->AccelInfoRec = infoRec;
infoRec->ScratchGC.pScreen = pScreen;
if(!infoRec->GetImage)
infoRec->GetImage = XAAGetImage;
if(!infoRec->GetSpans)
infoRec->GetSpans = XAAGetSpans;
if(!infoRec->PaintWindowBackground)
infoRec->PaintWindowBackground = XAAPaintWindow;
if(!infoRec->PaintWindowBorder)
infoRec->PaintWindowBorder = XAAPaintWindow;
if(!infoRec->CopyWindow)
infoRec->CopyWindow = XAACopyWindow;
if(!infoRec->SaveAreas)
infoRec->SaveAreas = XAASaveAreas;
if(!infoRec->RestoreAreas)
infoRec->RestoreAreas = XAARestoreAreas;
pScreenPriv->CreateGC = pScreen->CreateGC;
pScreen->CreateGC = XAACreateGC;
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = XAACloseScreen;
pScreenPriv->GetImage = pScreen->GetImage;
pScreen->GetImage = infoRec->GetImage;
pScreenPriv->GetSpans = pScreen->GetSpans;
pScreen->GetSpans = infoRec->GetSpans;
pScreenPriv->PaintWindowBackground = pScreen->PaintWindowBackground;
pScreen->PaintWindowBackground = infoRec->PaintWindowBackground;
pScreenPriv->PaintWindowBorder = pScreen->PaintWindowBorder;
pScreen->PaintWindowBorder = infoRec->PaintWindowBorder;
pScreenPriv->CopyWindow = pScreen->CopyWindow;
pScreen->CopyWindow = infoRec->CopyWindow;
pScreenPriv->CreatePixmap = pScreen->CreatePixmap;
pScreen->CreatePixmap = XAACreatePixmap;
pScreenPriv->DestroyPixmap = pScreen->DestroyPixmap;
pScreen->DestroyPixmap = XAADestroyPixmap;
pScreenPriv->BackingStoreFuncs.RestoreAreas =
pScreen->BackingStoreFuncs.RestoreAreas;
pScreen->BackingStoreFuncs.RestoreAreas = infoRec->RestoreAreas;
pScreenPriv->BackingStoreFuncs.SaveAreas =
pScreen->BackingStoreFuncs.SaveAreas;
pScreen->BackingStoreFuncs.SaveAreas = infoRec->SaveAreas;
pScreenPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
pScreen->ChangeWindowAttributes = XAAChangeWindowAttributes;
pScreenPriv->EnterVT = pScrn->EnterVT;
pScrn->EnterVT = XAAEnterVT;
pScreenPriv->LeaveVT = pScrn->LeaveVT;
pScrn->LeaveVT = XAALeaveVT;
pScreenPriv->SetDGAMode = pScrn->SetDGAMode;
pScrn->SetDGAMode = XAASetDGAMode;
pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
pScrn->EnableDisableFBAccess = XAAEnableDisableFBAccess;
pScreenPriv->WindowExposures = pScreen->WindowExposures;
#ifdef RENDER
if (ps)
{
pScreenPriv->Composite = ps->Composite;
ps->Composite = XAAComposite;
pScreenPriv->Glyphs = ps->Glyphs;
ps->Glyphs = XAAGlyphs;
}
#endif
if(pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
XAASetupOverlay8_32Planar(pScreen);
infoRec->PreAllocMem = xalloc(MAX_PREALLOC_MEM);
if(infoRec->PreAllocMem)
infoRec->PreAllocSize = MAX_PREALLOC_MEM;
if(infoRec->Flags & PIXMAP_CACHE)
xf86RegisterFreeBoxCallback(pScreen, infoRec->InitPixmapCache,
(pointer)infoRec);
if(infoRec->Flags & MICROSOFT_ZERO_LINE_BIAS)
miSetZeroLineBias(pScreen, OCTANT1 | OCTANT2 | OCTANT3 | OCTANT4);
#ifdef COMPOSITE
/* Initialize the composite wrapper. This needs to happen after the
* wrapping above (so it comes before us), but before all other extensions,
* so it doesn't confuse them. (particularly damage).
*/
miInitializeCompositeWrapper(pScreen);
#endif
return TRUE;
}
void
MultibufferExtensionInit()
{
ExtensionEntry *extEntry;
int i, j;
ScreenPtr pScreen;
MultibufferScreenPtr pMultibufferScreen;
/*
* allocate private pointers in windows and screens. Allocating
* window privates may seem like an unnecessary expense, but every
* PositionWindow call must check to see if the window is
* multi-buffered; a resource lookup is too expensive.
*/
MultibufferScreenIndex = AllocateScreenPrivateIndex ();
if (MultibufferScreenIndex < 0)
return;
MultibufferWindowIndex = AllocateWindowPrivateIndex ();
for (i = 0; i < screenInfo.numScreens; i++)
{
pScreen = screenInfo.screens[i];
if (!AllocateWindowPrivate (pScreen, MultibufferWindowIndex, 0) ||
!(pMultibufferScreen = (MultibufferScreenPtr) xalloc (sizeof (MultibufferScreenRec))))
{
for (j = 0; j < i; j++)
xfree (screenInfo.screens[j]->devPrivates[MultibufferScreenIndex].ptr);
return;
}
pScreen->devPrivates[MultibufferScreenIndex].ptr = (pointer) pMultibufferScreen;
/*
* wrap PositionWindow to resize the pixmap when the window
* changes size
*/
pMultibufferScreen->PositionWindow = pScreen->PositionWindow;
pScreen->PositionWindow = MultibufferPositionWindow;
}
/*
* create the resource types
*/
MultibufferDrawableResType =
CreateNewResourceType(MultibufferDrawableDelete)|RC_CACHED|RC_DRAWABLE;
MultibufferResType = CreateNewResourceType(MultibufferDelete);
MultibuffersResType = CreateNewResourceType(MultibuffersDelete);
OtherClientResType = CreateNewResourceType(OtherClientDelete);
if (MultibufferDrawableResType && MultibufferResType &&
MultibuffersResType && OtherClientResType &&
(extEntry = AddExtension(MULTIBUFFER_PROTOCOL_NAME,
MultibufferNumberEvents,
MultibufferNumberErrors,
ProcMultibufferDispatch, SProcMultibufferDispatch,
MultibufferResetProc, StandardMinorOpcode)))
{
#if 0
MultibufferReqCode = (unsigned char)extEntry->base;
#endif
MultibufferEventBase = extEntry->eventBase;
MultibufferErrorBase = extEntry->errorBase;
EventSwapVector[MultibufferEventBase + MultibufferClobberNotify] = (EventSwapPtr) SClobberNotifyEvent;
EventSwapVector[MultibufferEventBase + MultibufferUpdateNotify] = (EventSwapPtr) SUpdateNotifyEvent;
}
}
/**
* @param pScreen screen being initialized
* @param pScreenInfo EXA driver record
*
* exaDriverInit sets up EXA given a driver record filled in by the driver.
* pScreenInfo should have been allocated by exaDriverAlloc(). See the
* comments in _ExaDriver for what must be filled in and what is optional.
*
* @return TRUE if EXA was successfully initialized.
*/
Bool
exaDriverInit (ScreenPtr pScreen,
ExaDriverPtr pScreenInfo)
{
ExaScreenPrivPtr pExaScr;
#ifdef RENDER
PictureScreenPtr ps;
#endif
if (!pScreenInfo)
return FALSE;
if (!pScreenInfo->memoryBase) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memoryBase must be "
"non-zero\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->memorySize) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memorySize must be "
"non-zero\n", pScreen->myNum);
return FALSE;
}
if (pScreenInfo->offScreenBase > pScreenInfo->memorySize) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::offScreenBase must be <= "
"ExaDriverRec::memorySize\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->PrepareSolid) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareSolid must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->PrepareCopy) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareCopy must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->WaitMarker) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::WaitMarker must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
if (pScreenInfo->exa_major != EXA_VERSION_MAJOR ||
pScreenInfo->exa_minor > EXA_VERSION_MINOR)
{
LogMessage(X_ERROR, "EXA(%d): driver's EXA version requirements "
"(%d.%d) are incompatible with EXA version (%d.%d)\n",
pScreen->myNum,
pScreenInfo->exa_major, pScreenInfo->exa_minor,
EXA_VERSION_MAJOR, EXA_VERSION_MINOR);
return FALSE;
}
#ifdef RENDER
ps = GetPictureScreenIfSet(pScreen);
#endif
if (exaGeneration != serverGeneration)
{
exaScreenPrivateIndex = AllocateScreenPrivateIndex();
exaPixmapPrivateIndex = AllocatePixmapPrivateIndex();
exaGeneration = serverGeneration;
}
pExaScr = xcalloc (sizeof (ExaScreenPrivRec), 1);
if (!pExaScr) {
LogMessage(X_WARNING, "EXA(%d): Failed to allocate screen private\n",
pScreen->myNum);
return FALSE;
}
pExaScr->info = pScreenInfo;
pScreen->devPrivates[exaScreenPrivateIndex].ptr = (pointer) pExaScr;
pExaScr->migration = ExaMigrationAlways;
exaDDXDriverInit(pScreen);
/*
* Replace various fb screen functions
*/
pExaScr->SavedCloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = exaCloseScreen;
pExaScr->SavedCreateGC = pScreen->CreateGC;
pScreen->CreateGC = exaCreateGC;
pExaScr->SavedGetImage = pScreen->GetImage;
pScreen->GetImage = exaGetImage;
pExaScr->SavedGetSpans = pScreen->GetSpans;
pScreen->GetSpans = exaGetSpans;
pExaScr->SavedCopyWindow = pScreen->CopyWindow;
pScreen->CopyWindow = exaCopyWindow;
pExaScr->SavedPaintWindowBackground = pScreen->PaintWindowBackground;
pScreen->PaintWindowBackground = exaPaintWindow;
pExaScr->SavedPaintWindowBorder = pScreen->PaintWindowBorder;
pScreen->PaintWindowBorder = exaPaintWindow;
pScreen->BackingStoreFuncs.SaveAreas = ExaCheckSaveAreas;
pScreen->BackingStoreFuncs.RestoreAreas = ExaCheckRestoreAreas;
#ifdef RENDER
if (ps) {
pExaScr->SavedComposite = ps->Composite;
ps->Composite = exaComposite;
pExaScr->SavedRasterizeTrapezoid = ps->RasterizeTrapezoid;
ps->RasterizeTrapezoid = exaRasterizeTrapezoid;
pExaScr->SavedAddTriangles = ps->AddTriangles;
ps->AddTriangles = exaAddTriangles;
pExaScr->SavedGlyphs = ps->Glyphs;
ps->Glyphs = exaGlyphs;
pExaScr->SavedTrapezoids = ps->Trapezoids;
ps->Trapezoids = exaTrapezoids;
}
#endif
#ifdef MITSHM
/* Re-register with the MI funcs, which don't allow shared pixmaps.
* Shared pixmaps are almost always a performance loss for us, but this
* still allows for SHM PutImage.
*/
ShmRegisterFuncs(pScreen, NULL);
#endif
/*
* Hookup offscreen pixmaps
*/
if ((pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS) &&
pExaScr->info->offScreenBase < pExaScr->info->memorySize)
{
if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex,
sizeof (ExaPixmapPrivRec))) {
LogMessage(X_WARNING,
"EXA(%d): Failed to allocate pixmap private\n",
pScreen->myNum);
return FALSE;
}
pExaScr->SavedCreatePixmap = pScreen->CreatePixmap;
pScreen->CreatePixmap = exaCreatePixmap;
pExaScr->SavedDestroyPixmap = pScreen->DestroyPixmap;
pScreen->DestroyPixmap = exaDestroyPixmap;
LogMessage(X_INFO, "EXA(%d): Offscreen pixmap area of %d bytes\n",
pScreen->myNum,
pExaScr->info->memorySize - pExaScr->info->offScreenBase);
}
else
{
LogMessage(X_INFO, "EXA(%d): No offscreen pixmaps\n", pScreen->myNum);
if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, 0))
return FALSE;
}
DBG_PIXMAP(("============== %ld < %ld\n", pExaScr->info->offScreenBase,
pExaScr->info->memorySize));
if (pExaScr->info->offScreenBase < pExaScr->info->memorySize) {
if (!exaOffscreenInit (pScreen)) {
LogMessage(X_WARNING, "EXA(%d): Offscreen pixmap setup failed\n",
pScreen->myNum);
return FALSE;
}
}
LogMessage(X_INFO, "EXA(%d): Driver registered support for the following"
" operations:\n", pScreen->myNum);
assert(pScreenInfo->PrepareSolid != NULL);
LogMessage(X_INFO, " Solid\n");
assert(pScreenInfo->PrepareCopy != NULL);
LogMessage(X_INFO, " Copy\n");
if (pScreenInfo->PrepareComposite != NULL) {
LogMessage(X_INFO, " Composite (RENDER acceleration)\n");
}
if (pScreenInfo->UploadToScreen != NULL) {
LogMessage(X_INFO, " UploadToScreen\n");
}
if (pScreenInfo->DownloadFromScreen != NULL) {
LogMessage(X_INFO, " DownloadFromScreen\n");
}
return TRUE;
}
Bool
ShadowFBInit2 (
ScreenPtr pScreen,
RefreshAreaFuncPtr preRefreshArea,
RefreshAreaFuncPtr postRefreshArea
){
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
ShadowScreenPtr pPriv;
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif /* RENDER */
if(!preRefreshArea && !postRefreshArea) return FALSE;
if (ShadowGeneration != serverGeneration) {
if(((ShadowScreenIndex = AllocateScreenPrivateIndex ()) < 0) ||
((ShadowGCIndex = AllocateGCPrivateIndex()) < 0))
return FALSE;
ShadowGeneration = serverGeneration;
}
if(!AllocateGCPrivate(pScreen, ShadowGCIndex, sizeof(ShadowGCRec)))
return FALSE;
if(!(pPriv = (ShadowScreenPtr)xalloc(sizeof(ShadowScreenRec))))
return FALSE;
pScreen->devPrivates[ShadowScreenIndex].ptr = (pointer)pPriv;
pPriv->pScrn = pScrn;
pPriv->preRefresh = preRefreshArea;
pPriv->postRefresh = postRefreshArea;
pPriv->vtSema = TRUE;
pPriv->CloseScreen = pScreen->CloseScreen;
pPriv->PaintWindowBackground = pScreen->PaintWindowBackground;
pPriv->PaintWindowBorder = pScreen->PaintWindowBorder;
pPriv->CopyWindow = pScreen->CopyWindow;
pPriv->CreateGC = pScreen->CreateGC;
pPriv->RestoreAreas = pScreen->BackingStoreFuncs.RestoreAreas;
pPriv->ModifyPixmapHeader = pScreen->ModifyPixmapHeader;
pPriv->EnterVT = pScrn->EnterVT;
pPriv->LeaveVT = pScrn->LeaveVT;
pScreen->CloseScreen = ShadowCloseScreen;
pScreen->PaintWindowBackground = ShadowPaintWindow;
pScreen->PaintWindowBorder = ShadowPaintWindow;
pScreen->CopyWindow = ShadowCopyWindow;
pScreen->CreateGC = ShadowCreateGC;
pScreen->BackingStoreFuncs.RestoreAreas = ShadowRestoreAreas;
pScreen->ModifyPixmapHeader = ShadowModifyPixmapHeader;
pScrn->EnterVT = ShadowEnterVT;
pScrn->LeaveVT = ShadowLeaveVT;
#ifdef RENDER
if(ps) {
pPriv->Composite = ps->Composite;
ps->Composite = ShadowComposite;
}
#endif /* RENDER */
return TRUE;
}
