Index: /trunk/include/VBox/VBoxVideo.h =================================================================== --- /trunk/include/VBox/VBoxVideo.h (revision 26629) +++ /trunk/include/VBox/VBoxVideo.h (revision 26630) @@ -1060,11 +1060,59 @@ } VBOXVDMA_RECTL, *PVBOXVDMA_RECTL; +typedef enum +{ + VBOXVDMA_PIXEL_FORMAT_UNKNOWN = 0, + VBOXVDMA_PIXEL_FORMAT_R8G8B8 = 20, + VBOXVDMA_PIXEL_FORMAT_A8R8G8B8 = 21, + VBOXVDMA_PIXEL_FORMAT_X8R8G8B8 = 22, + VBOXVDMA_PIXEL_FORMAT_R5G6B5 = 23, + VBOXVDMA_PIXEL_FORMAT_X1R5G5B5 = 24, + VBOXVDMA_PIXEL_FORMAT_A1R5G5B5 = 25, + VBOXVDMA_PIXEL_FORMAT_A4R4G4B4 = 26, + VBOXVDMA_PIXEL_FORMAT_R3G3B2 = 27, + VBOXVDMA_PIXEL_FORMAT_A8 = 28, + VBOXVDMA_PIXEL_FORMAT_A8R3G3B2 = 29, + VBOXVDMA_PIXEL_FORMAT_X4R4G4B4 = 30, + VBOXVDMA_PIXEL_FORMAT_A2B10G10R10 = 31, + VBOXVDMA_PIXEL_FORMAT_A8B8G8R8 = 32, + VBOXVDMA_PIXEL_FORMAT_X8B8G8R8 = 33, + VBOXVDMA_PIXEL_FORMAT_G16R16 = 34, + VBOXVDMA_PIXEL_FORMAT_A2R10G10B10 = 35, + VBOXVDMA_PIXEL_FORMAT_A16B16G16R16 = 36, + VBOXVDMA_PIXEL_FORMAT_A8P8 = 40, + VBOXVDMA_PIXEL_FORMAT_P8 = 41, + VBOXVDMA_PIXEL_FORMAT_L8 = 50, + VBOXVDMA_PIXEL_FORMAT_A8L8 = 51, + VBOXVDMA_PIXEL_FORMAT_A4L4 = 52, + VBOXVDMA_PIXEL_FORMAT_V8U8 = 60, + VBOXVDMA_PIXEL_FORMAT_L6V5U5 = 61, + VBOXVDMA_PIXEL_FORMAT_X8L8V8U8 = 62, + VBOXVDMA_PIXEL_FORMAT_Q8W8V8U8 = 63, + VBOXVDMA_PIXEL_FORMAT_V16U16 = 64, + VBOXVDMA_PIXEL_FORMAT_W11V11U10 = 65, + VBOXVDMA_PIXEL_FORMAT_A2W10V10U10 = 67 +} VBOXVDMA_PIXEL_FORMAT; + +typedef struct VBOXVDMA_SURF_DESC +{ + uint32_t width; + uint32_t height; + VBOXVDMA_PIXEL_FORMAT format; + uint32_t bpp; + uint32_t pitch; + uint32_t fFlags; +} VBOXVDMA_SURF_DESC, *PVBOXVDMA_SURF_DESC; + //typedef uint64_t VBOXVDMAPHADDRESS; typedef uint64_t VBOXVDMASURFHANDLE; +typedef uint32_t VBOXVIDEOOFFSET; + +#define VBOXVIDEOOFFSET_VOID ((VBOXVIDEOOFFSET)~0) + typedef enum { VBOXVDMACMD_TYPE_UNDEFINED = 0, - VBOXVDMACMD_TYPE_DMATRANSFER = 1 + VBOXVDMACMD_TYPE_DMA_PRESENT_BLT = 1 } VBOXVDMACMD_TYPE; @@ -1076,33 +1124,4 @@ #define VBOXVDMAOPERAND_FLAGS_VRAMOFFSET 0x4 -typedef struct VBOXVDMA_RANGE_RECTL -{ - VBOXVDMA_RECTL RangeRectl; - VBOXVDMA_RECTL SurfSize; -}VBOXVDMA_RANGE_RECTL, *PVBOXVDMA_RANGE_RECTL; - -typedef struct VBOXVDMA_RANGE_SIZE -{ - uint32_t cbSize; - uint32_t u32Reserved; -}VBOXVDMA_RANGE_SIZE, *PVBOXVDMA_RANGE_SIZE; - -typedef struct VBOXVDMAOPERAND -{ - uint32_t fFlags; - union - { - /* for Src specifies num of Dsts */ - uint32_t cDsts; - /* for Dst specifies Screen ID in case VBOXVDMAOPERAND_FLAGS_PRIMARY flag is present in fFlags */ - uint32_t iScreen; - } Info; - RTGCPHYS phAddress; - union - { - VBOXVDMA_RANGE_RECTL Rectl; - VBOXVDMA_RANGE_SIZE Size; - } Range; -} VBOXVDMAOPERAND, *PVBOXVDMAOPERAND; /* VBOXVDMACBUF_DR::phBuf specifies offset in VRAM */ @@ -1137,18 +1156,26 @@ { VBOXVDMACMD_TYPE enmType; - uint32_t cbCmd; + uint32_t u32CmdSpecific; } VBOXVDMACMD, *PVBOXVDMACMD; #define VBOXVDMACMD_HEADER_SIZE() sizeof (VBOXVDMACMD) -#define VBOXVDMACMD_BODY_SIZE(_pCmd) ((_pCmd)->cbBody) -#define VBOXVDMACMD_SIZE(_pCmd) (VBOXVDMACMD_HEADER_SIZE() + VBOXVDMACMD_BODY_SIZE(_pCmd)) -#define VBOXVDMACMD_BODY(_pCmd, _t) ( (_t)(((uint8_t*)(_pCmd)) + VBOXVDMACMD_HEADER_SIZE()) ) - -typedef struct VBOXVDMACMD_DMATRANSFER -{ - VBOXVDMAOPERAND Src; - /* the size of aDst is specified in Src::u32CmdSpecific*/ - VBOXVDMAOPERAND aDst[1]; -} VBOXVDMACMD_DMATRANSFER, *PVBOXVDMACMD_DMATRANSFER; +#define VBOXVDMACMD_SIZE_FROMBODYSIZE(_s) (VBOXVDMACMD_HEADER_SIZE() + (_s)) +#define VBOXVDMACMD_SIZE(_t) (VBOXVDMACMD_SIZE_FROMBODYSIZE(sizeof (_t))) +#define VBOXVDMACMD_BODY(_pCmd, _t) ( (_t*)(((uint8_t*)(_pCmd)) + VBOXVDMACMD_HEADER_SIZE()) ) +#define VBOXVDMACMD_BODY_FIELD_OFFSET(_ot, _t, _f) ( (_ot)( VBOXVDMACMD_BODY(0, uint8_t) + RT_OFFSETOF(_t, _f) ) ) + +typedef struct VBOXVDMACMD_DMA_PRESENT_BLT +{ + VBOXVIDEOOFFSET offSrc; + VBOXVIDEOOFFSET offDst; + VBOXVDMA_SURF_DESC srcDesc; + VBOXVDMA_SURF_DESC dstDesc; + VBOXVDMA_RECTL srcRectl; + VBOXVDMA_RECTL dstRectl; + uint32_t u32Reserved; + uint32_t cDstSubRects; + VBOXVDMA_RECTL aDstSubRects[1]; +} VBOXVDMACMD_DMA_PRESENT_BLT, *PVBOXVDMACMD_DMA_PRESENT_BLT; + # pragma pack() #endif /* #ifdef VBOXVDMA */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp (revision 26629) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp (revision 26630) @@ -760,5 +760,5 @@ if (DeviceExtension->CurrentMode == 0) #else - if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].ulFrameBufferSize) + if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pAllocation) #endif { @@ -790,12 +790,12 @@ } #else - if (DeviceExtension->cSources && DeviceExtension->aSources[0].ulFrameBufferSize) + if (DeviceExtension->cSources && DeviceExtension->aSources[0].pAllocation) { if (!xres) - xres = DeviceExtension->aSources[0].VisScreenWidth; + xres = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.width; if (!yres) - yres = DeviceExtension->aSources[0].VisScreenHeight; + yres = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.height; if (!bpp) - bpp = DeviceExtension->aSources[0].BitsPerPlane; + bpp = DeviceExtension->aSources[0].pAllocation->u.SurfInfo.bpp; } #endif @@ -824,5 +824,5 @@ if (DeviceExtension->CurrentMode != 0) #else - if (DeviceExtension->cSources && DeviceExtension->aSources[0].ulFrameBufferSize) + if (DeviceExtension->cSources && DeviceExtension->aSources[0].pAllocation) #endif { @@ -904,5 +904,5 @@ if (DeviceExtension->CurrentMode == 0) #else - if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].ulFrameBufferSize) + if (!DeviceExtension->cSources || !DeviceExtension->aSources[0].pAllocation) #endif { @@ -2498,14 +2498,4 @@ return TRUE; } -#else - Assert(!srcId); - - if (srcId) - { - dprintf(("VBoxVideo::VBoxVideoSetCurrentMode: Skipping for ? non-primary ? source ? %d\n", - srcId)); - return TRUE; - } -#endif /* set the mode characteristics */ @@ -2527,4 +2517,34 @@ */ // VBoxVideoSetGraphicsCap(TRUE); +#else + Assert(!srcId); + + if (srcId) + { + dprintf(("VBoxVideo::VBoxVideoSetCurrentMode: Skipping for ? non-primary ? source ? %d\n", + srcId)); + return TRUE; + } + + /* set the mode characteristics */ + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_XRES); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, (USHORT)ModeInfo->pAllocation->u.SurfInfo.width); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_YRES); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, (USHORT)ModeInfo->pAllocation->u.SurfInfo.height); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_BPP); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, (USHORT)ModeInfo->pAllocation->u.SurfInfo.bpp); + /* enable the mode */ + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ENABLE); + VBoxVideoCmnPortWriteUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED); + /** @todo read from the port to see if the mode switch was successful */ + + /* Tell the host that we now support graphics in the additions. + * @todo: Keep old behaviour, because VBoxVideoResetDevice is called on every graphics + * mode switch and causes an OFF/ON sequence which is not handled by frontends + * (for example Qt GUI debug build asserts when seamless is being enabled). + */ + // VBoxVideoSetGraphicsCap(TRUE); + +#endif return TRUE; } Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h (revision 26629) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h (revision 26630) @@ -119,4 +119,5 @@ #include "wddm/VBoxVideoShgsmi.h" #include "wddm/VBoxVideoVdma.h" +#include "wddm/VBoxVideoWddm.h" typedef KSPIN_LOCK VBOXVCMNSPIN_LOCK, *PVBOXVCMNSPIN_LOCK; @@ -129,86 +130,7 @@ typedef struct VBOXWDDM_SOURCE { - ULONG VisScreenWidth; - ULONG VisScreenHeight; - ULONG BitsPerPlane; - - ULONG ulFrameBufferOffset; /* The framebuffer position in the VRAM. */ - ULONG ulFrameBufferSize; /* The size of the current framebuffer. */ + struct VBOXWDDM_ALLOCATION * pAllocation; } VBOXWDDM_SOURCE, *PVBOXWDDM_SOURCE; -typedef enum -{ - VBOXWDDM_ALLOC_UNEFINED = 0, - VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE, - VBOXWDDM_ALLOC_STD_SHADOWSURFACE, - VBOXWDDM_ALLOC_STD_STAGINGSURFACE, - /* this one is win 7-specific and hence unused for now */ - VBOXWDDM_ALLOC_STD_GDISURFACE - /* custom allocation types requested from user-mode d3d module will go here */ -} VBOXWDDM_ALLOC_TYPE; - -typedef struct VBOXWDDM_ALLOCINFO -{ - VBOXWDDM_ALLOC_TYPE enmType; - char Body[1]; -} VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO; - -#define VBOXWDDM_ALLOCINFO_HEADSIZE() (RT_OFFSETOF(VBOXWDDM_ALLOCINFO, Body)) -#define VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCINFO_HEADSIZE() + (_s)) -#define VBOXWDDM_ALLOCINFO_SIZE(_tCmd) (VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(sizeof(_tCmd))) -#define VBOXWDDM_ALLOCINFO_BODY(_p, _t) ((_t*)(_p)->Body) -#define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - RT_OFFSETOF(VBOXWDDM_ALLOCINFO, Body))) - -typedef struct VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE -{ - D3DKMDT_SHAREDPRIMARYSURFACEDATA SurfData; -} VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE; - -typedef struct VBOXWDDM_ALLOCINFO_SHADOWSURFACE -{ - D3DKMDT_SHADOWSURFACEDATA SurfData; -} VBOXWDDM_ALLOCINFO_SHADOWSURFACE, *PVBOXWDDM_ALLOCINFO_SHADOWSURFACE; - -typedef struct VBOXWDDM_ALLOCINFO_STAGINGSURFACE -{ - D3DKMDT_STAGINGSURFACEDATA SurfData; -} VBOXWDDM_ALLOCINFO_STAGINGSURFACE, *PVBOXWDDM_ALLOCINFO_STAGINGSURFACE; - -/* allocation */ -typedef struct VBOXWDDM_ALLOCATION -{ - VBOXWDDM_ALLOC_TYPE enmType; - char Body[1]; -} VBOXWDDM_ALLOCATION, *PVBOXWDDM_ALLOCATION; - -#define VBOXWDDM_ALLOCATION_HEADSIZE() (RT_OFFSETOF(VBOXWDDM_ALLOCATION, Body)) -#define VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCATION_HEADSIZE() + (_s)) -#define VBOXWDDM_ALLOCATION_SIZE(_tCmd) (VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(sizeof(_tCmd))) -#define VBOXWDDM_ALLOCATION_BODY(_p, _t) ((_t*)(_p)->Body) -#define VBOXWDDM_ALLOCATION_HEAD(_pb) ((VBOXWDDM_ALLOCATION*)((uint8_t *)(_pb) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, Body))) - -typedef struct VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE -{ - VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE AllocInfo; -} VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE; - -typedef struct VBOXWDDM_ALLOCATION_SHADOWSURFACE -{ - VBOXWDDM_ALLOCINFO_SHADOWSURFACE AllocInfo; -} VBOXWDDM_ALLOCATION_SHADOWSURFACE, *PVBOXWDDM_ALLOCATION_SHADOWSURFACE; - -typedef struct VBOXWDDM_ALLOCATION_STAGINGSURFACE -{ - VBOXWDDM_ALLOCINFO_STAGINGSURFACE AllocInfo; -} VBOXWDDM_ALLOCATION_STAGINGSURFACE, *PVBOXWDDM_ALLOCATION_STAGINGSURFACE; - - -typedef struct VBOXWDDM_DEVICE -{ - HANDLE hDevice; /* the handle that the driver should use when it calls back into the Microsoft DirectX graphics kernel subsystem */ - struct _DEVICE_EXTENSION * pAdapter; /* Adapder info */ - DXGK_CREATEDEVICEFLAGS fCreationFlags; /* device creation flags passed to DxgkDdiCreateDevice, not sure we need it */ - DXGK_DEVICEINFO DeviceInfo; -} VBOXWDDM_DEVICE, *PVBOXWDDM_DEVICE; #endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 26629) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (revision 26630) @@ -1032,4 +1032,7 @@ } +/** + * DxgkDdiQueryAdapterInfo + */ NTSTATUS APIENTRY DxgkDdiQueryAdapterInfo( CONST HANDLE hAdapter, @@ -1069,5 +1072,5 @@ pCaps->SchedulingCaps.Value = 0; /* we might need it for Aero. - * Setting this glag means we support DeviceContext, i.e. + * Setting this flag means we support DeviceContext, i.e. * DxgkDdiCreateContext and DxgkDdiDestroyContext */ @@ -1131,4 +1134,7 @@ } +/** + * DxgkDdiCreateDevice + */ NTSTATUS APIENTRY DxgkDdiCreateDevice( CONST HANDLE hAdapter, @@ -1143,18 +1149,17 @@ PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)vboxWddmMemAllocZero(sizeof (VBOXWDDM_DEVICE)); - pDevice->hDevice = pCreateDevice->hDevice; + pCreateDevice->hDevice = pDevice; + if (pCreateDevice->Flags.SystemDevice) + pDevice->enmType = VBOXWDDM_DEVICE_TYPE_SYSTEM; + else + { + AssertBreakpoint(); /* we do not support custom contexts for now */ + drprintf((__FUNCTION__ ": we do not support custom devices for now, hAdapter (0x%x)\n", hAdapter)); + } + pDevice->pAdapter = pContext; - pDevice->fCreationFlags = pCreateDevice->Flags; - - pDevice->DeviceInfo.AllocationListSize = 1024; - pDevice->DeviceInfo.DmaBufferSegmentSet = 0; - pDevice->DeviceInfo.DmaBufferPrivateDataSize = 0; - pDevice->DeviceInfo.AllocationListSize = 4; - pDevice->DeviceInfo.PatchLocationListSize = 4; - pDevice->DeviceInfo.Flags.Value = 0; - pDevice->DeviceInfo.Flags.GuaranteedDmaBufferContract = 1; - - pCreateDevice->pInfo = &pDevice->DeviceInfo; + pCreateDevice->hDevice = pDevice; + pCreateDevice->pInfo = NULL; dfprintf(("<== "__FUNCTION__ ", context(0x%x), Status(0x%x)\n", hAdapter, Status)); @@ -1187,8 +1192,5 @@ if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE)) { - PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); - UINT bpp = vboxWddmCalcBitsPerPixel(pInfo->SurfData.Format); - Assert(bpp); - if (bpp != 0) + if (pAllocInfo->u.SurfInfo.bpp != 0) { PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_SIZE(VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE)); @@ -1196,13 +1198,18 @@ if (pAllocation) { - UINT Pitch = vboxWddmCalcPitch(pInfo->SurfData.Width, bpp); pAllocation->enmType = VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE; + pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo; PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocInfo, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); - memcpy(&pAlloc->AllocInfo, pInfo, sizeof (pAlloc->AllocInfo)); + PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE pAllocI = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); +// memcpy(&pAlloc->AllocInfo, pInfo, sizeof (pAlloc->AllocInfo)); + pAlloc->RefreshRate = pAllocI->RefreshRate; + pAlloc->VidPnSourceId = pAllocI->VidPnSourceId; + pAlloc->offAddress = VBOXVIDEOOFFSET_VOID; + pAlloc->bVisible = FALSE; pAllocationInfo->pPrivateDriverData = NULL; pAllocationInfo->PrivateDriverDataSize = 0; pAllocationInfo->Alignment = 0; - pAllocationInfo->Size = Pitch * pInfo->SurfData.Height; + pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height; pAllocationInfo->PitchAlignedSize = 0; pAllocationInfo->HintedBank.Value = 0; @@ -1212,5 +1219,5 @@ pAllocationInfo->EvictionSegmentSet = 0; pAllocationInfo->MaximumRenamingListLength = 0; - pAllocationInfo->hAllocation = pAlloc; + pAllocationInfo->hAllocation = pAllocation; pAllocationInfo->Flags.Value = 0; pAllocationInfo->Flags.CpuVisible = 1; @@ -1226,5 +1233,5 @@ else { - drprintf((__FUNCTION__ ": Invalid format (%d)\n", pInfo->SurfData.Format)); + drprintf((__FUNCTION__ ": Invalid format (%d)\n", pAllocInfo->u.SurfInfo.format)); Status = STATUS_INVALID_PARAMETER; } @@ -1232,5 +1239,5 @@ else { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHADOWSURFACE))); + drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE))); Status = STATUS_INVALID_PARAMETER; } @@ -1238,21 +1245,20 @@ } case VBOXWDDM_ALLOC_STD_SHADOWSURFACE: - { - Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHADOWSURFACE)); - if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHADOWSURFACE)) + case VBOXWDDM_ALLOC_STD_STAGINGSURFACE: + { + Assert(pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()); + if (pAllocationInfo->PrivateDriverDataSize >= VBOXWDDM_ALLOCINFO_HEADSIZE()) { - PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCATION_SIZE(VBOXWDDM_ALLOCATION_SHADOWSURFACE)); + PVBOXWDDM_ALLOCATION pAllocation = (PVBOXWDDM_ALLOCATION)vboxWddmMemAllocZero(VBOXWDDM_ALLOCINFO_HEADSIZE()); Assert(pAllocation); if (pAllocation) { - pAllocation->enmType = VBOXWDDM_ALLOC_STD_SHADOWSURFACE; - PVBOXWDDM_ALLOCATION_SHADOWSURFACE pAlloc = VBOXWDDM_ALLOCATION_BODY(pAllocInfo, VBOXWDDM_ALLOCATION_SHADOWSURFACE); - PVBOXWDDM_ALLOCINFO_SHADOWSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHADOWSURFACE); - memcpy(&pAlloc->AllocInfo, pInfo, sizeof (pAlloc->AllocInfo)); + pAllocation->enmType = pAllocInfo->enmType; + pAllocation->u.SurfInfo = pAllocInfo->u.SurfInfo; pAllocationInfo->pPrivateDriverData = NULL; pAllocationInfo->PrivateDriverDataSize = 0; pAllocationInfo->Alignment = 0; - pAllocationInfo->Size = pInfo->SurfData.Pitch * pInfo->SurfData.Height; + pAllocationInfo->Size = pAllocInfo->u.SurfInfo.pitch * pAllocInfo->u.SurfInfo.height; pAllocationInfo->PitchAlignedSize = 0; pAllocationInfo->HintedBank.Value = 0; @@ -1262,5 +1268,5 @@ pAllocationInfo->EvictionSegmentSet = 0; pAllocationInfo->MaximumRenamingListLength = 0; - pAllocationInfo->hAllocation = pAlloc; + pAllocationInfo->hAllocation = pAllocation; pAllocationInfo->Flags.Value = 0; pAllocationInfo->Flags.CpuVisible = 1; @@ -1276,13 +1282,7 @@ else { - drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than VBOXWDDM_ALLOC_STD_SHADOWSURFACE cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHADOWSURFACE))); + drprintf((__FUNCTION__ ": ERROR: PrivateDriverDataSize(%d) less than VBOXWDDM_ALLOC_STD_SHADOWSURFACE cmd size(%d)\n", pAllocationInfo->PrivateDriverDataSize, VBOXWDDM_ALLOCINFO_HEADSIZE())); Status = STATUS_INVALID_PARAMETER; } - break; - } - case VBOXWDDM_ALLOC_STD_STAGINGSURFACE: - { - /* @todo: impl */ - AssertBreakpoint(); break; } @@ -1366,5 +1366,5 @@ /** - * + * DxgkDdiGetStandardAllocationDriverData */ NTSTATUS @@ -1391,6 +1391,12 @@ pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; pAllocInfo->enmType = VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE; + pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width; + pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Height; + pAllocInfo->u.SurfInfo.format = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Format; + pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); + pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); - memcpy(&pInfo->SurfData, pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData, sizeof (pInfo->SurfData)); + pInfo->RefreshRate = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->RefreshRate; + pInfo->VidPnSourceId = pGetStandardAllocationDriverData->pCreateSharedPrimarySurfaceData->VidPnSourceId; } pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE); @@ -1415,8 +1421,13 @@ pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; pAllocInfo->enmType = VBOXWDDM_ALLOC_STD_SHADOWSURFACE; - PVBOXWDDM_ALLOCINFO_SHADOWSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_SHADOWSURFACE); - memcpy(&pInfo->SurfData, pGetStandardAllocationDriverData->pCreateShadowSurfaceData, sizeof (pInfo->SurfData)); + pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width; + pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Height; + pAllocInfo->u.SurfInfo.format = pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Format; + pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); + pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); + + pGetStandardAllocationDriverData->pCreateShadowSurfaceData->Pitch = pAllocInfo->u.SurfInfo.pitch; } - pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_SHADOWSURFACE); + pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_HEADSIZE(); pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0; @@ -1436,8 +1447,13 @@ pAllocInfo = (PVBOXWDDM_ALLOCINFO)pGetStandardAllocationDriverData->pAllocationPrivateDriverData; pAllocInfo->enmType = VBOXWDDM_ALLOC_STD_STAGINGSURFACE; - PVBOXWDDM_ALLOCINFO_STAGINGSURFACE pInfo = VBOXWDDM_ALLOCINFO_BODY(pAllocInfo, VBOXWDDM_ALLOCINFO_STAGINGSURFACE); - memcpy(&pInfo->SurfData, pGetStandardAllocationDriverData->pCreateStagingSurfaceData, sizeof (pInfo->SurfData)); - } - pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_SIZE(VBOXWDDM_ALLOCINFO_STAGINGSURFACE); + pAllocInfo->u.SurfInfo.width = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width; + pAllocInfo->u.SurfInfo.height = pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Height; + pAllocInfo->u.SurfInfo.format = D3DDDIFMT_X8R8G8B8; /* staging has always always D3DDDIFMT_X8R8G8B8 */ + pAllocInfo->u.SurfInfo.bpp = vboxWddmCalcBitsPerPixel(pAllocInfo->u.SurfInfo.format); + pAllocInfo->u.SurfInfo.pitch = vboxWddmCalcPitch(pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Width, pAllocInfo->u.SurfInfo.bpp); + + pGetStandardAllocationDriverData->pCreateStagingSurfaceData->Pitch = pAllocInfo->u.SurfInfo.pitch; + } + pGetStandardAllocationDriverData->AllocationPrivateDriverDataSize = VBOXWDDM_ALLOCINFO_HEADSIZE(); pGetStandardAllocationDriverData->ResourcePrivateDriverDataSize = 0; @@ -1446,4 +1462,5 @@ //#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) // case D3DKMDT_STANDARDALLOCATION_GDISURFACE: +//# error port to Win7 DDI // break; //#endif @@ -2054,5 +2071,18 @@ CONST DXGKARG_OPENALLOCATION *pOpenAllocation) { - return STATUS_NOT_IMPLEMENTED; + /* DxgkDdiOpenAllocation should be made pageable. */ + PAGED_CODE(); + + NTSTATUS Status = STATUS_SUCCESS; + + for (UINT i = 0; i < pOpenAllocation->NumAllocations; ++i) + { + DXGK_OPENALLOCATIONINFO* pInfo = &pOpenAllocation->pOpenAllocation[i]; + PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OPENALLOCATION)); + pOa->hAllocation = pInfo->hAllocation; + pInfo->hDeviceSpecificAllocation = pOa; + } + + return Status; } @@ -2072,7 +2102,89 @@ DXGKARG_RENDER *pRender) { - return STATUS_NOT_IMPLEMENTED; -} - + drprintf(("==> "__FUNCTION__ ", !!NOT_IMPLEMENTED!! hContext(0x%x)\n", hContext)); + + AssertBreakpoint(); + + drprintf(("<== "__FUNCTION__ ", !!NOT_IMPLEMENTED!! hContext(0x%x)\n", hContext)); + + return STATUS_NOT_IMPLEMENTED; +} + +#define VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE() (VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_PRESENT_BLT)) +#define VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(_c) (VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[_c])) + +DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromOpenData(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OPENALLOCATION pOa) +{ + DXGKARGCB_GETHANDLEDATA GhData; + GhData.hObject = pOa->hAllocation; + GhData.Type = DXGK_HANDLE_ALLOCATION; + GhData.Flags.Value = 0; + return (PVBOXWDDM_ALLOCATION)pDevExt->u.primary.DxgkInterface.DxgkCbGetHandleData(&GhData); +} + +DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PDEVICE_EXTENSION pDevExt, DXGK_ALLOCATIONLIST *pAllocList) +{ + return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation); +} + +DECLINLINE(VBOXVIDEOOFFSET) vboxWddmOffsetFromPhAddress(PHYSICAL_ADDRESS phAddr) +{ + return (VBOXVIDEOOFFSET)(phAddr.QuadPart ? phAddr.QuadPart - VBE_DISPI_LFB_PHYSICAL_ADDRESS : VBOXVIDEOOFFSET_VOID); +} + +DECLINLINE(VOID) vboxWddmRectlFromRect(const RECT *pRect, PVBOXVDMA_RECTL pRectl) +{ + pRectl->left = (int16_t)pRect->left; + pRectl->width = (uint16_t)(pRect->right - pRect->left); + pRectl->top = (int16_t)pRect->top; + pRectl->height = (uint16_t)(pRect->bottom - pRect->top); +} + +DECLINLINE(VBOXVDMA_PIXEL_FORMAT) vboxWddmFromPixFormat(D3DDDIFORMAT format) +{ + return (VBOXVDMA_PIXEL_FORMAT)format; +} + +DECLINLINE(VOID) vboxWddmSurfDescFromAllocation(PVBOXWDDM_ALLOCATION pAllocation, PVBOXVDMA_SURF_DESC pDesc) +{ + pDesc->width = pAllocation->u.SurfInfo.width; + pDesc->height = pAllocation->u.SurfInfo.height; + pDesc->format = vboxWddmFromPixFormat(pAllocation->u.SurfInfo.format); + pDesc->bpp = pAllocation->u.SurfInfo.bpp; + pDesc->pitch = pAllocation->u.SurfInfo.pitch; + pDesc->fFlags = 0; +} + +DECLINLINE(BOOLEAN) vboxWddmPixFormatConversionSupported(D3DDDIFORMAT From, D3DDDIFORMAT To) +{ + Assert(From != D3DDDIFMT_UNKNOWN); + Assert(To != D3DDDIFMT_UNKNOWN); + Assert(From == To); + return From == To; +} + +DECLINLINE(PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE) vboxWddmCheckForVisiblePrimary(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_ALLOCATION pAllocation) +{ + if (pAllocation->enmType != VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE) + return NULL; + + PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE pPrimary = VBOXWDDM_ALLOCATION_BODY(pAllocation, VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE); + if (!pPrimary->bVisible) + return NULL; + + D3DDDI_VIDEO_PRESENT_SOURCE_ID id = pPrimary->VidPnSourceId; + if (id >= pDevExt->cSources) + return NULL; + + PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[id]; + if (pSource->pAllocation != pAllocation) + return NULL; + + return pPrimary; +} + +/** + * DxgkDdiPresent + */ NTSTATUS APIENTRY @@ -2081,5 +2193,109 @@ DXGKARG_PRESENT *pPresent) { - return STATUS_NOT_IMPLEMENTED; + PAGED_CODE(); + + dfprintf(("==> "__FUNCTION__ ", hContext(0x%x)\n", hContext)); + + NTSTATUS Status = STATUS_SUCCESS; + PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext; + PVBOXWDDM_DEVICE pDevice = pContext->pDevice; + PDEVICE_EXTENSION pDevExt = pDevice->pAdapter; + + if (pPresent->Flags.Blt) + { + Assert(pPresent->Flags.Value == 1); /* only Blt is set, we do not support anything else for now */ + UINT cbCmd = pPresent->DmaSize; + + UINT cmdSize = VBOXVDMACMD_DMA_PRESENT_BLT_SIZE(pPresent->SubRectCnt - pPresent->MultipassOffset); + PVBOXVDMACMD pCmd = (PVBOXVDMACMD)pPresent->pDmaBuffer; + pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + cmdSize; + Assert(cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE()); + if (cbCmd >= VBOXVDMACMD_DMA_PRESENT_BLT_MINSIZE()) + { + DXGK_ALLOCATIONLIST *pSrc = &pPresent->pAllocationList[DXGK_PRESENT_SOURCE_INDEX]; + DXGK_ALLOCATIONLIST *pDst = &pPresent->pAllocationList[DXGK_PRESENT_DESTINATION_INDEX]; + PVBOXWDDM_ALLOCATION pSrcAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pSrc); + Assert(pSrcAlloc); + if (pSrcAlloc) + { + PVBOXWDDM_ALLOCATION pDstAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pDst); + Assert(pDstAlloc); + if (pDstAlloc) + { + if (vboxWddmPixFormatConversionSupported(pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)) + { + memset(pPresent->pPatchLocationListOut, 0, 2*sizeof (D3DDDI_PATCHLOCATIONLIST)); + pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offSrc); + ++pPresent->pPatchLocationListOut; + pPresent->pPatchLocationListOut->PatchOffset = VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, offDst); + pPresent->pPatchLocationListOut->AllocationIndex = 1; + ++pPresent->pPatchLocationListOut; + + pCmd->enmType = VBOXVDMACMD_TYPE_DMA_PRESENT_BLT; + pCmd->u32CmdSpecific = 0; + PVBOXVDMACMD_DMA_PRESENT_BLT pTransfer = VBOXVDMACMD_BODY(pCmd, VBOXVDMACMD_DMA_PRESENT_BLT); + pTransfer->offSrc = vboxWddmOffsetFromPhAddress(pSrc->PhysicalAddress); + pTransfer->offDst = vboxWddmOffsetFromPhAddress(pDst->PhysicalAddress); + vboxWddmSurfDescFromAllocation(pSrcAlloc, &pTransfer->srcDesc); + vboxWddmSurfDescFromAllocation(pDstAlloc, &pTransfer->dstDesc); + vboxWddmRectlFromRect(&pPresent->SrcRect, &pTransfer->srcRectl); + vboxWddmRectlFromRect(&pPresent->DstRect, &pTransfer->dstRectl); + UINT i = 0; + cbCmd -= VBOXVDMACMD_BODY_FIELD_OFFSET(UINT, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects); + Assert(cbCmd >= sizeof (VBOXVDMA_RECTL)); + Assert(cbCmd < pPresent->DmaSize); + for (; i < pPresent->SubRectCnt; ++i) + { + if (cbCmd < sizeof (VBOXVDMA_RECTL)) + { + Assert(i); + pPresent->MultipassOffset += i; + Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER; + break; + } + vboxWddmRectlFromRect(&pPresent->pDstSubRects[i + pPresent->MultipassOffset], &pTransfer->aDstSubRects[i]); + cbCmd -= sizeof (VBOXVDMA_RECTL); + } + Assert(i); + pTransfer->cDstSubRects = i; + } + else + { + AssertBreakpoint(); + drprintf((__FUNCTION__": unsupported format conversion from(%d) to (%d)\n",pSrcAlloc->u.SurfInfo.format, pDstAlloc->u.SurfInfo.format)); + Status = STATUS_GRAPHICS_CANNOTCOLORCONVERT; + } + } + else + { + /* this should not happen actually */ + drprintf((__FUNCTION__": failed to get Dst Allocation info for hDeviceSpecificAllocation(0x%x)\n",pDst->hDeviceSpecificAllocation)); + Status = STATUS_INVALID_HANDLE; + } + } + else + { + /* this should not happen actually */ + drprintf((__FUNCTION__": failed to get Src Allocation info for hDeviceSpecificAllocation(0x%x)\n",pSrc->hDeviceSpecificAllocation)); + Status = STATUS_INVALID_HANDLE; + } + } + else + { + /* this should not happen actually */ + drprintf((__FUNCTION__": cbCmd too small!! (%d)\n", cbCmd)); + Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER; + } + + } + else + { + drprintf((__FUNCTION__": cmd NOT IMPLEMENTED!! Flags(0x%x)\n", pPresent->Flags.Value)); + AssertBreakpoint(); + } + + dfprintf(("<== "__FUNCTION__ ", hContext(0x%x), Status(0x%x)\n", hContext, Status)); + + return Status; } @@ -2110,4 +2326,7 @@ } +/** + * DxgkDdiCreateContext + */ NTSTATUS APIENTRY @@ -2116,5 +2335,38 @@ DXGKARG_CREATECONTEXT *pCreateContext) { - return STATUS_NOT_IMPLEMENTED; + /* DxgkDdiCreateContext should be made pageable */ + PAGED_CODE(); + + dfprintf(("==> "__FUNCTION__ ", hDevice(0x%x)\n", hDevice)); + + NTSTATUS Status = STATUS_SUCCESS; + PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice; + PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)vboxWddmMemAllocZero(sizeof (VBOXWDDM_CONTEXT)); + + pContext->pDevice = pDevice; + pContext->EngineAffinity = pCreateContext->EngineAffinity; + pContext->NodeOrdinal = pCreateContext->NodeOrdinal; + if (pCreateContext->Flags.SystemContext) + pContext->enmType = VBOXWDDM_CONTEXT_TYPE_SYSTEM; + else + { + AssertBreakpoint(); /* we do not support custom contexts for now */ + drprintf((__FUNCTION__ ", we do not support custom contexts for now, hDevice (0x%x)\n", hDevice)); + } + + pCreateContext->hContext = pContext; + pCreateContext->ContextInfo.DmaBufferSize = VBOXWDDM_C_DMA_BUFFER_SIZE; + pCreateContext->ContextInfo.DmaBufferSegmentSet = 0; + pCreateContext->ContextInfo.DmaBufferPrivateDataSize = sizeof (VBOXWDDM_DMA_PRIVATE_DATA); + pCreateContext->ContextInfo.AllocationListSize = VBOXWDDM_C_ALLOC_LIST_SIZE; + pCreateContext->ContextInfo.PatchLocationListSize = VBOXWDDM_C_PATH_LOCATION_LIST_SIZE; +//#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) +//# error port to Win7 DDI +// //pCreateContext->ContextInfo.DmaBufferAllocationGroup = ???; +//#endif // DXGKDDI_INTERFACE_VERSION + + dfprintf(("<== "__FUNCTION__ ", hDevice(0x%x)\n", hDevice)); + + return Status; } @@ -2154,9 +2406,9 @@ ) { + PAGED_CODE(); + dprintf(("VBoxVideoWddm::DriverEntry. Built %s %s\n", __DATE__, __TIME__)); DRIVER_INITIALIZATION_DATA DriverInitializationData = {'\0'}; - - PAGED_CODE(); if (! ARGUMENT_PRESENT(DriverObject) || @@ -2253,9 +2505,10 @@ //#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) -// DriverInitializationData.DxgkDdiRenderKm = D3DDDIRenderKm; -// DriverInitializationData.DxgkDdiRestartFromTimeout = D3DDDIRestartFromTimeout; +//# error port to Win7 DDI +// DriverInitializationData.DxgkDdiRenderKm = DxgkDdiRenderKm; +// DriverInitializationData.DxgkDdiRestartFromTimeout = DxgkDdiRestartFromTimeout; // DriverInitializationData.DxgkDdiSetVidPnSourceVisibility = DxgkDdiSetVidPnSourceVisibility; -// DriverInitializationData.DxgkDdiUpdateActiveVidPnPresentPath = D3DDDIUpdateActiveVidPnPresentPath; -// DriverInitializationData.DxgkDdiQueryVidPnHWCapability = D3DDDI DxgkDdiQueryVidPnHWCapability; +// DriverInitializationData.DxgkDdiUpdateActiveVidPnPresentPath = DxgkDdiUpdateActiveVidPnPresentPath; +// DriverInitializationData.DxgkDdiQueryVidPnHWCapability = DxgkDdiQueryVidPnHWCapability; //#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 26630) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h (revision 26630) @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2010 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * 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. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ +#ifndef ___VBoxVideoWddm_h___ +#define ___VBoxVideoWddm_h___ + +#define VBOXWDDM_C_DMA_BUFFER_SIZE 0x10000 +#define VBOXWDDM_C_ALLOC_LIST_SIZE 0xc00 +#define VBOXWDDM_C_PATH_LOCATION_LIST_SIZE 0xc00 + +typedef enum +{ + VBOXWDDM_ALLOC_UNEFINED = 0, + VBOXWDDM_ALLOC_STD_SHAREDPRIMARYSURFACE, + VBOXWDDM_ALLOC_STD_SHADOWSURFACE, + VBOXWDDM_ALLOC_STD_STAGINGSURFACE, + /* this one is win 7-specific and hence unused for now */ + VBOXWDDM_ALLOC_STD_GDISURFACE + /* custom allocation types requested from user-mode d3d module will go here */ +} VBOXWDDM_ALLOC_TYPE; + +typedef struct VBOXWDDM_SURFACE_DESC +{ + UINT width; + UINT height; + D3DDDIFORMAT format; + UINT bpp; + UINT pitch; +} VBOXWDDM_SURFACE_DESC, *PVBOXWDDM_SURFACE_DESC; + +typedef struct VBOXWDDM_ALLOCINFO +{ + VBOXWDDM_ALLOC_TYPE enmType; + union + { + VBOXWDDM_SURFACE_DESC SurfInfo; + } u; +} VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO; + +#define VBOXWDDM_ALLOCINFO_HEADSIZE() (sizeof (VBOXWDDM_ALLOCINFO)) +#define VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCINFO_HEADSIZE() + (_s)) +#define VBOXWDDM_ALLOCINFO_SIZE(_tCmd) (VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(sizeof(_tCmd))) +#define VBOXWDDM_ALLOCINFO_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCINFO_HEADSIZE()) ) +#define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE())) + + +typedef struct VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE +{ + D3DDDI_RATIONAL RefreshRate; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} VBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCINFO_SHAREDPRIMARYSURFACE; + +/* allocation */ +typedef struct VBOXWDDM_ALLOCATION +{ + VBOXWDDM_ALLOC_TYPE enmType; + union + { + VBOXWDDM_SURFACE_DESC SurfInfo; + } u; +} VBOXWDDM_ALLOCATION, *PVBOXWDDM_ALLOCATION; + +#define VBOXWDDM_ALLOCATION_HEADSIZE() (sizeof (VBOXWDDM_ALLOCATION)) +#define VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCATION_HEADSIZE() + (_s)) +#define VBOXWDDM_ALLOCATION_SIZE(_tCmd) (VBOXWDDM_ALLOCATION_SIZE_FROMBODYSIZE(sizeof(_tCmd))) +#define VBOXWDDM_ALLOCATION_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCATION_HEADSIZE()) ) +#define VBOXWDDM_ALLOCATION_HEAD(_pb) ((VBOXWDDM_ALLOCATION*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE())) + +typedef struct VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE +{ + D3DDDI_RATIONAL RefreshRate; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + VBOXVIDEOOFFSET offAddress; + BOOLEAN bVisible; +} VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE, *PVBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE; + +typedef enum +{ + VBOXWDDM_DEVICE_TYPE_UNDEFINED = 0, + VBOXWDDM_DEVICE_TYPE_SYSTEM +} VBOXWDDM_DEVICE_TYPE; + +typedef struct VBOXWDDM_DEVICE +{ + struct _DEVICE_EXTENSION * pAdapter; /* Adapder info */ + VBOXWDDM_DEVICE_TYPE enmType; /* device creation flags passed to DxgkDdiCreateDevice, not sure we need it */ +} VBOXWDDM_DEVICE, *PVBOXWDDM_DEVICE; + +typedef enum +{ + VBOXWDDM_CONTEXT_TYPE_UNDEFINED = 0, + VBOXWDDM_CONTEXT_TYPE_SYSTEM +} VBOXWDDM_CONTEXT_TYPE; + +typedef struct VBOXWDDM_CONTEXT +{ + struct VBOXWDDM_DEVICE * pDevice; + VBOXWDDM_CONTEXT_TYPE enmType; + UINT NodeOrdinal; + UINT EngineAffinity; +} VBOXWDDM_CONTEXT, *PVBOXWDDM_CONTEXT; + +typedef struct VBOXWDDM_DMA_PRIVATE_DATA +{ + uint8_t Reserved[64]; +}VBOXWDDM_DMA_PRIVATE_DATA, *PVBOXWDDM_DMA_PRIVATE_DATA; + +typedef struct VBOXWDDM_OPENALLOCATION +{ + D3DKMT_HANDLE hAllocation; +} VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION; + +#endif /* #ifndef ___VBoxVideoWddm_h___ */