Changeset 42217 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video/mp

Timestamp:

Jul 18, 2012 8:41:29 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

79234

Message:

wddm: autoresize, etc. fixes, more to follow..

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp

Files:

• common/VBoxMPCommon.h (modified) (2 diffs)
• common/VBoxMPVidModes.cpp (modified) (3 diffs)
• wddm/VBoxMPVidPn.cpp (modified) (7 diffs)
• wddm/VBoxMPWddm.cpp (modified) (7 diffs)

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

@@ -42 +42 @@
 
 #ifdef VBOX_WDDM_MINIPORT
-void VBoxWddmInvalidateVideoModesInfo(PVBOXMP_DEVEXT pExt);
-PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfo(PVBOXMP_DEVEXT pExt, PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo);
+void VBoxWddmInvalidateAllVideoModesInfos(PVBOXMP_DEVEXT pExt);
+void VBoxWddmInvalidateVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);
+PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfoByMask(PVBOXMP_DEVEXT pExt, uint8_t *pScreenIdMask);
+PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateAllVideoModesInfos(PVBOXMP_DEVEXT pExt);
 NTSTATUS VBoxWddmGetModesForResolution(VIDEO_MODE_INFORMATION *pAllModes, uint32_t cAllModes, int iSearchPreferredMode,
                                        const D3DKMDT_2DREGION *pResolution, VIDEO_MODE_INFORMATION * pModes,
@@ -50 +52 @@
 PVBOXWDDM_VIDEOMODES_INFO VBoxWddmGetVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId);
 bool VBoxWddmFillMode(VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h);
+bool VBoxWddmFillMode(VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h);
+void VBoxWddmAdjustMode(PVBOXMP_DEVEXT pExt, PVBOXWDDM_ADJUSTVIDEOMODE pMode);
+void VBoxWddmAdjustModes(PVBOXMP_DEVEXT pExt, uint32_t cModes, PVBOXWDDM_ADJUSTVIDEOMODE aModes);
 #endif
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPVidModes.cpp

@@ -1090 +1090 @@
 }
 
-void VBoxWddmInvalidateVideoModesInfo(PVBOXMP_DEVEXT pExt)
-{
+void VBoxWddmInvalidateVideoModesInfo(PVBOXMP_DEVEXT pExt, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
+{
+    if (VidPnTargetId != D3DDDI_ID_ALL)
+    {
+        if (VidPnTargetId >= RT_ELEMENTS(g_aVBoxVideoModeInfos))
+        {
+            WARN(("VidPnTargetId (%d) must be less than (%d)", VidPnTargetId, RT_ELEMENTS(g_aVBoxVideoModeInfos)));
+            return;
+        }
+        g_aVBoxVideoModeInfos[VidPnTargetId].cModes = 0;
+        return;
+    }
+
     for (UINT i = 0; i < RT_ELEMENTS(g_aVBoxVideoModeInfos); ++i)
     {
@@ -1098 +1109 @@
 }
 
-PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfo(PVBOXMP_DEVEXT pExt, PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo)
-{
-    VBoxWddmInvalidateVideoModesInfo(pExt);
-
-    if (pVidPnInfo)
-    {
-        for (UINT i = 0; i < pVidPnInfo->cScreenInfos; ++i)
-        {
-            PVBOXWDDM_RECOMMENDVIDPN_SCREEN_INFO pScreenInfo = &pVidPnInfo->aScreenInfos[i];
-            Assert(pScreenInfo->Id < (DWORD)VBoxCommonFromDeviceExt(pExt)->cDisplays);
-            if (pScreenInfo->Id < (DWORD)VBoxCommonFromDeviceExt(pExt)->cDisplays)
-            {
-                PVBOXWDDM_VIDEOMODES_INFO pInfo = &g_aVBoxVideoModeInfos[pScreenInfo->Id];
-                VIDEO_MODE_INFORMATION ModeInfo = {0};
-                D3DDDIFORMAT enmFormat;
-                switch (pScreenInfo->BitsPerPixel)
-                {
-                    case 32:
-                        enmFormat = D3DDDIFMT_A8R8G8B8;
-                        break;
-                    case 24:
-                        enmFormat = D3DDDIFMT_R8G8B8;
-                        break;
-                    case 16:
-                        enmFormat = D3DDDIFMT_R5G6B5;
-                        break;
-                    case 8:
-                        enmFormat = D3DDDIFMT_P8;
-                        break;
-                    default:
-                        Assert(0);
-                        enmFormat = D3DDDIFMT_UNKNOWN;
-                        break;
-                }
-                if (enmFormat != D3DDDIFMT_UNKNOWN)
-                {
-                    if (VBoxWddmFillMode(pExt, pScreenInfo->Id, &ModeInfo, enmFormat, pScreenInfo->Width, pScreenInfo->Height))
-                    {
-                        VBoxWddmBuildVideoModesInfo(pExt, pScreenInfo->Id, pInfo, &ModeInfo, 1);
-                    }
-                    else
-                    {
-                        Assert(0);
-                    }
-                }
-            }
-        }
+void VBoxWddmInvalidateAllVideoModesInfos(PVBOXMP_DEVEXT pExt)
+{
+    VBoxWddmInvalidateVideoModesInfo(pExt, D3DDDI_ID_ALL);
+}
+
+PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateVideoModesInfoByMask(PVBOXMP_DEVEXT pExt, uint8_t *pScreenIdMask)
+{
+    for (int i = 0; i < VBoxCommonFromDeviceExt(pExt)->cDisplays; ++i)
+    {
+        if (ASMBitTest(pScreenIdMask, i))
+            VBoxWddmInvalidateVideoModesInfo(pExt, i);
     }
 
@@ -1150 +1125 @@
     VBoxWddmGetAllVideoModesInfos(pExt);
     return g_aVBoxVideoModeInfos;
+}
+
+PVBOXWDDM_VIDEOMODES_INFO VBoxWddmUpdateAllVideoModesInfos(PVBOXMP_DEVEXT pExt)
+{
+    VBoxWddmInvalidateAllVideoModesInfos(pExt);
+
+    /* ensure we have all the rest populated */
+    VBoxWddmGetAllVideoModesInfos(pExt);
+    return g_aVBoxVideoModeInfos;
+}
+
+void VBoxWddmAdjustMode(PVBOXMP_DEVEXT pExt, PVBOXWDDM_ADJUSTVIDEOMODE pMode)
+{
+    pMode->fFlags = 0;
+
+    if (pMode->Mode.Id >= (UINT)VBoxCommonFromDeviceExt(pExt)->cDisplays)
+    {
+        WARN(("invalid screen id (%d)", pMode->Mode.Id));
+        pMode->fFlags = VBOXWDDM_ADJUSTVIDEOMODE_F_INVALISCREENID;
+        return;
+    }
+
+    PVBOXWDDM_TARGET pTarget = &pExt->aTargets[pMode->Mode.Id];
+    /* @todo: this info should go from the target actually */
+    PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id];
+    if (pTarget->HeightVisible /* <- active */
+            && pSource->AllocData.SurfDesc.width == pMode->Mode.Width
+            && pSource->AllocData.SurfDesc.height == pMode->Mode.Height
+            && pSource->AllocData.SurfDesc.bpp == pMode->Mode.BitsPerPixel)
+    {
+        pMode->fFlags = VBOXWDDM_ADJUSTVIDEOMODE_F_CURRENT;
+        return;
+    }
+
+    UINT newWidth = pMode->Mode.Width;
+    UINT newHeight = pMode->Mode.Height;
+    UINT newBpp = pMode->Mode.BitsPerPixel;
+
+    if (!VBoxMPValidateVideoModeParams(pExt, pMode->Mode.Id, newWidth, newHeight, newBpp))
+    {
+        PVBOXWDDM_SOURCE pSource = &pExt->aSources[pMode->Mode.Id];
+        pMode->fFlags = VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED;
+    }
+
+    if (pMode->Mode.Width != newWidth
+            || pMode->Mode.Height != newHeight
+            || pMode->Mode.BitsPerPixel != newBpp)
+    {
+        pMode->fFlags |= VBOXWDDM_ADJUSTVIDEOMODE_F_ADJUSTED;
+        pMode->Mode.Width = newWidth;
+        pMode->Mode.Height = newHeight;
+        pMode->Mode.BitsPerPixel = newBpp;
+    }
+
+    if (pTarget->HeightVisible /* <- active */
+            && pSource->AllocData.SurfDesc.width == pMode->Mode.Width
+            && pSource->AllocData.SurfDesc.height == pMode->Mode.Height
+            && pSource->AllocData.SurfDesc.bpp == pMode->Mode.BitsPerPixel)
+    {
+        pMode->fFlags |= VBOXWDDM_ADJUSTVIDEOMODE_F_CURRENT;
+        if (pMode->fFlags & VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED)
+        {
+            WARN(("current mode is reported as unsupported, cleaning the unsupported flag"));
+            pMode->fFlags &= ~VBOXWDDM_ADJUSTVIDEOMODE_F_UNSUPPORTED;
+        }
+    }
+}
+
+void VBoxWddmAdjustModes(PVBOXMP_DEVEXT pExt, uint32_t cModes, PVBOXWDDM_ADJUSTVIDEOMODE aModes)
+{
+    for (UINT i = 0; i < cModes; ++i)
+    {
+        PVBOXWDDM_ADJUSTVIDEOMODE pMode = &aModes[i];
+        VBoxWddmAdjustMode(pExt, pMode);
+    }
 }
 

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

@@ -219 +219 @@
     NTSTATUS Status = STATUS_SUCCESS;
 
-    pVsi->VideoStandard  = D3DKMDT_VSS_VESA_DMT;
+    pVsi->VideoStandard  = D3DKMDT_VSS_OTHER;
     pVsi->ActiveSize = *pResolution;
     pVsi->VSyncFreq.Numerator = VSync * 1000;
     pVsi->VSyncFreq.Denominator = 1000;
-    pVsi->TotalSize.cx = pVsi->ActiveSize.cx + VBOXVDPN_C_DISPLAY_HBLANK_SIZE;
-    pVsi->TotalSize.cy = pVsi->ActiveSize.cy + VBOXVDPN_C_DISPLAY_VBLANK_SIZE;
+    pVsi->TotalSize.cx = pVsi->ActiveSize.cx;// + VBOXVDPN_C_DISPLAY_HBLANK_SIZE;
+    pVsi->TotalSize.cy = pVsi->ActiveSize.cy;// + VBOXVDPN_C_DISPLAY_VBLANK_SIZE;
     pVsi->PixelRate = pVsi->TotalSize.cx * pVsi->TotalSize.cy * VSync;
     pVsi->HSyncFreq.Numerator = (UINT)((pVsi->PixelRate / pVsi->TotalSize.cy) * 1000);
@@ -527 +527 @@
     D3DKMDT_2DREGION *paResolutions;
     uint32_t cResolutions;
-    BOOLEAN fMatch;
+    BOOLEAN fMatched;
 } VBOXVIDPNMATCHMONMODESENUM, *PVBOXVIDPNMATCHMONMODESENUM;
 
@@ -535 +535 @@
     PVBOXVIDPNMATCHMONMODESENUM pInfo = (PVBOXVIDPNMATCHMONMODESENUM)pContext;
 
-    Assert(pInfo->fMatch);
+    Assert(pInfo->fMatched);
+
+    BOOLEAN fFound = FALSE;
 
     for (UINT i = 0; i < pInfo->cResolutions; ++i)
     {
         D3DKMDT_2DREGION *pResolution = &pInfo->paResolutions[i];
-        if (pMonitorSMI->VideoSignalInfo.ActiveSize.cx != pResolution->cx
-                || pMonitorSMI->VideoSignalInfo.ActiveSize.cy != pResolution->cy)
-        {
-            pInfo->fMatch = FALSE;
+        if (pMonitorSMI->VideoSignalInfo.ActiveSize.cx == pResolution->cx
+                && pMonitorSMI->VideoSignalInfo.ActiveSize.cy == pResolution->cy)
+        {
+            fFound = TRUE;
             break;
         }
     }
 
+    if (!fFound)
+        pInfo->fMatched = FALSE;
+
     pMonitorSMSIf->pfnReleaseModeInfo(hMonitorSMS, pMonitorSMI);
 
-    return pInfo->fMatch;
+    return pInfo->fMatched;
 }
 
@@ -585 +590 @@
     }
 
-    VBOXVIDPNMATCHMONMODESENUM Info;
-    Info.paResolutions = pResolutions;
-    Info.cResolutions = cResolutions;
-    Info.fMatch = TRUE;
-
-    Status = vboxVidPnEnumMonitorSourceModes(hMonitorSMS, pMonitorSMSIf, vboxFidPnMatchMonitorModesEnum, &Info);
+    /* we care only about monitor modes covering all needed resolutions,
+     * we do NOT care if resolutions do not cover some monitor modes */
+    SIZE_T cModes = 0;
+    Status = pMonitorSMSIf->pfnGetNumModes(hMonitorSMS, &cModes);
     if (NT_SUCCESS(Status))
     {
-        *pfMatch = Info.fMatch;
-    }
+        if (cModes < cResolutions)
+            *pfMatch = FALSE;
+        else
+        {
+            VBOXVIDPNMATCHMONMODESENUM Info;
+            Info.paResolutions = pResolutions;
+            Info.cResolutions = cResolutions;
+            Info.fMatched = TRUE;
+
+            Status = vboxVidPnEnumMonitorSourceModes(hMonitorSMS, pMonitorSMSIf, vboxFidPnMatchMonitorModesEnum, &Info);
+            if (NT_SUCCESS(Status))
+                *pfMatch = Info.fMatched;
+        }
+    }
+    else
+        WARN(("pfnGetNumModes failed, Status 0x%x", Status));
 
     NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hMonitorSMS);
@@ -1299 +1316 @@
                     {
                         Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, pResolution, i == pInfo->iPreferredResolution);
-                        Assert(Status == STATUS_SUCCESS);
                         if (NT_SUCCESS(Status))
                         {
@@ -1309 +1325 @@
                                 continue;
                             }
+                            else
+                            {
+                                WARN(("pfnAddMode failed, Status 0x%x", Status));
+                            }
+                        }
+                        else
+                        {
+                            WARN(("vboxVidPnPopulateTargetModeInfoFromLegacy failed, Status 0x%x", Status));
                         }
 
@@ -1314 +1338 @@
                         Assert(tmpStatus == STATUS_SUCCESS);
                     }
+
                     /* we're here because of an error */
                     Assert(!NT_SUCCESS(Status));
-                    break;
+                    /* ignore mode addition failure */
+                    Status = STATUS_SUCCESS;
+                    continue;
                 }
             }

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

@@ -681 +681 @@
 
         bChanged[i] = !fMatch;
-
-        if (!fMatch)
-        {
-            Status = vboxWddmChildStatusReportReconnected(pDevExt, i);
-            if (!NT_SUCCESS(Status))
+    }
+
+    if (!NT_SUCCESS(Status))
+    {
+        WARN(("updating monitor modes failed, Status(0x%x)", Status));
+        return Status;
+    }
+
+    for (i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
+    {
+        if (bChanged[i])
+        {
+            NTSTATUS tmpStatus = vboxWddmChildStatusReportReconnected(pDevExt, i);
+            if (!NT_SUCCESS(tmpStatus))
             {
                 WARN(("vboxWddmChildStatusReportReconnected failed Status(0x%x)", Status));
@@ -692 +701 @@
             }
         }
-    }
-
-    if (!NT_SUCCESS(Status))
-    {
-        WARN(("updating monitor modes failed, Status(0x%x)", Status));
-        return Status;
     }
 
@@ -1121 +1124 @@
 
                     VBoxMPCmnInitCustomVideoModes(pDevExt);
-                    VBoxWddmInvalidateVideoModesInfo(pDevExt);
+                    VBoxWddmInvalidateAllVideoModesInfos(pDevExt);
+
+                    pDevExt->fAnyX = VBoxVideoAnyWidthAllowed();
 #if 0
                     vboxShRcTreeInit(pDevExt);
@@ -4137 +4142 @@
             case VBOXESC_REINITVIDEOMODES:
             {
-                PVBOXWDDM_VIDEOMODES_INFO pInfo = VBoxWddmUpdateVideoModesInfo(pDevExt, NULL);
-                Status = vboxWddmChildStatusCheck(pDevExt, pInfo);
+                if (pEscape->Flags.HardwareAccess)
+                {
+                    WARN(("VBOXESC_REINITVIDEOMODES called with HardwareAccess flag set, failing"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+                WARN(("VBOXESC_REINITVIDEOMODESBYMASK should be called instead"));
+                PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateAllVideoModesInfos(pDevExt);
+                Status = vboxWddmChildStatusCheck(pDevExt, pInfos);
                 if (!NT_SUCCESS(Status))
                 {
@@ -4144 +4156 @@
                 }
                 break;
+            }
+            case VBOXESC_REINITVIDEOMODESBYMASK:
+            {
+                BOOLEAN fCheckDisplayRecconect = (pEscapeHdr->u32CmdSpecific & VBOXWDDM_REINITVIDEOMODESBYMASK_F_RECONNECT_DISPLAYS_ON_CHANGE);
+                if (fCheckDisplayRecconect && pEscape->Flags.HardwareAccess)
+                {
+                    WARN(("VBOXESC_REINITVIDEOMODESBYMASK called with HardwareAccess flag set, failing"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK))
+                {
+                    WARN(("invalid private driver size %d", pEscape->PrivateDriverDataSize));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+                PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK pData = (PVBOXDISPIFESCAPE_REINITVIDEOMODESBYMASK)pEscapeHdr;
+                PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateVideoModesInfoByMask(pDevExt, pData->ScreenMask);
+                if (fCheckDisplayRecconect)
+                {
+                    Status = vboxWddmChildStatusCheck(pDevExt, pInfos);
+                    if (!NT_SUCCESS(Status))
+                    {
+                        WARN(("vboxWddmChildStatusCheck failed, Status 0x%x", Status));
+                    }
+                }
+                break;
+            }
+            case VBOXESC_ADJUSTVIDEOMODES:
+            {
+                if (!pEscape->Flags.HardwareAccess)
+                {
+                    WARN(("VBOXESC_ADJUSTVIDEOMODES called without HardwareAccess flag set, failing"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                uint32_t cModes = pEscapeHdr->u32CmdSpecific;
+                if (cModes > VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos)
+                        || pEscape->PrivateDriverDataSize != RT_OFFSETOF(VBOXDISPIFESCAPE_ADJUSTVIDEOMODES, aScreenInfos[cModes]))
+                {
+                    WARN(("invalid modes count passed"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES pPodesInfo = (PVBOXDISPIFESCAPE_ADJUSTVIDEOMODES)pEscapeHdr;
+                VBoxWddmAdjustModes(pDevExt, cModes, pPodesInfo->aScreenInfos);
+                Status = STATUS_SUCCESS;
             }
             case VBOXESC_SHRC_ADDREF:
@@ -4394 +4455 @@
     PVBOXWDDM_RECOMMENDVIDPN pVidPnInfo = pRecommendFunctionalVidPnArg->PrivateDriverDataSize >= sizeof (VBOXWDDM_RECOMMENDVIDPN) ?
             (PVBOXWDDM_RECOMMENDVIDPN)pRecommendFunctionalVidPnArg->pPrivateDriverData : NULL;
-    PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateVideoModesInfo(pDevExt, NULL /*pVidPnInfo*/);
+    PVBOXWDDM_VIDEOMODES_INFO pInfos = VBoxWddmUpdateAllVideoModesInfos(pDevExt);
     int i;
 
@@ -4410 +4471 @@
         Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, pInfo->aResolutions, pInfo->cResolutions, pInfo->iPreferredResolution);
 #endif
-        Assert(Status == STATUS_SUCCESS);
         if (Status != STATUS_SUCCESS)
         {
-            LOGREL(("vboxVidPnCheckAddMonitorModes failed Status(0x%x)", Status));
+            WARN(("vboxVidPnCheckAddMonitorModes failed Status(0x%x)", Status));
             break;
         }