vidmode: move to a separate library of its own

XVidMode extension might be useful to non hardware servers as well (e.g.
Xwayand) so that applications that rely on it (e.g. lot of older games)
can at least have read access to XVidMode.

But the implementation is very XFree86 centric, so the idea is to add
a bunch of vfunc that other non-XFree86 servers can hook up into to
provide a similar functionality.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=87806
Reviewed-by: Adam Jackson <ajax@redhat.com>
Signed-off-by: Olivier Fourdan <ofourdan@redhat.com>
(cherry picked from commit f175cf45aebcdda53f3ae49c0eaf27da1f194e92)

12 files changed, 592 insertions, 450 deletions

diff --git a/Xext/Makefile.am b/Xext/Makefile.am
index a9a446820..1ceb9803d 100644
--- a/Xext/Makefile.am
+++ b/Xext/Makefile.am
@@ -1,4 +1,4 @@
-noinst_LTLIBRARIES = libXext.la libXextdpmsstubs.la
+noinst_LTLIBRARIES = libXext.la libXextdpmsstubs.la libXvidmode.la
 
 AM_CFLAGS = $(DIX_CFLAGS)
 
@@ -6,7 +6,7 @@ if XORG
 sdk_HEADERS = xvdix.h xvmcext.h geext.h geint.h shmint.h syncsdk.h
 endif
 
-# Sources always included in libXextbuiltin.la & libXext.la
+# Sources always included in libXextbuiltin.la, libXext.la
 BUILTIN_SRCS =			\
 	bigreq.c		\
         geext.c			\
@@ -98,6 +98,9 @@ libXext_la_LIBADD =		$(BUILTIN_LIBS)
 
 libXextdpmsstubs_la_SOURCES = dpmsstubs.c
 
+# XVidMode extension
+libXvidmode_la_SOURCES = vidmode.c
+
 EXTRA_DIST = \
 	$(MITSHM_SRCS) \
 	$(XV_SRCS) \
diff --git a/hw/xfree86/common/xf86vmode.c b/Xext/vidmode.c
index 0ad1b8d33..7ea5ddfb5 100644
--- a/hw/xfree86/common/xf86vmode.c
+++ b/Xext/vidmode.c
@@ -1,4 +1,3 @@
-
 /*
 
 Copyright 1995  Kaleb S. KEITHLEY
@@ -30,32 +29,32 @@ from Kaleb S. KEITHLEY
 */
 /* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
 
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
 #endif
 
 #include <X11/X.h>
 #include <X11/Xproto.h>
+#include <X11/extensions/xf86vmproto.h>
 #include "misc.h"
 #include "dixstruct.h"
 #include "extnsionst.h"
-#include "xf86Extensions.h"
 #include "scrnintstr.h"
 #include "servermd.h"
-#include <X11/extensions/xf86vmproto.h>
 #include "swaprep.h"
-#include "xf86.h"
-#include "vidmodeproc.h"
+#include "vidmodestr.h"
 #include "globals.h"
 #include "protocol-versions.h"
 
-#define DEFAULT_XF86VIDMODE_VERBOSITY	3
-
 static int VidModeErrorBase;
-static DevPrivateKeyRec VidModeClientPrivateKeyRec;
+static int VidModeAllowNonLocal;
 
+static DevPrivateKeyRec VidModeClientPrivateKeyRec;
 #define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec)
 
+static DevPrivateKeyRec VidModePrivateKeyRec;
+#define VidModePrivateKey (&VidModePrivateKeyRec)
+
 /* This holds the client's version information */
 typedef struct {
     int major;
@@ -67,12 +66,8 @@ typedef struct {
 #define VM_SETPRIV(c,p) \
     dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey, p)
 
-#if 0
-static unsigned char XF86VidModeReqCode = 0;
-#endif
-
 #ifdef DEBUG
-#define DEBUG_P(x) ErrorF(x"\n");
+#define DEBUG_P(x) LogMessage(X_INFO, x"\n");
 #else
 #define DEBUG_P(x) /**/
 #endif
@@ -196,7 +191,7 @@ ClientMajorVersion(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeQueryVersion(ClientPtr client)
+ProcVidModeQueryVersion(ClientPtr client)
 {
     xXF86VidModeQueryVersionReply rep = {
         .type = X_Reply,
@@ -221,7 +216,7 @@ ProcXF86VidModeQueryVersion(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeGetModeLine(ClientPtr client)
+ProcVidModeGetModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetModeLineReq);
     xXF86VidModeGetModeLineReply rep = {
@@ -229,6 +224,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
         .sequenceNumber = client->sequence
     };
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode;
     int dotClock;
     int ver;
@@ -250,8 +246,11 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
 
-    if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+    if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     rep.dotclock = dotClock;
@@ -266,15 +265,13 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
     rep.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
     rep.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
 
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("GetModeLine - scrn: %d clock: %ld\n",
+    LogMessage(X_INFO, "GetModeLine - scrn: %d clock: %ld\n",
                stuff->screen, (unsigned long) rep.dotclock);
-        ErrorF("GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
                rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal);
-        ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
                rep.vdisplay, rep.vsyncstart, rep.vsyncend,
                rep.vtotal, (unsigned long) rep.flags);
-    }
 
     /*
      * Older servers sometimes had server privates that the VidMode
@@ -325,11 +322,12 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeGetAllModeLines(ClientPtr client)
+ProcVidModeGetAllModeLines(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetAllModeLinesReq);
     xXF86VidModeGetAllModeLinesReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode;
     int modecount, dotClock;
     int ver;
@@ -342,12 +340,15 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
     ver = ClientMajorVersion(client);
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
 
-    modecount = xf86VidModeGetNumOfModes(pScreen);
+    modecount = pVidMode->GetNumOfModes(pScreen);
     if (modecount < 1)
         return VidModeErrorBase + XF86VidModeExtensionDisabled;
 
-    if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+    if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     rep = (xXF86VidModeGetAllModeLinesReply) {
@@ -418,7 +419,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
             WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
         }
 
-    } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
+    } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
 
     return Success;
 }
@@ -435,13 +436,14 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
      && VidModeGetModeValue(mode, VIDMODE_FLAGS)  == stuff->flags )
 
 static int
-ProcXF86VidModeAddModeLine(ClientPtr client)
+ProcVidModeAddModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeAddModeLineReq);
     xXF86OldVidModeAddModeLineReq *oldstuff =
         (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
     xXF86VidModeAddModeLineReq newstuff;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode;
     int len;
     int dotClock;
@@ -479,25 +481,23 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
         stuff->after_vtotal = oldstuff->after_vtotal;
         stuff->after_flags = oldstuff->after_flags;
     }
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("AddModeLine - scrn: %d clock: %ld\n",
+    LogMessage(X_INFO, "AddModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
-        ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
                stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
-        ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
                stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
                stuff->vtotal, (unsigned long) stuff->flags);
-        ErrorF("      after - scrn: %d clock: %ld\n",
+    LogMessage(X_INFO, "      after - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->after_dotclock);
-        ErrorF("              hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "              hdsp: %d hbeg: %d hend: %d httl: %d\n",
                stuff->after_hdisplay, stuff->after_hsyncstart,
                stuff->after_hsyncend, stuff->after_htotal);
-        ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
                stuff->after_vdisplay, stuff->after_vsyncstart,
                stuff->after_vsyncend, stuff->after_vtotal,
                (unsigned long) stuff->after_flags);
-    }
 
     if (ver < 2) {
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
@@ -533,17 +533,21 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
         stuff->after_vtotal < stuff->after_vsyncend)
         return BadValue;
 
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
     if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
         Bool found = FALSE;
 
-        if (xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock)) {
+        if (pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) {
             do {
-                if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock)
+                if ((pVidMode->GetDotClock(pScreen, stuff->dotclock)
                      == dotClock) && MODEMATCH(mode, stuff)) {
                     found = TRUE;
                     break;
                 }
-            } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
+            } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
         }
         if (!found)
             return BadValue;
@@ -566,10 +570,10 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
     VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
 
     if (stuff->privsize)
-        ErrorF("AddModeLine - Privates in request have been ignored\n");
+        LogMessage(X_INFO, "AddModeLine - Privates in request have been ignored\n");
 
     /* Check that the mode is consistent with the monitor specs */
-    switch (xf86VidModeCheckModeForMonitor(pScreen, mode)) {
+    switch (pVidMode->CheckModeForMonitor(pScreen, mode)) {
     case MODE_OK:
         break;
     case MODE_HSYNC:
@@ -586,28 +590,29 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
     }
 
     /* Check that the driver is happy with the mode */
-    if (xf86VidModeCheckModeForDriver(pScreen, mode) != MODE_OK) {
+    if (pVidMode->CheckModeForDriver(pScreen, mode) != MODE_OK) {
         free(mode);
         return VidModeErrorBase + XF86VidModeModeUnsuitable;
     }
 
-    xf86VidModeSetCrtcForMode(pScreen, mode);
+    pVidMode->SetCrtcForMode(pScreen, mode);
+
+    pVidMode->AddModeline(pScreen, mode);
 
-    xf86VidModeAddModeline(pScreen, mode);
+    LogMessage(X_INFO, "AddModeLine - Succeeded\n");
 
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
-        ErrorF("AddModeLine - Succeeded\n");
     return Success;
 }
 
 static int
-ProcXF86VidModeDeleteModeLine(ClientPtr client)
+ProcVidModeDeleteModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeDeleteModeLineReq);
     xXF86OldVidModeDeleteModeLineReq *oldstuff =
         (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
     xXF86VidModeDeleteModeLineReq newstuff;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode;
     int len, dotClock;
     int ver;
@@ -633,17 +638,14 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
     }
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("DeleteModeLine - scrn: %d clock: %ld\n",
+    LogMessage(X_INFO, "DeleteModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
-        ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
                stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
-        ErrorF
-            ("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
              stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
              (unsigned long) stuff->flags);
-    }
 
     if (ver < 2) {
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
@@ -658,13 +660,11 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
             bytes_to_int32(sizeof(xXF86VidModeDeleteModeLineReq));
     }
     if (len != stuff->privsize) {
-        if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-            ErrorF("req_len = %ld, sizeof(Req) = %d, privsize = %ld, "
+        LogMessage(X_INFO, "req_len = %ld, sizeof(Req) = %d, privsize = %ld, "
                    "len = %d, length = %d\n",
                    (unsigned long) client->req_len,
                    (int) sizeof(xXF86VidModeDeleteModeLineReq) >> 2,
                    (unsigned long) stuff->privsize, len, stuff->length);
-        }
         return BadLength;
     }
 
@@ -672,69 +672,69 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("Checking against clock: %d (%d)\n",
+    LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
                VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
-        ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
                VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
                VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
                VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
                VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
-        ErrorF
-            ("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
-             VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
-             VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
-             VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
-             VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
-             VidModeGetModeValue(mode, VIDMODE_FLAGS));
-    }
-    if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+    LogMessage(X_INFO, "                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+               VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+               VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+               VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+               VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+               VidModeGetModeValue(mode, VIDMODE_FLAGS));
+
+    if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
         MODEMATCH(mode, stuff))
         return BadValue;
 
-    if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+    if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     do {
-        if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-            ErrorF("Checking against clock: %d (%d)\n",
+        LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
                    VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
-            ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
+        LogMessage(X_INFO, "                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
                    VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
                    VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
                    VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
                    VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
-            ErrorF
-                ("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
-                 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
-                 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
-                 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
-                 VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
-                 VidModeGetModeValue(mode, VIDMODE_FLAGS));
-        }
-        if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+        LogMessage(X_INFO, "                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+                   VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+                   VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+                   VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+                   VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+                   VidModeGetModeValue(mode, VIDMODE_FLAGS));
+
+        if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
             MODEMATCH(mode, stuff)) {
-            xf86VidModeDeleteModeline(pScreen, mode);
-            if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
-                ErrorF("DeleteModeLine - Succeeded\n");
+            pVidMode->DeleteModeline(pScreen, mode);
+            LogMessage(X_INFO, "DeleteModeLine - Succeeded\n");
             return Success;
         }
-    } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
+    } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
 
     return BadValue;
 }
 
 static int
-ProcXF86VidModeModModeLine(ClientPtr client)
+ProcVidModeModModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeModModeLineReq);
     xXF86OldVidModeModModeLineReq *oldstuff =
         (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
     xXF86VidModeModModeLineReq newstuff;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode, modetmp;
     int len, dotClock;
     int ver;
@@ -759,14 +759,12 @@ ProcXF86VidModeModModeLine(ClientPtr client)
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
     }
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
                (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
-        ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
                stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
                stuff->vtotal, (unsigned long) stuff->flags);
-    }
 
     if (ver < 2) {
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
@@ -794,7 +792,11 @@ ProcXF86VidModeModModeLine(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     modetmp = VidModeCreateMode();
@@ -812,10 +814,10 @@ ProcXF86VidModeModModeLine(ClientPtr client)
     VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
 
     if (stuff->privsize)
-        ErrorF("ModModeLine - Privates in request have been ignored\n");
+        LogMessage(X_INFO, "ModModeLine - Privates in request have been ignored\n");
 
     /* Check that the mode is consistent with the monitor specs */
-    switch (xf86VidModeCheckModeForMonitor(pScreen, modetmp)) {
+    switch (pVidMode->CheckModeForMonitor(pScreen, modetmp)) {
     case MODE_OK:
         break;
     case MODE_HSYNC:
@@ -832,7 +834,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
     }
 
     /* Check that the driver is happy with the mode */
-    if (xf86VidModeCheckModeForDriver(pScreen, modetmp) != MODE_OK) {
+    if (pVidMode->CheckModeForDriver(pScreen, modetmp) != MODE_OK) {
         free(modetmp);
         return VidModeErrorBase + XF86VidModeModeUnsuitable;
     }
@@ -849,16 +851,15 @@ ProcXF86VidModeModModeLine(ClientPtr client)
     VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
     VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
 
-    xf86VidModeSetCrtcForMode(pScreen, mode);
-    xf86VidModeSwitchMode(pScreen, mode);
+    pVidMode->SetCrtcForMode(pScreen, mode);
+    pVidMode->SwitchMode(pScreen, mode);
 
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
-        ErrorF("ModModeLine - Succeeded\n");
+    LogMessage(X_INFO, "ModModeLine - Succeeded\n");
     return Success;
 }
 
 static int
-ProcXF86VidModeValidateModeLine(ClientPtr client)
+ProcVidModeValidateModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeValidateModeLineReq);
     xXF86OldVidModeValidateModeLineReq *oldstuff =
@@ -866,6 +867,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
     xXF86VidModeValidateModeLineReq newstuff;
     xXF86VidModeValidateModeLineReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode, modetmp = NULL;
     int len, status, dotClock;
     int ver;
@@ -891,17 +893,15 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
     }
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("ValidateModeLine - scrn: %d clock: %ld\n",
+
+    LogMessage(X_INFO, "ValidateModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
-        ErrorF("                   hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "                   hdsp: %d hbeg: %d hend: %d httl: %d\n",
                stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
-        ErrorF
-            ("                   vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+    LogMessage(X_INFO, "                   vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
              stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
              (unsigned long) stuff->flags);
-    }
 
     if (ver < 2) {
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
@@ -933,7 +933,11 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
         goto status_reply;
     }
 
-    if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     modetmp = VidModeCreateMode();
@@ -950,15 +954,15 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
     VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
     VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
     if (stuff->privsize)
-        ErrorF("ValidateModeLine - Privates in request have been ignored\n");
+        LogMessage(X_INFO, "ValidateModeLine - Privates in request have been ignored\n");
 
     /* Check that the mode is consistent with the monitor specs */
     if ((status =
-         xf86VidModeCheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
+         pVidMode->CheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
         goto status_reply;
 
     /* Check that the driver is happy with the mode */
-    status = xf86VidModeCheckModeForDriver(pScreen, modetmp);
+    status = pVidMode->CheckModeForDriver(pScreen, modetmp);
 
  status_reply:
     free(modetmp);
@@ -976,16 +980,17 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
         swapl(&rep.status);
     }
     WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
-        ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status);
+    LogMessage(X_INFO, "ValidateModeLine - Succeeded (status = %d)\n", status);
+
     return Success;
 }
 
 static int
-ProcXF86VidModeSwitchMode(ClientPtr client)
+ProcVidModeSwitchMode(ClientPtr client)
 {
     REQUEST(xXF86VidModeSwitchModeReq);
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     DEBUG_P("XF86VidModeSwitchMode");
 
@@ -995,19 +1000,24 @@ ProcXF86VidModeSwitchMode(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    xf86VidModeZoomViewport(pScreen, (short) stuff->zoom);
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    pVidMode->ZoomViewport(pScreen, (short) stuff->zoom);
 
     return Success;
 }
 
 static int
-ProcXF86VidModeSwitchToMode(ClientPtr client)
+ProcVidModeSwitchToMode(ClientPtr client)
 {
     REQUEST(xXF86VidModeSwitchToModeReq);
     xXF86OldVidModeSwitchToModeReq *oldstuff =
         (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
     xXF86VidModeSwitchToModeReq newstuff;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     DisplayModePtr mode;
     int len, dotClock;
     int ver;
@@ -1033,17 +1043,15 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
     }
-    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-        ErrorF("SwitchToMode - scrn: %d clock: %ld\n",
+
+    LogMessage(X_INFO, "SwitchToMode - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
-        ErrorF("               hdsp: %d hbeg: %d hend: %d httl: %d\n",
+    LogMessage(X_INFO, "               hdsp: %d hbeg: %d hend: %d httl: %d\n",
                stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
-        ErrorF
-            ("               vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
-             stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
-             (unsigned long) stuff->flags);
-    }
+    LogMessage(X_INFO, "               vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
+               stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
+               (unsigned long) stuff->flags);
 
     if (ver < 2) {
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeSwitchToModeReq);
@@ -1064,53 +1072,55 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeGetCurrentModeline(pScreen, &mode, &dotClock))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
-    if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock)
+    if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock)
         && MODEMATCH(mode, stuff))
         return Success;
 
-    if (!xf86VidModeGetFirstModeline(pScreen, &mode, &dotClock))
+    if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
         return BadValue;
 
     do {
-        if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
-            ErrorF("Checking against clock: %d (%d)\n",
+        LogMessage(X_INFO, "Checking against clock: %d (%d)\n",
                    VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
-            ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
+        LogMessage(X_INFO, "                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
                    VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
                    VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
                    VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
                    VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
-            ErrorF
-                ("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
+        LogMessage(X_INFO, "                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
                  VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
                  VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
                  VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
                  VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
                  VidModeGetModeValue(mode, VIDMODE_FLAGS));
-        }
-        if ((xf86VidModeGetDotClock(pScreen, stuff->dotclock) == dotClock) &&
+
+        if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
             MODEMATCH(mode, stuff)) {
 
-            if (!xf86VidModeSwitchMode(pScreen, mode))
+            if (!pVidMode->SwitchMode(pScreen, mode))
                 return BadValue;
 
-            if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
-                ErrorF("SwitchToMode - Succeeded\n");
+            LogMessage(X_INFO, "SwitchToMode - Succeeded\n");
             return Success;
         }
-    } while (xf86VidModeGetNextModeline(pScreen, &mode, &dotClock));
+    } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
 
     return BadValue;
 }
 
 static int
-ProcXF86VidModeLockModeSwitch(ClientPtr client)
+ProcVidModeLockModeSwitch(ClientPtr client)
 {
     REQUEST(xXF86VidModeLockModeSwitchReq);
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
 
@@ -1120,14 +1130,18 @@ ProcXF86VidModeLockModeSwitch(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeLockZoom(pScreen, (short) stuff->lock))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->LockZoom(pScreen, (short) stuff->lock))
         return VidModeErrorBase + XF86VidModeZoomLocked;
 
     return Success;
 }
 
 static int
-ProcXF86VidModeGetMonitor(ClientPtr client)
+ProcVidModeGetMonitor(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetMonitorReq);
     xXF86VidModeGetMonitorReply rep = {
@@ -1135,8 +1149,9 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
         .sequenceNumber = client->sequence
     };
     CARD32 *hsyncdata, *vsyncdata;
-    int i, nHsync, nVrefresh;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
+    int i, nHsync, nVrefresh;
 
     DEBUG_P("XF86VidModeGetMonitor");
 
@@ -1146,19 +1161,23 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    nHsync = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
-    nVrefresh = xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
 
-    if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
-        rep.vendorLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
-                                                                       VIDMODE_MON_VENDOR,
-                                                                       0)).ptr);
+    nHsync = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
+    nVrefresh = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
+
+    if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
+        rep.vendorLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
+                                                                      VIDMODE_MON_VENDOR,
+                                                                      0)).ptr);
     else
         rep.vendorLength = 0;
-    if ((char *) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
-        rep.modelLength = strlen((char *) (xf86VidModeGetMonitorValue(pScreen,
-                                                                      VIDMODE_MON_MODEL,
-                                                                      0)).ptr);
+    if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
+        rep.modelLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
+                                                                     VIDMODE_MON_MODEL,
+                                                                     0)).ptr);
     else
         rep.modelLength = 0;
     rep.length =
@@ -1181,20 +1200,20 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
     }
 
     for (i = 0; i < nHsync; i++) {
-        hsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
-                                                                    VIDMODE_MON_HSYNC_LO,
-                                                                    i)).f |
+        hsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
+                                                                   VIDMODE_MON_HSYNC_LO,
+                                                                   i)).f |
             (unsigned
-             short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
-                                            i)).f << 16;
+             short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
+                                               i)).f << 16;
     }
     for (i = 0; i < nVrefresh; i++) {
-        vsyncdata[i] = (unsigned short) (xf86VidModeGetMonitorValue(pScreen,
-                                                                    VIDMODE_MON_VREFRESH_LO,
-                                                                    i)).f |
+        vsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
+                                                                   VIDMODE_MON_VREFRESH_LO,
+                                                                   i)).f |
             (unsigned
-             short) (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
-                                                i)).f << 16;
+             short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
+                                               i)).f << 16;
     }
 
     if (client->swapped) {
@@ -1207,10 +1226,10 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
     WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
     if (rep.vendorLength)
         WriteToClient(client, rep.vendorLength,
-                 (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
+                 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
     if (rep.modelLength)
         WriteToClient(client, rep.modelLength,
-                 (xf86VidModeGetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
+                 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
 
     free(hsyncdata);
     free(vsyncdata);
@@ -1219,11 +1238,12 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeGetViewPort(ClientPtr client)
+ProcVidModeGetViewPort(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetViewPortReq);
     xXF86VidModeGetViewPortReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     int x, y;
 
     DEBUG_P("XF86VidModeGetViewPort");
@@ -1234,7 +1254,11 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    xf86VidModeGetViewPort(pScreen, &x, &y);
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    pVidMode->GetViewPort(pScreen, &x, &y);
 
     rep = (xXF86VidModeGetViewPortReply) {
         .type = X_Reply,
@@ -1255,10 +1279,11 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeSetViewPort(ClientPtr client)
+ProcVidModeSetViewPort(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetViewPortReq);
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     DEBUG_P("XF86VidModeSetViewPort");
 
@@ -1268,18 +1293,23 @@ ProcXF86VidModeSetViewPort(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeSetViewPort(pScreen, stuff->x, stuff->y))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->SetViewPort(pScreen, stuff->x, stuff->y))
         return BadValue;
 
     return Success;
 }
 
 static int
-ProcXF86VidModeGetDotClocks(ClientPtr client)
+ProcVidModeGetDotClocks(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetDotClocksReq);
     xXF86VidModeGetDotClocksReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     int n;
     int numClocks;
     CARD32 dotclock;
@@ -1294,7 +1324,11 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    numClocks = xf86VidModeGetNumOfClocks(pScreen, &ClockProg);
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    numClocks = pVidMode->GetNumOfClocks(pScreen, &ClockProg);
 
     rep = (xXF86VidModeGetDotClocksReply) {
         .type = X_Reply,
@@ -1310,7 +1344,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
         Clocks = calloc(numClocks, sizeof(int));
         if (!Clocks)
             return BadValue;
-        if (!xf86VidModeGetClocks(pScreen, Clocks)) {
+        if (!pVidMode->GetClocks(pScreen, Clocks)) {
             free(Clocks);
             return BadValue;
         }
@@ -1343,10 +1377,11 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeSetGamma(ClientPtr client)
+ProcVidModeSetGamma(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetGammaReq);
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     DEBUG_P("XF86VidModeSetGamma");
 
@@ -1356,20 +1391,25 @@ ProcXF86VidModeSetGamma(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeSetGamma(pScreen, ((float) stuff->red) / 10000.,
-                                      ((float) stuff->green) / 10000.,
-                                      ((float) stuff->blue) / 10000.))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->SetGamma(pScreen, ((float) stuff->red) / 10000.,
+                         ((float) stuff->green) / 10000.,
+                         ((float) stuff->blue) / 10000.))
         return BadValue;
 
     return Success;
 }
 
 static int
-ProcXF86VidModeGetGamma(ClientPtr client)
+ProcVidModeGetGamma(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetGammaReq);
     xXF86VidModeGetGammaReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
     float red, green, blue;
 
     DEBUG_P("XF86VidModeGetGamma");
@@ -1380,7 +1420,11 @@ ProcXF86VidModeGetGamma(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (!xf86VidModeGetGamma(pScreen, &red, &green, &blue))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (!pVidMode->GetGamma(pScreen, &red, &green, &blue))
         return BadValue;
     rep = (xXF86VidModeGetGammaReply) {
         .type = X_Reply,
@@ -1403,11 +1447,12 @@ ProcXF86VidModeGetGamma(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeSetGammaRamp(ClientPtr client)
+ProcVidModeSetGammaRamp(ClientPtr client)
 {
-    ScreenPtr pScreen;
     CARD16 *r, *g, *b;
     int length;
+    ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     REQUEST(xXF86VidModeSetGammaRampReq);
 
@@ -1415,7 +1460,11 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
         return BadValue;
 
     length = (stuff->size + 1) & ~1;
@@ -1426,20 +1475,21 @@ ProcXF86VidModeSetGammaRamp(ClientPtr client)
     g = r + length;
     b = g + length;
 
-    if (!xf86VidModeSetGammaRamp(pScreen, stuff->size, r, g, b))
+    if (!pVidMode->SetGammaRamp(pScreen, stuff->size, r, g, b))
         return BadValue;
 
     return Success;
 }
 
 static int
-ProcXF86VidModeGetGammaRamp(ClientPtr client)
+ProcVidModeGetGammaRamp(ClientPtr client)
 {
     CARD16 *ramp = NULL;
     int length;
     size_t ramplen = 0;
     xXF86VidModeGetGammaRampReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     REQUEST(xXF86VidModeGetGammaRampReq);
 
@@ -1449,7 +1499,11 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
-    if (stuff->size != xf86VidModeGetGammaRampSize(pScreen))
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
+    if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
         return BadValue;
 
     length = (stuff->size + 1) & ~1;
@@ -1459,8 +1513,8 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
             return BadAlloc;
         ramplen = length * 3 * sizeof(CARD16);
 
-        if (!xf86VidModeGetGammaRamp(pScreen, stuff->size,
-                                     ramp, ramp + length, ramp + (length * 2))) {
+        if (!pVidMode->GetGammaRamp(pScreen, stuff->size,
+                                 ramp, ramp + length, ramp + (length * 2))) {
             free(ramp);
             return BadValue;
         }
@@ -1487,11 +1541,13 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
     return Success;
 }
 
+
 static int
-ProcXF86VidModeGetGammaRampSize(ClientPtr client)
+ProcVidModeGetGammaRampSize(ClientPtr client)
 {
     xXF86VidModeGetGammaRampSizeReply rep;
     ScreenPtr pScreen;
+    VidModePtr pVidMode;
 
     REQUEST(xXF86VidModeGetGammaRampSizeReq);
 
@@ -1501,11 +1557,15 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
         return BadValue;
     pScreen = screenInfo.screens[stuff->screen];
 
+    pVidMode = VidModeGetPtr(pScreen);
+    if (pVidMode == NULL)
+        return BadImplementation;
+
     rep = (xXF86VidModeGetGammaRampSizeReply) {
         .type = X_Reply,
         .sequenceNumber = client->sequence,
         .length = 0,
-        .size = xf86VidModeGetGammaRampSize(pScreen)
+        .size = pVidMode->GetGammaRampSize(pScreen)
     };
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
@@ -1518,7 +1578,7 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeGetPermissions(ClientPtr client)
+ProcVidModeGetPermissions(ClientPtr client)
 {
     xXF86VidModeGetPermissionsReply rep =  {
         .type = X_Reply,
@@ -1534,8 +1594,7 @@ ProcXF86VidModeGetPermissions(ClientPtr client)
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
-    if (xf86GetVidModeEnabled() &&
-        (xf86GetVidModeAllowNonLocal() || client->local)) {
+    if (VidModeAllowNonLocal || client->local) {
         rep.permissions |= XF86VM_WRITE_PERMISSION;
     }
     if (client->swapped) {
@@ -1549,7 +1608,7 @@ ProcXF86VidModeGetPermissions(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeSetClientVersion(ClientPtr client)
+ProcVidModeSetClientVersion(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetClientVersionReq);
 
@@ -1573,57 +1632,55 @@ ProcXF86VidModeSetClientVersion(ClientPtr client)
 }
 
 static int
-ProcXF86VidModeDispatch(ClientPtr client)
+ProcVidModeDispatch(ClientPtr client)
 {
     REQUEST(xReq);
     switch (stuff->data) {
     case X_XF86VidModeQueryVersion:
-        return ProcXF86VidModeQueryVersion(client);
+        return ProcVidModeQueryVersion(client);
     case X_XF86VidModeGetModeLine:
-        return ProcXF86VidModeGetModeLine(client);
+        return ProcVidModeGetModeLine(client);
     case X_XF86VidModeGetMonitor:
-        return ProcXF86VidModeGetMonitor(client);
+        return ProcVidModeGetMonitor(client);
     case X_XF86VidModeGetAllModeLines:
-        return ProcXF86VidModeGetAllModeLines(client);
+        return ProcVidModeGetAllModeLines(client);
     case X_XF86VidModeValidateModeLine:
-        return ProcXF86VidModeValidateModeLine(client);
+        return ProcVidModeValidateModeLine(client);
     case X_XF86VidModeGetViewPort:
-        return ProcXF86VidModeGetViewPort(client);
+        return ProcVidModeGetViewPort(client);
     case X_XF86VidModeGetDotClocks:
-        return ProcXF86VidModeGetDotClocks(client);
+        return ProcVidModeGetDotClocks(client);
     case X_XF86VidModeSetClientVersion:
-        return ProcXF86VidModeSetClientVersion(client);
+        return ProcVidModeSetClientVersion(client);
     case X_XF86VidModeGetGamma:
-        return ProcXF86VidModeGetGamma(client);
+        return ProcVidModeGetGamma(client);
     case X_XF86VidModeGetGammaRamp:
-        return ProcXF86VidModeGetGammaRamp(client);
+        return ProcVidModeGetGammaRamp(client);
     case X_XF86VidModeGetGammaRampSize:
-        return ProcXF86VidModeGetGammaRampSize(client);
+        return ProcVidModeGetGammaRampSize(client);
     case X_XF86VidModeGetPermissions:
-        return ProcXF86VidModeGetPermissions(client);
+        return ProcVidModeGetPermissions(client);
     default:
-        if (!xf86GetVidModeEnabled())
-            return VidModeErrorBase + XF86VidModeExtensionDisabled;
-        if (xf86GetVidModeAllowNonLocal() || client->local) {
+        if (VidModeAllowNonLocal || client->local) {
             switch (stuff->data) {
             case X_XF86VidModeAddModeLine:
-                return ProcXF86VidModeAddModeLine(client);
+                return ProcVidModeAddModeLine(client);
             case X_XF86VidModeDeleteModeLine:
-                return ProcXF86VidModeDeleteModeLine(client);
+                return ProcVidModeDeleteModeLine(client);
             case X_XF86VidModeModModeLine:
-                return ProcXF86VidModeModModeLine(client);
+                return ProcVidModeModModeLine(client);
             case X_XF86VidModeSwitchMode:
-                return ProcXF86VidModeSwitchMode(client);
+                return ProcVidModeSwitchMode(client);
             case X_XF86VidModeSwitchToMode:
-                return ProcXF86VidModeSwitchToMode(client);
+                return ProcVidModeSwitchToMode(client);
             case X_XF86VidModeLockModeSwitch:
-                return ProcXF86VidModeLockModeSwitch(client);
+                return ProcVidModeLockModeSwitch(client);
             case X_XF86VidModeSetViewPort:
-                return ProcXF86VidModeSetViewPort(client);
+                return ProcVidModeSetViewPort(client);
             case X_XF86VidModeSetGamma:
-                return ProcXF86VidModeSetGamma(client);
+                return ProcVidModeSetGamma(client);
             case X_XF86VidModeSetGammaRamp:
-                return ProcXF86VidModeSetGammaRamp(client);
+                return ProcVidModeSetGammaRamp(client);
             default:
                 return BadRequest;
             }
@@ -1634,35 +1691,35 @@ ProcXF86VidModeDispatch(ClientPtr client)
 }
 
 static int
-SProcXF86VidModeQueryVersion(ClientPtr client)
+SProcVidModeQueryVersion(ClientPtr client)
 {
     REQUEST(xXF86VidModeQueryVersionReq);
     swaps(&stuff->length);
-    return ProcXF86VidModeQueryVersion(client);
+    return ProcVidModeQueryVersion(client);
 }
 
 static int
-SProcXF86VidModeGetModeLine(ClientPtr client)
+SProcVidModeGetModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetModeLineReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetModeLine(client);
+    return ProcVidModeGetModeLine(client);
 }
 
 static int
-SProcXF86VidModeGetAllModeLines(ClientPtr client)
+SProcVidModeGetAllModeLines(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetAllModeLinesReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetAllModeLines(client);
+    return ProcVidModeGetAllModeLines(client);
 }
 
 static int
-SProcXF86VidModeAddModeLine(ClientPtr client)
+SProcVidModeAddModeLine(ClientPtr client)
 {
     xXF86OldVidModeAddModeLineReq *oldstuff =
         (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
@@ -1703,11 +1760,11 @@ SProcXF86VidModeAddModeLine(ClientPtr client)
         swapl(&stuff->privsize);
         SwapRestL(stuff);
     }
-    return ProcXF86VidModeAddModeLine(client);
+    return ProcVidModeAddModeLine(client);
 }
 
 static int
-SProcXF86VidModeDeleteModeLine(ClientPtr client)
+SProcVidModeDeleteModeLine(ClientPtr client)
 {
     xXF86OldVidModeDeleteModeLineReq *oldstuff =
         (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
@@ -1748,11 +1805,11 @@ SProcXF86VidModeDeleteModeLine(ClientPtr client)
         swapl(&stuff->privsize);
         SwapRestL(stuff);
     }
-    return ProcXF86VidModeDeleteModeLine(client);
+    return ProcVidModeDeleteModeLine(client);
 }
 
 static int
-SProcXF86VidModeModModeLine(ClientPtr client)
+SProcVidModeModModeLine(ClientPtr client)
 {
     xXF86OldVidModeModModeLineReq *oldstuff =
         (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
@@ -1793,11 +1850,11 @@ SProcXF86VidModeModModeLine(ClientPtr client)
         swapl(&stuff->privsize);
         SwapRestL(stuff);
     }
-    return ProcXF86VidModeModModeLine(client);
+    return ProcVidModeModModeLine(client);
 }
 
 static int
-SProcXF86VidModeValidateModeLine(ClientPtr client)
+SProcVidModeValidateModeLine(ClientPtr client)
 {
     xXF86OldVidModeValidateModeLineReq *oldstuff =
         (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
@@ -1838,63 +1895,63 @@ SProcXF86VidModeValidateModeLine(ClientPtr client)
         swapl(&stuff->privsize);
         SwapRestL(stuff);
     }
-    return ProcXF86VidModeValidateModeLine(client);
+    return ProcVidModeValidateModeLine(client);
 }
 
 static int
-SProcXF86VidModeSwitchMode(ClientPtr client)
+SProcVidModeSwitchMode(ClientPtr client)
 {
     REQUEST(xXF86VidModeSwitchModeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
     swaps(&stuff->screen);
     swaps(&stuff->zoom);
-    return ProcXF86VidModeSwitchMode(client);
+    return ProcVidModeSwitchMode(client);
 }
 
 static int
-SProcXF86VidModeSwitchToMode(ClientPtr client)
+SProcVidModeSwitchToMode(ClientPtr client)
 {
     REQUEST(xXF86VidModeSwitchToModeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq);
     swapl(&stuff->screen);
-    return ProcXF86VidModeSwitchToMode(client);
+    return ProcVidModeSwitchToMode(client);
 }
 
 static int
-SProcXF86VidModeLockModeSwitch(ClientPtr client)
+SProcVidModeLockModeSwitch(ClientPtr client)
 {
     REQUEST(xXF86VidModeLockModeSwitchReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
     swaps(&stuff->screen);
     swaps(&stuff->lock);
-    return ProcXF86VidModeLockModeSwitch(client);
+    return ProcVidModeLockModeSwitch(client);
 }
 
 static int
-SProcXF86VidModeGetMonitor(ClientPtr client)
+SProcVidModeGetMonitor(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetMonitorReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetMonitor(client);
+    return ProcVidModeGetMonitor(client);
 }
 
 static int
-SProcXF86VidModeGetViewPort(ClientPtr client)
+SProcVidModeGetViewPort(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetViewPortReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetViewPort(client);
+    return ProcVidModeGetViewPort(client);
 }
 
 static int
-SProcXF86VidModeSetViewPort(ClientPtr client)
+SProcVidModeSetViewPort(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetViewPortReq);
     swaps(&stuff->length);
@@ -1902,32 +1959,32 @@ SProcXF86VidModeSetViewPort(ClientPtr client)
     swaps(&stuff->screen);
     swapl(&stuff->x);
     swapl(&stuff->y);
-    return ProcXF86VidModeSetViewPort(client);
+    return ProcVidModeSetViewPort(client);
 }
 
 static int
-SProcXF86VidModeGetDotClocks(ClientPtr client)
+SProcVidModeGetDotClocks(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetDotClocksReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetDotClocks(client);
+    return ProcVidModeGetDotClocks(client);
 }
 
 static int
-SProcXF86VidModeSetClientVersion(ClientPtr client)
+SProcVidModeSetClientVersion(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetClientVersionReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
     swaps(&stuff->major);
     swaps(&stuff->minor);
-    return ProcXF86VidModeSetClientVersion(client);
+    return ProcVidModeSetClientVersion(client);
 }
 
 static int
-SProcXF86VidModeSetGamma(ClientPtr client)
+SProcVidModeSetGamma(ClientPtr client)
 {
     REQUEST(xXF86VidModeSetGammaReq);
     swaps(&stuff->length);
@@ -1936,21 +1993,21 @@ SProcXF86VidModeSetGamma(ClientPtr client)
     swapl(&stuff->red);
     swapl(&stuff->green);
     swapl(&stuff->blue);
-    return ProcXF86VidModeSetGamma(client);
+    return ProcVidModeSetGamma(client);
 }
 
 static int
-SProcXF86VidModeGetGamma(ClientPtr client)
+SProcVidModeGetGamma(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetGammaReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetGamma(client);
+    return ProcVidModeGetGamma(client);
 }
 
 static int
-SProcXF86VidModeSetGammaRamp(ClientPtr client)
+SProcVidModeSetGammaRamp(ClientPtr client)
 {
     int length;
 
@@ -1962,92 +2019,90 @@ SProcXF86VidModeSetGammaRamp(ClientPtr client)
     length = ((stuff->size + 1) & ~1) * 6;
     REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length);
     SwapRestS(stuff);
-    return ProcXF86VidModeSetGammaRamp(client);
+    return ProcVidModeSetGammaRamp(client);
 }
 
 static int
-SProcXF86VidModeGetGammaRamp(ClientPtr client)
+SProcVidModeGetGammaRamp(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetGammaRampReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
     swaps(&stuff->size);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetGammaRamp(client);
+    return ProcVidModeGetGammaRamp(client);
 }
 
 static int
-SProcXF86VidModeGetGammaRampSize(ClientPtr client)
+SProcVidModeGetGammaRampSize(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetGammaRampSizeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetGammaRampSize(client);
+    return ProcVidModeGetGammaRampSize(client);
 }
 
 static int
-SProcXF86VidModeGetPermissions(ClientPtr client)
+SProcVidModeGetPermissions(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetPermissionsReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
     swaps(&stuff->screen);
-    return ProcXF86VidModeGetPermissions(client);
+    return ProcVidModeGetPermissions(client);
 }
 
 static int
-SProcXF86VidModeDispatch(ClientPtr client)
+SProcVidModeDispatch(ClientPtr client)
 {
     REQUEST(xReq);
     switch (stuff->data) {
     case X_XF86VidModeQueryVersion:
-        return SProcXF86VidModeQueryVersion(client);
+        return SProcVidModeQueryVersion(client);
     case X_XF86VidModeGetModeLine:
-        return SProcXF86VidModeGetModeLine(client);
+        return SProcVidModeGetModeLine(client);
     case X_XF86VidModeGetMonitor:
-        return SProcXF86VidModeGetMonitor(client);
+        return SProcVidModeGetMonitor(client);
     case X_XF86VidModeGetAllModeLines:
-        return SProcXF86VidModeGetAllModeLines(client);
+        return SProcVidModeGetAllModeLines(client);
     case X_XF86VidModeGetViewPort:
-        return SProcXF86VidModeGetViewPort(client);
+        return SProcVidModeGetViewPort(client);
     case X_XF86VidModeValidateModeLine:
-        return SProcXF86VidModeValidateModeLine(client);
+        return SProcVidModeValidateModeLine(client);
     case X_XF86VidModeGetDotClocks:
-        return SProcXF86VidModeGetDotClocks(client);
+        return SProcVidModeGetDotClocks(client);
     case X_XF86VidModeSetClientVersion:
-        return SProcXF86VidModeSetClientVersion(client);
+        return SProcVidModeSetClientVersion(client);
     case X_XF86VidModeGetGamma:
-        return SProcXF86VidModeGetGamma(client);
+        return SProcVidModeGetGamma(client);
     case X_XF86VidModeGetGammaRamp:
-        return SProcXF86VidModeGetGammaRamp(client);
+        return SProcVidModeGetGammaRamp(client);
     case X_XF86VidModeGetGammaRampSize:
-        return SProcXF86VidModeGetGammaRampSize(client);
+        return SProcVidModeGetGammaRampSize(client);
     case X_XF86VidModeGetPermissions:
-        return SProcXF86VidModeGetPermissions(client);
+        return SProcVidModeGetPermissions(client);
     default:
-        if (!xf86GetVidModeEnabled())
-            return VidModeErrorBase + XF86VidModeExtensionDisabled;
-        if (xf86GetVidModeAllowNonLocal() || client->local) {
+        if (VidModeAllowNonLocal || client->local) {
             switch (stuff->data) {
             case X_XF86VidModeAddModeLine:
-                return SProcXF86VidModeAddModeLine(client);
+                return SProcVidModeAddModeLine(client);
             case X_XF86VidModeDeleteModeLine:
-                return SProcXF86VidModeDeleteModeLine(client);
+                return SProcVidModeDeleteModeLine(client);
             case X_XF86VidModeModModeLine:
-                return SProcXF86VidModeModModeLine(client);
+                return SProcVidModeModModeLine(client);
             case X_XF86VidModeSwitchMode:
-                return SProcXF86VidModeSwitchMode(client);
+                return SProcVidModeSwitchMode(client);
             case X_XF86VidModeSwitchToMode:
-                return SProcXF86VidModeSwitchToMode(client);
+                return SProcVidModeSwitchToMode(client);
             case X_XF86VidModeLockModeSwitch:
-                return SProcXF86VidModeLockModeSwitch(client);
+                return SProcVidModeLockModeSwitch(client);
             case X_XF86VidModeSetViewPort:
-                return SProcXF86VidModeSetViewPort(client);
+                return SProcVidModeSetViewPort(client);
             case X_XF86VidModeSetGamma:
-                return SProcXF86VidModeSetGamma(client);
+                return SProcVidModeSetGamma(client);
             case X_XF86VidModeSetGammaRamp:
-                return SProcXF86VidModeSetGammaRamp(client);
+                return SProcVidModeSetGammaRamp(client);
             default:
                 return BadRequest;
             }
@@ -2058,36 +2113,35 @@ SProcXF86VidModeDispatch(ClientPtr client)
 }
 
 void
-XFree86VidModeExtensionInit(void)
+VidModeAddExtension(Bool allow_non_local)
 {
     ExtensionEntry *extEntry;
-    ScreenPtr pScreen;
-    int i;
-    Bool enabled = FALSE;
-
-    DEBUG_P("XFree86VidModeExtensionInit");
 
-    if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0))
-        return;
+    DEBUG_P("VidModeAddExtension");
 
-    for (i = 0; i < screenInfo.numScreens; i++) {
-        pScreen = screenInfo.screens[i];
-        if (xf86VidModeExtensionInit(pScreen))
-            enabled = TRUE;
-    }
-    /* This means that the DDX doesn't want the vidmode extension enabled */
-    if (!enabled)
+    if (!dixRegisterPrivateKey(VidModeClientPrivateKey, PRIVATE_CLIENT, 0))
         return;
 
     if ((extEntry = AddExtension(XF86VIDMODENAME,
                                  XF86VidModeNumberEvents,
                                  XF86VidModeNumberErrors,
-                                 ProcXF86VidModeDispatch,
-                                 SProcXF86VidModeDispatch,
+                                 ProcVidModeDispatch,
+                                 SProcVidModeDispatch,
                                  NULL, StandardMinorOpcode))) {
-#if 0
-        XF86VidModeReqCode = (unsigned char) extEntry->base;
-#endif
         VidModeErrorBase = extEntry->errorBase;
+        VidModeAllowNonLocal = allow_non_local;
     }
 }
+
+VidModePtr VidModeGetPtr(ScreenPtr pScreen)
+{
+    return (VidModePtr) (dixLookupPrivate(&pScreen->devPrivates, VidModePrivateKey));
+}
+
+VidModePtr VidModeInit(ScreenPtr pScreen)
+{
+    if (!dixRegisterPrivateKey(VidModePrivateKey, PRIVATE_SCREEN, sizeof(VidModeRec)))
+        return NULL;
+
+    return VidModeGetPtr(pScreen);
+}
diff --git a/hw/xfree86/Makefile.am b/hw/xfree86/Makefile.am
index 64c4f7456..85bd0bed0 100644
--- a/hw/xfree86/Makefile.am
+++ b/hw/xfree86/Makefile.am
@@ -72,7 +72,9 @@ LOCAL_LIBS = \
 	    $(DRI3_LIB) \
 	    $(top_builddir)/miext/sync/libsync.la \
             $(top_builddir)/mi/libmi.la \
-            $(top_builddir)/os/libos.la
+            $(top_builddir)/os/libos.la \
+	    $(top_builddir)/Xext/libXvidmode.la
+
 Xorg_LDADD = \
             $(LOCAL_LIBS) \
             $(XORG_SYS_LIBS) \
diff --git a/hw/xfree86/common/Makefile.am b/hw/xfree86/common/Makefile.am
index 3bc0046aa..2eed5defc 100644
--- a/hw/xfree86/common/Makefile.am
+++ b/hw/xfree86/common/Makefile.am
@@ -14,10 +14,6 @@ XVSOURCES = xf86xv.c xf86xvmc.c
 XVSDKINCS = xf86xv.h xf86xvmc.h xf86xvpriv.h
 endif
 
-if XF86VIDMODE
-XF86VMODESOURCES = xf86vmode.c
-endif
-
 if DGA
 DGASOURCES = xf86DGA.c
 DGA_SDK = dgaproc.h
diff --git a/hw/xfree86/common/vidmodeproc.h b/hw/xfree86/common/vidmodeproc.h
deleted file mode 100644
index 4410253d6..000000000
--- a/hw/xfree86/common/vidmodeproc.h
+++ /dev/null
@@ -1,78 +0,0 @@
-
-/* Prototypes for DGA functions that the DDX must provide */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef _VIDMODEPROC_H_
-#define _VIDMODEPROC_H_
-
-typedef enum {
-    VIDMODE_H_DISPLAY,
-    VIDMODE_H_SYNCSTART,
-    VIDMODE_H_SYNCEND,
-    VIDMODE_H_TOTAL,
-    VIDMODE_H_SKEW,
-    VIDMODE_V_DISPLAY,
-    VIDMODE_V_SYNCSTART,
-    VIDMODE_V_SYNCEND,
-    VIDMODE_V_TOTAL,
-    VIDMODE_FLAGS,
-    VIDMODE_CLOCK
-} VidModeSelectMode;
-
-typedef enum {
-    VIDMODE_MON_VENDOR,
-    VIDMODE_MON_MODEL,
-    VIDMODE_MON_NHSYNC,
-    VIDMODE_MON_NVREFRESH,
-    VIDMODE_MON_HSYNC_LO,
-    VIDMODE_MON_HSYNC_HI,
-    VIDMODE_MON_VREFRESH_LO,
-    VIDMODE_MON_VREFRESH_HI
-} VidModeSelectMonitor;
-
-typedef union {
-    const void *ptr;
-    int i;
-    float f;
-} vidMonitorValue;
-
-extern Bool xf86VidModeExtensionInit(ScreenPtr pScreen);
-
-extern Bool xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode,
-                                          int *dotClock);
-extern Bool xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode,
-                                        int *dotClock);
-extern Bool xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode,
-                                       int *dotClock);
-extern Bool xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom);
-extern Bool xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y);
-extern Bool xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y);
-extern Bool xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock);
-extern int xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock);
-extern Bool xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks);
-extern ModeStatus xf86VidModeCheckModeForMonitor(ScreenPtr pScreen,
-                                                 DisplayModePtr mode);
-extern ModeStatus xf86VidModeCheckModeForDriver(ScreenPtr pScreen,
-                                                DisplayModePtr mode);
-extern void xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode);
-extern Bool xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode);
-extern int xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock);
-extern int xf86VidModeGetNumOfModes(ScreenPtr pScreen);
-extern Bool xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green,
-                                float blue);
-extern Bool xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green,
-                                float *blue);
-extern vidMonitorValue xf86VidModeGetMonitorValue(ScreenPtr pScreen,
-                                                  int valtyp, int indx);
-extern Bool xf86VidModeSetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
-                                    CARD16 *);
-extern Bool xf86VidModeGetGammaRamp(ScreenPtr, int, CARD16 *, CARD16 *,
-                                    CARD16 *);
-extern int xf86VidModeGetGammaRampSize(ScreenPtr pScreen);
-
-#endif
diff --git a/hw/xfree86/common/xf86Extensions.c b/hw/xfree86/common/xf86Extensions.c
index 25b2bc3d0..1b8b78505 100644
--- a/hw/xfree86/common/xf86Extensions.c
+++ b/hw/xfree86/common/xf86Extensions.c
@@ -28,6 +28,7 @@
 #endif
 
 #include "extension.h"
+#include "extinit.h"
 #include "globals.h"
 
 #include "xf86.h"
@@ -47,7 +48,7 @@
 
 #ifdef XF86VIDMODE
 #include <X11/extensions/xf86vmproto.h>
-#include "vidmodeproc.h"
+#include "vidmodestr.h"
 #endif
 
 /*
diff --git a/hw/xfree86/common/xf86Init.c b/hw/xfree86/common/xf86Init.c
index 017dcb6bb..de51497b5 100644
--- a/hw/xfree86/common/xf86Init.c
+++ b/hw/xfree86/common/xf86Init.c
@@ -72,6 +72,7 @@
 #include "mipointer.h"
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
+#include "xf86Extensions.h"
 #include "xf86DDC.h"
 #include "xf86Xinput.h"
 #include "xf86InPriv.h"
diff --git a/hw/xfree86/common/xf86Privstr.h b/hw/xfree86/common/xf86Privstr.h
index bddccf57a..58d5a0f13 100644
--- a/hw/xfree86/common/xf86Privstr.h
+++ b/hw/xfree86/common/xf86Privstr.h
@@ -115,15 +115,6 @@ typedef struct {
 } DPMSRec, *DPMSPtr;
 #endif
 
-#ifdef XF86VIDMODE
-/* Private info for Video Mode Extentsion */
-typedef struct {
-    DisplayModePtr First;
-    DisplayModePtr Next;
-    int Flags;
-} VidModeRec, *VidModePtr;
-#endif
-
 /* Information for root window properties. */
 typedef struct _RootWinProp {
     struct _RootWinProp *next;
diff --git a/hw/xfree86/common/xf86VidMode.c b/hw/xfree86/common/xf86VidMode.c
index 5d047389c..d2bdf6b02 100644
--- a/hw/xfree86/common/xf86VidMode.c
+++ b/hw/xfree86/common/xf86VidMode.c
@@ -42,29 +42,18 @@
 #include "os.h"
 #include "xf86.h"
 #include "xf86Priv.h"
+#include "extinit.h"
 
 #ifdef XF86VIDMODE
-#include "vidmodeproc.h"
+#include "vidmodestr.h"
+#include "xf86Privstr.h"
+#include "xf86Extensions.h"
 #include "xf86cmap.h"
 
-static DevPrivateKeyRec VidModeKeyRec;
-#define VidModeKey (&VidModeKeyRec)
-
-#define VMPTR(p) ((VidModePtr)dixLookupPrivate(&(p)->devPrivates, VidModeKey))
-
-#endif
-
-#ifdef XF86VIDMODE
-
 static Bool
 xf86VidModeAvailable(ScreenPtr pScreen)
 {
-    if (pScreen == NULL) {
-        DebugF("pScreen == NULL\n");
-        return FALSE;
-    }
-
-    if (VMPTR(pScreen))
+    if (VidModeGetPtr(pScreen))
         return TRUE;
     else {
         DebugF("pVidMode == NULL\n");
@@ -72,7 +61,7 @@ xf86VidModeAvailable(ScreenPtr pScreen)
     }
 }
 
-vidMonitorValue
+static vidMonitorValue
 xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
 {
     vidMonitorValue ret = { NULL, };
@@ -114,7 +103,7 @@ xf86VidModeGetMonitorValue(ScreenPtr pScreen, int valtyp, int indx)
     return ret;
 }
 
-Bool
+static Bool
 xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
 {
     ScrnInfoPtr pScrn;
@@ -133,7 +122,7 @@ xf86VidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotC
     return FALSE;
 }
 
-int
+static int
 xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
 {
     ScrnInfoPtr pScrn;
@@ -148,7 +137,7 @@ xf86VidModeGetDotClock(ScreenPtr pScreen, int Clock)
         return pScrn->clock[Clock];
 }
 
-int
+static int
 xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
 {
     ScrnInfoPtr pScrn;
@@ -167,7 +156,7 @@ xf86VidModeGetNumOfClocks(ScreenPtr pScreen, Bool *progClock)
     }
 }
 
-Bool
+static Bool
 xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
 {
     ScrnInfoPtr pScrn;
@@ -187,7 +176,7 @@ xf86VidModeGetClocks(ScreenPtr pScreen, int *Clocks)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
 {
     VidModePtr pVidMode;
@@ -196,7 +185,7 @@ xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotCloc
     if (!xf86VidModeAvailable(pScreen))
         return FALSE;
 
-    pVidMode = VMPTR(pScreen);
+    pVidMode = VidModeGetPtr(pScreen);
 
     for (p = pVidMode->Next; p != NULL && p != pVidMode->First; p = p->next) {
         if (p->status == MODE_OK) {
@@ -210,7 +199,7 @@ xf86VidModeGetNextModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotCloc
     return FALSE;
 }
 
-Bool
+static Bool
 xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
 {
     ScrnInfoPtr pScrn;
@@ -223,7 +212,7 @@ xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClo
     if (pScrn->modes == NULL)
         return FALSE;
 
-    pVidMode = VMPTR(pScreen);
+    pVidMode = VidModeGetPtr(pScreen);
     pVidMode->First = pScrn->modes;
     pVidMode->Next = pVidMode->First->next;
 
@@ -236,7 +225,7 @@ xf86VidModeGetFirstModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClo
     return xf86VidModeGetNextModeline(pScreen, mode, dotClock);
 }
 
-Bool
+static Bool
 xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -249,7 +238,7 @@ xf86VidModeDeleteModeline(ScreenPtr pScreen, DisplayModePtr mode)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
 {
     if (!xf86VidModeAvailable(pScreen))
@@ -259,7 +248,7 @@ xf86VidModeZoomViewport(ScreenPtr pScreen, int zoom)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
 {
     ScrnInfoPtr pScrn;
@@ -280,7 +269,7 @@ xf86VidModeSetViewPort(ScreenPtr pScreen, int x, int y)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
 {
     ScrnInfoPtr pScrn;
@@ -294,7 +283,7 @@ xf86VidModeGetViewPort(ScreenPtr pScreen, int *x, int *y)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -316,7 +305,7 @@ xf86VidModeSwitchMode(ScreenPtr pScreen, DisplayModePtr mode)
     return retval;
 }
 
-Bool
+static Bool
 xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
 {
     if (!xf86VidModeAvailable(pScreen))
@@ -329,7 +318,7 @@ xf86VidModeLockZoom(ScreenPtr pScreen, Bool lock)
     return TRUE;
 }
 
-ModeStatus
+static ModeStatus
 xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -342,7 +331,7 @@ xf86VidModeCheckModeForMonitor(ScreenPtr pScreen, DisplayModePtr mode)
     return xf86CheckModeForMonitor(mode, pScrn->monitor);
 }
 
-ModeStatus
+static ModeStatus
 xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -355,7 +344,7 @@ xf86VidModeCheckModeForDriver(ScreenPtr pScreen, DisplayModePtr mode)
     return xf86CheckModeForDriver(pScrn, mode, 0);
 }
 
-void
+static void
 xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -374,7 +363,7 @@ xf86VidModeSetCrtcForMode(ScreenPtr pScreen, DisplayModePtr mode)
     return;
 }
 
-Bool
+static Bool
 xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
 {
     ScrnInfoPtr pScrn;
@@ -395,7 +384,7 @@ xf86VidModeAddModeline(ScreenPtr pScreen, DisplayModePtr mode)
     return TRUE;
 }
 
-int
+static int
 xf86VidModeGetNumOfModes(ScreenPtr pScreen)
 {
     DisplayModePtr mode = NULL;
@@ -411,7 +400,7 @@ xf86VidModeGetNumOfModes(ScreenPtr pScreen)
     } while (TRUE);
 }
 
-Bool
+static Bool
 xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
 {
     Gamma gamma;
@@ -428,7 +417,7 @@ xf86VidModeSetGamma(ScreenPtr pScreen, float red, float green, float blue)
         return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
 {
     ScrnInfoPtr pScrn;
@@ -443,7 +432,7 @@ xf86VidModeGetGamma(ScreenPtr pScreen, float *red, float *green, float *blue)
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
 {
     if (!xf86VidModeAvailable(pScreen))
@@ -453,7 +442,7 @@ xf86VidModeSetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
     return TRUE;
 }
 
-Bool
+static Bool
 xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD16 *b)
 {
     if (!xf86VidModeAvailable(pScreen))
@@ -463,7 +452,7 @@ xf86VidModeGetGammaRamp(ScreenPtr pScreen, int size, CARD16 *r, CARD16 *g, CARD1
     return TRUE;
 }
 
-int
+static int
 xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
 {
     if (!xf86VidModeAvailable(pScreen))
@@ -472,12 +461,9 @@ xf86VidModeGetGammaRampSize(ScreenPtr pScreen)
     return xf86GetGammaRampSize(pScreen);
 }
 
-#endif                          /* XF86VIDMODE */
-
-Bool
-xf86VidModeExtensionInit(ScreenPtr pScreen)
+static Bool
+xf86VidModeInit(ScreenPtr pScreen)
 {
-#ifdef XF86VIDMODE
     VidModePtr pVidMode;
 
     if (!xf86GetVidModeEnabled()) {
@@ -485,18 +471,61 @@ xf86VidModeExtensionInit(ScreenPtr pScreen)
         return FALSE;
     }
 
-    if (!dixRegisterPrivateKey(&VidModeKeyRec, PRIVATE_SCREEN, sizeof(VidModeRec)))
+    pVidMode = VidModeInit(pScreen);
+    if (!pVidMode)
         return FALSE;
 
-    pVidMode = VMPTR(pScreen);
-
     pVidMode->Flags = 0;
     pVidMode->Next = NULL;
 
+    pVidMode->GetMonitorValue = xf86VidModeGetMonitorValue;
+    pVidMode->GetCurrentModeline = xf86VidModeGetCurrentModeline;
+    pVidMode->GetFirstModeline = xf86VidModeGetFirstModeline;
+    pVidMode->GetNextModeline = xf86VidModeGetNextModeline;
+    pVidMode->DeleteModeline = xf86VidModeDeleteModeline;
+    pVidMode->ZoomViewport = xf86VidModeZoomViewport;
+    pVidMode->GetViewPort = xf86VidModeGetViewPort;
+    pVidMode->SetViewPort = xf86VidModeSetViewPort;
+    pVidMode->SwitchMode = xf86VidModeSwitchMode;
+    pVidMode->LockZoom = xf86VidModeLockZoom;
+    pVidMode->GetNumOfClocks = xf86VidModeGetNumOfClocks;
+    pVidMode->GetClocks = xf86VidModeGetClocks;
+    pVidMode->CheckModeForMonitor = xf86VidModeCheckModeForMonitor;
+    pVidMode->CheckModeForDriver = xf86VidModeCheckModeForDriver;
+    pVidMode->SetCrtcForMode = xf86VidModeSetCrtcForMode;
+    pVidMode->AddModeline = xf86VidModeAddModeline;
+    pVidMode->GetDotClock = xf86VidModeGetDotClock;
+    pVidMode->GetNumOfModes = xf86VidModeGetNumOfModes;
+    pVidMode->SetGamma = xf86VidModeSetGamma;
+    pVidMode->GetGamma = xf86VidModeGetGamma;
+    pVidMode->SetGammaRamp = xf86VidModeSetGammaRamp;
+    pVidMode->GetGammaRamp = xf86VidModeGetGammaRamp;
+    pVidMode->GetGammaRampSize = xf86VidModeGetGammaRampSize;
+
     return TRUE;
-#else
-    DebugF("no vidmode extension\n");
-    return FALSE;
-#endif
 }
 
+void
+XFree86VidModeExtensionInit(void)
+{
+    int i;
+    Bool enabled = FALSE;
+
+    DebugF("XFree86VidModeExtensionInit");
+
+    /* This means that the DDX doesn't want the vidmode extension enabled */
+    if (!xf86GetVidModeEnabled())
+        return;
+
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        if (xf86VidModeInit (screenInfo.screens[i]))
+            enabled = TRUE;
+    }
+    /* This means that the DDX doesn't want the vidmode extension enabled */
+    if (!enabled)
+        return;
+
+   VidModeAddExtension(xf86GetVidModeAllowNonLocal());
+}
+
+#endif                          /* XF86VIDMODE */
diff --git a/include/Makefile.am b/include/Makefile.am
index 4c8ea6a2a..b9cf584cb 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -76,4 +76,5 @@ EXTRA_DIST = 	\
 	swaprep.h \
 	swapreq.h \
 	systemd-logind.h \
+        vidmodestr.h \
 	xsha1.h
diff --git a/include/vidmodestr.h b/include/vidmodestr.h
new file mode 100644
index 000000000..3a4418501
--- /dev/null
+++ b/include/vidmodestr.h
@@ -0,0 +1,140 @@
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _VIDMODEPROC_H_
+#define _VIDMODEPROC_H_
+
+#include "displaymode.h"
+
+typedef enum {
+    VIDMODE_H_DISPLAY,
+    VIDMODE_H_SYNCSTART,
+    VIDMODE_H_SYNCEND,
+    VIDMODE_H_TOTAL,
+    VIDMODE_H_SKEW,
+    VIDMODE_V_DISPLAY,
+    VIDMODE_V_SYNCSTART,
+    VIDMODE_V_SYNCEND,
+    VIDMODE_V_TOTAL,
+    VIDMODE_FLAGS,
+    VIDMODE_CLOCK
+} VidModeSelectMode;
+
+typedef enum {
+    VIDMODE_MON_VENDOR,
+    VIDMODE_MON_MODEL,
+    VIDMODE_MON_NHSYNC,
+    VIDMODE_MON_NVREFRESH,
+    VIDMODE_MON_HSYNC_LO,
+    VIDMODE_MON_HSYNC_HI,
+    VIDMODE_MON_VREFRESH_LO,
+    VIDMODE_MON_VREFRESH_HI
+} VidModeSelectMonitor;
+
+typedef union {
+    const void *ptr;
+    int i;
+    float f;
+} vidMonitorValue;
+
+typedef Bool            (*VidModeExtensionInitProcPtr)       (ScreenPtr pScreen);
+typedef vidMonitorValue (*VidModeGetMonitorValueProcPtr)     (ScreenPtr pScreen,
+                                                              int valtyp,
+                                                              int indx);
+typedef Bool            (*VidModeGetEnabledProcPtr)          (void);
+typedef Bool            (*VidModeGetAllowNonLocalProcPtr)    (void);
+typedef Bool            (*VidModeGetCurrentModelineProcPtr)  (ScreenPtr pScreen,
+                                                              DisplayModePtr *mode,
+                                                              int *dotClock);
+typedef Bool            (*VidModeGetFirstModelineProcPtr)    (ScreenPtr pScreen,
+                                                              DisplayModePtr *mode,
+                                                              int *dotClock);
+typedef Bool            (*VidModeGetNextModelineProcPtr)     (ScreenPtr pScreen,
+                                                              DisplayModePtr *mode,
+                                                              int *dotClock);
+typedef Bool            (*VidModeDeleteModelineProcPtr)      (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef Bool            (*VidModeZoomViewportProcPtr)        (ScreenPtr pScreen,
+                                                              int zoom);
+typedef Bool            (*VidModeGetViewPortProcPtr)         (ScreenPtr pScreen,
+                                                              int *x,
+                                                              int *y);
+typedef Bool            (*VidModeSetViewPortProcPtr)         (ScreenPtr pScreen,
+                                                              int x,
+                                                              int y);
+typedef Bool            (*VidModeSwitchModeProcPtr)          (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef Bool            (*VidModeLockZoomProcPtr)            (ScreenPtr pScreen,
+                                                              Bool lock);
+typedef int             (*VidModeGetNumOfClocksProcPtr)      (ScreenPtr pScreen,
+                                                              Bool *progClock);
+typedef Bool            (*VidModeGetClocksProcPtr)           (ScreenPtr pScreen,
+                                                              int *Clocks);
+typedef ModeStatus      (*VidModeCheckModeForMonitorProcPtr) (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef ModeStatus      (*VidModeCheckModeForDriverProcPtr)  (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef void            (*VidModeSetCrtcForModeProcPtr)      (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef Bool            (*VidModeAddModelineProcPtr)         (ScreenPtr pScreen,
+                                                              DisplayModePtr mode);
+typedef int             (*VidModeGetDotClockProcPtr)         (ScreenPtr pScreen,
+                                                              int Clock);
+typedef int             (*VidModeGetNumOfModesProcPtr)       (ScreenPtr pScreen);
+typedef Bool            (*VidModeSetGammaProcPtr)            (ScreenPtr pScreen,
+                                                              float red,
+                                                              float green,
+                                                              float blue);
+typedef Bool            (*VidModeGetGammaProcPtr)            (ScreenPtr pScreen,
+                                                              float *red,
+                                                              float *green,
+                                                              float *blue);
+typedef Bool            (*VidModeSetGammaRampProcPtr)        (ScreenPtr pScreen,
+                                                              int size,
+                                                              CARD16 *red,
+                                                              CARD16 *green,
+                                                              CARD16 *blue);
+typedef Bool            (*VidModeGetGammaRampProcPtr)        (ScreenPtr pScreen,
+                                                              int size,
+                                                              CARD16 *red,
+                                                              CARD16 *green,
+                                                              CARD16 *blue);
+typedef int             (*VidModeGetGammaRampSizeProcPtr)    (ScreenPtr pScreen);
+
+typedef struct {
+    DisplayModePtr First;
+    DisplayModePtr Next;
+    int Flags;
+
+    VidModeExtensionInitProcPtr       ExtensionInit;
+    VidModeGetMonitorValueProcPtr     GetMonitorValue;
+    VidModeGetCurrentModelineProcPtr  GetCurrentModeline;
+    VidModeGetFirstModelineProcPtr    GetFirstModeline;
+    VidModeGetNextModelineProcPtr     GetNextModeline;
+    VidModeDeleteModelineProcPtr      DeleteModeline;
+    VidModeZoomViewportProcPtr        ZoomViewport;
+    VidModeGetViewPortProcPtr         GetViewPort;
+    VidModeSetViewPortProcPtr         SetViewPort;
+    VidModeSwitchModeProcPtr          SwitchMode;
+    VidModeLockZoomProcPtr            LockZoom;
+    VidModeGetNumOfClocksProcPtr      GetNumOfClocks;
+    VidModeGetClocksProcPtr           GetClocks;
+    VidModeCheckModeForMonitorProcPtr CheckModeForMonitor;
+    VidModeCheckModeForDriverProcPtr  CheckModeForDriver;
+    VidModeSetCrtcForModeProcPtr      SetCrtcForMode;
+    VidModeAddModelineProcPtr         AddModeline;
+    VidModeGetDotClockProcPtr         GetDotClock;
+    VidModeGetNumOfModesProcPtr       GetNumOfModes;
+    VidModeSetGammaProcPtr            SetGamma;
+    VidModeGetGammaProcPtr            GetGamma;
+    VidModeSetGammaRampProcPtr        SetGammaRamp;
+    VidModeGetGammaRampProcPtr        GetGammaRamp;
+    VidModeGetGammaRampSizeProcPtr    GetGammaRampSize;
+} VidModeRec, *VidModePtr;
+
+void VidModeAddExtension(Bool allow_non_local);
+VidModePtr VidModeGetPtr(ScreenPtr pScreen);
+VidModePtr VidModeInit(ScreenPtr pScreen);
+
+#endif
diff --git a/test/Makefile.am b/test/Makefile.am
index d151b02d0..9f13e269d 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -56,6 +56,7 @@ libxservertest_la_LIBADD += \
             $(top_builddir)/hw/xfree86/ddc/libddc.la \
             $(top_builddir)/hw/xfree86/i2c/libi2c.la \
             $(top_builddir)/hw/xfree86/dixmods/libxorgxkb.la \
+            $(top_builddir)/Xext/libXvidmode.la \
             @XORG_LIBS@
 
 BUILT_SOURCES = sdksyms.c
@@ -91,6 +92,7 @@ libxservertest_la_LIBADD += \
             $(top_builddir)/render/librender.la \
             $(top_builddir)/Xext/libXext.la \
             $(top_builddir)/Xext/libXextdpmsstubs.la \
+            $(top_builddir)/Xext/libXvidmode.la \
             $(top_builddir)/Xi/libXi.la \
             $(top_builddir)/Xi/libXistubs.la \
             $(top_builddir)/xfixes/libxfixes.la \