VirtualBox

Ignore:
Timestamp:
Oct 4, 2010 11:14:12 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
66372
Message:

wddm/3d: chromium over hgsmi transport fixing & perf measurement

Location:
trunk/src/VBox/Additions/WINNT/Graphics
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r32877 r32889  
    8888 VBoxDispD3D_DEFS   += VBOX_WDDMDISP_WITH_PROFILE
    8989endif
     90ifdef VBOXWDDM_TEST_UHGSMI
     91 VBoxDispD3D_DEFS   += VBOXWDDM_TEST_UHGSMI
     92endif
    9093VBoxDispD3D_SOURCES  = \
    9194        wddm/VBoxDispD3D.cpp \

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

    r32877 r32889  
    53645364    return hr;
    53655365}
     5366
     5367#ifdef VBOXWDDM_TEST_UHGSMI
     5368int vboxUhgsmiTst(PVBOXUHGSMI pUhgsmi, uint32_t cbBuf, uint32_t cNumCals, uint64_t * pTimeMs);
     5369#endif
     5370
    53665371static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
    53675372{
    … …  
    53745379    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
    53755380    {
     5381#ifdef VBOXWDDM_TEST_UHGSMI
     5382        {
     5383            Assert(0);
     5384            static uint32_t cCals = 10000;
     5385            static uint32_t cbData = 8 * 1024 * 1024;
     5386            uint64_t TimeMs;
     5387            int rc = vboxUhgsmiTst(&pDevice->Uhgsmi.Base, cbData, cCals, &TimeMs);
     5388            uint32_t cCPS = (((uint64_t)cCals) * 1000ULL)/TimeMs;
     5389            Assert(0);
     5390            vboxVDbgDoMpPrintF(pDevice, "Time : %I64u ms, calls: %d, cps: %d\n", TimeMs, cCals, cCPS);
     5391        }
     5392#endif
    53765393#if 1
    53775394        PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
    … …  
    71227139                    && !pCreateData->PatchLocationListSize)
    71237140            {
    7124                 hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
     7141                hr = vboxUhgsmiD3DInit(&pDevice->Uhgsmi, pDevice);
    71257142                Assert(hr == S_OK);
    71267143                if (hr == S_OK)
    71277144                {
    7128 #ifdef VBOXDISP_EARLYCREATEDEVICE
    7129                     PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(2);
    7130                     Assert(pRc);
    7131                     if (pRc)
     7145                    hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
     7146                    Assert(hr == S_OK);
     7147                    if (hr == S_OK)
    71327148                    {
    7133                         D3DPRESENT_PARAMETERS params;
    7134                         memset(&params, 0, sizeof (params));
    7135 //                        params.BackBufferWidth = 640;
    7136 //                        params.BackBufferHeight = 480;
    7137                         params.BackBufferWidth = 0x400;
    7138                         params.BackBufferHeight = 0x300;
    7139                         params.BackBufferFormat = D3DFMT_A8R8G8B8;
    7140 //                        params.BackBufferCount = 0;
    7141                         params.BackBufferCount = 1;
    7142                         params.MultiSampleType = D3DMULTISAMPLE_NONE;
    7143                         params.SwapEffect = D3DSWAPEFFECT_DISCARD;
    7144     //                    params.hDeviceWindow = hWnd;
    7145                                     /* @todo: it seems there should be a way to detect this correctly since
    7146                                      * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
    7147                         params.Windowed = TRUE;
    7148                         //            params.EnableAutoDepthStencil = FALSE;
    7149                         //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
    7150                         //            params.Flags;
    7151                         //            params.FullScreen_RefreshRateInHz;
    7152                         //            params.FullScreen_PresentationInterval;
    7153 
    7154                         hr = vboxWddmD3DDeviceCreate(pDevice, 0, pRc, &params, TRUE /*BOOL bLockable*/);
    7155                         Assert(hr == S_OK);
    7156                         if (hr == S_OK)
    7157                             break;
    7158                         vboxResourceFree(pRc);
     7149    #ifdef VBOXDISP_EARLYCREATEDEVICE
     7150                        PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(2);
     7151                        Assert(pRc);
     7152                        if (pRc)
     7153                        {
     7154                            D3DPRESENT_PARAMETERS params;
     7155                            memset(&params, 0, sizeof (params));
     7156    //                        params.BackBufferWidth = 640;
     7157    //                        params.BackBufferHeight = 480;
     7158                            params.BackBufferWidth = 0x400;
     7159                            params.BackBufferHeight = 0x300;
     7160                            params.BackBufferFormat = D3DFMT_A8R8G8B8;
     7161    //                        params.BackBufferCount = 0;
     7162                            params.BackBufferCount = 1;
     7163                            params.MultiSampleType = D3DMULTISAMPLE_NONE;
     7164                            params.SwapEffect = D3DSWAPEFFECT_DISCARD;
     7165        //                    params.hDeviceWindow = hWnd;
     7166                                        /* @todo: it seems there should be a way to detect this correctly since
     7167                                         * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
     7168                            params.Windowed = TRUE;
     7169                            //            params.EnableAutoDepthStencil = FALSE;
     7170                            //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
     7171                            //            params.Flags;
     7172                            //            params.FullScreen_RefreshRateInHz;
     7173                            //            params.FullScreen_PresentationInterval;
     7174
     7175                            hr = vboxWddmD3DDeviceCreate(pDevice, 0, pRc, &params, TRUE /*BOOL bLockable*/);
     7176                            Assert(hr == S_OK);
     7177                            if (hr == S_OK)
     7178                                break;
     7179                            vboxResourceFree(pRc);
     7180                        }
     7181                        else
     7182                        {
     7183                            hr = E_OUTOFMEMORY;
     7184                        }
     7185    #else
     7186    //# define VBOXDISP_TEST_SWAPCHAIN
     7187    # ifdef VBOXDISP_TEST_SWAPCHAIN
     7188                        VBOXDISP_D3DEV(pDevice);
     7189    # endif
     7190                        break;
     7191    #endif
     7192
     7193                        HRESULT tmpHr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
     7194                        Assert(tmpHr == S_OK);
    71597195                    }
    7160                     else
    7161                     {
    7162                         hr = E_OUTOFMEMORY;
    7163                     }
    7164 #else
    7165 //# define VBOXDISP_TEST_SWAPCHAIN
    7166 # ifdef VBOXDISP_TEST_SWAPCHAIN
    7167                     VBOXDISP_D3DEV(pDevice);
    7168 # endif
    7169                     break;
    7170 #endif
    7171 
    7172                     HRESULT tmpHr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
    7173                     Assert(tmpHr == S_OK);
    71747196                }
    71757197            }

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

    r32697 r32889  
    1818#include "VBoxDispD3DIf.h"
    1919#include "../../Miniport/wddm/VBoxVideoIf.h"
     20#include "VBoxUhgsmiDisp.h"
    2021
    2122#include <iprt/cdefs.h>
    … …  
    177178    D3DVIEWPORT9 ViewPort;
    178179    VBOXWDDMDISP_CONTEXT DefaultContext;
     180    VBOXUHGSMI_PRIVATE_D3D Uhgsmi;
    179181
    180182    CRITICAL_SECTION DirtyAllocListLock;

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

    r32739 r32889  
    3333#include "../../Miniport/wddm/VBoxVideoIf.h"
    3434#include "VBoxDispCm.h"
     35#include "VBoxUhgsmiDisp.h"
    3536#include "VBoxDispD3D.h"
    3637
    … …  
    4142#endif
    4243
    43 #if defined(VBOXWDDMDISP_DEBUG) || defined(VBOX_WDDMDISP_WITH_PROFILE)
     44#if defined(VBOXWDDMDISP_DEBUG) || defined(VBOX_WDDMDISP_WITH_PROFILE) || defined(VBOXWDDM_TEST_UHGSMI)
    4445# define VBOXWDDMDISP_DEBUG_PRINT
    4546#endif

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

    r30515 r32889  
    1616
    1717#include <iprt/thread.h>
     18#include <iprt/err.h>
    1819
    1920#include "VBoxDispD3DCmn.h"
     21
     22#include "VBoxDispProfile.h"
    2023
    2124static RTTHREAD g_VBoxDispMpTstThread;
    … …  
    143146}
    144147
     148int vboxUhgsmiTst(PVBOXUHGSMI pUhgsmi, uint32_t cbBuf, uint32_t cNumCals, uint64_t * pTimeMs)
     149{
     150    PVBOXUHGSMI_BUFFER pBuf;
     151    int rc = pUhgsmi->pfnBufferCreate(pUhgsmi, cbBuf, VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT, NULL, &pBuf);
     152    AssertRC(rc);
     153    if (RT_SUCCESS(rc))
     154    {
     155        uint64_t TimeMs = VBOXDISPPROFILE_GET_TIME_MILLI();
     156        do
     157        {
     158            VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
     159            fFlags.Value = 0;
     160            fFlags.bLockEntire = 1;
     161            fFlags.bDiscard = 1;
     162
     163            void *pvLock;
     164            rc = pBuf->pfnLock(pBuf, 0, cbBuf, fFlags, &pvLock);
     165            AssertRC(rc);
     166            if (!RT_SUCCESS(rc))
     167                break;
     168
     169            rc = pBuf->pfnUnlock(pBuf);
     170            AssertRC(rc);
     171            if (!RT_SUCCESS(rc))
     172                break;
     173
     174            VBOXUHGSMI_BUFFER_SUBMIT SubmitData;
     175            SubmitData.pBuf = pBuf;
     176            SubmitData.fFlags.Value = 0;
     177            SubmitData.fFlags.bDoNotRetire = 1;
     178            SubmitData.fFlags.bEntireBuffer = 1;
     179
     180            rc = pUhgsmi->pfnBufferSubmitAsynch(pUhgsmi, &SubmitData, 1);
     181            AssertRC(rc);
     182            if (!RT_SUCCESS(rc))
     183                break;
     184
     185            DWORD dw = WaitForSingleObject(pBuf->hSynch, INFINITE);
     186            Assert(dw == WAIT_OBJECT_0);
     187            if (dw)
     188                break;
     189        } while (--cNumCals);
     190
     191        TimeMs = VBOXDISPPROFILE_GET_TIME_MILLI() - TimeMs;
     192        *pTimeMs = TimeMs;
     193
     194        pBuf->pfnDestroy(pBuf);
     195    }
     196    return rc;
     197}

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

    r32877 r32889  
    1313 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1414 */
    15 #include "VBoxUhgsmiDisp.h"
     15#include "VBoxDispD3DCmn.h"
    1616
    1717#include <iprt/mem.h>
    … …  
    5454{
    5555    PVBOXUHGSMI_BUFFER_PRIVATE_D3D pBuffer = VBOXUHGSMID3D_GET_BUFFER(pBuf);
    56     if (!cbLock)
    57     {
    58         Assert(0);
    59         return VERR_INVALID_PARAMETER;
    60     }
    61     if (offLock + cbLock > pBuf->cbBuffer)
    62     {
    63         Assert(0);
    64         return VERR_INVALID_PARAMETER;
    65     }
    66     uint32_t iFirstPage = offLock >> 0x1000;
    67     uint32_t iAfterLastPage = (cbLock + 0xfff) >> 0x1000;
    68     uint32_t cPages = iAfterLastPage - iFirstPage;
    69     uint32_t cBufPages = pBuf->cbBuffer >> 0x1000;
    70     Assert(cPages <= (cBufPages));
    7156    D3DDDICB_LOCK DdiLock;
    7257    DdiLock.hAllocation = pBuffer->hAllocation;
    7358    DdiLock.PrivateDriverData = 0;
    74     if (cPages == cBufPages)
    75     {
    76         DdiLock.NumPages = 0;
    77         DdiLock.pPages = NULL;
     59
     60    if (fFlags.bLockEntire)
     61    {
     62        offLock = 0;
    7863        DdiLock.Flags.Value = 0;
    7964        DdiLock.Flags.LockEntire = 1;
    … …  
    8166    else
    8267    {
    83         DdiLock.NumPages = cPages;
    84         DdiLock.pPages = pBuffer->aLockPageIndices;
    85         DdiLock.Flags.Value = 0;
    86         for (UINT i = 0, j = iFirstPage; i < cPages; ++i, ++j)
    87         {
    88             pBuffer->aLockPageIndices[i] = j;
    89         }
     68        if (!cbLock)
     69        {
     70            Assert(0);
     71            return VERR_INVALID_PARAMETER;
     72        }
     73        if (offLock + cbLock > pBuf->cbBuffer)
     74        {
     75            Assert(0);
     76            return VERR_INVALID_PARAMETER;
     77        }
     78
     79        uint32_t iFirstPage = offLock >> 0x1000;
     80        uint32_t iAfterLastPage = (cbLock + 0xfff) >> 0x1000;
     81        uint32_t cPages = iAfterLastPage - iFirstPage;
     82        uint32_t cBufPages = pBuf->cbBuffer >> 0x1000;
     83        Assert(cPages <= (cBufPages));
     84
     85        if (cPages == cBufPages)
     86        {
     87            DdiLock.NumPages = 0;
     88            DdiLock.pPages = NULL;
     89            DdiLock.Flags.Value = 0;
     90            DdiLock.Flags.LockEntire = 1;
     91        }
     92        else
     93        {
     94            DdiLock.NumPages = cPages;
     95            DdiLock.pPages = pBuffer->aLockPageIndices;
     96            DdiLock.Flags.Value = 0;
     97            for (UINT i = 0, j = iFirstPage; i < cPages; ++i, ++j)
     98            {
     99                pBuffer->aLockPageIndices[i] = j;
     100            }
     101        }
     102
    90103    }
    91104    DdiLock.pData = NULL;
    … …  
    93106    DdiLock.Flags.WriteOnly = fFlags.bWriteOnly;
    94107    DdiLock.Flags.DonotWait = fFlags.bDonotWait;
    95     DdiLock.Flags.Discard = fFlags.bDiscard;
     108//    DdiLock.Flags.Discard = fFlags.bDiscard;
    96109
    97110    HRESULT hr = pBuffer->pDevice->RtCallbacks.pfnLockCb(pBuffer->pDevice->hDevice, &DdiLock);
    … …  
    99112    if (hr == S_OK)
    100113    {
    101         *pvLock = (void*)(((uint8_t*)DdiLock.pPages) + (offLock & 0xfff));
     114        *pvLock = (void*)(((uint8_t*)DdiLock.pData) + (offLock & 0xfff));
    102115        return VINF_SUCCESS;
    103116    }
    … …  
    217230            pBuf->pDevice = pPrivate->pDevice;
    218231            pBuf->hAllocation = Buf.DdiAllocInfo.hAllocation;
     232
     233            *ppBuf = &pBuf->Base;
     234
    219235            return VINF_SUCCESS;
    220236        }
    … …  
    264280        pAllocationList->DoNotRetireInstance = pBufInfo->fFlags.bDoNotRetire;
    265281        pBufSubmInfo->fSubFlags = pBufInfo->fFlags;
    266         pBufSubmInfo->offData = pBufInfo->offData;
    267         pBufSubmInfo->cbData = pBufInfo->cbData;
     282        if (pBufInfo->fFlags.bEntireBuffer)
     283        {
     284            pBufSubmInfo->offData = 0;
     285            pBufSubmInfo->cbData = pBuffer->Base.cbBuffer;
     286        }
     287        else
     288        {
     289            pBufSubmInfo->offData = pBufInfo->offData;
     290            pBufSubmInfo->cbData = pBufInfo->cbData;
     291        }
    268292
    269293        ++pAllocationList;

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

    r32877 r32889  
    2222{
    2323    VBOXUHGSMI Base;
    24     PVBOXWDDMDISP_DEVICE pDevice;
     24    struct VBOXWDDMDISP_DEVICE *pDevice;
    2525} VBOXUHGSMI_PRIVATE_D3D, *PVBOXUHGSMI_PRIVATE_D3D;
    2626
    27 HRESULT vboxUhgsmiD3DInit(PVBOXUHGSMI_PRIVATE_D3D pHgsmi, PVBOXWDDMDISP_DEVICE pDevice);
     27HRESULT vboxUhgsmiD3DInit(PVBOXUHGSMI_PRIVATE_D3D pHgsmi, struct VBOXWDDMDISP_DEVICE *pDevice);
    2828#endif /* #ifndef ___VBoxUhgsmiDisp_h__ */

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

    r32877 r32889  
    9090  endif
    9191 endif
    92  ifdef VBOXVDMA_WITH_VDMA
    93   VBoxVideoWddm_DEFS     += VBOXVDMA_WITH_VDMA
     92 ifdef VBOX_WITH_VDMA
     93  VBoxVideoWddm_DEFS     += VBOX_WITH_VDMA
    9494 endif
    9595 ifdef DEBUG_misha

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

    r32876 r32889  
    336336   VBOXSHGSMILIST VhwaCmdList;
    337337#endif
    338    BOOL bSetNotifyDxDpc;
     338//   BOOL bSetNotifyDxDpc;
    339339   BOOL bNotifyDxDpc;
    340340

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

    r32877 r32889  
    3434        struct
    3535        {
    36             uint32_t bReadOnly  : 1;
    37             uint32_t bWriteOnly : 1;
    38             uint32_t bDonotWait : 1;
    39             uint32_t bDiscard   : 1;
    40             uint32_t Reserved   : 28;
     36            uint32_t bReadOnly   : 1;
     37            uint32_t bWriteOnly  : 1;
     38            uint32_t bDonotWait  : 1;
     39            uint32_t bDiscard    : 1;
     40            uint32_t bLockEntire : 1;
     41            uint32_t Reserved    : 27;
    4142        };
    4243        uint32_t Value;
    … …  
    5455            uint32_t bDoNotRetire           : 1; /* <- the buffer will be used in a subsequent command */
    5556            uint32_t bDoNotSignalCompletion : 1; /* <- do not signal notification object on completion for this alloc */
    56             uint32_t Reserved               : 28;
     57            uint32_t bEntireBuffer          : 1; /* <- do not signal notification object on completion for this alloc */
     58            uint32_t Reserved               : 27;
    5759        };
    5860        uint32_t Value;

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

    r32766 r32889  
    693693NTSTATUS vboxWddmDisplaySettingsQueryPos(IN PDEVICE_EXTENSION pDeviceExtension, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, POINT * pPos)
    694694{
     695    Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
    695696    HANDLE hKey;
    696697    NTSTATUS Status = vboxWddmRegOpenDisplaySettingsKey(pDeviceExtension, VidPnSourceId, &hKey);

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

    r32877 r32889  
    10021002static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
    10031003{
    1004     VBoxHGSMIGuestWrite(pDevExt, offDr);
     1004    VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(pDevExt), offDr);
    10051005    return VINF_SUCCESS;
    10061006}
    … …  
    10121012    int rc = VINF_SUCCESS;
    10131013
    1014     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1014    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    10151015    if (pCmd)
    10161016    {
    … …  
    10191019        pCmd->i32Result = VERR_NOT_SUPPORTED;
    10201020
    1021         const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
     1021        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10221022        Assert(pHdr);
    10231023        if (pHdr)
    … …  
    10251025            do
    10261026            {
    1027                 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1027                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10281028                Assert(offCmd != HGSMIOFFSET_VOID);
    10291029                if (offCmd != HGSMIOFFSET_VOID)
    … …  
    10331033                    if (RT_SUCCESS(rc))
    10341034                    {
    1035                         rc = VBoxSHGSMICommandDoneSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1035                        rc = VBoxSHGSMICommandDoneSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10361036                        AssertRC(rc);
    10371037                        if (RT_SUCCESS(rc))
    … …  
    10461046                    rc = VERR_INVALID_PARAMETER;
    10471047                /* fail to submit, cancel it */
    1048                 VBoxSHGSMICommandCancelSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1048                VBoxSHGSMICommandCancelSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10491049            } while (0);
    10501050        }
    10511051
    1052         VBoxSHGSMICommandFree (&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
     1052        VBoxSHGSMICommandFree (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10531053    }
    10541054    else
    … …  
    12471247    }
    12481248
    1249     vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType);
     1249    if (vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType))
     1250    {
     1251        pDevExt->bNotifyDxDpc = TRUE;
     1252    }
    12501253
    12511254    /* inform SHGSMI we DO NOT want to be called at DPC later */

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

    r32877 r32889  
    7979}
    8080
     81DECLINLINE(BOOLEAN) vboxVdmaDdiCmdIsCompletedListEmptyIsr(PVBOXVDMADDI_CMD_QUEUE pQueue)
     82{
     83    return IsListEmpty(&pQueue->DpcCmdQueue);
     84}
     85
    8186#define VBOXVDMADDI_CMD_FROM_ENTRY(_pEntry) ((PVBOXVDMADDI_CMD)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXVDMADDI_CMD, QueueEntry)))
    8287

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

    r32877 r32889  
    214214     * Set the current mode into the hardware.
    215215     */
    216     NTSTATUS Status= vboxWddmDisplaySettingsQueryPos(pDevExt, VidPnSourceId, &pSource->VScreenPos);
    217     Assert(Status == STATUS_SUCCESS);
    218     Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation);
     216//    NTSTATUS Status= vboxWddmDisplaySettingsQueryPos(pDevExt, VidPnSourceId, &pSource->VScreenPos);
     217//    Assert(Status == STATUS_SUCCESS);
     218    NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation);
    219219    Assert(Status == STATUS_SUCCESS);
    220220    if (Status == STATUS_SUCCESS)
    … …  
    886886        }
    887887
    888         if (pDevExt->bSetNotifyDxDpc)
    889         {
    890             Assert(bNeedDpc == TRUE);
    891             pDevExt->bNotifyDxDpc = TRUE;
    892             pDevExt->bSetNotifyDxDpc = FALSE;
     888        if (pDevExt->bNotifyDxDpc)
     889        {
     890//            Assert(bNeedDpc == TRUE);
     891//            pDevExt->bNotifyDxDpc = TRUE;
     892//            pDevExt->bSetNotifyDxDpc = FALSE;
    893893            bNeedDpc = TRUE;
    894894        }
    … …  
    14421442//        }
    14431443//#endif
     1444        case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
     1445        {
     1446            ObDereferenceObject(pAllocation->pSynchEvent);
     1447            break;
     1448        }
    14441449        default:
    14451450            break;
    … …  
    14721477        if (pAllocation)
    14731478        {
    1474             pAllocation->enmType = pAllocInfo->enmType;
    1475             pAllocation->fRcFlags = pAllocInfo->fFlags;
    1476             pAllocation->offVram = VBOXVIDEOOFFSET_VOID;
    1477             pAllocation->SurfDesc = pAllocInfo->SurfDesc;
    1478             pAllocation->bVisible = FALSE;
    1479             pAllocation->bAssigned = FALSE;
    1480 
    14811479            pAllocationInfo->pPrivateDriverData = NULL;
    14821480            pAllocationInfo->PrivateDriverDataSize = 0;
    14831481            pAllocationInfo->Alignment = 0;
    1484             pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
    14851482            pAllocationInfo->PitchAlignedSize = 0;
    14861483            pAllocationInfo->HintedBank.Value = 0;
    … …  
    14951492            pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL;
    14961493
     1494            pAllocation->enmType = pAllocInfo->enmType;
     1495            pAllocation->offVram = VBOXVIDEOOFFSET_VOID;
     1496            pAllocation->bVisible = FALSE;
     1497            pAllocation->bAssigned = FALSE;
     1498
    14971499            switch (pAllocInfo->enmType)
    14981500            {
    14991501                case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
     1502                case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
     1503                case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
     1504                case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
     1505                {
     1506                    pAllocation->fRcFlags = pAllocInfo->fFlags;
     1507                    pAllocation->SurfDesc = pAllocInfo->SurfDesc;
     1508
     1509                    pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
     1510
     1511                    switch (pAllocInfo->enmType)
     1512                    {
     1513                        case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
    15001514#if 0 //defined(VBOXWDDM_RENDER_FROM_SHADOW)
    1501                     pAllocationInfo->SupportedReadSegmentSet = 2;
    1502                     pAllocationInfo->SupportedWriteSegmentSet = 2;
     1515                            pAllocationInfo->SupportedReadSegmentSet = 2;
     1516                            pAllocationInfo->SupportedWriteSegmentSet = 2;
    15031517#endif
    15041518#ifndef VBOXWDDM_RENDER_FROM_SHADOW
    1505                     pAllocationInfo->Flags.CpuVisible = 1;
     1519                            pAllocationInfo->Flags.CpuVisible = 1;
    15061520#endif
    1507                     break;
    1508                 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    1509 //                    Assert(pResource);
    1510 //                    if (pResource)
    1511                     {
    1512 //                        Assert(pResource->cAllocations);
    1513 //                        if (pResource->cAllocations)
    1514                         {
     1521                            break;
     1522                        case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    15151523#ifdef VBOX_WITH_VIDEOHWACCEL
    15161524                            if (pAllocInfo->fFlags.Overlay)
    … …  
    15441552                                }
    15451553                            }
    1546                         }
    1547 //                        else
    1548 //                            Status = STATUS_INVALID_PARAMETER;
     1554                            break;
     1555                        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
     1556                        case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
     1557                            pAllocationInfo->Flags.CpuVisible = 1;
     1558                            break;
     1559                    }
     1560
     1561                    if (Status == STATUS_SUCCESS)
     1562                    {
     1563                        pAllocation->UsageHint.Version = 0;
     1564                        pAllocation->UsageHint.v1.Flags.Value = 0;
     1565                        pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
     1566                        pAllocation->UsageHint.v1.SwizzledFormat = 0;
     1567                        pAllocation->UsageHint.v1.ByteOffset = 0;
     1568                        pAllocation->UsageHint.v1.Width = pAllocation->SurfDesc.width;
     1569                        pAllocation->UsageHint.v1.Height = pAllocation->SurfDesc.height;
     1570                        pAllocation->UsageHint.v1.Pitch = pAllocation->SurfDesc.pitch;
     1571                        pAllocation->UsageHint.v1.Depth = 0;
     1572                        pAllocation->UsageHint.v1.SlicePitch = 0;
     1573
     1574                        Assert(!pAllocationInfo->pAllocationUsageHint);
     1575                        pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
     1576                    }
     1577
     1578                    break;
     1579                }
     1580                case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
     1581                {
     1582                    pAllocationInfo->Size = pAllocInfo->cbBuffer;
     1583                    pAllocation->enmSynchType = pAllocInfo->enmSynchType;
     1584                    pAllocation->SurfDesc.cbSize = pAllocInfo->cbBuffer;
     1585                    pAllocationInfo->Flags.CpuVisible = 1;
     1586                    pAllocationInfo->Flags.SynchronousPaging = 1;
     1587                    pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_MAXIMUM;
     1588                    switch (pAllocInfo->enmSynchType)
     1589                    {
     1590                        case VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT:
     1591                            Status = ObReferenceObjectByHandle(pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExEventObjectType, UserMode,
     1592                                    (PVOID*)&pAllocation->pSynchEvent,
     1593                                    NULL);
     1594                            Assert(Status == STATUS_SUCCESS);
     1595                            break;
     1596                        case VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE:
     1597                            Status = ObReferenceObjectByHandle(pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExSemaphoreObjectType, UserMode,
     1598                                    (PVOID*)&pAllocation->pSynchSemaphore,
     1599                                    NULL);
     1600                            Assert(Status == STATUS_SUCCESS);
     1601                            break;
     1602                        default:
     1603                            drprintf((__FUNCTION__ ": ERROR: invalid synch info type(%d)\n", pAllocInfo->enmSynchType));
     1604                            AssertBreakpoint();
     1605                            Status = STATUS_INVALID_PARAMETER;
     1606                            break;
    15491607                    }
    15501608                    break;
    1551                 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    1552                 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
    1553                     pAllocationInfo->Flags.CpuVisible = 1;
    1554                     break;
     1609                }
     1610
    15551611                default:
    15561612                    drprintf((__FUNCTION__ ": ERROR: invalid alloc info type(%d)\n", pAllocInfo->enmType));
    … …  
    15581614                    Status = STATUS_INVALID_PARAMETER;
    15591615                    break;
    1560             }
    1561 
    1562             if (Status == STATUS_SUCCESS)
    1563             {
    1564                 pAllocation->UsageHint.Version = 0;
    1565                 pAllocation->UsageHint.v1.Flags.Value = 0;
    1566                 pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
    1567                 pAllocation->UsageHint.v1.SwizzledFormat = 0;
    1568                 pAllocation->UsageHint.v1.ByteOffset = 0;
    1569                 pAllocation->UsageHint.v1.Width = pAllocation->SurfDesc.width;
    1570                 pAllocation->UsageHint.v1.Height = pAllocation->SurfDesc.height;
    1571                 pAllocation->UsageHint.v1.Pitch = pAllocation->SurfDesc.pitch;
    1572                 pAllocation->UsageHint.v1.Depth = 0;
    1573                 pAllocation->UsageHint.v1.SlicePitch = 0;
    1574 
    1575                 Assert(!pAllocationInfo->pAllocationUsageHint);
    1576                 pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
    1577             }
    1578             else
     1616
     1617            }
     1618
     1619            if (Status != STATUS_SUCCESS)
    15791620                vboxWddmAllocationDeleteFromResource(pResource, pAllocation);
    15801621        }
    … …  
    19932034                    if (pAllocationList->SegmentId)
    19942035                    {
    1995                         DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)pPrivateBuf + pPatchList->PatchOffset;
     2036                        DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)(pPrivateBuf + pPatchList->PatchOffset);
    19962037                        pAllocation2Patch->SegmentId = pAllocationList->SegmentId;
    19972038                        pAllocation2Patch->PhysicalAddress = pAllocationList->PhysicalAddress;
    … …  
    21242165DECLCALLBACK(VOID) vboxWddmDmaCompleteChromiumCmd(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
    21252166{
    2126     PVBOXVDMACBUF_DR pDr = (pDr)pvContext;
     2167    PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvContext;
    21272168    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    21282169    UINT cBufs = pHdr->u32CmdSpecific;
    … …  
    23422383            pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
    23432384            pDr->cbBuf = cbCmd;
    2344             pDr->u32FenceId = pSubmitCommand->SubmissionFenceId;
    23452385            pDr->rc = VERR_NOT_IMPLEMENTED;
    2346             pDr->u64GuestContext = (uint64_t)pContext;
    23472386
    23482387            PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    … …  
    23632402            PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
    23642403            vboxVdmaDdiCmdInit(pDdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxWddmDmaCompleteChromiumCmd, pDr);
    2365             NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
     2404            NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, pDdiCmd);
    23662405            Assert(Status == STATUS_SUCCESS);
    23672406            if (Status == STATUS_SUCCESS)
    … …  
    23782417            Assert(Status == STATUS_SUCCESS);
    23792418#endif
     2419            break;
    23802420        }
    23812421        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
    … …  
    24422482        {
    24432483            AssertBreakpoint();
    2444 #ifdef VBOX_WITH_VDMA
     2484#if 0 //def VBOX_WITH_VDMA
    24452485            VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
    24462486            PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, 0);
    … …  
    34343474                pSource->offVram = VBOXVIDEOOFFSET_VOID;
    34353475#endif
     3476                Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &pSource->VScreenPos);
     3477                Assert(Status == STATUS_SUCCESS);
    34363478                /* should not generally happen, but still inform host*/
    34373479                Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceAddress->VidPnSourceId);
    … …  
    35003542                        pSource->offVram = VBOXVIDEOOFFSET_VOID;
    35013543#endif
    3502 #if 0 /* tmp */
     3544                        Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &pSource->VScreenPos);
     3545                        Assert(Status == STATUS_SUCCESS);
    35033546                        Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceVisibility->VidPnSourceId);
    35043547                        Assert(Status == STATUS_SUCCESS);
    35053548                        if (Status != STATUS_SUCCESS)
    35063549                            drprintf((__FUNCTION__": vboxWddmGhDisplaySetInfo failed, Status (0x%x)\n", Status));
    3507 #endif
    35083550                    }
    35093551                }
    … …  
    45794621    int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo);
    45804622    AssertRC(rc);
    4581     if (RT_FAILURE(rc))
     4623    if (RT_SUCCESS(rc))
     4624    {
     4625        RECT DstRect;
     4626        vboxVhwaHlpOverlayDstRectGet(pOverlay->pDevExt, pOverlay, &DstRect);
     4627        Status = vboxVdmaHlpUpdatePrimary(pOverlay->pDevExt, pOverlay->VidPnSourceId, &DstRect);
     4628        Assert(Status == STATUS_SUCCESS);
     4629    }
     4630    else
    45824631        Status = STATUS_UNSUCCESSFUL;
    45834632
    … …  
    46684717            {
    46694718                pDevExt->aSources[i].offVram = VBOXVIDEOOFFSET_VOID;
     4719                Status= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos);
     4720                Assert(Status == STATUS_SUCCESS);
    46704721            }
    46714722        }
Note: See TracChangeset for help on using the changeset viewer.

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