VirtualBox

Changeset 76790 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Jan 12, 2019 11:08:29 AM (6 years ago)
Author:
vboxsync
Message:

WDDM: Gallium miniport driver: VidPn notifications and DxgkDdiPresentDisplayOnly. bugref:8893

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

Legend:

Unmodified
Added
Removed

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

    r76553 r76790  
    51955195                for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    51965196                {
     5197#ifdef VBOX_WITH_MESA3D
     5198                    if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     5199                    {
     5200                        GaVidPnSourceCheckPos(pDevExt, i);
     5201                        continue;
     5202                    }
     5203#endif
     5204
    51975205                    vboxWddmDisplaySettingsCheckPos(pDevExt, i);
    51985206                }
    … …  
    54465454
    54475455    LOGF(("ENTER, context(0x%x)", hAdapter));
     5456    LOG(("id %d, seg %d, addr 0x%RX64, hAllocation %p, ctx cnt %d, f 0x%x",
     5457         pSetVidPnSourceAddress->VidPnSourceId,
     5458         pSetVidPnSourceAddress->PrimarySegment,
     5459         pSetVidPnSourceAddress->PrimaryAddress.QuadPart,
     5460         pSetVidPnSourceAddress->hAllocation,
     5461         pSetVidPnSourceAddress->ContextCount,
     5462         pSetVidPnSourceAddress->Flags.Value));
    54485463
    54495464    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
    … …  
    54545469    }
    54555470
     5471#ifdef VBOX_WITH_MESA3D
     5472    if (pDevExt->enmHwType != VBOXVIDEO_HWTYPE_VMSVGA)
     5473#endif
    54565474    vboxWddmDisplaySettingsCheckPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId);
    54575475
    54585476    NTSTATUS Status = STATUS_SUCCESS;
    54595477    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pSetVidPnSourceAddress->VidPnSourceId];
    5460 #ifdef VBOX_WITH_MESA3D
    5461     if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    5462     {
    5463         GaScreenDefine(pDevExt->pGa, (uint32_t)pSetVidPnSourceAddress->PrimaryAddress.QuadPart,
    5464                        pSetVidPnSourceAddress->VidPnSourceId,
    5465                        pSource->VScreenPos.x, pSource->VScreenPos.y,
    5466                        pSource->AllocData.SurfDesc.width, pSource->AllocData.SurfDesc.height);
    5467         return STATUS_SUCCESS;
    5468     }
    5469 #endif
    5470 
     5478
     5479    /*
     5480     * Update the source VRAM address.
     5481     */
    54715482    PVBOXWDDM_ALLOCATION pAllocation;
    54725483    Assert(pSetVidPnSourceAddress->hAllocation);
    … …  
    55025513
    55035514    pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
     5515
     5516    /*
     5517     * Report the source.
     5518     */
     5519#ifdef VBOX_WITH_MESA3D
     5520    if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     5521    {
     5522        /* Query the position of the screen to make sure it is up to date. */
     5523        vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &pSource->VScreenPos);
     5524
     5525        GaVidPnSourceReport(pDevExt, pSource);
     5526        return STATUS_SUCCESS;
     5527    }
     5528#endif
    55045529
    55055530    vboxWddmGhDisplayCheckSetInfoFromSource(pDevExt, pSource);
    … …  
    55325557    }
    55335558
     5559#ifdef VBOX_WITH_MESA3D
     5560    if (pDevExt->enmHwType != VBOXVIDEO_HWTYPE_VMSVGA)
     5561#endif
    55345562    vboxWddmDisplaySettingsCheckPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId);
    55355563
    … …  
    55535581    }
    55545582
     5583#ifdef VBOX_WITH_MESA3D
     5584    if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     5585    {
     5586        GaVidPnSourceCheckPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId);
     5587    }
     5588#endif
     5589
    55555590    LOGF(("LEAVE, status(0x%x), context(0x%x)", Status, hAdapter));
    55565591
    … …  
    56395674        VBoxDumpSourceTargetArrays(paSources, paTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays);
    56405675
     5676#ifdef VBOX_WITH_MESA3D
     5677        if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     5678        {
     5679            for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     5680            {
     5681                VBOXWDDM_SOURCE *pSource = &pDevExt->aSources[i];
     5682
     5683                LOG(("Source [%d]: visible %d, blanked %d", i, pSource->bVisible, pSource->bBlankedByPowerOff));
     5684
     5685                /* Update positions of all screens. */
     5686                vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pSource->VScreenPos);
     5687
     5688                GaVidPnSourceReport(pDevExt, pSource);
     5689            }
     5690
     5691            for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     5692            {
     5693                VBOXWDDM_TARGET *pTarget = &pDevExt->aTargets[i];
     5694                Assert(pTarget->u32Id == i);
     5695                if (pTarget->VidPnSourceId != D3DDDI_ID_UNINITIALIZED)
     5696                {
     5697                    continue;
     5698                }
     5699
     5700                LOG(("Target [%d]: blanked %d", i, pTarget->fBlankedByPowerOff));
     5701
     5702                if (pTarget->fBlankedByPowerOff)
     5703                {
     5704                    GaScreenDefine(pDevExt->pGa, 0, pTarget->u32Id, 0, 0, 0, 0, true);
     5705                }
     5706                else
     5707                {
     5708                    GaScreenDestroy(pDevExt->pGa, pTarget->u32Id);
     5709                }
     5710            }
     5711
     5712            break;
     5713        }
     5714#endif
    56415715        vboxWddmGhDisplayCheckSetInfo(pDevExt);
    56425716    } while (0);
    … …  
    70807154            Assert(pCreateContext->Flags.Value <= 2); /* 2 is a GDI context in Win7 */
    70817155            pContext->enmType = VBOXWDDM_CONTEXT_TYPE_SYSTEM;
    7082             for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    7083             {
    7084                 vboxWddmDisplaySettingsCheckPos(pDevExt, i);
    7085             }
    70867156
    70877157            if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VBOX)
    70887158            {
     7159                for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
     7160                {
     7161                    vboxWddmDisplaySettingsCheckPos(pDevExt, i);
     7162                }
     7163
    70897164#ifdef VBOX_WITH_CROGL
    70907165                if (!VBOXWDDM_IS_DISPLAYONLY() && pDevExt->f3DEnabled)
    … …  
    74447519
    74457520    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
     7521#ifdef VBOX_WITH_MESA3D
     7522    if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     7523    {
     7524        return GaDxgkDdiPresentDisplayOnly(hAdapter, pPresentDisplayOnly);
     7525    }
     7526#endif
    74467527    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pPresentDisplayOnly->VidPnSourceId];
    74477528    Assert(pSource->AllocData.Addr.SegmentId == 1);
    … …  
    75187599    if (bUpdateRectInited && pSource->bVisible)
    75197600    {
    7520 #ifdef VBOX_WITH_MESA3D
    7521         if (pDevExt->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    7522         {
    7523             /** @todo BLIT_GMRFB_TO_SCREEN */
    7524             GaUpdate(pDevExt->pGa,
    7525                      UpdateRect.left,
    7526                      UpdateRect.top,
    7527                      UpdateRect.right - UpdateRect.left,
    7528                      UpdateRect.bottom - UpdateRect.top);
    7529         }
    7530         else
    7531 #endif
    75327601        VBOXVBVA_OP_WITHLOCK(ReportDirtyRect, pDevExt, pSource, &UpdateRect);
    75337602    }

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

    r76553 r76790  
    216216                          int32_t yOrigin,
    217217                          uint32_t u32Width,
    218                           uint32_t u32Height)
     218                          uint32_t u32Height,
     219                          bool fBlank)
    219220{
    220221    NTSTATUS Status = STATUS_SUCCESS;
    221222
    222223    const uint32_t cbSubmit =   sizeof(uint32_t)
    223                               + sizeof(SVGAScreenObject)
    224                               + sizeof(uint32_t)
    225                               + sizeof(SVGAFifoCmdDefineGMRFB);
     224                              + sizeof(SVGAScreenObject);
    226225    void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
    227226    if (pvCmd)
    … …  
    229228        SvgaCmdDefineScreen(pvCmd, u32ScreenId, true,
    230229                            xOrigin, yOrigin, u32Width, u32Height,
    231                             /* fPrimary = */ false, u32Offset, /* fBlank = */ false);
    232         pvCmd = (uint8_t *)pvCmd + sizeof(uint32_t) + sizeof(SVGAScreenObject);
    233 
    234         uint32_t u32BytesPerLine = u32Width * 4;
    235         /* Start at offset 0, because we use it to address entire VRAM. */
    236         SvgaCmdDefineGMRFB(pvCmd, 0, u32BytesPerLine);
     230                            /* fPrimary = */ false, u32Offset, fBlank);
    237231        SvgaFifoCommit(pSvga, cbSubmit);
    238 
    239         /* Save the screen offset. */
    240         pSvga->u32ScreenOffset = u32Offset;
    241         pSvga->cbScreenPitch = u32BytesPerLine;
    242232    }
    243233    else
    … …  
    260250    {
    261251        SvgaCmdDestroyScreen(pvCmd, u32ScreenId);
     252        SvgaFifoCommit(pSvga, cbSubmit);
    262253    }
    263254    else
    … …  
    764755                            uint32_t u32Width,
    765756                            uint32_t u32Height,
     757                            uint32_t u32VRAMOffset,
    766758                            void *pvDst,
    767759                            uint32_t cbDst,
    768760                            uint32_t *pcbOut)
    769761{
     762    RT_NOREF(pSvga);
     763
    770764    const uint32_t cbCmdSurfaceDMAToFB =   sizeof(SVGA3dCmdHeader)
    771765                                         + sizeof(SVGA3dCmdSurfaceDMA)
    … …  
    786780    }
    787781
    788     Svga3dCmdSurfaceDMAToFB(pvDst, u32Sid, u32Width, u32Height, pSvga->u32ScreenOffset);
     782    Svga3dCmdSurfaceDMAToFB(pvDst, u32Sid, u32Width, u32Height, u32VRAMOffset);
    789783    SvgaCmdUpdate((uint8_t *)pvDst + cbCmdSurfaceDMAToFB, 0, 0, u32Width, u32Height);
    790784
    … …  
    795789                         uint32_t u32Sid,
    796790                         uint32_t u32Width,
    797                          uint32_t u32Height)
     791                         uint32_t u32Height,
     792                         uint32_t u32VRAMOffset)
    798793{
    799794    NTSTATUS Status = STATUS_SUCCESS;
    800795
    801796    uint32_t cbSubmit = 0;
    802     SvgaGenPresentVRAM(pSvga, 0, 0, 0, NULL, 0, &cbSubmit);
     797    SvgaGenPresentVRAM(pSvga, 0, 0, 0, 0, NULL, 0, &cbSubmit);
    803798
    804799    void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
    805800    if (pvCmd)
    806801    {
    807         Status = SvgaGenPresentVRAM(pSvga, u32Sid, u32Width, u32Height, pvCmd, cbSubmit, NULL);
     802        Status = SvgaGenPresentVRAM(pSvga, u32Sid, u32Width, u32Height, u32VRAMOffset, pvCmd, cbSubmit, NULL);
    808803        Assert(Status == STATUS_SUCCESS);
    809804        SvgaFifoCommit(pSvga, cbSubmit);
    … …  
    878873
    879874    return STATUS_SUCCESS;
     875}
     876
     877NTSTATUS SvgaBlitGMRFBToScreen(PVBOXWDDM_EXT_VMSVGA pSvga,
     878                               uint32_t idDstScreen,
     879                               int32_t xSrc,
     880                               int32_t ySrc,
     881                               RECT const *pDstRect)
     882{
     883    NTSTATUS Status = STATUS_SUCCESS;
     884
     885    uint32_t cbSubmit = 0;
     886    SvgaGenBlitGMRFBToScreen(pSvga, idDstScreen, xSrc, ySrc, pDstRect,
     887                             NULL, 0, &cbSubmit);
     888
     889    void *pvCmd = SvgaFifoReserve(pSvga, cbSubmit);
     890    if (pvCmd)
     891    {
     892        Status = SvgaGenBlitGMRFBToScreen(pSvga, idDstScreen, xSrc, ySrc, pDstRect,
     893                                          pvCmd, cbSubmit, NULL);
     894        Assert(Status == STATUS_SUCCESS);
     895        SvgaFifoCommit(pSvga, cbSubmit);
     896    }
     897    else
     898    {
     899        Status = STATUS_INSUFFICIENT_RESOURCES;
     900    }
     901
     902    return Status;
    880903}
    881904
    … …  
    10211044NTSTATUS SvgaDefineGMRFB(PVBOXWDDM_EXT_VMSVGA pSvga,
    10221045                         uint32_t u32Offset,
    1023                          uint32_t u32BytesPerLine)
     1046                         uint32_t u32BytesPerLine,
     1047                         bool fForce)
    10241048{
    10251049    NTSTATUS Status = STATUS_SUCCESS;
     1050
     1051    ExAcquireFastMutex(&pSvga->SvgaMutex);
     1052    if (   !fForce
     1053        && pSvga->lastGMRFB.u32Offset == u32Offset
     1054        && pSvga->lastGMRFB.u32BytesPerLine == u32BytesPerLine)
     1055    {
     1056        ExReleaseFastMutex(&pSvga->SvgaMutex);
     1057        return VINF_SUCCESS;
     1058    }
     1059    ExReleaseFastMutex(&pSvga->SvgaMutex);
    10261060
    10271061    uint32_t cbSubmit = 0;
    … …  
    10401074    {
    10411075        Status = STATUS_INSUFFICIENT_RESOURCES;
     1076    }
     1077
     1078    if (Status == STATUS_SUCCESS)
     1079    {
     1080        ExAcquireFastMutex(&pSvga->SvgaMutex);
     1081        pSvga->lastGMRFB.u32Offset = u32Offset;
     1082        pSvga->lastGMRFB.u32BytesPerLine = u32BytesPerLine;
     1083        ExReleaseFastMutex(&pSvga->SvgaMutex);
    10421084    }
    10431085

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

    r76563 r76790  
    8686    VMSVGAFIFO fifo;
    8787
    88     /** Offset of the screen relative to VRAM start. */
    89     uint32_t u32ScreenOffset;
    90 
    91     /** Scanline width in bytes of the screen. */
    92     uint32_t cbScreenPitch;
    93 
    9488    /** For atomic hardware access. */
    9589    KSPIN_LOCK HwSpinLock;
    … …  
    10498    /** SVGA data access. */
    10599    FAST_MUTEX SvgaMutex;
     100
     101    struct
     102    {
     103        uint32_t u32Offset;
     104        uint32_t u32BytesPerLine;
     105    } lastGMRFB;
    106106
    107107    /** AVL tree for mapping sids to the original sid for shared resources. */
    … …  
    135135                          int32_t yOrigin,
    136136                          uint32_t u32Width,
    137                           uint32_t u32Height);
     137                          uint32_t u32Height,
     138                          bool fBlank);
    138139NTSTATUS SvgaScreenDestroy(PVBOXWDDM_EXT_VMSVGA pSvga,
    139140                           uint32_t u32ScreenId);
    … …  
    208209                            uint32_t u32Width,
    209210                            uint32_t u32Height,
     211                            uint32_t u32VRAMOffset,
    210212                            void *pvDst,
    211213                            uint32_t cbDst,
    … …  
    214216                         uint32_t u32Sid,
    215217                         uint32_t u32Width,
    216                          uint32_t u32Height);
     218                         uint32_t u32Height,
     219                         uint32_t u32VRAMOffset);
    217220
    218221NTSTATUS SvgaGenSurfaceDMA(PVBOXWDDM_EXT_VMSVGA pSvga,
    … …  
    242245                                  uint32_t *pcbOut);
    243246
     247NTSTATUS SvgaBlitGMRFBToScreen(PVBOXWDDM_EXT_VMSVGA pSvga,
     248                               uint32_t idDstScreen,
     249                               int32_t xSrc,
     250                               int32_t ySrc,
     251                               RECT const *pDstRect);
     252
    244253NTSTATUS SvgaGenBlitSurfaceToScreen(PVBOXWDDM_EXT_VMSVGA pSvga,
    245254                                    uint32_t sid,
    … …  
    266275                            uint32_t cbDst,
    267276                            uint32_t *pcbOut);
     277
     278NTSTATUS SvgaDefineGMRFB(PVBOXWDDM_EXT_VMSVGA pSvga,
     279                         uint32_t u32Offset,
     280                         uint32_t u32BytesPerLine,
     281                         bool fForce);
    268282
    269283NTSTATUS SvgaGenGMRReport(PVBOXWDDM_EXT_VMSVGA pSvga,

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

    r76553 r76790  
    1717
    1818#include "VBoxMPGaWddm.h"
     19#include "../VBoxMPVidPn.h"
    1920
    2021#include "Svga.h"
    … …  
    472473                        int32_t yOrigin,
    473474                        uint32_t u32Width,
    474                         uint32_t u32Height)
    475 {
    476     return SvgaScreenDefine(pGaDevExt->hw.pSvga, u32Offset, u32ScreenId, xOrigin, yOrigin, u32Width, u32Height);
     475                        uint32_t u32Height,
     476                        bool fBlank)
     477{
     478    return SvgaScreenDefine(pGaDevExt->hw.pSvga, u32Offset, u32ScreenId, xOrigin, yOrigin, u32Width, u32Height, fBlank);
    477479}
    478480
    … …  
    652654                          uint32_t u32Sid,
    653655                          uint32_t u32Width,
    654                           uint32_t u32Height)
    655 {
    656     return SvgaPresentVRAM(pGaDevExt->hw.pSvga, u32Sid, u32Width, u32Height);
     656                          uint32_t u32Height,
     657                          uint32_t u32VRAMOffset)
     658{
     659    return SvgaPresentVRAM(pGaDevExt->hw.pSvga, u32Sid, u32Width, u32Height, u32VRAMOffset);
    657660}
    658661
    … …  
    878881                                              pu8Target, cbTarget, &cbCmd);
    879882            }
    880             else
    881             {
    882                 /* Define GMRFB to point to the start of VRAM. */
    883                 /** @todo This is a workaround for current BlitSurfaceToScreen host implementation
    884                  *        expecting that GMRFB will be at the start of VRAM.
    885                  */
    886                 Status = SvgaGenDefineGMRFB(pSvga, 0, pSvga->cbScreenPitch,
    887                                             pu8Target, cbTarget, &cbCmd);
    888             }
    889883
    890884            if (Status == STATUS_BUFFER_OVERFLOW)
    … …  
    10171011        pu8Target += cbCmd;
    10181012        cbTarget -= cbCmd;
    1019     }
    1020 
    1021     if (Status == STATUS_SUCCESS)
    1022     {
    1023         if (iSubRect == pPresent->SubRectCnt)
    1024         {
    1025             /** @todo No more rects. Have to reset the GMRFB, some code expects this. */
    1026             Status = SvgaGenDefineGMRFB(pSvga, 0, pSvga->cbScreenPitch,
    1027                                         pu8Target, cbTarget, &cbCmd);
    1028             if (Status == STATUS_BUFFER_OVERFLOW)
    1029             {
    1030                 Status = STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER;
    1031             }
    1032             else
    1033             {
    1034                 pu8Target += cbCmd;
    1035                 cbTarget -= cbCmd;
    1036             }
    1037         }
    10381013    }
    10391014
    … …  
    19881963
    19891964            VBOXDISPIFESCAPE_GAPRESENT *pGaPresent = (VBOXDISPIFESCAPE_GAPRESENT *)pEscapeHdr;
    1990             Status = gaPresent(pDevExt->pGa, pGaPresent->u32Sid, pGaPresent->u32Width, pGaPresent->u32Height);
     1965            /** @todo This always writes to the start of VRAM. This is a debug function
     1966             * and is not used for normal operations anymore.
     1967             */
     1968            Status = gaPresent(pDevExt->pGa, pGaPresent->u32Sid, pGaPresent->u32Width, pGaPresent->u32Height, 0);
    19911969            break;
    19921970        }
    … …  
    21062084    return Status;
    21072085}
     2086
     2087DECLINLINE(VBOXVIDEOOFFSET) vboxWddmAddrVRAMOffset(VBOXWDDM_ADDR const *pAddr)
     2088{
     2089    return (pAddr->offVram != VBOXVIDEOOFFSET_VOID && pAddr->SegmentId) ?
     2090                (pAddr->SegmentId == 1 ? pAddr->offVram : 0) :
     2091                VBOXVIDEOOFFSET_VOID;
     2092}
     2093
     2094static void vboxWddmRectCopy(void *pvDst, uint32_t cbDstBytesPerPixel, uint32_t cbDstPitch,
     2095                             void const *pvSrc, uint32_t cbSrcBytesPerPixel, uint32_t cbSrcPitch,
     2096                             RECT const *pRect)
     2097{
     2098    uint8_t *pu8Dst = (uint8_t *)pvDst;
     2099    pu8Dst += pRect->top * cbDstPitch + pRect->left * cbDstBytesPerPixel;
     2100
     2101    uint8_t const *pu8Src = (uint8_t *)pvSrc;
     2102    pu8Src += pRect->top * cbSrcPitch + pRect->left * cbSrcBytesPerPixel;
     2103
     2104    uint32_t const cbLine = (pRect->right - pRect->left) * cbDstBytesPerPixel;
     2105    for (INT y = pRect->top; y < pRect->bottom; ++y)
     2106    {
     2107        memcpy(pu8Dst, pu8Src, cbLine);
     2108        pu8Dst += cbDstPitch;
     2109        pu8Src += cbSrcPitch;
     2110    }
     2111}
     2112
     2113static NTSTATUS gaSourceBlitToScreen(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_SOURCE *pSource, RECT const *pRect)
     2114{
     2115    NTSTATUS Status = STATUS_SUCCESS;
     2116    PVBOXWDDM_EXT_VMSVGA pSvga = pDevExt->pGa->hw.pSvga;
     2117
     2118    VBOXWDDM_TARGET_ITER Iter;
     2119    VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
     2120    for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     2121         pTarget;
     2122         pTarget = VBoxVidPnStTIterNext(&Iter))
     2123    {
     2124        Status = SvgaBlitGMRFBToScreen(pSvga,
     2125                                       pTarget->u32Id,
     2126                                       pRect->left,
     2127                                       pRect->top,
     2128                                       pRect);
     2129        AssertBreak(Status == STATUS_SUCCESS);
     2130    }
     2131
     2132    return Status;
     2133}
     2134
     2135NTSTATUS APIENTRY GaDxgkDdiPresentDisplayOnly(const HANDLE hAdapter,
     2136                                              const DXGKARG_PRESENT_DISPLAYONLY *pPresentDisplayOnly)
     2137{
     2138    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
     2139
     2140    LOG(("VidPnSourceId %d, pSource %p, BytesPerPixel %d, Pitch %d, Flags 0x%x, NumMoves %d, NumDirtyRects %d, pfn %p\n",
     2141         pPresentDisplayOnly->VidPnSourceId,
     2142         pPresentDisplayOnly->pSource,
     2143         pPresentDisplayOnly->BytesPerPixel,
     2144         pPresentDisplayOnly->Pitch,
     2145         pPresentDisplayOnly->Flags.Value,
     2146         pPresentDisplayOnly->NumMoves,
     2147         pPresentDisplayOnly->NumDirtyRects,
     2148         pPresentDisplayOnly->pDirtyRect,
     2149         pPresentDisplayOnly->pfnPresentDisplayOnlyProgress));
     2150
     2151    /*
     2152     * Copy the image to the corresponding VidPn source allocation.
     2153     */
     2154    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pPresentDisplayOnly->VidPnSourceId];
     2155    AssertReturn(pSource->AllocData.Addr.SegmentId == 1, STATUS_SUCCESS); /* Ignore such VidPn sources. */
     2156
     2157    VBOXVIDEOOFFSET const offVRAM = vboxWddmAddrVRAMOffset(&pSource->AllocData.Addr);
     2158    AssertReturn(offVRAM != VBOXVIDEOOFFSET_VOID, STATUS_SUCCESS); /* Ignore such VidPn sources. */
     2159
     2160    for (ULONG i = 0; i < pPresentDisplayOnly->NumMoves; ++i)
     2161    {
     2162        RECT *pRect = &pPresentDisplayOnly->pMoves[i].DestRect;
     2163        vboxWddmRectCopy(pDevExt->pvVisibleVram + offVRAM,    // dst pointer
     2164                         pSource->AllocData.SurfDesc.bpp / 8, // dst bytes per pixel
     2165                         pSource->AllocData.SurfDesc.pitch,   // dst pitch
     2166                         pPresentDisplayOnly->pSource,        // src pointer
     2167                         pPresentDisplayOnly->BytesPerPixel,  // src bytes per pixel
     2168                         pPresentDisplayOnly->Pitch,          // src pitch
     2169                         pRect);
     2170    }
     2171
     2172    for (ULONG i = 0; i < pPresentDisplayOnly->NumDirtyRects; ++i)
     2173    {
     2174        RECT *pRect = &pPresentDisplayOnly->pDirtyRect[i];
     2175        if (pRect->left >= pRect->right || pRect->top >= pRect->bottom)
     2176        {
     2177            continue;
     2178        }
     2179
     2180        vboxWddmRectCopy(pDevExt->pvVisibleVram + offVRAM,    // dst pointer
     2181                         pSource->AllocData.SurfDesc.bpp / 8, // dst bytes per pixel
     2182                         pSource->AllocData.SurfDesc.pitch,   // dst pitch
     2183                         pPresentDisplayOnly->pSource,        // src pointer
     2184                         pPresentDisplayOnly->BytesPerPixel,  // src bytes per pixel
     2185                         pPresentDisplayOnly->Pitch,          // src pitch
     2186                         pRect);
     2187    }
     2188
     2189    NTSTATUS Status = STATUS_SUCCESS;
     2190    if (pSource->bVisible) /// @todo Does/should this have any effect?
     2191    {
     2192        PVBOXWDDM_EXT_VMSVGA pSvga = pDevExt->pGa->hw.pSvga;
     2193        Status = SvgaDefineGMRFB(pSvga, (uint32_t)offVRAM, pSource->AllocData.SurfDesc.pitch, false);
     2194        if (Status == STATUS_SUCCESS)
     2195        {
     2196            for (ULONG i = 0; i < pPresentDisplayOnly->NumMoves; ++i)
     2197            {
     2198                RECT *pRect = &pPresentDisplayOnly->pMoves[i].DestRect;
     2199                Status = gaSourceBlitToScreen(pDevExt, pSource, pRect);
     2200                AssertBreak(Status == STATUS_SUCCESS);
     2201            }
     2202        }
     2203
     2204        if (Status == STATUS_SUCCESS)
     2205        {
     2206            for (ULONG i = 0; i < pPresentDisplayOnly->NumDirtyRects; ++i)
     2207            {
     2208                RECT *pRect = &pPresentDisplayOnly->pDirtyRect[i];
     2209                Status = gaSourceBlitToScreen(pDevExt, pSource, pRect);
     2210                AssertBreak(Status == STATUS_SUCCESS);
     2211            }
     2212        }
     2213    }
     2214
     2215    return Status;
     2216}
     2217
     2218NTSTATUS GaVidPnSourceReport(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_SOURCE *pSource)
     2219{
     2220    NTSTATUS Status = STATUS_SUCCESS;
     2221
     2222    VBOXVIDEOOFFSET offVRAM = vboxWddmAddrVRAMOffset(&pSource->AllocData.Addr);
     2223    if (offVRAM == VBOXVIDEOOFFSET_VOID)
     2224        return STATUS_SUCCESS; /* Ignore such VidPn sources. */
     2225
     2226    VBOXWDDM_TARGET_ITER Iter;
     2227    VBoxVidPnStTIterInit(pSource, pDevExt->aTargets, VBoxCommonFromDeviceExt(pDevExt)->cDisplays, &Iter);
     2228    for (PVBOXWDDM_TARGET pTarget = VBoxVidPnStTIterNext(&Iter);
     2229         pTarget;
     2230         pTarget = VBoxVidPnStTIterNext(&Iter))
     2231    {
     2232        Status = GaScreenDefine(pDevExt->pGa,
     2233                                (uint32_t)offVRAM,
     2234                                pTarget->u32Id,
     2235                                pSource->VScreenPos.x, pSource->VScreenPos.y,
     2236                                pSource->AllocData.SurfDesc.width, pSource->AllocData.SurfDesc.height,
     2237                                RT_BOOL(pSource->bBlankedByPowerOff));
     2238        AssertBreak(Status == STATUS_SUCCESS);
     2239    }
     2240
     2241    return Status;
     2242}
     2243
     2244NTSTATUS GaVidPnSourceCheckPos(PVBOXMP_DEVEXT pDevExt, UINT iSource)
     2245{
     2246    POINT Pos = {0};
     2247    NTSTATUS Status = vboxWddmDisplaySettingsQueryPos(pDevExt, iSource, &Pos);
     2248    if (NT_SUCCESS(Status))
     2249    {
     2250        PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[iSource];
     2251        if (memcmp(&pSource->VScreenPos, &Pos, sizeof(Pos)))
     2252        {
     2253            pSource->VScreenPos = Pos;
     2254            Status = GaVidPnSourceReport(pDevExt, pSource);
     2255        }
     2256    }
     2257    return Status;
     2258}

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

    r76563 r76790  
    3737                        int32_t yOrigin,
    3838                        uint32_t u32Width,
    39                         uint32_t u32Height);
     39                        uint32_t u32Height,
     40                        bool fBlank);
    4041NTSTATUS GaScreenDestroy(PVBOXWDDM_EXT_GA pGaDevExt,
    4142                         uint32_t u32ScreenId);
    … …  
    5960NTSTATUS APIENTRY GaDxgkDdiBuildPagingBuffer(const HANDLE hAdapter,
    6061                                             DXGKARG_BUILDPAGINGBUFFER *pBuildPagingBuffer);
     62NTSTATUS APIENTRY GaDxgkDdiPresentDisplayOnly(const HANDLE hAdapter,
     63                                              const DXGKARG_PRESENT_DISPLAYONLY *pPresentDisplayOnly);
    6164NTSTATUS APIENTRY GaDxgkDdiPresent(const HANDLE hContext,
    6265                                   DXGKARG_PRESENT *pPresent);
    … …  
    8790}
    8891
     92NTSTATUS GaVidPnSourceReport(PVBOXMP_DEVEXT pDevExt, VBOXWDDM_SOURCE *pSource);
     93NTSTATUS GaVidPnSourceCheckPos(PVBOXMP_DEVEXT pDevExt, UINT iSource);
     94
    8995#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_mp_wddm_gallium_VBoxMPGaWddm_h */
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