VBoxDispD3D.cpp revision a8c55533d05702bac64a11faba9cfc8ca5cf1129
/** @file
*
* VBoxVideo Display D3D User mode dll
*
* 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 <iprt/initterm.h>
#include <VBox/VBoxGuestLib.h>
#include "VBoxDispD3DCmn.h"
#include "VBoxDispD3D.h"
#ifdef VBOXDISPMP_TEST
#endif
#ifdef VBOXWDDMDISP_DEBUG
# include <stdio.h>
#endif
#define VBOXWDDMDISP_WITH_TMPWORKAROUND 1
#define VBOXWDDMOVERLAY_TEST
static FORMATOP gVBoxFormatOps3D[] = {
FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_SRGBWRITE|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
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},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
0|
0|
FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
0|
0|
0|
FORMATOP_NOTEXCOORDWRAPNORMIP, 0, 0, 0},
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
FORMATOP_OVERLAY, 0, 0, 0},
{D3DDDIFMT_BINARYBUFFER, FORMATOP_OFFSCREENPLAIN, 0, 0, 0},
0|
0|
FORMATOP_VERTEXTEXTURE, 0, 0, 0},
0|
FORMATOP_AUTOGENMIPMAP|FORMATOP_VERTEXTEXTURE, 0, 0, 0},
};
static FORMATOP gVBoxFormatOpsBase[] = {
{D3DDDIFMT_X8R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
{D3DDDIFMT_R8G8B8, FORMATOP_DISPLAYMODE, 0, 0, 0},
{D3DDDIFMT_R5G6B5, FORMATOP_DISPLAYMODE, 0, 0, 0},
{D3DDDIFMT_P8, FORMATOP_DISPLAYMODE, 0, 0, 0},
};
static DDSURFACEDESC gVBoxSurfDescsBase[] = {
{
sizeof (DDSURFACEDESC), /* DWORD dwSize; */
0, /* DWORD dwHeight; */
0, /* DWORD dwWidth; */
{
0, /* Union */
/* LONG lPitch; */
/* DWORD dwLinearSize; */
},
0, /* DWORD dwBackBufferCount; */
{
0, /* Union */
/* DWORD dwMipMapCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwRefreshRate; */
},
0, /* DWORD dwAlphaBitDepth; */
0, /* DWORD dwReserved; */
NULL, /* LPVOID lpSurface; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestBlt; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcBlt; */
{
sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
DDPF_RGB, /* DWORD dwFlags; */
0, /* DWORD dwFourCC; */
{
32, /* union */
/* DWORD dwRGBBitCount; */
/* DWORD dwYUVBitCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwAlphaBitDepth; */
/* DWORD dwLuminanceBitCount; */
/* DWORD dwBumpBitCount; */
},
{
0xff0000, /* union */
/* DWORD dwRBitMask; */
/* DWORD dwYBitMask; */
/* DWORD dwStencilBitDepth; */
/* DWORD dwLuminanceBitMask; */
/* DWORD dwBumpDuBitMask; */
},
{
0xff00,
/* DWORD dwGBitMask; */
/* DWORD dwUBitMask; */
/* DWORD dwZBitMask; */
/* DWORD dwBumpDvBitMask; */
},
{
0xff,
/* DWORD dwBBitMask; */
/* DWORD dwVBitMask; */
/* DWORD dwStencilBitMask; */
/* DWORD dwBumpLuminanceBitMask; */
},
{
0,
/* DWORD dwRGBAlphaBitMask; */
/* DWORD dwYUVAlphaBitMask; */
/* DWORD dwLuminanceAlphaBitMask; */
/* DWORD dwRGBZBitMask; */
/* DWORD dwYUVZBitMask; */
},
}, /* DDPIXELFORMAT ddpfPixelFormat; */
{
| DDSCAPS_VISIBLE /* DWORD dwCaps; */
} /* DDSCAPS ddsCaps; */
},
{
sizeof (DDSURFACEDESC), /* DWORD dwSize; */
0, /* DWORD dwHeight; */
0, /* DWORD dwWidth; */
{
0, /* Union */
/* LONG lPitch; */
/* DWORD dwLinearSize; */
},
0, /* DWORD dwBackBufferCount; */
{
0, /* Union */
/* DWORD dwMipMapCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwRefreshRate; */
},
0, /* DWORD dwAlphaBitDepth; */
0, /* DWORD dwReserved; */
NULL, /* LPVOID lpSurface; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestBlt; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcBlt; */
{
sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
DDPF_RGB, /* DWORD dwFlags; */
0, /* DWORD dwFourCC; */
{
24, /* union */
/* DWORD dwRGBBitCount; */
/* DWORD dwYUVBitCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwAlphaBitDepth; */
/* DWORD dwLuminanceBitCount; */
/* DWORD dwBumpBitCount; */
},
{
0xff0000, /* union */
/* DWORD dwRBitMask; */
/* DWORD dwYBitMask; */
/* DWORD dwStencilBitDepth; */
/* DWORD dwLuminanceBitMask; */
/* DWORD dwBumpDuBitMask; */
},
{
0xff00,
/* DWORD dwGBitMask; */
/* DWORD dwUBitMask; */
/* DWORD dwZBitMask; */
/* DWORD dwBumpDvBitMask; */
},
{
0xff,
/* DWORD dwBBitMask; */
/* DWORD dwVBitMask; */
/* DWORD dwStencilBitMask; */
/* DWORD dwBumpLuminanceBitMask; */
},
{
0,
/* DWORD dwRGBAlphaBitMask; */
/* DWORD dwYUVAlphaBitMask; */
/* DWORD dwLuminanceAlphaBitMask; */
/* DWORD dwRGBZBitMask; */
/* DWORD dwYUVZBitMask; */
},
}, /* DDPIXELFORMAT ddpfPixelFormat; */
{
| DDSCAPS_VISIBLE /* DWORD dwCaps; */
} /* DDSCAPS ddsCaps; */
},
{
sizeof (DDSURFACEDESC), /* DWORD dwSize; */
0, /* DWORD dwHeight; */
0, /* DWORD dwWidth; */
{
0, /* Union */
/* LONG lPitch; */
/* DWORD dwLinearSize; */
},
0, /* DWORD dwBackBufferCount; */
{
0, /* Union */
/* DWORD dwMipMapCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwRefreshRate; */
},
0, /* DWORD dwAlphaBitDepth; */
0, /* DWORD dwReserved; */
NULL, /* LPVOID lpSurface; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKDestBlt; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcOverlay; */
{
0, /* DWORD dwColorSpaceLowValue; */
0, /* DWORD dwColorSpaceHighValue; */
}, /* DDCOLORKEY ddckCKSrcBlt; */
{
sizeof (DDPIXELFORMAT), /* DWORD dwSize; */
DDPF_RGB, /* DWORD dwFlags; */
0, /* DWORD dwFourCC; */
{
16, /* union */
/* DWORD dwRGBBitCount; */
/* DWORD dwYUVBitCount; */
/* DWORD dwZBufferBitDepth; */
/* DWORD dwAlphaBitDepth; */
/* DWORD dwLuminanceBitCount; */
/* DWORD dwBumpBitCount; */
},
{
0xf800, /* union */
/* DWORD dwRBitMask; */
/* DWORD dwYBitMask; */
/* DWORD dwStencilBitDepth; */
/* DWORD dwLuminanceBitMask; */
/* DWORD dwBumpDuBitMask; */
},
{
0x7e0,
/* DWORD dwGBitMask; */
/* DWORD dwUBitMask; */
/* DWORD dwZBitMask; */
/* DWORD dwBumpDvBitMask; */
},
{
0x1f,
/* DWORD dwBBitMask; */
/* DWORD dwVBitMask; */
/* DWORD dwStencilBitMask; */
/* DWORD dwBumpLuminanceBitMask; */
},
{
0,
/* DWORD dwRGBAlphaBitMask; */
/* DWORD dwYUVAlphaBitMask; */
/* DWORD dwLuminanceAlphaBitMask; */
/* DWORD dwRGBZBitMask; */
/* DWORD dwYUVZBitMask; */
},
}, /* DDPIXELFORMAT ddpfPixelFormat; */
{
| DDSCAPS_VISIBLE /* DWORD dwCaps; */
} /* DDSCAPS ddsCaps; */
},
};
static D3DDDIQUERYTYPE gVBoxQueryTypes[] = {
};
#ifdef VBOX_WITH_VIDEOHWACCEL
{
{
return true;
}
return false;
}
{
{
)
return true;
}
return false;
}
{
}
#endif
{
}
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;
}
{
pAdapter->cFormstOps = 0;
pAdapter->cSurfDescs = 0;
{
{
if (pAdapter->paFormstOps)
{
}
else
return VERR_OUT_OF_RESOURCES;
/* @todo: do we need surface caps here ? */
}
}
#ifdef VBOX_WITH_VIDEOHWACCEL
else
{
/* just calc the max number of formats */
uint32_t cOverlayFormats = 0;
{
{
}
}
/* ensure the surf descs are 8 byte alligned */
if (pvBuf)
{
{
{
{
}
}
}
{
{
{
if (fourcc)
{
}
}
}
}
}
else
return VERR_OUT_OF_RESOURCES;
}
#endif
return VINF_SUCCESS;
}
{
if (pAdapter->paFormstOps)
}
{
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)
else
}
else
{
if (bToLockInfo)
{
}
else
{
}
{
}
}
}
else
{
/* @todo: this is not entirely correct */
if (bToLockInfo)
{
}
else
{
}
{
}
else
{
{
}
}
}
}
#if 0
{
/* we do not support stretching */
if (DstCopyWidth != SrcCopyWidth)
return E_FAIL;
if (DstCopyHeight != SrcCopyWidth)
return E_FAIL;
if (DstWidth == DstCopyWidth
&& SrcWidth == SrcCopyWidth
{
}
else
{
uint32_t offDstLineEnd = ((pDstCopyRect->left * dstBpp + 7) >> 3) + ((dstBpp * DstCopyWidth + 7) >> 3);
uint32_t offSrcLineEnd = ((pSrcCopyRect->left * srcBpp + 7) >> 3) + ((srcBpp * SrcCopyWidth + 7) >> 3);
for (uint32_t i = 0; ; ++i)
{
if (i == DstCopyHeight)
break;
pvDstStart += cbDstSkip;
pvSrcStart += cbSrcSkip;
}
}
return S_OK;
}
#endif
{
/* we do not support stretching */
return E_FAIL;
return E_FAIL;
{
}
else
{
for (uint32_t i = 0; ; ++i)
{
if (i == DstHeight)
break;
}
}
return S_OK;
}
static HRESULT vboxWddmRenderTargetUpdateSurface(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t iBBuf)
{
{
}
return hr;
}
static HRESULT vboxWddmRenderTargetUpdate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, uint32_t iNewRTFB)
{
{
}
{
}
HRESULT tmpHr = vboxWddmRenderTargetUpdateSurface(pDevice, pAlloc, ~0UL /* <- for the frontbuffer */);
return S_OK;
}
{
/* @todo: check they are all equal */
}
{
/* @todo: check they are all equal */
return (D3DMULTISAMPLE_TYPE)enmType;
}
{
/* @todo: check they are all equal */
switch (enmPool)
{
case D3DDDIPOOL_SYSTEMMEM:
return D3DPOOL_SYSTEMMEM;
case D3DDDIPOOL_VIDEOMEMORY:
case D3DDDIPOOL_LOCALVIDMEM:
/* @todo: what would be propper here? */
return D3DPOOL_DEFAULT;
default:
}
return D3DPOOL_DEFAULT;
}
{
/* @todo: @fixme: not entirely correct, need to check */
return (D3DRENDERSTATETYPE)enmType;
}
{
static const VBOXWDDMDISP_TSS_LOOKUP lookup[] =
{
};
}
{
if (fFlags.AutogenMipmap)
fUsage |= D3DUSAGE_DMAP;
if (fFlags.RenderTarget)
//below are wddm 1.1-specific
// if (fFlags.RestrictedContent)
// fUsage |= D3DUSAGE_RESTRICTED_CONTENT;
// if (fFlags.RestrictSharedAccess)
// fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
return fUsage;
}
{
if (fLockFlags.Discard)
if (fLockFlags.NoOverwrite)
if (fLockFlags.ReadOnly)
if (fLockFlags.DoNotWait)
return fFlags;
}
{
{
/* no flags other than [Begin|Continue|End]PresentToDwm are set */
return D3DTEXF_POINT;
}
{
/* no flags other than [Begin|Continue|End]PresentToDwm are set */
return D3DTEXF_LINEAR;
}
/* no flags other than [Begin|Continue|End]PresentToDwm are set */
return D3DTEXF_NONE;
}
{
}
/**
* DLL entry point.
*/
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{
RTR3Init();
#ifdef VBOXDISPMP_TEST
{
hr = vboxDispMpTstStart();
}
#endif
vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
else
// VbglR3Init();
break;
}
case DLL_PROCESS_DETACH:
{
#ifdef VBOXDISPMP_TEST
hr = vboxDispMpTstStop();
#endif
{
hr = vboxDispCmTerm();
vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
else
}
// VbglR3Term();
/// @todo RTR3Term();
break;
}
default:
break;
}
return bOk;
}
{
{
case D3DDDICAPS_DDRAW:
{
{
#ifdef VBOX_WITH_VIDEOHWACCEL
if (vboxVhwaHasCKeying(pAdapter))
{
// pCaps->Caps2 |= DDRAW_CAPS2_FLIPNOVSYNC;
}
#endif
}
else
hr = E_INVALIDARG;
break;
}
{
{
zero starting with the one following "Head", i.e. Caps */,
#ifdef VBOX_WITH_VIDEOHWACCEL
{
{
| MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
;
}
{
| MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
| MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
| MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
;
}
}
#endif
}
else
hr = E_INVALIDARG;
break;
}
break;
case D3DDDICAPS_GETFORMATDATA:
break;
#if 0
#else
#endif
break;
#if 0
#else
#endif
break;
case D3DDDICAPS_GETD3D3CAPS:
{
// | D3DDEVCAPS_DRAWPRIMTLVERTEX
// | D3DDEVCAPS_FLOATTLVERTEX
// | D3DDEVCAPS_HWTRANSFORMANDLIGHT
// | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
// | D3DDEVCAPS_TEXTUREVIDEOMEMORY
;
pCaps->dwNumVertices = 0;
pCaps->dwNumClipVertices = 0;
}
else
hr = E_INVALIDARG;
break;
case D3DDDICAPS_GETD3D7CAPS:
{
}
else
hr = E_INVALIDARG;
break;
case D3DDDICAPS_GETD3D9CAPS:
{
// AssertBreakpoint();
{
if (VBOXDISPMODE_IS_3D(pAdapter))
{
{
/*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER | D3DDEVCAPS_SUBVOLUMELOCK */;
pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
#if 1 /* workaround for wine not returning InstructionSlots correctly for shaders v3.0 */
{
}
#endif
#ifdef DEBUG
{
}
{
}
else
{
}
#endif
break;
}
/* let's fall back to the 3D disabled case */
}
}
else
hr = E_INVALIDARG;
break;
}
break;
break;
case D3DDDICAPS_GETD3D5CAPS:
case D3DDDICAPS_GETD3D6CAPS:
case D3DDDICAPS_GETD3D8CAPS:
break;
default:
}
return S_OK;
}
static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
{
HRESULT hr = pDevice->pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
return hr;
}
{
return S_OK;
}
static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
{
if (!lookup.bSamplerState)
{
hr = pDevice->pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
}
else
{
hr = pDevice->pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
}
return hr;
}
{
// Assert(pRc);
if (pRc)
{
}
else
// Assert(pD3DIfTex);
return hr;
}
{
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
{
HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
{
// IDirect3DVertexBuffer9 *pStreamData;
// UINT cbOffset;
// UINT cbStride;
// hr = pDevice->pDevice9If->GetStreamSource(pData->Stream, &pStreamData, &cbOffset, &cbStride);
// Assert(hr == S_OK);
// if (hr == S_OK)
// {
// if (pStreamData)
// {
// AssertBreakpoint();
// /* @todo: impl! */
// }
// else
// {
// }
// }
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)
{
if (!pDevice->cStreamSources)
{
{
#ifdef DEBUG
{
}
#endif
((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
}
else
{
/* todo: impl */
}
}
else
{
#if 0
{
{
{
{
{
{
{
}
}
/* vertex size is MAX(all Offset's) + sizeof (data_type with MAX offset) + stride*/
switch (pLastCDecl9->Type)
{
case D3DDECLTYPE_FLOAT1:
cbType = sizeof (float);
break;
case D3DDECLTYPE_FLOAT2:
cbType = sizeof (float) * 2;
break;
case D3DDECLTYPE_FLOAT3:
cbType = sizeof (float) * 3;
break;
case D3DDECLTYPE_FLOAT4:
cbType = sizeof (float) * 4;
break;
case D3DDECLTYPE_D3DCOLOR:
cbType = 4;
break;
case D3DDECLTYPE_UBYTE4:
cbType = 4;
break;
case D3DDECLTYPE_SHORT2:
cbType = sizeof (short) * 2;
break;
case D3DDECLTYPE_SHORT4:
cbType = sizeof (short) * 4;
break;
case D3DDECLTYPE_UBYTE4N:
cbType = 4;
break;
case D3DDECLTYPE_SHORT2N:
cbType = sizeof (short) * 2;
break;
case D3DDECLTYPE_SHORT4N:
cbType = sizeof (short) * 4;
break;
case D3DDECLTYPE_USHORT2N:
cbType = sizeof (short) * 2;
break;
case D3DDECLTYPE_USHORT4N:
cbType = sizeof (short) * 4;
break;
case D3DDECLTYPE_UDEC3:
cbType = sizeof (signed) * 3;
break;
case D3DDECLTYPE_DEC3N:
cbType = sizeof (unsigned) * 3;
break;
case D3DDECLTYPE_FLOAT16_2:
break;
case D3DDECLTYPE_FLOAT16_4:
break;
default:
cbType = 1;
}
switch (pData->PrimitiveType)
{
case D3DPT_POINTLIST:
break;
case D3DPT_LINELIST:
break;
case D3DPT_LINESTRIP:
break;
case D3DPT_TRIANGLELIST:
break;
case D3DPT_TRIANGLESTRIP:
break;
case D3DPT_TRIANGLEFAN:
break;
default:
}
{
if (pCurVb)
{
{
/* ensure our data feets in the buffer */
{
}
}
}
}
else
{
}
if (!pVb)
{
0, /* DWORD Usage */
0, /* DWORD FVF */
D3DPOOL_DEFAULT, /* D3DPOOL Pool */
&pVb,
NULL /*HANDLE* pSharedHandle*/);
{
{
if (pCurVb)
}
else
{
}
}
}
if (pVb)
{
&pvData,
{
}
}
}
}
}
}
{
0 /* <- since we use our owne StreamSource buffer which has data at the very beginning*/,
}
}
#endif
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
{
return hr;
}
static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
{
#if 0
int stream;
{
{
{
IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf;
RECT r;
r.top = 0;
r.bottom = 1;
vboxWddmLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/);
}
}
}
hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
#else
int stream;
{
{
{
(void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
hr = pDevice->pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
}
else
{
hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
}
}
}
#endif
return hr;
}
static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
{
return E_FAIL;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
{
/* first check if we can do IDirect3DDevice9::UpdateTexture */
{
}
else
{
/* @todo: impl */
}
}
else
{
/* @todo: impl */
}
return hr;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
{
pData->FillStencil);
return hr;
}
static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
{
(CONST float*)pRegisters,
return hr;
}
static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
{
return hr;
}
{
return hr;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
{
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)
{
return E_NOTIMPL;
}
{
return E_INVALIDARG;
{
{
bool bNeedResynch = false;
{
}
/* else - we lock the entire texture, pRect == NULL */
// Assert(!pLockAlloc->LockInfo.cLocks);
{
{
// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
if (pRect)
{
// pLockAlloc->LockInfo.fFlags.AreaValid = 1;
}
else
{
// pLockAlloc->LockInfo.fFlags.AreaValid = 0;
}
}
}
else
{
// Assert(pLockAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
// if (pLockAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
// {
// }
{
}
if (/*(pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard)
|| */
{
{
}
}
}
{
{
pData->SlicePitch = 0;
}
else
{
if (bNeedResynch)
vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect, pRect, false /*bool bToLockInfo*/);
}
}
}
{
{
}
/* else - we lock the entire vertex buffer, pRect == NULL */
{
{
bLocked = true;
}
{
// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
if (pRange)
{
// pAlloc->LockInfo.fFlags.RangeValid = 1;
}
else
{
// pAlloc->LockInfo.fFlags.RangeValid = 0;
}
}
}
else
{
// Assert(pAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
// if (pAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
// {
// }
{
}
}
{
{
pData->SlicePitch = 0;
}
else
{
{
if (pRange)
{
r.top = 0;
r.bottom = 1;
pr = &r;
}
else
}
}
}
}
{
{
}
/* else - we lock the entire vertex buffer, pRect == NULL */
{
{
bLocked = true;
}
{
// Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
if (pRange)
{
// pAlloc->LockInfo.fFlags.RangeValid = 1;
}
else
{
// pAlloc->LockInfo.fFlags.RangeValid = 0;
}
}
}
else
{
// Assert(pAlloc->LockInfo.fFlags.Value == pData->Flags.Value);
// if (pAlloc->LockInfo.fFlags.Value != pData->Flags.Value)
// {
// }
{
}
}
{
{
pData->SlicePitch = 0;
}
else
{
{
if (pRange)
{
r.top = 0;
r.bottom = 1;
pr = &r;
}
else
}
}
}
}
else
{
}
}
else
{
{
{
}
{
}
{
}
else
{
offset = 0;
}
{
else
{
}
}
{
/* check if the surface was renamed */
if (LockData.hAllocation)
}
}
}
return hr;
}
{
return E_INVALIDARG;
{
{
// pLockAlloc->LockInfo.cLocks = 0;
{
// Assert(!pLockAlloc->LockInfo.cLocks);
/* this is a sysmem texture, update */
{
true /*bool bToLockInfo*/);
}
}
else
{
}
}
{
{
// Assert(!pAlloc->LockInfo.cLocks);
/* this is a sysmem texture, update */
{
{
r.top = 0;
r.bottom = 1;
pr = &r;
}
else
pr,
true /*bool bToLockInfo*/);
}
}
else
{
}
}
{
{
// Assert(!pAlloc->LockInfo.cLocks);
/* this is a sysmem texture, update */
{
{
r.top = 0;
r.bottom = 1;
pr = &r;
}
else
pr,
true /*bool bToLockInfo*/);
}
}
else
{
}
}
else
{
}
}
else
{
struct
{
} UnlockData;
{
}
}
return hr;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
}
{
/* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
if (pvBuf)
{
{
}
return pAlloc;
}
return NULL;
}
static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_ALLOCATION pAllocation)
{
{
{
}
}
else
{
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
{
if (pRc)
{
bool bIssueCreateResource = false;
{
}
if (VBOXDISPMODE_IS_3D(pAdapter))
{
{
AssertBreakpoint(); /* <-- need to test that */
bIssueCreateResource = true;
}
{
{
TRUE /* @todo: BOOL Discard */,
NULL /*HANDLE* pSharedHandle*/);
{
}
else
{
for (UINT j = 0; j < i; ++j)
{
}
break;
}
}
}
{
{
NULL /*HANDLE* pSharedHandle*/);
{
{
{
}
}
else
{
}
}
else
{
for (UINT j = 0; j < i; ++j)
{
}
break;
}
}
}
{
{
NULL /*HANDLE* pSharedHandle*/
);
{
{
{
}
}
else
{
}
}
else
{
for (UINT j = 0; j < i; ++j)
{
}
break;
}
}
}
{
#ifdef DEBUG
{
{
tstW /= 2;
tstH /= 2;
}
}
#endif
bIssueCreateResource = true;
NULL /* HANDLE* pSharedHandle */
);
{
{
{
{
}
else
{
break;
}
}
}
}
#ifdef DEBUG
else
{
{
}
}
#endif
}
{
bIssueCreateResource = true;
if (!pDevice->pDevice9If)
{
hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
{
/* @todo: it seems there should be a way to detect this correctly since
* our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
// params.EnableAutoDepthStencil = FALSE;
// params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
// params.Flags;
// params.FullScreen_RefreshRateInHz;
// params.FullScreen_PresentationInterval;
hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, ¶ms, &pDevice9If);
{
{
}
{
{
{
break;
}
}
{
{
}
}
}
pDevice9If->Release();
}
{
}
}
}
else
{
{
NULL /* HANDLE* pSharedHandle */
);
{
continue;
/* fail branch */
}
for (UINT j = 0; j < i; ++j)
{
}
break;
}
}
}
else
{
Assert(0);
}
}
else
bIssueCreateResource = true;
{
if (pDdiAllocate)
{
{
{
}
else
if (pSurf->SysMemPitch)
{
#ifdef DEBUG
#endif
}
else
}
{
{
}
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
{
if (VBOXDISPMODE_IS_3D(pAdapter))
{
{
}
{
}
}
if (pRc->hKMResource)
{
{
/* according to the docs the below two are ignored in case we set the hResource */
Dealloc.NumAllocations = 0;
// for (UINT j = 0; j < pRc->cAllocations; ++j)
// {
// D3DDDICB_DEALLOCATE Dealloc;
// Dealloc.hResource = NULL;
// Dealloc.NumAllocations = 1;
// Dealloc.HandleList = &pRc->aAllocations[j].hAllocation;
// HRESULT tmpHr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
// Assert(tmpHr = S_OK);
// }
}
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
{
D3DDDICB_SETDISPLAYMODE DdiDm = {0};
// DdiDm.PrivateDriverFormatAttribute = 0;
#if 0
#endif
{
}
return hr;
}
{
{
#if 1
NULL, /* CONST RECT * pDestRect */
NULL, /* HWND hDestWindowOverride */
NULL /*CONST RGNDATA * pDirtyRegion */
);
#endif
}
#if 0
else
#endif
{
{
iNewRTFB = 0;
/* assign a new frontbuffer index */
}
D3DDDICB_PRESENT DdiPresent = {0};
if (pData->hSrcResource)
{
}
if (pData->hDstResource)
{
}
// DdiPresent.BroadcastContextCount;
// DdiPresent.BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT];
}
return hr;
}
{
{
#if 0
NULL, /* CONST RECT * pDestRect */
NULL, /* HWND hDestWindowOverride */
NULL /*CONST RGNDATA * pDirtyRegion */
);
#endif
}
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)
{
);
{
}
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)
{
HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
{
HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
return hr;
}
{
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
{
if (pRc)
{
}
HRESULT hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
{
{
}
{
}
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
{
return E_FAIL;
}
{
{
{
break;
}
{
break;
}
default:
break;
}
return hr;
}
{
{
{
break;
}
{
break;
}
default:
break;
}
return hr;
}
/* on success increments the surface ref counter,
* i.e. one must call pSurf->Release() once the surface is not needed*/
{
{
{
pD3DIfSurf->AddRef();
*ppSurf = pD3DIfSurf;
break;
}
{
{
*ppSurf = pSurfaceLevel;
}
break;
}
default:
break;
}
return hr;
}
{
/* try StretchRect */
{
{
/* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001 | 0x00000002))) == 0);
pDstSurfIf->Release();
}
pSrcSurfIf->Release();
}
{
/* todo: fallback to memcpy or whatever ? */
}
#if 0
if ((use pAlloc->enmD3DIfType instead!!! pDstRc->RcDesc.fFlags.Texture || pDstRc->RcDesc.fFlags.Value == 0)
{
{
)
{
}
{
hr = pD3DIfDstTex->LockRect(pData->DstSubResourceIndex, &DstRect, &pData->DstRect, D3DLOCK_DISCARD);
{
hr = pD3DIfSrcTex->LockRect(pData->SrcSubResourceIndex, &SrcRect, &pData->SrcRect, D3DLOCK_READONLY);
{
}
}
}
else
{
/* @todo: impl */
}
}
else
{
/* @todo: impl */
}
}
else
{
{
{
{
}
}
}
else
{
/* @todo: impl */
}
}
#endif
return hr;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
{
{
/* work-around wine double-buffering for the case we have no backbuffers */
}
else
{
}
{
}
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)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
{
HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
return hr;
}
static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
{
HRESULT hr = pDevice->pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
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)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
{
return E_FAIL;
}
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
{
return E_FAIL;
}
{
if (pDevice->pDevice9If)
{
}
return hr;
}
{
if (pOverlay)
{
#ifndef VBOXWDDMOVERLAY_TEST
{
{
/* we have reported the dirty rect, may clear it if no locks are pending currently */
}
}
else
{
}
#else
#endif
}
else
hr = E_OUTOFMEMORY;
return hr;
}
static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
{
#ifndef VBOXWDDMOVERLAY_TEST
#endif
{
{
/* we have reported the dirty rect, may clear it if no locks are pending currently */
}
}
return hr;
}
{
#ifndef VBOXWDDMOVERLAY_TEST
#endif
{
{
/* we have reported the dirty rect, may clear it if no locks are pending currently */
}
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
{
#ifndef VBOXWDDMOVERLAY_TEST
#else
#endif
{
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
{
#if 0
{
if (pRc->hKMResource)
{
}
}
#endif
return hr;
}
static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
{
{
}
else
{
vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
hr = E_INVALIDARG;
}
return hr;
}
{
if (pRc)
{
{
/* this is a "standard" allocation resource */
/* both should be actually zero */
if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
{
switch(pAllocInfo->enmType)
{
break;
default:
hr = E_INVALIDARG;
}
}
else
hr = E_INVALIDARG;
}
else
{
AssertBreakpoint(); /* <-- need to test that */
/* this is a "generic" resource whose creation is initiaded by the UMD */
{
}
else
hr = E_INVALIDARG;
}
{
{
break;
}
}
else
}
else
{
vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
hr = E_OUTOFMEMORY;
}
return hr;
}
static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
{
return E_FAIL;
}
static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
{
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));
// AssertBreakpoint();
if (pDevice)
{
/* Set Viewport to some default values */
pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
do
{
&& !pCreateData->PatchLocationListSize);
{
break;
}
else
{
vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
//pCreateData->pAllocationList = ??
}
} while (0);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
{
// AssertBreakpoint();
if (VBOXDISPMODE_IS_3D(pAdapter))
{
}
return S_OK;
}
{
{
return E_FAIL;
}
/* check the miniport version match display version */
{
Query.u32Version));
return E_FAIL;
}
#ifdef VBOX_WITH_VIDEOHWACCEL
PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
#else
#endif
if (pAdapter)
{
/*
* here we detect whether we are called by the d3d or ddraw.
* in the d3d case we init our d3d environment
* in the ddraw case we init 2D acceleration
* if interface version is > 7, this is D3D, treat it as so
* otherwise treat it as ddraw
* @todo: need a more clean way of doing this */
{
do
{
/* try enable the 3D */
{
{
{
break;
}
}
else
}
else
} while (0);
}
#ifdef VBOX_WITH_VIDEOHWACCEL
else
{
{
}
}
#endif
// RTMemFree(pAdapter);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
#ifdef VBOXWDDMDISP_DEBUG
{
char szBuffer[1024] = {0};
}
#endif