VirtualBox

Ignore:
Timestamp:
May 30, 2010 7:27:02 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
62136
Message:

wddm: open,create,destroy,lock,unlock resource

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r29798 r29883  
    857857}
    858858
     859static PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs)
     860{
     861    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
     862    Assert(pRc);
     863    if (pRc)
     864    {
     865        pRc->cAllocations = cAllocs;
     866        return pRc;
     867    }
     868    return NULL;
     869}
     870
     871static void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc)
     872{
     873    RTMemFree(pRc);
     874}
     875
    859876/**
    860877 * DLL entry point.
    … …  
    13961413static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
    13971414{
    1398     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1399     AssertBreakpoint();
    1400     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1401     return E_FAIL;
     1415    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1416    AssertBreakpoint();
     1417    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1418    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     1419    Assert(pData->SubResourceIndex < pRc->cAllocations);
     1420    if (pData->SubResourceIndex >= pRc->cAllocations)
     1421        return E_INVALIDARG;
     1422
     1423    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     1424    D3DDDICB_LOCK LockData;
     1425    LockData.hAllocation = pAlloc->hAllocation;
     1426    LockData.PrivateDriverData = 0;
     1427    LockData.NumPages = 0;
     1428    LockData.pPages = NULL;
     1429    LockData.pData = NULL; /* out */
     1430    LockData.Flags.Value = 0;
     1431    LockData.Flags.Discard = pData->Flags.Discard;
     1432    LockData.Flags.DonotWait = pData->Flags.DoNotWait;
     1433
     1434
     1435    HRESULT hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData);
     1436    Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
     1437    if (hr == S_OK)
     1438    {
     1439        uintptr_t offset;
     1440        if (pData->Flags.AreaValid)
     1441        {
     1442            offset = pAlloc->SurfDesc.pitch * pData->Area.top +
     1443                    ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
     1444        }
     1445        else if (pData->Flags.RangeValid)
     1446        {
     1447            offset = pData->Range.Offset;
     1448        }
     1449        else if (pData->Flags.BoxValid)
     1450        {
     1451            vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
     1452            AssertBreakpoint();
     1453        }
     1454        else
     1455        {
     1456            AssertBreakpoint();
     1457        }
     1458
     1459        if (pData->Flags.Discard)
     1460        {
     1461            /* check if the surface was renamed */
     1462            if (LockData.hAllocation)
     1463                pAlloc->hAllocation = LockData.hAllocation;
     1464        }
     1465
     1466        pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
     1467        pData->Pitch = pAlloc->SurfDesc.pitch;
     1468        pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
     1469    }
     1470
     1471    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1472    return hr;
    14021473}
    14031474static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
    14041475{
    1405     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1406     AssertBreakpoint();
    1407     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1408     return E_FAIL;
     1476    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1477    AssertBreakpoint();
     1478    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1479    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     1480    HRESULT hr = S_OK;
     1481
     1482    Assert(pData->SubResourceIndex < pRc->cAllocations);
     1483    if (pData->SubResourceIndex >= pRc->cAllocations)
     1484        return E_INVALIDARG;
     1485
     1486    struct
     1487    {
     1488        D3DDDICB_UNLOCK Unlock;
     1489        D3DKMT_HANDLE hAllocation;
     1490    } UnlockData;
     1491
     1492    UnlockData.Unlock.NumAllocations = 1;
     1493    UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
     1494    UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation;
     1495
     1496    hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock);
     1497    Assert(hr == S_OK);
     1498
     1499    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1500    return hr;
    14091501}
    14101502static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
    … …  
    14291521    return E_FAIL;
    14301522}
     1523
    14311524static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
    14321525{
    1433     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1434     AssertBreakpoint();
    1435     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1436     return E_FAIL;
    1437 }
     1526    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1527    HRESULT hr = S_OK;
     1528    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1529    Assert(pDevice);
     1530    Assert(pResource);
     1531
     1532    /* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
     1533    uint32_t cbBuf = sizeof (D3DDDICB_ALLOCATE);
     1534    uint32_t offDdiAllocInfos = (cbBuf + 7) & ~3;
     1535    uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
     1536    cbBuf = offDdiAllocInfos + cbDdiAllocInfos;
     1537    uint32_t offRcInfo = (cbBuf + 7) & ~3;
     1538    uint32_t cbRcInfo = sizeof (VBOXWDDM_RCINFO);
     1539    cbBuf = offRcInfo + cbRcInfo;
     1540    uint32_t offAllocInfos = (cbBuf + 7) & ~3;
     1541    uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
     1542    cbBuf = offAllocInfos + cbAllocInfos;
     1543    uint8_t *pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
     1544    if (pvBuf)
     1545    {
     1546        D3DDDICB_ALLOCATE *pAllocate = (D3DDDICB_ALLOCATE*)pvBuf;
     1547        D3DDDI_ALLOCATIONINFO* pDdiAllocInfos = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
     1548        PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
     1549        PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
     1550        pAllocate->pPrivateDriverData = pRcInfo;
     1551        pAllocate->PrivateDriverDataSize = cbRcInfo;
     1552        pAllocate->hResource = pResource->hResource;
     1553        pAllocate->hKMResource = NULL;
     1554        pAllocate->NumAllocations = pResource->SurfCount;
     1555        pAllocate->pAllocationInfo = pDdiAllocInfos;
     1556
     1557        pRcInfo->fFlags = VBOXWDDM_RESOURCE_F_TYPE_GENERIC;
     1558        pRcInfo->RcDesc.fFlags = pResource->Flags;
     1559        pRcInfo->RcDesc.enmFormat = pResource->Format;
     1560        pRcInfo->RcDesc.enmPool = pResource->Pool;
     1561        pRcInfo->RcDesc.enmMultisampleType = pResource->MultisampleType;
     1562        pRcInfo->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
     1563        pRcInfo->RcDesc.MipLevels = pResource->MipLevels;
     1564        pRcInfo->RcDesc.Fvf = pResource->Fvf;
     1565        pRcInfo->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
     1566        pRcInfo->RcDesc.RefreshRate = pResource->RefreshRate;
     1567        pRcInfo->RcDesc.enmRotation = pResource->Rotation;
     1568        pRcInfo->cAllocInfos = pResource->SurfCount;
     1569
     1570        for (UINT i = 0; i < pResource->SurfCount; ++i)
     1571        {
     1572            PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
     1573            D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
     1574            CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
     1575            pDdiAllocInfo->hAllocation = NULL;
     1576            pDdiAllocInfo->pSystemMem = pSurf->pSysMem;
     1577            Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
     1578            pDdiAllocInfo->pPrivateDriverData = pAllocInfo;
     1579            pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
     1580            pDdiAllocInfo->VidPnSourceId = pResource->VidPnSourceId;
     1581            pDdiAllocInfo->Flags.Value = 0;
     1582            if (pResource->Flags.Primary)
     1583                pDdiAllocInfo->Flags.Primary = 1;
     1584
     1585            pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
     1586            pAllocInfo->SurfDesc.width = pSurf->Width;
     1587            pAllocInfo->SurfDesc.height = pSurf->Height;
     1588            pAllocInfo->SurfDesc.format = pResource->Format;
     1589            pAllocInfo->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
     1590
     1591            if (pSurf->SysMemPitch)
     1592            {
     1593                pAllocInfo->SurfDesc.pitch = pSurf->SysMemPitch;
     1594#ifdef DEBUG
     1595                UINT tst = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
     1596                Assert(tst == pSurf->SysMemPitch);
     1597#endif
     1598            }
     1599            else
     1600                pAllocInfo->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pAllocInfo->SurfDesc.bpp);
     1601
     1602            pAllocInfo->SurfDesc.depth = pSurf->Depth;
     1603            pAllocInfo->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
     1604            pAllocInfo->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
     1605            pAllocInfo->SurfDesc.RefreshRate = pResource->RefreshRate;
     1606        }
     1607
     1608        hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pAllocate);
     1609        Assert(hr == S_OK);
     1610        if (hr == S_OK)
     1611        {
     1612            Assert(pAllocate->hKMResource);
     1613            PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
     1614            if (pRc)
     1615            {
     1616                pRc->hResource = pResource->hResource;
     1617                pRc->hKMResource = pAllocate->hKMResource;
     1618                pRc->pDevice = pDevice;
     1619                pRc->fFlags = pRcInfo->fFlags;
     1620                pRc->RcDesc = pRcInfo->RcDesc;
     1621                pRc->cAllocations = pRcInfo->cAllocInfos;
     1622                for (UINT i = 0; i < pRcInfo->cAllocInfos; ++i)
     1623                {
     1624                    PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[1];
     1625                    D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pDdiAllocInfos[i];
     1626                    PVBOXWDDM_ALLOCINFO pAllocInfo = &pAllocInfos[i];
     1627                    CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
     1628                    pAllocation->hAllocation = pDdiAllocInfo->hAllocation;
     1629                    pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
     1630                    pAllocation->pvMem = pSurf->pSysMem;
     1631                    pAllocation->SurfDesc = pAllocInfo->SurfDesc;
     1632                }
     1633
     1634                pResource->hResource = pRc;
     1635//                vboxResourceFree(pRc);
     1636            }
     1637            else
     1638            {
     1639                hr = E_OUTOFMEMORY;
     1640            }
     1641        }
     1642
     1643        RTMemFree(pvBuf);
     1644    }
     1645    else
     1646    {
     1647        hr = E_OUTOFMEMORY;
     1648    }
     1649
     1650    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1651    return hr;
     1652}
     1653
    14381654static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
    14391655{
    1440     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1441     AssertBreakpoint();
    1442     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1443     return E_FAIL;
     1656    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1657    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1658    HRESULT hr = S_OK;
     1659
     1660    Assert(pDevice);
     1661    Assert(hResource);
     1662    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
     1663    if (!(pRc->fFlags & VBOXWDDM_RESOURCE_F_OPENNED))
     1664    {
     1665        D3DDDICB_DEALLOCATE Dealloc;
     1666        Dealloc.hResource = pRc->hResource;
     1667        Assert(pRc->hResource);
     1668        /* according to the docs the below two are ignored in case we set the hResource */
     1669        Dealloc.NumAllocations = 0;
     1670        Dealloc.HandleList = NULL;
     1671        hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
     1672        Assert(hr == S_OK);
     1673    }
     1674
     1675    vboxResourceFree(pRc);
     1676    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1677    return hr;
    14441678}
    14451679static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
    … …  
    18302064    return E_FAIL;
    18312065}
     2066
     2067static HRESULT vboxAllocationInit(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_OPENALLOCATIONINFO *pInfo)
     2068{
     2069    HRESULT hr = S_OK;
     2070    pAlloc->hAllocation = pInfo->hAllocation;
     2071    Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
     2072    Assert(pInfo->pPrivateDriverData);
     2073    if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
     2074    {
     2075        PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
     2076        pAlloc->enmType = pAllocInfo->enmType;
     2077        Assert(pAllocInfo->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
     2078                || VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE
     2079                || VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE);
     2080        pAlloc->pvMem = NULL;
     2081        pAlloc->SurfDesc = pAllocInfo->SurfDesc;
     2082    }
     2083    else
     2084    {
     2085        vboxVDbgPrintR((__FUNCTION__": ERROR: PrivateDriverDataSize(%d) < (%d)\n", pInfo->PrivateDriverDataSize, sizeof (VBOXWDDM_ALLOCINFO)));
     2086        hr = E_INVALIDARG;
     2087    }
     2088    return hr;
     2089}
     2090
    18322091static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
    18332092{
    1834     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1835     AssertBreakpoint();
    1836     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1837     return E_FAIL;
     2093    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2094    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2095    HRESULT hr = S_OK;
     2096
     2097    Assert(pDevice);
     2098    Assert(pData->NumAllocations);
     2099    PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
     2100    Assert(pRc);
     2101    if (pRc)
     2102    {
     2103        pRc->hResource = pData->hResource;
     2104        pRc->hKMResource = pData->hKMResource;
     2105        pRc->pDevice = pDevice;
     2106        pRc->RcDesc.enmRotation = pData->Rotation;
     2107        pRc->fFlags = VBOXWDDM_RESOURCE_F_OPENNED;
     2108        if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize)
     2109        {
     2110            /* this is a "standard" allocation resource */
     2111
     2112            /* both should be actually zero */
     2113            Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
     2114            pRc->RcDesc.enmPool = D3DDDIPOOL_LOCALVIDMEM;
     2115            pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
     2116            pRc->RcDesc.MultisampleQuality = 0;
     2117            pRc->RcDesc.MipLevels = 0;
     2118            pRc->RcDesc.Fvf;
     2119            pRc->RcDesc.fFlags.Value = 0;
     2120
     2121            Assert(pData->NumAllocations);
     2122            D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
     2123            Assert(pDdiAllocInfo->pPrivateDriverData);
     2124            Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
     2125            if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
     2126            {
     2127                PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
     2128                switch(pAllocInfo->enmType)
     2129                {
     2130                    case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
     2131                        pRc->RcDesc.fFlags.Primary = 1;
     2132                    case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
     2133                    case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
     2134                        pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
     2135                        pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
     2136                        pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
     2137                        break;
     2138                    default:
     2139                        AssertBreakpoint();
     2140                        hr = E_INVALIDARG;
     2141                }
     2142            }
     2143            else
     2144                hr = E_INVALIDARG;
     2145        }
     2146        else
     2147        {
     2148            /* this is a "generic" resource whose creation is initiaded by the UMD */
     2149            Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
     2150            if (pData->PrivateDriverDataSize >= sizeof (VBOXWDDM_RCINFO))
     2151            {
     2152                VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData;
     2153                Assert(pRcInfo->fFlags == VBOXWDDM_RESOURCE_F_TYPE_GENERIC);
     2154                Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
     2155                pRc->fFlags = pRcInfo->fFlags | VBOXWDDM_RESOURCE_F_OPENNED;
     2156                pRc->RcDesc = pRcInfo->RcDesc;
     2157                pRc->cAllocations = pData->NumAllocations;
     2158            }
     2159            else
     2160                hr = E_INVALIDARG;
     2161        }
     2162
     2163        if (hr == S_OK)
     2164        {
     2165            for (UINT i = 0; i < pData->NumAllocations; ++i)
     2166            {
     2167                hr = vboxAllocationInit(&pRc->aAllocations[i], &pData->pOpenAllocationInfo[i]);
     2168                Assert(hr == S_OK);
     2169                if (hr != S_OK)
     2170                    break;
     2171            }
     2172        }
     2173
     2174        if (hr == S_OK)
     2175            pData->hResource = pRc;
     2176        else
     2177            vboxResourceFree(pRc);
     2178    }
     2179    else
     2180    {
     2181        vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
     2182        hr = E_OUTOFMEMORY;
     2183    }
     2184
     2185    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2186    return hr;
    18382187}
    18392188static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)

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

    r29798 r29883  
    7474} VBOXWDDMDISP_DEVICE, *PVBOXWDDMDISP_DEVICE;
    7575
     76typedef struct VBOXWDDMDISP_ALLOCATION
     77{
     78    D3DKMT_HANDLE hAllocation;
     79    VBOXWDDM_ALLOC_TYPE enmType;
     80    CONST VOID* pvMem;
     81    VBOXWDDM_SURFACE_DESC SurfDesc;
     82} VBOXWDDMDISP_ALLOCATION, *PVBOXWDDMDISP_ALLOCATION;
     83
     84typedef struct VBOXWDDMDISP_RESOURCE
     85{
     86    HANDLE hResource;
     87    D3DKMT_HANDLE hKMResource;
     88    PVBOXWDDMDISP_DEVICE pDevice;
     89    uint32_t fFlags;
     90    VBOXWDDM_RC_DESC RcDesc;
     91    UINT cAllocations;
     92    VBOXWDDMDISP_ALLOCATION aAllocations[1];
     93} VBOXWDDMDISP_RESOURCE, *PVBOXWDDMDISP_RESOURCE;
     94
    7695DECLINLINE(bool) vboxDispD3DIs3DEnabled(VBOXWDDMDISP_ADAPTER * pAdapter)
    7796{
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