VirtualBox

Ignore:
Timestamp:
Feb 7, 2014 2:11:50 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92115
Message:

crOpenGL: screenshot support; a bit of performance for video recording

Location:
trunk/src/VBox/HostServices/SharedOpenGL
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

    r50341 r50364  
    939939        CR_SCREENSHOT Screenshot;
    940940
    941         int rc = crServerVBoxScreenshotGet(idScreen, &Screenshot);
     941        int rc = crServerVBoxScreenshotGet(idScreen, pScreenshot->u32Width, pScreenshot->u32Height, pScreenshot->u32Pitch, pScreenshot->pvBuffer, &Screenshot);
    942942        if (RT_SUCCESS(rc))
    943943        {
    944             pScreenshot->pfnScreenshotPerform(pScreenshot->pvContext, idScreen,
    945                     0, 0, 32,
    946                     Screenshot.Img.pitch, Screenshot.Img.width, Screenshot.Img.height,
    947                     (uint8_t*)Screenshot.Img.pvData, u64Now);
     944            if (pScreenshot->pfnScreenshotPerform)
     945                pScreenshot->pfnScreenshotPerform(pScreenshot->pvContext, idScreen,
     946                        0, 0, 32,
     947                        Screenshot.Img.pitch, Screenshot.Img.width, Screenshot.Img.height,
     948                        (uint8_t*)Screenshot.Img.pvData, u64Now);
    948949            crServerVBoxScreenshotRelease(&Screenshot);
    949950        }

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r50318 r50364  
    425425void CrFbVisitCreatedEntries(HCR_FRAMEBUFFER hFb, PFNCR_FRAMEBUFFER_ENTRIES_VISITOR_CB pfnVisitorCb, void *pvContext);
    426426int CrFbResize(HCR_FRAMEBUFFER hFb, const struct VBVAINFOSCREEN * pScreen, void *pvVRAM);
    427 int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTPOINT *pPoint, uint32_t cRects, const RTRECT *pPrects, CR_BLITTER_IMG *pImg);
     427int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pPrects, CR_BLITTER_IMG *pImg);
    428428bool CrFbIsEnabled(HCR_FRAMEBUFFER hFb);
    429429int CrFbEntryCreateForTexId(HCR_FRAMEBUFFER hFb, GLuint idTex, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry);

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp

    r50313 r50364  
    658658}
    659659
    660 DECLEXPORT(int) crServerVBoxScreenshotGet(uint32_t u32Screen, CR_SCREENSHOT *pScreenshot)
     660DECLEXPORT(void) crServerVBoxScreenshotRelease(CR_SCREENSHOT *pScreenshot)
     661{
     662    if (pScreenshot->fDataAllocated)
     663    {
     664        RTMemFree(pScreenshot->Img.pvData);
     665        pScreenshot->fDataAllocated = 0;
     666    }
     667}
     668
     669DECLEXPORT(int) crServerVBoxScreenshotGet(uint32_t u32Screen, uint32_t width, uint32_t height, uint32_t pitch, void *pvBuffer, CR_SCREENSHOT *pScreenshot)
    661670{
    662671    HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(u32Screen);
    … …  
    666675    const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
    667676
    668     if (CrFbHas3DData(hFb))
    669     {
    670         RTPOINT Pos = {0, 0};
     677    if (!width)
     678        width = pScreen->u32Width;
     679    if (!height)
     680        height = pScreen->u32Height;
     681    if (!pitch)
     682        pitch = pScreen->u32LineSize;
     683
     684    if (CrFbHas3DData(hFb)
     685            || pScreen->u32Width != width
     686            || pScreen->u32Height != height
     687            || pScreen->u32LineSize != pitch
     688            || pScreen->u16BitsPerPixel != 32)
     689    {
    671690        RTRECT Rect;
    672691
    673692        pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
    674         pScreenshot->Img.pvData = RTMemAlloc(pScreenshot->Img.cbData);
    675         if (!pScreenshot->Img.pvData)
    676         {
    677             WARN(("RTMemAlloc failed"));
    678             return VERR_NO_MEMORY;
     693        if (!pvBuffer)
     694        {
     695            pScreenshot->Img.pvData = RTMemAlloc(pScreenshot->Img.cbData);
     696            if (!pScreenshot->Img.pvData)
     697            {
     698                WARN(("RTMemAlloc failed"));
     699                return VERR_NO_MEMORY;
     700            }
     701            pScreenshot->fDataAllocated = 1;
     702        }
     703        else
     704        {
     705            pScreenshot->Img.pvData = pvBuffer;
     706            pScreenshot->fDataAllocated = 0;
     707        }
     708
     709        pScreenshot->Img.enmFormat = GL_BGRA;
     710        pScreenshot->Img.width = width;
     711        pScreenshot->Img.height = height;
     712        pScreenshot->Img.bpp = 32;
     713        pScreenshot->Img.pitch = pitch;
     714        Rect.xLeft = 0;
     715        Rect.yTop = 0;
     716        Rect.xRight = pScreen->u32Width;
     717        Rect.yBottom = pScreen->u32Height;
     718        int rc = CrFbBltGetContents(hFb, &Rect, 1, &Rect, &pScreenshot->Img);
     719        if (!RT_SUCCESS(rc))
     720        {
     721            WARN(("CrFbBltGetContents failed %d", rc));
     722            crServerVBoxScreenshotRelease(pScreenshot);
     723            return rc;
     724        }
     725    }
     726    else
     727    {
     728        pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
     729        if (!pvBuffer)
     730            pScreenshot->Img.pvData = CrFbGetVRAM(hFb);
     731        else
     732        {
     733            pScreenshot->Img.pvData = pvBuffer;
     734            memcpy(pvBuffer, CrFbGetVRAM(hFb), pScreenshot->Img.cbData);
    679735        }
    680736        pScreenshot->Img.enmFormat = GL_BGRA;
    … …  
    683739        pScreenshot->Img.bpp = pScreen->u16BitsPerPixel;
    684740        pScreenshot->Img.pitch = pScreen->u32LineSize;
    685         Rect.xLeft = 0;
    686         Rect.yTop = 0;
    687         Rect.xRight = pScreenshot->Img.width;
    688         Rect.yBottom = pScreenshot->Img.height;
    689         int rc = CrFbBltGetContents(hFb, &Pos, 1, &Rect, &pScreenshot->Img);
    690         if (!RT_SUCCESS(rc))
    691         {
    692             WARN(("CrFbBltGetContents failed %d", rc));
    693             RTMemFree(pScreenshot->Img.pvData);
    694             return rc;
    695         }
    696         pScreenshot->fDataIsFbDirect = 0;
    697     }
    698     else
    699     {
    700         pScreenshot->Img.pvData = CrFbGetVRAM(hFb);
    701         pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
    702         pScreenshot->Img.enmFormat = GL_BGRA;
    703         pScreenshot->Img.width = pScreen->u32Width;
    704         pScreenshot->Img.height = pScreen->u32Height;
    705         pScreenshot->Img.bpp = pScreen->u16BitsPerPixel;
    706         pScreenshot->Img.pitch = pScreen->u32LineSize;
    707 
    708         pScreenshot->fDataIsFbDirect = 1;
     741
     742        pScreenshot->fDataAllocated = 0;
    709743    }
    710744
    … …  
    712746
    713747    return VINF_SUCCESS;
    714 }
    715 
    716 DECLEXPORT(void) crServerVBoxScreenshotRelease(CR_SCREENSHOT *pScreenshot)
    717 {
    718     if (!pScreenshot->fDataIsFbDirect)
    719     {
    720         RTMemFree(pScreenshot->Img.pvData);
    721         pScreenshot->fDataIsFbDirect = 1;
    722     }
    723748}
    724749

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

    r50313 r50364  
    2727#include <cr_vreg.h>
    2828#include <cr_htable.h>
     29#include <cr_bmpscale.h>
    2930
    3031#include <iprt/cdefs.h>
    … …  
    8384    CRHTABLE SlotTable;
    8485} CR_FRAMEBUFFER;
     86
     87typedef union CR_FBENTRY_FLAGS
     88{
     89    struct {
     90        uint32_t fCreateNotified : 1;
     91        uint32_t fInList         : 1;
     92        uint32_t Reserved        : 30;
     93    };
     94    uint32_t Value;
     95} CR_FBENTRY_FLAGS;
     96
     97typedef struct CR_FRAMEBUFFER_ENTRY
     98{
     99    VBOXVR_SCR_COMPOSITOR_ENTRY Entry;
     100    RTLISTNODE Node;
     101    uint32_t cRefs;
     102    CR_FBENTRY_FLAGS Flags;
     103    CRHTABLE HTable;
     104} CR_FRAMEBUFFER_ENTRY;
     105
     106typedef struct CR_FBTEX
     107{
     108    CR_TEXDATA Tex;
     109    CRTextureObj *pTobj;
     110} CR_FBTEX;
     111
     112#define PCR_FBTEX_FROM_TEX(_pTex) ((CR_FBTEX*)((uint8_t*)(_pTex) - RT_OFFSETOF(CR_FBTEX, Tex)))
     113#define PCR_FRAMEBUFFER_FROM_COMPOSITOR(_pCompositor) ((CR_FRAMEBUFFER*)((uint8_t*)(_pCompositor) - RT_OFFSETOF(CR_FRAMEBUFFER, Compositor)))
     114#define PCR_FBENTRY_FROM_ENTRY(_pEntry) ((CR_FRAMEBUFFER_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_FRAMEBUFFER_ENTRY, Entry)))
     115
    85116
    86117typedef struct CR_FBDISPLAY_INFO
    … …  
    234265}
    235266
    236 int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTPOINT *pPoint, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
     267static void crFbBltImgStretched(void *pvSrc, const RTRECT *pSrcDataRect, bool fSrcInvert, const RTRECT *pCopyRect, const RTPOINT *pDstDataPoint, float strX, float strY, CR_BLITTER_IMG *pDst)
     268{
     269    int32_t cbSrcPitch = (pSrcDataRect->xRight - pSrcDataRect->xLeft) * 4;
     270    int32_t srcX = pCopyRect->xLeft - pSrcDataRect->xLeft;
     271    int32_t srcY = pCopyRect->yTop - pSrcDataRect->yTop;
     272    Assert(srcX >= 0);
     273    Assert(srcY >= 0);
     274    Assert(srcX < pSrcDataRect->xRight - pSrcDataRect->xLeft);
     275    Assert(srcY < pSrcDataRect->yBottom - pSrcDataRect->yTop);
     276
     277    int32_t cbDstPitch = (int32_t)pDst->pitch;
     278    int32_t dstX = static_cast<uint32_t>(strX * pCopyRect->xLeft - pDstDataPoint->x);
     279    int32_t dstY = static_cast<uint32_t>(strY * pCopyRect->yTop - pDstDataPoint->y);
     280    Assert(dstX >= 0);
     281    Assert(dstY >= 0);
     282
     283    uint8_t *pu8Src = ((uint8_t*)pvSrc) + cbSrcPitch * (!fSrcInvert ? srcY : pSrcDataRect->yBottom - pSrcDataRect->yTop - srcY - 1) + srcX * 4;
     284    uint8_t *pu8Dst = ((uint8_t*)pDst->pvData) + cbDstPitch * dstY + dstX * 4;
     285    if (fSrcInvert)
     286        cbSrcPitch = -cbSrcPitch;
     287
     288    int srcW = pCopyRect->xRight - pCopyRect->xLeft;
     289    int srcH = pCopyRect->yBottom - pCopyRect->yTop;
     290    int dstW = static_cast<uint32_t>(strX * srcW);
     291    int dstH = static_cast<uint32_t>(strY * srcH);
     292
     293    CrBmpScale32(pu8Dst, cbDstPitch,
     294                            dstW, dstH,
     295                            pu8Src,
     296                            cbSrcPitch,
     297                            srcW, srcH);
     298}
     299
     300
     301static int crFbBltGetContentsDirect(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
    237302{
    238303    VBOXVR_LIST List;
    239304    uint32_t c2DRects = 0;
    240305    CR_TEXDATA *pEnteredTex = NULL;
     306    PCR_BLITTER pEnteredBlitter = NULL;
     307
     308    VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
     309    RTPOINT SrcPoint = {pSrcRect->xLeft, pSrcRect->yTop};
     310    float strX = ((float)pImg->width) / (pSrcRect->xRight - pSrcRect->xLeft);
     311    float strY = ((float)pImg->height) / (pSrcRect->yBottom - pSrcRect->yTop);
     312
    241313    VBoxVrListInit(&List);
    242314    int rc = VBoxVrListRectsAdd(&List, 1, CrVrScrCompositorRectGet(&hFb->Compositor), NULL);
    … …  
    247319    }
    248320
    249     VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
    250 
    251321    CrVrScrCompositorConstIterInit(&hFb->Compositor, &Iter);
    252322
    … …  
    271341        }
    272342
    273         Assert(!pEnteredTex);
     343        uint32_t width, height;
     344        RTRECT SrcRect;
    274345
    275346        for (uint32_t i = 0; i < cRects; ++i)
    … …  
    284355                    continue;
    285356
     357                VBoxRectStretch(&Intersection, strX, strY);
     358                if (VBoxRectIsZero(&Intersection))
     359                    continue;
     360
    286361                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
    287362                const CR_BLITTER_IMG *pSrcImg;
    288363
    289                 if (!pEnteredTex)
     364                if (pEnteredTex != pTex)
    290365                {
     366                    if (!pEnteredBlitter)
     367                    {
     368                        pEnteredBlitter = CrTdBlitterGet(pTex);
     369                        rc = CrBltEnter(pEnteredBlitter);
     370                        if (!RT_SUCCESS(rc))
     371                        {
     372                            WARN(("CrBltEnter failed %d", rc));
     373                            pEnteredBlitter = NULL;
     374                            goto end;
     375                        }
     376                    }
     377
     378                    if (pEnteredTex)
     379                    {
     380                        CrTdBltLeave(pEnteredTex);
     381
     382                        pEnteredTex = NULL;
     383
     384                        if (pEnteredBlitter != CrTdBlitterGet(pTex))
     385                        {
     386                            WARN(("blitters not equal!"));
     387                            CrBltLeave(pEnteredBlitter);
     388
     389                            pEnteredBlitter = CrTdBlitterGet(pTex);
     390                            rc = CrBltEnter(pEnteredBlitter);
     391                             if (!RT_SUCCESS(rc))
     392                             {
     393                                 WARN(("CrBltEnter failed %d", rc));
     394                                 pEnteredBlitter = NULL;
     395                                 goto end;
     396                             }
     397                        }
     398                    }
     399
    291400                    rc = CrTdBltEnter(pTex);
    292401                    if (!RT_SUCCESS(rc))
    … …  
    297406
    298407                    pEnteredTex = pTex;
     408
     409                    const VBOXVR_TEXTURE *pVrTex = CrTdTexGet(pTex);
     410
     411                    width = static_cast<uint32_t>(strX * pVrTex->width);
     412                    height = static_cast<uint32_t>(strY * pVrTex->height);
     413                    VBoxRectStretched(CrVrScrCompositorEntryRectGet(pEntry), strX, strY, &SrcRect);
    299414                }
    300415
    301                 rc = CrTdBltDataAcquire(pTex, GL_BGRA, false, &pSrcImg);
     416                rc = CrTdBltDataAcquireStretched(pTex, GL_BGRA, false, width, height, &pSrcImg);
    302417                if (!RT_SUCCESS(rc))
    303418                {
    … …  
    306421                }
    307422
    308                 const RTRECT *pEntryRect = CrVrScrCompositorEntryRectGet(pEntry);
    309423                bool fInvert = !(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS);
    310424
    311                 crFbBltImg(pSrcImg->pvData, pEntryRect, fInvert, &Intersection, pPoint, pImg);
    312 
    313                 CrTdBltDataRelease(pTex);
     425                crFbBltImg(pSrcImg->pvData, &SrcRect, fInvert, &Intersection, &SrcPoint, pImg);
     426
     427                CrTdBltDataReleaseStretched(pTex, pSrcImg);
    314428            }
    315         }
    316 
    317         if (pEnteredTex)
    318         {
    319             CrTdBltLeave(pEnteredTex);
    320             pEnteredTex = NULL;
    321429        }
    322430    }
    … …  
    351459
    352460        RTPOINT Pos = {0};
     461        const RTRECT *pCompRect = CrVrScrCompositorRectGet(&hFb->Compositor);
     462        uint32_t fbPitch = (pCompRect->xRight - pCompRect->xLeft) * 4;
     463        uint32_t fbHeight = pCompRect->yBottom - pCompRect->yTop;
     464
     465        uint32_t dstPitch = static_cast<uint32_t>(strX * fbPitch);
     466        uint32_t dstHeight = static_cast<uint32_t>(strY * fbHeight);
     467
     468        bool fStretch = fbPitch != dstPitch || fbHeight != dstHeight;
    353469
    354470        for (uint32_t i = 0; i < cRects; ++i)
    … …  
    363479                    continue;
    364480
    365                 crFbBltImg(hFb->pvVram, CrVrScrCompositorRectGet(&hFb->Compositor), false, &Intersection, pPoint, pImg);
     481                if (!fStretch)
     482                    crFbBltImg(hFb->pvVram, pCompRect, false, &Intersection, &SrcPoint, pImg);
     483                else
     484                    crFbBltImgStretched(hFb->pvVram, pCompRect, false, &Intersection, &SrcPoint, strX, strY, pImg);
    366485            }
    367486        }
    … …  
    373492        CrTdBltLeave(pEnteredTex);
    374493
     494    if (pEnteredBlitter)
     495        CrBltLeave(pEnteredBlitter);
     496
    375497    VBoxVrListClear(&List);
    376498
    377499    return rc;
    378500}
     501
     502static int crFbBltGetContentsStretchCPU(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
     503{
     504    uint32_t srcWidth = pSrcRect->xRight - pSrcRect->xLeft;
     505    uint32_t srcHeight = pSrcRect->yBottom - pSrcRect->yTop;
     506
     507    /* destination is bigger than the source, do 3D data stretching with CPU */
     508    CR_BLITTER_IMG Img;
     509    Img.cbData = srcWidth * srcHeight * 4;
     510    Img.pvData = RTMemAlloc(Img.cbData);
     511    if (!Img.pvData)
     512    {
     513        WARN(("RTMemAlloc Failed"));
     514        return VERR_NO_MEMORY;
     515    }
     516    Img.enmFormat = pImg->enmFormat;
     517    Img.width = srcWidth;
     518    Img.height = srcHeight;
     519    Img.bpp = pImg->bpp;
     520    Img.pitch = Img.width * 4;
     521
     522    int rc = CrFbBltGetContents(hFb, pSrcRect, cRects, pRects, &Img);
     523    if (RT_SUCCESS(rc))
     524    {
     525        CrBmpScale32((uint8_t *)pImg->pvData,
     526                            pImg->pitch,
     527                            pImg->width, pImg->height,
     528                            (const uint8_t *)Img.pvData,
     529                            Img.pitch,
     530                            Img.width, Img.height);
     531    }
     532    else
     533        WARN(("CrFbBltGetContents failed %d", rc));
     534
     535    RTMemFree(Img.pvData);
     536
     537    return rc;
     538
     539}
     540
     541int CrFbBltGetContents(HCR_FRAMEBUFFER hFb, const RTRECT *pSrcRect, uint32_t cRects, const RTRECT *pRects, CR_BLITTER_IMG *pImg)
     542{
     543    uint32_t srcWidth = pSrcRect->xRight - pSrcRect->xLeft;
     544    uint32_t srcHeight = pSrcRect->yBottom - pSrcRect->yTop;
     545    if ((srcWidth == pImg->width
     546            && srcHeight == pImg->height)
     547            || !CrFbHas3DData(hFb)
     548            || (srcWidth * srcHeight > pImg->width * pImg->height))
     549    {
     550        return crFbBltGetContentsDirect(hFb, pSrcRect, cRects, pRects, pImg);
     551    }
     552
     553    return crFbBltGetContentsStretchCPU(hFb, pSrcRect, cRects, pRects, pImg);
     554}
     555
    379556
    380557int CrFbResize(CR_FRAMEBUFFER *pFb, const struct VBVAINFOSCREEN * pScreen, void *pvVRAM)
    … …  
    454631}
    455632
    456 typedef union CR_FBENTRY_FLAGS
    457 {
    458     struct {
    459         uint32_t fCreateNotified : 1;
    460         uint32_t fInList         : 1;
    461         uint32_t Reserved        : 30;
    462     };
    463     uint32_t Value;
    464 } CR_FBENTRY_FLAGS;
    465 
    466 typedef struct CR_FRAMEBUFFER_ENTRY
    467 {
    468     VBOXVR_SCR_COMPOSITOR_ENTRY Entry;
    469     RTLISTNODE Node;
    470     uint32_t cRefs;
    471     CR_FBENTRY_FLAGS Flags;
    472     CRHTABLE HTable;
    473 } CR_FRAMEBUFFER_ENTRY;
    474 
    475 typedef struct CR_FBTEX
    476 {
    477     CR_TEXDATA Tex;
    478     CRTextureObj *pTobj;
    479 } CR_FBTEX;
    480 
    481 #define PCR_FBTEX_FROM_TEX(_pTex) ((CR_FBTEX*)((uint8_t*)(_pTex) - RT_OFFSETOF(CR_FBTEX, Tex)))
    482 #define PCR_FRAMEBUFFER_FROM_COMPOSITOR(_pCompositor) ((CR_FRAMEBUFFER*)((uint8_t*)(_pCompositor) - RT_OFFSETOF(CR_FRAMEBUFFER, Compositor)))
    483 #define PCR_FBENTRY_FROM_ENTRY(_pEntry) ((CR_FRAMEBUFFER_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_FRAMEBUFFER_ENTRY, Entry)))
    484 
    485633#define CR_PMGR_MODE_WINDOW 0x1
    486634/* mutually exclusive with CR_PMGR_MODE_WINDOW */
    … …  
    661809        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pEntry->Entry);
    662810        if (pTex)
    663             CrTdBltDataDiscardNe(pTex);
     811            CrTdBltDataInvalidateNe(pTex);
    664812    }
    665813}
    … …  
    702850
    703851        CrHTableMoveTo(&pFbEntry->HTable, &pFbReplacingEntry->HTable);
     852
     853        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pFbEntry->Entry);
     854        CR_TEXDATA *pReplacingTex = CrVrScrCompositorEntryTexGet(&pFbReplacingEntry->Entry);
     855
     856        CrTdBltStretchCacheMoveTo(pTex, pReplacingTex);
     857
    704858        if (pFb->pDisplay)
    705859            pFb->pDisplay->EntryReplaced(pFb, pFbReplacingEntry, pFbEntry);
    706860
    707         CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pFbEntry->Entry);
    708         if (pTex)
    709             CrTdBltDataDiscardNe(pTex);
     861        CrTdBltDataInvalidateNe(pTex);
    710862
    711863        /* 2. mark the replaced entry is destroyed */
    … …  
    727879            CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pFbEntry->Entry);
    728880            if (pTex)
    729                 CrTdBltDataDiscardNe(pTex);
     881                CrTdBltDataInvalidateNe(pTex);
    730882        }
    731883    }
    … …  
    791943        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&pEntry->Entry);
    792944        if (pTex)
    793             CrTdBltDataDiscardNe(pTex);
     945            CrTdBltDataInvalidateNe(pTex);
    794946    }
    795947
    … …  
    9311083                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&hEntry->Entry);
    9321084                if (pTex)
    933                     CrTdBltDataDiscardNe(pTex);
     1085                    CrTdBltDataInvalidateNe(pTex);
    9341086            }
    9351087        }
    … …  
    10051157                CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(&hEntry->Entry);
    10061158                if (pTex)
    1007                     CrTdBltDataDiscardNe(pTex);
     1159                    CrTdBltDataInvalidateNe(pTex);
    10081160            }
    10091161        }
    … …  
    27912943        CR_TEXDATA *pNewTex = CrVrScrCompositorEntryTexGet(pNewEntry);
    27922944
    2793         rc = CrTdBltEnter(pReplacedTex);
     2945        CrTdBltDataInvalidateNe(pReplacedTex);
     2946
     2947        rc = CrTdBltEnter(pNewTex);
    27942948        if (RT_SUCCESS(rc))
    27952949        {
    2796             if (pNewTex != pReplacedTex)
    2797             {
    2798                 CrTdBltDataDiscard(pReplacedTex);
    2799                 rc = CrTdBltEnter(pNewTex);
    2800                 if (RT_SUCCESS(rc))
    2801                 {
    2802                     rc = vrdpFrame(hNewEntry);
    2803                     CrTdBltLeave(pNewTex);
    2804                 }
    2805                 else
    2806                     WARN(("CrTdBltEnter failed %d", rc));
    2807             }
    2808             else
    2809                 rc = vrdpFrame(hNewEntry);
    2810 
    2811             CrTdBltLeave(pReplacedTex);
     2950            rc = vrdpFrame(hNewEntry);
     2951            CrTdBltLeave(pNewTex);
    28122952        }
    28132953        else
    28142954            WARN(("CrTdBltEnter failed %d", rc));
    28152955
    2816         return rc;
     2956        return rc;
    28172957    }
    28182958
    … …  
    28492989            return rc;
    28502990        }
     2991
     2992        const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
     2993        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
     2994        CrTdBltDataInvalidateNe(pTex);
    28512995
    28522996        return vrdpRegions(pFb, hEntry);
    … …  
    29903134        CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
    29913135        const CR_BLITTER_IMG *pImg;
    2992         CrTdBltDataDiscard(pTex);
     3136        CrTdBltDataInvalidateNe(pTex);
    29933137        int rc = CrTdBltDataAcquire(pTex, GL_BGRA, !!(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS), &pImg);
    29943138        if (!RT_SUCCESS(rc))
    … …  
    31873331}
    31883332#endif
     3333
     3334class CrFbDisplayEntryDataMonitor : public CrFbDisplayBase
     3335{
     3336public:
     3337    virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
     3338    {
     3339        entryDataChanged(pFb, hReplacedEntry);
     3340        return VINF_SUCCESS;
     3341    }
     3342
     3343    virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
     3344    {
     3345        entryDataChanged(pFb, hEntry);
     3346        return VINF_SUCCESS;
     3347    }
     3348
     3349    virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
     3350    {
     3351        entryDataChanged(pFb, hEntry);
     3352        return VINF_SUCCESS;
     3353    }
     3354protected:
     3355    virtual void entryDataChanged(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry)
     3356    {
     3357
     3358    }
     3359};
    31893360
    31903361int CrPMgrInit()
    … …  
    42504421                uint8_t *pu8Buf = g_pvVRamBase + offVRAM;
    42514422
    4252                 RTPOINT Pos = {pBlt->Pos.x, pBlt->Pos.y};
     4423                RTRECT Rect;
     4424                Rect.xLeft = pBlt->Pos.x;
     4425                Rect.yTop = pBlt->Pos.y;
     4426                Rect.xRight = Rect.xLeft + pScreen->u32Width;
     4427                Rect.yBottom = Rect.yTop + pScreen->u32Height;
    42534428                CR_BLITTER_IMG Img;
    42544429                Img.pvData = pu8Buf;
    … …  
    42594434                Img.bpp = pScreen->u16BitsPerPixel;
    42604435                Img.pitch = pScreen->u32LineSize;
    4261                 int rc = CrFbBltGetContents(hFb, &Pos, cRects, pRects, &Img);
     4436                int rc = CrFbBltGetContents(hFb, &Rect, cRects, pRects, &Img);
    42624437                if (!RT_SUCCESS(rc))
    42634438                {
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette