VirtualBox

Ignore:
Timestamp:
Sep 14, 2012 5:34:33 PM (12 years ago)
Author:
vboxsync
Message:

wddm/3d: volume texture func impl; fixes & cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r43314 r43334  
    22092209            VBOXVDBG_DUMP_SETTEXTURE(pRc);
    22102210        }
     2211        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     2212        {
     2213            pD3DIfTex = (IDirect3DVolumeTexture9*)pRc->aAllocations[0].pD3DIf;
     2214
     2215            VBOXVDBG_BREAK_SHARED(pRc);
     2216            VBOXVDBG_DUMP_SETTEXTURE(pRc);
     2217        }
    22112218        else
    22122219        {
    … …  
    27012708}
    27022709
     2710AssertCompile(sizeof (D3DDDIBOX) == sizeof (VBOXBOX3D));
     2711AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
     2712AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
     2713AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
     2714AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
     2715AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
     2716AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
     2717
     2718AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
     2719AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
     2720AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
     2721AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
     2722AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
     2723AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
     2724
    27032725static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
    27042726{
    27052727    VBOXDISP_DDI_PROLOGUE_DEV(hDevice);
     2728    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2729    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2730    Assert(pDevice);
     2731    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
     2732    IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
     2733    PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
     2734    PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
     2735    /* requirements for D3DDevice9::UpdateTexture */
     2736    Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2737    Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2738    IDirect3DVolumeTexture9 * pSrcTex = (IDirect3DVolumeTexture9*)pSrcRc->aAllocations[0].pD3DIf;
     2739    IDirect3DVolumeTexture9 * pDstTex = (IDirect3DVolumeTexture9*)pDstRc->aAllocations[0].pD3DIf;
     2740    VBOXPOINT3D Point;
     2741    Point.x = pData->DstX;
     2742    Point.y = pData->DstY;
     2743    Point.z = pData->DstZ;
     2744
     2745    HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9VolTexBlt((IDirect3DDevice9Ex*)pDevice9If, pSrcTex, pDstTex,
     2746                                        (VBOXBOX3D*)&pData->SrcBox, &Point);
     2747    if (FAILED(hr))
     2748        WARN(("pfnVBoxWineExD3DDev9VolTexBlt failed hr 0x%x", hr));
     2749    else
     2750        hr = S_OK;
    27062751    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2707     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
    2708     Assert(pDevice);
    2709     VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    2710     Assert(0);
    2711 //    @todo: vboxWddmDalCheckAdd(pDevice);
    2712     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2713     return E_FAIL;
     2752    return hr;;
    27142753}
    27152754
    … …  
    27392778    /* requirements for D3DDevice9::UpdateTexture */
    27402779    Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
    2741             || pDstRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
     2780            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
     2781            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
    27422782    Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
    2743             || pSrcRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
     2783            || pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
     2784            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2785    Assert(pSrcRc->aAllocations[0].enmD3DIfType == pDstRc->aAllocations[0].enmD3DIfType);
    27442786    Assert(pSrcRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
    27452787    Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
    … …  
    27692811    else
    27702812    {
     2813        Assert(pDstRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2814        Assert(pSrcRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     2815
    27712816        IDirect3DSurface9 *pSrcSurfIf = NULL;
    27722817        IDirect3DSurface9 *pDstSurfIf = NULL;
    … …  
    30403085}
    30413086
     3087AssertCompile(sizeof (D3DDDIBOX) == sizeof (D3DBOX));
     3088AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(D3DBOX, Left));
     3089AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(D3DBOX, Top));
     3090AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(D3DBOX, Right));
     3091AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(D3DBOX, Bottom));
     3092AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(D3DBOX, Front));
     3093AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(D3DBOX, Back));
     3094
     3095AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(D3DBOX, Left));
     3096AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(D3DBOX, Top));
     3097AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(D3DBOX, Right));
     3098AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(D3DBOX, Bottom));
     3099AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(D3DBOX, Front));
     3100AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(D3DBOX, Back));
     3101
    30423102static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
    30433103{
    … …  
    30703130            Assert(pTexAlloc->pD3DIf);
    30713131            RECT *pRect = NULL;
    3072             bool bNeedResynch = false;
     3132            BOOL fNeedLock = TRUE;
    30733133            Assert(!pData->Flags.RangeValid);
    30743134            Assert(!pData->Flags.BoxValid);
    … …  
    30803140            /* else - we lock the entire texture, pRect == NULL */
    30813141
    3082             if (!pLockAlloc->LockInfo.cLocks)
     3142            if (pLockAlloc->LockInfo.cLocks)
     3143            {
     3144                Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
     3145                if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
     3146                {
     3147                    Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
     3148                    Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
     3149                    Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
     3150                    Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
     3151                }
     3152                Assert(pLockAlloc->LockInfo.LockedRect.pBits);
     3153                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3154
     3155                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3156                {
     3157                    switch (pTexAlloc->enmD3DIfType)
     3158                    {
     3159                        case VBOXDISP_D3DIFTYPE_TEXTURE:
     3160                            hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
     3161                            break;
     3162                        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
     3163                            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
     3164                                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
     3165                            break;
     3166                        case VBOXDISP_D3DIFTYPE_SURFACE:
     3167                            hr = pD3DIfSurface->UnlockRect();
     3168                            break;
     3169                        default:
     3170                            Assert(0);
     3171                            break;
     3172                    }
     3173                    Assert(hr == S_OK);
     3174                }
     3175                else
     3176                {
     3177                    fNeedLock = FALSE;
     3178                }
     3179            }
     3180
     3181            if (fNeedLock && SUCCEEDED(hr))
    30833182            {
    30843183                VBOXVDBG_CHECK_SMSYNC(pRc);
     3184
     3185                pLockAlloc->LockInfo.fFlags = pData->Flags;
     3186                if (pRect)
     3187                {
     3188                    pLockAlloc->LockInfo.Area = *pRect;
     3189                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
     3190                }
     3191                else
     3192                {
     3193                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
     3194                }
     3195
    30853196                switch (pTexAlloc->enmD3DIfType)
    30863197                {
    … …  
    31073218                        break;
    31083219                }
    3109                 Assert(hr == S_OK);
    3110                 if (hr == S_OK)
    3111                 {
    3112                     pLockAlloc->LockInfo.fFlags = pData->Flags;
    3113                     if (pRect)
    3114                     {
    3115                         pLockAlloc->LockInfo.Area = *pRect;
    3116                         Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
    3117                     }
    3118                     else
    3119                     {
    3120                         Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
    3121                     }
    3122 
    3123                     bNeedResynch = !pData->Flags.Discard;
    3124                 }
    3125             }
    3126             else
    3127             {
    3128                 Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
    3129                 if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
    3130                 {
    3131                     Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
    3132                     Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
    3133                     Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
    3134                     Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
    3135                 }
    3136                 Assert(pLockAlloc->LockInfo.LockedRect.pBits);
    3137 
    3138                 bNeedResynch = pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard;
    3139 
    3140                 Assert(!bNeedResynch);
    3141 
    3142                 if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
    3143                 {
    3144                     switch (pTexAlloc->enmD3DIfType)
    3145                     {
    3146                         case VBOXDISP_D3DIFTYPE_TEXTURE:
    3147                             hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
    3148                             break;
    3149                         case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
    3150                             hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
    3151                                     VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
    3152                             break;
    3153                         case VBOXDISP_D3DIFTYPE_SURFACE:
    3154                             hr = pD3DIfSurface->UnlockRect();
    3155                             break;
    3156                         default:
    3157                             Assert(0);
    3158                             break;
    3159                     }
    3160                     Assert(hr == S_OK);
    3161                     if (hr == S_OK)
    3162                     {
    3163                         switch (pTexAlloc->enmD3DIfType)
    3164                         {
    3165                             case VBOXDISP_D3DIFTYPE_TEXTURE:
    3166                                 hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
    3167                                         &pLockAlloc->LockInfo.LockedRect,
    3168                                         pRect,
    3169                                         vboxDDI2D3DLockFlags(pData->Flags));
    3170                                 break;
    3171                             case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
    3172                                 hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
    3173                                         VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex),
    3174                                         &pLockAlloc->LockInfo.LockedRect,
    3175                                         pRect,
    3176                                         vboxDDI2D3DLockFlags(pData->Flags));
    3177                                 break;
    3178                             case VBOXDISP_D3DIFTYPE_SURFACE:
    3179                                 hr = pD3DIfSurface->LockRect(&pLockAlloc->LockInfo.LockedRect,
    3180                                         pRect,
    3181                                         vboxDDI2D3DLockFlags(pData->Flags));
    3182                                 break;
    3183                             default:
    3184                                 Assert(0);
    3185                                 break;
    3186                         }
    3187                         Assert(hr == S_OK);
    3188                         pLockAlloc->LockInfo.fFlags.ReadOnly = 0;
    3189                     }
    3190                 }
    3191             }
    3192 
    3193             if (hr == S_OK)
     3220
     3221                if (FAILED(hr))
     3222                {
     3223                    WARN(("LockRect failed, hr", hr));
     3224                }
     3225            }
     3226
     3227            if (SUCCEEDED(hr))
    31943228            {
    31953229                ++pLockAlloc->LockInfo.cLocks;
    … …  
    32103244
    32113245                VBOXVDBG_DUMP_LOCK_ST(pData);
     3246
     3247                hr = S_OK;
     3248            }
     3249        }
     3250        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     3251        {
     3252            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     3253            Assert(pData->SubResourceIndex < pRc->cAllocations);
     3254            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3255            IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
     3256            Assert(pTexAlloc->pD3DIf);
     3257            D3DDDIBOX *pBox = NULL;
     3258            BOOL fNeedLock = TRUE;
     3259            Assert(!pData->Flags.AreaValid);
     3260            Assert(!pData->Flags.BoxValid);
     3261            if (pData->Flags.BoxValid)
     3262            {
     3263                pBox = &pData->Box;
     3264            }
     3265
     3266            /* else - we lock the entire texture, pBox == NULL */
     3267
     3268            if (pLockAlloc->LockInfo.cLocks)
     3269            {
     3270                Assert(pLockAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
     3271                if (pLockAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
     3272                {
     3273                    Assert(pLockAlloc->LockInfo.Box.Left == pData->Box.Left);
     3274                    Assert(pLockAlloc->LockInfo.Box.Top == pData->Box.Top);
     3275                    Assert(pLockAlloc->LockInfo.Box.Right == pData->Box.Right);
     3276                    Assert(pLockAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
     3277                    Assert(pLockAlloc->LockInfo.Box.Front == pData->Box.Front);
     3278                    Assert(pLockAlloc->LockInfo.Box.Back == pData->Box.Back);
     3279                }
     3280                Assert(pLockAlloc->LockInfo.LockedBox.pBits);
     3281                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
     3282
     3283                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
     3284                {
     3285                    hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
     3286                    Assert(hr == S_OK);
     3287                }
     3288                else
     3289                {
     3290                    fNeedLock = FALSE;
     3291                }
     3292            }
     3293
     3294            if (fNeedLock && SUCCEEDED(hr))
     3295            {
     3296                VBOXVDBG_CHECK_SMSYNC(pRc);
     3297
     3298                pLockAlloc->LockInfo.fFlags = pData->Flags;
     3299                if (pBox)
     3300                {
     3301                    pLockAlloc->LockInfo.Box = *pBox;
     3302                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 1);
     3303                }
     3304                else
     3305                {
     3306                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 0);
     3307                }
     3308
     3309                hr = pD3DIfTex->LockBox(pData->SubResourceIndex,
     3310                                &pLockAlloc->LockInfo.LockedBox,
     3311                                (D3DBOX*)pBox,
     3312                                vboxDDI2D3DLockFlags(pData->Flags));
     3313                if (FAILED(hr))
     3314                {
     3315                    WARN(("LockRect failed, hr", hr));
     3316                }
     3317            }
     3318
     3319            if (SUCCEEDED(hr))
     3320            {
     3321                ++pLockAlloc->LockInfo.cLocks;
     3322
     3323                if (!pData->Flags.NotifyOnly)
     3324                {
     3325                    pData->pSurfData = pLockAlloc->LockInfo.LockedBox.pBits;
     3326                    pData->Pitch = pLockAlloc->LockInfo.LockedBox.RowPitch;
     3327                    pData->SlicePitch = pLockAlloc->LockInfo.LockedBox.SlicePitch;
     3328                    Assert(!pLockAlloc->pvMem);
     3329                }
     3330                else
     3331                {
     3332                    Assert(pLockAlloc->pvMem);
     3333                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
     3334                }
     3335
     3336                VBOXVDBG_DUMP_LOCK_ST(pData);
     3337
     3338                hr = S_OK;
    32123339            }
    32133340        }
    … …  
    35463673                        break;
    35473674                }
    3548                 Assert(hr == S_OK);
     3675                if (FAILED(hr))
     3676                    WARN(("UnlockRect failed, hr 0x%x", hr));
    35493677                VBOXVDBG_CHECK_SMSYNC(pRc);
    35503678            }
    3551             else
    3552             {
    3553                 Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
     3679        }
     3680        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     3681        {
     3682            Assert(pData->SubResourceIndex < pRc->cAllocations);
     3683            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3684
     3685            VBOXVDBG_DUMP_UNLOCK_ST(pData);
     3686
     3687            --pLockAlloc->LockInfo.cLocks;
     3688            Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
     3689            if (!pLockAlloc->LockInfo.cLocks)
     3690            {
     3691                PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
     3692                Assert(pTexAlloc->pD3DIf);
     3693                IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
     3694                hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
     3695                if (FAILED(hr))
     3696                    WARN(("UnlockBox failed, hr 0x%x", hr));
     3697                VBOXVDBG_CHECK_SMSYNC(pRc);
    35543698            }
    35553699        }
    … …  
    38584002
    38594003        pAllocation->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
     4004
     4005        if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
     4006        {
     4007            Assert(pAllocation->pvMem);
     4008            Assert(pAllocation->SurfDesc.pitch);
     4009            UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
     4010            Assert(minPitch);
     4011            if (minPitch)
     4012            {
     4013                if (pAllocation->SurfDesc.pitch != minPitch)
     4014                {
     4015                    Assert(pAllocation->SurfDesc.pitch > minPitch);
     4016                    pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
     4017                    Assert(VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags) && !pRc->RcDesc.fFlags.CubeMap); /* <- tested for textures only! */
     4018                }
     4019                Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width);
     4020            }
     4021            else
     4022            {
     4023                Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width);
     4024            }
     4025        }
     4026
    38604027    }
    38614028
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