DisplayImpl.cpp revision 7b84c84954ddfdd1a3c65f0023f107b6bfcf3cc3
65fea56f17cd614bc8908264df980a62e1931468vboxsync * VirtualBox COM class implementation
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Copyright (C) 2006-2013 Oracle Corporation
65fea56f17cd614bc8908264df980a62e1931468vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
65fea56f17cd614bc8908264df980a62e1931468vboxsync * available from http://www.virtualbox.org. This file is free software;
65fea56f17cd614bc8908264df980a62e1931468vboxsync * you can redistribute it and/or modify it under the terms of the GNU
65fea56f17cd614bc8908264df980a62e1931468vboxsync * General Public License (GPL) as published by the Free Software
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
65fea56f17cd614bc8908264df980a62e1931468vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
65fea56f17cd614bc8908264df980a62e1931468vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
65fea56f17cd614bc8908264df980a62e1931468vboxsync/* generated header */
65fea56f17cd614bc8908264df980a62e1931468vboxsync#if defined(VBOX_WITH_CROGL) || defined(VBOX_WITH_CRHGSMI)
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Display driver instance data.
65fea56f17cd614bc8908264df980a62e1931468vboxsync * @implements PDMIDISPLAYCONNECTOR
65fea56f17cd614bc8908264df980a62e1931468vboxsync /** Pointer to the display object. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /** Pointer to the driver instance structure. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /** Pointer to the keyboard port interface of the driver/device above us. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /** Our display connector interface. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync#if defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI)
65fea56f17cd614bc8908264df980a62e1931468vboxsync /** VBVA callbacks */
65fea56f17cd614bc8908264df980a62e1931468vboxsync/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) RT_FROM_MEMBER(pInterface, DRVMAINDISPLAY, IConnector)
65fea56f17cd614bc8908264df980a62e1931468vboxsyncstatic int g_stam = 0;
65fea56f17cd614bc8908264df980a62e1931468vboxsync#endif /* DEBUG_sunlover */
65fea56f17cd614bc8908264df980a62e1931468vboxsync// constructor / destructor
65fea56f17cd614bc8908264df980a62e1931468vboxsync/////////////////////////////////////////////////////////////////////////////
65fea56f17cd614bc8908264df980a62e1931468vboxsync// public initializer/uninitializer for internal purposes only
65fea56f17cd614bc8908264df980a62e1931468vboxsync/////////////////////////////////////////////////////////////////////////////
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Save thumbnail and screenshot of the guest screen.
65fea56f17cd614bc8908264df980a62e1931468vboxsyncstatic int displayMakeThumbnail(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
65fea56f17cd614bc8908264df980a62e1931468vboxsync uint8_t **ppu8Thumbnail, uint32_t *pcbThumbnail, uint32_t *pcxThumbnail, uint32_t *pcyThumbnail)
65fea56f17cd614bc8908264df980a62e1931468vboxsync LogRelFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxThumbnail, cyThumbnail));
65fea56f17cd614bc8908264df980a62e1931468vboxsyncDisplay::displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* 32bpp small RGB image. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* PNG screenshot. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* Query RGB bitmap. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync int rc = Display::displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pu8Data, &cbData, &cx, &cy);
65fea56f17cd614bc8908264df980a62e1931468vboxsync * It is possible that success is returned but everything is 0 or NULL.
65fea56f17cd614bc8908264df980a62e1931468vboxsync * (no display attached if a VM is running with VBoxHeadless on OSE for example)
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* Prepare a small thumbnail and a PNG screenshot. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync displayMakeThumbnail(pu8Data, cx, cy, &pu8Thumbnail, &cbThumbnail, &cxThumbnail, &cyThumbnail);
65fea56f17cd614bc8908264df980a62e1931468vboxsync rc = DisplayMakePNG(pu8Data, cx, cy, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 1);
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* This can be called from any thread. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync that->mpDrv->pUpPort->pfnFreeScreenshot(that->mpDrv->pUpPort, pu8Data);
65fea56f17cd614bc8908264df980a62e1931468vboxsync LogFunc(("Failed to get VM pointer 0x%x\n", ptrVM.rc()));
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* Regardless of rc, save what is available:
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Data format:
65fea56f17cd614bc8908264df980a62e1931468vboxsync * uint32_t cBlocks;
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Each block is:
65fea56f17cd614bc8908264df980a62e1931468vboxsync * uint32_t cbBlock; if 0 - no 'block data'.
65fea56f17cd614bc8908264df980a62e1931468vboxsync * uint32_t typeOfBlock; 0 - 32bpp RGB bitmap, 1 - PNG, ignored if 'cbBlock' is 0.
65fea56f17cd614bc8908264df980a62e1931468vboxsync * [block data]
65fea56f17cd614bc8908264df980a62e1931468vboxsync * Block data for bitmap and PNG:
65fea56f17cd614bc8908264df980a62e1931468vboxsync * uint32_t cx;
65fea56f17cd614bc8908264df980a62e1931468vboxsync * uint32_t cy;
65fea56f17cd614bc8908264df980a62e1931468vboxsync * [image data]
65fea56f17cd614bc8908264df980a62e1931468vboxsync SSMR3PutU32(pSSM, 2); /* Write thumbnail and PNG screenshot. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync /* First block. */
65fea56f17cd614bc8908264df980a62e1931468vboxsync SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof (uint32_t));
if (cbPNG)
DECLCALLBACK(int)
return rc;
DECLCALLBACK(void)
DECLCALLBACK(int)
return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, that->mcMonitors);
uint32_t w;
uint32_t h;
return VINF_SUCCESS;
#ifdef VBOX_WITH_HGSMI
return S_OK;
if (mParent)
if (mpDrv)
mfVMMDevInited = true;
#ifdef VBOX_WITH_VPX
/* uInstance is an arbitrary value greater than 1024. Such a value will ensure a quick seek in saved state file. */
rc = SSMR3RegisterExternal(pUVM, "DisplayScreenshot", 1100 /*uInstance*/, sSSMDisplayScreenshotVer, 0 /*cbGuess*/,
return VINF_SUCCESS;
switch (aType)
mfMachineRunning = true;
mfMachineRunning = false;
AssertFailed();
return S_OK;
if (!finished)
return VINF_VGA_RESIZE_IN_PROGRESS;
return VINF_SUCCESS;
return VINF_SUCCESS;
mLastWidth = w;
mLastHeight = h;
switch (bpp)
return VINF_VGA_RESIZE_IN_PROGRESS;
return rc;
return VINF_SUCCESS;
unsigned uScreenId;
bool f = ASMAtomicCmpXchgU32 (&pFBInfo->u32ResizeStatus, ResizeStatus_Void, ResizeStatus_UpdateDisplayData);
pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h, pFBInfo->pendingResize.flags);
#ifdef DEBUG_sunlover
if (!g_stam)
if (is3denabled)
if (pVMMDev)
pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
if (*px < 0)
*px = 0;
if (*py < 0)
*py = 0;
unsigned mapCoordsToScreen(DISPLAYFBINFO *pInfos, unsigned cInfos, int *px, int *py, int *pw, int *ph)
unsigned uScreenId;
LogSunlover((" [%d] %d,%d %dx%d\n", uScreenId, pInfo->xOrigin, pInfo->yOrigin, pInfo->w, pInfo->h));
uScreenId = 0;
return uScreenId;
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover
#ifndef VBOX_WITH_HGSMI
if (!mfVideoAccelEnabled)
if (!mpDrv)
* sizeof (RTRECT));
if (!pVisibleRegion)
return VERR_NO_TMP_MEMORY;
unsigned uScreenId;
if (mpDrv)
uint32_t i;
for (i = 0; i < cRect; i++)
return VINF_SUCCESS;
return VERR_NOT_SUPPORTED;
typedef struct _VBVADIRTYREGION
unsigned cMonitors;
static void vbvaRgnInit (VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors, Display *pd, PPDMIDISPLAYPORT pp)
unsigned uScreenId;
prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
bool fVideoAccelEnabled,
bool fVideoAccelVRDP,
unsigned cFBInfos)
if (pVbvaMemory)
if (fVideoAccelEnabled)
if (fVideoAccelVRDP)
unsigned uScreenId;
#ifdef VBOX_WITH_HGSMI
bool fVideoAccelVRDP,
if (fVideoAccelVRDP)
LogRelFlowFunc((" fu32HostEvents = 0x%08X, fu32SupportedOrders = 0x%08X\n", fu32HostEvents, fu32SupportedOrders));
bool fVideoAccelVRDP,
unsigned cFBInfos)
unsigned uScreenId;
int rc;
vbvaLock();
vbvaUnlock();
return rc;
if (!VideoAccelAllowed ())
return VERR_NOT_SUPPORTED;
if (!mfMachineRunning)
if (fEnable)
return rc;
return rc;
if (mfVideoAccelEnabled)
videoAccelFlush ();
mfVideoAccelEnabled = false;
if (pVMMDev)
if (pVMMDevPort)
if (fEnable)
mfVideoAccelEnabled = true;
vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
mfu32PendingVideoAccelDisable = false;
return rc;
vbvaLock();
int c = fEnable?
Assert (c >= 0);
mfVideoAccelVRDP = false;
mfu32SupportedOrders = 0;
vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
#ifdef VBOX_WITH_HGSMI
&& !mfVideoAccelVRDP)
mfVideoAccelVRDP = true;
mfu32SupportedOrders = ~0;
vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
#ifdef VBOX_WITH_HGSMI
vbvaUnlock();
if (i32Diff <= 0)
static bool vbvaPartialRead (uint8_t **ppu8, uint32_t *pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
if (*ppu8)
if (!pu8New)
cbRecord));
if (*ppu8)
*pcb = 0;
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover
if (mcbVbvaPartial)
LogFlowFunc(("continue partial record mcbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
mcbVbvaPartial = 0;
#ifdef DEBUG_sunlover
LogFlowFunc(("started partial record mcbVbvaPartial = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
if (cbRecord)
if (!dst)
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover
mcbVbvaPartial = 0;
vbvaLock();
vbvaUnlock();
#ifdef DEBUG_sunlover_2
if (!mfVideoAccelEnabled)
#ifdef DEBUG_sunlover_2
mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree, mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
unsigned uScreenId;
Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
if (cbCmd != 0)
#ifdef DEBUG_sunlover
int x = phdr->x;
int y = phdr->y;
int w = phdr->w;
int h = phdr->h;
vbvaLock();
else if (mfPendingVideoAccelEnable)
if (mfMachineRunning)
mfPendingVideoAccelEnable = false;
if (mfVideoAccelEnabled)
videoAccelFlush ();
vbvaUnlock();
return rc;
return E_INVALIDARG;
if (aWidth)
if (aHeight)
if (aBitsPerPixel)
return S_OK;
if (is3denabled)
if (pVMMDev)
vrc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
return S_OK;
return E_INVALIDARG;
if (*aFramebuffer)
if (aXOrigin)
if (aYOrigin)
return S_OK;
if (!width)
if (!height)
if (!bpp)
return E_INVALIDARG;
return E_INVALIDARG;
if (pVMMDev)
if (pVMMDevPort)
return S_OK;
if (pVMMDev)
if (pVMMDevPort)
if (!enabled)
return S_OK;
int Display::displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData, uint32_t *pu32Width, uint32_t *pu32Height)
int rc;
rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppu8Data, pcbData, pu32Width, pu32Height);
if (cbRequired)
*pcbData = 0;
*pu32Width = 0;
*pu32Height = 0;
return rc;
static int displayTakeScreenshot(PUVM pUVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId,
while (cRetries-- > 0)
src,
return vrc;
if (!mpDrv)
return E_FAIL;
return rc;
if (!mpDrv)
return E_FAIL;
if (!pu8Data)
return E_OUTOFMEMORY;
while (cPixels)
cPixels--;
return rc;
if (!pu8Data)
return E_OUTOFMEMORY;
if (pu8PNG)
if (pu8PNG)
return rc;
int Display::drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height)
rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
xSrc = x;
ySrc = y;
return rc;
return rc;
unsigned uScreenId;
if (!fUpdateAll)
/* pdm.h says that this has to be called from the EMT thread */
int rcVBox = VMR3ReqCallVoidWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
return rc;
return S_OK;
#ifdef VBOX_WITH_VIDEOHWACCEL
return S_OK;
return E_NOTIMPL;
if (is3denabled)
if (pVMMDev)
pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_VIEWPORT_CHANGED, SHCRGL_CPARMS_VIEWPORT_CHANGED, aParms);
return S_OK;
if (!mpDrv)
#ifdef VBOX_STRICT
if (pFramebuffer)
#ifdef VBOX_WITH_CRHGSMI
if (pVMMDev)
unsigned uScreenId)
#if defined(VBOX_WITH_CROGL)
if (is3denabled)
pFBInfo->w,
pFBInfo->h,
return VINF_SUCCESS;
return pDrv->pDisplay->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover_2
bool fNoUpdate = false; /* Do not update the display if any of the framebuffers is being resized. */
unsigned uScreenId;
fNoUpdate = true;
if (!fNoUpdate)
#ifdef VBOX_WITH_VPX
int rc;
#ifdef DEBUG_sunlover
#ifdef DEBUG_sunlover_2
DECLCALLBACK(void) Display::displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
/* The LFBModeChange function is called under DevVGA lock. Postpone disabling VBVA, do it in the refresh timer. */
DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize)
#ifndef VBOX_WITH_HGSMI
LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
LogRelFlow(("VBOX_VIDEO_INFO_TYPE_DISPLAY: %d: at 0x%08X, size 0x%08X, info 0x%08X\n", pDisplay->u32Index, pDisplay->u32Offset, pDisplay->u32FramebufferSize, pDisplay->u32InformationSize));
LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP) /** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp pushing this to us? */
LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
DECLCALLBACK(void) Display::displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId)
LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
LogRelFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel, (uint8_t *)pvVRAM + pFBInfo->u32Offset, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, VBVA_SCREEN_F_ACTIVE);
LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
pHostEvents));
LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
#ifdef VBOX_WITH_VIDEOHWACCEL
#ifdef DEBUG_misha
DECLCALLBACK(void) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
#ifdef VBOX_WITH_CRHGSMI
void Display::handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
void Display::handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr, result);
void Display::handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
if (mhCrOglSvc)
if (pVMMDev)
void Display::handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
if (mhCrOglSvc)
if (pVMMDev)
rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm, Display::displayCrHgsmiControlCompletion, this);
DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
#ifdef VBOX_WITH_HGSMI
DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags)
vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
return VINF_SUCCESS;
DECLCALLBACK(void) Display::displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
pFBInfo->w = 0;
pFBInfo->h = 0;
DECLCALLBACK(void) Display::displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers, pThis->mcMonitors);
DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd)
LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy)
#ifdef DEBUG_sunlover
static void logVBVAResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, const DISPLAYFBINFO *pFBInfo)
" pFBInfo->pendingResize.cbLine 0x%08X\n"
pFBInfo->w,
pFBInfo->h,
DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
return VINF_SUCCESS;
if (fNewOrigin)
if (is3denabled)
if (pVMMDev)
pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
if (!fResize)
if (fNewOrigin)
return VINF_SUCCESS;
/* If no framebuffer, the resize will be done later when a new framebuffer will be set in changeFramebuffer. */
return VINF_SUCCESS;
DECLCALLBACK(int) Display::displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
const void *pvShape)
if (pvShape)
if (pvShape)
return VINF_SUCCESS;
return NULL;
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_VIDEOHWACCEL
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_HGSMI
return VERR_PDM_MISSING_INTERFACE_ABOVE;
return VERR_PDM_MISSING_INTERFACE_ABOVE;
void *pv;
return rc;
#ifdef VBOX_WITH_CRHGSMI
#ifdef VBOX_WITH_VPX
return E_FAIL;
if (fEnabled)
if (pszExt)
if (!pszAbsPath)
if (!pszExt)
return VINF_SUCCESS;
sizeof(DRVMAINDISPLAY),
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,