VirtualBox

Changeset 28011 in vbox


Ignore:
Timestamp:
Apr 6, 2010 2:42:48 PM (15 years ago)
Author:
vboxsync
Message:

wddm: autoresize & seamless working (debug & cleaning still needed)

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp

    r27997 r28011  
    141141            */
    142142            /* not support copy protection for now */
    143             if (pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType != D3DKMDT_VPPMT_NOPROTECTION)
     143            if (pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType != D3DKMDT_VPPMT_NOPROTECTION
     144                    && pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType != D3DKMDT_VPPMT_UNINITIALIZED)
    144145            {
    145146                dprintf(("Copy protection not supported CopyProtectionType(%d)\n", pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType));
    … …  
    167168            }
    168169
    169             if (pNewVidPnPresentPathInfo->GammaRamp.Type != D3DDDI_GAMMARAMP_DEFAULT)
     170            if (pNewVidPnPresentPathInfo->GammaRamp.Type != D3DDDI_GAMMARAMP_DEFAULT
     171                    && pNewVidPnPresentPathInfo->GammaRamp.Type != D3DDDI_GAMMARAMP_UNINITIALIZED)
    170172            {
    171173                dprintf(("Unsupported GammaRamp.Type (%d)\n", pNewVidPnPresentPathInfo->GammaRamp.Type));
    … …  
    527529        VIDEO_MODE_INFORMATION *pModes,
    528530        uint32_t cModes,
    529         int iPreferredMode)
     531        int iPreferredMode,
     532        D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID *pPreferredModeId)
    530533{
    531534    NTSTATUS Status = STATUS_SUCCESS;
     535    D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID PreferredModeId = D3DDDI_ID_UNINITIALIZED;
    532536    for (uint32_t i = 0; i < cModes; ++i)
    533537    {
    … …  
    548552                    if (iPreferredMode == i)
    549553                    {
    550                         AssertBreakpoint();
    551                         Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, modeId);
    552                         Assert(Status == STATUS_SUCCESS);
    553                         if (Status != STATUS_SUCCESS)
    554                         {
    555                             drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
    556                             /* don't treat it as fatal */
    557                             Status = STATUS_SUCCESS;
    558                         }
     554                        PreferredModeId = modeId;
     555//                        AssertBreakpoint();
     556//                        Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, modeId);
     557//                        Assert(Status == STATUS_SUCCESS);
     558//                        if (Status != STATUS_SUCCESS)
     559//                        {
     560//                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
     561//                            /* don't treat it as fatal */
     562//                            Status = STATUS_SUCCESS;
     563//                        }
    559564                    }
    560565                }
    … …  
    574579        }
    575580    }
     581
     582    if (pPreferredModeId)
     583        *pPreferredModeId = PreferredModeId;
     584
    576585    return Status;
    577586}
    … …  
    663672        uint32_t cResolutions,
    664673        VIDEO_MODE_INFORMATION *pPreferredMode,
    665         uint32_t fFlags)
     674        uint32_t fFlags,
     675        D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID *pPreferredModeId)
    666676{
    667677    NTSTATUS Status = STATUS_SUCCESS;
     678    D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID PreferredModeId = D3DDDI_ID_UNINITIALIZED;
    668679    for (uint32_t i = 0; i < cResolutions; ++i)
    669680    {
    … …  
    673684        if (Status == STATUS_SUCCESS)
    674685        {
    675             bool bPreferred = pPreferredMode ? pPreferredMode->VisScreenHeight == pResolutions[i].cx
    676                     && pPreferredMode->VisScreenWidth == pResolutions[i].cy : FALSE;
     686            bool bPreferred = pPreferredMode ? pPreferredMode->VisScreenWidth == pResolutions[i].cx
     687                    && pPreferredMode->VisScreenHeight == pResolutions[i].cy : FALSE;
    677688            Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, &pResolutions[i], bPreferred && (fFlags & VBOXVIDPN_MODESET_MARK_PREFERRED));
    678689            Assert(Status == STATUS_SUCCESS);
    … …  
    684695                if (Status == STATUS_SUCCESS)
    685696                {
    686                     if (bPreferred && !(fFlags & VBOXVIDPN_MODESET_NO_PIN_PREFERRED))
     697                    if (bPreferred) // && !(fFlags & VBOXVIDPN_MODESET_NO_PIN_PREFERRED))
    687698                    {
    688                         AssertBreakpoint();
    689                         Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, modeId);
    690                         Assert(Status == STATUS_SUCCESS);
    691                         if (Status != STATUS_SUCCESS)
    692                         {
    693                             drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
    694                             /* don't treat it as fatal */
    695                             Status = STATUS_SUCCESS;
    696                         }
     699                        PreferredModeId = modeId;
     700//                        AssertBreakpoint();
     701//                        Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, modeId);
     702//                        Assert(Status == STATUS_SUCCESS);
     703//                        if (Status != STATUS_SUCCESS)
     704//                        {
     705//                            drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
     706//                            /* don't treat it as fatal */
     707//                            Status = STATUS_SUCCESS;
     708//                        }
    697709                    }
    698710                }
    … …  
    712724        }
    713725    }
     726
     727    if (pPreferredModeId)
     728        *pPreferredModeId = PreferredModeId;
    714729    return Status;
    715730}
    … …  
    717732NTSTATUS vboxVidPnCreatePopulateSourceModeSetFromLegacy(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
    718733                    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
    719                     VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode)
     734                    VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode, D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID *pPreferredModeId)
    720735{
    721736    D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet;
    … …  
    730745        Status = vboxVidPnPopulateSourceModeSetFromLegacy(pDevExt,
    731746                    hNewVidPnSourceModeSet, pNewVidPnSourceModeSetInterface,
    732                     pModes, cModes, iPreferredMode);
     747                    pModes, cModes, iPreferredMode, pPreferredModeId);
    733748        Assert(Status == STATUS_SUCCESS);
    734749        if (Status == STATUS_SUCCESS)
    … …  
    759774                    D3DKMDT_2DREGION *pResolutions,
    760775                    uint32_t cResolutions,
    761                     VIDEO_MODE_INFORMATION *pPreferredMode, uint32_t fFlags)
     776                    VIDEO_MODE_INFORMATION *pPreferredMode, uint32_t fFlags,
     777                    D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID *pPreferredModeId)
    762778{
    763779    D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet;
    … …  
    772788        Status = vboxVidPnPopulateTargetModeSetFromLegacy(pDevExt,
    773789                    hNewVidPnTargetModeSet, pNewVidPnTargetModeSetInterface,
    774                     pResolutions, cResolutions, pPreferredMode, fFlags);
     790                    pResolutions, cResolutions, pPreferredMode, fFlags, pPreferredModeId);
    775791        Assert(Status == STATUS_SUCCESS);
    776792        if (Status == STATUS_SUCCESS)
    … …  
    839855}
    840856
    841 NTSTATUS vboxVidPnCheckAddMonitorModes(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin, D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions)
     857NTSTATUS vboxVidPnCheckAddMonitorModes(PDEVICE_EXTENSION pDevExt,
     858        D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin,
     859        D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, int32_t iPreferred)
    842860{
    843861    NTSTATUS Status;
    … …  
    881899                                        pRes,
    882900                                        enmOrigin,
    883                                         FALSE);
     901                                        i == (uint32_t)iPreferred);
    884902                                Assert(Status == STATUS_SUCCESS);
    885903                                if (Status != STATUS_SUCCESS)
    … …  
    920938    const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
    921939    VIDEO_MODE_INFORMATION *pPreferredMode = iPreferredMode >= 0 ? &pModes[iPreferredMode] : NULL;
    922     NTSTATUS Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
     940    D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID PreferredSrcModeId = D3DDDI_ID_UNINITIALIZED;
     941    D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet;
     942    const DXGK_VIDPNSOURCEMODESET_INTERFACE *pNewVidPnSourceModeSetInterface;
     943    D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId = 0;
     944    D3DDDI_VIDEO_PRESENT_TARGET_ID tgtId = 0;
     945    NTSTATUS Status = pVidPnInterface->pfnCreateNewSourceModeSet(hVidPn,
     946                        srcId, /*__in CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID  VidPnSourceId */
     947                        &hNewVidPnSourceModeSet,
     948                        &pNewVidPnSourceModeSetInterface);
     949    Assert(Status == STATUS_SUCCESS);
    923950    if (Status == STATUS_SUCCESS)
    924951    {
    925         D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo;
    926         Status = pVidPnTopologyInterface->pfnCreateNewPathInfo(hVidPnTopology, &pNewVidPnPresentPathInfo);
     952        Status = vboxVidPnPopulateSourceModeSetFromLegacy(pDevExt,
     953                    hNewVidPnSourceModeSet, pNewVidPnSourceModeSetInterface,
     954                    pModes, cModes, iPreferredMode, &PreferredSrcModeId);
     955        Assert(Status == STATUS_SUCCESS);
    927956        if (Status == STATUS_SUCCESS)
    928957        {
    929             pNewVidPnPresentPathInfo->VidPnSourceId = 0;
    930             pNewVidPnPresentPathInfo->VidPnTargetId = 0;
    931             pNewVidPnPresentPathInfo->ImportanceOrdinal = D3DKMDT_VPPI_PRIMARY;
    932             pNewVidPnPresentPathInfo->ContentTransformation.Scaling = D3DKMDT_VPPS_IDENTITY;
    933             memset(&pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport,
    934                     0, sizeof (pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport));
    935             pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Identity = 1;
    936             pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Centered = 1;
    937             pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Stretched = 0;
    938             pNewVidPnPresentPathInfo->ContentTransformation.Rotation = D3DKMDT_VPPR_IDENTITY;
    939             pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Identity = 1;
    940             pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate180 = 0;
    941             pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate270 = 0;
    942             pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate90 = 0;
    943             pNewVidPnPresentPathInfo->VisibleFromActiveTLOffset.cx = 0;
    944             pNewVidPnPresentPathInfo->VisibleFromActiveTLOffset.cy = 0;
    945             pNewVidPnPresentPathInfo->VisibleFromActiveBROffset.cx = 0;
    946             pNewVidPnPresentPathInfo->VisibleFromActiveBROffset.cy = 0;
    947             pNewVidPnPresentPathInfo->VidPnTargetColorBasis = D3DKMDT_CB_SRGB; /* @todo: how does it matters? */
    948             pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FirstChannel =  8;
    949             pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.SecondChannel =  8;
    950             pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.ThirdChannel =  8;
    951             pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FourthChannel =  0;
    952             pNewVidPnPresentPathInfo->Content = D3DKMDT_VPPC_GRAPHICS;
    953             pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType = D3DKMDT_VPPMT_NOPROTECTION;
    954             pNewVidPnPresentPathInfo->CopyProtection.APSTriggerBits = 0;
    955             memset(&pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport, 0, sizeof (pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport));
    956             pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport.NoProtection  = 1;
    957             pNewVidPnPresentPathInfo->GammaRamp.Type = D3DDDI_GAMMARAMP_DEFAULT;
    958             pNewVidPnPresentPathInfo->GammaRamp.DataSize = 0;
    959             Status = pVidPnTopologyInterface->pfnAddPath(hVidPnTopology, pNewVidPnPresentPathInfo);
    960             if (Status == STATUS_SUCCESS)
    961             {
    962                 Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hVidPn, pVidPnInterface, 0, pModes, cModes, iPreferredMode);
     958            Status = pVidPnInterface->pfnAssignSourceModeSet(hVidPn,
     959                        srcId,
     960                        hNewVidPnSourceModeSet);
     961            Assert(Status == STATUS_SUCCESS);
     962            if(Status == STATUS_SUCCESS)
     963            {
     964                Assert(PreferredSrcModeId != D3DDDI_ID_UNINITIALIZED);
     965                D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID PreferredTrgModeId = D3DDDI_ID_UNINITIALIZED;
     966                D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet;
     967                const DXGK_VIDPNTARGETMODESET_INTERFACE *pNewVidPnTargetModeSetInterface;
     968                NTSTATUS Status = pVidPnInterface->pfnCreateNewTargetModeSet(hVidPn,
     969                                    tgtId, /*__in CONST D3DDDI_VIDEO_PRESENT_TARGET_ID  VidPnTargetId */
     970                                    &hNewVidPnTargetModeSet,
     971                                    &pNewVidPnTargetModeSetInterface);
    963972                Assert(Status == STATUS_SUCCESS);
    964973                if (Status == STATUS_SUCCESS)
    965974                {
    966                     Status = vboxVidPnCreatePopulateTargetModeSetFromLegacy(pDevExt, hVidPn, pVidPnInterface, 0,
    967                             pResolutions, cResolutions, pPreferredMode, 0);
     975                    Status = vboxVidPnPopulateTargetModeSetFromLegacy(pDevExt,
     976                                hNewVidPnTargetModeSet, pNewVidPnTargetModeSetInterface,
     977                                pResolutions, cResolutions, pPreferredMode, 0, &PreferredTrgModeId);
    968978                    Assert(Status == STATUS_SUCCESS);
    969                     if (Status != STATUS_SUCCESS)
    970                         drprintf((__FUNCTION__": vboxVidPnCreatePopulateTargetModeSetFromLegacy failed Status(0x%x)\n", Status));
     979                    if (Status == STATUS_SUCCESS)
     980                    {
     981                        Status = pVidPnInterface->pfnAssignTargetModeSet(hVidPn,
     982                                    tgtId,
     983                                    hNewVidPnTargetModeSet);
     984                        Assert(Status == STATUS_SUCCESS);
     985                        if(Status == STATUS_SUCCESS)
     986                        {
     987
     988                            Assert(PreferredTrgModeId != D3DDDI_ID_UNINITIALIZED);
     989                            Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
     990                            if (Status == STATUS_SUCCESS)
     991                            {
     992                                D3DKMDT_VIDPN_PRESENT_PATH *pNewVidPnPresentPathInfo;
     993                                Status = pVidPnTopologyInterface->pfnCreateNewPathInfo(hVidPnTopology, &pNewVidPnPresentPathInfo);
     994                                if (Status == STATUS_SUCCESS)
     995                                {
     996                                    pNewVidPnPresentPathInfo->VidPnSourceId = 0;
     997                                    pNewVidPnPresentPathInfo->VidPnTargetId = 0;
     998                                    pNewVidPnPresentPathInfo->ImportanceOrdinal = D3DKMDT_VPPI_PRIMARY;
     999                                    pNewVidPnPresentPathInfo->ContentTransformation.Scaling = D3DKMDT_VPPS_IDENTITY;
     1000                                    memset(&pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport,
     1001                                            0, sizeof (pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport));
     1002                                    pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Identity = 1;
     1003                                    pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Centered = 0;
     1004                                    pNewVidPnPresentPathInfo->ContentTransformation.ScalingSupport.Stretched = 0;
     1005                                    pNewVidPnPresentPathInfo->ContentTransformation.Rotation = D3DKMDT_VPPR_IDENTITY;
     1006                                    pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Identity = 1;
     1007                                    pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate180 = 0;
     1008                                    pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate270 = 0;
     1009                                    pNewVidPnPresentPathInfo->ContentTransformation.RotationSupport.Rotate90 = 0;
     1010                                    pNewVidPnPresentPathInfo->VisibleFromActiveTLOffset.cx = 0;
     1011                                    pNewVidPnPresentPathInfo->VisibleFromActiveTLOffset.cy = 0;
     1012                                    pNewVidPnPresentPathInfo->VisibleFromActiveBROffset.cx = 0;
     1013                                    pNewVidPnPresentPathInfo->VisibleFromActiveBROffset.cy = 0;
     1014                                    pNewVidPnPresentPathInfo->VidPnTargetColorBasis = D3DKMDT_CB_SRGB; /* @todo: how does it matters? */
     1015                                    pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FirstChannel =  8;
     1016                                    pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.SecondChannel =  8;
     1017                                    pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.ThirdChannel =  8;
     1018                                    pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FourthChannel =  0;
     1019                                    pNewVidPnPresentPathInfo->Content = D3DKMDT_VPPC_GRAPHICS;
     1020                                    pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType = D3DKMDT_VPPMT_UNINITIALIZED;
     1021                //                    pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType = D3DKMDT_VPPMT_NOPROTECTION;
     1022                                    pNewVidPnPresentPathInfo->CopyProtection.APSTriggerBits = 0;
     1023                                    memset(&pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport, 0, sizeof (pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport));
     1024                        //            pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport.NoProtection  = 1;
     1025                                    memset (&pNewVidPnPresentPathInfo->GammaRamp, 0, sizeof (pNewVidPnPresentPathInfo->GammaRamp));
     1026                        //            pNewVidPnPresentPathInfo->GammaRamp.Type = D3DDDI_GAMMARAMP_DEFAULT;
     1027                        //            pNewVidPnPresentPathInfo->GammaRamp.DataSize = 0;
     1028                                    Status = pVidPnTopologyInterface->pfnAddPath(hVidPnTopology, pNewVidPnPresentPathInfo);
     1029                                    Assert(Status == STATUS_SUCCESS);
     1030                                    if (Status == STATUS_SUCCESS)
     1031                                    {
     1032                                        if (PreferredSrcModeId != D3DDDI_ID_UNINITIALIZED)
     1033                                        {
     1034                                            Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, PreferredSrcModeId);
     1035                                            Assert(Status == STATUS_SUCCESS);
     1036                                            if (Status == STATUS_SUCCESS)
     1037                                            {
     1038                                                Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, PreferredTrgModeId);
     1039                                                Assert(Status == STATUS_SUCCESS);
     1040                                                if (Status != STATUS_SUCCESS)
     1041                                                    drprintf((__FUNCTION__": TRG pfnPinMode failed Status(0x%x)\n", Status));
     1042                                            }
     1043                                            else
     1044                                                drprintf((__FUNCTION__": SRC pfnPinMode failed Status(0x%x)\n", Status));
     1045                                        }
     1046                                    }
     1047                                    else
     1048                                    {
     1049                                        drprintf((__FUNCTION__": pfnAddPath failed Status(0x%x)\n", Status));
     1050                                        pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pNewVidPnPresentPathInfo);
     1051                                        pNewVidPnPresentPathInfo = NULL;
     1052                                    }
     1053                                }
     1054                                else
     1055                                    drprintf((__FUNCTION__": pfnCreateNewPathInfo failed Status(0x%x)\n", Status));
     1056                            }
     1057                            else
     1058                                drprintf((__FUNCTION__": pfnGetTopology failed Status(0x%x)\n", Status));
     1059                        }
     1060                        else
     1061                        {
     1062                            drprintf((__FUNCTION__": pfnAssignTargetModeSet failed Status(0x%x)\n", Status));
     1063                            pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hNewVidPnTargetModeSet);
     1064                        }
     1065                    }
     1066                    else
     1067                    {
     1068                        drprintf((__FUNCTION__": vboxVidPnPopulateTargetModeSetFromLegacy failed Status(0x%x)\n", Status));
     1069                        pVidPnInterface->pfnReleaseTargetModeSet(hVidPn, hNewVidPnTargetModeSet);
     1070                    }
    9711071                }
    9721072                else
    973                     drprintf((__FUNCTION__": vboxVidPnCreatePopulateSourceModeSetFromLegacy failed Status(0x%x)\n", Status));
     1073                    drprintf((__FUNCTION__": pfnCreateNewTargetModeSet failed Status(0x%x)\n", Status));
    9741074            }
    9751075            else
    9761076            {
    977                 drprintf((__FUNCTION__": pfnAddPath failed Status(0x%x)\n", Status));
    978                 pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pNewVidPnPresentPathInfo);
    979                 pNewVidPnPresentPathInfo = NULL;
     1077                drprintf((__FUNCTION__": pfnAssignSourceModeSet failed Status(0x%x)\n", Status));
     1078                pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hNewVidPnSourceModeSet);
    9801079            }
    9811080        }
    9821081        else
    9831082        {
    984             drprintf((__FUNCTION__": pfnCreateNewPathInfo failed Status(0x%x)\n", Status));
     1083            drprintf((__FUNCTION__": vboxVidPnPopulateSourceModeSetFromLegacy failed Status(0x%x)\n", Status));
     1084            pVidPnInterface->pfnReleaseSourceModeSet(hVidPn, hNewVidPnSourceModeSet);
    9851085        }
    9861086    }
    9871087    else
    988     {
    989         drprintf((__FUNCTION__": pfnGetTopology failed Status(0x%x)\n", Status));
    990     }
     1088        drprintf((__FUNCTION__": pfnCreateNewSourceModeSet failed Status(0x%x)\n", Status));
    9911089
    9921090    return Status;
    … …  
    11321230                                            1,
    11331231                                            pPreferredMode,
    1134                                             0);
     1232                                            0,
     1233                                            NULL);
    11351234                                    Assert(Status == STATUS_SUCCESS);
    11361235                                    if (Status != STATUS_SUCCESS)
    … …  
    11571256                    Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hDesiredVidPn, pVidPnInterface,
    11581257                            pNewVidPnPresentPathInfo->VidPnSourceId,
    1159                             pModes, cModes, iPreferredMode);
     1258                            pModes, cModes, iPreferredMode, NULL);
    11601259                    Assert(Status == STATUS_SUCCESS);
    11611260                    if (Status == STATUS_SUCCESS)
    … …  
    11671266                                cResolutions,
    11681267                                pPreferredMode,
    1169                                 0);
     1268                                0,
     1269                                NULL);
    11701270                        Assert(Status == STATUS_SUCCESS);
    11711271                        if (Status != STATUS_SUCCESS)

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.h

    r27997 r28011  
    125125        D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions);
    126126
    127 NTSTATUS vboxVidPnCheckAddMonitorModes(struct _DEVICE_EXTENSION* pDevExt, D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin, D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions);
     127NTSTATUS vboxVidPnCheckAddMonitorModes(struct _DEVICE_EXTENSION* pDevExt,
     128        D3DDDI_VIDEO_PRESENT_TARGET_ID targetId, D3DKMDT_MONITOR_CAPABILITIES_ORIGIN enmOrigin,
     129        D3DKMDT_2DREGION *pResolutions, uint32_t cResolutions, int32_t iPreferred);
    128130#endif /* #ifndef ___VBoxVideoVidPn_h___ */

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r27997 r28011  
    24652465        for (uint32_t i = 0; i < pDevExt->cSources; ++i)
    24662466        {
    2467             Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, pResolutions, cResolutions);
     2467            Status = vboxVidPnCheckAddMonitorModes(pDevExt, i, D3DKMDT_MCO_DRIVER, &Resolution, 1, 0);
    24682468            Assert(Status == STATUS_SUCCESS);
    24692469            if (Status != STATUS_SUCCESS)
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