Changeset 29710 in vbox for trunk

Timestamp:

May 20, 2010 7:57:47 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

61885

Message:

wddm/2D: more impl & fixes

Location:

trunk/src/VBox/Additions/WINNT/Graphics

Files:

• Display/wddm/VBoxDispD3D.cpp (modified) (6 diffs)
• Display/wddm/VBoxDispD3D.h (modified) (2 diffs)
• Miniport/VBoxVideo.h (modified) (3 diffs)
• Miniport/wddm/VBoxVideoIf.h (modified) (2 diffs)
• Miniport/wddm/VBoxVideoVhwa.cpp (modified) (20 diffs)
• Miniport/wddm/VBoxVideoVhwa.h (modified) (1 diff)
• Miniport/wddm/VBoxVideoWddm.cpp (modified) (3 diffs)
• Miniport/wddm/VBoxVideoWddm.h (modified) (1 diff)

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
@@ -297 +296 @@
 
 #define VBOX_FORMATOP_COUNT() (sizeof(gVBoxFormatOps)/sizeof(gVBoxFormatOps[0]))
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+
+static bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
+{
+    for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
+    {
+        if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
+            return true;
+    }
+    return false;
+}
+
+static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
+{
+    for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
+    {
+        VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
+        if ((pSettings->fFlags & VBOXVHWA_F_ENABLED)
+                && ((pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
+                        || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC))
+               )
+            return true;
+    }
+    return false;
+}
+
+#endif
 
 /**
@@ -348 +375 @@
                 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 (vboxVhwaHasCKeying(pAdapter))
                 {
-                    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 */
-                        }
-                    }
+                    DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
+                    pCaps->Caps |= DDRAW_CAPS_COLORKEY;
                 }
 #endif
@@ -395 +397 @@
                         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)
+                VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
+                if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
                 {
-                    if (Query.hdr.rc == VINF_SUCCESS)
+                    pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
+
+                    if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
                     {
-                        /* 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;
-                            }
-                        }
+                        pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
+                                | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
+                                ;
                     }
+
+                    if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
+                    {
+                        pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
+                                | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
+                                | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
+                                | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
+                                ;
+                    }
+
+                    pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
+                            | MODE_FXCAPS_OVERLAYSHRINKY
+                            | MODE_FXCAPS_OVERLAYSTRETCHX
+                            | MODE_FXCAPS_OVERLAYSTRETCHY;
+
+
+                    pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
+                    pCaps->MinOverlayStretch = 1;
+                    pCaps->MaxOverlayStretch = 32000;
                 }
 #endif
@@ -1421 +1413 @@
     vboxVDbgPrint(("==> "__FUNCTION__"\n"));
 
-//    AssertBreakpoint();
-
-    HRESULT hr = S_OK;
+    VBOXWDDM_QI Query;
+    D3DDDICB_QUERYADAPTERINFO DdiQuery;
+    DdiQuery.PrivateDriverDataSize = sizeof(Query);
+    DdiQuery.pPrivateDriverData = &Query;
+    HRESULT hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
+    Assert(hr == S_OK);
+    if (hr != S_OK)
+    {
+        vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
+        return E_FAIL;
+    }
+
+    /* check the miniport version match display version */
+    if (Query.u32Version != VBOXVIDEOIF_VERSION)
+    {
+        vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
+                VBOXVIDEOIF_VERSION,
+                Query.u32Version));
+        return E_FAIL;
+    }
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    Assert(Query.cInfos >= 1);
+    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
+#else
     PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
+#endif
     Assert(pAdapter);
     if (pAdapter)
@@ -1432 +1447 @@
         pAdapter->uRtVersion= pOpenData->Version;
         pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        pAdapter->cHeads = Query.cInfos;
+        for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
+        {
+            pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
+        }
+#endif
 
         pOpenData->hAdapter = pAdapter;

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

@@ -17 +17 @@
 
 #include "VBoxDispD3DIf.h"
+#include "../../Miniport/wddm/VBoxVideoIf.h"
 
 #include <iprt/cdefs.h>
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+typedef struct VBOXDISPVHWA_INFO
+{
+    VBOXVHWA_INFO Settings;
+}VBOXDISPVHWA_INFO;
+
+/* represents settings secific to
+ * display device (head) on the multiple-head graphics card
+ * currently used for 2D (overlay) only since in theory its settings
+ * can differ per each frontend's framebuffer. */
+typedef struct VBOXWDDMDISP_HEAD
+{
+    VBOXDISPVHWA_INFO Vhwa;
+} VBOXWDDMDISP_HEAD;
+#endif
 
 typedef struct VBOXWDDMDISP_ADAPTER
@@ -28 +45 @@
     IDirect3D9Ex * pD3D9If;
     D3DDDI_ADAPTERCALLBACKS RtCallbacks;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    uint32_t cHeads;
+    VBOXWDDMDISP_HEAD aHeads[1];
+#endif
 } VBOXWDDMDISP_ADAPTER, *PVBOXWDDMDISP_ADAPTER;
 

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

@@ -153 +153 @@
 } VBOXWDDM_POINTER_INFO, *PVBOXWDDM_POINTER_INFO;
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+typedef struct VBOXWDDM_VHWA
+{
+    VBOXVHWA_INFO Settings;
+} VBOXWDDM_VHWA;
+#endif
+
 typedef struct VBOXWDDM_SOURCE
 {
@@ -161 +168 @@
     VBOXWDDM_SURFACE_DESC SurfInfo;
     VBOXVBVAINFO Vbva;
+#endif
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    /* @todo: in our case this seems more like a target property,
+     * but keep it here for now */
+    VBOXWDDM_VHWA Vhwa;
 #endif
     VBOXWDDM_POINTER_INFO PointerInfo;
@@ -214 +226 @@
 # ifdef VBOXVDMA_WITH_VBVA
            VBOXVBVAINFO Vbva;
-# endif
-# ifdef VBOX_WITH_VIDEOHWACCEL
-           VBOXVHWA_INFO Vhwa;
 # endif
 #endif

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

@@ -23 +23 @@
 
 #include <VBox/VBoxVideo.h>
+
+/* @todo: implement a check to ensure display & miniport versions match
+ * one would increase this whenever defines in this file change */
+#define VBOXVIDEOIF_VERSION 1
 
 /* create allocation func */
@@ -60 +64 @@
 #define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE()))
 
+
+#define VBOXVHWA_F_ENABLED  0x00000001
+#define VBOXVHWA_F_CKEY_DST 0x00000002
+#define VBOXVHWA_F_CKEY_SRC 0x00000004
+
+#define VBOXVHWA_MAX_FORMATS 8
+
+typedef struct VBOXVHWA_INFO
+{
+    uint32_t fFlags;
+    uint32_t cOverlaysSupported;
+    uint32_t cFormats;
+    D3DDDIFORMAT aFormats[VBOXVHWA_MAX_FORMATS];
+} VBOXVHWA_INFO;
+
 /* query info func */
-typedef enum
-{
-    VBOXWDDM_QI_TYPE_UNEFINED = 0,
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    /* VBOXVHWACMD_QUERYINFO1 */
-    VBOXWDDM_QI_TYPE_2D_1,
-    /* VBOXVHWACMD_QUERYINFO2 */
-    VBOXWDDM_QI_TYPE_2D_2
-#endif
-} VBOXWDDM_QI_TYPE;
-
 typedef struct VBOXWDDM_QI
 {
-    VBOXWDDM_QI_TYPE enmType;
-    int rc;
+    uint32_t u32Version;
+    uint32_t cInfos;
+    VBOXVHWA_INFO aInfos[VBOX_VIDEO_MAX_SCREENS];
 } VBOXWDDM_QI;
-
-typedef struct VBOXWDDM_QI_2D_1
-{
-    VBOXWDDM_QI hdr;
-    VBOXVHWACMD_QUERYINFO1 Info;
-} VBOXWDDM_QI_2D_1;
-
-typedef struct VBOXWDDM_QI_2D_2
-{
-    VBOXWDDM_QI hdr;
-    VBOXVHWACMD_QUERYINFO2 Info;
-} VBOXWDDM_QI_2D_2;
 
 /* submit cmd func */

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

@@ -13 +13 @@
 #include "../Helper.h"
 
-VBOXVHWACMD* vboxVhwaCtlCommandCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
-{
+#ifndef VBOXVHWA_WITH_SHGSMI
+# include <iprt/semaphore.h>
+# include <iprt/asm.h>
+#endif
+
+
+
+DECLINLINE(void) vboxVhwaHdrInit(VBOXVHWACMD* pHdr, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd)
+{
+    memset(pHdr, 0, sizeof(VBOXVHWACMD));
+    pHdr->iDisplay = srcId;
+    pHdr->rc = VERR_GENERAL_FAILURE;
+    pHdr->enmCmd = enmCmd;
+#ifndef VBOXVHWA_WITH_SHGSMI
+    pHdr->cRefs = 1;
+#endif
+}
+
+#ifdef VBOXVHWA_WITH_SHGSMI
+static int vboxVhwaCommandSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, HGSMIOFFSET offDr)
+{
+    VBoxHGSMIGuestWrite(pDevExt, offDr);
+    return VINF_SUCCESS;
+}
+#else
+DECLINLINE(void) vbvaVhwaCommandRelease(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
+{
+    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
+    Assert(cRefs < UINT32_MAX / 2);
+    if(!cRefs)
+    {
+        vboxHGSMIBufferFree(pDevExt, pCmd);
+    }
+}
+
+DECLINLINE(void) vbvaVhwaCommandRetain(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
+{
+    ASMAtomicIncU32(&pCmd->cRefs);
+}
+
+/* do not wait for completion */
+void vboxVhwaCommandSubmitAsynch(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext)
+{
+    pCmd->GuestVBVAReserved1 = (uintptr_t)pfnCompletion;
+    pCmd->GuestVBVAReserved2 = (uintptr_t)pContext;
+    vbvaVhwaCommandRetain(pDevExt, pCmd);
+
+    vboxHGSMIBufferSubmit(pDevExt, pCmd);
+
+    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
+            || ((pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
+                    && (pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)))
+    {
+        /* the command is completed */
+        pfnCompletion(pDevExt, pCmd, pContext);
+    }
+
+    vbvaVhwaCommandRelease(pDevExt, pCmd);
+}
+
+static DECLCALLBACK(void) vboxVhwaCompletionSetEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD * pCmd, void * pvContext)
+{
+    RTSemEventSignal((RTSEMEVENT)pvContext);
+}
+
+void vboxVhwaCommandSubmitAsynchByEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent)
+{
+    vboxVhwaCommandSubmitAsynch(pDevExt, pCmd, vboxVhwaCompletionSetEvent, hEvent);
+}
+#endif
+
+VBOXVHWACMD* vboxVhwaCommandCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
+{
+#ifdef VBOXVHWA_WITH_SHGSMI
     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap,
                               cbCmd + VBOXVHWACMD_HEADSIZE(),
                               HGSMI_CH_VBVA,
                               VBVA_VHWA_CMD);
+#else
+    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(pDevExt,
+                              cbCmd + VBOXVHWACMD_HEADSIZE(),
+                              HGSMI_CH_VBVA,
+                              VBVA_VHWA_CMD);
+#endif
     Assert(pHdr);
     if (!pHdr)
@@ -26 +104 @@
     else
     {
-        vboxVhwaInitHdr(pHdr, srcId, enmCmd);
+        vboxVhwaHdrInit(pHdr, srcId, enmCmd);
     }
 
@@ -32 +110 @@
 }
 
-void vboxVhwaCtlCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
-{
+void vboxVhwaCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
+{
+#ifdef VBOXVHWA_WITH_SHGSMI
     VBoxSHGSMICommandFree(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
-}
-
-static int vboxVhwaCtlCommandSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, HGSMIOFFSET offDr)
-{
-    VBoxHGSMIGuestWrite(pDevExt, offDr);
-    return VINF_SUCCESS;
-}
-
-int vboxVhwaCtlCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
-{
+#else
+    vbvaVhwaCommandRelease(pDevExt, pCmd);
+#endif
+}
+
+int vboxVhwaCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
+{
+#ifdef VBOXVHWA_WITH_SHGSMI
     const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
     Assert(pHdr);
@@ -56 +133 @@
             if (offCmd != HGSMIOFFSET_VOID)
             {
-                rc = vboxVhwaCtlCommandSubmitHgsmi(pDevExt, offCmd);
+                rc = vboxVhwaCommandSubmitHgsmi(pDevExt, offCmd);
                 AssertRC(rc);
                 if (RT_SUCCESS(rc))
@@ -74 +151 @@
         rc = VERR_INVALID_PARAMETER;
     return rc;
+#else
+    RTSEMEVENT hEvent;
+    int rc = RTSemEventCreate(&hEvent);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ;
+        vboxVhwaCommandSubmitAsynchByEvent(pDevExt, pCmd, hEvent);
+        rc = RTSemEventWait(hEvent, RT_INDEFINITE_WAIT);
+        AssertRC(rc);
+        if (RT_SUCCESS(rc))
+            RTSemEventDestroy(hEvent);
+    }
+    return rc;
+#endif
+}
+
+#ifndef VBOXVHWA_WITH_SHGSMI
+static DECLCALLBACK(void) vboxVhwaCompletionFreeCmd(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD * pCmd, void * pContext)
+{
+    vboxVhwaCommandFree(pDevExt, pCmd);
+}
+#endif
+
+void vboxVhwaCommandSubmitAsynchAndComplete(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
+{
+#ifdef VBOXVHWA_WITH_SHGSMI
+# error "port me"
+#else
+    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION;
+
+    vboxVhwaCommandSubmitAsynch(pDevExt, pCmd, vboxVhwaCompletionFreeCmd, NULL);
+#endif
 }
 
@@ -79 +189 @@
 {
     VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo);
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
 }
 
@@ -85 +195 @@
 {
     VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo);
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
 }
 
 VBOXVHWACMD_QUERYINFO1* vboxVHWAQueryHostInfo1(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
 {
-    VBOXVHWACMD* pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
     VBOXVHWACMD_QUERYINFO1 *pInfo1;
 
@@ -106 +216 @@
     pInfo1->u.in.guestVersion.reserved = VBOXVHWA_VERSION_RSV;
 
-    if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
+    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
     {
         if(RT_SUCCESS(pCmd->rc))
@@ -114 +224 @@
     }
 
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
     return NULL;
 }
@@ -120 +230 @@
 VBOXVHWACMD_QUERYINFO2* vboxVHWAQueryHostInfo2(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC)
 {
-    VBOXVHWACMD* pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC));
+    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC));
     VBOXVHWACMD_QUERYINFO2 *pInfo2;
     Assert(pCmd);
@@ -132 +242 @@
     pInfo2->numFourCC = numFourCC;
 
-    if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
+    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
     {
         if(RT_SUCCESS(pCmd->rc))
@@ -143 +253 @@
     }
 
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
     return NULL;
 }
@@ -152 +262 @@
     VBOXVHWACMD* pCmd;
 
-    pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
+    pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
     Assert(pCmd);
     if (!pCmd)
@@ -160 +270 @@
     }
 
-    if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
+    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
     {
         if(RT_SUCCESS(pCmd->rc))
@@ -168 +278 @@
     }
 
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
     return rc;
 }
@@ -177 +287 @@
     VBOXVHWACMD* pCmd;
 
-    pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
+    pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
     Assert(pCmd);
     if (!pCmd)
@@ -185 +295 @@
     }
 
-    if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
+    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
     {
         if(RT_SUCCESS(pCmd->rc))
@@ -193 +303 @@
     }
 
-    vboxVhwaCtlCommandFree(pDevExt, pCmd);
+    vboxVhwaCommandFree(pDevExt, pCmd);
     return rc;
 }
 
-void vboxVHWAInit(PDEVICE_EXTENSION pDevExt)
-{
-    VBOXVHWA_INFO *pSettings = &pDevExt->u.primary.Vhwa;
+static void vboxVHWAInitSrc(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
+{
+    Assert(srcId < pDevExt->cSources);
+    VBOXVHWA_INFO *pSettings = &pDevExt->aSources[srcId].Vhwa.Settings;
     memset (pSettings, 0, sizeof (VBOXVHWA_INFO));
 
-    VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVHWAQueryHostInfo1(pDevExt,
-            0 /*D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId*/);
+    VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVHWAQueryHostInfo1(pDevExt, srcId);
     if (pInfo1)
     {
         if (pInfo1->u.out.cfgFlags & VBOXVHWA_CFG_ENABLED)
         {
-            if (pInfo1->u.out.numOverlays)
+            if ((pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAY)
+                    && (pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAYSTRETCH)
+                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_OVERLAY)
+                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_FLIP)
+                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_LOCALVIDMEM)
+                    && pInfo1->u.out.numOverlays)
             {
-                pSettings->bEnabled = true;
+                pSettings->fFlags |= VBOXVHWA_F_ENABLED;
+
+                if (pInfo1->u.out.caps & VBOXVHWA_CAPS_COLORKEY)
+                {
+                    if (pInfo1->u.out.colorKeyCaps & VBOXVHWA_CKEYCAPS_SRCOVERLAY)
+                    {
+                        pSettings->fFlags |= VBOXVHWA_F_CKEY_SRC;
+                        /* todo: VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE ? */
+                    }
+
+                    if (pInfo1->u.out.colorKeyCaps & VBOXVHWA_CKEYCAPS_DESTOVERLAY)
+                    {
+                        pSettings->fFlags |= VBOXVHWA_F_CKEY_DST;
+                        /* todo: VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE ? */
+                    }
+                }
+
                 pSettings->cFormats = 0;
 
@@ -218 +349 @@
                 ++pSettings->cFormats;
 
-                if (pInfo1->u.out.numFourCC)
+                if (pInfo1->u.out.numFourCC
+                        && (pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAYFOURCC))
                 {
-                    VBOXVHWACMD_QUERYINFO2* pInfo2 = vboxVHWAQueryHostInfo2(pDevExt,
-                            0 /*D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId*/,
-                            pInfo1->u.out.numFourCC);
+                    VBOXVHWACMD_QUERYINFO2* pInfo2 = vboxVHWAQueryHostInfo2(pDevExt, srcId, pInfo1->u.out.numFourCC);
                     if (pInfo2)
                     {
@@ -238 +368 @@
     }
 }
+
+void vboxVHWAInit(PDEVICE_EXTENSION pDevExt)
+{
+    for (uint32_t i = 0; i < pDevExt->cSources; ++i)
+    {
+        vboxVHWAInitSrc(pDevExt, i);
+    }
+}

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

@@ -15 +15 @@
 #include <iprt/cdefs.h>
 
-/*
- * with wddm 2D commands are split into two categories:
- * 1. control commands: those that are not (and actually can not be)
- * handled.trasfered as DMA commands in terms of WDDM model
- * these are:
- *  VBOXVHWACMD_TYPE_QUERY_INFO1,
- *  VBOXVHWACMD_TYPE_QUERY_INFO2,
- *  VBOXVHWACMD_TYPE_ENABLE,
- *  VBOXVHWACMD_TYPE_DISABLE,
- * 2. DMA commands: all the rest are handled as DMA commands
- * (i.e. using vboxVdmaXxx API)
- * This is opaque to the host 2D frontend
- * */
-#define VBOXVHWA_MAX_FORMATS 64
-typedef struct VBOXVHWA_INFO
-{
-    bool bEnabled;
-    uint32_t cOverlaysSupported;
-    uint32_t cFormats;
-    D3DDDIFORMAT aFormats[VBOXVHWA_MAX_FORMATS];
-} VBOXVHWA_INFO;
-DECLINLINE(void) vboxVhwaInitHdr(VBOXVHWACMD* pHdr, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd)
-{
-    memset(pHdr, 0, sizeof(VBOXVHWACMD));
-    pHdr->iDisplay = srcId;
-    pHdr->rc = VERR_GENERAL_FAILURE;
-    pHdr->enmCmd = enmCmd;
-    /* no need for the cRefs since we're using SHGSMI that has its own ref counting */
-//    pHdr->cRefs = 1;
-}
-
-VBOXVHWACMD* vboxVhwaCtlCommandCreate(PDEVICE_EXTENSION pDevExt,
+VBOXVHWACMD* vboxVhwaCommandCreate(PDEVICE_EXTENSION pDevExt,
         D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId,
         VBOXVHWACMD_TYPE enmCmd,
         VBOXVHWACMD_LENGTH cbCmd);
 
-void vboxVhwaCtlCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
-int vboxVhwaCtlCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
-int vboxVhwaCtlCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
+void vboxVhwaCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
+int vboxVhwaCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
+int vboxVhwaCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
+void vboxVhwaCommandSubmitAsynchAndComplete(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd);
+
+#ifndef VBOXVHWA_WITH_SHGSMI
+typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD * pCmd, void * pContext);
+typedef FNVBOXVHWACMDCOMPLETION *PFNVBOXVHWACMDCOMPLETION;
+
+void vboxVhwaCommandSubmitAsynch(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext);
+void vboxVhwaCommandSubmitAsynchByEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent);
+#endif
+
 void vboxVHWAFreeHostInfo1(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD_QUERYINFO1* pInfo);
 void vboxVHWAFreeHostInfo2(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD_QUERYINFO2* pInfo);

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

@@ -1183 +1183 @@
     PAGED_CODE();
 
-    dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
+    dfprintf(("==> "__FUNCTION__ ", context(0x%x), Query type (%d)\n", hAdapter, pQueryAdapterInfo->Type));
     NTSTATUS Status = STATUS_SUCCESS;
     PDEVICE_EXTENSION pContext = (PDEVICE_EXTENSION)hAdapter;
@@ -1204 +1204 @@
             pCaps->InterruptMessageNumber = 0;
             pCaps->NumberOfSwizzlingRanges = 0;
-            /* @todo: need to adjust this for proper 2D Accel support */
-            pCaps->MaxOverlays = 0; /* ?? how much should we support? 32 */
+            pCaps->MaxOverlays = 0;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+            for (uint32_t i = 0; i < pContext->cSources; ++i)
+            {
+                if ( pContext->aSources[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
+                    pCaps->MaxOverlays += pContext->aSources[i].Vhwa.Settings.cOverlaysSupported;
+            }
+#endif
             pCaps->GammaRampCaps.Value = 0;
             pCaps->PresentationCaps.Value = 0;
@@ -1283 +1289 @@
         }
         case DXGKQAITYPE_UMDRIVERPRIVATE:
-            AssertBreakpoint();
-            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)
+            Assert (pQueryAdapterInfo->OutputDataSize >= sizeof (VBOXWDDM_QI));
+            if (pQueryAdapterInfo->OutputDataSize >= sizeof (VBOXWDDM_QI))
+            {
+                VBOXWDDM_QI * pQi = (VBOXWDDM_QI*)pQueryAdapterInfo->pOutputData;
+                memset (pQi, 0, sizeof (VBOXWDDM_QI));
+                pQi->u32Version = VBOXVIDEOIF_VERSION;
+                pQi->cInfos = pContext->cSources;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                for (uint32_t i = 0; i < pContext->cSources; ++i)
                 {
-#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;
+                    pQi->aInfos[i] = pContext->aSources[i].Vhwa.Settings;
+                }
 #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"));
+                drprintf((__FUNCTION__ ": buffer too small\n"));
                 Status = STATUS_BUFFER_TOO_SMALL;
             }

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

@@ -75 +75 @@
 
 
-
-
-
 typedef struct VBOXWDDM_ALLOCATION_SHAREDPRIMARYSURFACE
 {