Changeset 29488 in vbox for trunk/src/VBox/Additions/WINNT/Graphics

Timestamp:

May 14, 2010 5:05:43 PM (15 years ago)

Author:

vboxsync

Message:

wddm: getcaps for d3d9, start impl 2D support

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Display/Makefile.kmk (modified) (1 diff)
• Display/wddm/VBoxDispD3D.cpp (modified) (3 diffs)
• Miniport/VBoxVideo.h (modified) (1 diff)
• Miniport/wddm/VBoxVideoIf.h (added)
• Miniport/wddm/VBoxVideoWddm.cpp (modified) (4 diffs)
• Miniport/wddm/VBoxVideoWddm.h (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk

@@ -77 +77 @@
 VBoxDispD3D_TEMPLATE = VBOXGUESTR3DLL
 VBoxDispD3D_DEFS     = UNICODE _UNICODE
+ifdef VBOX_WITH_VIDEOHWACCEL
+ VBoxDispD3D_DEFS   += VBOX_WITH_VIDEOHWACCEL
+endif
 VBoxDispD3D_SOURCES  = \
         wddm/VBoxDispD3D.cpp \

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -30 +30 @@
 #include "VBoxDispD3D.h"
 #include "VBoxDispD3DCmn.h"
+#include "../../Miniport/wddm/VBoxVideoIf.h"
 
 #ifdef VBOXWDDMDISP_DEBUG
@@ -73 +74 @@
 
     HRESULT hr = S_OK;
+    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
 
     switch (pData->Type)
     {
         case D3DDDICAPS_DDRAW:
+        {
+            AssertBreakpoint();
             Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
             if (pData->DataSize >= sizeof (DDRAW_CAPS))
+            {
                 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                VBOXWDDM_QI_2D_1 Query;
+                Query.hdr.enmType = VBOXWDDM_QI_TYPE_2D_1;
+                VBOXVHWA_VERSION_INIT(&Query.Info.u.in.guestVersion);
+                D3DDDICB_QUERYADAPTERINFO DdiQuery;
+                DdiQuery.PrivateDriverDataSize = sizeof(Query);
+                DdiQuery.pPrivateDriverData = &Query;
+                hr = pAdapter->RtCallbacks.pfnQueryAdapterInfoCb(pAdapter->hAdapter, &DdiQuery);
+                Assert(hr == S_OK);
+                if (hr == S_OK)
+                {
+                    if (Query.hdr.rc == VINF_SUCCESS)
+                    {
+                        /* query succeeded, check the results */
+                        if (Query.Info.u.out.cfgFlags == VBOXVHWA_CFG_ENABLED)
+                        {
+                            /* 2D is enabled*/
+                            DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
+                            /* overlay supported */
+                            if (Query.Info.u.out.surfaceCaps & VBOXVHWA_SCAPS_OVERLAY)
+                            {
+                                if (Query.Info.u.out.caps & VBOXVHWA_CAPS_COLORKEY)
+                                {
+                                    pCaps->Caps = DDRAW_CAPS_COLORKEY;
+                                }
+                            }
+
+                            /* @todo: feel the caps from here */
+                        }
+                    }
+                }
+#endif
+            }
             else
                 hr = E_INVALIDARG;
             break;
+        }
         case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
+        {
+            AssertBreakpoint();
             Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
             if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
-                memset(pData->pData, 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS));
+            {
+                DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
+                memset(&pCaps->Caps /* do not cleanup the first "Head" field,
+                                    zero starting with the one following "Head", i.e. Caps */,
+                        0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                VBOXWDDM_QI_2D_1 Query;
+                Query.hdr.enmType = VBOXWDDM_QI_TYPE_2D_1;
+                VBOXVHWA_VERSION_INIT(&Query.Info.u.in.guestVersion);
+                D3DDDICB_QUERYADAPTERINFO DdiQuery;
+                DdiQuery.PrivateDriverDataSize = sizeof(Query);
+                DdiQuery.pPrivateDriverData = &Query;
+                hr = pAdapter->RtCallbacks.pfnQueryAdapterInfoCb(pAdapter->hAdapter, &DdiQuery);
+                Assert(hr == S_OK);
+                if (hr == S_OK)
+                {
+                    if (Query.hdr.rc == VINF_SUCCESS)
+                    {
+                        /* query succeeded, check the results */
+                        if (Query.Info.u.out.cfgFlags == VBOXVHWA_CFG_ENABLED)
+                        {
+                            /* 2D is enabled*/
+                            if (Query.Info.u.out.surfaceCaps & VBOXVHWA_SCAPS_OVERLAY)
+                            {
+                                /* overlay supported */
+                                pCaps->Caps = MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
+                                if (Query.Info.u.out.caps & VBOXVHWA_CAPS_COLORKEY)
+                                {
+                                    if (Query.Info.u.out.colorKeyCaps & VBOXVHWA_CKEYCAPS_DESTOVERLAY)
+                                    {
+                                        pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
+                                                | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */;
+                                    }
+                                }
+
+                                pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
+                                        | MODE_FXCAPS_OVERLAYSHRINKY
+                                        | MODE_FXCAPS_OVERLAYSTRETCHX
+                                        | MODE_FXCAPS_OVERLAYSTRETCHY;
+
+                                pCaps->MaxVisibleOverlays = Query.Info.u.out.numOverlays;
+                                pCaps->MinOverlayStretch = 1;
+                                pCaps->MaxOverlayStretch = 32000;
+                            }
+                        }
+                    }
+                }
+#endif
+            }
             else
                 hr = E_INVALIDARG;
             break;
+        }
         case D3DDDICAPS_GETFORMATCOUNT:
             *((uint32_t*)pData->pData) = 0;
@@ -114 +204 @@
             break;
         case D3DDDICAPS_GETD3D9CAPS:
+        {
             Assert(pData->DataSize >= sizeof (D3DCAPS9));
             if (pData->DataSize >= sizeof (D3DCAPS9))
+            {
+                if (pAdapter->pD3D9If)
+                {
+                    hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, (D3DCAPS9*)pData->pData);
+                    Assert(hr == S_OK);
+                    if (hr == S_OK)
+                        break;
+
+                    vboxVDbgPrintR((__FUNCTION__": GetDeviceCaps hr(%d)\n", hr));
+                    /* let's fall back to the 3D disabled case */
+                    hr = S_OK;
+                }
+
                 memset(pData->pData, 0, sizeof (D3DCAPS9));
+            }
             else
                 hr = E_INVALIDARG;
             break;
+        }
         case D3DDDICAPS_GETGAMMARAMPCAPS:
             *((uint32_t*)pData->pData) = 0;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

@@ -115 +115 @@
 #else
 #include <VBox/VBoxVideo.h>
+#include "wddm/VBoxVideoIf.h"
 #include "wddm/VBoxVideoWddm.h"
 #include "wddm/VBoxVideoShgsmi.h"

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

@@ -1280 +1280 @@
         }
         case DXGKQAITYPE_UMDRIVERPRIVATE:
-            drprintf((__FUNCTION__ ": we do not support DXGKQAITYPE_UMDRIVERPRIVATE\n"));
             AssertBreakpoint();
-            Status = STATUS_NOT_SUPPORTED;
+            Assert(pQueryAdapterInfo->InputDataSize > sizeof (VBOXWDDM_QI));
+            if (pQueryAdapterInfo->InputDataSize > sizeof (VBOXWDDM_QI)
+                    && pQueryAdapterInfo->OutputDataSize > sizeof (VBOXWDDM_QI))
+            {
+                VBOXWDDM_QI * pQi = (VBOXWDDM_QI*)pQueryAdapterInfo->pInputData;
+                switch (pQi->enmType)
+                {
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    case VBOXWDDM_QI_TYPE_2D_1:
+                    {
+                        if (pQueryAdapterInfo->InputDataSize >= sizeof (VBOXWDDM_QI_2D_1)
+                                && pQueryAdapterInfo->OutputDataSize >= sizeof (VBOXWDDM_QI_2D_1))
+                        {
+                            VBOXWDDM_QI_2D_1 * pQueryIn = (VBOXWDDM_QI_2D_1*)pQueryAdapterInfo->pInputData;
+                            VBOXWDDM_QI_2D_1 * pQueryOut = (VBOXWDDM_QI_2D_1*)pQueryAdapterInfo->pOutputData;
+                            /* @todo: submit to the host */
+#if 0
+                            VBOXVHWACMD *pCmd = create-cmd;
+                            VBOXVHWACMD_QUERYINFO1 *pQueryCmd = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
+                            pQueryCmd->u.in.guestVersion = pQueryIn->Info.in.guestVersion;
+                            int rc = submit-cmd;
+                            pQueryOut->hdr.rc = rc;
+                            if (RT_SUCCESS(rc))
+                            {
+                                memcpy(&pQueryOut->Info, pQueryCmd, sizeof(VBOXVHWACMD_QUERYINFO1));
+                            }
+#else
+                            pQueryOut->hdr.rc = VERR_NOT_SUPPORTED;
+#endif
+                        }
+                        else
+                        {
+                            drprintf((__FUNCTION__ ": in or out buffer for VBOXWDDM_QI_TYPE_2D_1 too small\n"));
+                            Status = STATUS_BUFFER_TOO_SMALL;
+                        }
+                        break;
+                    }
+                    case VBOXWDDM_QI_TYPE_2D_2:
+                    {
+                        /* @todo: submit to the host */
+                        break;
+                    }
+#endif
+                    default:
+                        drprintf((__FUNCTION__ ": unsupported qi (%d)\n", pQi->enmType));
+                        AssertBreakpoint();
+                        Status = STATUS_INVALID_PARAMETER;
+                }
+            }
+            else
+            {
+                drprintf((__FUNCTION__ ": in or out buffer too small\n"));
+                Status = STATUS_BUFFER_TOO_SMALL;
+            }
             break;
         default:
@@ -1790 +1842 @@
     dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
 
-    vboxVDbgBreakF();
+    vboxVDbgBreakFv();
 
     /* Value == 2 is Present
@@ -1897 +1949 @@
 //    dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
 
-    vboxVDbgBreakF();
+    vboxVDbgBreakFv();
 
     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
@@ -3752 +3804 @@
     PAGED_CODE();
 
-    AssertBreakpoint();
+    vboxVDbgBreakFv();
 
     drprintf(("VBoxVideoWddm::DriverEntry. Built %s %s\n", __DATE__, __TIME__));

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.h

@@ -34 +34 @@
 PVOID vboxWddmMemAllocZero(IN SIZE_T cbSize);
 VOID vboxWddmMemFree(PVOID pvMem);
-
-typedef enum
-{
-    VBOXWDDM_ALLOC_TYPE_UNEFINED = 0,
-    VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE,
-    VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE,
-    VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE,
-    /* this one is win 7-specific and hence unused for now */
-    VBOXWDDM_ALLOC_TYPE_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