libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

9 files changed, 3944 insertions, 4104 deletions

diff --git a/xorg-server/hw/kdrive/src/kcmap.c b/xorg-server/hw/kdrive/src/kcmap.c
index 6e0fc1417..c93c2f4d3 100644
--- a/xorg-server/hw/kdrive/src/kcmap.c
+++ b/xorg-server/hw/kdrive/src/kcmap.c
@@ -30,25 +30,25 @@
  */
 
 void
-KdSetColormap (ScreenPtr pScreen)
+KdSetColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    ColormapPtr	pCmap = pScreenPriv->pInstalledmap;
-    Pixel	pixels[KD_MAX_PSEUDO_SIZE];
-    xrgb	colors[KD_MAX_PSEUDO_SIZE];
-    xColorItem	defs[KD_MAX_PSEUDO_SIZE];
-    int		i;
+    ColormapPtr pCmap = pScreenPriv->pInstalledmap;
+    Pixel pixels[KD_MAX_PSEUDO_SIZE];
+    xrgb colors[KD_MAX_PSEUDO_SIZE];
+    xColorItem defs[KD_MAX_PSEUDO_SIZE];
+    int i;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
     if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
-	return;
+        return;
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
 
     if (!pCmap)
-	return;
+        return;
 
     /*
      * Make DIX convert pixels into RGB values -- this handles
@@ -56,26 +56,26 @@ KdSetColormap (ScreenPtr pScreen)
      */
 
     for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-	pixels[i] = i;
+        pixels[i] = i;
 
-    QueryColors (pCmap, (1 << pScreenPriv->screen->fb.depth), pixels, colors, serverClient);
+    QueryColors(pCmap, (1 << pScreenPriv->screen->fb.depth), pixels, colors,
+                serverClient);
 
-    for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-    {
-	defs[i].pixel = i;
-	defs[i].red = colors[i].red;
-	defs[i].green = colors[i].green;
-	defs[i].blue = colors[i].blue;
-	defs[i].flags = DoRed|DoGreen|DoBlue;
+    for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++) {
+        defs[i].pixel = i;
+        defs[i].red = colors[i].red;
+        defs[i].green = colors[i].green;
+        defs[i].blue = colors[i].blue;
+        defs[i].flags = DoRed | DoGreen | DoBlue;
     }
 
     (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen,
-					     (1 << pScreenPriv->screen->fb.depth),
-					     defs);
+                                             (1 << pScreenPriv->screen->fb.
+                                              depth), defs);
 
     /* recolor hardware cursor */
     if (pScreenPriv->card->cfuncs->recolorCursor)
-	(*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, 0, 0);
+        (*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, 0, 0);
 }
 
 /*
@@ -83,38 +83,38 @@ KdSetColormap (ScreenPtr pScreen)
  * the current colormap
  */
 void
-KdEnableColormap (ScreenPtr pScreen)
+KdEnableColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    int	    i;
+    int i;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
-
-    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
-    {
-	for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
-	    pScreenPriv->systemPalette[i].pixel = i;
-	(*pScreenPriv->card->cfuncs->getColors) (pScreen,
-						 (1 << pScreenPriv->screen->fb.depth),
-						 pScreenPriv->systemPalette);
+        return;
+
+    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH) {
+        for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
+            pScreenPriv->systemPalette[i].pixel = i;
+        (*pScreenPriv->card->cfuncs->getColors) (pScreen,
+                                                 (1 << pScreenPriv->screen->fb.
+                                                  depth),
+                                                 pScreenPriv->systemPalette);
     }
-    KdSetColormap (pScreen);
+    KdSetColormap(pScreen);
 }
 
 void
-KdDisableColormap (ScreenPtr pScreen)
+KdDisableColormap(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
 
-    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
-    {
-	(*pScreenPriv->card->cfuncs->putColors) (pScreen,
-						 (1 << pScreenPriv->screen->fb.depth),
-						 pScreenPriv->systemPalette);
+    if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH) {
+        (*pScreenPriv->card->cfuncs->putColors) (pScreen,
+                                                 (1 << pScreenPriv->screen->fb.
+                                                  depth),
+                                                 pScreenPriv->systemPalette);
     }
 }
 
@@ -128,22 +128,22 @@ KdDisableColormap (ScreenPtr pScreen)
  * colormap and realize it into the Windows system palette.
  */
 void
-KdInstallColormap (ColormapPtr pCmap)
+KdInstallColormap(ColormapPtr pCmap)
 {
     KdScreenPriv(pCmap->pScreen);
 
     if (pCmap == pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     /* Tell X clients that the installed colormap is going away. */
     if (pScreenPriv->pInstalledmap)
-	WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap,
-		 (pointer) &(pScreenPriv->pInstalledmap->mid));
+        WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap,
+                 (pointer) &(pScreenPriv->pInstalledmap->mid));
 
     /* Take note of the new installed colorscreen-> */
     pScreenPriv->pInstalledmap = pCmap;
 
-    KdSetColormap (pCmap->pScreen);
+    KdSetColormap(pCmap->pScreen);
 
     /* Tell X clients of the new colormap */
     WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &(pCmap->mid));
@@ -157,45 +157,42 @@ KdInstallColormap (ColormapPtr pCmap)
  * The default X colormap itself cannot be uninstalled.
  */
 void
-KdUninstallColormap (ColormapPtr pCmap)
+KdUninstallColormap(ColormapPtr pCmap)
 {
     KdScreenPriv(pCmap->pScreen);
-    Colormap	defMapID;
+    Colormap defMapID;
     ColormapPtr defMap;
 
     /* ignore if not installed */
     if (pCmap != pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     /* ignore attempts to uninstall default colormap */
     defMapID = pCmap->pScreen->defColormap;
     if ((Colormap) pCmap->mid == defMapID)
-	return;
+        return;
 
     /* install default */
-    dixLookupResourceByType((pointer *)&defMap, defMapID, RT_COLORMAP,
-			    serverClient, DixInstallAccess);
+    dixLookupResourceByType((pointer *) &defMap, defMapID, RT_COLORMAP,
+                            serverClient, DixInstallAccess);
     if (defMap)
-	(*pCmap->pScreen->InstallColormap)(defMap);
-    else
-    {
-	/* uninstall and clear colormap pointer */
-	WalkTree(pCmap->pScreen, TellLostMap,
-		 (pointer) &(pCmap->mid));
-	pScreenPriv->pInstalledmap = 0;
+        (*pCmap->pScreen->InstallColormap) (defMap);
+    else {
+        /* uninstall and clear colormap pointer */
+        WalkTree(pCmap->pScreen, TellLostMap, (pointer) &(pCmap->mid));
+        pScreenPriv->pInstalledmap = 0;
     }
 }
 
 int
-KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps)
+KdListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmaps)
 {
     KdScreenPriv(pScreen);
-    int		n = 0;
+    int n = 0;
 
-    if (pScreenPriv->pInstalledmap)
-    {
-	*pCmaps++ = pScreenPriv->pInstalledmap->mid;
-	n++;
+    if (pScreenPriv->pInstalledmap) {
+        *pCmaps++ = pScreenPriv->pInstalledmap->mid;
+        n++;
     }
     return n;
 }
@@ -208,39 +205,39 @@ KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps)
  * colormap; it can be either the default colormap or a private colorscreen->
  */
 void
-KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs)
+KdStoreColors(ColormapPtr pCmap, int ndef, xColorItem * pdefs)
 {
     KdScreenPriv(pCmap->pScreen);
-    VisualPtr           pVisual;
-    xColorItem          expanddefs[KD_MAX_PSEUDO_SIZE];
+    VisualPtr pVisual;
+    xColorItem expanddefs[KD_MAX_PSEUDO_SIZE];
 
     if (pCmap != pScreenPriv->pInstalledmap)
-	return;
+        return;
 
     if (!pScreenPriv->card->cfuncs->putColors)
-	return;
+        return;
 
     if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
-	return;
+        return;
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
 
     /* Check for DirectColor or TrueColor being simulated on a PseudoColor device. */
     pVisual = pCmap->pVisual;
-    if ((pVisual->class | DynamicClass) == DirectColor)
-    {
-	/*
-	 * Expand DirectColor or TrueColor color values into a PseudoColor
-	 * format.  Defer to the Color Framebuffer (CFB) code to do that.
-	 */
-	ndef = fbExpandDirectColors(pCmap, ndef, pdefs, expanddefs);
-	pdefs = expanddefs;
+    if ((pVisual->class | DynamicClass) == DirectColor) {
+        /*
+         * Expand DirectColor or TrueColor color values into a PseudoColor
+         * format.  Defer to the Color Framebuffer (CFB) code to do that.
+         */
+        ndef = fbExpandDirectColors(pCmap, ndef, pdefs, expanddefs);
+        pdefs = expanddefs;
     }
 
     (*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, ndef, pdefs);
 
     /* recolor hardware cursor */
     if (pScreenPriv->card->cfuncs->recolorCursor)
-	(*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, ndef, pdefs);
+        (*pScreenPriv->card->cfuncs->recolorCursor) (pCmap->pScreen, ndef,
+                                                     pdefs);
 }
diff --git a/xorg-server/hw/kdrive/src/kdrive.c b/xorg-server/hw/kdrive/src/kdrive.c
index f6cc351cd..f65ab96bc 100644
--- a/xorg-server/hw/kdrive/src/kdrive.c
+++ b/xorg-server/hw/kdrive/src/kdrive.c
@@ -46,197 +46,191 @@
 #include <signal.h>
 
 typedef struct _kdDepths {
-    CARD8   depth;
-    CARD8   bpp;
+    CARD8 depth;
+    CARD8 bpp;
 } KdDepths;
 
-KdDepths    kdDepths[] = {
-    { 1, 1 },
-    { 4, 4 },
-    { 8, 8 },
-    { 15, 16 },
-    { 16, 16 },
-    { 24, 32 },
-    { 32, 32 }
+KdDepths kdDepths[] = {
+    {1, 1},
+    {4, 4},
+    {8, 8},
+    {15, 16},
+    {16, 16},
+    {24, 32},
+    {32, 32}
 };
 
 #define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))
 
 #define KD_DEFAULT_BUTTONS 5
 
-DevPrivateKeyRec    kdScreenPrivateKeyRec;
-unsigned long	    kdGeneration;
-
-Bool                kdVideoTest;
-unsigned long       kdVideoTestTime;
-Bool		    kdEmulateMiddleButton;
-Bool		    kdRawPointerCoordinates;
-Bool		    kdDisableZaphod;
-Bool                kdAllowZap;
-Bool		    kdEnabled;
-int		    kdSubpixelOrder;
-int		    kdVirtualTerminal = -1;
-Bool		    kdSwitchPending;
-char		    *kdSwitchCmd;
-DDXPointRec	    kdOrigin;
-Bool		    kdHasPointer = FALSE;
-Bool		    kdHasKbd = FALSE;
-
-static Bool         kdCaughtSignal = FALSE;
+DevPrivateKeyRec kdScreenPrivateKeyRec;
+unsigned long kdGeneration;
+
+Bool kdVideoTest;
+unsigned long kdVideoTestTime;
+Bool kdEmulateMiddleButton;
+Bool kdRawPointerCoordinates;
+Bool kdDisableZaphod;
+Bool kdAllowZap;
+Bool kdEnabled;
+int kdSubpixelOrder;
+int kdVirtualTerminal = -1;
+Bool kdSwitchPending;
+char *kdSwitchCmd;
+DDXPointRec kdOrigin;
+Bool kdHasPointer = FALSE;
+Bool kdHasKbd = FALSE;
+
+static Bool kdCaughtSignal = FALSE;
 
 /*
  * Carry arguments from InitOutput through driver initialization
  * to KdScreenInit
  */
 
-KdOsFuncs	*kdOsFuncs;
+KdOsFuncs *kdOsFuncs;
 
 void
-KdDisableScreen (ScreenPtr pScreen)
+KdDisableScreen(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
 
     if (!pScreenPriv->enabled)
-	return;
+        return;
     if (!pScreenPriv->closed)
-	SetRootClip (pScreen, FALSE);
-    KdDisableColormap (pScreen);
+        SetRootClip(pScreen, FALSE);
+    KdDisableColormap(pScreen);
     if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->disableAccel)
-	(*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->disableCursor)
-	(*pScreenPriv->card->cfuncs->disableCursor) (pScreen);
+        (*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
+    if (!pScreenPriv->screen->softCursor &&
+        pScreenPriv->card->cfuncs->disableCursor)
+        (*pScreenPriv->card->cfuncs->disableCursor) (pScreen);
     if (pScreenPriv->card->cfuncs->dpms)
-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+        (*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
     pScreenPriv->enabled = FALSE;
-    if(pScreenPriv->card->cfuncs->disable)
+    if (pScreenPriv->card->cfuncs->disable)
         (*pScreenPriv->card->cfuncs->disable) (pScreen);
 }
 
 static void
-KdDoSwitchCmd (const char *reason)
+KdDoSwitchCmd(const char *reason)
 {
-    if (kdSwitchCmd)
-    {
-	char    *command;
-
-	if (asprintf(&command, "%s %s", kdSwitchCmd, reason) == -1)
-	    return;
-	system (command);
-	free(command);
+    if (kdSwitchCmd) {
+        char *command;
+
+        if (asprintf(&command, "%s %s", kdSwitchCmd, reason) == -1)
+            return;
+        system(command);
+        free(command);
     }
 }
 
 void
-KdSuspend (void)
+KdSuspend(void)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (kdEnabled)
-    {
-	for (card = kdCardInfo; card; card = card->next)
-	{
-	    for (screen = card->screenList; screen; screen = screen->next)
-		if (screen->mynum == card->selected && screen->pScreen)
-		    KdDisableScreen (screen->pScreen);
-	    if (card->driver && card->cfuncs->restore)
-		(*card->cfuncs->restore) (card);
-	}
-	KdDisableInput ();
-	KdDoSwitchCmd ("suspend");
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (kdEnabled) {
+        for (card = kdCardInfo; card; card = card->next) {
+            for (screen = card->screenList; screen; screen = screen->next)
+                if (screen->mynum == card->selected && screen->pScreen)
+                    KdDisableScreen(screen->pScreen);
+            if (card->driver && card->cfuncs->restore)
+                (*card->cfuncs->restore) (card);
+        }
+        KdDisableInput();
+        KdDoSwitchCmd("suspend");
     }
 }
 
 void
-KdDisableScreens (void)
+KdDisableScreens(void)
 {
-    KdSuspend ();
-    if (kdEnabled)
-    {
+    KdSuspend();
+    if (kdEnabled) {
         if (kdOsFuncs->Disable)
             (*kdOsFuncs->Disable) ();
-	kdEnabled = FALSE;
+        kdEnabled = FALSE;
     }
 }
 
 Bool
-KdEnableScreen (ScreenPtr pScreen)
+KdEnableScreen(ScreenPtr pScreen)
 {
-    KdScreenPriv (pScreen);
+    KdScreenPriv(pScreen);
 
     if (pScreenPriv->enabled)
-	return TRUE;
-    if(pScreenPriv->card->cfuncs->enable)
-	if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))
-	    return FALSE;
+        return TRUE;
+    if (pScreenPriv->card->cfuncs->enable)
+        if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))
+            return FALSE;
     pScreenPriv->enabled = TRUE;
     pScreenPriv->dpmsState = KD_DPMS_NORMAL;
     pScreenPriv->card->selected = pScreenPriv->screen->mynum;
-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->enableCursor)
-	(*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
+    if (!pScreenPriv->screen->softCursor &&
+        pScreenPriv->card->cfuncs->enableCursor)
+        (*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
     if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->enableAccel)
-	(*pScreenPriv->card->cfuncs->enableAccel) (pScreen);
-    KdEnableColormap (pScreen);
-    SetRootClip (pScreen, TRUE);
+        (*pScreenPriv->card->cfuncs->enableAccel) (pScreen);
+    KdEnableColormap(pScreen);
+    SetRootClip(pScreen, TRUE);
     if (pScreenPriv->card->cfuncs->dpms)
-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);
+        (*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);
     return TRUE;
 }
 
 void
-KdResume (void)
+KdResume(void)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (kdEnabled)
-    {
-	KdDoSwitchCmd ("resume");
-	for (card = kdCardInfo; card; card = card->next)
-	{
-	    if(card->cfuncs->preserve)
-		(*card->cfuncs->preserve) (card);
-	    for (screen = card->screenList; screen; screen = screen->next)
-		if (screen->mynum == card->selected && screen->pScreen)
-		    KdEnableScreen (screen->pScreen);
-	}
-	KdEnableInput ();
-	KdReleaseAllKeys ();
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (kdEnabled) {
+        KdDoSwitchCmd("resume");
+        for (card = kdCardInfo; card; card = card->next) {
+            if (card->cfuncs->preserve)
+                (*card->cfuncs->preserve) (card);
+            for (screen = card->screenList; screen; screen = screen->next)
+                if (screen->mynum == card->selected && screen->pScreen)
+                    KdEnableScreen(screen->pScreen);
+        }
+        KdEnableInput();
+        KdReleaseAllKeys();
     }
 }
 
 void
-KdEnableScreens (void)
+KdEnableScreens(void)
 {
-    if (!kdEnabled)
-    {
-	kdEnabled = TRUE;
+    if (!kdEnabled) {
+        kdEnabled = TRUE;
         if (kdOsFuncs->Enable)
             (*kdOsFuncs->Enable) ();
     }
-    KdResume ();
+    KdResume();
 }
 
 void
-KdProcessSwitch (void)
+KdProcessSwitch(void)
 {
     if (kdEnabled)
-	KdDisableScreens ();
+        KdDisableScreens();
     else
-	KdEnableScreens ();
+        KdEnableScreens();
 }
 
 void
 AbortDDX(enum ExitCode error)
 {
-    KdDisableScreens ();
-    if (kdOsFuncs)
-    {
-	if (kdEnabled && kdOsFuncs->Disable)
-	    (*kdOsFuncs->Disable) ();
+    KdDisableScreens();
+    if (kdOsFuncs) {
+        if (kdEnabled && kdOsFuncs->Disable)
+            (*kdOsFuncs->Disable) ();
         if (kdOsFuncs->Fini)
             (*kdOsFuncs->Fini) ();
-	KdDoSwitchCmd ("stop");
+        KdDoSwitchCmd("stop");
     }
 
     if (kdCaughtSignal)
@@ -244,58 +238,56 @@ AbortDDX(enum ExitCode error)
 }
 
 void
-ddxGiveUp (enum ExitCode error)
+ddxGiveUp(enum ExitCode error)
 {
-    AbortDDX (error);
+    AbortDDX(error);
 }
 
-Bool	kdDumbDriver;
-Bool	kdSoftCursor;
+Bool kdDumbDriver;
+Bool kdSoftCursor;
 
 char *
-KdParseFindNext (char *cur, const char *delim, char *save, char *last)
+KdParseFindNext(char *cur, const char *delim, char *save, char *last)
 {
-    while (*cur && !strchr (delim, *cur))
-    {
-	*save++ = *cur++;
+    while (*cur && !strchr(delim, *cur)) {
+        *save++ = *cur++;
     }
     *save = 0;
     *last = *cur;
     if (*cur)
-	cur++;
+        cur++;
     return cur;
 }
 
 Rotation
-KdAddRotation (Rotation a, Rotation b)
+KdAddRotation(Rotation a, Rotation b)
 {
-    Rotation	rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);
-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+    Rotation rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);
+    Rotation reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
 
     if (rotate > RR_Rotate_270)
-	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+        rotate /= (RR_Rotate_270 * RR_Rotate_90);
     return reflect | rotate;
 }
 
 Rotation
-KdSubRotation (Rotation a, Rotation b)
+KdSubRotation(Rotation a, Rotation b)
 {
-    Rotation	rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);
-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+    Rotation rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);
+    Rotation reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
 
     if (rotate > RR_Rotate_270)
-	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+        rotate /= (RR_Rotate_270 * RR_Rotate_90);
     return reflect | rotate;
 }
 
 void
-KdParseScreen (KdScreenInfo *screen,
-	       char	    *arg)
+KdParseScreen(KdScreenInfo * screen, char *arg)
 {
-    char    delim;
-    char    save[1024];
-    int	    i;
-    int	    pixels, mm;
+    char delim;
+    char save[1024];
+    int i;
+    int pixels, mm;
 
     screen->dumb = kdDumbDriver;
     screen->softCursor = kdSoftCursor;
@@ -309,39 +301,35 @@ KdParseScreen (KdScreenInfo *screen,
     screen->rate = 0;
     screen->fb.depth = 0;
     if (!arg)
-	return;
-    if (strlen (arg) >= sizeof (save))
-	return;
-
-    for (i = 0; i < 2; i++)
-    {
-	arg = KdParseFindNext (arg, "x/@XY", save, &delim);
-	if (!save[0])
-	    return;
-
-	pixels = atoi(save);
-	mm = 0;
-
-	if (delim == '/')
-	{
-	    arg = KdParseFindNext (arg, "x@XY", save, &delim);
-	    if (!save[0])
-		return;
-	    mm = atoi(save);
-	}
-
-	if (i == 0)
-	{
-	    screen->width = pixels;
-	    screen->width_mm = mm;
-	}
-	else
-	{
-	    screen->height = pixels;
-	    screen->height_mm = mm;
-	}
-	if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')
-	    return;
+        return;
+    if (strlen(arg) >= sizeof(save))
+        return;
+
+    for (i = 0; i < 2; i++) {
+        arg = KdParseFindNext(arg, "x/@XY", save, &delim);
+        if (!save[0])
+            return;
+
+        pixels = atoi(save);
+        mm = 0;
+
+        if (delim == '/') {
+            arg = KdParseFindNext(arg, "x@XY", save, &delim);
+            if (!save[0])
+                return;
+            mm = atoi(save);
+        }
+
+        if (i == 0) {
+            screen->width = pixels;
+            screen->width_mm = mm;
+        }
+        else {
+            screen->height = pixels;
+            screen->height_mm = mm;
+        }
+        if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')
+            return;
     }
 
     kdOrigin.x += screen->width;
@@ -350,55 +338,49 @@ KdParseScreen (KdScreenInfo *screen,
     kdSoftCursor = FALSE;
     kdSubpixelOrder = SubPixelUnknown;
 
-    if (delim == '@')
-    {
-	arg = KdParseFindNext (arg, "xXY", save, &delim);
-	if (save[0])
-	{
-	    int	    rotate = atoi (save);
-	    if (rotate < 45)
-		screen->randr = RR_Rotate_0;
-	    else if (rotate < 135)
-		screen->randr = RR_Rotate_90;
-	    else if (rotate < 225)
-		screen->randr = RR_Rotate_180;
-	    else if (rotate < 315)
-		screen->randr = RR_Rotate_270;
-	    else
-		screen->randr = RR_Rotate_0;
-	}
+    if (delim == '@') {
+        arg = KdParseFindNext(arg, "xXY", save, &delim);
+        if (save[0]) {
+            int rotate = atoi(save);
+
+            if (rotate < 45)
+                screen->randr = RR_Rotate_0;
+            else if (rotate < 135)
+                screen->randr = RR_Rotate_90;
+            else if (rotate < 225)
+                screen->randr = RR_Rotate_180;
+            else if (rotate < 315)
+                screen->randr = RR_Rotate_270;
+            else
+                screen->randr = RR_Rotate_0;
+        }
     }
-    if (delim == 'X')
-    {
-	arg = KdParseFindNext (arg, "xY", save, &delim);
-	screen->randr |= RR_Reflect_X;
+    if (delim == 'X') {
+        arg = KdParseFindNext(arg, "xY", save, &delim);
+        screen->randr |= RR_Reflect_X;
     }
 
-    if (delim == 'Y')
-    {
-	arg = KdParseFindNext (arg, "xY", save, &delim);
-	screen->randr |= RR_Reflect_Y;
+    if (delim == 'Y') {
+        arg = KdParseFindNext(arg, "xY", save, &delim);
+        screen->randr |= RR_Reflect_Y;
     }
 
-    arg = KdParseFindNext (arg, "x/,", save, &delim);
-    if (save[0])
-    {
-	screen->fb.depth = atoi(save);
-	if (delim == '/')
-	{
-	    arg = KdParseFindNext (arg, "x,", save, &delim);
-	    if (save[0])
-		screen->fb.bitsPerPixel = atoi (save);
-	}
-	else
-	    screen->fb.bitsPerPixel = 0;
+    arg = KdParseFindNext(arg, "x/,", save, &delim);
+    if (save[0]) {
+        screen->fb.depth = atoi(save);
+        if (delim == '/') {
+            arg = KdParseFindNext(arg, "x,", save, &delim);
+            if (save[0])
+                screen->fb.bitsPerPixel = atoi(save);
+        }
+        else
+            screen->fb.bitsPerPixel = 0;
     }
 
-    if (delim == 'x')
-    {
-	arg = KdParseFindNext (arg, "x", save, &delim);
-	if (save[0])
-	    screen->rate = atoi(save);
+    if (delim == 'x') {
+        arg = KdParseFindNext(arg, "x", save, &delim);
+        if (save[0])
+            screen->rate = atoi(save);
     }
 }
 
@@ -414,162 +396,154 @@ KdParseScreen (KdScreenInfo *screen,
  */
 
 void
-KdParseRgba (char *rgba)
+KdParseRgba(char *rgba)
 {
-    if (!strcmp (rgba, "rgb"))
-	kdSubpixelOrder = SubPixelHorizontalRGB;
-    else if (!strcmp (rgba, "bgr"))
-	kdSubpixelOrder = SubPixelHorizontalBGR;
-    else if (!strcmp (rgba, "vrgb"))
-	kdSubpixelOrder = SubPixelVerticalRGB;
-    else if (!strcmp (rgba, "vbgr"))
-	kdSubpixelOrder = SubPixelVerticalBGR;
-    else if (!strcmp (rgba, "none"))
-	kdSubpixelOrder = SubPixelNone;
+    if (!strcmp(rgba, "rgb"))
+        kdSubpixelOrder = SubPixelHorizontalRGB;
+    else if (!strcmp(rgba, "bgr"))
+        kdSubpixelOrder = SubPixelHorizontalBGR;
+    else if (!strcmp(rgba, "vrgb"))
+        kdSubpixelOrder = SubPixelVerticalRGB;
+    else if (!strcmp(rgba, "vbgr"))
+        kdSubpixelOrder = SubPixelVerticalBGR;
+    else if (!strcmp(rgba, "none"))
+        kdSubpixelOrder = SubPixelNone;
     else
-	kdSubpixelOrder = SubPixelUnknown;
+        kdSubpixelOrder = SubPixelUnknown;
 }
 
 void
-KdUseMsg (void)
+KdUseMsg(void)
 {
     ErrorF("\nTinyX Device Dependent Usage:\n");
-    ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");
-    ErrorF("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");
-    ErrorF("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");
-    ErrorF("-keybd driver [,,options]      Specify the keyboard driver and its options\n");
+    ErrorF
+        ("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");
+    ErrorF
+        ("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");
+    ErrorF
+        ("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");
+    ErrorF
+        ("-keybd driver [,,options]      Specify the keyboard driver and its options\n");
     ErrorF("-zaphod          Disable cursor screen switching\n");
     ErrorF("-2button         Emulate 3 button mouse\n");
     ErrorF("-3button         Disable 3 button mouse emulation\n");
-    ErrorF("-rawcoord        Don't transform pointer coordinates on rotation\n");
+    ErrorF
+        ("-rawcoord        Don't transform pointer coordinates on rotation\n");
     ErrorF("-dumb            Disable hardware acceleration\n");
     ErrorF("-softCursor      Force software cursor\n");
     ErrorF("-videoTest       Start the server, pause momentarily and exit\n");
-    ErrorF("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");
+    ErrorF
+        ("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");
     ErrorF("-switchCmd       Command to execute on vt switch\n");
     ErrorF("-zap             Terminate server on Ctrl+Alt+Backspace\n");
-    ErrorF("vtxx             Use virtual terminal xx instead of the next available\n");
+    ErrorF
+        ("vtxx             Use virtual terminal xx instead of the next available\n");
 }
 
 int
-KdProcessArgument (int argc, char **argv, int i)
+KdProcessArgument(int argc, char **argv, int i)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (!strcmp (argv[i], "-screen"))
-    {
-	if ((i+1) < argc)
-	{
-	    card = KdCardInfoLast ();
-	    if (!card)
-	    {
-		InitCard (0);
-		card = KdCardInfoLast ();
-	    }
-	    if (card) {
-		screen = KdScreenInfoAdd (card);
-		KdParseScreen (screen, argv[i+1]);
-	    } else
-		ErrorF("No matching card found!\n");
-	}
-	else
-	    UseMsg ();
-	return 2;
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (!strcmp(argv[i], "-screen")) {
+        if ((i + 1) < argc) {
+            card = KdCardInfoLast();
+            if (!card) {
+                InitCard(0);
+                card = KdCardInfoLast();
+            }
+            if (card) {
+                screen = KdScreenInfoAdd(card);
+                KdParseScreen(screen, argv[i + 1]);
+            }
+            else
+                ErrorF("No matching card found!\n");
+        }
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-zaphod"))
-    {
-	kdDisableZaphod = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-zaphod")) {
+        kdDisableZaphod = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-zap"))
-    {
-	kdAllowZap = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-zap")) {
+        kdAllowZap = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-3button"))
-    {
-	kdEmulateMiddleButton = FALSE;
-	return 1;
+    if (!strcmp(argv[i], "-3button")) {
+        kdEmulateMiddleButton = FALSE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-2button"))
-    {
-	kdEmulateMiddleButton = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-2button")) {
+        kdEmulateMiddleButton = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-rawcoord"))
-    {
-	kdRawPointerCoordinates = 1;
-	return 1;
+    if (!strcmp(argv[i], "-rawcoord")) {
+        kdRawPointerCoordinates = 1;
+        return 1;
     }
-    if (!strcmp (argv[i], "-dumb"))
-    {
-	kdDumbDriver = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-dumb")) {
+        kdDumbDriver = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-softCursor"))
-    {
-	kdSoftCursor = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-softCursor")) {
+        kdSoftCursor = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-videoTest"))
-    {
-	kdVideoTest = TRUE;
-	return 1;
+    if (!strcmp(argv[i], "-videoTest")) {
+        kdVideoTest = TRUE;
+        return 1;
     }
-    if (!strcmp (argv[i], "-origin"))
-    {
-	if ((i+1) < argc)
-	{
-	    char    *x = argv[i+1];
-	    char    *y = strchr (x, ',');
-	    if (x)
-		kdOrigin.x = atoi (x);
-	    else
-		kdOrigin.x = 0;
-	    if (y)
-		kdOrigin.y = atoi(y+1);
-	    else
-		kdOrigin.y = 0;
-	}
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-origin")) {
+        if ((i + 1) < argc) {
+            char *x = argv[i + 1];
+            char *y = strchr(x, ',');
+
+            if (x)
+                kdOrigin.x = atoi(x);
+            else
+                kdOrigin.x = 0;
+            if (y)
+                kdOrigin.y = atoi(y + 1);
+            else
+                kdOrigin.y = 0;
+        }
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-rgba"))
-    {
-	if ((i+1) < argc)
-	    KdParseRgba (argv[i+1]);
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-rgba")) {
+        if ((i + 1) < argc)
+            KdParseRgba(argv[i + 1]);
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strcmp (argv[i], "-switchCmd"))
-    {
-	if ((i+1) < argc)
-	    kdSwitchCmd = argv[i+1];
-	else
-	    UseMsg ();
-	return 2;
+    if (!strcmp(argv[i], "-switchCmd")) {
+        if ((i + 1) < argc)
+            kdSwitchCmd = argv[i + 1];
+        else
+            UseMsg();
+        return 2;
     }
-    if (!strncmp (argv[i], "vt", 2) &&
-	sscanf (argv[i], "vt%2d", &kdVirtualTerminal) == 1)
-    {
-	return 1;
+    if (!strncmp(argv[i], "vt", 2) &&
+        sscanf(argv[i], "vt%2d", &kdVirtualTerminal) == 1) {
+        return 1;
     }
-    if (!strcmp (argv[i], "-mouse") ||
-        !strcmp (argv[i], "-pointer")) {
+    if (!strcmp(argv[i], "-mouse") || !strcmp(argv[i], "-pointer")) {
         if (i + 1 >= argc)
             UseMsg();
         KdAddConfigPointer(argv[i + 1]);
-	kdHasPointer = TRUE;
+        kdHasPointer = TRUE;
         return 2;
     }
-    if (!strcmp (argv[i], "-keybd")) {
+    if (!strcmp(argv[i], "-keybd")) {
         if (i + 1 >= argc)
             UseMsg();
         KdAddConfigKeyboard(argv[i + 1]);
-	kdHasKbd = TRUE;
+        kdHasKbd = TRUE;
         return 2;
     }
 
@@ -582,116 +556,110 @@ KdProcessArgument (int argc, char **argv, int i)
  */
 
 void
-KdOsInit (KdOsFuncs *pOsFuncs)
+KdOsInit(KdOsFuncs * pOsFuncs)
 {
     kdOsFuncs = pOsFuncs;
-    if (pOsFuncs)
-    {
-	if (serverGeneration == 1)
-	{
-	    KdDoSwitchCmd ("start");
+    if (pOsFuncs) {
+        if (serverGeneration == 1) {
+            KdDoSwitchCmd("start");
             if (pOsFuncs->Init)
                 (*pOsFuncs->Init) ();
-	}
+        }
     }
 }
 
 Bool
-KdAllocatePrivates (ScreenPtr pScreen)
+KdAllocatePrivates(ScreenPtr pScreen)
 {
-    KdPrivScreenPtr	pScreenPriv;
+    KdPrivScreenPtr pScreenPriv;
 
     if (kdGeneration != serverGeneration)
-	kdGeneration = serverGeneration;
+        kdGeneration = serverGeneration;
 
     if (!dixRegisterPrivateKey(&kdScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
-    pScreenPriv = calloc(1, sizeof (*pScreenPriv));
+    pScreenPriv = calloc(1, sizeof(*pScreenPriv));
     if (!pScreenPriv)
-	return FALSE;
-    KdSetScreenPriv (pScreen, pScreenPriv);
+        return FALSE;
+    KdSetScreenPriv(pScreen, pScreenPriv);
     return TRUE;
 }
 
 Bool
-KdCreateScreenResources (ScreenPtr pScreen)
+KdCreateScreenResources(ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdCardInfo	    *card = pScreenPriv->card;
+    KdCardInfo *card = pScreenPriv->card;
     Bool ret;
 
     pScreen->CreateScreenResources = pScreenPriv->CreateScreenResources;
-    if(pScreen->CreateScreenResources)
-	ret = (*pScreen->CreateScreenResources) (pScreen);
+    if (pScreen->CreateScreenResources)
+        ret = (*pScreen->CreateScreenResources) (pScreen);
     else
-	ret= -1;
+        ret = -1;
     pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;
     pScreen->CreateScreenResources = KdCreateScreenResources;
     if (ret && card->cfuncs->createRes)
-	ret = (*card->cfuncs->createRes) (pScreen);
+        ret = (*card->cfuncs->createRes) (pScreen);
     return ret;
 }
 
 Bool
-KdCloseScreen (int index, ScreenPtr pScreen)
+KdCloseScreen(int index, ScreenPtr pScreen)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo    *screen = pScreenPriv->screen;
-    KdCardInfo	    *card = pScreenPriv->card;
-    Bool	    ret;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    KdCardInfo *card = pScreenPriv->card;
+    Bool ret;
 
     pScreenPriv->closed = TRUE;
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    if(pScreen->CloseScreen)
+    if (pScreen->CloseScreen)
         ret = (*pScreen->CloseScreen) (index, pScreen);
     else
-	ret = TRUE;
+        ret = TRUE;
 
     if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)
-	(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+        (*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
 
     if (screen->mynum == card->selected)
-	KdDisableScreen (pScreen);
+        KdDisableScreen(pScreen);
 
     /*
      * Restore video hardware when last screen is closed
      */
-    if (screen == card->screenList)
-    {
-	if (kdEnabled && card->cfuncs->restore)
-	    (*card->cfuncs->restore) (card);
+    if (screen == card->screenList) {
+        if (kdEnabled && card->cfuncs->restore)
+            (*card->cfuncs->restore) (card);
     }
 
     if (!pScreenPriv->screen->dumb && card->cfuncs->finiAccel)
-	(*card->cfuncs->finiAccel) (pScreen);
+        (*card->cfuncs->finiAccel) (pScreen);
 
     if (!pScreenPriv->screen->softCursor && card->cfuncs->finiCursor)
-	(*card->cfuncs->finiCursor) (pScreen);
+        (*card->cfuncs->finiCursor) (pScreen);
 
-    if(card->cfuncs->scrfini)
+    if (card->cfuncs->scrfini)
         (*card->cfuncs->scrfini) (screen);
 
     /*
      * Clean up card when last screen is closed, DIX closes them in
      * reverse order, thus we check for when the first in the list is closed
      */
-    if (screen == card->screenList)
-    {
-	if(card->cfuncs->cardfini)
-	    (*card->cfuncs->cardfini) (card);
-	/*
-	 * Clean up OS when last card is closed
-	 */
-	if (card == kdCardInfo)
-	{
-	    if (kdEnabled)
-	    {
-		kdEnabled = FALSE;
-		if(kdOsFuncs->Disable)
-		    (*kdOsFuncs->Disable) ();
-	    }
-	}
+    if (screen == card->screenList) {
+        if (card->cfuncs->cardfini)
+            (*card->cfuncs->cardfini) (card);
+        /*
+         * Clean up OS when last card is closed
+         */
+        if (card == kdCardInfo) {
+            if (kdEnabled) {
+                kdEnabled = FALSE;
+                if (kdOsFuncs->Disable)
+                    (*kdOsFuncs->Disable) ();
+            }
+        }
     }
 
     pScreenPriv->screen->pScreen = 0;
@@ -701,112 +669,107 @@ KdCloseScreen (int index, ScreenPtr pScreen)
 }
 
 Bool
-KdSaveScreen (ScreenPtr pScreen, int on)
+KdSaveScreen(ScreenPtr pScreen, int on)
 {
     KdScreenPriv(pScreen);
-    int	    dpmsState;
+    int dpmsState;
 
     if (!pScreenPriv->card->cfuncs->dpms)
-	return FALSE;
+        return FALSE;
 
     dpmsState = pScreenPriv->dpmsState;
     switch (on) {
     case SCREEN_SAVER_OFF:
-	dpmsState = KD_DPMS_NORMAL;
-	break;
+        dpmsState = KD_DPMS_NORMAL;
+        break;
     case SCREEN_SAVER_ON:
-	if (dpmsState == KD_DPMS_NORMAL)
-	    dpmsState = KD_DPMS_NORMAL+1;
-	break;
+        if (dpmsState == KD_DPMS_NORMAL)
+            dpmsState = KD_DPMS_NORMAL + 1;
+        break;
     case SCREEN_SAVER_CYCLE:
-	if (dpmsState < KD_DPMS_MAX)
-	    dpmsState++;
-	break;
+        if (dpmsState < KD_DPMS_MAX)
+            dpmsState++;
+        break;
     case SCREEN_SAVER_FORCER:
-	break;
+        break;
     }
-    if (dpmsState != pScreenPriv->dpmsState)
-    {
-	if (pScreenPriv->enabled)
-	    (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);
-	pScreenPriv->dpmsState = dpmsState;
+    if (dpmsState != pScreenPriv->dpmsState) {
+        if (pScreenPriv->enabled)
+            (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);
+        pScreenPriv->dpmsState = dpmsState;
     }
     return TRUE;
 }
 
 static Bool
-KdCreateWindow (WindowPtr pWin)
+KdCreateWindow(WindowPtr pWin)
 {
 #ifndef PHOENIX
-    if (!pWin->parent)
-    {
-	KdScreenPriv(pWin->drawable.pScreen);
-
-	if (!pScreenPriv->enabled)
-	{
-	    RegionEmpty(&pWin->borderClip);
-	    RegionBreak(&pWin->clipList);
-	}
+    if (!pWin->parent) {
+        KdScreenPriv(pWin->drawable.pScreen);
+
+        if (!pScreenPriv->enabled) {
+            RegionEmpty(&pWin->borderClip);
+            RegionBreak(&pWin->clipList);
+        }
     }
 #endif
-    return fbCreateWindow (pWin);
+    return fbCreateWindow(pWin);
 }
 
 void
-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr)
+KdSetSubpixelOrder(ScreenPtr pScreen, Rotation randr)
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	*screen = pScreenPriv->screen;
-    int			subpixel_order = screen->subpixel_order;
-    Rotation		subpixel_dir;
-    int			i;
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int subpixel_order = screen->subpixel_order;
+    Rotation subpixel_dir;
+    int i;
 
     static struct {
-	int	    subpixel_order;
-	Rotation    direction;
+        int subpixel_order;
+        Rotation direction;
     } orders[] = {
-	{ SubPixelHorizontalRGB, 	RR_Rotate_0 },
-	{ SubPixelHorizontalBGR,	RR_Rotate_180 },
-	{ SubPixelVerticalRGB,		RR_Rotate_270 },
-	{ SubPixelVerticalBGR,		RR_Rotate_90 },
-    };
+        {
+        SubPixelHorizontalRGB, RR_Rotate_0}, {
+        SubPixelHorizontalBGR, RR_Rotate_180}, {
+        SubPixelVerticalRGB, RR_Rotate_270}, {
+    SubPixelVerticalBGR, RR_Rotate_90},};
 
     static struct {
-	int	bit;
-	int	normal;
-	int	reflect;
+        int bit;
+        int normal;
+        int reflect;
     } reflects[] = {
-	{ RR_Reflect_X, SubPixelHorizontalRGB,	SubPixelHorizontalBGR },
-	{ RR_Reflect_X, SubPixelHorizontalBGR,	SubPixelHorizontalRGB },
-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalBGR },
-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalRGB },
-    };
+        {
+        RR_Reflect_X, SubPixelHorizontalRGB, SubPixelHorizontalBGR}, {
+        RR_Reflect_X, SubPixelHorizontalBGR, SubPixelHorizontalRGB}, {
+        RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalBGR}, {
+    RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalRGB},};
 
     /* map subpixel to direction */
     for (i = 0; i < 4; i++)
-	if (orders[i].subpixel_order == subpixel_order)
-	    break;
-    if (i < 4)
-    {
-	subpixel_dir = KdAddRotation (randr & RR_Rotate_All, orders[i].direction);
-
-	/* map back to subpixel order */
-	for (i = 0; i < 4; i++)
-	    if (orders[i].direction & subpixel_dir)
-	    {
-		subpixel_order = orders[i].subpixel_order;
-		break;
-	    }
-	/* reflect */
-	for (i = 0; i < 4; i++)
-	    if ((randr & reflects[i].bit) &&
-		reflects[i].normal == subpixel_order)
-	    {
-		subpixel_order = reflects[i].reflect;
-		break;
-	    }
+        if (orders[i].subpixel_order == subpixel_order)
+            break;
+    if (i < 4) {
+        subpixel_dir =
+            KdAddRotation(randr & RR_Rotate_All, orders[i].direction);
+
+        /* map back to subpixel order */
+        for (i = 0; i < 4; i++)
+            if (orders[i].direction & subpixel_dir) {
+                subpixel_order = orders[i].subpixel_order;
+                break;
+            }
+        /* reflect */
+        for (i = 0; i < 4; i++)
+            if ((randr & reflects[i].bit) &&
+                reflects[i].normal == subpixel_order) {
+                subpixel_order = reflects[i].reflect;
+                break;
+            }
     }
-    PictureSetSubpixelOrder (pScreen, subpixel_order);
+    PictureSetSubpixelOrder(pScreen, subpixel_order);
 }
 
 /* Pass through AddScreen, which doesn't take any closure */
@@ -815,34 +778,33 @@ static KdScreenInfo *kdCurrentScreen;
 Bool
 KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
 {
-    KdScreenInfo	*screen = kdCurrentScreen;
-    KdCardInfo		*card = screen->card;
-    KdPrivScreenPtr	pScreenPriv;
+    KdScreenInfo *screen = kdCurrentScreen;
+    KdCardInfo *card = screen->card;
+    KdPrivScreenPtr pScreenPriv;
+
     /*
      * note that screen->fb is set up for the nominal orientation
      * of the screen; that means if randr is rotated, the values
      * there should reflect a rotated frame buffer (or shadow).
      */
-    Bool		rotated = (screen->randr & (RR_Rotate_90|RR_Rotate_270)) != 0;
-    int			width, height, *width_mmp, *height_mmp;
+    Bool rotated = (screen->randr & (RR_Rotate_90 | RR_Rotate_270)) != 0;
+    int width, height, *width_mmp, *height_mmp;
 
-    KdAllocatePrivates (pScreen);
+    KdAllocatePrivates(pScreen);
 
     pScreenPriv = KdGetScreenPriv(pScreen);
 
-    if (!rotated)
-    {
-	width = screen->width;
-	height = screen->height;
-	width_mmp = &screen->width_mm;
-	height_mmp = &screen->height_mm;
+    if (!rotated) {
+        width = screen->width;
+        height = screen->height;
+        width_mmp = &screen->width_mm;
+        height_mmp = &screen->height_mm;
     }
-    else
-    {
-	width = screen->height;
-	height = screen->width;
-	width_mmp = &screen->height_mm;
-	height_mmp = &screen->width_mm;
+    else {
+        width = screen->height;
+        height = screen->width;
+        width_mmp = &screen->height_mm;
+        height_mmp = &screen->width_mm;
     }
     screen->pScreen = pScreen;
     pScreenPriv->screen = screen;
@@ -853,41 +815,37 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     pScreen->y = screen->origin.y;
 
     if (!monitorResolution)
-	monitorResolution = 75;
+        monitorResolution = 75;
     /*
      * This is done in this order so that backing store wraps
      * our GC functions; fbFinishScreenInit initializes MI
      * backing store
      */
-    if (!fbSetupScreen (pScreen,
-			screen->fb.frameBuffer,
-			width, height,
-			monitorResolution, monitorResolution,
-			screen->fb.pixelStride,
-			screen->fb.bitsPerPixel))
-    {
-	return FALSE;
+    if (!fbSetupScreen(pScreen,
+                       screen->fb.frameBuffer,
+                       width, height,
+                       monitorResolution, monitorResolution,
+                       screen->fb.pixelStride, screen->fb.bitsPerPixel)) {
+        return FALSE;
     }
 
     /*
      * Set colormap functions
      */
-    pScreen->InstallColormap	= KdInstallColormap;
-    pScreen->UninstallColormap	= KdUninstallColormap;
+    pScreen->InstallColormap = KdInstallColormap;
+    pScreen->UninstallColormap = KdUninstallColormap;
     pScreen->ListInstalledColormaps = KdListInstalledColormaps;
-    pScreen->StoreColors	= KdStoreColors;
-
-    pScreen->SaveScreen		= KdSaveScreen;
-    pScreen->CreateWindow	= KdCreateWindow;
-
-    if (!fbFinishScreenInit (pScreen,
-			     screen->fb.frameBuffer,
-			     width, height,
-			     monitorResolution, monitorResolution,
-			     screen->fb.pixelStride,
-			     screen->fb.bitsPerPixel))
-    {
-	return FALSE;
+    pScreen->StoreColors = KdStoreColors;
+
+    pScreen->SaveScreen = KdSaveScreen;
+    pScreen->CreateWindow = KdCreateWindow;
+
+    if (!fbFinishScreenInit(pScreen,
+                            screen->fb.frameBuffer,
+                            width, height,
+                            monitorResolution, monitorResolution,
+                            screen->fb.pixelStride, screen->fb.bitsPerPixel)) {
+        return FALSE;
     }
 
     /*
@@ -895,44 +853,44 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
      * Rounding errors are annoying
      */
     if (*width_mmp)
-	pScreen->mmWidth = *width_mmp;
+        pScreen->mmWidth = *width_mmp;
     else
-	*width_mmp = pScreen->mmWidth;
+        *width_mmp = pScreen->mmWidth;
     if (*height_mmp)
-	pScreen->mmHeight = *height_mmp;
+        pScreen->mmHeight = *height_mmp;
     else
-	*height_mmp = pScreen->mmHeight;
+        *height_mmp = pScreen->mmHeight;
 
     /*
      * Plug in our own block/wakeup handlers.
      * miScreenInit installs NoopDDA in both places
      */
-    pScreen->BlockHandler	= KdBlockHandler;
-    pScreen->WakeupHandler	= KdWakeupHandler;
+    pScreen->BlockHandler = KdBlockHandler;
+    pScreen->WakeupHandler = KdWakeupHandler;
 
-    if (!fbPictureInit (pScreen, 0, 0))
-	return FALSE;
+    if (!fbPictureInit(pScreen, 0, 0))
+        return FALSE;
     if (card->cfuncs->initScreen)
-	if (!(*card->cfuncs->initScreen) (pScreen))
-	    return FALSE;
+        if (!(*card->cfuncs->initScreen) (pScreen))
+            return FALSE;
 
     if (!screen->dumb && card->cfuncs->initAccel)
-	if (!(*card->cfuncs->initAccel) (pScreen))
-	    screen->dumb = TRUE;
+        if (!(*card->cfuncs->initAccel) (pScreen))
+            screen->dumb = TRUE;
 
     if (card->cfuncs->finishInitScreen)
-	if (!(*card->cfuncs->finishInitScreen) (pScreen))
-	    return FALSE;
+        if (!(*card->cfuncs->finishInitScreen) (pScreen))
+            return FALSE;
 
 #if 0
-    fbInitValidateTree (pScreen);
+    fbInitValidateTree(pScreen);
 #endif
 
     /*
      * Wrap CloseScreen, the order now is:
-     *	KdCloseScreen
-     *	miBSCloseScreen
-     *	fbCloseScreen
+     *  KdCloseScreen
+     *  miBSCloseScreen
+     *  fbCloseScreen
      */
     pScreenPriv->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = KdCloseScreen;
@@ -941,78 +899,70 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
     pScreen->CreateScreenResources = KdCreateScreenResources;
 
     if (screen->softCursor ||
-	!card->cfuncs->initCursor ||
-	!(*card->cfuncs->initCursor) (pScreen))
-    {
-	/* Use MI for cursor display and event queueing. */
-	screen->softCursor = TRUE;
-	miDCInitialize(pScreen, &kdPointerScreenFuncs);
+        !card->cfuncs->initCursor || !(*card->cfuncs->initCursor) (pScreen)) {
+        /* Use MI for cursor display and event queueing. */
+        screen->softCursor = TRUE;
+        miDCInitialize(pScreen, &kdPointerScreenFuncs);
     }
 
-
-    if (!fbCreateDefColormap (pScreen))
-    {
-	return FALSE;
+    if (!fbCreateDefColormap(pScreen)) {
+        return FALSE;
     }
 
-    KdSetSubpixelOrder (pScreen, screen->randr);
+    KdSetSubpixelOrder(pScreen, screen->randr);
 
     /*
      * Enable the hardware
      */
-    if (!kdEnabled)
-    {
-	kdEnabled = TRUE;
-	if(kdOsFuncs->Enable)
-	    (*kdOsFuncs->Enable) ();
+    if (!kdEnabled) {
+        kdEnabled = TRUE;
+        if (kdOsFuncs->Enable)
+            (*kdOsFuncs->Enable) ();
     }
 
-    if (screen->mynum == card->selected)
-    {
-	if(card->cfuncs->preserve)
-	    (*card->cfuncs->preserve) (card);
-	if(card->cfuncs->enable)
-	    if (!(*card->cfuncs->enable) (pScreen))
-		return FALSE;
-	pScreenPriv->enabled = TRUE;
-	if (!screen->softCursor && card->cfuncs->enableCursor)
-	    (*card->cfuncs->enableCursor) (pScreen);
-	KdEnableColormap (pScreen);
-	if (!screen->dumb && card->cfuncs->enableAccel)
-	    (*card->cfuncs->enableAccel) (pScreen);
+    if (screen->mynum == card->selected) {
+        if (card->cfuncs->preserve)
+            (*card->cfuncs->preserve) (card);
+        if (card->cfuncs->enable)
+            if (!(*card->cfuncs->enable) (pScreen))
+                return FALSE;
+        pScreenPriv->enabled = TRUE;
+        if (!screen->softCursor && card->cfuncs->enableCursor)
+            (*card->cfuncs->enableCursor) (pScreen);
+        KdEnableColormap(pScreen);
+        if (!screen->dumb && card->cfuncs->enableAccel)
+            (*card->cfuncs->enableAccel) (pScreen);
     }
 
     return TRUE;
 }
 
 void
-KdInitScreen (ScreenInfo    *pScreenInfo,
-	      KdScreenInfo  *screen,
-	      int	    argc,
-	      char	    **argv)
+KdInitScreen(ScreenInfo * pScreenInfo,
+             KdScreenInfo * screen, int argc, char **argv)
 {
-    KdCardInfo	*card = screen->card;
+    KdCardInfo *card = screen->card;
 
     (*card->cfuncs->scrinit) (screen);
 
     if (!card->cfuncs->initAccel)
-	screen->dumb = TRUE;
+        screen->dumb = TRUE;
     if (!card->cfuncs->initCursor)
-	screen->softCursor = TRUE;
+        screen->softCursor = TRUE;
 }
 
 static Bool
-KdSetPixmapFormats (ScreenInfo	*pScreenInfo)
+KdSetPixmapFormats(ScreenInfo * pScreenInfo)
 {
-    CARD8	    depthToBpp[33];	/* depth -> bpp map */
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-    int		    i;
-    int		    bpp;
+    CARD8 depthToBpp[33];       /* depth -> bpp map */
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+    int i;
+    int bpp;
     PixmapFormatRec *format;
 
     for (i = 1; i <= 32; i++)
-	depthToBpp[i] = 0;
+        depthToBpp[i] = 0;
 
     /*
      * Generate mappings between bitsPerPixel and depth,
@@ -1020,148 +970,135 @@ KdSetPixmapFormats (ScreenInfo	*pScreenInfo)
      * restrictions on equivalent formats for the same
      * depth on different screens
      */
-    for (card = kdCardInfo; card; card = card->next)
-    {
-	for (screen = card->screenList; screen; screen = screen->next)
-	{
-	    bpp = screen->fb.bitsPerPixel;
-	    if (bpp == 24)
-		bpp = 32;
-	    if (!depthToBpp[screen->fb.depth])
-		depthToBpp[screen->fb.depth] = bpp;
-	    else if (depthToBpp[screen->fb.depth] != bpp)
-		return FALSE;
-	}
+    for (card = kdCardInfo; card; card = card->next) {
+        for (screen = card->screenList; screen; screen = screen->next) {
+            bpp = screen->fb.bitsPerPixel;
+            if (bpp == 24)
+                bpp = 32;
+            if (!depthToBpp[screen->fb.depth])
+                depthToBpp[screen->fb.depth] = bpp;
+            else if (depthToBpp[screen->fb.depth] != bpp)
+                return FALSE;
+        }
     }
 
     /*
      * Fill in additional formats
      */
     for (i = 0; i < NUM_KD_DEPTHS; i++)
-	if (!depthToBpp[kdDepths[i].depth])
-	    depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;
+        if (!depthToBpp[kdDepths[i].depth])
+            depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;
 
-    pScreenInfo->imageByteOrder     = IMAGE_BYTE_ORDER;
+    pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
     pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
-    pScreenInfo->bitmapScanlinePad  = BITMAP_SCANLINE_PAD;
-    pScreenInfo->bitmapBitOrder     = BITMAP_BIT_ORDER;
+    pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
+    pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
 
     pScreenInfo->numPixmapFormats = 0;
 
-    for (i = 1; i <= 32; i++)
-    {
-	if (depthToBpp[i])
-	{
-	    format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];
-	    format->depth = i;
-	    format->bitsPerPixel = depthToBpp[i];
-	    format->scanlinePad = BITMAP_SCANLINE_PAD;
-	}
+    for (i = 1; i <= 32; i++) {
+        if (depthToBpp[i]) {
+            format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];
+            format->depth = i;
+            format->bitsPerPixel = depthToBpp[i];
+            format->scanlinePad = BITMAP_SCANLINE_PAD;
+        }
     }
 
     return TRUE;
 }
 
 static void
-KdAddScreen (ScreenInfo	    *pScreenInfo,
-	     KdScreenInfo   *screen,
-	     int	    argc,
-	     char	    **argv)
+KdAddScreen(ScreenInfo * pScreenInfo,
+            KdScreenInfo * screen, int argc, char **argv)
 {
-    int	    i;
+    int i;
+
     /*
      * Fill in fb visual type masks for this screen
      */
-    for (i = 0; i < pScreenInfo->numPixmapFormats; i++)
-    {
-	unsigned long	visuals;
-	Pixel		rm, gm, bm;
-
-	visuals = 0;
-	rm = gm = bm = 0;
-	if (pScreenInfo->formats[i].depth == screen->fb.depth)
-	{
-	    visuals = screen->fb.visuals;
-	    rm = screen->fb.redMask;
-	    gm = screen->fb.greenMask;
-	    bm = screen->fb.blueMask;
-	}
-	fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth,
-				  visuals,
-				  8,
-				  rm, gm, bm);
+    for (i = 0; i < pScreenInfo->numPixmapFormats; i++) {
+        unsigned long visuals;
+        Pixel rm, gm, bm;
+
+        visuals = 0;
+        rm = gm = bm = 0;
+        if (pScreenInfo->formats[i].depth == screen->fb.depth) {
+            visuals = screen->fb.visuals;
+            rm = screen->fb.redMask;
+            gm = screen->fb.greenMask;
+            bm = screen->fb.blueMask;
+        }
+        fbSetVisualTypesAndMasks(pScreenInfo->formats[i].depth,
+                                 visuals, 8, rm, gm, bm);
     }
 
     kdCurrentScreen = screen;
 
-    AddScreen (KdScreenInit, argc, argv);
+    AddScreen(KdScreenInit, argc, argv);
 }
 
-#if 0 /* This function is not used currently */
+#if 0                           /* This function is not used currently */
 
 int
-KdDepthToFb (ScreenPtr	pScreen, int depth)
+KdDepthToFb(ScreenPtr pScreen, int depth)
 {
     KdScreenPriv(pScreen);
 
     for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++)
-	if (pScreenPriv->screen->fb.depth == depth)
-	    return fb;
+        if (pScreenPriv->screen->fb.depth == depth)
+            return fb;
 }
 
 #endif
 
 static int
-KdSignalWrapper (int signum)
+KdSignalWrapper(int signum)
 {
     kdCaughtSignal = TRUE;
-    return 1; /* use generic OS layer cleanup & abort */
+    return 1;                   /* use generic OS layer cleanup & abort */
 }
 
 void
-KdInitOutput (ScreenInfo    *pScreenInfo,
-	      int	    argc,
-	      char	    **argv)
+KdInitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 {
-    KdCardInfo	    *card;
-    KdScreenInfo    *screen;
-
-    if (!kdCardInfo)
-    {
-	InitCard (0);
-	if (!(card = KdCardInfoLast ()))
-	    FatalError("No matching cards found!\n");
-	screen = KdScreenInfoAdd (card);
-	KdParseScreen (screen, 0);
+    KdCardInfo *card;
+    KdScreenInfo *screen;
+
+    if (!kdCardInfo) {
+        InitCard(0);
+        if (!(card = KdCardInfoLast()))
+            FatalError("No matching cards found!\n");
+        screen = KdScreenInfoAdd(card);
+        KdParseScreen(screen, 0);
     }
     /*
      * Initialize all of the screens for all of the cards
      */
-    for (card = kdCardInfo; card; card = card->next)
-    {
-	int ret=1;
-	if(card->cfuncs->cardinit)
-		ret=(*card->cfuncs->cardinit) (card);
-	if (ret)
-	{
-	    for (screen = card->screenList; screen; screen = screen->next)
-		KdInitScreen (pScreenInfo, screen, argc, argv);
-	}
+    for (card = kdCardInfo; card; card = card->next) {
+        int ret = 1;
+
+        if (card->cfuncs->cardinit)
+            ret = (*card->cfuncs->cardinit) (card);
+        if (ret) {
+            for (screen = card->screenList; screen; screen = screen->next)
+                KdInitScreen(pScreenInfo, screen, argc, argv);
+        }
     }
 
     /*
      * Merge the various pixmap formats together, this can fail
      * when two screens share depth but not bitsPerPixel
      */
-    if (!KdSetPixmapFormats (pScreenInfo))
-	return;
+    if (!KdSetPixmapFormats(pScreenInfo))
+        return;
 
     /*
      * Add all of the screens
      */
     for (card = kdCardInfo; card; card = card->next)
-	for (screen = card->screenList; screen; screen = screen->next)
-	    KdAddScreen (pScreenInfo, screen, argc, argv);
+        for (screen = card->screenList; screen; screen = screen->next)
+            KdAddScreen(pScreenInfo, screen, argc, argv);
 
     OsRegisterSigWrapper(KdSignalWrapper);
 }
@@ -1178,7 +1115,7 @@ DPMSSet(ClientPtr client, int level)
 }
 
 Bool
-DPMSSupported (void)
+DPMSSupported(void)
 {
     return FALSE;
 }
diff --git a/xorg-server/hw/kdrive/src/kdrive.h b/xorg-server/hw/kdrive/src/kdrive.h
index cda965d84..6c2f29309 100644
--- a/xorg-server/hw/kdrive/src/kdrive.h
+++ b/xorg-server/hw/kdrive/src/kdrive.h
@@ -56,80 +56,80 @@
 #define Status int
 
 typedef struct _KdCardInfo {
-    struct _KdCardFuncs	    *cfuncs;
-    void		    *closure;
-    void		    *driver;
-    struct _KdScreenInfo    *screenList;
-    int			    selected;
-    struct _KdCardInfo	    *next;
+    struct _KdCardFuncs *cfuncs;
+    void *closure;
+    void *driver;
+    struct _KdScreenInfo *screenList;
+    int selected;
+    struct _KdCardInfo *next;
 } KdCardInfo;
 
-extern KdCardInfo	*kdCardInfo;
+extern KdCardInfo *kdCardInfo;
 
 /*
  * Configuration information per X screen
  */
 typedef struct _KdFrameBuffer {
-    CARD8	*frameBuffer;
-    int		depth;
-    int		bitsPerPixel;
-    int		pixelStride;
-    int		byteStride;
-    Bool	shadow;
-    unsigned long   visuals;
-    Pixel       redMask, greenMask, blueMask;
-    void	*closure;
+    CARD8 *frameBuffer;
+    int depth;
+    int bitsPerPixel;
+    int pixelStride;
+    int byteStride;
+    Bool shadow;
+    unsigned long visuals;
+    Pixel redMask, greenMask, blueMask;
+    void *closure;
 } KdFrameBuffer;
 
 #define RR_Rotate_All	(RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)
 #define RR_Reflect_All	(RR_Reflect_X|RR_Reflect_Y)
 
 typedef struct _KdScreenInfo {
-    struct _KdScreenInfo    *next;
-    KdCardInfo	*card;
-    ScreenPtr	pScreen;
-    void	*driver;
-    Rotation	randr;	/* rotation and reflection */
-    int		width;
-    int		height;
-    int		rate;
-    int		width_mm;
-    int		height_mm;
-    int		subpixel_order;
-    Bool        dumb;
-    Bool        softCursor;
-    int		mynum;
-    DDXPointRec	origin;
-    KdFrameBuffer   fb;
+    struct _KdScreenInfo *next;
+    KdCardInfo *card;
+    ScreenPtr pScreen;
+    void *driver;
+    Rotation randr;             /* rotation and reflection */
+    int width;
+    int height;
+    int rate;
+    int width_mm;
+    int height_mm;
+    int subpixel_order;
+    Bool dumb;
+    Bool softCursor;
+    int mynum;
+    DDXPointRec origin;
+    KdFrameBuffer fb;
 } KdScreenInfo;
 
 typedef struct _KdCardFuncs {
-    Bool	(*cardinit) (KdCardInfo *); /* detect and map device */
-    Bool	(*scrinit) (KdScreenInfo *);/* initialize screen information */
-    Bool	(*initScreen) (ScreenPtr);  /* initialize ScreenRec */
-    Bool	(*finishInitScreen) (ScreenPtr pScreen);
-    Bool	(*createRes) (ScreenPtr);   /* create screen resources */
-    void	(*preserve) (KdCardInfo *); /* save graphics card state */
-    Bool        (*enable) (ScreenPtr);      /* set up for rendering */
-    Bool	(*dpms) (ScreenPtr, int);   /* set DPMS screen saver */
-    void        (*disable) (ScreenPtr);     /* turn off rendering */
-    void	(*restore) (KdCardInfo *);  /* restore graphics card state */
-    void	(*scrfini) (KdScreenInfo *);/* close down screen */
-    void        (*cardfini) (KdCardInfo *); /* close down */
-
-    Bool        (*initCursor) (ScreenPtr);      /* detect and map cursor */
-    void        (*enableCursor) (ScreenPtr);    /* enable cursor */
-    void        (*disableCursor) (ScreenPtr);   /* disable cursor */
-    void        (*finiCursor) (ScreenPtr);      /* close down */
-    void        (*recolorCursor) (ScreenPtr, int, xColorItem *);
-
-    Bool        (*initAccel) (ScreenPtr);
-    void        (*enableAccel) (ScreenPtr);
-    void        (*disableAccel) (ScreenPtr);
-    void        (*finiAccel) (ScreenPtr);
-
-    void        (*getColors) (ScreenPtr, int, xColorItem *);
-    void        (*putColors) (ScreenPtr, int, xColorItem *);
+    Bool (*cardinit) (KdCardInfo *);    /* detect and map device */
+    Bool (*scrinit) (KdScreenInfo *);   /* initialize screen information */
+    Bool (*initScreen) (ScreenPtr);     /* initialize ScreenRec */
+    Bool (*finishInitScreen) (ScreenPtr pScreen);
+    Bool (*createRes) (ScreenPtr);      /* create screen resources */
+    void (*preserve) (KdCardInfo *);    /* save graphics card state */
+    Bool (*enable) (ScreenPtr); /* set up for rendering */
+    Bool (*dpms) (ScreenPtr, int);      /* set DPMS screen saver */
+    void (*disable) (ScreenPtr);        /* turn off rendering */
+    void (*restore) (KdCardInfo *);     /* restore graphics card state */
+    void (*scrfini) (KdScreenInfo *);   /* close down screen */
+    void (*cardfini) (KdCardInfo *);    /* close down */
+
+    Bool (*initCursor) (ScreenPtr);     /* detect and map cursor */
+    void (*enableCursor) (ScreenPtr);   /* enable cursor */
+    void (*disableCursor) (ScreenPtr);  /* disable cursor */
+    void (*finiCursor) (ScreenPtr);     /* close down */
+    void (*recolorCursor) (ScreenPtr, int, xColorItem *);
+
+    Bool (*initAccel) (ScreenPtr);
+    void (*enableAccel) (ScreenPtr);
+    void (*disableAccel) (ScreenPtr);
+    void (*finiAccel) (ScreenPtr);
+
+    void (*getColors) (ScreenPtr, int, xColorItem *);
+    void (*putColors) (ScreenPtr, int, xColorItem *);
 
 } KdCardFuncs;
 
@@ -137,20 +137,20 @@ typedef struct _KdCardFuncs {
 #define KD_MAX_PSEUDO_SIZE	    (1 << KD_MAX_PSEUDO_DEPTH)
 
 typedef struct {
-    KdScreenInfo    *screen;
-    KdCardInfo	    *card;
+    KdScreenInfo *screen;
+    KdCardInfo *card;
 
-    Bool	    enabled;
-    Bool	    closed;
-    int		    bytesPerPixel;
+    Bool enabled;
+    Bool closed;
+    int bytesPerPixel;
 
-    int		    dpmsState;
+    int dpmsState;
 
-    ColormapPtr     pInstalledmap;                    /* current colormap */
-    xColorItem      systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
+    ColormapPtr pInstalledmap;  /* current colormap */
+    xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];       /* saved windows colors */
 
-    CreateScreenResourcesProcPtr    CreateScreenResources;
-    CloseScreenProcPtr  CloseScreen;
+    CreateScreenResourcesProcPtr CreateScreenResources;
+    CloseScreenProcPtr CloseScreen;
 } KdPrivScreenRec, *KdPrivScreenPtr;
 
 typedef enum _kdPointerState {
@@ -175,33 +175,33 @@ typedef enum _kdPointerState {
 typedef struct _KdPointerInfo KdPointerInfo;
 
 typedef struct _KdPointerDriver {
-    char                    *name;
-    Status                  (*Init)    (KdPointerInfo *);
-    Status                  (*Enable)  (KdPointerInfo *);
-    void                    (*Disable) (KdPointerInfo *);
-    void                    (*Fini)    (KdPointerInfo *);
+    char *name;
+     Status(*Init) (KdPointerInfo *);
+     Status(*Enable) (KdPointerInfo *);
+    void (*Disable) (KdPointerInfo *);
+    void (*Fini) (KdPointerInfo *);
     struct _KdPointerDriver *next;
 } KdPointerDriver;
 
 struct _KdPointerInfo {
-    DeviceIntPtr          dixdev;
-    char                  *name;
-    char                  *path;
-    char                  *protocol;
-    InputOption           *options;
-    int                   inputClass;
-
-    CARD8                 map[KD_MAX_BUTTON + 1];
-    int                   nButtons;
-    int                   nAxes;
-
-    Bool                  emulateMiddleButton;
-    unsigned long         emulationTimeout;
-    int                   emulationDx, emulationDy;
-
-    Bool                  timeoutPending;
-    KdPointerState        mouseState;
-    Bool                  eventHeld;
+    DeviceIntPtr dixdev;
+    char *name;
+    char *path;
+    char *protocol;
+    InputOption *options;
+    int inputClass;
+
+    CARD8 map[KD_MAX_BUTTON + 1];
+    int nButtons;
+    int nAxes;
+
+    Bool emulateMiddleButton;
+    unsigned long emulationTimeout;
+    int emulationDx, emulationDy;
+
+    Bool timeoutPending;
+    KdPointerState mouseState;
+    Bool eventHeld;
     struct {
         int type;
         int x;
@@ -210,26 +210,25 @@ struct _KdPointerInfo {
         int flags;
         int absrel;
     } heldEvent;
-    unsigned char         buttonState;
-    Bool                  transformCoordinates;
-    int                   pressureThreshold;
+    unsigned char buttonState;
+    Bool transformCoordinates;
+    int pressureThreshold;
 
-    KdPointerDriver       *driver;
-    void                  *driverPrivate;
+    KdPointerDriver *driver;
+    void *driverPrivate;
 
     struct _KdPointerInfo *next;
 };
 
 extern int KdCurScreen;
 
-void KdAddPointerDriver (KdPointerDriver *driver);
-void KdRemovePointerDriver (KdPointerDriver *driver);
-KdPointerInfo *KdNewPointer (void);
-void KdFreePointer (KdPointerInfo *);
-int KdAddPointer (KdPointerInfo *ki);
-int KdAddConfigPointer (char *pointer);
-void KdRemovePointer (KdPointerInfo *ki);
-
+void KdAddPointerDriver(KdPointerDriver * driver);
+void KdRemovePointerDriver(KdPointerDriver * driver);
+KdPointerInfo *KdNewPointer(void);
+void KdFreePointer(KdPointerInfo *);
+int KdAddPointer(KdPointerInfo * ki);
+int KdAddConfigPointer(char *pointer);
+void KdRemovePointer(KdPointerInfo * ki);
 
 #define KD_KEY_COUNT 248
 #define KD_MIN_KEYCODE  8
@@ -239,64 +238,64 @@ void KdRemovePointer (KdPointerInfo *ki);
 
 typedef struct {
     KeySym modsym;
-    int    modbit;
+    int modbit;
 } KdKeySymModsRec;
 
 typedef struct _KdKeyboardInfo KdKeyboardInfo;
 
 typedef struct _KdKeyboardDriver {
-    char                  *name;
-    Bool                  (*Init)    (KdKeyboardInfo *);
-    Bool                  (*Enable)  (KdKeyboardInfo *);
-    void                  (*Leds)    (KdKeyboardInfo *, int);
-    void                  (*Bell)    (KdKeyboardInfo *, int, int, int);
-    void                  (*Disable) (KdKeyboardInfo *);
-    void                  (*Fini)    (KdKeyboardInfo *);
+    char *name;
+    Bool (*Init) (KdKeyboardInfo *);
+    Bool (*Enable) (KdKeyboardInfo *);
+    void (*Leds) (KdKeyboardInfo *, int);
+    void (*Bell) (KdKeyboardInfo *, int, int, int);
+    void (*Disable) (KdKeyboardInfo *);
+    void (*Fini) (KdKeyboardInfo *);
     struct _KdKeyboardDriver *next;
 } KdKeyboardDriver;
 
 struct _KdKeyboardInfo {
     struct _KdKeyboardInfo *next;
-    DeviceIntPtr        dixdev;
-    void                *closure;
-    char                *name;
-    char                *path;
-    int                 inputClass;
-    char                *xkbRules;
-    char                *xkbModel;
-    char                *xkbLayout;
-    char                *xkbVariant;
-    char                *xkbOptions;
-    int                 LockLed;
-
-    int                 minScanCode;
-    int                 maxScanCode;
-
-    int                 leds;
-    int                 bellPitch;
-    int                 bellDuration;
-    InputOption         *options;
-
-    KdKeyboardDriver    *driver;
-    void                *driverPrivate;
+    DeviceIntPtr dixdev;
+    void *closure;
+    char *name;
+    char *path;
+    int inputClass;
+    char *xkbRules;
+    char *xkbModel;
+    char *xkbLayout;
+    char *xkbVariant;
+    char *xkbOptions;
+    int LockLed;
+
+    int minScanCode;
+    int maxScanCode;
+
+    int leds;
+    int bellPitch;
+    int bellDuration;
+    InputOption *options;
+
+    KdKeyboardDriver *driver;
+    void *driverPrivate;
 };
 
-void KdAddKeyboardDriver (KdKeyboardDriver *driver);
-void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);
-KdKeyboardInfo *KdNewKeyboard (void);
-void KdFreeKeyboard (KdKeyboardInfo *ki);
-int KdAddConfigKeyboard (char *pointer);
-int KdAddKeyboard (KdKeyboardInfo *ki);
-void KdRemoveKeyboard (KdKeyboardInfo *ki);
+void KdAddKeyboardDriver(KdKeyboardDriver * driver);
+void KdRemoveKeyboardDriver(KdKeyboardDriver * driver);
+KdKeyboardInfo *KdNewKeyboard(void);
+void KdFreeKeyboard(KdKeyboardInfo * ki);
+int KdAddConfigKeyboard(char *pointer);
+int KdAddKeyboard(KdKeyboardInfo * ki);
+void KdRemoveKeyboard(KdKeyboardInfo * ki);
 
 typedef struct _KdOsFuncs {
-    int		    (*Init) (void);
-    void	    (*Enable) (void);
-    Bool	    (*SpecialKey) (KeySym);
-    void	    (*Disable) (void);
-    void	    (*Fini) (void);
-    void	    (*pollEvents) (void);
-    void            (*Bell) (int, int, int);
+    int (*Init) (void);
+    void (*Enable) (void);
+    Bool (*SpecialKey) (KeySym);
+    void (*Disable) (void);
+    void (*Fini) (void);
+    void (*pollEvents) (void);
+    void (*Bell) (int, int, int);
 } KdOsFuncs;
 
 typedef enum _KdSyncPolarity {
@@ -305,28 +304,28 @@ typedef enum _KdSyncPolarity {
 
 typedef struct _KdMonitorTiming {
     /* label */
-    int		    horizontal;
-    int		    vertical;
-    int		    rate;
+    int horizontal;
+    int vertical;
+    int rate;
     /* pixel clock */
-    int		    clock;  /* in KHz */
+    int clock;                  /* in KHz */
     /* horizontal timing */
-    int		    hfp;    /* front porch */
-    int		    hbp;    /* back porch */
-    int		    hblank; /* blanking */
-    KdSyncPolarity  hpol;   /* polarity */
+    int hfp;                    /* front porch */
+    int hbp;                    /* back porch */
+    int hblank;                 /* blanking */
+    KdSyncPolarity hpol;        /* polarity */
     /* vertical timing */
-    int		    vfp;    /* front porch */
-    int		    vbp;    /* back porch */
-    int		    vblank; /* blanking */
-    KdSyncPolarity  vpol;   /* polarity */
+    int vfp;                    /* front porch */
+    int vbp;                    /* back porch */
+    int vblank;                 /* blanking */
+    KdSyncPolarity vpol;        /* polarity */
 } KdMonitorTiming;
 
-extern const KdMonitorTiming	kdMonitorTimings[];
-extern const int		kdNumMonitorTimings;
+extern const KdMonitorTiming kdMonitorTimings[];
+extern const int kdNumMonitorTimings;
 
 typedef struct _KdPointerMatrix {
-    int	    matrix[2][3];
+    int matrix[2][3];
 } KdPointerMatrix;
 
 /*
@@ -342,18 +341,19 @@ typedef struct _KdPointerMatrix {
     (PixmapWidthPaddingInfo[d].padRoundUp+1)))
 #endif
 
-extern DevPrivateKeyRec	kdScreenPrivateKeyRec;
+extern DevPrivateKeyRec kdScreenPrivateKeyRec;
+
 #define kdScreenPrivateKey (&kdScreenPrivateKeyRec)
 
-extern unsigned long	kdGeneration;
-extern Bool		kdEnabled;
-extern Bool		kdSwitchPending;
-extern Bool		kdEmulateMiddleButton;
-extern Bool		kdDisableZaphod;
-extern Bool		kdAllowZap;
-extern int		kdVirtualTerminal;
-extern char		*kdSwitchCmd;
-extern KdOsFuncs	*kdOsFuncs;
+extern unsigned long kdGeneration;
+extern Bool kdEnabled;
+extern Bool kdSwitchPending;
+extern Bool kdEmulateMiddleButton;
+extern Bool kdDisableZaphod;
+extern Bool kdAllowZap;
+extern int kdVirtualTerminal;
+extern char *kdSwitchCmd;
+extern KdOsFuncs *kdOsFuncs;
 
 #define KdGetScreenPriv(pScreen) ((KdPrivScreenPtr) \
     dixLookupPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey))
@@ -363,158 +363,142 @@ extern KdOsFuncs	*kdOsFuncs;
 
 /* kcmap.c */
 void
-KdSetColormap (ScreenPtr pScreen);
+ KdSetColormap(ScreenPtr pScreen);
 
 void
-KdEnableColormap (ScreenPtr pScreen);
+ KdEnableColormap(ScreenPtr pScreen);
 
 void
-KdDisableColormap (ScreenPtr pScreen);
+ KdDisableColormap(ScreenPtr pScreen);
 
 void
-KdInstallColormap (ColormapPtr pCmap);
+ KdInstallColormap(ColormapPtr pCmap);
 
 void
-KdUninstallColormap (ColormapPtr pCmap);
+ KdUninstallColormap(ColormapPtr pCmap);
 
 int
-KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps);
+ KdListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmaps);
 
 void
-KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs);
+ KdStoreColors(ColormapPtr pCmap, int ndef, xColorItem * pdefs);
 
 /* kdrive.c */
 extern miPointerScreenFuncRec kdPointerScreenFuncs;
 
 void
-KdDisableScreen (ScreenPtr pScreen);
+ KdDisableScreen(ScreenPtr pScreen);
 
 void
-KdDisableScreens (void);
+ KdDisableScreens(void);
 
 Bool
-KdEnableScreen (ScreenPtr pScreen);
+ KdEnableScreen(ScreenPtr pScreen);
 
 void
-KdEnableScreens (void);
+ KdEnableScreens(void);
 
 void
-KdSuspend (void);
+ KdSuspend(void);
 
 void
-KdResume (void);
+ KdResume(void);
 
 void
-KdProcessSwitch (void);
+ KdProcessSwitch(void);
 
-Rotation
-KdAddRotation (Rotation a, Rotation b);
+Rotation KdAddRotation(Rotation a, Rotation b);
 
-Rotation
-KdSubRotation (Rotation a, Rotation b);
+Rotation KdSubRotation(Rotation a, Rotation b);
 
 void
-KdParseScreen (KdScreenInfo *screen,
-	       char	    *arg);
+ KdParseScreen(KdScreenInfo * screen, char *arg);
 
-KdPointerInfo *
-KdParsePointer (char *arg);
+KdPointerInfo *KdParsePointer(char *arg);
 
-KdKeyboardInfo *
-KdParseKeyboard (char *arg);
+KdKeyboardInfo *KdParseKeyboard(char *arg);
 
-char *
-KdParseFindNext (char *cur, const char *delim, char *save, char *last);
+char *KdParseFindNext(char *cur, const char *delim, char *save, char *last);
 
 void
-KdParseRgba (char *rgba);
+ KdParseRgba(char *rgba);
 
 void
-KdUseMsg (void);
+ KdUseMsg(void);
 
 int
-KdProcessArgument (int argc, char **argv, int i);
+ KdProcessArgument(int argc, char **argv, int i);
 
 void
-KdOsInit (KdOsFuncs *pOsFuncs);
+ KdOsInit(KdOsFuncs * pOsFuncs);
 
 void
-KdOsAddInputDrivers (void);
+ KdOsAddInputDrivers(void);
 
 Bool
-KdAllocatePrivates (ScreenPtr pScreen);
+ KdAllocatePrivates(ScreenPtr pScreen);
 
 Bool
-KdCreateScreenResources (ScreenPtr pScreen);
+ KdCreateScreenResources(ScreenPtr pScreen);
 
 Bool
-KdCloseScreen (int index, ScreenPtr pScreen);
+ KdCloseScreen(int index, ScreenPtr pScreen);
 
 Bool
-KdSaveScreen (ScreenPtr pScreen, int on);
+ KdSaveScreen(ScreenPtr pScreen, int on);
 
 Bool
-KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);
+ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);
 
 void
-KdInitScreen (ScreenInfo    *pScreenInfo,
-	      KdScreenInfo  *screen,
-	      int	    argc,
-	      char	    **argv);
+
+KdInitScreen(ScreenInfo * pScreenInfo,
+             KdScreenInfo * screen, int argc, char **argv);
 
 void
-KdInitCard (ScreenInfo	    *pScreenInfo,
-	    KdCardInfo	    *card,
-	    int		    argc,
-	    char	    **argv);
+ KdInitCard(ScreenInfo * pScreenInfo, KdCardInfo * card, int argc, char **argv);
 
 void
-KdInitOutput (ScreenInfo    *pScreenInfo,
-	      int	    argc,
-	      char	    **argv);
+ KdInitOutput(ScreenInfo * pScreenInfo, int argc, char **argv);
 
 void
-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);
+ KdSetSubpixelOrder(ScreenPtr pScreen, Rotation randr);
 
 void
-KdBacktrace (int signum);
+ KdBacktrace(int signum);
 
 /* kinfo.c */
-KdCardInfo *
-KdCardInfoAdd (KdCardFuncs  *funcs,
-	       void	    *closure);
+KdCardInfo *KdCardInfoAdd(KdCardFuncs * funcs, void *closure);
 
-KdCardInfo *
-KdCardInfoLast (void);
+KdCardInfo *KdCardInfoLast(void);
 
 void
-KdCardInfoDispose (KdCardInfo *ci);
+ KdCardInfoDispose(KdCardInfo * ci);
 
-KdScreenInfo *
-KdScreenInfoAdd (KdCardInfo *ci);
+KdScreenInfo *KdScreenInfoAdd(KdCardInfo * ci);
 
 void
-KdScreenInfoDispose (KdScreenInfo *si);
-
+ KdScreenInfoDispose(KdScreenInfo * si);
 
 /* kinput.c */
 void
-KdInitInput(void);
+ KdInitInput(void);
 void
-KdCloseInput(void);
+ KdCloseInput(void);
 
 Bool
-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);
+ KdRegisterFd(int fd, void (*read) (int fd, void *closure), void *closure);
 
 void
-KdUnregisterFds (void *closure, Bool do_close);
+ KdUnregisterFds(void *closure, Bool do_close);
 
 void
-KdUnregisterFd (void *closure, int fd, Bool do_close);
+ KdUnregisterFd(void *closure, int fd, Bool do_close);
 
 void
-KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
-                    unsigned char is_up);
+
+KdEnqueueKeyboardEvent(KdKeyboardInfo * ki, unsigned char scan_code,
+                       unsigned char is_up);
 
 #define KD_BUTTON_1	0x01
 #define KD_BUTTON_2	0x02
@@ -525,97 +509,96 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
 #define KD_MOUSE_DELTA	0x80000000
 
 void
-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+
+KdEnqueuePointerEvent(KdPointerInfo * pi, unsigned long flags, int rx, int ry,
                       int rz);
 
 void
-_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,
+
+_KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
                        int b, int absrel, Bool force);
 
 void
-KdReleaseAllKeys (void);
+ KdReleaseAllKeys(void);
 
 void
-KdSetLed (KdKeyboardInfo *ki, int led, Bool on);
+ KdSetLed(KdKeyboardInfo * ki, int led, Bool on);
 
 void
-KdSetPointerMatrix (KdPointerMatrix *pointer);
+ KdSetPointerMatrix(KdPointerMatrix * pointer);
 
 void
-KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);
+
+KdComputePointerMatrix(KdPointerMatrix * pointer, Rotation randr, int width,
+                       int height);
 
 void
-KdScreenToPointerCoords (int *x, int *y);
+ KdScreenToPointerCoords(int *x, int *y);
 
 void
-KdBlockHandler (int		screen,
-		pointer		blockData,
-		pointer		timeout,
-		pointer		readmask);
+
+KdBlockHandler(int screen,
+               pointer blockData, pointer timeout, pointer readmask);
 
 void
-KdWakeupHandler (int		screen,
-		 pointer    	data,
-		 unsigned long	result,
-		 pointer	readmask);
+
+KdWakeupHandler(int screen,
+                pointer data, unsigned long result, pointer readmask);
 
 void
-KdDisableInput (void);
+ KdDisableInput(void);
 
 void
-KdEnableInput (void);
+ KdEnableInput(void);
 
 void
-ProcessInputEvents (void);
+ ProcessInputEvents(void);
 
 void
-KdRingBell (KdKeyboardInfo      *ki,
-            int                 volume,
-            int                 pitch,
-            int                 duration);
+ KdRingBell(KdKeyboardInfo * ki, int volume, int pitch, int duration);
 
 /* kmode.c */
-const KdMonitorTiming *
-KdFindMode (KdScreenInfo    *screen,
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *));
+const KdMonitorTiming *KdFindMode(KdScreenInfo * screen,
+                                  Bool (*supported) (KdScreenInfo *,
+                                                     const KdMonitorTiming *));
 
 Bool
-KdTuneMode (KdScreenInfo    *screen,
-	    Bool	    (*usable) (KdScreenInfo *),
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *));
+
+KdTuneMode(KdScreenInfo * screen,
+           Bool (*usable) (KdScreenInfo *),
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *));
 
 #ifdef RANDR
 Bool
-KdRandRGetInfo (ScreenPtr pScreen,
-		int randr,
-		Bool (*supported) (ScreenPtr pScreen,
-				   const KdMonitorTiming *));
-
-const KdMonitorTiming *
-KdRandRGetTiming (ScreenPtr	    pScreen,
-		  Bool		    (*supported) (ScreenPtr pScreen,
-						  const KdMonitorTiming *),
-		  int		    rate,
-		  RRScreenSizePtr   pSize);
+
+KdRandRGetInfo(ScreenPtr pScreen,
+               int randr,
+               Bool (*supported) (ScreenPtr pScreen, const KdMonitorTiming *));
+
+const KdMonitorTiming *KdRandRGetTiming(ScreenPtr pScreen,
+                                        Bool (*supported) (ScreenPtr pScreen,
+                                                           const KdMonitorTiming
+                                                           *), int rate,
+                                        RRScreenSizePtr pSize);
 #endif
 
 /* kshadow.c */
 Bool
-KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate);
+ KdShadowFbAlloc(KdScreenInfo * screen, Bool rotate);
 
 void
-KdShadowFbFree (KdScreenInfo *screen);
+ KdShadowFbFree(KdScreenInfo * screen);
 
 Bool
-KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window);
+
+KdShadowSet(ScreenPtr pScreen, int randr, ShadowUpdateProc update,
+            ShadowWindowProc window);
 
 void
-KdShadowUnset (ScreenPtr pScreen);
+ KdShadowUnset(ScreenPtr pScreen);
 
 /* function prototypes to be implemented by the drivers */
 void
-InitCard (char *name);
+ InitCard(char *name);
 
-#endif /* _KDRIVE_H_ */
+#endif                          /* _KDRIVE_H_ */
diff --git a/xorg-server/hw/kdrive/src/kinfo.c b/xorg-server/hw/kdrive/src/kinfo.c
index 0055b16db..01ae1e491 100644
--- a/xorg-server/hw/kdrive/src/kinfo.c
+++ b/xorg-server/hw/kdrive/src/kinfo.c
@@ -25,17 +25,16 @@
 #endif
 #include "kdrive.h"
 
-KdCardInfo  *kdCardInfo;
+KdCardInfo *kdCardInfo;
 
 KdCardInfo *
-KdCardInfoAdd (KdCardFuncs  *funcs,
-	       void	    *closure)
+KdCardInfoAdd(KdCardFuncs * funcs, void *closure)
 {
-    KdCardInfo	*ci, **prev;
+    KdCardInfo *ci, **prev;
 
-    ci = calloc(1, sizeof (KdCardInfo));
+    ci = calloc(1, sizeof(KdCardInfo));
     if (!ci)
-	return 0;
+        return 0;
     for (prev = &kdCardInfo; *prev; prev = &(*prev)->next);
     *prev = ci;
     ci->cfuncs = funcs;
@@ -47,39 +46,38 @@ KdCardInfoAdd (KdCardFuncs  *funcs,
 }
 
 KdCardInfo *
-KdCardInfoLast (void)
+KdCardInfoLast(void)
 {
-    KdCardInfo	*ci;
+    KdCardInfo *ci;
 
     if (!kdCardInfo)
-	return 0;
+        return 0;
     for (ci = kdCardInfo; ci->next; ci = ci->next);
     return ci;
 }
 
 void
-KdCardInfoDispose (KdCardInfo *ci)
+KdCardInfoDispose(KdCardInfo * ci)
 {
-    KdCardInfo	**prev;
+    KdCardInfo **prev;
 
     for (prev = &kdCardInfo; *prev; prev = &(*prev)->next)
-	if (*prev == ci)
-	{
-	    *prev = ci->next;
-	    free(ci);
-	    break;
-	}
+        if (*prev == ci) {
+            *prev = ci->next;
+            free(ci);
+            break;
+        }
 }
 
 KdScreenInfo *
-KdScreenInfoAdd (KdCardInfo *ci)
+KdScreenInfoAdd(KdCardInfo * ci)
 {
-    KdScreenInfo    *si, **prev;
-    int		    n;
+    KdScreenInfo *si, **prev;
+    int n;
 
-    si = calloc(1, sizeof (KdScreenInfo));
+    si = calloc(1, sizeof(KdScreenInfo));
     if (!si)
-	return 0;
+        return 0;
     for (prev = &ci->screenList, n = 0; *prev; prev = &(*prev)->next, n++);
     *prev = si;
     si->next = 0;
@@ -89,30 +87,29 @@ KdScreenInfoAdd (KdCardInfo *ci)
 }
 
 void
-KdScreenInfoDispose (KdScreenInfo *si)
+KdScreenInfoDispose(KdScreenInfo * si)
 {
-    KdCardInfo	    *ci = si->card;
-    KdScreenInfo    **prev;
+    KdCardInfo *ci = si->card;
+    KdScreenInfo **prev;
 
     for (prev = &ci->screenList; *prev; prev = &(*prev)->next) {
-	if (*prev == si)
-	{
-	    *prev = si->next;
-	    free(si);
-	    if (!ci->screenList)
-		KdCardInfoDispose (ci);
-	    break;
-	}
+        if (*prev == si) {
+            *prev = si->next;
+            free(si);
+            if (!ci->screenList)
+                KdCardInfoDispose(ci);
+            break;
+        }
     }
 }
 
 KdPointerInfo *
-KdNewPointer (void)
+KdNewPointer(void)
 {
     KdPointerInfo *pi;
     int i;
 
-    pi = (KdPointerInfo *)calloc(1, sizeof(KdPointerInfo));
+    pi = (KdPointerInfo *) calloc(1, sizeof(KdPointerInfo));
     if (!pi)
         return NULL;
 
@@ -132,7 +129,7 @@ KdNewPointer (void)
 }
 
 void
-KdFreePointer(KdPointerInfo *pi)
+KdFreePointer(KdPointerInfo * pi)
 {
     free(pi->name);
     free(pi->path);
@@ -141,7 +138,7 @@ KdFreePointer(KdPointerInfo *pi)
 }
 
 void
-KdFreeKeyboard(KdKeyboardInfo *ki)
+KdFreeKeyboard(KdKeyboardInfo * ki)
 {
     free(ki->name);
     free(ki->path);
diff --git a/xorg-server/hw/kdrive/src/kinput.c b/xorg-server/hw/kdrive/src/kinput.c
index 968ebb159..e16fe78f2 100644
--- a/xorg-server/hw/kdrive/src/kinput.c
+++ b/xorg-server/hw/kdrive/src/kinput.c
@@ -35,14 +35,14 @@
 #include <signal.h>
 #include <stdio.h>
 #ifdef sun
-#include <sys/file.h> /* needed for FNONBLOCK & FASYNC */
+#include <sys/file.h>           /* needed for FNONBLOCK & FASYNC */
 #endif
 
 #include "xkbsrv.h"
 
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "XIstubs.h" /* even though we don't use stubs.  cute, no? */
+#include "XIstubs.h"            /* even though we don't use stubs.  cute, no? */
 #include "exevents.h"
 #include "extinit.h"
 #include "exglobals.h"
@@ -59,79 +59,80 @@ struct KdConfigDevice {
 };
 
 /* kdKeyboards and kdPointers hold all the real devices. */
-static KdKeyboardInfo *kdKeyboards         = NULL;
-static KdPointerInfo  *kdPointers          = NULL;
-static struct KdConfigDevice *kdConfigKeyboards   = NULL;
-static struct KdConfigDevice *kdConfigPointers    = NULL;
+static KdKeyboardInfo *kdKeyboards = NULL;
+static KdPointerInfo *kdPointers = NULL;
+static struct KdConfigDevice *kdConfigKeyboards = NULL;
+static struct KdConfigDevice *kdConfigPointers = NULL;
 
 static KdKeyboardDriver *kdKeyboardDrivers = NULL;
-static KdPointerDriver  *kdPointerDrivers  = NULL;
-
-static Bool		kdInputEnabled;
-static Bool		kdOffScreen;
-static unsigned long	kdOffScreenTime;
-static KdPointerMatrix	kdPointerMatrix = {
-   { { 1, 0, 0 },
-     { 0, 1, 0 } }
+static KdPointerDriver *kdPointerDrivers = NULL;
+
+static Bool kdInputEnabled;
+static Bool kdOffScreen;
+static unsigned long kdOffScreenTime;
+
+static KdPointerMatrix kdPointerMatrix = {
+    {{1, 0, 0},
+     {0, 1, 0}}
 };
 
-void KdResetInputMachine (void);
+void KdResetInputMachine(void);
 
 #define KD_MAX_INPUT_FDS    8
 
 typedef struct _kdInputFd {
-    int	        fd;
-    void        (*read) (int fd, void *closure);
-    int	        (*enable) (int fd, void *closure);
-    void        (*disable) (int fd, void *closure);
-    void        *closure;
+    int fd;
+    void (*read) (int fd, void *closure);
+    int (*enable) (int fd, void *closure);
+    void (*disable) (int fd, void *closure);
+    void *closure;
 } KdInputFd;
 
 static KdInputFd kdInputFds[KD_MAX_INPUT_FDS];
-static int	 kdNumInputFds;
+static int kdNumInputFds;
 
-extern Bool      kdRawPointerCoordinates;
+extern Bool kdRawPointerCoordinates;
 
 static void
-KdSigio (int sig)
+KdSigio(int sig)
 {
-    int	i;
+    int i;
 
     for (i = 0; i < kdNumInputFds; i++)
-	(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+        (*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
 }
 
 static void
-KdBlockSigio (void)
+KdBlockSigio(void)
 {
-    sigset_t	set;
+    sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_BLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_BLOCK, &set, 0);
 }
 
 static void
-KdUnblockSigio (void)
+KdUnblockSigio(void)
 {
-    sigset_t	set;
+    sigset_t set;
 
-    sigemptyset (&set);
-    sigaddset (&set, SIGIO);
-    sigprocmask (SIG_UNBLOCK, &set, 0);
+    sigemptyset(&set);
+    sigaddset(&set, SIGIO);
+    sigprocmask(SIG_UNBLOCK, &set, 0);
 }
 
 #ifdef DEBUG_SIGIO
 
 void
-KdAssertSigioBlocked (char *where)
+KdAssertSigioBlocked(char *where)
 {
-    sigset_t	set, old;
+    sigset_t set, old;
 
-    sigemptyset (&set);
-    sigprocmask (SIG_BLOCK, &set, &old);
-    if (!sigismember (&old, SIGIO)) {
-	ErrorF ("SIGIO not blocked at %s\n", where);
+    sigemptyset(&set);
+    sigprocmask(SIG_BLOCK, &set, &old);
+    if (!sigismember(&old, SIGIO)) {
+        ErrorF("SIGIO not blocked at %s\n", where);
         KdBacktrace(0);
     }
 }
@@ -142,7 +143,7 @@ KdAssertSigioBlocked (char *where)
 
 #endif
 
-static int  kdnFds;
+static int kdnFds;
 
 #ifdef FNONBLOCK
 #define NOBLOCK FNONBLOCK
@@ -151,7 +152,7 @@ static int  kdnFds;
 #endif
 
 void
-KdResetInputMachine (void)
+KdResetInputMachine(void)
 {
     KdPointerInfo *pi;
 
@@ -162,60 +163,60 @@ KdResetInputMachine (void)
 }
 
 static void
-KdNonBlockFd (int fd)
+KdNonBlockFd(int fd)
 {
-    int	flags;
-    flags = fcntl (fd, F_GETFL);
-    flags |= FASYNC|NOBLOCK;
-    fcntl (fd, F_SETFL, flags);
+    int flags;
+
+    flags = fcntl(fd, F_GETFL);
+    flags |= FASYNC | NOBLOCK;
+    fcntl(fd, F_SETFL, flags);
 }
 
 static void
-KdAddFd (int fd)
+KdAddFd(int fd)
 {
-    struct sigaction	act;
-    sigset_t		set;
+    struct sigaction act;
+    sigset_t set;
 
     kdnFds++;
-    fcntl (fd, F_SETOWN, getpid());
-    KdNonBlockFd (fd);
-    AddEnabledDevice (fd);
-    memset (&act, '\0', sizeof act);
+    fcntl(fd, F_SETOWN, getpid());
+    KdNonBlockFd(fd);
+    AddEnabledDevice(fd);
+    memset(&act, '\0', sizeof act);
     act.sa_handler = KdSigio;
-    sigemptyset (&act.sa_mask);
-    sigaddset (&act.sa_mask, SIGIO);
-    sigaddset (&act.sa_mask, SIGALRM);
-    sigaddset (&act.sa_mask, SIGVTALRM);
-    sigaction (SIGIO, &act, 0);
-    sigemptyset (&set);
-    sigprocmask (SIG_SETMASK, &set, 0);
+    sigemptyset(&act.sa_mask);
+    sigaddset(&act.sa_mask, SIGIO);
+    sigaddset(&act.sa_mask, SIGALRM);
+    sigaddset(&act.sa_mask, SIGVTALRM);
+    sigaction(SIGIO, &act, 0);
+    sigemptyset(&set);
+    sigprocmask(SIG_SETMASK, &set, 0);
 }
 
 static void
-KdRemoveFd (int fd)
+KdRemoveFd(int fd)
 {
-    struct sigaction	act;
-    int			flags;
+    struct sigaction act;
+    int flags;
 
     kdnFds--;
-    RemoveEnabledDevice (fd);
-    flags = fcntl (fd, F_GETFL);
-    flags &= ~(FASYNC|NOBLOCK);
-    fcntl (fd, F_SETFL, flags);
-    if (kdnFds == 0)
-    {
-	memset (&act, '\0', sizeof act);
-	act.sa_handler = SIG_IGN;
-	sigemptyset (&act.sa_mask);
-	sigaction (SIGIO, &act, 0);
+    RemoveEnabledDevice(fd);
+    flags = fcntl(fd, F_GETFL);
+    flags &= ~(FASYNC | NOBLOCK);
+    fcntl(fd, F_SETFL, flags);
+    if (kdnFds == 0) {
+        memset(&act, '\0', sizeof act);
+        act.sa_handler = SIG_IGN;
+        sigemptyset(&act.sa_mask);
+        sigaction(SIGIO, &act, 0);
     }
 }
 
 Bool
-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)
+KdRegisterFd(int fd, void (*read) (int fd, void *closure), void *closure)
 {
     if (kdNumInputFds == KD_MAX_INPUT_FDS)
-	return FALSE;
+        return FALSE;
     kdInputFds[kdNumInputFds].fd = fd;
     kdInputFds[kdNumInputFds].read = read;
     kdInputFds[kdNumInputFds].enable = 0;
@@ -223,38 +224,38 @@ KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)
     kdInputFds[kdNumInputFds].closure = closure;
     kdNumInputFds++;
     if (kdInputEnabled)
-	KdAddFd (fd);
+        KdAddFd(fd);
     return TRUE;
 }
 
 void
-KdUnregisterFd (void *closure, int fd, Bool do_close)
+KdUnregisterFd(void *closure, int fd, Bool do_close)
 {
-    int	i, j;
+    int i, j;
 
     for (i = 0; i < kdNumInputFds; i++) {
-	if (kdInputFds[i].closure == closure &&
+        if (kdInputFds[i].closure == closure &&
             (fd == -1 || kdInputFds[i].fd == fd)) {
-	    if (kdInputEnabled)
-		KdRemoveFd (kdInputFds[i].fd);
-	    if (do_close)
-		close (kdInputFds[i].fd);
-	    kdNumInputFds--;
-	    for (j = i; j < kdNumInputFds; j++)
-		kdInputFds[j] = kdInputFds[j+1];
+            if (kdInputEnabled)
+                KdRemoveFd(kdInputFds[i].fd);
+            if (do_close)
+                close(kdInputFds[i].fd);
+            kdNumInputFds--;
+            for (j = i; j < kdNumInputFds; j++)
+                kdInputFds[j] = kdInputFds[j + 1];
             break;
-	}
+        }
     }
 }
 
 void
-KdUnregisterFds (void *closure, Bool do_close)
+KdUnregisterFds(void *closure, Bool do_close)
 {
     KdUnregisterFd(closure, -1, do_close);
 }
 
 void
-KdDisableInput (void)
+KdDisableInput(void)
 {
     KdKeyboardInfo *ki;
     KdPointerInfo *pi;
@@ -283,7 +284,7 @@ KdDisableInput (void)
                     ErrorF("    fd %d belongs to keybd driver %s\n",
                            kdInputFds[i].fd,
                            ki->driver && ki->driver->name ?
-                             ki->driver->name : "(unnamed!)");
+                           ki->driver->name : "(unnamed!)");
                     found = 1;
                     break;
                 }
@@ -299,7 +300,7 @@ KdDisableInput (void)
                     ErrorF("    fd %d belongs to pointer driver %s\n",
                            kdInputFds[i].fd,
                            pi->driver && pi->driver->name ?
-                             pi->driver->name : "(unnamed!)");
+                           pi->driver->name : "(unnamed!)");
                     break;
                 }
             }
@@ -319,7 +320,7 @@ KdDisableInput (void)
 }
 
 void
-KdEnableInput (void)
+KdEnableInput(void)
 {
     InternalEvent ev;
     KdKeyboardInfo *ki;
@@ -338,14 +339,15 @@ KdEnableInput (void)
     }
 
     /* reset screen saver */
-    ev.any.time = GetTimeInMillis ();
-    NoticeEventTime (&ev);
+    ev.any.time = GetTimeInMillis();
+    NoticeEventTime(&ev, pi->dixdev);
+    NoticeEventTime(&ev, ki->dixdev);
 
-    KdUnblockSigio ();
+    KdUnblockSigio();
 }
 
 static KdKeyboardDriver *
-KdFindKeyboardDriver (const char *name)
+KdFindKeyboardDriver(const char *name)
 {
     KdKeyboardDriver *ret;
 
@@ -362,7 +364,7 @@ KdFindKeyboardDriver (const char *name)
 }
 
 static KdPointerDriver *
-KdFindPointerDriver (const char *name)
+KdFindPointerDriver(const char *name)
 {
     KdPointerDriver *ret;
 
@@ -381,14 +383,14 @@ KdFindPointerDriver (const char *name)
 static int
 KdPointerProc(DeviceIntPtr pDevice, int onoff)
 {
-    DevicePtr       pDev = (DevicePtr)pDevice;
-    KdPointerInfo   *pi;
-    Atom            xiclass;
-    Atom            *btn_labels;
-    Atom            *axes_labels;
+    DevicePtr pDev = (DevicePtr) pDevice;
+    KdPointerInfo *pi;
+    Atom xiclass;
+    Atom *btn_labels;
+    Atom *axes_labels;
 
     if (!pDev)
-	return BadImplementation;
+        return BadImplementation;
 
     for (pi = kdPointers; pi; pi = pi->next) {
         if (pi->dixdev && pi->dixdev->id == pDevice->id)
@@ -401,8 +403,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         return BadImplementation;
     }
 
-    switch (onoff)
-    {
+    switch (onoff) {
     case DEVICE_INIT:
 #ifdef DEBUG
         ErrorF("initialising pointer %s ...\n", pi->name);
@@ -433,44 +434,43 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
             return !Success;
         }
 
-	btn_labels = calloc(pi->nButtons, sizeof(Atom));
-	if (!btn_labels)
-	    return BadAlloc;
-	axes_labels = calloc(pi->nAxes, sizeof(Atom));
-	if (!axes_labels) {
-	    free(btn_labels);
-	    return BadAlloc;
-	}
-
-	switch(pi->nAxes)
-	{
-	    default:
-	    case 7:
-		btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
-	    case 6:
-		btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
-	    case 5:
-		btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
-	    case 4:
-		btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
-	    case 3:
-		btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
-	    case 2:
-		btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
-	    case 1:
-		btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
-	    case 0:
-		break;
-	}
-
-	if (pi->nAxes >= 2) {
-	    axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
-	    axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
-	}
-
-	InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,
-	    (PtrCtrlProcPtr)NoopDDA,
-	    GetMotionHistorySize(), pi->nAxes, axes_labels);
+        btn_labels = calloc(pi->nButtons, sizeof(Atom));
+        if (!btn_labels)
+            return BadAlloc;
+        axes_labels = calloc(pi->nAxes, sizeof(Atom));
+        if (!axes_labels) {
+            free(btn_labels);
+            return BadAlloc;
+        }
+
+        switch (pi->nAxes) {
+        default:
+        case 7:
+            btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+        case 6:
+            btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+        case 5:
+            btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+        case 4:
+            btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
+        case 3:
+            btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
+        case 2:
+            btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
+        case 1:
+            btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
+        case 0:
+            break;
+        }
+
+        if (pi->nAxes >= 2) {
+            axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
+            axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
+        }
+
+        InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,
+                                (PtrCtrlProcPtr) NoopDDA,
+                                GetMotionHistorySize(), pi->nAxes, axes_labels);
 
         free(btn_labels);
         free(axes_labels);
@@ -485,7 +485,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         AssignTypeAndName(pi->dixdev, xiclass,
                           pi->name ? pi->name : "Generic KDrive Pointer");
 
-	return Success;
+        return Success;
 
     case DEVICE_ON:
         if (pDev->on == TRUE)
@@ -504,7 +504,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
             return BadImplementation;
         }
 
-	return Success;
+        return Success;
 
     case DEVICE_OFF:
         if (pDev->on == FALSE) {
@@ -523,7 +523,7 @@ KdPointerProc(DeviceIntPtr pDevice, int onoff)
         return Success;
 
     case DEVICE_CLOSE:
-	if (pDev->on) {
+        if (pDev->on) {
             if (!pi->driver->Disable) {
                 return BadImplementation;
             }
@@ -552,7 +552,7 @@ LegalModifier(unsigned int key, DeviceIntPtr pDev)
 }
 
 static void
-KdBell (int volume, DeviceIntPtr pDev, pointer arg, int something)
+KdBell(int volume, DeviceIntPtr pDev, pointer arg, int something)
 {
     KeybdCtrl *ctrl = arg;
     KdKeyboardInfo *ki = NULL;
@@ -574,7 +574,7 @@ DDXRingBell(int volume, int pitch, int duration)
     KdKeyboardInfo *ki = NULL;
 
     if (kdOsFuncs->Bell) {
-        (*kdOsFuncs->Bell)(volume, pitch, duration);
+        (*kdOsFuncs->Bell) (volume, pitch, duration);
     }
     else {
         for (ki = kdKeyboards; ki; ki = ki->next) {
@@ -585,7 +585,7 @@ DDXRingBell(int volume, int pitch, int duration)
 }
 
 void
-KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)
+KdRingBell(KdKeyboardInfo * ki, int volume, int pitch, int duration)
 {
     if (!ki || !ki->driver || !ki->driver->Bell)
         return;
@@ -594,9 +594,8 @@ KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)
         (*ki->driver->Bell) (ki, volume, pitch, duration);
 }
 
-
 static void
-KdSetLeds (KdKeyboardInfo *ki, int leds)
+KdSetLeds(KdKeyboardInfo * ki, int leds)
 {
     if (!ki || !ki->driver)
         return;
@@ -608,75 +607,85 @@ KdSetLeds (KdKeyboardInfo *ki, int leds)
 }
 
 void
-KdSetLed (KdKeyboardInfo *ki, int led, Bool on)
+KdSetLed(KdKeyboardInfo * ki, int led, Bool on)
 {
     if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed)
         return;
 
-    NoteLedState (ki->dixdev, led, on);
-    KdSetLeds (ki, ki->dixdev->kbdfeed->ctrl.leds);
+    NoteLedState(ki->dixdev, led, on);
+    KdSetLeds(ki, ki->dixdev->kbdfeed->ctrl.leds);
 }
 
 void
-KdSetPointerMatrix (KdPointerMatrix *matrix)
+KdSetPointerMatrix(KdPointerMatrix * matrix)
 {
     kdPointerMatrix = *matrix;
 }
 
 void
-KdComputePointerMatrix (KdPointerMatrix *m, Rotation randr, int width,
-                        int height)
+KdComputePointerMatrix(KdPointerMatrix * m, Rotation randr, int width,
+                       int height)
 {
-    int		    x_dir = 1, y_dir = 1;
-    int		    i, j;
-    int		    size[2];
+    int x_dir = 1, y_dir = 1;
+    int i, j;
+    int size[2];
 
-    size[0] = width; size[1] = height;
+    size[0] = width;
+    size[1] = height;
     if (randr & RR_Reflect_X)
-	x_dir = -1;
+        x_dir = -1;
     if (randr & RR_Reflect_Y)
-	y_dir = -1;
+        y_dir = -1;
     switch (randr & (RR_Rotate_All)) {
     case RR_Rotate_0:
-	m->matrix[0][0] = x_dir; m->matrix[0][1] = 0;
-	m->matrix[1][0] = 0; m->matrix[1][1] = y_dir;
-	break;
+        m->matrix[0][0] = x_dir;
+        m->matrix[0][1] = 0;
+        m->matrix[1][0] = 0;
+        m->matrix[1][1] = y_dir;
+        break;
     case RR_Rotate_90:
-	m->matrix[0][0] = 0; m->matrix[0][1] = -x_dir;
-	m->matrix[1][0] = y_dir; m->matrix[1][1] = 0;
-	break;
+        m->matrix[0][0] = 0;
+        m->matrix[0][1] = -x_dir;
+        m->matrix[1][0] = y_dir;
+        m->matrix[1][1] = 0;
+        break;
     case RR_Rotate_180:
-	m->matrix[0][0] = -x_dir; m->matrix[0][1] = 0;
-	m->matrix[1][0] = 0; m->matrix[1][1] = -y_dir;
-	break;
+        m->matrix[0][0] = -x_dir;
+        m->matrix[0][1] = 0;
+        m->matrix[1][0] = 0;
+        m->matrix[1][1] = -y_dir;
+        break;
     case RR_Rotate_270:
-	m->matrix[0][0] = 0; m->matrix[0][1] = x_dir;
-	m->matrix[1][0] = -y_dir; m->matrix[1][1] = 0;
-	break;
+        m->matrix[0][0] = 0;
+        m->matrix[0][1] = x_dir;
+        m->matrix[1][0] = -y_dir;
+        m->matrix[1][1] = 0;
+        break;
     }
-    for (i = 0; i < 2; i++)
-    {
-	m->matrix[i][2] = 0;
-	for (j = 0 ; j < 2; j++)
-	    if (m->matrix[i][j] < 0)
-		m->matrix[i][2] = size[j] - 1;
+    for (i = 0; i < 2; i++) {
+        m->matrix[i][2] = 0;
+        for (j = 0; j < 2; j++)
+            if (m->matrix[i][j] < 0)
+                m->matrix[i][2] = size[j] - 1;
     }
 }
 
 void
-KdScreenToPointerCoords (int *x, int *y)
+KdScreenToPointerCoords(int *x, int *y)
 {
-    int	(*m)[3] = kdPointerMatrix.matrix;
+    int (*m)[3] = kdPointerMatrix.matrix;
     int div = m[0][1] * m[1][0] - m[1][1] * m[0][0];
     int sx = *x;
     int sy = *y;
 
-    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] - m[1][1] * sx) / div;
-    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] - m[0][0] * sy) / div;
+    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] -
+          m[1][1] * sx) / div;
+    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] -
+          m[0][0] * sy) / div;
 }
 
 static void
-KdKbdCtrl (DeviceIntPtr pDevice, KeybdCtrl *ctrl)
+KdKbdCtrl(DeviceIntPtr pDevice, KeybdCtrl * ctrl)
 {
     KdKeyboardInfo *ki;
 
@@ -698,14 +707,14 @@ extern KeybdCtrl defaultKeyboardControl;
 static int
 KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
 {
-    Bool        ret;
-    DevicePtr   pDev = (DevicePtr)pDevice;
+    Bool ret;
+    DevicePtr pDev = (DevicePtr) pDevice;
     KdKeyboardInfo *ki;
     Atom xiclass;
     XkbRMLVOSet rmlvo;
 
     if (!pDev)
-	return BadImplementation;
+        return BadImplementation;
 
     for (ki = kdKeyboards; ki; ki = ki->next) {
         if (ki->dixdev && ki->dixdev->id == pDevice->id)
@@ -716,8 +725,7 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         return BadImplementation;
     }
 
-    switch (onoff)
-    {
+    switch (onoff) {
     case DEVICE_INIT:
 #ifdef DEBUG
         ErrorF("initialising keyboard %s\n", ki->name);
@@ -754,10 +762,10 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         rmlvo.layout = ki->xkbLayout;
         rmlvo.variant = ki->xkbVariant;
         rmlvo.options = ki->xkbOptions;
-        ret = InitKeyboardDeviceStruct (pDevice, &rmlvo, KdBell, KdKbdCtrl);
-	if (!ret) {
+        ret = InitKeyboardDeviceStruct(pDevice, &rmlvo, KdBell, KdKbdCtrl);
+        if (!ret) {
             ErrorF("Couldn't initialise keyboard %s\n", ki->name);
-	    return BadImplementation;
+            return BadImplementation;
         }
 
         xiclass = AtomFromName(XI_KEYBOARD);
@@ -797,13 +805,13 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         break;
 
     case DEVICE_CLOSE:
-	if (pDev->on) {
+        if (pDev->on) {
             if (!ki->driver->Disable)
                 return BadImplementation;
 
             (*ki->driver->Disable) (ki);
             pDev->on = FALSE;
-	}
+        }
 
         if (!ki->driver->Fini)
             return BadImplementation;
@@ -820,7 +828,7 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
 }
 
 void
-KdAddPointerDriver (KdPointerDriver *driver)
+KdAddPointerDriver(KdPointerDriver * driver)
 {
     KdPointerDriver **prev;
 
@@ -835,7 +843,7 @@ KdAddPointerDriver (KdPointerDriver *driver)
 }
 
 void
-KdRemovePointerDriver (KdPointerDriver *driver)
+KdRemovePointerDriver(KdPointerDriver * driver)
 {
     KdPointerDriver *tmp;
 
@@ -852,7 +860,7 @@ KdRemovePointerDriver (KdPointerDriver *driver)
 }
 
 void
-KdAddKeyboardDriver (KdKeyboardDriver *driver)
+KdAddKeyboardDriver(KdKeyboardDriver * driver)
 {
     KdKeyboardDriver **prev;
 
@@ -867,7 +875,7 @@ KdAddKeyboardDriver (KdKeyboardDriver *driver)
 }
 
 void
-KdRemoveKeyboardDriver (KdKeyboardDriver *driver)
+KdRemoveKeyboardDriver(KdKeyboardDriver * driver)
 {
     KdKeyboardDriver *tmp;
 
@@ -884,9 +892,10 @@ KdRemoveKeyboardDriver (KdKeyboardDriver *driver)
 }
 
 KdKeyboardInfo *
-KdNewKeyboard (void)
+KdNewKeyboard(void)
 {
     KdKeyboardInfo *ki = calloc(sizeof(KdKeyboardInfo), 1);
+
     if (!ki)
         return NULL;
 
@@ -907,7 +916,7 @@ KdNewKeyboard (void)
 }
 
 int
-KdAddConfigKeyboard (char *keyboard)
+KdAddConfigKeyboard(char *keyboard)
 {
     struct KdConfigDevice **prev, *new;
 
@@ -928,7 +937,7 @@ KdAddConfigKeyboard (char *keyboard)
 }
 
 int
-KdAddKeyboard (KdKeyboardInfo *ki)
+KdAddKeyboard(KdKeyboardInfo * ki)
 {
     KdKeyboardInfo **prev;
 
@@ -953,7 +962,7 @@ KdAddKeyboard (KdKeyboardInfo *ki)
 }
 
 void
-KdRemoveKeyboard (KdKeyboardInfo *ki)
+KdRemoveKeyboard(KdKeyboardInfo * ki)
 {
     KdKeyboardInfo **prev;
 
@@ -971,7 +980,7 @@ KdRemoveKeyboard (KdKeyboardInfo *ki)
 }
 
 int
-KdAddConfigPointer (char *pointer)
+KdAddConfigPointer(char *pointer)
 {
     struct KdConfigDevice **prev, *new;
 
@@ -992,7 +1001,7 @@ KdAddConfigPointer (char *pointer)
 }
 
 int
-KdAddPointer (KdPointerInfo *pi)
+KdAddPointer(KdPointerInfo * pi)
 {
     KdPointerInfo **prev;
 
@@ -1016,7 +1025,7 @@ KdAddPointer (KdPointerInfo *pi)
 }
 
 void
-KdRemovePointer (KdPointerInfo *pi)
+KdRemovePointer(KdPointerInfo * pi)
 {
     KdPointerInfo **prev;
 
@@ -1039,15 +1048,13 @@ KdRemovePointer (KdPointerInfo *pi)
  * evdev,,device=/dev/input/event1,xkbmodel=abnt2,xkblayout=br
  */
 static Bool
-KdGetOptions (InputOption **options, char *string)
+KdGetOptions(InputOption **options, char *string)
 {
-    InputOption     *newopt = NULL;
-    char            *key = NULL,
-                    *value = NULL;
-    int             tam_key = 0;
+    InputOption *newopt = NULL;
+    char *key = NULL, *value = NULL;
+    int tam_key = 0;
 
-    if (strchr(string, '='))
-    {
+    if (strchr(string, '=')) {
         tam_key = (strchr(string, '=') - string);
         key = strndup(string, tam_key);
         if (!key)
@@ -1057,8 +1064,7 @@ KdGetOptions (InputOption **options, char *string)
         if (!value)
             goto out;
     }
-    else
-    {
+    else {
         key = strdup(string);
         value = NULL;
     }
@@ -1067,7 +1073,7 @@ KdGetOptions (InputOption **options, char *string)
     if (newopt)
         *options = newopt;
 
-out:
+ out:
     free(key);
     free(value);
 
@@ -1075,12 +1081,11 @@ out:
 }
 
 static void
-KdParseKbdOptions (KdKeyboardInfo *ki)
+KdParseKbdOptions(KdKeyboardInfo * ki)
 {
     InputOption *option = NULL;
 
-    nt_list_for_each_entry(option, ki->options, list.next)
-    {
+    nt_list_for_each_entry(option, ki->options, list.next) {
         const char *key = input_option_get_key(option);
         const char *value = input_option_get_value(option);
 
@@ -1094,21 +1099,21 @@ KdParseKbdOptions (KdKeyboardInfo *ki)
             ki->xkbVariant = strdup(value);
         else if (strcasecmp(key, "XkbOptions") == 0)
             ki->xkbOptions = strdup(value);
-        else if (!strcasecmp (key, "device"))
+        else if (!strcasecmp(key, "device"))
             ki->path = strdup(value);
         else
-           ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",
-                    key, value);
+            ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",
+                   key, value);
     }
 }
 
 KdKeyboardInfo *
-KdParseKeyboard (char *arg)
+KdParseKeyboard(char *arg)
 {
-    char            save[1024];
-    char            delim;
-    InputOption     *options = NULL;
-    KdKeyboardInfo     *ki = NULL;
+    char save[1024];
+    char delim;
+    InputOption *options = NULL;
+    KdKeyboardInfo *ki = NULL;
 
     ki = KdNewKeyboard();
     if (!ki)
@@ -1120,53 +1125,46 @@ KdParseKeyboard (char *arg)
     ki->driverPrivate = NULL;
     ki->next = NULL;
 
-    if (!arg)
-    {
+    if (!arg) {
         ErrorF("keybd: no arg\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    if (strlen (arg) >= sizeof (save))
-    {
+    if (strlen(arg) >= sizeof(save)) {
         ErrorF("keybd: arg too long\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-    {
+    arg = KdParseFindNext(arg, ",", save, &delim);
+    if (!save[0]) {
         ErrorF("keybd: failed on save[0]\n");
-        KdFreeKeyboard (ki);
+        KdFreeKeyboard(ki);
         return NULL;
     }
 
-    if (strcmp (save, "auto") == 0)
+    if (strcmp(save, "auto") == 0)
         ki->driverPrivate = NULL;
     else
         ki->driverPrivate = strdup(save);
 
-    if (delim != ',')
-    {
+    if (delim != ',') {
         return ki;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
+    arg = KdParseFindNext(arg, ",", save, &delim);
 
-    while (delim == ',')
-    {
-        arg = KdParseFindNext (arg, ",", save, &delim);
+    while (delim == ',') {
+        arg = KdParseFindNext(arg, ",", save, &delim);
 
-	if (!KdGetOptions(&options, save))
-	{
-	    KdFreeKeyboard(ki);
-	    return NULL;
+        if (!KdGetOptions(&options, save)) {
+            KdFreeKeyboard(ki);
+            return NULL;
         }
     }
 
-    if (options)
-    {
+    if (options) {
         ki->options = options;
         KdParseKbdOptions(ki);
     }
@@ -1175,41 +1173,40 @@ KdParseKeyboard (char *arg)
 }
 
 static void
-KdParsePointerOptions (KdPointerInfo *pi)
+KdParsePointerOptions(KdPointerInfo * pi)
 {
     InputOption *option = NULL;
 
-    nt_list_for_each_entry(option, pi->options, list.next)
-    {
+    nt_list_for_each_entry(option, pi->options, list.next) {
         const char *key = input_option_get_key(option);
         const char *value = input_option_get_value(option);
 
-        if (!strcmp (key, "emulatemiddle"))
+        if (!strcmp(key, "emulatemiddle"))
             pi->emulateMiddleButton = TRUE;
-        else if (!strcmp (key, "noemulatemiddle"))
+        else if (!strcmp(key, "noemulatemiddle"))
             pi->emulateMiddleButton = FALSE;
-        else if (!strcmp (key, "transformcoord"))
+        else if (!strcmp(key, "transformcoord"))
             pi->transformCoordinates = TRUE;
-        else if (!strcmp (key, "rawcoord"))
+        else if (!strcmp(key, "rawcoord"))
             pi->transformCoordinates = FALSE;
-        else if (!strcasecmp (key, "device"))
+        else if (!strcasecmp(key, "device"))
             pi->path = strdup(value);
-        else if (!strcasecmp (key, "protocol"))
+        else if (!strcasecmp(key, "protocol"))
             pi->protocol = strdup(value);
         else
             ErrorF("Pointer option key (%s) of value (%s) not assigned!\n",
-                    key, value);
+                   key, value);
     }
 }
 
 KdPointerInfo *
-KdParsePointer (char *arg)
+KdParsePointer(char *arg)
 {
-    char            save[1024];
-    char            delim;
-    KdPointerInfo   *pi = NULL;
-    InputOption     *options = NULL;
-    int             i = 0;
+    char save[1024];
+    char delim;
+    KdPointerInfo *pi = NULL;
+    InputOption *options = NULL;
+    int i = 0;
 
     pi = KdNewPointer();
     if (!pi)
@@ -1217,27 +1214,24 @@ KdParsePointer (char *arg)
     pi->emulateMiddleButton = kdEmulateMiddleButton;
     pi->transformCoordinates = !kdRawPointerCoordinates;
     pi->protocol = NULL;
-    pi->nButtons = 5; /* XXX should not be hardcoded */
+    pi->nButtons = 5;           /* XXX should not be hardcoded */
     pi->inputClass = KD_MOUSE;
 
-    if (!arg)
-    {
+    if (!arg) {
         ErrorF("mouse: no arg\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
 
-    if (strlen (arg) >= sizeof (save))
-    {
+    if (strlen(arg) >= sizeof(save)) {
         ErrorF("mouse: arg too long\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
-    arg = KdParseFindNext (arg, ",", save, &delim);
-    if (!save[0])
-    {
+    arg = KdParseFindNext(arg, ",", save, &delim);
+    if (!save[0]) {
         ErrorF("failed on save[0]\n");
-        KdFreePointer (pi);
+        KdFreePointer(pi);
         return NULL;
     }
 
@@ -1246,41 +1240,35 @@ KdParsePointer (char *arg)
     else
         pi->driverPrivate = strdup(save);
 
-    if (delim != ',')
-    {
+    if (delim != ',') {
         return pi;
     }
 
-    arg = KdParseFindNext (arg, ",", save, &delim);
+    arg = KdParseFindNext(arg, ",", save, &delim);
 
-    while (delim == ',')
-    {
-        arg = KdParseFindNext (arg, ",", save, &delim);
-        if (save[0] == '{')
-        {
+    while (delim == ',') {
+        arg = KdParseFindNext(arg, ",", save, &delim);
+        if (save[0] == '{') {
             char *s = save + 1;
-             i = 0;
-             while (*s && *s != '}')
-             {
+
+            i = 0;
+            while (*s && *s != '}') {
                 if ('1' <= *s && *s <= '0' + pi->nButtons)
                     pi->map[i] = *s - '0';
                 else
-                    UseMsg ();
+                    UseMsg();
                 s++;
-             }
+            }
         }
-        else
-        {
-            if (!KdGetOptions(&options, save))
-            {
+        else {
+            if (!KdGetOptions(&options, save)) {
                 KdFreePointer(pi);
                 return NULL;
             }
         }
     }
 
-    if (options)
-    {
+    if (options) {
         pi->options = options;
         KdParsePointerOptions(pi);
     }
@@ -1288,9 +1276,8 @@ KdParsePointer (char *arg)
     return pi;
 }
 
-
 void
-KdInitInput (void)
+KdInitInput(void)
 {
     KdPointerInfo *pi;
     KdKeyboardInfo *ki;
@@ -1317,7 +1304,7 @@ KdInitInput (void)
 }
 
 void
-KdCloseInput (void)
+KdCloseInput(void)
 {
     mieqFini();
 }
@@ -1480,195 +1467,203 @@ typedef enum _inputAction {
 #define MAX_ACTIONS 2
 
 typedef struct _inputTransition {
-    KdInputAction  actions[MAX_ACTIONS];
+    KdInputAction actions[MAX_ACTIONS];
     KdPointerState nextState;
 } KdInputTransition;
 
 static const
-KdInputTransition  kdInputMachine[num_input_states][num_input_class] = {
+KdInputTransition kdInputMachine[num_input_states][num_input_class] = {
     /* start */
     {
-	{ { hold, setto },	    button_1_pend },	/* v1 */
-	{ { deliver, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    button_2_down },	/* v2 */
-	{ { deliver, noop },	    start },		/* ^2 */
-	{ { hold, setto },	    button_3_pend },	/* v3 */
-	{ { deliver, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    start },		/* vo */
-	{ { deliver, noop },	    start },		/* ^o */
-	{ { deliver, noop },	    start },		/* <> */
-	{ { deliver, noop },	    start },		/* <-> */
-	{ { noop, noop },	    start },		/* k */
-	{ { noop, noop },	    start },		/* ... */
-    },
+     {{hold, setto}, button_1_pend},    /* v1 */
+     {{deliver, noop}, start},  /* ^1 */
+     {{deliver, noop}, button_2_down},  /* v2 */
+     {{deliver, noop}, start},  /* ^2 */
+     {{hold, setto}, button_3_pend},    /* v3 */
+     {{deliver, noop}, start},  /* ^3 */
+     {{deliver, noop}, start},  /* vo */
+     {{deliver, noop}, start},  /* ^o */
+     {{deliver, noop}, start},  /* <> */
+     {{deliver, noop}, start},  /* <-> */
+     {{noop, noop}, start},     /* k */
+     {{noop, noop}, start},     /* ... */
+     },
     /* button_1_pend */
     {
-	{ { noop, noop },	    button_1_pend },	/* v1 */
-	{ { release, deliver },	    start },		/* ^1 */
-	{ { release, deliver },	    button_1_down },	/* v2 */
-	{ { release, deliver },	    button_1_down },	/* ^2 */
-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v3 */
-	{ { release, deliver },	    button_1_down },	/* ^3 */
-	{ { release, deliver },	    button_1_down },	/* vo */
-	{ { release, deliver },	    button_1_down },	/* ^o */
-	{ { deliver, noop },	    button_1_pend },	/* <> */
-	{ { release, deliver },	    button_1_down },	/* <-> */
-	{ { noop, noop },	    button_1_down },	/* k */
-	{ { release, noop },	    button_1_down },	/* ... */
-    },
+     {{noop, noop}, button_1_pend},     /* v1 */
+     {{release, deliver}, start},       /* ^1 */
+     {{release, deliver}, button_1_down},       /* v2 */
+     {{release, deliver}, button_1_down},       /* ^2 */
+     {{clearto, gen_down_2}, synth_2_down_13},  /* v3 */
+     {{release, deliver}, button_1_down},       /* ^3 */
+     {{release, deliver}, button_1_down},       /* vo */
+     {{release, deliver}, button_1_down},       /* ^o */
+     {{deliver, noop}, button_1_pend},  /* <> */
+     {{release, deliver}, button_1_down},       /* <-> */
+     {{noop, noop}, button_1_down},     /* k */
+     {{release, noop}, button_1_down},  /* ... */
+     },
     /* button_1_down */
     {
-	{ { noop, noop },	    button_1_down },	/* v1 */
-	{ { deliver, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    button_1_down },	/* v2 */
-	{ { deliver, noop },	    button_1_down },	/* ^2 */
-	{ { deliver, noop },	    button_1_down },	/* v3 */
-	{ { deliver, noop },	    button_1_down },	/* ^3 */
-	{ { deliver, noop },	    button_1_down },	/* vo */
-	{ { deliver, noop },	    button_1_down },	/* ^o */
-	{ { deliver, noop },	    button_1_down },	/* <> */
-	{ { deliver, noop },	    button_1_down },	/* <-> */
-	{ { noop, noop },	    button_1_down },	/* k */
-	{ { noop, noop },	    button_1_down },	/* ... */
-    },
+     {{noop, noop}, button_1_down},     /* v1 */
+     {{deliver, noop}, start},  /* ^1 */
+     {{deliver, noop}, button_1_down},  /* v2 */
+     {{deliver, noop}, button_1_down},  /* ^2 */
+     {{deliver, noop}, button_1_down},  /* v3 */
+     {{deliver, noop}, button_1_down},  /* ^3 */
+     {{deliver, noop}, button_1_down},  /* vo */
+     {{deliver, noop}, button_1_down},  /* ^o */
+     {{deliver, noop}, button_1_down},  /* <> */
+     {{deliver, noop}, button_1_down},  /* <-> */
+     {{noop, noop}, button_1_down},     /* k */
+     {{noop, noop}, button_1_down},     /* ... */
+     },
     /* button_2_down */
     {
-	{ { deliver, noop },	    button_2_down },	/* v1 */
-	{ { deliver, noop },	    button_2_down },	/* ^1 */
-	{ { noop, noop },	    button_2_down },	/* v2 */
-	{ { deliver, noop },	    start },		/* ^2 */
-	{ { deliver, noop },	    button_2_down },	/* v3 */
-	{ { deliver, noop },	    button_2_down },	/* ^3 */
-	{ { deliver, noop },	    button_2_down },	/* vo */
-	{ { deliver, noop },	    button_2_down },	/* ^o */
-	{ { deliver, noop },	    button_2_down },	/* <> */
-	{ { deliver, noop },	    button_2_down },	/* <-> */
-	{ { noop, noop },	    button_2_down },	/* k */
-	{ { noop, noop },	    button_2_down },	/* ... */
-    },
+     {{deliver, noop}, button_2_down},  /* v1 */
+     {{deliver, noop}, button_2_down},  /* ^1 */
+     {{noop, noop}, button_2_down},     /* v2 */
+     {{deliver, noop}, start},  /* ^2 */
+     {{deliver, noop}, button_2_down},  /* v3 */
+     {{deliver, noop}, button_2_down},  /* ^3 */
+     {{deliver, noop}, button_2_down},  /* vo */
+     {{deliver, noop}, button_2_down},  /* ^o */
+     {{deliver, noop}, button_2_down},  /* <> */
+     {{deliver, noop}, button_2_down},  /* <-> */
+     {{noop, noop}, button_2_down},     /* k */
+     {{noop, noop}, button_2_down},     /* ... */
+     },
     /* button_3_pend */
     {
-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v1 */
-	{ { release, deliver },	    button_3_down },	/* ^1 */
-	{ { release, deliver },	    button_3_down },	/* v2 */
-	{ { release, deliver },	    button_3_down },	/* ^2 */
-	{ { release, deliver },	    button_3_down },	/* v3 */
-	{ { release, deliver },	    start },		/* ^3 */
-	{ { release, deliver },	    button_3_down },	/* vo */
-	{ { release, deliver },	    button_3_down },	/* ^o */
-	{ { deliver, noop },	    button_3_pend },	/* <> */
-	{ { release, deliver },	    button_3_down },	/* <-> */
-	{ { release, noop },	    button_3_down },	/* k */
-	{ { release, noop },	    button_3_down },	/* ... */
-    },
+     {{clearto, gen_down_2}, synth_2_down_13},  /* v1 */
+     {{release, deliver}, button_3_down},       /* ^1 */
+     {{release, deliver}, button_3_down},       /* v2 */
+     {{release, deliver}, button_3_down},       /* ^2 */
+     {{release, deliver}, button_3_down},       /* v3 */
+     {{release, deliver}, start},       /* ^3 */
+     {{release, deliver}, button_3_down},       /* vo */
+     {{release, deliver}, button_3_down},       /* ^o */
+     {{deliver, noop}, button_3_pend},  /* <> */
+     {{release, deliver}, button_3_down},       /* <-> */
+     {{release, noop}, button_3_down},  /* k */
+     {{release, noop}, button_3_down},  /* ... */
+     },
     /* button_3_down */
     {
-	{ { deliver, noop },	    button_3_down },	/* v1 */
-	{ { deliver, noop },	    button_3_down },	/* ^1 */
-	{ { deliver, noop },	    button_3_down },	/* v2 */
-	{ { deliver, noop },	    button_3_down },	/* ^2 */
-	{ { noop, noop },	    button_3_down },	/* v3 */
-	{ { deliver, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    button_3_down },	/* vo */
-	{ { deliver, noop },	    button_3_down },	/* ^o */
-	{ { deliver, noop },	    button_3_down },	/* <> */
-	{ { deliver, noop },	    button_3_down },	/* <-> */
-	{ { noop, noop },	    button_3_down },	/* k */
-	{ { noop, noop },	    button_3_down },	/* ... */
-    },
+     {{deliver, noop}, button_3_down},  /* v1 */
+     {{deliver, noop}, button_3_down},  /* ^1 */
+     {{deliver, noop}, button_3_down},  /* v2 */
+     {{deliver, noop}, button_3_down},  /* ^2 */
+     {{noop, noop}, button_3_down},     /* v3 */
+     {{deliver, noop}, start},  /* ^3 */
+     {{deliver, noop}, button_3_down},  /* vo */
+     {{deliver, noop}, button_3_down},  /* ^o */
+     {{deliver, noop}, button_3_down},  /* <> */
+     {{deliver, noop}, button_3_down},  /* <-> */
+     {{noop, noop}, button_3_down},     /* k */
+     {{noop, noop}, button_3_down},     /* ... */
+     },
     /* synthetic_2_down_13 */
     {
-	{ { noop, noop },	    synth_2_down_13 },	/* v1 */
-	{ { gen_up_2, noop },	    synth_2_down_3 },	/* ^1 */
-	{ { noop, noop },	    synth_2_down_13 },	/* v2 */
-	{ { noop, noop },	    synth_2_down_13 },	/* ^2 */
-	{ { noop, noop },	    synth_2_down_13 },	/* v3 */
-	{ { gen_up_2, noop },	    synth_2_down_1 },	/* ^3 */
-	{ { deliver, noop },	    synth_2_down_13 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_13 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_13 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_13 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_13 },	/* k */
-	{ { noop, noop },	    synth_2_down_13 },	/* ... */
-    },
+     {{noop, noop}, synth_2_down_13},   /* v1 */
+     {{gen_up_2, noop}, synth_2_down_3},        /* ^1 */
+     {{noop, noop}, synth_2_down_13},   /* v2 */
+     {{noop, noop}, synth_2_down_13},   /* ^2 */
+     {{noop, noop}, synth_2_down_13},   /* v3 */
+     {{gen_up_2, noop}, synth_2_down_1},        /* ^3 */
+     {{deliver, noop}, synth_2_down_13},        /* vo */
+     {{deliver, noop}, synth_2_down_13},        /* ^o */
+     {{deliver, noop}, synth_2_down_13},        /* <> */
+     {{deliver, noop}, synth_2_down_13},        /* <-> */
+     {{noop, noop}, synth_2_down_13},   /* k */
+     {{noop, noop}, synth_2_down_13},   /* ... */
+     },
     /* synthetic_2_down_3 */
     {
-	{ { deliver, noop },	    synth_2_down_3 },	/* v1 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^1 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* v2 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^2 */
-	{ { noop, noop },	    synth_2_down_3 },	/* v3 */
-	{ { noop, noop },	    start },		/* ^3 */
-	{ { deliver, noop },	    synth_2_down_3 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_3 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_3 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_3 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_3 },	/* k */
-	{ { noop, noop },	    synth_2_down_3 },	/* ... */
-    },
+     {{deliver, noop}, synth_2_down_3}, /* v1 */
+     {{deliver, noop}, synth_2_down_3}, /* ^1 */
+     {{deliver, noop}, synth_2_down_3}, /* v2 */
+     {{deliver, noop}, synth_2_down_3}, /* ^2 */
+     {{noop, noop}, synth_2_down_3},    /* v3 */
+     {{noop, noop}, start},     /* ^3 */
+     {{deliver, noop}, synth_2_down_3}, /* vo */
+     {{deliver, noop}, synth_2_down_3}, /* ^o */
+     {{deliver, noop}, synth_2_down_3}, /* <> */
+     {{deliver, noop}, synth_2_down_3}, /* <-> */
+     {{noop, noop}, synth_2_down_3},    /* k */
+     {{noop, noop}, synth_2_down_3},    /* ... */
+     },
     /* synthetic_2_down_1 */
     {
-	{ { noop, noop },	    synth_2_down_1 },	/* v1 */
-	{ { noop, noop },	    start },		/* ^1 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* v2 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^2 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* v3 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^3 */
-	{ { deliver, noop },	    synth_2_down_1 },	/* vo */
-	{ { deliver, noop },	    synth_2_down_1 },	/* ^o */
-	{ { deliver, noop },	    synth_2_down_1 },	/* <> */
-	{ { deliver, noop },	    synth_2_down_1 },	/* <-> */
-	{ { noop, noop },	    synth_2_down_1 },	/* k */
-	{ { noop, noop },	    synth_2_down_1 },	/* ... */
-    },
+     {{noop, noop}, synth_2_down_1},    /* v1 */
+     {{noop, noop}, start},     /* ^1 */
+     {{deliver, noop}, synth_2_down_1}, /* v2 */
+     {{deliver, noop}, synth_2_down_1}, /* ^2 */
+     {{deliver, noop}, synth_2_down_1}, /* v3 */
+     {{deliver, noop}, synth_2_down_1}, /* ^3 */
+     {{deliver, noop}, synth_2_down_1}, /* vo */
+     {{deliver, noop}, synth_2_down_1}, /* ^o */
+     {{deliver, noop}, synth_2_down_1}, /* <> */
+     {{deliver, noop}, synth_2_down_1}, /* <-> */
+     {{noop, noop}, synth_2_down_1},    /* k */
+     {{noop, noop}, synth_2_down_1},    /* ... */
+     },
 };
 
 #define EMULATION_WINDOW    10
 #define EMULATION_TIMEOUT   100
 
 static int
-KdInsideEmulationWindow (KdPointerInfo *pi, int x, int y, int z)
+KdInsideEmulationWindow(KdPointerInfo * pi, int x, int y, int z)
 {
     pi->emulationDx = pi->heldEvent.x - x;
     pi->emulationDy = pi->heldEvent.y - y;
 
-    return (abs (pi->emulationDx) < EMULATION_WINDOW &&
-	    abs (pi->emulationDy) < EMULATION_WINDOW);
+    return (abs(pi->emulationDx) < EMULATION_WINDOW &&
+            abs(pi->emulationDy) < EMULATION_WINDOW);
 }
 
 static KdInputClass
-KdClassifyInput (KdPointerInfo *pi, int type, int x, int y, int z, int b)
+KdClassifyInput(KdPointerInfo * pi, int type, int x, int y, int z, int b)
 {
     switch (type) {
     case ButtonPress:
-	switch (b) {
-	case 1: return down_1;
-	case 2: return down_2;
-	case 3: return down_3;
-	default: return down_o;
-	}
-	break;
+        switch (b) {
+        case 1:
+            return down_1;
+        case 2:
+            return down_2;
+        case 3:
+            return down_3;
+        default:
+            return down_o;
+        }
+        break;
     case ButtonRelease:
-	switch (b) {
-	case 1: return up_1;
-	case 2: return up_2;
-	case 3: return up_3;
-	default: return up_o;
-	}
-	break;
+        switch (b) {
+        case 1:
+            return up_1;
+        case 2:
+            return up_2;
+        case 3:
+            return up_3;
+        default:
+            return up_o;
+        }
+        break;
     case MotionNotify:
-	if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))
-	    return outside_box;
-	else
-	    return motion;
+        if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))
+            return outside_box;
+        else
+            return motion;
     default:
-	return keyboard;
+        return keyboard;
     }
     return keyboard;
 }
 
 #ifdef DEBUG
-char	*kdStateNames[] = {
+char *kdStateNames[] = {
     "start",
     "button_1_pend",
     "button_1_down",
@@ -1681,7 +1676,7 @@ char	*kdStateNames[] = {
     "num_input_states"
 };
 
-char	*kdClassNames[] = {
+char *kdClassNames[] = {
     "down_1", "up_1",
     "down_2", "up_2",
     "down_3", "up_3",
@@ -1700,95 +1695,92 @@ char *kdActionNames[] = {
     "gen_down_2",
     "gen_up_2",
 };
-#endif /* DEBUG */
+#endif                          /* DEBUG */
 
 static void
-KdQueueEvent (DeviceIntPtr pDev, InternalEvent *ev)
+KdQueueEvent(DeviceIntPtr pDev, InternalEvent *ev)
 {
-    KdAssertSigioBlocked ("KdQueueEvent");
-    mieqEnqueue (pDev, ev);
+    KdAssertSigioBlocked("KdQueueEvent");
+    mieqEnqueue(pDev, ev);
 }
 
 /* We return true if we're stealing the event. */
 static Bool
-KdRunMouseMachine (KdPointerInfo *pi, KdInputClass c, int type, int x, int y,
-                   int z, int b, int absrel)
+KdRunMouseMachine(KdPointerInfo * pi, KdInputClass c, int type, int x, int y,
+                  int z, int b, int absrel)
 {
     const KdInputTransition *t;
-    int	a;
+    int a;
 
     c = KdClassifyInput(pi, type, x, y, z, b);
     t = &kdInputMachine[pi->mouseState][c];
-    for (a = 0; a < MAX_ACTIONS; a++)
-    {
-	switch (t->actions[a]) {
-	case noop:
-	    break;
-	case hold:
-	    pi->eventHeld = TRUE;
-	    pi->emulationDx = 0;
-	    pi->emulationDy = 0;
-	    pi->heldEvent.type = type;
+    for (a = 0; a < MAX_ACTIONS; a++) {
+        switch (t->actions[a]) {
+        case noop:
+            break;
+        case hold:
+            pi->eventHeld = TRUE;
+            pi->emulationDx = 0;
+            pi->emulationDy = 0;
+            pi->heldEvent.type = type;
             pi->heldEvent.x = x;
             pi->heldEvent.y = y;
             pi->heldEvent.z = z;
             pi->heldEvent.flags = b;
             pi->heldEvent.absrel = absrel;
             return TRUE;
-	    break;
-	case setto:
-	    pi->emulationTimeout = GetTimeInMillis () + EMULATION_TIMEOUT;
-	    pi->timeoutPending = TRUE;
-	    break;
-	case deliver:
-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
-                                    pi->heldEvent.y, pi->heldEvent.z,
-                                    pi->heldEvent.flags, pi->heldEvent.absrel,
-                                    TRUE);
-	    break;
-	case release:
-	    pi->eventHeld = FALSE;
-	    pi->timeoutPending = FALSE;
-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
-                                    pi->heldEvent.y, pi->heldEvent.z,
-                                    pi->heldEvent.flags, pi->heldEvent.absrel,
-                                    TRUE);
+            break;
+        case setto:
+            pi->emulationTimeout = GetTimeInMillis() + EMULATION_TIMEOUT;
+            pi->timeoutPending = TRUE;
+            break;
+        case deliver:
+            _KdEnqueuePointerEvent(pi, pi->heldEvent.type, pi->heldEvent.x,
+                                   pi->heldEvent.y, pi->heldEvent.z,
+                                   pi->heldEvent.flags, pi->heldEvent.absrel,
+                                   TRUE);
+            break;
+        case release:
+            pi->eventHeld = FALSE;
+            pi->timeoutPending = FALSE;
+            _KdEnqueuePointerEvent(pi, pi->heldEvent.type, pi->heldEvent.x,
+                                   pi->heldEvent.y, pi->heldEvent.z,
+                                   pi->heldEvent.flags, pi->heldEvent.absrel,
+                                   TRUE);
             return TRUE;
-	    break;
-	case clearto:
-	    pi->timeoutPending = FALSE;
-	    break;
-	case gen_down_2:
-            _KdEnqueuePointerEvent (pi, ButtonPress, x, y, z, 2, absrel,
-                                    TRUE);
-	    pi->eventHeld = FALSE;
+            break;
+        case clearto:
+            pi->timeoutPending = FALSE;
+            break;
+        case gen_down_2:
+            _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, 2, absrel, TRUE);
+            pi->eventHeld = FALSE;
             return TRUE;
-	    break;
-	case gen_up_2:
-            _KdEnqueuePointerEvent (pi, ButtonRelease, x, y, z, 2, absrel,
-                                    TRUE);
+            break;
+        case gen_up_2:
+            _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, 2, absrel, TRUE);
             return TRUE;
-	    break;
-	}
+            break;
+        }
     }
     pi->mouseState = t->nextState;
     return FALSE;
 }
 
 static int
-KdHandlePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z, int b,
-                      int absrel)
+KdHandlePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z, int b,
+                     int absrel)
 {
     if (pi->emulateMiddleButton)
-        return KdRunMouseMachine (pi, KdClassifyInput(pi, type, x, y, z, b),
-                                  type, x, y, z, b, absrel);
+        return KdRunMouseMachine(pi, KdClassifyInput(pi, type, x, y, z, b),
+                                 type, x, y, z, b, absrel);
     return FALSE;
 }
 
 static void
-KdReceiveTimeout (KdPointerInfo *pi)
+KdReceiveTimeout(KdPointerInfo * pi)
 {
-    KdRunMouseMachine (pi, timeout, 0, 0, 0, 0, 0, 0);
+    KdRunMouseMachine(pi, timeout, 0, 0, 0, 0, 0, 0);
 }
 
 /*
@@ -1805,17 +1797,16 @@ KdReceiveTimeout (KdPointerInfo *pi)
 extern int nClients;
 
 void
-KdReleaseAllKeys (void)
+KdReleaseAllKeys(void)
 {
 #if 0
-    int	key;
+    int key;
     KdKeyboardInfo *ki;
 
-    KdBlockSigio ();
+    KdBlockSigio();
 
     for (ki = kdKeyboards; ki; ki = ki->next) {
-        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode;
-             key++) {
+        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode; key++) {
             if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {
                 KdHandleKeyboardEvent(ki, KeyRelease, key);
                 QueueGetKeyboardEvents(ki->dixdev, KeyRelease, key, NULL);
@@ -1823,56 +1814,55 @@ KdReleaseAllKeys (void)
         }
     }
 
-    KdUnblockSigio ();
+    KdUnblockSigio();
 #endif
 }
 
 static void
-KdCheckLock (void)
+KdCheckLock(void)
 {
-    KeyClassPtr	    keyc = NULL;
-    Bool	    isSet = FALSE, shouldBeSet = FALSE;
-    KdKeyboardInfo     *tmp = NULL;
+    KeyClassPtr keyc = NULL;
+    Bool isSet = FALSE, shouldBeSet = FALSE;
+    KdKeyboardInfo *tmp = NULL;
 
     for (tmp = kdKeyboards; tmp; tmp = tmp->next) {
         if (tmp->LockLed && tmp->dixdev && tmp->dixdev->key) {
             keyc = tmp->dixdev->key;
-            isSet = (tmp->leds & (1 << (tmp->LockLed-1))) != 0;
+            isSet = (tmp->leds & (1 << (tmp->LockLed - 1))) != 0;
             /* FIXME: Just use XKB indicators! */
-            shouldBeSet = !!(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);
+            shouldBeSet =
+                ! !(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);
             if (isSet != shouldBeSet)
-                KdSetLed (tmp, tmp->LockLed, shouldBeSet);
+                KdSetLed(tmp, tmp->LockLed, shouldBeSet);
         }
     }
 }
 
 void
-KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
-                       unsigned char scan_code,
-		       unsigned char is_up)
+KdEnqueueKeyboardEvent(KdKeyboardInfo * ki,
+                       unsigned char scan_code, unsigned char is_up)
 {
     unsigned char key_code;
-    KeyClassPtr	keyc = NULL;
+    KeyClassPtr keyc = NULL;
     KeybdCtrl *ctrl = NULL;
     int type;
 
     if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed || !ki->dixdev->key)
-	return;
+        return;
 
     keyc = ki->dixdev->key;
     ctrl = &ki->dixdev->kbdfeed->ctrl;
 
-    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode)
-    {
-	key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;
+    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode) {
+        key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;
 
-	/*
-	 * Set up this event -- the type may be modified below
-	 */
-	if (is_up)
-	    type = KeyRelease;
-	else
-	    type = KeyPress;
+        /*
+         * Set up this event -- the type may be modified below
+         */
+        if (is_up)
+            type = KeyRelease;
+        else
+            type = KeyPress;
 
         QueueKeyboardEvents(ki->dixdev, type, key_code, NULL);
     }
@@ -1893,74 +1883,72 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
 
 /* FIXME do something a little more clever to deal with multiple axes here */
 void
-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+KdEnqueuePointerEvent(KdPointerInfo * pi, unsigned long flags, int rx, int ry,
                       int rz)
 {
-    CARD32        ms;
+    CARD32 ms;
     unsigned char buttons;
-    int           x, y, z;
-    int           (*matrix)[3] = kdPointerMatrix.matrix;
+    int x, y, z;
+    int (*matrix)[3] = kdPointerMatrix.matrix;
     unsigned long button;
-    int           n;
-    int           dixflags = 0;
+    int n;
+    int dixflags = 0;
 
     if (!pi)
-	return;
+        return;
 
     ms = GetTimeInMillis();
 
     /* we don't need to transform z, so we don't. */
     if (flags & KD_MOUSE_DELTA) {
-	if (pi->transformCoordinates) {
-	    x = matrix[0][0] * rx + matrix[0][1] * ry;
-	    y = matrix[1][0] * rx + matrix[1][1] * ry;
-	}
-	else {
-	    x = rx;
-	    y = ry;
-	}
+        if (pi->transformCoordinates) {
+            x = matrix[0][0] * rx + matrix[0][1] * ry;
+            y = matrix[1][0] * rx + matrix[1][1] * ry;
+        }
+        else {
+            x = rx;
+            y = ry;
+        }
     }
     else {
-	if (pi->transformCoordinates) {
-	    x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];
-	    y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];
-	}
-	else {
-	    x = rx;
-	    y = ry;
-	}
+        if (pi->transformCoordinates) {
+            x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];
+            y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];
+        }
+        else {
+            x = rx;
+            y = ry;
+        }
     }
     z = rz;
 
-    if (flags & KD_MOUSE_DELTA)
-    {
-        if (x || y || z)
-        {
+    if (flags & KD_MOUSE_DELTA) {
+        if (x || y || z) {
             dixflags = POINTER_RELATIVE | POINTER_ACCELERATE;
-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags,
+                                   FALSE);
         }
-    } else
-    {
+    }
+    else {
         dixflags = POINTER_ABSOLUTE;
         if (x != pi->dixdev->last.valuators[0] ||
             y != pi->dixdev->last.valuators[1])
-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags,
+                                   FALSE);
     }
 
     buttons = flags;
 
-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
-         button <<= 1, n++) {
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons; button <<= 1, n++) {
         if (((pi->buttonState & button) ^ (buttons & button)) &&
-           !(buttons & button)) {
+            !(buttons & button)) {
             _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, n,
                                    dixflags, FALSE);
-	}
+        }
     }
-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
-         button <<= 1, n++) {
-	if (((pi->buttonState & button) ^ (buttons & button)) &&
-	    (buttons & button)) {
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons; button <<= 1, n++) {
+        if (((pi->buttonState & button) ^ (buttons & button)) &&
+            (buttons & button)) {
             _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, n,
                                    dixflags, FALSE);
         }
@@ -1970,8 +1958,8 @@ KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
 }
 
 void
-_KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
-                        int b, int absrel, Bool force)
+_KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
+                       int b, int absrel, Bool force)
 {
     int valuators[3] = { x, y, z };
     ValuatorMask mask;
@@ -1986,73 +1974,60 @@ _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
 }
 
 void
-KdBlockHandler (int		screen,
-		pointer		blockData,
-		pointer		timeout,
-		pointer		readmask)
+KdBlockHandler(int screen, pointer blockData, pointer timeout, pointer readmask)
 {
-    KdPointerInfo		    *pi;
-    int myTimeout=0;
-
-    for (pi = kdPointers; pi; pi = pi->next)
-    {
-	if (pi->timeoutPending)
-	{
-	    int	ms;
+    KdPointerInfo *pi;
+    int myTimeout = 0;
 
-	    ms = pi->emulationTimeout - GetTimeInMillis ();
-	    if (ms < 1)
-		ms = 1;
-	    if(ms<myTimeout || myTimeout==0)
-		    myTimeout=ms;
-	}
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->timeoutPending) {
+            int ms;
+
+            ms = pi->emulationTimeout - GetTimeInMillis();
+            if (ms < 1)
+                ms = 1;
+            if (ms < myTimeout || myTimeout == 0)
+                myTimeout = ms;
+        }
     }
     /* if we need to poll for events, do that */
-    if(kdOsFuncs->pollEvents)
-    {
-	    (*kdOsFuncs->pollEvents)();
-	    myTimeout=20;
+    if (kdOsFuncs->pollEvents) {
+        (*kdOsFuncs->pollEvents) ();
+        myTimeout = 20;
     }
-    if(myTimeout>0)
-    	AdjustWaitForDelay (timeout, myTimeout);
+    if (myTimeout > 0)
+        AdjustWaitForDelay(timeout, myTimeout);
 }
 
 void
-KdWakeupHandler (int		screen,
-		 pointer    	data,
-		 unsigned long	lresult,
-		 pointer	readmask)
+KdWakeupHandler(int screen,
+                pointer data, unsigned long lresult, pointer readmask)
 {
-    int		result = (int) lresult;
-    fd_set	*pReadmask = (fd_set *) readmask;
-    int		i;
-    KdPointerInfo	*pi;
+    int result = (int) lresult;
+    fd_set *pReadmask = (fd_set *) readmask;
+    int i;
+    KdPointerInfo *pi;
 
-    if (kdInputEnabled && result > 0)
-    {
-	for (i = 0; i < kdNumInputFds; i++)
-	    if (FD_ISSET (kdInputFds[i].fd, pReadmask))
-	    {
-		KdBlockSigio ();
-		(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
-		KdUnblockSigio ();
-	    }
-    }
-    for (pi = kdPointers; pi; pi = pi->next)
-    {
-	if (pi->timeoutPending)
-	{
-	    if ((long) (GetTimeInMillis () - pi->emulationTimeout) >= 0)
-	    {
-		pi->timeoutPending = FALSE;
-		KdBlockSigio ();
-		KdReceiveTimeout (pi);
-		KdUnblockSigio ();
-	    }
-	}
+    if (kdInputEnabled && result > 0) {
+        for (i = 0; i < kdNumInputFds; i++)
+            if (FD_ISSET(kdInputFds[i].fd, pReadmask)) {
+                KdBlockSigio();
+                (*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+                KdUnblockSigio();
+            }
+    }
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->timeoutPending) {
+            if ((long) (GetTimeInMillis() - pi->emulationTimeout) >= 0) {
+                pi->timeoutPending = FALSE;
+                KdBlockSigio();
+                KdReceiveTimeout(pi);
+                KdUnblockSigio();
+            }
+        }
     }
     if (kdSwitchPending)
-	KdProcessSwitch ();
+        KdProcessSwitch();
 }
 
 #define KdScreenOrigin(pScreen) (&(KdGetScreenPriv(pScreen)->screen->origin))
@@ -2060,84 +2035,75 @@ KdWakeupHandler (int		screen,
 static Bool
 KdCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
 {
-    ScreenPtr	pScreen  = *ppScreen;
-    ScreenPtr	pNewScreen;
-    int		n;
-    int		dx, dy;
-    int		best_x, best_y;
-    int		n_best_x, n_best_y;
-    CARD32	ms;
+    ScreenPtr pScreen = *ppScreen;
+    ScreenPtr pNewScreen;
+    int n;
+    int dx, dy;
+    int best_x, best_y;
+    int n_best_x, n_best_y;
+    CARD32 ms;
 
     if (kdDisableZaphod || screenInfo.numScreens <= 1)
-	return FALSE;
+        return FALSE;
 
     if (0 <= *x && *x < pScreen->width && 0 <= *y && *y < pScreen->height)
-	return FALSE;
+        return FALSE;
 
-    ms = GetTimeInMillis ();
+    ms = GetTimeInMillis();
     if (kdOffScreen && (int) (ms - kdOffScreenTime) < 1000)
-	return FALSE;
+        return FALSE;
     kdOffScreen = TRUE;
     kdOffScreenTime = ms;
     n_best_x = -1;
     best_x = 32767;
     n_best_y = -1;
     best_y = 32767;
-    for (n = 0; n < screenInfo.numScreens; n++)
-    {
-	pNewScreen = screenInfo.screens[n];
-	if (pNewScreen == pScreen)
-	    continue;
-	dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;
-	dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;
-	if (*x < 0)
-	{
-	    if (dx <= 0 && -dx < best_x)
-	    {
-		best_x = -dx;
-		n_best_x = n;
-	    }
-	}
-	else if (*x >= pScreen->width)
-	{
-	    if (dx >= 0 && dx < best_x)
-	    {
-		best_x = dx;
-		n_best_x = n;
-	    }
-	}
-	if (*y < 0)
-	{
-	    if (dy <= 0 && -dy < best_y)
-	    {
-		best_y = -dy;
-		n_best_y = n;
-	    }
-	}
-	else if (*y >= pScreen->height)
-	{
-	    if (dy >= 0 && dy < best_y)
-	    {
-		best_y = dy;
-		n_best_y = n;
-	    }
-	}
+    for (n = 0; n < screenInfo.numScreens; n++) {
+        pNewScreen = screenInfo.screens[n];
+        if (pNewScreen == pScreen)
+            continue;
+        dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;
+        dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;
+        if (*x < 0) {
+            if (dx <= 0 && -dx < best_x) {
+                best_x = -dx;
+                n_best_x = n;
+            }
+        }
+        else if (*x >= pScreen->width) {
+            if (dx >= 0 && dx < best_x) {
+                best_x = dx;
+                n_best_x = n;
+            }
+        }
+        if (*y < 0) {
+            if (dy <= 0 && -dy < best_y) {
+                best_y = -dy;
+                n_best_y = n;
+            }
+        }
+        else if (*y >= pScreen->height) {
+            if (dy >= 0 && dy < best_y) {
+                best_y = dy;
+                n_best_y = n;
+            }
+        }
     }
     if (best_y < best_x)
-	n_best_x = n_best_y;
+        n_best_x = n_best_y;
     if (n_best_x == -1)
-	return FALSE;
+        return FALSE;
     pNewScreen = screenInfo.screens[n_best_x];
 
     if (*x < 0)
-	*x += pNewScreen->width;
+        *x += pNewScreen->width;
     if (*y < 0)
-	*y += pNewScreen->height;
+        *y += pNewScreen->height;
 
     if (*x >= pScreen->width)
-	*x -= pScreen->width;
+        *x -= pScreen->width;
     if (*y >= pScreen->height)
-	*y -= pScreen->height;
+        *y -= pScreen->height;
 
     *ppScreen = pNewScreen;
     return TRUE;
@@ -2148,31 +2114,30 @@ KdCrossScreen(ScreenPtr pScreen, Bool entering)
 {
 }
 
-int KdCurScreen;	/* current event screen */
+int KdCurScreen;                /* current event screen */
 
 static void
-KdWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+KdWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 {
-    KdBlockSigio ();
+    KdBlockSigio();
     KdCurScreen = pScreen->myNum;
     miPointerWarpCursor(pDev, pScreen, x, y);
-    KdUnblockSigio ();
+    KdUnblockSigio();
 }
 
-miPointerScreenFuncRec kdPointerScreenFuncs =
-{
+miPointerScreenFuncRec kdPointerScreenFuncs = {
     KdCursorOffScreen,
     KdCrossScreen,
     KdWarpCursor
 };
 
 void
-ProcessInputEvents (void)
+ProcessInputEvents(void)
 {
     mieqProcessInputEvents();
     if (kdSwitchPending)
-	KdProcessSwitch ();
-    KdCheckLock ();
+        KdProcessSwitch();
+    KdCheckLock();
 }
 
 /* At the moment, absolute/relative is up to the client. */
@@ -2191,7 +2156,7 @@ SetDeviceValuators(register ClientPtr client, DeviceIntPtr pDev,
 
 int
 ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,
-                        xDeviceCtl *control)
+                    xDeviceCtl * control)
 {
     switch (control->control) {
     case DEVICE_RESOLUTION:
@@ -2214,7 +2179,7 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,
 }
 
 int
-NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
+NewInputDeviceRequest(InputOption *options, InputAttributes * attrs,
                       DeviceIntPtr *pdev)
 {
     InputOption *option = NULL;
@@ -2243,16 +2208,14 @@ NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
         }
 #ifdef CONFIG_HAL
         else if (strcmp(key, "_source") == 0 &&
-                 strcmp(value, "server/hal") == 0)
-        {
+                 strcmp(value, "server/hal") == 0) {
             ErrorF("Ignoring device from HAL.\n");
             return BadValue;
         }
 #endif
 #ifdef CONFIG_UDEV
         else if (strcmp(key, "_source") == 0 &&
-                 strcmp(value, "server/udev") == 0)
-        {
+                 strcmp(value, "server/udev") == 0) {
             ErrorF("Ignoring device from udev.\n");
             return BadValue;
         }
@@ -2317,7 +2280,8 @@ NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
 
     if (pi) {
         *pdev = pi->dixdev;
-    } else if(ki) {
+    }
+    else if (ki) {
         *pdev = ki->dixdev;
     }
 
diff --git a/xorg-server/hw/kdrive/src/kmode.c b/xorg-server/hw/kdrive/src/kmode.c
index 38b7bc881..ef1b6b4fa 100644
--- a/xorg-server/hw/kdrive/src/kmode.c
+++ b/xorg-server/hw/kdrive/src/kmode.c
@@ -26,223 +26,222 @@
 #endif
 #include "kdrive.h"
 
-const KdMonitorTiming  kdMonitorTimings[] = {
-    /*	H	V	Hz	KHz */
-		/*  FP	    BP	    BLANK   POLARITY */
+const KdMonitorTiming kdMonitorTimings[] = {
+    /*  H       V       Hz      KHz */
+    /*  FP      BP      BLANK   POLARITY */
 
     /* IPAQ modeline:
      *
      * Modeline "320x240"      5.7222 320 337 340 352   240 241 244 254"
      */
-    {   320,	240,	64,	16256,
-	            17,	    12,	    32,     KdSyncNegative,
-	            1,      11,     14,     KdSyncNegative,
-    },
+    {320, 240, 64, 16256,
+     17, 12, 32, KdSyncNegative,
+     1, 11, 14, KdSyncNegative,
+     },
 
     /* Other VESA modes */
-    {	640,	350,	85,	31500,			    /* VESA */
-		    32,	    96,	    192,    KdSyncPositive, /* 26.413 */
-		    32,	    60,	    95,	    KdSyncNegative, /* 59.354 */
-    },
-    {	640,	400,	60,	31500,			    /* VESA */
-		    32,	    96,	    192,    KdSyncNegative, /* 26.413 */
-		    1,	    41,	    45,	    KdSyncPositive, /* 59.354 */
-    },
-    {	720,	400,	85,	35500,			    /* VESA */
-		    36,	    108,    216,    KdSyncNegative, /* 37.927 */
-		    1,	    42,	    46,	    KdSyncPositive, /* 85.039 */
-    },
-
+    {640, 350, 85, 31500,       /* VESA */
+     32, 96, 192, KdSyncPositive,       /* 26.413 */
+     32, 60, 95, KdSyncNegative,        /* 59.354 */
+     },
+    {640, 400, 60, 31500,       /* VESA */
+     32, 96, 192, KdSyncNegative,       /* 26.413 */
+     1, 41, 45, KdSyncPositive, /* 59.354 */
+     },
+    {720, 400, 85, 35500,       /* VESA */
+     36, 108, 216, KdSyncNegative,      /* 37.927 */
+     1, 42, 46, KdSyncPositive, /* 85.039 */
+     },
 
     /* Modeline "720x576"     29.000 720  736  800  880   576  577  580  625 */
     {
-        720,    576,    52,     32954,                      /* PAL Video */
-        16,     80,  160, KdSyncPositive, /* 32.954 */
-        1,      45,   49, KdSyncPositive, /* 52.727 */
-    },
+     720, 576, 52, 32954,       /* PAL Video */
+     16, 80, 160, KdSyncPositive,       /* 32.954 */
+     1, 45, 49, KdSyncPositive, /* 52.727 */
+     },
 
     /* 640x480 modes */
-    {	640,	480,	85,	36000,			    /* VESA */
-		    56,	    80,	    192,    KdSyncNegative, /* 43.269 */
-		    1,	    25,	    29,	    KdSyncNegative, /* 85.008 */
-    },
-    {	640,	480,	75,	31500,			    /* VESA */
-		    16,	    120,    200,    KdSyncNegative, /* 37.500 */
-		    1,	    16,	    20,	    KdSyncNegative, /* 75.000 */
-    },
-    {	640,	480,	72,	31500,			    /* VESA */
-		    16,	    120,    176,    KdSyncNegative, /* 37.861 */
-		    1,	    20,	    24,	    KdSyncNegative, /* 72.809 */
-    },
-    {	640,	480,	60,	25175,			    /* VESA */
-		   16,	    48,	    160,    KdSyncNegative, /* 31.469 */
-		   10,	    33,	    45,	    KdSyncNegative, /* 59.940 */
-    },
+    {640, 480, 85, 36000,       /* VESA */
+     56, 80, 192, KdSyncNegative,       /* 43.269 */
+     1, 25, 29, KdSyncNegative, /* 85.008 */
+     },
+    {640, 480, 75, 31500,       /* VESA */
+     16, 120, 200, KdSyncNegative,      /* 37.500 */
+     1, 16, 20, KdSyncNegative, /* 75.000 */
+     },
+    {640, 480, 72, 31500,       /* VESA */
+     16, 120, 176, KdSyncNegative,      /* 37.861 */
+     1, 20, 24, KdSyncNegative, /* 72.809 */
+     },
+    {640, 480, 60, 25175,       /* VESA */
+     16, 48, 160, KdSyncNegative,       /* 31.469 */
+     10, 33, 45, KdSyncNegative,        /* 59.940 */
+     },
 
     /* 800x600 modes */
-    {	800,	600,	85,	56250,			    /* VESA */
-		    32,	    152,    248,    KdSyncPositive, /* 53.674 */
-		    1,	    27,	    31,	    KdSyncPositive, /* 85.061 */
-    },
-    {	800,	600,	75,	49500,			    /* VESA */
-		    16,	    160,    256,    KdSyncPositive, /* 46.875 */
-		    1,	    21,	    25,	    KdSyncPositive, /* 75.000 */
-    },
+    {800, 600, 85, 56250,       /* VESA */
+     32, 152, 248, KdSyncPositive,      /* 53.674 */
+     1, 27, 31, KdSyncPositive, /* 85.061 */
+     },
+    {800, 600, 75, 49500,       /* VESA */
+     16, 160, 256, KdSyncPositive,      /* 46.875 */
+     1, 21, 25, KdSyncPositive, /* 75.000 */
+     },
     /* DEFAULT */
 #define MONITOR_TIMING_DEFAULT	9
-    {	800,	600,	72,	50000,			    /* VESA */
-		    56,	    64,	    240,    KdSyncPositive, /* 48.077 */
-		    37,	    23,	    66,	    KdSyncPositive, /* 72.188 */
-    },
-    {	800,	600,	60,	40000,			    /* VESA */
-		    40,	    88,	    256,    KdSyncPositive, /* 37.879 */
-		    1,	    23,	    28,	    KdSyncPositive, /* 60.317 */
-    },
-    {	800,	600,	56,	36000,			    /* VESA */
-		    24,	    128,    224,    KdSyncPositive, /* 35.156 */
-		    1,	    22,	    25,	    KdSyncPositive, /* 56.250 */
-    },
+    {800, 600, 72, 50000,       /* VESA */
+     56, 64, 240, KdSyncPositive,       /* 48.077 */
+     37, 23, 66, KdSyncPositive,        /* 72.188 */
+     },
+    {800, 600, 60, 40000,       /* VESA */
+     40, 88, 256, KdSyncPositive,       /* 37.879 */
+     1, 23, 28, KdSyncPositive, /* 60.317 */
+     },
+    {800, 600, 56, 36000,       /* VESA */
+     24, 128, 224, KdSyncPositive,      /* 35.156 */
+     1, 22, 25, KdSyncPositive, /* 56.250 */
+     },
 
     /* 1024x768 modes */
-    {	1024,	768,	85,	94500,			    /* VESA */
-		    48,	    208,    352,    KdSyncPositive, /* 68.677 */
-		    1,	    36,	    40,	    KdSyncPositive, /* 84.997 */
-    },
-    {	1024,	768,	75,	78750,			    /* VESA */
-		    16,	    176,    288,    KdSyncPositive, /* 60.023 */
-		    1,	    28,	    32,	    KdSyncPositive, /* 75.029 */
-    },
-    {	1024,	768,	70,	75000,			    /* VESA */
-		    24,	    144,    304,    KdSyncNegative, /* 56.476 */
-		    3,	    29,	    38,	    KdSyncNegative, /* 70.069 */
-    },
-    {	1024,	768,	60,	65000,			    /* VESA */
-		    24,	    160,    320,    KdSyncNegative, /* 48.363 */
-		    3,	    29,	    38,	    KdSyncNegative, /* 60.004 */
-    },
+    {1024, 768, 85, 94500,      /* VESA */
+     48, 208, 352, KdSyncPositive,      /* 68.677 */
+     1, 36, 40, KdSyncPositive, /* 84.997 */
+     },
+    {1024, 768, 75, 78750,      /* VESA */
+     16, 176, 288, KdSyncPositive,      /* 60.023 */
+     1, 28, 32, KdSyncPositive, /* 75.029 */
+     },
+    {1024, 768, 70, 75000,      /* VESA */
+     24, 144, 304, KdSyncNegative,      /* 56.476 */
+     3, 29, 38, KdSyncNegative, /* 70.069 */
+     },
+    {1024, 768, 60, 65000,      /* VESA */
+     24, 160, 320, KdSyncNegative,      /* 48.363 */
+     3, 29, 38, KdSyncNegative, /* 60.004 */
+     },
 
     /* 1152x864 mode */
-    {	1152,	864,	75,	108000,			    /* VESA */
-		    64,	    256,    448,    KdSyncPositive, /* 67.500 */
-		    1,	    32,	    36,	    KdSyncPositive, /* 75.000 */
-    },
+    {1152, 864, 75, 108000,     /* VESA */
+     64, 256, 448, KdSyncPositive,      /* 67.500 */
+     1, 32, 36, KdSyncPositive, /* 75.000 */
+     },
 
     /* 1152x900 modes */
-    {	1152,	900,	85,	122500,			    /* ADDED */
-		    48,	    208,    384,    KdSyncPositive, /* 79.753 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 85.024 */
-    },
-    {	1152,	900,	75,	108250,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 70.475 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 75.133 */
-    },
-    {	1152,	900,	70,	100250,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 65.267 */
-		    2,	    32,	    38,	    KdSyncPositive, /* 69.581 */
-    },
-    {	1152,	900,	66,	95000,			    /* ADDED */
-		    32,	    208,    384,    KdSyncPositive, /* 61.849 */
-		    1,	    32,	    38,	    KdSyncPositive, /* 65.937 */
-    },
+    {1152, 900, 85, 122500,     /* ADDED */
+     48, 208, 384, KdSyncPositive,      /* 79.753 */
+     1, 32, 38, KdSyncPositive, /* 85.024 */
+     },
+    {1152, 900, 75, 108250,     /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 70.475 */
+     1, 32, 38, KdSyncPositive, /* 75.133 */
+     },
+    {1152, 900, 70, 100250,     /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 65.267 */
+     2, 32, 38, KdSyncPositive, /* 69.581 */
+     },
+    {1152, 900, 66, 95000,      /* ADDED */
+     32, 208, 384, KdSyncPositive,      /* 61.849 */
+     1, 32, 38, KdSyncPositive, /* 65.937 */
+     },
 
     /* 1280x854 modes */
-    {   1280,   854,   103,     12500,			    /* ADDED */
-	            56,     16,     128,    KdSyncPositive, /* 102.554 */
-	            1,     216,     12,     KdSyncPositive,
-    },
+    {1280, 854, 103, 12500,     /* ADDED */
+     56, 16, 128, KdSyncPositive,       /* 102.554 */
+     1, 216, 12, KdSyncPositive,
+     },
 
     /* 1280x960 modes */
-    {	1280,	960,	85,	148500,			    /* VESA */
-		    64,	    224,    448,    KdSyncPositive, /* 85.938 */
-		    1,	    47,	    51,	    KdSyncPositive, /* 85.002 */
-    },
-    {	1280,	960,	60,	108000,			    /* VESA */
-		    96,	    312,    520,    KdSyncPositive, /* 60.000 */
-		    1,	    36,	    40,	    KdSyncPositive, /* 60.000 */
-    },
+    {1280, 960, 85, 148500,     /* VESA */
+     64, 224, 448, KdSyncPositive,      /* 85.938 */
+     1, 47, 51, KdSyncPositive, /* 85.002 */
+     },
+    {1280, 960, 60, 108000,     /* VESA */
+     96, 312, 520, KdSyncPositive,      /* 60.000 */
+     1, 36, 40, KdSyncPositive, /* 60.000 */
+     },
 
     /* 1280x1024 modes */
-    {	1280,	1024,	85,	157500,			    /* VESA */
-		    64,	    224,    448,    KdSyncPositive, /* 91.146 */
-		    1,	    44,	    48,	    KdSyncPositive, /* 85.024 */
-    },
-    {	1280,	1024,	75,	135000,			    /* VESA */
-		    16,	    248,    408,    KdSyncPositive, /* 79.976 */
-		    1,	    38,	    42,	    KdSyncPositive, /* 75.025 */
-    },
-    {	1280,	1024,	60,	108000,			    /* VESA */
-		    48,	    248,    408,    KdSyncPositive, /* 63.981 */
-		    1,	    38,	    42,	    KdSyncPositive, /* 60.020 */
-    },
+    {1280, 1024, 85, 157500,    /* VESA */
+     64, 224, 448, KdSyncPositive,      /* 91.146 */
+     1, 44, 48, KdSyncPositive, /* 85.024 */
+     },
+    {1280, 1024, 75, 135000,    /* VESA */
+     16, 248, 408, KdSyncPositive,      /* 79.976 */
+     1, 38, 42, KdSyncPositive, /* 75.025 */
+     },
+    {1280, 1024, 60, 108000,    /* VESA */
+     48, 248, 408, KdSyncPositive,      /* 63.981 */
+     1, 38, 42, KdSyncPositive, /* 60.020 */
+     },
 
     /* 1600x1200 modes */
-    {	1600,	1200,	85,	229500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 106.250 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 85.000 */
-    },
-    {	1600,	1200,	75,	202500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 93.750 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 75.000 */
-    },
-    {	1600,	1200,	70,	189000,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 87.500 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 70.000 */
-    },
-    {	1600,	1200,	65,	175500,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 81.250 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 65.000 */
-    },
-    {	1600,	1200,	60,	162000,			    /* VESA */
-		    64,	    304,    560,    KdSyncPositive, /* 75.000 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 60.000 */
-    },
+    {1600, 1200, 85, 229500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 106.250 */
+     1, 46, 50, KdSyncPositive, /* 85.000 */
+     },
+    {1600, 1200, 75, 202500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 93.750 */
+     1, 46, 50, KdSyncPositive, /* 75.000 */
+     },
+    {1600, 1200, 70, 189000,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 87.500 */
+     1, 46, 50, KdSyncPositive, /* 70.000 */
+     },
+    {1600, 1200, 65, 175500,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 81.250 */
+     1, 46, 50, KdSyncPositive, /* 65.000 */
+     },
+    {1600, 1200, 60, 162000,    /* VESA */
+     64, 304, 560, KdSyncPositive,      /* 75.000 */
+     1, 46, 50, KdSyncPositive, /* 60.000 */
+     },
 
     /* 1792x1344 modes */
-    {	1792,	1344,	85,	301500,			    /* ADDED */
-		    96,	    352,    672,    KdSyncNegative, /* 122.362 */
-		    1,	    92,	    96,	    KdSyncPositive, /* 84.974 */
-    },
-    {	1792,	1344,	75,	261000,			    /* VESA */
-		    96,	    352,    664,    KdSyncNegative, /* 106.270 */
-		    1,	    69,	    73,	    KdSyncPositive, /* 74.997 */
-    },
-    {	1792,	1344,	60,	204750,			    /* VESA */
-		    128,    328,    656,    KdSyncNegative, /* 83.640 */
-		    1,	    46,	    50,	    KdSyncPositive, /* 60.000 */
-    },
+    {1792, 1344, 85, 301500,    /* ADDED */
+     96, 352, 672, KdSyncNegative,      /* 122.362 */
+     1, 92, 96, KdSyncPositive, /* 84.974 */
+     },
+    {1792, 1344, 75, 261000,    /* VESA */
+     96, 352, 664, KdSyncNegative,      /* 106.270 */
+     1, 69, 73, KdSyncPositive, /* 74.997 */
+     },
+    {1792, 1344, 60, 204750,    /* VESA */
+     128, 328, 656, KdSyncNegative,     /* 83.640 */
+     1, 46, 50, KdSyncPositive, /* 60.000 */
+     },
 
 #if 0
-    { 1800, 1012, 75 },
-    { 1906, 1072, 68 },
+    {1800, 1012, 75},
+    {1906, 1072, 68},
 #endif
 
     /* 1856x1392 modes */
-    {	1856,	1392,	85,	330500,			    /* ADDED */
-		    160,    352,    736,    KdSyncNegative, /* 127.508 */
-		    1,	    104,    108,    KdSyncPositive, /* 85.001 */
-    },
-    {	1856,	1392,	75,	288000,			    /* VESA */
-		    128,    352,    704,    KdSyncNegative, /* 112.500 */
-		    1,	    104,    108,    KdSyncPositive, /* 75.000 */
-    },
-    {	1856,	1392,	60,	218250,			    /* VESA */
-		    96,	    352,    672,    KdSyncNegative, /* 86.333 */
-		    1,	    43,	    47,	    KdSyncPositive, /* 59.995 */
-    },
+    {1856, 1392, 85, 330500,    /* ADDED */
+     160, 352, 736, KdSyncNegative,     /* 127.508 */
+     1, 104, 108, KdSyncPositive,       /* 85.001 */
+     },
+    {1856, 1392, 75, 288000,    /* VESA */
+     128, 352, 704, KdSyncNegative,     /* 112.500 */
+     1, 104, 108, KdSyncPositive,       /* 75.000 */
+     },
+    {1856, 1392, 60, 218250,    /* VESA */
+     96, 352, 672, KdSyncNegative,      /* 86.333 */
+     1, 43, 47, KdSyncPositive, /* 59.995 */
+     },
 
     /* 1920x1440 modes */
-    {	1920,	1440,	85,	341750,			    /* ADDED */
-		    160,    352,    760,    KdSyncNegative, /* 127.512 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 85.012 */
-    },
-    {	1920,	1440,	75,	297000,			    /* VESA */
-		    144,    352,    720,    KdSyncNegative, /* 112.500 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 75.000 */
-    },
-    {	1920,	1440,	60,	234000,			    /* VESA */
-		    128,    244,    680,    KdSyncNegative, /* 90.000 */
-		    1,	    56,	    60,	    KdSyncPositive, /* 60.000 */
-    },
+    {1920, 1440, 85, 341750,    /* ADDED */
+     160, 352, 760, KdSyncNegative,     /* 127.512 */
+     1, 56, 60, KdSyncPositive, /* 85.012 */
+     },
+    {1920, 1440, 75, 297000,    /* VESA */
+     144, 352, 720, KdSyncNegative,     /* 112.500 */
+     1, 56, 60, KdSyncPositive, /* 75.000 */
+     },
+    {1920, 1440, 60, 234000,    /* VESA */
+     128, 244, 680, KdSyncNegative,     /* 90.000 */
+     1, 56, 60, KdSyncPositive, /* 60.000 */
+     },
 };
 
 #define NUM_MONITOR_TIMINGS (sizeof kdMonitorTimings/sizeof kdMonitorTimings[0])
@@ -250,148 +249,129 @@ const KdMonitorTiming  kdMonitorTimings[] = {
 const int kdNumMonitorTimings = NUM_MONITOR_TIMINGS;
 
 const KdMonitorTiming *
-KdFindMode (KdScreenInfo    *screen,
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *))
+KdFindMode(KdScreenInfo * screen,
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *))
 {
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if ((*supported) (screen, t) &&
-	    t->horizontal == screen->width &&
-	    t->vertical == screen->height &&
-	    (!screen->rate || t->rate <= screen->rate))
-	{
-	    return t;
-	}
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if ((*supported) (screen, t) &&
+            t->horizontal == screen->width &&
+            t->vertical == screen->height &&
+            (!screen->rate || t->rate <= screen->rate)) {
+            return t;
+        }
     }
     ErrorF("Warning: mode not found, using default\n");
     return &kdMonitorTimings[MONITOR_TIMING_DEFAULT];
 }
 
 static const KdMonitorTiming *
-kdFindPrevSize (const KdMonitorTiming *old)
+kdFindPrevSize(const KdMonitorTiming * old)
 {
-    const KdMonitorTiming   *new, *prev;
+    const KdMonitorTiming *new, *prev;
 
     if (old == kdMonitorTimings)
-	return 0;
+        return 0;
     new = old;
     /*
      * Search for the previous size
      */
-    while (new != kdMonitorTimings)
-    {
-	new--;
-	if (new->horizontal != old->horizontal &&
-	    new->vertical != old->vertical)
-	{
-	    break;
-	}
+    while (new != kdMonitorTimings) {
+        new--;
+        if (new->horizontal != old->horizontal &&
+            new->vertical != old->vertical) {
+            break;
+        }
     }
     /*
      * Match the refresh rate (<=)
      */
-    while (new != kdMonitorTimings)
-    {
-	prev = new - 1;
-	if (prev->horizontal == new->horizontal &&
-	    prev->vertical == new->vertical &&
-	    prev->rate > old->rate)
-	{
-	    break;
-	}
-	new--;
+    while (new != kdMonitorTimings) {
+        prev = new - 1;
+        if (prev->horizontal == new->horizontal &&
+            prev->vertical == new->vertical && prev->rate > old->rate) {
+            break;
+        }
+        new--;
     }
     return new;
 }
 
 Bool
-KdTuneMode (KdScreenInfo    *screen,
-	    Bool	    (*usable) (KdScreenInfo *),
-	    Bool	    (*supported) (KdScreenInfo *,
-					  const KdMonitorTiming *))
+KdTuneMode(KdScreenInfo * screen,
+           Bool (*usable) (KdScreenInfo *),
+           Bool (*supported) (KdScreenInfo *, const KdMonitorTiming *))
 {
-    const KdMonitorTiming   *t;
-
-    while (!(*usable) (screen))
-    {
-	/*
-	 * Fix requested depth and geometry until it works
-	 */
-	if (screen->fb.depth > 16)
-	    screen->fb.depth = 16;
-	else if (screen->fb.depth > 8)
-	    screen->fb.depth = 8;
-	else
-	{
-	    t = kdFindPrevSize (KdFindMode (screen, supported));
-	    if (!t)
-		return FALSE;
-	    screen->width = t->horizontal;
-	    screen->height = t->vertical;
-	    screen->rate = t->rate;
-	}
+    const KdMonitorTiming *t;
+
+    while (!(*usable) (screen)) {
+        /*
+         * Fix requested depth and geometry until it works
+         */
+        if (screen->fb.depth > 16)
+            screen->fb.depth = 16;
+        else if (screen->fb.depth > 8)
+            screen->fb.depth = 8;
+        else {
+            t = kdFindPrevSize(KdFindMode(screen, supported));
+            if (!t)
+                return FALSE;
+            screen->width = t->horizontal;
+            screen->height = t->vertical;
+            screen->rate = t->rate;
+        }
     }
     return TRUE;
 }
 
 #ifdef RANDR
 Bool
-KdRandRGetInfo (ScreenPtr pScreen,
-		int randr,
-		Bool (*supported) (ScreenPtr pScreen,
-				   const KdMonitorTiming *))
+KdRandRGetInfo(ScreenPtr pScreen,
+               int randr,
+               Bool (*supported) (ScreenPtr pScreen, const KdMonitorTiming *))
 {
     KdScreenPriv(pScreen);
-    KdScreenInfo	    *screen = pScreenPriv->screen;
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if ((*supported) (pScreen, t))
-	{
-	    RRScreenSizePtr pSize;
-
-	    pSize = RRRegisterSize (pScreen,
-				    t->horizontal,
-				    t->vertical,
-				    screen->width_mm,
-				    screen->height_mm);
-	    if (!pSize)
-		return FALSE;
-	    if (!RRRegisterRate (pScreen, pSize, t->rate))
-		return FALSE;
-	    if (t->horizontal == screen->width &&
-		t->vertical == screen->height &&
-		t->rate == screen->rate)
-		RRSetCurrentConfig (pScreen, randr, t->rate, pSize);
-	}
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if ((*supported) (pScreen, t)) {
+            RRScreenSizePtr pSize;
+
+            pSize = RRRegisterSize(pScreen,
+                                   t->horizontal,
+                                   t->vertical,
+                                   screen->width_mm, screen->height_mm);
+            if (!pSize)
+                return FALSE;
+            if (!RRRegisterRate(pScreen, pSize, t->rate))
+                return FALSE;
+            if (t->horizontal == screen->width &&
+                t->vertical == screen->height && t->rate == screen->rate)
+                RRSetCurrentConfig(pScreen, randr, t->rate, pSize);
+        }
     }
 
     return TRUE;
 }
 
 const KdMonitorTiming *
-KdRandRGetTiming (ScreenPtr	    pScreen,
-		  Bool		    (*supported) (ScreenPtr pScreen,
-						  const KdMonitorTiming *),
-		  int		    rate,
-		  RRScreenSizePtr   pSize)
+KdRandRGetTiming(ScreenPtr pScreen,
+                 Bool (*supported) (ScreenPtr pScreen,
+                                    const KdMonitorTiming *),
+                 int rate, RRScreenSizePtr pSize)
 {
-    int			    i;
-    const KdMonitorTiming   *t;
-
-    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++)
-    {
-	if (t->horizontal == pSize->width &&
-	    t->vertical == pSize->height &&
-	    t->rate == rate &&
-	    (*supported) (pScreen, t))
-	    return t;
+    int i;
+    const KdMonitorTiming *t;
+
+    for (i = 0, t = kdMonitorTimings; i < NUM_MONITOR_TIMINGS; i++, t++) {
+        if (t->horizontal == pSize->width &&
+            t->vertical == pSize->height &&
+            t->rate == rate && (*supported) (pScreen, t))
+            return t;
     }
     return 0;
 }
diff --git a/xorg-server/hw/kdrive/src/kshadow.c b/xorg-server/hw/kdrive/src/kshadow.c
index 63bb87bc6..828ea19a6 100644
--- a/xorg-server/hw/kdrive/src/kshadow.c
+++ b/xorg-server/hw/kdrive/src/kshadow.c
@@ -26,21 +26,21 @@
 #include "kdrive.h"
 
 Bool
-KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate)
+KdShadowFbAlloc(KdScreenInfo * screen, Bool rotate)
 {
-    int	    paddedWidth;
-    void    *buf;
-    int	    width = rotate ? screen->height : screen->width;
-    int	    height = rotate ? screen->width : screen->height;
-    int	    bpp = screen->fb.bitsPerPixel;
+    int paddedWidth;
+    void *buf;
+    int width = rotate ? screen->height : screen->width;
+    int height = rotate ? screen->width : screen->height;
+    int bpp = screen->fb.bitsPerPixel;
 
     /* use fb computation for width */
-    paddedWidth = ((width * bpp + FB_MASK) >> FB_SHIFT) * sizeof (FbBits);
+    paddedWidth = ((width * bpp + FB_MASK) >> FB_SHIFT) * sizeof(FbBits);
     buf = malloc(paddedWidth * height);
     if (!buf)
-	return FALSE;
+        return FALSE;
     if (screen->fb.shadow)
-	free(screen->fb.frameBuffer);
+        free(screen->fb.frameBuffer);
     screen->fb.shadow = TRUE;
     screen->fb.frameBuffer = buf;
     screen->fb.byteStride = paddedWidth;
@@ -49,33 +49,32 @@ KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate)
 }
 
 void
-KdShadowFbFree (KdScreenInfo *screen)
+KdShadowFbFree(KdScreenInfo * screen)
 {
-    if (screen->fb.shadow)
-    {
-	free(screen->fb.frameBuffer);
-	screen->fb.frameBuffer = 0;
-	screen->fb.shadow = FALSE;
+    if (screen->fb.shadow) {
+        free(screen->fb.frameBuffer);
+        screen->fb.frameBuffer = 0;
+        screen->fb.shadow = FALSE;
     }
 }
 
 Bool
-KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window)
+KdShadowSet(ScreenPtr pScreen, int randr, ShadowUpdateProc update,
+            ShadowWindowProc window)
 {
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
 
-    shadowRemove (pScreen, pScreen->GetScreenPixmap(pScreen));
-    if(screen->fb.shadow)
-    {
-	return shadowAdd (pScreen, pScreen->GetScreenPixmap(pScreen),
-			  update, window, randr, 0);
+    shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
+    if (screen->fb.shadow) {
+        return shadowAdd(pScreen, pScreen->GetScreenPixmap(pScreen),
+                         update, window, randr, 0);
     }
     return TRUE;
 }
 
 void
-KdShadowUnset (ScreenPtr pScreen)
+KdShadowUnset(ScreenPtr pScreen)
 {
     shadowRemove(pScreen, pScreen->GetScreenPixmap(pScreen));
 }
diff --git a/xorg-server/hw/kdrive/src/kxv.c b/xorg-server/hw/kdrive/src/kxv.c
index e76a2c419..7097aee5c 100644
--- a/xorg-server/hw/kdrive/src/kxv.c
+++ b/xorg-server/hw/kdrive/src/kxv.c
@@ -1,1906 +1,1891 @@
-/*

-

-   XFree86 Xv DDX written by Mark Vojkovich (markv@valinux.com)

-   Adapted for KDrive by Pontus Lidman <pontus.lidman@nokia.com>

-

-   Copyright (C) 2000, 2001 - Nokia Home Communications

-   Copyright (C) 1998, 1999 - The XFree86 Project Inc.

-

-All rights reserved.

-

-Permission is hereby granted, free of charge, to any person obtaining

-a copy of this software and associated documentation files (the

-"Software"), to deal in the Software without restriction, including

-without limitation the rights to use, copy, modify, merge, publish,

-distribute, and/or sell copies of the Software, and to permit persons

-to whom the Software is furnished to do so, provided that the above

-copyright notice(s) and this permission notice appear in all copies of

-the Software and that both the above copyright notice(s) and this

-permission notice appear in supporting documentation.

-

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT

-OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

-HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY

-SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER

-RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF

-CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

-CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-Except as contained in this notice, the name of a copyright holder

-shall not be used in advertising or otherwise to promote the sale, use

-or other dealings in this Software without prior written authorization

-of the copyright holder.

-

-*/

-

-#ifdef HAVE_CONFIG_H

-#include <kdrive-config.h>

-#endif

-#include "kdrive.h"

-

-#include "scrnintstr.h"

-#include "regionstr.h"

-#include "windowstr.h"

-#include "pixmapstr.h"

-#include "mivalidate.h"

-#include "validate.h"

-#include "resource.h"

-#include "gcstruct.h"

-#include "dixstruct.h"

-

-#include <X11/extensions/Xv.h>

-#include <X11/extensions/Xvproto.h>

-

-#include "kxv.h"

-#include "fourcc.h"

-

-

-/* XvScreenRec fields */

-

-static Bool KdXVCloseScreen(int, ScreenPtr);

-static int KdXVQueryAdaptors(ScreenPtr, XvAdaptorPtr *, int *);

-

-/* XvAdaptorRec fields */

-

-static int KdXVAllocatePort(unsigned long, XvPortPtr, XvPortPtr*);

-static int KdXVFreePort(XvPortPtr);

-static int KdXVPutVideo(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,

-   				INT16, INT16, CARD16, CARD16,

-				INT16, INT16, CARD16, CARD16);

-static int KdXVPutStill(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,

-   				INT16, INT16, CARD16, CARD16,

-				INT16, INT16, CARD16, CARD16);

-static int KdXVGetVideo(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,

-   				INT16, INT16, CARD16, CARD16,

-				INT16, INT16, CARD16, CARD16);

-static int KdXVGetStill(ClientPtr, DrawablePtr,XvPortPtr, GCPtr,

-   				INT16, INT16, CARD16, CARD16,

-				INT16, INT16, CARD16, CARD16);

-static int KdXVStopVideo(ClientPtr, XvPortPtr, DrawablePtr);

-static int KdXVSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32);

-static int KdXVGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32 *);

-static int KdXVQueryBestSize(ClientPtr, XvPortPtr, CARD8,

-   				CARD16, CARD16,CARD16, CARD16,

-				unsigned int*, unsigned int*);

-static int KdXVPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,

-   				INT16, INT16, CARD16, CARD16,

-				INT16, INT16, CARD16, CARD16,

-				XvImagePtr, unsigned char*, Bool,

-				CARD16, CARD16);

-static int KdXVQueryImageAttributes(ClientPtr, XvPortPtr, XvImagePtr,

-				CARD16*, CARD16*, int*, int*);

-

-

-/* ScreenRec fields */

-

-static Bool KdXVCreateWindow(WindowPtr pWin);

-static Bool KdXVDestroyWindow(WindowPtr pWin);

-static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2);

-static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);

-

-/* misc */

-static Bool KdXVInitAdaptors(ScreenPtr, KdVideoAdaptorPtr*, int);

-

-static DevPrivateKeyRec KdXVWindowKeyRec;

-#define KdXVWindowKey (&KdXVWindowKeyRec)

-static DevPrivateKey KdXvScreenKey;

-static unsigned long KdXVGeneration = 0;

-static unsigned long PortResource = 0;

-

-DevPrivateKey (*XvGetScreenKeyProc)(void) = XvGetScreenKey;

-unsigned long (*XvGetRTPortProc)(void) = XvGetRTPort;

-int (*XvScreenInitProc)(ScreenPtr) = XvScreenInit;

-

-#define GET_XV_SCREEN(pScreen) ((XvScreenPtr) \

-    dixLookupPrivate(&(pScreen)->devPrivates, KdXvScreenKey))

-

-#define GET_KDXV_SCREEN(pScreen) \

-  	((KdXVScreenPtr)(GET_XV_SCREEN(pScreen)->devPriv.ptr))

-

-#define GET_KDXV_WINDOW(pWin) ((KdXVWindowPtr) \

-    dixLookupPrivate(&(pWin)->devPrivates, KdXVWindowKey))

-

-static KdXVInitGenericAdaptorPtr *GenDrivers = NULL;

-static int NumGenDrivers = 0;

-

-int

-KdXVRegisterGenericAdaptorDriver(

-    KdXVInitGenericAdaptorPtr InitFunc

-){

-  KdXVInitGenericAdaptorPtr *newdrivers;

-

-/*   fprintf(stderr,"KdXVRegisterGenericAdaptorDriver\n"); */

-

-  newdrivers = realloc(GenDrivers, sizeof(KdXVInitGenericAdaptorPtr) *

-			(1 + NumGenDrivers));

-  if (!newdrivers)

-    return 0;

-  GenDrivers = newdrivers;

-

-  GenDrivers[NumGenDrivers++] = InitFunc;

-

-  return 1;

-}

-

-int

-KdXVListGenericAdaptors(

-    KdScreenInfo *          screen,

-    KdVideoAdaptorPtr **adaptors

-){

-    int i,j,n,num;

-    KdVideoAdaptorPtr *DrivAdap,*new;

-

-    num = 0;

-    *adaptors = NULL;

-    for (i = 0; i < NumGenDrivers; i++) {

-	n = GenDrivers[i](screen,&DrivAdap);

-	if (0 == n)

-	    continue;

-	new = realloc(*adaptors, sizeof(KdVideoAdaptorPtr) * (num+n));

-	if (NULL == new)

-	    continue;

-	*adaptors = new;

-	for (j = 0; j < n; j++, num++)

-	    (*adaptors)[num] = DrivAdap[j];

-    }

-    return num;

-}

-

-KdVideoAdaptorPtr

-KdXVAllocateVideoAdaptorRec(KdScreenInfo * screen)

-{

-    return calloc(1, sizeof(KdVideoAdaptorRec));

-}

-

-void

-KdXVFreeVideoAdaptorRec(KdVideoAdaptorPtr ptr)

-{

-    free(ptr);

-}

-

-

-Bool

-KdXVScreenInit(

-   ScreenPtr pScreen,

-   KdVideoAdaptorPtr *adaptors,

-   int num

-){

-  KdXVScreenPtr ScreenPriv;

-  XvScreenPtr pxvs;

-

-/*   fprintf(stderr,"KdXVScreenInit initializing %d adaptors\n",num); */

-

-  if (KdXVGeneration != serverGeneration)

-      KdXVGeneration = serverGeneration;

-

-  if(!XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)

-	return FALSE;

-

-  if (!dixRegisterPrivateKey(&KdXVWindowKeyRec, PRIVATE_WINDOW, 0))

-      return FALSE;

-

-  if(Success != (*XvScreenInitProc)(pScreen)) return FALSE;

-

-  KdXvScreenKey = (*XvGetScreenKeyProc)();

-  PortResource = (*XvGetRTPortProc)();

-

-  pxvs = GET_XV_SCREEN(pScreen);

-

-

-  /* Anyone initializing the Xv layer must provide these two.

-     The Xv di layer calls them without even checking if they exist! */

-

-  pxvs->ddCloseScreen = KdXVCloseScreen;

-  pxvs->ddQueryAdaptors = KdXVQueryAdaptors;

-

-  /* The Xv di layer provides us with a private hook so that we don't

-     have to allocate our own screen private.  They also provide

-     a CloseScreen hook so that we don't have to wrap it.  I'm not

-     sure that I appreciate that.  */

-

-  ScreenPriv = malloc(sizeof(KdXVScreenRec));

-  pxvs->devPriv.ptr = (pointer)ScreenPriv;

-

-  if(!ScreenPriv) return FALSE;

-

-

-  ScreenPriv->CreateWindow = pScreen->CreateWindow;

-  ScreenPriv->DestroyWindow = pScreen->DestroyWindow;

-  ScreenPriv->WindowExposures = pScreen->WindowExposures;

-  ScreenPriv->ClipNotify = pScreen->ClipNotify;

-

-/*   fprintf(stderr,"XV: Wrapping screen funcs\n"); */

-

-  pScreen->CreateWindow = KdXVCreateWindow;

-  pScreen->DestroyWindow = KdXVDestroyWindow;

-  pScreen->WindowExposures = KdXVWindowExposures;

-  pScreen->ClipNotify = KdXVClipNotify;

-

-  if(!KdXVInitAdaptors(pScreen, adaptors, num))

-	return FALSE;

-

-  return TRUE;

-}

-

-static void

-KdXVFreeAdaptor(XvAdaptorPtr pAdaptor)

-{

-   int i;

-

-   free(pAdaptor->name);

-

-   if(pAdaptor->pEncodings) {

-      XvEncodingPtr pEncode = pAdaptor->pEncodings;

-

-      for(i = 0; i < pAdaptor->nEncodings; i++, pEncode++) {

-          free(pEncode->name);

-      }

-      free(pAdaptor->pEncodings);

-   }

-

-   free(pAdaptor->pFormats);

-

-   if(pAdaptor->pPorts) {

-      XvPortPtr pPort = pAdaptor->pPorts;

-      XvPortRecPrivatePtr pPriv;

-

-      for(i = 0; i < pAdaptor->nPorts; i++, pPort++) {

-          pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;

-	  if(pPriv) {

-	     if(pPriv->clientClip)

-		RegionDestroy(pPriv->clientClip);

-             if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		RegionDestroy(pPriv->pCompositeClip);

-	     free(pPriv);

-	  }

-      }

-      free(pAdaptor->pPorts);

-   }

-

-   if(pAdaptor->nAttributes) {

-      XvAttributePtr pAttribute = pAdaptor->pAttributes;

-

-      for(i = 0; i < pAdaptor->nAttributes; i++, pAttribute++) {

-          free(pAttribute->name);

-      }

-

-      free(pAdaptor->pAttributes);

-   }

-

-   free(pAdaptor->pImages);

-

-   free(pAdaptor->devPriv.ptr);

-}

-

-static Bool

-KdXVInitAdaptors(

-   ScreenPtr pScreen,

-   KdVideoAdaptorPtr *infoPtr,

-   int number

-) {

-    KdScreenPriv(pScreen);

-    KdScreenInfo * screen = pScreenPriv->screen;

-

-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);

-  KdVideoAdaptorPtr adaptorPtr;

-  XvAdaptorPtr pAdaptor, pa;

-  XvAdaptorRecPrivatePtr adaptorPriv;

-  int na, numAdaptor;

-  XvPortRecPrivatePtr portPriv;

-  XvPortPtr pPort, pp;

-  int numPort;

-  KdAttributePtr attributePtr;

-  XvAttributePtr pAttribute, pat;

-  KdVideoFormatPtr formatPtr;

-  XvFormatPtr pFormat, pf;

-  int numFormat, totFormat;

-  KdVideoEncodingPtr encodingPtr;

-  XvEncodingPtr pEncode, pe;

-  KdImagePtr imagePtr;

-  XvImagePtr pImage, pi;

-  int numVisuals;

-  VisualPtr pVisual;

-  int i;

-

-  pxvs->nAdaptors = 0;

-  pxvs->pAdaptors = NULL;

-

-  if(!(pAdaptor = calloc(number, sizeof(XvAdaptorRec))))

-      return FALSE;

-

-  for(pa = pAdaptor, na = 0, numAdaptor = 0; na < number; na++, adaptorPtr++) {

-      adaptorPtr = infoPtr[na];

-

-      if(!adaptorPtr->StopVideo || !adaptorPtr->SetPortAttribute ||

-	 !adaptorPtr->GetPortAttribute || !adaptorPtr->QueryBestSize)

-	   continue;

-

-      /* client libs expect at least one encoding */

-      if(!adaptorPtr->nEncodings || !adaptorPtr->pEncodings)

-	   continue;

-

-      pa->type = adaptorPtr->type;

-

-      if(!adaptorPtr->PutVideo && !adaptorPtr->GetVideo)

-	 pa->type &= ~XvVideoMask;

-

-      if(!adaptorPtr->PutStill && !adaptorPtr->GetStill)

-	 pa->type &= ~XvStillMask;

-

-      if(!adaptorPtr->PutImage || !adaptorPtr->QueryImageAttributes)

-	 pa->type &= ~XvImageMask;

-

-      if(!adaptorPtr->PutVideo && !adaptorPtr->PutImage &&

-							  !adaptorPtr->PutStill)

-	 pa->type &= ~XvInputMask;

-

-      if(!adaptorPtr->GetVideo && !adaptorPtr->GetStill)

-	 pa->type &= ~XvOutputMask;

-

-      if(!(adaptorPtr->type & (XvPixmapMask | XvWindowMask)))

-	  continue;

-      if(!(adaptorPtr->type & (XvImageMask | XvVideoMask | XvStillMask)))

-	  continue;

-

-      pa->pScreen = pScreen;

-      pa->ddAllocatePort = KdXVAllocatePort;

-      pa->ddFreePort = KdXVFreePort;

-      pa->ddPutVideo = KdXVPutVideo;

-      pa->ddPutStill = KdXVPutStill;

-      pa->ddGetVideo = KdXVGetVideo;

-      pa->ddGetStill = KdXVGetStill;

-      pa->ddStopVideo = KdXVStopVideo;

-      pa->ddPutImage = KdXVPutImage;

-      pa->ddSetPortAttribute = KdXVSetPortAttribute;

-      pa->ddGetPortAttribute = KdXVGetPortAttribute;

-      pa->ddQueryBestSize = KdXVQueryBestSize;

-      pa->ddQueryImageAttributes = KdXVQueryImageAttributes;

-      pa->name = strdup(adaptorPtr->name);

-

-      if(adaptorPtr->nEncodings &&

-	(pEncode = calloc(adaptorPtr->nEncodings, sizeof(XvEncodingRec)))) {

-

-	for(pe = pEncode, encodingPtr = adaptorPtr->pEncodings, i = 0;

-	    i < adaptorPtr->nEncodings; pe++, i++, encodingPtr++)

-        {

-	    pe->id = encodingPtr->id;

-	    pe->pScreen = pScreen;

-	    pe->name = strdup(encodingPtr->name);

-	    pe->width = encodingPtr->width;

-	    pe->height = encodingPtr->height;

-	    pe->rate.numerator = encodingPtr->rate.numerator;

-	    pe->rate.denominator = encodingPtr->rate.denominator;

-	}

-	pa->nEncodings = adaptorPtr->nEncodings;

-	pa->pEncodings = pEncode;

-      }

-

-      if(adaptorPtr->nImages &&

-         (pImage = calloc(adaptorPtr->nImages, sizeof(XvImageRec)))) {

-

-          for(i = 0, pi = pImage, imagePtr = adaptorPtr->pImages;

-	      i < adaptorPtr->nImages; i++, pi++, imagePtr++)

-  	  {

-	     pi->id = imagePtr->id;

-	     pi->type = imagePtr->type;

-	     pi->byte_order = imagePtr->byte_order;

-	     memcpy(pi->guid, imagePtr->guid, 16);

-	     pi->bits_per_pixel = imagePtr->bits_per_pixel;

-	     pi->format = imagePtr->format;

-	     pi->num_planes = imagePtr->num_planes;

-	     pi->depth = imagePtr->depth;

-	     pi->red_mask = imagePtr->red_mask;

-	     pi->green_mask = imagePtr->green_mask;

-	     pi->blue_mask = imagePtr->blue_mask;

-	     pi->y_sample_bits = imagePtr->y_sample_bits;

-	     pi->u_sample_bits = imagePtr->u_sample_bits;

-	     pi->v_sample_bits = imagePtr->v_sample_bits;

-	     pi->horz_y_period = imagePtr->horz_y_period;

-	     pi->horz_u_period = imagePtr->horz_u_period;

-	     pi->horz_v_period = imagePtr->horz_v_period;

-	     pi->vert_y_period = imagePtr->vert_y_period;

-	     pi->vert_u_period = imagePtr->vert_u_period;

-	     pi->vert_v_period = imagePtr->vert_v_period;

-	     memcpy(pi->component_order, imagePtr->component_order, 32);

-	     pi->scanline_order = imagePtr->scanline_order;

-          }

-	  pa->nImages = adaptorPtr->nImages;

-	  pa->pImages = pImage;

-      }

-

-      if(adaptorPtr->nAttributes &&

-	(pAttribute = calloc(adaptorPtr->nAttributes, sizeof(XvAttributeRec))))

-      {

-	for(pat = pAttribute, attributePtr = adaptorPtr->pAttributes, i = 0;

-	    i < adaptorPtr->nAttributes; pat++, i++, attributePtr++)

-        {

-	    pat->flags = attributePtr->flags;

-	    pat->min_value = attributePtr->min_value;

-	    pat->max_value = attributePtr->max_value;

-	    pat->name = strdup(attributePtr->name);

-	}

-	pa->nAttributes = adaptorPtr->nAttributes;

-	pa->pAttributes = pAttribute;

-      }

-

-

-      totFormat = adaptorPtr->nFormats;

-

-      if(!(pFormat = calloc(totFormat, sizeof(XvFormatRec)))) {

-          KdXVFreeAdaptor(pa);

-          continue;

-      }

-      for(pf = pFormat, i = 0, numFormat = 0, formatPtr = adaptorPtr->pFormats;

-	  i < adaptorPtr->nFormats; i++, formatPtr++)

-      {

-	  numVisuals = pScreen->numVisuals;

-          pVisual = pScreen->visuals;

-

-          while(numVisuals--) {

-              if((pVisual->class == formatPtr->class) &&

-                 (pVisual->nplanes == formatPtr->depth)) {

-

-		   if(numFormat >= totFormat) {

-			void *moreSpace;

-			totFormat *= 2;

-			moreSpace = realloc(pFormat,

-					     totFormat * sizeof(XvFormatRec));

-			if(!moreSpace) break;

-			pFormat = moreSpace;

-			pf = pFormat + numFormat;

-		   }

-

-                   pf->visual = pVisual->vid;

-		   pf->depth = formatPtr->depth;

-

-		   pf++;

-		   numFormat++;

-              }

-              pVisual++;

-          }

-      }

-      pa->nFormats = numFormat;

-      pa->pFormats = pFormat;

-      if(!numFormat) {

-          KdXVFreeAdaptor(pa);

-          continue;

-      }

-

-      if(!(adaptorPriv = calloc(1, sizeof(XvAdaptorRecPrivate)))) {

-          KdXVFreeAdaptor(pa);

-          continue;

-      }

-

-      adaptorPriv->flags = adaptorPtr->flags;

-      adaptorPriv->PutVideo = adaptorPtr->PutVideo;

-      adaptorPriv->PutStill = adaptorPtr->PutStill;

-      adaptorPriv->GetVideo = adaptorPtr->GetVideo;

-      adaptorPriv->GetStill = adaptorPtr->GetStill;

-      adaptorPriv->StopVideo = adaptorPtr->StopVideo;

-      adaptorPriv->SetPortAttribute = adaptorPtr->SetPortAttribute;

-      adaptorPriv->GetPortAttribute = adaptorPtr->GetPortAttribute;

-      adaptorPriv->QueryBestSize = adaptorPtr->QueryBestSize;

-      adaptorPriv->QueryImageAttributes = adaptorPtr->QueryImageAttributes;

-      adaptorPriv->PutImage = adaptorPtr->PutImage;

-      adaptorPriv->ReputImage = adaptorPtr->ReputImage;

-

-      pa->devPriv.ptr = (pointer)adaptorPriv;

-

-      if(!(pPort = calloc(adaptorPtr->nPorts, sizeof(XvPortRec)))) {

-          KdXVFreeAdaptor(pa);

-          continue;

-      }

-      for(pp = pPort, i = 0, numPort = 0;

-	  i < adaptorPtr->nPorts; i++) {

-

-          if(!(pp->id = FakeClientID(0)))

-		continue;

-

-	  if(!(portPriv = calloc(1, sizeof(XvPortRecPrivate))))

-		continue;

-

-	  if(!AddResource(pp->id, PortResource, pp)) {

-		free(portPriv);

-		continue;

-	  }

-

-          pp->pAdaptor = pa;

-          pp->pNotify = (XvPortNotifyPtr)NULL;

-          pp->pDraw = (DrawablePtr)NULL;

-          pp->client = (ClientPtr)NULL;

-          pp->grab.client = (ClientPtr)NULL;

-          pp->time = currentTime;

-          pp->devPriv.ptr = portPriv;

-

-	  portPriv->screen = screen;

-	  portPriv->AdaptorRec = adaptorPriv;

-          portPriv->DevPriv.ptr = adaptorPtr->pPortPrivates[i].ptr;

-

-          pp++;

-          numPort++;

-      }

-      pa->nPorts = numPort;

-      pa->pPorts = pPort;

-      if(!numPort) {

-          KdXVFreeAdaptor(pa);

-          continue;

-      }

-

-      pa->base_id = pPort->id;

-

-      pa++;

-      numAdaptor++;

-  }

-

-  if(numAdaptor) {

-      pxvs->nAdaptors = numAdaptor;

-      pxvs->pAdaptors = pAdaptor;

-  } else {

-     free(pAdaptor);

-     return FALSE;

-  }

-

-  return TRUE;

-}

-

-/* Video should be clipped to the intersection of the window cliplist

-   and the client cliplist specified in the GC for which the video was

-   initialized.  When we need to reclip a window, the GC that started

-   the video may not even be around anymore.  That's why we save the

-   client clip from the GC when the video is initialized.  We then

-   use KdXVUpdateCompositeClip to calculate the new composite clip

-   when we need it.  This is different from what DEC did.  They saved

-   the GC and used it's clip list when they needed to reclip the window,

-   even if the client clip was different from the one the video was

-   initialized with.  If the original GC was destroyed, they had to stop

-   the video.  I like the new method better (MArk).

-

-   This function only works for windows.  Will need to rewrite when

-   (if) we support pixmap rendering.

-*/

-

-static void

-KdXVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)

-{

-   RegionPtr	pregWin, pCompositeClip;

-   WindowPtr	pWin;

-   Bool 	freeCompClip = FALSE;

-

-   if(portPriv->pCompositeClip)

-	return;

-

-   pWin = (WindowPtr)portPriv->pDraw;

-

-   /* get window clip list */

-   if(portPriv->subWindowMode == IncludeInferiors) {

-	pregWin = NotClippedByChildren(pWin);

-	freeCompClip = TRUE;

-   } else

-	pregWin = &pWin->clipList;

-

-   if(!portPriv->clientClip) {

-	portPriv->pCompositeClip = pregWin;

-	portPriv->FreeCompositeClip = freeCompClip;

-	return;

-   }

-

-   pCompositeClip = RegionCreate(NullBox, 1);

-   RegionCopy(pCompositeClip, portPriv->clientClip);

-   RegionTranslate(pCompositeClip,

-			portPriv->pDraw->x + portPriv->clipOrg.x,

-			portPriv->pDraw->y + portPriv->clipOrg.y);

-   RegionIntersect(pCompositeClip, pregWin, pCompositeClip);

-

-   portPriv->pCompositeClip = pCompositeClip;

-   portPriv->FreeCompositeClip = TRUE;

-

-   if(freeCompClip) {

-	RegionDestroy(pregWin);

-   }

-}

-

-/* Save the current clientClip and update the CompositeClip whenever

-   we have a fresh GC */

-

-static void

-KdXVCopyClip(

-   XvPortRecPrivatePtr portPriv,

-   GCPtr pGC

-){

-    /* copy the new clip if it exists */

-    if((pGC->clientClipType == CT_REGION) && pGC->clientClip) {

-	if(!portPriv->clientClip)

-	    portPriv->clientClip = RegionCreate(NullBox, 1);

-	/* Note: this is in window coordinates */

-	RegionCopy(portPriv->clientClip, pGC->clientClip);

-    } else if(portPriv->clientClip) { /* free the old clientClip */

-	RegionDestroy(portPriv->clientClip);

-	portPriv->clientClip = NULL;

-    }

-

-    /* get rid of the old clip list */

-    if(portPriv->pCompositeClip && portPriv->FreeCompositeClip) {

-	RegionDestroy(portPriv->pCompositeClip);

-    }

-

-    portPriv->clipOrg = pGC->clipOrg;

-    portPriv->pCompositeClip = pGC->pCompositeClip;

-    portPriv->FreeCompositeClip = FALSE;

-    portPriv->subWindowMode = pGC->subWindowMode;

-}

-

-static int

-KdXVRegetVideo(XvPortRecPrivatePtr portPriv)

-{

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  KdXVUpdateCompositeClip(portPriv);

-

-  /* translate the video region to the screen */

-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;

-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;

-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;

-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;

-

-  /* clip to the window composite clip */

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

-

-  /* that's all if it's totally obscured */

-  if(!RegionNotEmpty(&ClipRegion)) {

-	clippedAway = TRUE;

-	goto CLIP_VIDEO_BAILOUT;

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->GetVideo)(portPriv->screen, portPriv->pDraw,

-			portPriv->vid_x, portPriv->vid_y,

-			WinBox.x1, WinBox.y1,

-			portPriv->vid_w, portPriv->vid_h,

-			portPriv->drw_w, portPriv->drw_h,

-			&ClipRegion, portPriv->DevPriv.ptr);

-

-  if(ret == Success)

-	portPriv->isOn = XV_ON;

-

-CLIP_VIDEO_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && portPriv->isOn == XV_ON) {

-	(*portPriv->AdaptorRec->StopVideo)(

-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-	portPriv->isOn = XV_PENDING;

-  }

-

-  /* This clip was copied and only good for one shot */

-  if(!portPriv->FreeCompositeClip)

-     portPriv->pCompositeClip = NULL;

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-

-static int

-KdXVReputVideo(XvPortRecPrivatePtr portPriv)

-{

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  ScreenPtr pScreen = portPriv->pDraw->pScreen;

-  KdScreenPriv(pScreen);

-  KdScreenInfo *screen=pScreenPriv->screen;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  KdXVUpdateCompositeClip(portPriv);

-

-  /* translate the video region to the screen */

-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;

-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;

-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;

-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;

-

-  /* clip to the window composite clip */

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

-

-  /* clip and translate to the viewport */

-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

-     RegionRec VPReg;

-     BoxRec VPBox;

-

-     VPBox.x1 = 0;

-     VPBox.y1 = 0;

-     VPBox.x2 = screen->width;

-     VPBox.y2 = screen->height;

-

-     RegionInit(&VPReg, &VPBox, 1);

-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

-     RegionUninit(&VPReg);

-  }

-

-  /* that's all if it's totally obscured */

-  if(!RegionNotEmpty(&ClipRegion)) {

-	clippedAway = TRUE;

-	goto CLIP_VIDEO_BAILOUT;

-  }

-

-  /* bailout if we have to clip but the hardware doesn't support it */

-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = RegionRects(&ClipRegion);

-     if(  (RegionNumRects(&ClipRegion) != 1) ||

-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

-     {

-	    clippedAway = TRUE;

-	    goto CLIP_VIDEO_BAILOUT;

-     }

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->PutVideo)(portPriv->screen, portPriv->pDraw,

-			portPriv->vid_x, portPriv->vid_y,

-			WinBox.x1, WinBox.y1,

-			portPriv->vid_w, portPriv->vid_h,

-			portPriv->drw_w, portPriv->drw_h,

-			&ClipRegion, portPriv->DevPriv.ptr);

-

-  if(ret == Success) portPriv->isOn = XV_ON;

-

-CLIP_VIDEO_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {

-	(*portPriv->AdaptorRec->StopVideo)(

-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-	portPriv->isOn = XV_PENDING;

-  }

-

-  /* This clip was copied and only good for one shot */

-  if(!portPriv->FreeCompositeClip)

-     portPriv->pCompositeClip = NULL;

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-static int

-KdXVReputImage(XvPortRecPrivatePtr portPriv)

-{

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  ScreenPtr pScreen = portPriv->pDraw->pScreen;

-  KdScreenPriv(pScreen);

-  KdScreenInfo *screen=pScreenPriv->screen;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  KdXVUpdateCompositeClip(portPriv);

-

-  /* translate the video region to the screen */

-  WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;

-  WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;

-  WinBox.x2 = WinBox.x1 + portPriv->drw_w;

-  WinBox.y2 = WinBox.y1 + portPriv->drw_h;

-

-  /* clip to the window composite clip */

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);

-

-  /* clip and translate to the viewport */

-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

-     RegionRec VPReg;

-     BoxRec VPBox;

-

-     VPBox.x1 = 0;

-     VPBox.y1 = 0;

-     VPBox.x2 = screen->width;

-     VPBox.y2 = screen->height;

-

-     RegionInit(&VPReg, &VPBox, 1);

-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

-     RegionUninit(&VPReg);

-  }

-

-  /* that's all if it's totally obscured */

-  if(!RegionNotEmpty(&ClipRegion)) {

-	clippedAway = TRUE;

-	goto CLIP_VIDEO_BAILOUT;

-  }

-

-  /* bailout if we have to clip but the hardware doesn't support it */

-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = RegionRects(&ClipRegion);

-     if(  (RegionNumRects(&ClipRegion) != 1) ||

-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

-     {

-	    clippedAway = TRUE;

-	    goto CLIP_VIDEO_BAILOUT;

-     }

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->ReputImage)(portPriv->screen, portPriv->pDraw,

-			WinBox.x1, WinBox.y1,

-			&ClipRegion, portPriv->DevPriv.ptr);

-

-  portPriv->isOn = (ret == Success) ? XV_ON : XV_OFF;

-

-CLIP_VIDEO_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {

-	(*portPriv->AdaptorRec->StopVideo)(

-		portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-	portPriv->isOn = XV_PENDING;

-  }

-

-  /* This clip was copied and only good for one shot */

-  if(!portPriv->FreeCompositeClip)

-     portPriv->pCompositeClip = NULL;

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-

-static int

-KdXVReputAllVideo(WindowPtr pWin, pointer data)

-{

-    KdXVWindowPtr WinPriv;

-

-    if (pWin->drawable.type != DRAWABLE_WINDOW)

-	return WT_DONTWALKCHILDREN;

-

-    WinPriv = GET_KDXV_WINDOW(pWin);

-

-    while(WinPriv) {

-	if(WinPriv->PortRec->type == XvInputMask)

-	    KdXVReputVideo(WinPriv->PortRec);

-	else

-	    KdXVRegetVideo(WinPriv->PortRec);

-	WinPriv = WinPriv->next;

-    }

-

-    return WT_WALKCHILDREN;

-}

-

-static int

-KdXVEnlistPortInWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)

-{

-   KdXVWindowPtr winPriv, PrivRoot;

-

-   winPriv = PrivRoot = GET_KDXV_WINDOW(pWin);

-

-  /* Enlist our port in the window private */

-   while(winPriv) {

-	if(winPriv->PortRec == portPriv) /* we're already listed */

-	    break;

-	winPriv = winPriv->next;

-   }

-

-   if(!winPriv) {

-	winPriv = malloc(sizeof(KdXVWindowRec));

-	if(!winPriv) return BadAlloc;

-	winPriv->PortRec = portPriv;

-	winPriv->next = PrivRoot;

-	dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv);

-   }

-   return Success;

-}

-

-

-static void

-KdXVRemovePortFromWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)

-{

-     KdXVWindowPtr winPriv, prevPriv = NULL;

-

-     winPriv = GET_KDXV_WINDOW(pWin);

-

-     while(winPriv) {

-	if(winPriv->PortRec == portPriv) {

-	    if(prevPriv)

-		prevPriv->next = winPriv->next;

-	    else

-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv->next);

-	    free(winPriv);

-	    break;

-	}

-	prevPriv = winPriv;

-	winPriv = winPriv->next;

-     }

-     portPriv->pDraw = NULL;

-}

-

-/****  ScreenRec fields ****/

-

-

-static Bool

-KdXVCreateWindow(WindowPtr pWin)

-{

-  ScreenPtr pScreen = pWin->drawable.pScreen;

-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);

-  int ret;

-

-  pScreen->CreateWindow = ScreenPriv->CreateWindow;

-  ret = (*pScreen->CreateWindow)(pWin);

-  pScreen->CreateWindow = KdXVCreateWindow;

-

-  if (ret)

-      dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);

-

-  return ret;

-}

-

-

-static Bool

-KdXVDestroyWindow(WindowPtr pWin)

-{

-  ScreenPtr pScreen = pWin->drawable.pScreen;

-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);

-  KdXVWindowPtr tmp, WinPriv = GET_KDXV_WINDOW(pWin);

-  int ret;

-

-  while(WinPriv) {

-     XvPortRecPrivatePtr pPriv = WinPriv->PortRec;

-

-     if(pPriv->isOn > XV_OFF) {

-	(*pPriv->AdaptorRec->StopVideo)(

-			pPriv->screen, pPriv->DevPriv.ptr, TRUE);

-	pPriv->isOn = XV_OFF;

-     }

-

-     pPriv->pDraw = NULL;

-     tmp = WinPriv;

-     WinPriv = WinPriv->next;

-     free(tmp);

-  }

-

-  dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);

-

-  pScreen->DestroyWindow = ScreenPriv->DestroyWindow;

-  ret = (*pScreen->DestroyWindow)(pWin);

-  pScreen->DestroyWindow = KdXVDestroyWindow;

-

-  return ret;

-}

-

-

-static void

-KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)

-{

-  ScreenPtr pScreen = pWin->drawable.pScreen;

-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);

-  KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);

-  KdXVWindowPtr pPrev;

-  XvPortRecPrivatePtr pPriv;

-  Bool AreasExposed;

-

-  AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));

-

-  pScreen->WindowExposures = ScreenPriv->WindowExposures;

-  (*pScreen->WindowExposures)(pWin, reg1, reg2);

-  pScreen->WindowExposures = KdXVWindowExposures;

-

-  /* filter out XClearWindow/Area */

-  if (!pWin->valdata) return;

-

-  pPrev = NULL;

-

-  while(WinPriv) {

-     pPriv = WinPriv->PortRec;

-

-     /* Reput anyone with a reput function */

-

-     switch(pPriv->type) {

-     case XvInputMask:

-	KdXVReputVideo(pPriv);

-	break;

-     case XvOutputMask:

-	KdXVRegetVideo(pPriv);

-	break;

-     default:  /* overlaid still/image*/

-	if (pPriv->AdaptorRec->ReputImage)

-	   KdXVReputImage(pPriv);

-	else if(AreasExposed) {

-	    KdXVWindowPtr tmp;

-

-	    if (pPriv->isOn == XV_ON) {

-		(*pPriv->AdaptorRec->StopVideo)(

-		    pPriv->screen, pPriv->DevPriv.ptr, FALSE);

-		pPriv->isOn = XV_PENDING;

-	    }

-	    pPriv->pDraw = NULL;

-

-	    if(!pPrev)

-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, WinPriv->next);

-	    else

-	       pPrev->next = WinPriv->next;

-	    tmp = WinPriv;

-	    WinPriv = WinPriv->next;

-	    free(tmp);

-	    continue;

-	}

-	break;

-     }

-     pPrev = WinPriv;

-     WinPriv = WinPriv->next;

-  }

-}

-

-

-static void

-KdXVClipNotify(WindowPtr pWin, int dx, int dy)

-{

-  ScreenPtr pScreen = pWin->drawable.pScreen;

-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);

-  KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);

-  KdXVWindowPtr tmp, pPrev = NULL;

-  XvPortRecPrivatePtr pPriv;

-  Bool visible = (pWin->visibility == VisibilityUnobscured) ||

-		 (pWin->visibility == VisibilityPartiallyObscured);

-

-  while(WinPriv) {

-     pPriv = WinPriv->PortRec;

-

-     if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-	RegionDestroy(pPriv->pCompositeClip);

-

-     pPriv->pCompositeClip = NULL;

-

-     /* Stop everything except images, but stop them too if the

-	window isn't visible.  But we only remove the images. */

-

-     if(pPriv->type || !visible) {

-	if(pPriv->isOn == XV_ON) {

-	    (*pPriv->AdaptorRec->StopVideo)(

-			pPriv->screen, pPriv->DevPriv.ptr, FALSE);

-	    pPriv->isOn = XV_PENDING;

-	}

-

-	if(!pPriv->type) {  /* overlaid still/image */

-	    pPriv->pDraw = NULL;

-

-	    if(!pPrev)

-		dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, WinPriv->next);

-	    else

-	       pPrev->next = WinPriv->next;

-	    tmp = WinPriv;

-	    WinPriv = WinPriv->next;

-	    free(tmp);

-	    continue;

-	}

-     }

-

-     pPrev = WinPriv;

-     WinPriv = WinPriv->next;

-  }

-

-  if(ScreenPriv->ClipNotify) {

-      pScreen->ClipNotify = ScreenPriv->ClipNotify;

-      (*pScreen->ClipNotify)(pWin, dx, dy);

-      pScreen->ClipNotify = KdXVClipNotify;

-  }

-}

-

-

-

-/**** Required XvScreenRec fields ****/

-

-static Bool

-KdXVCloseScreen(int i, ScreenPtr pScreen)

-{

-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);

-  KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);

-  XvAdaptorPtr pa;

-  int c;

-

-  if(!ScreenPriv) return TRUE;

-

-  pScreen->CreateWindow = ScreenPriv->CreateWindow;

-  pScreen->DestroyWindow = ScreenPriv->DestroyWindow;

-  pScreen->WindowExposures = ScreenPriv->WindowExposures;

-  pScreen->ClipNotify = ScreenPriv->ClipNotify;

-

-/*   fprintf(stderr,"XV: Unwrapping screen funcs\n"); */

-

-  for(c = 0, pa = pxvs->pAdaptors; c < pxvs->nAdaptors; c++, pa++) {

-       KdXVFreeAdaptor(pa);

-  }

-

-  free(pxvs->pAdaptors);

-  free(ScreenPriv);

-

-  return TRUE;

-}

-

-

-static int

-KdXVQueryAdaptors(

-   ScreenPtr pScreen,

-   XvAdaptorPtr *p_pAdaptors,

-   int *p_nAdaptors

-){

-  XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);

-

-  *p_nAdaptors = pxvs->nAdaptors;

-  *p_pAdaptors = pxvs->pAdaptors;

-

-  return Success;

-}

-

-static Bool

-KdXVRunning (ScreenPtr pScreen)

-{

-    return (KdXVGeneration == serverGeneration &&

-	    GET_XV_SCREEN(pScreen) != 0);

-}

-

-Bool

-KdXVEnable(ScreenPtr pScreen)

-{

-    if (!KdXVRunning (pScreen))

-	return TRUE;

-

-    WalkTree(pScreen, KdXVReputAllVideo, 0);

-

-    return TRUE;

-}

-

-void

-KdXVDisable(ScreenPtr pScreen)

-{

-    XvScreenPtr pxvs;

-    KdXVScreenPtr ScreenPriv;

-    XvAdaptorPtr pAdaptor;

-    XvPortPtr pPort;

-    XvPortRecPrivatePtr pPriv;

-    int i, j;

-

-    if (!KdXVRunning (pScreen))

-	return;

-

-    pxvs = GET_XV_SCREEN(pScreen);

-    ScreenPriv = GET_KDXV_SCREEN(pScreen);

-

-    for(i = 0; i < pxvs->nAdaptors; i++) {

-	pAdaptor = &pxvs->pAdaptors[i];

-	for(j = 0; j < pAdaptor->nPorts; j++) {

-	    pPort = &pAdaptor->pPorts[j];

-	    pPriv = (XvPortRecPrivatePtr)pPort->devPriv.ptr;

-	    if(pPriv->isOn > XV_OFF) {

-

-		(*pPriv->AdaptorRec->StopVideo)(

-			pPriv->screen, pPriv->DevPriv.ptr, TRUE);

-		pPriv->isOn = XV_OFF;

-

-		if(pPriv->pCompositeClip && pPriv->FreeCompositeClip)

-		    RegionDestroy(pPriv->pCompositeClip);

-

-		pPriv->pCompositeClip = NULL;

-

-		if(!pPriv->type && pPriv->pDraw) { /* still */

-		    KdXVRemovePortFromWindow((WindowPtr)pPriv->pDraw, pPriv);

-		}

-	    }

-	}

-    }

-}

-

-/**** XvAdaptorRec fields ****/

-

-static int

-KdXVAllocatePort(

-   unsigned long port,

-   XvPortPtr pPort,

-   XvPortPtr *ppPort

-){

-  *ppPort = pPort;

-  return Success;

-}

-

-static int

-KdXVFreePort(XvPortPtr pPort)

-{

-  return Success;

-}

-

-static int

-KdXVPutVideo(

-   ClientPtr client,

-   DrawablePtr pDraw,

-   XvPortPtr pPort,

-   GCPtr pGC,

-   INT16 vid_x, INT16 vid_y,

-   CARD16 vid_w, CARD16 vid_h,

-   INT16 drw_x, INT16 drw_y,

-   CARD16 drw_w, CARD16 drw_h

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  KdScreenPriv(portPriv->screen->pScreen);

-  int result;

-

-  /* No dumping video to pixmaps... For now anyhow */

-  if(pDraw->type != DRAWABLE_WINDOW) {

-      pPort->pDraw = (DrawablePtr)NULL;

-      return BadAlloc;

-  }

-

-  /* If we are changing windows, unregister our port in the old window */

-  if(portPriv->pDraw && (portPriv->pDraw != pDraw))

-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

-

-  /* Register our port with the new window */

-  result =  KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);

-  if(result != Success) return result;

-

-  portPriv->pDraw = pDraw;

-  portPriv->type = XvInputMask;

-

-  /* save a copy of these parameters */

-  portPriv->vid_x = vid_x;  portPriv->vid_y = vid_y;

-  portPriv->vid_w = vid_w;  portPriv->vid_h = vid_h;

-  portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;

-  portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;

-

-  /* make sure we have the most recent copy of the clientClip */

-  KdXVCopyClip(portPriv, pGC);

-

-  /* To indicate to the DI layer that we were successful */

-  pPort->pDraw = pDraw;

-

-  if (!pScreenPriv->enabled) return Success;

-

-  return(KdXVReputVideo(portPriv));

-}

-

-static int

-KdXVPutStill(

-   ClientPtr client,

-   DrawablePtr pDraw,

-   XvPortPtr pPort,

-   GCPtr pGC,

-   INT16 vid_x, INT16 vid_y,

-   CARD16 vid_w, CARD16 vid_h,

-   INT16 drw_x, INT16 drw_y,

-   CARD16 drw_w, CARD16 drw_h

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen = pDraw->pScreen;

-  KdScreenPriv(pScreen);

-  KdScreenInfo *screen=pScreenPriv->screen;

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  if (pDraw->type != DRAWABLE_WINDOW)

-      return BadAlloc;

-

-  if (!pScreenPriv->enabled) return Success;

-

-  WinBox.x1 = pDraw->x + drw_x;

-  WinBox.y1 = pDraw->y + drw_y;

-  WinBox.x2 = WinBox.x1 + drw_w;

-  WinBox.y2 = WinBox.y1 + drw_h;

-

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

-

-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

-     RegionRec VPReg;

-     BoxRec VPBox;

-

-     VPBox.x1 = 0;

-     VPBox.y1 = 0;

-     VPBox.x2 = screen->width;

-     VPBox.y2 = screen->height;

-

-     RegionInit(&VPReg, &VPBox, 1);

-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

-     RegionUninit(&VPReg);

-  }

-

-  if(portPriv->pDraw) {

-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

-  }

-

-  if(!RegionNotEmpty(&ClipRegion)) {

-     clippedAway = TRUE;

-     goto PUT_STILL_BAILOUT;

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = RegionRects(&ClipRegion);

-     if(  (RegionNumRects(&ClipRegion) != 1) ||

-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

-     {

-	  clippedAway = TRUE;

-          goto PUT_STILL_BAILOUT;

-     }

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->PutStill)(portPriv->screen, pDraw,

-		vid_x, vid_y, WinBox.x1, WinBox.y1,

-		vid_w, vid_h, drw_w, drw_h,

-		&ClipRegion, portPriv->DevPriv.ptr);

-

-  if((ret == Success) &&

-	(portPriv->AdaptorRec->flags & VIDEO_OVERLAID_STILLS)) {

-

-     KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);

-     portPriv->isOn = XV_ON;

-     portPriv->pDraw = pDraw;

-     portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;

-     portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;

-     portPriv->type = 0;  /* no mask means it's transient and should

-			     not be reput once it's removed */

-     pPort->pDraw = pDraw;  /* make sure we can get stop requests */

-  }

-

-PUT_STILL_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {

-        (*portPriv->AdaptorRec->StopVideo)(

-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-        portPriv->isOn = XV_PENDING;

-  }

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-static int

-KdXVGetVideo(

-   ClientPtr client,

-   DrawablePtr pDraw,

-   XvPortPtr pPort,

-   GCPtr pGC,

-   INT16 vid_x, INT16 vid_y,

-   CARD16 vid_w, CARD16 vid_h,

-   INT16 drw_x, INT16 drw_y,

-   CARD16 drw_w, CARD16 drw_h

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  int result;

-  KdScreenPriv(portPriv->screen->pScreen);

-

-  /* No pixmaps... For now anyhow */

-  if(pDraw->type != DRAWABLE_WINDOW) {

-      pPort->pDraw = (DrawablePtr)NULL;

-      return BadAlloc;

-  }

-

-  /* If we are changing windows, unregister our port in the old window */

-  if(portPriv->pDraw && (portPriv->pDraw != pDraw))

-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

-

-  /* Register our port with the new window */

-  result =  KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);

-  if(result != Success) return result;

-

-  portPriv->pDraw = pDraw;

-  portPriv->type = XvOutputMask;

-

-  /* save a copy of these parameters */

-  portPriv->vid_x = vid_x;  portPriv->vid_y = vid_y;

-  portPriv->vid_w = vid_w;  portPriv->vid_h = vid_h;

-  portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;

-  portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;

-

-  /* make sure we have the most recent copy of the clientClip */

-  KdXVCopyClip(portPriv, pGC);

-

-  /* To indicate to the DI layer that we were successful */

-  pPort->pDraw = pDraw;

-

-  if(!pScreenPriv->enabled) return Success;

-

-  return(KdXVRegetVideo(portPriv));

-}

-

-static int

-KdXVGetStill(

-   ClientPtr client,

-   DrawablePtr pDraw,

-   XvPortPtr pPort,

-   GCPtr pGC,

-   INT16 vid_x, INT16 vid_y,

-   CARD16 vid_w, CARD16 vid_h,

-   INT16 drw_x, INT16 drw_y,

-   CARD16 drw_w, CARD16 drw_h

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen = pDraw->pScreen;

-  KdScreenPriv(pScreen);

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  if (pDraw->type != DRAWABLE_WINDOW)

-      return BadAlloc;

-

-  if(!pScreenPriv->enabled) return Success;

-

-  WinBox.x1 = pDraw->x + drw_x;

-  WinBox.y1 = pDraw->y + drw_y;

-  WinBox.x2 = WinBox.x1 + drw_w;

-  WinBox.y2 = WinBox.y1 + drw_h;

-

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

-

-  if(portPriv->pDraw) {

-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

-  }

-

-  if(!RegionNotEmpty(&ClipRegion)) {

-     clippedAway = TRUE;

-     goto GET_STILL_BAILOUT;

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->GetStill)(portPriv->screen, pDraw,

-		vid_x, vid_y, WinBox.x1, WinBox.y1,

-		vid_w, vid_h, drw_w, drw_h,

-		&ClipRegion, portPriv->DevPriv.ptr);

-

-GET_STILL_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {

-        (*portPriv->AdaptorRec->StopVideo)(

-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-        portPriv->isOn = XV_PENDING;

-  }

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-

-

-static int

-KdXVStopVideo(

-   ClientPtr client,

-   XvPortPtr pPort,

-   DrawablePtr pDraw

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  KdScreenPriv(portPriv->screen->pScreen);

-

-  if(pDraw->type != DRAWABLE_WINDOW)

-      return BadAlloc;

-

-  KdXVRemovePortFromWindow((WindowPtr)pDraw, portPriv);

-

-  if(!pScreenPriv->enabled) return Success;

-

-  /* Must free resources. */

-

-  if(portPriv->isOn > XV_OFF) {

-	(*portPriv->AdaptorRec->StopVideo)(

-		portPriv->screen, portPriv->DevPriv.ptr, TRUE);

-	portPriv->isOn = XV_OFF;

-  }

-

-  return Success;

-}

-

-static int

-KdXVSetPortAttribute(

-   ClientPtr client,

-   XvPortPtr pPort,

-   Atom attribute,

-   INT32 value

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-

-  return((*portPriv->AdaptorRec->SetPortAttribute)(portPriv->screen,

-		attribute, value, portPriv->DevPriv.ptr));

-}

-

-

-static int

-KdXVGetPortAttribute(

-   ClientPtr client,

-   XvPortPtr pPort,

-   Atom attribute,

-   INT32 *p_value

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-

-  return((*portPriv->AdaptorRec->GetPortAttribute)(portPriv->screen,

-		attribute, (int *) p_value, portPriv->DevPriv.ptr));

-}

-

-

-

-static int

-KdXVQueryBestSize(

-   ClientPtr client,

-   XvPortPtr pPort,

-   CARD8 motion,

-   CARD16 vid_w, CARD16 vid_h,

-   CARD16 drw_w, CARD16 drw_h,

-   unsigned int *p_w, unsigned int *p_h

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-

-  (*portPriv->AdaptorRec->QueryBestSize)(portPriv->screen,

-		(Bool)motion, vid_w, vid_h, drw_w, drw_h,

-		p_w, p_h, portPriv->DevPriv.ptr);

-

-  return Success;

-}

-

-

-static int

-KdXVPutImage(

-   ClientPtr client,

-   DrawablePtr pDraw,

-   XvPortPtr pPort,

-   GCPtr pGC,

-   INT16 src_x, INT16 src_y,

-   CARD16 src_w, CARD16 src_h,

-   INT16 drw_x, INT16 drw_y,

-   CARD16 drw_w, CARD16 drw_h,

-   XvImagePtr format,

-   unsigned char* data,

-   Bool sync,

-   CARD16 width, CARD16 height

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-  ScreenPtr pScreen = pDraw->pScreen;

-  KdScreenPriv(pScreen);

-  RegionRec WinRegion;

-  RegionRec ClipRegion;

-  BoxRec WinBox;

-  int ret = Success;

-  Bool clippedAway = FALSE;

-

-  if (pDraw->type != DRAWABLE_WINDOW)

-      return BadAlloc;

-

-  if(!pScreenPriv->enabled) return Success;

-

-  WinBox.x1 = pDraw->x + drw_x;

-  WinBox.y1 = pDraw->y + drw_y;

-  WinBox.x2 = WinBox.x1 + drw_w;

-  WinBox.y2 = WinBox.y1 + drw_h;

-

-  RegionInit(&WinRegion, &WinBox, 1);

-  RegionInit(&ClipRegion, NullBox, 1);

-  RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);

-

-  if(portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {

-     RegionRec VPReg;

-     BoxRec VPBox;

-

-     VPBox.x1 = 0;

-     VPBox.y1 = 0;

-     VPBox.x2 = pScreen->width;

-     VPBox.y2 = pScreen->height;

-

-     RegionInit(&VPReg, &VPBox, 1);

-     RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);

-     RegionUninit(&VPReg);

-  }

-

-  if(portPriv->pDraw) {

-     KdXVRemovePortFromWindow((WindowPtr)(portPriv->pDraw), portPriv);

-  }

-

-  if(!RegionNotEmpty(&ClipRegion)) {

-     clippedAway = TRUE;

-     goto PUT_IMAGE_BAILOUT;

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {

-     BoxPtr clipBox = RegionRects(&ClipRegion);

-     if(  (RegionNumRects(&ClipRegion) != 1) ||

-	  (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||

-	  (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2))

-     {

-	  clippedAway = TRUE;

-          goto PUT_IMAGE_BAILOUT;

-     }

-  }

-

-  if(portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {

-     RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);

-  }

-

-  ret = (*portPriv->AdaptorRec->PutImage)(portPriv->screen, pDraw,

-		src_x, src_y, WinBox.x1, WinBox.y1,

-		src_w, src_h, drw_w, drw_h, format->id, data, width, height,

-		sync, &ClipRegion, portPriv->DevPriv.ptr);

-

-  if((ret == Success) &&

-	(portPriv->AdaptorRec->flags & VIDEO_OVERLAID_IMAGES)) {

-

-     KdXVEnlistPortInWindow((WindowPtr)pDraw, portPriv);

-     portPriv->isOn = XV_ON;

-     portPriv->pDraw = pDraw;

-     portPriv->drw_x = drw_x;  portPriv->drw_y = drw_y;

-     portPriv->drw_w = drw_w;  portPriv->drw_h = drw_h;

-     portPriv->type = 0;  /* no mask means it's transient and should

-			     not be reput once it's removed */

-     pPort->pDraw = pDraw;  /* make sure we can get stop requests */

-  }

-

-PUT_IMAGE_BAILOUT:

-

-  if((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {

-        (*portPriv->AdaptorRec->StopVideo)(

-                portPriv->screen, portPriv->DevPriv.ptr, FALSE);

-        portPriv->isOn = XV_PENDING;

-  }

-

-  RegionUninit(&WinRegion);

-  RegionUninit(&ClipRegion);

-

-  return ret;

-}

-

-

-static  int

-KdXVQueryImageAttributes(

-   ClientPtr client,

-   XvPortPtr pPort,

-   XvImagePtr format,

-   CARD16 *width,

-   CARD16 *height,

-   int *pitches,

-   int *offsets

-){

-  XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr)(pPort->devPriv.ptr);

-

-  return (*portPriv->AdaptorRec->QueryImageAttributes)(portPriv->screen,

-			format->id, width, height, pitches, offsets);

-}

-

-

-/****************  Common video manipulation functions *******************/

-

-void

-KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,

-    int srcPitch, int dstPitch, int srcW, int srcH, int top, int left,

-    int h, int w)

-{

-    int srcDown = srcPitch, srcRight = 2, srcNext;

-    int p;

-

-    switch (randr & RR_Rotate_All) {

-    case RR_Rotate_0:

-	srcDown = srcPitch;

-	srcRight = 2;

-	break;

-    case RR_Rotate_90:

-	src += (srcH - 1) * 2;

-	srcDown = -2;

-	srcRight = srcPitch;

-	break;

-    case RR_Rotate_180:

-	src += srcPitch * (srcH - 1) + (srcW - 1) * 2;

-	srcDown = -srcPitch;

-	srcRight = -2;

-	break;

-    case RR_Rotate_270:

-	src += srcPitch * (srcW - 1);

-	srcDown = 2;

-	srcRight = -srcPitch;

-	break;

-    }

-

-    src = src + top * srcDown + left * srcRight;

-

-    w >>= 1;

-    /* srcRight >>= 1; */

-    srcNext = srcRight >> 1;

-    while (h--) {

-	CARD16 *s = (CARD16 *)src;

-	CARD32 *d = (CARD32 *)dst;

-	p = w;

-	while (p--) {

-	    *d++ = s[0] | (s[srcNext] << 16);

-	    s += srcRight;

-	}

-	src += srcPitch;

-	dst += dstPitch;

-    }

-}

-

-void

-KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,

-    int srcPitch, int srcPitch2, int dstPitch, int srcW, int srcH, int height,

-    int top, int left, int h, int w, int id)

-{

-    int i, j;

-    CARD8 *src1, *src2, *src3, *dst1;

-    int srcDown = srcPitch, srcDown2 = srcPitch2;

-    int srcRight = 2, srcRight2 = 1, srcNext = 1;

-

-    /* compute source data pointers */

-    src1 = src;

-    src2 = src1 + height * srcPitch;

-    src3 = src2 + (height >> 1) * srcPitch2;

-    switch (randr & RR_Rotate_All) {

-    case RR_Rotate_0:

-	srcDown = srcPitch;

-	srcDown2 = srcPitch2;

-	srcRight = 2;

-	srcRight2 = 1;

-	srcNext = 1;

-	break;

-    case RR_Rotate_90:

-	src1 = src1 + srcH - 1;

-	src2 = src2 + (srcH >> 1) - 1;

-	src3 = src3 + (srcH >> 1) - 1;

-	srcDown = -1;

-	srcDown2 = -1;

-	srcRight = srcPitch * 2;

-	srcRight2 = srcPitch2;

-	srcNext = srcPitch;

-	break;

-    case RR_Rotate_180:

-	src1 = src1 + srcPitch * (srcH - 1) + (srcW - 1);

-	src2 = src2 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);

-	src3 = src3 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);

-	srcDown = -srcPitch;

-	srcDown2 = -srcPitch2;

-	srcRight = -2;

-	srcRight2 = -1;

-	srcNext = -1;

-	break;

-    case RR_Rotate_270:

-	src1 = src1 + srcPitch * (srcW - 1);

-	src2 = src2 + srcPitch2 * ((srcW >> 1) - 1);

-	src3 = src3 + srcPitch2 * ((srcW >> 1) - 1);

-	srcDown = 1;

-	srcDown2 = 1;

-	srcRight = -srcPitch * 2;

-	srcRight2 = -srcPitch2;

-	srcNext = -srcPitch;

-	break;

-    }

-

-    /* adjust for origin */

-    src1 += top * srcDown + left * srcNext;

-    src2 += (top >> 1) * srcDown2 + (left >> 1) * srcRight2;

-    src3 += (top >> 1) * srcDown2 + (left >> 1) * srcRight2;

-

-    if (id == FOURCC_I420) {

-	CARD8 *srct = src2;

-	src2 = src3;

-	src3 = srct;

-    }

-

-    dst1 = dst;

-

-    w >>= 1;

-    for (j = 0; j < h; j++) {

-	CARD32 *dst = (CARD32 *)dst1;

-	CARD8 *s1l = src1;

-	CARD8 *s1r = src1 + srcNext;

-	CARD8 *s2 = src2;

-	CARD8 *s3 = src3;

-

-	for (i = 0; i < w; i++) {

-	    *dst++ = *s1l | (*s1r << 16) | (*s3 << 8) | (*s2 << 24);

-	    s1l += srcRight;

-	    s1r += srcRight;

-	    s2 += srcRight2;

-	    s3 += srcRight2;

-	}

-	src1 += srcDown;

-	dst1 += dstPitch;

-	if (j & 1) {

-	    src2 += srcDown2;

-	    src3 += srcDown2;

-	}

-    }

-}

-

-void

-KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)

-{

-    GCPtr	pGC;

-    ChangeGCVal	val[2];

-    xRectangle	*rects, *r;

-    BoxPtr	pBox = RegionRects (pRgn);

-    int		nBox = RegionNumRects (pRgn);

-

-    rects = malloc(nBox * sizeof (xRectangle));

-    if (!rects)

-	goto bail0;

-    r = rects;

-    while (nBox--)

-    {

-	r->x = pBox->x1 - pDraw->x;

-	r->y = pBox->y1 - pDraw->y;

-	r->width = pBox->x2 - pBox->x1;

-	r->height = pBox->y2 - pBox->y1;

-	r++;

-	pBox++;

-    }

-

-    pGC = GetScratchGC (pDraw->depth, pDraw->pScreen);

-    if (!pGC)

-	goto bail1;

-

-    val[0].val = fg;

-    val[1].val = IncludeInferiors;

-    ChangeGC (NullClient, pGC, GCForeground|GCSubwindowMode, val);

-

-    ValidateGC (pDraw, pGC);

-

-    (*pGC->ops->PolyFillRect) (pDraw, pGC,

-			       RegionNumRects (pRgn), rects);

-

-    FreeScratchGC (pGC);

-bail1:

-    free(rects);

-bail0:

-    ;

-}

+/*
+
+   XFree86 Xv DDX written by Mark Vojkovich (markv@valinux.com)
+   Adapted for KDrive by Pontus Lidman <pontus.lidman@nokia.com>
+
+   Copyright (C) 2000, 2001 - Nokia Home Communications
+   Copyright (C) 1998, 1999 - The XFree86 Project Inc.
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, provided that the above
+copyright notice(s) and this permission notice appear in all copies of
+the Software and that both the above copyright notice(s) and this
+permission notice appear in supporting documentation.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY
+SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+of the copyright holder.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "kdrive.h"
+
+#include "scrnintstr.h"
+#include "regionstr.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "mivalidate.h"
+#include "validate.h"
+#include "resource.h"
+#include "gcstruct.h"
+#include "dixstruct.h"
+
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvproto.h>
+
+#include "kxv.h"
+#include "fourcc.h"
+
+/* XvScreenRec fields */
+
+static Bool KdXVCloseScreen(int, ScreenPtr);
+static int KdXVQueryAdaptors(ScreenPtr, XvAdaptorPtr *, int *);
+
+/* XvAdaptorRec fields */
+
+static int KdXVAllocatePort(unsigned long, XvPortPtr, XvPortPtr *);
+static int KdXVFreePort(XvPortPtr);
+static int KdXVPutVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVPutStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVGetVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVGetStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16);
+static int KdXVStopVideo(ClientPtr, XvPortPtr, DrawablePtr);
+static int KdXVSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32);
+static int KdXVGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32 *);
+static int KdXVQueryBestSize(ClientPtr, XvPortPtr, CARD8,
+                             CARD16, CARD16, CARD16, CARD16,
+                             unsigned int *, unsigned int *);
+static int KdXVPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
+                        INT16, INT16, CARD16, CARD16,
+                        INT16, INT16, CARD16, CARD16,
+                        XvImagePtr, unsigned char *, Bool, CARD16, CARD16);
+static int KdXVQueryImageAttributes(ClientPtr, XvPortPtr, XvImagePtr,
+                                    CARD16 *, CARD16 *, int *, int *);
+
+/* ScreenRec fields */
+
+static Bool KdXVCreateWindow(WindowPtr pWin);
+static Bool KdXVDestroyWindow(WindowPtr pWin);
+static void KdXVWindowExposures(WindowPtr pWin, RegionPtr r1, RegionPtr r2);
+static void KdXVClipNotify(WindowPtr pWin, int dx, int dy);
+
+/* misc */
+static Bool KdXVInitAdaptors(ScreenPtr, KdVideoAdaptorPtr *, int);
+
+static DevPrivateKeyRec KdXVWindowKeyRec;
+
+#define KdXVWindowKey (&KdXVWindowKeyRec)
+static DevPrivateKey KdXvScreenKey;
+static unsigned long KdXVGeneration = 0;
+static unsigned long PortResource = 0;
+
+DevPrivateKey (*XvGetScreenKeyProc) (void) = XvGetScreenKey;
+unsigned long (*XvGetRTPortProc) (void) = XvGetRTPort;
+int (*XvScreenInitProc) (ScreenPtr) = XvScreenInit;
+
+#define GET_XV_SCREEN(pScreen) ((XvScreenPtr) \
+    dixLookupPrivate(&(pScreen)->devPrivates, KdXvScreenKey))
+
+#define GET_KDXV_SCREEN(pScreen) \
+  	((KdXVScreenPtr)(GET_XV_SCREEN(pScreen)->devPriv.ptr))
+
+#define GET_KDXV_WINDOW(pWin) ((KdXVWindowPtr) \
+    dixLookupPrivate(&(pWin)->devPrivates, KdXVWindowKey))
+
+static KdXVInitGenericAdaptorPtr *GenDrivers = NULL;
+static int NumGenDrivers = 0;
+
+int
+KdXVRegisterGenericAdaptorDriver(KdXVInitGenericAdaptorPtr InitFunc)
+{
+    KdXVInitGenericAdaptorPtr *newdrivers;
+
+/*   fprintf(stderr,"KdXVRegisterGenericAdaptorDriver\n"); */
+
+    newdrivers = realloc(GenDrivers, sizeof(KdXVInitGenericAdaptorPtr) *
+                         (1 + NumGenDrivers));
+    if (!newdrivers)
+        return 0;
+    GenDrivers = newdrivers;
+
+    GenDrivers[NumGenDrivers++] = InitFunc;
+
+    return 1;
+}
+
+int
+KdXVListGenericAdaptors(KdScreenInfo * screen, KdVideoAdaptorPtr ** adaptors)
+{
+    int i, j, n, num;
+    KdVideoAdaptorPtr *DrivAdap, *new;
+
+    num = 0;
+    *adaptors = NULL;
+    for (i = 0; i < NumGenDrivers; i++) {
+        n = GenDrivers[i] (screen, &DrivAdap);
+        if (0 == n)
+            continue;
+        new = realloc(*adaptors, sizeof(KdVideoAdaptorPtr) * (num + n));
+        if (NULL == new)
+            continue;
+        *adaptors = new;
+        for (j = 0; j < n; j++, num++)
+            (*adaptors)[num] = DrivAdap[j];
+    }
+    return num;
+}
+
+KdVideoAdaptorPtr
+KdXVAllocateVideoAdaptorRec(KdScreenInfo * screen)
+{
+    return calloc(1, sizeof(KdVideoAdaptorRec));
+}
+
+void
+KdXVFreeVideoAdaptorRec(KdVideoAdaptorPtr ptr)
+{
+    free(ptr);
+}
+
+Bool
+KdXVScreenInit(ScreenPtr pScreen, KdVideoAdaptorPtr * adaptors, int num)
+{
+    KdXVScreenPtr ScreenPriv;
+    XvScreenPtr pxvs;
+
+/*   fprintf(stderr,"KdXVScreenInit initializing %d adaptors\n",num); */
+
+    if (KdXVGeneration != serverGeneration)
+        KdXVGeneration = serverGeneration;
+
+    if (!XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)
+        return FALSE;
+
+    if (!dixRegisterPrivateKey(&KdXVWindowKeyRec, PRIVATE_WINDOW, 0))
+        return FALSE;
+
+    if (Success != (*XvScreenInitProc) (pScreen))
+        return FALSE;
+
+    KdXvScreenKey = (*XvGetScreenKeyProc) ();
+    PortResource = (*XvGetRTPortProc) ();
+
+    pxvs = GET_XV_SCREEN(pScreen);
+
+    /* Anyone initializing the Xv layer must provide these two.
+       The Xv di layer calls them without even checking if they exist! */
+
+    pxvs->ddCloseScreen = KdXVCloseScreen;
+    pxvs->ddQueryAdaptors = KdXVQueryAdaptors;
+
+    /* The Xv di layer provides us with a private hook so that we don't
+       have to allocate our own screen private.  They also provide
+       a CloseScreen hook so that we don't have to wrap it.  I'm not
+       sure that I appreciate that.  */
+
+    ScreenPriv = malloc(sizeof(KdXVScreenRec));
+    pxvs->devPriv.ptr = (pointer) ScreenPriv;
+
+    if (!ScreenPriv)
+        return FALSE;
+
+    ScreenPriv->CreateWindow = pScreen->CreateWindow;
+    ScreenPriv->DestroyWindow = pScreen->DestroyWindow;
+    ScreenPriv->WindowExposures = pScreen->WindowExposures;
+    ScreenPriv->ClipNotify = pScreen->ClipNotify;
+
+/*   fprintf(stderr,"XV: Wrapping screen funcs\n"); */
+
+    pScreen->CreateWindow = KdXVCreateWindow;
+    pScreen->DestroyWindow = KdXVDestroyWindow;
+    pScreen->WindowExposures = KdXVWindowExposures;
+    pScreen->ClipNotify = KdXVClipNotify;
+
+    if (!KdXVInitAdaptors(pScreen, adaptors, num))
+        return FALSE;
+
+    return TRUE;
+}
+
+static void
+KdXVFreeAdaptor(XvAdaptorPtr pAdaptor)
+{
+    int i;
+
+    free(pAdaptor->name);
+
+    if (pAdaptor->pEncodings) {
+        XvEncodingPtr pEncode = pAdaptor->pEncodings;
+
+        for (i = 0; i < pAdaptor->nEncodings; i++, pEncode++) {
+            free(pEncode->name);
+        }
+        free(pAdaptor->pEncodings);
+    }
+
+    free(pAdaptor->pFormats);
+
+    if (pAdaptor->pPorts) {
+        XvPortPtr pPort = pAdaptor->pPorts;
+        XvPortRecPrivatePtr pPriv;
+
+        for (i = 0; i < pAdaptor->nPorts; i++, pPort++) {
+            pPriv = (XvPortRecPrivatePtr) pPort->devPriv.ptr;
+            if (pPriv) {
+                if (pPriv->clientClip)
+                    RegionDestroy(pPriv->clientClip);
+                if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+                    RegionDestroy(pPriv->pCompositeClip);
+                free(pPriv);
+            }
+        }
+        free(pAdaptor->pPorts);
+    }
+
+    if (pAdaptor->nAttributes) {
+        XvAttributePtr pAttribute = pAdaptor->pAttributes;
+
+        for (i = 0; i < pAdaptor->nAttributes; i++, pAttribute++) {
+            free(pAttribute->name);
+        }
+
+        free(pAdaptor->pAttributes);
+    }
+
+    free(pAdaptor->pImages);
+
+    free(pAdaptor->devPriv.ptr);
+}
+
+static Bool
+KdXVInitAdaptors(ScreenPtr pScreen, KdVideoAdaptorPtr * infoPtr, int number)
+{
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+    KdVideoAdaptorPtr adaptorPtr;
+    XvAdaptorPtr pAdaptor, pa;
+    XvAdaptorRecPrivatePtr adaptorPriv;
+    int na, numAdaptor;
+    XvPortRecPrivatePtr portPriv;
+    XvPortPtr pPort, pp;
+    int numPort;
+    KdAttributePtr attributePtr;
+    XvAttributePtr pAttribute, pat;
+    KdVideoFormatPtr formatPtr;
+    XvFormatPtr pFormat, pf;
+    int numFormat, totFormat;
+    KdVideoEncodingPtr encodingPtr;
+    XvEncodingPtr pEncode, pe;
+    KdImagePtr imagePtr;
+    XvImagePtr pImage, pi;
+    int numVisuals;
+    VisualPtr pVisual;
+    int i;
+
+    pxvs->nAdaptors = 0;
+    pxvs->pAdaptors = NULL;
+
+    if (!(pAdaptor = calloc(number, sizeof(XvAdaptorRec))))
+        return FALSE;
+
+    for (pa = pAdaptor, na = 0, numAdaptor = 0; na < number; na++, adaptorPtr++) {
+        adaptorPtr = infoPtr[na];
+
+        if (!adaptorPtr->StopVideo || !adaptorPtr->SetPortAttribute ||
+            !adaptorPtr->GetPortAttribute || !adaptorPtr->QueryBestSize)
+            continue;
+
+        /* client libs expect at least one encoding */
+        if (!adaptorPtr->nEncodings || !adaptorPtr->pEncodings)
+            continue;
+
+        pa->type = adaptorPtr->type;
+
+        if (!adaptorPtr->PutVideo && !adaptorPtr->GetVideo)
+            pa->type &= ~XvVideoMask;
+
+        if (!adaptorPtr->PutStill && !adaptorPtr->GetStill)
+            pa->type &= ~XvStillMask;
+
+        if (!adaptorPtr->PutImage || !adaptorPtr->QueryImageAttributes)
+            pa->type &= ~XvImageMask;
+
+        if (!adaptorPtr->PutVideo && !adaptorPtr->PutImage &&
+            !adaptorPtr->PutStill)
+            pa->type &= ~XvInputMask;
+
+        if (!adaptorPtr->GetVideo && !adaptorPtr->GetStill)
+            pa->type &= ~XvOutputMask;
+
+        if (!(adaptorPtr->type & (XvPixmapMask | XvWindowMask)))
+            continue;
+        if (!(adaptorPtr->type & (XvImageMask | XvVideoMask | XvStillMask)))
+            continue;
+
+        pa->pScreen = pScreen;
+        pa->ddAllocatePort = KdXVAllocatePort;
+        pa->ddFreePort = KdXVFreePort;
+        pa->ddPutVideo = KdXVPutVideo;
+        pa->ddPutStill = KdXVPutStill;
+        pa->ddGetVideo = KdXVGetVideo;
+        pa->ddGetStill = KdXVGetStill;
+        pa->ddStopVideo = KdXVStopVideo;
+        pa->ddPutImage = KdXVPutImage;
+        pa->ddSetPortAttribute = KdXVSetPortAttribute;
+        pa->ddGetPortAttribute = KdXVGetPortAttribute;
+        pa->ddQueryBestSize = KdXVQueryBestSize;
+        pa->ddQueryImageAttributes = KdXVQueryImageAttributes;
+        pa->name = strdup(adaptorPtr->name);
+
+        if (adaptorPtr->nEncodings &&
+            (pEncode = calloc(adaptorPtr->nEncodings, sizeof(XvEncodingRec)))) {
+
+            for (pe = pEncode, encodingPtr = adaptorPtr->pEncodings, i = 0;
+                 i < adaptorPtr->nEncodings; pe++, i++, encodingPtr++) {
+                pe->id = encodingPtr->id;
+                pe->pScreen = pScreen;
+                pe->name = strdup(encodingPtr->name);
+                pe->width = encodingPtr->width;
+                pe->height = encodingPtr->height;
+                pe->rate.numerator = encodingPtr->rate.numerator;
+                pe->rate.denominator = encodingPtr->rate.denominator;
+            }
+            pa->nEncodings = adaptorPtr->nEncodings;
+            pa->pEncodings = pEncode;
+        }
+
+        if (adaptorPtr->nImages &&
+            (pImage = calloc(adaptorPtr->nImages, sizeof(XvImageRec)))) {
+
+            for (i = 0, pi = pImage, imagePtr = adaptorPtr->pImages;
+                 i < adaptorPtr->nImages; i++, pi++, imagePtr++) {
+                pi->id = imagePtr->id;
+                pi->type = imagePtr->type;
+                pi->byte_order = imagePtr->byte_order;
+                memcpy(pi->guid, imagePtr->guid, 16);
+                pi->bits_per_pixel = imagePtr->bits_per_pixel;
+                pi->format = imagePtr->format;
+                pi->num_planes = imagePtr->num_planes;
+                pi->depth = imagePtr->depth;
+                pi->red_mask = imagePtr->red_mask;
+                pi->green_mask = imagePtr->green_mask;
+                pi->blue_mask = imagePtr->blue_mask;
+                pi->y_sample_bits = imagePtr->y_sample_bits;
+                pi->u_sample_bits = imagePtr->u_sample_bits;
+                pi->v_sample_bits = imagePtr->v_sample_bits;
+                pi->horz_y_period = imagePtr->horz_y_period;
+                pi->horz_u_period = imagePtr->horz_u_period;
+                pi->horz_v_period = imagePtr->horz_v_period;
+                pi->vert_y_period = imagePtr->vert_y_period;
+                pi->vert_u_period = imagePtr->vert_u_period;
+                pi->vert_v_period = imagePtr->vert_v_period;
+                memcpy(pi->component_order, imagePtr->component_order, 32);
+                pi->scanline_order = imagePtr->scanline_order;
+            }
+            pa->nImages = adaptorPtr->nImages;
+            pa->pImages = pImage;
+        }
+
+        if (adaptorPtr->nAttributes &&
+            (pAttribute =
+             calloc(adaptorPtr->nAttributes, sizeof(XvAttributeRec)))) {
+            for (pat = pAttribute, attributePtr = adaptorPtr->pAttributes, i =
+                 0; i < adaptorPtr->nAttributes; pat++, i++, attributePtr++) {
+                pat->flags = attributePtr->flags;
+                pat->min_value = attributePtr->min_value;
+                pat->max_value = attributePtr->max_value;
+                pat->name = strdup(attributePtr->name);
+            }
+            pa->nAttributes = adaptorPtr->nAttributes;
+            pa->pAttributes = pAttribute;
+        }
+
+        totFormat = adaptorPtr->nFormats;
+
+        if (!(pFormat = calloc(totFormat, sizeof(XvFormatRec)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+        for (pf = pFormat, i = 0, numFormat = 0, formatPtr =
+             adaptorPtr->pFormats; i < adaptorPtr->nFormats; i++, formatPtr++) {
+            numVisuals = pScreen->numVisuals;
+            pVisual = pScreen->visuals;
+
+            while (numVisuals--) {
+                if ((pVisual->class == formatPtr->class) &&
+                    (pVisual->nplanes == formatPtr->depth)) {
+
+                    if (numFormat >= totFormat) {
+                        void *moreSpace;
+
+                        totFormat *= 2;
+                        moreSpace = realloc(pFormat,
+                                            totFormat * sizeof(XvFormatRec));
+                        if (!moreSpace)
+                            break;
+                        pFormat = moreSpace;
+                        pf = pFormat + numFormat;
+                    }
+
+                    pf->visual = pVisual->vid;
+                    pf->depth = formatPtr->depth;
+
+                    pf++;
+                    numFormat++;
+                }
+                pVisual++;
+            }
+        }
+        pa->nFormats = numFormat;
+        pa->pFormats = pFormat;
+        if (!numFormat) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        if (!(adaptorPriv = calloc(1, sizeof(XvAdaptorRecPrivate)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        adaptorPriv->flags = adaptorPtr->flags;
+        adaptorPriv->PutVideo = adaptorPtr->PutVideo;
+        adaptorPriv->PutStill = adaptorPtr->PutStill;
+        adaptorPriv->GetVideo = adaptorPtr->GetVideo;
+        adaptorPriv->GetStill = adaptorPtr->GetStill;
+        adaptorPriv->StopVideo = adaptorPtr->StopVideo;
+        adaptorPriv->SetPortAttribute = adaptorPtr->SetPortAttribute;
+        adaptorPriv->GetPortAttribute = adaptorPtr->GetPortAttribute;
+        adaptorPriv->QueryBestSize = adaptorPtr->QueryBestSize;
+        adaptorPriv->QueryImageAttributes = adaptorPtr->QueryImageAttributes;
+        adaptorPriv->PutImage = adaptorPtr->PutImage;
+        adaptorPriv->ReputImage = adaptorPtr->ReputImage;
+
+        pa->devPriv.ptr = (pointer) adaptorPriv;
+
+        if (!(pPort = calloc(adaptorPtr->nPorts, sizeof(XvPortRec)))) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+        for (pp = pPort, i = 0, numPort = 0; i < adaptorPtr->nPorts; i++) {
+
+            if (!(pp->id = FakeClientID(0)))
+                continue;
+
+            if (!(portPriv = calloc(1, sizeof(XvPortRecPrivate))))
+                continue;
+
+            if (!AddResource(pp->id, PortResource, pp)) {
+                free(portPriv);
+                continue;
+            }
+
+            pp->pAdaptor = pa;
+            pp->pNotify = (XvPortNotifyPtr) NULL;
+            pp->pDraw = (DrawablePtr) NULL;
+            pp->client = (ClientPtr) NULL;
+            pp->grab.client = (ClientPtr) NULL;
+            pp->time = currentTime;
+            pp->devPriv.ptr = portPriv;
+
+            portPriv->screen = screen;
+            portPriv->AdaptorRec = adaptorPriv;
+            portPriv->DevPriv.ptr = adaptorPtr->pPortPrivates[i].ptr;
+
+            pp++;
+            numPort++;
+        }
+        pa->nPorts = numPort;
+        pa->pPorts = pPort;
+        if (!numPort) {
+            KdXVFreeAdaptor(pa);
+            continue;
+        }
+
+        pa->base_id = pPort->id;
+
+        pa++;
+        numAdaptor++;
+    }
+
+    if (numAdaptor) {
+        pxvs->nAdaptors = numAdaptor;
+        pxvs->pAdaptors = pAdaptor;
+    }
+    else {
+        free(pAdaptor);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/* Video should be clipped to the intersection of the window cliplist
+   and the client cliplist specified in the GC for which the video was
+   initialized.  When we need to reclip a window, the GC that started
+   the video may not even be around anymore.  That's why we save the
+   client clip from the GC when the video is initialized.  We then
+   use KdXVUpdateCompositeClip to calculate the new composite clip
+   when we need it.  This is different from what DEC did.  They saved
+   the GC and used it's clip list when they needed to reclip the window,
+   even if the client clip was different from the one the video was
+   initialized with.  If the original GC was destroyed, they had to stop
+   the video.  I like the new method better (MArk).
+
+   This function only works for windows.  Will need to rewrite when
+   (if) we support pixmap rendering.
+*/
+
+static void
+KdXVUpdateCompositeClip(XvPortRecPrivatePtr portPriv)
+{
+    RegionPtr pregWin, pCompositeClip;
+    WindowPtr pWin;
+    Bool freeCompClip = FALSE;
+
+    if (portPriv->pCompositeClip)
+        return;
+
+    pWin = (WindowPtr) portPriv->pDraw;
+
+    /* get window clip list */
+    if (portPriv->subWindowMode == IncludeInferiors) {
+        pregWin = NotClippedByChildren(pWin);
+        freeCompClip = TRUE;
+    }
+    else
+        pregWin = &pWin->clipList;
+
+    if (!portPriv->clientClip) {
+        portPriv->pCompositeClip = pregWin;
+        portPriv->FreeCompositeClip = freeCompClip;
+        return;
+    }
+
+    pCompositeClip = RegionCreate(NullBox, 1);
+    RegionCopy(pCompositeClip, portPriv->clientClip);
+    RegionTranslate(pCompositeClip,
+                    portPriv->pDraw->x + portPriv->clipOrg.x,
+                    portPriv->pDraw->y + portPriv->clipOrg.y);
+    RegionIntersect(pCompositeClip, pregWin, pCompositeClip);
+
+    portPriv->pCompositeClip = pCompositeClip;
+    portPriv->FreeCompositeClip = TRUE;
+
+    if (freeCompClip) {
+        RegionDestroy(pregWin);
+    }
+}
+
+/* Save the current clientClip and update the CompositeClip whenever
+   we have a fresh GC */
+
+static void
+KdXVCopyClip(XvPortRecPrivatePtr portPriv, GCPtr pGC)
+{
+    /* copy the new clip if it exists */
+    if ((pGC->clientClipType == CT_REGION) && pGC->clientClip) {
+        if (!portPriv->clientClip)
+            portPriv->clientClip = RegionCreate(NullBox, 1);
+        /* Note: this is in window coordinates */
+        RegionCopy(portPriv->clientClip, pGC->clientClip);
+    }
+    else if (portPriv->clientClip) {    /* free the old clientClip */
+        RegionDestroy(portPriv->clientClip);
+        portPriv->clientClip = NULL;
+    }
+
+    /* get rid of the old clip list */
+    if (portPriv->pCompositeClip && portPriv->FreeCompositeClip) {
+        RegionDestroy(portPriv->pCompositeClip);
+    }
+
+    portPriv->clipOrg = pGC->clipOrg;
+    portPriv->pCompositeClip = pGC->pCompositeClip;
+    portPriv->FreeCompositeClip = FALSE;
+    portPriv->subWindowMode = pGC->subWindowMode;
+}
+
+static int
+KdXVRegetVideo(XvPortRecPrivatePtr portPriv)
+{
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->GetVideo) (portPriv->screen, portPriv->pDraw,
+                                             portPriv->vid_x, portPriv->vid_y,
+                                             WinBox.x1, WinBox.y1,
+                                             portPriv->vid_w, portPriv->vid_h,
+                                             portPriv->drw_w, portPriv->drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if (ret == Success)
+        portPriv->isOn = XV_ON;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && portPriv->isOn == XV_ON) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVReputVideo(XvPortRecPrivatePtr portPriv)
+{
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    ScreenPtr pScreen = portPriv->pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* clip and translate to the viewport */
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    /* bailout if we have to clip but the hardware doesn't support it */
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto CLIP_VIDEO_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutVideo) (portPriv->screen, portPriv->pDraw,
+                                             portPriv->vid_x, portPriv->vid_y,
+                                             WinBox.x1, WinBox.y1,
+                                             portPriv->vid_w, portPriv->vid_h,
+                                             portPriv->drw_w, portPriv->drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if (ret == Success)
+        portPriv->isOn = XV_ON;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVReputImage(XvPortRecPrivatePtr portPriv)
+{
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    ScreenPtr pScreen = portPriv->pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    KdXVUpdateCompositeClip(portPriv);
+
+    /* translate the video region to the screen */
+    WinBox.x1 = portPriv->pDraw->x + portPriv->drw_x;
+    WinBox.y1 = portPriv->pDraw->y + portPriv->drw_y;
+    WinBox.x2 = WinBox.x1 + portPriv->drw_w;
+    WinBox.y2 = WinBox.y1 + portPriv->drw_h;
+
+    /* clip to the window composite clip */
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, portPriv->pCompositeClip);
+
+    /* clip and translate to the viewport */
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    /* that's all if it's totally obscured */
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto CLIP_VIDEO_BAILOUT;
+    }
+
+    /* bailout if we have to clip but the hardware doesn't support it */
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto CLIP_VIDEO_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret =
+        (*portPriv->AdaptorRec->ReputImage) (portPriv->screen, portPriv->pDraw,
+                                             WinBox.x1, WinBox.y1, &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    portPriv->isOn = (ret == Success) ? XV_ON : XV_OFF;
+
+ CLIP_VIDEO_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    /* This clip was copied and only good for one shot */
+    if (!portPriv->FreeCompositeClip)
+        portPriv->pCompositeClip = NULL;
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVReputAllVideo(WindowPtr pWin, pointer data)
+{
+    KdXVWindowPtr WinPriv;
+
+    if (pWin->drawable.type != DRAWABLE_WINDOW)
+        return WT_DONTWALKCHILDREN;
+
+    WinPriv = GET_KDXV_WINDOW(pWin);
+
+    while (WinPriv) {
+        if (WinPriv->PortRec->type == XvInputMask)
+            KdXVReputVideo(WinPriv->PortRec);
+        else
+            KdXVRegetVideo(WinPriv->PortRec);
+        WinPriv = WinPriv->next;
+    }
+
+    return WT_WALKCHILDREN;
+}
+
+static int
+KdXVEnlistPortInWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)
+{
+    KdXVWindowPtr winPriv, PrivRoot;
+
+    winPriv = PrivRoot = GET_KDXV_WINDOW(pWin);
+
+    /* Enlist our port in the window private */
+    while (winPriv) {
+        if (winPriv->PortRec == portPriv)       /* we're already listed */
+            break;
+        winPriv = winPriv->next;
+    }
+
+    if (!winPriv) {
+        winPriv = malloc(sizeof(KdXVWindowRec));
+        if (!winPriv)
+            return BadAlloc;
+        winPriv->PortRec = portPriv;
+        winPriv->next = PrivRoot;
+        dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv);
+    }
+    return Success;
+}
+
+static void
+KdXVRemovePortFromWindow(WindowPtr pWin, XvPortRecPrivatePtr portPriv)
+{
+    KdXVWindowPtr winPriv, prevPriv = NULL;
+
+    winPriv = GET_KDXV_WINDOW(pWin);
+
+    while (winPriv) {
+        if (winPriv->PortRec == portPriv) {
+            if (prevPriv)
+                prevPriv->next = winPriv->next;
+            else
+                dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, winPriv->next);
+            free(winPriv);
+            break;
+        }
+        prevPriv = winPriv;
+        winPriv = winPriv->next;
+    }
+    portPriv->pDraw = NULL;
+}
+
+/****  ScreenRec fields ****/
+
+static Bool
+KdXVCreateWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    int ret;
+
+    pScreen->CreateWindow = ScreenPriv->CreateWindow;
+    ret = (*pScreen->CreateWindow) (pWin);
+    pScreen->CreateWindow = KdXVCreateWindow;
+
+    if (ret)
+        dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
+
+    return ret;
+}
+
+static Bool
+KdXVDestroyWindow(WindowPtr pWin)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr tmp, WinPriv = GET_KDXV_WINDOW(pWin);
+    int ret;
+
+    while (WinPriv) {
+        XvPortRecPrivatePtr pPriv = WinPriv->PortRec;
+
+        if (pPriv->isOn > XV_OFF) {
+            (*pPriv->AdaptorRec->StopVideo) (pPriv->screen, pPriv->DevPriv.ptr,
+                                             TRUE);
+            pPriv->isOn = XV_OFF;
+        }
+
+        pPriv->pDraw = NULL;
+        tmp = WinPriv;
+        WinPriv = WinPriv->next;
+        free(tmp);
+    }
+
+    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey, NULL);
+
+    pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
+    ret = (*pScreen->DestroyWindow) (pWin);
+    pScreen->DestroyWindow = KdXVDestroyWindow;
+
+    return ret;
+}
+
+static void
+KdXVWindowExposures(WindowPtr pWin, RegionPtr reg1, RegionPtr reg2)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
+    KdXVWindowPtr pPrev;
+    XvPortRecPrivatePtr pPriv;
+    Bool AreasExposed;
+
+    AreasExposed = (WinPriv && reg1 && RegionNotEmpty(reg1));
+
+    pScreen->WindowExposures = ScreenPriv->WindowExposures;
+    (*pScreen->WindowExposures) (pWin, reg1, reg2);
+    pScreen->WindowExposures = KdXVWindowExposures;
+
+    /* filter out XClearWindow/Area */
+    if (!pWin->valdata)
+        return;
+
+    pPrev = NULL;
+
+    while (WinPriv) {
+        pPriv = WinPriv->PortRec;
+
+        /* Reput anyone with a reput function */
+
+        switch (pPriv->type) {
+        case XvInputMask:
+            KdXVReputVideo(pPriv);
+            break;
+        case XvOutputMask:
+            KdXVRegetVideo(pPriv);
+            break;
+        default:               /* overlaid still/image */
+            if (pPriv->AdaptorRec->ReputImage)
+                KdXVReputImage(pPriv);
+            else if (AreasExposed) {
+                KdXVWindowPtr tmp;
+
+                if (pPriv->isOn == XV_ON) {
+                    (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                     pPriv->DevPriv.ptr, FALSE);
+                    pPriv->isOn = XV_PENDING;
+                }
+                pPriv->pDraw = NULL;
+
+                if (!pPrev)
+                    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey,
+                                  WinPriv->next);
+                else
+                    pPrev->next = WinPriv->next;
+                tmp = WinPriv;
+                WinPriv = WinPriv->next;
+                free(tmp);
+                continue;
+            }
+            break;
+        }
+        pPrev = WinPriv;
+        WinPriv = WinPriv->next;
+    }
+}
+
+static void
+KdXVClipNotify(WindowPtr pWin, int dx, int dy)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    KdXVWindowPtr WinPriv = GET_KDXV_WINDOW(pWin);
+    KdXVWindowPtr tmp, pPrev = NULL;
+    XvPortRecPrivatePtr pPriv;
+    Bool visible = (pWin->visibility == VisibilityUnobscured) ||
+        (pWin->visibility == VisibilityPartiallyObscured);
+
+    while (WinPriv) {
+        pPriv = WinPriv->PortRec;
+
+        if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+            RegionDestroy(pPriv->pCompositeClip);
+
+        pPriv->pCompositeClip = NULL;
+
+        /* Stop everything except images, but stop them too if the
+           window isn't visible.  But we only remove the images. */
+
+        if (pPriv->type || !visible) {
+            if (pPriv->isOn == XV_ON) {
+                (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                 pPriv->DevPriv.ptr, FALSE);
+                pPriv->isOn = XV_PENDING;
+            }
+
+            if (!pPriv->type) { /* overlaid still/image */
+                pPriv->pDraw = NULL;
+
+                if (!pPrev)
+                    dixSetPrivate(&pWin->devPrivates, KdXVWindowKey,
+                                  WinPriv->next);
+                else
+                    pPrev->next = WinPriv->next;
+                tmp = WinPriv;
+                WinPriv = WinPriv->next;
+                free(tmp);
+                continue;
+            }
+        }
+
+        pPrev = WinPriv;
+        WinPriv = WinPriv->next;
+    }
+
+    if (ScreenPriv->ClipNotify) {
+        pScreen->ClipNotify = ScreenPriv->ClipNotify;
+        (*pScreen->ClipNotify) (pWin, dx, dy);
+        pScreen->ClipNotify = KdXVClipNotify;
+    }
+}
+
+/**** Required XvScreenRec fields ****/
+
+static Bool
+KdXVCloseScreen(int i, ScreenPtr pScreen)
+{
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+    KdXVScreenPtr ScreenPriv = GET_KDXV_SCREEN(pScreen);
+    XvAdaptorPtr pa;
+    int c;
+
+    if (!ScreenPriv)
+        return TRUE;
+
+    pScreen->CreateWindow = ScreenPriv->CreateWindow;
+    pScreen->DestroyWindow = ScreenPriv->DestroyWindow;
+    pScreen->WindowExposures = ScreenPriv->WindowExposures;
+    pScreen->ClipNotify = ScreenPriv->ClipNotify;
+
+/*   fprintf(stderr,"XV: Unwrapping screen funcs\n"); */
+
+    for (c = 0, pa = pxvs->pAdaptors; c < pxvs->nAdaptors; c++, pa++) {
+        KdXVFreeAdaptor(pa);
+    }
+
+    free(pxvs->pAdaptors);
+    free(ScreenPriv);
+
+    return TRUE;
+}
+
+static int
+KdXVQueryAdaptors(ScreenPtr pScreen,
+                  XvAdaptorPtr * p_pAdaptors, int *p_nAdaptors)
+{
+    XvScreenPtr pxvs = GET_XV_SCREEN(pScreen);
+
+    *p_nAdaptors = pxvs->nAdaptors;
+    *p_pAdaptors = pxvs->pAdaptors;
+
+    return Success;
+}
+
+static Bool
+KdXVRunning(ScreenPtr pScreen)
+{
+    return (KdXVGeneration == serverGeneration && GET_XV_SCREEN(pScreen) != 0);
+}
+
+Bool
+KdXVEnable(ScreenPtr pScreen)
+{
+    if (!KdXVRunning(pScreen))
+        return TRUE;
+
+    WalkTree(pScreen, KdXVReputAllVideo, 0);
+
+    return TRUE;
+}
+
+void
+KdXVDisable(ScreenPtr pScreen)
+{
+    XvScreenPtr pxvs;
+    KdXVScreenPtr ScreenPriv;
+    XvAdaptorPtr pAdaptor;
+    XvPortPtr pPort;
+    XvPortRecPrivatePtr pPriv;
+    int i, j;
+
+    if (!KdXVRunning(pScreen))
+        return;
+
+    pxvs = GET_XV_SCREEN(pScreen);
+    ScreenPriv = GET_KDXV_SCREEN(pScreen);
+
+    for (i = 0; i < pxvs->nAdaptors; i++) {
+        pAdaptor = &pxvs->pAdaptors[i];
+        for (j = 0; j < pAdaptor->nPorts; j++) {
+            pPort = &pAdaptor->pPorts[j];
+            pPriv = (XvPortRecPrivatePtr) pPort->devPriv.ptr;
+            if (pPriv->isOn > XV_OFF) {
+
+                (*pPriv->AdaptorRec->StopVideo) (pPriv->screen,
+                                                 pPriv->DevPriv.ptr, TRUE);
+                pPriv->isOn = XV_OFF;
+
+                if (pPriv->pCompositeClip && pPriv->FreeCompositeClip)
+                    RegionDestroy(pPriv->pCompositeClip);
+
+                pPriv->pCompositeClip = NULL;
+
+                if (!pPriv->type && pPriv->pDraw) {     /* still */
+                    KdXVRemovePortFromWindow((WindowPtr) pPriv->pDraw, pPriv);
+                }
+            }
+        }
+    }
+}
+
+/**** XvAdaptorRec fields ****/
+
+static int
+KdXVAllocatePort(unsigned long port, XvPortPtr pPort, XvPortPtr * ppPort)
+{
+    *ppPort = pPort;
+    return Success;
+}
+
+static int
+KdXVFreePort(XvPortPtr pPort)
+{
+    return Success;
+}
+
+static int
+KdXVPutVideo(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    KdScreenPriv(portPriv->screen->pScreen);
+    int result;
+
+    /* No dumping video to pixmaps... For now anyhow */
+    if (pDraw->type != DRAWABLE_WINDOW) {
+        pPort->pDraw = (DrawablePtr) NULL;
+        return BadAlloc;
+    }
+
+    /* If we are changing windows, unregister our port in the old window */
+    if (portPriv->pDraw && (portPriv->pDraw != pDraw))
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+
+    /* Register our port with the new window */
+    result = KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+    if (result != Success)
+        return result;
+
+    portPriv->pDraw = pDraw;
+    portPriv->type = XvInputMask;
+
+    /* save a copy of these parameters */
+    portPriv->vid_x = vid_x;
+    portPriv->vid_y = vid_y;
+    portPriv->vid_w = vid_w;
+    portPriv->vid_h = vid_h;
+    portPriv->drw_x = drw_x;
+    portPriv->drw_y = drw_y;
+    portPriv->drw_w = drw_w;
+    portPriv->drw_h = drw_h;
+
+    /* make sure we have the most recent copy of the clientClip */
+    KdXVCopyClip(portPriv, pGC);
+
+    /* To indicate to the DI layer that we were successful */
+    pPort->pDraw = pDraw;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    return (KdXVReputVideo(portPriv));
+}
+
+static int
+KdXVPutStill(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    KdScreenInfo *screen = pScreenPriv->screen;
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
+
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = screen->width;
+        VPBox.y2 = screen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
+
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto PUT_STILL_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto PUT_STILL_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutStill) (portPriv->screen, pDraw,
+                                             vid_x, vid_y, WinBox.x1, WinBox.y1,
+                                             vid_w, vid_h, drw_w, drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if ((ret == Success) &&
+        (portPriv->AdaptorRec->flags & VIDEO_OVERLAID_STILLS)) {
+
+        KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+        portPriv->isOn = XV_ON;
+        portPriv->pDraw = pDraw;
+        portPriv->drw_x = drw_x;
+        portPriv->drw_y = drw_y;
+        portPriv->drw_w = drw_w;
+        portPriv->drw_h = drw_h;
+        portPriv->type = 0;     /* no mask means it's transient and should
+                                   not be reput once it's removed */
+        pPort->pDraw = pDraw;   /* make sure we can get stop requests */
+    }
+
+ PUT_STILL_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVGetVideo(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    int result;
+
+    KdScreenPriv(portPriv->screen->pScreen);
+
+    /* No pixmaps... For now anyhow */
+    if (pDraw->type != DRAWABLE_WINDOW) {
+        pPort->pDraw = (DrawablePtr) NULL;
+        return BadAlloc;
+    }
+
+    /* If we are changing windows, unregister our port in the old window */
+    if (portPriv->pDraw && (portPriv->pDraw != pDraw))
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+
+    /* Register our port with the new window */
+    result = KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+    if (result != Success)
+        return result;
+
+    portPriv->pDraw = pDraw;
+    portPriv->type = XvOutputMask;
+
+    /* save a copy of these parameters */
+    portPriv->vid_x = vid_x;
+    portPriv->vid_y = vid_y;
+    portPriv->vid_w = vid_w;
+    portPriv->vid_h = vid_h;
+    portPriv->drw_x = drw_x;
+    portPriv->drw_y = drw_y;
+    portPriv->drw_w = drw_w;
+    portPriv->drw_h = drw_h;
+
+    /* make sure we have the most recent copy of the clientClip */
+    KdXVCopyClip(portPriv, pGC);
+
+    /* To indicate to the DI layer that we were successful */
+    pPort->pDraw = pDraw;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    return (KdXVRegetVideo(portPriv));
+}
+
+static int
+KdXVGetStill(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 vid_x, INT16 vid_y,
+             CARD16 vid_w, CARD16 vid_h,
+             INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
+
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
+
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto GET_STILL_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->GetStill) (portPriv->screen, pDraw,
+                                             vid_x, vid_y, WinBox.x1, WinBox.y1,
+                                             vid_w, vid_h, drw_w, drw_h,
+                                             &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+ GET_STILL_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVStopVideo(ClientPtr client, XvPortPtr pPort, DrawablePtr pDraw)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    KdScreenPriv(portPriv->screen->pScreen);
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    KdXVRemovePortFromWindow((WindowPtr) pDraw, portPriv);
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    /* Must free resources. */
+
+    if (portPriv->isOn > XV_OFF) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, TRUE);
+        portPriv->isOn = XV_OFF;
+    }
+
+    return Success;
+}
+
+static int
+KdXVSetPortAttribute(ClientPtr client,
+                     XvPortPtr pPort, Atom attribute, INT32 value)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    return ((*portPriv->AdaptorRec->SetPortAttribute) (portPriv->screen,
+                                                       attribute, value,
+                                                       portPriv->DevPriv.ptr));
+}
+
+static int
+KdXVGetPortAttribute(ClientPtr client,
+                     XvPortPtr pPort, Atom attribute, INT32 *p_value)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    return ((*portPriv->AdaptorRec->GetPortAttribute) (portPriv->screen,
+                                                       attribute,
+                                                       (int *) p_value,
+                                                       portPriv->DevPriv.ptr));
+}
+
+static int
+KdXVQueryBestSize(ClientPtr client,
+                  XvPortPtr pPort,
+                  CARD8 motion,
+                  CARD16 vid_w, CARD16 vid_h,
+                  CARD16 drw_w, CARD16 drw_h,
+                  unsigned int *p_w, unsigned int *p_h)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    (*portPriv->AdaptorRec->QueryBestSize) (portPriv->screen,
+                                            (Bool) motion, vid_w, vid_h, drw_w,
+                                            drw_h, p_w, p_h,
+                                            portPriv->DevPriv.ptr);
+
+    return Success;
+}
+
+static int
+KdXVPutImage(ClientPtr client,
+             DrawablePtr pDraw,
+             XvPortPtr pPort,
+             GCPtr pGC,
+             INT16 src_x, INT16 src_y,
+             CARD16 src_w, CARD16 src_h,
+             INT16 drw_x, INT16 drw_y,
+             CARD16 drw_w, CARD16 drw_h,
+             XvImagePtr format,
+             unsigned char *data, Bool sync, CARD16 width, CARD16 height)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+    ScreenPtr pScreen = pDraw->pScreen;
+
+    KdScreenPriv(pScreen);
+    RegionRec WinRegion;
+    RegionRec ClipRegion;
+    BoxRec WinBox;
+    int ret = Success;
+    Bool clippedAway = FALSE;
+
+    if (pDraw->type != DRAWABLE_WINDOW)
+        return BadAlloc;
+
+    if (!pScreenPriv->enabled)
+        return Success;
+
+    WinBox.x1 = pDraw->x + drw_x;
+    WinBox.y1 = pDraw->y + drw_y;
+    WinBox.x2 = WinBox.x1 + drw_w;
+    WinBox.y2 = WinBox.y1 + drw_h;
+
+    RegionInit(&WinRegion, &WinBox, 1);
+    RegionInit(&ClipRegion, NullBox, 1);
+    RegionIntersect(&ClipRegion, &WinRegion, pGC->pCompositeClip);
+
+    if (portPriv->AdaptorRec->flags & VIDEO_CLIP_TO_VIEWPORT) {
+        RegionRec VPReg;
+        BoxRec VPBox;
+
+        VPBox.x1 = 0;
+        VPBox.y1 = 0;
+        VPBox.x2 = pScreen->width;
+        VPBox.y2 = pScreen->height;
+
+        RegionInit(&VPReg, &VPBox, 1);
+        RegionIntersect(&ClipRegion, &ClipRegion, &VPReg);
+        RegionUninit(&VPReg);
+    }
+
+    if (portPriv->pDraw) {
+        KdXVRemovePortFromWindow((WindowPtr) (portPriv->pDraw), portPriv);
+    }
+
+    if (!RegionNotEmpty(&ClipRegion)) {
+        clippedAway = TRUE;
+        goto PUT_IMAGE_BAILOUT;
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_NO_CLIPPING) {
+        BoxPtr clipBox = RegionRects(&ClipRegion);
+
+        if ((RegionNumRects(&ClipRegion) != 1) ||
+            (clipBox->x1 != WinBox.x1) || (clipBox->x2 != WinBox.x2) ||
+            (clipBox->y1 != WinBox.y1) || (clipBox->y2 != WinBox.y2)) {
+            clippedAway = TRUE;
+            goto PUT_IMAGE_BAILOUT;
+        }
+    }
+
+    if (portPriv->AdaptorRec->flags & VIDEO_INVERT_CLIPLIST) {
+        RegionSubtract(&ClipRegion, &WinRegion, &ClipRegion);
+    }
+
+    ret = (*portPriv->AdaptorRec->PutImage) (portPriv->screen, pDraw,
+                                             src_x, src_y, WinBox.x1, WinBox.y1,
+                                             src_w, src_h, drw_w, drw_h,
+                                             format->id, data, width, height,
+                                             sync, &ClipRegion,
+                                             portPriv->DevPriv.ptr);
+
+    if ((ret == Success) &&
+        (portPriv->AdaptorRec->flags & VIDEO_OVERLAID_IMAGES)) {
+
+        KdXVEnlistPortInWindow((WindowPtr) pDraw, portPriv);
+        portPriv->isOn = XV_ON;
+        portPriv->pDraw = pDraw;
+        portPriv->drw_x = drw_x;
+        portPriv->drw_y = drw_y;
+        portPriv->drw_w = drw_w;
+        portPriv->drw_h = drw_h;
+        portPriv->type = 0;     /* no mask means it's transient and should
+                                   not be reput once it's removed */
+        pPort->pDraw = pDraw;   /* make sure we can get stop requests */
+    }
+
+ PUT_IMAGE_BAILOUT:
+
+    if ((clippedAway || (ret != Success)) && (portPriv->isOn == XV_ON)) {
+        (*portPriv->AdaptorRec->StopVideo) (portPriv->screen,
+                                            portPriv->DevPriv.ptr, FALSE);
+        portPriv->isOn = XV_PENDING;
+    }
+
+    RegionUninit(&WinRegion);
+    RegionUninit(&ClipRegion);
+
+    return ret;
+}
+
+static int
+KdXVQueryImageAttributes(ClientPtr client,
+                         XvPortPtr pPort,
+                         XvImagePtr format,
+                         CARD16 *width,
+                         CARD16 *height, int *pitches, int *offsets)
+{
+    XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) (pPort->devPriv.ptr);
+
+    return (*portPriv->AdaptorRec->QueryImageAttributes) (portPriv->screen,
+                                                          format->id, width,
+                                                          height, pitches,
+                                                          offsets);
+}
+
+/****************  Common video manipulation functions *******************/
+
+void
+KdXVCopyPackedData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int dstPitch, int srcW, int srcH, int top,
+                   int left, int h, int w)
+{
+    int srcDown = srcPitch, srcRight = 2, srcNext;
+    int p;
+
+    switch (randr & RR_Rotate_All) {
+    case RR_Rotate_0:
+        srcDown = srcPitch;
+        srcRight = 2;
+        break;
+    case RR_Rotate_90:
+        src += (srcH - 1) * 2;
+        srcDown = -2;
+        srcRight = srcPitch;
+        break;
+    case RR_Rotate_180:
+        src += srcPitch * (srcH - 1) + (srcW - 1) * 2;
+        srcDown = -srcPitch;
+        srcRight = -2;
+        break;
+    case RR_Rotate_270:
+        src += srcPitch * (srcW - 1);
+        srcDown = 2;
+        srcRight = -srcPitch;
+        break;
+    }
+
+    src = src + top * srcDown + left * srcRight;
+
+    w >>= 1;
+    /* srcRight >>= 1; */
+    srcNext = srcRight >> 1;
+    while (h--) {
+        CARD16 *s = (CARD16 *) src;
+        CARD32 *d = (CARD32 *) dst;
+
+        p = w;
+        while (p--) {
+            *d++ = s[0] | (s[srcNext] << 16);
+            s += srcRight;
+        }
+        src += srcPitch;
+        dst += dstPitch;
+    }
+}
+
+void
+KdXVCopyPlanarData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int srcPitch2, int dstPitch, int srcW,
+                   int srcH, int height, int top, int left, int h, int w,
+                   int id)
+{
+    int i, j;
+    CARD8 *src1, *src2, *src3, *dst1;
+    int srcDown = srcPitch, srcDown2 = srcPitch2;
+    int srcRight = 2, srcRight2 = 1, srcNext = 1;
+
+    /* compute source data pointers */
+    src1 = src;
+    src2 = src1 + height * srcPitch;
+    src3 = src2 + (height >> 1) * srcPitch2;
+    switch (randr & RR_Rotate_All) {
+    case RR_Rotate_0:
+        srcDown = srcPitch;
+        srcDown2 = srcPitch2;
+        srcRight = 2;
+        srcRight2 = 1;
+        srcNext = 1;
+        break;
+    case RR_Rotate_90:
+        src1 = src1 + srcH - 1;
+        src2 = src2 + (srcH >> 1) - 1;
+        src3 = src3 + (srcH >> 1) - 1;
+        srcDown = -1;
+        srcDown2 = -1;
+        srcRight = srcPitch * 2;
+        srcRight2 = srcPitch2;
+        srcNext = srcPitch;
+        break;
+    case RR_Rotate_180:
+        src1 = src1 + srcPitch * (srcH - 1) + (srcW - 1);
+        src2 = src2 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
+        src3 = src3 + srcPitch2 * ((srcH >> 1) - 1) + ((srcW >> 1) - 1);
+        srcDown = -srcPitch;
+        srcDown2 = -srcPitch2;
+        srcRight = -2;
+        srcRight2 = -1;
+        srcNext = -1;
+        break;
+    case RR_Rotate_270:
+        src1 = src1 + srcPitch * (srcW - 1);
+        src2 = src2 + srcPitch2 * ((srcW >> 1) - 1);
+        src3 = src3 + srcPitch2 * ((srcW >> 1) - 1);
+        srcDown = 1;
+        srcDown2 = 1;
+        srcRight = -srcPitch * 2;
+        srcRight2 = -srcPitch2;
+        srcNext = -srcPitch;
+        break;
+    }
+
+    /* adjust for origin */
+    src1 += top * srcDown + left * srcNext;
+    src2 += (top >> 1) * srcDown2 + (left >> 1) * srcRight2;
+    src3 += (top >> 1) * srcDown2 + (left >> 1) * srcRight2;
+
+    if (id == FOURCC_I420) {
+        CARD8 *srct = src2;
+
+        src2 = src3;
+        src3 = srct;
+    }
+
+    dst1 = dst;
+
+    w >>= 1;
+    for (j = 0; j < h; j++) {
+        CARD32 *dst = (CARD32 *) dst1;
+        CARD8 *s1l = src1;
+        CARD8 *s1r = src1 + srcNext;
+        CARD8 *s2 = src2;
+        CARD8 *s3 = src3;
+
+        for (i = 0; i < w; i++) {
+            *dst++ = *s1l | (*s1r << 16) | (*s3 << 8) | (*s2 << 24);
+            s1l += srcRight;
+            s1r += srcRight;
+            s2 += srcRight2;
+            s3 += srcRight2;
+        }
+        src1 += srcDown;
+        dst1 += dstPitch;
+        if (j & 1) {
+            src2 += srcDown2;
+            src3 += srcDown2;
+        }
+    }
+}
+
+void
+KXVPaintRegion(DrawablePtr pDraw, RegionPtr pRgn, Pixel fg)
+{
+    GCPtr pGC;
+    ChangeGCVal val[2];
+    xRectangle *rects, *r;
+    BoxPtr pBox = RegionRects(pRgn);
+    int nBox = RegionNumRects(pRgn);
+
+    rects = malloc(nBox * sizeof(xRectangle));
+    if (!rects)
+        goto bail0;
+    r = rects;
+    while (nBox--) {
+        r->x = pBox->x1 - pDraw->x;
+        r->y = pBox->y1 - pDraw->y;
+        r->width = pBox->x2 - pBox->x1;
+        r->height = pBox->y2 - pBox->y1;
+        r++;
+        pBox++;
+    }
+
+    pGC = GetScratchGC(pDraw->depth, pDraw->pScreen);
+    if (!pGC)
+        goto bail1;
+
+    val[0].val = fg;
+    val[1].val = IncludeInferiors;
+    ChangeGC(NullClient, pGC, GCForeground | GCSubwindowMode, val);
+
+    ValidateGC(pDraw, pGC);
+
+    (*pGC->ops->PolyFillRect) (pDraw, pGC, RegionNumRects(pRgn), rects);
+
+    FreeScratchGC(pGC);
+ bail1:
+    free(rects);
+ bail0:
+    ;
+}
diff --git a/xorg-server/hw/kdrive/src/kxv.h b/xorg-server/hw/kdrive/src/kxv.h
index 21a295be3..29118bc96 100644
--- a/xorg-server/hw/kdrive/src/kxv.h
+++ b/xorg-server/hw/kdrive/src/kxv.h
@@ -57,80 +57,86 @@ of the copyright holder.
 #define VIDEO_CLIP_TO_VIEWPORT			0x00000010
 
 typedef struct {
-  int id;
-  int type;
-  int byte_order;
-  unsigned char guid[16];
-  int bits_per_pixel;
-  int format;
-  int num_planes;
-
-  /* for RGB formats only */
-  int depth;
-  unsigned int red_mask;
-  unsigned int green_mask;
-  unsigned int blue_mask;
-
-  /* for YUV formats only */
-  unsigned int y_sample_bits;
-  unsigned int u_sample_bits;
-  unsigned int v_sample_bits;
-  unsigned int horz_y_period;
-  unsigned int horz_u_period;
-  unsigned int horz_v_period;
-  unsigned int vert_y_period;
-  unsigned int vert_u_period;
-  unsigned int vert_v_period;
-  char component_order[32];
-  int scanline_order;
+    int id;
+    int type;
+    int byte_order;
+    unsigned char guid[16];
+    int bits_per_pixel;
+    int format;
+    int num_planes;
+
+    /* for RGB formats only */
+    int depth;
+    unsigned int red_mask;
+    unsigned int green_mask;
+    unsigned int blue_mask;
+
+    /* for YUV formats only */
+    unsigned int y_sample_bits;
+    unsigned int u_sample_bits;
+    unsigned int v_sample_bits;
+    unsigned int horz_y_period;
+    unsigned int horz_u_period;
+    unsigned int horz_v_period;
+    unsigned int vert_y_period;
+    unsigned int vert_u_period;
+    unsigned int vert_v_period;
+    char component_order[32];
+    int scanline_order;
 } KdImageRec, *KdImagePtr;
 
-
 typedef struct {
-  KdScreenInfo * screen;
-  int id;
-  unsigned short width, height;
-  int *pitches; /* bytes */
-  int *offsets; /* in bytes from start of framebuffer */
-  DevUnion devPrivate;
+    KdScreenInfo *screen;
+    int id;
+    unsigned short width, height;
+    int *pitches;               /* bytes */
+    int *offsets;               /* in bytes from start of framebuffer */
+    DevUnion devPrivate;
 } KdSurfaceRec, *KdSurfacePtr;
 
-
-typedef int (* PutVideoFuncPtr)( KdScreenInfo * screen, DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* PutStillFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* GetVideoFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* GetStillFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short vid_x, short vid_y, short drw_x, short drw_y,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	RegionPtr clipBoxes, pointer data );
-typedef void (* StopVideoFuncPtr)(KdScreenInfo * screen, pointer data, Bool Exit);
-typedef int (* SetPortAttributeFuncPtr)(KdScreenInfo * screen, Atom attribute,
-	int value, pointer data);
-typedef int (* GetPortAttributeFuncPtr)(KdScreenInfo * screen, Atom attribute,
-	int *value, pointer data);
-typedef void (* QueryBestSizeFuncPtr)(KdScreenInfo * screen, Bool motion,
-	short vid_w, short vid_h, short drw_w, short drw_h,
-	unsigned int *p_w, unsigned int *p_h, pointer data);
-typedef int (* PutImageFuncPtr)( KdScreenInfo * screen,  DrawablePtr pDraw,
-	short src_x, short src_y, short drw_x, short drw_y,
-	short src_w, short src_h, short drw_w, short drw_h,
-	int image, unsigned char* buf, short width, short height, Bool Sync,
-	RegionPtr clipBoxes, pointer data );
-typedef int (* ReputImageFuncPtr)( KdScreenInfo * screen, DrawablePtr pDraw,
-				  short drw_x, short drw_y,
-				  RegionPtr clipBoxes, pointer data );
-typedef int (*QueryImageAttributesFuncPtr)(KdScreenInfo * screen,
-	int image, unsigned short *width, unsigned short *height,
-	int *pitches, int *offsets);
+typedef int (*PutVideoFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*PutStillFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*GetVideoFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef int (*GetStillFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short vid_x, short vid_y, short drw_x,
+                                short drw_y, short vid_w, short vid_h,
+                                short drw_w, short drw_h, RegionPtr clipBoxes,
+                                pointer data);
+typedef void (*StopVideoFuncPtr) (KdScreenInfo * screen, pointer data,
+                                  Bool Exit);
+typedef int (*SetPortAttributeFuncPtr) (KdScreenInfo * screen, Atom attribute,
+                                        int value, pointer data);
+typedef int (*GetPortAttributeFuncPtr) (KdScreenInfo * screen, Atom attribute,
+                                        int *value, pointer data);
+typedef void (*QueryBestSizeFuncPtr) (KdScreenInfo * screen, Bool motion,
+                                      short vid_w, short vid_h, short drw_w,
+                                      short drw_h, unsigned int *p_w,
+                                      unsigned int *p_h, pointer data);
+typedef int (*PutImageFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                short src_x, short src_y, short drw_x,
+                                short drw_y, short src_w, short src_h,
+                                short drw_w, short drw_h, int image,
+                                unsigned char *buf, short width, short height,
+                                Bool Sync, RegionPtr clipBoxes, pointer data);
+typedef int (*ReputImageFuncPtr) (KdScreenInfo * screen, DrawablePtr pDraw,
+                                  short drw_x, short drw_y, RegionPtr clipBoxes,
+                                  pointer data);
+typedef int (*QueryImageAttributesFuncPtr) (KdScreenInfo * screen, int image,
+                                            unsigned short *width,
+                                            unsigned short *height,
+                                            int *pitches, int *offsets);
 
 typedef enum {
     XV_OFF,
@@ -141,84 +147,78 @@ typedef enum {
 /*** this is what the driver needs to fill out ***/
 
 typedef struct {
-  int id;
-  char *name;
-  unsigned short width, height;
-  XvRationalRec rate;
+    int id;
+    char *name;
+    unsigned short width, height;
+    XvRationalRec rate;
 } KdVideoEncodingRec, *KdVideoEncodingPtr;
 
 typedef struct {
-  char 	depth;
-  short class;
+    char depth;
+    short class;
 } KdVideoFormatRec, *KdVideoFormatPtr;
 
 typedef struct {
-  int   flags;
-  int   min_value;
-  int   max_value;
-  char  *name;
+    int flags;
+    int min_value;
+    int max_value;
+    char *name;
 } KdAttributeRec, *KdAttributePtr;
 
 typedef struct {
-  unsigned int type;
-  int flags;
-  char *name;
-  int nEncodings;
-  KdVideoEncodingPtr pEncodings;
-  int nFormats;
-  KdVideoFormatPtr pFormats;
-  int nPorts;
-  DevUnion *pPortPrivates;
-  int nAttributes;
-  KdAttributePtr pAttributes;
-  int nImages;
-  KdImagePtr pImages;
-  PutVideoFuncPtr PutVideo;
-  PutStillFuncPtr PutStill;
-  GetVideoFuncPtr GetVideo;
-  GetStillFuncPtr GetStill;
-  StopVideoFuncPtr StopVideo;
-  SetPortAttributeFuncPtr SetPortAttribute;
-  GetPortAttributeFuncPtr GetPortAttribute;
-  QueryBestSizeFuncPtr QueryBestSize;
-  PutImageFuncPtr PutImage;
-  ReputImageFuncPtr ReputImage;
-  QueryImageAttributesFuncPtr QueryImageAttributes;
+    unsigned int type;
+    int flags;
+    char *name;
+    int nEncodings;
+    KdVideoEncodingPtr pEncodings;
+    int nFormats;
+    KdVideoFormatPtr pFormats;
+    int nPorts;
+    DevUnion *pPortPrivates;
+    int nAttributes;
+    KdAttributePtr pAttributes;
+    int nImages;
+    KdImagePtr pImages;
+    PutVideoFuncPtr PutVideo;
+    PutStillFuncPtr PutStill;
+    GetVideoFuncPtr GetVideo;
+    GetStillFuncPtr GetStill;
+    StopVideoFuncPtr StopVideo;
+    SetPortAttributeFuncPtr SetPortAttribute;
+    GetPortAttributeFuncPtr GetPortAttribute;
+    QueryBestSizeFuncPtr QueryBestSize;
+    PutImageFuncPtr PutImage;
+    ReputImageFuncPtr ReputImage;
+    QueryImageAttributesFuncPtr QueryImageAttributes;
 } KdVideoAdaptorRec, *KdVideoAdaptorPtr;
 
 Bool
-KdXVScreenInit(
-   ScreenPtr pScreen,
-   KdVideoAdaptorPtr 	*Adaptors,
-   int num
-);
+ KdXVScreenInit(ScreenPtr pScreen, KdVideoAdaptorPtr * Adaptors, int num);
 
-typedef int (* KdXVInitGenericAdaptorPtr)(KdScreenInfo * screen,
-	KdVideoAdaptorPtr **Adaptors);
+typedef int (*KdXVInitGenericAdaptorPtr) (KdScreenInfo * screen,
+                                          KdVideoAdaptorPtr ** Adaptors);
 
 int
-KdXVRegisterGenericAdaptorDriver(
-    KdXVInitGenericAdaptorPtr InitFunc
-);
+ KdXVRegisterGenericAdaptorDriver(KdXVInitGenericAdaptorPtr InitFunc);
 
 int
-KdXVListGenericAdaptors(
-    KdScreenInfo *          screen,
-    KdVideoAdaptorPtr  **Adaptors
-);
+ KdXVListGenericAdaptors(KdScreenInfo * screen, KdVideoAdaptorPtr ** Adaptors);
 
 void
-KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-   int srcPitch, int dstPitch, int srcW, int srcH, int top, int left,
-   int h, int w);
+
+KdXVCopyPackedData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int dstPitch, int srcW, int srcH, int top,
+                   int left, int h, int w);
 
 void
-KdXVCopyPlanarData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
-   int srcPitch, int srcPitch2, int dstPitch, int srcW, int srcH, int height,
-   int top, int left, int h, int w, int id);
+
+KdXVCopyPlanarData(KdScreenInfo * screen, CARD8 *src, CARD8 *dst, int randr,
+                   int srcPitch, int srcPitch2, int dstPitch, int srcW,
+                   int srcH, int height, int top, int left, int h, int w,
+                   int id);
 
 void
-KXVPaintRegion (DrawablePtr pDraw, RegionPtr pRgn, Pixel fg);
+ KXVPaintRegion(DrawablePtr pDraw, RegionPtr pRgn, Pixel fg);
 
 KdVideoAdaptorPtr KdXVAllocateVideoAdaptorRec(KdScreenInfo * screen);
 
@@ -230,50 +230,48 @@ void KdXVDisable(ScreenPtr);
 
 /*** These are DDX layer privates ***/
 
-
 typedef struct {
-   CreateWindowProcPtr		CreateWindow;
-   DestroyWindowProcPtr		DestroyWindow;
-   ClipNotifyProcPtr		ClipNotify;
-   WindowExposuresProcPtr	WindowExposures;
+    CreateWindowProcPtr CreateWindow;
+    DestroyWindowProcPtr DestroyWindow;
+    ClipNotifyProcPtr ClipNotify;
+    WindowExposuresProcPtr WindowExposures;
 } KdXVScreenRec, *KdXVScreenPtr;
 
 typedef struct {
-  int flags;
-  PutVideoFuncPtr PutVideo;
-  PutStillFuncPtr PutStill;
-  GetVideoFuncPtr GetVideo;
-  GetStillFuncPtr GetStill;
-  StopVideoFuncPtr StopVideo;
-  SetPortAttributeFuncPtr SetPortAttribute;
-  GetPortAttributeFuncPtr GetPortAttribute;
-  QueryBestSizeFuncPtr QueryBestSize;
-  PutImageFuncPtr PutImage;
-  ReputImageFuncPtr ReputImage;
-  QueryImageAttributesFuncPtr QueryImageAttributes;
+    int flags;
+    PutVideoFuncPtr PutVideo;
+    PutStillFuncPtr PutStill;
+    GetVideoFuncPtr GetVideo;
+    GetStillFuncPtr GetStill;
+    StopVideoFuncPtr StopVideo;
+    SetPortAttributeFuncPtr SetPortAttribute;
+    GetPortAttributeFuncPtr GetPortAttribute;
+    QueryBestSizeFuncPtr QueryBestSize;
+    PutImageFuncPtr PutImage;
+    ReputImageFuncPtr ReputImage;
+    QueryImageAttributesFuncPtr QueryImageAttributes;
 } XvAdaptorRecPrivate, *XvAdaptorRecPrivatePtr;
 
 typedef struct {
-   KdScreenInfo * screen;
-   DrawablePtr pDraw;
-   unsigned char type;
-   unsigned int subWindowMode;
-   DDXPointRec clipOrg;
-   RegionPtr clientClip;
-   RegionPtr pCompositeClip;
-   Bool FreeCompositeClip;
-   XvAdaptorRecPrivatePtr AdaptorRec;
-   XvStatus isOn;
-   Bool moved;
-   int vid_x, vid_y, vid_w, vid_h;
-   int drw_x, drw_y, drw_w, drw_h;
-   DevUnion DevPriv;
+    KdScreenInfo *screen;
+    DrawablePtr pDraw;
+    unsigned char type;
+    unsigned int subWindowMode;
+    DDXPointRec clipOrg;
+    RegionPtr clientClip;
+    RegionPtr pCompositeClip;
+    Bool FreeCompositeClip;
+    XvAdaptorRecPrivatePtr AdaptorRec;
+    XvStatus isOn;
+    Bool moved;
+    int vid_x, vid_y, vid_w, vid_h;
+    int drw_x, drw_y, drw_w, drw_h;
+    DevUnion DevPriv;
 } XvPortRecPrivate, *XvPortRecPrivatePtr;
 
-typedef struct _KdXVWindowRec{
-   XvPortRecPrivatePtr PortRec;
-   struct _KdXVWindowRec *next;
+typedef struct _KdXVWindowRec {
+    XvPortRecPrivatePtr PortRec;
+    struct _KdXVWindowRec *next;
 } KdXVWindowRec, *KdXVWindowPtr;
 
-#endif  /* _XVDIX_H_ */
-
+#endif                          /* _XVDIX_H_ */