VirtualBox

Changeset 47566 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Aug 6, 2013 10:20:23 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
87766
Message:

crOpenGL/wddm: TexPresent fixes, irq handling fix

Location:
trunk/src/VBox
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCr.cpp

    r47070 r47566  
    893893    }
    894894
    895 #if 1 //ndef DEBUG_misha
     895#ifndef DEBUG_misha
    896896    /* zero it up temporary to avoid new code activation */
    897897    g_VBoxMpCrHostCaps = 0;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

    r47059 r47566  
    242242}
    243243
    244 PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc)
     244PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOCATION *pAlloc)
    245245{
    246246    return vboxWddmSwapchainRetainByAllocData(pDevExt, &pAlloc->AllocData);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h

    r47059 r47566  
    7474BOOLEAN vboxWddmSwapchainRetain(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SWAPCHAIN pSwapchain);
    7575VOID vboxWddmSwapchainRelease(PVBOXWDDM_SWAPCHAIN pSwapchain);
    76 PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc);
     76PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOCATION *pAlloc);
    7777PVBOXWDDM_SWAPCHAIN vboxWddmSwapchainRetainByAllocData(PVBOXMP_DEVEXT pDevExt, const struct VBOXWDDM_ALLOC_DATA *pAllocData);
    7878VOID vboxWddmSwapchainAllocRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SWAPCHAIN pSwapchain, PVBOXWDDM_ALLOCATION pAlloc);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

    r47151 r47566  
    992992        VBOXMP_CRPACKER *pCrPacker,
    993993        uint32_t u32CrConClientID,
    994         const VBOXWDDM_ALLOC_DATA *pSrcAllocData,
    995         const VBOXWDDM_ALLOC_DATA *pDstAllocData,
     994        const VBOXWDDM_ALLOCATION *pSrcAlloc,
     995        const VBOXWDDM_ALLOCATION *pDstAlloc,
    996996        const RECT *pSrcRect, const VBOXVDMAPIPE_RECTS *pDstRects)
    997997{
    998     D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = pDstAllocData->SurfDesc.VidPnSourceId;
     998    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = pDstAlloc->AllocData.SurfDesc.VidPnSourceId;
    999999    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[srcId];
    10001000    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    10031003    {
    10041004        /* we care only about screen regions */
    1005         if (pDstAllocData != &pSource->pPrimaryAllocation->AllocData)
     1005        if (pDstAlloc != pSource->pPrimaryAllocation)
    10061006        {
    10071007            WARN(("non-primary allocation passed to vboxWddmSubmitBltCmd!"));
    … …  
    10091009        }
    10101010
    1011         uint32_t hostID = pSrcAllocData->hostID;
     1011        uint32_t hostID = pSrcAlloc->AllocData.hostID;
    10121012        int rc;
    10131013        if (hostID)
    … …  
    10291029                WARN(("vboxVdmaTexPresentSubmit failed Status 0x%x", Status));
    10301030        }
    1031         else if (&pSource->pPrimaryAllocation->AllocData == pDstAllocData)
     1031        else if (pSource->pPrimaryAllocation == pDstAlloc)
    10321032        {
    10331033            bool fChanged = false;
    … …  
    10491049                                if (Rect.xLeft == 0
    10501050                                        && Rect.yTop == 0
    1051                                         && Rect.xRight == pDstAllocData->SurfDesc.width
    1052                                         && Rect.yBottom == pDstAllocData->SurfDesc.height)
     1051                                        && Rect.xRight == pDstAlloc->AllocData.SurfDesc.width
     1052                                        && Rect.yBottom == pDstAlloc->AllocData.SurfDesc.height)
    10531053                                {
    10541054                                    pSource->fHas3DVrs = FALSE;
    … …  
    10721072    else
    10731073    {
    1074         PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAllocData(pDevExt, pSrcAllocData);
     1074        PVBOXWDDM_SWAPCHAIN pSwapchain = vboxWddmSwapchainRetainByAlloc(pDevExt, pSrcAlloc);
    10751075
    10761076        if (pSwapchain)
    10771077        {
    1078             Assert(pSrcAllocData->SurfDesc.width == pSwapchain->width);
    1079             Assert(pSrcAllocData->SurfDesc.height == pSwapchain->height);
     1078            Assert(pSrcAlloc->AllocData.SurfDesc.width == pSwapchain->width);
     1079            Assert(pSrcAlloc->AllocData.SurfDesc.height == pSwapchain->height);
    10801080        }
    10811081
    … …  
    10911091}
    10921092
    1093 NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
     1093NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc)
    10941094{
    10951095    VBOXMP_CRPACKER CrPacker;
    … …  
    11071107    Rect.left = 0;
    11081108    Rect.top = 0;
    1109     Rect.right = pAllocData->SurfDesc.width;
    1110     Rect.bottom = pAllocData->SurfDesc.height;
     1109    Rect.right = pRealFbAlloc->AllocData.SurfDesc.width;
     1110    Rect.bottom = pRealFbAlloc->AllocData.SurfDesc.height;
    11111111
    11121112    VBOXVDMAPIPE_RECTS RectInfo;
    … …  
    11161116
    11171117    return vboxVdmaProcessVReg(pDevExt, &CrPacker, u32CrConClientID,
    1118             pAllocData, pAllocData,
     1118            pRealFbAlloc, pRealFbAlloc,
    11191119            &Rect, &RectInfo);
    11201120}
    … …  
    11261126{
    11271127    return vboxVdmaProcessVReg(pDevExt, &pContext->CrPacker, pContext->u32CrConClientID,
    1128             &pSrcAllocInfo->pAlloc->AllocData, &pDstAllocInfo->pAlloc->AllocData,
     1128            pSrcAllocInfo->pAlloc, pDstAllocInfo->pAlloc,
    11291129            pSrcRect, pDstRects);
    11301130}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h

    r47063 r47566  
    334334NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF);
    335335
    336 NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData);
     336NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc);
    337337
    338338#endif /* #ifndef ___VBoxMPVdma_h___ */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r47151 r47566  
    270270}
    271271
    272 NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos)
     272NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos)
    273273{
    274274    NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
    … …  
    283283                if (pDevExt->f3DEnabled)
    284284                {
    285                     Status = vboxVdmaTexPresentSetAlloc(pDevExt, pAllocData);
     285                    Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
    286286                    if (NT_SUCCESS(Status))
    287287                        return STATUS_SUCCESS;
    … …  
    311311    char fGhSynced = 1;
    312312    PVBOXWDDM_ALLOCATION pFbAlloc = VBOXWDDM_FB_ALLOCATION(pDevExt, pSource);
     313    PVBOXWDDM_ALLOCATION pRealFbAlloc = pSource->pPrimaryAllocation;
    313314#ifdef VBOXWDDM_RENDER_FROM_SHADOW
    314315# ifdef VBOX_WDDM_WIN8
    … …  
    339340    Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.SegmentId == pSource->AllocData.Addr.SegmentId);
    340341
    341     NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos);
     342    NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos);
    342343    if (NT_SUCCESS(Status))
    343344        pSource->fGhSynced = fGhSynced;
    … …  
    14281429        uint32_t flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
    14291430        bOur = (flags & HGSMIHOSTFLAGS_IRQ);
     1431
     1432        if (bOur)
     1433            VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
     1434
    14301435        do
    14311436        {
    … …  
    15591564            }
    15601565
    1561             VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pDevExt)->hostCtx);
    15621566#if 0 //def DEBUG_misha
    15631567            /* this is not entirely correct since host may concurrently complete some commands and raise a new IRQ while we are here,

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

    r47485 r47566  
    209209    VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;
    210210    VBOXVR_SCR_COMPOSITOR_ENTRY RootVrCEntry;
    211     void *pvUserData1;
    212     void *pvUserData2;
    213211} CR_DISPLAY_ENTRY, *PCR_DISPLAY_ENTRY;
    214212/**/
    … …  
    349347/* DISPLAY */
    350348
     349#define CR_DENTRY_FROM_CENTRY(_pCentry) ((CR_DISPLAY_ENTRY*)((uint8_t*)(_pCentry) - RT_OFFSETOF(CR_DISPLAY_ENTRY, CEntry)))
     350
     351
    351352/* @todo:
    352353 * 1. use compositor stored inside mural to use current MuralFBO and window-related API
    … …  
    359360} CR_DISPLAY, *PCR_DISPLAY;
    360361
    361 int CrDpInit(PCR_DISPLAY pDisplay);
    362 void CrDpTerm(PCR_DISPLAY pDisplay);
    363 void CrDpResize(PCR_DISPLAY pDisplay, int32_t xPos, int32_t yPos, uint32_t width, uint32_t height);
    364 void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData, void *pvUserData);
    365 void CrDpEntryCleanup(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry);
    366 int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
    367 int CrDpEntryRegionsAdd(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
    368 void CrDpEntryRegionsClear(PCR_DISPLAY pDisplay);
    369 DECLINLINE(bool) CrDpEntryIsUsed(PCR_DISPLAY_ENTRY pEntry)
    370 {
    371     return CrVrScrCompositorEntryIsInList(&pEntry->CEntry);
    372 }
    373 
    374 DECLINLINE(CRMuralInfo*) CrDpGetMural(PCR_DISPLAY pDisplay)
    375 {
    376     return &pDisplay->Mural;
    377 }
    378362
    379363typedef struct CR_DISPLAY_ENTRY_MAP
    380364{
    381     CRHashTable * pTextureMap;
     365    CRHashTable * pTexIdToDemInfoMap;
    382366} CR_DISPLAY_ENTRY_MAP, *PCR_DISPLAY_ENTRY_MAP;
    383367
    384 int CrDemInit(PCR_DISPLAY_ENTRY_MAP pMap);
    385 void CrDemTerm(PCR_DISPLAY_ENTRY_MAP pMap);
    386 PCR_DISPLAY_ENTRY CrDemEntryAcquire(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture);
    387 void CrDemEntryRelease(PCR_DISPLAY_ENTRY pEntry);
    388 //void CrDemEntryDestroy(PCR_DISPLAY_ENTRY_MAP pMap, GLuint idTexture);
    389368
    390369/* */

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

    r47116 r47566  
    3737/* dummy windows and contexts have 0 external IDs, so never get stored to the state */
    3838#define SHCROGL_SSM_VERSION_WITH_FIXED_DUMMYIDS                     39
    39 #define SHCROGL_SSM_VERSION                                         39
     39#define SHCROGL_SSM_VERSION_WITH_SCREEN_INFO                        40
     40#define SHCROGL_SSM_VERSION                                         40
    4041
    4142/* These define the Chromium release number.

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

    r46966 r47566  
    400400VBOXVREGDECL(int) CrVrScrCompositorEntryRemove(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
    401401VBOXVREGDECL(void) CrVrScrCompositorEntryFlagsSet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t fFlags);
    402 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
     402VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry);
     403DECLINLINE(uint32_t) CrVrScrCompositorEntryFlagsGet(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
     404{
     405    return pEntry->fFlags;
     406}
     407
    403408VBOXVREGDECL(void) CrVrScrCompositorInit(PVBOXVR_SCR_COMPOSITOR pCompositor);
    404409VBOXVREGDECL(void) CrVrScrCompositorClear(PVBOXVR_SCR_COMPOSITOR pCompositor);

  • trunk/src/VBox/GuestHost/OpenGL/util/vreg.cpp

    r46966 r47566  
    17491749    Assert(cRects);
    17501750    Assert(cRects <= pData->cRects);
    1751     int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstRects);
     1751    int rc = VBoxVrListRectsGet(&pCEntry->Vr, cRects, pEntry->paDstUnstretchedRects);
    17521752    AssertRC(rc);
    17531753
    1754     memcpy(pEntry->paDstUnstretchedRects, pEntry->paDstRects, cRects * sizeof (*pEntry->paDstUnstretchedRects));
    1755 
    17561754    if (!pEntry->Pos.x && !pEntry->Pos.y)
    17571755    {
    1758         memcpy(pEntry->paSrcRects, pEntry->paDstRects, cRects * sizeof (*pEntry->paSrcRects));
     1756        memcpy(pEntry->paSrcRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paSrcRects));
    17591757    }
    17601758    else
    … …  
    17621760        for (uint32_t i = 0; i < cRects; ++i)
    17631761        {
    1764             pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstRects[i].xLeft - pEntry->Pos.x));
    1765             pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstRects[i].yTop - pEntry->Pos.y));
    1766             pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstRects[i].xRight - pEntry->Pos.x));
    1767             pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstRects[i].yBottom - pEntry->Pos.y));
     1762            pEntry->paSrcRects[i].xLeft = (int32_t)((pEntry->paDstUnstretchedRects[i].xLeft - pEntry->Pos.x));
     1763            pEntry->paSrcRects[i].yTop = (int32_t)((pEntry->paDstUnstretchedRects[i].yTop - pEntry->Pos.y));
     1764            pEntry->paSrcRects[i].xRight = (int32_t)((pEntry->paDstUnstretchedRects[i].xRight - pEntry->Pos.x));
     1765            pEntry->paSrcRects[i].yBottom = (int32_t)((pEntry->paDstUnstretchedRects[i].yBottom - pEntry->Pos.y));
    17681766        }
    17691767    }
    … …  
    17761774            if (pCompositor->StretchX != 1.)
    17771775            {
    1778                 pEntry->paDstRects[i].xLeft = (int32_t)(pEntry->paDstRects[i].xLeft * pCompositor->StretchX);
    1779                 pEntry->paDstRects[i].xRight = (int32_t)(pEntry->paDstRects[i].xRight * pCompositor->StretchX);
     1776                pEntry->paDstRects[i].xLeft = (int32_t)(pEntry->paDstUnstretchedRects[i].xLeft * pCompositor->StretchX);
     1777                pEntry->paDstRects[i].xRight = (int32_t)(pEntry->paDstUnstretchedRects[i].xRight * pCompositor->StretchX);
    17801778            }
    17811779            if (pCompositor->StretchY != 1.)
    17821780            {
    1783                 pEntry->paDstRects[i].yTop = (int32_t)(pEntry->paDstRects[i].yTop * pCompositor->StretchY);
    1784                 pEntry->paDstRects[i].yBottom = (int32_t)(pEntry->paDstRects[i].yBottom * pCompositor->StretchY);
    1785             }
    1786         }
    1787     }
    1788 
     1781                pEntry->paDstRects[i].yTop = (int32_t)(pEntry->paDstUnstretchedRects[i].yTop * pCompositor->StretchY);
     1782                pEntry->paDstRects[i].yBottom = (int32_t)(pEntry->paDstUnstretchedRects[i].yBottom * pCompositor->StretchY);
     1783            }
     1784        }
     1785    }
     1786    else
     1787#endif
     1788    {
     1789        memcpy(pEntry->paDstRects, pEntry->paDstUnstretchedRects, cRects * sizeof (*pEntry->paDstUnstretchedRects));
     1790    }
     1791
     1792#if 0//ndef IN_RING0
    17891793    bool canZeroX = (pCompositor->StretchX < 1.);
    17901794    bool canZeroY = (pCompositor->StretchY < 1.);
    … …  
    17951799        for (iOrig = 0, iNew = 0; iOrig < cRects; ++iOrig)
    17961800        {
    1797             PRTRECT pOrigRect = &pEntry->paSrcRects[iOrig];
    1798             if (pOrigRect->xLeft == pOrigRect->xRight
    1799                     || pOrigRect->yTop == pOrigRect->yBottom)
     1801            PRTRECT pOrigRect = &pEntry->paDstRects[iOrig];
     1802            if (pOrigRect->xLeft != pOrigRect->xRight
     1803                    && pOrigRect->yTop != pOrigRect->yBottom)
    18001804                continue;
    18011805
    … …  
    22942298}
    22952299
    2296 VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
     2300VBOXVREGDECL(uint32_t) CrVrScrCompositorEntryFlagsCombinedGet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
    22972301{
    22982302    return CRBLT_FOP_COMBINE(pCompositor->fFlags, pEntry->fFlags);

  • 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))

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

    r46885 r47566  
    669669        const RTRECT *paSrcRegions, *paDstRegions;
    670670        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
    671         uint32_t fFlags = CrVrScrCompositorEntryFlagsGet(pCompositor, pEntry);
     671        uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
    672672        if (RT_SUCCESS(rc))
    673673        {
    … …  
    700700        const RTRECT *paSrcRegions, *paDstRegions;
    701701        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
    702         uint32_t fFlags = CrVrScrCompositorEntryFlagsGet(pCompositor, pEntry);
     702        uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
    703703        if (RT_SUCCESS(rc))
    704704        {

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m

    r46885 r47566  
    12551255        const RTRECT *paSrcRegions, *paDstRegions;
    12561256        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
    1257         uint32_t fFlags = CrVrScrCompositorEntryFlagsGet(pCompositor, pEntry);
     1257        uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
    12581258        if (RT_SUCCESS(rc))
    12591259        {
    … …  
    13791379                const RTRECT *paSrcRegions, *paDstRegions;
    13801380                int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
    1381                 uint32_t fFlags = CrVrScrCompositorEntryFlagsGet(pCompositor, pEntry);
     1381                uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
    13821382                if (RT_SUCCESS(rc))
    13831383                {
Note: See TracChangeset for help on using the changeset viewer.

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