VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/DisplayImpl.cpp@ 47908

Last change on this file since 47908 was 47905, checked in by vboxsync, 11 years ago

Main: warnings.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 152.6 KB
Line 
1/* $Id: DisplayImpl.cpp 47905 2013-08-20 12:47:22Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2013 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#include "DisplayImpl.h"
19#include "DisplayUtils.h"
20#include "ConsoleImpl.h"
21#include "ConsoleVRDPServer.h"
22#include "VMMDev.h"
23
24#include "AutoCaller.h"
25#include "Logging.h"
26
27/* generated header */
28#include "VBoxEvents.h"
29
30#include <iprt/semaphore.h>
31#include <iprt/thread.h>
32#include <iprt/asm.h>
33#include <iprt/time.h>
34#include <iprt/cpp/utils.h>
35
36#include <VBox/vmm/pdmdrv.h>
37#if defined(DEBUG) || defined(VBOX_STRICT) /* for VM_ASSERT_EMT(). */
38# include <VBox/vmm/vm.h>
39#endif
40
41#ifdef VBOX_WITH_VIDEOHWACCEL
42# include <VBox/VBoxVideo.h>
43#endif
44
45#if defined(VBOX_WITH_CROGL) || defined(VBOX_WITH_CRHGSMI)
46# include <VBox/HostServices/VBoxCrOpenGLSvc.h>
47#endif
48
49#include <VBox/com/array.h>
50
51#ifdef VBOX_WITH_VPX
52# include <iprt/path.h>
53# include "VideoRec.h"
54#endif
55
56/**
57 * Display driver instance data.
58 *
59 * @implements PDMIDISPLAYCONNECTOR
60 */
61typedef struct DRVMAINDISPLAY
62{
63 /** Pointer to the display object. */
64 Display *pDisplay;
65 /** Pointer to the driver instance structure. */
66 PPDMDRVINS pDrvIns;
67 /** Pointer to the keyboard port interface of the driver/device above us. */
68 PPDMIDISPLAYPORT pUpPort;
69 /** Our display connector interface. */
70 PDMIDISPLAYCONNECTOR IConnector;
71#if defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI)
72 /** VBVA callbacks */
73 PPDMIDISPLAYVBVACALLBACKS pVBVACallbacks;
74#endif
75} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
76
77/** Converts PDMIDISPLAYCONNECTOR pointer to a DRVMAINDISPLAY pointer. */
78#define PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface) RT_FROM_MEMBER(pInterface, DRVMAINDISPLAY, IConnector)
79
80#ifdef DEBUG_sunlover
81static STAMPROFILE g_StatDisplayRefresh;
82static int g_stam = 0;
83#endif /* DEBUG_sunlover */
84
85// constructor / destructor
86/////////////////////////////////////////////////////////////////////////////
87
88Display::Display()
89 : mParent(NULL)
90{
91}
92
93Display::~Display()
94{
95}
96
97
98HRESULT Display::FinalConstruct()
99{
100 mpVbvaMemory = NULL;
101 mfVideoAccelEnabled = false;
102 mfVideoAccelVRDP = false;
103 mfu32SupportedOrders = 0;
104 mcVideoAccelVRDPRefs = 0;
105
106 mpPendingVbvaMemory = NULL;
107 mfPendingVideoAccelEnable = false;
108
109 mfMachineRunning = false;
110
111 mpu8VbvaPartial = NULL;
112 mcbVbvaPartial = 0;
113
114 mpDrv = NULL;
115 mpVMMDev = NULL;
116 mfVMMDevInited = false;
117
118 mLastAddress = NULL;
119 mLastBytesPerLine = 0;
120 mLastBitsPerPixel = 0,
121 mLastWidth = 0;
122 mLastHeight = 0;
123
124 int rc = RTCritSectInit(&mVBVALock);
125 AssertRC(rc);
126
127 rc = RTCritSectInit(&mSaveSeamlessRectLock);
128 AssertRC(rc);
129
130 mfu32PendingVideoAccelDisable = false;
131
132#ifdef VBOX_WITH_HGSMI
133 mu32UpdateVBVAFlags = 0;
134#endif
135#ifdef VBOX_WITH_VPX
136 mpVideoRecCtx = NULL;
137 for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
138 maVideoRecEnabled[i] = true;
139#endif
140
141 return BaseFinalConstruct();
142}
143
144void Display::FinalRelease()
145{
146 uninit();
147
148 if (RTCritSectIsInitialized (&mVBVALock))
149 {
150 RTCritSectDelete (&mVBVALock);
151 RT_ZERO(mVBVALock);
152 }
153
154 if (RTCritSectIsInitialized(&mSaveSeamlessRectLock))
155 {
156 RTCritSectDelete(&mSaveSeamlessRectLock);
157 RT_ZERO(mSaveSeamlessRectLock);
158 }
159 BaseFinalRelease();
160}
161
162// public initializer/uninitializer for internal purposes only
163/////////////////////////////////////////////////////////////////////////////
164
165#define kMaxSizeThumbnail 64
166
167/**
168 * Save thumbnail and screenshot of the guest screen.
169 */
170static int displayMakeThumbnail(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
171 uint8_t **ppu8Thumbnail, uint32_t *pcbThumbnail, uint32_t *pcxThumbnail, uint32_t *pcyThumbnail)
172{
173 int rc = VINF_SUCCESS;
174
175 uint8_t *pu8Thumbnail = NULL;
176 uint32_t cbThumbnail = 0;
177 uint32_t cxThumbnail = 0;
178 uint32_t cyThumbnail = 0;
179
180 if (cx > cy)
181 {
182 cxThumbnail = kMaxSizeThumbnail;
183 cyThumbnail = (kMaxSizeThumbnail * cy) / cx;
184 }
185 else
186 {
187 cyThumbnail = kMaxSizeThumbnail;
188 cxThumbnail = (kMaxSizeThumbnail * cx) / cy;
189 }
190
191 LogRelFlowFunc(("%dx%d -> %dx%d\n", cx, cy, cxThumbnail, cyThumbnail));
192
193 cbThumbnail = cxThumbnail * 4 * cyThumbnail;
194 pu8Thumbnail = (uint8_t *)RTMemAlloc(cbThumbnail);
195
196 if (pu8Thumbnail)
197 {
198 uint8_t *dst = pu8Thumbnail;
199 uint8_t *src = pu8Data;
200 int dstW = cxThumbnail;
201 int dstH = cyThumbnail;
202 int srcW = cx;
203 int srcH = cy;
204 int iDeltaLine = cx * 4;
205
206 BitmapScale32 (dst,
207 dstW, dstH,
208 src,
209 iDeltaLine,
210 srcW, srcH);
211
212 *ppu8Thumbnail = pu8Thumbnail;
213 *pcbThumbnail = cbThumbnail;
214 *pcxThumbnail = cxThumbnail;
215 *pcyThumbnail = cyThumbnail;
216 }
217 else
218 {
219 rc = VERR_NO_MEMORY;
220 }
221
222 return rc;
223}
224
225DECLCALLBACK(void)
226Display::displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
227{
228 Display *that = static_cast<Display*>(pvUser);
229
230 /* 32bpp small RGB image. */
231 uint8_t *pu8Thumbnail = NULL;
232 uint32_t cbThumbnail = 0;
233 uint32_t cxThumbnail = 0;
234 uint32_t cyThumbnail = 0;
235
236 /* PNG screenshot. */
237 uint8_t *pu8PNG = NULL;
238 uint32_t cbPNG = 0;
239 uint32_t cxPNG = 0;
240 uint32_t cyPNG = 0;
241
242 Console::SafeVMPtr ptrVM(that->mParent);
243 if (ptrVM.isOk())
244 {
245 /* Query RGB bitmap. */
246 uint8_t *pu8Data = NULL;
247 size_t cbData = 0;
248 uint32_t cx = 0;
249 uint32_t cy = 0;
250
251 /* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
252 int rc = Display::displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pu8Data, &cbData, &cx, &cy);
253
254 /*
255 * It is possible that success is returned but everything is 0 or NULL.
256 * (no display attached if a VM is running with VBoxHeadless on OSE for example)
257 */
258 if (RT_SUCCESS(rc) && pu8Data)
259 {
260 Assert(cx && cy);
261
262 /* Prepare a small thumbnail and a PNG screenshot. */
263 displayMakeThumbnail(pu8Data, cx, cy, &pu8Thumbnail, &cbThumbnail, &cxThumbnail, &cyThumbnail);
264 rc = DisplayMakePNG(pu8Data, cx, cy, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 1);
265 if (RT_FAILURE(rc))
266 {
267 if (pu8PNG)
268 {
269 RTMemFree(pu8PNG);
270 pu8PNG = NULL;
271 }
272 cbPNG = 0;
273 cxPNG = 0;
274 cyPNG = 0;
275 }
276
277 /* This can be called from any thread. */
278 that->mpDrv->pUpPort->pfnFreeScreenshot(that->mpDrv->pUpPort, pu8Data);
279 }
280 }
281 else
282 {
283 LogFunc(("Failed to get VM pointer 0x%x\n", ptrVM.rc()));
284 }
285
286 /* Regardless of rc, save what is available:
287 * Data format:
288 * uint32_t cBlocks;
289 * [blocks]
290 *
291 * Each block is:
292 * uint32_t cbBlock; if 0 - no 'block data'.
293 * uint32_t typeOfBlock; 0 - 32bpp RGB bitmap, 1 - PNG, ignored if 'cbBlock' is 0.
294 * [block data]
295 *
296 * Block data for bitmap and PNG:
297 * uint32_t cx;
298 * uint32_t cy;
299 * [image data]
300 */
301 SSMR3PutU32(pSSM, 2); /* Write thumbnail and PNG screenshot. */
302
303 /* First block. */
304 SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof (uint32_t));
305 SSMR3PutU32(pSSM, 0); /* Block type: thumbnail. */
306
307 if (cbThumbnail)
308 {
309 SSMR3PutU32(pSSM, cxThumbnail);
310 SSMR3PutU32(pSSM, cyThumbnail);
311 SSMR3PutMem(pSSM, pu8Thumbnail, cbThumbnail);
312 }
313
314 /* Second block. */
315 SSMR3PutU32(pSSM, cbPNG + 2 * sizeof (uint32_t));
316 SSMR3PutU32(pSSM, 1); /* Block type: png. */
317
318 if (cbPNG)
319 {
320 SSMR3PutU32(pSSM, cxPNG);
321 SSMR3PutU32(pSSM, cyPNG);
322 SSMR3PutMem(pSSM, pu8PNG, cbPNG);
323 }
324
325 RTMemFree(pu8PNG);
326 RTMemFree(pu8Thumbnail);
327}
328
329DECLCALLBACK(int)
330Display::displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
331{
332 Display *that = static_cast<Display*>(pvUser);
333
334 if (uVersion != sSSMDisplayScreenshotVer)
335 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
336 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
337
338 /* Skip data. */
339 uint32_t cBlocks;
340 int rc = SSMR3GetU32(pSSM, &cBlocks);
341 AssertRCReturn(rc, rc);
342
343 for (uint32_t i = 0; i < cBlocks; i++)
344 {
345 uint32_t cbBlock;
346 rc = SSMR3GetU32(pSSM, &cbBlock);
347 AssertRCBreak(rc);
348
349 uint32_t typeOfBlock;
350 rc = SSMR3GetU32(pSSM, &typeOfBlock);
351 AssertRCBreak(rc);
352
353 LogRelFlowFunc(("[%d] type %d, size %d bytes\n", i, typeOfBlock, cbBlock));
354
355 /* Note: displaySSMSaveScreenshot writes size of a block = 8 and
356 * do not write any data if the image size was 0.
357 * @todo Fix and increase saved state version.
358 */
359 if (cbBlock > 2 * sizeof (uint32_t))
360 {
361 rc = SSMR3Skip(pSSM, cbBlock);
362 AssertRCBreak(rc);
363 }
364 }
365
366 return rc;
367}
368
369/**
370 * Save/Load some important guest state
371 */
372DECLCALLBACK(void)
373Display::displaySSMSave(PSSMHANDLE pSSM, void *pvUser)
374{
375 Display *that = static_cast<Display*>(pvUser);
376
377 SSMR3PutU32(pSSM, that->mcMonitors);
378 for (unsigned i = 0; i < that->mcMonitors; i++)
379 {
380 SSMR3PutU32(pSSM, that->maFramebuffers[i].u32Offset);
381 SSMR3PutU32(pSSM, that->maFramebuffers[i].u32MaxFramebufferSize);
382 SSMR3PutU32(pSSM, that->maFramebuffers[i].u32InformationSize);
383 SSMR3PutU32(pSSM, that->maFramebuffers[i].w);
384 SSMR3PutU32(pSSM, that->maFramebuffers[i].h);
385 SSMR3PutS32(pSSM, that->maFramebuffers[i].xOrigin);
386 SSMR3PutS32(pSSM, that->maFramebuffers[i].yOrigin);
387 SSMR3PutU32(pSSM, that->maFramebuffers[i].flags);
388 }
389}
390
391DECLCALLBACK(int)
392Display::displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
393{
394 Display *that = static_cast<Display*>(pvUser);
395
396 if (!( uVersion == sSSMDisplayVer
397 || uVersion == sSSMDisplayVer2
398 || uVersion == sSSMDisplayVer3))
399 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
400 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
401
402 uint32_t cMonitors;
403 int rc = SSMR3GetU32(pSSM, &cMonitors);
404 if (cMonitors != that->mcMonitors)
405 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Number of monitors changed (%d->%d)!"), cMonitors, that->mcMonitors);
406
407 for (uint32_t i = 0; i < cMonitors; i++)
408 {
409 SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32Offset);
410 SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32MaxFramebufferSize);
411 SSMR3GetU32(pSSM, &that->maFramebuffers[i].u32InformationSize);
412 if ( uVersion == sSSMDisplayVer2
413 || uVersion == sSSMDisplayVer3)
414 {
415 uint32_t w;
416 uint32_t h;
417 SSMR3GetU32(pSSM, &w);
418 SSMR3GetU32(pSSM, &h);
419 that->maFramebuffers[i].w = w;
420 that->maFramebuffers[i].h = h;
421 }
422 if (uVersion == sSSMDisplayVer3)
423 {
424 int32_t xOrigin;
425 int32_t yOrigin;
426 uint32_t flags;
427 SSMR3GetS32(pSSM, &xOrigin);
428 SSMR3GetS32(pSSM, &yOrigin);
429 SSMR3GetU32(pSSM, &flags);
430 that->maFramebuffers[i].xOrigin = xOrigin;
431 that->maFramebuffers[i].yOrigin = yOrigin;
432 that->maFramebuffers[i].flags = (uint16_t)flags;
433 that->maFramebuffers[i].fDisabled = (that->maFramebuffers[i].flags & VBVA_SCREEN_F_DISABLED) != 0;
434 }
435 }
436
437 return VINF_SUCCESS;
438}
439
440/**
441 * Initializes the display object.
442 *
443 * @returns COM result indicator
444 * @param parent handle of our parent object
445 * @param qemuConsoleData address of common console data structure
446 */
447HRESULT Display::init(Console *aParent)
448{
449 ComAssertRet(aParent, E_INVALIDARG);
450 /* Enclose the state transition NotReady->InInit->Ready */
451 AutoInitSpan autoInitSpan(this);
452 AssertReturn(autoInitSpan.isOk(), E_FAIL);
453
454 unconst(mParent) = aParent;
455
456 ULONG ul;
457 mParent->machine()->COMGETTER(MonitorCount)(&ul);
458 mcMonitors = ul;
459
460 for (ul = 0; ul < mcMonitors; ul++)
461 {
462 maFramebuffers[ul].u32Offset = 0;
463 maFramebuffers[ul].u32MaxFramebufferSize = 0;
464 maFramebuffers[ul].u32InformationSize = 0;
465
466 maFramebuffers[ul].pFramebuffer = NULL;
467 /* All secondary monitors are disabled at startup. */
468 maFramebuffers[ul].fDisabled = ul > 0;
469
470 maFramebuffers[ul].xOrigin = 0;
471 maFramebuffers[ul].yOrigin = 0;
472
473 maFramebuffers[ul].w = 0;
474 maFramebuffers[ul].h = 0;
475
476 maFramebuffers[ul].flags = maFramebuffers[ul].fDisabled? VBVA_SCREEN_F_DISABLED: 0;
477
478 maFramebuffers[ul].u16BitsPerPixel = 0;
479 maFramebuffers[ul].pu8FramebufferVRAM = NULL;
480 maFramebuffers[ul].u32LineSize = 0;
481
482 maFramebuffers[ul].pHostEvents = NULL;
483
484 maFramebuffers[ul].u32ResizeStatus = ResizeStatus_Void;
485
486 maFramebuffers[ul].fDefaultFormat = false;
487
488 maFramebuffers[ul].mcSavedVisibleRegion = 0;
489 maFramebuffers[ul].mpSavedVisibleRegion = NULL;
490
491 RT_ZERO(maFramebuffers[ul].dirtyRect);
492 RT_ZERO(maFramebuffers[ul].pendingResize);
493#ifdef VBOX_WITH_HGSMI
494 maFramebuffers[ul].fVBVAEnabled = false;
495 maFramebuffers[ul].cVBVASkipUpdate = 0;
496 RT_ZERO(maFramebuffers[ul].vbvaSkippedRect);
497 maFramebuffers[ul].pVBVAHostFlags = NULL;
498#endif /* VBOX_WITH_HGSMI */
499 }
500
501 {
502 // register listener for state change events
503 ComPtr<IEventSource> es;
504 mParent->COMGETTER(EventSource)(es.asOutParam());
505 com::SafeArray <VBoxEventType_T> eventTypes;
506 eventTypes.push_back(VBoxEventType_OnStateChanged);
507 es->RegisterListener(this, ComSafeArrayAsInParam(eventTypes), true);
508 }
509
510 /* Confirm a successful initialization */
511 autoInitSpan.setSucceeded();
512
513 return S_OK;
514}
515
516/**
517 * Uninitializes the instance and sets the ready flag to FALSE.
518 * Called either from FinalRelease() or by the parent when it gets destroyed.
519 */
520void Display::uninit()
521{
522 LogRelFlowFunc(("this=%p\n", this));
523
524 /* Enclose the state transition Ready->InUninit->NotReady */
525 AutoUninitSpan autoUninitSpan(this);
526 if (autoUninitSpan.uninitDone())
527 return;
528
529 ULONG ul;
530 for (ul = 0; ul < mcMonitors; ul++)
531 maFramebuffers[ul].pFramebuffer = NULL;
532
533 if (mParent)
534 {
535 ComPtr<IEventSource> es;
536 mParent->COMGETTER(EventSource)(es.asOutParam());
537 es->UnregisterListener(this);
538 }
539
540 unconst(mParent) = NULL;
541
542 if (mpDrv)
543 mpDrv->pDisplay = NULL;
544
545 mpDrv = NULL;
546 mpVMMDev = NULL;
547 mfVMMDevInited = true;
548}
549
550/**
551 * Register the SSM methods. Called by the power up thread to be able to
552 * pass pVM
553 */
554int Display::registerSSM(PUVM pUVM)
555{
556 /* Version 2 adds width and height of the framebuffer; version 3 adds
557 * the framebuffer offset in the virtual desktop and the framebuffer flags.
558 */
559 int rc = SSMR3RegisterExternal(pUVM, "DisplayData", 0, sSSMDisplayVer3,
560 mcMonitors * sizeof(uint32_t) * 8 + sizeof(uint32_t),
561 NULL, NULL, NULL,
562 NULL, displaySSMSave, NULL,
563 NULL, displaySSMLoad, NULL, this);
564 AssertRCReturn(rc, rc);
565
566 /*
567 * Register loaders for old saved states where iInstance was
568 * 3 * sizeof(uint32_t *) due to a code mistake.
569 */
570 rc = SSMR3RegisterExternal(pUVM, "DisplayData", 12 /*uInstance*/, sSSMDisplayVer, 0 /*cbGuess*/,
571 NULL, NULL, NULL,
572 NULL, NULL, NULL,
573 NULL, displaySSMLoad, NULL, this);
574 AssertRCReturn(rc, rc);
575
576 rc = SSMR3RegisterExternal(pUVM, "DisplayData", 24 /*uInstance*/, sSSMDisplayVer, 0 /*cbGuess*/,
577 NULL, NULL, NULL,
578 NULL, NULL, NULL,
579 NULL, displaySSMLoad, NULL, this);
580 AssertRCReturn(rc, rc);
581
582 /* uInstance is an arbitrary value greater than 1024. Such a value will ensure a quick seek in saved state file. */
583 rc = SSMR3RegisterExternal(pUVM, "DisplayScreenshot", 1100 /*uInstance*/, sSSMDisplayScreenshotVer, 0 /*cbGuess*/,
584 NULL, NULL, NULL,
585 NULL, displaySSMSaveScreenshot, NULL,
586 NULL, displaySSMLoadScreenshot, NULL, this);
587
588 AssertRCReturn(rc, rc);
589
590 return VINF_SUCCESS;
591}
592
593// IEventListener method
594STDMETHODIMP Display::HandleEvent(IEvent * aEvent)
595{
596 VBoxEventType_T aType = VBoxEventType_Invalid;
597
598 aEvent->COMGETTER(Type)(&aType);
599 switch (aType)
600 {
601 case VBoxEventType_OnStateChanged:
602 {
603 ComPtr<IStateChangedEvent> scev = aEvent;
604 Assert(scev);
605 MachineState_T machineState;
606 scev->COMGETTER(State)(&machineState);
607 if ( machineState == MachineState_Running
608 || machineState == MachineState_Teleporting
609 || machineState == MachineState_LiveSnapshotting
610 )
611 {
612 LogRelFlowFunc(("Machine is running.\n"));
613
614 mfMachineRunning = true;
615 }
616 else
617 mfMachineRunning = false;
618 break;
619 }
620 default:
621 AssertFailed();
622 }
623
624 return S_OK;
625}
626
627// public methods only for internal purposes
628/////////////////////////////////////////////////////////////////////////////
629
630/**
631 * @thread EMT
632 */
633static int callFramebufferResize (IFramebuffer *pFramebuffer, unsigned uScreenId,
634 ULONG pixelFormat, void *pvVRAM,
635 uint32_t bpp, uint32_t cbLine,
636 int w, int h)
637{
638 Assert (pFramebuffer);
639
640 /* Call the framebuffer to try and set required pixelFormat. */
641 BOOL finished = TRUE;
642
643 pFramebuffer->RequestResize (uScreenId, pixelFormat, (BYTE *) pvVRAM,
644 bpp, cbLine, w, h, &finished);
645
646 if (!finished)
647 {
648 LogRelFlowFunc(("External framebuffer wants us to wait!\n"));
649 return VINF_VGA_RESIZE_IN_PROGRESS;
650 }
651
652 return VINF_SUCCESS;
653}
654
655/**
656 * Handles display resize event.
657 * Disables access to VGA device;
658 * calls the framebuffer RequestResize method;
659 * if framebuffer resizes synchronously,
660 * updates the display connector data and enables access to the VGA device.
661 *
662 * @param w New display width
663 * @param h New display height
664 *
665 * @thread EMT
666 */
667int Display::handleDisplayResize (unsigned uScreenId, uint32_t bpp, void *pvVRAM,
668 uint32_t cbLine, int w, int h, uint16_t flags)
669{
670 LogRel(("Display::handleDisplayResize(): uScreenId = %d, pvVRAM=%p "
671 "w=%d h=%d bpp=%d cbLine=0x%X, flags=0x%X\n",
672 uScreenId, pvVRAM, w, h, bpp, cbLine, flags));
673
674 /* If there is no framebuffer, this call is not interesting. */
675 if ( uScreenId >= mcMonitors
676 || maFramebuffers[uScreenId].pFramebuffer.isNull())
677 {
678 return VINF_SUCCESS;
679 }
680
681 mLastAddress = pvVRAM;
682 mLastBytesPerLine = cbLine;
683 mLastBitsPerPixel = bpp,
684 mLastWidth = w;
685 mLastHeight = h;
686 mLastFlags = flags;
687
688 ULONG pixelFormat;
689
690 switch (bpp)
691 {
692 case 32:
693 case 24:
694 case 16:
695 pixelFormat = FramebufferPixelFormat_FOURCC_RGB;
696 break;
697 default:
698 pixelFormat = FramebufferPixelFormat_Opaque;
699 bpp = cbLine = 0;
700 break;
701 }
702
703 /* Atomically set the resize status before calling the framebuffer. The new InProgress status will
704 * disable access to the VGA device by the EMT thread.
705 */
706 bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
707 ResizeStatus_InProgress, ResizeStatus_Void);
708 if (!f)
709 {
710 /* This could be a result of the screenshot taking call Display::TakeScreenShot:
711 * if the framebuffer is processing the resize request and GUI calls the TakeScreenShot
712 * and the guest has reprogrammed the virtual VGA devices again so a new resize is required.
713 *
714 * Save the resize information and return the pending status code.
715 *
716 * Note: the resize information is only accessed on EMT so no serialization is required.
717 */
718 LogRel(("Display::handleDisplayResize(): Warning: resize postponed.\n"));
719
720 maFramebuffers[uScreenId].pendingResize.fPending = true;
721 maFramebuffers[uScreenId].pendingResize.pixelFormat = pixelFormat;
722 maFramebuffers[uScreenId].pendingResize.pvVRAM = pvVRAM;
723 maFramebuffers[uScreenId].pendingResize.bpp = bpp;
724 maFramebuffers[uScreenId].pendingResize.cbLine = cbLine;
725 maFramebuffers[uScreenId].pendingResize.w = w;
726 maFramebuffers[uScreenId].pendingResize.h = h;
727 maFramebuffers[uScreenId].pendingResize.flags = flags;
728
729 return VINF_VGA_RESIZE_IN_PROGRESS;
730 }
731
732 int rc = callFramebufferResize (maFramebuffers[uScreenId].pFramebuffer, uScreenId,
733 pixelFormat, pvVRAM, bpp, cbLine, w, h);
734 if (rc == VINF_VGA_RESIZE_IN_PROGRESS)
735 {
736 /* Immediately return to the caller. ResizeCompleted will be called back by the
737 * GUI thread. The ResizeCompleted callback will change the resize status from
738 * InProgress to UpdateDisplayData. The latter status will be checked by the
739 * display timer callback on EMT and all required adjustments will be done there.
740 */
741 return rc;
742 }
743
744 /* Set the status so the 'handleResizeCompleted' would work. */
745 f = ASMAtomicCmpXchgU32 (&maFramebuffers[uScreenId].u32ResizeStatus,
746 ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
747 AssertRelease(f);NOREF(f);
748
749 AssertRelease(!maFramebuffers[uScreenId].pendingResize.fPending);
750
751 /* The method also unlocks the framebuffer. */
752 handleResizeCompletedEMT();
753
754 return VINF_SUCCESS;
755}
756
757/**
758 * Framebuffer has been resized.
759 * Read the new display data and unlock the framebuffer.
760 *
761 * @thread EMT
762 */
763void Display::handleResizeCompletedEMT (void)
764{
765 LogRelFlowFunc(("\n"));
766
767 unsigned uScreenId;
768 for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
769 {
770 DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
771
772 /* Try to into non resizing state. */
773 bool f = ASMAtomicCmpXchgU32 (&pFBInfo->u32ResizeStatus, ResizeStatus_Void, ResizeStatus_UpdateDisplayData);
774
775 if (f == false)
776 {
777 /* This is not the display that has completed resizing. */
778 continue;
779 }
780
781 /* Check whether a resize is pending for this framebuffer. */
782 if (pFBInfo->pendingResize.fPending)
783 {
784 /* Reset the condition, call the display resize with saved data and continue.
785 *
786 * Note: handleDisplayResize can call handleResizeCompletedEMT back,
787 * but infinite recursion is not possible, because when the handleResizeCompletedEMT
788 * is called, the pFBInfo->pendingResize.fPending is equal to false.
789 */
790 pFBInfo->pendingResize.fPending = false;
791 handleDisplayResize (uScreenId, pFBInfo->pendingResize.bpp, pFBInfo->pendingResize.pvVRAM,
792 pFBInfo->pendingResize.cbLine, pFBInfo->pendingResize.w, pFBInfo->pendingResize.h, pFBInfo->pendingResize.flags);
793 continue;
794 }
795
796 /* @todo Merge these two 'if's within one 'if (!pFBInfo->pFramebuffer.isNull())' */
797 if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && !pFBInfo->pFramebuffer.isNull())
798 {
799 /* Primary framebuffer has completed the resize. Update the connector data for VGA device. */
800 updateDisplayData();
801
802 /* Check the framebuffer pixel format to setup the rendering in VGA device. */
803 BOOL usesGuestVRAM = FALSE;
804 pFBInfo->pFramebuffer->COMGETTER(UsesGuestVRAM) (&usesGuestVRAM);
805
806 pFBInfo->fDefaultFormat = (usesGuestVRAM == FALSE);
807
808 /* If the primary framebuffer is disabled, tell the VGA device to not to copy
809 * pixels from VRAM to the framebuffer.
810 */
811 if (pFBInfo->fDisabled)
812 mpDrv->pUpPort->pfnSetRenderVRAM (mpDrv->pUpPort, false);
813 else
814 mpDrv->pUpPort->pfnSetRenderVRAM (mpDrv->pUpPort,
815 pFBInfo->fDefaultFormat);
816
817 /* If the screen resize was because of disabling, tell framebuffer to repaint.
818 * The framebuffer if now in default format so it will not use guest VRAM
819 * and will show usually black image which is there after framebuffer resize.
820 */
821 if (pFBInfo->fDisabled)
822 pFBInfo->pFramebuffer->NotifyUpdate(0, 0, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
823 }
824 else if (!pFBInfo->pFramebuffer.isNull())
825 {
826 BOOL usesGuestVRAM = FALSE;
827 pFBInfo->pFramebuffer->COMGETTER(UsesGuestVRAM) (&usesGuestVRAM);
828
829 pFBInfo->fDefaultFormat = (usesGuestVRAM == FALSE);
830
831 /* If the screen resize was because of disabling, tell framebuffer to repaint.
832 * The framebuffer if now in default format so it will not use guest VRAM
833 * and will show usually black image which is there after framebuffer resize.
834 */
835 if (pFBInfo->fDisabled)
836 pFBInfo->pFramebuffer->NotifyUpdate(0, 0, pFBInfo->w, pFBInfo->h);
837 }
838 LogRelFlow(("[%d]: default format %d\n", uScreenId, pFBInfo->fDefaultFormat));
839
840 /* Handle the case if there are some saved visible region that needs to be
841 * applied after the resize of the framebuffer is completed
842 */
843 SaveSeamlessRectLock();
844 PRTRECT pSavedVisibleRegion = pFBInfo->mpSavedVisibleRegion;
845 uint32_t cSavedVisibleRegion = pFBInfo->mcSavedVisibleRegion;
846 pFBInfo->mpSavedVisibleRegion = NULL;
847 pFBInfo->mcSavedVisibleRegion = 0;
848 SaveSeamlessRectUnLock();
849
850 if (pSavedVisibleRegion)
851 {
852 handleSetVisibleRegion(cSavedVisibleRegion, pSavedVisibleRegion);
853 RTMemFree(pSavedVisibleRegion);
854 }
855
856#ifdef DEBUG_sunlover
857 if (!g_stam)
858 {
859 Console::SafeVMPtr ptrVM(mParent);
860 AssertComRC(ptrVM.rc());
861 STAMR3RegisterU(ptrVM.rawUVM(), &g_StatDisplayRefresh, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
862 "/PROF/Display/Refresh", STAMUNIT_TICKS_PER_CALL, "Time spent in EMT for display updates.");
863 g_stam = 1;
864 }
865#endif /* DEBUG_sunlover */
866
867 /* Inform VRDP server about the change of display parameters. */
868 LogRelFlowFunc(("Calling VRDP\n"));
869 mParent->consoleVRDPServer()->SendResize();
870
871#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
872 {
873 BOOL is3denabled;
874 mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
875
876 if (is3denabled)
877 {
878 VBOXHGCMSVCPARM parm;
879
880 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
881 parm.u.uint32 = uScreenId;
882
883 VMMDev *pVMMDev = mParent->getVMMDev();
884 if (pVMMDev)
885 pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
886 }
887 }
888#endif /* VBOX_WITH_CROGL */
889 }
890}
891
892static void checkCoordBounds (int *px, int *py, int *pw, int *ph, int cx, int cy)
893{
894 /* Correct negative x and y coordinates. */
895 if (*px < 0)
896 {
897 *px += *pw; /* Compute xRight which is also the new width. */
898
899 *pw = (*px < 0)? 0: *px;
900
901 *px = 0;
902 }
903
904 if (*py < 0)
905 {
906 *py += *ph; /* Compute xBottom, which is also the new height. */
907
908 *ph = (*py < 0)? 0: *py;
909
910 *py = 0;
911 }
912
913 /* Also check if coords are greater than the display resolution. */
914 if (*px + *pw > cx)
915 {
916 *pw = cx > *px? cx - *px: 0;
917 }
918
919 if (*py + *ph > cy)
920 {
921 *ph = cy > *py? cy - *py: 0;
922 }
923}
924
925unsigned mapCoordsToScreen(DISPLAYFBINFO *pInfos, unsigned cInfos, int *px, int *py, int *pw, int *ph)
926{
927 DISPLAYFBINFO *pInfo = pInfos;
928 unsigned uScreenId;
929 LogSunlover(("mapCoordsToScreen: %d,%d %dx%d\n", *px, *py, *pw, *ph));
930 for (uScreenId = 0; uScreenId < cInfos; uScreenId++, pInfo++)
931 {
932 LogSunlover((" [%d] %d,%d %dx%d\n", uScreenId, pInfo->xOrigin, pInfo->yOrigin, pInfo->w, pInfo->h));
933 if ( (pInfo->xOrigin <= *px && *px < pInfo->xOrigin + (int)pInfo->w)
934 && (pInfo->yOrigin <= *py && *py < pInfo->yOrigin + (int)pInfo->h))
935 {
936 /* The rectangle belongs to the screen. Correct coordinates. */
937 *px -= pInfo->xOrigin;
938 *py -= pInfo->yOrigin;
939 LogSunlover((" -> %d,%d", *px, *py));
940 break;
941 }
942 }
943 if (uScreenId == cInfos)
944 {
945 /* Map to primary screen. */
946 uScreenId = 0;
947 }
948 LogSunlover((" scr %d\n", uScreenId));
949 return uScreenId;
950}
951
952
953/**
954 * Handles display update event.
955 *
956 * @param x Update area x coordinate
957 * @param y Update area y coordinate
958 * @param w Update area width
959 * @param h Update area height
960 *
961 * @thread EMT
962 */
963void Display::handleDisplayUpdateLegacy (int x, int y, int w, int h)
964{
965 unsigned uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
966
967#ifdef DEBUG_sunlover
968 LogFlowFunc(("%d,%d %dx%d (checked)\n", x, y, w, h));
969#endif /* DEBUG_sunlover */
970
971 handleDisplayUpdate (uScreenId, x, y, w, h);
972}
973
974void Display::handleDisplayUpdate (unsigned uScreenId, int x, int y, int w, int h)
975{
976 /*
977 * Always runs under either VBVA lock or, for HGSMI, DevVGA lock.
978 * Safe to use VBVA vars and take the framebuffer lock.
979 */
980
981#ifdef DEBUG_sunlover
982 LogFlowFunc(("[%d] %d,%d %dx%d (%d,%d)\n",
983 uScreenId, x, y, w, h, mpDrv->IConnector.cx, mpDrv->IConnector.cy));
984#endif /* DEBUG_sunlover */
985
986 IFramebuffer *pFramebuffer = maFramebuffers[uScreenId].pFramebuffer;
987
988 // if there is no framebuffer, this call is not interesting
989 if ( pFramebuffer == NULL
990 || maFramebuffers[uScreenId].fDisabled)
991 return;
992
993 pFramebuffer->Lock();
994
995 if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
996 checkCoordBounds (&x, &y, &w, &h, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
997 else
998 checkCoordBounds (&x, &y, &w, &h, maFramebuffers[uScreenId].w,
999 maFramebuffers[uScreenId].h);
1000
1001 if (w != 0 && h != 0)
1002 pFramebuffer->NotifyUpdate(x, y, w, h);
1003
1004 pFramebuffer->Unlock();
1005
1006#ifndef VBOX_WITH_HGSMI
1007 if (!mfVideoAccelEnabled)
1008 {
1009#else
1010 if (!mfVideoAccelEnabled && !maFramebuffers[uScreenId].fVBVAEnabled)
1011 {
1012#endif /* VBOX_WITH_HGSMI */
1013 /* When VBVA is enabled, the VRDP server is informed in the VideoAccelFlush.
1014 * Inform the server here only if VBVA is disabled.
1015 */
1016 if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
1017 mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
1018 }
1019}
1020
1021/**
1022 * Returns the upper left and lower right corners of the virtual framebuffer.
1023 * The lower right is "exclusive" (i.e. first pixel beyond the framebuffer),
1024 * and the origin is (0, 0), not (1, 1) like the GUI returns.
1025 */
1026void Display::getFramebufferDimensions(int32_t *px1, int32_t *py1,
1027 int32_t *px2, int32_t *py2)
1028{
1029 int32_t x1 = 0, y1 = 0, x2 = 0, y2 = 0;
1030 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1031
1032 AssertPtrReturnVoid(px1);
1033 AssertPtrReturnVoid(py1);
1034 AssertPtrReturnVoid(px2);
1035 AssertPtrReturnVoid(py2);
1036 LogRelFlowFunc(("\n"));
1037
1038 if (!mpDrv)
1039 return;
1040 /* If VBVA is not in use then this flag will not be set and this
1041 * will still work as it should. */
1042 if (!maFramebuffers[0].fDisabled)
1043 {
1044 x1 = (int32_t)maFramebuffers[0].xOrigin;
1045 y1 = (int32_t)maFramebuffers[0].yOrigin;
1046 x2 = mpDrv->IConnector.cx + (int32_t)maFramebuffers[0].xOrigin;
1047 y2 = mpDrv->IConnector.cy + (int32_t)maFramebuffers[0].yOrigin;
1048 }
1049 for (unsigned i = 1; i < mcMonitors; ++i)
1050 {
1051 if (!maFramebuffers[i].fDisabled)
1052 {
1053 x1 = RT_MIN(x1, maFramebuffers[i].xOrigin);
1054 y1 = RT_MIN(y1, maFramebuffers[i].yOrigin);
1055 x2 = RT_MAX(x2, maFramebuffers[i].xOrigin
1056 + (int32_t)maFramebuffers[i].w);
1057 y2 = RT_MAX(y2, maFramebuffers[i].yOrigin
1058 + (int32_t)maFramebuffers[i].h);
1059 }
1060 }
1061 *px1 = x1;
1062 *py1 = y1;
1063 *px2 = x2;
1064 *py2 = y2;
1065}
1066
1067static bool displayIntersectRect(RTRECT *prectResult,
1068 const RTRECT *prect1,
1069 const RTRECT *prect2)
1070{
1071 /* Initialize result to an empty record. */
1072 memset (prectResult, 0, sizeof (RTRECT));
1073
1074 int xLeftResult = RT_MAX(prect1->xLeft, prect2->xLeft);
1075 int xRightResult = RT_MIN(prect1->xRight, prect2->xRight);
1076
1077 if (xLeftResult < xRightResult)
1078 {
1079 /* There is intersection by X. */
1080
1081 int yTopResult = RT_MAX(prect1->yTop, prect2->yTop);
1082 int yBottomResult = RT_MIN(prect1->yBottom, prect2->yBottom);
1083
1084 if (yTopResult < yBottomResult)
1085 {
1086 /* There is intersection by Y. */
1087
1088 prectResult->xLeft = xLeftResult;
1089 prectResult->yTop = yTopResult;
1090 prectResult->xRight = xRightResult;
1091 prectResult->yBottom = yBottomResult;
1092
1093 return true;
1094 }
1095 }
1096
1097 return false;
1098}
1099
1100int Display::handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
1101{
1102 RTRECT *pVisibleRegion = (RTRECT *)RTMemTmpAlloc( RT_MAX(cRect, 1)
1103 * sizeof (RTRECT));
1104 if (!pVisibleRegion)
1105 {
1106 return VERR_NO_TMP_MEMORY;
1107 }
1108
1109 unsigned uScreenId;
1110 for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
1111 {
1112 DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1113
1114 if (!pFBInfo->pFramebuffer.isNull())
1115 {
1116 if (pFBInfo->u32ResizeStatus != ResizeStatus_Void)
1117 {
1118 /* handle the case where new rectangles are received from the GA
1119 * when framebuffer resizing is in progress.
1120 * Just save the rectangles to be applied for later time when FB resizing is complete
1121 * (from handleResizeCompletedEMT).
1122 * This is done to prevent a race condition where a new rectangles are received
1123 * from the GA after a resize event and framebuffer resizing is still in progress
1124 * As a result the coordinates of the framebuffer are still
1125 * not updated and hence there is no intersection with the new rectangles passed
1126 * for the new region (THis is checked in the above if condition ). With 0 intersection,
1127 * cRectVisibleRegions = 0 is returned to the GUI and if GUI has invalidated its
1128 * earlier region then it draws nothihing and seamless mode doesn't display the
1129 * guest desktop.
1130 */
1131 SaveSeamlessRectLock();
1132 RTMemFree(pFBInfo->mpSavedVisibleRegion);
1133
1134 pFBInfo->mpSavedVisibleRegion = (RTRECT *)RTMemAlloc( RT_MAX(cRect, 1)
1135 * sizeof (RTRECT));
1136 if (pFBInfo->mpSavedVisibleRegion)
1137 {
1138 memcpy(pFBInfo->mpSavedVisibleRegion, pRect, cRect * sizeof(RTRECT));
1139 pFBInfo->mcSavedVisibleRegion = cRect;
1140 }
1141 else
1142 {
1143 pFBInfo->mcSavedVisibleRegion = 0;
1144 }
1145 SaveSeamlessRectUnLock();
1146 continue;
1147 }
1148 /* Prepare a new array of rectangles which intersect with the framebuffer.
1149 */
1150 RTRECT rectFramebuffer;
1151 if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
1152 {
1153 rectFramebuffer.xLeft = 0;
1154 rectFramebuffer.yTop = 0;
1155 if (mpDrv)
1156 {
1157 rectFramebuffer.xRight = mpDrv->IConnector.cx;
1158 rectFramebuffer.yBottom = mpDrv->IConnector.cy;
1159 }
1160 else
1161 {
1162 rectFramebuffer.xRight = 0;
1163 rectFramebuffer.yBottom = 0;
1164 }
1165 }
1166 else
1167 {
1168 rectFramebuffer.xLeft = pFBInfo->xOrigin;
1169 rectFramebuffer.yTop = pFBInfo->yOrigin;
1170 rectFramebuffer.xRight = pFBInfo->xOrigin + pFBInfo->w;
1171 rectFramebuffer.yBottom = pFBInfo->yOrigin + pFBInfo->h;
1172 }
1173
1174 uint32_t cRectVisibleRegion = 0;
1175
1176 uint32_t i;
1177 for (i = 0; i < cRect; i++)
1178 {
1179 if (displayIntersectRect(&pVisibleRegion[cRectVisibleRegion], &pRect[i], &rectFramebuffer))
1180 {
1181 pVisibleRegion[cRectVisibleRegion].xLeft -= pFBInfo->xOrigin;
1182 pVisibleRegion[cRectVisibleRegion].yTop -= pFBInfo->yOrigin;
1183 pVisibleRegion[cRectVisibleRegion].xRight -= pFBInfo->xOrigin;
1184 pVisibleRegion[cRectVisibleRegion].yBottom -= pFBInfo->yOrigin;
1185
1186 cRectVisibleRegion++;
1187 }
1188 }
1189 pFBInfo->pFramebuffer->SetVisibleRegion((BYTE *)pVisibleRegion, cRectVisibleRegion);
1190 }
1191 }
1192
1193#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
1194 BOOL is3denabled = FALSE;
1195
1196 mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
1197
1198 VMMDev *vmmDev = mParent->getVMMDev();
1199 if (is3denabled && vmmDev)
1200 {
1201 VBOXHGCMSVCPARM parms[2];
1202
1203 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
1204 parms[0].u.pointer.addr = pRect;
1205 parms[0].u.pointer.size = 0; /* We don't actually care. */
1206 parms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
1207 parms[1].u.uint32 = cRect;
1208
1209 vmmDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_VISIBLE_REGION, 2, &parms[0]);
1210 }
1211#endif
1212
1213 RTMemTmpFree(pVisibleRegion);
1214
1215 return VINF_SUCCESS;
1216}
1217
1218int Display::handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect)
1219{
1220 // @todo Currently not used by the guest and is not implemented in framebuffers. Remove?
1221 return VERR_NOT_SUPPORTED;
1222}
1223
1224typedef struct _VBVADIRTYREGION
1225{
1226 /* Copies of object's pointers used by vbvaRgn functions. */
1227 DISPLAYFBINFO *paFramebuffers;
1228 unsigned cMonitors;
1229 Display *pDisplay;
1230 PPDMIDISPLAYPORT pPort;
1231
1232} VBVADIRTYREGION;
1233
1234static void vbvaRgnInit (VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors, Display *pd, PPDMIDISPLAYPORT pp)
1235{
1236 prgn->paFramebuffers = paFramebuffers;
1237 prgn->cMonitors = cMonitors;
1238 prgn->pDisplay = pd;
1239 prgn->pPort = pp;
1240
1241 unsigned uScreenId;
1242 for (uScreenId = 0; uScreenId < cMonitors; uScreenId++)
1243 {
1244 DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1245
1246 RT_ZERO(pFBInfo->dirtyRect);
1247 }
1248}
1249
1250static void vbvaRgnDirtyRect (VBVADIRTYREGION *prgn, unsigned uScreenId, VBVACMDHDR *phdr)
1251{
1252 LogSunlover(("x = %d, y = %d, w = %d, h = %d\n",
1253 phdr->x, phdr->y, phdr->w, phdr->h));
1254
1255 /*
1256 * Here update rectangles are accumulated to form an update area.
1257 * @todo
1258 * Now the simplest method is used which builds one rectangle that
1259 * includes all update areas. A bit more advanced method can be
1260 * employed here. The method should be fast however.
1261 */
1262 if (phdr->w == 0 || phdr->h == 0)
1263 {
1264 /* Empty rectangle. */
1265 return;
1266 }
1267
1268 int32_t xRight = phdr->x + phdr->w;
1269 int32_t yBottom = phdr->y + phdr->h;
1270
1271 DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1272
1273 if (pFBInfo->dirtyRect.xRight == 0)
1274 {
1275 /* This is the first rectangle to be added. */
1276 pFBInfo->dirtyRect.xLeft = phdr->x;
1277 pFBInfo->dirtyRect.yTop = phdr->y;
1278 pFBInfo->dirtyRect.xRight = xRight;
1279 pFBInfo->dirtyRect.yBottom = yBottom;
1280 }
1281 else
1282 {
1283 /* Adjust region coordinates. */
1284 if (pFBInfo->dirtyRect.xLeft > phdr->x)
1285 {
1286 pFBInfo->dirtyRect.xLeft = phdr->x;
1287 }
1288
1289 if (pFBInfo->dirtyRect.yTop > phdr->y)
1290 {
1291 pFBInfo->dirtyRect.yTop = phdr->y;
1292 }
1293
1294 if (pFBInfo->dirtyRect.xRight < xRight)
1295 {
1296 pFBInfo->dirtyRect.xRight = xRight;
1297 }
1298
1299 if (pFBInfo->dirtyRect.yBottom < yBottom)
1300 {
1301 pFBInfo->dirtyRect.yBottom = yBottom;
1302 }
1303 }
1304
1305 if (pFBInfo->fDefaultFormat)
1306 {
1307 //@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
1308 prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
1309 prgn->pDisplay->handleDisplayUpdateLegacy (phdr->x + pFBInfo->xOrigin,
1310 phdr->y + pFBInfo->yOrigin, phdr->w, phdr->h);
1311 }
1312
1313 return;
1314}
1315
1316static void vbvaRgnUpdateFramebuffer (VBVADIRTYREGION *prgn, unsigned uScreenId)
1317{
1318 DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
1319
1320 uint32_t w = pFBInfo->dirtyRect.xRight - pFBInfo->dirtyRect.xLeft;
1321 uint32_t h = pFBInfo->dirtyRect.yBottom - pFBInfo->dirtyRect.yTop;
1322
1323 if (!pFBInfo->fDefaultFormat && pFBInfo->pFramebuffer && w != 0 && h != 0)
1324 {
1325 //@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
1326 prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
1327 prgn->pDisplay->handleDisplayUpdateLegacy (pFBInfo->dirtyRect.xLeft + pFBInfo->xOrigin,
1328 pFBInfo->dirtyRect.yTop + pFBInfo->yOrigin, w, h);
1329 }
1330}
1331
1332static void vbvaSetMemoryFlags (VBVAMEMORY *pVbvaMemory,
1333 bool fVideoAccelEnabled,
1334 bool fVideoAccelVRDP,
1335 uint32_t fu32SupportedOrders,
1336 DISPLAYFBINFO *paFBInfos,
1337 unsigned cFBInfos)
1338{
1339 if (pVbvaMemory)
1340 {
1341 /* This called only on changes in mode. So reset VRDP always. */
1342 uint32_t fu32Flags = VBVA_F_MODE_VRDP_RESET;
1343
1344 if (fVideoAccelEnabled)
1345 {
1346 fu32Flags |= VBVA_F_MODE_ENABLED;
1347
1348 if (fVideoAccelVRDP)
1349 {
1350 fu32Flags |= VBVA_F_MODE_VRDP | VBVA_F_MODE_VRDP_ORDER_MASK;
1351
1352 pVbvaMemory->fu32SupportedOrders = fu32SupportedOrders;
1353 }
1354 }
1355
1356 pVbvaMemory->fu32ModeFlags = fu32Flags;
1357 }
1358
1359 unsigned uScreenId;
1360 for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1361 {
1362 if (paFBInfos[uScreenId].pHostEvents)
1363 {
1364 paFBInfos[uScreenId].pHostEvents->fu32Events |= VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1365 }
1366 }
1367}
1368
1369#ifdef VBOX_WITH_HGSMI
1370static void vbvaSetMemoryFlagsHGSMI (unsigned uScreenId,
1371 uint32_t fu32SupportedOrders,
1372 bool fVideoAccelVRDP,
1373 DISPLAYFBINFO *pFBInfo)
1374{
1375 LogRelFlowFunc(("HGSMI[%d]: %p\n", uScreenId, pFBInfo->pVBVAHostFlags));
1376
1377 if (pFBInfo->pVBVAHostFlags)
1378 {
1379 uint32_t fu32HostEvents = VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
1380
1381 if (pFBInfo->fVBVAEnabled)
1382 {
1383 fu32HostEvents |= VBVA_F_MODE_ENABLED;
1384
1385 if (fVideoAccelVRDP)
1386 {
1387 fu32HostEvents |= VBVA_F_MODE_VRDP;
1388 }
1389 }
1390
1391 ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32HostEvents, fu32HostEvents);
1392 ASMAtomicWriteU32(&pFBInfo->pVBVAHostFlags->u32SupportedOrders, fu32SupportedOrders);
1393
1394 LogRelFlowFunc((" fu32HostEvents = 0x%08X, fu32SupportedOrders = 0x%08X\n", fu32HostEvents, fu32SupportedOrders));
1395 }
1396}
1397
1398static void vbvaSetMemoryFlagsAllHGSMI (uint32_t fu32SupportedOrders,
1399 bool fVideoAccelVRDP,
1400 DISPLAYFBINFO *paFBInfos,
1401 unsigned cFBInfos)
1402{
1403 unsigned uScreenId;
1404
1405 for (uScreenId = 0; uScreenId < cFBInfos; uScreenId++)
1406 {
1407 vbvaSetMemoryFlagsHGSMI(uScreenId, fu32SupportedOrders, fVideoAccelVRDP, &paFBInfos[uScreenId]);
1408 }
1409}
1410#endif /* VBOX_WITH_HGSMI */
1411
1412bool Display::VideoAccelAllowed (void)
1413{
1414 return true;
1415}
1416
1417int Display::vbvaLock(void)
1418{
1419 return RTCritSectEnter(&mVBVALock);
1420}
1421
1422void Display::vbvaUnlock(void)
1423{
1424 RTCritSectLeave(&mVBVALock);
1425}
1426
1427int Display::SaveSeamlessRectLock(void)
1428{
1429 return RTCritSectEnter(&mSaveSeamlessRectLock);
1430}
1431
1432void Display::SaveSeamlessRectUnLock(void)
1433{
1434 RTCritSectLeave(&mSaveSeamlessRectLock);
1435}
1436
1437
1438/**
1439 * @thread EMT
1440 */
1441int Display::VideoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
1442{
1443 int rc;
1444 vbvaLock();
1445 rc = videoAccelEnable (fEnable, pVbvaMemory);
1446 vbvaUnlock();
1447 return rc;
1448}
1449
1450int Display::videoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
1451{
1452 int rc = VINF_SUCCESS;
1453
1454 /* Called each time the guest wants to use acceleration,
1455 * or when the VGA device disables acceleration,
1456 * or when restoring the saved state with accel enabled.
1457 *
1458 * VGA device disables acceleration on each video mode change
1459 * and on reset.
1460 *
1461 * Guest enabled acceleration at will. And it has to enable
1462 * acceleration after a mode change.
1463 */
1464 LogRelFlowFunc(("mfVideoAccelEnabled = %d, fEnable = %d, pVbvaMemory = %p\n",
1465 mfVideoAccelEnabled, fEnable, pVbvaMemory));
1466
1467 /* Strictly check parameters. Callers must not pass anything in the case. */
1468 Assert((fEnable && pVbvaMemory) || (!fEnable && pVbvaMemory == NULL));
1469
1470 if (!VideoAccelAllowed ())
1471 return VERR_NOT_SUPPORTED;
1472
1473 /*
1474 * Verify that the VM is in running state. If it is not,
1475 * then this must be postponed until it goes to running.
1476 */
1477 if (!mfMachineRunning)
1478 {
1479 Assert (!mfVideoAccelEnabled);
1480
1481 LogRelFlowFunc(("Machine is not yet running.\n"));
1482
1483 if (fEnable)
1484 {
1485 mfPendingVideoAccelEnable = fEnable;
1486 mpPendingVbvaMemory = pVbvaMemory;
1487 }
1488
1489 return rc;
1490 }
1491
1492 /* Check that current status is not being changed */
1493 if (mfVideoAccelEnabled == fEnable)
1494 return rc;
1495
1496 if (mfVideoAccelEnabled)
1497 {
1498 /* Process any pending orders and empty the VBVA ring buffer. */
1499 videoAccelFlush ();
1500 }
1501
1502 if (!fEnable && mpVbvaMemory)
1503 mpVbvaMemory->fu32ModeFlags &= ~VBVA_F_MODE_ENABLED;
1504
1505 /* Safety precaution. There is no more VBVA until everything is setup! */
1506 mpVbvaMemory = NULL;
1507 mfVideoAccelEnabled = false;
1508
1509 /* Update entire display. */
1510 if (maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].u32ResizeStatus == ResizeStatus_Void)
1511 mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort);
1512
1513 /* Everything OK. VBVA status can be changed. */
1514
1515 /* Notify the VMMDev, which saves VBVA status in the saved state,
1516 * and needs to know current status.
1517 */
1518 VMMDev *pVMMDev = mParent->getVMMDev();
1519 if (pVMMDev)
1520 {
1521 PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
1522 if (pVMMDevPort)
1523 pVMMDevPort->pfnVBVAChange(pVMMDevPort, fEnable);
1524 }
1525
1526 if (fEnable)
1527 {
1528 mpVbvaMemory = pVbvaMemory;
1529 mfVideoAccelEnabled = true;
1530
1531 /* Initialize the hardware memory. */
1532 vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1533 mpVbvaMemory->off32Data = 0;
1534 mpVbvaMemory->off32Free = 0;
1535
1536 memset(mpVbvaMemory->aRecords, 0, sizeof (mpVbvaMemory->aRecords));
1537 mpVbvaMemory->indexRecordFirst = 0;
1538 mpVbvaMemory->indexRecordFree = 0;
1539
1540 mfu32PendingVideoAccelDisable = false;
1541
1542 LogRel(("VBVA: Enabled.\n"));
1543 }
1544 else
1545 {
1546 LogRel(("VBVA: Disabled.\n"));
1547 }
1548
1549 LogRelFlowFunc(("VideoAccelEnable: rc = %Rrc.\n", rc));
1550
1551 return rc;
1552}
1553
1554/* Called always by one VRDP server thread. Can be thread-unsafe.
1555 */
1556void Display::VideoAccelVRDP (bool fEnable)
1557{
1558 LogRelFlowFunc(("fEnable = %d\n", fEnable));
1559
1560 vbvaLock();
1561
1562 int c = fEnable?
1563 ASMAtomicIncS32 (&mcVideoAccelVRDPRefs):
1564 ASMAtomicDecS32 (&mcVideoAccelVRDPRefs);
1565
1566 Assert (c >= 0);
1567
1568 if (c == 0)
1569 {
1570 /* The last client has disconnected, and the accel can be
1571 * disabled.
1572 */
1573 Assert (fEnable == false);
1574
1575 mfVideoAccelVRDP = false;
1576 mfu32SupportedOrders = 0;
1577
1578 vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1579#ifdef VBOX_WITH_HGSMI
1580 /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1581 ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1582#endif /* VBOX_WITH_HGSMI */
1583
1584 LogRel(("VBVA: VRDP acceleration has been disabled.\n"));
1585 }
1586 else if ( c == 1
1587 && !mfVideoAccelVRDP)
1588 {
1589 /* The first client has connected. Enable the accel.
1590 */
1591 Assert (fEnable == true);
1592
1593 mfVideoAccelVRDP = true;
1594 /* Supporting all orders. */
1595 mfu32SupportedOrders = ~0;
1596
1597 vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
1598#ifdef VBOX_WITH_HGSMI
1599 /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
1600 ASMAtomicIncU32(&mu32UpdateVBVAFlags);
1601#endif /* VBOX_WITH_HGSMI */
1602
1603 LogRel(("VBVA: VRDP acceleration has been requested.\n"));
1604 }
1605 else
1606 {
1607 /* A client is connected or disconnected but there is no change in the
1608 * accel state. It remains enabled.
1609 */
1610 Assert (mfVideoAccelVRDP == true);
1611 }
1612 vbvaUnlock();
1613}
1614
1615static bool vbvaVerifyRingBuffer (VBVAMEMORY *pVbvaMemory)
1616{
1617 return true;
1618}
1619
1620static void vbvaFetchBytes (VBVAMEMORY *pVbvaMemory, uint8_t *pu8Dst, uint32_t cbDst)
1621{
1622 if (cbDst >= VBVA_RING_BUFFER_SIZE)
1623 {
1624 AssertMsgFailed (("cbDst = 0x%08X, ring buffer size 0x%08X", cbDst, VBVA_RING_BUFFER_SIZE));
1625 return;
1626 }
1627
1628 uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - pVbvaMemory->off32Data;
1629 uint8_t *src = &pVbvaMemory->au8RingBuffer[pVbvaMemory->off32Data];
1630 int32_t i32Diff = cbDst - u32BytesTillBoundary;
1631
1632 if (i32Diff <= 0)
1633 {
1634 /* Chunk will not cross buffer boundary. */
1635 memcpy (pu8Dst, src, cbDst);
1636 }
1637 else
1638 {
1639 /* Chunk crosses buffer boundary. */
1640 memcpy (pu8Dst, src, u32BytesTillBoundary);
1641 memcpy (pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
1642 }
1643
1644 /* Advance data offset. */
1645 pVbvaMemory->off32Data = (pVbvaMemory->off32Data + cbDst) % VBVA_RING_BUFFER_SIZE;
1646
1647 return;
1648}
1649
1650
1651static bool vbvaPartialRead (uint8_t **ppu8, uint32_t *pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
1652{
1653 uint8_t *pu8New;
1654
1655 LogFlow(("MAIN::DisplayImpl::vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
1656 *ppu8, *pcb, cbRecord));
1657
1658 if (*ppu8)
1659 {
1660 Assert (*pcb);
1661 pu8New = (uint8_t *)RTMemRealloc (*ppu8, cbRecord);
1662 }
1663 else
1664 {
1665 Assert (!*pcb);
1666 pu8New = (uint8_t *)RTMemAlloc (cbRecord);
1667 }
1668
1669 if (!pu8New)
1670 {
1671 /* Memory allocation failed, fail the function. */
1672 Log(("MAIN::vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
1673 cbRecord));
1674
1675 if (*ppu8)
1676 {
1677 RTMemFree (*ppu8);
1678 }
1679
1680 *ppu8 = NULL;
1681 *pcb = 0;
1682
1683 return false;
1684 }
1685
1686 /* Fetch data from the ring buffer. */
1687 vbvaFetchBytes (pVbvaMemory, pu8New + *pcb, cbRecord - *pcb);
1688
1689 *ppu8 = pu8New;
1690 *pcb = cbRecord;
1691
1692 return true;
1693}
1694
1695/* For contiguous chunks just return the address in the buffer.
1696 * For crossing boundary - allocate a buffer from heap.
1697 */
1698bool Display::vbvaFetchCmd (VBVACMDHDR **ppHdr, uint32_t *pcbCmd)
1699{
1700 uint32_t indexRecordFirst = mpVbvaMemory->indexRecordFirst;
1701 uint32_t indexRecordFree = mpVbvaMemory->indexRecordFree;
1702
1703#ifdef DEBUG_sunlover
1704 LogFlowFunc(("first = %d, free = %d\n",
1705 indexRecordFirst, indexRecordFree));
1706#endif /* DEBUG_sunlover */
1707
1708 if (!vbvaVerifyRingBuffer (mpVbvaMemory))
1709 {
1710 return false;
1711 }
1712
1713 if (indexRecordFirst == indexRecordFree)
1714 {
1715 /* No records to process. Return without assigning output variables. */
1716 return true;
1717 }
1718
1719 VBVARECORD *pRecord = &mpVbvaMemory->aRecords[indexRecordFirst];
1720
1721#ifdef DEBUG_sunlover
1722 LogFlowFunc(("cbRecord = 0x%08X\n", pRecord->cbRecord));
1723#endif /* DEBUG_sunlover */
1724
1725 uint32_t cbRecord = pRecord->cbRecord & ~VBVA_F_RECORD_PARTIAL;
1726
1727 if (mcbVbvaPartial)
1728 {
1729 /* There is a partial read in process. Continue with it. */
1730
1731 Assert (mpu8VbvaPartial);
1732
1733 LogFlowFunc(("continue partial record mcbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
1734 mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1735
1736 if (cbRecord > mcbVbvaPartial)
1737 {
1738 /* New data has been added to the record. */
1739 if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1740 {
1741 return false;
1742 }
1743 }
1744
1745 if (!(pRecord->cbRecord & VBVA_F_RECORD_PARTIAL))
1746 {
1747 /* The record is completed by guest. Return it to the caller. */
1748 *ppHdr = (VBVACMDHDR *)mpu8VbvaPartial;
1749 *pcbCmd = mcbVbvaPartial;
1750
1751 mpu8VbvaPartial = NULL;
1752 mcbVbvaPartial = 0;
1753
1754 /* Advance the record index. */
1755 mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1756
1757#ifdef DEBUG_sunlover
1758 LogFlowFunc(("partial done ok, data = %d, free = %d\n",
1759 mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1760#endif /* DEBUG_sunlover */
1761 }
1762
1763 return true;
1764 }
1765
1766 /* A new record need to be processed. */
1767 if (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL)
1768 {
1769 /* Current record is being written by guest. '=' is important here. */
1770 if (cbRecord >= VBVA_RING_BUFFER_SIZE - VBVA_RING_BUFFER_THRESHOLD)
1771 {
1772 /* Partial read must be started. */
1773 if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
1774 {
1775 return false;
1776 }
1777
1778 LogFlowFunc(("started partial record mcbVbvaPartial = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
1779 mcbVbvaPartial, pRecord->cbRecord, indexRecordFirst, indexRecordFree));
1780 }
1781
1782 return true;
1783 }
1784
1785 /* Current record is complete. If it is not empty, process it. */
1786 if (cbRecord)
1787 {
1788 /* The size of largest contiguous chunk in the ring biffer. */
1789 uint32_t u32BytesTillBoundary = VBVA_RING_BUFFER_SIZE - mpVbvaMemory->off32Data;
1790
1791 /* The ring buffer pointer. */
1792 uint8_t *au8RingBuffer = &mpVbvaMemory->au8RingBuffer[0];
1793
1794 /* The pointer to data in the ring buffer. */
1795 uint8_t *src = &au8RingBuffer[mpVbvaMemory->off32Data];
1796
1797 /* Fetch or point the data. */
1798 if (u32BytesTillBoundary >= cbRecord)
1799 {
1800 /* The command does not cross buffer boundary. Return address in the buffer. */
1801 *ppHdr = (VBVACMDHDR *)src;
1802
1803 /* Advance data offset. */
1804 mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1805 }
1806 else
1807 {
1808 /* The command crosses buffer boundary. Rare case, so not optimized. */
1809 uint8_t *dst = (uint8_t *)RTMemAlloc (cbRecord);
1810
1811 if (!dst)
1812 {
1813 LogRelFlowFunc(("could not allocate %d bytes from heap!!!\n", cbRecord));
1814 mpVbvaMemory->off32Data = (mpVbvaMemory->off32Data + cbRecord) % VBVA_RING_BUFFER_SIZE;
1815 return false;
1816 }
1817
1818 vbvaFetchBytes (mpVbvaMemory, dst, cbRecord);
1819
1820 *ppHdr = (VBVACMDHDR *)dst;
1821
1822#ifdef DEBUG_sunlover
1823 LogFlowFunc(("Allocated from heap %p\n", dst));
1824#endif /* DEBUG_sunlover */
1825 }
1826 }
1827
1828 *pcbCmd = cbRecord;
1829
1830 /* Advance the record index. */
1831 mpVbvaMemory->indexRecordFirst = (indexRecordFirst + 1) % VBVA_MAX_RECORDS;
1832
1833#ifdef DEBUG_sunlover
1834 LogFlowFunc(("done ok, data = %d, free = %d\n",
1835 mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1836#endif /* DEBUG_sunlover */
1837
1838 return true;
1839}
1840
1841void Display::vbvaReleaseCmd (VBVACMDHDR *pHdr, int32_t cbCmd)
1842{
1843 uint8_t *au8RingBuffer = mpVbvaMemory->au8RingBuffer;
1844
1845 if ( (uint8_t *)pHdr >= au8RingBuffer
1846 && (uint8_t *)pHdr < &au8RingBuffer[VBVA_RING_BUFFER_SIZE])
1847 {
1848 /* The pointer is inside ring buffer. Must be continuous chunk. */
1849 Assert (VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
1850
1851 /* Do nothing. */
1852
1853 Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1854 }
1855 else
1856 {
1857 /* The pointer is outside. It is then an allocated copy. */
1858
1859#ifdef DEBUG_sunlover
1860 LogFlowFunc(("Free heap %p\n", pHdr));
1861#endif /* DEBUG_sunlover */
1862
1863 if ((uint8_t *)pHdr == mpu8VbvaPartial)
1864 {
1865 mpu8VbvaPartial = NULL;
1866 mcbVbvaPartial = 0;
1867 }
1868 else
1869 {
1870 Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
1871 }
1872
1873 RTMemFree (pHdr);
1874 }
1875
1876 return;
1877}
1878
1879
1880/**
1881 * Called regularly on the DisplayRefresh timer.
1882 * Also on behalf of guest, when the ring buffer is full.
1883 *
1884 * @thread EMT
1885 */
1886void Display::VideoAccelFlush (void)
1887{
1888 vbvaLock();
1889 videoAccelFlush();
1890 vbvaUnlock();
1891}
1892
1893/* Under VBVA lock. DevVGA is not taken. */
1894void Display::videoAccelFlush (void)
1895{
1896#ifdef DEBUG_sunlover_2
1897 LogFlowFunc(("mfVideoAccelEnabled = %d\n", mfVideoAccelEnabled));
1898#endif /* DEBUG_sunlover_2 */
1899
1900 if (!mfVideoAccelEnabled)
1901 {
1902 Log(("Display::VideoAccelFlush: called with disabled VBVA!!! Ignoring.\n"));
1903 return;
1904 }
1905
1906 /* Here VBVA is enabled and we have the accelerator memory pointer. */
1907 Assert(mpVbvaMemory);
1908
1909#ifdef DEBUG_sunlover_2
1910 LogFlowFunc(("indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
1911 mpVbvaMemory->indexRecordFirst, mpVbvaMemory->indexRecordFree, mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1912#endif /* DEBUG_sunlover_2 */
1913
1914 /* Quick check for "nothing to update" case. */
1915 if (mpVbvaMemory->indexRecordFirst == mpVbvaMemory->indexRecordFree)
1916 {
1917 return;
1918 }
1919
1920 /* Process the ring buffer */
1921 unsigned uScreenId;
1922
1923 /* Initialize dirty rectangles accumulator. */
1924 VBVADIRTYREGION rgn;
1925 vbvaRgnInit (&rgn, maFramebuffers, mcMonitors, this, mpDrv->pUpPort);
1926
1927 for (;;)
1928 {
1929 VBVACMDHDR *phdr = NULL;
1930 uint32_t cbCmd = ~0;
1931
1932 /* Fetch the command data. */
1933 if (!vbvaFetchCmd (&phdr, &cbCmd))
1934 {
1935 Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
1936 mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
1937
1938 /* Disable VBVA on those processing errors. */
1939 videoAccelEnable (false, NULL);
1940
1941 break;
1942 }
1943
1944 if (cbCmd == uint32_t(~0))
1945 {
1946 /* No more commands yet in the queue. */
1947 break;
1948 }
1949
1950 if (cbCmd != 0)
1951 {
1952#ifdef DEBUG_sunlover
1953 LogFlowFunc(("hdr: cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
1954 cbCmd, phdr->x, phdr->y, phdr->w, phdr->h));
1955#endif /* DEBUG_sunlover */
1956
1957 VBVACMDHDR hdrSaved = *phdr;
1958
1959 int x = phdr->x;
1960 int y = phdr->y;
1961 int w = phdr->w;
1962 int h = phdr->h;
1963
1964 uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
1965
1966 phdr->x = (int16_t)x;
1967 phdr->y = (int16_t)y;
1968 phdr->w = (uint16_t)w;
1969 phdr->h = (uint16_t)h;
1970
1971 DISPLAYFBINFO *pFBInfo = &maFramebuffers[uScreenId];
1972
1973 if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
1974 {
1975 /* Handle the command.
1976 *
1977 * Guest is responsible for updating the guest video memory.
1978 * The Windows guest does all drawing using Eng*.
1979 *
1980 * For local output, only dirty rectangle information is used
1981 * to update changed areas.
1982 *
1983 * Dirty rectangles are accumulated to exclude overlapping updates and
1984 * group small updates to a larger one.
1985 */
1986
1987 /* Accumulate the update. */
1988 vbvaRgnDirtyRect (&rgn, uScreenId, phdr);
1989
1990 /* Forward the command to VRDP server. */
1991 mParent->consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
1992
1993 *phdr = hdrSaved;
1994 }
1995 }
1996
1997 vbvaReleaseCmd (phdr, cbCmd);
1998 }
1999
2000 for (uScreenId = 0; uScreenId < mcMonitors; uScreenId++)
2001 {
2002 if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
2003 {
2004 /* Draw the framebuffer. */
2005 vbvaRgnUpdateFramebuffer (&rgn, uScreenId);
2006 }
2007 }
2008}
2009
2010int Display::videoAccelRefreshProcess(void)
2011{
2012 int rc = VWRN_INVALID_STATE; /* Default is to do a display update in VGA device. */
2013
2014 vbvaLock();
2015
2016 if (ASMAtomicCmpXchgU32(&mfu32PendingVideoAccelDisable, false, true))
2017 {
2018 videoAccelEnable (false, NULL);
2019 }
2020 else if (mfPendingVideoAccelEnable)
2021 {
2022 /* Acceleration was enabled while machine was not yet running
2023 * due to restoring from saved state. Update entire display and
2024 * actually enable acceleration.
2025 */
2026 Assert(mpPendingVbvaMemory);
2027
2028 /* Acceleration can not be yet enabled.*/
2029 Assert(mpVbvaMemory == NULL);
2030 Assert(!mfVideoAccelEnabled);
2031
2032 if (mfMachineRunning)
2033 {
2034 videoAccelEnable (mfPendingVideoAccelEnable,
2035 mpPendingVbvaMemory);
2036
2037 /* Reset the pending state. */
2038 mfPendingVideoAccelEnable = false;
2039 mpPendingVbvaMemory = NULL;
2040 }
2041
2042 rc = VINF_TRY_AGAIN;
2043 }
2044 else
2045 {
2046 Assert(mpPendingVbvaMemory == NULL);
2047
2048 if (mfVideoAccelEnabled)
2049 {
2050 Assert(mpVbvaMemory);
2051 videoAccelFlush ();
2052
2053 rc = VINF_SUCCESS; /* VBVA processed, no need to a display update. */
2054 }
2055 }
2056
2057 vbvaUnlock();
2058
2059 return rc;
2060}
2061
2062
2063// IDisplay methods
2064/////////////////////////////////////////////////////////////////////////////
2065STDMETHODIMP Display::GetScreenResolution (ULONG aScreenId,
2066 ULONG *aWidth, ULONG *aHeight, ULONG *aBitsPerPixel,
2067 LONG *aXOrigin, LONG *aYOrigin)
2068{
2069 LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
2070
2071 AutoCaller autoCaller(this);
2072 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2073
2074 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2075
2076 uint32_t u32Width = 0;
2077 uint32_t u32Height = 0;
2078 uint32_t u32BitsPerPixel = 0;
2079 int32_t xOrigin = 0;
2080 int32_t yOrigin = 0;
2081
2082 if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2083 {
2084 CHECK_CONSOLE_DRV(mpDrv);
2085
2086 u32Width = mpDrv->IConnector.cx;
2087 u32Height = mpDrv->IConnector.cy;
2088 int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &u32BitsPerPixel);
2089 AssertRC(rc);
2090 }
2091 else if (aScreenId < mcMonitors)
2092 {
2093 DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
2094 u32Width = pFBInfo->w;
2095 u32Height = pFBInfo->h;
2096 u32BitsPerPixel = pFBInfo->u16BitsPerPixel;
2097 xOrigin = pFBInfo->xOrigin;
2098 yOrigin = pFBInfo->yOrigin;
2099 }
2100 else
2101 {
2102 return E_INVALIDARG;
2103 }
2104
2105 if (aWidth)
2106 *aWidth = u32Width;
2107 if (aHeight)
2108 *aHeight = u32Height;
2109 if (aBitsPerPixel)
2110 *aBitsPerPixel = u32BitsPerPixel;
2111 if (aXOrigin)
2112 *aXOrigin = xOrigin;
2113 if (aYOrigin)
2114 *aYOrigin = yOrigin;
2115
2116 return S_OK;
2117}
2118
2119STDMETHODIMP Display::SetFramebuffer(ULONG aScreenId, IFramebuffer *aFramebuffer)
2120{
2121 LogRelFlowFunc(("\n"));
2122
2123 if (aFramebuffer != NULL)
2124 CheckComArgOutPointerValid(aFramebuffer);
2125
2126 AutoCaller autoCaller(this);
2127 if (FAILED(autoCaller.rc()))
2128 return autoCaller.rc();
2129
2130 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2131
2132 Console::SafeVMPtrQuiet ptrVM(mParent);
2133 if (ptrVM.isOk())
2134 {
2135 /* Must release the lock here because the changeFramebuffer will
2136 * also obtain it. */
2137 alock.release();
2138
2139 /* send request to the EMT thread */
2140 int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY,
2141 (PFNRT)changeFramebuffer, 3, this, aFramebuffer, aScreenId);
2142
2143 alock.acquire();
2144
2145 ComAssertRCRet (vrc, E_FAIL);
2146
2147#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
2148 {
2149 BOOL is3denabled;
2150 mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
2151
2152 if (is3denabled)
2153 {
2154 VBOXHGCMSVCPARM parm;
2155
2156 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
2157 parm.u.uint32 = aScreenId;
2158
2159 VMMDev *pVMMDev = mParent->getVMMDev();
2160
2161 alock.release();
2162
2163 if (pVMMDev)
2164 vrc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
2165 /*ComAssertRCRet (vrc, E_FAIL);*/
2166
2167 alock.acquire();
2168 }
2169 }
2170#endif /* VBOX_WITH_CROGL */
2171 }
2172 else
2173 {
2174 /* No VM is created (VM is powered off), do a direct call */
2175 int vrc = changeFramebuffer (this, aFramebuffer, aScreenId);
2176 ComAssertRCRet (vrc, E_FAIL);
2177 }
2178
2179 return S_OK;
2180}
2181
2182STDMETHODIMP Display::GetFramebuffer(ULONG aScreenId,
2183 IFramebuffer **aFramebuffer, LONG *aXOrigin, LONG *aYOrigin)
2184{
2185 LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
2186
2187 CheckComArgOutPointerValid(aFramebuffer);
2188
2189 AutoCaller autoCaller(this);
2190 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2191
2192 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2193
2194 if (aScreenId != 0 && aScreenId >= mcMonitors)
2195 return E_INVALIDARG;
2196
2197 /* @todo this should be actually done on EMT. */
2198 DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
2199
2200 *aFramebuffer = pFBInfo->pFramebuffer;
2201 if (*aFramebuffer)
2202 (*aFramebuffer)->AddRef ();
2203 if (aXOrigin)
2204 *aXOrigin = pFBInfo->xOrigin;
2205 if (aYOrigin)
2206 *aYOrigin = pFBInfo->yOrigin;
2207
2208 return S_OK;
2209}
2210
2211STDMETHODIMP Display::SetVideoModeHint(ULONG aDisplay, BOOL aEnabled,
2212 BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
2213 ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel)
2214{
2215 AutoCaller autoCaller(this);
2216 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2217
2218 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2219
2220 CHECK_CONSOLE_DRV(mpDrv);
2221
2222 /*
2223 * Do some rough checks for valid input
2224 */
2225 ULONG width = aWidth;
2226 if (!width)
2227 width = mpDrv->IConnector.cx;
2228 ULONG height = aHeight;
2229 if (!height)
2230 height = mpDrv->IConnector.cy;
2231 ULONG bpp = aBitsPerPixel;
2232 if (!bpp)
2233 {
2234 uint32_t cBits = 0;
2235 int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &cBits);
2236 AssertRC(rc);
2237 bpp = cBits;
2238 }
2239 ULONG cMonitors;
2240 mParent->machine()->COMGETTER(MonitorCount)(&cMonitors);
2241 if (cMonitors == 0 && aDisplay > 0)
2242 return E_INVALIDARG;
2243 if (aDisplay >= cMonitors)
2244 return E_INVALIDARG;
2245
2246 /*
2247 * sunlover 20070614: It is up to the guest to decide whether the hint is
2248 * valid. Therefore don't do any VRAM sanity checks here!
2249 */
2250
2251 /* Have to release the lock because the pfnRequestDisplayChange
2252 * will call EMT. */
2253 alock.release();
2254
2255 VMMDev *pVMMDev = mParent->getVMMDev();
2256 if (pVMMDev)
2257 {
2258 PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
2259 if (pVMMDevPort)
2260 pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel,
2261 aDisplay, aOriginX, aOriginY,
2262 RT_BOOL(aEnabled), RT_BOOL(aChangeOrigin));
2263 }
2264 return S_OK;
2265}
2266
2267STDMETHODIMP Display::SetSeamlessMode (BOOL enabled)
2268{
2269 AutoCaller autoCaller(this);
2270 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2271
2272 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2273
2274 /* Have to release the lock because the pfnRequestSeamlessChange will call EMT. */
2275 alock.release();
2276
2277 VMMDev *pVMMDev = mParent->getVMMDev();
2278 if (pVMMDev)
2279 {
2280 PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
2281 if (pVMMDevPort)
2282 pVMMDevPort->pfnRequestSeamlessChange(pVMMDevPort, !!enabled);
2283 }
2284
2285#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
2286 if (!enabled)
2287 {
2288 BOOL is3denabled = FALSE;
2289
2290 mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
2291
2292 VMMDev *vmmDev = mParent->getVMMDev();
2293 if (is3denabled && vmmDev)
2294 {
2295 VBOXHGCMSVCPARM parms[2];
2296
2297 parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
2298 /* NULL means disable */
2299 parms[0].u.pointer.addr = NULL;
2300 parms[0].u.pointer.size = 0; /* We don't actually care. */
2301 parms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
2302 parms[1].u.uint32 = 0;
2303
2304 vmmDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SET_VISIBLE_REGION, 2, &parms[0]);
2305 }
2306 }
2307#endif
2308 return S_OK;
2309}
2310
2311int Display::displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData, uint32_t *pu32Width, uint32_t *pu32Height)
2312{
2313 int rc;
2314 pDisplay->vbvaLock();
2315 if ( aScreenId == VBOX_VIDEO_PRIMARY_SCREEN
2316 && pDisplay->maFramebuffers[aScreenId].fVBVAEnabled == false) /* A non-VBVA mode. */
2317 {
2318 rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppu8Data, pcbData, pu32Width, pu32Height);
2319 }
2320 else if (aScreenId < pDisplay->mcMonitors)
2321 {
2322 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2323
2324 uint32_t width = pFBInfo->w;
2325 uint32_t height = pFBInfo->h;
2326
2327 /* Allocate 32 bit per pixel bitmap. */
2328 size_t cbRequired = width * 4 * height;
2329
2330 if (cbRequired)
2331 {
2332 uint8_t *pu8Data = (uint8_t *)RTMemAlloc(cbRequired);
2333
2334 if (pu8Data == NULL)
2335 {
2336 rc = VERR_NO_MEMORY;
2337 }
2338 else
2339 {
2340 /* Copy guest VRAM to the allocated 32bpp buffer. */
2341 const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
2342 int32_t xSrc = 0;
2343 int32_t ySrc = 0;
2344 uint32_t u32SrcWidth = width;
2345 uint32_t u32SrcHeight = height;
2346 uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
2347 uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2348
2349 uint8_t *pu8Dst = pu8Data;
2350 int32_t xDst = 0;
2351 int32_t yDst = 0;
2352 uint32_t u32DstWidth = u32SrcWidth;
2353 uint32_t u32DstHeight = u32SrcHeight;
2354 uint32_t u32DstLineSize = u32DstWidth * 4;
2355 uint32_t u32DstBitsPerPixel = 32;
2356
2357 rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2358 width, height,
2359 pu8Src,
2360 xSrc, ySrc,
2361 u32SrcWidth, u32SrcHeight,
2362 u32SrcLineSize, u32SrcBitsPerPixel,
2363 pu8Dst,
2364 xDst, yDst,
2365 u32DstWidth, u32DstHeight,
2366 u32DstLineSize, u32DstBitsPerPixel);
2367 if (RT_SUCCESS(rc))
2368 {
2369 *ppu8Data = pu8Data;
2370 *pcbData = cbRequired;
2371 *pu32Width = width;
2372 *pu32Height = height;
2373 }
2374 else
2375 {
2376 RTMemFree(pu8Data);
2377 }
2378 }
2379 }
2380 else
2381 {
2382 /* No image. */
2383 *ppu8Data = NULL;
2384 *pcbData = 0;
2385 *pu32Width = 0;
2386 *pu32Height = 0;
2387 rc = VINF_SUCCESS;
2388 }
2389 }
2390 else
2391 {
2392 rc = VERR_INVALID_PARAMETER;
2393 }
2394 pDisplay->vbvaUnlock();
2395 return rc;
2396}
2397
2398static int displayTakeScreenshot(PUVM pUVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId,
2399 BYTE *address, ULONG width, ULONG height)
2400{
2401 uint8_t *pu8Data = NULL;
2402 size_t cbData = 0;
2403 uint32_t cx = 0;
2404 uint32_t cy = 0;
2405 int vrc = VINF_SUCCESS;
2406
2407 int cRetries = 5;
2408
2409 while (cRetries-- > 0)
2410 {
2411 /* Note! Not sure if the priority call is such a good idea here, but
2412 it would be nice to have an accurate screenshot for the bug
2413 report if the VM deadlocks. */
2414 vrc = VMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::displayTakeScreenshotEMT, 6,
2415 pDisplay, aScreenId, &pu8Data, &cbData, &cx, &cy);
2416 if (vrc != VERR_TRY_AGAIN)
2417 {
2418 break;
2419 }
2420
2421 RTThreadSleep(10);
2422 }
2423
2424 if (RT_SUCCESS(vrc) && pu8Data)
2425 {
2426 if (cx == width && cy == height)
2427 {
2428 /* No scaling required. */
2429 memcpy(address, pu8Data, cbData);
2430 }
2431 else
2432 {
2433 /* Scale. */
2434 LogRelFlowFunc(("SCALE: %dx%d -> %dx%d\n", cx, cy, width, height));
2435
2436 uint8_t *dst = address;
2437 uint8_t *src = pu8Data;
2438 int dstW = width;
2439 int dstH = height;
2440 int srcW = cx;
2441 int srcH = cy;
2442 int iDeltaLine = cx * 4;
2443
2444 BitmapScale32(dst,
2445 dstW, dstH,
2446 src,
2447 iDeltaLine,
2448 srcW, srcH);
2449 }
2450
2451 if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2452 {
2453 /* This can be called from any thread. */
2454 pDrv->pUpPort->pfnFreeScreenshot(pDrv->pUpPort, pu8Data);
2455 }
2456 else
2457 {
2458 RTMemFree(pu8Data);
2459 }
2460 }
2461
2462 return vrc;
2463}
2464
2465STDMETHODIMP Display::TakeScreenShot(ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
2466{
2467 /// @todo (r=dmik) this function may take too long to complete if the VM
2468 // is doing something like saving state right now. Which, in case if it
2469 // is called on the GUI thread, will make it unresponsive. We should
2470 // check the machine state here (by enclosing the check and VMRequCall
2471 // within the Console lock to make it atomic).
2472
2473 LogRelFlowFunc(("address=%p, width=%d, height=%d\n",
2474 address, width, height));
2475
2476 CheckComArgNotNull(address);
2477 CheckComArgExpr(width, width != 0);
2478 CheckComArgExpr(height, height != 0);
2479
2480 /* Do not allow too large screenshots. This also filters out negative
2481 * values passed as either 'width' or 'height'.
2482 */
2483 CheckComArgExpr(width, width <= 32767);
2484 CheckComArgExpr(height, height <= 32767);
2485
2486 AutoCaller autoCaller(this);
2487 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2488
2489 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2490
2491 if (!mpDrv)
2492 return E_FAIL;
2493
2494 Console::SafeVMPtr ptrVM(mParent);
2495 if (!ptrVM.isOk())
2496 return ptrVM.rc();
2497
2498 HRESULT rc = S_OK;
2499
2500 LogRelFlowFunc(("Sending SCREENSHOT request\n"));
2501
2502 /* Release lock because other thread (EMT) is called and it may initiate a resize
2503 * which also needs lock.
2504 *
2505 * This method does not need the lock anymore.
2506 */
2507 alock.release();
2508
2509 int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, address, width, height);
2510
2511 if (vrc == VERR_NOT_IMPLEMENTED)
2512 rc = setError(E_NOTIMPL,
2513 tr("This feature is not implemented"));
2514 else if (vrc == VERR_TRY_AGAIN)
2515 rc = setError(E_UNEXPECTED,
2516 tr("This feature is not available at this time"));
2517 else if (RT_FAILURE(vrc))
2518 rc = setError(VBOX_E_IPRT_ERROR,
2519 tr("Could not take a screenshot (%Rrc)"), vrc);
2520
2521 LogRelFlowFunc(("rc=%Rhrc\n", rc));
2522 return rc;
2523}
2524
2525STDMETHODIMP Display::TakeScreenShotToArray(ULONG aScreenId, ULONG width, ULONG height,
2526 ComSafeArrayOut(BYTE, aScreenData))
2527{
2528 LogRelFlowFunc(("width=%d, height=%d\n", width, height));
2529
2530 CheckComArgOutSafeArrayPointerValid(aScreenData);
2531 CheckComArgExpr(width, width != 0);
2532 CheckComArgExpr(height, height != 0);
2533
2534 /* Do not allow too large screenshots. This also filters out negative
2535 * values passed as either 'width' or 'height'.
2536 */
2537 CheckComArgExpr(width, width <= 32767);
2538 CheckComArgExpr(height, height <= 32767);
2539
2540 AutoCaller autoCaller(this);
2541 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2542
2543 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2544
2545 if (!mpDrv)
2546 return E_FAIL;
2547
2548 Console::SafeVMPtr ptrVM(mParent);
2549 if (!ptrVM.isOk())
2550 return ptrVM.rc();
2551
2552 HRESULT rc = S_OK;
2553
2554 LogRelFlowFunc(("Sending SCREENSHOT request\n"));
2555
2556 /* Release lock because other thread (EMT) is called and it may initiate a resize
2557 * which also needs lock.
2558 *
2559 * This method does not need the lock anymore.
2560 */
2561 alock.release();
2562
2563 size_t cbData = width * 4 * height;
2564 uint8_t *pu8Data = (uint8_t *)RTMemAlloc(cbData);
2565
2566 if (!pu8Data)
2567 return E_OUTOFMEMORY;
2568
2569 int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
2570
2571 if (RT_SUCCESS(vrc))
2572 {
2573 /* Convert pixels to format expected by the API caller: [0] R, [1] G, [2] B, [3] A. */
2574 uint8_t *pu8 = pu8Data;
2575 unsigned cPixels = width * height;
2576 while (cPixels)
2577 {
2578 uint8_t u8 = pu8[0];
2579 pu8[0] = pu8[2];
2580 pu8[2] = u8;
2581 pu8[3] = 0xff;
2582 cPixels--;
2583 pu8 += 4;
2584 }
2585
2586 com::SafeArray<BYTE> screenData(cbData);
2587 screenData.initFrom(pu8Data, cbData);
2588 screenData.detachTo(ComSafeArrayOutArg(aScreenData));
2589 }
2590 else if (vrc == VERR_NOT_IMPLEMENTED)
2591 rc = setError(E_NOTIMPL,
2592 tr("This feature is not implemented"));
2593 else
2594 rc = setError(VBOX_E_IPRT_ERROR,
2595 tr("Could not take a screenshot (%Rrc)"), vrc);
2596
2597 RTMemFree(pu8Data);
2598
2599 LogRelFlowFunc(("rc=%Rhrc\n", rc));
2600 return rc;
2601}
2602
2603STDMETHODIMP Display::TakeScreenShotPNGToArray(ULONG aScreenId, ULONG width, ULONG height,
2604 ComSafeArrayOut(BYTE, aScreenData))
2605{
2606 LogRelFlowFunc(("width=%d, height=%d\n", width, height));
2607
2608 CheckComArgOutSafeArrayPointerValid(aScreenData);
2609 CheckComArgExpr(width, width != 0);
2610 CheckComArgExpr(height, height != 0);
2611
2612 /* Do not allow too large screenshots. This also filters out negative
2613 * values passed as either 'width' or 'height'.
2614 */
2615 CheckComArgExpr(width, width <= 32767);
2616 CheckComArgExpr(height, height <= 32767);
2617
2618 AutoCaller autoCaller(this);
2619 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2620
2621 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2622
2623 CHECK_CONSOLE_DRV(mpDrv);
2624
2625 Console::SafeVMPtr ptrVM(mParent);
2626 if (!ptrVM.isOk())
2627 return ptrVM.rc();
2628
2629 HRESULT rc = S_OK;
2630
2631 LogRelFlowFunc(("Sending SCREENSHOT request\n"));
2632
2633 /* Release lock because other thread (EMT) is called and it may initiate a resize
2634 * which also needs lock.
2635 *
2636 * This method does not need the lock anymore.
2637 */
2638 alock.release();
2639
2640 size_t cbData = width * 4 * height;
2641 uint8_t *pu8Data = (uint8_t *)RTMemAlloc(cbData);
2642
2643 if (!pu8Data)
2644 return E_OUTOFMEMORY;
2645
2646 int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
2647
2648 if (RT_SUCCESS(vrc))
2649 {
2650 uint8_t *pu8PNG = NULL;
2651 uint32_t cbPNG = 0;
2652 uint32_t cxPNG = 0;
2653 uint32_t cyPNG = 0;
2654
2655 vrc = DisplayMakePNG(pu8Data, width, height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
2656 if (RT_SUCCESS(vrc))
2657 {
2658 com::SafeArray<BYTE> screenData(cbPNG);
2659 screenData.initFrom(pu8PNG, cbPNG);
2660 if (pu8PNG)
2661 RTMemFree(pu8PNG);
2662
2663 screenData.detachTo(ComSafeArrayOutArg(aScreenData));
2664 }
2665 else
2666 {
2667 if (pu8PNG)
2668 RTMemFree(pu8PNG);
2669 rc = setError(VBOX_E_IPRT_ERROR,
2670 tr("Could not convert screenshot to PNG (%Rrc)"), vrc);
2671 }
2672 }
2673 else if (vrc == VERR_NOT_IMPLEMENTED)
2674 rc = setError(E_NOTIMPL,
2675 tr("This feature is not implemented"));
2676 else
2677 rc = setError(VBOX_E_IPRT_ERROR,
2678 tr("Could not take a screenshot (%Rrc)"), vrc);
2679
2680 RTMemFree(pu8Data);
2681
2682 LogRelFlowFunc(("rc=%Rhrc\n", rc));
2683 return rc;
2684}
2685
2686int Display::VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
2687{
2688#ifdef VBOX_WITH_VPX
2689 com::SafeArray<BOOL> Screens(ComSafeArrayInArg(aScreens));
2690 for (unsigned i = 0; i < Screens.size(); i++)
2691 maVideoRecEnabled[i] = RT_BOOL(Screens[i]);
2692 return VINF_SUCCESS;
2693#else
2694 return VERR_NOT_IMPLEMENTED;
2695#endif
2696}
2697
2698/**
2699 * Start video capturing. Does nothing if capturing is already active.
2700 */
2701int Display::VideoCaptureStart()
2702{
2703#ifdef VBOX_WITH_VPX
2704 if (VideoRecIsEnabled(mpVideoRecCtx))
2705 return VINF_SUCCESS;
2706
2707 int rc = VideoRecContextCreate(&mpVideoRecCtx, mcMonitors);
2708 if (RT_FAILURE(rc))
2709 {
2710 LogFlow(("Failed to create video recording context (%Rrc)!\n", rc));
2711 return rc;
2712 }
2713 ComPtr<IMachine> pMachine = mParent->machine();
2714 com::SafeArray<BOOL> screens;
2715 HRESULT hrc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens));
2716 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2717 for (unsigned i = 0; i < RT_ELEMENTS(maVideoRecEnabled); i++)
2718 maVideoRecEnabled[i] = i < screens.size() && screens[i];
2719 ULONG ulWidth;
2720 hrc = pMachine->COMGETTER(VideoCaptureWidth)(&ulWidth);
2721 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2722 ULONG ulHeight;
2723 hrc = pMachine->COMGETTER(VideoCaptureHeight)(&ulHeight);
2724 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2725 ULONG ulRate;
2726 hrc = pMachine->COMGETTER(VideoCaptureRate)(&ulRate);
2727 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2728 ULONG ulFPS;
2729 hrc = pMachine->COMGETTER(VideoCaptureFPS)(&ulFPS);
2730 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2731 BSTR strFile;
2732 hrc = pMachine->COMGETTER(VideoCaptureFile)(&strFile);
2733 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
2734 RTTIMESPEC ts;
2735 RTTimeNow(&ts);
2736 RTTIME time;
2737 RTTimeExplode(&time, &ts);
2738 for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++)
2739 {
2740 char *pszAbsPath = RTPathAbsDup(com::Utf8Str(strFile).c_str());
2741 char *pszExt = RTPathExt(pszAbsPath);
2742 if (pszExt)
2743 pszExt = RTStrDup(pszExt);
2744 RTPathStripExt(pszAbsPath);
2745 if (!pszAbsPath)
2746 rc = VERR_INVALID_PARAMETER;
2747 if (!pszExt)
2748 pszExt = RTStrDup(".webm");
2749 char *pszName = NULL;
2750 if (RT_SUCCESS(rc))
2751 {
2752 if (mcMonitors > 1)
2753 rc = RTStrAPrintf(&pszName, "%s-%u%s", pszAbsPath, uScreen+1, pszExt);
2754 else
2755 rc = RTStrAPrintf(&pszName, "%s%s", pszAbsPath, pszExt);
2756 }
2757 if (RT_SUCCESS(rc))
2758 {
2759 rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2760 pszName, ulWidth, ulHeight, ulRate, ulFPS);
2761 if (rc == VERR_ALREADY_EXISTS)
2762 {
2763 RTStrFree(pszName);
2764 pszName = NULL;
2765
2766 if (mcMonitors > 1)
2767 rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
2768 pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2769 time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2770 uScreen+1, pszExt);
2771 else
2772 rc = RTStrAPrintf(&pszName, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
2773 pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
2774 time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
2775 pszExt);
2776 if (RT_SUCCESS(rc))
2777 rc = VideoRecStrmInit(mpVideoRecCtx, uScreen,
2778 pszName, ulWidth, ulHeight, ulRate, ulFPS);
2779 }
2780 }
2781
2782 if (RT_SUCCESS(rc))
2783 LogRel(("WebM/VP8 video recording screen #%u with %ux%u @ %u kbps, %u fps to '%s' enabled.\n",
2784 uScreen, ulWidth, ulHeight, ulRate, ulFPS, pszName));
2785 else
2786 LogRel(("Failed to initialize video recording context #%u (%Rrc)!\n", uScreen, rc));
2787 RTStrFree(pszName);
2788 RTStrFree(pszExt);
2789 RTStrFree(pszAbsPath);
2790 }
2791 return rc;
2792#else
2793 return VERR_NOT_IMPLEMENTED;
2794#endif
2795}
2796
2797/**
2798 * Stop video capturing. Does nothing if video capturing is not active.
2799 */
2800void Display::VideoCaptureStop()
2801{
2802#ifdef VBOX_WITH_VPX
2803 if (VideoRecIsEnabled(mpVideoRecCtx))
2804 LogRel(("WebM/VP8 video recording stopped.\n"));
2805 VideoRecContextClose(mpVideoRecCtx);
2806 mpVideoRecCtx = NULL;
2807#endif
2808}
2809
2810int Display::drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address,
2811 ULONG x, ULONG y, ULONG width, ULONG height)
2812{
2813 int rc = VINF_SUCCESS;
2814 pDisplay->vbvaLock();
2815
2816 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[aScreenId];
2817
2818 if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
2819 {
2820 if (pFBInfo->u32ResizeStatus == ResizeStatus_Void)
2821 {
2822 rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
2823 }
2824 }
2825 else if (aScreenId < pDisplay->mcMonitors)
2826 {
2827 /* Copy the bitmap to the guest VRAM. */
2828 const uint8_t *pu8Src = address;
2829 int32_t xSrc = 0;
2830 int32_t ySrc = 0;
2831 uint32_t u32SrcWidth = width;
2832 uint32_t u32SrcHeight = height;
2833 uint32_t u32SrcLineSize = width * 4;
2834 uint32_t u32SrcBitsPerPixel = 32;
2835
2836 uint8_t *pu8Dst = pFBInfo->pu8FramebufferVRAM;
2837 int32_t xDst = x;
2838 int32_t yDst = y;
2839 uint32_t u32DstWidth = pFBInfo->w;
2840 uint32_t u32DstHeight = pFBInfo->h;
2841 uint32_t u32DstLineSize = pFBInfo->u32LineSize;
2842 uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
2843
2844 rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2845 width, height,
2846 pu8Src,
2847 xSrc, ySrc,
2848 u32SrcWidth, u32SrcHeight,
2849 u32SrcLineSize, u32SrcBitsPerPixel,
2850 pu8Dst,
2851 xDst, yDst,
2852 u32DstWidth, u32DstHeight,
2853 u32DstLineSize, u32DstBitsPerPixel);
2854 if (RT_SUCCESS(rc))
2855 {
2856 if (!pFBInfo->pFramebuffer.isNull())
2857 {
2858 /* Update the changed screen area. When framebuffer uses VRAM directly, just notify
2859 * it to update. And for default format, render the guest VRAM to framebuffer.
2860 */
2861 if ( pFBInfo->fDefaultFormat
2862 && !pFBInfo->fDisabled)
2863 {
2864 address = NULL;
2865 HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
2866 if (SUCCEEDED(hrc) && address != NULL)
2867 {
2868 pu8Src = pFBInfo->pu8FramebufferVRAM;
2869 xSrc = x;
2870 ySrc = y;
2871 u32SrcWidth = pFBInfo->w;
2872 u32SrcHeight = pFBInfo->h;
2873 u32SrcLineSize = pFBInfo->u32LineSize;
2874 u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
2875
2876 /* Default format is 32 bpp. */
2877 pu8Dst = address;
2878 xDst = xSrc;
2879 yDst = ySrc;
2880 u32DstWidth = u32SrcWidth;
2881 u32DstHeight = u32SrcHeight;
2882 u32DstLineSize = u32DstWidth * 4;
2883 u32DstBitsPerPixel = 32;
2884
2885 pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
2886 width, height,
2887 pu8Src,
2888 xSrc, ySrc,
2889 u32SrcWidth, u32SrcHeight,
2890 u32SrcLineSize, u32SrcBitsPerPixel,
2891 pu8Dst,
2892 xDst, yDst,
2893 u32DstWidth, u32DstHeight,
2894 u32DstLineSize, u32DstBitsPerPixel);
2895 }
2896 }
2897
2898 pDisplay->handleDisplayUpdate(aScreenId, x, y, width, height);
2899 }
2900 }
2901 }
2902 else
2903 {
2904 rc = VERR_INVALID_PARAMETER;
2905 }
2906
2907 if ( RT_SUCCESS(rc)
2908 && pDisplay->maFramebuffers[aScreenId].u32ResizeStatus == ResizeStatus_Void)
2909 pDisplay->mParent->consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
2910
2911 pDisplay->vbvaUnlock();
2912 return rc;
2913}
2914
2915STDMETHODIMP Display::DrawToScreen(ULONG aScreenId, BYTE *address,
2916 ULONG x, ULONG y, ULONG width, ULONG height)
2917{
2918 /// @todo (r=dmik) this function may take too long to complete if the VM
2919 // is doing something like saving state right now. Which, in case if it
2920 // is called on the GUI thread, will make it unresponsive. We should
2921 // check the machine state here (by enclosing the check and VMRequCall
2922 // within the Console lock to make it atomic).
2923
2924 LogRelFlowFunc(("address=%p, x=%d, y=%d, width=%d, height=%d\n",
2925 (void *)address, x, y, width, height));
2926
2927 CheckComArgNotNull(address);
2928 CheckComArgExpr(width, width != 0);
2929 CheckComArgExpr(height, height != 0);
2930
2931 AutoCaller autoCaller(this);
2932 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2933
2934 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2935
2936 CHECK_CONSOLE_DRV(mpDrv);
2937
2938 Console::SafeVMPtr ptrVM(mParent);
2939 if (!ptrVM.isOk())
2940 return ptrVM.rc();
2941
2942 /* Release lock because the call scheduled on EMT may also try to take it. */
2943 alock.release();
2944
2945 /*
2946 * Again we're lazy and make the graphics device do all the
2947 * dirty conversion work.
2948 */
2949 int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::drawToScreenEMT, 7,
2950 this, aScreenId, address, x, y, width, height);
2951
2952 /*
2953 * If the function returns not supported, we'll have to do all the
2954 * work ourselves using the framebuffer.
2955 */
2956 HRESULT rc = S_OK;
2957 if (rcVBox == VERR_NOT_SUPPORTED || rcVBox == VERR_NOT_IMPLEMENTED)
2958 {
2959 /** @todo implement generic fallback for screen blitting. */
2960 rc = E_NOTIMPL;
2961 }
2962 else if (RT_FAILURE(rcVBox))
2963 rc = setError(VBOX_E_IPRT_ERROR,
2964 tr("Could not draw to the screen (%Rrc)"), rcVBox);
2965//@todo
2966// else
2967// {
2968// /* All ok. Redraw the screen. */
2969// handleDisplayUpdate (x, y, width, height);
2970// }
2971
2972 LogRelFlowFunc(("rc=%Rhrc\n", rc));
2973 return rc;
2974}
2975
2976void Display::InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
2977{
2978 pDisplay->vbvaLock();
2979 unsigned uScreenId;
2980 for (uScreenId = (fUpdateAll ? 0 : uId); uScreenId < pDisplay->mcMonitors; uScreenId++)
2981 {
2982 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
2983
2984 if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN && !pFBInfo->pFramebuffer.isNull())
2985 {
2986 pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort);
2987 }
2988 else
2989 {
2990 if ( !pFBInfo->pFramebuffer.isNull()
2991 && !pFBInfo->fDisabled
2992 && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
2993 {
2994 /* Render complete VRAM screen to the framebuffer.
2995 * When framebuffer uses VRAM directly, just notify it to update.
2996 */
2997 if (pFBInfo->fDefaultFormat)
2998 {
2999 BYTE *address = NULL;
3000 ULONG uWidth = 0;
3001 ULONG uHeight = 0;
3002 pFBInfo->pFramebuffer->COMGETTER(Width) (&uWidth);
3003 pFBInfo->pFramebuffer->COMGETTER(Height) (&uHeight);
3004 HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
3005 if (SUCCEEDED(hrc) && address != NULL)
3006 {
3007 uint32_t width = pFBInfo->w;
3008 uint32_t height = pFBInfo->h;
3009
3010 const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
3011 int32_t xSrc = 0;
3012 int32_t ySrc = 0;
3013 uint32_t u32SrcWidth = pFBInfo->w;
3014 uint32_t u32SrcHeight = pFBInfo->h;
3015 uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
3016 uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
3017
3018 /* Default format is 32 bpp. */
3019 uint8_t *pu8Dst = address;
3020 int32_t xDst = xSrc;
3021 int32_t yDst = ySrc;
3022 uint32_t u32DstWidth = u32SrcWidth;
3023 uint32_t u32DstHeight = u32SrcHeight;
3024 uint32_t u32DstLineSize = u32DstWidth * 4;
3025 uint32_t u32DstBitsPerPixel = 32;
3026
3027 /* if uWidth != pFBInfo->w and uHeight != pFBInfo->h
3028 * implies resize of Framebuffer is in progress and
3029 * copyrect should not be called.
3030 */
3031 if (uWidth == pFBInfo->w && uHeight == pFBInfo->h)
3032 {
3033
3034 pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
3035 width, height,
3036 pu8Src,
3037 xSrc, ySrc,
3038 u32SrcWidth, u32SrcHeight,
3039 u32SrcLineSize, u32SrcBitsPerPixel,
3040 pu8Dst,
3041 xDst, yDst,
3042 u32DstWidth, u32DstHeight,
3043 u32DstLineSize, u32DstBitsPerPixel);
3044 }
3045 }
3046 }
3047
3048 pDisplay->handleDisplayUpdate (uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
3049 }
3050 }
3051 if (!fUpdateAll)
3052 break;
3053 }
3054 pDisplay->vbvaUnlock();
3055}
3056
3057/**
3058 * Does a full invalidation of the VM display and instructs the VM
3059 * to update it immediately.
3060 *
3061 * @returns COM status code
3062 */
3063STDMETHODIMP Display::InvalidateAndUpdate()
3064{
3065 LogRelFlowFunc(("\n"));
3066
3067 AutoCaller autoCaller(this);
3068 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3069
3070 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3071
3072 CHECK_CONSOLE_DRV(mpDrv);
3073
3074 Console::SafeVMPtr ptrVM(mParent);
3075 if (!ptrVM.isOk())
3076 return ptrVM.rc();
3077
3078 HRESULT rc = S_OK;
3079
3080 LogRelFlowFunc(("Sending DPYUPDATE request\n"));
3081
3082 /* Have to release the lock when calling EMT. */
3083 alock.release();
3084
3085 /* pdm.h says that this has to be called from the EMT thread */
3086 int rcVBox = VMR3ReqCallVoidWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
3087 3, this, 0, true);
3088 alock.acquire();
3089
3090 if (RT_FAILURE(rcVBox))
3091 rc = setError(VBOX_E_IPRT_ERROR,
3092 tr("Could not invalidate and update the screen (%Rrc)"), rcVBox);
3093
3094 LogRelFlowFunc(("rc=%Rhrc\n", rc));
3095 return rc;
3096}
3097
3098/**
3099 * Notification that the framebuffer has completed the
3100 * asynchronous resize processing
3101 *
3102 * @returns COM status code
3103 */
3104STDMETHODIMP Display::ResizeCompleted(ULONG aScreenId)
3105{
3106 LogRelFlowFunc(("\n"));
3107
3108 /// @todo (dmik) can we AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); here?
3109 // This will require general code review and may add some details.
3110 // In particular, we may want to check whether EMT is really waiting for
3111 // this notification, etc. It might be also good to obey the caller to make
3112 // sure this method is not called from more than one thread at a time
3113 // (and therefore don't use Display lock at all here to save some
3114 // milliseconds).
3115 AutoCaller autoCaller(this);
3116 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3117
3118 /* this is only valid for external framebuffers */
3119 if (maFramebuffers[aScreenId].pFramebuffer == NULL)
3120 return setError(VBOX_E_NOT_SUPPORTED,
3121 tr("Resize completed notification is valid only for external framebuffers"));
3122
3123 /* Set the flag indicating that the resize has completed and display
3124 * data need to be updated. */
3125 bool f = ASMAtomicCmpXchgU32 (&maFramebuffers[aScreenId].u32ResizeStatus,
3126 ResizeStatus_UpdateDisplayData, ResizeStatus_InProgress);
3127 AssertRelease(f);NOREF(f);
3128
3129 return S_OK;
3130}
3131
3132STDMETHODIMP Display::CompleteVHWACommand(BYTE *pCommand)
3133{
3134#ifdef VBOX_WITH_VIDEOHWACCEL
3135 mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsynch(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)pCommand);
3136 return S_OK;
3137#else
3138 return E_NOTIMPL;
3139#endif
3140}
3141
3142STDMETHODIMP Display::ViewportChanged(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
3143{
3144#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
3145 BOOL is3denabled;
3146 mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
3147
3148 if (is3denabled)
3149 {
3150 VBOXHGCMSVCPARM aParms[5];
3151
3152 aParms[0].type = VBOX_HGCM_SVC_PARM_32BIT;
3153 aParms[0].u.uint32 = aScreenId;
3154
3155 aParms[1].type = VBOX_HGCM_SVC_PARM_32BIT;
3156 aParms[1].u.uint32 = x;
3157
3158 aParms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
3159 aParms[2].u.uint32 = y;
3160
3161
3162 aParms[3].type = VBOX_HGCM_SVC_PARM_32BIT;
3163 aParms[3].u.uint32 = width;
3164
3165 aParms[4].type = VBOX_HGCM_SVC_PARM_32BIT;
3166 aParms[4].u.uint32 = height;
3167
3168 VMMDev *pVMMDev = mParent->getVMMDev();
3169
3170 if (pVMMDev)
3171 pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_VIEWPORT_CHANGED, SHCRGL_CPARMS_VIEWPORT_CHANGED, aParms);
3172 }
3173#endif /* VBOX_WITH_CROGL && VBOX_WITH_HGCM */
3174 return S_OK;
3175}
3176
3177// private methods
3178/////////////////////////////////////////////////////////////////////////////
3179
3180/**
3181 * Helper to update the display information from the framebuffer.
3182 *
3183 * @thread EMT
3184 */
3185void Display::updateDisplayData(void)
3186{
3187 LogRelFlowFunc(("\n"));
3188
3189 /* the driver might not have been constructed yet */
3190 if (!mpDrv)
3191 return;
3192
3193#ifdef VBOX_STRICT
3194 /*
3195 * Sanity check. Note that this method may be called on EMT after Console
3196 * has started the power down procedure (but before our #drvDestruct() is
3197 * called, in which case pVM will already be NULL but mpDrv will not). Since
3198 * we don't really need pVM to proceed, we avoid this check in the release
3199 * build to save some ms (necessary to construct SafeVMPtrQuiet) in this
3200 * time-critical method.
3201 */
3202 Console::SafeVMPtrQuiet ptrVM(mParent);
3203 if (ptrVM.isOk())
3204 {
3205 PVM pVM = VMR3GetVM(ptrVM.rawUVM());
3206 Assert(VM_IS_EMT(pVM));
3207 }
3208#endif
3209
3210 /* The method is only relevant to the primary framebuffer. */
3211 IFramebuffer *pFramebuffer = maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer;
3212
3213 if (pFramebuffer)
3214 {
3215 HRESULT rc;
3216 BYTE *address = 0;
3217 rc = pFramebuffer->COMGETTER(Address) (&address);
3218 AssertComRC (rc);
3219 ULONG bytesPerLine = 0;
3220 rc = pFramebuffer->COMGETTER(BytesPerLine) (&bytesPerLine);
3221 AssertComRC (rc);
3222 ULONG bitsPerPixel = 0;
3223 rc = pFramebuffer->COMGETTER(BitsPerPixel) (&bitsPerPixel);
3224 AssertComRC (rc);
3225 ULONG width = 0;
3226 rc = pFramebuffer->COMGETTER(Width) (&width);
3227 AssertComRC (rc);
3228 ULONG height = 0;
3229 rc = pFramebuffer->COMGETTER(Height) (&height);
3230 AssertComRC (rc);
3231
3232 mpDrv->IConnector.pu8Data = (uint8_t *) address;
3233 mpDrv->IConnector.cbScanline = bytesPerLine;
3234 mpDrv->IConnector.cBits = bitsPerPixel;
3235 mpDrv->IConnector.cx = width;
3236 mpDrv->IConnector.cy = height;
3237 }
3238 else
3239 {
3240 /* black hole */
3241 mpDrv->IConnector.pu8Data = NULL;
3242 mpDrv->IConnector.cbScanline = 0;
3243 mpDrv->IConnector.cBits = 0;
3244 mpDrv->IConnector.cx = 0;
3245 mpDrv->IConnector.cy = 0;
3246 }
3247 LogRelFlowFunc(("leave\n"));
3248}
3249
3250#ifdef VBOX_WITH_CRHGSMI
3251void Display::setupCrHgsmiData(void)
3252{
3253 VMMDev *pVMMDev = mParent->getVMMDev();
3254 Assert(pVMMDev);
3255 int rc = VERR_GENERAL_FAILURE;
3256 if (pVMMDev)
3257 rc = pVMMDev->hgcmHostSvcHandleCreate("VBoxSharedCrOpenGL", &mhCrOglSvc);
3258
3259 if (RT_SUCCESS(rc))
3260 {
3261 Assert(mhCrOglSvc);
3262 /* setup command completion callback */
3263 VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_COMPLETION Completion;
3264 Completion.Hdr.enmType = VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION;
3265 Completion.Hdr.cbCmd = sizeof (Completion);
3266 Completion.hCompletion = mpDrv->pVBVACallbacks;
3267 Completion.pfnCompletion = mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync;
3268
3269 VBOXHGCMSVCPARM parm;
3270 parm.type = VBOX_HGCM_SVC_PARM_PTR;
3271 parm.u.pointer.addr = &Completion;
3272 parm.u.pointer.size = 0;
3273
3274 rc = pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_CRHGSMI_CTL, 1, &parm);
3275 if (RT_SUCCESS(rc))
3276 return;
3277
3278 AssertMsgFailed(("VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_COMPLETION failed rc %d", rc));
3279 }
3280
3281 mhCrOglSvc = NULL;
3282}
3283
3284void Display::destructCrHgsmiData(void)
3285{
3286 mhCrOglSvc = NULL;
3287}
3288#endif
3289
3290/**
3291 * Changes the current frame buffer. Called on EMT to avoid both
3292 * race conditions and excessive locking.
3293 *
3294 * @note locks this object for writing
3295 * @thread EMT
3296 */
3297/* static */
3298DECLCALLBACK(int) Display::changeFramebuffer (Display *that, IFramebuffer *aFB,
3299 unsigned uScreenId)
3300{
3301 LogRelFlowFunc(("uScreenId = %d\n", uScreenId));
3302
3303 AssertReturn(that, VERR_INVALID_PARAMETER);
3304 AssertReturn(uScreenId < that->mcMonitors, VERR_INVALID_PARAMETER);
3305
3306 AutoCaller autoCaller(that);
3307 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3308
3309 AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
3310
3311 DISPLAYFBINFO *pDisplayFBInfo = &that->maFramebuffers[uScreenId];
3312 pDisplayFBInfo->pFramebuffer = aFB;
3313
3314 that->mParent->consoleVRDPServer()->SendResize ();
3315
3316 /* The driver might not have been constructed yet */
3317 if (that->mpDrv)
3318 {
3319 /* Setup the new framebuffer, the resize will lead to an updateDisplayData call. */
3320 DISPLAYFBINFO *pFBInfo = &that->maFramebuffers[uScreenId];
3321
3322#if defined(VBOX_WITH_CROGL)
3323 /* Release the lock, because SHCRGL_HOST_FN_SCREEN_CHANGED will read current framebuffer */
3324 {
3325 BOOL is3denabled;
3326 that->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
3327
3328 if (is3denabled)
3329 {
3330 alock.release();
3331 }
3332 }
3333#endif
3334
3335 if (pFBInfo->fVBVAEnabled && pFBInfo->pu8FramebufferVRAM)
3336 {
3337 /* This display in VBVA mode. Resize it to the last guest resolution,
3338 * if it has been reported.
3339 */
3340 that->handleDisplayResize(uScreenId, pFBInfo->u16BitsPerPixel,
3341 pFBInfo->pu8FramebufferVRAM,
3342 pFBInfo->u32LineSize,
3343 pFBInfo->w,
3344 pFBInfo->h,
3345 pFBInfo->flags);
3346 }
3347 else if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3348 {
3349 /* VGA device mode, only for the primary screen. */
3350 that->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, that->mLastBitsPerPixel,
3351 that->mLastAddress,
3352 that->mLastBytesPerLine,
3353 that->mLastWidth,
3354 that->mLastHeight,
3355 that->mLastFlags);
3356 }
3357 }
3358
3359 LogRelFlowFunc(("leave\n"));
3360 return VINF_SUCCESS;
3361}
3362
3363/**
3364 * Handle display resize event issued by the VGA device for the primary screen.
3365 *
3366 * @see PDMIDISPLAYCONNECTOR::pfnResize
3367 */
3368DECLCALLBACK(int) Display::displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
3369 uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
3370{
3371 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3372
3373 LogRelFlowFunc(("bpp %d, pvVRAM %p, cbLine %d, cx %d, cy %d\n",
3374 bpp, pvVRAM, cbLine, cx, cy));
3375
3376 return pDrv->pDisplay->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
3377}
3378
3379/**
3380 * Handle display update.
3381 *
3382 * @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
3383 */
3384DECLCALLBACK(void) Display::displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
3385 uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
3386{
3387 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3388
3389#ifdef DEBUG_sunlover
3390 LogFlowFunc(("mfVideoAccelEnabled = %d, %d,%d %dx%d\n",
3391 pDrv->pDisplay->mfVideoAccelEnabled, x, y, cx, cy));
3392#endif /* DEBUG_sunlover */
3393
3394 /* This call does update regardless of VBVA status.
3395 * But in VBVA mode this is called only as result of
3396 * pfnUpdateDisplayAll in the VGA device.
3397 */
3398
3399 pDrv->pDisplay->handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
3400}
3401
3402/**
3403 * Periodic display refresh callback.
3404 *
3405 * @see PDMIDISPLAYCONNECTOR::pfnRefresh
3406 * @thread EMT
3407 */
3408DECLCALLBACK(void) Display::displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
3409{
3410 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3411
3412#ifdef DEBUG_sunlover
3413 STAM_PROFILE_START(&g_StatDisplayRefresh, a);
3414#endif /* DEBUG_sunlover */
3415
3416#ifdef DEBUG_sunlover_2
3417 LogFlowFunc(("pDrv->pDisplay->mfVideoAccelEnabled = %d\n",
3418 pDrv->pDisplay->mfVideoAccelEnabled));
3419#endif /* DEBUG_sunlover_2 */
3420
3421 Display *pDisplay = pDrv->pDisplay;
3422 bool fNoUpdate = false; /* Do not update the display if any of the framebuffers is being resized. */
3423 unsigned uScreenId;
3424
3425 Log2(("DisplayRefreshCallback\n"));
3426 for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3427 {
3428 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3429
3430 /* Check the resize status. The status can be checked normally because
3431 * the status affects only the EMT.
3432 */
3433 uint32_t u32ResizeStatus = pFBInfo->u32ResizeStatus;
3434
3435 if (u32ResizeStatus == ResizeStatus_UpdateDisplayData)
3436 {
3437 LogRelFlowFunc(("ResizeStatus_UpdateDisplayData %d\n", uScreenId));
3438 fNoUpdate = true; /* Always set it here, because pfnUpdateDisplayAll can cause a new resize. */
3439 /* The framebuffer was resized and display data need to be updated. */
3440 pDisplay->handleResizeCompletedEMT ();
3441 if (pFBInfo->u32ResizeStatus != ResizeStatus_Void)
3442 {
3443 /* The resize status could be not Void here because a pending resize is issued. */
3444 continue;
3445 }
3446 /* Continue with normal processing because the status here is ResizeStatus_Void.
3447 * Repaint all displays because VM continued to run during the framebuffer resize.
3448 */
3449 pDisplay->InvalidateAndUpdateEMT(pDisplay, uScreenId, false);
3450 }
3451 else if (u32ResizeStatus == ResizeStatus_InProgress)
3452 {
3453 /* The framebuffer is being resized. Do not call the VGA device back. Immediately return. */
3454 LogRelFlowFunc(("ResizeStatus_InProcess\n"));
3455 fNoUpdate = true;
3456 continue;
3457 }
3458 }
3459
3460 if (!fNoUpdate)
3461 {
3462 int rc = pDisplay->videoAccelRefreshProcess();
3463 if (rc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
3464 {
3465 if (rc == VWRN_INVALID_STATE)
3466 {
3467 /* No VBVA do a display update. */
3468 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN];
3469 if (!pFBInfo->pFramebuffer.isNull() && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
3470 {
3471 Assert(pDrv->IConnector.pu8Data);
3472 pDisplay->vbvaLock();
3473 pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
3474 pDisplay->vbvaUnlock();
3475 }
3476 }
3477
3478 /* Inform the VRDP server that the current display update sequence is
3479 * completed. At this moment the framebuffer memory contains a definite
3480 * image, that is synchronized with the orders already sent to VRDP client.
3481 * The server can now process redraw requests from clients or initial
3482 * fullscreen updates for new clients.
3483 */
3484 for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3485 {
3486 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3487
3488 if (!pFBInfo->pFramebuffer.isNull() && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
3489 {
3490 Assert (pDisplay->mParent && pDisplay->mParent->consoleVRDPServer());
3491 pDisplay->mParent->consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
3492 }
3493 }
3494 }
3495 }
3496
3497#ifdef VBOX_WITH_VPX
3498 if (VideoRecIsEnabled(pDisplay->mpVideoRecCtx))
3499 {
3500 uint64_t u64Now = RTTimeProgramMilliTS();
3501 for (uScreenId = 0; uScreenId < pDisplay->mcMonitors; uScreenId++)
3502 {
3503 if (!pDisplay->maVideoRecEnabled[uScreenId])
3504 continue;
3505
3506 DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
3507
3508 if ( !pFBInfo->pFramebuffer.isNull()
3509 && !pFBInfo->fDisabled
3510 && pFBInfo->u32ResizeStatus == ResizeStatus_Void)
3511 {
3512 int rc;
3513 if ( pFBInfo->fVBVAEnabled
3514 && pFBInfo->pu8FramebufferVRAM)
3515 {
3516 rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3517 FramebufferPixelFormat_FOURCC_RGB,
3518 pFBInfo->u16BitsPerPixel,
3519 pFBInfo->u32LineSize, pFBInfo->w, pFBInfo->h,
3520 pFBInfo->pu8FramebufferVRAM, u64Now);
3521 }
3522 else
3523 {
3524 rc = VideoRecCopyToIntBuf(pDisplay->mpVideoRecCtx, uScreenId, 0, 0,
3525 FramebufferPixelFormat_FOURCC_RGB,
3526 pDrv->IConnector.cBits,
3527 pDrv->IConnector.cbScanline, pDrv->IConnector.cx,
3528 pDrv->IConnector.cy, pDrv->IConnector.pu8Data, u64Now);
3529 }
3530 if (rc == VINF_TRY_AGAIN)
3531 break;
3532 }
3533 }
3534 }
3535#endif
3536
3537#ifdef DEBUG_sunlover
3538 STAM_PROFILE_STOP(&g_StatDisplayRefresh, a);
3539#endif /* DEBUG_sunlover */
3540#ifdef DEBUG_sunlover_2
3541 LogFlowFunc(("leave\n"));
3542#endif /* DEBUG_sunlover_2 */
3543}
3544
3545/**
3546 * Reset notification
3547 *
3548 * @see PDMIDISPLAYCONNECTOR::pfnReset
3549 */
3550DECLCALLBACK(void) Display::displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
3551{
3552 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3553
3554 LogRelFlowFunc(("\n"));
3555
3556 /* Disable VBVA mode. */
3557 pDrv->pDisplay->VideoAccelEnable (false, NULL);
3558}
3559
3560/**
3561 * LFBModeChange notification
3562 *
3563 * @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
3564 */
3565DECLCALLBACK(void) Display::displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
3566{
3567 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3568
3569 LogRelFlowFunc(("fEnabled=%d\n", fEnabled));
3570
3571 NOREF(fEnabled);
3572
3573 /* Disable VBVA mode in any case. The guest driver reenables VBVA mode if necessary. */
3574 /* The LFBModeChange function is called under DevVGA lock. Postpone disabling VBVA, do it in the refresh timer. */
3575 ASMAtomicWriteU32(&pDrv->pDisplay->mfu32PendingVideoAccelDisable, true);
3576}
3577
3578/**
3579 * Adapter information change notification.
3580 *
3581 * @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
3582 */
3583DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize)
3584{
3585 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3586
3587 if (pvVRAM == NULL)
3588 {
3589 unsigned i;
3590 for (i = 0; i < pDrv->pDisplay->mcMonitors; i++)
3591 {
3592 DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[i];
3593
3594 pFBInfo->u32Offset = 0;
3595 pFBInfo->u32MaxFramebufferSize = 0;
3596 pFBInfo->u32InformationSize = 0;
3597 }
3598 }
3599#ifndef VBOX_WITH_HGSMI
3600 else
3601 {
3602 uint8_t *pu8 = (uint8_t *)pvVRAM;
3603 pu8 += u32VRAMSize - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3604
3605 // @todo
3606 uint8_t *pu8End = pu8 + VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
3607
3608 VBOXVIDEOINFOHDR *pHdr;
3609
3610 for (;;)
3611 {
3612 pHdr = (VBOXVIDEOINFOHDR *)pu8;
3613 pu8 += sizeof (VBOXVIDEOINFOHDR);
3614
3615 if (pu8 >= pu8End)
3616 {
3617 LogRel(("VBoxVideo: Guest adapter information overflow!!!\n"));
3618 break;
3619 }
3620
3621 if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
3622 {
3623 if (pHdr->u16Length != sizeof (VBOXVIDEOINFODISPLAY))
3624 {
3625 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
3626 break;
3627 }
3628
3629 VBOXVIDEOINFODISPLAY *pDisplay = (VBOXVIDEOINFODISPLAY *)pu8;
3630
3631 if (pDisplay->u32Index >= pDrv->pDisplay->mcMonitors)
3632 {
3633 LogRel(("VBoxVideo: Guest adapter information invalid display index %d!!!\n", pDisplay->u32Index));
3634 break;
3635 }
3636
3637 DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[pDisplay->u32Index];
3638
3639 pFBInfo->u32Offset = pDisplay->u32Offset;
3640 pFBInfo->u32MaxFramebufferSize = pDisplay->u32FramebufferSize;
3641 pFBInfo->u32InformationSize = pDisplay->u32InformationSize;
3642
3643 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));
3644 }
3645 else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
3646 {
3647 if (pHdr->u16Length != sizeof (VBOXVIDEOINFOQUERYCONF32))
3648 {
3649 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
3650 break;
3651 }
3652
3653 VBOXVIDEOINFOQUERYCONF32 *pConf32 = (VBOXVIDEOINFOQUERYCONF32 *)pu8;
3654
3655 switch (pConf32->u32Index)
3656 {
3657 case VBOX_VIDEO_QCI32_MONITOR_COUNT:
3658 {
3659 pConf32->u32Value = pDrv->pDisplay->mcMonitors;
3660 } break;
3661
3662 case VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE:
3663 {
3664 /* @todo make configurable. */
3665 pConf32->u32Value = _1M;
3666 } break;
3667
3668 default:
3669 LogRel(("VBoxVideo: CONF32 %d not supported!!! Skipping.\n", pConf32->u32Index));
3670 }
3671 }
3672 else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
3673 {
3674 if (pHdr->u16Length != 0)
3675 {
3676 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
3677 break;
3678 }
3679
3680 break;
3681 }
3682 else if (pHdr->u8Type != VBOX_VIDEO_INFO_TYPE_NV_HEAP) /** @todo why is Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp pushing this to us? */
3683 {
3684 LogRel(("Guest adapter information contains unsupported type %d. The block has been skipped.\n", pHdr->u8Type));
3685 }
3686
3687 pu8 += pHdr->u16Length;
3688 }
3689 }
3690#endif /* !VBOX_WITH_HGSMI */
3691}
3692
3693/**
3694 * Display information change notification.
3695 *
3696 * @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
3697 */
3698DECLCALLBACK(void) Display::displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId)
3699{
3700 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3701
3702 if (uScreenId >= pDrv->pDisplay->mcMonitors)
3703 {
3704 LogRel(("VBoxVideo: Guest display information invalid display index %d!!!\n", uScreenId));
3705 return;
3706 }
3707
3708 /* Get the display information structure. */
3709 DISPLAYFBINFO *pFBInfo = &pDrv->pDisplay->maFramebuffers[uScreenId];
3710
3711 uint8_t *pu8 = (uint8_t *)pvVRAM;
3712 pu8 += pFBInfo->u32Offset + pFBInfo->u32MaxFramebufferSize;
3713
3714 // @todo
3715 uint8_t *pu8End = pu8 + pFBInfo->u32InformationSize;
3716
3717 VBOXVIDEOINFOHDR *pHdr;
3718
3719 for (;;)
3720 {
3721 pHdr = (VBOXVIDEOINFOHDR *)pu8;
3722 pu8 += sizeof (VBOXVIDEOINFOHDR);
3723
3724 if (pu8 >= pu8End)
3725 {
3726 LogRel(("VBoxVideo: Guest display information overflow!!!\n"));
3727 break;
3728 }
3729
3730 if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
3731 {
3732 if (pHdr->u16Length != sizeof (VBOXVIDEOINFOSCREEN))
3733 {
3734 LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
3735 break;
3736 }
3737
3738 VBOXVIDEOINFOSCREEN *pScreen = (VBOXVIDEOINFOSCREEN *)pu8;
3739
3740 pFBInfo->xOrigin = pScreen->xOrigin;
3741 pFBInfo->yOrigin = pScreen->yOrigin;
3742
3743 pFBInfo->w = pScreen->u16Width;
3744 pFBInfo->h = pScreen->u16Height;
3745
3746 LogRelFlow(("VBOX_VIDEO_INFO_TYPE_SCREEN: (%p) %d: at %d,%d, linesize 0x%X, size %dx%d, bpp %d, flags 0x%02X\n",
3747 pHdr, uScreenId, pScreen->xOrigin, pScreen->yOrigin, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, pScreen->bitsPerPixel, pScreen->u8Flags));
3748
3749 if (uScreenId != VBOX_VIDEO_PRIMARY_SCREEN)
3750 {
3751 /* Primary screen resize is eeeeeeeee by the VGA device. */
3752 if (pFBInfo->fDisabled)
3753 {
3754 pFBInfo->fDisabled = false;
3755 fireGuestMonitorChangedEvent(pDrv->pDisplay->mParent->getEventSource(),
3756 GuestMonitorChangedEventType_Enabled,
3757 uScreenId,
3758 pFBInfo->xOrigin, pFBInfo->yOrigin,
3759 pFBInfo->w, pFBInfo->h);
3760 }
3761
3762 pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel, (uint8_t *)pvVRAM + pFBInfo->u32Offset, pScreen->u32LineSize, pScreen->u16Width, pScreen->u16Height, VBVA_SCREEN_F_ACTIVE);
3763 }
3764 }
3765 else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_END)
3766 {
3767 if (pHdr->u16Length != 0)
3768 {
3769 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "END", pHdr->u16Length));
3770 break;
3771 }
3772
3773 break;
3774 }
3775 else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
3776 {
3777 if (pHdr->u16Length != sizeof (VBOXVIDEOINFOHOSTEVENTS))
3778 {
3779 LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
3780 break;
3781 }
3782
3783 VBOXVIDEOINFOHOSTEVENTS *pHostEvents = (VBOXVIDEOINFOHOSTEVENTS *)pu8;
3784
3785 pFBInfo->pHostEvents = pHostEvents;
3786
3787 LogFlow(("VBOX_VIDEO_INFO_TYPE_HOSTEVENTS: (%p)\n",
3788 pHostEvents));
3789 }
3790 else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
3791 {
3792 if (pHdr->u16Length != sizeof (VBOXVIDEOINFOLINK))
3793 {
3794 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
3795 break;
3796 }
3797
3798 VBOXVIDEOINFOLINK *pLink = (VBOXVIDEOINFOLINK *)pu8;
3799 pu8 += pLink->i32Offset;
3800 }
3801 else
3802 {
3803 LogRel(("Guest display information contains unsupported type %d\n", pHdr->u8Type));
3804 }
3805
3806 pu8 += pHdr->u16Length;
3807 }
3808}
3809
3810#ifdef VBOX_WITH_VIDEOHWACCEL
3811
3812void Display::handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
3813{
3814 unsigned id = (unsigned)pCommand->iDisplay;
3815 int rc = VINF_SUCCESS;
3816 if (id < mcMonitors)
3817 {
3818 IFramebuffer *pFramebuffer = maFramebuffers[id].pFramebuffer;
3819#ifdef DEBUG_misha
3820 Assert (pFramebuffer);
3821#endif
3822
3823 if (pFramebuffer != NULL)
3824 {
3825 HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
3826 if (FAILED(hr))
3827 {
3828 rc = (hr == E_NOTIMPL) ? VERR_NOT_IMPLEMENTED : VERR_GENERAL_FAILURE;
3829 }
3830 }
3831 else
3832 {
3833 rc = VERR_NOT_IMPLEMENTED;
3834 }
3835 }
3836 else
3837 {
3838 rc = VERR_INVALID_PARAMETER;
3839 }
3840
3841 if (RT_FAILURE(rc))
3842 {
3843 /* tell the guest the command is complete */
3844 pCommand->Flags &= (~VBOXVHWACMD_FLAG_HG_ASYNCH);
3845 pCommand->rc = rc;
3846 }
3847}
3848
3849DECLCALLBACK(void) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
3850{
3851 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3852
3853 pDrv->pDisplay->handleVHWACommandProcess(pInterface, pCommand);
3854}
3855#endif
3856
3857#ifdef VBOX_WITH_CRHGSMI
3858void Display::handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3859{
3860 mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CMD)pParam->u.pointer.addr, result);
3861}
3862
3863void Display::handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
3864{
3865 mpDrv->pVBVACallbacks->pfnCrHgsmiControlCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr, result);
3866}
3867
3868void Display::handleCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
3869{
3870 int rc = VERR_INVALID_FUNCTION;
3871 VBOXHGCMSVCPARM parm;
3872 parm.type = VBOX_HGCM_SVC_PARM_PTR;
3873 parm.u.pointer.addr = pCmd;
3874 parm.u.pointer.size = cbCmd;
3875
3876 if (mhCrOglSvc)
3877 {
3878 VMMDev *pVMMDev = mParent->getVMMDev();
3879 if (pVMMDev)
3880 {
3881 /* no completion callback is specified with this call,
3882 * the CrOgl code will complete the CrHgsmi command once it processes it */
3883 rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm, NULL, NULL);
3884 AssertRC(rc);
3885 if (RT_SUCCESS(rc))
3886 return;
3887 }
3888 else
3889 rc = VERR_INVALID_STATE;
3890 }
3891
3892 /* we are here because something went wrong with command processing, complete it */
3893 handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
3894}
3895
3896void Display::handleCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
3897{
3898 int rc = VERR_INVALID_FUNCTION;
3899 VBOXHGCMSVCPARM parm;
3900 parm.type = VBOX_HGCM_SVC_PARM_PTR;
3901 parm.u.pointer.addr = pCtl;
3902 parm.u.pointer.size = cbCtl;
3903
3904 if (mhCrOglSvc)
3905 {
3906 VMMDev *pVMMDev = mParent->getVMMDev();
3907 if (pVMMDev)
3908 {
3909 rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm, Display::displayCrHgsmiControlCompletion, this);
3910 AssertRC(rc);
3911 if (RT_SUCCESS(rc))
3912 return;
3913 }
3914 else
3915 rc = VERR_INVALID_STATE;
3916 }
3917
3918 /* we are here because something went wrong with command processing, complete it */
3919 handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
3920}
3921
3922
3923DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
3924{
3925 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3926
3927 pDrv->pDisplay->handleCrHgsmiCommandProcess(pInterface, pCmd, cbCmd);
3928}
3929
3930DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, uint32_t cbCmd)
3931{
3932 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3933
3934 pDrv->pDisplay->handleCrHgsmiControlProcess(pInterface, pCmd, cbCmd);
3935}
3936
3937DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
3938{
3939 AssertMsgFailed(("not expected!"));
3940 Display *pDisplay = (Display *)pvContext;
3941 pDisplay->handleCrHgsmiCommandCompletion(result, u32Function, pParam);
3942}
3943
3944DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
3945{
3946 Display *pDisplay = (Display *)pvContext;
3947 pDisplay->handleCrHgsmiControlCompletion(result, u32Function, pParam);
3948}
3949#endif
3950
3951
3952#ifdef VBOX_WITH_HGSMI
3953DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags)
3954{
3955 LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3956
3957 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3958 Display *pThis = pDrv->pDisplay;
3959
3960 pThis->maFramebuffers[uScreenId].fVBVAEnabled = true;
3961 pThis->maFramebuffers[uScreenId].pVBVAHostFlags = pHostFlags;
3962
3963 vbvaSetMemoryFlagsHGSMI(uScreenId, pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, &pThis->maFramebuffers[uScreenId]);
3964
3965 return VINF_SUCCESS;
3966}
3967
3968DECLCALLBACK(void) Display::displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
3969{
3970 LogRelFlowFunc(("uScreenId %d\n", uScreenId));
3971
3972 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
3973 Display *pThis = pDrv->pDisplay;
3974
3975 DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
3976
3977 if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
3978 {
3979 /* Make sure that the primary screen is visible now.
3980 * The guest can't use VBVA anymore, so only only the VGA device output works.
3981 */
3982 if (pFBInfo->fDisabled)
3983 {
3984 pFBInfo->fDisabled = false;
3985 fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
3986 GuestMonitorChangedEventType_Enabled,
3987 uScreenId,
3988 pFBInfo->xOrigin, pFBInfo->yOrigin,
3989 pFBInfo->w, pFBInfo->h);
3990 }
3991 }
3992
3993 pFBInfo->fVBVAEnabled = false;
3994
3995 vbvaSetMemoryFlagsHGSMI(uScreenId, 0, false, pFBInfo);
3996
3997 pFBInfo->pVBVAHostFlags = NULL;
3998
3999 pFBInfo->u32Offset = 0; /* Not used in HGSMI. */
4000 pFBInfo->u32MaxFramebufferSize = 0; /* Not used in HGSMI. */
4001 pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
4002
4003 pFBInfo->xOrigin = 0;
4004 pFBInfo->yOrigin = 0;
4005
4006 pFBInfo->w = 0;
4007 pFBInfo->h = 0;
4008
4009 pFBInfo->u16BitsPerPixel = 0;
4010 pFBInfo->pu8FramebufferVRAM = NULL;
4011 pFBInfo->u32LineSize = 0;
4012}
4013
4014DECLCALLBACK(void) Display::displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
4015{
4016 LogFlowFunc(("uScreenId %d\n", uScreenId));
4017
4018 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4019 Display *pThis = pDrv->pDisplay;
4020 DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4021
4022 if (ASMAtomicReadU32(&pThis->mu32UpdateVBVAFlags) > 0)
4023 {
4024 vbvaSetMemoryFlagsAllHGSMI(pThis->mfu32SupportedOrders, pThis->mfVideoAccelVRDP, pThis->maFramebuffers, pThis->mcMonitors);
4025 ASMAtomicDecU32(&pThis->mu32UpdateVBVAFlags);
4026 }
4027
4028 if (RT_LIKELY(pFBInfo->u32ResizeStatus == ResizeStatus_Void))
4029 {
4030 if (RT_UNLIKELY(pFBInfo->cVBVASkipUpdate != 0))
4031 {
4032 /* Some updates were skipped. Note: displayVBVAUpdate* callbacks are called
4033 * under display device lock, so thread safe.
4034 */
4035 pFBInfo->cVBVASkipUpdate = 0;
4036 pThis->handleDisplayUpdate(uScreenId, pFBInfo->vbvaSkippedRect.xLeft - pFBInfo->xOrigin,
4037 pFBInfo->vbvaSkippedRect.yTop - pFBInfo->yOrigin,
4038 pFBInfo->vbvaSkippedRect.xRight - pFBInfo->vbvaSkippedRect.xLeft,
4039 pFBInfo->vbvaSkippedRect.yBottom - pFBInfo->vbvaSkippedRect.yTop);
4040 }
4041 }
4042 else
4043 {
4044 /* The framebuffer is being resized. */
4045 pFBInfo->cVBVASkipUpdate++;
4046 }
4047}
4048
4049DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd)
4050{
4051 LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
4052
4053 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4054 Display *pThis = pDrv->pDisplay;
4055 DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4056
4057 if (RT_LIKELY(pFBInfo->cVBVASkipUpdate == 0))
4058 {
4059 if (pFBInfo->fDefaultFormat)
4060 {
4061 /* Make sure that framebuffer contains the same image as the guest VRAM. */
4062 if ( uScreenId == VBOX_VIDEO_PRIMARY_SCREEN
4063 && !pFBInfo->pFramebuffer.isNull()
4064 && !pFBInfo->fDisabled)
4065 {
4066 pDrv->pUpPort->pfnUpdateDisplayRect (pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
4067 }
4068 else if ( !pFBInfo->pFramebuffer.isNull()
4069 && !pFBInfo->fDisabled)
4070 {
4071 /* Render VRAM content to the framebuffer. */
4072 BYTE *address = NULL;
4073 HRESULT hrc = pFBInfo->pFramebuffer->COMGETTER(Address) (&address);
4074 if (SUCCEEDED(hrc) && address != NULL)
4075 {
4076 uint32_t width = pCmd->w;
4077 uint32_t height = pCmd->h;
4078
4079 const uint8_t *pu8Src = pFBInfo->pu8FramebufferVRAM;
4080 int32_t xSrc = pCmd->x - pFBInfo->xOrigin;
4081 int32_t ySrc = pCmd->y - pFBInfo->yOrigin;
4082 uint32_t u32SrcWidth = pFBInfo->w;
4083 uint32_t u32SrcHeight = pFBInfo->h;
4084 uint32_t u32SrcLineSize = pFBInfo->u32LineSize;
4085 uint32_t u32SrcBitsPerPixel = pFBInfo->u16BitsPerPixel;
4086
4087 uint8_t *pu8Dst = address;
4088 int32_t xDst = xSrc;
4089 int32_t yDst = ySrc;
4090 uint32_t u32DstWidth = u32SrcWidth;
4091 uint32_t u32DstHeight = u32SrcHeight;
4092 uint32_t u32DstLineSize = u32DstWidth * 4;
4093 uint32_t u32DstBitsPerPixel = 32;
4094
4095 pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
4096 width, height,
4097 pu8Src,
4098 xSrc, ySrc,
4099 u32SrcWidth, u32SrcHeight,
4100 u32SrcLineSize, u32SrcBitsPerPixel,
4101 pu8Dst,
4102 xDst, yDst,
4103 u32DstWidth, u32DstHeight,
4104 u32DstLineSize, u32DstBitsPerPixel);
4105 }
4106 }
4107 }
4108
4109 VBVACMDHDR hdrSaved = *pCmd;
4110
4111 VBVACMDHDR *pHdrUnconst = (VBVACMDHDR *)pCmd;
4112
4113 pHdrUnconst->x -= (int16_t)pFBInfo->xOrigin;
4114 pHdrUnconst->y -= (int16_t)pFBInfo->yOrigin;
4115
4116 /* @todo new SendUpdate entry which can get a separate cmd header or coords. */
4117 pThis->mParent->consoleVRDPServer()->SendUpdate (uScreenId, pCmd, (uint32_t)cbCmd);
4118
4119 *pHdrUnconst = hdrSaved;
4120 }
4121}
4122
4123DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy)
4124{
4125 LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
4126
4127 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4128 Display *pThis = pDrv->pDisplay;
4129 DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[uScreenId];
4130
4131 /* @todo handleFramebufferUpdate (uScreenId,
4132 * x - pThis->maFramebuffers[uScreenId].xOrigin,
4133 * y - pThis->maFramebuffers[uScreenId].yOrigin,
4134 * cx, cy);
4135 */
4136 if (RT_LIKELY(pFBInfo->cVBVASkipUpdate == 0))
4137 {
4138 pThis->handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
4139 }
4140 else
4141 {
4142 /* Save the updated rectangle. */
4143 int32_t xRight = x + cx;
4144 int32_t yBottom = y + cy;
4145
4146 if (pFBInfo->cVBVASkipUpdate == 1)
4147 {
4148 pFBInfo->vbvaSkippedRect.xLeft = x;
4149 pFBInfo->vbvaSkippedRect.yTop = y;
4150 pFBInfo->vbvaSkippedRect.xRight = xRight;
4151 pFBInfo->vbvaSkippedRect.yBottom = yBottom;
4152 }
4153 else
4154 {
4155 if (pFBInfo->vbvaSkippedRect.xLeft > x)
4156 {
4157 pFBInfo->vbvaSkippedRect.xLeft = x;
4158 }
4159 if (pFBInfo->vbvaSkippedRect.yTop > y)
4160 {
4161 pFBInfo->vbvaSkippedRect.yTop = y;
4162 }
4163 if (pFBInfo->vbvaSkippedRect.xRight < xRight)
4164 {
4165 pFBInfo->vbvaSkippedRect.xRight = xRight;
4166 }
4167 if (pFBInfo->vbvaSkippedRect.yBottom < yBottom)
4168 {
4169 pFBInfo->vbvaSkippedRect.yBottom = yBottom;
4170 }
4171 }
4172 }
4173}
4174
4175#ifdef DEBUG_sunlover
4176static void logVBVAResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, const DISPLAYFBINFO *pFBInfo)
4177{
4178 LogRel(("displayVBVAResize: [%d] %s\n"
4179 " pView->u32ViewIndex %d\n"
4180 " pView->u32ViewOffset 0x%08X\n"
4181 " pView->u32ViewSize 0x%08X\n"
4182 " pView->u32MaxScreenSize 0x%08X\n"
4183 " pScreen->i32OriginX %d\n"
4184 " pScreen->i32OriginY %d\n"
4185 " pScreen->u32StartOffset 0x%08X\n"
4186 " pScreen->u32LineSize 0x%08X\n"
4187 " pScreen->u32Width %d\n"
4188 " pScreen->u32Height %d\n"
4189 " pScreen->u16BitsPerPixel %d\n"
4190 " pScreen->u16Flags 0x%04X\n"
4191 " pFBInfo->u32Offset 0x%08X\n"
4192 " pFBInfo->u32MaxFramebufferSize 0x%08X\n"
4193 " pFBInfo->u32InformationSize 0x%08X\n"
4194 " pFBInfo->fDisabled %d\n"
4195 " xOrigin, yOrigin, w, h: %d,%d %dx%d\n"
4196 " pFBInfo->u16BitsPerPixel %d\n"
4197 " pFBInfo->pu8FramebufferVRAM %p\n"
4198 " pFBInfo->u32LineSize 0x%08X\n"
4199 " pFBInfo->flags 0x%04X\n"
4200 " pFBInfo->pHostEvents %p\n"
4201 " pFBInfo->u32ResizeStatus %d\n"
4202 " pFBInfo->fDefaultFormat %d\n"
4203 " dirtyRect %d-%d %d-%d\n"
4204 " pFBInfo->pendingResize.fPending %d\n"
4205 " pFBInfo->pendingResize.pixelFormat %d\n"
4206 " pFBInfo->pendingResize.pvVRAM %p\n"
4207 " pFBInfo->pendingResize.bpp %d\n"
4208 " pFBInfo->pendingResize.cbLine 0x%08X\n"
4209 " pFBInfo->pendingResize.w,h %dx%d\n"
4210 " pFBInfo->pendingResize.flags 0x%04X\n"
4211 " pFBInfo->fVBVAEnabled %d\n"
4212 " pFBInfo->cVBVASkipUpdate %d\n"
4213 " pFBInfo->vbvaSkippedRect %d-%d %d-%d\n"
4214 " pFBInfo->pVBVAHostFlags %p\n"
4215 "",
4216 pScreen->u32ViewIndex,
4217 (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)? "DISABLED": "ENABLED",
4218 pView->u32ViewIndex,
4219 pView->u32ViewOffset,
4220 pView->u32ViewSize,
4221 pView->u32MaxScreenSize,
4222 pScreen->i32OriginX,
4223 pScreen->i32OriginY,
4224 pScreen->u32StartOffset,
4225 pScreen->u32LineSize,
4226 pScreen->u32Width,
4227 pScreen->u32Height,
4228 pScreen->u16BitsPerPixel,
4229 pScreen->u16Flags,
4230 pFBInfo->u32Offset,
4231 pFBInfo->u32MaxFramebufferSize,
4232 pFBInfo->u32InformationSize,
4233 pFBInfo->fDisabled,
4234 pFBInfo->xOrigin,
4235 pFBInfo->yOrigin,
4236 pFBInfo->w,
4237 pFBInfo->h,
4238 pFBInfo->u16BitsPerPixel,
4239 pFBInfo->pu8FramebufferVRAM,
4240 pFBInfo->u32LineSize,
4241 pFBInfo->flags,
4242 pFBInfo->pHostEvents,
4243 pFBInfo->u32ResizeStatus,
4244 pFBInfo->fDefaultFormat,
4245 pFBInfo->dirtyRect.xLeft,
4246 pFBInfo->dirtyRect.xRight,
4247 pFBInfo->dirtyRect.yTop,
4248 pFBInfo->dirtyRect.yBottom,
4249 pFBInfo->pendingResize.fPending,
4250 pFBInfo->pendingResize.pixelFormat,
4251 pFBInfo->pendingResize.pvVRAM,
4252 pFBInfo->pendingResize.bpp,
4253 pFBInfo->pendingResize.cbLine,
4254 pFBInfo->pendingResize.w,
4255 pFBInfo->pendingResize.h,
4256 pFBInfo->pendingResize.flags,
4257 pFBInfo->fVBVAEnabled,
4258 pFBInfo->cVBVASkipUpdate,
4259 pFBInfo->vbvaSkippedRect.xLeft,
4260 pFBInfo->vbvaSkippedRect.yTop,
4261 pFBInfo->vbvaSkippedRect.xRight,
4262 pFBInfo->vbvaSkippedRect.yBottom,
4263 pFBInfo->pVBVAHostFlags
4264 ));
4265}
4266#endif /* DEBUG_sunlover */
4267
4268DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
4269{
4270 LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
4271
4272 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4273 Display *pThis = pDrv->pDisplay;
4274
4275 DISPLAYFBINFO *pFBInfo = &pThis->maFramebuffers[pScreen->u32ViewIndex];
4276
4277 if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
4278 {
4279 pFBInfo->fDisabled = true;
4280 pFBInfo->flags = pScreen->u16Flags;
4281
4282 /* Ask the framebuffer to resize using a default format. The framebuffer will be black.
4283 * So if the frontend does not support GuestMonitorChangedEventType_Disabled event,
4284 * the VM window will be black. */
4285 uint32_t u32Width = pFBInfo->w ? pFBInfo->w : 640;
4286 uint32_t u32Height = pFBInfo->h ? pFBInfo->h : 480;
4287 pThis->handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
4288 u32Width, u32Height, pScreen->u16Flags);
4289
4290 fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
4291 GuestMonitorChangedEventType_Disabled,
4292 pScreen->u32ViewIndex,
4293 0, 0, 0, 0);
4294 return VINF_SUCCESS;
4295 }
4296
4297 /* If display was disabled or there is no framebuffer, a resize will be required,
4298 * because the framebuffer was/will be changed.
4299 */
4300 bool fResize = pFBInfo->fDisabled || pFBInfo->pFramebuffer.isNull();
4301
4302 if (pFBInfo->fDisabled)
4303 {
4304 pFBInfo->fDisabled = false;
4305 fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
4306 GuestMonitorChangedEventType_Enabled,
4307 pScreen->u32ViewIndex,
4308 pScreen->i32OriginX, pScreen->i32OriginY,
4309 pScreen->u32Width, pScreen->u32Height);
4310 /* Continue to update pFBInfo. */
4311 }
4312
4313 /* Check if this is a real resize or a notification about the screen origin.
4314 * The guest uses this VBVAResize call for both.
4315 */
4316 fResize = fResize
4317 || pFBInfo->u16BitsPerPixel != pScreen->u16BitsPerPixel
4318 || pFBInfo->pu8FramebufferVRAM != (uint8_t *)pvVRAM + pScreen->u32StartOffset
4319 || pFBInfo->u32LineSize != pScreen->u32LineSize
4320 || pFBInfo->w != pScreen->u32Width
4321 || pFBInfo->h != pScreen->u32Height;
4322
4323 bool fNewOrigin = pFBInfo->xOrigin != pScreen->i32OriginX
4324 || pFBInfo->yOrigin != pScreen->i32OriginY;
4325
4326 pFBInfo->u32Offset = pView->u32ViewOffset; /* Not used in HGSMI. */
4327 pFBInfo->u32MaxFramebufferSize = pView->u32MaxScreenSize; /* Not used in HGSMI. */
4328 pFBInfo->u32InformationSize = 0; /* Not used in HGSMI. */
4329
4330 pFBInfo->xOrigin = pScreen->i32OriginX;
4331 pFBInfo->yOrigin = pScreen->i32OriginY;
4332
4333 pFBInfo->w = pScreen->u32Width;
4334 pFBInfo->h = pScreen->u32Height;
4335
4336 pFBInfo->u16BitsPerPixel = pScreen->u16BitsPerPixel;
4337 pFBInfo->pu8FramebufferVRAM = (uint8_t *)pvVRAM + pScreen->u32StartOffset;
4338 pFBInfo->u32LineSize = pScreen->u32LineSize;
4339
4340 pFBInfo->flags = pScreen->u16Flags;
4341
4342 if (fNewOrigin)
4343 {
4344 fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
4345 GuestMonitorChangedEventType_NewOrigin,
4346 pScreen->u32ViewIndex,
4347 pScreen->i32OriginX, pScreen->i32OriginY,
4348 0, 0);
4349 }
4350
4351#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
4352 if (fNewOrigin && !fResize)
4353 {
4354 BOOL is3denabled;
4355 pThis->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
4356
4357 if (is3denabled)
4358 {
4359 VBOXHGCMSVCPARM parm;
4360
4361 parm.type = VBOX_HGCM_SVC_PARM_32BIT;
4362 parm.u.uint32 = pScreen->u32ViewIndex;
4363
4364 VMMDev *pVMMDev = pThis->mParent->getVMMDev();
4365
4366 if (pVMMDev)
4367 pVMMDev->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED, SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
4368 }
4369 }
4370#endif /* VBOX_WITH_CROGL */
4371
4372 if (!fResize)
4373 {
4374 /* No parameters of the framebuffer have actually changed. */
4375 if (fNewOrigin)
4376 {
4377 /* VRDP server still need this notification. */
4378 LogRelFlowFunc(("Calling VRDP\n"));
4379 pThis->mParent->consoleVRDPServer()->SendResize();
4380 }
4381 return VINF_SUCCESS;
4382 }
4383
4384 if (pFBInfo->pFramebuffer.isNull())
4385 {
4386 /* If no framebuffer, the resize will be done later when a new framebuffer will be set in changeFramebuffer. */
4387 return VINF_SUCCESS;
4388 }
4389
4390 /* If the framebuffer already set for the screen, do a regular resize. */
4391 return pThis->handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
4392 (uint8_t *)pvVRAM + pScreen->u32StartOffset,
4393 pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
4394}
4395
4396DECLCALLBACK(int) Display::displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
4397 uint32_t xHot, uint32_t yHot,
4398 uint32_t cx, uint32_t cy,
4399 const void *pvShape)
4400{
4401 LogFlowFunc(("\n"));
4402
4403 PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
4404 Display *pThis = pDrv->pDisplay;
4405
4406 size_t cbShapeSize = 0;
4407
4408 if (pvShape)
4409 {
4410 cbShapeSize = (cx + 7) / 8 * cy; /* size of the AND mask */
4411 cbShapeSize = ((cbShapeSize + 3) & ~3) + cx * 4 * cy; /* + gap + size of the XOR mask */
4412 }
4413 com::SafeArray<BYTE> shapeData(cbShapeSize);
4414
4415 if (pvShape)
4416 ::memcpy(shapeData.raw(), pvShape, cbShapeSize);
4417
4418 /* Tell the console about it */
4419 pDrv->pDisplay->mParent->onMousePointerShapeChange(fVisible, fAlpha,
4420 xHot, yHot, cx, cy, ComSafeArrayAsInParam(shapeData));
4421
4422 return VINF_SUCCESS;
4423}
4424#endif /* VBOX_WITH_HGSMI */
4425
4426/**
4427 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
4428 */
4429DECLCALLBACK(void *) Display::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
4430{
4431 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
4432 PDRVMAINDISPLAY pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4433 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
4434 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYCONNECTOR, &pDrv->IConnector);
4435 return NULL;
4436}
4437
4438
4439/**
4440 * Destruct a display driver instance.
4441 *
4442 * @returns VBox status.
4443 * @param pDrvIns The driver instance data.
4444 */
4445DECLCALLBACK(void) Display::drvDestruct(PPDMDRVINS pDrvIns)
4446{
4447 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
4448 PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4449 LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4450
4451 if (pThis->pDisplay)
4452 {
4453 AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
4454#ifdef VBOX_WITH_VPX
4455 pThis->pDisplay->VideoCaptureStop();
4456#endif
4457#ifdef VBOX_WITH_CRHGSMI
4458 pThis->pDisplay->destructCrHgsmiData();
4459#endif
4460 pThis->pDisplay->mpDrv = NULL;
4461 pThis->pDisplay->mpVMMDev = NULL;
4462 pThis->pDisplay->mLastAddress = NULL;
4463 pThis->pDisplay->mLastBytesPerLine = 0;
4464 pThis->pDisplay->mLastBitsPerPixel = 0,
4465 pThis->pDisplay->mLastWidth = 0;
4466 pThis->pDisplay->mLastHeight = 0;
4467 }
4468}
4469
4470
4471/**
4472 * Construct a display driver instance.
4473 *
4474 * @copydoc FNPDMDRVCONSTRUCT
4475 */
4476DECLCALLBACK(int) Display::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
4477{
4478 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
4479 PDRVMAINDISPLAY pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINDISPLAY);
4480 LogRelFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
4481
4482 /*
4483 * Validate configuration.
4484 */
4485 if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
4486 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
4487 AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
4488 ("Configuration error: Not possible to attach anything to this driver!\n"),
4489 VERR_PDM_DRVINS_NO_ATTACH);
4490
4491 /*
4492 * Init Interfaces.
4493 */
4494 pDrvIns->IBase.pfnQueryInterface = Display::drvQueryInterface;
4495
4496 pThis->IConnector.pfnResize = Display::displayResizeCallback;
4497 pThis->IConnector.pfnUpdateRect = Display::displayUpdateCallback;
4498 pThis->IConnector.pfnRefresh = Display::displayRefreshCallback;
4499 pThis->IConnector.pfnReset = Display::displayResetCallback;
4500 pThis->IConnector.pfnLFBModeChange = Display::displayLFBModeChangeCallback;
4501 pThis->IConnector.pfnProcessAdapterData = Display::displayProcessAdapterDataCallback;
4502 pThis->IConnector.pfnProcessDisplayData = Display::displayProcessDisplayDataCallback;
4503#ifdef VBOX_WITH_VIDEOHWACCEL
4504 pThis->IConnector.pfnVHWACommandProcess = Display::displayVHWACommandProcess;
4505#endif
4506#ifdef VBOX_WITH_CRHGSMI
4507 pThis->IConnector.pfnCrHgsmiCommandProcess = Display::displayCrHgsmiCommandProcess;
4508 pThis->IConnector.pfnCrHgsmiControlProcess = Display::displayCrHgsmiControlProcess;
4509#endif
4510#ifdef VBOX_WITH_HGSMI
4511 pThis->IConnector.pfnVBVAEnable = Display::displayVBVAEnable;
4512 pThis->IConnector.pfnVBVADisable = Display::displayVBVADisable;
4513 pThis->IConnector.pfnVBVAUpdateBegin = Display::displayVBVAUpdateBegin;
4514 pThis->IConnector.pfnVBVAUpdateProcess = Display::displayVBVAUpdateProcess;
4515 pThis->IConnector.pfnVBVAUpdateEnd = Display::displayVBVAUpdateEnd;
4516 pThis->IConnector.pfnVBVAResize = Display::displayVBVAResize;
4517 pThis->IConnector.pfnVBVAMousePointerShape = Display::displayVBVAMousePointerShape;
4518#endif
4519
4520 /*
4521 * Get the IDisplayPort interface of the above driver/device.
4522 */
4523 pThis->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYPORT);
4524 if (!pThis->pUpPort)
4525 {
4526 AssertMsgFailed(("Configuration error: No display port interface above!\n"));
4527 return VERR_PDM_MISSING_INTERFACE_ABOVE;
4528 }
4529#if defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_CRHGSMI)
4530 pThis->pVBVACallbacks = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYVBVACALLBACKS);
4531 if (!pThis->pVBVACallbacks)
4532 {
4533 AssertMsgFailed(("Configuration error: No VBVA callback interface above!\n"));
4534 return VERR_PDM_MISSING_INTERFACE_ABOVE;
4535 }
4536#endif
4537 /*
4538 * Get the Display object pointer and update the mpDrv member.
4539 */
4540 void *pv;
4541 int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
4542 if (RT_FAILURE(rc))
4543 {
4544 AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
4545 return rc;
4546 }
4547 Display *pDisplay = (Display *)pv; /** @todo Check this cast! */
4548 pThis->pDisplay = pDisplay;
4549 pThis->pDisplay->mpDrv = pThis;
4550 /*
4551 * Update our display information according to the framebuffer
4552 */
4553 pDisplay->updateDisplayData();
4554
4555 /*
4556 * Start periodic screen refreshes
4557 */
4558 pThis->pUpPort->pfnSetRefreshRate(pThis->pUpPort, 20);
4559
4560#ifdef VBOX_WITH_CRHGSMI
4561 pDisplay->setupCrHgsmiData();
4562#endif
4563
4564#ifdef VBOX_WITH_VPX
4565 ComPtr<IMachine> pMachine = pDisplay->mParent->machine();
4566 BOOL fEnabled = false;
4567 HRESULT hrc = pMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
4568 AssertComRCReturn(hrc, VERR_COM_UNEXPECTED);
4569 if (fEnabled)
4570 {
4571 rc = pDisplay->VideoCaptureStart();
4572 fireVideoCaptureChangedEvent(pDisplay->mParent->getEventSource());
4573 }
4574#endif
4575
4576 return rc;
4577}
4578
4579
4580/**
4581 * Display driver registration record.
4582 */
4583const PDMDRVREG Display::DrvReg =
4584{
4585 /* u32Version */
4586 PDM_DRVREG_VERSION,
4587 /* szName */
4588 "MainDisplay",
4589 /* szRCMod */
4590 "",
4591 /* szR0Mod */
4592 "",
4593 /* pszDescription */
4594 "Main display driver (Main as in the API).",
4595 /* fFlags */
4596 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
4597 /* fClass. */
4598 PDM_DRVREG_CLASS_DISPLAY,
4599 /* cMaxInstances */
4600 ~0U,
4601 /* cbInstance */
4602 sizeof(DRVMAINDISPLAY),
4603 /* pfnConstruct */
4604 Display::drvConstruct,
4605 /* pfnDestruct */
4606 Display::drvDestruct,
4607 /* pfnRelocate */
4608 NULL,
4609 /* pfnIOCtl */
4610 NULL,
4611 /* pfnPowerOn */
4612 NULL,
4613 /* pfnReset */
4614 NULL,
4615 /* pfnSuspend */
4616 NULL,
4617 /* pfnResume */
4618 NULL,
4619 /* pfnAttach */
4620 NULL,
4621 /* pfnDetach */
4622 NULL,
4623 /* pfnPowerOff */
4624 NULL,
4625 /* pfnSoftReset */
4626 NULL,
4627 /* u32EndVersion */
4628 PDM_DRVREG_VERSION
4629};
4630/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

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