Changeset 83136 in vbox for trunk/src/VBox/Additions/x11/VBoxClient/display-svga-x11.cpp

Timestamp:

Feb 21, 2020 2:36:52 PM (5 years ago)

Author:

vboxsync

Message:

bugref:9637. Adding randr event monitoring to display-svga client.

File:

• trunk/src/VBox/Additions/x11/VBoxClient/display-svga-x11.cpp (modified) (12 diffs)

trunk/src/VBox/Additions/x11/VBoxClient/display-svga-x11.cpp

@@ -37 +37 @@
  *  - When VMSVGA is not enabled, VBoxClient --vmsvga should never stay running.
  */
-#include "stdio.h"
+#include <stdio.h>
 #include "VBoxClient.h"
 
@@ -46 +46 @@
 #include <iprt/file.h>
 #include <iprt/string.h>
-
-#include <sys/utsname.h>
+#include <iprt/thread.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xlibint.h>
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xrandr.h>
 
 /** Maximum number of supported screens.  DRM and X11 both limit this to 32. */
@@ -53 +58 @@
  *  context structure. */
 #define VMW_MAX_HEADS 32
-
-#include "seamless-x11.h"
-
-#ifdef RT_OS_LINUX
-# include <sys/ioctl.h>
-#else  /* Solaris and BSDs, in case they ever adopt the DRM driver. */
-# include <sys/ioccom.h>
-#endif
-
-#define USE_XRANDR_BIN
-
+/** Monitor positions array. Allocated here and deallocated in the class descructor. */
+RTPOINT *mpMonitorPositions;
+/** Thread to listen to some of the X server events. */
+RTTHREAD mX11MonitorThread = NIL_RTTHREAD;
 
 struct X11VMWRECT /* xXineramaScreenInfo in Xlib headers. */
@@ -83 +81 @@
     int hRandRErrorBase;
     int hEventMask;
+    /** The number of outputs (monitors, including disconnect ones) xrandr reports. */
+    int hOutputCount;
     Window rootWindow;
 };
+
+static X11CONTEXT x11Context;
 
 #define MAX_MODE_NAME_LEN 64
@@ -93 +95 @@
 static const char *pcszXrandr = "xrandr";
 static const char *pcszCvt = "cvt";
-/** The number of outputs (monitors, including disconnect ones) xrandr reports. */
-static int iOutputCount = 0;
 
 struct DRMCONTEXT
@@ -111 +111 @@
 
 /** Forward declarations. */
-static void x11Connect(struct X11CONTEXT *pContext);
-
-static bool init(struct X11CONTEXT *pContext)
-{
-    if (!pContext)
+static void x11Connect();
+static int determineOutputCount();
+
+/** This function assumes monitors are named as from Virtual1 to VirtualX. */
+static int getMonitorIdFromName(const char *sMonitorName)
+{
+    if (!sMonitorName)
+        return -1;
+    int iLen = strlen(sMonitorName);
+    if (iLen <= 0)
+        return -1;
+    int iBase = 10;
+    int iResult = 0;
+    for (int i = iLen - 1; i >= 0; --i)
+    {
+        /* Stop upon seeing the first non-numeric char. */
+        if (sMonitorName[i] < 48 || sMonitorName[i] > 57)
+            break;
+        iResult += (sMonitorName[i] - 48) * iBase / 10;
+        iBase *= 10;
+    }
+    return iResult;
+}
+
+static void queryMonitorPositions()
+{
+    printf("===========================================================================================================================================");
+    static const int iSentinelPosition = -1;
+    if (mpMonitorPositions)
+    {
+        free(mpMonitorPositions);
+        mpMonitorPositions = NULL;
+    }
+    // if (!mHostMonitorPositionSendCallback)
+    // {
+    //     VBClLogFatalError("No monitor positions update callback\n");
+    //     return;
+    // }
+
+    XRRScreenResources *pScreenResources = XRRGetScreenResources (x11Context.pDisplay, DefaultRootWindow(x11Context.pDisplay));
+    AssertReturnVoid(pScreenResources);
+    XRRFreeScreenResources (pScreenResources);
+
+    int iMonitorCount = 0;
+    XRRMonitorInfo *pMonitorInfo = XRRGetMonitors(x11Context.pDisplay, DefaultRootWindow(x11Context.pDisplay), true, &iMonitorCount);
+    if (iMonitorCount == -1)
+        VBClLogError("Could not get monitor info\n");
+    else
+    {
+        getMonitorIdFromName("virtual123");
+        mpMonitorPositions = (RTPOINT*)malloc(x11Context.hOutputCount * sizeof(RTPOINT));
+        /* todo: memset? */
+        for (int i = 0; i < x11Context.hOutputCount; ++i)
+        {
+            mpMonitorPositions[i].x = iSentinelPosition;
+            mpMonitorPositions[i].y = iSentinelPosition;
+        }
+        for (int i = 0; i < iMonitorCount; ++i)
+        {
+            int iMonitorID = getMonitorIdFromName(XGetAtomName(x11Context.pDisplay, pMonitorInfo[i].name)) - 1;
+            if (iMonitorID >= x11Context.hOutputCount || iMonitorID == -1)
+                continue;
+            VBClLogInfo("Monitor %d (w,h)=(%d,%d) (x,y)=(%d,%d)\n",
+                        i,
+                        pMonitorInfo[i].width, pMonitorInfo[i].height,
+                        pMonitorInfo[i].x, pMonitorInfo[i].y);
+            mpMonitorPositions[iMonitorID].x = pMonitorInfo[i].x;
+            mpMonitorPositions[iMonitorID].y = pMonitorInfo[i].y;
+        }
+        // if (iMonitorCount > 0)
+        //     mHostMonitorPositionSendCallback(mpMonitorPositions, x11Context.hOutputCount);
+    }
+    XRRFreeMonitors(pMonitorInfo);
+}
+
+static void monitorRandREvents()
+{
+    XEvent event;
+    XNextEvent(x11Context.pDisplay, &event);
+    int eventTypeOffset = event.type - x11Context.hRandREventBase;
+    switch (eventTypeOffset)
+    {
+        case RRScreenChangeNotify:
+            VBClLogInfo("RRScreenChangeNotify\n");
+            queryMonitorPositions();
+            break;
+        case RRNotify:
+            VBClLogInfo("RRNotify\n");
+            break;
+        default:
+            VBClLogInfo("Unknown RR event\n");
+            break;
+    }
+}
+
+int x11MonitorThreadFunction(RTTHREAD hThreadSelf, void *pvUser)
+{
+    (void)hThreadSelf;
+    (void*)pvUser;
+    while(1)
+    {
+        monitorRandREvents();
+    }
+    return 0;
+}
+
+static int startX11MonitorThread()
+{
+    int rc;
+
+    if (mX11MonitorThread == NIL_RTTHREAD)
+    {
+        rc = RTThreadCreate(&mX11MonitorThread, x11MonitorThreadFunction, 0, 0,
+                            RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
+                            "X11 events");
+        if (RT_FAILURE(rc))
+            VBClLogFatalError("Warning: failed to start X11 monitor thread (VBoxClient) rc=%Rrc!\n", rc);
+    }
+    return rc;
+}
+
+static int stopX11MonitorThread(void)
+{
+    int rc;
+    if (mX11MonitorThread != NIL_RTTHREAD)
+    {
+        //????????
+        //mX11Monitor.interruptEventWait();
+        rc = RTThreadWait(mX11MonitorThread, 1000, NULL);
+        if (RT_SUCCESS(rc))
+            mX11MonitorThread = NIL_RTTHREAD;
+        else
+            VBClLogError("Failed to stop X11 monitor thread, rc=%Rrc!\n", rc);
+    }
+    return rc;
+}
+
+static bool init()
+{
+    x11Connect();
+    if (x11Context.pDisplay == NULL)
         return false;
-    x11Connect(pContext);
-    if (pContext->pDisplay == NULL)
+    if (RT_FAILURE(startX11MonitorThread()))
         return false;
+    XRRSelectInput(x11Context.pDisplay, x11Context.rootWindow, x11Context.hEventMask);
     return true;
 }
 
-static void x11Connect(struct X11CONTEXT *pContext)
+static void cleanup()
+{
+    if (mpMonitorPositions)
+    {
+        free(mpMonitorPositions);
+        mpMonitorPositions = NULL;
+    }
+    stopX11MonitorThread();
+    XRRSelectInput(x11Context.pDisplay, x11Context.rootWindow, 0);
+    XCloseDisplay(x11Context.pDisplay);
+}
+
+static void x11Connect()
 {
     int dummy;
-    if (pContext->pDisplay != NULL)
+    if (x11Context.pDisplay != NULL)
         VBClLogFatalError("%s called with bad argument\n", __func__);
-    pContext->pDisplay = XOpenDisplay(NULL);
-    if (pContext->pDisplay == NULL)
+    x11Context.pDisplay = XOpenDisplay(NULL);
+    if (x11Context.pDisplay == NULL)
         return;
-    if(!XQueryExtension(pContext->pDisplay, "VMWARE_CTRL",
-                        &pContext->hVMWMajor, &dummy, &dummy))
-    {
-        XCloseDisplay(pContext->pDisplay);
-        pContext->pDisplay = NULL;
-    }
-    if (!XRRQueryExtension(pContext->pDisplay, &pContext->hRandREventBase, &pContext->hRandRErrorBase))
-    {
-        XCloseDisplay(pContext->pDisplay);
-        pContext->pDisplay = NULL;
-    }
-    if (!XRRQueryVersion(pContext->pDisplay, &pContext->hRandRMajor, &pContext->hRandRMinor))
-    {
-        XCloseDisplay(pContext->pDisplay);
-        pContext->pDisplay = NULL;
-    }
-    pContext->hEventMask = RRScreenChangeNotifyMask;
-    if (pContext->hRandRMinor >= 2)
-        pContext->hEventMask |=  RRCrtcChangeNotifyMask |
+    if(!XQueryExtension(x11Context.pDisplay, "VMWARE_CTRL",
+                        &x11Context.hVMWMajor, &dummy, &dummy))
+    {
+        XCloseDisplay(x11Context.pDisplay);
+        x11Context.pDisplay = NULL;
+    }
+    if (!XRRQueryExtension(x11Context.pDisplay, &x11Context.hRandREventBase, &x11Context.hRandRErrorBase))
+    {
+        XCloseDisplay(x11Context.pDisplay);
+        x11Context.pDisplay = NULL;
+    }
+    if (!XRRQueryVersion(x11Context.pDisplay, &x11Context.hRandRMajor, &x11Context.hRandRMinor))
+    {
+        XCloseDisplay(x11Context.pDisplay);
+        x11Context.pDisplay = NULL;
+    }
+    x11Context.hEventMask = RRScreenChangeNotifyMask;
+    if (x11Context.hRandRMinor >= 2)
+        x11Context.hEventMask |=  RRCrtcChangeNotifyMask |
             RROutputChangeNotifyMask |
             RROutputPropertyNotifyMask;
-    pContext->rootWindow = DefaultRootWindow(pContext->pDisplay);
+    x11Context.rootWindow = DefaultRootWindow(x11Context.pDisplay);
+    x11Context.hOutputCount = determineOutputCount();
 }
 
@@ -313 +462 @@
     char szAddModeCommand[1024];
     /* try to add the new mode to all possible outputs. we currently dont care if most the are disabled. */
-    for(int i = 0; i < iOutputCount; ++i)
+    for(int i = 0; i < x11Context.hOutputCount; ++i)
     {
         RTStrPrintf(szAddModeCommand, sizeof(szAddModeCommand), "%s --addmode Virtual%d \"%s\"", pcszXrandr, i + 1, pszModeName);
@@ -350 +499 @@
     RTStrPrintf(szCommand, sizeof(szCommand), "%s ", pcszXrandr);
 
-    for (int i = 0; i < iOutputCount; ++i)
+    for (int i = 0; i < x11Context.hOutputCount; ++i)
     {
         char line[64];
@@ -390 +539 @@
 static int run(struct VBCLSERVICE **ppInterface, bool fDaemonised)
 {
-    iOutputCount = determineOutputCount();
     (void)ppInterface;
     (void)fDaemonised;
@@ -398 +546 @@
      * e.g. from before a guest reboot. */
     bool fAck = false;
-    struct X11CONTEXT x11Context = { NULL };
-    if (!init(&x11Context))
+
+    if (!init())
         return VINF_SUCCESS;
     static struct VMMDevDisplayDef aMonitors[VMW_MAX_HEADS];
@@ -458 +606 @@
             struct RANDROUTPUT aOutputs[VMW_MAX_HEADS];
             int iRunningX = 0;
-            for (int j = 0; j < iOutputCount; ++j)
+            for (int j = 0; j < x11Context.hOutputCount; ++j)
             {
                 aOutputs[j].x = iRunningX;
@@ -477 +625 @@
             VBClLogFatalError("Failure waiting for event, rc=%Rrc\n", rc);
     }
+    cleanup();
 }