path: root/drv/impedscrn.c

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include <stdlib.h>

#include "windowstr.h"
#include "windowstr.h"
#include "servermd.h"

#include "drv_imped.h"
#include "drvline.h"
#include "drv_pixmapstr.h"
#include "drv_scrnintstr.h"
#include "micmap.h"
#include "mi.h"
#include "privates.h"

DevPrivateKeyRec drvZeroLineScreenKeyRec;

DevPrivateKeyRec impedScreenPrivateKeyRec;
DevPrivateKeyRec impedPixmapPrivateKeyRec;
DevPrivateKeyRec impedGCPrivateKeyRec;
DevPrivateKeyRec impedPictPrivateKeyRec;

DevPrivateKey
impedGetScreenPrivKey(void) { return &impedScreenPrivateKeyRec; }

DevPrivateKey
impedGetPixmapPrivKey(void) { return &impedPixmapPrivateKeyRec; }

DevPrivateKey
impedGetGCPrivKey(void) { return &impedGCPrivateKeyRec; }

DevPrivateKey
impedGetPictPrivKey(void) { return &impedPictPrivateKeyRec; }

static DevPrivateKeyRec impedWinPrivateKeyRec;
static DevPrivateKey
impedGetWinPrivateKey (void) { return &impedWinPrivateKeyRec; }

#define impedGetScreenPixmap(s)	((PixmapPtr) (s)->devPrivate)
#define impedGetWindowPixmap(pWin)	((PixmapPtr)\
				 dixLookupPrivate(&((WindowPtr)(pWin))->devPrivates, impedGetWinPrivateKey()))


static Bool
impedAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *pGCKey)
{
    if (!dixRegisterPrivateKey(&impedWinPrivateKeyRec, PRIVATE_WINDOW, 0))
	return FALSE;

    if (!dixRegisterPrivateKey(&impedScreenPrivateKeyRec, PRIVATE_SCREEN,
			       sizeof(impedScreenPrivRec)))
        return FALSE;

    if (!dixRegisterPrivateKey(&impedPixmapPrivateKeyRec, PRIVATE_PIXMAP,
			       sizeof(impedPixmapPrivRec)))
        return FALSE;

    if (!dixRegisterPrivateKey(&impedGCPrivateKeyRec, PRIVATE_GC,
			       sizeof(impedGCPrivRec)))
        return FALSE;

    if (!dixRegisterPrivateKey(&impedPictPrivateKeyRec, PRIVATE_PICTURE,
			       sizeof(impedPictPrivRec)))
        return FALSE;

    return TRUE;
}

Bool
impedCreateScreenResources(ScreenPtr pScreen)
{
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
    PixmapPtr pPixmap;
    impedPixmapPrivPtr imped_pixmap;
    Bool ret;
    int i;

    ret = miCreateScreenResources(pScreen);
    if (!ret)
	return ret;
    
    pPixmap = pScreen->GetScreenPixmap(pScreen);
    imped_pixmap = impedGetPixmap(pPixmap);

    imped_pixmap->shattered = TRUE;
    for (i = 0; i < imped_screen->num_gpu; i++) {
	(imped_screen->gpu[i]->SetScreenPixmap)(imped_screen->gpu[i], imped_pixmap->gpu[i]);
	imped_pixmap->gpu[i]->shattered_x = imped_screen->gpu[i]->x;
	imped_pixmap->gpu[i]->width = imped_screen->gpu[i]->width;
	imped_pixmap->gpu[i]->shattered_y = imped_screen->gpu[i]->y;
	imped_pixmap->gpu[i]->height = imped_screen->gpu[i]->height;
    }

    for (i = 0; i < imped_screen->num_gpu; i++) {
	(imped_screen->gpu[i]->CreateScreenResources)(imped_screen->gpu[i]);
    }
    return TRUE;
}

static Bool
impedCreateWindow(WindowPtr pWin)
{
    dixSetPrivate(&pWin->devPrivates, impedGetWinPrivateKey(),
		  impedGetScreenPixmap(pWin->drawable.pScreen));
    return TRUE;
}

static Bool
impedPositionWindow(WindowPtr pWin, int x, int y)
{
    return TRUE;
}

static Bool
impedDestroyWindow(WindowPtr pWin)
{
    return TRUE;
}

static Bool
impedMapWindow(WindowPtr pWindow)
{
    return TRUE;
}


static Bool
impedUnmapWindow(WindowPtr pWindow)
{
    return TRUE;
}

static void
impedCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
    /* get the pixmaps */
    ScreenPtr pScreen = pWin->drawable.pScreen;
    PixmapPtr pPixmap = pScreen->GetWindowPixmap(pWin);
    RegionRec   rgnDst;
    int dx, dy;

    dx = ptOldOrg.x - pWin->drawable.x;
    dy = ptOldOrg.y - pWin->drawable.y;
    RegionTranslate(prgnSrc, -dx, -dy);
    RegionNull(&rgnDst);
    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
#ifdef COMPOSITE
    if (pPixmap->screen_x || pPixmap->screen_y) {
        int xoff = 0, yoff = 0;

        xoff = -pPixmap->screen_x;
        yoff = -pPixmap->screen_y;
        RegionTranslate(&rgnDst, xoff, yoff);
    }
#endif

    miCopyRegion(&pWin->drawable, &pWin->drawable, NULL,
                 &rgnDst, dx, dy, impedCopyNtoN, 0, 0);

    RegionUninit(&rgnDst);    
}

static Bool
impedChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
{
    ScreenPtr pScreen = pWin->drawable.pScreen;
    int i;
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);

    for (i = 0; i < imped_screen->num_gpu; i++) {
	if (mask & CWBackPixmap)
	    if (pWin->backgroundState == BackgroundPixmap) {
		impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pWin->background.pixmap);
		
		(*imped_screen->gpu[i]->PixmapWindowFixup)(&imped_pixmap->gpu[i], pWin->drawable.bitsPerPixel);
	    }

	if (mask & CWBorderPixmap)
	    if (pWin->borderIsPixel == FALSE) {
		impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pWin->border.pixmap);
		(*imped_screen->gpu[i]->PixmapWindowFixup)(&imped_pixmap->gpu[i], pWin->drawable.bitsPerPixel);
	    }
    }
    return TRUE;
}

static Bool
impedRealizeFont(ScreenPtr pScreen, FontPtr pFont)
{
    return TRUE;
}

static Bool
impedUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)
{
    return TRUE;
}

static void
impedGetImage (DrawablePtr	    pDrawable,
	       int		    x,
	       int		    y,
	       int		    w,
	       int		    h,
	       unsigned int    format,
	       unsigned long   planeMask,
	       char	    *d)
{
    ScreenPtr pScreen = pDrawable->pScreen;
    int x_off, y_off;
    int i;
    PixmapPtr pPixmap = GetDrawablePixmap(pDrawable);
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);

    if (!impedDrawableEnabled(pDrawable))
	return;

    impedGetDrawableDeltas(pDrawable, pPixmap, &x_off, &y_off);
    x += x_off;
    y += y_off;

    for (i = 0; i < imped_screen->num_gpu; i++) {
	(imped_screen->gpu[i]->GetImage)(imped_pixmap->gpu[i], x, y, w, h, format, planeMask, d);
    }
}

static void
impedGetSpans(DrawablePtr	pDrawable, 
	      int		wMax, 
	      DDXPointPtr	ppt, 
	      int		*pwidth, 
	      int		nspans, 
	      char		*pchardstStart)
{
    ScreenPtr pScreen = pDrawable->pScreen;
    PixmapPtr pPixmap = GetDrawablePixmap(pDrawable);
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
    int i;

    /*
     * XFree86 DDX empties the root borderClip when the VT is
     * switched away; this checks for that case
     */
    if (!impedDrawableEnabled(pDrawable))
	return;
    
    for (i = 0; i < imped_screen->num_gpu; i++) {
	imped_screen->gpu[i]->GetSpans(imped_pixmap->gpu[i], wMax, ppt, pwidth, nspans, pchardstStart);
    }
}


static PixmapPtr
_impedGetWindowPixmap (WindowPtr pWindow)
{
    return impedGetWindowPixmap (pWindow);
}

static void
_impedSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
{
    dixSetPrivate(&pWindow->devPrivates, impedGetWinPrivateKey(), pPixmap);
}

static PixmapPtr
impedCreatePixmap (ScreenPtr pScreen, int width, int height, int depth,
		   unsigned usage_hint)
{
    PixmapPtr pPixmap;
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);

    pPixmap = AllocatePixmap(pScreen, 0);
    if (!pPixmap)
	return NULL;

    pPixmap->drawable.type = DRAWABLE_PIXMAP;
    pPixmap->drawable.class = 0;
    pPixmap->drawable.pScreen = pScreen;
    pPixmap->drawable.depth = depth;
    pPixmap->drawable.bitsPerPixel = BitsPerPixel (depth);
    pPixmap->drawable.id = 0;
    pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
    pPixmap->drawable.x = 0;
    pPixmap->drawable.y = 0;
    pPixmap->drawable.width = width;
    pPixmap->drawable.height = height;
    pPixmap->devKind = width;
    pPixmap->refcnt = 1;

#ifdef COMPOSITE
    pPixmap->screen_x = 0;
    pPixmap->screen_y = 0;
#endif

    pPixmap->usage_hint = usage_hint;

    
    {
	impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
	int i;
	imped_pixmap->shattered = FALSE;
	for (i = 0; i < imped_screen->num_gpu; i++) {
	    imped_pixmap->gpu[i] = imped_screen->gpu[i]->CreatePixmap(imped_screen->gpu[i], width, height, depth, usage_hint, pPixmap);
	}
    }
    return pPixmap;
}

static Bool
impedDestroyPixmap(PixmapPtr pPixmap)
{
    int i;
    impedPixmapPrivPtr imped_pixmap;
    impedScreenPrivPtr imped_screen;
    if(--pPixmap->refcnt)
	return TRUE;

    imped_pixmap = impedGetPixmap(pPixmap);
    imped_screen = impedGetScreen(pPixmap->drawable.pScreen);
    for (i = 0; i < imped_screen->num_gpu; i++)
	imped_screen->gpu[i]->DestroyPixmap(imped_pixmap->gpu[i]);
    FreePixmap(pPixmap);
    return TRUE;
}

static Bool
impedModifyPixmapHeader(PixmapPtr pPixmap, int w, int h, int d,
			int bpp, int devKind, pointer pPixData)
{
    int i;
    impedScreenPrivPtr imped_screen;
    impedPixmapPrivPtr imped_pixmap;

    if (!pPixmap)
	return FALSE;
    imped_pixmap = impedGetPixmap(pPixmap);
    imped_screen = impedGetScreen(pPixmap->drawable.pScreen);

    miModifyPixmapHeader(pPixmap, w, h, d, bpp, devKind, pPixData);
    for (i = 0; i < imped_screen->num_gpu; i++)
	imped_screen->gpu[i]->ModifyPixmapHeader(imped_pixmap->gpu[i], w, h, d,
						 bpp, devKind, pPixData);

    return TRUE;
}

static void
impedQueryBestSize (int class, 
		    unsigned short *width, unsigned short *height,
		    ScreenPtr pScreen)
{
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
    imped_screen->gpu[0]->QueryBestSize(class, width, height, imped_screen->gpu[0]);
}

static RegionPtr
impedBitmapToRegion(PixmapPtr pPix)
{
    impedScreenPrivPtr imped_screen = impedGetScreen(pPix->drawable.pScreen);
    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPix);
    return imped_screen->gpu[0]->PixmapToRegion(imped_pixmap->gpu[0]);
}

Bool
impedCloseScreen (int index,ScreenPtr pScreen)
{
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
    int i;

    for (i = 0; i < imped_screen->num_gpu; i++) {
	if (imped_screen->gpu[i]->CloseScreen)
	    return imped_screen->gpu[i]->CloseScreen(imped_screen->gpu[i]);
    }
    return TRUE;
}

Bool
impedSetupScreen(int index, ScreenPtr pScreen)
{

    if (!impedAllocatePrivates(pScreen, NULL))
	return FALSE;
    pScreen->defColormap = FakeClientID(0);

    pScreen->ChangeWindowAttributes = impedChangeWindowAttributes;
    pScreen->CreateWindow = impedCreateWindow;
    pScreen->CopyWindow = impedCopyWindow;
    pScreen->PositionWindow = impedPositionWindow;
    pScreen->RealizeWindow = impedMapWindow;
    pScreen->UnrealizeWindow = impedUnmapWindow;
    pScreen->DestroyWindow = impedDestroyWindow;
    pScreen->GetImage = impedGetImage;
    pScreen->GetSpans = impedGetSpans;
    pScreen->GetWindowPixmap = _impedGetWindowPixmap;
    pScreen->SetWindowPixmap = _impedSetWindowPixmap;

    pScreen->RealizeFont = impedRealizeFont;
    pScreen->UnrealizeFont = impedUnrealizeFont;

    pScreen->CreateColormap = miInitializeColormap;
    pScreen->DestroyColormap = (void (*)(ColormapPtr))NoopDDA;
    pScreen->InstallColormap = miInstallColormap;
    pScreen->UninstallColormap = miUninstallColormap;
    pScreen->ListInstalledColormaps = miListInstalledColormaps;
    pScreen->StoreColors = (void (*)(ColormapPtr, int, xColorItem *))NoopDDA;
    pScreen->ResolveColor = miResolveColor;

    pScreen->CreatePixmap = impedCreatePixmap;
    pScreen->DestroyPixmap = impedDestroyPixmap;

    pScreen->CreateGC = impedCreateGC;

    pScreen->QueryBestSize = impedQueryBestSize;

    pScreen->BitmapToRegion = impedBitmapToRegion;

    /* replace miCloseScreen */
    pScreen->CloseScreen = impedCloseScreen;

    drvSetZeroLineBias(pScreen, DEFAULTZEROLINEBIAS);

    return TRUE;
}

Bool impedFinishScreenInit(ScreenPtr pScreen,
			   pointer pbits,
			   int		xsize,
			   int		ysize,
			   int		dpix,
			   int		dpiy,
			   int		width,
			   int		bpp)
{
    VisualPtr	visuals;
    DepthPtr	depths;
    int		nvisuals;
    int		ndepths;
    int		rootdepth;
    VisualID	defaultVisual;
    int		imagebpp = bpp;

    rootdepth = 0;

    if (!miInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
		       &defaultVisual, 8, ((unsigned long)1<<(imagebpp - 1)), -1))
	return FALSE;
    if (!miScreenInit(pScreen, NULL,  xsize, ysize, dpix, dpiy, width,
		      rootdepth, ndepths, depths, defaultVisual,
		      nvisuals, visuals))
	return FALSE;

    pScreen->ModifyPixmapHeader = impedModifyPixmapHeader;
    pScreen->CreateScreenResources = impedCreateScreenResources;

}
void
impedScreenSetPixmapSize(ScreenPtr pScreen)
{
    /* might be wrong */
    pScreen->totalPixmapSize = BitmapBytePad((sizeof(PixmapRec) + dixPrivatesSize(PRIVATE_PIXMAP)) * 8);
}

DevPrivateKeyRec drvZeroLineScreenKeyRec;

void
drvSetZeroLineBias(ScreenPtr pScreen, unsigned int bias)
{
    if (!dixRegisterPrivateKey(&drvZeroLineScreenKeyRec, PRIVATE_SCREEN, 0))
	return;

    dixSetPrivate(&pScreen->devPrivates, drvZeroLineScreenKey, 
		  (unsigned long *)(unsigned long)bias);
}

void impedAttachDrvScreen(ScreenPtr pScreen, DrvScreenPtr pDrvScreen)
{
    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen); 
    int i;

    i = imped_screen->num_gpu;

    if (imped_screen->num_gpu + 1 > MAX_GPU) {
	ErrorF("Too man driver screens attached\n");
	return;
    }

    imped_screen->gpu[i] = pDrvScreen;
    pDrvScreen->pScreen = pScreen;
    imped_screen->num_gpu++;
}

struct list drvscreen_list;

DrvScreenPtr DrvScreenAllocate(void)
{
    DrvScreenPtr screen;
    screen = calloc(1, sizeof(DrvScreenRec));

    if (!screen)
	return NULL;

    if (!dixAllocatePrivates(&screen->devPrivates, PRIVATE_DRV_SCREEN)) {
	free(screen);
	return NULL;
    }

    list_add(&screen->imped_list, &drvscreen_list);
    return screen;
}

static Bool
fixupDrvScreens(FixupFunc fixup, unsigned bytes)
{
    int s;
    DrvScreenPtr drvscreen;

    list_for_each_entry(drvscreen, &drvscreen_list, imped_list) {
	if (!fixup(&drvscreen->devPrivates, dixPrivateGetKeyOffset(PRIVATE_DRV_SCREEN), bytes))
	    return FALSE;
    }
    return TRUE;
}

void impedInit(void)
{
    list_init(&drvscreen_list);
    dixRegisterPrivateFixup(PRIVATE_DRV_SCREEN, fixupDrvScreens);
}