VirtualBox

Ignore:
Timestamp:
Aug 6, 2013 10:20:23 PM (12 years ago)
Author:
vboxsync
Message:

crOpenGL/wddm: TexPresent fixes, irq handling fix

Location:
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r47485 r47566  
    398398
    399399int crServerVBoxParseNumerics(const char *pszStr, const int defaultVal);
     400
     401
    400402void CrDpEnter(PCR_DISPLAY pDisplay);
    401403void CrDpLeave(PCR_DISPLAY pDisplay);
     404int CrDpInit(PCR_DISPLAY pDisplay);
     405void CrDpTerm(PCR_DISPLAY pDisplay);
     406
     407DECLINLINE(bool) CrDpIsEmpty(PCR_DISPLAY pDisplay)
     408{
     409    return CrVrScrCompositorIsEmpty(&pDisplay->Mural.Compositor);
     410}
     411
     412int CrDpSaveState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM);
     413int CrDpLoadState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM, uint32_t version);
     414
     415void CrDpResize(PCR_DISPLAY pDisplay, int32_t xPos, int32_t yPos, uint32_t width, uint32_t height);
     416void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData);
     417void CrDpEntryCleanup(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry);
     418int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
     419int CrDpEntryRegionsAdd(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
     420void CrDpEntryRegionsClear(PCR_DISPLAY pDisplay);
     421DECLINLINE(bool) CrDpEntryIsUsed(PCR_DISPLAY_ENTRY pEntry)
     422{
     423    return CrVrScrCompositorEntryIsInList(&pEntry->CEntry);
     424}
     425
     426DECLINLINE(CRMuralInfo*) CrDpGetMural(PCR_DISPLAY pDisplay)
     427{
     428    return &pDisplay->Mural;
     429}
     430
     431int CrDemGlobalInit();
     432void CrDemTeGlobalTerm();
     433int CrDemInit(PCR_DISPLAY_ENTRY_MAP pMap);
     434void CrDemTerm(PCR_DISPLAY_ENTRY_MAP pMap);
     435PCR_DISPLAY_ENTRY CrDemEntryAcquire(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture);
     436void CrDemEntryRelease(PCR_DISPLAY_ENTRY pEntry);
     437int CrDemEntrySaveState(PCR_DISPLAY_ENTRY pEntry, PSSMHANDLE pSSM);
     438int CrDemEntryLoadState(PCR_DISPLAY_ENTRY_MAP pMap, PCR_DISPLAY_ENTRY *ppEntry, PSSMHANDLE pSSM);
     439
     440int crServerDisplaySaveState(PSSMHANDLE pSSM);
     441int crServerDisplayLoadState(PSSMHANDLE pSSM, uint32_t u32Version);
    402442
    403443//#define VBOX_WITH_CRSERVER_DUMPER

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

    r46173 r47566  
    382382        if (id != mural->iCurDrawBuffer)
    383383        {
    384             crWarning("DBO draw buffer changed on make current");
     384            crDebug("DBO draw buffer changed on make current");
    385385            mural->iCurDrawBuffer = id;
    386386        }
    … …  
    389389        if (id != mural->iCurReadBuffer)
    390390        {
    391             crWarning("DBO read buffer changed on make current");
     391            crDebug("DBO read buffer changed on make current");
    392392            mural->iCurReadBuffer = id;
    393393        }

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

    r47529 r47566  
    189189    crServerDisplayTermAll();
    190190    CrDemTerm(&cr_server.PresentTexturepMap);
     191    CrDemTeGlobalTerm();
    191192    memset(cr_server.DisplaysInitMap, 0, sizeof (cr_server.DisplaysInitMap));
    192193    memset(cr_server.aDispplays, 0, sizeof (cr_server.aDispplays));
    … …  
    348349        cr_server.u32Caps = 0;
    349350#ifdef DEBUG_misha
    350 //        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT;
     351        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT;
    351352#endif
    352353    }
    … …  
    381382    cr_server.dummyMuralTable = crAllocHashtable();
    382383
     384    CrDemGlobalInit();
     385
    383386    CrDemInit(&cr_server.PresentTexturepMap);
    384387    memset(cr_server.DisplaysInitMap, 0, sizeof (cr_server.DisplaysInitMap));
    … …  
    460463        cr_server.u32Caps = 0;
    461464#ifdef DEBUG_misha
    462 //        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT;
     465        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT;
    463466#endif
    464467    }
    … …  
    501504
    502505    cr_server.dummyMuralTable = crAllocHashtable();
     506
     507    CrDemGlobalInit();
    503508
    504509    CrDemInit(&cr_server.PresentTexturepMap);
    … …  
    17251730    }
    17261731
     1732    rc = crServerDisplaySaveState(pSSM);
     1733    AssertRCReturn(rc, rc);
     1734
    17271735    /* all context gl error states should have now be synced with chromium erro states,
    17281736     * reset the error if any */
    … …  
    26122620    cr_server.curClient = NULL;
    26132621
     2622    if (version >= SHCROGL_SSM_VERSION_WITH_SCREEN_INFO)
     2623    {
     2624        rc = crServerDisplayLoadState(pSSM, version);
     2625        AssertRCReturn(rc, rc);
     2626    }
     2627
    26142628    while ((err = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR)
    26152629        crWarning("crServer: glGetError %d after loading snapshot", err);

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

    r47116 r47566  
    3131#include <iprt/asm.h>
    3232#include <iprt/mem.h>
     33#include <iprt/list.h>
     34#include <iprt/memcache.h>
    3335
    3436
    … …  
    6365{
    6466    const GLint visBits = cr_server.MainContextInfo.CreateInfo.visualBits;
    65     if (crServerMuralInit(&pDisplay->Mural, "", visBits, 0, GL_FALSE) < 0)
     67    if (crServerMuralInit(&pDisplay->Mural, "", visBits, -1, GL_FALSE) < 0)
    6668    {
    6769        crWarning("crServerMuralInit failed!");
    … …  
    8587    CrVrScrCompositorSetStretching(&pDisplay->Mural.Compositor, 1., 1.);
    8688}
     89
     90int CrDpSaveState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM)
     91{
     92    VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
     93    CrVrScrCompositorIterInit(&pDisplay->Mural.Compositor, &Iter);
     94    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
     95    uint32_t u32 = 0;
     96    while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
     97    {
     98        ++u32;
     99    }
     100
     101    int rc = SSMR3PutU32(pSSM, u32);
     102    AssertRCReturn(rc, rc);
     103
     104    CrVrScrCompositorIterInit(&pDisplay->Mural.Compositor, &Iter);
     105
     106    while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
     107    {
     108        CR_DISPLAY_ENTRY *pDEntry = CR_DENTRY_FROM_CENTRY(pEntry);
     109        rc = CrDemEntrySaveState(pDEntry, pSSM);
     110        AssertRCReturn(rc, rc);
     111
     112        u32 = CrVrScrCompositorEntryFlagsGet(&pDEntry->CEntry);
     113        rc = SSMR3PutU32(pSSM, u32);
     114        AssertRCReturn(rc, rc);
     115
     116        rc = SSMR3PutS32(pSSM, CrVrScrCompositorEntryPosGet(&pDEntry->CEntry)->x);
     117        AssertRCReturn(rc, rc);
     118
     119        rc = SSMR3PutS32(pSSM, CrVrScrCompositorEntryPosGet(&pDEntry->CEntry)->y);
     120        AssertRCReturn(rc, rc);
     121
     122        const RTRECT * pRects;
     123        rc = CrVrScrCompositorEntryRegionsGet(&pDisplay->Mural.Compositor, &pDEntry->CEntry, &u32, NULL, NULL, &pRects);
     124        AssertRCReturn(rc, rc);
     125
     126        rc = SSMR3PutU32(pSSM, u32);
     127        AssertRCReturn(rc, rc);
     128
     129        if (u32)
     130        {
     131            rc = SSMR3PutMem(pSSM, pRects, u32 * sizeof (*pRects));
     132            AssertRCReturn(rc, rc);
     133        }
     134    }
     135
     136    return VINF_SUCCESS;
     137}
     138
     139int CrDpLoadState(PCR_DISPLAY pDisplay, PSSMHANDLE pSSM, uint32_t version)
     140{
     141    uint32_t u32 = 0;
     142    int rc = SSMR3GetU32(pSSM, &u32);
     143    AssertRCReturn(rc, rc);
     144
     145    if (!u32)
     146        return VINF_SUCCESS;
     147
     148    CrDpEnter(pDisplay);
     149
     150    for (uint32_t i = 0; i < u32; ++i)
     151    {
     152        CR_DISPLAY_ENTRY *pDEntry;
     153        rc = CrDemEntryLoadState(&cr_server.PresentTexturepMap, &pDEntry, pSSM);
     154        AssertRCReturn(rc, rc);
     155
     156        uint32_t fFlags;
     157        rc = SSMR3GetU32(pSSM, &fFlags);
     158        AssertRCReturn(rc, rc);
     159
     160        CrVrScrCompositorEntryFlagsSet(&pDEntry->CEntry, fFlags);
     161
     162        RTPOINT Pos;
     163        rc = SSMR3GetS32(pSSM, &Pos.x);
     164        AssertRCReturn(rc, rc);
     165
     166        rc = SSMR3GetS32(pSSM, &Pos.y);
     167        AssertRCReturn(rc, rc);
     168
     169        uint32_t cRects;
     170        rc = SSMR3GetU32(pSSM, &cRects);
     171        AssertRCReturn(rc, rc);
     172
     173        RTRECT * pRects = NULL;
     174        if (cRects)
     175        {
     176            pRects = (RTRECT *)crAlloc(cRects * sizeof (*pRects));
     177            AssertReturn(pRects, VERR_NO_MEMORY);
     178
     179            rc = SSMR3GetMem(pSSM, pRects, cRects * sizeof (*pRects));
     180            AssertRCReturn(rc, rc);
     181        }
     182
     183        rc = CrDpEntryRegionsAdd(pDisplay, pDEntry, &Pos, (uint32_t)cRects, (const RTRECT*)pRects);
     184        AssertRCReturn(rc, rc);
     185
     186        if (pRects)
     187            crFree(pRects);
     188    }
     189
     190    CrDpLeave(pDisplay);
     191
     192    return VINF_SUCCESS;
     193}
     194
    87195
    88196int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
    … …  
    147255}
    148256
    149 void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData, void *pvUserData1, void *pvUserData2)
     257void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData)
    150258{
    151259    CrVrScrCompositorEntryInit(&pEntry->CEntry, pTextureData, crDpEntryCEntryReleaseCB);
    … …  
    153261    CrVrScrCompositorEntryInit(&pEntry->RootVrCEntry, pTextureData, NULL);
    154262    CrVrScrCompositorEntryFlagsSet(&pEntry->RootVrCEntry, CRBLT_F_INVERT_SRC_YCOORDS);
    155     pEntry->pvUserData1 = pvUserData1;
    156     pEntry->pvUserData2 = pvUserData2;
    157263}
    158264
    … …  
    174280}
    175281
    176 int CrDemInit(PCR_DISPLAY_ENTRY_MAP pMap)
    177 {
    178     pMap->pTextureMap = crAllocHashtable();
    179     if (pMap->pTextureMap)
    180         return VINF_SUCCESS;
    181 
    182     crWarning("crAllocHashtable failed!");
    183     return VERR_NO_MEMORY;
    184 }
    185 
    186 void crDemEntryRelease(PCR_DISPLAY_ENTRY_MAP pMap, PCR_DISPLAY_ENTRY pEntry, bool fForceDelete)
    187 {
    188     CRTextureObj *pTobj = (CRTextureObj *)pEntry->pvUserData2;
    189     if (!pTobj)
    190     {
    191         crWarning("Trying to release entry that does not have tobj specified");
    192         return;
    193     }
    194 
    195     CR_STATE_SHAREDOBJ_USAGE_CLEAR(pTobj, cr_server.MainContextInfo.pContext);
    196 
    197     bool fDeleteEntry = fForceDelete;
    198     GLuint idTexture = pTobj->id;
     282typedef struct CR_DEM_ENTRY_INFO
     283{
     284    CRTextureObj *pTobj;
     285    uint32_t cEntries;
     286} CR_DEM_ENTRY_INFO;
     287
     288typedef struct CR_DEM_ENTRY
     289{
     290    CR_DISPLAY_ENTRY Entry;
     291    CR_DEM_ENTRY_INFO *pInfo;
     292    CR_DISPLAY_ENTRY_MAP *pMap;
     293} CR_DEM_ENTRY;
     294
     295#define PCR_DEM_ENTRY_FROM_ENTRY(_pEntry) ((CR_DEM_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_DEM_ENTRY, Entry)))
     296
     297static RTMEMCACHE g_VBoxCrDemLookasideList;
     298static RTMEMCACHE g_VBoxCrDemInfoLookasideList;
     299
     300int CrDemGlobalInit()
     301{
     302    int rc = RTMemCacheCreate(&g_VBoxCrDemLookasideList, sizeof (CR_DEM_ENTRY),
     303                            0, /* size_t cbAlignment */
     304                            UINT32_MAX, /* uint32_t cMaxObjects */
     305                            NULL, /* PFNMEMCACHECTOR pfnCtor*/
     306                            NULL, /* PFNMEMCACHEDTOR pfnDtor*/
     307                            NULL, /* void *pvUser*/
     308                            0 /* uint32_t fFlags*/
     309                            );
     310    if (RT_SUCCESS(rc))
     311    {
     312        rc = RTMemCacheCreate(&g_VBoxCrDemInfoLookasideList, sizeof (CR_DEM_ENTRY_INFO),
     313                                    0, /* size_t cbAlignment */
     314                                    UINT32_MAX, /* uint32_t cMaxObjects */
     315                                    NULL, /* PFNMEMCACHECTOR pfnCtor*/
     316                                    NULL, /* PFNMEMCACHEDTOR pfnDtor*/
     317                                    NULL, /* void *pvUser*/
     318                                    0 /* uint32_t fFlags*/
     319                                    );
     320        if (RT_SUCCESS(rc))
     321            return VINF_SUCCESS;
     322        else
     323            crWarning("RTMemCacheCreate failed rc %d", rc);
     324
     325        RTMemCacheDestroy(g_VBoxCrDemLookasideList);
     326    }
     327    else
     328        crWarning("RTMemCacheCreate failed rc %d", rc);
     329    return VINF_SUCCESS;
     330}
     331
     332void CrDemTeGlobalTerm()
     333{
     334    RTMemCacheDestroy(g_VBoxCrDemLookasideList);
     335    RTMemCacheDestroy(g_VBoxCrDemInfoLookasideList);
     336}
     337
     338static CR_DEM_ENTRY* crDemEntryAlloc()
     339{
     340    return (CR_DEM_ENTRY*)RTMemCacheAlloc(g_VBoxCrDemLookasideList);
     341}
     342
     343static CR_DEM_ENTRY_INFO* crDemEntryInfoAlloc()
     344{
     345    return (CR_DEM_ENTRY_INFO*)RTMemCacheAlloc(g_VBoxCrDemInfoLookasideList);
     346}
     347
     348static void crDemEntryFree(CR_DEM_ENTRY* pDemEntry)
     349{
     350    RTMemCacheFree(g_VBoxCrDemLookasideList, pDemEntry);
     351}
     352
     353static void crDemEntryInfoFree(CR_DEM_ENTRY_INFO* pDemEntryInfo)
     354{
     355    RTMemCacheFree(g_VBoxCrDemInfoLookasideList, pDemEntryInfo);
     356}
     357
     358void crDemEntryRelease(PCR_DISPLAY_ENTRY_MAP pMap, CR_DEM_ENTRY *pDemEntry)
     359{
     360    CR_DEM_ENTRY_INFO *pInfo = pDemEntry->pInfo;
     361    CRTextureObj *pTobj = pInfo->pTobj;
     362
     363    --pInfo->cEntries;
     364
     365    if (!pInfo->cEntries)
     366    {
     367        CR_STATE_SHAREDOBJ_USAGE_CLEAR(pInfo->pTobj, cr_server.MainContextInfo.pContext);
     368
     369        crHashtableDelete(pMap->pTexIdToDemInfoMap, pTobj->id, NULL);
     370
     371        crDemEntryInfoFree(pInfo);
     372    }
    199373
    200374    if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pTobj))
    … …  
    205379        /* on the host side, we need to delete an ogl texture object here as well, which crStateDeleteTextureCallback will do
    206380         * in addition to calling crStateDeleteTextureObject to delete a state object */
    207         crHashtableDelete(pShared->textureTable, idTexture, crStateDeleteTextureCallback);
     381        crHashtableDelete(pShared->textureTable, pTobj->id, crStateDeleteTextureCallback);
    208382
    209383        crStateGlobalSharedRelease();
    210 
    211         fDeleteEntry = true;
    212     }
    213     else
    214     {
    215         /* this is something we would not generally expect */
    216         CRASSERT(!fForceDelete);
    217     }
    218 
    219     if (fDeleteEntry)
    220     {
    221         if (pMap)
    222             crHashtableDelete(pMap->pTextureMap, idTexture, crFree);
    223         else
    224             crFree(pEntry); /* <- when called from crDemTermEntryCb */
    225 
    226         crStateGlobalSharedRelease();
    227     }
    228 }
    229 
    230 void crDemTermEntryCb(void *pvEntry)
    231 {
    232     crDemEntryRelease(NULL, (PCR_DISPLAY_ENTRY)pvEntry, true);
     384    }
     385
     386    crDemEntryFree(pDemEntry);
     387
     388    crStateGlobalSharedRelease();
     389}
     390
     391int CrDemInit(PCR_DISPLAY_ENTRY_MAP pMap)
     392{
     393    pMap->pTexIdToDemInfoMap = crAllocHashtable();
     394    if (pMap->pTexIdToDemInfoMap)
     395        return VINF_SUCCESS;
     396
     397    crWarning("crAllocHashtable failed");
     398    return VERR_NO_MEMORY;
    233399}
    234400
    235401void CrDemTerm(PCR_DISPLAY_ENTRY_MAP pMap)
    236402{
    237     crFreeHashtable(pMap->pTextureMap, crDemTermEntryCb);
     403    crFreeHashtable(pMap->pTexIdToDemInfoMap, NULL);
     404    pMap->pTexIdToDemInfoMap = NULL;
    238405}
    239406
    240407void CrDemEntryRelease(PCR_DISPLAY_ENTRY pEntry)
    241408{
    242     PCR_DISPLAY_ENTRY_MAP pMap = (PCR_DISPLAY_ENTRY_MAP)pEntry->pvUserData1;
    243     Assert(pMap);
    244     crDemEntryRelease(pMap, pEntry, false);
     409    CR_DEM_ENTRY *pDemEntry = PCR_DEM_ENTRY_FROM_ENTRY(pEntry);
     410    crDemEntryRelease(pDemEntry->pMap, pDemEntry);
     411}
     412
     413int CrDemEntrySaveState(PCR_DISPLAY_ENTRY pEntry, PSSMHANDLE pSSM)
     414{
     415    CR_DEM_ENTRY *pDemEntry = PCR_DEM_ENTRY_FROM_ENTRY(pEntry);
     416    int  rc = SSMR3PutU32(pSSM, pDemEntry->pInfo->pTobj->id);
     417    AssertRCReturn(rc, rc);
     418    return rc;
     419}
     420
     421int CrDemEntryLoadState(PCR_DISPLAY_ENTRY_MAP pMap, PCR_DISPLAY_ENTRY *ppEntry, PSSMHANDLE pSSM)
     422{
     423    uint32_t u32;
     424    int  rc = SSMR3GetU32(pSSM, &u32);
     425    AssertRCReturn(rc, rc);
     426
     427    PCR_DISPLAY_ENTRY pEntry = CrDemEntryAcquire(pMap, u32);
     428    if (!pEntry)
     429    {
     430        crWarning("CrDemEntryAcquire failed");
     431        return VERR_NO_MEMORY;
     432    }
     433
     434    *ppEntry = pEntry;
     435    return VINF_SUCCESS;
    245436}
    246437
    247438PCR_DISPLAY_ENTRY CrDemEntryAcquire(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture)
    248439{
    249     PCR_DISPLAY_ENTRY pEntry = (PCR_DISPLAY_ENTRY)crHashtableSearch(pMap->pTextureMap, idTexture);
    250     if (pEntry)
    251         return pEntry;
     440    CR_DEM_ENTRY *pDemEntry = NULL;
    252441
    253442    CRSharedState *pShared = crStateGlobalSharedAcquire();
    … …  
    282471    TextureData.hwid = hwId;
    283472
    284     pEntry = (PCR_DISPLAY_ENTRY)crAlloc(sizeof (*pEntry));
    285     if (!pEntry)
    286     {
    287         crWarning("crAlloc failed allocating CR_DISPLAY_ENTRY");
     473    pDemEntry = crDemEntryAlloc();
     474    if (!pDemEntry)
     475    {
     476        crWarning("crDemEntryAlloc failed allocating CR_DEM_ENTRY");
    288477        crStateGlobalSharedRelease();
    289478        return NULL;
    290479    }
    291480
    292     CrDpEntryInit(pEntry, &TextureData, pMap, pTobj);
     481    CrDpEntryInit(&pDemEntry->Entry, &TextureData);
     482
     483    CR_DEM_ENTRY_INFO *pInfo = (CR_DEM_ENTRY_INFO*)crHashtableSearch(pMap->pTexIdToDemInfoMap, pTobj->id);
     484    if (!pInfo)
     485    {
     486        pInfo = crDemEntryInfoAlloc();
     487        CRASSERT(pInfo);
     488        crHashtableAdd(pMap->pTexIdToDemInfoMap, pTobj->id, pInfo);
     489        pInfo->cEntries = 0;
     490        pInfo->pTobj = pTobj;
     491    }
     492
     493    ++pInfo->cEntries;
     494    pDemEntry->pInfo = pInfo;
     495    pDemEntry->pMap = pMap;
    293496
    294497    /* just use main context info's context to hold the texture reference */
    295498    CR_STATE_SHAREDOBJ_USAGE_SET(pTobj, cr_server.MainContextInfo.pContext);
    296499
    297     crHashtableAdd(pMap->pTextureMap, idTexture, pEntry);
    298     return pEntry;
    299 
    300 }
    301 #if 0
    302 void CrDemEntryDestroy(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture)
    303 {
    304 #ifdef DEBUG
    305     {
    306         PCR_DISPLAY_ENTRY pEntry = (PCR_DISPLAY_ENTRY)crHashtableSearch(pMap->pTextureMap, idTexture);
    307         if (!pEntry)
    308         {
    309             crWarning("request to delete inexistent entry");
    310             return;
    311         }
    312 
    313         Assert(!CrDpEntryIsUsed(pEntry));
    314     }
    315 #endif
    316     crHashtableDelete(pMap->pTextureMap, idTexture, crFree);
    317 }
    318 #endif
     500    return &pDemEntry->Entry;
     501}
     502
    319503PCR_DISPLAY crServerDisplayGetInitialized(uint32_t idScreen)
    320504{
    … …  
    352536}
    353537
     538int crServerDisplaySaveState(PSSMHANDLE pSSM)
     539{
     540    int rc;
     541    int cDisplays = 0, i;
     542    for (i = 0; i < cr_server.screenCount; ++i)
     543    {
     544        if (ASMBitTest(cr_server.DisplaysInitMap, i) && !CrDpIsEmpty(&cr_server.aDispplays[i]))
     545            ++cDisplays;
     546    }
     547
     548    rc = SSMR3PutS32(pSSM, cDisplays);
     549    AssertRCReturn(rc, rc);
     550
     551    for (i = 0; i < cr_server.screenCount; ++i)
     552    {
     553        if (ASMBitTest(cr_server.DisplaysInitMap, i) && !CrDpIsEmpty(&cr_server.aDispplays[i]))
     554        {
     555            rc = SSMR3PutS32(pSSM, i);
     556            AssertRCReturn(rc, rc);
     557
     558            rc = CrDpSaveState(&cr_server.aDispplays[i], pSSM);
     559            AssertRCReturn(rc, rc);
     560        }
     561    }
     562
     563    return VINF_SUCCESS;
     564}
     565
     566int crServerDisplayLoadState(PSSMHANDLE pSSM, uint32_t u32Version)
     567{
     568    int rc;
     569    int s32, i;
     570
     571    rc = SSMR3GetS32(pSSM, &s32);
     572    AssertRCReturn(rc, rc);
     573
     574    for (i = 0; i < s32; ++i)
     575    {
     576        int iScreen;
     577
     578        rc = SSMR3GetS32(pSSM, &iScreen);
     579        AssertRCReturn(rc, rc);
     580
     581        PCR_DISPLAY pDisplay = crServerDisplayGet((uint32_t)iScreen);
     582        if (!pDisplay)
     583        {
     584            crWarning("crServerDisplayGet failed");
     585            return VERR_GENERAL_FAILURE;
     586        }
     587
     588        rc = CrDpLoadState(pDisplay, pSSM, u32Version);
     589        AssertRCReturn(rc, rc);
     590    }
     591
     592    return VINF_SUCCESS;
     593}
     594
    354595void crServerDisplayTermAll()
    355596{

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

    r47529 r47566  
    492492}
    493493
    494 #define CR_DENTRY_FROM_CENTRY(_pCentry) ((CR_DISPLAY_ENTRY*)((uint8_t*)(_pCentry) - RT_OFFSETOF(CR_DISPLAY_ENTRY, CEntry)))
    495 
    496494static DECLCALLBACK(VBOXVR_SCR_COMPOSITOR_ENTRY*) crServerMuralGetRootVrCEntry(VBOXVR_SCR_COMPOSITOR_ENTRY*pEntry, void *pvContext)
    497495{
    … …  
    706704            if (mural->fRootVrOn)
    707705            {
    708                 uint32_t cRects;
    709                 const RTRECT *pRects;
    710706                int rc = crServerMuralSynchRootVr(mural);
    711707                if (RT_SUCCESS(rc))
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