VirtualBox

source: vbox/trunk/src/VBox/Main/DisplayImpl.cpp@ 33146

Last change on this file since 33146 was 33146, checked in by vboxsync, 14 years ago

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