Changeset 4264 in vbox

Timestamp:

Aug 21, 2007 3:23:28 PM (17 years ago)

Author:

vboxsync

Message:

Backed out 23773 until it works

Location:

trunk/src/VBox/Additions/WINNT/VBoxService

Files:

• Makefile.kmk (modified) (1 diff)
• VBoxClipboard.h (deleted)
• VBoxDisplay.cpp (deleted)
• VBoxDisplay.h (deleted)
• VBoxService.cpp (modified) (5 diffs)

trunk/src/VBox/Additions/WINNT/VBoxService/Makefile.kmk

@@ -30 +30 @@
         VBoxSeamless.cpp \
         VBoxClipboard.cpp \
-        VBoxDisplay.cpp \
         helpers.cpp \
         VBoxService.rc

trunk/src/VBox/Additions/WINNT/VBoxService/VBoxService.cpp

@@ -17 +17 @@
 #include "VBoxService.h"
 #include "VBoxSeamless.h"
-#include "VBoxClipboard.h"
-#include "VBoxDisplay.h"
 #include <VBoxHook.h>
 #include "resource.h"
@@ -70 +68 @@
 
 
+/* The shared clipboard service prototypes. */
+int                VBoxClipboardInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
+unsigned __stdcall VBoxClipboardThread  (void *pInstance);
+void               VBoxClipboardDestroy (const VBOXSERVICEENV *pEnv, void *pInstance);
+
 /* The service table. */
 static VBOXSERVICEINFO vboxServiceTable[] =
 {
-    {
-        "Display",
-        VBoxDisplayInit,
-        VBoxDisplayThread,
-        VBoxDisplayDestroy,
-    },
     {
         "Shared Clipboard",
@@ -299 +296 @@
     }
 
+    /* create display change thread */
+    HANDLE hDisplayChangeThread;
+    if (status == NO_ERROR)
+    {
+        hDisplayChangeThread = (HANDLE)_beginthread(DisplayChangeThread, 0, NULL);
+        if ((int)hDisplayChangeThread == -1L)
+            status = ERROR_GEN_FAILURE;
+    }
+
+    dprintf(("VBoxService: hDisplayChangeThread h %p, st %p\n", hDisplayChangeThread, status));
+
     /* terminate service if something went wrong */
     if (status != NO_ERROR)
@@ -372 +380 @@
     dprintf(("VBoxService: waiting for display change thread...\n"));
 
+    /* wait for the display change thread to terminate */
+    WaitForSingleObject(hDisplayChangeThread, INFINITE);
+
     vboxStopServices (&svcEnv, vboxServiceTable);
 
@@ -401 +412 @@
 }
 
+static bool isVBoxDisplayDriverActive (void)
+{
+    bool result = false;
+
+    DISPLAY_DEVICE dispDevice;
+
+    FillMemory(&dispDevice, sizeof(DISPLAY_DEVICE), 0);
+
+    dispDevice.cb = sizeof(DISPLAY_DEVICE);
+
+    INT devNum = 0;
+
+    while (EnumDisplayDevices(NULL,
+                              devNum,
+                              &dispDevice,
+                              0))
+    {
+        DDCLOG(("DevNum:%d\nName:%s\nString:%s\nID:%s\nKey:%s\nFlags=%08X\n\n",
+                      devNum,
+                      &dispDevice.DeviceName[0],
+                      &dispDevice.DeviceString[0],
+                      &dispDevice.DeviceID[0],
+                      &dispDevice.DeviceKey[0],
+                      dispDevice.StateFlags));
+
+        if (dispDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+        {
+            DDCLOG(("Primary device.\n"));
+
+            if (strcmp(&dispDevice.DeviceString[0], "VirtualBox Graphics Adapter") == 0)
+            {
+                DDCLOG(("VBox display driver is active.\n"));
+                result = true;
+            }
+
+            break;
+        }
+
+        FillMemory(&dispDevice, sizeof(DISPLAY_DEVICE), 0);
+
+        dispDevice.cb = sizeof(DISPLAY_DEVICE);
+
+        devNum++;
+    }
+
+    return result;
+}
+
+/* ChangeDisplaySettingsEx does not exist in NT. ResizeDisplayDevice uses the function. */
+typedef LONG WINAPI defChangeDisplaySettingsEx(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
+static defChangeDisplaySettingsEx *pChangeDisplaySettingsEx = NULL;
+
+/* Returns TRUE to try again. */
+static BOOL ResizeDisplayDevice(ULONG Id, DWORD Width, DWORD Height, DWORD BitsPerPixel)
+{
+    BOOL fModeReset = (Width == 0 && Height == 0 && BitsPerPixel == 0);
+    
+    DISPLAY_DEVICE DisplayDevice;
+
+    ZeroMemory(&DisplayDevice, sizeof(DisplayDevice));
+    DisplayDevice.cb = sizeof(DisplayDevice);
+    
+    /* Find out how many display devices the system has */
+    DWORD NumDevices = 0;
+    DWORD i = 0;
+    while (EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
+    { 
+        DDCLOG(("[%d] %s\n", i, DisplayDevice.DeviceName));
+
+        if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+        {
+            DDCLOG(("Found primary device. err %d\n", GetLastError ()));
+            NumDevices++;
+        }
+        else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
+        {
+            
+            DDCLOG(("Found secondary device. err %d\n", GetLastError ()));
+            NumDevices++;
+        }
+        
+        ZeroMemory(&DisplayDevice, sizeof(DisplayDevice));
+        DisplayDevice.cb = sizeof(DisplayDevice);
+        i++;
+    }
+    
+    DDCLOG(("Found total %d devices. err %d\n", NumDevices, GetLastError ()));
+    
+    if (NumDevices == 0 || Id >= NumDevices)
+    {
+        DDCLOG(("Requested identifier %d is invalid. err %d\n", Id, GetLastError ()));
+        return FALSE;
+    }
+    
+    DISPLAY_DEVICE *paDisplayDevices = (DISPLAY_DEVICE *)alloca (sizeof (DISPLAY_DEVICE) * NumDevices);
+    DEVMODE *paDeviceModes = (DEVMODE *)alloca (sizeof (DEVMODE) * NumDevices);
+    RECTL *paRects = (RECTL *)alloca (sizeof (RECTL) * NumDevices);
+    
+    /* Fetch information about current devices and modes. */
+    DWORD DevNum = 0;
+    DWORD DevPrimaryNum = 0;
+    
+    ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
+    DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
+    
+    i = 0;
+    while (EnumDisplayDevices (NULL, i, &DisplayDevice, 0))
+    { 
+        DDCLOG(("[%d(%d)] %s\n", i, DevNum, DisplayDevice.DeviceName));
+        
+        BOOL bFetchDevice = FALSE;
+
+        if (DisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+        {
+            DDCLOG(("Found primary device. err %d\n", GetLastError ()));
+            DevPrimaryNum = DevNum;
+            bFetchDevice = TRUE;
+        }
+        else if (!(DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
+        {
+            
+            DDCLOG(("Found secondary device. err %d\n", GetLastError ()));
+            bFetchDevice = TRUE;
+        }
+        
+        if (bFetchDevice)
+        {
+            if (DevNum >= NumDevices)
+            {
+                DDCLOG(("%d >= %d\n", NumDevices, DevNum));
+                return FALSE;
+            }
+        
+            paDisplayDevices[DevNum] = DisplayDevice;
+            
+            ZeroMemory(&paDeviceModes[DevNum], sizeof(DEVMODE));
+            paDeviceModes[DevNum].dmSize = sizeof(DEVMODE);
+            if (!EnumDisplaySettings((LPSTR)DisplayDevice.DeviceName,
+                 ENUM_REGISTRY_SETTINGS, &paDeviceModes[DevNum]))
+            {
+                DDCLOG(("EnumDisplaySettings err %d\n", GetLastError ()));
+                return FALSE;
+            }
+            
+            DDCLOG(("%dx%d at %d,%d\n",
+                    paDeviceModes[DevNum].dmPelsWidth,
+                    paDeviceModes[DevNum].dmPelsHeight,
+                    paDeviceModes[DevNum].dmPosition.x,
+                    paDeviceModes[DevNum].dmPosition.y));
+                    
+            paRects[DevNum].left   = paDeviceModes[DevNum].dmPosition.x;
+            paRects[DevNum].top    = paDeviceModes[DevNum].dmPosition.y;
+            paRects[DevNum].right  = paDeviceModes[DevNum].dmPosition.x + paDeviceModes[DevNum].dmPelsWidth;
+            paRects[DevNum].bottom = paDeviceModes[DevNum].dmPosition.y + paDeviceModes[DevNum].dmPelsHeight;
+            DevNum++;
+        }
+        
+        ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));
+        DisplayDevice.cb = sizeof(DISPLAY_DEVICE);
+        i++;
+    }
+    
+    if (Width == 0)
+    {
+        Width = paRects[Id].right - paRects[Id].left;
+    }
+
+    if (Height == 0)
+    {
+        Height = paRects[Id].bottom - paRects[Id].top;
+    }
+
+    /* Check whether a mode reset or a change is requested. */
+    if (   !fModeReset
+        && paRects[Id].right - paRects[Id].left == Width
+        && paRects[Id].bottom - paRects[Id].top == Height
+        && paDeviceModes[Id].dmBitsPerPel == BitsPerPixel)
+    {
+        DDCLOG(("VBoxService: already at desired resolution.\n"));
+        return FALSE;
+    }
+
+    resizeRect(paRects, NumDevices, DevPrimaryNum, Id, Width, Height);
+#ifdef DDCLOG
+    for (i = 0; i < NumDevices; i++)
+    {
+        DDCLOG(("[%d]: %d,%d %dx%d\n",
+                i, paRects[i].left, paRects[i].top,
+                paRects[i].right - paRects[i].left,
+                paRects[i].bottom - paRects[i].top));
+    }
+#endif /* DDCLOG */
+    
+    /* Without this, Windows will not ask the miniport for its
+     * mode table but uses an internal cache instead.
+     */
+    DEVMODE tempDevMode;
+    ZeroMemory (&tempDevMode, sizeof (tempDevMode));
+    tempDevMode.dmSize = sizeof(DEVMODE);
+    EnumDisplaySettings(NULL, 0xffffff, &tempDevMode);
+
+    /* Assign the new rectangles to displays. */
+    for (i = 0; i < NumDevices; i++)
+    {
+        paDeviceModes[i].dmPosition.x = paRects[i].left;
+        paDeviceModes[i].dmPosition.y = paRects[i].top;
+        paDeviceModes[i].dmPelsWidth  = paRects[i].right - paRects[i].left;
+        paDeviceModes[i].dmPelsHeight = paRects[i].bottom - paRects[i].top;
+        
+        paDeviceModes[i].dmFields = DM_POSITION | DM_PELSHEIGHT | DM_PELSWIDTH;
+        
+        if (   i == Id
+            && BitsPerPixel != 0)
+        {
+            paDeviceModes[i].dmFields |= DM_BITSPERPEL;
+            paDeviceModes[i].dmBitsPerPel = BitsPerPixel;
+        }
+        
+        pChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName, 
+                 &paDeviceModes[i], NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL); 
+        DDCLOG(("ChangeDisplaySettings position err %d\n", GetLastError ()));
+    }
+    
+    /* A second call to ChangeDisplaySettings updates the monitor. */
+    LONG status = ChangeDisplaySettings(NULL, 0); 
+    DDCLOG(("ChangeDisplaySettings update status %d\n", status));
+    if (status == DISP_CHANGE_SUCCESSFUL || status == DISP_CHANGE_BADMODE)
+    {
+        /* Successfully set new video mode or our driver can not set the requested mode. Stop trying. */
+        return FALSE;
+    }
+
+    /* Retry the request. */
+    return TRUE;
+}
+
+/**
+ * Thread function to wait for and process display change
+ * requests
+ */
+VOID DisplayChangeThread(void *dummy)
+{
+    bool fTerminate = false;
+    VBoxGuestFilterMaskInfo maskInfo;
+    DWORD cbReturned;
+    
+    HMODULE hUser = GetModuleHandle("USER32");
+
+    if (hUser)
+    {
+        pChangeDisplaySettingsEx = (defChangeDisplaySettingsEx *)GetProcAddress(hUser, "ChangeDisplaySettingsExA"); 
+        DDCLOG(("VBoxService: pChangeDisplaySettingsEx = %p\n", pChangeDisplaySettingsEx));
+    }
+
+    maskInfo.u32OrMask = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+    maskInfo.u32NotMask = 0;
+    if (DeviceIoControl (gVBoxDriver, IOCTL_VBOXGUEST_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
+    {
+        DDCLOG(("VBoxService: DeviceIOControl(CtlMask - or) succeeded\n"));
+    }
+    else
+    {
+        dprintf(("VBoxService: DeviceIOControl(CtlMask) failed, DisplayChangeThread exited\n"));
+        return;
+    }
+
+    do
+    {
+        /* wait for a display change event */
+        VBoxGuestWaitEventInfo waitEvent;
+        waitEvent.u32TimeoutIn = 100;
+        waitEvent.u32EventMaskIn = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+        if (DeviceIoControl(gVBoxDriver, IOCTL_VBOXGUEST_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
+        {
+            DDCLOG(("VBoxService: DeviceIOControl succeded\n"));
+
+            /* are we supposed to stop? */
+            if (WaitForSingleObject(gStopSem, 0) == WAIT_OBJECT_0)
+                break;
+
+            DDCLOG(("VBoxService: checking event\n"));
+
+            /* did we get the right event? */
+            if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
+            {
+                DDCLOG(("VBoxService: going to get display change information.\n"));
+
+                /* We got at least one event. Read the requested resolution
+                 * and try to set it until success. New events will not be seen
+                 * but a new resolution will be read in this poll loop.
+                 */
+                for (;;)
+                {
+                    /* get the display change request */
+                    VMMDevDisplayChangeRequest2 displayChangeRequest = {0};
+                    displayChangeRequest.header.size        = sizeof(VMMDevDisplayChangeRequest2);
+                    displayChangeRequest.header.version     = VMMDEV_REQUEST_HEADER_VERSION;
+                    displayChangeRequest.header.requestType = VMMDevReq_GetDisplayChangeRequest2;
+                    displayChangeRequest.eventAck           = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+                    BOOL fDisplayChangeQueried = DeviceIoControl(gVBoxDriver, IOCTL_VBOXGUEST_VMMREQUEST, &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest2),
+                                                                 &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest2), &cbReturned, NULL);
+                    if (!fDisplayChangeQueried)
+                    {
+                        /* Try the old version of the request for old VBox hosts. */
+                        displayChangeRequest.header.size        = sizeof(VMMDevDisplayChangeRequest);
+                        displayChangeRequest.header.version     = VMMDEV_REQUEST_HEADER_VERSION;
+                        displayChangeRequest.header.requestType = VMMDevReq_GetDisplayChangeRequest;
+                        displayChangeRequest.eventAck           = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+                        fDisplayChangeQueried = DeviceIoControl(gVBoxDriver, IOCTL_VBOXGUEST_VMMREQUEST, &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest),
+                                                                 &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest), &cbReturned, NULL);
+                        displayChangeRequest.display = 0;
+                    }
+
+                    if (fDisplayChangeQueried)
+                    {
+                        DDCLOG(("VBoxService: VMMDevReq_GetDisplayChangeRequest2: %dx%dx%d at %d\n", displayChangeRequest.xres, displayChangeRequest.yres, displayChangeRequest.bpp, displayChangeRequest.display));
+
+                        /* Horizontal resolution must be a multiple of 8, round down. */
+                        displayChangeRequest.xres &= 0xfff8;
+
+                        /*
+                         * Only try to change video mode if the active display driver is VBox additions.
+                         */
+                        if (isVBoxDisplayDriverActive ())
+                        {
+                            if (pChangeDisplaySettingsEx != 0)
+                            {
+                                /* W2K or later. */
+                                if (!ResizeDisplayDevice(displayChangeRequest.display,
+                                                         displayChangeRequest.xres,
+                                                         displayChangeRequest.yres,
+                                                         displayChangeRequest.bpp))
+                                {
+                                    break;
+                                }
+                            }
+                            else
+                            {
+                                /* Single monitor NT. */
+                                DEVMODE devMode;
+                                memset (&devMode, 0, sizeof (devMode));
+                                devMode.dmSize = sizeof(DEVMODE);
+
+                                /* get the current screen setup */
+                                if (EnumDisplaySettings(NULL, ENUM_REGISTRY_SETTINGS, &devMode))
+                                {
+                                    dprintf(("VBoxService: Current mode: %dx%dx%d at %d,%d\n", devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmBitsPerPel, devMode.dmPosition.x, devMode.dmPosition.y));
+
+                                    /* Check whether a mode reset or a change is requested. */
+                                    if (displayChangeRequest.xres || displayChangeRequest.yres || displayChangeRequest.bpp)
+                                    {
+                                        /* A change is requested.
+                                         * Set values which are not to be changed to the current values.
+                                         */
+                                        if (!displayChangeRequest.xres)
+                                            displayChangeRequest.xres = devMode.dmPelsWidth;
+                                        if (!displayChangeRequest.yres)
+                                            displayChangeRequest.yres = devMode.dmPelsHeight;
+                                        if (!displayChangeRequest.bpp)
+                                            displayChangeRequest.bpp = devMode.dmBitsPerPel;
+                                    }
+                                    else
+                                    {
+                                        /* All zero values means a forced mode reset. Do nothing. */
+                                    }
+
+                                    /* Verify that the mode is indeed changed. */
+                                    if (   devMode.dmPelsWidth  == displayChangeRequest.xres
+                                        && devMode.dmPelsHeight == displayChangeRequest.yres
+                                        && devMode.dmBitsPerPel == displayChangeRequest.bpp)
+                                    {
+                                        dprintf(("VBoxService: already at desired resolution.\n"));
+                                        break;
+                                    }
+
+                                    // without this, Windows will not ask the miniport for its
+                                    // mode table but uses an internal cache instead
+                                    DEVMODE tempDevMode = {0};
+                                    tempDevMode.dmSize = sizeof(DEVMODE);
+                                    EnumDisplaySettings(NULL, 0xffffff, &tempDevMode);
+
+                                    /* adjust the values that are supposed to change */
+                                    if (displayChangeRequest.xres)
+                                        devMode.dmPelsWidth  = displayChangeRequest.xres;
+                                    if (displayChangeRequest.yres)
+                                        devMode.dmPelsHeight = displayChangeRequest.yres;
+                                    if (displayChangeRequest.bpp)
+                                        devMode.dmBitsPerPel = displayChangeRequest.bpp;
+
+                                    DDCLOG(("VBoxService: setting the new mode %dx%dx%d\n", devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmBitsPerPel));
+
+                                    /* set the new mode */
+                                    LONG status = ChangeDisplaySettings(&devMode, CDS_UPDATEREGISTRY);
+                                    if (status != DISP_CHANGE_SUCCESSFUL)
+                                    {
+                                        dprintf(("VBoxService: error from ChangeDisplaySettings: %d\n", status));
+
+                                        if (status == DISP_CHANGE_BADMODE)
+                                        {
+                                            /* Our driver can not set the requested mode. Stop trying. */
+                                            break;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        /* Successfully set new video mode. */
+                                        break;
+                                    }
+                                }
+                                else
+                                {
+                                    dprintf(("VBoxService: error from EnumDisplaySettings: %d\n", GetLastError ()));
+                                    break;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            dprintf(("VBoxService: vboxDisplayDriver is not active.\n"));
+                        }
+
+                        /* Retry the change a bit later. */
+                        /* are we supposed to stop? */
+                        if (WaitForSingleObject(gStopSem, 1000) == WAIT_OBJECT_0)
+                        {
+                            fTerminate = true;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        dprintf(("VBoxService: error from DeviceIoControl IOCTL_VBOXGUEST_VMMREQUEST\n"));
+                        /* sleep a bit to not eat too much CPU while retrying */
+                        /* are we supposed to stop? */
+                        if (WaitForSingleObject(gStopSem, 50) == WAIT_OBJECT_0)
+                        {
+                            fTerminate = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        } else
+        {
+            dprintf(("VBoxService: error 0 from DeviceIoControl IOCTL_VBOXGUEST_WAITEVENT\n"));
+            /* sleep a bit to not eat too much CPU in case the above call always fails */
+            if (WaitForSingleObject(gStopSem, 10) == WAIT_OBJECT_0)
+            {
+                fTerminate = true;
+                break;
+            }
+        }
+    } while (!fTerminate);
+
+    maskInfo.u32OrMask = 0;
+    maskInfo.u32NotMask = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+    if (DeviceIoControl (gVBoxDriver, IOCTL_VBOXGUEST_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
+    {
+        DDCLOG(("VBoxService: DeviceIOControl(CtlMask - not) succeeded\n"));
+    }
+    else
+    {
+        dprintf(("VBoxService: DeviceIOControl(CtlMask) failed\n"));
+    }
+
+    dprintf(("VBoxService: finished display change request thread\n"));
+}
+
 /**
  * Window procedure for our tool window