VirtualBox

Ignore:
Timestamp:
Jun 8, 2010 5:02:04 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
62478
Message:

wddm/3d: texture lock/unlock + bugfixes

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

    r30085 r30096  
    861861    }
    862862    return NULL;
     863}
     864
     865static void vboxWddmRectUnited(RECT *pR, const RECT *pR2Unite)
     866{
     867    pR->left = RT_MIN(pR->left, pR2Unite->left);
     868    pR->top = RT_MIN(pR->top, pR2Unite->top);
     869    pR->right = RT_MAX(pR->right, pR2Unite->right);
     870    pR->bottom = RT_MAX(pR->bottom, pR2Unite->bottom);
     871}
     872
     873static void vboxWddmLockUnlockMemSynch(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo, RECT *pRect, bool bToLockInfo)
     874{
     875    Assert(pAlloc->SurfDesc.pitch);
     876    Assert(pAlloc->pvMem);
     877
     878    if (!pRect)
     879    {
     880        if (pAlloc->SurfDesc.pitch == pLockInfo->Pitch)
     881        {
     882            if (bToLockInfo)
     883                memcpy(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
     884            else
     885                memcpy(pAlloc->pvMem, pLockInfo->pBits, pAlloc->SurfDesc.pitch * pAlloc->SurfDesc.height);
     886        }
     887        else
     888        {
     889            uint8_t *pvSrc, *pvDst;
     890            uint32_t srcPitch, dstPitch;
     891            if (bToLockInfo)
     892            {
     893                pvSrc = (uint8_t *)pAlloc->pvMem;
     894                pvDst = (uint8_t *)pLockInfo->pBits;
     895                srcPitch = pAlloc->SurfDesc.pitch;
     896                dstPitch = pLockInfo->Pitch;
     897            }
     898            else
     899            {
     900                pvDst = (uint8_t *)pAlloc->pvMem;
     901                pvSrc = (uint8_t *)pLockInfo->pBits;
     902                dstPitch = pAlloc->SurfDesc.pitch;
     903                srcPitch = (uint32_t)pLockInfo->Pitch;
     904            }
     905
     906            uint32_t pitch = RT_MIN(srcPitch, dstPitch);
     907            Assert(pitch);
     908            for (UINT j = 0; j < pAlloc->SurfDesc.height; ++j)
     909            {
     910                memcpy(pvDst, pvSrc, pitch);
     911                pvSrc += srcPitch;
     912                pvDst += dstPitch;
     913            }
     914        }
     915    }
     916    else
     917    {
     918        uint8_t *pvSrc, *pvDst;
     919        uint32_t srcPitch, dstPitch;
     920        /* @todo: this is not entirely correct */
     921        uint8_t * pvAllocMemStart = (uint8_t *)pAlloc->pvMem;
     922        uint32_t cbPP = pAlloc->SurfDesc.pitch/pAlloc->SurfDesc.width;
     923        pvAllocMemStart += pAlloc->SurfDesc.pitch * pRect->top + pRect->left * cbPP;
     924
     925        if (bToLockInfo)
     926        {
     927            pvSrc = (uint8_t *)pvAllocMemStart;
     928            pvDst = (uint8_t *)pLockInfo->pBits;
     929            srcPitch = pAlloc->SurfDesc.pitch;
     930            dstPitch = pLockInfo->Pitch;
     931        }
     932        else
     933        {
     934            pvDst = (uint8_t *)pvAllocMemStart;
     935            pvSrc = (uint8_t *)pLockInfo->pBits;
     936            dstPitch = pAlloc->SurfDesc.pitch;
     937            srcPitch = (uint32_t)pLockInfo->Pitch;
     938        }
     939
     940        uint32_t cPixCopyLine = pRect->left - pRect->right;
     941
     942        if (cPixCopyLine == pAlloc->SurfDesc.width && srcPitch == dstPitch)
     943        {
     944            memcpy(pvDst, pvSrc, pAlloc->SurfDesc.pitch * (pRect->bottom - pRect->top));
     945        }
     946        else
     947        {
     948            uint32_t pitch = RT_MIN(srcPitch, dstPitch);
     949            uint32_t cbCopyLine = cPixCopyLine * cbPP;
     950            Assert(pitch);
     951            for (int j = pRect->top; j < pRect->bottom; ++j)
     952            {
     953                memcpy(pvDst, pvSrc, cbCopyLine);
     954                pvSrc += srcPitch;
     955                pvDst += dstPitch;
     956            }
     957        }
     958    }
    863959}
    864960
    … …  
    9341030//        fUsage |= D3DUSAGE_RESTRICT_SHARED_RESOURCE;
    9351031    return fUsage;
     1032}
     1033
     1034DWORD vboxDDI2D3DLockFlags(D3DDDI_LOCKFLAGS fLockFlags)
     1035{
     1036    DWORD fFlags = 0;
     1037    if (fLockFlags.Discard)
     1038        fFlags |= D3DLOCK_DISCARD;
     1039    if (fLockFlags.NoOverwrite)
     1040        fFlags |= D3DLOCK_NOOVERWRITE;
     1041    if (fLockFlags.ReadOnly)
     1042        fFlags |= D3DLOCK_READONLY;
     1043    if (fLockFlags.DoNotWait)
     1044        fFlags |= D3DLOCK_DONOTWAIT;
     1045    return fFlags;
    9361046}
    9371047
    … …  
    13011411{
    13021412    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1303     AssertBreakpoint();
    1304     /* misha> @todo: implement */
    13051413    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    13061414    return S_OK;
    … …  
    16001708        if (pRc->RcDesc.fFlags.Texture)
    16011709        {
    1602             PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
     1710            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     1711            Assert(pData->SubResourceIndex < pRc->cAllocations);
     1712            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     1713            Assert(!pLockAlloc->LockInfo.cLocks);
     1714            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
     1715            Assert(pD3DIfTex);
     1716            D3DLOCKED_RECT LockInfo;
     1717            RECT *pRect = NULL;
     1718            if (pData->Flags.AreaValid)
     1719            {
     1720                pRect = &pData->Area;
     1721            }
     1722            else if (pData->Flags.RangeValid)
     1723            {
     1724                AssertBreakpoint();
     1725            }
     1726            else if (pData->Flags.BoxValid)
     1727            {
     1728                AssertBreakpoint();
     1729            }
     1730            /* else - we lock the entire texture, pRect == NULL */
     1731            hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
     1732                    &LockInfo,
     1733                    pRect,
     1734                    vboxDDI2D3DLockFlags(pData->Flags));
     1735            Assert(hr == S_OK);
     1736            if (hr == S_OK)
     1737            {
     1738                Assert(!pLockAlloc->LockInfo.cLocks);
     1739                if (pLockAlloc->LockInfo.cLocks)
     1740                {
     1741//                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid || pLockAlloc->LockInfo.fFlags.Value == 0);
     1742                    /* else the entire texture is locked already - nothing to be done */
     1743
     1744                    AssertBreakpoint();
     1745                    /* @todo: merge flags */
     1746                    pLockAlloc->LockInfo.fFlags.Value &= pData->Flags.Value;
     1747
     1748                    if (pLockAlloc->LockInfo.fFlags.AreaValid)
     1749                    {
     1750                        Assert(pRect);
     1751                        vboxWddmRectUnited(&pLockAlloc->LockInfo.Area, pRect);
     1752                    }
     1753
     1754                    Assert(pLockAlloc->LockInfo.LockedRect.pBits);
     1755                    if (pLockAlloc->LockInfo.LockedRect.pBits)
     1756                    {
     1757                        Assert(pLockAlloc->LockInfo.LockedRect.Pitch == LockInfo.Pitch);
     1758                        pLockAlloc->LockInfo.LockedRect.pBits = RT_MIN(pLockAlloc->LockInfo.LockedRect.pBits, LockInfo.pBits);
     1759                    }
     1760                    else
     1761                        pLockAlloc->LockInfo.LockedRect = LockInfo;
     1762                }
     1763                else
     1764                {
     1765//                    Assert(pLockAlloc->LockInfo.fFlags.Value == 0);
     1766                    pLockAlloc->LockInfo.fFlags = pData->Flags;
     1767                    if (pRect)
     1768                    {
     1769                        pLockAlloc->LockInfo.Area = *pRect;
     1770                        Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
     1771//                        pLockAlloc->LockInfo.fFlags.AreaValid = 1;
     1772                    }
     1773                    else
     1774                    {
     1775                        Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
     1776//                        pLockAlloc->LockInfo.fFlags.AreaValid = 0;
     1777                    }
     1778
     1779                    pLockAlloc->LockInfo.LockedRect = LockInfo;
     1780                }
     1781                ++pLockAlloc->LockInfo.cLocks;
     1782
     1783                if (!pData->Flags.NotifyOnly)
     1784                {
     1785                    pData->pSurfData = LockInfo.pBits;
     1786                    pData->Pitch = LockInfo.Pitch;
     1787                    pData->SlicePitch = 0;
     1788                    Assert(pLockAlloc->SurfDesc.slicePitch == 0);
     1789                    Assert(!pLockAlloc->pvMem);
     1790                }
     1791                else
     1792                {
     1793                    Assert(pLockAlloc->pvMem);
     1794                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
     1795                    if (/* !pData->Flags.WriteOnly && */ !pData->Flags.Discard)
     1796                        vboxWddmLockUnlockMemSynch(pLockAlloc, &LockInfo, pRect, false /*bool bToLockInfo*/);
     1797                }
     1798            }
    16031799        }
    16041800        else
    … …  
    16641860{
    16651861    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1666     AssertBreakpoint();
    16671862    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
    16681863    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
    … …  
    16731868        return E_INVALIDARG;
    16741869
    1675     struct
     1870    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
    16761871    {
    1677         D3DDDICB_UNLOCK Unlock;
    1678         D3DKMT_HANDLE hAllocation;
    1679     } UnlockData;
    1680 
    1681     UnlockData.Unlock.NumAllocations = 1;
    1682     UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
    1683     UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation;
    1684 
    1685     hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock);
    1686     Assert(hr == S_OK);
     1872        if (pRc->RcDesc.fFlags.Texture)
     1873        {
     1874            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     1875            Assert(pData->SubResourceIndex < pRc->cAllocations);
     1876            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     1877            Assert(pLockAlloc->LockInfo.cLocks);
     1878            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
     1879            Assert(pD3DIfTex);
     1880            /* this is a sysmem texture, update  */
     1881            if (pLockAlloc->pvMem && !pLockAlloc->LockInfo.fFlags.ReadOnly)
     1882            {
     1883                vboxWddmLockUnlockMemSynch(pLockAlloc, &pLockAlloc->LockInfo.LockedRect,
     1884                        pLockAlloc->LockInfo.fFlags.AreaValid ? &pLockAlloc->LockInfo.Area : NULL,
     1885                        true /*bool bToLockInfo*/);
     1886            }
     1887            hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
     1888            Assert(hr == S_OK);
     1889            if (hr == S_OK)
     1890            {
     1891                --pLockAlloc->LockInfo.cLocks;
     1892                Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
     1893            }
     1894        }
     1895        else
     1896        {
     1897            AssertBreakpoint();
     1898        }
     1899    }
     1900    else
     1901    {
     1902        struct
     1903        {
     1904            D3DDDICB_UNLOCK Unlock;
     1905            D3DKMT_HANDLE hAllocation;
     1906        } UnlockData;
     1907
     1908        UnlockData.Unlock.NumAllocations = 1;
     1909        UnlockData.Unlock.phAllocations = &UnlockData.hAllocation;
     1910        UnlockData.hAllocation = pRc->aAllocations[pData->SubResourceIndex].hAllocation;
     1911
     1912        hr = pDevice->RtCallbacks.pfnUnlockCb(hDevice, &UnlockData.Unlock);
     1913        Assert(hr == S_OK);
     1914    }
    16871915
    16881916    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    … …  
    17371965                pAllocation->hAllocation = NULL;
    17381966                pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
    1739                 pAllocation->pvMem = pSurf->pSysMem;
     1967                pAllocation->pvMem = (void*)pSurf->pSysMem;
    17401968                pAllocation->SurfDesc.pitch = pSurf->SysMemPitch;
    17411969                pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
    … …  
    17992027                {
    18002028                    PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
    1801                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
    1802                     Assert(!pSurf->pSysMem);
    18032029                    IDirect3DSurface9 *pD3D9Surf;
    1804                     hr = pDevice->pDevice9If->CreateDepthStencilSurface(pSurf->Width,
    1805                             pSurf->Height,
     2030                    hr = pDevice->pDevice9If->CreateDepthStencilSurface(pAllocation->SurfDesc.width,
     2031                            pAllocation->SurfDesc.height,
    18062032                            vboxDDI2D3DFormat(pResource->Format),
    18072033                            vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
    … …  
    18142040                    {
    18152041                        Assert(pD3D9Surf);
     2042                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
     2043                        {
     2044                            Assert(pAllocation->pvMem);
     2045                            D3DLOCKED_RECT lockInfo;
     2046                            hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
     2047                            Assert(hr == S_OK);
     2048                            if (hr == S_OK)
     2049                            {
     2050                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2051                                HRESULT tmpHr = pD3D9Surf->UnlockRect();
     2052                                Assert(tmpHr == S_OK);
     2053                            }
     2054                        }
     2055                        else
     2056                        {
     2057                            Assert(!pAllocation->pvMem);
     2058                        }
    18162059                        pAllocation->pD3DIf = pD3D9Surf;
    18172060                    }
    … …  
    18322075                {
    18332076                    PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
    1834                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
    1835                     Assert(!pSurf->pSysMem);
    18362077                    IDirect3DVertexBuffer9  *pD3D9VBuf;
    1837                     hr = pDevice->pDevice9If->CreateVertexBuffer(pSurf->Width,
     2078                    hr = pDevice->pDevice9If->CreateVertexBuffer(pAllocation->SurfDesc.width,
    18382079                            vboxDDI2D3DUsage(pResource->Flags),
    18392080                            pResource->Fvf,
    … …  
    18452086                    {
    18462087                        Assert(pD3D9VBuf);
     2088                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
     2089                        {
     2090                            Assert(pAllocation->pvMem);
     2091                            D3DLOCKED_RECT lockInfo;
     2092                            hr = pD3D9VBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
     2093                            Assert(hr == S_OK);
     2094                            if (hr == S_OK)
     2095                            {
     2096                                lockInfo.Pitch = pAllocation->SurfDesc.pitch;
     2097                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2098                                HRESULT tmpHr = pD3D9VBuf->Unlock();
     2099                                Assert(tmpHr == S_OK);
     2100                            }
     2101                        }
     2102                        else
     2103                        {
     2104                            Assert(!pAllocation->pvMem);
     2105                        }
    18472106                        pAllocation->pD3DIf = pD3D9VBuf;
    18482107                    }
    … …  
    18642123                    PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
    18652124                    CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
    1866                     Assert(!pSurf->pSysMem);
    18672125                    IDirect3DIndexBuffer9  *pD3D9IBuf;
    18682126                    hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
    … …  
    18772135                    {
    18782136                        Assert(pD3D9IBuf);
     2137                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
     2138                        {
     2139                            Assert(pAllocation->pvMem);
     2140                            D3DLOCKED_RECT lockInfo;
     2141                            hr = pD3D9IBuf->Lock(0, pAllocation->SurfDesc.width, &lockInfo.pBits, D3DLOCK_DISCARD);
     2142                            Assert(hr == S_OK);
     2143                            if (hr == S_OK)
     2144                            {
     2145                                lockInfo.Pitch = pAllocation->SurfDesc.pitch;
     2146                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2147                                HRESULT tmpHr = pD3D9IBuf->Unlock();
     2148                                Assert(tmpHr == S_OK);
     2149                            }
     2150                        }
     2151                        else
     2152                        {
     2153                            Assert(!pAllocation->pvMem);
     2154                        }
    18792155                        pAllocation->pD3DIf = pD3D9IBuf;
    18802156                    }
    … …  
    19232199                {
    19242200                    Assert(pD3DIfTex);
    1925                     pAllocation->pD3DIf = pD3DIfTex;
    1926                     for (UINT i = 0; i < pResource->SurfCount; ++i)
     2201                    if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    19272202                    {
    1928                         D3DLOCKED_RECT lockInfo;
    1929                         CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
    1930                         hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
    1931                         Assert(hr == S_OK);
    1932                         if (hr == S_OK)
     2203                        for (UINT i = 0; i < pResource->SurfCount; ++i)
    19332204                        {
    1934                             Assert(lockInfo.Pitch == pSurf->SysMemPitch);
    1935                             if (pSurf->SysMemPitch == lockInfo.Pitch)
     2205                            D3DLOCKED_RECT lockInfo;
     2206                            PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
     2207                            Assert(pAllocation->pvMem);
     2208                            hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
     2209                            Assert(hr == S_OK);
     2210                            if (hr == S_OK)
    19362211                            {
    1937                                 memcpy(lockInfo.pBits, pSurf->pSysMem, pSurf->SysMemPitch * pSurf->Height);
     2212                                vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2213                                HRESULT tmpHr = pD3DIfTex->UnlockRect(i);
     2214                                Assert(tmpHr == S_OK);
    19382215                            }
    19392216                            else
    19402217                            {
    1941                                 uint8_t * pvSrc = (uint8_t *)pSurf->pSysMem;
    1942                                 uint8_t * pvDst = (uint8_t *)lockInfo.pBits;
    1943                                 uint32_t pitch = RT_MIN(pSurf->SysMemPitch, (UINT)lockInfo.Pitch);
    1944                                 Assert(pitch);
    1945                                 for (UINT j = 0; j < pSurf->Height; ++j)
    1946                                 {
    1947                                     memcpy(pvDst, pvSrc, pitch);
    1948                                     pvSrc += pSurf->SysMemPitch;
    1949                                     pvDst += lockInfo.Pitch;
    1950                                 }
     2218                                pD3DIfTex->Release();
     2219                                break;
    19512220                            }
    1952                             pD3DIfTex->UnlockRect(i);
    1953                         }
    1954                         else
    1955                         {
    1956                             pD3DIfTex->Release();
    1957                             break;
    19582221                        }
    19592222                    }
     2223                    pAllocation->pD3DIf = pD3DIfTex;
    19602224                }
     2225#ifdef DEBUG
     2226                else
     2227                {
     2228                    for (UINT i = 0; i < pResource->SurfCount; ++i)
     2229                    {
     2230                        PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
     2231                        Assert(!pAllocation->pvMem);
     2232                    }
     2233                }
     2234#endif
    19612235            }
    19622236            else
    … …  
    20792353                        pAllocation->hAllocation = pDdiAllocInfo->hAllocation;
    20802354                        pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
    2081                         pAllocation->pvMem = pSurf->pSysMem;
     2355                        pAllocation->pvMem = (void*)pSurf->pSysMem;
    20822356                        pAllocation->SurfDesc = pAllocInfo->SurfDesc;
    20832357                    }

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

    r30057 r30096  
    8080} VBOXWDDMDISP_DEVICE, *PVBOXWDDMDISP_DEVICE;
    8181
     82typedef struct VBOXWDDMDISP_LOCKINFO
     83{
     84    uint32_t cLocks;
     85    union {
     86        D3DDDIRANGE  Range;
     87        RECT  Area;
     88        D3DDDIBOX  Box;
     89    };
     90    D3DDDI_LOCKFLAGS fFlags;
     91    D3DLOCKED_RECT LockedRect;
     92} VBOXWDDMDISP_LOCKINFO;
     93
    8294typedef struct VBOXWDDMDISP_ALLOCATION
    8395{
    8496    D3DKMT_HANDLE hAllocation;
    8597    VBOXWDDM_ALLOC_TYPE enmType;
    86     CONST VOID* pvMem;
     98    void* pvMem;
    8799    /* object type depends on resource type */
    88100    IUnknown *pD3DIf;
     101    VBOXWDDMDISP_LOCKINFO LockInfo;
    89102    VBOXWDDM_SURFACE_DESC SurfDesc;
    90103} VBOXWDDMDISP_ALLOCATION, *PVBOXWDDMDISP_ALLOCATION;
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