VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp@ 50149

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

crOpenGL: bugfixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 94.9 KB
Line 
1/* $Id: server_presenter.cpp 50149 2014-01-21 18:18:36Z vboxsync $ */
2
3/** @file
4 * Presenter API
5 */
6
7/*
8 * Copyright (C) 2012-2013 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18#include "cr_spu.h"
19#include "chromium.h"
20#include "cr_error.h"
21#include "cr_net.h"
22#include "cr_rand.h"
23#include "server_dispatch.h"
24#include "server.h"
25#include "cr_mem.h"
26#include "cr_string.h"
27#include <cr_vreg.h>
28#include <cr_htable.h>
29
30#include <iprt/cdefs.h>
31#include <iprt/types.h>
32#include <iprt/asm.h>
33#include <iprt/mem.h>
34#include <iprt/list.h>
35
36
37#ifdef DEBUG_misha
38# define VBOXVDBG_MEMCACHE_DISABLE
39#endif
40
41#ifndef VBOXVDBG_MEMCACHE_DISABLE
42# include <iprt/memcache.h>
43#endif
44
45#include "render/renderspu.h"
46
47class ICrFbDisplay
48{
49public:
50 virtual int UpdateBegin(struct CR_FRAMEBUFFER *pFb) = 0;
51 virtual void UpdateEnd(struct CR_FRAMEBUFFER *pFb) = 0;
52
53 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
54 virtual int EntryAdded(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
55 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry) = 0;
56 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
57 virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
58 virtual int EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
59 virtual int EntryPosChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry) = 0;
60
61 virtual int RegionsChanged(struct CR_FRAMEBUFFER *pFb) = 0;
62
63 virtual int FramebufferChanged(struct CR_FRAMEBUFFER *pFb) = 0;
64
65 virtual ~ICrFbDisplay() {}
66};
67
68class CrFbDisplayComposite;
69class CrFbDisplayBase;
70class CrFbDisplayWindow;
71class CrFbDisplayWindowRootVr;
72class CrFbDisplayVrdp;
73
74typedef struct CR_FRAMEBUFFER
75{
76 VBOXVR_SCR_COMPOSITOR Compositor;
77 struct VBVAINFOSCREEN ScreenInfo;
78 void *pvVram;
79 ICrFbDisplay *pDisplay;
80 CRHTABLE SlotTable;
81 uint32_t cUpdating;
82} CR_FRAMEBUFFER;
83
84typedef struct CR_FBDISPLAY_INFO
85{
86 uint32_t u32Mode;
87 CrFbDisplayWindow *pDpWin;
88 CrFbDisplayWindowRootVr *pDpWinRootVr;
89 CrFbDisplayVrdp *pDpVrdp;
90 CrFbDisplayComposite *pDpComposite;
91} CR_FBDISPLAY_INFO;
92
93typedef struct CR_PRESENTER_GLOBALS
94{
95#ifndef VBOXVDBG_MEMCACHE_DISABLE
96 RTMEMCACHE FbEntryLookasideList;
97 RTMEMCACHE FbTexLookasideList;
98 RTMEMCACHE CEntryLookasideList;
99#endif
100 uint32_t u32DisplayMode;
101 CRHashTable *pFbTexMap;
102 CR_FBDISPLAY_INFO aDisplayInfos[CR_MAX_GUEST_MONITORS];
103 CR_FBMAP FramebufferInitMap;
104 CR_FRAMEBUFFER aFramebuffers[CR_MAX_GUEST_MONITORS];
105} CR_PRESENTER_GLOBALS;
106
107static CR_PRESENTER_GLOBALS g_CrPresenter;
108
109/* FRAMEBUFFER */
110
111void CrFbInit(CR_FRAMEBUFFER *pFb, uint32_t idScreen)
112{
113 RTRECT Rect;
114 Rect.xLeft = 0;
115 Rect.yTop = 0;
116 Rect.xRight = 1;
117 Rect.yBottom = 1;
118 memset(pFb, 0, sizeof (*pFb));
119 pFb->ScreenInfo.u16Flags = VBVA_SCREEN_F_DISABLED;
120 pFb->ScreenInfo.u32ViewIndex = idScreen;
121 CrVrScrCompositorInit(&pFb->Compositor, &Rect);
122 CrHTableCreate(&pFb->SlotTable, 0);
123}
124
125bool CrFbIsEnabled(CR_FRAMEBUFFER *pFb)
126{
127 return !(pFb->ScreenInfo.u16Flags & VBVA_SCREEN_F_DISABLED);
128}
129
130HCR_FRAMEBUFFER_ENTRY CrFbEntryFromCompositorEntry(const struct VBOXVR_SCR_COMPOSITOR_ENTRY* pCEntry);
131
132const struct VBOXVR_SCR_COMPOSITOR* CrFbGetCompositor(CR_FRAMEBUFFER *pFb)
133{
134 return &pFb->Compositor;
135}
136
137DECLINLINE(CR_FRAMEBUFFER*) CrFbFromCompositor(const struct VBOXVR_SCR_COMPOSITOR* pCompositor)
138{
139 return RT_FROM_MEMBER(pCompositor, CR_FRAMEBUFFER, Compositor);
140}
141
142const struct VBVAINFOSCREEN* CrFbGetScreenInfo(HCR_FRAMEBUFFER hFb)
143{
144 return &hFb->ScreenInfo;
145}
146
147
148int CrFbUpdateBegin(CR_FRAMEBUFFER *pFb)
149{
150 ++pFb->cUpdating;
151
152 if (pFb->cUpdating == 1)
153 {
154 if (pFb->pDisplay)
155 pFb->pDisplay->UpdateBegin(pFb);
156 }
157
158 return VINF_SUCCESS;
159}
160
161void CrFbUpdateEnd(CR_FRAMEBUFFER *pFb)
162{
163 if (!pFb->cUpdating)
164 {
165 WARN(("invalid UpdateEnd call!"));
166 return;
167 }
168
169 --pFb->cUpdating;
170
171 if (!pFb->cUpdating)
172 {
173 if (pFb->pDisplay)
174 pFb->pDisplay->UpdateEnd(pFb);
175 }
176}
177
178bool CrFbIsUpdating(const CR_FRAMEBUFFER *pFb)
179{
180 return !!pFb->cUpdating;
181}
182
183int CrFbResize(CR_FRAMEBUFFER *pFb, const struct VBVAINFOSCREEN * pScreen, void *pvVRAM)
184{
185 if (!pFb->cUpdating)
186 {
187 WARN(("no update in progress"));
188 return VERR_INVALID_STATE;
189 }
190 RTRECT Rect;
191 Rect.xLeft = 0;
192 Rect.yTop = 0;
193 Rect.xRight = pScreen->u32Width;
194 Rect.yBottom = pScreen->u32Height;
195 int rc = CrVrScrCompositorRectSet(&pFb->Compositor, &Rect, NULL);
196 if (!RT_SUCCESS(rc))
197 {
198 WARN(("CrVrScrCompositorRectSet failed rc %d", rc));
199 return rc;
200 }
201
202 pFb->ScreenInfo = *pScreen;
203 pFb->pvVram = pvVRAM;
204
205 if (pFb->pDisplay)
206 pFb->pDisplay->FramebufferChanged(pFb);
207 return VINF_SUCCESS;
208}
209
210void CrFbTerm(CR_FRAMEBUFFER *pFb)
211{
212 if (pFb->cUpdating)
213 {
214 WARN(("update in progress"));
215 return;
216 }
217 uint32_t idScreen = pFb->ScreenInfo.u32ViewIndex;
218
219 CrVrScrCompositorClear(&pFb->Compositor);
220 CrHTableDestroy(&pFb->SlotTable);
221 memset(pFb, 0, sizeof (*pFb));
222
223 pFb->ScreenInfo.u16Flags = VBVA_SCREEN_F_DISABLED;
224 pFb->ScreenInfo.u32ViewIndex = idScreen;
225}
226
227ICrFbDisplay* CrFbDisplayGet(CR_FRAMEBUFFER *pFb)
228{
229 return pFb->pDisplay;
230}
231
232int CrFbDisplaySet(CR_FRAMEBUFFER *pFb, ICrFbDisplay *pDisplay)
233{
234 if (pFb->cUpdating)
235 {
236 WARN(("update in progress"));
237 return VERR_INVALID_STATE;
238 }
239
240 if (pFb->pDisplay == pDisplay)
241 return VINF_SUCCESS;
242
243 CrHTableEmpty(&pFb->SlotTable);
244
245 pFb->pDisplay = pDisplay;
246
247 return VINF_SUCCESS;
248}
249
250typedef union CR_FBENTRY_FLAGS
251{
252 struct {
253 uint32_t fCreateNotified : 1;
254 uint32_t Reserved : 31;
255 };
256 uint32_t Value;
257} CR_FBENTRY_FLAGS;
258
259typedef struct CR_FRAMEBUFFER_ENTRY
260{
261 VBOXVR_SCR_COMPOSITOR_ENTRY Entry;
262 uint32_t cRefs;
263 CR_FBENTRY_FLAGS Flags;
264 CRHTABLE HTable;
265} CR_FRAMEBUFFER_ENTRY;
266
267typedef struct CR_FBTEX
268{
269 CR_TEXDATA Tex;
270 CRTextureObj *pTobj;
271} CR_FBTEX;
272
273#define PCR_FBTEX_FROM_TEX(_pTex) ((CR_FBTEX*)((uint8_t*)(_pTex) - RT_OFFSETOF(CR_FBTEX, Tex)))
274#define PCR_FRAMEBUFFER_FROM_COMPOSITOR(_pCompositor) ((CR_FRAMEBUFFER*)((uint8_t*)(_pCompositor) - RT_OFFSETOF(CR_FRAMEBUFFER, Compositor)))
275#define PCR_FBENTRY_FROM_ENTRY(_pEntry) ((CR_FRAMEBUFFER_ENTRY*)((uint8_t*)(_pEntry) - RT_OFFSETOF(CR_FRAMEBUFFER_ENTRY, Entry)))
276
277#define CR_PMGR_MODE_WINDOW 0x1
278/* mutually exclusive with CR_PMGR_MODE_WINDOW */
279#define CR_PMGR_MODE_ROOTVR 0x2
280#define CR_PMGR_MODE_VRDP 0x4
281#define CR_PMGR_MODE_ALL 0x7
282
283static int crPMgrModeModifyGlobal(uint32_t u32Mode, bool fEnable);
284
285static CR_FBTEX* crFbTexAlloc()
286{
287#ifndef VBOXVDBG_MEMCACHE_DISABLE
288 return (CR_FBTEX*)RTMemCacheAlloc(g_CrPresenter.FbTexLookasideList);
289#else
290 return (CR_FBTEX*)RTMemAlloc(sizeof (CR_FBTEX));
291#endif
292}
293
294static void crFbTexFree(CR_FBTEX *pTex)
295{
296#ifndef VBOXVDBG_MEMCACHE_DISABLE
297 RTMemCacheFree(g_CrPresenter.FbTexLookasideList, pTex);
298#else
299 RTMemFree(pTex);
300#endif
301}
302
303static CR_FRAMEBUFFER_ENTRY* crFbEntryAlloc()
304{
305#ifndef VBOXVDBG_MEMCACHE_DISABLE
306 return (CR_FRAMEBUFFER_ENTRY*)RTMemCacheAlloc(g_CrPresenter.FbEntryLookasideList);
307#else
308 return (CR_FRAMEBUFFER_ENTRY*)RTMemAlloc(sizeof (CR_FRAMEBUFFER_ENTRY));
309#endif
310}
311
312static void crFbEntryFree(CR_FRAMEBUFFER_ENTRY *pEntry)
313{
314 Assert(!CrVrScrCompositorEntryIsUsed(&pEntry->Entry));
315#ifndef VBOXVDBG_MEMCACHE_DISABLE
316 RTMemCacheFree(g_CrPresenter.FbEntryLookasideList, pEntry);
317#else
318 RTMemFree(pEntry);
319#endif
320}
321
322DECLCALLBACK(void) crFbTexRelease(CR_TEXDATA *pTex)
323{
324 CR_FBTEX *pFbTex = PCR_FBTEX_FROM_TEX(pTex);
325 CRTextureObj *pTobj = pFbTex->pTobj;
326
327 CrTdBltDataCleanup(pTex);
328
329 if (pTobj)
330 {
331 CR_STATE_SHAREDOBJ_USAGE_CLEAR(pTobj, cr_server.MainContextInfo.pContext);
332
333 crHashtableDelete(g_CrPresenter.pFbTexMap, pTobj->id, NULL);
334
335 if (!CR_STATE_SHAREDOBJ_USAGE_IS_USED(pTobj))
336 {
337 CRSharedState *pShared = crStateGlobalSharedAcquire();
338
339 CRASSERT(pShared);
340 /* on the host side, we need to delete an ogl texture object here as well, which crStateDeleteTextureCallback will do
341 * in addition to calling crStateDeleteTextureObject to delete a state object */
342 crHashtableDelete(pShared->textureTable, pTobj->id, crStateDeleteTextureCallback);
343
344 crStateGlobalSharedRelease();
345 }
346
347 crStateGlobalSharedRelease();
348 }
349
350 crFbTexFree(pFbTex);
351}
352
353void CrFbTexDataInit(CR_TEXDATA* pFbTex, const VBOXVR_TEXTURE *pTex, PFNCRTEXDATA_RELEASED pfnTextureReleased)
354{
355 PCR_BLITTER pBlitter = crServerVBoxBlitterGet();
356
357 CrTdInit(pFbTex, pTex, pBlitter, pfnTextureReleased);
358}
359
360static CR_FBTEX* crFbTexCreate(const VBOXVR_TEXTURE *pTex)
361{
362 CR_FBTEX *pFbTex = crFbTexAlloc();
363 if (!pFbTex)
364 {
365 WARN(("crFbTexAlloc failed!"));
366 return NULL;
367 }
368
369 CrFbTexDataInit(&pFbTex->Tex, pTex, crFbTexRelease);
370 pFbTex->pTobj = NULL;
371
372 return pFbTex;
373}
374
375
376CR_TEXDATA* CrFbTexDataCreate(const VBOXVR_TEXTURE *pTex)
377{
378 CR_FBTEX *pFbTex = crFbTexCreate(pTex);
379 if (!pFbTex)
380 {
381 WARN(("crFbTexCreate failed!"));
382 return NULL;
383 }
384
385 return &pFbTex->Tex;
386}
387
388static CR_FBTEX* crFbTexAcquire(GLuint idTexture)
389{
390 CR_FBTEX *pFbTex = (CR_FBTEX *)crHashtableSearch(g_CrPresenter.pFbTexMap, idTexture);
391 if (pFbTex)
392 {
393 CrTdAddRef(&pFbTex->Tex);
394 return pFbTex;
395 }
396
397 CRSharedState *pShared = crStateGlobalSharedAcquire();
398 if (!pShared)
399 {
400 WARN(("pShared is null!"));
401 return NULL;
402 }
403
404 CRTextureObj *pTobj = (CRTextureObj*)crHashtableSearch(pShared->textureTable, idTexture);
405 if (!pTobj)
406 {
407 WARN(("pTobj is null!"));
408 crStateGlobalSharedRelease();
409 return NULL;
410 }
411
412 Assert(pTobj->id == idTexture);
413
414 GLuint hwid = crStateGetTextureObjHWID(pTobj);
415 if (!hwid)
416 {
417 WARN(("hwId is null!"));
418 crStateGlobalSharedRelease();
419 return NULL;
420 }
421
422 VBOXVR_TEXTURE Tex;
423 Tex.width = pTobj->level[0]->width;
424 Tex.height = pTobj->level[0]->height;
425 Tex.hwid = hwid;
426 Tex.target = pTobj->target;
427
428 pFbTex = crFbTexCreate(&Tex);
429 if (!pFbTex)
430 {
431 WARN(("crFbTexCreate failed!"));
432 crStateGlobalSharedRelease();
433 return NULL;
434 }
435
436 CR_STATE_SHAREDOBJ_USAGE_SET(pTobj, cr_server.MainContextInfo.pContext);
437
438 pFbTex->pTobj = pTobj;
439
440 crHashtableAdd(g_CrPresenter.pFbTexMap, idTexture, pFbTex);
441
442 return pFbTex;
443}
444
445static void crFbEntryMarkDestroyed(CR_FRAMEBUFFER *pFb, CR_FRAMEBUFFER_ENTRY* pEntry)
446{
447 if (pEntry->Flags.fCreateNotified)
448 {
449 pEntry->Flags.fCreateNotified = 0;
450 if (pFb->pDisplay)
451 pFb->pDisplay->EntryDestroyed(pFb, pEntry);
452 }
453}
454
455static void crFbEntryDestroy(CR_FRAMEBUFFER *pFb, CR_FRAMEBUFFER_ENTRY* pEntry)
456{
457 crFbEntryMarkDestroyed(pFb, pEntry);
458 CrVrScrCompositorEntryCleanup(&pEntry->Entry);
459 CrHTableDestroy(&pEntry->HTable);
460 crFbEntryFree(pEntry);
461}
462
463DECLINLINE(uint32_t) crFbEntryAddRef(CR_FRAMEBUFFER_ENTRY* pEntry)
464{
465 return ++pEntry->cRefs;
466}
467
468DECLINLINE(uint32_t) crFbEntryRelease(CR_FRAMEBUFFER *pFb, CR_FRAMEBUFFER_ENTRY* pEntry)
469{
470 uint32_t cRefs = --pEntry->cRefs;
471 if (!cRefs)
472 crFbEntryDestroy(pFb, pEntry);
473 return cRefs;
474}
475
476static DECLCALLBACK(void) crFbEntryReleased(const struct VBOXVR_SCR_COMPOSITOR *pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pReplacingEntry)
477{
478 CR_FRAMEBUFFER *pFb = PCR_FRAMEBUFFER_FROM_COMPOSITOR(pCompositor);
479 CR_FRAMEBUFFER_ENTRY *pFbEntry = PCR_FBENTRY_FROM_ENTRY(pEntry);
480 CR_FRAMEBUFFER_ENTRY *pFbReplacingEntry = pReplacingEntry ? PCR_FBENTRY_FROM_ENTRY(pReplacingEntry) : NULL;
481 if (pFbReplacingEntry)
482 {
483 /*replace operation implies the replaced entry gets auto-destroyed,
484 * while all its data gets moved to the *clean* replacing entry
485 * 1. ensure the replacing entry is cleaned up */
486 crFbEntryMarkDestroyed(pFb, pFbReplacingEntry);
487
488 CrHTableMoveTo(&pFbEntry->HTable, &pFbReplacingEntry->HTable);
489 if (pFb->pDisplay)
490 pFb->pDisplay->EntryReplaced(pFb, pFbReplacingEntry, pFbEntry);
491
492 /* 2. mark the replaced entry is destroyed */
493 Assert(pFbEntry->Flags.fCreateNotified);
494 pFbEntry->Flags.fCreateNotified = 0;
495 pFbReplacingEntry->Flags.fCreateNotified = 1;
496 }
497 else
498 {
499 if (pFb->pDisplay)
500 pFb->pDisplay->EntryRemoved(pFb, pFbEntry);
501 }
502
503 crFbEntryRelease(pFb, pFbEntry);
504}
505
506static CR_FRAMEBUFFER_ENTRY* crFbEntryCreate(CR_FRAMEBUFFER *pFb, CR_TEXDATA* pTex, const RTRECT *pRect, uint32_t fFlags)
507{
508 CR_FRAMEBUFFER_ENTRY *pEntry = crFbEntryAlloc();
509 if (!pEntry)
510 {
511 WARN(("crFbEntryAlloc failed!"));
512 return NULL;
513 }
514
515 CrVrScrCompositorEntryInit(&pEntry->Entry, pRect, pTex, crFbEntryReleased);
516 CrVrScrCompositorEntryFlagsSet(&pEntry->Entry, fFlags);
517 pEntry->cRefs = 1;
518 pEntry->Flags.Value = 0;
519 CrHTableCreate(&pEntry->HTable, 0);
520
521 return pEntry;
522}
523
524int CrFbEntryCreateForTexData(CR_FRAMEBUFFER *pFb, struct CR_TEXDATA *pTex, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry)
525{
526 RTRECT Rect;
527 Rect.xLeft = 0;
528 Rect.yTop = 0;
529 Rect.xRight = pTex->Tex.width;
530 Rect.yBottom = pTex->Tex.height;
531 CR_FRAMEBUFFER_ENTRY* pEntry = crFbEntryCreate(pFb, pTex, &Rect, fFlags);
532 if (!pEntry)
533 {
534 WARN(("crFbEntryCreate failed"));
535 return VERR_NO_MEMORY;
536 }
537
538 *phEntry = pEntry;
539 return VINF_SUCCESS;
540}
541
542int CrFbEntryTexDataUpdate(CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY pEntry, struct CR_TEXDATA *pTex)
543{
544 if (!pFb->cUpdating)
545 {
546 WARN(("framebuffer not updating"));
547 return VERR_INVALID_STATE;
548 }
549
550 if (pTex)
551 CrVrScrCompositorEntryTexSet(&pEntry->Entry, pTex);
552
553 if (CrVrScrCompositorEntryIsUsed(&pEntry->Entry))
554 {
555 if (pFb->pDisplay)
556 pFb->pDisplay->EntryTexChanged(pFb, pEntry);
557 }
558
559 return VINF_SUCCESS;
560}
561
562
563int CrFbEntryCreateForTexId(CR_FRAMEBUFFER *pFb, GLuint idTexture, uint32_t fFlags, HCR_FRAMEBUFFER_ENTRY *phEntry)
564{
565 CR_FBTEX* pFbTex = crFbTexAcquire(idTexture);
566 if (!pFbTex)
567 {
568 WARN(("crFbTexAcquire failed"));
569 return VERR_INVALID_PARAMETER;
570 }
571
572 CR_TEXDATA* pTex = &pFbTex->Tex;
573 int rc = CrFbEntryCreateForTexData(pFb, pTex, fFlags, phEntry);
574 if (!RT_SUCCESS(rc))
575 {
576 WARN(("CrFbEntryCreateForTexData failed rc %d", rc));
577 }
578
579 /*always release the tex, the CrFbEntryCreateForTexData will do incref as necessary */
580 CrTdRelease(pTex);
581 return rc;
582}
583
584void CrFbEntryAddRef(CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
585{
586 ++hEntry->cRefs;
587}
588
589void CrFbEntryRelease(CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
590{
591 crFbEntryRelease(pFb, hEntry);
592}
593
594int CrFbRegionsClear(HCR_FRAMEBUFFER hFb)
595{
596 if (!hFb->cUpdating)
597 {
598 WARN(("framebuffer not updating"));
599 return VERR_INVALID_STATE;
600 }
601
602 bool fChanged = false;
603 CrVrScrCompositorRegionsClear(&hFb->Compositor, &fChanged);
604 if (fChanged)
605 {
606 if (hFb->pDisplay)
607 hFb->pDisplay->RegionsChanged(hFb);
608 }
609
610 return VINF_SUCCESS;
611}
612
613int CrFbEntryRegionsAdd(CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated)
614{
615 if (!pFb->cUpdating)
616 {
617 WARN(("framebuffer not updating"));
618 return VERR_INVALID_STATE;
619 }
620
621 uint32_t fChangeFlags = 0;
622 VBOXVR_SCR_COMPOSITOR_ENTRY *pReplacedScrEntry = NULL;
623 VBOXVR_SCR_COMPOSITOR_ENTRY *pNewEntry;
624 bool fEntryWasInList;
625
626 if (hEntry)
627 {
628 crFbEntryAddRef(hEntry);
629 pNewEntry = &hEntry->Entry;
630 fEntryWasInList = CrVrScrCompositorEntryIsUsed(pNewEntry);
631 }
632 else
633 {
634 pNewEntry = NULL;
635 fEntryWasInList = false;
636 }
637
638 int rc = CrVrScrCompositorEntryRegionsAdd(&pFb->Compositor, hEntry ? &hEntry->Entry : NULL, pPos, cRegions, paRegions, fPosRelated, &pReplacedScrEntry, &fChangeFlags);
639 if (RT_SUCCESS(rc))
640 {
641 if (fChangeFlags & VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED)
642 {
643 if (!fEntryWasInList && pNewEntry)
644 {
645 Assert(CrVrScrCompositorEntryIsUsed(pNewEntry));
646 if (!hEntry->Flags.fCreateNotified)
647 {
648 hEntry->Flags.fCreateNotified = 1;
649 if (pFb->pDisplay)
650 pFb->pDisplay->EntryCreated(pFb, hEntry);
651 }
652
653 if (pFb->pDisplay)
654 pFb->pDisplay->EntryAdded(pFb, hEntry);
655 }
656 if (pFb->pDisplay)
657 pFb->pDisplay->RegionsChanged(pFb);
658
659 Assert(!pReplacedScrEntry);
660 }
661 else if (fChangeFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED)
662 {
663 Assert(pReplacedScrEntry);
664 /* we have already processed that in a "release" callback */
665 Assert(hEntry);
666 }
667 else
668 {
669 Assert(!fChangeFlags);
670 Assert(!pReplacedScrEntry);
671 }
672
673 if (hEntry)
674 {
675 if (CrVrScrCompositorEntryIsUsed(&hEntry->Entry))
676 {
677 if (pFb->pDisplay)
678 pFb->pDisplay->EntryTexChanged(pFb, hEntry);
679 }
680 }
681 }
682 else
683 WARN(("CrVrScrCompositorEntryRegionsAdd failed, rc %d", rc));
684
685 return rc;
686}
687
688int CrFbEntryRegionsSet(CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool fPosRelated)
689{
690 if (!pFb->cUpdating)
691 {
692 WARN(("framebuffer not updating"));
693 return VERR_INVALID_STATE;
694 }
695
696 bool fChanged = 0;
697 VBOXVR_SCR_COMPOSITOR_ENTRY *pReplacedScrEntry = NULL;
698 VBOXVR_SCR_COMPOSITOR_ENTRY *pNewEntry;
699 bool fEntryWasInList;
700
701 if (hEntry)
702 {
703 crFbEntryAddRef(hEntry);
704 pNewEntry = &hEntry->Entry;
705 fEntryWasInList = CrVrScrCompositorEntryIsUsed(pNewEntry);
706 }
707 else
708 {
709 pNewEntry = NULL;
710 fEntryWasInList = false;
711 }
712
713 int rc = CrVrScrCompositorEntryRegionsSet(&pFb->Compositor, pNewEntry, pPos, cRegions, paRegions, fPosRelated, &fChanged);
714 if (RT_SUCCESS(rc))
715 {
716 if (fChanged)
717 {
718 if (!fEntryWasInList && pNewEntry)
719 {
720 if (CrVrScrCompositorEntryIsUsed(pNewEntry))
721 {
722 if (!hEntry->Flags.fCreateNotified)
723 {
724 hEntry->Flags.fCreateNotified = 1;
725
726 if (pFb->pDisplay)
727 pFb->pDisplay->EntryCreated(pFb, hEntry);
728 }
729
730 if (pFb->pDisplay)
731 pFb->pDisplay->EntryAdded(pFb, hEntry);
732 }
733 }
734
735 if (pFb->pDisplay)
736 pFb->pDisplay->RegionsChanged(pFb);
737 }
738
739 if (hEntry)
740 {
741 if (CrVrScrCompositorEntryIsUsed(&hEntry->Entry))
742 {
743 if (pFb->pDisplay)
744 pFb->pDisplay->EntryTexChanged(pFb, hEntry);
745 }
746 }
747 }
748 else
749 WARN(("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc));
750
751 return rc;
752}
753
754const struct VBOXVR_SCR_COMPOSITOR_ENTRY* CrFbEntryGetCompositorEntry(HCR_FRAMEBUFFER_ENTRY hEntry)
755{
756 return &hEntry->Entry;
757}
758
759HCR_FRAMEBUFFER_ENTRY CrFbEntryFromCompositorEntry(const struct VBOXVR_SCR_COMPOSITOR_ENTRY* pCEntry)
760{
761 return RT_FROM_MEMBER(pCEntry, CR_FRAMEBUFFER_ENTRY, Entry);
762}
763
764CRHTABLE_HANDLE CrFbDDataAllocSlot(CR_FRAMEBUFFER *pFb)
765{
766 return CrHTablePut(&pFb->SlotTable, (void*)1);
767}
768
769void CrFbDDataReleaseSlot(CR_FRAMEBUFFER *pFb, CRHTABLE_HANDLE hSlot)
770{
771 CrHTableRemove(&pFb->SlotTable, hSlot);
772}
773
774int CrFbDDataEntryPut(HCR_FRAMEBUFFER_ENTRY hEntry, CRHTABLE_HANDLE hSlot, void *pvData)
775{
776 return CrHTablePutToSlot(&hEntry->HTable, hSlot, pvData);
777}
778
779void* CrFbDDataEntryGet(HCR_FRAMEBUFFER_ENTRY hEntry, CRHTABLE_HANDLE hSlot)
780{
781 return CrHTableGet(&hEntry->HTable, hSlot);
782}
783
784typedef union CR_FBDISPBASE_FLAGS
785{
786 struct {
787 uint32_t fRegionsShanged : 1;
788 uint32_t Reserved : 31;
789 };
790 uint32_t u32Value;
791} CR_FBDISPBASE_FLAGS;
792
793class CrFbDisplayBase : public ICrFbDisplay
794{
795public:
796 CrFbDisplayBase() :
797 mpContainer(NULL),
798 mpFb(NULL),
799 mcUpdates(0),
800 mhSlot(CRHTABLE_HANDLE_INVALID)
801 {
802 mFlags.u32Value = 0;
803 }
804
805 virtual bool isComposite()
806 {
807 return false;
808 }
809
810 class CrFbDisplayComposite* getContainer()
811 {
812 return mpContainer;
813 }
814
815 bool isInList()
816 {
817 return !!mpContainer;
818 }
819
820 bool isUpdating()
821 {
822 return !!mcUpdates;
823 }
824
825 int setRegionsChanged()
826 {
827 if (!mcUpdates)
828 {
829 WARN(("err"));
830 return VERR_INVALID_STATE;
831 }
832
833 mFlags.fRegionsShanged = 1;
834 return VINF_SUCCESS;
835 }
836
837 int setFramebuffer(struct CR_FRAMEBUFFER *pFb)
838 {
839 if (mcUpdates)
840 {
841 WARN(("trying to set framebuffer while update is in progress"));
842 return VERR_INVALID_STATE;
843 }
844
845 if (mpFb == pFb)
846 return VINF_SUCCESS;
847
848 int rc = setFramebufferBegin(pFb);
849 if (!RT_SUCCESS(rc))
850 {
851 WARN(("err"));
852 return rc;
853 }
854
855 if (mpFb)
856 {
857 rc = fbCleanup();
858 if (!RT_SUCCESS(rc))
859 {
860 WARN(("err"));
861 setFramebufferEnd(pFb);
862 return rc;
863 }
864 }
865
866 mpFb = pFb;
867
868 if (mpFb)
869 {
870 rc = fbSync();
871 if (!RT_SUCCESS(rc))
872 {
873 WARN(("err"));
874 setFramebufferEnd(pFb);
875 return rc;
876 }
877 }
878
879 setFramebufferEnd(pFb);
880 return VINF_SUCCESS;
881 }
882
883 struct CR_FRAMEBUFFER* getFramebuffer()
884 {
885 return mpFb;
886 }
887
888 virtual int UpdateBegin(struct CR_FRAMEBUFFER *pFb)
889 {
890 ++mcUpdates;
891 Assert(!mFlags.fRegionsShanged || mcUpdates > 1);
892 return VINF_SUCCESS;
893 }
894
895 virtual void UpdateEnd(struct CR_FRAMEBUFFER *pFb)
896 {
897 --mcUpdates;
898 Assert(mcUpdates < UINT32_MAX/2);
899 if (!mcUpdates)
900 onUpdateEnd();
901 }
902
903 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
904 {
905 if (!mcUpdates)
906 {
907 WARN(("err"));
908 return VERR_INVALID_STATE;
909 }
910 return VINF_SUCCESS;
911 }
912
913 virtual int EntryAdded(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
914 {
915 if (!mcUpdates)
916 {
917 WARN(("err"));
918 return VERR_INVALID_STATE;
919 }
920 mFlags.fRegionsShanged = 1;
921 return VINF_SUCCESS;
922 }
923
924 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
925 {
926 if (!mcUpdates)
927 {
928 WARN(("err"));
929 return VERR_INVALID_STATE;
930 }
931 return VINF_SUCCESS;
932 }
933
934 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
935 {
936 if (!mcUpdates)
937 {
938 WARN(("err"));
939 return VERR_INVALID_STATE;
940 }
941 return VINF_SUCCESS;
942 }
943
944 virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
945 {
946 if (!mcUpdates)
947 {
948 WARN(("err"));
949 return VERR_INVALID_STATE;
950 }
951 mFlags.fRegionsShanged = 1;
952 return VINF_SUCCESS;
953 }
954
955 virtual int EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
956 {
957 return VINF_SUCCESS;
958 }
959
960 virtual int EntryPosChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
961 {
962 if (!mcUpdates)
963 {
964 WARN(("err"));
965 return VERR_INVALID_STATE;
966 }
967 mFlags.fRegionsShanged = 1;
968 return VINF_SUCCESS;
969 }
970
971 virtual int RegionsChanged(struct CR_FRAMEBUFFER *pFb)
972 {
973 if (!mcUpdates)
974 {
975 WARN(("err"));
976 return VERR_INVALID_STATE;
977 }
978 mFlags.fRegionsShanged = 1;
979 return VINF_SUCCESS;
980 }
981
982 virtual int FramebufferChanged(struct CR_FRAMEBUFFER *pFb)
983 {
984 if (!mcUpdates)
985 {
986 WARN(("err"));
987 return VERR_INVALID_STATE;
988 }
989 return VINF_SUCCESS;
990 }
991
992 virtual ~CrFbDisplayBase();
993
994 /*@todo: move to protected and switch from RTLISTNODE*/
995 RTLISTNODE mNode;
996 class CrFbDisplayComposite* mpContainer;
997protected:
998 virtual void onUpdateEnd()
999 {
1000 if (mFlags.fRegionsShanged)
1001 {
1002 mFlags.fRegionsShanged = 0;
1003 ueRegions();
1004 }
1005 }
1006
1007 virtual void ueRegions()
1008 {
1009 }
1010
1011 int fbSynchAddAllEntries()
1012 {
1013 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
1014 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
1015
1016 CrVrScrCompositorConstIterInit(CrFbGetCompositor(mpFb), &Iter);
1017
1018 int rc = VINF_SUCCESS;
1019
1020 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
1021 {
1022 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
1023 rc = EntryCreated(mpFb, hEntry);
1024 if (!RT_SUCCESS(rc))
1025 {
1026 WARN(("err"));
1027 break;
1028 }
1029
1030 rc = EntryAdded(mpFb, hEntry);
1031 if (!RT_SUCCESS(rc))
1032 {
1033 WARN(("err"));
1034 EntryDestroyed(mpFb, hEntry);
1035 break;
1036 }
1037 }
1038
1039 return rc;
1040 }
1041
1042 int fbCleanupRemoveAllEntries(bool fNotifyDestroy)
1043 {
1044 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
1045 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
1046
1047 CrVrScrCompositorConstIterInit(CrFbGetCompositor(mpFb), &Iter);
1048
1049 int rc = VINF_SUCCESS;
1050
1051 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
1052 {
1053 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
1054 rc = EntryRemoved(mpFb, hEntry);
1055 if (!RT_SUCCESS(rc))
1056 {
1057 WARN(("err"));
1058 break;
1059 }
1060
1061 if (fNotifyDestroy)
1062 {
1063 rc = EntryDestroyed(mpFb, hEntry);
1064 if (!RT_SUCCESS(rc))
1065 {
1066 WARN(("err"));
1067 break;
1068 }
1069 }
1070 }
1071
1072 return rc;
1073 }
1074
1075 virtual int setFramebufferBegin(struct CR_FRAMEBUFFER *pFb)
1076 {
1077 return UpdateBegin(pFb);
1078 }
1079 virtual void setFramebufferEnd(struct CR_FRAMEBUFFER *pFb)
1080 {
1081 UpdateEnd(pFb);
1082 }
1083
1084 virtual int fbCleanup()
1085 {
1086 if (mhSlot)
1087 {
1088 CrFbDDataReleaseSlot(mpFb, mhSlot);
1089 mhSlot = 0;
1090 }
1091 mpFb = NULL;
1092 return VINF_SUCCESS;
1093 }
1094
1095 virtual int fbSync()
1096 {
1097 return VINF_SUCCESS;
1098 }
1099
1100 CRHTABLE_HANDLE slotGet()
1101 {
1102 if (!mhSlot)
1103 {
1104 if (mpFb)
1105 mhSlot = CrFbDDataAllocSlot(mpFb);
1106 }
1107
1108 return mhSlot;
1109 }
1110
1111private:
1112 struct CR_FRAMEBUFFER *mpFb;
1113 uint32_t mcUpdates;
1114 CRHTABLE_HANDLE mhSlot;
1115 CR_FBDISPBASE_FLAGS mFlags;
1116};
1117
1118class CrFbDisplayComposite : public CrFbDisplayBase
1119{
1120public:
1121 CrFbDisplayComposite() :
1122 mcDisplays(0)
1123 {
1124 RTListInit(&mDisplays);
1125 }
1126
1127 virtual bool isComposite()
1128 {
1129 return true;
1130 }
1131
1132 uint32_t getDisplayCount()
1133 {
1134 return mcDisplays;
1135 }
1136
1137 bool add(CrFbDisplayBase *pDisplay)
1138 {
1139 if (pDisplay->isInList())
1140 {
1141 WARN(("entry in list already"));
1142 return false;
1143 }
1144
1145 RTListAppend(&mDisplays, &pDisplay->mNode);
1146 pDisplay->mpContainer = this;
1147 pDisplay->setFramebuffer(getFramebuffer());
1148 ++mcDisplays;
1149 return true;
1150 }
1151
1152 bool remove(CrFbDisplayBase *pDisplay, bool fCleanupDisplay = true)
1153 {
1154 if (pDisplay->getContainer() != this)
1155 {
1156 WARN(("invalid entry container"));
1157 return false;
1158 }
1159
1160 RTListNodeRemove(&pDisplay->mNode);
1161 pDisplay->mpContainer = NULL;
1162 if (fCleanupDisplay)
1163 pDisplay->setFramebuffer(NULL);
1164 --mcDisplays;
1165 return true;
1166 }
1167
1168 CrFbDisplayBase* first()
1169 {
1170 return RTListGetFirstCpp(&mDisplays, CrFbDisplayBase, mNode);
1171 }
1172
1173 CrFbDisplayBase* next(CrFbDisplayBase* pDisplay)
1174 {
1175 if (pDisplay->getContainer() != this)
1176 {
1177 WARN(("invalid entry container"));
1178 return NULL;
1179 }
1180
1181 return RTListGetNextCpp(&mDisplays, pDisplay, CrFbDisplayBase, mNode);
1182 }
1183
1184 virtual int setFramebuffer(struct CR_FRAMEBUFFER *pFb)
1185 {
1186 CrFbDisplayBase::setFramebuffer(pFb);
1187
1188 CrFbDisplayBase *pIter;
1189 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1190 {
1191 pIter->setFramebuffer(pFb);
1192 }
1193
1194 return VINF_SUCCESS;
1195 }
1196
1197 virtual int UpdateBegin(struct CR_FRAMEBUFFER *pFb)
1198 {
1199 int rc = CrFbDisplayBase::UpdateBegin(pFb);
1200 if (!RT_SUCCESS(rc))
1201 {
1202 WARN(("err"));
1203 return rc;
1204 }
1205
1206 CrFbDisplayBase *pIter;
1207 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1208 {
1209 rc = pIter->UpdateBegin(pFb);
1210 if (!RT_SUCCESS(rc))
1211 {
1212 WARN(("err"));
1213 return rc;
1214 }
1215 }
1216 return VINF_SUCCESS;
1217 }
1218
1219 virtual void UpdateEnd(struct CR_FRAMEBUFFER *pFb)
1220 {
1221 CrFbDisplayBase *pIter;
1222 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1223 {
1224 pIter->UpdateEnd(pFb);
1225 }
1226
1227 CrFbDisplayBase::UpdateEnd(pFb);
1228 }
1229
1230 virtual int EntryAdded(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1231 {
1232 int rc = CrFbDisplayBase::EntryAdded(pFb, hEntry);
1233 if (!RT_SUCCESS(rc))
1234 {
1235 WARN(("err"));
1236 return rc;
1237 }
1238
1239 CrFbDisplayBase *pIter;
1240 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1241 {
1242 int rc = pIter->EntryAdded(pFb, hEntry);
1243 if (!RT_SUCCESS(rc))
1244 {
1245 WARN(("err"));
1246 return rc;
1247 }
1248 }
1249 return VINF_SUCCESS;
1250 }
1251
1252 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1253 {
1254 int rc = CrFbDisplayBase::EntryAdded(pFb, hEntry);
1255 if (!RT_SUCCESS(rc))
1256 {
1257 WARN(("err"));
1258 return rc;
1259 }
1260
1261 CrFbDisplayBase *pIter;
1262 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1263 {
1264 int rc = pIter->EntryCreated(pFb, hEntry);
1265 if (!RT_SUCCESS(rc))
1266 {
1267 WARN(("err"));
1268 return rc;
1269 }
1270 }
1271 return VINF_SUCCESS;
1272 }
1273
1274 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
1275 {
1276 int rc = CrFbDisplayBase::EntryReplaced(pFb, hNewEntry, hReplacedEntry);
1277 if (!RT_SUCCESS(rc))
1278 {
1279 WARN(("err"));
1280 return rc;
1281 }
1282
1283 CrFbDisplayBase *pIter;
1284 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1285 {
1286 int rc = pIter->EntryReplaced(pFb, hNewEntry, hReplacedEntry);
1287 if (!RT_SUCCESS(rc))
1288 {
1289 WARN(("err"));
1290 return rc;
1291 }
1292 }
1293 return VINF_SUCCESS;
1294 }
1295
1296 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1297 {
1298 int rc = CrFbDisplayBase::EntryTexChanged(pFb, hEntry);
1299 if (!RT_SUCCESS(rc))
1300 {
1301 WARN(("err"));
1302 return rc;
1303 }
1304
1305 CrFbDisplayBase *pIter;
1306 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1307 {
1308 int rc = pIter->EntryTexChanged(pFb, hEntry);
1309 if (!RT_SUCCESS(rc))
1310 {
1311 WARN(("err"));
1312 return rc;
1313 }
1314 }
1315 return VINF_SUCCESS;
1316 }
1317
1318 virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1319 {
1320 int rc = CrFbDisplayBase::EntryRemoved(pFb, hEntry);
1321 if (!RT_SUCCESS(rc))
1322 {
1323 WARN(("err"));
1324 return rc;
1325 }
1326
1327 CrFbDisplayBase *pIter;
1328 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1329 {
1330 int rc = pIter->EntryRemoved(pFb, hEntry);
1331 if (!RT_SUCCESS(rc))
1332 {
1333 WARN(("err"));
1334 return rc;
1335 }
1336 }
1337 return VINF_SUCCESS;
1338 }
1339
1340 virtual int EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1341 {
1342 int rc = CrFbDisplayBase::EntryDestroyed(pFb, hEntry);
1343 if (!RT_SUCCESS(rc))
1344 {
1345 WARN(("err"));
1346 return rc;
1347 }
1348
1349 CrFbDisplayBase *pIter;
1350 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1351 {
1352 int rc = pIter->EntryDestroyed(pFb, hEntry);
1353 if (!RT_SUCCESS(rc))
1354 {
1355 WARN(("err"));
1356 return rc;
1357 }
1358 }
1359 return VINF_SUCCESS;
1360 }
1361
1362 virtual int RegionsChanged(struct CR_FRAMEBUFFER *pFb)
1363 {
1364 int rc = CrFbDisplayBase::RegionsChanged(pFb);
1365 if (!RT_SUCCESS(rc))
1366 {
1367 WARN(("err"));
1368 return rc;
1369 }
1370
1371 CrFbDisplayBase *pIter;
1372 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1373 {
1374 int rc = pIter->RegionsChanged(pFb);
1375 if (!RT_SUCCESS(rc))
1376 {
1377 WARN(("err"));
1378 return rc;
1379 }
1380 }
1381 return VINF_SUCCESS;
1382 }
1383
1384 virtual int FramebufferChanged(struct CR_FRAMEBUFFER *pFb)
1385 {
1386 int rc = CrFbDisplayBase::FramebufferChanged(pFb);
1387 if (!RT_SUCCESS(rc))
1388 {
1389 WARN(("err"));
1390 return rc;
1391 }
1392
1393 CrFbDisplayBase *pIter;
1394 RTListForEachCpp(&mDisplays, pIter, CrFbDisplayBase, mNode)
1395 {
1396 int rc = pIter->FramebufferChanged(pFb);
1397 if (!RT_SUCCESS(rc))
1398 {
1399 WARN(("err"));
1400 return rc;
1401 }
1402 }
1403 return VINF_SUCCESS;
1404 }
1405
1406 virtual ~CrFbDisplayComposite()
1407 {
1408 cleanup();
1409 }
1410
1411 void cleanup(bool fCleanupDisplays = true)
1412 {
1413 CrFbDisplayBase *pIter, *pIterNext;
1414 RTListForEachSafeCpp(&mDisplays, pIter, pIterNext, CrFbDisplayBase, mNode)
1415 {
1416 remove(pIter, fCleanupDisplays);
1417 }
1418 }
1419private:
1420 RTLISTNODE mDisplays;
1421 uint32_t mcDisplays;
1422};
1423
1424typedef union CR_FBWIN_FLAGS
1425{
1426 struct {
1427 uint32_t fVisible : 1;
1428 uint32_t fDataPresented : 1;
1429 uint32_t fForcePresentOnReenable : 1;
1430 uint32_t fCompositoEntriesModified : 1;
1431 uint32_t Reserved : 28;
1432 };
1433 uint32_t Value;
1434} CR_FBWIN_FLAGS;
1435
1436class CrFbWindow
1437{
1438public:
1439 CrFbWindow(uint64_t parentId) :
1440 mSpuWindow(0),
1441 mpCompositor(NULL),
1442 mcUpdates(0),
1443 mxPos(0),
1444 myPos(0),
1445 mWidth(0),
1446 mHeight(0),
1447 mParentId(parentId)
1448 {
1449 mFlags.Value = 0;
1450 }
1451
1452 bool IsCreated()
1453 {
1454 return !!mSpuWindow;
1455 }
1456
1457 void Destroy()
1458 {
1459 CRASSERT(!mcUpdates);
1460
1461 if (!mSpuWindow)
1462 return;
1463
1464 cr_server.head_spu->dispatch_table.WindowDestroy(mSpuWindow);
1465
1466 mSpuWindow = 0;
1467 mFlags.fDataPresented = 0;
1468 }
1469
1470 int Reparent(uint64_t parentId)
1471 {
1472 if (!checkInitedUpdating())
1473 {
1474 WARN(("err"));
1475 return VERR_INVALID_STATE;
1476 }
1477
1478 uint64_t oldParentId = mParentId;
1479
1480 mParentId = parentId;
1481
1482 if (mSpuWindow)
1483 {
1484 if (oldParentId && !parentId && mFlags.fVisible)
1485 cr_server.head_spu->dispatch_table.WindowShow(mSpuWindow, false);
1486
1487 renderspuSetWindowId(mParentId);
1488 renderspuReparentWindow(mSpuWindow);
1489 renderspuSetWindowId(cr_server.screen[0].winID);
1490
1491 if (parentId)
1492 cr_server.head_spu->dispatch_table.WindowPosition(mSpuWindow, mxPos, myPos);
1493
1494 if (!oldParentId && parentId && mFlags.fVisible)
1495 cr_server.head_spu->dispatch_table.WindowShow(mSpuWindow, true);
1496 }
1497
1498 return VINF_SUCCESS;
1499 }
1500
1501 int SetVisible(bool fVisible)
1502 {
1503 if (!checkInitedUpdating())
1504 {
1505 WARN(("err"));
1506 return VERR_INVALID_STATE;
1507 }
1508
1509 LOG(("CrWIN: Vidible [%d]", fVisible));
1510
1511 if (!fVisible != !mFlags.fVisible)
1512 {
1513 mFlags.fVisible = fVisible;
1514 if (mSpuWindow && mParentId)
1515 cr_server.head_spu->dispatch_table.WindowShow(mSpuWindow, fVisible);
1516 }
1517
1518 return VINF_SUCCESS;
1519 }
1520
1521 int SetSize(uint32_t width, uint32_t height)
1522 {
1523 if (!checkInitedUpdating())
1524 {
1525 WARN(("err"));
1526 return VERR_INVALID_STATE;
1527 }
1528
1529 LOG(("CrWIN: Size [%d ; %d]", width, height));
1530
1531 if (mWidth != width || mHeight != height)
1532 {
1533 mFlags.fCompositoEntriesModified = 1;
1534 mWidth = width;
1535 mHeight = height;
1536 if (mSpuWindow)
1537 cr_server.head_spu->dispatch_table.WindowSize(mSpuWindow, width, height);
1538 }
1539
1540 return VINF_SUCCESS;
1541 }
1542
1543 int SetPosition(int32_t x, int32_t y)
1544 {
1545 if (!checkInitedUpdating())
1546 {
1547 WARN(("err"));
1548 return VERR_INVALID_STATE;
1549 }
1550
1551 LOG(("CrWIN: Pos [%d ; %d]", x, y));
1552
1553 if (x != mxPos || y != myPos)
1554 {
1555 mxPos = x;
1556 myPos = y;
1557 if (mSpuWindow)
1558 cr_server.head_spu->dispatch_table.WindowPosition(mSpuWindow, x, y);
1559 }
1560
1561 return VINF_SUCCESS;
1562 }
1563
1564 int SetVisibleRegionsChanged()
1565 {
1566 if (!checkInitedUpdating())
1567 {
1568 WARN(("err"));
1569 return VERR_INVALID_STATE;
1570 }
1571
1572 mFlags.fCompositoEntriesModified = 1;
1573 return VINF_SUCCESS;
1574 }
1575
1576 int SetCompositor(const struct VBOXVR_SCR_COMPOSITOR * pCompositor)
1577 {
1578 if (!checkInitedUpdating())
1579 {
1580 WARN(("err"));
1581 return VERR_INVALID_STATE;
1582 }
1583
1584 mpCompositor = pCompositor;
1585 mFlags.fCompositoEntriesModified = 1;
1586 return VINF_SUCCESS;
1587 }
1588
1589 int UpdateBegin()
1590 {
1591 ++mcUpdates;
1592 if (mcUpdates > 1)
1593 return VINF_SUCCESS;
1594
1595 Assert(!mFlags.fForcePresentOnReenable);
1596// Assert(!mFlags.fCompositoEntriesModified);
1597
1598 if (mFlags.fDataPresented)
1599 {
1600 Assert(mSpuWindow);
1601 cr_server.head_spu->dispatch_table.VBoxPresentComposition(mSpuWindow, NULL, NULL);
1602 mFlags.fForcePresentOnReenable = isPresentNeeded();
1603 }
1604
1605 return VINF_SUCCESS;
1606 }
1607
1608 void UpdateEnd()
1609 {
1610 --mcUpdates;
1611 Assert(mcUpdates < UINT32_MAX/2);
1612 if (mcUpdates)
1613 return;
1614
1615 checkRegions();
1616
1617 if (mSpuWindow)
1618 {
1619 bool fPresentNeeded = isPresentNeeded();
1620 if (fPresentNeeded || mFlags.fForcePresentOnReenable)
1621 {
1622 mFlags.fForcePresentOnReenable = false;
1623 cr_server.head_spu->dispatch_table.VBoxPresentComposition(mSpuWindow, mpCompositor, NULL);
1624 }
1625
1626 /* even if the above branch is entered due to mFlags.fForcePresentOnReenable,
1627 * the backend should clean up the compositor as soon as presentation is performed */
1628 mFlags.fDataPresented = fPresentNeeded;
1629 }
1630 else
1631 {
1632 Assert(!mFlags.fDataPresented);
1633 Assert(!mFlags.fForcePresentOnReenable);
1634 }
1635 }
1636
1637 uint64_t GetParentId()
1638 {
1639 return mParentId;
1640 }
1641
1642 int Create()
1643 {
1644 if (mSpuWindow)
1645 {
1646 //WARN(("window already created"));
1647 return VINF_ALREADY_INITIALIZED;
1648 }
1649
1650 CRASSERT(cr_server.fVisualBitsDefault);
1651 renderspuSetWindowId(mParentId);
1652 mSpuWindow = cr_server.head_spu->dispatch_table.WindowCreate("", cr_server.fVisualBitsDefault);
1653 renderspuSetWindowId(cr_server.screen[0].winID);
1654 if (mSpuWindow < 0) {
1655 WARN(("WindowCreate failed"));
1656 return VERR_GENERAL_FAILURE;
1657 }
1658
1659 cr_server.head_spu->dispatch_table.WindowSize(mSpuWindow, mWidth, mHeight);
1660 cr_server.head_spu->dispatch_table.WindowPosition(mSpuWindow, mxPos, myPos);
1661
1662 checkRegions();
1663
1664 if (mParentId && mFlags.fVisible)
1665 cr_server.head_spu->dispatch_table.WindowShow(mSpuWindow, true);
1666
1667 return VINF_SUCCESS;
1668 }
1669
1670 ~CrFbWindow()
1671 {
1672 Destroy();
1673 }
1674protected:
1675 void checkRegions()
1676 {
1677 if (!mSpuWindow)
1678 return;
1679
1680 if (!mFlags.fCompositoEntriesModified)
1681 return;
1682
1683 uint32_t cRects;
1684 const RTRECT *pRects;
1685 if (mpCompositor)
1686 {
1687 int rc = CrVrScrCompositorRegionsGet(mpCompositor, &cRects, NULL, &pRects, NULL);
1688 if (!RT_SUCCESS(rc))
1689 {
1690 WARN(("CrVrScrCompositorRegionsGet failed rc %d", rc));
1691 cRects = 0;
1692 pRects = NULL;
1693 }
1694 }
1695 else
1696 {
1697 cRects = 0;
1698 pRects = NULL;
1699 }
1700
1701 cr_server.head_spu->dispatch_table.WindowVisibleRegion(mSpuWindow, cRects, (const GLint*)pRects);
1702
1703 mFlags.fCompositoEntriesModified = 0;
1704 }
1705
1706 bool isPresentNeeded()
1707 {
1708 return mFlags.fVisible && mWidth && mHeight && mpCompositor && !CrVrScrCompositorIsEmpty(mpCompositor);
1709 }
1710
1711 bool checkInitedUpdating()
1712 {
1713 if (!mcUpdates)
1714 {
1715 WARN(("not updating"));
1716 return false;
1717 }
1718
1719 return true;
1720 }
1721private:
1722 GLint mSpuWindow;
1723 const struct VBOXVR_SCR_COMPOSITOR * mpCompositor;
1724 uint32_t mcUpdates;
1725 int32_t mxPos;
1726 int32_t myPos;
1727 uint32_t mWidth;
1728 uint32_t mHeight;
1729 CR_FBWIN_FLAGS mFlags;
1730 uint64_t mParentId;
1731};
1732
1733class CrFbDisplayWindow : public CrFbDisplayBase
1734{
1735public:
1736 CrFbDisplayWindow(CrFbWindow *pWindow, const RTRECT *pViewportRect) :
1737 mpWindow(pWindow),
1738 mViewportRect(*pViewportRect)
1739 {
1740 CRASSERT(pWindow);
1741 }
1742
1743 virtual ~CrFbDisplayWindow()
1744 {
1745 if (mpWindow)
1746 delete mpWindow;
1747 }
1748
1749 virtual int UpdateBegin(struct CR_FRAMEBUFFER *pFb)
1750 {
1751 int rc = mpWindow->UpdateBegin();
1752 if (RT_SUCCESS(rc))
1753 {
1754 rc = CrFbDisplayBase::UpdateBegin(pFb);
1755 if (RT_SUCCESS(rc))
1756 return VINF_SUCCESS;
1757 else
1758 WARN(("err"));
1759 }
1760 else
1761 WARN(("err"));
1762
1763 return rc;
1764 }
1765
1766 virtual void UpdateEnd(struct CR_FRAMEBUFFER *pFb)
1767 {
1768 CrFbDisplayBase::UpdateEnd(pFb);
1769
1770 mpWindow->UpdateEnd();
1771 }
1772
1773 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1774 {
1775 int rc = CrFbDisplayBase::EntryCreated(pFb, hEntry);
1776 if (!RT_SUCCESS(rc))
1777 {
1778 WARN(("err"));
1779 return rc;
1780 }
1781
1782 if (mpWindow->GetParentId())
1783 {
1784 rc = mpWindow->Create();
1785 if (!RT_SUCCESS(rc))
1786 {
1787 WARN(("err"));
1788 return rc;
1789 }
1790 }
1791
1792 return VINF_SUCCESS;
1793 }
1794
1795 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
1796 {
1797 int rc = CrFbDisplayBase::EntryReplaced(pFb, hNewEntry, hReplacedEntry);
1798 if (!RT_SUCCESS(rc))
1799 {
1800 WARN(("err"));
1801 return rc;
1802 }
1803
1804 if (mpWindow->GetParentId())
1805 {
1806 rc = mpWindow->Create();
1807 if (!RT_SUCCESS(rc))
1808 {
1809 WARN(("err"));
1810 return rc;
1811 }
1812 }
1813
1814 return VINF_SUCCESS;
1815 }
1816
1817 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
1818 {
1819 int rc = CrFbDisplayBase::EntryTexChanged(pFb, hEntry);
1820 if (!RT_SUCCESS(rc))
1821 {
1822 WARN(("err"));
1823 return rc;
1824 }
1825
1826 if (mpWindow->GetParentId())
1827 {
1828 rc = mpWindow->Create();
1829 if (!RT_SUCCESS(rc))
1830 {
1831 WARN(("err"));
1832 return rc;
1833 }
1834 }
1835
1836 return VINF_SUCCESS;
1837 }
1838
1839 virtual int FramebufferChanged(struct CR_FRAMEBUFFER *pFb)
1840 {
1841 int rc = CrFbDisplayBase::FramebufferChanged(pFb);
1842 if (!RT_SUCCESS(rc))
1843 {
1844 WARN(("err"));
1845 return rc;
1846 }
1847
1848 return screenChanged();
1849 }
1850
1851 virtual int setViewportRect(const RTRECT *pViewportRect)
1852 {
1853 if (!isUpdating())
1854 {
1855 WARN(("not updating!"));
1856 return VERR_INVALID_STATE;
1857 }
1858
1859 if (pViewportRect->xLeft != mViewportRect.xLeft || pViewportRect->yTop != mViewportRect.yTop)
1860 {
1861 const RTRECT* pRect = CrVrScrCompositorRectGet(getCompositor());
1862 int rc = mpWindow->SetPosition(pRect->xLeft - mViewportRect.xLeft, pRect->yTop - mViewportRect.yTop);
1863 if (!RT_SUCCESS(rc))
1864 {
1865 WARN(("SetPosition failed"));
1866 return rc;
1867 }
1868 }
1869
1870 mViewportRect = *pViewportRect;
1871
1872 return VINF_SUCCESS;
1873 }
1874
1875 virtual CrFbWindow * windowDetach()
1876 {
1877 if (isUpdating())
1878 {
1879 WARN(("updating!"));
1880 return NULL;
1881 }
1882
1883 CrFbWindow * pWindow = mpWindow;
1884 if (mpWindow)
1885 {
1886 windowCleanup();
1887 mpWindow = NULL;
1888 }
1889 return pWindow;
1890 }
1891
1892 virtual CrFbWindow * windowAttach(CrFbWindow * pNewWindow)
1893 {
1894 if (isUpdating())
1895 {
1896 WARN(("updating!"));
1897 return NULL;
1898 }
1899
1900 CrFbWindow * pOld = mpWindow;
1901 if (mpWindow)
1902 windowDetach();
1903
1904 mpWindow = pNewWindow;
1905 if (pNewWindow)
1906 windowSync();
1907
1908 return mpWindow;
1909 }
1910
1911 virtual int reparent(uint64_t parentId)
1912 {
1913 if (!isUpdating())
1914 {
1915 WARN(("not updating!"));
1916 return VERR_INVALID_STATE;
1917 }
1918
1919 int rc = mpWindow->Reparent(parentId);
1920 if (!RT_SUCCESS(rc))
1921 WARN(("window reparent failed"));
1922
1923 return rc;
1924 }
1925
1926protected:
1927 virtual void ueRegions()
1928 {
1929 mpWindow->SetVisibleRegionsChanged();
1930 }
1931
1932 virtual int screenChanged()
1933 {
1934 if (!isUpdating())
1935 {
1936 WARN(("not updating!"));
1937 return VERR_INVALID_STATE;
1938 }
1939
1940 const RTRECT* pRect = CrVrScrCompositorRectGet(getCompositor());
1941 int rc = mpWindow->SetPosition(pRect->xLeft - mViewportRect.xLeft, pRect->yTop - mViewportRect.yTop);
1942 if (!RT_SUCCESS(rc))
1943 {
1944 WARN(("SetComposition failed rc %d", rc));
1945 return rc;
1946 }
1947
1948 setRegionsChanged();
1949
1950 return mpWindow->SetSize((uint32_t)(pRect->xRight - pRect->xLeft), (uint32_t)(pRect->yBottom - pRect->yTop));
1951 }
1952
1953 virtual int windowCleanup()
1954 {
1955 int rc = mpWindow->UpdateBegin();
1956 if (!RT_SUCCESS(rc))
1957 {
1958 WARN(("err"));
1959 return rc;
1960 }
1961
1962 rc = mpWindow->SetVisible(false);
1963 if (!RT_SUCCESS(rc))
1964 {
1965 WARN(("err"));
1966 mpWindow->UpdateEnd();
1967 return rc;
1968 }
1969
1970 rc = mpWindow->SetCompositor(NULL);
1971 if (!RT_SUCCESS(rc))
1972 {
1973 WARN(("err"));
1974 mpWindow->UpdateEnd();
1975 return rc;
1976 }
1977
1978 mpWindow->UpdateEnd();
1979
1980 return VINF_SUCCESS;
1981 }
1982
1983 virtual int fbCleanup()
1984 {
1985 int rc = windowCleanup();
1986 if (!RT_SUCCESS(rc))
1987 {
1988 WARN(("windowCleanup failed"));
1989 return rc;
1990 }
1991 return CrFbDisplayBase::fbCleanup();
1992 }
1993
1994 virtual int windowSync()
1995 {
1996 const struct VBOXVR_SCR_COMPOSITOR* pCompositor = getCompositor();
1997 const RTRECT* pRect = CrVrScrCompositorRectGet(pCompositor);
1998
1999 int rc = mpWindow->UpdateBegin();
2000 if (!RT_SUCCESS(rc))
2001 {
2002 WARN(("err"));
2003 return rc;
2004 }
2005
2006 rc = mpWindow->SetCompositor(pCompositor);
2007 if (!RT_SUCCESS(rc))
2008 {
2009 WARN(("err"));
2010 mpWindow->UpdateEnd();
2011 return rc;
2012 }
2013
2014 rc = mpWindow->SetPosition(pRect->xLeft - mViewportRect.xLeft, pRect->yTop - mViewportRect.yTop);
2015 if (!RT_SUCCESS(rc))
2016 {
2017 WARN(("err"));
2018 mpWindow->UpdateEnd();
2019 return rc;
2020 }
2021
2022 rc = mpWindow->SetSize((uint32_t)(pRect->xRight - pRect->xLeft), (uint32_t)(pRect->yBottom - pRect->yTop));
2023 if (!RT_SUCCESS(rc))
2024 {
2025 WARN(("err"));
2026 mpWindow->UpdateEnd();
2027 return rc;
2028 }
2029
2030 rc = mpWindow->SetVisible(true);
2031 if (!RT_SUCCESS(rc))
2032 {
2033 WARN(("err"));
2034 mpWindow->UpdateEnd();
2035 return rc;
2036 }
2037
2038 mpWindow->UpdateEnd();
2039
2040 return rc;
2041 }
2042
2043 virtual int fbSync()
2044 {
2045 int rc = CrFbDisplayBase::fbSync();
2046 if (!RT_SUCCESS(rc))
2047 {
2048 WARN(("err"));
2049 return rc;
2050 }
2051
2052 return windowSync();
2053 }
2054
2055 virtual const struct VBOXVR_SCR_COMPOSITOR* getCompositor()
2056 {
2057 return CrFbGetCompositor(getFramebuffer());
2058 }
2059
2060 CrFbWindow* getWindow() {return mpWindow;}
2061private:
2062 CrFbWindow *mpWindow;
2063 RTRECT mViewportRect;
2064};
2065
2066class CrFbDisplayWindowRootVr : public CrFbDisplayWindow
2067{
2068public:
2069 CrFbDisplayWindowRootVr(CrFbWindow *pWindow, const RTRECT *pViewportRect) :
2070 CrFbDisplayWindow(pWindow, pViewportRect)
2071 {
2072 CrVrScrCompositorInit(&mCompositor, NULL);
2073 memset(&mPos, 0, sizeof (mPos));
2074 }
2075
2076 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2077 {
2078 int rc = CrFbDisplayWindow::EntryCreated(pFb, hEntry);
2079 if (!RT_SUCCESS(rc))
2080 {
2081 WARN(("err"));
2082 return rc;
2083 }
2084
2085 Assert(!CrFbDDataEntryGet(hEntry, slotGet()));
2086
2087 const VBOXVR_SCR_COMPOSITOR_ENTRY* pSrcEntry = CrFbEntryGetCompositorEntry(hEntry);
2088 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = entryAlloc();
2089 CrVrScrCompositorEntryInit(pMyEntry, CrVrScrCompositorEntryRectGet(pSrcEntry), CrVrScrCompositorEntryTexGet(pSrcEntry), NULL);
2090 CrVrScrCompositorEntryFlagsSet(pMyEntry, CrVrScrCompositorEntryFlagsGet(pSrcEntry));
2091 rc = CrFbDDataEntryPut(hEntry, slotGet(), pMyEntry);
2092 if (!RT_SUCCESS(rc))
2093 {
2094 WARN(("CrFbDDataEntryPut failed rc %d", rc));
2095 entryFree(pMyEntry);
2096 return rc;
2097 }
2098
2099 return VINF_SUCCESS;
2100 }
2101
2102 virtual int EntryAdded(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2103 {
2104 int rc = CrFbDisplayWindow::EntryAdded(pFb, hEntry);
2105 if (!RT_SUCCESS(rc))
2106 {
2107 WARN(("err"));
2108 return rc;
2109 }
2110
2111 const VBOXVR_SCR_COMPOSITOR_ENTRY* pSrcEntry = CrFbEntryGetCompositorEntry(hEntry);
2112 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hEntry, slotGet());
2113 Assert(pMyEntry);
2114 CrVrScrCompositorEntryTexSet(pMyEntry, CrVrScrCompositorEntryTexGet(pSrcEntry));
2115
2116 return VINF_SUCCESS;
2117 }
2118
2119 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
2120 {
2121 int rc = CrFbDisplayWindow::EntryReplaced(pFb, hNewEntry, hReplacedEntry);
2122 if (!RT_SUCCESS(rc))
2123 {
2124 WARN(("err"));
2125 return rc;
2126 }
2127
2128 const VBOXVR_SCR_COMPOSITOR_ENTRY* pSrcNewEntry = CrFbEntryGetCompositorEntry(hNewEntry);
2129 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hNewEntry, slotGet());
2130 CrVrScrCompositorEntryTexSet(pMyEntry, CrVrScrCompositorEntryTexGet(pSrcNewEntry));
2131
2132 return VINF_SUCCESS;
2133 }
2134
2135 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2136 {
2137 int rc = CrFbDisplayWindow::EntryTexChanged(pFb, hEntry);
2138 if (!RT_SUCCESS(rc))
2139 {
2140 WARN(("err"));
2141 return rc;
2142 }
2143
2144 const VBOXVR_SCR_COMPOSITOR_ENTRY* pSrcEntry = CrFbEntryGetCompositorEntry(hEntry);
2145 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hEntry, slotGet());
2146 CrVrScrCompositorEntryTexSet(pMyEntry, CrVrScrCompositorEntryTexGet(pSrcEntry));
2147
2148 return VINF_SUCCESS;
2149 }
2150
2151 virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2152 {
2153 int rc = CrFbDisplayWindow::EntryRemoved(pFb, hEntry);
2154 if (!RT_SUCCESS(rc))
2155 {
2156 WARN(("err"));
2157 return rc;
2158 }
2159
2160 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hEntry, slotGet());
2161 rc = CrVrScrCompositorEntryRegionsSet(&mCompositor, pMyEntry, NULL, 0, NULL, false, NULL);
2162 if (!RT_SUCCESS(rc))
2163 {
2164 WARN(("err"));
2165 return rc;
2166 }
2167
2168 return VINF_SUCCESS;
2169 }
2170
2171 virtual int EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2172 {
2173 int rc = CrFbDisplayWindow::EntryDestroyed(pFb, hEntry);
2174 if (!RT_SUCCESS(rc))
2175 {
2176 WARN(("err"));
2177 return rc;
2178 }
2179
2180 const VBOXVR_SCR_COMPOSITOR_ENTRY* pSrcEntry = CrFbEntryGetCompositorEntry(hEntry);
2181 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hEntry, slotGet());
2182 CrVrScrCompositorEntryCleanup(pMyEntry);
2183 entryFree(pMyEntry);
2184
2185 return VINF_SUCCESS;
2186 }
2187
2188 virtual int setViewportRect(const RTRECT *pViewportRect)
2189 {
2190 int rc = CrFbDisplayWindow::setViewportRect(pViewportRect);
2191 if (!RT_SUCCESS(rc))
2192 {
2193 WARN(("err"));
2194 return rc;
2195 }
2196
2197 rc = synchCompositorData();
2198 if (!RT_SUCCESS(rc))
2199 {
2200 WARN(("err"));
2201 return rc;
2202 }
2203
2204 return VINF_SUCCESS;
2205 }
2206
2207protected:
2208 virtual void ueRegions()
2209 {
2210 synchCompositorRegions();
2211 }
2212
2213 virtual int screenChanged()
2214 {
2215 int rc = CrFbDisplayWindow::screenChanged();
2216 if (!RT_SUCCESS(rc))
2217 {
2218 WARN(("screenChanged failed %d", rc));
2219 return rc;
2220 }
2221
2222 rc = synchCompositorData();
2223 if (!RT_SUCCESS(rc))
2224 {
2225 WARN(("err"));
2226 return rc;
2227 }
2228
2229 return VINF_SUCCESS;
2230 }
2231
2232 virtual const struct VBOXVR_SCR_COMPOSITOR* getCompositor()
2233 {
2234 return &mCompositor;
2235 }
2236
2237 virtual int fbCleanup()
2238 {
2239 int rc = clearCompositor();
2240 if (!RT_SUCCESS(rc))
2241 {
2242 WARN(("err"));
2243 return rc;
2244 }
2245
2246 return CrFbDisplayWindow::fbCleanup();
2247 }
2248
2249 virtual int fbSync()
2250 {
2251 int rc = synchCompositor();
2252 if (!RT_SUCCESS(rc))
2253 {
2254 WARN(("err"));
2255 return rc;
2256 }
2257
2258 return CrFbDisplayWindow::fbSync();
2259 }
2260
2261 VBOXVR_SCR_COMPOSITOR_ENTRY* entryAlloc()
2262 {
2263#ifndef VBOXVDBG_MEMCACHE_DISABLE
2264 return (VBOXVR_SCR_COMPOSITOR_ENTRY*)RTMemCacheAlloc(g_CrPresenter.CEntryLookasideList);
2265#else
2266 return (VBOXVR_SCR_COMPOSITOR_ENTRY*)RTMemAlloc(sizeof (VBOXVR_SCR_COMPOSITOR_ENTRY));
2267#endif
2268 }
2269
2270 void entryFree(VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry)
2271 {
2272 Assert(!CrVrScrCompositorEntryIsUsed(pEntry));
2273#ifndef VBOXVDBG_MEMCACHE_DISABLE
2274 RTMemCacheFree(g_CrPresenter.CEntryLookasideList, pEntry);
2275#else
2276 RTMemFree(pEntry);
2277#endif
2278 }
2279
2280 int synchCompositorRegions()
2281 {
2282 int rc;
2283
2284 rootVrTranslateForPos();
2285
2286 /* ensure the rootvr compositor does not hold any data,
2287 * i.e. cleanup all rootvr entries data */
2288 CrVrScrCompositorClear(&mCompositor);
2289
2290 rc = CrVrScrCompositorIntersectedList(CrFbGetCompositor(getFramebuffer()), &cr_server.RootVr, &mCompositor, rootVrGetCEntry, this, NULL);
2291 if (!RT_SUCCESS(rc))
2292 {
2293 WARN(("CrVrScrCompositorIntersectedList failed, rc %d", rc));
2294 return rc;
2295 }
2296
2297 return getWindow()->SetVisibleRegionsChanged();
2298 }
2299
2300 int synchCompositorData()
2301 {
2302 CrVrScrCompositorClear(&mCompositor);
2303
2304 const struct VBVAINFOSCREEN* pScreenInfo = CrFbGetScreenInfo(getFramebuffer());
2305 mPos.x = pScreenInfo->i32OriginX;
2306 mPos.y = pScreenInfo->i32OriginY;
2307
2308 int rc = CrVrScrCompositorRectSet(&mCompositor, CrVrScrCompositorRectGet(CrFbGetCompositor(getFramebuffer())), NULL);
2309 if (!RT_SUCCESS(rc))
2310 {
2311 WARN(("CrVrScrCompositorRectSet failed, rc %d", rc));
2312 return rc;
2313 }
2314 rc = synchCompositorRegions();
2315 if (!RT_SUCCESS(rc))
2316 {
2317 WARN(("synchCompositorRegions failed, rc %d", rc));
2318 return rc;
2319 }
2320
2321 return rc;
2322 }
2323
2324 virtual int synchCompositor()
2325 {
2326 int rc = CrVrScrCompositorRectSet(&mCompositor, CrVrScrCompositorRectGet(CrFbGetCompositor(getFramebuffer())), NULL);
2327 if (!RT_SUCCESS(rc))
2328 {
2329 WARN(("CrVrScrCompositorRectSet failed, rc %d", rc));
2330 return rc;
2331 }
2332
2333 rc = fbSynchAddAllEntries();
2334 if (!RT_SUCCESS(rc))
2335 {
2336 WARN(("fbSynchAddAllEntries failed, rc %d", rc));
2337 return rc;
2338 }
2339
2340 rc = synchCompositorRegions();
2341 if (!RT_SUCCESS(rc))
2342 {
2343 WARN(("synchCompositorRegions failed, rc %d", rc));
2344 return rc;
2345 }
2346
2347 return rc;
2348 }
2349
2350 virtual int clearCompositor()
2351 {
2352 return fbCleanupRemoveAllEntries(true);
2353 }
2354
2355 void rootVrTranslateForPos()
2356 {
2357 int32_t dx = cr_server.RootVrCurPoint.x - mPos.x;
2358 int32_t dy = cr_server.RootVrCurPoint.y - mPos.y;
2359
2360 cr_server.RootVrCurPoint.x = mPos.x;
2361 cr_server.RootVrCurPoint.y = mPos.y;
2362
2363 VBoxVrListTranslate(&cr_server.RootVr, dx, dy);
2364 }
2365
2366 static DECLCALLBACK(VBOXVR_SCR_COMPOSITOR_ENTRY*) rootVrGetCEntry(const VBOXVR_SCR_COMPOSITOR_ENTRY*pEntry, void *pvContext)
2367 {
2368 CrFbDisplayWindowRootVr *pThis = (CrFbDisplayWindowRootVr*)pvContext;
2369 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
2370 VBOXVR_SCR_COMPOSITOR_ENTRY *pMyEntry = (VBOXVR_SCR_COMPOSITOR_ENTRY*)CrFbDDataEntryGet(hEntry, pThis->slotGet());
2371 Assert(!CrVrScrCompositorEntryIsUsed(pMyEntry));
2372 CrVrScrCompositorEntryRectSet(&pThis->mCompositor, pMyEntry, CrVrScrCompositorEntryRectGet(pEntry));
2373 return pMyEntry;
2374 }
2375private:
2376 VBOXVR_SCR_COMPOSITOR mCompositor;
2377 RTPOINT mPos;
2378};
2379
2380class CrFbDisplayVrdp : public CrFbDisplayBase
2381{
2382public:
2383 CrFbDisplayVrdp()
2384 {
2385 memset(&mPos, 0, sizeof (mPos));
2386 }
2387
2388 virtual int EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2389 {
2390 int rc = CrFbDisplayBase::EntryCreated(pFb, hEntry);
2391 if (!RT_SUCCESS(rc))
2392 {
2393 WARN(("EntryAdded failed rc %d", rc));
2394 return rc;
2395 }
2396
2397 Assert(!CrFbDDataEntryGet(hEntry, slotGet()));
2398 rc = vrdpCreate(pFb, hEntry);
2399 if (!RT_SUCCESS(rc))
2400 {
2401 WARN(("vrdpCreate failed rc %d", rc));
2402 return rc;
2403 }
2404
2405 return VINF_SUCCESS;
2406 }
2407
2408 virtual int EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
2409 {
2410 int rc = CrFbDisplayBase::EntryReplaced(pFb, hNewEntry, hReplacedEntry);
2411 if (!RT_SUCCESS(rc))
2412 {
2413 WARN(("err"));
2414 return rc;
2415 }
2416
2417 return vrdpFrame(hNewEntry);
2418 }
2419
2420 virtual int EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2421 {
2422 int rc = CrFbDisplayBase::EntryTexChanged(pFb, hEntry);
2423 if (!RT_SUCCESS(rc))
2424 {
2425 WARN(("err"));
2426 return rc;
2427 }
2428
2429 return vrdpFrame(hEntry);
2430 }
2431
2432 virtual int EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2433 {
2434 int rc = CrFbDisplayBase::EntryRemoved(pFb, hEntry);
2435 if (!RT_SUCCESS(rc))
2436 {
2437 WARN(("err"));
2438 return rc;
2439 }
2440
2441 return vrdpRegions(pFb, hEntry);
2442 }
2443
2444 virtual int EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2445 {
2446 int rc = CrFbDisplayBase::EntryDestroyed(pFb, hEntry);
2447 if (!RT_SUCCESS(rc))
2448 {
2449 WARN(("err"));
2450 return rc;
2451 }
2452
2453 vrdpDestroy(hEntry);
2454 return VINF_SUCCESS;
2455 }
2456
2457 virtual int EntryPosChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2458 {
2459 int rc = CrFbDisplayBase::EntryPosChanged(pFb, hEntry);
2460 if (!RT_SUCCESS(rc))
2461 {
2462 WARN(("err"));
2463 return rc;
2464 }
2465
2466 vrdpGeometry(hEntry);
2467
2468 return VINF_SUCCESS;
2469 }
2470
2471 virtual int RegionsChanged(struct CR_FRAMEBUFFER *pFb)
2472 {
2473 int rc = CrFbDisplayBase::RegionsChanged(pFb);
2474 if (!RT_SUCCESS(rc))
2475 {
2476 WARN(("err"));
2477 return rc;
2478 }
2479
2480 return vrdpRegionsAll(pFb);
2481 }
2482
2483 virtual int FramebufferChanged(struct CR_FRAMEBUFFER *pFb)
2484 {
2485 int rc = CrFbDisplayBase::FramebufferChanged(pFb);
2486 if (!RT_SUCCESS(rc))
2487 {
2488 WARN(("err"));
2489 return rc;
2490 }
2491
2492 syncPos();
2493
2494 rc = vrdpSyncEntryAll(pFb);
2495 if (!RT_SUCCESS(rc))
2496 {
2497 WARN(("err"));
2498 return rc;
2499 }
2500
2501 return vrdpRegionsAll(pFb);
2502 }
2503
2504protected:
2505 void syncPos()
2506 {
2507 const struct VBVAINFOSCREEN* pScreenInfo = CrFbGetScreenInfo(getFramebuffer());
2508 mPos.x = pScreenInfo->i32OriginX;
2509 mPos.y = pScreenInfo->i32OriginY;
2510 }
2511
2512 virtual int fbCleanup()
2513 {
2514 int rc = fbCleanupRemoveAllEntries(true);
2515 if (!RT_SUCCESS(rc))
2516 {
2517 WARN(("err"));
2518 return rc;
2519 }
2520
2521 return CrFbDisplayBase::fbCleanup();
2522 }
2523
2524 virtual int fbSync()
2525 {
2526 syncPos();
2527
2528 int rc = fbSynchAddAllEntries();
2529 if (!RT_SUCCESS(rc))
2530 {
2531 WARN(("err"));
2532 return rc;
2533 }
2534
2535 return CrFbDisplayBase::fbSync();
2536 }
2537protected:
2538 void vrdpDestroy(HCR_FRAMEBUFFER_ENTRY hEntry)
2539 {
2540 void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
2541 cr_server.outputRedirect.CROREnd(pVrdp);
2542 }
2543
2544 void vrdpGeometry(HCR_FRAMEBUFFER_ENTRY hEntry)
2545 {
2546 void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
2547 const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
2548
2549 cr_server.outputRedirect.CRORGeometry(pVrdp,
2550 mPos.x + CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
2551 mPos.y + CrVrScrCompositorEntryRectGet(pEntry)->yTop,
2552 CrVrScrCompositorEntryTexGet(pEntry)->Tex.width,
2553 CrVrScrCompositorEntryTexGet(pEntry)->Tex.height);
2554 }
2555
2556 int vrdpRegions(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2557 {
2558 void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
2559 const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
2560 const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
2561 uint32_t cRects;
2562 const RTRECT *pRects;
2563
2564 int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRects, NULL, &pRects, NULL);
2565 if (!RT_SUCCESS(rc))
2566 {
2567 WARN(("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc));
2568 return rc;
2569 }
2570
2571 cr_server.outputRedirect.CRORVisibleRegion(pVrdp, cRects, pRects);
2572 return VINF_SUCCESS;
2573 }
2574
2575 int vrdpFrame(HCR_FRAMEBUFFER_ENTRY hEntry)
2576 {
2577 void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
2578 const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
2579 CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
2580 const CR_BLITTER_IMG *pImg;
2581 int rc = CrTdBltDataAcquire(pTex, GL_BGRA, !!(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS), &pImg);
2582 if (!RT_SUCCESS(rc))
2583 {
2584 WARN(("CrTdBltDataAcquire failed rc %d", rc));
2585 return rc;
2586 }
2587
2588 cr_server.outputRedirect.CRORFrame(pVrdp, pImg->pvData, pImg->cbData);
2589 CrTdBltDataRelease(pTex);
2590 return VINF_SUCCESS;
2591 }
2592
2593 int vrdpRegionsAll(struct CR_FRAMEBUFFER *pFb)
2594 {
2595 const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
2596 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
2597 CrVrScrCompositorConstIterInit(pCompositor, &Iter);
2598 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
2599 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
2600 {
2601 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
2602 vrdpRegions(pFb, hEntry);
2603 }
2604
2605 return VINF_SUCCESS;
2606 }
2607
2608 int vrdpSynchEntry(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2609 {
2610 vrdpGeometry(hEntry);
2611
2612 return vrdpRegions(pFb, hEntry);;
2613 }
2614
2615 int vrdpSyncEntryAll(struct CR_FRAMEBUFFER *pFb)
2616 {
2617 const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
2618 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
2619 CrVrScrCompositorConstIterInit(pCompositor, &Iter);
2620 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
2621 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
2622 {
2623 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
2624 int rc = vrdpSynchEntry(pFb, hEntry);
2625 if (!RT_SUCCESS(rc))
2626 {
2627 WARN(("vrdpSynchEntry failed rc %d", rc));
2628 return rc;
2629 }
2630 }
2631
2632 return VINF_SUCCESS;
2633 }
2634
2635 int vrdpCreate(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry)
2636 {
2637 void *pVrdp;
2638
2639 /* Query supported formats. */
2640 uint32_t cbFormats = 4096;
2641 char *pachFormats = (char *)crAlloc(cbFormats);
2642
2643 if (!pachFormats)
2644 {
2645 WARN(("crAlloc failed"));
2646 return VERR_NO_MEMORY;
2647 }
2648
2649 int rc = cr_server.outputRedirect.CRORContextProperty(cr_server.outputRedirect.pvContext,
2650 0 /* H3DOR_PROP_FORMATS */, // @todo from a header
2651 pachFormats, cbFormats, &cbFormats);
2652 if (RT_SUCCESS(rc))
2653 {
2654 if (RTStrStr(pachFormats, "H3DOR_FMT_RGBA_TOPDOWN"))
2655 {
2656 cr_server.outputRedirect.CRORBegin(cr_server.outputRedirect.pvContext,
2657 &pVrdp,
2658 "H3DOR_FMT_RGBA_TOPDOWN"); // @todo from a header
2659
2660 if (pVrdp)
2661 {
2662 rc = CrFbDDataEntryPut(hEntry, slotGet(), pVrdp);
2663 if (RT_SUCCESS(rc))
2664 {
2665 vrdpGeometry(hEntry);
2666 vrdpRegions(hFb, hEntry);
2667 //vrdpFrame(hEntry);
2668 return VINF_SUCCESS;
2669 }
2670 else
2671 WARN(("CrFbDDataEntryPut failed rc %d", rc));
2672
2673 cr_server.outputRedirect.CROREnd(pVrdp);
2674 }
2675 else
2676 {
2677 WARN(("CRORBegin failed"));
2678 rc = VERR_GENERAL_FAILURE;
2679 }
2680 }
2681 }
2682 else
2683 WARN(("CRORContextProperty failed rc %d", rc));
2684
2685 crFree(pachFormats);
2686
2687 return rc;
2688 }
2689private:
2690 RTPOINT mPos;
2691};
2692
2693CrFbDisplayBase::~CrFbDisplayBase()
2694{
2695 Assert(!mcUpdates);
2696
2697 if (mpContainer)
2698 mpContainer->remove(this);
2699}
2700
2701
2702#if 0
2703
2704
2705
2706
2707
2708void crDbgDumpRect(uint32_t i, const RTRECT *pRect)
2709{
2710 crDebug("%d: (%d;%d) X (%d;%d)", i, pRect->xLeft, pRect->yTop, pRect->xRight, pRect->yBottom);
2711}
2712
2713void crDbgDumpRects(uint32_t cRects, const RTRECT *paRects)
2714{
2715 crDebug("Dumping rects (%d)", cRects);
2716 for (uint32_t i = 0; i < cRects; ++i)
2717 {
2718 crDbgDumpRect(i, &paRects[i]);
2719 }
2720 crDebug("End Dumping rects (%d)", cRects);
2721}
2722
2723int crServerDisplaySaveState(PSSMHANDLE pSSM)
2724{
2725 int rc;
2726 int cDisplays = 0, i;
2727 for (i = 0; i < cr_server.screenCount; ++i)
2728 {
2729 if (ASMBitTest(cr_server.DisplaysInitMap, i) && !CrDpIsEmpty(&cr_server.aDispplays[i]))
2730 ++cDisplays;
2731 }
2732
2733 rc = SSMR3PutS32(pSSM, cDisplays);
2734 AssertRCReturn(rc, rc);
2735
2736 if (!cDisplays)
2737 return VINF_SUCCESS;
2738
2739 rc = SSMR3PutS32(pSSM, cr_server.screenCount);
2740 AssertRCReturn(rc, rc);
2741
2742 for (i = 0; i < cr_server.screenCount; ++i)
2743 {
2744 rc = SSMR3PutS32(pSSM, cr_server.screen[i].x);
2745 AssertRCReturn(rc, rc);
2746
2747 rc = SSMR3PutS32(pSSM, cr_server.screen[i].y);
2748 AssertRCReturn(rc, rc);
2749
2750 rc = SSMR3PutU32(pSSM, cr_server.screen[i].w);
2751 AssertRCReturn(rc, rc);
2752
2753 rc = SSMR3PutU32(pSSM, cr_server.screen[i].h);
2754 AssertRCReturn(rc, rc);
2755 }
2756
2757 for (i = 0; i < cr_server.screenCount; ++i)
2758 {
2759 if (ASMBitTest(cr_server.DisplaysInitMap, i) && !CrDpIsEmpty(&cr_server.aDispplays[i]))
2760 {
2761 rc = SSMR3PutS32(pSSM, i);
2762 AssertRCReturn(rc, rc);
2763
2764 rc = CrDpSaveState(&cr_server.aDispplays[i], pSSM);
2765 AssertRCReturn(rc, rc);
2766 }
2767 }
2768
2769 return VINF_SUCCESS;
2770}
2771
2772int crServerDisplayLoadState(PSSMHANDLE pSSM, uint32_t u32Version)
2773{
2774
2775}
2776#endif
2777
2778int CrPMgrInit()
2779{
2780 int rc = VINF_SUCCESS;
2781 memset(&g_CrPresenter, 0, sizeof (g_CrPresenter));
2782 g_CrPresenter.pFbTexMap = crAllocHashtable();
2783 if (g_CrPresenter.pFbTexMap)
2784 {
2785#ifndef VBOXVDBG_MEMCACHE_DISABLE
2786 rc = RTMemCacheCreate(&g_CrPresenter.FbEntryLookasideList, sizeof (CR_FRAMEBUFFER_ENTRY),
2787 0, /* size_t cbAlignment */
2788 UINT32_MAX, /* uint32_t cMaxObjects */
2789 NULL, /* PFNMEMCACHECTOR pfnCtor*/
2790 NULL, /* PFNMEMCACHEDTOR pfnDtor*/
2791 NULL, /* void *pvUser*/
2792 0 /* uint32_t fFlags*/
2793 );
2794 if (RT_SUCCESS(rc))
2795 {
2796 rc = RTMemCacheCreate(&g_CrPresenter.FbTexLookasideList, sizeof (CR_FBTEX),
2797 0, /* size_t cbAlignment */
2798 UINT32_MAX, /* uint32_t cMaxObjects */
2799 NULL, /* PFNMEMCACHECTOR pfnCtor*/
2800 NULL, /* PFNMEMCACHEDTOR pfnDtor*/
2801 NULL, /* void *pvUser*/
2802 0 /* uint32_t fFlags*/
2803 );
2804 if (RT_SUCCESS(rc))
2805 {
2806 rc = RTMemCacheCreate(&g_CrPresenter.CEntryLookasideList, sizeof (VBOXVR_SCR_COMPOSITOR_ENTRY),
2807 0, /* size_t cbAlignment */
2808 UINT32_MAX, /* uint32_t cMaxObjects */
2809 NULL, /* PFNMEMCACHECTOR pfnCtor*/
2810 NULL, /* PFNMEMCACHEDTOR pfnDtor*/
2811 NULL, /* void *pvUser*/
2812 0 /* uint32_t fFlags*/
2813 );
2814 if (RT_SUCCESS(rc))
2815 {
2816#endif
2817 rc = crPMgrModeModifyGlobal(CR_PMGR_MODE_WINDOW, true);
2818 if (RT_SUCCESS(rc))
2819 return VINF_SUCCESS;
2820 else
2821 WARN(("crPMgrModeModifyGlobal failed rc %d", rc));
2822#ifndef VBOXVDBG_MEMCACHE_DISABLE
2823 RTMemCacheDestroy(g_CrPresenter.CEntryLookasideList);
2824 }
2825 else
2826 WARN(("RTMemCacheCreate failed rc %d", rc));
2827
2828 RTMemCacheDestroy(g_CrPresenter.FbTexLookasideList);
2829 }
2830 else
2831 WARN(("RTMemCacheCreate failed rc %d", rc));
2832
2833 RTMemCacheDestroy(g_CrPresenter.FbEntryLookasideList);
2834 }
2835 else
2836 WARN(("RTMemCacheCreate failed rc %d", rc));
2837#endif
2838 }
2839 else
2840 {
2841 WARN(("crAllocHashtable failed"));
2842 rc = VERR_NO_MEMORY;
2843 }
2844 return rc;
2845}
2846
2847void CrPMgrTerm()
2848{
2849 crPMgrModeModifyGlobal(CR_PMGR_MODE_ALL, false);
2850
2851 HCR_FRAMEBUFFER hFb;
2852
2853 for (hFb = CrPMgrFbGetFirstInitialized();
2854 hFb;
2855 hFb = CrPMgrFbGetNextInitialized(hFb))
2856 {
2857 uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
2858 CrFbDisplaySet(hFb, NULL);
2859 CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
2860
2861 if (pInfo->pDpComposite)
2862 delete pInfo->pDpComposite;
2863
2864 Assert(!pInfo->pDpWin);
2865 Assert(!pInfo->pDpWinRootVr);
2866 Assert(!pInfo->pDpVrdp);
2867
2868 CrFbTerm(hFb);
2869 }
2870
2871#ifndef VBOXVDBG_MEMCACHE_DISABLE
2872 RTMemCacheDestroy(g_CrPresenter.FbEntryLookasideList);
2873 RTMemCacheDestroy(g_CrPresenter.FbTexLookasideList);
2874 RTMemCacheDestroy(g_CrPresenter.CEntryLookasideList);
2875#endif
2876 crFreeHashtable(g_CrPresenter.pFbTexMap, NULL);
2877
2878 memset(&g_CrPresenter, 0, sizeof (g_CrPresenter));
2879}
2880
2881HCR_FRAMEBUFFER CrPMgrFbGet(uint32_t idScreen)
2882{
2883 if (idScreen >= CR_MAX_GUEST_MONITORS)
2884 {
2885 WARN(("invalid idScreen %d", idScreen));
2886 return NULL;
2887 }
2888
2889 if (!CrFBmIsSet(&g_CrPresenter.FramebufferInitMap, idScreen))
2890 {
2891 CrFbInit(&g_CrPresenter.aFramebuffers[idScreen], idScreen);
2892 CrFBmSet(&g_CrPresenter.FramebufferInitMap, idScreen);
2893 }
2894 else
2895 Assert(g_CrPresenter.aFramebuffers[idScreen].ScreenInfo.u32ViewIndex == idScreen);
2896
2897 return &g_CrPresenter.aFramebuffers[idScreen];
2898}
2899
2900HCR_FRAMEBUFFER CrPMgrFbGetInitialized(uint32_t idScreen)
2901{
2902 if (idScreen >= CR_MAX_GUEST_MONITORS)
2903 {
2904 WARN(("invalid idScreen %d", idScreen));
2905 return NULL;
2906 }
2907
2908 if (!CrFBmIsSet(&g_CrPresenter.FramebufferInitMap, idScreen))
2909 {
2910 return NULL;
2911 }
2912 else
2913 Assert(g_CrPresenter.aFramebuffers[idScreen].ScreenInfo.u32ViewIndex == idScreen);
2914
2915 return &g_CrPresenter.aFramebuffers[idScreen];
2916}
2917
2918HCR_FRAMEBUFFER CrPMgrFbGetEnabled(uint32_t idScreen)
2919{
2920 HCR_FRAMEBUFFER hFb = CrPMgrFbGetInitialized(idScreen);
2921
2922 if(hFb && CrFbIsEnabled(hFb))
2923 return hFb;
2924
2925 return NULL;
2926}
2927
2928static HCR_FRAMEBUFFER crPMgrFbGetNextEnabled(uint32_t i)
2929{
2930 for (;i < cr_server.screenCount; ++i)
2931 {
2932 HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(i);
2933 if (hFb)
2934 return hFb;
2935 }
2936
2937 return NULL;
2938}
2939
2940static HCR_FRAMEBUFFER crPMgrFbGetNextInitialized(uint32_t i)
2941{
2942 for (;i < cr_server.screenCount; ++i)
2943 {
2944 HCR_FRAMEBUFFER hFb = CrPMgrFbGetInitialized(i);
2945 if (hFb)
2946 return hFb;
2947 }
2948
2949 return NULL;
2950}
2951
2952HCR_FRAMEBUFFER CrPMgrFbGetFirstEnabled()
2953{
2954 HCR_FRAMEBUFFER hFb = crPMgrFbGetNextEnabled(0);
2955// if (!hFb)
2956// WARN(("no enabled framebuffer found"));
2957 return hFb;
2958}
2959
2960HCR_FRAMEBUFFER CrPMgrFbGetNextEnabled(HCR_FRAMEBUFFER hFb)
2961{
2962 return crPMgrFbGetNextEnabled(hFb->ScreenInfo.u32ViewIndex+1);
2963}
2964
2965HCR_FRAMEBUFFER CrPMgrFbGetFirstInitialized()
2966{
2967 HCR_FRAMEBUFFER hFb = crPMgrFbGetNextInitialized(0);
2968// if (!hFb)
2969// WARN(("no initialized framebuffer found"));
2970 return hFb;
2971}
2972
2973HCR_FRAMEBUFFER CrPMgrFbGetNextInitialized(HCR_FRAMEBUFFER hFb)
2974{
2975 return crPMgrFbGetNextInitialized(hFb->ScreenInfo.u32ViewIndex+1);
2976}
2977
2978static uint32_t crPMgrModeAdjustVal(uint32_t u32Mode)
2979{
2980 u32Mode = CR_PMGR_MODE_ALL & u32Mode;
2981 if (CR_PMGR_MODE_ROOTVR & u32Mode)
2982 u32Mode &= ~CR_PMGR_MODE_WINDOW;
2983 return u32Mode;
2984}
2985
2986int CrPMgrScreenChanged(uint32_t idScreen)
2987{
2988 if (idScreen >= CR_MAX_GUEST_MONITORS)
2989 {
2990 WARN(("invalid idScreen %d", idScreen));
2991 return VERR_INVALID_PARAMETER;
2992 }
2993
2994 CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
2995 if (pInfo->pDpWin)
2996 {
2997 HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen);
2998 if (CrFbIsUpdating(hFb))
2999 {
3000 WARN(("trying to update viewport while framebuffer is being updated"));
3001 return VERR_INVALID_STATE;
3002 }
3003
3004 int rc = pInfo->pDpWin->UpdateBegin(hFb);
3005 if (RT_SUCCESS(rc))
3006 {
3007 pInfo->pDpWin->reparent(cr_server.screen[idScreen].winID);
3008
3009 pInfo->pDpWin->UpdateEnd(hFb);
3010 }
3011 else
3012 WARN(("UpdateBegin failed %d", rc));
3013 }
3014
3015 return VINF_SUCCESS;
3016}
3017
3018int CrPMgrViewportUpdate(uint32_t idScreen)
3019{
3020 if (idScreen >= CR_MAX_GUEST_MONITORS)
3021 {
3022 WARN(("invalid idScreen %d", idScreen));
3023 return VERR_INVALID_PARAMETER;
3024 }
3025
3026 CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
3027 if (pInfo->pDpWin)
3028 {
3029 HCR_FRAMEBUFFER hFb = CrPMgrFbGet(idScreen);
3030 if (CrFbIsUpdating(hFb))
3031 {
3032 WARN(("trying to update viewport while framebuffer is being updated"));
3033 return VERR_INVALID_STATE;
3034 }
3035
3036 int rc = pInfo->pDpWin->UpdateBegin(hFb);
3037 if (RT_SUCCESS(rc))
3038 {
3039 pInfo->pDpWin->setViewportRect(&cr_server.screenVieport[idScreen].Rect);
3040 pInfo->pDpWin->UpdateEnd(hFb);
3041 }
3042 else
3043 WARN(("UpdateBegin failed %d", rc));
3044 }
3045
3046 return VINF_SUCCESS;
3047}
3048
3049int CrPMgrModeModify(HCR_FRAMEBUFFER hFb, uint32_t u32ModeAdd, uint32_t u32ModeRemove)
3050{
3051 uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
3052
3053 CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
3054 u32ModeRemove = ((u32ModeRemove | crPMgrModeAdjustVal(u32ModeRemove)) & CR_PMGR_MODE_ALL);
3055 u32ModeAdd = crPMgrModeAdjustVal(u32ModeAdd);
3056 u32ModeRemove &= pInfo->u32Mode;
3057 u32ModeAdd &= ~(u32ModeRemove | pInfo->u32Mode);
3058 uint32_t u32ModeResulting = ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove);
3059 uint32_t u32Tmp = crPMgrModeAdjustVal(u32ModeResulting);
3060 if (u32Tmp != u32ModeResulting)
3061 {
3062 u32ModeAdd |= (u32Tmp & ~u32ModeResulting);
3063 u32ModeRemove |= (~u32Tmp & u32ModeResulting);
3064 u32ModeResulting = u32Tmp;
3065 Assert(u32ModeResulting == ((pInfo->u32Mode | u32ModeAdd) & ~u32ModeRemove));
3066 }
3067 if (!u32ModeRemove && !u32ModeAdd)
3068 return VINF_SUCCESS;
3069
3070 if (!pInfo->pDpComposite)
3071 {
3072 pInfo->pDpComposite = new CrFbDisplayComposite();
3073 pInfo->pDpComposite->setFramebuffer(hFb);
3074 }
3075
3076 CrFbWindow * pOldWin = NULL;
3077
3078 if (u32ModeRemove & CR_PMGR_MODE_ROOTVR)
3079 {
3080 CRASSERT(pInfo->pDpWinRootVr);
3081 CRASSERT(pInfo->pDpWin == pInfo->pDpWinRootVr);
3082 pInfo->pDpComposite->remove(pInfo->pDpWinRootVr);
3083 pOldWin = pInfo->pDpWinRootVr->windowDetach();
3084 CRASSERT(pOldWin);
3085 delete pInfo->pDpWinRootVr;
3086 pInfo->pDpWinRootVr = NULL;
3087 pInfo->pDpWin = NULL;
3088 }
3089 else if (u32ModeRemove & CR_PMGR_MODE_WINDOW)
3090 {
3091 CRASSERT(!pInfo->pDpWinRootVr);
3092 CRASSERT(pInfo->pDpWin);
3093 pInfo->pDpComposite->remove(pInfo->pDpWin);
3094 pOldWin = pInfo->pDpWin->windowDetach();
3095 CRASSERT(pOldWin);
3096 delete pInfo->pDpWin;
3097 pInfo->pDpWin = NULL;
3098 }
3099
3100 if (u32ModeRemove & CR_PMGR_MODE_VRDP)
3101 {
3102 CRASSERT(pInfo->pDpVrdp);
3103 if (pInfo->pDpComposite)
3104 pInfo->pDpComposite->remove(pInfo->pDpVrdp);
3105 else
3106 CrFbDisplaySet(hFb, NULL);
3107
3108 delete pInfo->pDpVrdp;
3109 pInfo->pDpVrdp = NULL;
3110 }
3111
3112 CrFbDisplayBase *pDpToSet = NULL;
3113
3114 if (u32ModeAdd & CR_PMGR_MODE_ROOTVR)
3115 {
3116 CRASSERT(!pInfo->pDpWin);
3117 CRASSERT(!pInfo->pDpWinRootVr);
3118
3119 if (!pOldWin)
3120 pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID);
3121
3122 pInfo->pDpWinRootVr = new CrFbDisplayWindowRootVr(pOldWin, &cr_server.screenVieport[idScreen].Rect);
3123 pOldWin = NULL;
3124 pInfo->pDpWin = pInfo->pDpWinRootVr;
3125 pInfo->pDpComposite->add(pInfo->pDpWinRootVr);
3126 }
3127 else if (u32ModeAdd & CR_PMGR_MODE_WINDOW)
3128 {
3129 CRASSERT(!pInfo->pDpWin);
3130 CRASSERT(!pInfo->pDpWinRootVr);
3131
3132 if (!pOldWin)
3133 pOldWin = new CrFbWindow(cr_server.screen[idScreen].winID);
3134
3135 pInfo->pDpWin = new CrFbDisplayWindow(pOldWin, &cr_server.screenVieport[idScreen].Rect);
3136 pOldWin = NULL;
3137 pInfo->pDpComposite->add(pInfo->pDpWin);
3138 }
3139
3140 if (u32ModeAdd & CR_PMGR_MODE_VRDP)
3141 {
3142 CRASSERT(!pInfo->pDpVrdp);
3143 pInfo->pDpVrdp = new CrFbDisplayVrdp();
3144 pInfo->pDpComposite->add(pInfo->pDpVrdp);
3145 }
3146
3147 if (pInfo->pDpComposite->getDisplayCount() > 1)
3148 {
3149 ICrFbDisplay* pCur = CrFbDisplayGet(hFb);
3150 if (pCur != (ICrFbDisplay*)pInfo->pDpComposite)
3151 CrFbDisplaySet(hFb, pInfo->pDpComposite);
3152 }
3153 else
3154 {
3155 ICrFbDisplay* pCur = CrFbDisplayGet(hFb);
3156 ICrFbDisplay* pFirst = pInfo->pDpComposite->first();
3157 if (pCur != pFirst)
3158 CrFbDisplaySet(hFb, pFirst);
3159 }
3160
3161 if (pOldWin)
3162 delete pOldWin;
3163
3164 pInfo->u32Mode = u32ModeResulting;
3165
3166 return VINF_SUCCESS;
3167}
3168
3169static int crPMgrModeModifyGlobal(uint32_t u32Mode, bool fEnable)
3170{
3171 uint32_t u32ModeAdd, u32ModeRemove;
3172 if (fEnable)
3173 {
3174 u32ModeAdd = u32Mode;
3175 u32ModeRemove = 0;
3176 }
3177 else
3178 {
3179 u32ModeAdd = 0;
3180 u32ModeRemove = u32Mode;
3181 }
3182
3183 g_CrPresenter.u32DisplayMode = (g_CrPresenter.u32DisplayMode | u32ModeAdd) & ~u32ModeRemove;
3184
3185 for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
3186 hFb;
3187 hFb = CrPMgrFbGetNextEnabled(hFb))
3188 {
3189 CrPMgrModeModify(hFb, u32ModeAdd, u32ModeRemove);
3190 }
3191
3192 return VINF_SUCCESS;
3193}
3194
3195int CrPMgrModeVrdp(bool fEnable)
3196{
3197 return crPMgrModeModifyGlobal(CR_PMGR_MODE_VRDP, fEnable);
3198}
3199
3200int CrPMgrModeRootVr(bool fEnable)
3201{
3202 return crPMgrModeModifyGlobal(CR_PMGR_MODE_ROOTVR, fEnable);
3203}
3204
3205int CrPMgrRootVrUpdate()
3206{
3207 for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
3208 hFb;
3209 hFb = CrPMgrFbGetNextEnabled(hFb))
3210 {
3211 uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
3212 CR_FBDISPLAY_INFO *pInfo = &g_CrPresenter.aDisplayInfos[idScreen];
3213 int rc = CrFbUpdateBegin(hFb);
3214 if (RT_SUCCESS(rc))
3215 {
3216 pInfo->pDpWinRootVr->RegionsChanged(hFb);
3217 CrFbUpdateEnd(hFb);
3218 }
3219 else
3220 WARN(("CrFbUpdateBegin failed %d", rc));
3221 }
3222
3223 return VINF_SUCCESS;
3224}
3225
3226/*helper function that calls CrFbUpdateBegin for all enabled framebuffers */
3227int CrPMgrHlpGlblUpdateBegin(CR_FBMAP *pMap)
3228{
3229 CrFBmInit(pMap);
3230 for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
3231 hFb;
3232 hFb = CrPMgrFbGetNextEnabled(hFb))
3233 {
3234 int rc = CrFbUpdateBegin(hFb);
3235 if (!RT_SUCCESS(rc))
3236 {
3237 WARN(("UpdateBegin failed, rc %d", rc));
3238 for (HCR_FRAMEBUFFER hTmpFb = CrPMgrFbGetFirstEnabled();
3239 hFb != hTmpFb;
3240 hTmpFb = CrPMgrFbGetNextEnabled(hTmpFb))
3241 {
3242 CrFbUpdateEnd(hTmpFb);
3243 CrFBmClear(pMap, CrFbGetScreenInfo(hFb)->u32ViewIndex);
3244 }
3245 return rc;
3246 }
3247
3248 CrFBmSet(pMap, CrFbGetScreenInfo(hFb)->u32ViewIndex);
3249 }
3250
3251 return VINF_SUCCESS;
3252}
3253
3254/*helper function that calls CrFbUpdateEnd for all framebuffers being updated */
3255void CrPMgrHlpGlblUpdateEnd(CR_FBMAP *pMap)
3256{
3257 for (uint32_t i = 0; i < cr_server.screenCount; ++i)
3258 {
3259 if (!CrFBmIsSet(pMap, i))
3260 continue;
3261
3262 HCR_FRAMEBUFFER hFb = CrPMgrFbGetInitialized(i);
3263 CRASSERT(hFb);
3264 CrFbUpdateEnd(hFb);
3265 }
3266}
3267
3268/*client should notify the manager about the framebuffer resize via this function */
3269int CrPMgrNotifyResize(HCR_FRAMEBUFFER hFb)
3270{
3271 int rc = VINF_SUCCESS;
3272 if (CrFbIsEnabled(hFb))
3273 {
3274 rc = CrPMgrModeModify(hFb, g_CrPresenter.u32DisplayMode, 0);
3275 if (!RT_SUCCESS(rc))
3276 {
3277 WARN(("CrPMgrModeModify failed rc %d", rc));
3278 return rc;
3279 }
3280 }
3281 else
3282 {
3283 rc = CrPMgrModeModify(hFb, 0, CR_PMGR_MODE_ALL);
3284 if (!RT_SUCCESS(rc))
3285 {
3286 WARN(("CrPMgrModeModify failed rc %d", rc));
3287 return rc;
3288 }
3289 }
3290
3291 return VINF_SUCCESS;
3292}
3293
3294int CrFbEntrySaveState(CR_FRAMEBUFFER *pFb, CR_FRAMEBUFFER_ENTRY *hEntry, PSSMHANDLE pSSM)
3295{
3296 const struct VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry = CrFbEntryGetCompositorEntry(hEntry);
3297 CR_TEXDATA *pTexData = CrVrScrCompositorEntryTexGet(pEntry);
3298 CR_FBTEX *pFbTex = PCR_FBTEX_FROM_TEX(pTexData);
3299 int rc = SSMR3PutU32(pSSM, pFbTex->pTobj->id);
3300 AssertRCReturn(rc, rc);
3301 uint32_t u32 = 0;
3302
3303 u32 = CrVrScrCompositorEntryFlagsGet(pEntry);
3304 rc = SSMR3PutU32(pSSM, u32);
3305 AssertRCReturn(rc, rc);
3306
3307 const RTRECT *pRect = CrVrScrCompositorEntryRectGet(pEntry);
3308
3309 rc = SSMR3PutS32(pSSM, pRect->xLeft);
3310 AssertRCReturn(rc, rc);
3311 rc = SSMR3PutS32(pSSM, pRect->yTop);
3312 AssertRCReturn(rc, rc);
3313#if 0
3314 rc = SSMR3PutS32(pSSM, pRect->xRight);
3315 AssertRCReturn(rc, rc);
3316 rc = SSMR3PutS32(pSSM, pRect->yBottom);
3317 AssertRCReturn(rc, rc);
3318#endif
3319
3320 rc = CrVrScrCompositorEntryRegionsGet(&pFb->Compositor, pEntry, &u32, NULL, NULL, &pRect);
3321 AssertRCReturn(rc, rc);
3322
3323 rc = SSMR3PutU32(pSSM, u32);
3324 AssertRCReturn(rc, rc);
3325
3326 if (u32)
3327 {
3328 rc = SSMR3PutMem(pSSM, pRect, u32 * sizeof (*pRect));
3329 AssertRCReturn(rc, rc);
3330 }
3331 return rc;
3332}
3333
3334int CrFbSaveState(CR_FRAMEBUFFER *pFb, PSSMHANDLE pSSM)
3335{
3336 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
3337 CrVrScrCompositorConstIterInit(&pFb->Compositor, &Iter);
3338 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
3339 uint32_t u32 = 0;
3340 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
3341 {
3342 CR_TEXDATA *pTexData = CrVrScrCompositorEntryTexGet(pEntry);
3343 CRASSERT(pTexData);
3344 CR_FBTEX *pFbTex = PCR_FBTEX_FROM_TEX(pTexData);
3345 if (pFbTex->pTobj)
3346 ++u32;
3347 }
3348
3349 int rc = SSMR3PutU32(pSSM, u32);
3350 AssertRCReturn(rc, rc);
3351
3352 CrVrScrCompositorConstIterInit(&pFb->Compositor, &Iter);
3353
3354 while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
3355 {
3356 CR_TEXDATA *pTexData = CrVrScrCompositorEntryTexGet(pEntry);
3357 CR_FBTEX *pFbTex = PCR_FBTEX_FROM_TEX(pTexData);
3358 if (pFbTex->pTobj)
3359 {
3360 HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
3361 rc = CrFbEntrySaveState(pFb, hEntry, pSSM);
3362 AssertRCReturn(rc, rc);
3363 }
3364 }
3365
3366 return VINF_SUCCESS;
3367}
3368
3369int CrPMgrSaveState(PSSMHANDLE pSSM)
3370{
3371 int rc;
3372 int cDisplays = 0, i;
3373 for (i = 0; i < cr_server.screenCount; ++i)
3374 {
3375 if (CrPMgrFbGetEnabled(i))
3376 ++cDisplays;
3377 }
3378
3379 rc = SSMR3PutS32(pSSM, cDisplays);
3380 AssertRCReturn(rc, rc);
3381
3382 if (!cDisplays)
3383 return VINF_SUCCESS;
3384
3385 rc = SSMR3PutS32(pSSM, cr_server.screenCount);
3386 AssertRCReturn(rc, rc);
3387
3388 for (i = 0; i < cr_server.screenCount; ++i)
3389 {
3390 CR_FRAMEBUFFER *hFb = CrPMgrFbGetEnabled(i);
3391 if (hFb)
3392 {
3393 Assert(hFb->ScreenInfo.u32ViewIndex == i);
3394 rc = SSMR3PutU32(pSSM, hFb->ScreenInfo.u32ViewIndex);
3395 AssertRCReturn(rc, rc);
3396
3397 rc = SSMR3PutS32(pSSM, hFb->ScreenInfo.i32OriginX);
3398 AssertRCReturn(rc, rc);
3399
3400 rc = SSMR3PutS32(pSSM, hFb->ScreenInfo.i32OriginY);
3401 AssertRCReturn(rc, rc);
3402
3403 rc = SSMR3PutU32(pSSM, hFb->ScreenInfo.u32StartOffset);
3404 AssertRCReturn(rc, rc);
3405
3406 rc = SSMR3PutU32(pSSM, hFb->ScreenInfo.u32LineSize);
3407 AssertRCReturn(rc, rc);
3408
3409 rc = SSMR3PutU32(pSSM, hFb->ScreenInfo.u32Width);
3410 AssertRCReturn(rc, rc);
3411
3412 rc = SSMR3PutU32(pSSM, hFb->ScreenInfo.u32Height);
3413 AssertRCReturn(rc, rc);
3414
3415 rc = SSMR3PutU16(pSSM, hFb->ScreenInfo.u16BitsPerPixel);
3416 AssertRCReturn(rc, rc);
3417
3418 rc = SSMR3PutU16(pSSM, hFb->ScreenInfo.u16Flags);
3419 AssertRCReturn(rc, rc);
3420
3421 rc = SSMR3PutU32(pSSM, (uint32_t)(((uintptr_t)hFb->pvVram) - ((uintptr_t)g_pvVRamBase)));
3422 AssertRCReturn(rc, rc);
3423
3424 rc = CrFbSaveState(hFb, pSSM);
3425 AssertRCReturn(rc, rc);
3426 }
3427 }
3428
3429 return VINF_SUCCESS;
3430}
3431
3432int CrFbEntryLoadState(CR_FRAMEBUFFER *pFb, PSSMHANDLE pSSM, uint32_t version)
3433{
3434 uint32_t texture;
3435 int rc = SSMR3GetU32(pSSM, &texture);
3436 AssertRCReturn(rc, rc);
3437
3438 uint32_t fFlags;
3439 rc = SSMR3GetU32(pSSM, &fFlags);
3440 AssertRCReturn(rc, rc);
3441
3442
3443 HCR_FRAMEBUFFER_ENTRY hEntry;
3444
3445 rc = CrFbEntryCreateForTexId(pFb, texture, fFlags, &hEntry);
3446 if (!RT_SUCCESS(rc))
3447 {
3448 WARN(("CrFbEntryCreateForTexId Failed"));
3449 return rc;
3450 }
3451
3452 Assert(hEntry);
3453
3454 const struct VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry = CrFbEntryGetCompositorEntry(hEntry);
3455 CR_TEXDATA *pTexData = CrVrScrCompositorEntryTexGet(pEntry);
3456 CR_FBTEX *pFbTex = PCR_FBTEX_FROM_TEX(pTexData);
3457
3458 RTPOINT Point;
3459 rc = SSMR3GetS32(pSSM, &Point.x);
3460 AssertRCReturn(rc, rc);
3461
3462 rc = SSMR3GetS32(pSSM, &Point.y);
3463 AssertRCReturn(rc, rc);
3464
3465 uint32_t cRects;
3466 rc = SSMR3GetU32(pSSM, &cRects);
3467 AssertRCReturn(rc, rc);
3468
3469 RTRECT * pRects = NULL;
3470 if (cRects)
3471 {
3472 pRects = (RTRECT *)crAlloc(cRects * sizeof (*pRects));
3473 AssertReturn(pRects, VERR_NO_MEMORY);
3474
3475 rc = SSMR3GetMem(pSSM, pRects, cRects * sizeof (*pRects));
3476 AssertRCReturn(rc, rc);
3477 }
3478
3479 rc = CrFbEntryRegionsSet(pFb, hEntry, &Point, cRects, pRects, false);
3480 AssertRCReturn(rc, rc);
3481
3482 if (pRects)
3483 crFree(pRects);
3484
3485 return VINF_SUCCESS;
3486}
3487
3488int CrFbLoadState(CR_FRAMEBUFFER *pFb, PSSMHANDLE pSSM, uint32_t version)
3489{
3490 uint32_t u32 = 0;
3491 int rc = SSMR3GetU32(pSSM, &u32);
3492 AssertRCReturn(rc, rc);
3493
3494 if (!u32)
3495 return VINF_SUCCESS;
3496
3497 rc = CrFbUpdateBegin(pFb);
3498 AssertRCReturn(rc, rc);
3499
3500 for (uint32_t i = 0; i < u32; ++i)
3501 {
3502 rc = CrFbEntryLoadState(pFb, pSSM, version);
3503 AssertRCReturn(rc, rc);
3504
3505 }
3506
3507 CrFbUpdateEnd(pFb);
3508
3509 return VINF_SUCCESS;
3510}
3511
3512int CrPMgrLoadState(PSSMHANDLE pSSM, uint32_t version)
3513{
3514 int rc;
3515 int cDisplays, screenCount, i;
3516
3517 rc = SSMR3GetS32(pSSM, &cDisplays);
3518 AssertRCReturn(rc, rc);
3519
3520 if (!cDisplays)
3521 return VINF_SUCCESS;
3522
3523 rc = SSMR3GetS32(pSSM, &screenCount);
3524 AssertRCReturn(rc, rc);
3525
3526 CRASSERT(screenCount == cr_server.screenCount);
3527
3528 CRScreenInfo screen[CR_MAX_GUEST_MONITORS];
3529
3530 if (version < SHCROGL_SSM_VERSION_WITH_FB_INFO)
3531 {
3532 for (i = 0; i < cr_server.screenCount; ++i)
3533 {
3534 rc = SSMR3GetS32(pSSM, &screen[i].x);
3535 AssertRCReturn(rc, rc);
3536
3537 rc = SSMR3GetS32(pSSM, &screen[i].y);
3538 AssertRCReturn(rc, rc);
3539
3540 rc = SSMR3GetU32(pSSM, &screen[i].w);
3541 AssertRCReturn(rc, rc);
3542
3543 rc = SSMR3GetU32(pSSM, &screen[i].h);
3544 AssertRCReturn(rc, rc);
3545 }
3546 }
3547
3548 for (i = 0; i < cDisplays; ++i)
3549 {
3550 int iScreen;
3551
3552 rc = SSMR3GetS32(pSSM, &iScreen);
3553 AssertRCReturn(rc, rc);
3554
3555 CR_FRAMEBUFFER *pFb = CrPMgrFbGet(iScreen);
3556 Assert(pFb);
3557
3558 rc = CrFbUpdateBegin(pFb);
3559 if (!RT_SUCCESS(rc))
3560 {
3561 WARN(("CrFbUpdateBegin failed %d", rc));
3562 return rc;
3563 }
3564
3565 VBVAINFOSCREEN Screen;
3566 void *pvVRAM;
3567
3568 Screen.u32ViewIndex = iScreen;
3569
3570 if (version < SHCROGL_SSM_VERSION_WITH_FB_INFO)
3571 {
3572 memset(&Screen, 0, sizeof (Screen));
3573 Screen.u32LineSize = 4 * screen[iScreen].w;
3574 Screen.u32Width = screen[iScreen].w;
3575 Screen.u32Height = screen[iScreen].h;
3576 Screen.u16BitsPerPixel = 4;
3577 Screen.u16Flags = VBVA_SCREEN_F_ACTIVE;
3578
3579 pvVRAM = g_pvVRamBase;
3580 }
3581 else
3582 {
3583 rc = SSMR3GetS32(pSSM, &Screen.i32OriginX);
3584 AssertRCReturn(rc, rc);
3585
3586 rc = SSMR3GetS32(pSSM, &Screen.i32OriginY);
3587 AssertRCReturn(rc, rc);
3588
3589 rc = SSMR3GetU32(pSSM, &Screen.u32StartOffset);
3590 AssertRCReturn(rc, rc);
3591
3592 rc = SSMR3GetU32(pSSM, &Screen.u32LineSize);
3593 AssertRCReturn(rc, rc);
3594
3595 rc = SSMR3GetU32(pSSM, &Screen.u32Width);
3596 AssertRCReturn(rc, rc);
3597
3598 rc = SSMR3GetU32(pSSM, &Screen.u32Height);
3599 AssertRCReturn(rc, rc);
3600
3601 rc = SSMR3GetU16(pSSM, &Screen.u16BitsPerPixel);
3602 AssertRCReturn(rc, rc);
3603
3604 rc = SSMR3GetU16(pSSM, &Screen.u16Flags);
3605 AssertRCReturn(rc, rc);
3606
3607 uint32_t offVram = 0;
3608 rc = SSMR3GetU32(pSSM, &offVram);
3609 AssertRCReturn(rc, rc);
3610
3611 pvVRAM = (void*)(((uintptr_t)g_pvVRamBase) + offVram);
3612 }
3613
3614 crVBoxServerMuralFbResizeBegin(pFb);
3615
3616 rc = CrFbResize(pFb, &Screen, pvVRAM);
3617 if (!RT_SUCCESS(rc))
3618 {
3619 WARN(("CrFbResize failed %d", rc));
3620 return rc;
3621 }
3622
3623 rc = CrFbLoadState(pFb, pSSM, version);
3624 AssertRCReturn(rc, rc);
3625
3626 crVBoxServerMuralFbResizeEnd(pFb);
3627
3628 CrFbUpdateEnd(pFb);
3629
3630 CrPMgrNotifyResize(pFb);
3631 }
3632
3633 return VINF_SUCCESS;
3634}
3635
3636
3637void SERVER_DISPATCH_APIENTRY
3638crServerDispatchVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, const GLint *pRects)
3639{
3640 uint32_t idScreen = CR_PRESENT_GET_SCREEN(cfg);
3641 if (idScreen >= CR_MAX_GUEST_MONITORS)
3642 {
3643 WARN(("Invalid guest screen"));
3644 return;
3645 }
3646
3647 HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabled(idScreen);
3648 if (!hFb)
3649 {
3650 WARN(("request to present on disabled framebuffer, ignore"));
3651 return;
3652 }
3653
3654 HCR_FRAMEBUFFER_ENTRY hEntry;
3655 int rc;
3656 if (texture)
3657 {
3658 rc = CrFbEntryCreateForTexId(hFb, texture, (cfg & CR_PRESENT_FLAG_TEX_NONINVERT_YCOORD) ? 0 : CRBLT_F_INVERT_SRC_YCOORDS, &hEntry);
3659 if (!RT_SUCCESS(rc))
3660 {
3661 WARN(("CrFbEntryCreateForTexId Failed"));
3662 return;
3663 }
3664
3665 Assert(hEntry);
3666
3667#if 0
3668 if (!(cfg & CR_PRESENT_FLAG_CLEAR_RECTS))
3669 {
3670 CR_SERVER_DUMP_TEXPRESENT(&pEntry->CEntry.Tex);
3671 }
3672#endif
3673 }
3674 else
3675 hEntry = NULL;
3676
3677 rc = CrFbUpdateBegin(hFb);
3678 if (RT_SUCCESS(rc))
3679 {
3680 if (!(cfg & CR_PRESENT_FLAG_CLEAR_RECTS))
3681 {
3682 RTPOINT Point = {xPos, yPos};
3683 rc = CrFbEntryRegionsAdd(hFb, hEntry, &Point, (uint32_t)cRects, (const RTRECT*)pRects, false);
3684 }
3685 else
3686 {
3687 CrFbRegionsClear(hFb);
3688 }
3689
3690 CrFbUpdateEnd(hFb);
3691 }
3692 else
3693 {
3694 WARN(("CrFbUpdateBegin Failed"));
3695 }
3696
3697 if (hEntry)
3698 CrFbEntryRelease(hFb, hEntry);
3699}
Note: See TracBrowser for help on using the repository browser.

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