VirtualBox

Changeset 51064 in vbox


Ignore:
Timestamp:
Apr 14, 2014 2:21:37 PM (11 years ago)
Author:
vboxsync
Message:

crOpenGL: fix to switch on/off new command submission

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/include/chromium.h

    r50095 r51064  
    728728
    729729#define GL_HH_SET_TMPCTX_MAKE_CURRENT 0x8B2E
     730/* inform renderspu about the current render thread */
     731#define GL_HH_RENDERTHREAD_INFORM     0x8B2F
    730732
    731733/**********************************************************************/

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

    r51005 r51064  
    30063006}
    30073007
     3008static void crVBoxServerDeleteMuralCb(unsigned long key, void *data1, void *data2)
     3009{
     3010    CRHashTable *h = (CRHashTable*)data2;
     3011    CRMuralInfo *m = (CRMuralInfo *) data1;
     3012    if (m->spuWindow == CR_RENDER_DEFAULT_WINDOW_ID)
     3013        return;
     3014
     3015    crHashtableDelete(h, key, NULL);
     3016    crServerMuralTerm(m);
     3017    crFree(m);
     3018}
     3019
     3020static void crVBoxServerDefaultContextClear()
     3021{
     3022    HCR_FRAMEBUFFER hFb;
     3023    int rc = CrPMgrDisable();
     3024    if (RT_FAILURE(rc))
     3025    {
     3026        WARN(("CrPMgrDisable failed %d", rc));
     3027        return;
     3028    }
     3029
     3030    for (hFb = CrPMgrFbGetFirstEnabled(); hFb; hFb = CrPMgrFbGetNextEnabled(hFb))
     3031    {
     3032        int rc = CrFbUpdateBegin(hFb);
     3033        if (RT_SUCCESS(rc))
     3034        {
     3035            CrFbRegionsClear(hFb);
     3036            CrFbUpdateEnd(hFb);
     3037        }
     3038        else
     3039            WARN(("CrFbUpdateBegin failed %d", rc));
     3040    }
     3041
     3042    cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
     3043
     3044    /* note: we need to clean all contexts, since otherwise renderspu leanup won't work,
     3045     * i.e. renderspu would need to clean up its own internal windows, it won't be able to do that if
     3046     * some those windows is associated with any context.  */
     3047    if (cr_server.MainContextInfo.SpuContext)
     3048    {
     3049        cr_server.head_spu->dispatch_table.DestroyContext(cr_server.MainContextInfo.SpuContext);
     3050        memset(&cr_server.MainContextInfo, 0, sizeof (cr_server.MainContextInfo));
     3051    }
     3052
     3053    CRASSERT(!cr_server.curClient);
     3054
     3055    cr_server.currentCtxInfo = NULL;
     3056    cr_server.currentWindow = 0;
     3057    cr_server.currentNativeWindow = 0;
     3058    cr_server.currentMural = NULL;
     3059
     3060    crStateCleanupCurrent();
     3061
     3062    if (CrBltIsInitialized(&cr_server.Blitter))
     3063    {
     3064        CrBltTerm(&cr_server.Blitter);
     3065        Assert(!CrBltIsInitialized(&cr_server.Blitter));
     3066    }
     3067
     3068    crHashtableWalk(cr_server.dummyMuralTable, crVBoxServerDeleteMuralCb, cr_server.dummyMuralTable);
     3069
     3070    cr_server.head_spu->dispatch_table.ChromiumParameteriCR(GL_HH_RENDERTHREAD_INFORM, 0);
     3071}
     3072
    30083073static void crVBoxServerDefaultContextSet()
    30093074{
    3010     GLint spuWindow, spuCtx;
    3011     CRContext *ctx = NULL;
    3012 
    3013     if (cr_server.MainContextInfo.SpuContext)
    3014     {
    3015         CRMuralInfo *pMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
    3016         if (!pMural)
    3017         {
    3018             WARN(("dummy mural is NULL"));
    3019             spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
    3020             spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
    3021         }
    3022         else
    3023         {
    3024             spuCtx = cr_server.MainContextInfo.SpuContext;
    3025             spuWindow = pMural->spuWindow;
    3026             ctx = cr_server.MainContextInfo.pContext;
    3027             Assert(ctx);
    3028         }
    3029     }
    3030     else
    3031     {
    3032         spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
    3033         spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
    3034     }
    3035 
    3036     cr_server.head_spu->dispatch_table.MakeCurrent(spuWindow, 0, spuCtx);
    3037     crStateSetCurrent(ctx);
    3038 
     3075    cr_server.head_spu->dispatch_table.ChromiumParameteriCR(GL_HH_RENDERTHREAD_INFORM, 1);
     3076
     3077    CRASSERT(!cr_server.MainContextInfo.SpuContext);
     3078
     3079    crStateSetCurrent(NULL);
     3080
     3081    CrPMgrEnable();
    30393082}
    30403083
    … …  
    33693412    CrHTableEmpty(&cr_server.clientTable);
    33703413
    3371     cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
    3372     crStateCleanupCurrent();
     3414    crVBoxServerDefaultContextClear();
    33733415
    33743416    memset(&cr_server.CrCmdClientInfo, 0, sizeof (cr_server.CrCmdClientInfo));
    … …  
    41894231    }
    41904232
    4191     cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
    4192     crStateCleanupCurrent();
     4233    crVBoxServerDefaultContextClear();
    41934234
    41944235    cr_server.DisableData = *pData;

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

    r50277 r51064  
    281281    case GL_HH_SET_DEFAULT_SHARED_CTX:
    282282        crWarning("Recieved GL_HH_SET_DEFAULT_SHARED_CTX from guest, ignoring");
     283        break;
     284    case GL_HH_RENDERTHREAD_INFORM:
     285        crWarning("Recieved GL_HH_RENDERTHREAD_INFORM from guest, ignoring");
    283286        break;
    284287    default:

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

    r50957 r51064  
    132132#endif
    133133    uint32_t u32DisplayMode;
     134    uint32_t u32DisabledDisplayMode;
     135    bool fEnabled;
    134136    CRHashTable *pFbTexMap;
    135137    CR_FBDISPLAY_INFO aDisplayInfos[CR_MAX_GUEST_MONITORS];
    … …  
    37263728};
    37273729
     3730int CrPMgrDisable()
     3731{
     3732    if (!g_CrPresenter.fEnabled)
     3733        return VINF_SUCCESS;
     3734
     3735    g_CrPresenter.u32DisabledDisplayMode = g_CrPresenter.u32DisplayMode;
     3736
     3737    int rc = crPMgrModeModifyGlobal(0, CR_PMGR_MODE_WINDOW);
     3738    if (RT_FAILURE(rc))
     3739    {
     3740        WARN(("crPMgrModeModifyGlobal failed %d", rc));
     3741        return rc;
     3742    }
     3743
     3744    g_CrPresenter.fEnabled = false;
     3745
     3746    return VINF_SUCCESS;
     3747}
     3748
     3749int CrPMgrEnable()
     3750{
     3751    if (g_CrPresenter.fEnabled)
     3752        return VINF_SUCCESS;
     3753
     3754    g_CrPresenter.fEnabled = true;
     3755
     3756    int rc = crPMgrModeModifyGlobal(g_CrPresenter.u32DisabledDisplayMode, 0);
     3757    if (RT_FAILURE(rc))
     3758    {
     3759        WARN(("crPMgrModeModifyGlobal failed %d", rc));
     3760        g_CrPresenter.fEnabled = false;
     3761        return rc;
     3762    }
     3763
     3764    g_CrPresenter.u32DisabledDisplayMode = 0;
     3765
     3766    return VINF_SUCCESS;
     3767}
     3768
    37283769int CrPMgrInit()
    37293770{
    37303771    int rc = VINF_SUCCESS;
    37313772    memset(&g_CrPresenter, 0, sizeof (g_CrPresenter));
     3773    g_CrPresenter.fEnabled = true;
    37323774    g_CrPresenter.pFbTexMap = crAllocHashtable();
    37333775    if (g_CrPresenter.pFbTexMap)
    … …  
    41254167static int crPMgrModeModifyGlobal(uint32_t u32ModeAdd, uint32_t u32ModeRemove)
    41264168{
    4127     g_CrPresenter.u32DisplayMode = (g_CrPresenter.u32DisplayMode | u32ModeAdd) & ~u32ModeRemove;
     4169    uint32_t u32DisplayMode = (g_CrPresenter.u32DisplayMode | u32ModeAdd) & ~u32ModeRemove;
     4170    if (!g_CrPresenter.fEnabled)
     4171    {
     4172        g_CrPresenter.u32DisabledDisplayMode = u32DisplayMode;
     4173        return VINF_SUCCESS;
     4174    }
     4175
     4176    g_CrPresenter.u32DisplayMode = u32DisplayMode;
    41284177
    41294178    for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c

    r50814 r51064  
    203203    else
    204204    {
    205         CRASSERT(cr_server.currentWindow != mural->CreateInfo.externalID);
     205        CRASSERT(cr_server.currentMural != mural);
    206206    }
    207207

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

    r50405 r51064  
    599599}
    600600
     601void renderspuWindowTermBase( WindowInfo *window )
     602{
     603    renderspuVBoxCompositorSet(window, NULL);
     604    renderspuVBoxPresentBlitterCleanup(window);
     605    renderspu_SystemDestroyWindow( window );
     606    RTCritSectDelete(&window->CompositorLock);
     607}
     608
    601609void renderspuWindowTerm( WindowInfo *window )
    602610{
    … …  
    605613    CRASSERT(!pOldCtx == !pOldWindow);
    606614    /* ensure no concurrent draws can take place */
    607     renderspuVBoxCompositorSet(window, NULL);
    608     renderspuVBoxPresentBlitterCleanup(window);
    609     renderspu_SystemDestroyWindow( window );
    610     RTCritSectDelete(&window->CompositorLock);
     615    renderspuWindowTermBase(window);
    611616    /* check if this window is bound to some ctx. Note: window pointer is already freed here */
    612617    crHashtableWalk(render_spu.contextTable, renderspuCheckCurrentCtxWindowCB, window);
    … …  
    13671372}
    13681373
    1369 
    13701374static void RENDER_APIENTRY renderspuChromiumParameteriCR(GLenum target, GLint value)
    13711375{
    1372 
    13731376    switch (target)
    13741377    {
    … …  
    13821385
    13831386            renderspuSetDefaultSharedContext(pCtx);
     1387            break;
     1388        }
     1389        case GL_HH_RENDERTHREAD_INFORM:
     1390        {
     1391            if (value)
     1392            {
     1393                int rc = renderspuDefaultCtxInit();
     1394                if (RT_FAILURE(rc))
     1395                {
     1396                    WARN(("renderspuDefaultCtxInit failed"));
     1397                    break;
     1398                }
     1399            }
     1400            else
     1401            {
     1402                renderspuCleanupBase(false);
     1403            }
    13841404            break;
    13851405        }
    … …  
    17531773{
    17541774    WindowInfo *pWindow = (WindowInfo *)data1;
    1755 
    1756     renderspu_SystemReparentWindow(pWindow);
     1775    CRHashTable *pTable = (CRHashTable*)data2;
     1776
     1777    crHashtableDelete(pTable, key, NULL);
     1778
     1779    renderspuWindowTerm(pWindow);
     1780
     1781    crFree(pWindow);
    17571782}
    17581783

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.h

    r50095 r51064  
    424424extern PCR_BLITTER renderspuVBoxPresentBlitterGetAndEnter( WindowInfo *window, int32_t i32MakeCurrentUserData );
    425425extern PCR_BLITTER renderspuVBoxPresentBlitterEnsureCreated( WindowInfo *window, int32_t i32MakeCurrentUserData );
     426void renderspuWindowTermBase( WindowInfo *window );
    426427extern void renderspuWindowTerm( WindowInfo *window );
    427428extern WindowInfo* renderspuGetDummyWindow(GLint visBits);
    … …  
    443444extern uint32_t renderspuContextMarkDeletedAndRelease( ContextInfo *context );
    444445
     446int renderspuDefaultCtxInit();
     447void renderspuCleanupBase(bool fDeleteTables);
     448
    445449ContextInfo * renderspuDefaultSharedContextAcquire();
    446450void renderspuDefaultSharedContextRelease(ContextInfo * pCtx);

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c

    r50095 r51064  
    673673        if (RT_SUCCESS(rc))
    674674        {
    675             rc = RTSemEventWait(render_spu.hWinCmdCompleteEvent, RT_INDEFINITE_WAIT);
     675            rc = RTSemEventWait(render_spu.hWinCmdCompleteEvent, RT_INDEFINITE_WAIT);
    676676            if (RT_SUCCESS(rc))
    677677            {
    678                 return VINF_SUCCESS;
    679             }
     678                return VINF_SUCCESS;
     679            }
    680680            else
    681681            {
    682                 crWarning("RTSemEventWait failed rc %d", rc);
    683             }
    684 
    685             RTThreadWait(render_spu.hWinCmdThread, RT_INDEFINITE_WAIT, NULL);
     682            crWarning("RTSemEventWait failed rc %d", rc);
     683        }
     684
     685        RTThreadWait(render_spu.hWinCmdThread, RT_INDEFINITE_WAIT, NULL);
    686686        }
    687687        else
    … …  
    689689            crWarning("RTThreadCreate failed rc %d", rc);
    690690        }
    691         RTSemEventDestroy(render_spu.hWinCmdCompleteEvent);
     691            RTSemEventDestroy(render_spu.hWinCmdCompleteEvent);
    692692    }
    693693    else

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c

    r50095 r51064  
    134134#endif
    135135
     136int renderspuDefaultCtxInit()
     137{
     138    GLint defaultWin, defaultCtx;
     139    WindowInfo *windowInfo;
     140
     141    /*
     142     * Create the default window and context.  Their indexes are zero and
     143     * a client can use them without calling CreateContext or WindowCreate.
     144     */
     145    crDebug("Render SPU: Creating default window (visBits=0x%x, id=0)",
     146            render_spu.default_visual);
     147    defaultWin = renderspuWindowCreateEx( NULL, render_spu.default_visual, CR_RENDER_DEFAULT_WINDOW_ID );
     148    if (defaultWin != CR_RENDER_DEFAULT_WINDOW_ID) {
     149        crError("Render SPU: Couldn't get a double-buffered, RGB visual with Z!");
     150        return VERR_GENERAL_FAILURE;
     151    }
     152    crDebug( "Render SPU: WindowCreate returned %d (0=normal)", defaultWin );
     153
     154    crDebug("Render SPU: Creating default context, visBits=0x%x",
     155            render_spu.default_visual );
     156    defaultCtx = renderspuCreateContextEx( NULL, render_spu.default_visual, CR_RENDER_DEFAULT_CONTEXT_ID, 0 );
     157    if (defaultCtx != CR_RENDER_DEFAULT_CONTEXT_ID) {
     158        crError("Render SPU: failed to create default context!");
     159        return VERR_GENERAL_FAILURE;
     160    }
     161
     162    renderspuMakeCurrent( defaultWin, 0, defaultCtx );
     163
     164    /* Get windowInfo for the default window */
     165    windowInfo = (WindowInfo *) crHashtableSearch(render_spu.windowTable, CR_RENDER_DEFAULT_WINDOW_ID);
     166    CRASSERT(windowInfo);
     167    windowInfo->mapPending = GL_TRUE;
     168
     169    return VINF_SUCCESS;
     170}
     171
    136172static SPUFunctions *
    137173renderSPUInit( int id, SPU *child, SPU *self,
    … …  
    139175{
    140176    int numFuncs, numSpecial;
    141     GLint defaultWin, defaultCtx;
    142     WindowInfo *windowInfo;
     177
    143178    const char * pcpwSetting;
    144179    int rc;
    … …  
    267302#endif /* DARWIN */
    268303
    269     /*
    270      * Create the default window and context.  Their indexes are zero and
    271      * a client can use them without calling CreateContext or WindowCreate.
    272      */
    273     crDebug("Render SPU: Creating default window (visBits=0x%x, id=0)",
    274             render_spu.default_visual);
    275     defaultWin = renderspuWindowCreateEx( NULL, render_spu.default_visual, CR_RENDER_DEFAULT_WINDOW_ID );
    276     if (defaultWin != CR_RENDER_DEFAULT_WINDOW_ID) {
    277         crError("Render SPU: Couldn't get a double-buffered, RGB visual with Z!");
     304    rc = renderspuDefaultCtxInit();
     305    if (!RT_SUCCESS(rc))
     306    {
     307        WARN(("renderspuDefaultCtxInit failed %d", rc));
    278308        return NULL;
    279309    }
    280     crDebug( "Render SPU: WindowCreate returned %d (0=normal)", defaultWin );
    281 
    282     crDebug("Render SPU: Creating default context, visBits=0x%x",
    283             render_spu.default_visual );
    284     defaultCtx = renderspuCreateContextEx( NULL, render_spu.default_visual, CR_RENDER_DEFAULT_CONTEXT_ID, 0 );
    285     if (defaultCtx != CR_RENDER_DEFAULT_CONTEXT_ID) {
    286         crError("Render SPU: failed to create default context!");
    287         return NULL;
    288     }
    289 
    290     renderspuMakeCurrent( defaultWin, 0, defaultCtx );
    291 
    292     /* Get windowInfo for the default window */
    293     windowInfo = (WindowInfo *) crHashtableSearch(render_spu.windowTable, CR_RENDER_DEFAULT_WINDOW_ID);
    294     CRASSERT(windowInfo);
    295     windowInfo->mapPending = GL_TRUE;
    296310
    297311    /*
    … …  
    414428{
    415429    WindowInfo *window = (WindowInfo *) data;
    416     renderspu_SystemDestroyWindow(window);
     430    renderspuWindowTermBase(window);
    417431    crFree(window);
    418432}
    … …  
    433447}
    434448
     449
     450static void renderspuDeleteBlitterCB(unsigned long key, void *data1, void *data2)
     451{
     452    CRHashTable *pTbl = (CRHashTable*)data2;
     453
     454    crHashtableDelete( pTbl, key, NULL );
     455
     456    DeleteBlitterCallback(data1);
     457}
     458
     459
     460static void renderspuDeleteWindowCB(unsigned long key, void *data1, void *data2)
     461{
     462    CRHashTable *pTbl = (CRHashTable*)data2;
     463
     464    crHashtableDelete( pTbl, key, NULL );
     465
     466    DeleteWindowCallback(data1);
     467}
     468
     469static void renderspuDeleteBarierCB(unsigned long key, void *data1, void *data2)
     470{
     471    CRHashTable *pTbl = (CRHashTable*)data2;
     472
     473    crHashtableDelete( pTbl, key, NULL );
     474
     475    crFree(data1);
     476}
     477
     478
     479static void renderspuDeleteContextCB(unsigned long key, void *data1, void *data2)
     480{
     481    CRHashTable *pTbl = (CRHashTable*)data2;
     482
     483    crHashtableDelete( pTbl, key, NULL );
     484
     485    DeleteContextCallback(data1);
     486}
     487
     488void renderspuCleanupBase(bool fDeleteTables)
     489{
     490    renderspuVBoxCompositorClearAll();
     491
     492    if (render_spu.blitterTable)
     493    {
     494        if (fDeleteTables)
     495        {
     496            crFreeHashtable(render_spu.blitterTable, DeleteBlitterCallback);
     497            render_spu.blitterTable = NULL;
     498        }
     499        else
     500        {
     501            crHashtableWalk(render_spu.blitterTable, renderspuDeleteBlitterCB, render_spu.contextTable);
     502        }
     503    }
     504    else
     505    {
     506        crHashtableWalk(render_spu.windowTable, renderspuBlitterCleanupCB, NULL);
     507
     508        crHashtableWalk(render_spu.dummyWindowTable, renderspuBlitterCleanupCB, NULL);
     509    }
     510
     511    renderspuSetDefaultSharedContext(NULL);
     512
     513    if (fDeleteTables)
     514    {
     515        crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
     516        render_spu.contextTable = NULL;
     517        crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
     518        render_spu.windowTable = NULL;
     519        crFreeHashtable(render_spu.dummyWindowTable, DeleteWindowCallback);
     520        render_spu.dummyWindowTable = NULL;
     521        crFreeHashtable(render_spu.barrierHash, crFree);
     522        render_spu.barrierHash = NULL;
     523    }
     524    else
     525    {
     526        crHashtableWalk(render_spu.contextTable, renderspuDeleteContextCB, render_spu.contextTable);
     527        crHashtableWalk(render_spu.windowTable, renderspuDeleteWindowCB, render_spu.windowTable);
     528        crHashtableWalk(render_spu.dummyWindowTable, renderspuDeleteWindowCB, render_spu.dummyWindowTable);
     529        crHashtableWalk(render_spu.barrierHash, renderspuDeleteBarierCB, render_spu.barrierHash);
     530    }
     531}
     532
    435533static int renderSPUCleanup(void)
    436534{
    437     renderspuVBoxCompositorClearAll();
    438 
    439     if (render_spu.blitterTable)
    440     {
    441         crFreeHashtable(render_spu.blitterTable, DeleteBlitterCallback);
    442         render_spu.blitterTable = NULL;
    443     }
    444     else
    445     {
    446         crHashtableWalk(render_spu.windowTable, renderspuBlitterCleanupCB, NULL);
    447 
    448         crHashtableWalk(render_spu.dummyWindowTable, renderspuBlitterCleanupCB, NULL);
    449     }
    450 
    451     renderspuSetDefaultSharedContext(NULL);
    452 
    453     crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
    454     render_spu.contextTable = NULL;
    455     crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
    456     render_spu.windowTable = NULL;
    457     crFreeHashtable(render_spu.dummyWindowTable, DeleteWindowCallback);
    458     render_spu.dummyWindowTable = NULL;
    459     crFreeHashtable(render_spu.barrierHash, crFree);
    460     render_spu.barrierHash = NULL;
     535    renderspuCleanupBase(true);
    461536
    462537#ifdef RT_OS_DARWIN
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette