VirtualBox

Ignore:
Timestamp:
Jul 2, 2010 4:03:52 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: better Blt impl + bugfixes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r30570 r30582  
    11871187        fFlags |= D3DLOCK_DONOTWAIT;
    11881188    return fFlags;
     1189}
     1190
     1191D3DTEXTUREFILTERTYPE vboxDDI2D3DBltFlags(D3DDDI_BLTFLAGS fFlags)
     1192{
     1193    if (fFlags.Point)
     1194    {
     1195        /* no flags other than [Begin|Continue|End]PresentToDwm are set */
     1196        Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 1);
     1197        return D3DTEXF_POINT;
     1198    }
     1199    if (fFlags.Linear)
     1200    {
     1201        /* no flags other than [Begin|Continue|End]PresentToDwm are set */
     1202        Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 2);
     1203        return D3DTEXF_LINEAR;
     1204    }
     1205    /* no flags other than [Begin|Continue|End]PresentToDwm are set */
     1206    Assert((fFlags.Value & (~(0x00000100 | 0x00000200 | 0x00000400))) == 0);
     1207    return D3DTEXF_NONE;
    11891208}
    11901209
    … …  
    16181637    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
    16191638//    Assert(pRc);
    1620     IDirect3DTexture9 *pD3DIfTex = pRc ? (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf : NULL;
     1639    IDirect3DTexture9 *pD3DIfTex;
     1640    if (pRc)
     1641    {
     1642        Assert(pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE);
     1643        pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
     1644    }
     1645    else
     1646        pD3DIfTex = NULL;
     1647
    16211648//    Assert(pD3DIfTex);
    16221649    HRESULT hr = pDevice->pDevice9If->SetTexture(Stage, pD3DIfTex);
    … …  
    23142341    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
    23152342    {
    2316         if (pRc->RcDesc.fFlags.Texture || pRc->RcDesc.fFlags.Value == 0)
     2343        if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
    23172344        {
    23182345            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
    … …  
    24202447            }
    24212448        }
    2422         else if (pRc->RcDesc.fFlags.VertexBuffer)
     2449        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
    24232450        {
    24242451            Assert(pData->SubResourceIndex < pRc->cAllocations);
    … …  
    25172544            }
    25182545        }
    2519         else if (pRc->RcDesc.fFlags.IndexBuffer)
     2546        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
    25202547        {
    25212548            Assert(pData->SubResourceIndex < pRc->cAllocations);
    … …  
    27032730    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
    27042731    {
    2705         if (pRc->RcDesc.fFlags.Texture || pRc->RcDesc.fFlags.Value == 0)
     2732        if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
    27062733        {
    27072734            Assert(pData->SubResourceIndex < pRc->cAllocations);
    … …  
    27322759            }
    27332760        }
    2734         else if (pRc->RcDesc.fFlags.VertexBuffer)
     2761        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
    27352762        {
    27362763            Assert(pData->SubResourceIndex < pRc->cAllocations);
    … …  
    27722799            }
    27732800        }
    2774         else if (pRc->RcDesc.fFlags.IndexBuffer)
     2801        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
    27752802        {
    27762803            Assert(pData->SubResourceIndex < pRc->cAllocations);
    … …  
    29793006                    {
    29803007                        Assert(pD3D9Surf);
     3008                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
     3009                        pAllocation->pD3DIf = pD3D9Surf;
    29813010                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    29823011                        {
    … …  
    29963025                            Assert(!pAllocation->pvMem);
    29973026                        }
    2998                         pAllocation->pD3DIf = pD3D9Surf;
    29993027                    }
    30003028                    else
    … …  
    30253053                    {
    30263054                        Assert(pD3D9VBuf);
     3055                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_VERTEXBUFFER;
     3056                        pAllocation->pD3DIf = pD3D9VBuf;
    30273057                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    30283058                        {
    … …  
    30433073                            Assert(!pAllocation->pvMem);
    30443074                        }
    3045                         pAllocation->pD3DIf = pD3D9VBuf;
    30463075                    }
    30473076                    else
    … …  
    30743103                    {
    30753104                        Assert(pD3D9IBuf);
     3105                        pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_INDEXBUFFER;
     3106                        pAllocation->pD3DIf = pD3D9IBuf;
    30763107                        if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    30773108                        {
    … …  
    30923123                            Assert(!pAllocation->pvMem);
    30933124                        }
    3094                         pAllocation->pD3DIf = pD3D9IBuf;
    30953125                    }
    30963126                    else
    … …  
    31213151                }
    31223152#endif
     3153
     3154                if (pResource->Flags.RenderTarget)
     3155                    bIssueCreateResource = true;
    31233156
    31243157                PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
    … …  
    31383171                {
    31393172                    Assert(pD3DIfTex);
     3173                    pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
     3174                    pAllocation->pD3DIf = pD3DIfTex;
    31403175                    if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    31413176                    {
    … …  
    31603195                        }
    31613196                    }
    3162                     pAllocation->pD3DIf = pD3DIfTex;
    31633197                }
    31643198#ifdef DEBUG
    … …  
    31923226                        D3DPRESENT_PARAMETERS params;
    31933227                        memset(&params, 0, sizeof (params));
    3194             //            params.BackBufferWidth = 0;
    3195             //            params.BackBufferHeight = 0;
     3228                        //            params.BackBufferWidth = 0;
     3229                        //            params.BackBufferHeight = 0;
    31963230                        params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
    31973231                        Assert(pResource->SurfCount);
    … …  
    32013235                            params.SwapEffect = D3DSWAPEFFECT_DISCARD;
    32023236                        params.hDeviceWindow = hWnd;
    3203                         /* @todo: it seems there should be a way to detect this correctly since
    3204                          * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
     3237                                    /* @todo: it seems there should be a way to detect this correctly since
     3238                                     * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
    32053239                        params.Windowed = TRUE;
    3206             //            params.EnableAutoDepthStencil = FALSE;
    3207             //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
    3208             //            params.Flags;
    3209             //            params.FullScreen_RefreshRateInHz;
    3210             //            params.FullScreen_PresentationInterval;
     3240                        //            params.EnableAutoDepthStencil = FALSE;
     3241                        //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
     3242                        //            params.Flags;
     3243                        //            params.FullScreen_RefreshRateInHz;
     3244                        //            params.FullScreen_PresentationInterval;
    32113245                        hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
    32123246                        Assert(hr == S_OK);
    … …  
    32223256                {
    32233257                    Assert(pDevice->hWnd);
    3224 
    32253258                }
    32263259
    … …  
    32353268                        IDirect3DSurface9* pD3D9Surf;
    32363269                        hr = pDevice->pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
    3237                                     pAllocation->SurfDesc.height,
    3238                                     vboxDDI2D3DFormat(pResource->Format),
    3239                                     vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
    3240                                     pResource->MultisampleQuality,
    3241                                     !pResource->Flags.NotLockable /* BOOL Lockable */,
    3242                                     &pD3D9Surf,
    3243                                     NULL /* HANDLE* pSharedHandle */
    3244                                   );
     3270                                pAllocation->SurfDesc.height,
     3271                                vboxDDI2D3DFormat(pResource->Format),
     3272                                vboxDDI2D3DMultiSampleType(pResource->MultisampleType),
     3273                                pResource->MultisampleQuality,
     3274                                !pResource->Flags.NotLockable /* BOOL Lockable */,
     3275                                &pD3D9Surf,
     3276                                NULL /* HANDLE* pSharedHandle */
     3277                                );
    32453278                        Assert(hr == S_OK);
    32463279                        if (hr == S_OK)
    32473280                        {
    32483281                            Assert(pD3D9Surf);
     3282                            pAllocation->enmD3DIfType = VBOXDISP_D3DIFTYPE_SURFACE;
     3283                            pAllocation->pD3DIf = pD3D9Surf;
    32493284                            if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    32503285                            {
    … …  
    32643299                                Assert(!pAllocation->pvMem);
    32653300                            }
    3266                             pAllocation->pD3DIf = pD3D9Surf;
    32673301                        }
    32683302                        else
    … …  
    34723506    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
    34733507    Assert(pRc->RcDesc.fFlags.RenderTarget);
     3508    Assert(pRc->aAllocations[pData->SubResourceIndex].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
    34743509    Assert(pAlloc->hAllocation);
    34753510    D3DDDICB_SETDISPLAYMODE DdiDm = {0};
    … …  
    36103645    Assert(pDevice->pDevice9If);
    36113646    IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
    3612     HRESULT hr = pDecl->Release();
    3613     Assert(hr == S_OK);
     3647    HRESULT hr = S_OK;
     3648    pDecl->Release();
    36143649    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    36153650    return hr;
    … …  
    36533688    Assert(pDevice->pDevice9If);
    36543689    IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
    3655     HRESULT hr = pShader->Release();
    3656     Assert(hr == S_OK);
     3690    HRESULT hr = S_OK;
     3691    pShader->Release();
    36573692    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    36583693    return hr;
    … …  
    37503785    return E_FAIL;
    37513786}
    3752 static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_ALLOCATION pAlloc, UINT iAlloc, D3DDDI_RESOURCEFLAGS fAllocType,
     3787static HRESULT vboxWddmLockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc,
    37533788        D3DLOCKED_RECT * pLockedRect,
    37543789        CONST RECT *pRect,
    … …  
    37563791{
    37573792    HRESULT hr = E_FAIL;
    3758     Assert(!pAlloc->LockInfo.cLocks);
    3759     if (fAllocType.Texture || fAllocType.Value == 0)
    3760     {
    3761         IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pAlloc->pD3DIf;
    3762         Assert(pD3DIfTex);
    3763         hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
    3764         Assert(hr == S_OK);
    3765     }
    3766     else if (fAllocType.RenderTarget)
    3767     {
    3768         IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
    3769         Assert(pD3DIfSurf);
    3770         hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
    3771         Assert(hr == S_OK);
    3772     }
    3773     else
    3774     {
    3775         AssertBreakpoint();
    3776     }
    3777     return hr;
    3778 }
    3779 static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_ALLOCATION pAlloc, UINT iAlloc, D3DDDI_RESOURCEFLAGS fAllocType)
    3780 {
    3781     HRESULT hr = E_FAIL;
    3782     Assert(!pAlloc->LockInfo.cLocks);
    3783     if (fAllocType.Texture || fAllocType.Value == 0)
    3784     {
    3785         IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pAlloc->pD3DIf;
    3786         Assert(pD3DIfTex);
    3787         hr = pD3DIfTex->UnlockRect(iAlloc);
    3788         Assert(hr == S_OK);
    3789     }
    3790     else if (fAllocType.RenderTarget)
    3791     {
    3792         IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
    3793         Assert(pD3DIfSurf);
    3794         hr = pD3DIfSurf->UnlockRect();
    3795         Assert(hr == S_OK);
    3796     }
    3797     else
    3798     {
    3799         AssertBreakpoint();
    3800     }
    3801     return hr;
    3802 }
     3793    Assert(!pRc->aAllocations[iAlloc].LockInfo.cLocks);
     3794    Assert(pRc->cAllocations > iAlloc);
     3795    switch (pRc->aAllocations[0].enmD3DIfType)
     3796    {
     3797        case VBOXDISP_D3DIFTYPE_SURFACE:
     3798        {
     3799            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
     3800            Assert(pD3DIfSurf);
     3801            hr = pD3DIfSurf->LockRect(pLockedRect, pRect, fLockFlags);
     3802            Assert(hr == S_OK);
     3803            break;
     3804        }
     3805        case VBOXDISP_D3DIFTYPE_TEXTURE:
     3806        {
     3807            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
     3808            Assert(pD3DIfTex);
     3809            hr = pD3DIfTex->LockRect(iAlloc, pLockedRect, pRect, fLockFlags);
     3810            Assert(hr == S_OK);
     3811            break;
     3812        }
     3813        default:
     3814            AssertBreakpoint();
     3815            break;
     3816    }
     3817    return hr;
     3818}
     3819static HRESULT vboxWddmUnlockRect(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc)
     3820{
     3821    HRESULT hr = S_OK;
     3822    Assert(pRc->cAllocations > iAlloc);
     3823    switch (pRc->aAllocations[0].enmD3DIfType)
     3824    {
     3825        case VBOXDISP_D3DIFTYPE_SURFACE:
     3826        {
     3827            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
     3828            Assert(pD3DIfSurf);
     3829            hr = pD3DIfSurf->UnlockRect();
     3830            Assert(hr == S_OK);
     3831            break;
     3832        }
     3833        case VBOXDISP_D3DIFTYPE_TEXTURE:
     3834        {
     3835            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
     3836            Assert(pD3DIfTex);
     3837            hr = pD3DIfTex->UnlockRect(iAlloc);
     3838            Assert(hr == S_OK);
     3839            break;
     3840        }
     3841        default:
     3842            AssertBreakpoint();
     3843            hr = E_FAIL;
     3844            break;
     3845    }
     3846    return hr;
     3847}
     3848
     3849/* on success increments the surface ref counter,
     3850 * i.e. one must call pSurf->Release() once the surface is not needed*/
     3851static HRESULT vboxWddmSurfGet(PVBOXWDDMDISP_RESOURCE pRc, UINT iAlloc, IDirect3DSurface9 **ppSurf)
     3852{
     3853    HRESULT hr = S_OK;
     3854    Assert(pRc->cAllocations > iAlloc);
     3855    switch (pRc->aAllocations[0].enmD3DIfType)
     3856    {
     3857        case VBOXDISP_D3DIFTYPE_SURFACE:
     3858        {
     3859            IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pRc->aAllocations[iAlloc].pD3DIf;
     3860            Assert(pD3DIfSurf);
     3861            pD3DIfSurf->AddRef();
     3862            *ppSurf = pD3DIfSurf;
     3863            break;
     3864        }
     3865        case VBOXDISP_D3DIFTYPE_TEXTURE:
     3866        {
     3867            IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
     3868            IDirect3DSurface9 *pSurfaceLevel;
     3869            Assert(pD3DIfTex);
     3870            hr = pD3DIfTex->GetSurfaceLevel(iAlloc, &pSurfaceLevel);
     3871            Assert(hr == S_OK);
     3872            if (hr == S_OK)
     3873            {
     3874                *ppSurf = pSurfaceLevel;
     3875            }
     3876            break;
     3877        }
     3878        default:
     3879            AssertBreakpoint();
     3880            hr = E_FAIL;
     3881            break;
     3882    }
     3883    return hr;
     3884}
     3885
    38033886static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
    38043887{
    … …  
    38113894    Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
    38123895    Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
    3813     PVBOXWDDMDISP_ALLOCATION pSrcAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
    3814     PVBOXWDDMDISP_ALLOCATION pDstAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
    38153896    HRESULT hr = S_OK;
    3816     if ((pDstRc->RcDesc.fFlags.Texture || pDstRc->RcDesc.fFlags.Value == 0)
     3897    /* try StretchRect */
     3898    IDirect3DSurface9 *pSrcSurfIf = NULL;
     3899    IDirect3DSurface9 *pDstSurfIf = NULL;
     3900    hr = vboxWddmSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf);
     3901    Assert(hr == S_OK);
     3902    if (hr == S_OK)
     3903    {
     3904        Assert(pSrcSurfIf);
     3905        hr = vboxWddmSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf);
     3906        Assert(hr == S_OK);
     3907        if (hr == S_OK)
     3908        {
     3909            Assert(pDstSurfIf);
     3910            /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
     3911            Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001  | 0x00000002))) == 0);
     3912            hr = pDevice->pDevice9If->StretchRect(pSrcSurfIf,
     3913                                &pData->SrcRect,
     3914                                pDstSurfIf,
     3915                                &pData->DstRect,
     3916                                vboxDDI2D3DBltFlags(pData->Flags));
     3917            Assert(hr == S_OK);
     3918            pDstSurfIf->Release();
     3919        }
     3920        pSrcSurfIf->Release();
     3921    }
     3922
     3923    if (hr != S_OK)
     3924    {
     3925        /* todo: fallback to memcpy or whatever ? */
     3926        AssertBreakpoint();
     3927    }
     3928
     3929
     3930#if 0
     3931    if ((use pAlloc->enmD3DIfType instead!!! pDstRc->RcDesc.fFlags.Texture || pDstRc->RcDesc.fFlags.Value == 0)
    38173932            && (pSrcRc->RcDesc.fFlags.Texture || pSrcRc->RcDesc.fFlags.Value == 0))
    38183933    {
    … …  
    39154030        }
    39164031    }
     4032#endif
    39174033
    39184034    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    … …  
    40504166    Assert(pDevice->pDevice9If);
    40514167    IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
    4052     HRESULT hr = pShader->Release();
    4053     Assert(hr == S_OK);
     4168    HRESULT hr = S_OK;
     4169    pShader->Release();
    40544170    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    40554171    return hr;
    … …  
    47014817        HRESULT hr = VBoxDispWorkerDestroy(&pAdapter->WndWorker);
    47024818        Assert(hr == S_OK);
    4703         hr = pAdapter->pD3D9If->Release();
    4704         Assert(hr == S_OK);
     4819        pAdapter->pD3D9If->Release();
    47054820        VBoxDispD3DClose(&pAdapter->D3D);
    47064821    }
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