VirtualBox

Changeset 50628 in vbox


Ignore:
Timestamp:
Feb 27, 2014 12:39:15 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92510
Message:

wddm: misc bugfixes

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp

    r49449 r50628  
    267267{
    268268    HRESULT hr = S_OK;
    269     if (pData->cAllocationList && pData->cPatchLocationList && pData->cbCommandBuffer > 4)
     269    Assert(pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
     270    if (pData->cAllocationList && pData->cPatchLocationList && pData->cbCommandBuffer >= 4)
    270271    {
    271272        memset(pData->pAllocationList, 0, sizeof (D3DDDI_ALLOCATIONLIST));
    … …  
    294295}
    295296
    296 static BOOLEAN vboxWddmDalCheckRemove(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
    297 {
    298     BOOLEAN fRemoved = FALSE;
    299 
    300     if (pAlloc->DirtyAllocListEntry.pNext)
    301     {
    302         RTListNodeRemove(&pAlloc->DirtyAllocListEntry);
    303         pAlloc->fDirtyWrite = FALSE;
    304         fRemoved = TRUE;
    305     }
    306 
    307     return fRemoved;
    308 }
     297static VOID vboxWddmDalRemove(PVBOXWDDMDISP_ALLOCATION pAlloc)
     298{
     299    RTListNodeRemove(&pAlloc->DirtyAllocListEntry);
     300    pAlloc->fDirtyWrite = FALSE;
     301}
     302
     303#ifdef DEBUG_misha
     304typedef struct VBOXWDDM_DBG_ALLOC
     305{
     306    BOOLEAN fWrite;
     307    PVBOXWDDMDISP_ALLOCATION pAlloc;
     308} VBOXWDDM_DBG_ALLOC;
     309#endif
    309310
    310311static HRESULT vboxWddmDalNotifyChange(PVBOXWDDMDISP_DEVICE pDevice)
    … …  
    312313    VBOXWDDMDISP_NSCADD NscAdd;
    313314    BOOL bReinitRenderData = TRUE;
     315#ifdef DEBUG_misha
     316    uint32_t cDbgAllocs = 0;
     317    VBOXWDDM_DBG_ALLOC aDbgAllocs[128];
     318#endif
    314319
    315320    do
    … …  
    333338            NscAdd.cbCommandBuffer -= sizeof (*pHdr);
    334339            bReinitRenderData = FALSE;
     340
     341#ifdef DEBUG_misha
     342            {
     343                memset(aDbgAllocs, 0, sizeof (aDbgAllocs));
     344                PVBOXWDDMDISP_ALLOCATION pAlloc;
     345                uint32_t cAllocs = 0;
     346                RTListForEach(&pDevice->DirtyAllocList, pAlloc, VBOXWDDMDISP_ALLOCATION, DirtyAllocListEntry)
     347                {
     348                    Assert(pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
     349                    if (cAllocs < RT_ELEMENTS(aDbgAllocs))
     350                    {
     351                        aDbgAllocs[cAllocs].pAlloc = pAlloc;
     352                        aDbgAllocs[cAllocs].fWrite = pAlloc->fDirtyWrite;
     353                        ++cDbgAllocs;
     354                    }
     355                    ++cAllocs;
     356                }
     357            }
     358#endif
    335359        }
    336360
    … …  
    339363        {
    340364            HRESULT tmpHr = vboxWddmNSCAddAlloc(&NscAdd, pAlloc);
     365#ifdef DEBUG_misha
     366            Assert(tmpHr == S_OK);
     367#endif
    341368            Assert(tmpHr == S_OK || tmpHr == S_FALSE);
    342369            if (tmpHr == S_OK)
    343370            {
    344                 vboxWddmDalCheckRemove(pDevice, pAlloc);
     371                vboxWddmDalRemove(pAlloc);
    345372                continue;
    346373            }
    … …  
    385412}
    386413
    387 //#define VBOX_WDDM_SHRC_WO_NOTIFY
     414#ifdef VBOXWDDMDISP_DAL_CHECK_LOCK
     415static HRESULT vboxWddmDalCheckUnlock(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
     416{
     417    if (!pAlloc->fAllocLocked || pAlloc->LockInfo.cLocks)
     418        return S_OK;
     419
     420    Assert(pAlloc->hAllocation);
     421
     422    D3DDDICB_UNLOCK Unlock;
     423
     424    Unlock.NumAllocations = 1;
     425    Unlock.phAllocations = &pAlloc->hAllocation;
     426
     427    HRESULT hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &Unlock);
     428    if(hr != S_OK)
     429    {
     430        WARN(("pfnUnlockCb failed, hr %#x", hr));
     431    }
     432
     433    return hr;
     434}
     435
     436static HRESULT vboxWddmDalCheckLock(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_LOCKFLAGS Flags)
     437{
     438    if (!pAlloc->hAllocation || pAlloc->fAllocLocked)
     439        return S_OK;
     440
     441    HRESULT hr;
     442
     443    if (pAlloc->fDirtyWrite)
     444    {
     445        Assert(pAlloc->DirtyAllocListEntry.pNext);
     446        hr = vboxWddmDalNotifyChange(pDevice);
     447        if (hr == S_OK)
     448        {
     449            Assert(!pAlloc->DirtyAllocListEntry.pNext);
     450        }
     451        else
     452        {
     453            WARN(("vboxWddmDalNotifyChange failed %#x, ignoring", hr));
     454        }
     455    }
     456
     457    D3DDDICB_LOCK LockData;
     458    LockData.hAllocation = pAlloc->hAllocation;
     459    LockData.PrivateDriverData = 0;
     460    LockData.NumPages = 0;
     461    LockData.pPages = NULL;
     462    LockData.pData = NULL; /* out */
     463    LockData.Flags.Value = 0;
     464    LockData.Flags.Discard = Flags.Discard;
     465    LockData.Flags.DonotWait = Flags.DoNotWait;
     466
     467    hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
     468    if (hr == S_OK)
     469    {
     470        if (!Flags.ReadOnly)
     471            pAlloc->fEverWritten = TRUE;
     472        pAlloc->fAllocLocked = TRUE;
     473        return S_OK;
     474    }
     475
     476    WARN(("pfnLockCb failed %#x, Flags %#x", hr, Flags.Value));
     477
     478    return hr;
     479}
     480#endif
     481
     482static BOOLEAN vboxWddmDalCheckNotifyRemove(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
     483{
     484    if (pAlloc->DirtyAllocListEntry.pNext)
     485    {
     486        HRESULT hr = vboxWddmDalNotifyChange(pDevice);
     487        if (hr == S_OK)
     488        {
     489            Assert(!pAlloc->DirtyAllocListEntry.pNext);
     490        }
     491        else
     492        {
     493            WARN(("vboxWddmDalNotifyChange failed %#x", hr));
     494            if (pAlloc->DirtyAllocListEntry.pNext)
     495                vboxWddmDalRemove(pAlloc);
     496        }
     497
     498        return TRUE;
     499    }
     500
     501    return FALSE;
     502}
     503
    388504static BOOLEAN vboxWddmDalCheckAdd(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOLEAN fWrite)
    389505{
    390506    if (!pAlloc->hAllocation /* only shared resources matter */
    391 #ifdef VBOX_WDDM_SHRC_WO_NOTIFY
    392             || !fWrite /* only write op matter */
    393 #endif
     507            || (/*!fWrite &&*/ !pAlloc->hSharedHandle)
    394508            )
    395509    {
    396 #ifdef VBOX_WDDM_SHRC_WO_NOTIFY
    397         Assert(!pAlloc->DirtyAllocListEntry.pNext || (!fWrite && pAlloc->hSharedHandle && pAlloc->fDirtyWrite));
    398 #else
    399         Assert(!pAlloc->DirtyAllocListEntry.pNext);
    400 #endif
     510        Assert(!pAlloc->DirtyAllocListEntry.pNext || pAlloc->hSharedHandle /*|| pAlloc->fDirtyWrite*/);
     511
    401512        Assert(!pAlloc->hSharedHandle);
    402513
    403514        return FALSE;
    404515    }
     516
     517    Assert(fWrite || pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
    405518
    406519    if (!pAlloc->DirtyAllocListEntry.pNext)
    … …  
    409522        RTListAppend(&pDevice->DirtyAllocList, &pAlloc->DirtyAllocListEntry);
    410523    }
     524    else
     525    {
     526        Assert(pAlloc->fDirtyWrite == fWrite);
     527    }
    411528    pAlloc->fDirtyWrite |= fWrite;
     529    pAlloc->fEverWritten |= fWrite;
    412530
    413531    return TRUE;
    … …  
    425543}
    426544
    427 static VOID vboxWddmDalCheckAddRtsSamplers(PVBOXWDDMDISP_DEVICE pDevice)
     545static VOID vboxWddmDalCheckAddDepthStencil(PVBOXWDDMDISP_DEVICE pDevice)
     546{
     547    if (pDevice->pDepthStencilRc)
     548        vboxWddmDalCheckAddRc(pDevice, pDevice->pDepthStencilRc, TRUE);
     549}
     550
     551static VOID vboxWddmDalCheckAddRTs(PVBOXWDDMDISP_DEVICE pDevice)
    428552{
    429553    for (UINT i = 0; i < pDevice->cRTs; ++i)
    … …  
    434558        }
    435559    }
    436 
     560}
     561
     562static VOID vboxWddmDalCheckAddSamplers(PVBOXWDDMDISP_DEVICE pDevice)
     563{
    437564    for (UINT i = 0, iSampler = 0; iSampler < pDevice->cSamplerTextures; ++i)
    438565    {
    … …  
    442569        ++iSampler;
    443570    }
     571}
     572
     573static VOID vboxWddmDalCheckAddOnDraw(PVBOXWDDMDISP_DEVICE pDevice)
     574{
     575    vboxWddmDalCheckAddRTs(pDevice);
     576
     577    vboxWddmDalCheckAddDepthStencil(pDevice);
     578
     579    vboxWddmDalCheckAddSamplers(pDevice);
     580}
     581
     582static BOOLEAN vboxWddmDalIsEmpty(PVBOXWDDMDISP_DEVICE pDevice)
     583{
     584    return RTListIsEmpty(&pDevice->DirtyAllocList);
    444585}
    445586
    … …  
    25082649    }
    25092650
    2510     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2651    vboxWddmDalCheckAddOnDraw(pDevice);
    25112652
    25122653    VBOXVDBG_DUMP_DRAWPRIM_LEAVE(pDevice);
    … …  
    26392780    }
    26402781
    2641     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2782    vboxWddmDalCheckAddOnDraw(pDevice);
    26422783
    26432784    VBOXVDBG_DUMP_DRAWPRIM_LEAVE(pDevice);
    … …  
    26552796    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    26562797    Assert(0);
    2657     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2798    vboxWddmDalCheckAddOnDraw(pDevice);
    26582799    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    26592800    return E_FAIL;
    … …  
    26682809    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    26692810    Assert(0);
    2670     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2811    vboxWddmDalCheckAddOnDraw(pDevice);
    26712812    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    26722813    return E_FAIL;
    … …  
    27612902#endif
    27622903
    2763     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2904    vboxWddmDalCheckAddOnDraw(pDevice);
    27642905
    27652906    VBOXVDBG_DUMP_DRAWPRIM_LEAVE(pDevice);
    … …  
    28452986    }
    28462987
    2847     vboxWddmDalCheckAddRtsSamplers(pDevice);
     2988    vboxWddmDalCheckAddOnDraw(pDevice);
    28482989    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    28492990    return hr;
    … …  
    30353176            pData->FillDepth,
    30363177            pData->FillStencil);
    3037     Assert(hr == S_OK);
     3178    if (SUCCEEDED(hr))
     3179    {
     3180        if (pData->Flags & D3DCLEAR_TARGET)
     3181            vboxWddmDalCheckAddRTs(pDevice);
     3182        if ((pData->Flags & D3DCLEAR_STENCIL)
     3183                || (pData->Flags & D3DCLEAR_ZBUFFER))
     3184            vboxWddmDalCheckAddDepthStencil(pDevice);
     3185    }
     3186    else
     3187        WARN(("Clear failed %#x", hr));
     3188
    30383189    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    30393190    return hr;
    … …  
    32503401    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    32513402    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
    3252     Assert(pData->SubResourceIndex < pRc->cAllocations);
    32533403    if (pData->SubResourceIndex >= pRc->cAllocations)
    32543404        return E_INVALIDARG;
     3405    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3406    Assert(pData->SubResourceIndex < pRc->cAllocations);
    32553407
    32563408    HRESULT hr = S_OK;
    … …  
    32593411    {
    32603412//        Assert(pRc != pScreen->pRenderTargetRc || pScreen->iRenderTargetFrontBuf != pData->SubResourceIndex);
     3413#ifdef VBOXWDDMDISP_DAL_CHECK_LOCK
     3414        hr = vboxWddmDalCheckLock(pDevice, pAlloc, pData->Flags);
     3415        if (!SUCCEEDED(hr))
     3416        {
     3417            WARN(("vboxWddmDalCheckLock failed %#x", hr));
     3418            return hr;
     3419        }
     3420#endif
    32613421
    32623422        if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
    … …  
    32663426            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
    32673427            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3268             PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    32693428            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
    32703429            IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pTexAlloc->pD3DIf;
    … …  
    32823441            /* else - we lock the entire texture, pRect == NULL */
    32833442
    3284             if (pLockAlloc->LockInfo.cLocks)
    3285             {
    3286                 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
    3287                 if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
    3288                 {
    3289                     Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
    3290                     Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
    3291                     Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
    3292                     Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
    3293                 }
    3294                 Assert(pLockAlloc->LockInfo.LockedRect.pBits);
    3295                 Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
    3296 
    3297                 if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3443            if (pAlloc->LockInfo.cLocks)
     3444            {
     3445                Assert(pAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
     3446                if (pAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
     3447                {
     3448                    Assert(pAlloc->LockInfo.Area.left == pData->Area.left);
     3449                    Assert(pAlloc->LockInfo.Area.top == pData->Area.top);
     3450                    Assert(pAlloc->LockInfo.Area.right == pData->Area.right);
     3451                    Assert(pAlloc->LockInfo.Area.bottom == pData->Area.bottom);
     3452                }
     3453                Assert(pAlloc->LockInfo.LockedRect.pBits);
     3454                Assert((pAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3455
     3456                if (pAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
    32983457                {
    32993458                    switch (pTexAlloc->enmD3DIfType)
    … …  
    33253484                VBOXVDBG_CHECK_SMSYNC(pRc);
    33263485
    3327                 pLockAlloc->LockInfo.fFlags = pData->Flags;
     3486                pAlloc->LockInfo.fFlags = pData->Flags;
    33283487                if (pRect)
    33293488                {
    3330                     pLockAlloc->LockInfo.Area = *pRect;
    3331                     Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
     3489                    pAlloc->LockInfo.Area = *pRect;
     3490                    Assert(pAlloc->LockInfo.fFlags.AreaValid == 1);
    33323491                }
    33333492                else
    33343493                {
    3335                     Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
     3494                    Assert(pAlloc->LockInfo.fFlags.AreaValid == 0);
    33363495                }
    33373496
    … …  
    33403499                    case VBOXDISP_D3DIFTYPE_TEXTURE:
    33413500                        hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
    3342                                 &pLockAlloc->LockInfo.LockedRect,
     3501                                &pAlloc->LockInfo.LockedRect,
    33433502                                pRect,
    33443503                                vboxDDI2D3DLockFlags(pData->Flags));
    … …  
    33473506                        hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
    33483507                                VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex),
    3349                                 &pLockAlloc->LockInfo.LockedRect,
     3508                                &pAlloc->LockInfo.LockedRect,
    33503509                                pRect,
    33513510                                vboxDDI2D3DLockFlags(pData->Flags));
    33523511                        break;
    33533512                    case VBOXDISP_D3DIFTYPE_SURFACE:
    3354                         hr = pD3DIfSurface->LockRect(&pLockAlloc->LockInfo.LockedRect,
     3513                        hr = pD3DIfSurface->LockRect(&pAlloc->LockInfo.LockedRect,
    33553514                                pRect,
    33563515                                vboxDDI2D3DLockFlags(pData->Flags));
    … …  
    33693528            if (SUCCEEDED(hr))
    33703529            {
    3371                 ++pLockAlloc->LockInfo.cLocks;
     3530                ++pAlloc->LockInfo.cLocks;
    33723531
    33733532                if (!pData->Flags.NotifyOnly)
    33743533                {
    3375                     pData->pSurfData = pLockAlloc->LockInfo.LockedRect.pBits;
    3376                     pData->Pitch = pLockAlloc->LockInfo.LockedRect.Pitch;
     3534                    pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
     3535                    pData->Pitch = pAlloc->LockInfo.LockedRect.Pitch;
    33773536                    pData->SlicePitch = 0;
    3378                     Assert(pLockAlloc->SurfDesc.slicePitch == 0);
    3379                     Assert(!pLockAlloc->pvMem);
     3537                    Assert(pAlloc->SurfDesc.slicePitch == 0);
     3538                    Assert(!pAlloc->pvMem);
    33803539                }
    33813540                else
    33823541                {
    3383                     Assert(pLockAlloc->pvMem);
     3542                    Assert(pAlloc->pvMem);
    33843543                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
    33853544                }
    … …  
    33943553            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
    33953554            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3396             PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    33973555            IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
    33983556            Assert(pTexAlloc->pD3DIf);
    … …  
    34083566            /* else - we lock the entire texture, pBox == NULL */
    34093567
    3410             if (pLockAlloc->LockInfo.cLocks)
    3411             {
    3412                 Assert(pLockAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
    3413                 if (pLockAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
    3414                 {
    3415                     Assert(pLockAlloc->LockInfo.Box.Left == pData->Box.Left);
    3416                     Assert(pLockAlloc->LockInfo.Box.Top == pData->Box.Top);
    3417                     Assert(pLockAlloc->LockInfo.Box.Right == pData->Box.Right);
    3418                     Assert(pLockAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
    3419                     Assert(pLockAlloc->LockInfo.Box.Front == pData->Box.Front);
    3420                     Assert(pLockAlloc->LockInfo.Box.Back == pData->Box.Back);
    3421                 }
    3422                 Assert(pLockAlloc->LockInfo.LockedBox.pBits);
    3423                 Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
    3424 
    3425                 if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3568            if (pAlloc->LockInfo.cLocks)
     3569            {
     3570                Assert(pAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
     3571                if (pAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
     3572                {
     3573                    Assert(pAlloc->LockInfo.Box.Left == pData->Box.Left);
     3574                    Assert(pAlloc->LockInfo.Box.Top == pData->Box.Top);
     3575                    Assert(pAlloc->LockInfo.Box.Right == pData->Box.Right);
     3576                    Assert(pAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
     3577                    Assert(pAlloc->LockInfo.Box.Front == pData->Box.Front);
     3578                    Assert(pAlloc->LockInfo.Box.Back == pData->Box.Back);
     3579                }
     3580                Assert(pAlloc->LockInfo.LockedBox.pBits);
     3581                Assert((pAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3582
     3583                if (pAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
    34263584                {
    34273585                    hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
    … …  
    34383596                VBOXVDBG_CHECK_SMSYNC(pRc);
    34393597
    3440                 pLockAlloc->LockInfo.fFlags = pData->Flags;
     3598                pAlloc->LockInfo.fFlags = pData->Flags;
    34413599                if (pBox)
    34423600                {
    3443                     pLockAlloc->LockInfo.Box = *pBox;
    3444                     Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 1);
     3601                    pAlloc->LockInfo.Box = *pBox;
     3602                    Assert(pAlloc->LockInfo.fFlags.BoxValid == 1);
    34453603                }
    34463604                else
    34473605                {
    3448                     Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 0);
     3606                    Assert(pAlloc->LockInfo.fFlags.BoxValid == 0);
    34493607                }
    34503608
    34513609                hr = pD3DIfTex->LockBox(pData->SubResourceIndex,
    3452                                 &pLockAlloc->LockInfo.LockedBox,
     3610                                &pAlloc->LockInfo.LockedBox,
    34533611                                (D3DBOX*)pBox,
    34543612                                vboxDDI2D3DLockFlags(pData->Flags));
    … …  
    34613619            if (SUCCEEDED(hr))
    34623620            {
    3463                 ++pLockAlloc->LockInfo.cLocks;
     3621                ++pAlloc->LockInfo.cLocks;
    34643622
    34653623                if (!pData->Flags.NotifyOnly)
    34663624                {
    3467                     pData->pSurfData = pLockAlloc->LockInfo.LockedBox.pBits;
    3468                     pData->Pitch = pLockAlloc->LockInfo.LockedBox.RowPitch;
    3469                     pData->SlicePitch = pLockAlloc->LockInfo.LockedBox.SlicePitch;
    3470                     Assert(!pLockAlloc->pvMem);
     3625                    pData->pSurfData = pAlloc->LockInfo.LockedBox.pBits;
     3626                    pData->Pitch = pAlloc->LockInfo.LockedBox.RowPitch;
     3627                    pData->SlicePitch = pAlloc->LockInfo.LockedBox.SlicePitch;
     3628                    Assert(!pAlloc->pvMem);
    34713629                }
    34723630                else
    34733631                {
    3474                     Assert(pLockAlloc->pvMem);
     3632                    Assert(pAlloc->pvMem);
    34753633                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
    34763634                }
    … …  
    34843642        {
    34853643            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3486             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    34873644            IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
    34883645            BOOL bLocked = false;
    … …  
    35153672                    Assert(pAlloc->SurfDesc.pitch == pAlloc->SurfDesc.width);
    35163673                    pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.pitch;
    3517 //                    Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
     3674//                    Assert(pAlloc->LockInfo.fFlags.Value == 0);
    35183675                    pAlloc->LockInfo.fFlags = pData->Flags;
    35193676                    if (pRange)
    … …  
    35783735        {
    35793736            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3580             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    35813737            IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
    35823738            BOOL bLocked = false;
    … …  
    36093765                    Assert(pAlloc->SurfDesc.pitch == pAlloc->SurfDesc.width);
    36103766                    pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.pitch;
    3611 //                    Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
     3767//                    Assert(pAlloc->LockInfo.fFlags.Value == 0);
    36123768                    pAlloc->LockInfo.fFlags = pData->Flags;
    36133769                    if (pRange)
    … …  
    36713827        else
    36723828        {
    3673             Assert(0);
    3674         }
     3829            WARN(("not implemented %d", pRc->aAllocations[0].enmD3DIfType));
     3830        }
     3831
     3832#ifdef VBOXWDDMDISP_DAL_CHECK_LOCK
     3833        if (!SUCCEEDED(hr))
     3834        {
     3835            WARN(("lock failed %#x", hr));
     3836            vboxWddmDalCheckUnlock(pDevice, pAlloc);
     3837        }
     3838#endif
    36753839    }
    36763840    else /* if !VBOXDISPMODE_IS_3D(pDevice->pAdapter) */
    36773841    {
    3678         PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    36793842        if (pAlloc->hAllocation)
    36803843        {
    … …  
    37733936        return E_INVALIDARG;
    37743937
     3938    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3939
    37753940    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
    37763941    {
    … …  
    37803945        {
    37813946            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3782             PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    37833947
    37843948            VBOXVDBG_DUMP_UNLOCK_ST(pData);
    37853949
    3786             --pLockAlloc->LockInfo.cLocks;
    3787             Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
    3788             if (!pLockAlloc->LockInfo.cLocks)
     3950            --pAlloc->LockInfo.cLocks;
     3951            Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
     3952            if (!pAlloc->LockInfo.cLocks)
    37893953            {
    37903954                PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
    … …  
    38233987        {
    38243988            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3825             PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    38263989
    38273990            VBOXVDBG_DUMP_UNLOCK_ST(pData);
    38283991
    3829             --pLockAlloc->LockInfo.cLocks;
    3830             Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
    3831             if (!pLockAlloc->LockInfo.cLocks)
     3992            --pAlloc->LockInfo.cLocks;
     3993            Assert(pAlloc->LockInfo.cLocks < UINT32_MAX);
     3994            if (!pAlloc->LockInfo.cLocks)
    38323995            {
    38333996                PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
    … …  
    38434006        {
    38444007            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3845             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    38464008
    38474009            --pAlloc->LockInfo.cLocks;
    … …  
    38844046        {
    38854047            Assert(pData->SubResourceIndex < pRc->cAllocations);
    3886             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    38874048
    38884049            --pAlloc->LockInfo.cLocks;
    … …  
    39244085        else
    39254086        {
    3926             Assert(0);
    3927         }
     4087            WARN(("Unlock unsupported %d", pRc->aAllocations[0].enmD3DIfType));
     4088        }
     4089
     4090#ifdef VBOXWDDMDISP_DAL_CHECK_LOCK
     4091        if (SUCCEEDED(hr))
     4092        {
     4093            hr = vboxWddmDalCheckUnlock(pDevice, pAlloc);
     4094            if (!SUCCEEDED(hr))
     4095                WARN(("vboxWddmDalCheckUnlock failed %#x", hr));
     4096        }
     4097        else
     4098            WARN(("unlock failed %#x", hr));
     4099#endif
    39284100    }
    39294101    else
    39304102    {
    3931         PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    3932 
    39334103        if (pAlloc->hAllocation)
    39344104        {
    … …  
    39754145            if (fDoUnlock)
    39764146            {
    3977                 struct
    3978                 {
    3979                     D3DDDICB_UNLOCK Unlock;
    3980                     D3DKMT_HANDLE hAllocation;
    3981                 } UnlockData;
    3982 
    3983 
    3984                 UnlockData.Unlock.NumAllocations = 1;
    3985                 UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
    3986                 UnlockData.hAllocation = pAlloc->hAllocation;
    3987 
    3988                 hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &UnlockData.Unlock);
     4147                D3DDDICB_UNLOCK Unlock;
     4148
     4149                Unlock.NumAllocations = 1;
     4150                Unlock.phAllocations = &pAlloc->hAllocation;
     4151
     4152                hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &Unlock);
    39894153                if(hr != S_OK)
    39904154                {
    … …  
    44174581            }
    44184582
    4419             vboxWddmDalCheckRemove(pDevice, pAlloc);
     4583            vboxWddmDalCheckNotifyRemove(pDevice, pAlloc);
    44204584        }
    44214585    }
    … …  
    44974661    PVBOXWDDMDISP_RESOURCE pSrcRc = NULL, pDstRc = NULL;
    44984662    PVBOXWDDMDISP_ALLOCATION pSrcAlloc = NULL, pDstAlloc = NULL;
     4663
     4664    Assert(vboxWddmDalIsEmpty(pDevice));
    44994665
    45004666    if (pData->hSrcResource)
    … …  
    51535319        hr = pDevice9If->SetDepthStencilSurface(pD3D9Surf);
    51545320        if (SUCCEEDED(hr))
     5321        {
     5322            pDevice->pDepthStencilRc = pRc;
    51555323            hr = S_OK;
     5324        }
    51565325        else
    51575326            WARN(("VBoxD3DIfSurfGet failed, hr (0x%x)",hr));

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h

    r49180 r50628  
    212212    struct VBOXWDDMDISP_RESOURCE *aSamplerTextures[VBOXWDDMDISP_TOTAL_SAMPLERS];
    213213
     214    struct VBOXWDDMDISP_RESOURCE *pDepthStencilRc;
     215
    214216    HMODULE hHgsmiTransportModule;
    215217
    … …  
    270272    /* list entry used to add allocation to the dirty alloc list */
    271273    RTLISTNODE DirtyAllocListEntry;
     274    BOOLEAN fEverWritten;
    272275    BOOLEAN fDirtyWrite;
     276    BOOLEAN fAllocLocked;
    273277    HANDLE hSharedHandle;
    274278    VBOXWDDMDISP_LOCKINFO LockInfo;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

    r49591 r50628  
    150150   KEVENT WdEvent;
    151151#endif
    152 
     152   BOOL bVSyncTimerEnabled;
     153   volatile uint32_t fVSyncInVBlank;
     154   volatile LARGE_INTEGER VSyncTime;
    153155   KTIMER VSyncTimer;
    154156   KDPC VSyncDpc;

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

    r49591 r50628  
    18951895NTSTATUS VBoxWddmSlEnableVSyncNotification(PVBOXMP_DEVEXT pDevExt, BOOLEAN fEnable)
    18961896{
     1897    if (!pDevExt->bVSyncTimerEnabled == !fEnable)
     1898        return STATUS_SUCCESS;
     1899
    18971900    if (!fEnable)
    18981901    {
    … …  
    19011904    else
    19021905    {
     1906        KeQuerySystemTime(&pDevExt->VSyncTime);
     1907
    19031908        LARGE_INTEGER DueTime;
    19041909        DueTime.QuadPart = -166666LL; /* 60 Hz */
    19051910        KeSetTimerEx(&pDevExt->VSyncTimer, DueTime, 16, &pDevExt->VSyncDpc);
    19061911    }
     1912
     1913    pDevExt->bVSyncTimerEnabled = !!fEnable;
     1914
    19071915    return STATUS_SUCCESS;
    19081916}
    … …  
    19151923    Assert(pTarget->HeightVisible);
    19161924    Assert(pTarget->HeightTotal >= pTarget->HeightVisible);
    1917     Assert(pTarget->ScanLineState < pTarget->HeightTotal);
    19181925    if (pTarget->HeightTotal)
    19191926    {
    1920         uint32_t curScanLine = pTarget->ScanLineState;
    1921         ++pTarget->ScanLineState;
    1922         if (pTarget->ScanLineState >= pTarget->HeightTotal)
    1923             pTarget->ScanLineState = 0;
    1924 
    1925 
    1926         BOOL bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
     1927        uint32_t curScanLine;
     1928        BOOL bVBlank;
     1929        LARGE_INTEGER DevVSyncTime;
     1930        DevVSyncTime.QuadPart =  ASMAtomicReadU64((volatile uint64_t*)&pDevExt->VSyncTime.QuadPart);
     1931        LARGE_INTEGER VSyncTime;
     1932        KeQuerySystemTime(&VSyncTime);
     1933
     1934        if (VSyncTime.QuadPart < DevVSyncTime.QuadPart)
     1935        {
     1936            WARN(("vsync time is less than the one stored in device"));
     1937            curScanLine = 0;
     1938        }
     1939        else
     1940        {
     1941            VSyncTime.QuadPart = VSyncTime.QuadPart - DevVSyncTime.QuadPart;
     1942            /* time is in 100ns, */
     1943            curScanLine = (uint32_t)((pTarget->HeightTotal * VSyncTime.QuadPart) / DevVSyncTime.QuadPart);
     1944            if (pDevExt->bVSyncTimerEnabled)
     1945            {
     1946                if (curScanLine >= pTarget->HeightTotal)
     1947                    curScanLine = 0;
     1948            }
     1949            else
     1950            {
     1951                curScanLine %= pTarget->HeightTotal;
     1952            }
     1953        }
     1954
     1955        bVBlank = (!curScanLine || curScanLine > pTarget->HeightVisible);
    19271956        pGetScanLine->ScanLine = curScanLine;
    19281957        pGetScanLine->InVerticalBlank = bVBlank;
    … …  
    19341963    }
    19351964    return STATUS_SUCCESS;
     1965}
     1966
     1967static BOOLEAN vboxWddmSlVSyncIrqCb(PVOID pvContext)
     1968{
     1969    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvContext;
     1970    DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
     1971    BOOLEAN bNeedDpc = FALSE;
     1972    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     1973    {
     1974        PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
     1975        if (pTarget->fConnected)
     1976        {
     1977            memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
     1978            notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
     1979            notify.CrtcVsync.VidPnTargetId = i;
     1980            pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
     1981            bNeedDpc = TRUE;
     1982        }
     1983    }
     1984
     1985    if (bNeedDpc)
     1986    {
     1987        pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
     1988    }
     1989
     1990    return FALSE;
    19361991}
    19371992
    … …  
    19441999{
    19452000    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)DeferredContext;
    1946     DXGKARGCB_NOTIFY_INTERRUPT_DATA notify;
    1947     BOOLEAN bNeedDpc = FALSE;
    1948     for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    1949     {
    1950         PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
    1951         PVBOXWDDM_ALLOCATION pPrimary = vboxWddmAquirePrimary(pDevExt, pSource, i);
    1952         if (pPrimary)
    1953         {
    1954             VBOXVIDEOOFFSET offVram = pPrimary->AllocData.Addr.offVram;
    1955             if (offVram != VBOXVIDEOOFFSET_VOID)
    1956             {
    1957                 memset(&notify, 0, sizeof(DXGKARGCB_NOTIFY_INTERRUPT_DATA));
    1958                 notify.InterruptType = DXGK_INTERRUPT_CRTC_VSYNC;
    1959                 /* @todo: !!!this is not correct in case we want source[i]->target[i!=j] mapping */
    1960                 notify.CrtcVsync.VidPnTargetId = i;
    1961                 notify.CrtcVsync.PhysicalAddress.QuadPart = offVram;
    1962                 /* yes, we can report VSync at dispatch */
    1963                 pDevExt->u.primary.DxgkInterface.DxgkCbNotifyInterrupt(pDevExt->u.primary.DxgkInterface.DeviceHandle, &notify);
    1964                 bNeedDpc = TRUE;
    1965             }
    1966 
    1967             vboxWddmAllocationRelease(pPrimary);
    1968         }
    1969     }
    1970 
    1971     if (bNeedDpc)
    1972     {
    1973         pDevExt->u.primary.DxgkInterface.DxgkCbQueueDpc(pDevExt->u.primary.DxgkInterface.DeviceHandle);
    1974     }
     2001    Assert(!pDevExt->fVSyncInVBlank);
     2002    ASMAtomicWriteU32(&pDevExt->fVSyncInVBlank, 1);
     2003
     2004    BOOLEAN bDummy;
     2005    NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbSynchronizeExecution(
     2006            pDevExt->u.primary.DxgkInterface.DeviceHandle,
     2007            vboxWddmSlVSyncIrqCb,
     2008            pDevExt,
     2009            0, /* IN ULONG MessageNumber */
     2010            &bDummy);
     2011    if (!NT_SUCCESS(Status))
     2012        WARN(("DxgkCbSynchronizeExecution failed Status %#x", Status));
     2013
     2014    LARGE_INTEGER VSyncTime;
     2015    KeQuerySystemTime(&VSyncTime);
     2016    ASMAtomicWriteU64((volatile uint64_t*)&pDevExt->VSyncTime.QuadPart, VSyncTime.QuadPart);
     2017
     2018    ASMAtomicWriteU32(&pDevExt->fVSyncInVBlank, 0);
    19752019}
    19762020
    19772021NTSTATUS VBoxWddmSlInit(PVBOXMP_DEVEXT pDevExt)
    19782022{
     2023    pDevExt->bVSyncTimerEnabled = FALSE;
     2024    pDevExt->fVSyncInVBlank = 0;
     2025    KeQuerySystemTime(&pDevExt->VSyncTime);
    19792026    KeInitializeTimer(&pDevExt->VSyncTimer);
    19802027    KeInitializeDpc(&pDevExt->VSyncDpc, vboxWddmSlVSyncDpc, pDevExt);
    … …  
    20352082        if (pSource->AllocData.Addr.offVram != PhAddr.QuadPart
    20362083                || pSource->AllocData.Addr.SegmentId != 1)
    2037             pSource->fGhSynced = 0;
     2084            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    20382085        pSource->AllocData.Addr.SegmentId = 1;
    20392086        pSource->AllocData.Addr.offVram = PhAddr.QuadPart;

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

    r49591 r50628  
    112112} VBOXWDDM_ALLOC_DATA, *PVBOXWDDM_ALLOC_DATA;
    113113
     114#define VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS 0x01
     115#define VBOXWDDM_HGSYNC_F_SYNCED_LOCATION   0x02
     116#define VBOXWDDM_HGSYNC_F_SYNCED_ALL        (VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS | VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
     117#define VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY        (VBOXWDDM_HGSYNC_F_SYNCED_ALL & ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION)
     118
    114119typedef struct VBOXWDDM_SOURCE
    115120{
    … …  
    119124#endif
    120125    VBOXWDDM_ALLOC_DATA AllocData;
     126    uint8_t u8SyncState;
    121127    BOOLEAN bVisible;
    122     char fGhSynced;
    123128    /* specifies whether the source has 3D overlay data visible */
    124129    BOOLEAN fHas3DVrs;
    … …  
    140145typedef struct VBOXWDDM_TARGET
    141146{
    142     uint32_t ScanLineState;
    143147    uint32_t HeightVisible;
    144148    uint32_t HeightTotal;
    145149    /* since there coul be multiple state changes on auto-resize,
    146      * we pend notifying host to avoi flickering */
     150     * we pend notifying host to avoid flickering */
    147151    volatile bool fStateSyncPening;
    148152    bool fConnected;

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

    r48070 r50628  
    20902090NTSTATUS vboxVidPnSetupSourceInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_SOURCE pSource, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
    20912091{
    2092     vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId);
    20932092    /* pVidPnSourceModeInfo could be null if STATUS_GRAPHICS_MODE_NOT_PINNED,
    20942093     * see vboxVidPnCommitSourceModeForSrcId */
     2094    uint8_t fChanges = 0;
    20952095    if (pVidPnSourceModeInfo)
    20962096    {
    2097         pSource->AllocData.SurfDesc.width = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx;
    2098         pSource->AllocData.SurfDesc.height = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
    2099         pSource->AllocData.SurfDesc.format = pVidPnSourceModeInfo->Format.Graphics.PixelFormat;
    2100         pSource->AllocData.SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat);
    2101         pSource->AllocData.SurfDesc.pitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
     2097        if (pSource->AllocData.SurfDesc.width != pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx)
     2098        {
     2099            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2100            pSource->AllocData.SurfDesc.width = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx;
     2101        }
     2102        if (pSource->AllocData.SurfDesc.height != pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)
     2103        {
     2104            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2105            pSource->AllocData.SurfDesc.height = pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
     2106        }
     2107        if (pSource->AllocData.SurfDesc.format != pVidPnSourceModeInfo->Format.Graphics.PixelFormat)
     2108        {
     2109            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2110            pSource->AllocData.SurfDesc.format = pVidPnSourceModeInfo->Format.Graphics.PixelFormat;
     2111        }
     2112        if (pSource->AllocData.SurfDesc.bpp != vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat))
     2113        {
     2114            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2115            pSource->AllocData.SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pVidPnSourceModeInfo->Format.Graphics.PixelFormat);
     2116        }
     2117        if(pSource->AllocData.SurfDesc.pitch != pVidPnSourceModeInfo->Format.Graphics.Stride)
     2118        {
     2119            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2120            pSource->AllocData.SurfDesc.pitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
     2121        }
    21022122        pSource->AllocData.SurfDesc.depth = 1;
    2103         pSource->AllocData.SurfDesc.slicePitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
    2104         pSource->AllocData.SurfDesc.cbSize = pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
     2123        if (pSource->AllocData.SurfDesc.slicePitch != pVidPnSourceModeInfo->Format.Graphics.Stride)
     2124        {
     2125            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2126            pSource->AllocData.SurfDesc.slicePitch = pVidPnSourceModeInfo->Format.Graphics.Stride;
     2127        }
     2128        if (pSource->AllocData.SurfDesc.cbSize != pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)
     2129        {
     2130            fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     2131            pSource->AllocData.SurfDesc.cbSize = pVidPnSourceModeInfo->Format.Graphics.Stride * pVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy;
     2132        }
    21052133#ifdef VBOX_WDDM_WIN8
    21062134        if (g_VBoxDisplayOnly)
    … …  
    21132141    {
    21142142        Assert(!pAllocation);
    2115     }
     2143        fChanges |= VBOXWDDM_HGSYNC_F_SYNCED_ALL;
     2144    }
     2145
     2146    vboxWddmAssignPrimary(pDevExt, pSource, pAllocation, srcId);
     2147
    21162148    Assert(pSource->AllocData.SurfDesc.VidPnSourceId == srcId);
    2117     pSource->fGhSynced = 0;
     2149    pSource->u8SyncState &= ~fChanges;
    21182150    return STATUS_SUCCESS;
    21192151}
    … …  
    21612193                pTarget->HeightVisible = pPinnedVidPnTargetModeInfo->VideoSignalInfo.ActiveSize.cy;
    21622194                pTarget->HeightTotal = pPinnedVidPnTargetModeInfo->VideoSignalInfo.TotalSize.cy;
    2163                 pTarget->ScanLineState = 0;
    21642195            }
    21652196            pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hVidPnTargetModeSet, pPinnedVidPnTargetModeInfo);

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

    r50313 r50628  
    242242NTSTATUS vboxWddmGhDisplayHideScreen(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
    243243{
    244     VBOXWDDM_SURFACE_DESC SurfDesc = {0};
     244    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnTargetId];
     245    /* this will force update on re-activation */
     246    pSource->AllocData.SurfDesc.width = 0;
     247    pSource->AllocData.SurfDesc.height = 0;
    245248    POINT VScreenPos = {0};
    246     SurfDesc.VidPnSourceId = VidPnTargetId;
    247     NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &SurfDesc, &VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
     249
     250    NTSTATUS Status = vboxWddmGhDisplayPostInfoScreenBySDesc(pDevExt, &pSource->AllocData.SurfDesc, &VScreenPos, VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED);
    248251    if (!NT_SUCCESS(Status))
    249252        WARN(("vboxWddmGhDisplayPostInfoScreenBySDesc failed Status 0x%x", Status));
    … …  
    341344}
    342345
    343 NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos)
    344 {
    345     NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
     346NTSTATUS vboxWddmGhDisplaySetInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pRealFbAlloc, const VBOXWDDM_ALLOC_DATA *pAllocData, const POINT * pVScreenPos, uint8_t u8CurCyncState)
     347{
     348    NTSTATUS Status;
     349
     350    if ((u8CurCyncState & VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY) == VBOXWDDM_HGSYNC_F_CHANGED_LOCATION_ONLY
     351            && pRealFbAlloc->AllocData.hostID)
     352    {
     353        Status = vboxVdmaTexPresentSetAlloc(pDevExt, pRealFbAlloc);
     354        if (!NT_SUCCESS(Status))
     355            WARN(("vboxVdmaTexPresentSetAlloc failed, Status 0x%x", Status));
     356        return Status;
     357    }
     358
     359    Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocData);
    346360    if (NT_SUCCESS(Status))
    347361    {
    … …  
    378392    {
    379393        vboxWddmGhDisplayHideScreen(pDevExt, pSource->AllocData.SurfDesc.VidPnSourceId);
    380         pSource->fGhSynced = 1;
     394        pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
    381395        return true;
    382396    }
    383397
    384     char fGhSynced = 1;
    385398    PVBOXWDDM_ALLOCATION pFbAlloc = VBOXWDDM_FB_ALLOCATION(pDevExt, pSource);
    386399    PVBOXWDDM_ALLOCATION pRealFbAlloc = pSource->pPrimaryAllocation;
    … …  
    394407
    395408        if (!pFbAlloc)
    396         {
    397             pFbAlloc = VBOXWDDM_NONFB_ALLOCATION(pDevExt, pSource);
    398             fGhSynced = -1;
    399         }
     409            pFbAlloc = pRealFbAlloc;
    400410
    401411        if (!pFbAlloc || pFbAlloc->AllocData.Addr.offVram == VBOXVIDEOOFFSET_VOID)
    … …  
    416426    Assert(!pFbAlloc || pFbAlloc->AllocData.Addr.SegmentId == pSource->AllocData.Addr.SegmentId);
    417427
    418     NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos);
     428    NTSTATUS Status = vboxWddmGhDisplaySetInfo(pDevExt, pRealFbAlloc, pFbAlloc ? &pFbAlloc->AllocData : &pSource->AllocData, &pSource->VScreenPos, pSource->u8SyncState);
    419429    if (NT_SUCCESS(Status))
    420         pSource->fGhSynced = fGhSynced;
     430        pSource->u8SyncState = VBOXWDDM_HGSYNC_F_SYNCED_ALL;
    421431    else
    422432        WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
    … …  
    432442            || !pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId].HeightVisible);
    433443
    434     if (pSource->fGhSynced)
     444    if (pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL)
    435445        return false;
    436446
    … …  
    475485
    476486        /* ensure we issue resize command on next update */
    477         pSource->fGhSynced = 0;
     487        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    478488    }
    479489}
    … …  
    517527    pContext->fRenderFromShadowDisabled = FALSE;
    518528}
    519 
    520 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    521 bool vboxWddmCheckUpdateFramebufferAddress(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
    522 {
    523     if (pSource->pPrimaryAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC
    524             || pSource->pPrimaryAllocation->AllocData.hostID)
    525     {
    526 //        Assert(pSource->fGhSynced == FALSE);
    527         return false;
    528     }
    529 
    530     return vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    531 }
    532 #endif
    533529
    534530PVBOXSHGSMI vboxWddmHgsmiGetHeapFromCmdOffset(PVBOXMP_DEVEXT pDevExt, HGSMIOFFSET offCmd)
    … …  
    28712867    {
    28722868        /* this is a NOP, just return success */
    2873         WARN(("null data size, treating as NOP"));
     2869//        LOG(("null data size, treating as NOP"));
    28742870        return STATUS_SUCCESS;
    28752871    }
    … …  
    30043000    else if (pSubmitCommand->DmaBufferPrivateDataSubmissionEndOffset == pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset)
    30053001    {
    3006         WARN(("null data size, treating as NOP"));
    30073002        enmCmd = VBOXVDMACMD_TYPE_DMA_NOP;
    30083003    }
    … …  
    30293024            BOOLEAN fShadowChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
    30303025            if (fShadowChanged)
    3031                 pSource->fGhSynced = 0;
     3026                pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    30323027            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
    30333028            vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    3034             vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
     3029            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    30353030            if (pSrcAlloc->bVisible)
    30363031            {
    … …  
    30563051            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
    30573052            BOOLEAN fSrcChanged;
    3058 
    3059             vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
     3053            BOOLEAN fDstChanged;
     3054
     3055            fDstChanged = vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
    30603056            fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
    30613057
     3058            vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     3059
    30623060            if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc))
    30633061            {
    30643062                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
     3063
    30653064                Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
    3066 
    3067                 if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
     3065#if 0
     3066                if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc) && pDstAlloc->AllocData.hostID)
     3067                {
     3068                    if (pSource->AllocData.hostID != pDstAlloc->AllocData.hostID)
     3069                    {
     3070                        pSource->AllocData.hostID = pDstAlloc->AllocData.hostID;
     3071                        fDstChanged = TRUE;
     3072                    }
     3073
     3074                    if (fDstChanged)
     3075                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
     3076                }
     3077                else
     3078#endif
     3079                    if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
    30683080                {
    30693081                    if (fSrcChanged)
    3070                         pSource->fGhSynced = 0;
     3082                        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    30713083
    30723084                    vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId);
    3073                 }
    3074                 vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    3075                 if(pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D
    3076                         || pDstAlloc->enmType !=VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
    3077                     vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
    3078             }
    3079             else
    3080                 vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     3085                    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
     3086                }
     3087
     3088                Assert(pSource->u8SyncState == VBOXWDDM_HGSYNC_F_SYNCED_ALL);
     3089            }
    30813090
    30823091            Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt);
    … …  
    30913100        {
    30923101            VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
    3093             vboxWddmAddrSetVram(&pFlip->Flip.Alloc.pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
    3094 
    3095             Status = vboxVdmaProcessFlipCmd(pDevExt, pContext, pFlip);
    3096             if (!NT_SUCCESS(Status))
    3097                 WARN(("vboxVdmaProcessFlipCmd failed, Status 0x%x", Status));
     3102            PVBOXWDDM_ALLOCATION pAlloc = pFlip->Flip.Alloc.pAlloc;
     3103            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
     3104            vboxWddmAddrSetVram(&pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
     3105            vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
     3106            vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    30983107
    30993108            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
    … …  
    33063315            }
    33073316            /** @todo: add necessary bits */
     3317            WARN(("Impl!"));
    33083318            break;
    33093319        }
    … …  
    33523362    LOGF(("ENTER, context(0x%x)", hAdapter));
    33533363
     3364    uint32_t cbCmdDma = 0;
     3365
    33543366    /* @todo: */
    33553367    switch (pBuildPagingBuffer->Operation)
    … …  
    33573369        case DXGK_OPERATION_TRANSFER:
    33583370        {
     3371            cbCmdDma = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
    33593372#ifdef VBOX_WITH_VDMA
    33603373#if 0
    … …  
    35073520        case DXGK_OPERATION_FILL:
    35083521        {
     3522            cbCmdDma = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
    35093523            Assert(pBuildPagingBuffer->Fill.FillPattern == 0);
    35103524            PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
    … …  
    35193533        default:
    35203534        {
    3521             LOGREL(("unsupported op (%d)", pBuildPagingBuffer->Operation));
    3522             AssertBreakpoint();
     3535            WARN(("unsupported op (%d)", pBuildPagingBuffer->Operation));
    35233536            break;
    35243537        }
     3538    }
     3539
     3540    if (cbCmdDma)
     3541    {
     3542        pBuildPagingBuffer->pDmaBuffer = ((uint8_t*)pBuildPagingBuffer->pDmaBuffer) + cbCmdDma;
    35253543    }
    35263544
    … …  
    48844902
    48854903    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceAddress->VidPnSourceId];
    4886     Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &pSource->VScreenPos);
     4904    POINT Pos;
     4905    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &Pos);
    48874906    Assert(Status == STATUS_SUCCESS);
     4907    if (NT_SUCCESS(Status))
     4908    {
     4909        if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
     4910        {
     4911            pSource->VScreenPos = Pos;
     4912            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     4913        }
     4914    }
     4915
    48884916    Status = STATUS_SUCCESS;
    48894917
    … …  
    49304958    }
    49314959
    4932     pSource->fGhSynced = 0; /* force guest->host notification */
     4960    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    49334961
    49344962    if (pSource->bVisible)
    … …  
    49614989
    49624990    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceVisibility->VidPnSourceId];
    4963     Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &pSource->VScreenPos);
     4991    POINT Pos;
     4992    Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &Pos);
    49644993    Assert(Status == STATUS_SUCCESS);
     4994    if (NT_SUCCESS(Status))
     4995    {
     4996        if (memcmp(&pSource->VScreenPos, &Pos, sizeof (Pos)))
     4997        {
     4998            pSource->VScreenPos = Pos;
     4999            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_DIMENSIONS;
     5000        }
     5001    }
    49655002    Status = STATUS_SUCCESS;
    49665003
    … …  
    57135750    if (pRender->DmaBufferPrivateDataSize < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
    57145751    {
    5715         LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
     5752        WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
    57165753                pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
    57175754        /* @todo: can this actually happen? what status to return? */
    … …  
    57205757    if (pRender->CommandLength < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
    57215758    {
    5722         Assert(0);
    5723         LOGREL(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
     5759        WARN(("Present->DmaBufferPrivateDataSize(%d) < sizeof VBOXWDDM_DMA_PRIVATEDATA_BASEHDR (%d)",
    57245760                pRender->DmaBufferPrivateDataSize , sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR)));
    57255761        /* @todo: can this actually happen? what status to return? */
    … …  
    57375773
    57385774            pRender->pDmaBufferPrivateData = (uint8_t*)pRender->pDmaBufferPrivateData + sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR);
     5775            memset(pRender->pDmaBuffer, 0, pRender->CommandLength);
    57395776            pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + pRender->CommandLength;
    57405777            Assert(pRender->DmaSize >= pRender->CommandLength);
    … …  
    59205957            }
    59215958
    5922             pBlt->Pos.x = pPresent->DstRect.left - pPresent->SrcRect.left;
    5923             pBlt->Pos.y = pPresent->DstRect.top - pPresent->SrcRect.top;
     5959            pBlt->Pos.x = (int16_t)(pPresent->DstRect.left - pPresent->SrcRect.left);
     5960            pBlt->Pos.y = (int16_t)(pPresent->DstRect.top - pPresent->SrcRect.top);
    59245961
    59255962            paRects = pBlt->aRects;
    … …  
    59435980                u32DstPatch = RT_OFFSETOF(VBOXCMDVBVA_BLT_OFFPRIMSZFMT_OR_ID, dst.offVRAM);
    59445981
    5945             pBlt->Pos.x = pPresent->DstRect.left - pPresent->SrcRect.left;
    5946             pBlt->Pos.y = pPresent->DstRect.top - pPresent->SrcRect.top;
     5982            pBlt->Pos.x = (int16_t)(pPresent->DstRect.left - pPresent->SrcRect.left);
     5983            pBlt->Pos.y = (int16_t)(pPresent->DstRect.top - pPresent->SrcRect.top);
    59475984
    59485985            paRects = pBlt->aRects;
    … …  
    63796416            for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    63806417            {
    6381                 pDevExt->aSources[i].fGhSynced = 0;
     6418                pDevExt->aSources[i].u8SyncState = 0;
    63826419                NTSTATUS tmpStatus= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos);
    63836420                Assert(tmpStatus == STATUS_SUCCESS);

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

    r49591 r50628  
    134134    }
    135135
    136     if (pSource->pShadowAllocation == pAllocation && pSource->fGhSynced > 0)
     136    if (pSource->pShadowAllocation == pAllocation)
    137137    {
    138138        Assert(pAllocation->bAssigned);
    … …  
    162162
    163163        if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
    164             pSource->fGhSynced = 0; /* force guest->host notification */
    165         pSource->AllocData.Addr = pAllocation->AllocData.Addr;
    166     }
     164        {
     165            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     166            pSource->AllocData.Addr = pAllocation->AllocData.Addr;
     167        }
     168        if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
     169        {
     170            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     171            pSource->AllocData.hostID = pAllocation->AllocData.hostID;
     172        }
     173    }
     174    else
     175        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
    167176
    168177    pSource->pShadowAllocation = pAllocation;
    169 
    170     Assert(!pSource->AllocData.pSwapchain);
    171     Assert(!pSource->AllocData.hostID);
    172178}
    173179#endif
    … …  
    197203
    198204        if(!vboxWddmAddrVramEqual(&pSource->AllocData.Addr, &pAllocation->AllocData.Addr))
    199             pSource->fGhSynced = 0; /* force guest->host notification */
    200         pSource->AllocData.Addr = pAllocation->AllocData.Addr;
     205        {
     206            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     207            pSource->AllocData.Addr = pAllocation->AllocData.Addr;
     208        }
     209        if (pSource->AllocData.hostID != pAllocation->AllocData.hostID)
     210        {
     211            pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
     212            pSource->AllocData.hostID = pAllocation->AllocData.hostID;
     213        }
    201214
    202215        vboxWddmAllocationRetain(pAllocation);
    203216    }
     217    else
     218        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION; /* force guest->host notification */
    204219
    205220    KIRQL OldIrql;
    … …  
    207222    pSource->pPrimaryAllocation = pAllocation;
    208223    KeReleaseSpinLock(&pSource->AllocationLock, OldIrql);
    209 
    210     Assert(!pSource->AllocData.pSwapchain);
    211     Assert(!pSource->AllocData.hostID);
    212224}
    213225
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