VirtualBox

Changeset 30405 in vbox for trunk/src


Ignore:
Timestamp:
Jun 23, 2010 8:52:35 PM (15 years ago)
Author:
vboxsync
Message:

wddm/3d: basics for visible regions handling

Location:
trunk/src/VBox/Additions/WINNT
Files:
3 added
11 edited

Legend:

Unmodified
Added
Removed

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

    r29488 r30405  
    7676 endif
    7777VBoxDispD3D_TEMPLATE = VBOXGUESTR3DLL
    78 VBoxDispD3D_DEFS     = UNICODE _UNICODE
     78VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOXWDDM VBOXVDMA
     79ifdef VBOXWDDM_WITH_VBVA
     80VBoxDispD3D_DEFS    += VBOXWDDM_WITH_VBVA
     81endif
     82
    7983ifdef VBOX_WITH_VIDEOHWACCEL
    8084 VBoxDispD3D_DEFS   += VBOX_WITH_VIDEOHWACCEL
    … …  
    8387        wddm/VBoxDispD3D.cpp \
    8488    wddm/VBoxDispD3DIf.cpp \
     89    wddm/VBoxDispCm.cpp \
    8590        wddm/VBoxDispD3D.def \
    8691        wddm/VBoxDispD3D.rc

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

    r30346 r30405  
    1313 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1414 */
    15 #include <windows.h>
    16 #include <d3d9types.h>
    17 //#include <d3dtypes.h>
    18 #include <D3dumddi.h>
    19 #include <d3dhal.h>
    20 
    21 
    2215#include <iprt/initterm.h>
    2316#include <iprt/log.h>
    … …  
    2821#include <VBox/VBoxGuestLib.h>
    2922
     23#include "VBoxDispD3DCmn.h"
    3024#include "VBoxDispD3D.h"
    31 #include "VBoxDispD3DCmn.h"
    3225
    3326#ifdef VBOXWDDMDISP_DEBUG

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

    r30215 r30405  
    2020
    2121#include <iprt/cdefs.h>
     22#include <iprt/list.h>
    2223
    2324#define VBOXWDDMDISP_MAX_VERTEX_STREAMS 16
    … …  
    6061typedef struct VBOXWDDMDISP_CONTEXT
    6162{
     63    RTLISTNODE ListNode;
    6264    struct VBOXWDDMDISP_DEVICE *pDevice;
    6365    D3DDDICB_CREATECONTEXT ContextInfo;

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3DCmn.h

    r30133 r30405  
    2121#include <D3dumddi.h>
    2222#include <d3dhal.h>
    23 
    2423
    2524#include <iprt/initterm.h>

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk

    r29670 r30405  
    102102        wddm/VBoxVideoVdma.cpp \
    103103        wddm/VBoxVideoShgsmi.cpp \
     104        wddm/VBoxVideoCm.cpp \
    104105        wddm/VBoxVideoWddm.rc
    105106 ifdef VBOXWDDM_WITH_VBVA

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

    r30226 r30405  
    118118#include <VBox/VBoxVideo.h>
    119119#include "wddm/VBoxVideoIf.h"
     120#include "wddm/VBoxVideoShgsmi.h"
     121#include "wddm/VBoxVideoCm.h"
    120122#include "wddm/VBoxVideoWddm.h"
    121 #include "wddm/VBoxVideoShgsmi.h"
    122123#include "wddm/VBoxVideoVdma.h"
    123124#include "wddm/VBoxVideoVidPn.h"
    … …  
    298299   PDEVICE_OBJECT pPDO;
    299300
     301   VBOXVIDEOCM_MGR CmMgr;
     302   LIST_ENTRY ContextList3D;
     303   KSPIN_LOCK SynchLock;
     304
    300305   VBOXSHGSMILIST CtlList;
    301306   VBOXSHGSMILIST DmaCmdList;

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

    r30308 r30405  
    6262} VBOXWDDM_ALLOCINFO, *PVBOXWDDM_ALLOCINFO;
    6363
    64 //#define VBOXWDDM_ALLOCINFO_HEADSIZE() (sizeof (VBOXWDDM_ALLOCINFO))
    65 //#define VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(_s) (VBOXWDDM_ALLOCINFO_HEADSIZE() + (_s))
    66 //#define VBOXWDDM_ALLOCINFO_SIZE(_tCmd) (VBOXWDDM_ALLOCINFO_SIZE_FROMBODYSIZE(sizeof(_tCmd)))
    67 //#define VBOXWDDM_ALLOCINFO_BODY(_p, _t) ( (_t*)(((uint8_t*)(_p)) + VBOXWDDM_ALLOCINFO_HEADSIZE()) )
    68 //#define VBOXWDDM_ALLOCINFO_HEAD(_pb) ((VBOXWDDM_ALLOCINFO*)((uint8_t *)(_pb) - VBOXWDDM_ALLOCATION_HEADSIZE()))
    69 
    7064/* this resource is OpenResource'd rather than CreateResource'd */
    7165#define VBOXWDDM_RESOURCE_F_OPENNED      0x00000001
    … …  
    149143} VBOXWDDM_OVERLAYFLIP_INFO, *PVBOXWDDM_OVERLAYFLIP_INFO;
    150144
     145typedef struct VBOXWDDM_CREATECONTEXT_INFO
     146{
     147    /* we use uint64_t instead of HANDLE to ensure structure def is the same for both 32-bit and 64-bit
     148     * since x64 kernel driver can be called by 32-bit UMD */
     149    uint64_t hUmEvent;
     150    /* info to be passed to UMD notification to identify the context */
     151    uint64_t u64UmInfo;
     152} VBOXWDDM_CREATECONTEXT_INFO, *PVBOXWDDM_CREATECONTEXT_INFO;
     153
     154
     155typedef struct VBOXWDDM_RECTS_FLAFS
     156{
     157    union
     158    {
     159        struct
     160        {
     161            UINT bPositionRectValid : 1;
     162            UINT bVisibleRectsValid : 1;
     163            UINT bAddHiddenRectsValid : 1;
     164            UINT Reserved : 29;
     165        };
     166        uint32_t Value;
     167    };
     168} VBOXWDDM_RECTS_FLAFS, *PVBOXWDDM_RECTS_FLAFS;
     169
     170typedef struct VBOXWDDM_RECTS_INFO
     171{
     172    uint32_t cRects;
     173    RECT aRects[1];
     174} VBOXWDDM_RECTS_INFO, *PVBOXWDDM_RECTS_INFO;
     175
     176#define VBOXWDDM_RECTS_INFO_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXWDDM_RECTS_INFO, aRects[(_cRects)]))
     177#define VBOXWDDM_RECTS_INFO_SIZE(_pRects) (VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS((_pRects)->cRects))
     178
     179typedef struct VBOXVIDEOCM_CMD_HDR
     180{
     181    uint64_t u64UmData;
     182    uint32_t cbCmd;
     183    uint32_t u32CmdSpecific;
     184}VBOXVIDEOCM_CMD_HDR, *PVBOXVIDEOCM_CMD_HDR;
     185
     186typedef struct VBOXVIDEOCM_CMD_RECTS
     187{
     188    VBOXWDDM_RECTS_FLAFS fFlags;
     189    VBOXWDDM_RECTS_INFO RectsInfo;
     190} VBOXVIDEOCM_CMD_RECTS, *PVBOXVIDEOCM_CMD_RECTS;
     191
     192#define VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(_cRects) (RT_OFFSETOF(VBOXVIDEOCM_CMD_RECTS, RectsInfo.aRects[(_cRects)]))
     193#define VBOXVIDEOCM_CMD_RECTS_SIZE(_pCmd) (VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS((_pCmd)->cRects))
     194
     195typedef struct VBOXWDDM_GETVBOXVIDEOCMCMD_HDR
     196{
     197    uint32_t cbCmdsReturned;
     198    uint32_t cbRemainingCmds;
     199    uint32_t cbRemainingFirstCmd;
     200    uint32_t u32Reserved;
     201} VBOXWDDM_GETVBOXVIDEOCMCMD_HDR, *PVBOXWDDM_GETVBOXVIDEOCMCMD_HDR;
     202
     203#define VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_OFFSET() ((sizeof (VBOXWDDM_GETVBOXVIDEOCMCMD_HDR) + 7) & ~7)
     204#define VBOXWDDM_GETVBOXVIDEOCMCMD_DATA(_pHead, _t) ( (_t*)(((uint8_t*)(_pHead)) + VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_OFFSET()))
     205#define VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_SIZE(_s) ( (_s) < VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_OFFSET() ? 0 : (_s) - VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_OFFSET() )
     206#define VBOXWDDM_GETVBOXVIDEOCMCMD_SIZE(_cbData) ((_cbData) ? VBOXWDDM_GETVBOXVIDEOCMCMD_DATA_OFFSET() + (_cbData) : sizeof (VBOXWDDM_GETVBOXVIDEOCMCMD_HDR))
     207
    151208/* query info func */
    152209typedef struct VBOXWDDM_QI
    … …  
    158215
    159216/* submit cmd func */
    160 
    161 
    162 
    163217
    164218/* tooling */
    … …  
    244298}
    245299
     300DECLINLINE(bool) vboxWddmRectIntersection(const RECT *pRect1, const RECT *pRect2, RECT *pResult)
     301{
     302    if (pRect1->left < pRect2->left)
     303    {
     304        if (pRect1->right >= pRect2->left)
     305            pResult->left = pRect2->left;
     306        else
     307            return false;
     308    }
     309    else
     310    {
     311        if (pRect2->right >= pRect1->left)
     312            pResult->left = pRect1->left;
     313        else
     314            return false;
     315    }
     316
     317    pResult->right = RT_MIN(pRect1->right, pRect2->right);
     318
     319    if (pRect1->top < pRect2->top)
     320    {
     321        if (pRect1->bottom >= pRect2->top)
     322            pResult->top = pRect2->top;
     323        else
     324            return false;
     325    }
     326    else
     327    {
     328        if (pRect2->bottom >= pRect1->top)
     329            pResult->top = pRect1->top;
     330        else
     331            return false;
     332    }
     333
     334    pResult->bottom = RT_MIN(pRect1->bottom, pRect2->bottom);
     335
     336    return true;
     337}
     338
    246339DECLINLINE(void) vboxWddmDirtyRegionAddRect(PVBOXWDDM_DIRTYREGION pInfo, const RECT *pRect)
    247340{

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoShgsmi.h

    r29742 r30405  
    7070}
    7171
    72 DECLINLINE(void) vboxSHGSMICmdListDetach(PVBOXSHGSMILIST pList, PVBOXSHGSMILIST_ENTRY *ppFirst, PVBOXSHGSMILIST_ENTRY *ppLast)
     72DECLINLINE(void) vboxSHGSMIListDetach(PVBOXSHGSMILIST pList, PVBOXSHGSMILIST_ENTRY *ppFirst, PVBOXSHGSMILIST_ENTRY *ppLast)
    7373{
    7474    *ppFirst = pList->pFirst;
    … …  
    7979}
    8080
    81 DECLINLINE(void) vboxSHGSMICmdListDetach2List(PVBOXSHGSMILIST pList, PVBOXSHGSMILIST pDstList)
     81DECLINLINE(void) vboxSHGSMIListDetach2List(PVBOXSHGSMILIST pList, PVBOXSHGSMILIST pDstList)
    8282{
    83     vboxSHGSMICmdListDetach(pList, &pDstList->pFirst, &pDstList->pLast);
     83    vboxSHGSMIListDetach(pList, &pDstList->pFirst, &pDstList->pLast);
     84}
     85
     86DECLINLINE(void) vboxSHGSMIListDetachEntries(PVBOXSHGSMILIST pList, PVBOXSHGSMILIST_ENTRY pBeforeDetach, PVBOXSHGSMILIST_ENTRY pLast2Detach)
     87{
     88    if (pBeforeDetach)
     89    {
     90        pBeforeDetach->pNext = pLast2Detach->pNext;
     91        if (!pBeforeDetach->pNext)
     92            pList->pLast = pBeforeDetach;
     93    }
     94    else
     95    {
     96        pList->pFirst = pLast2Detach->pNext;
     97        if (!pList->pFirst)
     98            pList->pLast = NULL;
     99    }
     100    pLast2Detach->pNext = NULL;
    84101}
    85102

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

    r30346 r30405  
    3636{
    3737    ExFreePool(pvMem);
     38}
     39
     40DECLINLINE(void) vboxWddmDirtyRectsCalcIntersection(const RECT *pArea, const PVBOXWDDM_RECTS_INFO pRects, PVBOXWDDM_RECTS_INFO pResult)
     41{
     42    pResult->cRects = 0;
     43    for (uint32_t i = 0; i < pRects->cRects; ++i)
     44    {
     45        if (vboxWddmRectIntersection(pArea, &pRects->aRects[i], &pResult->aRects[pResult->cRects]))
     46        {
     47            ++pResult->cRects;
     48        }
     49    }
     50}
     51/**
     52 * @param pDevExt
     53 */
     54NTSTATUS vboxWddmDirtyRectsProcess(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_CONTEXT pContext, const RECT * pContextRect, const PVBOXWDDM_RECTS_INFO pRects)
     55{
     56    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
     57
     58    NTSTATUS Status = STATUS_SUCCESS;
     59    PVBOXVIDEOCM_CMD_RECTS pCmd = NULL;
     60    uint32_t cbCmd = VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pRects->cRects);
     61    KeAcquireSpinLockAtDpcLevel(&pDevExt->SynchLock);
     62    for (PLIST_ENTRY pCur = pDevExt->ContextList3D.Flink; pCur != &pDevExt->ContextList3D; pCur = pCur->Flink)
     63    {
     64        if (pCur != &pContext->ListEntry)
     65        {
     66            PVBOXWDDM_CONTEXT pCurContext = VBOXWDDMENTRY_2_CONTEXT(pCur);
     67            if (!pCmd)
     68            {
     69                pCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pCurContext->CmContext, cbCmd);
     70                Assert(pCmd);
     71                if (!pCmd)
     72                {
     73                    Status = STATUS_NO_MEMORY;
     74                    break;
     75                }
     76            }
     77            else
     78            {
     79                pCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdReinitForContext(pCmd, &pCurContext->CmContext);
     80            }
     81
     82            vboxWddmDirtyRectsCalcIntersection(&pContext->ViewRect, pRects, &pCmd->RectsInfo);
     83            if (pCmd->RectsInfo.cRects)
     84            {
     85                Assert(pCmd->fFlags.Value == 0);
     86                pCmd->fFlags.bAddHiddenRectsValid = 1;
     87                vboxVideoCmCmdSubmit(pCmd, VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pCmd->RectsInfo.cRects));
     88                pCmd = NULL;
     89            }
     90        }
     91        else
     92        {
     93            bool bRectShanged = (pContext->ViewRect.left != pContextRect->left
     94                    || pContext->ViewRect.top != pContextRect->top
     95                    || pContext->ViewRect.right != pContextRect->right
     96                    || pContext->ViewRect.bottom != pContextRect->bottom);
     97            PVBOXVIDEOCM_CMD_RECTS pDrCmd;
     98
     99            if (bRectShanged)
     100            {
     101                uint32_t cbDrCmd = VBOXVIDEOCM_CMD_RECTS_SIZE4CRECTS(pRects->cRects + 1);
     102                pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pContext->CmContext, cbDrCmd);
     103                Assert(pDrCmd);
     104                if (!pDrCmd)
     105                {
     106                    Status = STATUS_NO_MEMORY;
     107                    break;
     108                }
     109                pDrCmd->RectsInfo.cRects = pRects->cRects + 1;
     110            }
     111            else
     112            {
     113                if (pCmd)
     114                {
     115                    pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdReinitForContext(pCmd, &pContext->CmContext);
     116                    pCmd = NULL;
     117                }
     118                else
     119                {
     120                    pDrCmd = (PVBOXVIDEOCM_CMD_RECTS)vboxVideoCmCmdCreate(&pContext->CmContext, cbCmd);
     121                    Assert(pDrCmd);
     122                    if (!pDrCmd)
     123                    {
     124                        Status = STATUS_NO_MEMORY;
     125                        break;
     126                    }
     127                }
     128                pDrCmd->RectsInfo.cRects = pRects->cRects;
     129            }
     130
     131            Assert(pDrCmd->fFlags.Value == 0);
     132            RECT *pDirtyRect;
     133            if (bRectShanged)
     134            {
     135                pDrCmd->fFlags.bPositionRectValid = 1;
     136                pDrCmd->RectsInfo.aRects[0] = *pContextRect;
     137                pDirtyRect = &pDrCmd->RectsInfo.aRects[1];
     138            }
     139            else
     140                pDirtyRect = &pDrCmd->RectsInfo.aRects[0];
     141
     142            pDrCmd->fFlags.bVisibleRectsValid = 1;
     143            memcpy (pDirtyRect, pRects->aRects, sizeof (RECT) * pRects->cRects);
     144
     145            vboxVideoCmCmdSubmit(pDrCmd, VBOXVIDEOCM_SUBMITSIZE_DEFAULT);
     146        }
     147    }
     148    InsertHeadList(&pDevExt->ContextList3D, &pContext->ListEntry);
     149    KeReleaseSpinLockFromDpcLevel(&pDevExt->SynchLock);
     150
     151    if (pCmd)
     152        vboxVideoCmCmdRelease(pCmd);
     153
     154    return Status;
    38155}
    39156
    … …  
    651768                    vboxVhwaInit(pContext);
    652769#endif
     770                    vboxVideoCmInit(&pContext->CmMgr);
     771                    InitializeListHead(&pContext->ContextList3D);
     772                    KeInitializeSpinLock(&pContext->SynchLock);
    653773                }
    654774                else
    … …  
    696816    PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)MiniportDeviceContext;
    697817    NTSTATUS Status = STATUS_SUCCESS;
     818
     819    vboxVideoCmTerm(&pDevExt->CmMgr);
    698820
    699821    /* do everything we did on DxgkDdiStartDevice in the reverse order */
    … …  
    9681090    PVBOXWDDM_GETDPCDATA_CONTEXT pdc = (PVBOXWDDM_GETDPCDATA_CONTEXT)Context;
    9691091
    970     vboxSHGSMICmdListDetach2List(&pdc->pDevExt->CtlList, &pdc->data.CtlList);
    971     vboxSHGSMICmdListDetach2List(&pdc->pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
     1092    vboxSHGSMIListDetach2List(&pdc->pDevExt->CtlList, &pdc->data.CtlList);
     1093    vboxSHGSMIListDetach2List(&pdc->pDevExt->DmaCmdList, &pdc->data.DmaCmdList);
    9721094#ifdef VBOX_WITH_VIDEOHWACCEL
    973     vboxSHGSMICmdListDetach2List(&pdc->pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
     1095    vboxSHGSMIListDetach2List(&pdc->pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
    9741096#endif
    9751097    pdc->data.bNotifyDpc = pdc->pDevExt->bNotifyDxDpc;
    … …  
    25222644    NTSTATUS Status = STATUS_NOT_SUPPORTED;
    25232645    PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
     2646    Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE));
    25242647    if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE))
    25252648    {
    … …  
    25272650        switch (pEscapeHdr->escapeCode)
    25282651        {
     2652            case VBOXESC_GETVBOXVIDEOCMCMD:
     2653            {
     2654                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
     2655                Assert(pContext);
     2656                PVBOXWDDM_GETVBOXVIDEOCMCMD_HDR pHdr = VBOXDISPIFESCAPE_DATA(pEscapeHdr, VBOXWDDM_GETVBOXVIDEOCMCMD_HDR);
     2657                Status = vboxVideoCmEscape(&pContext->CmContext, pHdr, VBOXDISPIFESCAPE_DATA_SIZE(pEscape->PrivateDriverDataSize));
     2658                Assert(Status == STATUS_SUCCESS);
     2659                break;
     2660            }
    25292661            case VBOXESC_SETVISIBLEREGION:
    25302662            {
    … …  
    35593691                    Assert (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
    35603692#else
    3561                     Assert ((pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
    3562                             && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
    3563                             || (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
    3564                                     && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE));
     3693                    if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM)
     3694                    {
     3695                        Assert ((pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
     3696                                && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
     3697                                || (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
     3698                                        && pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE));
     3699                    }
    35653700#endif
    35663701                    if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
    35673702                            && pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
    35683703                    {
     3704                        Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
    35693705                        Assert(pDstAlloc->bAssigned);
    35703706                        Assert(pDstAlloc->bVisible);
    … …  
    38994035    NTSTATUS Status = STATUS_SUCCESS;
    39004036    PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
     4037    PDEVICE_EXTENSION pDevExt = pDevice->pAdapter;
    39014038    PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)vboxWddmMemAllocZero(sizeof (VBOXWDDM_CONTEXT));
    3902 
    3903     pContext->pDevice = pDevice;
    3904     pContext->hContext = pCreateContext->hContext;
    3905     pContext->EngineAffinity = pCreateContext->EngineAffinity;
    3906     pContext->NodeOrdinal = pCreateContext->NodeOrdinal;
    3907     if (pCreateContext->Flags.SystemContext)
    3908         pContext->enmType = VBOXWDDM_CONTEXT_TYPE_SYSTEM;
    3909 //    else
    3910 //    {
    3911 //        AssertBreakpoint(); /* we do not support custom contexts for now */
    3912 //        drprintf((__FUNCTION__ ", we do not support custom contexts for now, hDevice (0x%x)\n", hDevice));
    3913 //    }
    3914 
    3915     pCreateContext->hContext = pContext;
    3916     pCreateContext->ContextInfo.DmaBufferSize = VBOXWDDM_C_DMA_BUFFER_SIZE;
    3917     pCreateContext->ContextInfo.DmaBufferSegmentSet = 0;
    3918     pCreateContext->ContextInfo.DmaBufferPrivateDataSize = sizeof (VBOXWDDM_DMA_PRIVATE_DATA);
    3919     pCreateContext->ContextInfo.AllocationListSize = VBOXWDDM_C_ALLOC_LIST_SIZE;
    3920     pCreateContext->ContextInfo.PatchLocationListSize = VBOXWDDM_C_PATH_LOCATION_LIST_SIZE;
    3921 //#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7)
    3922 //# error port to Win7 DDI
    3923 //    //pCreateContext->ContextInfo.DmaBufferAllocationGroup = ???;
    3924 //#endif // DXGKDDI_INTERFACE_VERSION
     4039    Assert(pContext);
     4040    if (pContext)
     4041    {
     4042        InitializeListHead(&pContext->ListEntry);
     4043        pContext->pDevice = pDevice;
     4044        pContext->hContext = pCreateContext->hContext;
     4045        pContext->EngineAffinity = pCreateContext->EngineAffinity;
     4046        pContext->NodeOrdinal = pCreateContext->NodeOrdinal;
     4047        vboxVideoCmCtxInitEmpty(&pContext->CmContext);
     4048        if (pCreateContext->Flags.SystemContext)
     4049            pContext->enmType = VBOXWDDM_CONTEXT_TYPE_SYSTEM;
     4050        else if (pCreateContext->Flags.Value == 0)
     4051        {
     4052            Assert(pCreateContext->PrivateDriverDataSize == sizeof (VBOXWDDM_CREATECONTEXT_INFO));
     4053            Assert(pCreateContext->pPrivateDriverData);
     4054            if (pCreateContext->PrivateDriverDataSize == sizeof (VBOXWDDM_CREATECONTEXT_INFO))
     4055            {
     4056                pContext->enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D;
     4057                PVBOXWDDM_CREATECONTEXT_INFO pInfo = (PVBOXWDDM_CREATECONTEXT_INFO)pCreateContext->pPrivateDriverData;
     4058                Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->CmMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
     4059                Assert(Status == STATUS_SUCCESS);
     4060                if (Status == STATUS_SUCCESS)
     4061                {
     4062                    KIRQL OldIrql;
     4063                    KeAcquireSpinLock(&pDevExt->SynchLock, &OldIrql);
     4064                    InsertHeadList(&pDevExt->ContextList3D, &pContext->ListEntry);
     4065                    KeReleaseSpinLock(&pDevExt->SynchLock, OldIrql);
     4066                }
     4067            }
     4068            else
     4069            {
     4070                pContext->enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D;
     4071            }
     4072        }
     4073        else
     4074        {
     4075            AssertBreakpoint(); /* we do not support custom contexts for now */
     4076            drprintf((__FUNCTION__ ", we do not support custom contexts for now, hDevice (0x%x)\n", hDevice));
     4077        }
     4078
     4079        if (Status == STATUS_SUCCESS)
     4080        {
     4081            pCreateContext->hContext = pContext;
     4082            pCreateContext->ContextInfo.DmaBufferSize = VBOXWDDM_C_DMA_BUFFER_SIZE;
     4083            pCreateContext->ContextInfo.DmaBufferSegmentSet = 0;
     4084            pCreateContext->ContextInfo.DmaBufferPrivateDataSize = sizeof (VBOXWDDM_DMA_PRIVATE_DATA);
     4085            pCreateContext->ContextInfo.AllocationListSize = VBOXWDDM_C_ALLOC_LIST_SIZE;
     4086            pCreateContext->ContextInfo.PatchLocationListSize = VBOXWDDM_C_PATH_LOCATION_LIST_SIZE;
     4087        //#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7)
     4088        //# error port to Win7 DDI
     4089        //    //pCreateContext->ContextInfo.DmaBufferAllocationGroup = ???;
     4090        //#endif // DXGKDDI_INTERFACE_VERSION
     4091        }
     4092        else
     4093            vboxWddmMemFree(pContext);
     4094    }
     4095    else
     4096        Status = STATUS_NO_MEMORY;
    39254097
    39264098    dfprintf(("<== "__FUNCTION__ ", hDevice(0x%x)\n", hDevice));
    … …  
    39364108    dfprintf(("==> "__FUNCTION__ ", hContext(0x%x)\n", hContext));
    39374109    vboxVDbgBreakFv();
    3938     vboxWddmMemFree(hContext);
     4110    PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)hContext;
     4111    PDEVICE_EXTENSION pDevExt = pContext->pDevice->pAdapter;
     4112    if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
     4113    {
     4114        KIRQL OldIrql;
     4115        KeAcquireSpinLock(&pDevExt->SynchLock, &OldIrql);
     4116        RemoveEntryList(&pContext->ListEntry);
     4117        KeReleaseSpinLock(&pDevExt->SynchLock, OldIrql);
     4118    }
     4119
     4120    NTSTATUS Status = vboxVideoCmCtxRemove(&pContext->pDevice->pAdapter->CmMgr, &pContext->CmContext);
     4121    Assert(Status == STATUS_SUCCESS);
     4122    if (Status == STATUS_SUCCESS)
     4123        vboxWddmMemFree(pContext);
     4124
    39394125    dfprintf(("<== "__FUNCTION__ ", hContext(0x%x)\n", hContext));
    3940     return STATUS_SUCCESS;
     4126
     4127    return Status;
    39414128}
    39424129

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

    r30308 r30405  
    112112{
    113113    VBOXWDDM_CONTEXT_TYPE_UNDEFINED = 0,
    114     VBOXWDDM_CONTEXT_TYPE_SYSTEM
     114    VBOXWDDM_CONTEXT_TYPE_SYSTEM,
     115    VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D,
     116    VBOXWDDM_CONTEXT_TYPE_CUSTOM_2D
    115117} VBOXWDDM_CONTEXT_TYPE;
    116118
    117119typedef struct VBOXWDDM_CONTEXT
    118120{
     121    LIST_ENTRY ListEntry;
    119122    struct VBOXWDDM_DEVICE * pDevice;
    120123    HANDLE hContext;
    … …  
    123126    UINT  EngineAffinity;
    124127    UINT uLastCompletedCmdFenceId;
     128    RECT ViewRect;
     129    VBOXVIDEOCM_CTX CmContext;
    125130} VBOXWDDM_CONTEXT, *PVBOXWDDM_CONTEXT;
     131
     132#define VBOXWDDMENTRY_2_CONTEXT(_pE) ((PVBOXWDDM_CONTEXT)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_CONTEXT, ListEntry)))
    126133
    127134typedef struct VBOXWDDM_DMA_PRIVATE_DATA

  • trunk/src/VBox/Additions/WINNT/include/VBoxDisplay.h

    r28800 r30405  
    2020#ifdef VBOXWDDM
    2121# define VBOXESC_REINITVIDEOMODES           0xABCD9003
     22# define VBOXESC_GETVBOXVIDEOCMCMD          0xABCD9004
    2223
    2324typedef struct
    … …  
    3637
    3738#define VBOXWDDM_RECOMMENDVIDPN_SIZE(_c) (RT_OFFSETOF(VBOXWDDM_RECOMMENDVIDPN, aScreenInfos[_c]))
     39
    3840#endif /* #ifdef VBOXWDDM */
    3941
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette