VBoxDispD3D.cpp revision d64aa881df34a86dd70ab0e1b7b94ffa41be9731
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * VBoxVideo Display D3D User mode dll
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * Copyright (C) 2011 Oracle Corporation
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * available from http://www.virtualbox.org. This file is free software;
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * you can redistribute it and/or modify it under the terms of the GNU
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * General Public License (GPL) as published by the Free Software
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync/* uncomment to enable particular logging */
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync//#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_ENABLE
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsyncstatic VBoxDispProfileSet g_VBoxDispProfileDDI("D3D_DDI");
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE() VBOXDISPPROFILE_FUNCTION_LOGGER_DEFINE(g_VBoxDispProfileDDI)
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync } while (0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET() do {\
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync } while (0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DISABLE_CURRENT() do {\
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync VBOXDISPPROFILE_FUNCTION_LOGGER_DISABLE_CURRENT();\
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync } while (0)
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE() do {} while(0)
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DUMP() do {} while(0)
218c5abcfe14c89d04353015e755a02447960018vboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET() do {} while(0)
218c5abcfe14c89d04353015e755a02447960018vboxsync#define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DISABLE_CURRENT() do {} while (0)
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsyncstatic VBoxDispProfileFpsCounter g_VBoxDispFpsDDI(64);
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE() VBOXDISPPROFILE_STATISTIC_LOGGER_DEFINE(&g_VBoxDispFpsDDI)
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DISABLE_CURRENT() do {\
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync VBOXDISPPROFILE_STATISTIC_LOGGER_DISABLE_CURRENT();\
e45e3ae4a834169539e689759ba6b3ac71bfe40fvboxsync } while (0)
e7e589ca404045e288030a4151e57b63976cb39dvboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev) do { \
e7e589ca404045e288030a4151e57b63976cb39dvboxsync VBOXDISPPROFILE_STATISTIC_LOGGER_LOG_AND_DISABLE_CURRENT(); \
7255e1c7174fd3b892a74dede74e72557f6cced9vboxsync double tup = g_VBoxDispFpsDDI.GetTimeProcPercent(); \
7255e1c7174fd3b892a74dede74e72557f6cced9vboxsync VBOXDISPPROFILE_DUMP(("fps: %f, cps: %.1f, host %.1f%%\n", fps, cps, tup)); \
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync } while (0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE() do {} while(0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DISABLE_CURRENT() do {} while (0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev) do {} while (0)
7255e1c7174fd3b892a74dede74e72557f6cced9vboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DISABLE_CURRENT();\
7255e1c7174fd3b892a74dede74e72557f6cced9vboxsync } while (0)
9d508d63ddd8cbaa227c3e3176bb376ba98ffa53vboxsync#define VBOXDISPPROFILE_DDI_REPORT_FRAME(_pDev) do {\
9d508d63ddd8cbaa227c3e3176bb376ba98ffa53vboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev); \
9d508d63ddd8cbaa227c3e3176bb376ba98ffa53vboxsync } while (0)
b4514c911ccdb647c9c0f503f3cee0660f41104avboxsync#define VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE() do {} while (0)
218c5abcfe14c89d04353015e755a02447960018vboxsync#define VBOXDISPPROFILE_DDI_DUMPRESET(_pDev) do {} while (0)
#define VBOXDISP_DDI_PROLOGUE() \
VBOXVDBG_BREAK_DDI(); \
#ifdef VBOXDISPMP_TEST
#define VBOXDISP_WITH_WINE_BB_WORKAROUND
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
{D3DDDIFMT_D16, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
{D3DDDIFMT_D24S8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
{D3DDDIFMT_D24X8, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
{D3DDDIFMT_X8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
{D3DDDIFMT_D32F_LOCKABLE, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
{D3DDDIFMT_S8D24, FORMATOP_TEXTURE|FORMATOP_ZSTENCIL|FORMATOP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_OVERLAY, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
void vboxDispLock()
void vboxDispUnlock()
void vboxDispLockInit()
#ifdef VBOX_WITH_CRHGSMI
#define VBOXUHGSMIKMT_PERTHREAD
#ifdef VBOXUHGSMIKMT_PERTHREAD
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_CRHGSMI
vboxDispLock(); /* the lock is needed here only to ensure callbacks are not initialized & used concurrently
* @todo: make a separate call used to init the per-thread info and make the VBoxDispCrHgsmiInit be called only once */
#ifdef DEBUG_misha
if (pHgsmi)
return VINF_SUCCESS;
return VINF_SUCCESS;
#ifdef VBOX_WITH_CRHGSMI
#ifdef DEBUG_misha
if (pHgsmi)
return NULL;
vboxDispLock();
if (!g_cVBoxUhgsmiKmtRefs)
// g_VBoxUhgsmiKmt.BasePrivate.hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&g_VBoxUhgsmiKmt.BasePrivate.Base);
// Assert(g_VBoxUhgsmiKmt.BasePrivate.hClient);
return hr;
vboxDispLock();
if (!g_cVBoxUhgsmiKmtRefs)
return hr;
return hr;
return S_OK;
class VBoxDispCrHgsmiScope
#define VBOXDISPCRHGSMI_SCOPE_SET_DEV(_pDev) VBoxDispCrHgsmiScope __vboxCrHgsmiScope(&(_pDev)->Uhgsmi.BasePrivate)
#define VBOXDISPCRHGSMI_SCOPE_SET_GLOBAL() VBoxDispCrHgsmiScope __vboxCrHgsmiScope(&g_VBoxUhgsmiKmt.BasePrivate)
#define VBOXDISPCRHGSMI_SCOPE_SET_GLOBAL() do {} while(0)
return VERR_NOT_IMPLEMENTED;
return VERR_NOT_IMPLEMENTED;
return NULL;
typedef struct VBOXWDDMDISP_NSCADD
return hr;
static BOOLEAN vboxWddmDalCheckRemove(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
return fRemoved;
if (bReinitRenderData)
return E_FAIL;
PVBOXWDDMDISP_ALLOCATION pAlloc = RTListGetFirst(&pDevice->DirtyAllocList, VBOXWDDMDISP_ALLOCATION, DirtyAllocListEntry);
if (pAlloc)
RenderData.CommandLength = pDevice->DefaultContext.ContextInfo.CommandBufferSize - NscAdd.cbCommandBuffer;
RenderData.NumAllocations = pDevice->DefaultContext.ContextInfo.AllocationListSize - NscAdd.cAllocationList;
RenderData.NumPatchLocations = pDevice->DefaultContext.ContextInfo.PatchLocationListSize - NscAdd.cPatchLocationList;
return S_OK;
static BOOLEAN vboxWddmDalCheckAdd(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOLEAN fWrite)
#ifdef VBOX_WDDM_SHRC_WO_NOTIFY
#ifdef VBOX_WDDM_SHRC_WO_NOTIFY
Assert(!pAlloc->DirtyAllocListEntry.pNext || (!fWrite && pAlloc->hSharedHandle && pAlloc->fDirtyWrite));
return FALSE;
return TRUE;
#ifdef VBOX_WITH_VIDEOHWACCEL
int vboxSurfDescMerge(DDSURFACEDESC *paDescs, uint32_t *pcDescs, uint32_t cMaxDescs, DDSURFACEDESC *pDesc)
return VERR_INVALID_PARAMETER;
return VINF_SUCCESS;
++cDescs;
return VINF_SUCCESS;
return VERR_BUFFER_OVERFLOW;
return VINF_SUCCESS;
++cOps;
return VINF_SUCCESS;
return VERR_BUFFER_OVERFLOW;
return VERR_OUT_OF_RESOURCES;
#ifdef VBOX_WITH_VIDEOHWACCEL
if (pvBuf)
if (fourcc)
return VERR_OUT_OF_RESOURCES;
return VINF_SUCCESS;
PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
if (pRc)
return pRc;
return NULL;
static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)
if (!pRect)
if (bToLockInfo)
if (bToLockInfo)
uint32_t offAllocMemStart = vboxWddmCalcOffXYrd(pRect->top, pRect->left, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format);
if (bToLockInfo)
uint32_t cbSize = vboxWddmCalcSize(pAlloc->SurfDesc.pitch, pRect->bottom - pRect->top, pAlloc->SurfDesc.format);
Assert(0);
return hr;
Assert(0);
return hr;
return S_OK;
return hr;
return S_OK;
#ifdef VBOXWDDMDISP_DEBUG
int iRc = 0;
switch (enmPool)
case D3DDDIPOOL_SYSTEMMEM:
return D3DPOOL_SYSTEMMEM;
case D3DDDIPOOL_VIDEOMEMORY:
case D3DDDIPOOL_LOCALVIDMEM:
return D3DPOOL_DEFAULT;
Assert(0);
return D3DPOOL_DEFAULT;
return fUsage;
return fFlags;
return D3DTEXF_POINT;
return D3DTEXF_LINEAR;
return D3DTEXF_NONE;
static HRESULT vboxWddmRenderTargetSet(PVBOXWDDMDISP_DEVICE pDevice, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch);
static HRESULT vboxWddmSwapchainKmSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
} Buf;
++cAllocsKm;
DdiEscape.PrivateDriverDataSize = RT_OFFSETOF(VBOXDISPIFESCAPE_SWAPCHAININFO, SwapchainInfo.ahAllocs[Buf.SwapchainInfo.SwapchainInfo.cAllocs]);
#ifdef DEBUG_misha
return S_OK;
static HRESULT vboxWddmSwapchainKmDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
return hr;
static HRESULT vboxWddmSwapchainDestroyIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
#ifndef VBOXWDDM_WITH_VISIBLE_FB
return S_OK;
return S_OK;
DECLINLINE(VOID) vboxWddmSwapchainClear(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
static VOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
PVBOXWDDMDISP_SWAPCHAIN pCur = RTListGetFirst(&pDevice->SwapchainList, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
while (pCur)
PVBOXWDDMDISP_SWAPCHAIN pSwapchain = (PVBOXWDDMDISP_SWAPCHAIN)RTMemAllocZ(sizeof (VBOXWDDMDISP_SWAPCHAIN));
if (pSwapchain)
return pSwapchain;
return NULL;
DECLINLINE(VOID) vboxWddmSwapchainRtInit(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRt, PVBOXWDDMDISP_ALLOCATION pAlloc)
DECLINLINE(VOID) vboxWddmSwapchainBbAddTail(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bAssignAsBb)
else if (bAssignAsBb)
DECLINLINE(PVBOXWDDMDISP_RENDERTGT) vboxWddmSwapchainRtForAlloc(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc)
return NULL;
Assert(0);
return NULL;
DECLINLINE(UINT) vboxWddmSwapchainRtIndex(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
return iRt;
DECLINLINE(VOID) vboxWddmSwapchainRtRemove(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
DECLINLINE(VOID) vboxWddmSwapchainSetBb(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
static PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent)
if (pSwapchain)
return pSwapchain;
if (!pSwapchain)
PVBOXWDDMDISP_SWAPCHAIN pCur = RTListGetFirst(&pDevice->SwapchainList, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
while (pCur)
&& vboxWddmSwapchainRtIndex(pCur, pRt) == 0) /* <- in case we add a rt to the swapchain on present this would mean
if (!pSwapchain)
if (pSwapchain)
return pSwapchain;
static PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainCreateForRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc)
if (pSwapchain)
return pSwapchain;
return NULL;
return iBb != (~0) ? (iBb + pSwapchain->iBB) % pSwapchain->cRTs : vboxWddmSwapchainIdxFb(pSwapchain);
static HRESULT vboxWddmSwapchainRtSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, uint32_t iBb)
return S_OK;
iBb = 0;
return hr;
return hr;
#ifdef DEBUG_misha
if (pD3D9OldSurf)
tmpHr = pDevice->pDevice9If->StretchRect(pD3D9Bb, NULL, (IDirect3DSurface9*)vboxWddmSwapchainGetBb(pSwapchain)->pAlloc->pD3DIf, NULL, D3DTEXF_NONE);
return hr;
static HRESULT vboxWddmSwapchainSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
return hr;
static VOID vboxWddmSwapchainFillParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams)
#ifdef DEBUG_misha
/* not supported by wine properly, need to use offscreen render targets and blit their data to swapchain RTs*/
static HRESULT vboxWddmSwapchainSwtichOffscreenRt(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, BOOL fForceCreate)
if (pOldIf)
return hr;
if (fHasSurf)
if (pD3D9OldSurf)
if (pD3D9OldSurf)
if (pD3D9OldSurf)
if (pD3D9OldSurf)
return hr;
static HRESULT vboxWddmSwapchainSwtichRtPresent(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
return S_OK;
return hr;
return hr;
static HRESULT vboxWddmShRcRefAlloc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL fAddRef, DWORD *pcRefs)
return TRUE;
if (pcRefs)
return hr;
static HRESULT vboxWddmShRcRefRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, BOOL fAddRef, DWORD *pcRefs)
for (DWORD j = 0; j < i; ++j)
return hr;
if (pcRefs)
return S_OK;
static HRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
return S_OK;
if (pOldIf)
if (fNeedRtPresentSwitch)
if (!bReuseSwapchain)
hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params, &pDevice9If);
if (pOldIf)
return hr;
if (fNeedRtPresentSwitch)
#ifndef VBOXWDDM_WITH_VISIBLE_FB
#ifdef DEBUG
if (pOldIf)
return S_OK;
static HRESULT vboxWddmSwapchainCreateIfForRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_SWAPCHAIN *ppSwapchain)
if (pSwapchain)
return hr;
return E_OUTOFMEMORY;
static HRESULT vboxWddmSwapchainPresentPerform(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain);
static HRESULT vboxWddmSwapchainBbUpdate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pBbAlloc)
return S_OK;
return hr;
return E_FAIL;
static HRESULT vboxWddmSwapchainSurfGet(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc, IDirect3DSurface9 **ppSurf)
#ifndef VBOXWDDM_WITH_VISIBLE_FB
# ifdef VBOXDISP_WITH_WINE_BB_WORKAROUND
&& vboxWddmSwapchainNumRTs(pSwapchain) != 1 /* for swapchains w/o a backbuffer the alloc will contain the back-buffer actually */
return hr;
return S_OK;
static HRESULT vboxWddmSwapchainRtSurfGet(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch, IDirect3DSurface9 **ppSurf)
if (!bOnSwapchainSynch)
if (iRt == 0)
return hr;
return hr;
return hr;
return S_OK;
static HRESULT vboxWddmSwapchainPresentPerform(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
return hr;
return hr;
return hr;
return hr;
static HRESULT vboxWddmSwapchainPresent(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc)
/* we currently *assume* that presenting shared resource is only possible when 3d app is rendering with composited desktop on,
return S_OK;
if (!bNeedPresent)
return S_OK;
if (pSwapchain)
return hr;
return E_OUTOFMEMORY;
static void vboxWddmDbgRenderTargetUpdateCheckSurface(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t iBBuf)
static void vboxWddmDbgRenderTargetCheck(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, uint32_t iNewRTFB)
#ifdef VBOXWDDM_WITH_VISIBLE_FB
if (iNewRTFB == i)
# define VBOXVDBG_RTGT_STATECHECK(_pDev) (vboxWddmDbgRenderTargetCheck((_pDev), (_pDev)->aScreens[(_pDev)->iPrimaryScreen].pRenderTargetRc, (_pDev)->aScreens[(_pDev)->iPrimaryScreen].iRenderTargetFrontBuf))
if (pRc)
return hr;
static HRESULT vboxWddmRenderTargetSet(PVBOXWDDMDISP_DEVICE pDevice, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch)
if (pSwapchain)
return hr;
return hr;
return hr;
switch (dwReason)
case DLL_PROCESS_ATTACH:
#ifdef VBOXWDDMDISP_DEBUG_VEHANDLER
return TRUE;
VbglR3Term();
case DLL_PROCESS_DETACH:
#ifdef VBOXWDDMDISP_DEBUG_VEHANDLER
VbglR3Term();
return TRUE;
return TRUE;
return FALSE;
return hr;
pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
#ifdef DEBUG
Assert(0);
return S_OK;
case D3DDDICAPS_DDRAW:
#ifdef VBOX_WITH_VIDEOHWACCEL
#ifdef VBOX_WITH_VIDEOHWACCEL
case D3DDDICAPS_GETFORMATDATA:
Assert(0);
case D3DDDICAPS_GETD3D3CAPS:
case D3DDDICAPS_GETD3D7CAPS:
case D3DDDICAPS_GETD3D9CAPS:
case D3DDDICAPS_GETD3D8CAPS:
case D3DDDICAPS_GETD3D5CAPS:
case D3DDDICAPS_GETD3D6CAPS:
Assert(0);
Assert(0);
return S_OK;
static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
return hr;
return S_OK;
static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
#ifdef DEBUG_misha
Assert(0);
return S_OK;
static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
hr = pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
return hr;
if (pRc)
Assert(0);
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
return hr;
if (pRc)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
return hr;
static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
#ifdef DEBUG
((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
Assert(0);
#ifdef DEBUG
++cStreams;
return hr;
static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
#ifdef DEBUG
++cStreams;
return hr;
static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
int stream;
IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf;
RECT r;
r.top = 0;
vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/);
hr = pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
#ifdef DEBUG
int stream;
#ifdef DEBUG
++cStreams;
(void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
hr = pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
hr = pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
#ifdef DEBUG
return hr;
static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
#ifdef DEBUG
RECT tstRect = {0,0, pDstRc->aAllocations[0].SurfDesc.width, pDstRc->aAllocations[0].SurfDesc.height};
hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &DstRect, D3DTEXF_NONE); Assert(hr == S_OK),
return hr;
Assert(0);
return E_FAIL;
return S_OK;
static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
return hr;
static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
return hr;
static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
return hr;
return hr;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
return hr;
static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
switch (DevInfoID)
case D3DDDIDEVINFOID_VCACHE:
Assert(0);
return hr;
return E_INVALIDARG;
// Assert(pRc != pScreen->pRenderTargetRc || pScreen->iRenderTargetFrontBuf != pData->SubResourceIndex);
bool bNeedResynch = false;
Assert(0);
if (pRect)
Assert(0);
Assert(0);
bLocked = true;
if (pRange)
if (pRange)
r.top = 0;
pr = &r;
bLocked = true;
if (pRange)
if (pRange)
r.top = 0;
pr = &r;
Assert(0);
#ifdef DEBUG_misha
Assert(0);
offset = vboxWddmCalcOffXYrd(pData->Area.left, pData->Area.top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format);
Assert(0);
offset = 0;
return hr;
return E_INVALIDARG;
Assert(0);
// Assert(!pAlloc->LockInfo.cLocks);
r.top = 0;
pr = &r;
pr,
// Assert(!pAlloc->LockInfo.cLocks);
r.top = 0;
pr = &r;
pr,
Assert(0);
} UnlockData;
return hr;
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
/* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
if (pvBuf)
return pAlloc;
return NULL;
static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
if (!pRc)
return E_OUTOFMEMORY;
bool bIssueCreateResource = false;
bool bCreateSwapchain = false;
bool bCreateKMResource = false;
pAllocation->SurfDesc.cbSize = vboxWddmCalcSize(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.height, pAllocation->SurfDesc.format);
bIssueCreateResource = true;
bCreateKMResource = true;
for (UINT j = 0; j < i; ++j)
for (UINT j = 0; j < i; ++j)
for (UINT j = 0; j < i; ++j)
bIssueCreateResource = true;
#ifdef DEBUG
if (minPitch)
pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pSurf->SysMemPitch, pAllocation->SurfDesc.format);
if (pavClientMem)
#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
NULL,
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
if (!pavClientMem)
if (pavClientMem)
Assert(0);
if (pavClientMem)
#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
NULL,
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
if (pavClientMem)
bIssueCreateResource = true;
bCreateSwapchain = true;
#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
for (UINT j = 0; j < i; ++j)
Assert(0);
Assert(0);
bIssueCreateResource = true;
bCreateKMResource = true;
if (pDdiAllocate)
if (bCreateKMResource)
for (UINT j = 0; i < j; ++j)
#ifdef DEBUG_misha
if(bCreateSwapchain)
return hr;
if (cShRcRefs)
#ifdef DEBUG_misha
if (fSetDontDelete)
if (pSwapchain)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
return hr;
#ifdef VBOXWDDM_TEST_UHGSMI
#ifdef VBOXWDDM_TEST_UHGSMI
return hr;
return hr;
AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
bool bFreeVe = false;
if (pVe)
bFreeVe = true;
pVe,
if (bFreeVe)
return hr;
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
return hr;
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
if (pRc)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
Assert(0);
return E_FAIL;
Assert(!pDstSwapchain || vboxWddmSwapchainGetFb(pDstSwapchain)->pAlloc != pDstAlloc || vboxWddmSwapchainNumRTs(pDstSwapchain) == 1);
if (pSrcSwapchain)
Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001 | 0x00000002))) == 0);
VBOXVDBG_CHECK_BLT(hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &pData->DstRect, vboxDDI2D3DBltFlags(pData->Flags)); Assert(hr == S_OK),
Assert(0);
return hr;
return hr;
Assert(0);
return E_FAIL;
if (pQuery)
Assert(0);
return hr;
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
case D3DDDIQUERYTYPE_EVENT:
Assert(0);
return hr;
static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
if (pRc)
return hr;
static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
return hr;
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
return hr;
static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
return hr;
return hr;
static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
Assert(0);
return E_FAIL;
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
Assert(0);
return E_FAIL;
/* destroy the device first, since destroying PVBOXWDDMDISP_SWAPCHAIN would result in a device window termination */
#ifdef VBOX_WITH_CRHGSMI
vboxDispLock();
return hr;
if (pOverlay)
#ifndef VBOXWDDMOVERLAY_TEST
return hr;
static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
#ifndef VBOXWDDMOVERLAY_TEST
return hr;
#ifndef VBOXWDDMOVERLAY_TEST
return hr;
static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
#ifndef VBOXWDDMOVERLAY_TEST
return hr;
static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
return hr;
static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
return hr;
if (pRc)
if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
Assert(0);
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
NULL,
NULL);
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
Assert(0);
#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
NULL,
NULL);
#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
Assert(0);
vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
return hr;
static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
Assert(0);
return E_FAIL;
static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_DEVICE, apRTs[pAdapter->cMaxSimRTs]));
if (pDevice)
pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOXDISP_EARLYCREATEDEVICE
if (pRc)
// params.hDeviceWindow = hWnd;
# ifdef VBOXDISP_TEST_SWAPCHAIN
vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
return hr;
#ifdef VBOX_WITH_CRHGSMI
return S_OK;
#ifdef VBOX_WITH_VIDEOHWACCEL
PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
if (pAdapter)
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_VIDEOHWACCEL
return hr;