VirtualBox

Ignore:
Timestamp:
Aug 26, 2013 6:13:22 PM (11 years ago)
Author:
vboxsync
Message:

wddm,vboxtray: forward-port autoresize, multimon, and seamless fixes from 4.2 r87071, r87353, r87356, r87528, r87568, r87581, r87584, r87608, r87673, r87678, r87708, r87629, r87529; additional fixes

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCm.cpp

    r38112 r48070  
    7272    PKEVENT pUmEvent;
    7373    /* sync lock */
    74     FAST_MUTEX Mutex;
     74    KSPIN_LOCK SynchLock;
    7575    /* indicates whether event signaling is needed on cmd add */
    7676    bool bEventNeeded;
     
    181181    }
    182182
    183     Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    184     ExAcquireFastMutex(&pSession->Mutex);
     183    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     184
     185    KIRQL OldIrql;
     186    KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
    185187
    186188    InsertHeadList(&pSession->CommandsList, &pHdr->QueueList);
     
    191193    }
    192194
    193     ExReleaseFastMutex(&pSession->Mutex);
     195    KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    194196
    195197    if (bSignalEvent)
     
    225227    PVBOXVIDEOCM_CMD_DR pHdr;
    226228
    227     ExAcquireFastMutex(&pSession->Mutex);
     229    KIRQL OldIrql;
     230    KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
    228231
    229232    pCurEntry = pSession->CommandsList.Blink;
     
    260263
    261264
    262     ExReleaseFastMutex(&pSession->Mutex);
     265    KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    263266
    264267    return STATUS_SUCCESS;
     
    280283void vboxVideoCmSessionCtxAdd(PVBOXVIDEOCM_SESSION pSession, PVBOXVIDEOCM_CTX pContext)
    281284{
    282     Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    283     ExAcquireFastMutex(&pSession->Mutex);
     285    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     286    KIRQL OldIrql;
     287    KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
     288
    284289    vboxVideoCmSessionCtxAddLocked(pSession, pContext);
    285     ExReleaseFastMutex(&pSession->Mutex);
    286 
     290
     291    KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
     292}
     293
     294void vboxVideoCmSessionSignalEvent(PVBOXVIDEOCM_SESSION pSession)
     295{
     296    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     297    if (pSession->pUmEvent)
     298        KeSetEvent(pSession->pUmEvent, 0, FALSE);
    287299}
    288300
     
    346358    InitializeListHead(&RemainedList);
    347359    InitializeListHead(&RemainedPpList);
    348     Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    349     ExAcquireFastMutex(&pSession->Mutex);
     360    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     361    KIRQL OldIrql;
     362    KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
     363
    350364    pContext->pSession = NULL;
    351365    RemoveEntryList(&pContext->SessionEntry);
     
    362376        vboxVideoCmSessionCtxDetachCmdsLocked(&pSession->PpCommandsList, pContext, &RemainedPpList);
    363377    }
    364     ExReleaseFastMutex(&pSession->Mutex);
     378
     379    KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    365380
    366381    for (pCur = RemainedList.Flink; pCur != &RemainedList; pCur = RemainedList.Flink)
     
    393408        InitializeListHead(&pSession->PpCommandsList);
    394409        pSession->pUmEvent = pUmEvent;
    395         Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    396         ExInitializeFastMutex(&pSession->Mutex);
     410        Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     411        KeInitializeSpinLock(&pSession->SynchLock);
    397412        pSession->bEventNeeded = true;
    398413        vboxVideoCmSessionCtxAddLocked(pSession, pContext);
     
    421436    if (Status == STATUS_SUCCESS)
    422437    {
    423         Status = KeWaitForSingleObject(&pMgr->SynchEvent, Executive, KernelMode,
    424                 FALSE, /* BOOLEAN Alertable */
    425                 NULL /* PLARGE_INTEGER Timeout */
    426             );
    427         Assert(Status == STATUS_SUCCESS);
     438        KIRQL OldIrql;
     439        KeAcquireSpinLock(&pMgr->SynchLock, &OldIrql);
     440
     441        bool bFound = false;
     442        PVBOXVIDEOCM_SESSION pSession = NULL;
     443        for (PLIST_ENTRY pEntry = pMgr->SessionList.Flink; pEntry != &pMgr->SessionList; pEntry = pEntry->Flink)
     444        {
     445            pSession = VBOXCMENTRY_2_SESSION(pEntry);
     446            if (pSession->pUmEvent == pUmEvent)
     447            {
     448                bFound = true;
     449                break;
     450            }
     451        }
     452
     453        pContext->u64UmData = u64UmData;
     454
     455        if (!bFound)
     456        {
     457            Status = vboxVideoCmSessionCreateLocked(pMgr, &pSession, pUmEvent, pContext);
     458            Assert(Status == STATUS_SUCCESS);
     459        }
     460        else
     461        {
     462            /* Status = */vboxVideoCmSessionCtxAdd(pSession, pContext);
     463            /*Assert(Status == STATUS_SUCCESS);*/
     464        }
     465
     466        KeReleaseSpinLock(&pMgr->SynchLock, OldIrql);
     467
    428468        if (Status == STATUS_SUCCESS)
    429469        {
    430             bool bFound = false;
    431             PVBOXVIDEOCM_SESSION pSession = NULL;
    432             for (PLIST_ENTRY pEntry = pMgr->SessionList.Flink; pEntry != &pMgr->SessionList; pEntry = pEntry->Flink)
    433             {
    434                 pSession = VBOXCMENTRY_2_SESSION(pEntry);
    435                 if (pSession->pUmEvent == pUmEvent)
    436                 {
    437                     bFound = true;
    438                     break;
    439                 }
    440             }
    441 
    442             pContext->u64UmData = u64UmData;
    443 
    444             if (!bFound)
    445             {
    446                 Status = vboxVideoCmSessionCreateLocked(pMgr, &pSession, pUmEvent, pContext);
    447                 Assert(Status == STATUS_SUCCESS);
    448             }
    449             else
    450             {
    451                 /* Status = */vboxVideoCmSessionCtxAdd(pSession, pContext);
    452                 /*Assert(Status == STATUS_SUCCESS);*/
    453             }
    454             LONG tstL = KeSetEvent(&pMgr->SynchEvent, 0, FALSE);
    455             Assert(!tstL);
    456 
    457             if (Status == STATUS_SUCCESS)
    458             {
    459                 return STATUS_SUCCESS;
    460             }
     470            return STATUS_SUCCESS;
    461471        }
    462472
     
    472482        return STATUS_SUCCESS;
    473483
    474     NTSTATUS Status = KeWaitForSingleObject(&pMgr->SynchEvent, Executive, KernelMode,
    475                 FALSE, /* BOOLEAN Alertable */
    476                 NULL /* PLARGE_INTEGER Timeout */
    477     );
    478     Assert(Status == STATUS_SUCCESS);
    479     if (Status == STATUS_SUCCESS)
    480     {
    481         vboxVideoCmSessionCtxRemoveLocked(pSession, pContext);
    482         LONG tstL = KeSetEvent(&pMgr->SynchEvent, 0, FALSE);
    483         Assert(!tstL);
    484     }
    485 
    486     return Status;
     484    KIRQL OldIrql;
     485    KeAcquireSpinLock(&pMgr->SynchLock, &OldIrql);
     486
     487    vboxVideoCmSessionCtxRemoveLocked(pSession, pContext);
     488
     489    KeReleaseSpinLock(&pMgr->SynchLock, OldIrql);
     490
     491    return STATUS_SUCCESS;
    487492}
    488493
    489494NTSTATUS vboxVideoCmInit(PVBOXVIDEOCM_MGR pMgr)
    490495{
    491     KeInitializeEvent(&pMgr->SynchEvent, SynchronizationEvent, TRUE);
     496    KeInitializeSpinLock(&pMgr->SynchLock);
    492497    InitializeListHead(&pMgr->SessionList);
    493498    return STATUS_SUCCESS;
     
    500505}
    501506
     507NTSTATUS vboxVideoCmSignalEvents(PVBOXVIDEOCM_MGR pMgr)
     508{
     509    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     510    PVBOXVIDEOCM_SESSION pSession = NULL;
     511
     512    KIRQL OldIrql;
     513    KeAcquireSpinLock(&pMgr->SynchLock, &OldIrql);
     514
     515    for (PLIST_ENTRY pEntry = pMgr->SessionList.Flink; pEntry != &pMgr->SessionList; pEntry = pEntry->Flink)
     516    {
     517        pSession = VBOXCMENTRY_2_SESSION(pEntry);
     518        vboxVideoCmSessionSignalEvent(pSession);
     519    }
     520
     521    KeReleaseSpinLock(&pMgr->SynchLock, OldIrql);
     522
     523    return STATUS_SUCCESS;
     524}
     525
    502526VOID vboxVideoCmProcessKm(PVBOXVIDEOCM_CTX pContext, PVBOXVIDEOCM_CMD_CTL_KM pCmd)
    503527{
     
    515539        {
    516540            PVBOXVIDEOCM_CMD_DR pHdr = VBOXVIDEOCM_HEAD(pCmd);
    517             ExAcquireFastMutex(&pSession->Mutex);
     541            KIRQL OldIrql;
     542            KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
    518543            InsertTailList(&pSession->PpCommandsList, &pHdr->QueueList);
    519             ExReleaseFastMutex(&pSession->Mutex);
     544            KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    520545            break;
    521546        }
     
    550575//    PVBOXWDDM_GETVBOXVIDEOCMCMD_HDR *pvCmd
    551576
    552     Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    553     ExAcquireFastMutex(&pSession->Mutex);
     577    Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
     578    KIRQL OldIrql;
     579    KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
    554580
    555581    vboxVideoCmSessionCtxDetachCmdsLocked(&pSession->PpCommandsList, pContext, &DetachedPpList);
     
    606632    } while (1);
    607633
    608     ExReleaseFastMutex(&pSession->Mutex);
     634    KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    609635
    610636    vboxVideoCmSessionCtxPpList(pContext, &DetachedPpList);
     
    647673}
    648674
    649 VOID vboxVideoCmLock(PVBOXVIDEOCM_CTX pContext)
    650 {
    651     ExAcquireFastMutex(&pContext->pSession->Mutex);
    652 }
    653 
    654 VOID vboxVideoCmUnlock(PVBOXVIDEOCM_CTX pContext)
    655 {
    656     ExReleaseFastMutex(&pContext->pSession->Mutex);
    657 }
    658 
    659675static BOOLEAN vboxVideoCmHasUncompletedCmdsLocked(PVBOXVIDEOCM_MGR pMgr)
    660676{
     
    663679    {
    664680        pSession = VBOXCMENTRY_2_SESSION(pEntry);
    665         ExAcquireFastMutex(&pSession->Mutex);
     681        KIRQL OldIrql;
     682        KeAcquireSpinLock(&pSession->SynchLock, &OldIrql);
     683
    666684        if (pSession->bEventNeeded)
    667685        {
    668686            /* commands still being processed */
    669             ExReleaseFastMutex(&pSession->Mutex);
     687            KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    670688            return TRUE;
    671689        }
    672         ExReleaseFastMutex(&pSession->Mutex);
     690        KeReleaseSpinLock(&pSession->SynchLock, OldIrql);
    673691    }
    674692    return FALSE;
    675693}
    676 
    677 /* waits for all outstanding commands to completed by client
    678  * assumptions here are:
    679  * 1. no new commands are submitted while we are waiting
    680  * 2. it is assumed that a client completes all previously received commands
    681  *    once it queries for the new set of commands */
    682 NTSTATUS vboxVideoCmWaitCompletedCmds(PVBOXVIDEOCM_MGR pMgr, uint32_t msTimeout)
    683 {
    684     LARGE_INTEGER Timeout;
    685     PLARGE_INTEGER pTimeout;
    686     uint32_t cIters;
    687 
    688     if (msTimeout != RT_INDEFINITE_WAIT)
    689     {
    690         uint32_t msIter = 2;
    691         cIters = msTimeout/msIter;
    692         if (!cIters)
    693         {
    694             msIter = msTimeout;
    695             cIters = 1;
    696         }
    697         Timeout.QuadPart = -(int64_t) msIter /* ms */ * 10000;
    698         pTimeout = &Timeout;
    699     }
    700     else
    701     {
    702         pTimeout = NULL;
    703         cIters = 1;
    704     }
    705 
    706     Assert(cIters);
    707     do
    708     {
    709         NTSTATUS Status = KeWaitForSingleObject(&pMgr->SynchEvent, Executive, KernelMode,
    710                     FALSE, /* BOOLEAN Alertable */
    711                     pTimeout /* PLARGE_INTEGER Timeout */
    712         );
    713         if (Status == STATUS_TIMEOUT)
    714         {
    715             --cIters;
    716         }
    717         else
    718         {
    719             if (!NT_SUCCESS(Status))
    720             {
    721                 WARN(("KeWaitForSingleObject failed with Status (0x%x)", Status));
    722                 return Status;
    723             }
    724 
    725             /* succeeded */
    726             if (!vboxVideoCmHasUncompletedCmdsLocked(pMgr))
    727             {
    728                 LONG tstL = KeSetEvent(&pMgr->SynchEvent, 0, FALSE);
    729                 Assert(!tstL);
    730                 return STATUS_SUCCESS;
    731             }
    732 
    733             LONG tstL = KeSetEvent(&pMgr->SynchEvent, 0, FALSE);
    734             Assert(!tstL);
    735         }
    736 
    737         if (!cIters)
    738             break;
    739 
    740         KeDelayExecutionThread(KernelMode, FALSE, pTimeout);
    741         --cIters;
    742         if (!cIters)
    743             break;
    744     } while (0);
    745 
    746     return STATUS_TIMEOUT;
    747 }
    748 
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCm.h

    r38112 r48070  
    2222typedef struct VBOXVIDEOCM_MGR
    2323{
    24     KEVENT SynchEvent;
     24    KSPIN_LOCK SynchLock;
    2525    /* session list */
    2626    LIST_ENTRY SessionList;
     
    4141NTSTATUS vboxVideoCmInit(PVBOXVIDEOCM_MGR pMgr);
    4242NTSTATUS vboxVideoCmTerm(PVBOXVIDEOCM_MGR pMgr);
     43NTSTATUS vboxVideoCmSignalEvents(PVBOXVIDEOCM_MGR pMgr);
    4344
    4445NTSTATUS vboxVideoCmCmdSubmitCompleteEvent(PVBOXVIDEOCM_CTX pContext, PKEVENT pEvent);
     
    5859NTSTATUS vboxVideoCmEscape(PVBOXVIDEOCM_CTX pContext, PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD pCmd, uint32_t cbCmd);
    5960
    60 NTSTATUS vboxVideoCmWaitCompletedCmds(PVBOXVIDEOCM_MGR pMgr, uint32_t msTimeout);
    61 
    62 VOID vboxVideoCmLock(PVBOXVIDEOCM_CTX pContext);
    63 VOID vboxVideoCmUnlock(PVBOXVIDEOCM_CTX pContext);
    64 
    6561#endif /* #ifndef ___VBoxMPCm_h___ */
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

    r47566 r48070  
    573573}
    574574
    575 #define VBOXWDDM_REG_DRVKEY_PREFIX L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\"
    576 
    577575NTSTATUS vboxWddmRegQueryDrvKeyName(PVBOXMP_DEVEXT pDevExt, ULONG cbBuf, PWCHAR pBuf, PULONG pcbResult)
    578576{
     
    607605}
    608606
    609 #define VBOXWDDM_REG_DISPLAYSETTINGSKEY_PREFIX_VISTA L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Control\\VIDEO\\"
    610 #define VBOXWDDM_REG_DISPLAYSETTINGSKEY_PREFIX_WIN7 L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\UnitedVideo\\CONTROL\\VIDEO\\"
    611 
    612 #define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELX L"Attach.RelativeX"
    613 #define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELY L"Attach.RelativeY"
    614 #define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_DESKTOP L"Attach.ToDesktop"
    615 
    616607NTSTATUS vboxWddmRegQueryDisplaySettingsKeyName(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId,
    617608        ULONG cbBuf, PWCHAR pBuf, PULONG pcbResult)
     
    660651    return Status;
    661652}
    662 
    663 #define VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Video\\"
    664 #define VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY L"\\Video"
    665653
    666654NTSTATUS vboxWddmRegQueryVideoGuidString(PVBOXMP_DEVEXT pDevExt, ULONG cbBuf, PWCHAR pBuf, PULONG pcbResult)
     
    891879}
    892880
     881NTSTATUS vboxWddmRegDrvFlagsSet(PVBOXMP_DEVEXT pDevExt, DWORD fVal)
     882{
     883    HANDLE hKey = NULL;
     884    NTSTATUS Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_WRITE, &hKey);
     885    if (!NT_SUCCESS(Status))
     886    {
     887        WARN(("IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
     888        return Status;
     889    }
     890
     891    Status = vboxWddmRegSetValueDword(hKey, VBOXWDDM_REG_DRV_FLAGS_NAME, fVal);
     892    if (!NT_SUCCESS(Status))
     893        WARN(("vboxWddmRegSetValueDword failed, Status = 0x%x", Status));
     894
     895    NTSTATUS tmpStatus = ZwClose(hKey);
     896    Assert(tmpStatus == STATUS_SUCCESS);
     897
     898    return Status;
     899}
     900
     901DWORD vboxWddmRegDrvFlagsGet(PVBOXMP_DEVEXT pDevExt, DWORD fDefault)
     902{
     903    HANDLE hKey = NULL;
     904    NTSTATUS Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_READ, &hKey);
     905    if (!NT_SUCCESS(Status))
     906    {
     907        WARN(("IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
     908        return fDefault;
     909    }
     910
     911    DWORD dwVal = 0;
     912    Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DRV_FLAGS_NAME, &dwVal);
     913    if (!NT_SUCCESS(Status))
     914    {
     915        WARN(("vboxWddmRegQueryValueDword failed, Status = 0x%x", Status));
     916        dwVal = fDefault;
     917    }
     918
     919    NTSTATUS tmpStatus = ZwClose(hKey);
     920    Assert(tmpStatus == STATUS_SUCCESS);
     921
     922    return dwVal;
     923}
     924
    893925NTSTATUS vboxWddmRegQueryValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT PDWORD pDword)
    894926{
     
    920952}
    921953
    922 NTSTATUS vboxWddmRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT DWORD val)
     954NTSTATUS vboxWddmRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, IN DWORD val)
    923955{
    924956    UNICODE_STRING RtlStr;
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h

    r47566 r48070  
    9999NTSTATUS vboxWddmRegOpenKey(OUT PHANDLE phKey, IN PWCHAR pName, IN ACCESS_MASK fAccess);
    100100NTSTATUS vboxWddmRegQueryValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT PDWORD pDword);
    101 NTSTATUS vboxWddmRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT DWORD val);
     101NTSTATUS vboxWddmRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, IN DWORD val);
     102
     103NTSTATUS vboxWddmRegDrvFlagsSet(PVBOXMP_DEVEXT pDevExt, DWORD fVal);
     104DWORD vboxWddmRegDrvFlagsGet(PVBOXMP_DEVEXT pDevExt, DWORD fDefault);
    102105
    103106UNICODE_STRING* vboxWddmVGuidGet(PVBOXMP_DEVEXT pDevExt);
     
    184187#endif
    185188
     189NTSTATUS vboxWddmChildStatusConnect(PVBOXMP_DEVEXT pDevExt, uint32_t iChild, BOOLEAN fConnect);
     190
    186191#endif /* #ifndef ___VBoxMPMisc_h__ */
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h

    r47059 r48070  
    3535#include <cr_vreg.h>
    3636
     37#ifdef DEBUG_misha
     38extern DWORD g_VBoxDbgBreakModes;
     39#endif
    3740
    3841#if 0
     
    139142    uint32_t HeightVisible;
    140143    uint32_t HeightTotal;
     144    /* since there coul be multiple state changes on auto-resize,
     145     * we pend notifying host to avoi flickering */
     146    volatile bool fStateSyncPening;
     147    bool fConnected;
     148    bool fConfigured;
    141149} VBOXWDDM_TARGET, *PVBOXWDDM_TARGET;
    142150
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp

    r44529 r48070  
    12631263    const DXGK_VIDPNTARGETMODESET_INTERFACE *pNewVidPnTargetModeSetInterface;
    12641264
    1265     if (VidPnSourceId != VidPnTargetId || pCbContext->apPathInfos[VidPnTargetId].enmState != VBOXVIDPNPATHITEM_STATE_PRESENT)
    1266     {
    1267         return STATUS_SUCCESS;
    1268     }
     1265    Assert(VidPnSourceId == VidPnTargetId);
    12691266
    12701267    D3DKMDT_HVIDPNSOURCEMODESET hCurVidPnSourceModeSet;
     
    13061303        {
    13071304            Assert(hNewVidPnTargetModeSet);
    1308             if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnTargetId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
    1309             {
    1310                 Assert(VidPnSourceId == VidPnTargetId);
    1311 
     1305            Assert(VidPnSourceId == VidPnTargetId);
     1306//            if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnTargetId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
     1307            {
    13121308                for (uint32_t i = 0; i < pInfo->cResolutions; ++i)
    13131309                {
     
    13981394    const DXGK_VIDPNSOURCEMODESET_INTERFACE *pNewVidPnSourceModeSetInterface;
    13991395
    1400     if (VidPnSourceId != VidPnTargetId || pCbContext->apPathInfos[VidPnSourceId].enmState != VBOXVIDPNPATHITEM_STATE_PRESENT)
    1401     {
    1402         return STATUS_SUCCESS;
    1403     }
     1396    Assert(VidPnSourceId == VidPnTargetId);
    14041397
    14051398    D3DKMDT_HVIDPNTARGETMODESET hCurVidPnTargetModeSet;
     
    14411434        {
    14421435            Assert(hNewVidPnSourceModeSet);
    1443             if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnSourceId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
    1444             {
    1445                 Assert(VidPnSourceId == VidPnTargetId);
     1436            Assert(VidPnSourceId == VidPnTargetId);
     1437//            if (VidPnSourceId == VidPnTargetId && pCbContext->apPathInfos[VidPnSourceId].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
     1438            {
    14461439                for (uint32_t i = 0; i < pInfo->cModes; ++i)
    14471440                {
     
    17551748            else
    17561749            {
    1757                 AssertFailed();
     1750                WARN(("cItems(%d) <= VidPnSourceId(%d)", pCbContext->cItems, VidPnSourceId));
    17581751                Status = STATUS_BUFFER_OVERFLOW;
    17591752                break;
     
    17661759            else
    17671760            {
    1768                 AssertFailed();
     1761                WARN(("cItems(%d) <= VidPnTargetId(%d)", pCbContext->cItems, VidPnTargetId));
    17691762                Status = STATUS_BUFFER_OVERFLOW;
    17701763                break;
     
    17751768
    17761769        /* VidPnSourceId == VidPnTargetId */
     1770        Assert(VidPnSourceId == VidPnTargetId);
    17771771        if (pCbContext->cItems > VidPnSourceId)
    17781772        {
     
    17851779        else
    17861780        {
    1787             AssertFailed();
     1781            WARN(("cItems(%d) <= VidPnSource/TargetId(%d)", pCbContext->cItems, VidPnSourceId));
    17881782            Status = STATUS_BUFFER_OVERFLOW;
    17891783            break;
     
    18011795/* we currently support only 0 -> 0, 1 -> 1, 2 -> 2 paths, AND 0 -> 0 must be present
    18021796 * this routine disables all paths unsupported */
    1803 NTSTATUS vboxVidPnCheckTopology(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    1804                                     BOOLEAN fBreakOnDisabled, UINT cItems, PVBOXVIDPNPATHITEM paItems, BOOLEAN *pfDisabledFound)
    1805 {
     1797NTSTATUS vboxVidPnCheckTopology(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, BOOLEAN *pfSupported)
     1798{
     1799    VBOXVIDPNPATHITEM aItems[VBOX_VIDEO_MAX_SCREENS];
     1800    const uint32_t cItems = RT_ELEMENTS(aItems);
    18061801    UINT i;
    18071802    for (i = 0; i < cItems; ++i)
    18081803    {
    1809         paItems[i].enmState = VBOXVIDPNPATHITEM_STATE_NOT_EXISTS;
     1804        aItems[i].enmState = VBOXVIDPNPATHITEM_STATE_NOT_EXISTS;
    18101805    }
    18111806    VBOXVIDPNGETPATHSINFO CbContext = {0};
    18121807    CbContext.Status = STATUS_SUCCESS;
    1813     CbContext.fBreakOnDisabled = fBreakOnDisabled;
     1808    CbContext.fBreakOnDisabled = FALSE;
    18141809    CbContext.fDisabledFound = FALSE;
    18151810    CbContext.cItems = cItems;
    1816     CbContext.paItems = paItems;
     1811    CbContext.paItems = aItems;
    18171812    NTSTATUS Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface, vboxVidPnCheckTopologyEnum, &CbContext);
    18181813    if (!NT_SUCCESS(Status))
     
    18291824    }
    18301825
    1831     if (pfDisabledFound)
    1832         *pfDisabledFound = CbContext.fDisabledFound;
    1833 
    1834     if (!fBreakOnDisabled)
    1835     {
    1836         /* now check if 0->0 path is present and enabled, and if not, disable everything */
    1837         if (cItems && paItems[0].enmState != VBOXVIDPNPATHITEM_STATE_PRESENT)
    1838         {
    1839             LOGREL(("path 0 not set to present\n"));
    1840             for (i = 0; i < cItems; ++i)
    1841             {
    1842                 if (paItems[i].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
    1843                     paItems[i].enmState = VBOXVIDPNPATHITEM_STATE_DISABLED;
    1844             }
    1845         }
    1846     }
     1826    BOOLEAN fSupported = !CbContext.fDisabledFound;
     1827
     1828    /* now check if 0->0 path is present and enabled, and if not, disable everything */
     1829//    if (cItems && aItems[0].enmState != VBOXVIDPNPATHITEM_STATE_PRESENT)
     1830//    {
     1831//        LOG(("path 0 not set to present\n"));
     1832////        for (i = 0; i < cItems; ++i)
     1833////        {
     1834////            if (aItems[i].enmState == VBOXVIDPNPATHITEM_STATE_PRESENT)
     1835////                aItems[i].enmState = VBOXVIDPNPATHITEM_STATE_DISABLED;
     1836////        }
     1837//        fSupported = FALSE;
     1838//    }
     1839
     1840    if (pfSupported)
     1841        *pfSupported = fSupported;
    18471842
    18481843    return Status;
     
    20632058                else
    20642059                {
    2065                     Assert(Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET);
    20662060                    if (Status != STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
    2067                         LOGREL(("pfnAcquireNextPathInfo Failed Status(0x%x), ignored since callback returned false", Status));
     2061                        WARN(("pfnAcquireNextPathInfo Failed Status(0x%x), ignored since callback returned false", Status));
    20682062                    Status = STATUS_SUCCESS;
    20692063                }
     
    20802074            else
    20812075            {
    2082                 AssertBreakpoint();
    2083                 LOGREL(("pfnAcquireNextPathInfo Failed Status(0x%x)", Status));
     2076                WARN(("pfnAcquireNextPathInfo Failed Status(0x%x)", Status));
    20842077                pNewVidPnPresentPathInfo = NULL;
    20852078                break;
     
    20902083        Status = STATUS_SUCCESS;
    20912084    else
    2092         LOGREL(("pfnAcquireFirstModeInfo failed Status(0x%x)", Status));
     2085        WARN(("pfnAcquireFirstModeInfo failed Status(0x%x)", Status));
    20932086
    20942087    return Status;
     
    21812174    return Status == STATUS_SUCCESS;
    21822175}
     2176
     2177#ifdef DEBUG_misha
     2178DWORD g_VBoxDbgBreakModes = 0;
     2179#endif
    21832180
    21842181NTSTATUS vboxVidPnCommitSourceModeForSrcId(PVBOXMP_DEVEXT pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_ALLOCATION pAllocation)
     
    22352232                    }
    22362233                    else
    2237                         LOGREL(("vboxVidPnEnumTargetsForSource failed Status(0x%x)", Status));
     2234                        WARN(("vboxVidPnEnumTargetsForSource failed Status(0x%x)", Status));
    22382235                }
    22392236                else
    2240                     LOGREL(("pfnGetTopology failed Status(0x%x)", Status));
     2237                    WARN(("pfnGetTopology failed Status(0x%x)", Status));
    22412238            }
    22422239            else
    2243                 LOGREL(("vboxVidPnCommitSourceMode failed Status(0x%x)", Status));
     2240                WARN(("vboxVidPnCommitSourceMode failed Status(0x%x)", Status));
    22442241            /* release */
    22452242            pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo);
     
    22472244        else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED)
    22482245        {
     2246#ifdef DEBUG_misha
     2247            Assert(!g_VBoxDbgBreakModes);
     2248            ++g_VBoxDbgBreakModes;
     2249#endif
    22492250            Status = vboxVidPnCommitSourceMode(pDevExt, srcId, NULL, pAllocation);
    22502251            Assert(Status == STATUS_SUCCESS);
    22512252        }
    22522253        else
    2253             LOGREL(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status));
     2254            WARN(("pfnAcquirePinnedModeInfo failed Status(0x%x)", Status));
    22542255
    22552256        pVidPnInterface->pfnReleaseSourceModeSet(hDesiredVidPn, hCurVidPnSourceModeSet);
     
    22572258    else
    22582259    {
    2259         LOGREL(("pfnAcquireSourceModeSet failed Status(0x%x)", Status));
     2260        WARN(("pfnAcquireSourceModeSet failed Status(0x%x)", Status));
    22602261    }
    22612262
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.h

    r37490 r48070  
    5858    CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* pEnumCofuncModalityArg;
    5959    PVBOXWDDM_VIDEOMODES_INFO pInfos;
    60     UINT cPathInfos;
    61     PVBOXVIDPNPATHITEM apPathInfos;
     60//    UINT cPathInfos;
     61//    PVBOXVIDPNPATHITEM apPathInfos;
    6262} VBOXVIDPNCOFUNCMODALITY, *PVBOXVIDPNCOFUNCMODALITY;
    6363
     
    146146NTSTATUS vboxVidPnCofuncModalityForPath(PVBOXVIDPNCOFUNCMODALITY pCbContext, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);
    147147
    148 NTSTATUS vboxVidPnCheckTopology(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
    149                                     BOOLEAN fBreakOnDisabled, UINT cItems, PVBOXVIDPNPATHITEM paItems, BOOLEAN *pfDisabledFound);
     148NTSTATUS vboxVidPnCheckTopology(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface, BOOLEAN *pfSupported);
    150149
    151150NTSTATUS vboxVidPnPathAdd(D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r47603 r48070  
    3131#include <VBox/Hardware/VBoxVideoVBE.h>
    3232
     33#include <stdio.h>
     34
    3335DWORD g_VBoxLogUm = 0;
    3436#ifdef VBOX_WDDM_WIN8
     
    187189}
    188190
     191BOOL vboxWddmGhDisplayCheckCompletePeningScreenInfo(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
     192{
     193    if (!ASMAtomicCmpXchgBool(&pDevExt->aTargets[VidPnTargetId].fStateSyncPening, false, true))
     194        return FALSE;
     195    return vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, &pDevExt->aSources[VidPnTargetId]);
     196}
     197
    189198NTSTATUS vboxWddmGhDisplayPostInfoView(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData)
    190199{
     
    302311}
    303312
    304 bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
    305 {
    306 //    Assert(VBOXVIDEOOFFSET_VOID != pSource->AllocData.Addr.offVram);
    307 
    308     if (pSource->fGhSynced)
    309         return false;
     313bool vboxWddmGhDisplaySetInfoFromSourceTarget(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource, PVBOXWDDM_TARGET pTarget)
     314{
     315    if (!pTarget->HeightVisible)
     316    {
     317        vboxWddmGhDisplayHideScreen(pDevExt, pSource->AllocData.SurfDesc.VidPnSourceId);
     318        pSource->fGhSynced = 1;
     319        return true;
     320    }
    310321
    311322    char fGhSynced = 1;
     
    346357        WARN(("vboxWddmGhDisplaySetInfo failed, Status (0x%x)", Status));
    347358
     359    vboxVideoCmSignalEvents(&pDevExt->SeamlessCtxMgr);
     360
    348361    return true;
     362}
     363
     364bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource)
     365{
     366    Assert(VBOXVIDEOOFFSET_VOID != pSource->AllocData.Addr.offVram
     367            || !pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId].HeightVisible);
     368
     369    if (pSource->fGhSynced)
     370        return false;
     371
     372    PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[pSource->AllocData.SurfDesc.VidPnSourceId];
     373    if (ASMAtomicUoReadBool(&pTarget->fStateSyncPening))
     374        return false;
     375
     376    return vboxWddmGhDisplaySetInfoFromSourceTarget(pDevExt, pSource, pTarget);
    349377}
    350378
     
    467495        return VBOXWDDM_HGSMICMD_TYPE_CTL;
    468496    return VBOXWDDM_HGSMICMD_TYPE_UNDEFINED;
    469 }
    470 
    471 static NTSTATUS vboxWddmChildStatusReportPerform(PVBOXMP_DEVEXT pDevExt, PVBOXVDMA_CHILD_STATUS pChildStatus, D3DDDI_VIDEO_PRESENT_TARGET_ID iChild)
    472 {
    473     DXGK_CHILD_STATUS DdiChildStatus;
    474     if (pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_DISCONNECTED)
    475     {
    476         /* report disconnected */
    477         memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));
    478         DdiChildStatus.Type = StatusConnection;
    479         if (iChild != D3DDDI_ID_UNINITIALIZED)
    480         {
    481             Assert(iChild < UINT32_MAX/2);
    482             Assert(iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    483             DdiChildStatus.ChildUid = iChild;
    484         }
    485         else
    486         {
    487             Assert(pChildStatus->iChild < UINT32_MAX/2);
    488             Assert(pChildStatus->iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    489             DdiChildStatus.ChildUid = pChildStatus->iChild;
    490         }
    491         LOG(("Reporting DISCONNECT to child %d", DdiChildStatus.ChildUid));
    492         DdiChildStatus.HotPlug.Connected = FALSE;
    493         NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);
    494         if (!NT_SUCCESS(Status))
    495         {
    496             WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));
    497             return Status;
    498         }
    499     }
    500 
    501     if (pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_CONNECTED)
    502     {
    503         /* report disconnected */
    504         memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));
    505         DdiChildStatus.Type = StatusConnection;
    506         if (iChild != D3DDDI_ID_UNINITIALIZED)
    507         {
    508             Assert(iChild < UINT32_MAX/2);
    509             Assert(iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    510             DdiChildStatus.ChildUid = iChild;
    511         }
    512         else
    513         {
    514             Assert(pChildStatus->iChild < UINT32_MAX/2);
    515             Assert(pChildStatus->iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    516             DdiChildStatus.ChildUid = pChildStatus->iChild;
    517         }
    518         LOG(("Reporting CONNECT to child %d", DdiChildStatus.ChildUid));
    519         DdiChildStatus.HotPlug.Connected = TRUE;
    520         NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);
    521         if (!NT_SUCCESS(Status))
    522         {
    523             WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));
    524             return Status;
    525         }
    526     }
    527 
    528     if (pChildStatus->fFlags & VBOXVDMA_CHILD_STATUS_F_ROTATED)
    529     {
    530         /* report disconnected */
    531         memset(&DdiChildStatus, 0, sizeof (DdiChildStatus));
    532         DdiChildStatus.Type = StatusRotation;
    533         if (iChild != D3DDDI_ID_UNINITIALIZED)
    534         {
    535             Assert(iChild < UINT32_MAX/2);
    536             Assert(iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    537             DdiChildStatus.ChildUid = iChild;
    538         }
    539         else
    540         {
    541             Assert(pChildStatus->iChild < UINT32_MAX/2);
    542             Assert(pChildStatus->iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    543             DdiChildStatus.ChildUid = pChildStatus->iChild;
    544         }
    545         LOG(("Reporting ROTATED to child %d", DdiChildStatus.ChildUid));
    546         DdiChildStatus.Rotation.Angle = pChildStatus->u8RotationAngle;
    547         NTSTATUS Status = pDevExt->u.primary.DxgkInterface.DxgkCbIndicateChildStatus(pDevExt->u.primary.DxgkInterface.DeviceHandle, &DdiChildStatus);
    548         if (!NT_SUCCESS(Status))
    549         {
    550             WARN(("DxgkCbIndicateChildStatus failed with Status (0x%x)", Status));
    551             return Status;
    552         }
    553     }
    554 
    555     return STATUS_SUCCESS;
    556 }
    557 
    558 static NTSTATUS vboxWddmChildStatusDoReportReconnected(PVBOXMP_DEVEXT pDevExt, VBOXVDMACMD_CHILD_STATUS_IRQ *pBody)
    559 {
    560     NTSTATUS Status = STATUS_SUCCESS;
    561 
    562     for (UINT i = 0; i < pBody->cInfos; ++i)
    563     {
    564         PVBOXVDMA_CHILD_STATUS pInfo = &pBody->aInfos[i];
    565         if (pBody->fFlags & VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL)
    566         {
    567             for (D3DDDI_VIDEO_PRESENT_TARGET_ID iChild = 0; iChild < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++iChild)
    568             {
    569                 Status = vboxWddmChildStatusReportPerform(pDevExt, pInfo, iChild);
    570                 if (!NT_SUCCESS(Status))
    571                 {
    572                     WARN(("vboxWddmChildStatusReportPerform failed with Status (0x%x)", Status));
    573                     break;
    574                 }
    575             }
    576         }
    577         else
    578         {
    579             Status = vboxWddmChildStatusReportPerform(pDevExt, pInfo, D3DDDI_ID_UNINITIALIZED);
    580             if (!NT_SUCCESS(Status))
    581             {
    582                 WARN(("vboxWddmChildStatusReportPerform failed with Status (0x%x)", Status));
    583                 break;
    584             }
    585         }
    586     }
    587 
    588     return Status;
    589 }
    590 
    591 typedef struct VBOXWDDMCHILDSTATUSCB
    592 {
    593     PVBOXVDMACBUF_DR pDr;
    594     PKEVENT pEvent;
    595 } VBOXWDDMCHILDSTATUSCB, *PVBOXWDDMCHILDSTATUSCB;
    596 
    597 static DECLCALLBACK(VOID) vboxWddmChildStatusReportCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
    598 {
    599     /* we should be called from our DPC routine */
    600     Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    601 
    602     PVBOXWDDMCHILDSTATUSCB pCtx = (PVBOXWDDMCHILDSTATUSCB)pvContext;
    603     PVBOXVDMACBUF_DR pDr = pCtx->pDr;
    604     PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    605     VBOXVDMACMD_CHILD_STATUS_IRQ *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHILD_STATUS_IRQ);
    606 
    607     vboxWddmChildStatusDoReportReconnected(pDevExt, pBody);
    608 
    609     vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);
    610 
    611     if (pCtx->pEvent)
    612     {
    613         KeSetEvent(pCtx->pEvent, 0, FALSE);
    614     }
    615 }
    616 
    617 static NTSTATUS vboxWddmChildStatusReportReconnected(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID idTarget)
    618 {
    619 #ifdef VBOX_WDDM_MONITOR_REPLUG_IRQ
    620     NTSTATUS Status = STATUS_UNSUCCESSFUL;
    621     UINT cbCmd = VBOXVDMACMD_SIZE_FROMBODYSIZE(sizeof (VBOXVDMACMD_CHILD_STATUS_IRQ));
    622 
    623     PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate(&pDevExt->u.primary.Vdma, cbCmd);
    624     if (pDr)
    625     {
    626         // vboxVdmaCBufDrCreate zero initializes the pDr
    627         /* the command data follows the descriptor */
    628         pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
    629         pDr->cbBuf = cbCmd;
    630         pDr->rc = VERR_NOT_IMPLEMENTED;
    631 
    632         PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    633         pHdr->enmType = VBOXVDMACMD_TYPE_CHILD_STATUS_IRQ;
    634         pHdr->u32CmdSpecific = 0;
    635         PVBOXVDMACMD_CHILD_STATUS_IRQ pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHILD_STATUS_IRQ);
    636         pBody->cInfos = 1;
    637         if (idTarget == D3DDDI_ID_ALL)
    638         {
    639             pBody->fFlags |= VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL;
    640         }
    641         pBody->aInfos[0].iChild = idTarget;
    642         pBody->aInfos[0].fFlags = VBOXVDMA_CHILD_STATUS_F_DISCONNECTED | VBOXVDMA_CHILD_STATUS_F_CONNECTED;
    643         /* we're going to KeWaitForSingleObject */
    644         Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    645 
    646         PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
    647         VBOXWDDMCHILDSTATUSCB Ctx;
    648         KEVENT Event;
    649         KeInitializeEvent(&Event, NotificationEvent, FALSE);
    650         Ctx.pDr = pDr;
    651         Ctx.pEvent = &Event;
    652         vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxWddmChildStatusReportCompletion, &Ctx);
    653         /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
    654         vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
    655         int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
    656         Assert(rc == VINF_SUCCESS);
    657         if (RT_SUCCESS(rc))
    658         {
    659             Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
    660             Assert(Status == STATUS_SUCCESS);
    661             return STATUS_SUCCESS;
    662         }
    663 
    664         Status = STATUS_UNSUCCESSFUL;
    665 
    666         vboxVdmaCBufDrFree(&pDevExt->u.primary.Vdma, pDr);
    667     }
    668     else
    669     {
    670         Assert(0);
    671         /* @todo: try flushing.. */
    672         LOGREL(("vboxVdmaCBufDrCreate returned NULL"));
    673         Status = STATUS_INSUFFICIENT_RESOURCES;
    674     }
    675 
    676     return Status;
    677 #else
    678     VBOXVDMACMD_CHILD_STATUS_IRQ Body = {0};
    679     Body.cInfos = 1;
    680     if (idTarget == D3DDDI_ID_ALL)
    681     {
    682         Body.fFlags |= VBOXVDMACMD_CHILD_STATUS_IRQ_F_APPLY_TO_ALL;
    683     }
    684     Body.aInfos[0].iChild = idTarget;
    685     Body.aInfos[0].fFlags = VBOXVDMA_CHILD_STATUS_F_DISCONNECTED | VBOXVDMA_CHILD_STATUS_F_CONNECTED;
    686     Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    687     return vboxWddmChildStatusDoReportReconnected(pDevExt, &Body);
    688 #endif
    689 }
    690 
    691 static NTSTATUS vboxWddmChildStatusCheckByMask(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_VIDEOMODES_INFO paInfos, uint8_t *pMask)
    692 {
    693     NTSTATUS Status = STATUS_SUCCESS;
    694     bool bChanged[VBOX_VIDEO_MAX_SCREENS] = {0};
    695     int i;
    696 
    697     LOG(("checking child status.."));
    698 
    699     for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    700     {
    701         if (pMask && !ASMBitTest(pMask, i))
    702             continue;
    703 
    704         LOG(("requested to change child status for display %d", i));
    705 
    706         /* @todo: check that we actually need the current source->target */
    707         PVBOXWDDM_VIDEOMODES_INFO pInfo = &paInfos[i];
    708         VIDEO_MODE_INFORMATION *pModeInfo = &pInfo->aModes[pInfo->iPreferredMode];
    709         BOOLEAN fMatch = FALSE;
    710         Status = vboxVidPnMatchMonitorModes(pDevExt, i, pInfo->aResolutions, pInfo->cResolutions, &fMatch);
    711         if (!NT_SUCCESS(Status))
    712         {
    713             WARN(("vboxVidPnMatchMonitorModes failed Status(0x%x)", Status));
    714             /* ignore the failures here, although we probably should not?? */
    715             break;
    716         }
    717 
    718         bChanged[i] = !fMatch;
    719     }
    720 
    721     if (!NT_SUCCESS(Status))
    722     {
    723         WARN(("updating monitor modes failed, Status(0x%x)", Status));
    724         return Status;
    725     }
    726 
    727     for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    728     {
    729         if (bChanged[i])
    730         {
    731             LOG(("modes changed for display %d", i));
    732 
    733             NTSTATUS tmpStatus = vboxWddmChildStatusReportReconnected(pDevExt, i);
    734             if (!NT_SUCCESS(tmpStatus))
    735             {
    736                 WARN(("vboxWddmChildStatusReportReconnected failed Status(0x%x)", Status));
    737                 /* ignore the failures here, although we probably should not?? */
    738                 break;
    739             }
    740         }
    741     }
    742 
    743     /* wait for the reconnected monitor data to be picked up */
    744     CONST DXGK_MONITOR_INTERFACE *pMonitorInterface;
    745     Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryMonitorInterface(pDevExt->u.primary.DxgkInterface.DeviceHandle, DXGK_MONITOR_INTERFACE_VERSION_V1, &pMonitorInterface);
    746     if (!NT_SUCCESS(Status))
    747     {
    748         WARN(("DxgkCbQueryMonitorInterface failed, Status()0x%x", Status));
    749         return Status;
    750     }
    751 
    752     for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    753     {
    754         D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS;
    755         CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf;
    756         if (!bChanged[i])
    757             continue;
    758 
    759         while (1)
    760         {
    761             Status = pMonitorInterface->pfnAcquireMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle,
    762                                                 i,
    763                                                 &hMonitorSMS,
    764                                                 &pMonitorSMSIf);
    765             if (NT_SUCCESS(Status))
    766             {
    767                 NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hMonitorSMS);
    768                 if (!NT_SUCCESS(tmpStatus))
    769                 {
    770                     WARN(("pfnReleaseMonitorSourceModeSet failed tmpStatus(0x%x)", tmpStatus));
    771                 }
    772                 break;
    773             }
    774 
    775             if (Status != STATUS_GRAPHICS_MONITOR_NOT_CONNECTED)
    776             {
    777                 WARN(("DxgkCbQueryMonitorInterface failed, Status()0x%x", Status));
    778                 break;
    779             }
    780 
    781             Assert(KeGetCurrentIrql() < DISPATCH_LEVEL);
    782 
    783             LARGE_INTEGER Interval;
    784             Interval.QuadPart = -(int64_t) 2 /* ms */ * 10000;
    785             NTSTATUS tmpStatus = KeDelayExecutionThread(KernelMode, FALSE, &Interval);
    786             if (!NT_SUCCESS(tmpStatus))
    787             {
    788                 WARN(("KeDelayExecutionThread failed tmpStatus(0x%x)", tmpStatus));
    789             }
    790         }
    791     }
    792 
    793     return STATUS_SUCCESS;
    794497}
    795498
     
    1154857                    vboxVdmaDdiNodesInit(pDevExt);
    1155858                    vboxVideoCmInit(&pDevExt->CmMgr);
     859                    vboxVideoCmInit(&pDevExt->SeamlessCtxMgr);
    1156860                    InitializeListHead(&pDevExt->SwapchainList3D);
    1157861                    pDevExt->cContexts3D = 0;
    1158862                    pDevExt->cContexts2D = 0;
     863                    pDevExt->cContextsDispIfResize = 0;
    1159864                    pDevExt->cUnlockedVBVADisabled = 0;
    1160865                    VBOXWDDM_CTXLOCK_INIT(pDevExt);
     
    1162867
    1163868                    VBoxMPCmnInitCustomVideoModes(pDevExt);
    1164                     VBoxWddmInvalidateAllVideoModesInfos(pDevExt);
    1165869
    1166870                    VBoxCommonFromDeviceExt(pDevExt)->fAnyX = VBoxVideoAnyWidthAllowed();
     
    1192896                    }
    1193897
     898                    DWORD dwVal = VBOXWDDM_CFG_DRV_DEFAULT;
     899                    HANDLE hKey = NULL;
     900                    WCHAR aNameBuf[100];
     901
     902                    Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_READ, &hKey);
     903                    if (!NT_SUCCESS(Status))
     904                    {
     905                        WARN(("IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
     906                        hKey = NULL;
     907                    }
     908
     909
     910                    if (hKey)
     911                    {
     912                        Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DRV_FLAGS_NAME, &dwVal);
     913                        if (!NT_SUCCESS(Status))
     914                        {
     915                            LOG(("vboxWddmRegQueryValueDword failed, Status = 0x%x", Status));
     916                            dwVal = VBOXWDDM_CFG_DRV_DEFAULT;
     917                        }
     918                    }
     919
     920                    pDevExt->dwDrvCfgFlags = dwVal;
     921
     922                    for (UINT i = 0; i < (UINT)VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     923                    {
     924                        PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
     925                        if (i == 0 || (pDevExt->dwDrvCfgFlags & VBOXWDDM_CFG_DRV_SECONDARY_TARGETS_CONNECTED) || !hKey)
     926                        {
     927                            pTarget->fConnected = true;
     928                            pTarget->fConfigured = true;
     929                        }
     930                        else if (hKey)
     931                        {
     932                            swprintf(aNameBuf, L"%s%d", VBOXWDDM_REG_DRV_DISPFLAGS_PREFIX, i);
     933                            Status = vboxWddmRegQueryValueDword(hKey, aNameBuf, &dwVal);
     934                            if (NT_SUCCESS(Status))
     935                            {
     936                                pTarget->fConnected = !!(dwVal & VBOXWDDM_CFG_DRVTARGET_CONNECTED);
     937                                pTarget->fConfigured = true;
     938                            }
     939                            else
     940                            {
     941                                WARN(("vboxWddmRegQueryValueDword failed, Status = 0x%x", Status));
     942                                pTarget->fConnected = false;
     943                                pTarget->fConfigured = false;
     944                            }
     945                        }
     946                    }
     947
     948                    if (hKey)
     949                    {
     950                        NTSTATUS tmpStatus = ZwClose(hKey);
     951                        Assert(tmpStatus == STATUS_SUCCESS);
     952                    }
     953
     954                    Status = STATUS_SUCCESS;
    1194955#ifdef VBOX_WDDM_WIN8
    1195956                    DXGK_DISPLAY_INFORMATION DisplayInfo;
     
    1230991                    }
    1231992#endif
     993
     994                    VBoxWddmInitVideoModes(pDevExt);
    1232995                }
    1233996                else
     
    12801043
    12811044    vboxVideoCmTerm(&pDevExt->CmMgr);
     1045
     1046    vboxVideoCmTerm(&pDevExt->SeamlessCtxMgr);
    12821047
    12831048    /* do everything we did on DxgkDdiStartDevice in the reverse order */
     
    16911456        ChildRelations[i].ChildDeviceType = TypeVideoOutput;
    16921457        ChildRelations[i].ChildCapabilities.Type.VideoOutput.InterfaceTechnology = D3DKMDT_VOT_HD15; /* VGA */
    1693         ChildRelations[i].ChildCapabilities.Type.VideoOutput.MonitorOrientationAwareness = D3DKMDT_MOA_INTERRUPTIBLE; /* ?? D3DKMDT_MOA_NONE*/
     1458        ChildRelations[i].ChildCapabilities.Type.VideoOutput.MonitorOrientationAwareness = D3DKMDT_MOA_NONE; //D3DKMDT_MOA_INTERRUPTIBLE; /* ?? D3DKMDT_MOA_NONE*/
    16941459        ChildRelations[i].ChildCapabilities.Type.VideoOutput.SupportsSdtvModes = FALSE;
    16951460        ChildRelations[i].ChildCapabilities.HpdAwareness = HpdAwarenessInterruptible; /* ?? HpdAwarenessAlwaysConnected; */
     
    17141479    LOGF(("ENTER, context(0x%x)", MiniportDeviceContext));
    17151480
     1481    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)MiniportDeviceContext;
     1482
    17161483    NTSTATUS Status = STATUS_SUCCESS;
    17171484    switch (ChildStatus->Type)
    17181485    {
    17191486        case StatusConnection:
    1720             ChildStatus->HotPlug.Connected = TRUE;
     1487        {
    17211488            LOGF(("StatusConnection"));
     1489            VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[ChildStatus->ChildUid];
     1490            ChildStatus->HotPlug.Connected = !!pTarget->fConnected;
    17221491            break;
     1492        }
    17231493        case StatusRotation:
     1494            LOGF(("StatusRotation"));
    17241495            ChildStatus->Rotation.Angle = 0;
    1725             LOGF(("StatusRotation"));
    17261496            break;
    17271497        default:
    1728             LOGREL(("ERROR: status type: %d", ChildStatus->Type));
    1729             AssertBreakpoint();
     1498            WARN(("ERROR: status type: %d", ChildStatus->Type));
    17301499            Status = STATUS_INVALID_PARAMETER;
    17311500            break;
     
    29932762            VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pS2P->Shadow2Primary.VidPnSourceId];
    29942763            PVBOXWDDM_ALLOCATION pSrcAlloc = pS2P->Shadow2Primary.ShadowAlloc.pAlloc;
    2995             vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
     2764            BOOLEAN fShadowChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
     2765            if (fShadowChanged)
     2766                pSource->fGhSynced = 0;
    29962767            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
    29972768            vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     
    30192790            PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
    30202791            PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
     2792            BOOLEAN fSrcChanged;
    30212793
    30222794            vboxWddmAddrSetVram(&pDstAlloc->AllocData.Addr, pBlt->Blt.DstAlloc.segmentIdAlloc, pBlt->Blt.DstAlloc.offAlloc);
    3023             vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
     2795            fSrcChanged = vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
    30242796
    30252797            if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc))
     
    30292801
    30302802                if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
     2803                {
     2804                    if (fSrcChanged)
     2805                        pSource->fGhSynced = 0;
     2806
    30312807                    vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId);
     2808                }
    30322809                vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    30332810                if(pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D
     
    39103687            case VBOXESC_SETVISIBLEREGION:
    39113688            {
     3689                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
     3690                if (!pContext)
     3691                {
     3692                    WARN(("VBOXESC_SETVISIBLEREGION no context supplied!"));
     3693                    Status = STATUS_INVALID_PARAMETER;
     3694                    break;
     3695                }
     3696
     3697                if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS)
     3698                {
     3699                    WARN(("VBOXESC_SETVISIBLEREGION invalid context supplied %d!", pContext->enmType));
     3700                    Status = STATUS_INVALID_PARAMETER;
     3701                    break;
     3702                }
     3703
    39123704                /* visible regions for seamless */
    39133705                LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(pEscapeHdr, RGNDATA);
     
    39483740                        rc = VbglGRPerform (&req->header);
    39493741                        AssertRC(rc);
    3950                         if (!RT_SUCCESS(rc))
     3742                        if (RT_SUCCESS(rc))
     3743                            Status = STATUS_SUCCESS;
     3744                        else
    39513745                        {
    3952                             LOGREL(("VbglGRPerform failed rc (%d)", rc));
     3746                            WARN(("VbglGRPerform failed rc (%d)", rc));
    39533747                            Status = STATUS_UNSUCCESSFUL;
    39543748                        }
     
    39563750                    else
    39573751                    {
    3958                         LOGREL(("VbglGRAlloc failed rc (%d)", rc));
     3752                        WARN(("VbglGRAlloc failed rc (%d)", rc));
    39593753                        Status = STATUS_UNSUCCESSFUL;
    39603754                    }
     
    39623756                else
    39633757                {
    3964                     LOGREL(("VBOXESC_SETVISIBLEREGION: incorrect buffer size (%d), reported count (%d)", cbRects, lpRgnData->rdh.nCount));
    3965                     AssertBreakpoint();
     3758                    WARN(("VBOXESC_SETVISIBLEREGION: incorrect buffer size (%d), reported count (%d)", cbRects, lpRgnData->rdh.nCount));
    39663759                    Status = STATUS_INVALID_PARAMETER;
    39673760                }
     
    40543847            case VBOXESC_REINITVIDEOMODES:
    40553848            {
    4056                 if (pEscape->Flags.HardwareAccess)
    4057                 {
    4058                     WARN(("VBOXESC_REINITVIDEOMODES called with HardwareAccess flag set, failing"));
     3849                if (!pEscape->Flags.HardwareAccess)
     3850                {
     3851                    WARN(("VBOXESC_REINITVIDEOMODESBYMASK called without HardwareAccess flag set, failing"));
    40593852                    Status = STATUS_INVALID_PARAMETER;
    40603853                    break;
    40613854                }
    4062                 WARN(("VBOXESC_REINITVIDEOMODESBYMASK should be called instead"));
    4063                 PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateAllVideoModesInfos(pDevExt);
    4064                 Status = vboxWddmChildStatusCheckByMask(pDevExt, pInfos, NULL);
    4065                 if (!NT_SUCCESS(Status))
    4066                 {
    4067                     WARN(("vboxWddmChildStatusCheckByMask failed, Status 0x%x", Status));
    4068                 }
    4069                 break;
    4070             }
    4071             case VBOXESC_REINITVIDEOMODESBYMASK:
    4072             {
    4073                 BOOLEAN fCheckDisplayRecconect = (pEscapeHdr->u32CmdSpecific & VBOXWDDM_REINITVIDEOMODESBYMASK_F_RECONNECT_DISPLAYS_ON_CHANGE);
    4074                 if (fCheckDisplayRecconect && pEscape->Flags.HardwareAccess)
    4075                 {
    4076                     WARN(("VBOXESC_REINITVIDEOMODESBYMASK called with HardwareAccess flag set, failing"));
     3855
     3856                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
     3857                if (!pContext)
     3858                {
     3859                    WARN(("VBOXESC_REINITVIDEOMODES no context supplied!"));
    40773860                    Status = STATUS_INVALID_PARAMETER;
    40783861                    break;
    40793862                }
     3863
     3864                if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
     3865                {
     3866                    WARN(("VBOXESC_REINITVIDEOMODES invalid context supplied %d!", pContext->enmType));
     3867                    Status = STATUS_INVALID_PARAMETER;
     3868                    break;
     3869                }
     3870
     3871                WARN(("VBOXESC_REINITVIDEOMODESBYMASK should be called instead"));
     3872                VBoxWddmUpdateVideoModesInfoByMask(pDevExt, NULL);
     3873                Status = STATUS_SUCCESS;
     3874                break;
     3875            }
     3876            case VBOXESC_REINITVIDEOMODESBYMASK:
     3877            {
     3878                if (!pEscape->Flags.HardwareAccess)
     3879                {
     3880                    WARN(("VBOXESC_REINITVIDEOMODESBYMASK called without HardwareAccess flag set, failing"));
     3881                    Status = STATUS_INVALID_PARAMETER;
     3882                    break;
     3883                }
     3884
     3885                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
     3886                if (!pContext)
     3887                {
     3888                    WARN(("VBOXESC_REINITVIDEOMODESBYMASK no context supplied!"));
     3889                    Status = STATUS_INVALID_PARAMETER;
     3890                    break;
     3891                }
     3892
     3893                if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
     3894                {
     3895                    WARN(("VBOXESC_REINITVIDEOMODESBYMASK invalid context supplied %d!", pContext->enmType));
     3896                    Status = STATUS_INVALID_PARAMETER;
     3897                    break;
     3898                }
     3899
    40803900                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK))
    40813901                {
     
    40863906                LOG(("=> VBOXESC_REINITVIDEOMODESBYMASK"));
    40873907                PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK pData = (PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK)pEscapeHdr;
    4088                 PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateVideoModesInfoByMask(pDevExt, pData->ScreenMask);
    4089                 if (fCheckDisplayRecconect)
    4090                 {
    4091                     Status = vboxWddmChildStatusCheckByMask(pDevExt, pInfos, pData->ScreenMask);
     3908                VBoxWddmUpdateVideoModesInfoByMask(pDevExt, pData->ScreenMask);
     3909                Status = STATUS_SUCCESS;
     3910                LOG(("<= VBOXESC_REINITVIDEOMODESBYMASK"));
     3911                break;
     3912            }
     3913            case VBOXESC_CONFIGURETARGETS:
     3914            {
     3915                LOG(("=> VBOXESC_CONFIGURETARGETS"));
     3916
     3917                if (!pEscape->Flags.HardwareAccess)
     3918                {
     3919                    WARN(("VBOXESC_CONFIGURETARGETS called without HardwareAccess flag set, failing"));
     3920                    Status = STATUS_INVALID_PARAMETER;
     3921                    break;
     3922                }
     3923
     3924                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
     3925                if (!pContext)
     3926                {
     3927                    WARN(("VBOXESC_CONFIGURETARGETS no context supplied!"));
     3928                    Status = STATUS_INVALID_PARAMETER;
     3929                    break;
     3930                }
     3931
     3932                if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE)
     3933                {
     3934                    WARN(("VBOXESC_CONFIGURETARGETS invalid context supplied %d!", pContext->enmType));
     3935                    Status = STATUS_INVALID_PARAMETER;
     3936                    break;
     3937                }
     3938
     3939                if (pEscape->PrivateDriverDataSize != sizeof (*pEscapeHdr))
     3940                {
     3941                    WARN(("VBOXESC_CONFIGURETARGETS invalid private driver size %d", pEscape->PrivateDriverDataSize));
     3942                    Status = STATUS_INVALID_PARAMETER;
     3943                    break;
     3944                }
     3945
     3946                if (pEscapeHdr->u32CmdSpecific)
     3947                {
     3948                    WARN(("VBOXESC_CONFIGURETARGETS invalid command %d", pEscapeHdr->u32CmdSpecific));
     3949                    Status = STATUS_INVALID_PARAMETER;
     3950                    break;
     3951                }
     3952
     3953                HANDLE hKey = NULL;
     3954                WCHAR aNameBuf[100];
     3955                uint32_t cAdjusted = 0;
     3956
     3957                for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     3958                {
     3959                    VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i];
     3960                    if (pTarget->fConfigured)
     3961                        continue;
     3962
     3963                    pTarget->fConfigured = true;
     3964
     3965                    if (!pTarget->fConnected)
     3966                    {
     3967                        Status = vboxWddmChildStatusConnect(pDevExt, (uint32_t)i, TRUE);
     3968                        if (NT_SUCCESS(Status))
     3969                            ++cAdjusted;
     3970                        else
     3971                            WARN(("VBOXESC_CONFIGURETARGETS vboxWddmChildStatusConnectSecondaries failed Status 0x%x\n", Status));
     3972                    }
     3973
     3974                    if (!hKey)
     3975                    {
     3976                        Status = IoOpenDeviceRegistryKey(pDevExt->pPDO, PLUGPLAY_REGKEY_DRIVER, GENERIC_WRITE, &hKey);
     3977                        if (!NT_SUCCESS(Status))
     3978                        {
     3979                            WARN(("VBOXESC_CONFIGURETARGETS IoOpenDeviceRegistryKey failed, Status = 0x%x", Status));
     3980                            hKey = NULL;
     3981                            continue;
     3982                        }
     3983                    }
     3984
     3985                    Assert(hKey);
     3986
     3987                    swprintf(aNameBuf, L"%s%d", VBOXWDDM_REG_DRV_DISPFLAGS_PREFIX, i);
     3988                    Status = vboxWddmRegSetValueDword(hKey, aNameBuf, VBOXWDDM_CFG_DRVTARGET_CONNECTED);
    40923989                    if (!NT_SUCCESS(Status))
    4093                     {
    4094                         WARN(("vboxWddmChildStatusCheckByMask failed, Status 0x%x", Status));
    4095                     }
    4096                 }
    4097                 LOG(("<= VBOXESC_REINITVIDEOMODESBYMASK"));
     3990                        WARN(("VBOXESC_CONFIGURETARGETS vboxWddmRegSetValueDword (%d) failed Status 0x%x\n", aNameBuf, Status));
     3991
     3992                }
     3993
     3994                if (hKey)
     3995                {
     3996                    NTSTATUS tmpStatus = ZwClose(hKey);
     3997                    Assert(tmpStatus == STATUS_SUCCESS);
     3998                }
     3999
     4000                pEscapeHdr->u32CmdSpecific = cAdjusted;
     4001
     4002                Status = STATUS_SUCCESS;
     4003
     4004                LOG(("<= VBOXESC_CONFIGURETARGETS"));
    40984005                break;
    40994006            }
     
    42214128            }
    42224129            default:
    4223                 Assert(0);
    4224                 LOGREL(("unsupported escape code (0x%x)", pEscapeHdr->escapeCode));
     4130                WARN(("unsupported escape code (0x%x)", pEscapeHdr->escapeCode));
    42254131                break;
    42264132        }
     
    42284134    else
    42294135    {
    4230         LOGREL(("pEscape->PrivateDriverDataSize(%d) < (%d)", pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE)));
    4231         AssertBreakpoint();
     4136        WARN(("pEscape->PrivateDriverDataSize(%d) < (%d)", pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE)));
    42324137        Status = STATUS_BUFFER_TOO_SMALL;
    42334138    }
     
    43154220
    43164221    NTSTATUS Status = STATUS_SUCCESS;
    4317     BOOLEAN bSupported = TRUE;
    43184222
    43194223    PVBOXMP_DEVEXT pContext = (PVBOXMP_DEVEXT)hAdapter;
     
    43394243    }
    43404244
    4341     VBOXVIDPNPATHITEM aItems[VBOX_VIDEO_MAX_SCREENS];
    4342     BOOLEAN fDisabledFound = FALSE;
    4343     Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, TRUE /* fBreakOnDisabled */, RT_ELEMENTS(aItems), aItems, &fDisabledFound);
    4344     Assert(Status == STATUS_SUCCESS);
     4245    BOOLEAN fSupported = FALSE;
     4246    Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, &fSupported);
    43454247    if (!NT_SUCCESS(Status))
    43464248    {
     
    43494251    }
    43504252
    4351     if (fDisabledFound)
    4352     {
     4253    if (!fSupported)
    43534254        LOG(("found unsupported path"));
    4354         bSupported = FALSE;
    4355     }
    4356 
    4357     pIsSupportedVidPnArg->IsVidPnSupported = bSupported;
     4255
     4256    pIsSupportedVidPnArg->IsVidPnSupported = fSupported;
    43584257
    43594258#ifdef VBOXWDDM_DEBUG_VIDPN
     
    43804279    vboxVDbgBreakFv();
    43814280
     4281#ifdef DEBUG_misha
     4282    Assert(0);
     4283#endif
     4284
    43824285    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
    43834286    NTSTATUS Status;
    43844287    PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = pRecommendFunctionalVidPnArg->PrivateDriverDataSize >= sizeof (VBOXWDDM_RECOMMENDVIDPN) ?
    43854288            (PVBOXWDDM_RECOMMENDVIDPN)pRecommendFunctionalVidPnArg->pPrivateDriverData : NULL;
    4386     PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateAllVideoModesInfos(pDevExt);
     4289    PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);
    43874290    int i;
    43884291
     
    45294432    }
    45304433
    4531     VBOXVIDPNPATHITEM aItems[VBOX_VIDEO_MAX_SCREENS];
    4532     Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, FALSE /* fBreakOnDisabled */, RT_ELEMENTS(aItems), aItems, NULL /* *pfDisabledFound */);
    4533     Assert(Status == STATUS_SUCCESS);
     4434#ifdef DEBUG_misha
     4435    BOOLEAN fSupported = FALSE;
     4436    Status = vboxVidPnCheckTopology(hVidPnTopology, pVidPnTopologyInterface, &fSupported);
    45344437    if (!NT_SUCCESS(Status))
    45354438    {
     
    45384441    }
    45394442
     4443    Assert(fSupported);
     4444#endif
    45404445    VBOXVIDPNCOFUNCMODALITY CbContext = {0};
    45414446    CbContext.pDevExt = pDevExt;
     
    45434448    CbContext.pEnumCofuncModalityArg = pEnumCofuncModalityArg;
    45444449    CbContext.pInfos = VBoxWddmGetAllVideoModesInfos(pDevExt);
    4545     CbContext.cPathInfos = RT_ELEMENTS(aItems);
    4546     CbContext.apPathInfos = aItems;
    45474450
    45484451    Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
    45494452                    vboxVidPnCofuncModalityPathEnum, &CbContext);
    4550     Assert(Status == STATUS_SUCCESS);
    45514453    if (!NT_SUCCESS(Status))
    45524454    {
     
    47054607}
    47064608
    4707 
    47084609NTSTATUS
    47094610APIENTRY
     
    47164617
    47174618    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
    4718     uint32_t au32OldHeightVisible[VBOX_VIDEO_MAX_SCREENS];
    47194619    NTSTATUS Status;
    47204620
    47214621    vboxVDbgBreakFv();
    4722 
    4723     /* we first store the current visible height for each target (monitor)
    4724      * and then we will zero up it for targets either for the given source
    4725      * (in case pCommitVidPnArg->AffectedVidPnSourceId != D3DDDI_ID_ALL)
    4726      * or all targets otherwize.
    4727      * In the end we will match the old and new visible height for all targets to see if
    4728      * some of them become inactivated and hide them accordingly,
    4729      * or we will restore the old height values on failure */
    4730     for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    4731     {
    4732         PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
    4733         au32OldHeightVisible[i] = pTarget->HeightVisible;
    4734     }
    47354622
    47364623    do {
     
    48404727        pDevExt->u.primary.hCommittedVidPn = pCommitVidPnArg->hFunctionalVidPn;
    48414728
    4842         for (int i = 1; /* <- never try to hide a primary monitor */
    4843                 i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     4729        for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    48444730        {
    48454731            PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
    4846             if (!pTarget->HeightVisible && !!au32OldHeightVisible[i])
    4847             {
    4848                 /* the target was previously visible */
    4849                 vboxWddmGhDisplayHideScreen(pDevExt, i);
    4850             }
    4851         }
    4852 
    4853 //#ifdef VBOX_WDDM_WIN8
    4854 //        if (g_VBoxDisplayOnly)
    4855         {
    4856             for (int i = 0; /* <- never try to hide a primary monitor */
    4857                     i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    4858             {
    4859                 PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
    4860                 if (pSource->bVisible)
    4861                 {
     4732            PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
     4733            uint32_t cAutoresizes = pDevExt->cContextsDispIfResize;
     4734            if (!cAutoresizes)
     4735            {
     4736                if (pSource->bVisible || !pTarget->HeightVisible)
    48624737                    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    4863                 }
    4864             }
    4865         }
    4866 //#endif
     4738            }
     4739            else
     4740                pTarget->fStateSyncPening = true;
     4741        }
     4742
    48674743        LOGF(("LEAVE, SUCCESS status(0x%x), context(0x%x)", Status, hAdapter));
    48684744
     
    48714747
    48724748    AssertRelease(!NT_SUCCESS(Status));
    4873     /* failure branch restore original visible height values, see comments above */
    4874     for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    4875     {
    4876         PVBOXWDDM_TARGET pTarget = &pDevExt->aTargets[i];
    4877         pTarget->HeightVisible = au32OldHeightVisible[i];
    4878     }
    48794749
    48804750    LOGF(("LEAVE, !!FAILURE!! status(0x%x), context(0x%x)", Status, hAdapter));
     
    58485718                        break;
    58495719                    }
     5720                    case VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE:
     5721                    {
     5722                        pContext->enmType = pInfo->enmType;
     5723                        ASMAtomicIncU32(&pDevExt->cContextsDispIfResize);
     5724                        break;
     5725                    }
     5726                    case VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS:
     5727                    {
     5728                        pContext->enmType = pInfo->enmType;
     5729                        Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->SeamlessCtxMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
     5730                        if (!NT_SUCCESS(Status))
     5731                        {
     5732                            WARN(("vboxVideoCmCtxAdd failed, Status 0x%x", Status));
     5733                        }
     5734                        break;
     5735                    }
    58505736                    default:
    58515737                    {
    5852                         Assert(0);
     5738                        WARN(("unsupported context type %d", pInfo->enmType));
    58535739                        Status = STATUS_INVALID_PARAMETER;
    58545740                        break;
     
    58915777    PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
    58925778    PVBOXMP_DEVEXT pDevExt = pContext->pDevice->pAdapter;
     5779    NTSTATUS Status = STATUS_SUCCESS;
     5780
    58935781    switch(pContext->enmType)
    58945782    {
     
    59055793            uint32_t cContexts = ASMAtomicDecU32(&pDevExt->cContexts2D);
    59065794            Assert(cContexts < UINT32_MAX/2);
     5795            break;
     5796        }
     5797        case VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_RESIZE:
     5798        {
     5799            uint32_t cContexts = ASMAtomicDecU32(&pDevExt->cContextsDispIfResize);
     5800            Assert(cContexts < UINT32_MAX/2);
     5801            if (!cContexts)
     5802            {
     5803                for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     5804                {
     5805                    vboxWddmGhDisplayCheckCompletePeningScreenInfo(pDevExt, i);
     5806                }
     5807            }
     5808            break;
     5809        }
     5810        case VBOXWDDM_CONTEXT_TYPE_CUSTOM_DISPIF_SEAMLESS:
     5811        {
     5812            Status = vboxVideoCmCtxRemove(&pContext->pDevice->pAdapter->SeamlessCtxMgr, &pContext->CmContext);
     5813            if (!NT_SUCCESS(Status))
     5814                WARN(("vboxVideoCmCtxRemove failed, Status 0x%x", Status));
     5815
     5816            Assert(pContext->CmContext.pSession == NULL);
    59075817            break;
    59085818        }
     
    59235833    vboxWddmSwapchainCtxTerm(pDevExt, pContext);
    59245834
    5925     NTSTATUS Status = vboxVideoAMgrCtxDestroy(&pContext->AllocContext);
    5926     Assert(Status == STATUS_SUCCESS);
    5927     if (Status == STATUS_SUCCESS)
     5835    Status = vboxVideoAMgrCtxDestroy(&pContext->AllocContext);
     5836    if (NT_SUCCESS(Status))
    59285837    {
    59295838        Status = vboxVideoCmCtxRemove(&pContext->pDevice->pAdapter->CmMgr, &pContext->CmContext);
    5930         Assert(Status == STATUS_SUCCESS);
    5931         if (Status == STATUS_SUCCESS)
    5932         {
     5839        if (NT_SUCCESS(Status))
    59335840            vboxWddmMemFree(pContext);
    5934         }
    5935     }
     5841        else
     5842            WARN(("vboxVideoCmCtxRemove failed, Status 0x%x", Status));
     5843    }
     5844    else
     5845        WARN(("vboxVideoAMgrCtxDestroy failed, Status 0x%x", Status));
    59365846
    59375847    LOGF(("LEAVE, hContext(0x%x)", hContext));
  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h

    r47063 r48070  
    3737//#define VBOXWDDM_DEBUG_VIDPN
    3838
     39#define VBOXWDDM_CFG_DRV_DEFAULT                        0
     40#define VBOXWDDM_CFG_DRV_SECONDARY_TARGETS_CONNECTED    1
     41
     42#define VBOXWDDM_CFG_DRVTARGET_CONNECTED                1
     43
    3944#define VBOXWDDM_CFG_LOG_UM_BACKDOOR 0x00000001
    4045#define VBOXWDDM_CFG_LOG_UM_DBGPRINT 0x00000002
    4146#define VBOXWDDM_CFG_STR_LOG_UM L"VBoxLogUm"
     47
     48#define VBOXWDDM_REG_DRV_FLAGS_NAME L"VBoxFlags"
     49#define VBOXWDDM_REG_DRV_DISPFLAGS_PREFIX L"VBoxDispFlags"
     50
     51#define VBOXWDDM_REG_DRVKEY_PREFIX L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\"
     52
     53#define VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Video\\"
     54#define VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY L"\\Video"
     55
     56
     57#define VBOXWDDM_REG_DISPLAYSETTINGSKEY_PREFIX_VISTA L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Control\\VIDEO\\"
     58#define VBOXWDDM_REG_DISPLAYSETTINGSKEY_PREFIX_WIN7 L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\UnitedVideo\\CONTROL\\VIDEO\\"
     59
     60#define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELX L"Attach.RelativeX"
     61#define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELY L"Attach.RelativeY"
     62#define VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_DESKTOP L"Attach.ToDesktop"
     63
    4264extern DWORD g_VBoxLogUm;
    4365
     
    81103}
    82104
    83 DECLINLINE(VOID) vboxWddmAddrSetVram(PVBOXWDDM_ADDR pAddr, UINT SegmentId, VBOXVIDEOOFFSET offVram)
    84 {
     105DECLINLINE(BOOLEAN) vboxWddmAddrSetVram(PVBOXWDDM_ADDR pAddr, UINT SegmentId, VBOXVIDEOOFFSET offVram)
     106{
     107    if (pAddr->SegmentId == SegmentId && pAddr->offVram == offVram)
     108        return FALSE;
     109
    85110    pAddr->SegmentId = SegmentId;
    86111    pAddr->offVram = offVram;
     112    return TRUE;
    87113}
    88114
     
    191217    return pPrimary;
    192218}
     219
     220bool vboxWddmGhDisplayCheckSetInfoFromSource(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_SOURCE pSource);
    193221
    194222#define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))
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