VirtualBox

Changeset 47063 in vbox


Ignore:
Timestamp:
Jul 10, 2013 7:30:18 AM (12 years ago)
Author:
vboxsync
Message:

wddm: more cleanup & generic way for handling 3D and 2D commands

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

    r47059 r47063  
    11241124}
    11251125
    1126 NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt, VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags)
     1126static void vboxVdmaBltDirtyRectsUpdate(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_SOURCE *pSource, uint32_t cRects, const RECT *paRects)
     1127{
     1128    if (!cRects)
     1129    {
     1130        WARN(("vboxVdmaBltDirtyRectsUpdate: no rects specified"));
     1131        return;
     1132    }
     1133
     1134    RECT rect;
     1135    rect = paRects[0];
     1136    for (UINT i = 1; i < cRects; ++i)
     1137    {
     1138        vboxWddmRectUnited(&rect, &rect, &paRects[i]);
     1139    }
     1140
     1141    uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
     1142    if (!cUnlockedVBVADisabled)
     1143    {
     1144        VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &rect);
     1145    }
     1146    else
     1147    {
     1148        VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
     1149    }
     1150}
     1151
     1152NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt)
    11271153{
    11281154    NTSTATUS Status = STATUS_SUCCESS;
    1129 
    1130     if (fBltFlags.fRealOp)
    1131     {
    1132         PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
    1133         PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
    1134 
     1155    PVBOXWDDM_ALLOCATION pDstAlloc = pBlt->Blt.DstAlloc.pAlloc;
     1156    PVBOXWDDM_ALLOCATION pSrcAlloc = pBlt->Blt.SrcAlloc.pAlloc;
     1157    BOOLEAN fRenderFromSharedDisabled = pDevExt->fRenderToShadowDisabled;
     1158    BOOLEAN fVRAMUpdated = FALSE;
     1159
     1160    if (!pDstAlloc->AllocData.hostID && !pSrcAlloc->AllocData.hostID)
     1161    {
     1162        /* the allocations contain a real data in VRAM, do blitting */
    11351163        vboxVdmaGgDmaBlt(pDevExt, &pBlt->Blt);
    1136 
    1137         if (VBOXWDDM_IS_FB_ALLOCATION(pDevExt, pDstAlloc)
    1138                         && pDstAlloc->bVisible)
    1139         {
    1140             VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
    1141             Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
    1142             Assert(pSource->pPrimaryAllocation == pDstAlloc);
    1143 
    1144             RECT UpdateRect;
    1145             UpdateRect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
    1146             for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
    1147             {
    1148                 vboxWddmRectUnite(&UpdateRect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
    1149             }
    1150 
    1151             uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
    1152             if (!cUnlockedVBVADisabled)
    1153             {
    1154                 VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
    1155             }
    1156             else
    1157             {
    1158                 VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
    1159             }
    1160         }
    1161     }
    1162 
    1163     if (fBltFlags.fVisibleRegions)
    1164     {
    1165         Status = vboxVdmaProcessVRegCmd(pDevExt, pContext, &pBlt->Blt.SrcAlloc, &pBlt->Blt.DstAlloc, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects);
    1166         if (!NT_SUCCESS(Status))
    1167             WARN(("vboxVdmaProcessVRegCmd failed Status 0x%x", Status));
    1168     }
    1169 
    1170     return Status;
    1171 }
    1172 
    1173 NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip, VBOXVDMAPIPE_FLAGS_DMACMD fFlags)
     1164        fVRAMUpdated = TRUE;
     1165    }
     1166
     1167    if (VBOXWDDM_IS_REAL_FB_ALLOCATION(pDevExt, pDstAlloc)
     1168            && pDstAlloc->bVisible)
     1169    {
     1170        VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
     1171        Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
     1172        Assert(pSource->pPrimaryAllocation == pDstAlloc);
     1173
     1174
     1175        if (fVRAMUpdated)
     1176            vboxVdmaBltDirtyRectsUpdate(pDevExt, pSource, pBlt->Blt.DstRects.UpdateRects.cRects, pBlt->Blt.DstRects.UpdateRects.aRects);
     1177
     1178        if (pSrcAlloc->AllocData.hostID || pSource->fHas3DVrs)
     1179        {
     1180            Status = vboxVdmaProcessVRegCmd(pDevExt, pContext, &pBlt->Blt.SrcAlloc, &pBlt->Blt.DstAlloc, &pBlt->Blt.SrcRect, &pBlt->Blt.DstRects);
     1181            if (!NT_SUCCESS(Status))
     1182                WARN(("vboxVdmaProcessVRegCmd failed Status 0x%x", Status));
     1183        }
     1184    }
     1185
     1186    return Status;
     1187}
     1188
     1189NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip)
    11741190{
    11751191    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    11771193    VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pAlloc->AllocData.SurfDesc.VidPnSourceId];
    11781194    vboxWddmAssignPrimary(pDevExt, pSource, pAlloc, pAlloc->AllocData.SurfDesc.VidPnSourceId);
    1179     Assert(!fFlags.fRealOp);
    1180     if (fFlags.fVisibleRegions)
     1195    if (pAlloc->AllocData.hostID)
    11811196    {
    11821197        RECT SrcRect;
    … …  
    12031218}
    12041219
    1205 NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF, VBOXVDMAPIPE_FLAGS_DMACMD fFlags)
     1220NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_CONTEXT *pContext, VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF)
    12061221{
    12071222    NTSTATUS Status = STATUS_SUCCESS;
    1208     Assert(!fFlags.fVisibleRegions);
    1209 
    1210     if (fFlags.fRealOp)
     1223    PVBOXWDDM_ALLOCATION pAlloc = pCF->ClrFill.Alloc.pAlloc;
     1224
     1225    if (!pAlloc->AllocData.hostID)
    12111226    {
    12121227        Status = vboxVdmaGgDmaColorFill(pDevExt, &pCF->ClrFill);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.h

    r47059 r47063  
    212212} VBOXVDMAPIPE_CMD_CANCEL, *PVBOXVDMAPIPE_CMD_CANCEL;
    213213
    214 typedef struct VBOXVDMAPIPE_FLAGS_DMACMD
    215 {
    216     union
    217     {
    218         struct
    219         {
    220             UINT fRealOp             : 1;
    221             UINT fVisibleRegions     : 1;
    222             UINT Reserved            : 30;
    223         };
    224         UINT Value;
    225     };
    226 } VBOXVDMAPIPE_FLAGS_DMACMD, *PVBOXVDMAPIPE_FLAGS_DMACMD;
    227214typedef struct VBOXVDMAPIPE_CMD_DMACMD
    228215{
    … …  
    233220    PVBOXWDDM_CONTEXT pContext;
    234221    VBOXVDMACMD_TYPE enmCmd;
    235     VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
     222//    VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
    236223} VBOXVDMAPIPE_CMD_DMACMD, *PVBOXVDMAPIPE_CMD_DMACMD;
    237224
    … …  
    343330#define VBOXVDMAPIPE_CMD_DR_FROM_DDI_CMD(_pCmd) ((PVBOXVDMAPIPE_CMD_DR)(((uint8_t*)(_pCmd)) - RT_OFFSETOF(VBOXVDMAPIPE_CMD_DR, DdiCmd)))
    344331
    345 NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt, struct VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags);
    346 NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip, struct VBOXVDMAPIPE_FLAGS_DMACMD fFlags);
    347 NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF, struct VBOXVDMAPIPE_FLAGS_DMACMD fFlags);
     332NTSTATUS vboxVdmaProcessBltCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_BLT *pBlt);
     333NTSTATUS vboxVdmaProcessFlipCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip);
     334NTSTATUS vboxVdmaProcessClrFillCmd(PVBOXMP_DEVEXT pDevExt, struct VBOXWDDM_CONTEXT *pContext, struct VBOXWDDM_DMA_PRIVATEDATA_CLRFILL *pCF);
    348335
    349336NTSTATUS vboxVdmaTexPresentSetAlloc(PVBOXMP_DEVEXT pDevExt, const VBOXWDDM_ALLOC_DATA *pAllocData);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r47059 r47063  
    29722972        vboxWddmModeRenderFromShadowDisableRegister(pDevExt, pContext);
    29732973
    2974     BOOLEAN fRenderFromSharedDisabled = pDevExt->fRenderToShadowDisabled;
    2975 
    29762974    switch (enmCmd)
    29772975    {
    … …  
    29842982            vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pS2P->Shadow2Primary.ShadowAlloc.segmentIdAlloc, pS2P->Shadow2Primary.ShadowAlloc.offAlloc);
    29852983            vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pS2P->Shadow2Primary.VidPnSourceId);
    2986             fRenderFromSharedDisabled = vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     2984            vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    29872985            vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
    29882986            if (pSrcAlloc->bVisible)
    … …  
    30123010            vboxWddmAddrSetVram(&pSrcAlloc->AllocData.Addr, pBlt->Blt.SrcAlloc.segmentIdAlloc, pBlt->Blt.SrcAlloc.offAlloc);
    30133011
    3014             uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
    3015 
    3016             VBOXVDMAPIPE_FLAGS_DMACMD fBltFlags;
    3017             fBltFlags.Value = 0;
    3018 
    30193012            if (pDstAlloc->bAssigned &&
    30203013                    (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
    3021                         || pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
     3014                        || pDstAlloc->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
    30223015                    )
    30233016            {
    … …  
    30273020                if (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
    30283021                    vboxWddmAssignShadow(pDevExt, pSource, pSrcAlloc, pDstAlloc->AllocData.SurfDesc.VidPnSourceId);
    3029                 fRenderFromSharedDisabled = vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     3022                vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    30303023                if(pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D
    30313024                        || pDstAlloc->enmType !=VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
    30323025                    vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
    30333026            }
    3034             else if (pSrcAlloc->bAssigned &&
    3035                     (pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
    3036                         || pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE)
    3037                     )
    3038             {
    3039                 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
    3040                 Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
    3041 
    3042                 if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE)
    3043                     vboxWddmAssignShadow(pDevExt, pSource, pDstAlloc, pSrcAlloc->AllocData.SurfDesc.VidPnSourceId);
    3044                 fRenderFromSharedDisabled = vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
    3045                 if(pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D
    3046                         || pSrcAlloc->enmType !=VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
    3047                     vboxWddmCheckUpdateFramebufferAddress(pDevExt, pSource);
    3048             }
    3049 
    3050             if (pContext->enmType != VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D && fRenderFromSharedDisabled)
    3051                 fBltFlags.fRealOp = 1;
    3052 
    3053             switch (pDstAlloc->enmType)
    3054             {
    3055                 case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
    3056                 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    3057                 {
    3058                     if (pDstAlloc->bAssigned)
    3059                     {
    3060 //                        Assert(pSource->pPrimaryAllocation == pDstAlloc);
    3061 
    3062                         switch (pSrcAlloc->enmType)
    3063                         {
    3064                             case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    3065                             {
    3066                                 fBltFlags.fVisibleRegions = !!cContexts3D;
    3067                                 Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
    3068                                 VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[pDstAlloc->AllocData.SurfDesc.VidPnSourceId];
    3069                                 Assert(pDstAlloc->AllocData.SurfDesc.VidPnSourceId < VBOX_VIDEO_MAX_SCREENS);
    3070 
    3071                                 if (pSource->fHas3DVrs)
    3072                                     fBltFlags.fVisibleRegions = 1;
    3073 
    3074                                 if (!fRenderFromSharedDisabled && pSource->bVisible)
    3075                                 {
    3076                                     RECT rect;
    3077                                     if (pBlt->Blt.DstRects.UpdateRects.cRects)
    3078                                     {
    3079                                         rect = pBlt->Blt.DstRects.UpdateRects.aRects[0];
    3080                                         for (UINT i = 1; i < pBlt->Blt.DstRects.UpdateRects.cRects; ++i)
    3081                                         {
    3082                                             vboxWddmRectUnited(&rect, &rect, &pBlt->Blt.DstRects.UpdateRects.aRects[i]);
    3083                                         }
    3084                                     }
    3085                                     else
    3086                                         rect = pBlt->Blt.DstRects.ContextRect;
    3087 
    3088                                     uint32_t cUnlockedVBVADisabled = ASMAtomicReadU32(&pDevExt->cUnlockedVBVADisabled);
    3089                                     if (!cUnlockedVBVADisabled)
    3090                                     {
    3091                                         VBOXVBVA_OP(ReportDirtyRect, pDevExt, pSource, &rect);
    3092                                     }
    3093                                     else
    3094                                     {
    3095                                         VBOXVBVA_OP_WITHLOCK_ATDPC(ReportDirtyRect, pDevExt, pSource, &rect);
    3096                                     }
    3097                                 }
    3098 
    3099                                 break;
    3100                             }
    3101                             case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    3102                             {
    3103                                 if(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
    3104                                 {
    3105                                     Assert(pSrcAlloc->fRcFlags.RenderTarget);
    3106                                     if (pSrcAlloc->fRcFlags.RenderTarget)
    3107                                         fBltFlags.fVisibleRegions = 1;
    3108                                 }
    3109                                 break;
    3110                             }
    3111                             default:
    3112                             {
    3113                                 AssertBreakpoint();
    3114                                 break;
    3115                             }
    3116                         }
    3117                     }
    3118 
    3119                     break;
    3120                 }
    3121                 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
    3122                 {
    3123 //                    Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D);
    3124                     Assert(pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
    3125                     Assert(pSrcAlloc->fRcFlags.RenderTarget);
    3126                     Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, &pBlt->Blt.DstRects.ContextRect));
    3127                     Assert(pBlt->Blt.DstRects.UpdateRects.cRects == 1);
    3128                     Assert(vboxWddmRectIsEqual(&pBlt->Blt.SrcRect, pBlt->Blt.DstRects.UpdateRects.aRects));
    3129                     break;
    3130                 }
    3131                 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    3132                 {
    3133                     Assert(pSrcAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE);
    3134                     Assert(pContext->enmType == VBOXWDDM_CONTEXT_TYPE_SYSTEM);
    3135                     break;
    3136                 }
    3137                 default:
    3138                     AssertBreakpoint();
    3139                     break;
    3140             }
    3141 
    3142             if (fBltFlags.Value)
    3143                 Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt, fBltFlags);
     3027            else
     3028                vboxWddmModeRenderFromShadowCheckOnSubmitCommand(pDevExt, NULL);
     3029
     3030            Status = vboxVdmaProcessBltCmd(pDevExt, pContext, pBlt);
     3031            if (!NT_SUCCESS(Status))
     3032                WARN(("vboxVdmaProcessBltCmd failed, Status 0x%x", Status));
    31443033
    31453034            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
    … …  
    32043093            VBOXWDDM_DMA_PRIVATEDATA_FLIP *pFlip = (VBOXWDDM_DMA_PRIVATEDATA_FLIP*)pPrivateDataBase;
    32053094            vboxWddmAddrSetVram(&pFlip->Flip.Alloc.pAlloc->AllocData.Addr, pFlip->Flip.Alloc.segmentIdAlloc, pFlip->Flip.Alloc.offAlloc);
    3206             VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
    3207             fFlags.Value = 0;
    3208 
    3209             if (pContext->enmType == VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D)
    3210                 fFlags.fVisibleRegions = 1;
    3211             else
    3212                 WARN(("unexpected flip cmd"));
    3213 
    3214             if (fFlags.Value)
    3215                 Status = vboxVdmaProcessFlipCmd(pDevExt, pContext, pFlip, fFlags);
     3095
     3096            Status = vboxVdmaProcessFlipCmd(pDevExt, pContext, pFlip);
     3097            if (!NT_SUCCESS(Status))
     3098                WARN(("vboxVdmaProcessFlipCmd failed, Status 0x%x", Status));
    32163099
    32173100            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
    … …  
    32233106            PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL pCF = (PVBOXWDDM_DMA_PRIVATEDATA_CLRFILL)pPrivateDataBase;
    32243107            vboxWddmAddrSetVram(&pCF->ClrFill.Alloc.pAlloc->AllocData.Addr, pCF->ClrFill.Alloc.segmentIdAlloc, pCF->ClrFill.Alloc.offAlloc);
    3225             VBOXVDMAPIPE_FLAGS_DMACMD fFlags;
    3226             fFlags.Value = 0;
    3227             fFlags.fRealOp = 1;
    3228 
    3229             if (fFlags.Value)
    3230                 Status = vboxVdmaProcessClrFillCmd(pDevExt, pContext, pCF, fFlags);
     3108
     3109            Status = vboxVdmaProcessClrFillCmd(pDevExt, pContext, pCF);
     3110            if (!NT_SUCCESS(Status))
     3111                WARN(("vboxVdmaProcessClrFillCmd failed, Status 0x%x", Status));
    32313112
    32323113            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId,
    … …  
    55515432    PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR pPrivateData = (PVBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR)pPresent->pDmaBufferPrivateData;
    55525433    pPrivateData->BaseHdr.fFlags.Value = 0;
    5553     uint32_t cContexts3D = ASMAtomicReadU32(&pDevExt->cContexts3D);
    55545434    uint32_t cContexts2D = ASMAtomicReadU32(&pDevExt->cContexts2D);
    55555435#define VBOXWDDM_DUMMY_DMABUFFER_SIZE sizeof(RECT)
    … …  
    55845464                    }
    55855465#endif
    5586                     /* issue VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE ONLY in case there are no 3D contexts currently
     5466                    /* issue VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE ONLY in case there are no 3D Visible Regions currently
    55875467                     * otherwise we would need info about all rects being updated on primary for visible rect reporting */
    5588                     if (!cContexts3D && !cContexts2D && !pSource->fHas3DVrs)
     5468                    if (!cContexts2D && !pSource->fHas3DVrs)
    55895469                    {
    55905470                        if (pDstAlloc->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
    … …  
    58825762        if (pSrcAlloc)
    58835763        {
    5884             Assert(cContexts3D);
     5764            Assert(pDevExt->cContexts3D);
    58855765            pPrivateData->BaseHdr.enmCmd = VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP;
    58865766            PVBOXWDDM_DMA_PRIVATEDATA_FLIP pFlip = (PVBOXWDDM_DMA_PRIVATEDATA_FLIP)pPrivateData;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.h

    r47059 r47063  
    194194#define VBOXWDDMENTRY_2_SWAPCHAIN(_pE) ((PVBOXWDDM_SWAPCHAIN)((uint8_t*)(_pE) - RT_OFFSETOF(VBOXWDDM_SWAPCHAIN, DevExtListEntry)))
    195195
     196#ifdef VBOX_WDDM_WIN8
     197# define VBOXWDDM_IS_DISPLAYONLY() (g_VBoxDisplayOnly)
     198#else
     199# define VBOXWDDM_IS_DISPLAYONLY() (FALSE)
     200#endif
     201
    196202#ifdef VBOXWDDM_RENDER_FROM_SHADOW
    197 # ifdef VBOX_WDDM_WIN8
    198 #  define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
     203
     204# define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
    199205        && (  (_pAlloc)->AllocData.hostID \
    200206           || (_pAlloc)->enmType == \
    201                ((g_VBoxDisplayOnly || (_pDevExt)->fRenderToShadowDisabled) ? VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE : VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) \
     207               ((VBOXWDDM_IS_DISPLAYONLY() || (_pDevExt)->fRenderToShadowDisabled) ? VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE : VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) \
    202208               ))
    203 # else
    204 #  define VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
     209
     210# define VBOXWDDM_IS_REAL_FB_ALLOCATION(_pDevExt, _pAlloc) ( (_pAlloc)->bAssigned \
    205211        && (  (_pAlloc)->AllocData.hostID \
    206            || (_pAlloc)->enmType == \
    207                (((_pDevExt)->fRenderToShadowDisabled) ? VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE : VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE) \
     212           || (_pAlloc)->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE \
    208213               ))
    209 # endif
     214
    210215# define VBOXWDDM_FB_ALLOCATION(_pDevExt, _pSrc) ( ((_pSrc)->pPrimaryAllocation && VBOXWDDM_IS_FB_ALLOCATION(_pDevExt, (_pSrc)->pPrimaryAllocation)) ? \
    211216                (_pSrc)->pPrimaryAllocation : ( \
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