VirtualBox

Changeset 100157 in vbox for trunk/src/VBox/Devices/Graphics


Ignore:
Timestamp:
Jun 12, 2023 3:45:53 PM (23 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
157853
Message:

Devices/Graphics: merged SCREEN_TARGET resource type with TEXTURE_2D. bugref:9830

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx-dx11.cpp

    r100066 r100157  
    162162{
    163163    VMSVGA3D_RESTYPE_NONE           = 0,
    164     VMSVGA3D_RESTYPE_SCREEN_TARGET  = 1,
    165     VMSVGA3D_RESTYPE_TEXTURE_1D     = 2,
    166     VMSVGA3D_RESTYPE_TEXTURE_2D     = 3,
    167     VMSVGA3D_RESTYPE_TEXTURE_CUBE   = 4,
    168     VMSVGA3D_RESTYPE_TEXTURE_3D     = 5,
    169     VMSVGA3D_RESTYPE_BUFFER         = 6,
     164    VMSVGA3D_RESTYPE_TEXTURE_1D     = 1,
     165    VMSVGA3D_RESTYPE_TEXTURE_2D     = 2,
     166    VMSVGA3D_RESTYPE_TEXTURE_CUBE   = 3,
     167    VMSVGA3D_RESTYPE_TEXTURE_3D     = 4,
     168    VMSVGA3D_RESTYPE_BUFFER         = 5,
    170169} VMSVGA3DBACKRESTYPE;
    171170
    … …  
    21782177
    21792178
    2180 static int vmsvga3dBackSurfaceCreateScreenTarget(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
    2181 {
    2182     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2183     AssertReturn(p3dState, VERR_INVALID_STATE);
    2184 
    2185     PVMSVGA3DBACKEND pBackend = p3dState->pBackend;
    2186     AssertReturn(pBackend, VERR_INVALID_STATE);
    2187 
    2188     DXDEVICE *pDXDevice = &pBackend->dxDevice;
    2189     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
    2190 
    2191     /* Surface must have SCREEN_TARGET flag. */
    2192     ASSERT_GUEST_RETURN(RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET), VERR_INVALID_PARAMETER);
    2193 
    2194     if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
    2195     {
    2196         AssertFailed(); /* Should the function not be used like that? */
    2197         vmsvga3dBackSurfaceDestroy(pThisCC, false, pSurface);
    2198     }
    2199 
    2200     PVMSVGA3DBACKENDSURFACE pBackendSurface;
    2201     int rc = dxBackendSurfaceAlloc(&pBackendSurface);
    2202     AssertRCReturn(rc, rc);
    2203 
    2204     D3D11_TEXTURE2D_DESC td;
    2205     RT_ZERO(td);
    2206     td.Width              = pSurface->paMipmapLevels[0].mipmapSize.width;
    2207     td.Height             = pSurface->paMipmapLevels[0].mipmapSize.height;
    2208     Assert(pSurface->cLevels == 1);
    2209     td.MipLevels          = 1;
    2210     td.ArraySize          = 1;
    2211     td.Format             = vmsvgaDXSurfaceFormat2Dxgi(pSurface->format);
    2212     td.SampleDesc.Count   = 1;
    2213     td.SampleDesc.Quality = 0;
    2214     td.Usage              = D3D11_USAGE_DEFAULT;
    2215     td.BindFlags          = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
    2216     td.CPUAccessFlags     = 0;
    2217     td.MiscFlags          = pBackend->fSingleDevice ? 0 : D3D11_RESOURCE_MISC_SHARED;
    2218 
    2219     HRESULT hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.pTexture2D);
    2220     Assert(SUCCEEDED(hr));
    2221     if (SUCCEEDED(hr))
    2222     {
    2223         /* Map-able texture. */
    2224         td.Usage          = D3D11_USAGE_DYNAMIC;
    2225         td.BindFlags      = D3D11_BIND_SHADER_RESOURCE; /* Have to specify a supported flag, otherwise E_INVALIDARG will be returned. */
    2226         td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    2227         td.MiscFlags      = 0;
    2228         hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->dynamic.pTexture2D);
    2229         Assert(SUCCEEDED(hr));
    2230     }
    2231 
    2232     if (SUCCEEDED(hr))
    2233     {
    2234         /* Staging texture. */
    2235         td.Usage          = D3D11_USAGE_STAGING;
    2236         td.BindFlags      = 0; /* No flags allowed. */
    2237         td.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
    2238         hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->staging.pTexture2D);
    2239         Assert(SUCCEEDED(hr));
    2240     }
    2241 
    2242     if (SUCCEEDED(hr))
    2243         hr = dxInitSharedHandle(pBackend, pBackendSurface);
    2244 
    2245     if (SUCCEEDED(hr))
    2246     {
    2247         /*
    2248          * Success.
    2249          */
    2250         pBackendSurface->enmResType = VMSVGA3D_RESTYPE_SCREEN_TARGET;
    2251         pBackendSurface->enmDxgiFormat = td.Format;
    2252         pSurface->pBackendSurface = pBackendSurface;
    2253         pSurface->idAssociatedContext = DX_CID_BACKEND;
    2254         return VINF_SUCCESS;
    2255     }
    2256 
    2257     /* Failure. */
    2258     D3D_RELEASE(pBackendSurface->staging.pTexture2D);
    2259     D3D_RELEASE(pBackendSurface->dynamic.pTexture2D);
    2260     D3D_RELEASE(pBackendSurface->u.pTexture2D);
    2261     RTMemFree(pBackendSurface);
    2262     return VERR_NO_MEMORY;
    2263 }
    2264 
    2265 
    22662179static UINT dxBindFlags(SVGA3dSurfaceAllFlags surfaceFlags)
    22672180{
    … …  
    22942207    }
    22952208
    2296     if (dxIsSurfaceShareable(pSurface))
     2209    if (!pDXContext || dxIsSurfaceShareable(pSurface))
    22972210    {
    22982211        *pMiscFlags = D3D11_RESOURCE_MISC_SHARED;
    … …  
    24992412
    25002413    HRESULT hr = S_OK;
    2501     if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET)
    2502     {
    2503         /*
    2504          * Create the texture in backend device and open for the specified context.
    2505          */
    2506         D3D11_TEXTURE2D_DESC td;
    2507         RT_ZERO(td);
    2508         td.Width              = pSurface->paMipmapLevels[0].mipmapSize.width;
    2509         td.Height             = pSurface->paMipmapLevels[0].mipmapSize.height;
    2510         Assert(pSurface->cLevels == 1);
    2511         td.MipLevels          = 1;
    2512         td.ArraySize          = 1;
    2513         td.Format             = dxgiFormat;
    2514         td.SampleDesc.Count   = 1;
    2515         td.SampleDesc.Quality = 0;
    2516         td.Usage              = D3D11_USAGE_DEFAULT;
    2517         td.BindFlags          = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
    2518         td.CPUAccessFlags     = 0;
    2519         td.MiscFlags          = MiscFlags;
    2520 
    2521         hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.pTexture2D);
    2522         Assert(SUCCEEDED(hr));
    2523         if (SUCCEEDED(hr))
    2524         {
    2525             /* Map-able texture. */
    2526             td.Format         = dxgiFormatDynamic;
    2527             td.Usage          = D3D11_USAGE_DYNAMIC;
    2528             td.BindFlags      = D3D11_BIND_SHADER_RESOURCE; /* Have to specify a supported flag, otherwise E_INVALIDARG will be returned. */
    2529             td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    2530             td.MiscFlags      = 0;
    2531             hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->dynamic.pTexture2D);
    2532             Assert(SUCCEEDED(hr));
    2533         }
    2534 
    2535         if (SUCCEEDED(hr))
    2536         {
    2537             /* Staging texture. */
    2538             td.Format         = dxgiFormatStaging;
    2539             td.Usage          = D3D11_USAGE_STAGING;
    2540             td.BindFlags      = 0; /* No flags allowed. */
    2541             td.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
    2542             hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->staging.pTexture2D);
    2543             Assert(SUCCEEDED(hr));
    2544         }
    2545 
    2546         if (SUCCEEDED(hr))
    2547             hr = dxInitSharedHandle(pBackend, pBackendSurface);
    2548 
    2549         if (SUCCEEDED(hr))
    2550         {
    2551             pBackendSurface->enmResType = VMSVGA3D_RESTYPE_SCREEN_TARGET;
    2552         }
    2553     }
    2554     else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
     2414    if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
    25552415    {
    25562416        Assert(pSurface->cFaces == 6);
    … …  
    36133473    RT_ZERO(mappedResource);
    36143474
    3615     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
    3616     {
    3617         Assert(pImage->face == 0 && pImage->mipmap == 0);
    3618 
    3619         /* Wait for the surface to finish drawing. */
    3620         dxSurfaceWait(pState, pSurface, pSurface->idAssociatedContext);
    3621 
    3622         ID3D11Texture2D *pMappedTexture;
    3623         if (enmMapType == VMSVGA3D_SURFACE_MAP_READ)
    3624         {
    3625             pMappedTexture = pBackendSurface->staging.pTexture2D;
    3626 
    3627             /* Copy the texture content to the staging texture. */
    3628             pDevice->pImmediateContext->CopyResource(pBackendSurface->staging.pTexture2D, pBackendSurface->u.pTexture2D);
    3629         }
    3630         else if (enmMapType == VMSVGA3D_SURFACE_MAP_WRITE)
    3631             pMappedTexture = pBackendSurface->staging.pTexture2D;
    3632         else
    3633             pMappedTexture = pBackendSurface->dynamic.pTexture2D;
    3634 
    3635         UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
    3636         HRESULT hr = pDevice->pImmediateContext->Map(pMappedTexture, Subresource,
    3637                                                      d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
    3638         if (SUCCEEDED(hr))
    3639             vmsvga3dSurfaceMapInit(pMap, enmMapType, &clipBox, pSurface,
    3640                                    mappedResource.pData, mappedResource.RowPitch, mappedResource.DepthPitch);
    3641         else
    3642             AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
    3643     }
    3644     else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
    3645              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
    3646              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
    3647              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     3475    if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
     3476        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
     3477        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
     3478        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
    36483479    {
    36493480        dxSurfaceWait(pState, pSurface, pSurface->idAssociatedContext);
    … …  
    38073638    AssertReturn(pDevice && pDevice->pDevice, VERR_INVALID_STATE);
    38083639
    3809     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
    3810     {
    3811         ID3D11Texture2D *pMappedTexture;
    3812         if (pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ)
    3813             pMappedTexture = pBackendSurface->staging.pTexture2D;
    3814         else if (pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE)
    3815             pMappedTexture = pBackendSurface->staging.pTexture2D;
    3816         else
    3817             pMappedTexture = pBackendSurface->dynamic.pTexture2D;
    3818 
    3819         UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
    3820         pDevice->pImmediateContext->Unmap(pMappedTexture, Subresource);
    3821 
    3822         if (   fWritten
    3823             && (   pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE
    3824                 || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ_WRITE
    3825                 || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD))
    3826         {
    3827             ID3D11Resource *pDstResource = pBackendSurface->u.pTexture2D;
    3828             UINT DstSubresource = Subresource;
    3829             UINT DstX = pMap->box.x;
    3830             UINT DstY = pMap->box.y;
    3831             UINT DstZ = pMap->box.z;
    3832             ID3D11Resource *pSrcResource = pMappedTexture;
    3833             UINT SrcSubresource = Subresource;
    3834             D3D11_BOX SrcBox;
    3835             SrcBox.left   = pMap->box.x;
    3836             SrcBox.top    = pMap->box.y;
    3837             SrcBox.front  = pMap->box.z;
    3838             SrcBox.right  = pMap->box.x + pMap->box.w;
    3839             SrcBox.bottom = pMap->box.y + pMap->box.h;
    3840             SrcBox.back   = pMap->box.z + pMap->box.d;
    3841 
    3842             pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
    3843                                                               pSrcResource, SrcSubresource, &SrcBox);
    3844 
    3845             pBackendSurface->cidDrawing = pSurface->idAssociatedContext;
    3846         }
    3847     }
    3848     else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
    3849              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
    3850              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
    3851              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     3640    if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
     3641        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
     3642        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
     3643        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
    38523644    {
    38533645        ID3D11Resource *pMappedResource;
    … …  
    40103802        {
    40113803            /* Create the actual texture. */
    4012             rc = vmsvga3dBackSurfaceCreateScreenTarget(pThisCC, pSurface);
     3804            rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, NULL, pSurface);
    40133805            AssertRCReturn(rc, rc);
    40143806        }
    … …  
    40293821    {
    40303822        AssertReturn(   pSurface->pBackendSurface
    4031                      && pSurface->pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET, VERR_INVALID_PARAMETER);
     3823                     && pSurface->pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
     3824                     && RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET), VERR_INVALID_PARAMETER);
    40323825
    40333826        HANDLE const hSharedSurface = pHwScreen->SharedHandle;
    … …  
    40633856
    40643857    PVMSVGA3DBACKENDSURFACE pBackendSurface = pSurface->pBackendSurface;
    4065     AssertReturn(pBackendSurface && pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET, VERR_INVALID_PARAMETER);
     3858    AssertReturn(   pBackendSurface
     3859                 && pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
     3860                 && RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET),
     3861                 VERR_INVALID_PARAMETER);
    40663862
    40673863    SVGA3dRect boundRect;
    … …  
    51664962    }
    51674963
    5168     if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET
    5169         || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
     4964    if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
    51704965        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
    51714966        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
    … …  
    52895084    AssertReturn(pBackendSurface, VERR_INVALID_PARAMETER);
    52905085
    5291     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
    5292     {
    5293         /** @todo This is generic code and should be in DevVGA-SVGA3d.cpp for backends which support Map/Unmap. */
    5294         AssertReturn(uHostFace == 0 && uHostMipmap == 0, VERR_INVALID_PARAMETER);
    5295 
    5296         uint32_t const u32GuestBlockX = pBox->srcx / pSurface->cxBlock;
    5297         uint32_t const u32GuestBlockY = pBox->srcy / pSurface->cyBlock;
    5298         Assert(u32GuestBlockX * pSurface->cxBlock == pBox->srcx);
    5299         Assert(u32GuestBlockY * pSurface->cyBlock == pBox->srcy);
    5300         uint32_t const cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
    5301         uint32_t const cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
    5302         AssertMsgReturn(cBlocksX && cBlocksY, ("Empty box %dx%d\n", pBox->w, pBox->h), VERR_INTERNAL_ERROR);
    5303 
    5304         /* vmsvgaR3GmrTransfer verifies uGuestOffset.
    5305          * srcx(u32GuestBlockX) and srcy(u32GuestBlockY) have been verified in vmsvga3dSurfaceDMA
    5306          * to not cause 32 bit overflow when multiplied by cbBlock and cbGuestPitch.
    5307          */
    5308         uint64_t const uGuestOffset = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch;
    5309         AssertReturn(uGuestOffset < UINT32_MAX, VERR_INVALID_PARAMETER);
    5310 
    5311         SVGA3dSurfaceImageId image;
    5312         image.sid = pSurface->id;
    5313         image.face = uHostFace;
    5314         image.mipmap = uHostMipmap;
    5315 
    5316         SVGA3dBox box;
    5317         box.x = pBox->x;
    5318         box.y = pBox->y;
    5319         box.z = 0;
    5320         box.w = pBox->w;
    5321         box.h = pBox->h;
    5322         box.d = 1;
    5323 
    5324         VMSVGA3D_SURFACE_MAP const enmMap = transfer == SVGA3D_WRITE_HOST_VRAM
    5325                                           ? VMSVGA3D_SURFACE_MAP_WRITE
    5326                                           : VMSVGA3D_SURFACE_MAP_READ;
    5327 
    5328         VMSVGA3D_MAPPED_SURFACE map;
    5329         rc = vmsvga3dBackSurfaceMap(pThisCC, &image, &box, enmMap, &map);
    5330         if (RT_SUCCESS(rc))
    5331         {
    5332             /* Prepare parameters for vmsvgaR3GmrTransfer, which needs the host buffer address, size
    5333              * and offset of the first scanline.
    5334              */
    5335             uint32_t const cbLockedBuf = map.cbRowPitch * cBlocksY;
    5336             uint8_t *pu8LockedBuf = (uint8_t *)map.pvData;
    5337             uint32_t const offLockedBuf = 0;
    5338 
    5339             rc = vmsvgaR3GmrTransfer(pThis,
    5340                                      pThisCC,
    5341                                      transfer,
    5342                                      pu8LockedBuf,
    5343                                      cbLockedBuf,
    5344                                      offLockedBuf,
    5345                                      map.cbRowPitch,
    5346                                      GuestPtr,
    5347                                      (uint32_t)uGuestOffset,
    5348                                      cbGuestPitch,
    5349                                      cBlocksX * pSurface->cbBlock,
    5350                                      cBlocksY);
    5351             AssertRC(rc);
    5352 
    5353             // Log4(("first line:\n%.*Rhxd\n", cBlocksX * pSurface->cbBlock, LockedRect.pBits));
    5354 
    5355             //vmsvga3dMapWriteBmpFile(&map, "Dynamic");
    5356 
    5357             vmsvga3dBackSurfaceUnmap(pThisCC, &image, &map, /* fWritten = */ true);
    5358         }
    5359 #if 0
    5360             //DEBUG_BREAKPOINT_TEST();
    5361             rc = vmsvga3dBackSurfaceMap(pThisCC, &image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
    5362             if (RT_SUCCESS(rc))
    5363             {
    5364                 vmsvga3dMapWriteBmpFile(&map, "Staging");
    5365 
    5366                 vmsvga3dBackSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
    5367             }
    5368 #endif
    5369     }
    5370     else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
    5371              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
    5372              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
    5373              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     5086    if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_1D
     5087        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
     5088        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
     5089        || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
    53745090    {
    53755091        /** @todo This is generic code and should be in DevVGA-SVGA3d.cpp for backends which support Map/Unmap. */
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