VBoxVideoVidPn.cpp revision 92c6075e59a61be1eb07bf370501a93e6cd2d6ca
/*
* Copyright (C) 2010 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "../VBoxVideo-win.h"
#include "../Helper.h"
{
NTSTATUS Status = pVidPnTopologyInterface->pfnAcquireFirstPathInfo(hVidPnTopology, &pNewVidPnPresentPathInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
{
dprintf(("unsupported source(%d)->target(%d) pair\n", pNewVidPnPresentPathInfo->VidPnSourceId, pNewVidPnPresentPathInfo->VidPnTargetId));
bSupported = FALSE;
break;
}
if (pNewVidPnPresentPathInfo->VidPnSourceId == 0)
{
}
/*
ImportanceOrdinal does not matter for now
pNewVidPnPresentPathInfo->ImportanceOrdinal
*/
{
bSupported = FALSE;
break;
}
{
dprintf(("unsupported Scaling support (Stretched)\n"));
bSupported = FALSE;
break;
}
{
dprintf(("\"Identity\" or \"Centered\" Scaling support not set\n"));
bSupported = FALSE;
break;
}
{
bSupported = FALSE;
break;
}
{
dprintf(("unsupported RotationSupport\n"));
bSupported = FALSE;
break;
}
{
dprintf(("\"Identity\" RotationSupport not set\n"));
bSupported = FALSE;
break;
}
{
dprintf(("Non-zero TLOffset: cx(%d), cy(%d)\n",
bSupported = FALSE;
break;
}
{
dprintf(("Non-zero TLOffset: cx(%d), cy(%d)\n",
bSupported = FALSE;
break;
}
{
dprintf(("unsupported VidPnTargetColorBasis (%d)\n", pNewVidPnPresentPathInfo->VidPnTargetColorBasis));
bSupported = FALSE;
break;
}
/* channels?
pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FirstChannel;
pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.SecondChannel;
pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.ThirdChannel;
we definitely not support fourth channel
*/
{
dprintf(("Non-zero FourthChannel (%d)\n", pNewVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges.FourthChannel));
bSupported = FALSE;
break;
}
/* Content (D3DKMDT_VPPC_GRAPHICS, _NOTSPECIFIED, _VIDEO), does not matter for now
pNewVidPnPresentPathInfo->Content
*/
/* not support copy protection for now */
{
dprintf(("Copy protection not supported CopyProtectionType(%d)\n", pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType));
bSupported = FALSE;
break;
}
{
dprintf(("Copy protection not supported APSTriggerBits(%d)\n", pNewVidPnPresentPathInfo->CopyProtection.APSTriggerBits));
bSupported = FALSE;
break;
}
if (memcmp(&tstCPSupport, &pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport, sizeof(tstCPSupport)))
{
dprintf(("Copy protection support (0x%x)\n", *((UINT*)&pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport)));
bSupported = FALSE;
break;
}
{
bSupported = FALSE;
break;
}
{
dprintf(("Warning: non-zero GammaRamp.DataSize (%d), treating as supported\n", pNewVidPnPresentPathInfo->GammaRamp.DataSize));
}
Status = pVidPnTopologyInterface->pfnAcquireNextPathInfo(hVidPnTopology, pNewVidPnPresentPathInfo, &pNextVidPnPresentPathInfo);
if (Status == STATUS_SUCCESS)
{
}
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
{
/* we support both GRAPHICS and TEXT modes */
switch (pNewVidPnSourceModeInfo->Type)
{
case D3DKMDT_RMT_GRAPHICS:
/* any primary surface size actually
pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx
pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy
*/
if (pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cx != pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cx
|| pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize.cy != pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize.cy)
{
dprintf(("VisibleRegionSize(%d, %d) != PrimSurfSize(%d, %d)\n",
bSupported = FALSE;
break;
}
/*
pNewVidPnSourceModeInfo->Format.Graphics.Stride
pNewVidPnSourceModeInfo->Format.Graphics.PixelFormat
pNewVidPnSourceModeInfo->Format.Graphics.ColorBasis
pNewVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode
*/
break;
case D3DKMDT_RMT_TEXT:
break;
default:
break;
}
return STATUS_SUCCESS;
}
D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
NTSTATUS Status = pVidPnSourceModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
{
Status = pVidPnSourceModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo, &pNextVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
}
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
{
return Status;
}
BOOLEAN vboxVidPnMatchVideoSignal(const D3DKMDT_VIDEO_SIGNAL_INFO *pVsi1, const D3DKMDT_VIDEO_SIGNAL_INFO *pVsi2)
{
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return FALSE;
return TRUE;
}
{
&CmpRes,
pNewVidPnTargetModeInfo->VideoSignalInfo.VSyncFreq.Numerator/pNewVidPnTargetModeInfo->VideoSignalInfo.VSyncFreq.Denominator);
if (Status != STATUS_SUCCESS)
{
return Status;
}
{
bSupported = FALSE;
}
return STATUS_SUCCESS;
}
D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
NTSTATUS Status = pVidPnTargetModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
{
Status = pVidPnTargetModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo, &pNextVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
}
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
#if 0
DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalitySourceModeCheck(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
return Status == STATUS_SUCCESS;
}
DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalitySourceModeEnum(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
return Status == STATUS_SUCCESS;
}
DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityTargetModeEnum(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
return Status == STATUS_SUCCESS;
}
#endif
{
{
/* this is a graphics mode */
pNewVidPnSourceModeInfo->Format.Graphics.VisibleRegionSize = pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize;
{
else
}
else
{
}
}
else
{
/* @todo: XPDM driver does not seem to return text modes, should we? */
}
return Status;
}
int iPreferredMode,
{
{
/* disable 24 bpp for now */
continue;
Status = pNewVidPnSourceModeSetInterface->pfnCreateNewModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
Status = pNewVidPnSourceModeSetInterface->pfnAddMode(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
if (iPreferredMode == i)
{
// AssertBreakpoint();
// Status = pNewVidPnSourceModeSetInterface->pfnPinMode(hNewVidPnSourceModeSet, modeId);
// Assert(Status == STATUS_SUCCESS);
// if (Status != STATUS_SUCCESS)
// {
// drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
// /* don't treat it as fatal */
// Status = STATUS_SUCCESS;
// }
}
}
else
{
pNewVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo);
break;
}
}
else
{
pNewVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo);
break;
}
}
}
if (pPreferredModeId)
return Status;
}
{
NTSTATUS Status = vboxVidPnPopulateVideoSignalInfo(&pMonitorSourceMode->VideoSignalInfo, pResolution, 60 /* ULONG VSync */);
if (Status == STATUS_SUCCESS)
{
Assert(!bPreferred);
// pMonitorSourceMode->Preference = bPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED;
}
return Status;
}
{
if (Status == STATUS_SUCCESS)
{
do
{
if (Status == STATUS_SUCCESS)
{
// if (Status == STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET)
// Status = STATUS_SUCCESS;
if (Status == STATUS_SUCCESS)
break;
}
else
drprintf((__FUNCTION__": vboxVidPnPopulateMonitorSourceModeInfoFromLegacy failed, Status(0x%x)", Status));
/* we're here because of a failure */
if (tmpStatus != STATUS_SUCCESS)
} while (0);
}
else
return Status;
}
NTSTATUS vboxVidPnPopulateTargetModeInfoFromLegacy(D3DKMDT_VIDPN_TARGET_MODE *pNewVidPnTargetModeInfo,
{
Assert(!bPreferred);
// pNewVidPnTargetModeInfo->Preference = bPreferred ? D3DKMDT_MP_PREFERRED : D3DKMDT_MP_NOTPREFERRED;
return vboxVidPnPopulateVideoSignalInfo(&pNewVidPnTargetModeInfo->VideoSignalInfo, pResolution, 60 /* ULONG VSync */);
}
#define VBOXVIDPN_MODESET_NO_PIN_PREFERRED 0x00000001
#define VBOXVIDPN_MODESET_MARK_PREFERRED 0x00000002
{
for (uint32_t i = 0; i < cResolutions; ++i)
{
Status = pNewVidPnTargetModeSetInterface->pfnCreateNewModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
Status = vboxVidPnPopulateTargetModeInfoFromLegacy(pNewVidPnTargetModeInfo, &pResolutions[i], bPreferred && (fFlags & VBOXVIDPN_MODESET_MARK_PREFERRED));
if (Status == STATUS_SUCCESS)
{
Status = pNewVidPnTargetModeSetInterface->pfnAddMode(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
if (bPreferred) // && !(fFlags & VBOXVIDPN_MODESET_NO_PIN_PREFERRED))
{
// AssertBreakpoint();
// Status = pNewVidPnTargetModeSetInterface->pfnPinMode(hNewVidPnTargetModeSet, modeId);
// Assert(Status == STATUS_SUCCESS);
// if (Status != STATUS_SUCCESS)
// {
// drprintf((__FUNCTION__": pfnPinMode failed, Status(0x%x)", Status));
// /* don't treat it as fatal */
// Status = STATUS_SUCCESS;
// }
}
}
else
{
pNewVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo);
break;
}
}
else
{
pNewVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo);
break;
}
}
}
if (pPreferredModeId)
return Status;
}
NTSTATUS vboxVidPnCreatePopulateSourceModeSetFromLegacy(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
VIDEO_MODE_INFORMATION *pModes, uint32_t cModes, int iPreferredMode, D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID *pPreferredModeId)
{
srcId, /*__in CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if(Status != STATUS_SUCCESS)
{
}
}
else
{
}
}
else
return Status;
}
NTSTATUS vboxVidPnCreatePopulateTargetModeSetFromLegacy(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
{
tgtId, /*__in CONST D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if(Status != STATUS_SUCCESS)
{
}
}
else
{
}
}
else
return Status;
}
typedef struct VBOXVIDPNCHECKADDMONITORMODES
{
static DECLCALLBACK(BOOLEAN) vboxVidPnCheckAddMonitorModesEnum(struct _DEVICE_EXTENSION* pDevExt, D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf,
{
{
if (Status == STATUS_SUCCESS)
{
{
/* mark it as unneeded */
break;
}
}
else
{
drprintf((__FUNCTION__": vboxVidPnPopulateTargetModeInfoFromLegacy failed Status(0x%x)\n", Status));
break;
}
}
return Status == STATUS_SUCCESS;
}
typedef struct VBOXVIDPNCHECKMONMODESENUM
{
const D3DKMDT_MONITOR_SOURCE_MODE * pMonitorSMI;
static DECLCALLBACK(BOOLEAN) vboxFidPnCheckMonitorModesEnum(D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf,
{
{
if (pInfo->pMonitorSMI)
{
}
}
else
{
}
return TRUE;
}
{
Status = pDevExt->u.primary.DxgkInterface.DxgkCbQueryMonitorInterface(pDevExt->u.primary.DxgkInterface.DeviceHandle, DXGK_MONITOR_INTERFACE_VERSION_V1, &pMonitorInterface);
if (Status == STATUS_SUCCESS)
{
Status = pMonitorInterface->pfnAcquireMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle,
if (Status == STATUS_SUCCESS)
{
for (uint32_t i = 0; i < cResolutions; ++i)
{
if (Status == STATUS_SUCCESS)
{
if (!ChkInfo.pMonitorSMI)
{
pRes,
FALSE//i == (uint32_t)iPreferred
);
if (Status != STATUS_SUCCESS)
{
drprintf((__FUNCTION__": vboxVidPnCreatePopulateMonitorSourceModeInfoFromLegacy failed Status(0x%x)\n", Status));
break;
}
}
else
{
}
}
else
{
break;
}
}
NTSTATUS tmpStatus = pMonitorInterface->pfnReleaseMonitorSourceModeSet(pDevExt->u.primary.DxgkInterface.DeviceHandle, hMonitorSMS);
if (tmpStatus != STATUS_SUCCESS)
}
else
}
else
return Status;
}
NTSTATUS vboxVidPnCreatePopulateVidPnFromLegacy(PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
{
srcId, /*__in CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if(Status == STATUS_SUCCESS)
{
tgtId, /*__in CONST D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if(Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
pNewVidPnPresentPathInfo->VidPnTargetColorBasis = D3DKMDT_CB_SRGB; /* @todo: how does it matters? */
// pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionType = D3DKMDT_VPPMT_NOPROTECTION;
memset(&pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport, 0, sizeof (pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport));
// pNewVidPnPresentPathInfo->CopyProtection.CopyProtectionSupport.NoProtection = 1;
// pNewVidPnPresentPathInfo->GammaRamp.Type = D3DDDI_GAMMARAMP_DEFAULT;
// pNewVidPnPresentPathInfo->GammaRamp.DataSize = 0;
if (Status == STATUS_SUCCESS)
{
{
if (Status == STATUS_SUCCESS)
{
if (Status != STATUS_SUCCESS)
}
else
}
}
else
{
}
}
else
}
else
}
else
{
}
}
else
{
}
}
else
}
else
{
}
}
else
{
}
}
else
return Status;
}
typedef struct VBOXVIDPNPOPRESOLUTIONENUM
{
int cResolutions;
int cResultResolutions;
static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateResolutionsFromSourceModeSetEnum(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
if (vboxWddmVideoResolutionFind(pInfo->pResolutions, pInfo->cResultResolutions, &pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize) < 0)
{
{
pInfo->pResolutions[pInfo->cResultResolutions] = pNewVidPnSourceModeInfo->Format.Graphics.PrimSurfSize;
}
else
{
}
}
return Status == STATUS_SUCCESS;
}
static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateResolutionsFromTargetModeSetEnum(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
if (vboxWddmVideoResolutionFind(pInfo->pResolutions, pInfo->cResultResolutions, &pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize) < 0)
{
{
pInfo->pResolutions[pInfo->cResultResolutions] = pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize;
}
else
{
}
}
return Status == STATUS_SUCCESS;
}
typedef struct VBOXVIDPNPOPMODEENUM
{
int cModes;
int cResultModes;
static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateModesFromSourceModeSetEnum(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
{
{
{
++pInfo->cResultModes;
}
else
{
}
}
}
else
{
Assert(0);
}
return Status == STATUS_SUCCESS;
}
typedef struct VBOXVIDPNPOPMODETARGETENUM
{
int cSuperset;
static DECLCALLBACK(BOOLEAN) vboxVidPnPopulateModesFromTargetModeSetEnum(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
Status = vboxWddmGetModesForResolution(pInfo->pSuperset, pInfo->cSuperset, -1, &pNewVidPnTargetModeInfo->VideoSignalInfo.ActiveSize,
pInfo->Base.pModes + pInfo->Base.cResultModes, pInfo->Base.cModes - pInfo->Base.cResultModes, &cResult, NULL);
if (Status == STATUS_SUCCESS)
{
}
return Status == STATUS_SUCCESS;
}
{
if (Status == STATUS_SUCCESS)
{
Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo);
{
}
else if (Status != STATUS_SUCCESS)
if (Status == STATUS_SUCCESS)
{
Status = pCurVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo);
{
}
else if (Status != STATUS_SUCCESS)
if (bSrcPinned)
{
if (!bTgtPinned)
{
#if 1
NULL,
0, /* flags */
NULL);
#else
/* adjust target mode set relative to source mode set */
/* 1. get list of resolutions for source and for target
* 2. if they do not match create and populate a new set */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
D3DKMDT_2DREGION *pSrcResolutions = cSrcModes ? (D3DKMDT_2DREGION*)vboxWddmMemAlloc(cSrcModes * sizeof (pSrcResolutions[0])) : NULL;
if (pSrcResolutions || !cSrcModes)
{
VBOXVIDPNPOPRESOLUTIONENUM Info = {0};
if (cSrcModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
D3DKMDT_2DREGION *pTgtResolutions = cTgtModes ? (D3DKMDT_2DREGION*)vboxWddmMemAlloc(cTgtModes * sizeof (pTgtResolutions[0])) : NULL;
if (pTgtResolutions || !cTgtModes)
{
if (cTgtModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
bool bNeedSet;
{
/* need to check all modes */
}
else
{
bNeedSet = true;
}
if (bNeedSet)
{
NULL,
0, /* flags */
NULL);
}
}
else
{
}
}
if (pTgtResolutions)
}
else
{
}
}
else
{
}
}
if (pSrcResolutions)
}
else
{
}
}
}
#endif
}
}
else if (bTgtPinned)
{
#if 1
Status = Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hDesiredVidPn, pVidPnInterface,
#else
/* adjust source mode set relative to target mode set */
/* 1. get list of modes for target resolutions
* 2. get list of modes for sources
* 3. if modes do not match create and populate new set */
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
VIDEO_MODE_INFORMATION *pSrcModes = cSrcModes ? (VIDEO_MODE_INFORMATION*)vboxWddmMemAlloc(cSrcModes * sizeof (pSrcModes[0])) : NULL;
{
VBOXVIDPNPOPMODETARGETENUM Info = {0};
if (cSrcModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
VIDEO_MODE_INFORMATION *pTgtModes = cTgtModes ? (VIDEO_MODE_INFORMATION*)vboxWddmMemAlloc(pInfo->cModes * sizeof (pTgtModes[0])) : NULL;
{
if (cTgtModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
bool bNeedSet;
{
/* need to check all modes */
}
else
{
bNeedSet = true;
}
if (bNeedSet)
{
Status = Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hDesiredVidPn, pVidPnInterface,
}
}
else
{
}
}
if (pTgtModes)
}
else
{
}
}
else
{
}
}
if (pSrcModes)
}
else
{
}
}
}
#endif
}
else
{
#if 1
Status = Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hDesiredVidPn, pVidPnInterface,
NULL,
0,
NULL);
#else
/* neither Source nor Target are pinned */
/* 1. get list of target resolutions
* 2. if resolutions do not match with the complete list we have build - create and populate new
* 3. get list of modes for sources
* 4. if modes do not match with the complete list we have - create and populate a new set */
if (Status == STATUS_SUCCESS)
{
bool bNeedSet = false;
{
bNeedSet = true;
}
else
{
VIDEO_MODE_INFORMATION *pSrcModes = cSrcModes ? (VIDEO_MODE_INFORMATION*)vboxWddmMemAlloc(cSrcModes * sizeof (pSrcModes[0])) : NULL;
{
VBOXVIDPNPOPMODETARGETENUM Info = {0};
if (cSrcModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
{
/* need to check all modes */
}
else
{
bNeedSet = true;
}
}
}
if (pSrcModes)
}
else
{
}
}
{
Status = Status = vboxVidPnCreatePopulateSourceModeSetFromLegacy(pDevExt, hDesiredVidPn, pVidPnInterface,
}
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
bool bNeedSet = false;
if (cTgtModes == cResolutions)
{
D3DKMDT_2DREGION *pTgtResolutions = cTgtModes ? (D3DKMDT_2DREGION*)vboxWddmMemAlloc(cTgtModes * sizeof (pTgtResolutions[0])) : NULL;
if (pTgtResolutions || !cTgtModes)
{
VBOXVIDPNPOPRESOLUTIONENUM Info = {0};
if (cTgtModes)
{
}
if (Status == STATUS_SUCCESS)
{
{
{
/* need to check all modes */
}
else
{
bNeedSet = true;
}
}
else
{
}
}
if (pTgtResolutions)
}
else
{
}
}
else
{
bNeedSet = true;
}
{
NULL,
0, /* flags */
NULL);
}
}
}
}
#endif
}
{
pCurVidPnTargetModeSetInterface->pfnReleaseModeInfo(hCurVidPnTargetModeSet, pPinnedVidPnTargetModeInfo);
}
}
else
{
if (Status == STATUS_SUCCESS)
{
Msm.NumQualityLevels = 0;
}
pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo);
}
}
else
return Status;
}
DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
bool bConversionSupported =
(
)
&& (
)
pNewVidPnPresentPathInfo->VidPnSourceId, pNewVidPnPresentPathInfo->VidPnTargetId, bConversionSupported);
return Status == STATUS_SUCCESS;
}
DECLCALLBACK(BOOLEAN) vboxVidPnCofuncModalityCheckPathsSupportedEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
bool bConversionSupported =
(
)
&& (
)
pNewVidPnPresentPathInfo->VidPnSourceId, pNewVidPnPresentPathInfo->VidPnTargetId, bConversionSupported);
return Status == STATUS_SUCCESS;
}
NTSTATUS vboxVidPnEnumMonitorSourceModes(D3DKMDT_HMONITORSOURCEMODESET hMonitorSMS, CONST DXGK_MONITORSOURCEMODESET_INTERFACE *pMonitorSMSIf,
{
if (Status == STATUS_SUCCESS)
{
while (1)
{
{
if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
drprintf((__FUNCTION__": pfnAcquireNextModeInfo Failed Status(0x%x), ignored since callback returned false\n", Status));
}
break;
}
else if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
NTSTATUS vboxVidPnEnumSourceModes(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
NTSTATUS Status = pVidPnSourceModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
Status = pVidPnSourceModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnSourceModeSet, pNewVidPnSourceModeInfo, &pNextVidPnSourceModeInfo);
{
if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
drprintf((__FUNCTION__": pfnAcquireNextModeInfo Failed Status(0x%x), ignored since callback returned false\n", Status));
}
break;
}
else if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
NTSTATUS vboxVidPnEnumTargetModes(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
NTSTATUS Status = pVidPnTargetModeSetInterface->pfnAcquireFirstModeInfo(hNewVidPnTargetModeSet, &pNewVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
Status = pVidPnTargetModeSetInterface->pfnAcquireNextModeInfo(hNewVidPnTargetModeSet, pNewVidPnTargetModeInfo, &pNextVidPnTargetModeInfo);
{
if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
drprintf((__FUNCTION__": pfnAcquireNextModeInfo Failed Status(0x%x), ignored since callback returned false\n", Status));
}
break;
}
else if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
NTSTATUS vboxVidPnEnumTargetsForSource(PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
NTSTATUS Status = pVidPnTopologyInterface->pfnGetNumPathsFromSource(hVidPnTopology, VidPnSourceId, &cTgtPaths);
if (Status == STATUS_SUCCESS)
{
{
Status = pVidPnTopologyInterface->pfnEnumPathTargetsFromSource(hVidPnTopology, VidPnSourceId, i, &VidPnTargetId);
if (Status == STATUS_SUCCESS)
{
if (!pfnCallback(pDevExt, hVidPnTopology, pVidPnTopologyInterface, VidPnSourceId, VidPnTargetId, cTgtPaths, pContext))
break;
}
else
{
break;
}
}
}
else if (Status != STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY)
return Status;
}
NTSTATUS vboxVidPnEnumPaths(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
NTSTATUS Status = pVidPnTopologyInterface->pfnAcquireFirstPathInfo(hVidPnTopology, &pNewVidPnPresentPathInfo);
if (Status == STATUS_SUCCESS)
{
while (1)
{
Status = pVidPnTopologyInterface->pfnAcquireNextPathInfo(hVidPnTopology, pNewVidPnPresentPathInfo, &pNextVidPnPresentPathInfo);
{
if (Status == STATUS_SUCCESS)
else
{
drprintf((__FUNCTION__": pfnAcquireNextPathInfo Failed Status(0x%x), ignored since callback returned false\n", Status));
}
break;
}
else if (Status == STATUS_SUCCESS)
else if (Status == STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET)
{
break;
}
else
{
break;
}
}
}
else if (Status == STATUS_GRAPHICS_DATASET_IS_EMPTY)
else
return Status;
}
NTSTATUS vboxVidPnSetupSourceInfo(struct _DEVICE_EXTENSION* pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_SOURCE pSource, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
{
return STATUS_SUCCESS;
}
NTSTATUS vboxVidPnCommitSourceMode(struct _DEVICE_EXTENSION* pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, CONST D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, PVBOXWDDM_ALLOCATION pAllocation)
{
{
}
drprintf((__FUNCTION__": invalid srcId (%d), cSources(%d)\n", srcId, commonFromDeviceExt(pDevExt)->cDisplays));
return STATUS_INVALID_PARAMETER;
}
typedef struct VBOXVIDPNCOMMITTARGETMODE
{
const DXGK_VIDPN_INTERFACE* pVidPnInterface;
DECLCALLBACK(BOOLEAN) vboxVidPnCommitTargetModeEnum(PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, SIZE_T cTgtPaths, PVOID pContext)
{
NTSTATUS Status = pInfo->pVidPnInterface->pfnAcquireTargetModeSet(pInfo->hVidPn, VidPnTargetId, &hVidPnTargetModeSet, &pVidPnTargetModeSetInterface);
if (Status == STATUS_SUCCESS)
{
Status = pVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
{
pTarget->ScanLineState = 0;
}
}
}
else
return Status == STATUS_SUCCESS;
}
NTSTATUS vboxVidPnCommitSourceModeForSrcId(struct _DEVICE_EXTENSION* pDevExt, const D3DKMDT_HVIDPN hDesiredVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, PVBOXWDDM_ALLOCATION pAllocation)
{
if (Status == STATUS_SUCCESS)
{
Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
if (Status == STATUS_SUCCESS)
{
}
else if (Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY)
{
}
else
}
else
}
else
/* release */
pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo);
}
else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED)
{
}
else
}
else
{
}
return Status;
}
DECLCALLBACK(BOOLEAN) vboxVidPnCommitPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
{
Status = vboxVidPnCommitSourceModeForSrcId(pDevExt, hDesiredVidPn, pVidPnInterface, pVidPnPresentPathInfo->VidPnSourceId, (PVBOXWDDM_ALLOCATION)pCommitInfo->pCommitVidPnArg->hPrimaryAllocation);
if (Status != STATUS_SUCCESS)
}
return Status == STATUS_SUCCESS;
}
#define VBOXVIDPNDUMP_STRCASE(_t) \
#define VBOXVIDPNDUMP_STRCASE_UNKNOWN() \
default: Assert(0); return "Unknown";
{
switch (ImportanceOrdinal)
{
}
}
{
switch (Scaling)
{
}
}
{
switch (Rotation)
{
}
}
{
switch (ColorBasis)
{
}
}
{
switch (PixelValueAccessMode)
{
}
}
{
switch (Content)
{
}
}
const char* vboxVidPnDumpStrCopyProtectionType(D3DKMDT_VIDPN_PRESENT_PATH_COPYPROTECTION_TYPE CopyProtectionType)
{
switch (CopyProtectionType)
{
}
}
{
switch (Type)
{
}
}
{
switch (Type)
{
}
}
const char* vboxVidPnDumpStrScanLineOrdering(D3DDDI_VIDEO_SIGNAL_SCANLINE_ORDERING ScanLineOrdering)
{
switch (ScanLineOrdering)
{
}
}
{
switch (EnumPivotType)
{
}
}
{
switch (Preference)
{
}
}
{
switch (VideoStandard)
{
}
}
{
switch (PixelFormat)
{
}
}
void vboxVidPnDumpCopyProtectoin(const char *pPrefix, const D3DKMDT_VIDPN_PRESENT_PATH_COPYPROTECTION *pCopyProtection, const char *pSuffix)
{
}
void vboxVidPnDumpPathTransformation(const D3DKMDT_VIDPN_PRESENT_PATH_TRANSFORMATION *pContentTransformation)
{
drprintf((" --Transformation: Scaling(%s), ScalingSupport(%d), Rotation(%s), RotationSupport(%d)--\n",
vboxVidPnDumpStrRotation(pContentTransformation->Rotation), pContentTransformation->RotationSupport));
}
{
}
void vboxVidPnDumpRational(const char *pPrefix, const D3DDDI_RATIONAL *pRational, const char *pSuffix)
{
drprintf(("%s%d/%d=%d%s", pPrefix, pRational->Numerator, pRational->Denominator, pRational->Numerator/pRational->Denominator, pSuffix));
}
void vboxVidPnDumpRanges(const char *pPrefix, const D3DKMDT_COLOR_COEFF_DYNAMIC_RANGES *pDynamicRanges, const char *pSuffix)
{
pSuffix));
}
void vboxVidPnDumpGammaRamp(const char *pPrefix, const D3DKMDT_GAMMA_RAMP *pGammaRamp, const char *pSuffix)
{
pSuffix));
}
void vboxVidPnDumpSourceMode(const char *pPrefix, const D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, const char *pSuffix)
{
drprintf(("format(%s), ", vboxVidPnDumpStrPixFormat(pVidPnSourceModeInfo->Format.Graphics.PixelFormat)));
drprintf(("clrBasis(%s), ", vboxVidPnDumpStrColorBasis(pVidPnSourceModeInfo->Format.Graphics.ColorBasis)));
drprintf(("pvam(%s)%s", vboxVidPnDumpStrPvam(pVidPnSourceModeInfo->Format.Graphics.PixelValueAccessMode), pSuffix));
}
void vboxVidPnDumpSignalInfo(const char *pPrefix, const D3DKMDT_VIDEO_SIGNAL_INFO *pVideoSignalInfo, const char *pSuffix)
{
drprintf(("%sVStd(%s), ", pPrefix, vboxVidPnDumpStrSignalStandard(pVideoSignalInfo->VideoStandard)));
drprintf(("PixelRate(%d), ScanLineOrdering(%s)%s", pVideoSignalInfo->PixelRate, vboxVidPnDumpStrScanLineOrdering(pVideoSignalInfo->ScanLineOrdering), pSuffix));
}
void vboxVidPnDumpTargetMode(const char *pPrefix, const D3DKMDT_VIDPN_TARGET_MODE* CONST pVidPnTargetModeInfo, const char *pSuffix)
{
drprintf(("Preference(%s)%s", vboxVidPnDumpStrModePreference(pVidPnTargetModeInfo->Preference), pSuffix));
}
void vboxVidPnDumpPinnedSourceMode(const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
{
if (Status == STATUS_SUCCESS)
{
Status = pCurVidPnSourceModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnSourceModeSet, &pPinnedVidPnSourceModeInfo);
if (Status == STATUS_SUCCESS)
{
pCurVidPnSourceModeSetInterface->pfnReleaseModeInfo(hCurVidPnSourceModeSet, pPinnedVidPnSourceModeInfo);
}
else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED)
{
drprintf(("Source NOT Pinned\n"));
}
else
{
}
}
else
{
}
}
static DECLCALLBACK(BOOLEAN) vboxVidPnDumpSourceModeSetEnum(D3DKMDT_HVIDPNSOURCEMODESET hNewVidPnSourceModeSet, const DXGK_VIDPNSOURCEMODESET_INTERFACE *pVidPnSourceModeSetInterface,
{
return TRUE;
}
void vboxVidPnDumpSourceModeSet(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
{
if (Status == STATUS_SUCCESS)
{
if (Status != STATUS_SUCCESS)
{
}
}
else
{
}
}
DECLCALLBACK(BOOLEAN) vboxVidPnDumpTargetModeSetEnum(D3DKMDT_HVIDPNTARGETMODESET hNewVidPnTargetModeSet, const DXGK_VIDPNTARGETMODESET_INTERFACE *pVidPnTargetModeSetInterface,
{
return TRUE;
}
void vboxVidPnDumpTargetModeSet(PDEVICE_EXTENSION pDevExt, const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
{
if (Status == STATUS_SUCCESS)
{
if (Status != STATUS_SUCCESS)
{
}
}
else
{
}
}
void vboxVidPnDumpPinnedTargetMode(const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId)
{
if (Status == STATUS_SUCCESS)
{
Status = pCurVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hCurVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo);
if (Status == STATUS_SUCCESS)
{
pCurVidPnTargetModeSetInterface->pfnReleaseModeInfo(hCurVidPnTargetModeSet, pPinnedVidPnTargetModeInfo);
}
else if (Status == STATUS_GRAPHICS_MODE_NOT_PINNED)
{
drprintf(("Target NOT Pinned\n"));
}
else
{
}
}
else
{
}
}
void vboxVidPnDumpCofuncModalityArg(const char *pPrefix, CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* CONST pEnumCofuncModalityArg, const char *pSuffix)
{
drprintf(("%sPivotType(%s), SourceId(0x%x), TargetId(0x%x),%s", pPrefix, vboxVidPnDumpStrCFMPivotType(pEnumCofuncModalityArg->EnumPivotType),
pEnumCofuncModalityArg->EnumPivot.VidPnSourceId, pEnumCofuncModalityArg->EnumPivot.VidPnTargetId, pSuffix));
}
void vboxVidPnDumpPath(const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, const D3DKMDT_VIDPN_PRESENT_PATH *pVidPnPresentPathInfo)
{
drprintf((" >>**** Start Dump VidPn Path ****>>\n"));
drprintf(("VidPnSourceId(%d), VidPnTargetId(%d)\n",
drprintf(("Importance(%s), TargetColorBasis(%s), Content(%s), ",
vboxVidPnDumpRanges("CCDynamicRanges: ", &pVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges, "| ");
drprintf((" <<**** Stop Dump VidPn Path ****<<\n"));
}
typedef struct VBOXVIDPNDUMPPATHENUM
{
const DXGK_VIDPN_INTERFACE* pVidPnInterface;
static DECLCALLBACK(BOOLEAN) vboxVidPnDumpPathEnum(D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
{
return TRUE;
}
void vboxVidPnDumpVidPn(const char * pPrefix, PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface, const char * pSuffix)
{
NTSTATUS Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
if (Status == STATUS_SUCCESS)
{
}
{
}
}