VirtualBox

Changeset 102631 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Dec 18, 2023 12:01:14 PM (14 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
160788
Message:

WDDM: VGPU queries

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDX.cpp

    r102591 r102631  
    19571957}
    19581958
    1959 void vboxDXCreateQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery)
    1960 {
    1961     VMSVGAQUERYINFO const *pQueryInfo = getQueryInfo(pQuery->Query);
     1959
     1960#ifdef DEBUG
     1961static bool isBeginDisabled(D3D10DDI_QUERY q)
     1962{
     1963    return q == D3D10DDI_QUERY_EVENT
     1964        || q == D3D10DDI_QUERY_TIMESTAMP;
     1965}
     1966#endif
     1967
     1968
     1969void vboxDXCreateQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery, D3D10DDI_QUERY Query, UINT MiscFlags)
     1970{
     1971    VMSVGAQUERYINFO const *pQueryInfo = getQueryInfo(Query);
    19621972    AssertReturnVoidStmt(pQueryInfo, vboxDXDeviceSetError(pDevice, E_INVALIDARG));
    19631973
     1974    pQuery->Query = Query;
    19641975    pQuery->svga.queryType = pQueryInfo->queryTypeSvga;
     1976    pQuery->svga.flags = 0;
     1977    if (MiscFlags & D3D10DDI_QUERY_MISCFLAG_PREDICATEHINT)
     1978        pQuery->svga.flags |= SVGA3D_DXQUERY_FLAG_PREDICATEHINT;
    19651979    pQuery->enmQueryState = VBOXDXQUERYSTATE_CREATED;
     1980    pQuery->u64Value = 0;
    19661981
    19671982    int rc = RTHandleTableAlloc(pDevice->hHTQuery, pQuery, &pQuery->uQueryId);
    … …  
    19701985    /* Allocate mob space for this query. */
    19711986    pQuery->pCOAllocation = NULL;
     1987    uint32_t const cbAlloc = (pQuery->Query != D3D10DDI_QUERY_EVENT ? sizeof(uint32_t) : 0) + pQueryInfo->cbDataSvga;
    19721988    PVBOXDXCOALLOCATION pIter;
    19731989    RTListForEach(&pDevice->listCOAQuery, pIter, VBOXDXCOALLOCATION, nodeAllocationsChain)
    19741990    {
    1975         if (vboxDXCOABlockAlloc(pIter, pQueryInfo->cbDataSvga, &pQuery->offQuery))
     1991        if (vboxDXCOABlockAlloc(pIter, cbAlloc, &pQuery->offQuery))
    19761992        {
    19771993            pQuery->pCOAllocation = pIter;
    … …  
    19872003                                       vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY));
    19882004
    1989         if (!vboxDXCOABlockAlloc(pQuery->pCOAllocation, pQueryInfo->cbDataSvga, &pQuery->offQuery))
     2005        if (!vboxDXCOABlockAlloc(pQuery->pCOAllocation, cbAlloc, &pQuery->offQuery))
    19902006            AssertFailedReturnVoidStmt(RTHandleTableFree(pDevice->hHTQuery, pQuery->uQueryId);
    19912007                                       vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY));
    … …  
    19932009
    19942010    RTListAppend(&pDevice->listQueries, &pQuery->nodeQuery);
     2011
     2012    if (pQuery->Query != D3D10DDI_QUERY_EVENT)
     2013    {
     2014        D3DDDICB_LOCK ddiLock;
     2015        RT_ZERO(ddiLock);
     2016        ddiLock.hAllocation = pQuery->pCOAllocation->hCOAllocation;
     2017        ddiLock.Flags.WriteOnly = 1;
     2018        HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
     2019        if (SUCCEEDED(hr))
     2020        {
     2021            *(uint32_t *)((uint8_t *)ddiLock.pData + pQuery->offQuery) = SVGA3D_QUERYSTATE_PENDING;
     2022
     2023            D3DDDICB_UNLOCK ddiUnlock;
     2024            ddiUnlock.NumAllocations = 1;
     2025            ddiUnlock.phAllocations = &pQuery->pCOAllocation->hCOAllocation;
     2026            hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
     2027        }
     2028        AssertReturnVoidStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
     2029
     2030        vgpu10DefineQuery(pDevice, pQuery->uQueryId, pQuery->svga.queryType, pQuery->svga.flags);
     2031        vgpu10BindQuery(pDevice, pQuery->uQueryId, pQuery->pCOAllocation->hCOAllocation);
     2032        vgpu10SetQueryOffset(pDevice, pQuery->uQueryId, pQuery->offQuery);
     2033    }
    19952034}
    19962035
    … …  
    19982037void vboxDXDestroyQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery)
    19992038{
     2039    if (pQuery->Query != D3D10DDI_QUERY_EVENT)
     2040        vgpu10DestroyQuery(pDevice, pQuery->uQueryId);
     2041
    20002042    if (pQuery->pCOAllocation)
    20012043    {
    … …  
    20112053void vboxDXQueryBegin(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery)
    20122054{
     2055    Assert(pQuery->enmQueryState == VBOXDXQUERYSTATE_CREATED || pQuery->enmQueryState == VBOXDXQUERYSTATE_SIGNALED);
     2056
     2057    pQuery->enmQueryState = VBOXDXQUERYSTATE_BUILDING;
    20132058    if (pQuery->Query == D3D10DDI_QUERY_EVENT)
    2014     {
    2015         pQuery->enmQueryState = VBOXDXQUERYSTATE_BUILDING;
    20162059        return;
    2017     }
    2018 
    2019     RT_NOREF(pDevice);
    2020     DEBUG_BREAKPOINT_TEST();
     2060
     2061    vgpu10BeginQuery(pDevice, pQuery->uQueryId);
    20212062}
    20222063
    … …  
    20242065void vboxDXQueryEnd(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery)
    20252066{
     2067    Assert(   pQuery->enmQueryState == VBOXDXQUERYSTATE_BUILDING
     2068           || (   isBeginDisabled(pQuery->Query)
     2069               && (   pQuery->enmQueryState == VBOXDXQUERYSTATE_CREATED
     2070                   || pQuery->enmQueryState == VBOXDXQUERYSTATE_SIGNALED)
     2071              )
     2072          );
     2073
     2074    pQuery->enmQueryState = VBOXDXQUERYSTATE_ISSUED;
     2075
    20262076    if (pQuery->Query == D3D10DDI_QUERY_EVENT)
    20272077    {
    20282078        pQuery->u64Value = ASMAtomicIncU64(&pDevice->u64MobFenceValue);
    20292079        vgpu10MobFence64(pDevice, pQuery->u64Value, pQuery->pCOAllocation->hCOAllocation, pQuery->offQuery);
    2030         pQuery->enmQueryState = VBOXDXQUERYSTATE_ISSUED;
    20312080        return;
    20322081    }
    20332082
    2034     Assert(pQuery->enmQueryState == VBOXDXQUERYSTATE_BUILDING);
    2035     DEBUG_BREAKPOINT_TEST();
     2083    vgpu10EndQuery(pDevice, pQuery->uQueryId);
    20362084}
    20372085
    … …  
    20762124    }
    20772125
    2078     DEBUG_BREAKPOINT_TEST();
     2126    vgpu10ReadbackQuery(pDevice, pQuery->uQueryId);
     2127
     2128    VMSVGAQUERYINFO const *pQueryInfo = getQueryInfo(pQuery->Query);
     2129    AssertReturnVoidStmt(pQueryInfo, vboxDXDeviceSetError(pDevice, E_INVALIDARG));
     2130
     2131    void *pvResult = RTMemTmpAlloc(pQueryInfo->cbDataSvga);
     2132    AssertReturnVoidStmt(pvResult, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY));
     2133
     2134    uint32_t u32QueryStatus = SVGA3D_QUERYSTATE_PENDING;
     2135
     2136    D3DDDICB_LOCK ddiLock;
     2137    RT_ZERO(ddiLock);
     2138    ddiLock.hAllocation = pQuery->pCOAllocation->hCOAllocation;
     2139    ddiLock.Flags.ReadOnly = 1;
     2140    HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
     2141    if (SUCCEEDED(hr))
     2142    {
     2143        uint8_t *pu8 = (uint8_t *)ddiLock.pData + pQuery->offQuery;
     2144        u32QueryStatus = *(uint32_t *)pu8;
     2145
     2146        memcpy(pvResult, pu8 + sizeof(uint32_t), pQueryInfo->cbDataSvga);
     2147
     2148        D3DDDICB_UNLOCK ddiUnlock;
     2149        ddiUnlock.NumAllocations = 1;
     2150        ddiUnlock.phAllocations = &pQuery->pCOAllocation->hCOAllocation;
     2151        hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
     2152    }
     2153    AssertReturnVoidStmt(SUCCEEDED(hr), RTMemTmpFree(pvResult); vboxDXDeviceSetError(pDevice, hr));
     2154
     2155    if (u32QueryStatus != SVGA3D_QUERYSTATE_SUCCEEDED)
     2156        vboxDXDeviceSetError(pDevice, DXGI_DDI_ERR_WASSTILLDRAWING);
     2157    else
     2158    {
     2159        pQuery->enmQueryState = VBOXDXQUERYSTATE_SIGNALED;
     2160
     2161        if (pData && DataSize >= pQueryInfo->cbDataDDI)
     2162        {
     2163            typedef union DDIQUERYRESULT
     2164            {
     2165                UINT64                                   occlusion;            /* D3D10DDI_QUERY_OCCLUSION */
     2166                UINT64                                   timestamp;            /* D3D10DDI_QUERY_TIMESTAMP */
     2167                D3D10_DDI_QUERY_DATA_TIMESTAMP_DISJOINT  timestampDisjoint;    /* D3D10DDI_QUERY_TIMESTAMPDISJOINT */
     2168                D3D10_DDI_QUERY_DATA_PIPELINE_STATISTICS pipelineStatistics10; /* D3D10DDI_QUERY_PIPELINESTATS */
     2169                BOOL                                     occlusionPredicate;   /* D3D10DDI_QUERY_OCCLUSIONPREDICATE */
     2170                D3D10_DDI_QUERY_DATA_SO_STATISTICS       soStatistics;         /* D3D10DDI_QUERY_STREAMOUTPUTSTATS, D3D11DDI_QUERY_STREAMOUTPUTSTATS_STREAM[0-3] */
     2171                BOOL                                     soOverflowPredicate;  /* D3D10DDI_QUERY_STREAMOVERFLOWPREDICATE, D3D11DDI_QUERY_STREAMOVERFLOWPREDICATE_STREAM[0-3] */
     2172                D3D11_DDI_QUERY_DATA_PIPELINE_STATISTICS pipelineStatistics11; /* D3D11DDI_QUERY_PIPELINESTATS */
     2173            } DDIQUERYRESULT;
     2174            SVGADXQueryResultUnion const *pSvgaData = (SVGADXQueryResultUnion *)pvResult;
     2175            DDIQUERYRESULT *pDDIData = (DDIQUERYRESULT *)pData;
     2176            switch (pQuery->Query)
     2177            {
     2178                case D3D10DDI_QUERY_OCCLUSION:
     2179                {
     2180                    pDDIData->occlusion = pSvgaData->occ.samplesRendered;
     2181                    break;
     2182                }
     2183                case D3D10DDI_QUERY_TIMESTAMP:
     2184                {
     2185                    pDDIData->timestamp = pSvgaData->ts.timestamp;
     2186                    break;
     2187                }
     2188                case D3D10DDI_QUERY_TIMESTAMPDISJOINT:
     2189                {
     2190                    pDDIData->timestampDisjoint.Frequency = pSvgaData->tsDisjoint.realFrequency;
     2191                    pDDIData->timestampDisjoint.Disjoint = pSvgaData->tsDisjoint.disjoint;
     2192                    break;
     2193                }
     2194                case D3D10DDI_QUERY_PIPELINESTATS:
     2195                {
     2196                    pDDIData->pipelineStatistics10.IAVertices    = pSvgaData->pipelineStats.inputAssemblyVertices;
     2197                    pDDIData->pipelineStatistics10.IAPrimitives  = pSvgaData->pipelineStats.inputAssemblyPrimitives;
     2198                    pDDIData->pipelineStatistics10.VSInvocations = pSvgaData->pipelineStats.vertexShaderInvocations;
     2199                    pDDIData->pipelineStatistics10.GSInvocations = pSvgaData->pipelineStats.geometryShaderInvocations;
     2200                    pDDIData->pipelineStatistics10.GSPrimitives  = pSvgaData->pipelineStats.geometryShaderPrimitives;
     2201                    pDDIData->pipelineStatistics10.CInvocations  = pSvgaData->pipelineStats.clipperInvocations;
     2202                    pDDIData->pipelineStatistics10.CPrimitives   = pSvgaData->pipelineStats.clipperPrimitives;
     2203                    pDDIData->pipelineStatistics10.PSInvocations = pSvgaData->pipelineStats.pixelShaderInvocations;
     2204                    break;
     2205                }
     2206                case D3D10DDI_QUERY_OCCLUSIONPREDICATE:
     2207                {
     2208                    pDDIData->occlusionPredicate = pSvgaData->occPred.anySamplesRendered;
     2209                    break;
     2210                }
     2211                case D3D10DDI_QUERY_STREAMOUTPUTSTATS:
     2212                case D3D11DDI_QUERY_STREAMOUTPUTSTATS_STREAM0:
     2213                case D3D11DDI_QUERY_STREAMOUTPUTSTATS_STREAM1:
     2214                case D3D11DDI_QUERY_STREAMOUTPUTSTATS_STREAM2:
     2215                case D3D11DDI_QUERY_STREAMOUTPUTSTATS_STREAM3:
     2216                {
     2217                    pDDIData->soStatistics.NumPrimitivesWritten    = pSvgaData->soStats.numPrimitivesWritten;
     2218                    pDDIData->soStatistics.PrimitivesStorageNeeded = pSvgaData->soStats.numPrimitivesRequired;
     2219                    break;
     2220                }
     2221                case D3D11DDI_QUERY_STREAMOVERFLOWPREDICATE_STREAM0:
     2222                case D3D11DDI_QUERY_STREAMOVERFLOWPREDICATE_STREAM1:
     2223                case D3D11DDI_QUERY_STREAMOVERFLOWPREDICATE_STREAM2:
     2224                case D3D11DDI_QUERY_STREAMOVERFLOWPREDICATE_STREAM3:
     2225                case D3D10DDI_QUERY_STREAMOVERFLOWPREDICATE:
     2226                {
     2227                    pDDIData->soOverflowPredicate = pSvgaData->soPred.overflowed;
     2228                    break;
     2229                }
     2230                case D3D11DDI_QUERY_PIPELINESTATS:
     2231                {
     2232                    pDDIData->pipelineStatistics11.IAVertices    = pSvgaData->pipelineStats.inputAssemblyVertices;
     2233                    pDDIData->pipelineStatistics11.IAPrimitives  = pSvgaData->pipelineStats.inputAssemblyPrimitives;
     2234                    pDDIData->pipelineStatistics11.VSInvocations = pSvgaData->pipelineStats.vertexShaderInvocations;
     2235                    pDDIData->pipelineStatistics11.GSInvocations = pSvgaData->pipelineStats.geometryShaderInvocations;
     2236                    pDDIData->pipelineStatistics11.GSPrimitives  = pSvgaData->pipelineStats.geometryShaderPrimitives;
     2237                    pDDIData->pipelineStatistics11.CInvocations  = pSvgaData->pipelineStats.clipperInvocations;
     2238                    pDDIData->pipelineStatistics11.CPrimitives   = pSvgaData->pipelineStats.clipperPrimitives;
     2239                    pDDIData->pipelineStatistics11.PSInvocations = pSvgaData->pipelineStats.pixelShaderInvocations;
     2240                    pDDIData->pipelineStatistics11.HSInvocations = pSvgaData->pipelineStats.hullShaderInvocations;
     2241                    pDDIData->pipelineStatistics11.DSInvocations = pSvgaData->pipelineStats.domainShaderInvocations;
     2242                    pDDIData->pipelineStatistics11.CSInvocations = pSvgaData->pipelineStats.computeShaderInvocations;
     2243                    break;
     2244                }
     2245                default:
     2246                    break;
     2247            }
     2248        }
     2249    }
     2250
     2251    RTMemTmpFree(pvResult);
    20792252}
    20802253

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDX.h

    r102591 r102631  
    162162    D3D10DDI_HRTQUERY           hRTQuery;
    163163    D3D10DDI_QUERY              Query;
    164     UINT                        MiscFlags;
    165164    struct
    166165    {
    167166        SVGA3dQueryType         queryType;
     167        SVGA3dDXQueryFlags      flags;
    168168    } svga;
    169169    VBOXDXQUERYSTATE            enmQueryState;
    … …  
    686686                              UINT RasterizedStream);
    687687void vboxDXDestroyShader(PVBOXDX_DEVICE pDevice, PVBOXDXSHADER pShader);
    688 void vboxDXCreateQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery);
     688void vboxDXCreateQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery, D3D10DDI_QUERY Query, UINT MiscFlags);
    689689void vboxDXDestroyQuery(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery);
    690690void vboxDXQueryBegin(PVBOXDX_DEVICE pDevice, PVBOXDXQUERY pQuery);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXCmd.cpp

    r102408 r102631  
    12821282
    12831283
     1284int vgpu10DefineQuery(PVBOXDX_DEVICE pDevice,
     1285                      SVGA3dQueryId queryId,
     1286                      SVGA3dQueryType type,
     1287                      SVGA3dDXQueryFlags flags)
     1288{
     1289    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_DEFINE_QUERY,
     1290                                             sizeof(SVGA3dCmdDXDefineQuery), 0);
     1291    if (!pvCmd)
     1292        return VERR_NO_MEMORY;
     1293
     1294    SVGA3dCmdDXDefineQuery *cmd = (SVGA3dCmdDXDefineQuery *)pvCmd;
     1295    SET_CMD_FIELD(queryId);
     1296    SET_CMD_FIELD(type);
     1297    SET_CMD_FIELD(flags);
     1298
     1299    vboxDXCommandBufferCommit(pDevice);
     1300    return VINF_SUCCESS;
     1301}
     1302
     1303
     1304int vgpu10DestroyQuery(PVBOXDX_DEVICE pDevice,
     1305                       SVGA3dQueryId queryId)
     1306{
     1307    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_DESTROY_QUERY,
     1308                                             sizeof(SVGA3dCmdDXDestroyQuery), 0);
     1309    if (!pvCmd)
     1310        return VERR_NO_MEMORY;
     1311
     1312    SVGA3dCmdDXDestroyQuery *cmd = (SVGA3dCmdDXDestroyQuery *)pvCmd;
     1313    SET_CMD_FIELD(queryId);
     1314
     1315    vboxDXCommandBufferCommit(pDevice);
     1316    return VINF_SUCCESS;
     1317}
     1318
     1319
     1320int vgpu10BindQuery(PVBOXDX_DEVICE pDevice,
     1321                    SVGA3dQueryId queryId,
     1322                    D3DKMT_HANDLE hAllocation)
     1323{
     1324    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_BIND_QUERY,
     1325                                             sizeof(SVGA3dCmdDXBindQuery), 1);
     1326    if (!pvCmd)
     1327        return VERR_NO_MEMORY;
     1328
     1329    SVGA3dCmdDXBindQuery *cmd = (SVGA3dCmdDXBindQuery *)pvCmd;
     1330    SET_CMD_FIELD(queryId);
     1331    cmd->mobid = SVGA3D_INVALID_ID;
     1332
     1333    vboxDXStorePatchLocation(pDevice, &cmd->mobid, VBOXDXALLOCATIONTYPE_CO,
     1334                             hAllocation, 0, true);
     1335
     1336    vboxDXCommandBufferCommit(pDevice);
     1337    return VINF_SUCCESS;
     1338}
     1339
     1340
     1341int vgpu10SetQueryOffset(PVBOXDX_DEVICE pDevice,
     1342                         SVGA3dQueryId queryId,
     1343                         uint32 mobOffset)
     1344{
     1345    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_SET_QUERY_OFFSET,
     1346                                             sizeof(SVGA3dCmdDXSetQueryOffset), 0);
     1347    if (!pvCmd)
     1348        return VERR_NO_MEMORY;
     1349
     1350    SVGA3dCmdDXSetQueryOffset *cmd = (SVGA3dCmdDXSetQueryOffset *)pvCmd;
     1351    SET_CMD_FIELD(queryId);
     1352    SET_CMD_FIELD(mobOffset);
     1353
     1354    vboxDXCommandBufferCommit(pDevice);
     1355    return VINF_SUCCESS;
     1356}
     1357
     1358
     1359int vgpu10BeginQuery(PVBOXDX_DEVICE pDevice,
     1360                     SVGA3dQueryId queryId)
     1361{
     1362    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_BEGIN_QUERY,
     1363                                             sizeof(SVGA3dCmdDXBeginQuery), 0);
     1364    if (!pvCmd)
     1365        return VERR_NO_MEMORY;
     1366
     1367    SVGA3dCmdDXBeginQuery *cmd = (SVGA3dCmdDXBeginQuery *)pvCmd;
     1368    SET_CMD_FIELD(queryId);
     1369
     1370    vboxDXCommandBufferCommit(pDevice);
     1371    return VINF_SUCCESS;
     1372}
     1373
     1374
     1375int vgpu10EndQuery(PVBOXDX_DEVICE pDevice,
     1376                   SVGA3dQueryId queryId)
     1377{
     1378    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_END_QUERY,
     1379                                             sizeof(SVGA3dCmdDXEndQuery), 0);
     1380    if (!pvCmd)
     1381        return VERR_NO_MEMORY;
     1382
     1383    SVGA3dCmdDXEndQuery *cmd = (SVGA3dCmdDXEndQuery *)pvCmd;
     1384    SET_CMD_FIELD(queryId);
     1385
     1386    vboxDXCommandBufferCommit(pDevice);
     1387    return VINF_SUCCESS;
     1388}
     1389
     1390
     1391int vgpu10ReadbackQuery(PVBOXDX_DEVICE pDevice,
     1392                        SVGA3dQueryId queryId)
     1393{
     1394    void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_READBACK_QUERY,
     1395                                             sizeof(SVGA3dCmdDXReadbackQuery), 0);
     1396    if (!pvCmd)
     1397        return VERR_NO_MEMORY;
     1398
     1399    SVGA3dCmdDXReadbackQuery *cmd = (SVGA3dCmdDXReadbackQuery *)pvCmd;
     1400    SET_CMD_FIELD(queryId);
     1401
     1402    vboxDXCommandBufferCommit(pDevice);
     1403    return VINF_SUCCESS;
     1404}
     1405
     1406
    12841407int vgpu10SetPredication(PVBOXDX_DEVICE pDevice,
    12851408                         SVGA3dQueryId queryId,

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXCmd.h

    r102408 r102631  
    266266                     D3DKMT_HANDLE hAllocation,
    267267                     uint32 mobOffset);
     268int vgpu10DefineQuery(PVBOXDX_DEVICE pDevice,
     269                      SVGA3dQueryId queryId,
     270                      SVGA3dQueryType type,
     271                      SVGA3dDXQueryFlags flags);
     272int vgpu10DestroyQuery(PVBOXDX_DEVICE pDevice,
     273                       SVGA3dQueryId queryId);
     274int vgpu10BindQuery(PVBOXDX_DEVICE pDevice,
     275                    SVGA3dQueryId queryId,
     276                    D3DKMT_HANDLE hAllocation);
     277int vgpu10SetQueryOffset(PVBOXDX_DEVICE pDevice,
     278                         SVGA3dQueryId queryId,
     279                         uint32 mobOffset);
     280int vgpu10BeginQuery(PVBOXDX_DEVICE pDevice,
     281                     SVGA3dQueryId queryId);
     282int vgpu10EndQuery(PVBOXDX_DEVICE pDevice,
     283                   SVGA3dQueryId queryId);
     284int vgpu10ReadbackQuery(PVBOXDX_DEVICE pDevice,
     285                        SVGA3dQueryId queryId);
    268286int vgpu10SetPredication(PVBOXDX_DEVICE pDevice,
    269287                         SVGA3dQueryId queryId,

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXDDI.cpp

    r102591 r102631  
    25652565
    25662566    pQuery->hRTQuery = hRTQuery;
    2567     pQuery->Query = pCreateQuery->Query;
    2568     pQuery->MiscFlags = pCreateQuery->MiscFlags;
    2569 
    2570     vboxDXCreateQuery(pDevice, pQuery);
     2567    vboxDXCreateQuery(pDevice, pQuery, pCreateQuery->Query, pCreateQuery->MiscFlags);
    25712568}
    25722569
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