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

Timestamp:

Dec 21, 2012 12:02:47 PM (12 years ago)

Author:

vboxsync

Message:

crOpenGL: glGetError fixes

Location:

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Files:

• server_blitter.cpp (modified) (2 diffs)
• server_context.c (modified) (4 diffs)
• server_main.c (modified) (6 diffs)
• server_misc.c (modified) (1 diff)
• server_special (modified) (1 diff)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_blitter.cpp

@@ -407 +407 @@
                 pBlitter->pRestoreCtxInfo->SpuContext >= 0
                     ? pBlitter->pRestoreCtxInfo->SpuContext : cr_server.MainContextInfo.SpuContext);
-        crStateSwichPostprocess(pBlitter->pRestoreCtxInfo->pContext, pBlitter->pRestoreCtxInfo->pContext, idDrawFBO, idReadFBO);
+        crStateSwitchPostprocess(pBlitter->pRestoreCtxInfo->pContext, NULL, idDrawFBO, idReadFBO);
     }
     else
@@ -448 +448 @@
             idReadFBO = 0;
         }
-        crStateSwichPrepare(NULL, pRestoreCtxInfo->pContext, idDrawFBO, idReadFBO);
+        crStateSwitchPrepare(NULL, pRestoreCtxInfo->pContext, idDrawFBO, idReadFBO);
 
         cr_server.head_spu->dispatch_table.Flush();

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_context.c

@@ -140 +140 @@
     }
 
-    {
-        /* As we're using only one host context to serve all client contexts, newly created context will still
-         * hold last error value from any previous failed opengl call. Proper solution would be to redirect any
-         * client glGetError calls to our state tracker, but right now it's missing quite a lot of checks and doesn't
-         * reflect host driver/gpu specific issues. Thus we just reset last opengl error at context creation.
-         */
-        GLint err;
-
-        err = cr_server.head_spu->dispatch_table.GetError();
-        if (err!=GL_NO_ERROR)
-        {
-#ifdef DEBUG_misha
-            crDebug("Cleared gl error %#x on context creation", err);
-#else
-            crWarning("Cleared gl error %#x on context creation", err);
-#endif
-        }
-    }
-
     crServerReturnValue( &retVal, sizeof(retVal) );
 
@@ -330 +311 @@
     /* Ubuntu 11.04 hosts misbehave if context window switch is
      * done with non-default framebuffer object settings.
-     * crStateSwichPrepare & crStateSwichPostprocess are supposed to work around this problem
-     * crStateSwichPrepare restores the FBO state to its default values before the context window switch,
-     * while crStateSwichPostprocess restores it back to the original values */
+     * crStateSwitchPrepare & crStateSwitchPostprocess are supposed to work around this problem
+     * crStateSwitchPrepare restores the FBO state to its default values before the context window switch,
+     * while crStateSwitchPostprocess restores it back to the original values */
     oldCtx = crStateGetCurrent();
     if (oldMural && oldMural->fUseFBO && crServerSupportRedirMuralFBO())
@@ -344 +325 @@
         idReadFBO = 0;
     }
-    crStateSwichPrepare(cr_server.bUseMultipleContexts ? NULL : ctx, oldCtx, idDrawFBO, idReadFBO);
+    crStateSwitchPrepare(cr_server.bUseMultipleContexts ? NULL : ctx, oldCtx, idDrawFBO, idReadFBO);
 
     /*
@@ -431 +412 @@
         idReadFBO = 0;
     }
-    crStateSwichPostprocess(ctx, cr_server.bUseMultipleContexts ? ctx : oldCtx, idDrawFBO, idReadFBO);
+    crStateSwitchPostprocess(ctx, cr_server.bUseMultipleContexts ? NULL : oldCtx, idDrawFBO, idReadFBO);
 
     if (!ctx->framebufferobject.drawFB

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

@@ -761 +761 @@
 
 #ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
+    CRASSERT(cr_server.curClient);
     if (cr_server.curClient)
     {
-        unsigned long id;
-        if (!crHashtableGetDataKey(cr_server.contextTable, pContextInfo, &id))
-        {
-            crWarning("No client id for server ctx %d", pContext->id);
-        }
-        else
-        {
-            crServerDispatchMakeCurrent(cr_server.curClient->currentWindow, 0, id);
-        }
+# ifdef DEBUG_misha
+        {
+            unsigned long id;
+            if (!crHashtableGetDataKey(cr_server.contextTable, pContextInfo, &id))
+                crWarning("No client id for server ctx %d", pContext->id);
+            else
+                CRASSERT(id == key);
+        }
+# endif
+        crServerDispatchMakeCurrent(cr_server.curClient->currentWindow, 0, key);
     }
 #endif
@@ -778 +780 @@
     CRASSERT(rc == VINF_SUCCESS);
 }
+
+#if 0
+typedef struct CR_SERVER_CHECK_BUFFERS
+{
+    CRBufferObject *obj;
+    CRContext *ctx;
+}CR_SERVER_CHECK_BUFFERS, *PCR_SERVER_CHECK_BUFFERS;
+
+static void crVBoxServerCheckConsistencyContextBuffersCB(unsigned long key, void *data1, void *data2)
+{
+    CRContextInfo* pContextInfo = (CRContextInfo*)data1;
+    CRContext *ctx = pContextInfo->pContext;
+    PCR_SERVER_CHECK_BUFFERS pBuffers = (PCR_SERVER_CHECK_BUFFERS)data2;
+    CRBufferObject *obj = pBuffers->obj;
+    CRBufferObjectState *b = &(ctx->bufferobject);
+    int j, k;
+
+    if (obj == b->arrayBuffer)
+    {
+        Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+        pBuffers->ctx = ctx;
+    }
+    if (obj == b->elementsBuffer)
+    {
+        Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+        pBuffers->ctx = ctx;
+    }
+#ifdef CR_ARB_pixel_buffer_object
+    if (obj == b->packBuffer)
+    {
+        Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+        pBuffers->ctx = ctx;
+    }
+    if (obj == b->unpackBuffer)
+    {
+        Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+        pBuffers->ctx = ctx;
+    }
+#endif
+
+#ifdef CR_ARB_vertex_buffer_object
+    for (j=0; j<CRSTATECLIENT_MAX_VERTEXARRAYS; ++j)
+    {
+        CRClientPointer *cp = crStateGetClientPointerByIndex(j, &ctx->client.array);
+        if (obj == cp->buffer)
+        {
+            Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+            pBuffers->ctx = ctx;
+        }
+    }
+
+    for (k=0; k<ctx->client.vertexArrayStackDepth; ++k)
+    {
+        CRVertexArrays *pArray = &ctx->client.vertexArrayStack[k];
+        for (j=0; j<CRSTATECLIENT_MAX_VERTEXARRAYS; ++j)
+        {
+            CRClientPointer *cp = crStateGetClientPointerByIndex(j, pArray);
+            if (obj == cp->buffer)
+            {
+                Assert(!pBuffers->ctx || pBuffers->ctx == ctx);
+                pBuffers->ctx = ctx;
+            }
+        }
+    }
+#endif
+}
+
+static void crVBoxServerCheckConsistencyBuffersCB(unsigned long key, void *data1, void *data2)
+{
+    CRBufferObject *obj = (CRBufferObject *)data1;
+    CR_SERVER_CHECK_BUFFERS Buffers = {0};
+    Buffers.obj = obj;
+    crHashtableWalk(cr_server.contextTable, crVBoxServerCheckConsistencyContextBuffersCB, (void*)&Buffers);
+}
+
+//static void crVBoxServerCheckConsistency2CB(unsigned long key, void *data1, void *data2)
+//{
+//    CRContextInfo* pContextInfo1 = (CRContextInfo*)data1;
+//    CRContextInfo* pContextInfo2 = (CRContextInfo*)data2;
+//
+//    CRASSERT(pContextInfo1->pContext);
+//    CRASSERT(pContextInfo2->pContext);
+//
+//    if (pContextInfo1 == pContextInfo2)
+//    {
+//        CRASSERT(pContextInfo1->pContext == pContextInfo2->pContext);
+//        return;
+//    }
+//
+//    CRASSERT(pContextInfo1->pContext != pContextInfo2->pContext);
+//    CRASSERT(pContextInfo1->pContext->shared);
+//    CRASSERT(pContextInfo2->pContext->shared);
+//    CRASSERT(pContextInfo1->pContext->shared == pContextInfo2->pContext->shared);
+//    if (pContextInfo1->pContext->shared != pContextInfo2->pContext->shared)
+//        return;
+//
+//    crHashtableWalk(pContextInfo1->pContext->shared->buffersTable, crVBoxServerCheckConsistencyBuffersCB, pContextInfo2);
+//}
+static void crVBoxServerCheckSharedCB(unsigned long key, void *data1, void *data2)
+{
+    CRContextInfo* pContextInfo = (CRContextInfo*)data1;
+    void **ppShared = (void**)data2;
+    if (!*ppShared)
+        *ppShared = pContextInfo->pContext->shared;
+    else
+        Assert(pContextInfo->pContext->shared == *ppShared);
+}
+
+static void crVBoxServerCheckConsistency()
+{
+    CRSharedState *pShared = NULL;
+    crHashtableWalk(cr_server.contextTable, crVBoxServerCheckSharedCB, (void*)&pShared);
+    Assert(pShared);
+    if (pShared)
+    {
+        crHashtableWalk(pShared->buffersTable, crVBoxServerCheckConsistencyBuffersCB, NULL);
+    }
+}
+#endif
 
 static uint32_t g_hackVBoxServerSaveLoadCallsLeft = 0;
@@ -787 +908 @@
     GLboolean b;
     unsigned long key;
+    GLenum err;
 #ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
     unsigned long ctxID=-1, winID=-1;
+#endif
+
+#if 0
+    crVBoxServerCheckConsistency();
 #endif
 
@@ -904 +1030 @@
     }
 
+    /* all context gl error states should have now be synced with chromium erro states,
+     * reset the error if any */
+    while ((err = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR)
+        crWarning("crServer: glGetError %d after saving snapshot", err);
+
     cr_server.bIsInSavingState = GL_FALSE;
 
@@ -922 +1053 @@
     uint32_t ui, uiNumElems;
     unsigned long key;
+    GLenum err;
 
     if (!cr_server.bIsInLoadingState)
@@ -1200 +1332 @@
     cr_server.curClient = NULL;
 
-    {
-        GLenum err = crServerDispatchGetError();
-
-        if (err != GL_NO_ERROR)
-        {
-            crWarning("crServer: glGetError %d after loading snapshot", err);
-        }
-    }
+    while ((err = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR)
+        crWarning("crServer: glGetError %d after loading snapshot", err);
 
     cr_server.bIsInLoadingState = GL_FALSE;
+
+#if 0
+    crVBoxServerCheckConsistency();
+#endif
 
     return VINF_SUCCESS;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c

@@ -948 +948 @@
     cr_server.head_spu->dispatch_table.ReadBuffer( mode );
 }
+
+GLenum SERVER_DISPATCH_APIENTRY crServerDispatchGetError( void )
+{
+    GLenum retval, err;
+    CRContext *ctx = crStateGetCurrent();
+    retval = ctx->error;
+
+    err = cr_server.head_spu->dispatch_table.GetError();
+    if (retval == GL_NO_ERROR)
+        retval = err;
+    else
+        ctx->error = GL_NO_ERROR;
+
+    /* our impl has a single error flag, so we just loop here to reset all error flags to no_error */
+    while (err != GL_NO_ERROR)
+        err = cr_server.head_spu->dispatch_table.GetError();
+
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_special

@@ -250 +250 @@
 ReadBuffer
 TexPresent
+GetError