VirtualBox

Ignore:
Timestamp:
Jul 5, 2010 11:33:23 AM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
63329
Message:

wddm/3d: render target fixes

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

    r30588 r30603  
    29342934    return NULL;
    29352935}
     2936
     2937static HRESULT vboxWddmSurfSynchMem(PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_ALLOCATION pAllocation)
     2938{
     2939    HRESULT hr = S_OK;
     2940    Assert(pAllocation->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
     2941    if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
     2942    {
     2943        Assert(pAllocation->pvMem);
     2944        D3DLOCKED_RECT lockInfo;
     2945        IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pAllocation->pD3DIf;
     2946        hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
     2947        Assert(hr == S_OK);
     2948        if (hr == S_OK)
     2949        {
     2950            vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2951            HRESULT tmpHr = pD3D9Surf->UnlockRect();
     2952            Assert(tmpHr == S_OK);
     2953        }
     2954    }
     2955    else
     2956    {
     2957        Assert(!pAllocation->pvMem);
     2958    }
     2959    return hr;
     2960}
     2961
    29362962static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
    29372963{
     
    30083034                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
    30093035                        pAllocation->pD3DIf = pD3D9Surf;
    3010                         if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    3011                         {
    3012                             Assert(pAllocation->pvMem);
    3013                             D3DLOCKED_RECT lockInfo;
    3014                             hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
    3015                             Assert(hr == S_OK);
    3016                             if (hr == S_OK)
    3017                             {
    3018                                 vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
    3019                                 HRESULT tmpHr = pD3D9Surf->UnlockRect();
    3020                                 Assert(tmpHr == S_OK);
    3021                             }
    3022                         }
    3023                         else
    3024                         {
    3025                             Assert(!pAllocation->pvMem);
    3026                         }
     3036                        hr = vboxWddmSurfSynchMem(pRc, pAllocation);
     3037                        Assert(hr == S_OK);
    30273038                    }
    30283039                    else
     
    32103221            {
    32113222                HWND hWnd = NULL;
    3212                 bool bDevCreated = false;
     3223                bIssueCreateResource = true;
    32133224                Assert(pResource->SurfCount);
    32143225                if (!pDevice->pDevice9If)
     
    32493260                            pDevice->pDevice9If = pDevice9If;
    32503261                            pDevice->hWnd = hWnd;
    3251                             bDevCreated = true;
    3252 #ifdef VBOXDISP_TMP_NEWCREATEDEVICE
     3262                            pDevice->pRenderTargetRc = pRc;
     3263#if 0
    32533264                            IDirect3DSwapChain9 *pSwapChain;
    32543265                            hr = pDevice->pDevice9If->GetSwapChain(0, &pSwapChain);
     
    32563267                            if (hr == S_OK)
    32573268                            {
    3258                                 PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
     3269                                UINT i = 0, iAlloc = 0;
    32593270                                IDirect3DSurface9* pD3D9Surf;
    3260                                 hr = pSwapChain->GetFrontBufferData(&pD3D9Surf);
    3261                                 Assert(hr == S_OK);
    3262                                 if (hr == S_OK)
     3271                                for (; i < pResource->SurfCount; ++i)
    32633272                                {
    3264                                     Assert(pD3D9Surf);
    3265                                     pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
    3266                                     pAllocation->pD3DIf = pD3D9Surf;
    3267                                     if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
     3273                                    iAlloc = (i < pResource->SurfCount - 1) ? i+1 : 0;
     3274                                    PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[iAlloc];
     3275                                    hr = pSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
     3276                                    Assert(hr == S_OK);
     3277                                    if (hr == S_OK)
    32683278                                    {
    3269                                         Assert(pAllocation->pvMem);
    3270                                         D3DLOCKED_RECT lockInfo;
    3271                                         hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
     3279                                        Assert(pD3D9Surf);
     3280                                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
     3281                                        pAllocation->pD3DIf = pD3D9Surf;
     3282                                        hr = vboxWddmSurfSynchMem(pRc, pAllocation);
    32723283                                        Assert(hr == S_OK);
    32733284                                        if (hr == S_OK)
    32743285                                        {
    3275                                             vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
    3276                                             HRESULT tmpHr = pD3D9Surf->UnlockRect();
    3277                                             Assert(tmpHr == S_OK);
    3278                                         }
    3279                                     }
    3280                                     else
    3281                                     {
    3282                                         Assert(!pAllocation->pvMem);
    3283                                     }
    3284 
    3285                                     pD3D9Surf->Release();
    3286 
    3287                                     if (hr == S_OK)
    3288                                     {
    3289                                         UINT i = 1;
    3290                                         for (; i < pResource->SurfCount; ++i)
    3291                                         {
    3292                                             PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
    3293                                             hr = pSwapChain->GetBackBuffer(i - 1, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
     3286                                            hr = pSwapChain->Present(NULL, NULL, NULL, NULL, 0);
    32943287                                            Assert(hr == S_OK);
    32953288                                            if (hr == S_OK)
    32963289                                            {
    3297                                                 Assert(pD3D9Surf);
    3298                                                 pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
    3299                                                 pAllocation->pD3DIf = pD3D9Surf;
    3300                                                 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    3301                                                 {
    3302                                                     Assert(pAllocation->pvMem);
    3303                                                     D3DLOCKED_RECT lockInfo;
    3304                                                     hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
    3305                                                     Assert(hr == S_OK);
    3306                                                     if (hr == S_OK)
    3307                                                     {
    3308                                                         vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
    3309                                                         HRESULT tmpHr = pD3D9Surf->UnlockRect();
    3310                                                         Assert(tmpHr == S_OK);
    3311                                                     }
    3312                                                 }
    3313                                                 else
    3314                                                 {
    3315                                                     Assert(!pAllocation->pvMem);
    3316                                                 }
    3317                                                 pD3D9Surf->Release();
    3318                                             }
    3319                                             else
    3320                                             {
    3321                                                 for (UINT j = 0; j < i; ++j)
    3322                                                 {
    3323                                                     pRc->aAllocations[j].pD3DIf->Release();
    3324                                                 }
    3325                                                 break;
     3290                                                continue;
    33263291                                            }
    33273292                                        }
     3293                                        pD3D9Surf->Release();
     3294                                    }
     3295
     3296                                    /* above we are enumerating from 1..N-1, 0,
     3297                                     * should neve release [0], as it was released above on failure */
     3298                                    for (UINT j = 1; j < iAlloc ? iAlloc : pResource->SurfCount - 1; ++j)
     3299                                    {
     3300                                        pRc->aAllocations[j].pD3DIf->Release();
    33283301                                    }
    33293302                                }
     3303                                pSwapChain->Release();
    33303304                            }
     3305
     3306                            if (hr != S_OK)
     3307                                pDevice9If->Release();
    33313308#endif
    33323309                        }
     3310
     3311                        if (hr != S_OK)
     3312                        {
     3313                            HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
     3314                            Assert(tmpHr == S_OK);
     3315                        }
    33333316                    }
     3317                }
    33343318#ifdef VBOXDISP_TMP_NEWCREATEDEVICE
    3335                     break;
    3336 #endif
    3337                 }
    33383319                else
    3339                 {
    3340                     Assert(pDevice->hWnd);
    3341                 }
    3342 
    3343 #ifndef VBOXDISP_TMP_NEWCREATEDEVICE
     3320#else
    33443321                if (hr == S_OK)
    33453322#endif
    33463323                {
     3324                    Assert(pDevice->hWnd);
    33473325                    Assert(pDevice->pDevice9If);
    3348                     bIssueCreateResource = true;
    33493326                    for (UINT i = 0; i < pResource->SurfCount; ++i)
    33503327                    {
     
    33673344                            pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
    33683345                            pAllocation->pD3DIf = pD3D9Surf;
    3369                             if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    3370                             {
    3371                                 Assert(pAllocation->pvMem);
    3372                                 D3DLOCKED_RECT lockInfo;
    3373                                 hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
    3374                                 Assert(hr == S_OK);
    3375                                 if (hr == S_OK)
    3376                                 {
    3377                                     vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
    3378                                     HRESULT tmpHr = pD3D9Surf->UnlockRect();
    3379                                     Assert(tmpHr == S_OK);
    3380                                 }
    3381                             }
    3382                             else
    3383                             {
    3384                                 Assert(!pAllocation->pvMem);
    3385                             }
     3346                            hr = vboxWddmSurfSynchMem(pRc, pAllocation);
     3347                            Assert(hr == S_OK);
     3348                            if (hr == S_OK)
     3349                                continue;
     3350
     3351                            /* fail branch */
     3352                            pD3D9Surf->Release();
    33863353                        }
    3387                         else
     3354
     3355                        for (UINT j = 0; j < i; ++j)
    33883356                        {
    3389                             for (UINT j = 0; j < i; ++j)
    3390                             {
    3391                                 pRc->aAllocations[j].pD3DIf->Release();
    3392                             }
    3393                             break;
     3357                            pRc->aAllocations[j].pD3DIf->Release();
    33943358                        }
     3359                        break;
    33953360                    }
    33963361                }
    3397 #ifndef VBOXDISP_TMP_NEWCREATEDEVICE
    3398                 if (hr != S_OK)
    3399                 {
    3400                     if (bDevCreated)
    3401                     {
    3402                         VBoxDispWndDestroy(pAdapter, hWnd);
    3403                         pDevice->pDevice9If->Release();
    3404                     }
    3405                 }
    3406 #endif
    34073362            }
    34083363            else
     
    35973552    DdiDm.hPrimaryAllocation = pAlloc->hAllocation;
    35983553//    DdiDm.PrivateDriverFormatAttribute = 0;
     3554    Assert(pDevice->pRenderTargetRc == pRc);
     3555
    35993556#if 0
    36003557    IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
     
    41804137    Assert(pRc);
    41814138    Assert(pData->SubResourceIndex < pRc->cAllocations);
    4182     IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[pData->SubResourceIndex].pD3DIf;
    4183     Assert(pD3D9Surf);
    4184     HRESULT hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
    4185     Assert(hr == S_OK);
     4139    HRESULT hr = S_OK;
     4140#ifdef VBOXDISP_TMP_NEWCREATEDEVICE
     4141    if (pRc != pDevice->pRenderTargetRc || pRc->cAllocations > 1 || pData->RenderTargetIndex)
     4142#endif
     4143    {
     4144        IDirect3DSurface9 *pD3D9Surf;
     4145        hr = vboxWddmSurfGet(pRc, pData->SubResourceIndex, &pD3D9Surf);
     4146        Assert(hr == S_OK);
     4147        if (hr == S_OK)
     4148        {
     4149            Assert(pD3D9Surf);
     4150            hr = pDevice->pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
     4151            Assert(hr == S_OK);
     4152            pD3D9Surf->Release();
     4153        }
     4154    }
    41864155    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    41874156    return hr;
  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h

    r30582 r30603  
    102102    D3DDDI_CREATEDEVICEFLAGS fFlags;
    103103    HWND hWnd;
     104    struct VBOXWDDMDISP_RESOURCE *pRenderTargetRc;
    104105    /* number of StreamSources set */
    105106    UINT cStreamSources;
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