Changeset 34571 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

Timestamp:

Dec 1, 2010 1:45:57 PM (14 years ago)

Author:

vboxsync

Message:

crOpenGL: fix compiz for high resolution guests

File:

• trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (6 diffs)

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -73 +73 @@
 static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
 
+typedef struct _CRVBOXSVCBUFFER_t {
+    uint32_t uiId;
+    uint32_t uiSize;
+    void*    pData;
+    _CRVBOXSVCBUFFER_t *pNext, *pPrev;
+} CRVBOXSVCBUFFER_t;
+
+static CRVBOXSVCBUFFER_t *g_pCRVBoxSVCBuffers = NULL;
+static uint32_t g_CRVBoxSVCBufferID = 0;
+
 static DECLCALLBACK(int) svcUnload (void *)
 {
@@ -129 +139 @@
     rc = crVBoxServerSaveState(pSSM);
     AssertRCReturn(rc, rc);
+
+    /* Save svc buffers info */
+    {
+        CRVBOXSVCBUFFER_t *pBuffer = g_pCRVBoxSVCBuffers;
+
+        rc = SSMR3PutU32(pSSM, g_CRVBoxSVCBufferID);
+        AssertRCReturn(rc, rc);
+
+        while (pBuffer)
+        {
+            rc = SSMR3PutU32(pSSM, pBuffer->uiId);
+            AssertRCReturn(rc, rc);
+
+            rc = SSMR3PutU32(pSSM, pBuffer->uiSize);
+            AssertRCReturn(rc, rc);
+
+            rc = SSMR3PutMem(pSSM, pBuffer->pData, pBuffer->uiSize);
+            AssertRCReturn(rc, rc);
+
+            pBuffer = pBuffer->pNext;
+        }
+
+        rc = SSMR3PutU32(pSSM, 0);
+        AssertRCReturn(rc, rc);
+    }
 
     /* End */
@@ -159 +194 @@
 
     /* The state itself */
+#if SHCROGL_SSM_VERSION==24
+    if (ui32==23)
+    {
+        rc = crVBoxServerLoadState(pSSM, 24);
+    }
+    else
+#endif
     rc = crVBoxServerLoadState(pSSM, ui32);
 
@@ -190 +232 @@
     }
     AssertRCReturn(rc, rc);
+
+    /* Load svc buffers info */
+    if (ui32>=24)
+    {
+        uint32_t uiId;
+
+        rc = SSMR3GetU32(pSSM, &g_CRVBoxSVCBufferID);
+        AssertRCReturn(rc, rc);
+
+        rc = SSMR3GetU32(pSSM, &uiId);
+        AssertRCReturn(rc, rc);
+
+        while (uiId)
+        {
+            CRVBOXSVCBUFFER_t *pBuffer = (CRVBOXSVCBUFFER_t *) RTMemAlloc(sizeof(CRVBOXSVCBUFFER_t));
+            if (!pBuffer)
+            {
+                return VERR_NO_MEMORY;
+            }
+            pBuffer->uiId = uiId;
+
+            rc = SSMR3GetU32(pSSM, &pBuffer->uiSize);
+            AssertRCReturn(rc, rc);
+
+            pBuffer->pData = RTMemAlloc(pBuffer->uiSize);
+            if (!pBuffer->pData)
+            {
+                RTMemFree(pBuffer);
+                return VERR_NO_MEMORY;
+            }
+
+            rc = SSMR3GetMem(pSSM, pBuffer->pData, pBuffer->uiSize);
+            AssertRCReturn(rc, rc);
+
+            pBuffer->pNext = g_pCRVBoxSVCBuffers;
+            pBuffer->pPrev = NULL;
+            if (g_pCRVBoxSVCBuffers)
+            {
+                g_pCRVBoxSVCBuffers->pPrev = pBuffer;
+            }
+            g_pCRVBoxSVCBuffers = pBuffer;
+
+            rc = SSMR3GetU32(pSSM, &uiId);
+            AssertRCReturn(rc, rc);
+        }
+    }
 
     /* End of data */
@@ -247 +335 @@
     CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
     CHECK_ERROR(pDisplay, DrawToScreen(screenId, (BYTE*)data, x, y, w, h));
+}
+
+static CRVBOXSVCBUFFER_t* svcGetBuffer(uint32_t iBuffer, uint32_t cbBufferSize)
+{
+    CRVBOXSVCBUFFER_t* pBuffer;
+
+    if (iBuffer)
+    {
+        pBuffer = g_pCRVBoxSVCBuffers;
+        while (pBuffer)
+        {
+            if (pBuffer->uiId == iBuffer)
+            {
+                return pBuffer;
+            }
+            pBuffer = pBuffer->pNext;
+        }
+        return NULL;
+    }
+    else /*allocate new buffer*/
+    {
+        pBuffer = (CRVBOXSVCBUFFER_t*) RTMemAlloc(sizeof(CRVBOXSVCBUFFER_t));
+        if (pBuffer)
+        {
+            pBuffer->pData = RTMemAlloc(cbBufferSize);
+            if (!pBuffer->pData)
+            {
+                LogRel(("SHARED_CROPENGL svcGetBuffer: not enough memory (%d)\n", cbBufferSize));
+                RTMemFree(pBuffer);
+                return NULL;
+            }
+            pBuffer->uiId = ++g_CRVBoxSVCBufferID;
+            if (!pBuffer->uiId)
+            {
+                pBuffer->uiId = ++g_CRVBoxSVCBufferID;
+            }
+            Assert(pBuffer->uiId);
+            pBuffer->uiSize = cbBufferSize;
+            pBuffer->pPrev = NULL;
+            pBuffer->pNext = g_pCRVBoxSVCBuffers;
+            if (g_pCRVBoxSVCBuffers)
+            {
+                g_pCRVBoxSVCBuffers->pPrev = pBuffer;
+            }
+            g_pCRVBoxSVCBuffers = pBuffer;
+        }
+        else
+        {
+            LogRel(("SHARED_CROPENGL svcGetBuffer: not enough memory (%d)\n", sizeof(CRVBOXSVCBUFFER_t)));
+        }
+        return pBuffer;
+    }
+}
+
+static void svcFreeBuffer(CRVBOXSVCBUFFER_t* pBuffer)
+{
+    Assert(pBuffer);
+
+    if (pBuffer->pPrev)
+    {
+        pBuffer->pPrev->pNext = pBuffer->pNext;
+    }
+    else
+    {
+        Assert(pBuffer==g_pCRVBoxSVCBuffers);
+        g_pCRVBoxSVCBuffers = pBuffer->pNext;
+    }
+
+    if (pBuffer->pNext)
+    {
+        pBuffer->pNext->pPrev = pBuffer->pPrev;
+    }
+
+    RTMemFree(pBuffer->pData);
+    RTMemFree(pBuffer);
 }
 
@@ -484 +647 @@
                 /* Execute the function. */
                 rc = crVBoxServerClientSetPID(u32ClientID, pid);
+            }
+
+            break;
+        }
+
+        case SHCRGL_GUEST_FN_WRITE_BUFFER:
+        {
+            Log(("svcCall: SHCRGL_GUEST_FN_WRITE_BUFFER\n"));
+            /* Verify parameter count and types. */
+            if (cParms != SHCRGL_CPARMS_WRITE_BUFFER)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            if (   paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /*iBufferID*/
+                || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /*cbBufferSize*/
+                || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /*ui32Offset*/
+                || paParms[3].type != VBOX_HGCM_SVC_PARM_PTR   /*pBuffer*/
+               )
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            {
+                /* Fetch parameters. */
+                uint32_t iBuffer      = paParms[0].u.uint32;
+                uint32_t cbBufferSize = paParms[1].u.uint32;
+                uint32_t ui32Offset   = paParms[2].u.uint32;
+                uint8_t *pBuffer      = (uint8_t *)paParms[3].u.pointer.addr;
+                uint32_t cbBuffer     = paParms[3].u.pointer.size;
+
+                /* Execute the function. */
+                CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, cbBufferSize);
+                if (!pSvcBuffer || ui32Offset+cbBuffer>cbBufferSize)
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                }
+                else
+                {
+                    memcpy((void*)((uintptr_t)pSvcBuffer->pData+ui32Offset), pBuffer, cbBuffer);
+
+                    /* Return the buffer id */
+                    paParms[0].u.uint32 = pSvcBuffer->uiId;
+                }
+            }
+
+            break;
+        }
+
+        case SHCRGL_GUEST_FN_WRITE_READ_BUFFERED:
+        {
+            Log(("svcCall: SHCRGL_GUEST_FN_WRITE_READ_BUFFERED\n"));
+
+            /* Verify parameter count and types. */
+            if (cParms != SHCRGL_CPARMS_WRITE_READ_BUFFERED)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            if (    paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT   /* iBufferID */
+                 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR     /* pWriteback */
+                 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT   /* cbWriteback */
+                 || !paParms[0].u.uint32 /*iBufferID can't be 0 here*/
+               )
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            {
+                /* Fetch parameters. */
+                uint32_t iBuffer = paParms[0].u.uint32;
+                uint8_t *pWriteback  = (uint8_t *)paParms[1].u.pointer.addr;
+                uint32_t cbWriteback = paParms[1].u.pointer.size;
+
+                CRVBOXSVCBUFFER_t *pSvcBuffer = svcGetBuffer(iBuffer, 0);
+                if (!pSvcBuffer)
+                {
+                    LogRel(("SHARED_CROPENGL svcCall(WRITE_READ_BUFFERED): invalid buffer (%d)\n", iBuffer));
+                    rc = VERR_INVALID_PARAMETER;
+                    break;
+                }
+               
+                uint8_t *pBuffer     = (uint8_t *)pSvcBuffer->pData;
+                uint32_t cbBuffer    = pSvcBuffer->uiSize;
+
+                /* Execute the function. */
+                rc = crVBoxServerClientWrite(u32ClientID, pBuffer, cbBuffer);
+                if (!RT_SUCCESS(rc))
+                {
+                    Assert(VERR_NOT_SUPPORTED==rc);
+                    svcClientVersionUnsupported(0, 0);
+                }
+
+                rc = crVBoxServerClientRead(u32ClientID, pWriteback, &cbWriteback);
+
+                if (RT_SUCCESS(rc))
+                {
+                    /* Update parameters.*/
+                    paParms[1].u.pointer.size = cbWriteback;
+                }
+                /* Return the required buffer size always */
+                paParms[2].u.uint32 = cbWriteback;
+
+                svcFreeBuffer(pSvcBuffer);
             }