VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.cpp@ 78295

Last change on this file since 78295 was 78263, checked in by vboxsync, 6 years ago

Config.kmk,GuestHost\OpenGL,HostServices\SharedOpenGL: Fix a bunch of compiler warnings and enable them again
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.7 KB
Line 
1/* $Id: server_muralfbo.cpp 78263 2019-04-23 18:41:06Z vboxsync $ */
2
3/** @file
4 * VBox crOpenGL: Window to FBO redirect support.
5 */
6
7/*
8 * Copyright (C) 2010-2019 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
19#include "server.h"
20#include "cr_string.h"
21#include "cr_mem.h"
22#include "cr_vreg.h"
23#include "render/renderspu.h"
24
25static void crServerRedirMuralFbSync(CRMuralInfo *mural);
26
27void crServerCheckMuralGeometry(CRMuralInfo *mural)
28{
29 if (!mural->CreateInfo.externalID)
30 return;
31
32 CRASSERT(mural->spuWindow);
33 CRASSERT(mural->spuWindow != CR_RENDER_DEFAULT_WINDOW_ID);
34
35 if (!mural->width || !mural->height
36 || mural->fboWidth != mural->width
37 || mural->fboHeight != mural->height)
38 {
39 crServerRedirMuralFbClear(mural);
40 crServerRedirMuralFBO(mural, false);
41 crServerDeleteMuralFBO(mural);
42 }
43
44 if (!mural->width || !mural->height)
45 return;
46
47 crServerRedirMuralFBO(mural, true);
48 crServerRedirMuralFbSync(mural);
49}
50
51static void crServerCheckMuralGeometryCB(unsigned long key, void *data1, void *data2)
52{
53 RT_NOREF(key);
54
55 CRMuralInfo *pMI = (CRMuralInfo*) data1;
56
57 if (!pMI->fRedirected || pMI == data2)
58 return;
59
60 crServerCheckMuralGeometry(pMI);
61}
62
63
64void crServerCheckAllMuralGeometry(CRMuralInfo *pMI)
65{
66 CR_FBMAP Map;
67 int rc = CrPMgrHlpGlblUpdateBegin(&Map);
68 if (!RT_SUCCESS(rc))
69 {
70 WARN(("CrPMgrHlpGlblUpdateBegin failed %d", rc));
71 return;
72 }
73
74 crHashtableWalk(cr_server.muralTable, crServerCheckMuralGeometryCB, pMI);
75
76 if (pMI)
77 crServerCheckMuralGeometry(pMI);
78
79 CrPMgrHlpGlblUpdateEnd(&Map);
80}
81
82GLboolean crServerSupportRedirMuralFBO(void)
83{
84 static GLboolean fInited = GL_FALSE;
85 static GLboolean fSupported = GL_FALSE;
86 if (!fInited)
87 {
88 const GLubyte* pExt = cr_server.head_spu->dispatch_table.GetString(GL_REAL_EXTENSIONS);
89
90 fSupported = ( NULL!=crStrstr((const char*)pExt, "GL_ARB_framebuffer_object")
91 || NULL!=crStrstr((const char*)pExt, "GL_EXT_framebuffer_object"))
92 && NULL!=crStrstr((const char*)pExt, "GL_ARB_texture_non_power_of_two");
93 fInited = GL_TRUE;
94 }
95 return fSupported;
96}
97
98static void crServerCreateMuralFBO(CRMuralInfo *mural);
99
100void crServerRedirMuralFbClear(CRMuralInfo *mural)
101{
102 uint32_t i;
103 for (i = 0; i < mural->cUsedFBDatas; ++i)
104 {
105 CR_FBDATA *pData = mural->apUsedFBDatas[i];
106 int rc = CrFbUpdateBegin(pData->hFb);
107 if (RT_SUCCESS(rc))
108 {
109 CrFbEntryRegionsSet(pData->hFb, pData->hFbEntry, NULL, 0, NULL, false);
110 CrFbUpdateEnd(pData->hFb);
111 }
112 else
113 WARN(("CrFbUpdateBegin failed rc %d", rc));
114 }
115 mural->cUsedFBDatas = 0;
116
117 for (i = 0; i < (uint32_t)cr_server.screenCount; ++i)
118 {
119 GLuint j;
120 CR_FBDATA *pData = &mural->aFBDatas[i];
121 if (!pData->hFb)
122 continue;
123
124 if (pData->hFbEntry != NULL)
125 {
126 CrFbEntryRelease(pData->hFb, pData->hFbEntry);
127 pData->hFbEntry = NULL;
128 }
129
130 /* Release all valid texture data structures in the array.
131 * Do not rely on mural->cBuffers because it might be already
132 * set to zero in crServerDeleteMuralFBO.
133 */
134 for (j = 0; j < RT_ELEMENTS(pData->apTexDatas); ++j)
135 {
136 if (pData->apTexDatas[j] != NULL)
137 {
138 CrTdRelease(pData->apTexDatas[j]);
139 pData->apTexDatas[j] = NULL;
140 }
141 }
142
143 pData->hFb = NULL;
144 }
145}
146
147static int crServerRedirMuralDbSyncFb(CRMuralInfo *mural, HCR_FRAMEBUFFER hFb, CR_FBDATA **ppData)
148{
149 CR_FBDATA *pData;
150 const struct VBVAINFOSCREEN* pScreenInfo = CrFbGetScreenInfo(hFb);
151 const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(hFb);
152 RTRECT FbRect = *CrVrScrCompositorRectGet(pCompositor);
153 RTRECT DefaultRegionsRect;
154 const RTRECT * pRegions;
155 uint32_t cRegions;
156 RTPOINT Pos;
157 RTRECT MuralRect;
158 int rc;
159
160 CRASSERT(mural->fRedirected);
161
162 *ppData = NULL;
163
164 if (!mural->bVisible)
165 return VINF_SUCCESS;
166
167 MuralRect.xLeft = mural->gX;
168 MuralRect.yTop = mural->gY;
169 MuralRect.xRight = MuralRect.xLeft + mural->width;
170 MuralRect.yBottom = MuralRect.yTop + mural->height;
171
172 Pos.x = mural->gX - pScreenInfo->i32OriginX;
173 Pos.y = mural->gY - pScreenInfo->i32OriginY;
174
175 VBoxRectTranslate(&FbRect, pScreenInfo->i32OriginX, pScreenInfo->i32OriginY);
176
177 VBoxRectIntersect(&FbRect, &MuralRect);
178
179 if (VBoxRectIsZero(&FbRect))
180 return VINF_SUCCESS;
181
182 if (mural->bReceivedRects)
183 {
184 pRegions = (const RTRECT*)mural->pVisibleRects;
185 cRegions = mural->cVisibleRects;
186 }
187 else
188 {
189 DefaultRegionsRect.xLeft = 0;
190 DefaultRegionsRect.yTop = 0;
191 DefaultRegionsRect.xRight = mural->width;
192 DefaultRegionsRect.yBottom = mural->height;
193 pRegions = &DefaultRegionsRect;
194 cRegions = 1;
195 }
196
197 if (!cRegions)
198 return VINF_SUCCESS;
199
200 pData = &mural->aFBDatas[pScreenInfo->u32ViewIndex];
201
202 if (!pData->hFb)
203 {
204 /* Guard against modulo-by-zero when calling CrFbEntryCreateForTexData
205 below. Observed when failing to load atig6pxx.dll and similar. */
206 if (RT_UNLIKELY(mural->cBuffers == 0))
207 {
208 WARN(("crServerRedirMuralDbSyncFb: cBuffers == 0 (crServerSupportRedirMuralFBO=%d)", crServerSupportRedirMuralFBO()));
209 return VERR_NOT_SUPPORTED;
210 }
211
212 pData->hFb = hFb;
213
214 RT_ZERO(pData->apTexDatas);
215 for (uint32_t i = 0; i < mural->cBuffers; ++i)
216 {
217 VBOXVR_TEXTURE Tex;
218 Tex.width = mural->width;
219 Tex.height = mural->height;
220 Tex.hwid = mural->aidColorTexs[i];
221 Tex.target = GL_TEXTURE_2D;
222
223 pData->apTexDatas[i] = CrFbTexDataCreate(&Tex);
224 }
225
226 rc = CrFbEntryCreateForTexData(hFb, pData->apTexDatas[CR_SERVER_FBO_FB_IDX(mural)], 0, &pData->hFbEntry);
227 if (!RT_SUCCESS(rc))
228 {
229 WARN(("CrFbEntryCreateForTexData failed rc %d", rc));
230 }
231 }
232 else
233 {
234 CRASSERT(pData->hFb == hFb);
235 }
236
237 rc = CrFbUpdateBegin(hFb);
238 if (!RT_SUCCESS(rc))
239 {
240 WARN(("CrFbUpdateBegin failed rc %d", rc));
241 return rc;
242 }
243
244 rc = CrFbEntryRegionsSet(hFb, pData->hFbEntry, &Pos, cRegions, pRegions, true);
245 if (!RT_SUCCESS(rc))
246 {
247 WARN(("CrFbEntryRegionsSet failed rc %d", rc));
248 }
249
250 CrFbUpdateEnd(hFb);
251
252 const struct VBOXVR_SCR_COMPOSITOR_ENTRY* pCEntry = CrFbEntryGetCompositorEntry(pData->hFbEntry);
253 if (CrVrScrCompositorEntryIsUsed(pCEntry))
254 *ppData = pData;
255
256 return rc;
257}
258
259static void crServerRedirMuralFbSync(CRMuralInfo *mural)
260{
261 uint32_t i;
262 uint32_t cUsedFBs = 0;
263 HCR_FRAMEBUFFER ahUsedFbs[CR_MAX_GUEST_MONITORS];
264 HCR_FRAMEBUFFER hFb;
265
266 for (i = 0; i < mural->cUsedFBDatas; ++i)
267 {
268 CR_FBDATA *pData = mural->apUsedFBDatas[i];
269 int rc = CrFbUpdateBegin(pData->hFb);
270 if (RT_SUCCESS(rc))
271 {
272 ahUsedFbs[cUsedFBs] = pData->hFb;
273 CrFbEntryRegionsSet(pData->hFb, pData->hFbEntry, NULL, 0, NULL, false);
274 ++cUsedFBs;
275 }
276 else
277 WARN(("CrFbUpdateBegin failed rc %d", rc));
278 }
279 mural->cUsedFBDatas = 0;
280
281 if (!mural->width
282 || !mural->height
283 || !mural->bVisible
284 )
285 goto end;
286
287 CRASSERT(mural->fRedirected);
288
289 for (hFb = CrPMgrFbGetFirstEnabled();
290 hFb;
291 hFb = CrPMgrFbGetNextEnabled(hFb))
292 {
293 CR_FBDATA *pData = NULL;
294 int rc = crServerRedirMuralDbSyncFb(mural, hFb, &pData);
295 if (!RT_SUCCESS(rc))
296 {
297 WARN(("crServerRedirMuralDbSyncFb failed %d", rc));
298 continue;
299 }
300
301 if (!pData)
302 continue;
303
304 mural->apUsedFBDatas[mural->cUsedFBDatas] = pData;
305 ++mural->cUsedFBDatas;
306 }
307
308end:
309
310 for (i = 0; i < cUsedFBs; ++i)
311 {
312 CrFbUpdateEnd(ahUsedFbs[i]);
313 }
314}
315
316static void crVBoxServerMuralFbCleanCB(unsigned long key, void *data1, void *data2)
317{
318 RT_NOREF(key);
319
320 CRMuralInfo *pMI = (CRMuralInfo*) data1;
321 HCR_FRAMEBUFFER hFb = (HCR_FRAMEBUFFER)data2;
322 uint32_t i;
323 for (i = 0; i < pMI->cUsedFBDatas; ++i)
324 {
325 CR_FBDATA *pData = pMI->apUsedFBDatas[i];
326 if (hFb != pData->hFb)
327 continue;
328
329 CrFbEntryRegionsSet(pData->hFb, pData->hFbEntry, NULL, 0, NULL, false);
330 break;
331 }
332}
333
334static void crVBoxServerMuralFbSetCB(unsigned long key, void *data1, void *data2)
335{
336 RT_NOREF(key);
337
338 CRMuralInfo *pMI = (CRMuralInfo*) data1;
339 HCR_FRAMEBUFFER hFb = (HCR_FRAMEBUFFER)data2;
340 uint32_t i;
341 CR_FBDATA *pData = NULL;
342 bool fFbWasUsed = false;
343
344 Assert(hFb);
345
346 if (!pMI->fRedirected)
347 {
348 Assert(!pMI->cUsedFBDatas);
349 return;
350 }
351
352 for (i = 0; i < pMI->cUsedFBDatas; ++i)
353 {
354 CR_FBDATA *pData = pMI->apUsedFBDatas[i];
355 if (hFb != pData->hFb)
356 continue;
357
358 fFbWasUsed = true;
359 break;
360 }
361
362 if (CrFbIsEnabled(hFb))
363 {
364 int rc = crServerRedirMuralDbSyncFb(pMI, hFb, &pData);
365 if (!RT_SUCCESS(rc))
366 {
367 WARN(("crServerRedirMuralDbSyncFb failed %d", rc));
368 pData = NULL;
369 }
370 }
371
372 if (pData)
373 {
374 if (!fFbWasUsed)
375 {
376 uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
377 for (i = 0; i < pMI->cUsedFBDatas; ++i)
378 {
379 CR_FBDATA *pData = pMI->apUsedFBDatas[i];
380 uint32_t idCurScreen = CrFbGetScreenInfo(pData->hFb)->u32ViewIndex;
381 if (idCurScreen > idScreen)
382 break;
383
384 Assert(idCurScreen != idScreen);
385 }
386
387 for (uint32_t j = pMI->cUsedFBDatas; j > i; --j)
388 {
389 pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j-1];
390 }
391
392 pMI->apUsedFBDatas[i] = pData;
393 ++pMI->cUsedFBDatas;
394 }
395 /* else - nothing to do */
396 }
397 else
398 {
399 if (fFbWasUsed)
400 {
401 for (uint32_t j = i; j < pMI->cUsedFBDatas - 1; ++j)
402 {
403 pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j+1];
404 }
405 --pMI->cUsedFBDatas;
406 }
407 /* else - nothing to do */
408 }
409}
410
411void crVBoxServerMuralFbResizeEnd(HCR_FRAMEBUFFER hFb)
412{
413 crHashtableWalk(cr_server.muralTable, crVBoxServerMuralFbSetCB, hFb);
414}
415
416void crVBoxServerMuralFbResizeBegin(HCR_FRAMEBUFFER hFb)
417{
418 crHashtableWalk(cr_server.muralTable, crVBoxServerMuralFbCleanCB, hFb);
419}
420
421DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN *pScreen, void *pvVRAM)
422{
423 if (cr_server.fCrCmdEnabled)
424 {
425 WARN(("crVBoxServerNotifyResize for enabled CrCmd"));
426 return VERR_INVALID_STATE;
427 }
428
429 if (pScreen->u32ViewIndex >= (uint32_t)cr_server.screenCount)
430 {
431 WARN(("invalid view index"));
432 return VERR_INVALID_PARAMETER;
433 }
434
435 VBOXCMDVBVA_SCREENMAP_DECL(uint32_t, aTargetMap);
436
437 memset(aTargetMap, 0, sizeof (aTargetMap));
438
439 ASMBitSet(aTargetMap, pScreen->u32ViewIndex);
440
441 int rc = CrPMgrResize(pScreen, pvVRAM, aTargetMap);
442 if (!RT_SUCCESS(rc))
443 {
444 WARN(("err"));
445 return rc;
446 }
447
448 return VINF_SUCCESS;
449}
450
451void crServerRedirMuralFBO(CRMuralInfo *mural, bool fEnabled)
452{
453 if (!mural->fRedirected == !fEnabled)
454 {
455 return;
456 }
457
458 if (!mural->CreateInfo.externalID)
459 {
460 WARN(("trying to change redir setting for internal mural %d", mural->spuWindow));
461 return;
462 }
463
464 if (fEnabled)
465 {
466 if (!crServerSupportRedirMuralFBO())
467 {
468 WARN(("FBO not supported, can't redirect window output"));
469 return;
470 }
471
472 if (mural->aidFBOs[0]==0)
473 {
474 crServerCreateMuralFBO(mural);
475 }
476
477 if (cr_server.curClient && cr_server.curClient->currentMural == mural)
478 {
479 if (!crStateGetCurrent()->framebufferobject.drawFB)
480 {
481 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer));
482 }
483 if (!crStateGetCurrent()->framebufferobject.readFB)
484 {
485 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
486 }
487
488 crStateGetCurrent()->buffer.width = 0;
489 crStateGetCurrent()->buffer.height = 0;
490 }
491 }
492 else
493 {
494 if (cr_server.curClient && cr_server.curClient->currentMural == mural)
495 {
496 if (!crStateGetCurrent()->framebufferobject.drawFB)
497 {
498 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);
499 }
500 if (!crStateGetCurrent()->framebufferobject.readFB)
501 {
502 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, 0);
503 }
504
505 crStateGetCurrent()->buffer.width = mural->width;
506 crStateGetCurrent()->buffer.height = mural->height;
507 }
508 }
509
510 mural->fRedirected = !!fEnabled;
511}
512
513static void crServerCreateMuralFBO(CRMuralInfo *mural)
514{
515 CRContext *ctx = crStateGetCurrent();
516 GLuint uid, i;
517 GLenum status;
518 SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
519 CRContextInfo *pMuralContextInfo;
520
521 CRASSERT(mural->aidFBOs[0]==0);
522 CRASSERT(mural->aidFBOs[1]==0);
523
524 pMuralContextInfo = cr_server.currentCtxInfo;
525 if (!pMuralContextInfo)
526 {
527 /* happens on saved state load */
528 CRASSERT(cr_server.MainContextInfo.SpuContext);
529 pMuralContextInfo = &cr_server.MainContextInfo;
530 cr_server.head_spu->dispatch_table.MakeCurrent(mural->spuWindow, 0, cr_server.MainContextInfo.SpuContext);
531 }
532
533 if (pMuralContextInfo->CreateInfo.realVisualBits != mural->CreateInfo.realVisualBits)
534 {
535 WARN(("mural visual bits do not match with current context visual bits!"));
536 }
537
538 mural->cBuffers = 2;
539 mural->iBbBuffer = 0;
540 /*Color texture*/
541
542 if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
543 {
544 gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
545 }
546
547 for (i = 0; i < mural->cBuffers; ++i)
548 {
549 gl->GenTextures(1, &mural->aidColorTexs[i]);
550 gl->BindTexture(GL_TEXTURE_2D, mural->aidColorTexs[i]);
551 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
552 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
553 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
554 gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
555 gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, mural->width, mural->height,
556 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
557 }
558
559 /* Depth & Stencil. */
560 gl->GenRenderbuffersEXT(1, &mural->idDepthStencilRB);
561 gl->BindRenderbufferEXT(GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
562 gl->RenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
563 mural->width, mural->height);
564
565 /*FBO*/
566 for (i = 0; i < mural->cBuffers; ++i)
567 {
568 gl->GenFramebuffersEXT(1, &mural->aidFBOs[i]);
569 gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mural->aidFBOs[i]);
570
571 gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
572 GL_TEXTURE_2D, mural->aidColorTexs[i], 0);
573 gl->FramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
574 GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
575 gl->FramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
576 GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
577
578 status = gl->CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
579 if (status!=GL_FRAMEBUFFER_COMPLETE_EXT)
580 {
581 WARN(("FBO status(0x%x) isn't complete", status));
582 }
583 }
584
585 mural->iCurDrawBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.drawBuffer);
586 mural->iCurReadBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.readBuffer);
587
588 mural->fboWidth = mural->width;
589 mural->fboHeight = mural->height;
590
591 mural->iCurDrawBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.drawBuffer);
592 mural->iCurReadBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.readBuffer);
593
594 /*Restore gl state*/
595 uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid;
596 gl->BindTexture(GL_TEXTURE_2D, uid);
597
598 uid = ctx->framebufferobject.renderbuffer ? ctx->framebufferobject.renderbuffer->hwid:0;
599 gl->BindRenderbufferEXT(GL_RENDERBUFFER_EXT, uid);
600
601 uid = ctx->framebufferobject.drawFB ? ctx->framebufferobject.drawFB->hwid:0;
602 gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, uid);
603
604 uid = ctx->framebufferobject.readFB ? ctx->framebufferobject.readFB->hwid:0;
605 gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER, uid);
606
607 if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
608 {
609 gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
610 }
611
612 if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
613 {
614 gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
615 }
616 else
617 {
618 gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
619 }
620
621 CRASSERT(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
622}
623
624void crServerDeleteMuralFBO(CRMuralInfo *mural)
625{
626 if (mural->aidFBOs[0]!=0)
627 {
628 GLuint i;
629 for (i = 0; i < mural->cBuffers; ++i)
630 {
631 cr_server.head_spu->dispatch_table.DeleteTextures(1, &mural->aidColorTexs[i]);
632 mural->aidColorTexs[i] = 0;
633 }
634
635 cr_server.head_spu->dispatch_table.DeleteRenderbuffersEXT(1, &mural->idDepthStencilRB);
636 mural->idDepthStencilRB = 0;
637
638 for (i = 0; i < mural->cBuffers; ++i)
639 {
640 cr_server.head_spu->dispatch_table.DeleteFramebuffersEXT(1, &mural->aidFBOs[i]);
641 mural->aidFBOs[i] = 0;
642 }
643 }
644
645 mural->cBuffers = 0;
646}
647
648#define MIN(a, b) ((a) < (b) ? (a) : (b))
649#define MAX(a, b) ((a) > (b) ? (a) : (b))
650
651static GLboolean crServerIntersectRect(CRrecti *a, CRrecti *b, CRrecti *rect)
652{
653 CRASSERT(a && b && rect);
654
655 rect->x1 = MAX(a->x1, b->x1);
656 rect->x2 = MIN(a->x2, b->x2);
657 rect->y1 = MAX(a->y1, b->y1);
658 rect->y2 = MIN(a->y2, b->y2);
659
660 return (rect->x2>rect->x1) && (rect->y2>rect->y1);
661}
662
663DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable)
664{
665 RT_NOREF(fEnable);
666}
667
668DECLEXPORT(void) crServerVBoxScreenshotRelease(CR_SCREENSHOT *pScreenshot)
669{
670 if (pScreenshot->fDataAllocated)
671 {
672 RTMemFree(pScreenshot->Img.pvData);
673 pScreenshot->fDataAllocated = 0;
674 }
675}
676
677DECLEXPORT(int) crServerVBoxScreenshotGet(uint32_t u32Screen, uint32_t width, uint32_t height, uint32_t pitch, void *pvBuffer, CR_SCREENSHOT *pScreenshot)
678{
679 HCR_FRAMEBUFFER hFb = CrPMgrFbGetEnabledForScreen(u32Screen);
680 if (!hFb)
681 return VERR_INVALID_STATE;
682
683 const VBVAINFOSCREEN *pScreen = CrFbGetScreenInfo(hFb);
684
685 if (!width)
686 width = pScreen->u32Width;
687 if (!height)
688 height = pScreen->u32Height;
689 if (!pitch)
690 pitch = pScreen->u32LineSize;
691
692 if (CrFbHas3DData(hFb)
693 || pScreen->u32Width != width
694 || pScreen->u32Height != height
695 || pScreen->u32LineSize != pitch
696 || pScreen->u16BitsPerPixel != 32)
697 {
698 RTRECTSIZE SrcRectSize;
699 RTRECT DstRect;
700
701 pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
702 if (!pvBuffer)
703 {
704 pScreenshot->Img.pvData = RTMemAlloc(pScreenshot->Img.cbData);
705 if (!pScreenshot->Img.pvData)
706 {
707 WARN(("RTMemAlloc failed"));
708 return VERR_NO_MEMORY;
709 }
710 pScreenshot->fDataAllocated = 1;
711 }
712 else
713 {
714 pScreenshot->Img.pvData = pvBuffer;
715 pScreenshot->fDataAllocated = 0;
716 }
717
718 pScreenshot->Img.enmFormat = GL_BGRA;
719 pScreenshot->Img.width = width;
720 pScreenshot->Img.height = height;
721 pScreenshot->Img.bpp = 32;
722 pScreenshot->Img.pitch = pitch;
723 SrcRectSize.cx = pScreen->u32Width;
724 SrcRectSize.cy = pScreen->u32Height;
725 DstRect.xLeft = 0;
726 DstRect.yTop = 0;
727 DstRect.xRight = width;
728 DstRect.yBottom = height;
729 int rc = CrFbBltGetContentsEx(hFb, &SrcRectSize, &DstRect, 1, &DstRect, &pScreenshot->Img);
730 if (!RT_SUCCESS(rc))
731 {
732 WARN(("CrFbBltGetContents failed %d", rc));
733 crServerVBoxScreenshotRelease(pScreenshot);
734 return rc;
735 }
736 }
737 else
738 {
739 pScreenshot->Img.cbData = pScreen->u32LineSize * pScreen->u32Height;
740 if (!pvBuffer)
741 pScreenshot->Img.pvData = CrFbGetVRAM(hFb);
742 else
743 {
744 pScreenshot->Img.pvData = pvBuffer;
745 memcpy(pvBuffer, CrFbGetVRAM(hFb), pScreenshot->Img.cbData);
746 }
747 pScreenshot->Img.enmFormat = GL_BGRA;
748 pScreenshot->Img.width = pScreen->u32Width;
749 pScreenshot->Img.height = pScreen->u32Height;
750 pScreenshot->Img.bpp = pScreen->u16BitsPerPixel;
751 pScreenshot->Img.pitch = pScreen->u32LineSize;
752
753 pScreenshot->fDataAllocated = 0;
754 }
755
756 pScreenshot->u32Screen = u32Screen;
757
758 return VINF_SUCCESS;
759}
760
761extern DECLEXPORT(int) crServerVBoxWindowsShow(bool fShow)
762{
763 return CrPMgrModeWinVisible(fShow);
764}
765
766void crServerPresentFBO(CRMuralInfo *mural)
767{
768 uint32_t i;
769 for (i = 0; i < mural->cUsedFBDatas; ++i)
770 {
771 CR_FBDATA *pData = mural->apUsedFBDatas[i];
772 int rc = CrFbUpdateBegin(pData->hFb);
773 if (RT_SUCCESS(rc))
774 {
775 CrFbEntryTexDataUpdate(pData->hFb, pData->hFbEntry, pData->apTexDatas[CR_SERVER_FBO_FB_IDX(mural)]);
776 CrFbUpdateEnd(pData->hFb);
777 }
778 else
779 WARN(("CrFbUpdateBegin failed rc %d", rc));
780 }
781}
782
783GLboolean crServerIsRedirectedToFBO()
784{
785#ifdef DEBUG_misha
786 Assert(cr_server.curClient);
787 if (cr_server.curClient)
788 {
789 Assert(cr_server.curClient->currentMural == cr_server.currentMural);
790 Assert(cr_server.curClient->currentCtxInfo == cr_server.currentCtxInfo);
791 }
792#endif
793 return cr_server.curClient
794 && cr_server.curClient->currentMural
795 && cr_server.curClient->currentMural->fRedirected;
796}
797
798GLint crServerMuralFBOIdxFromBufferName(CRMuralInfo *mural, GLenum buffer)
799{
800 switch (buffer)
801 {
802 case GL_FRONT:
803 case GL_FRONT_LEFT:
804 case GL_FRONT_RIGHT:
805 return CR_SERVER_FBO_FB_IDX(mural);
806 case GL_BACK:
807 case GL_BACK_LEFT:
808 case GL_BACK_RIGHT:
809 return CR_SERVER_FBO_BB_IDX(mural);
810 case GL_NONE:
811 case GL_AUX0:
812 case GL_AUX1:
813 case GL_AUX2:
814 case GL_AUX3:
815 case GL_LEFT:
816 case GL_RIGHT:
817 case GL_FRONT_AND_BACK:
818 return -1;
819 default:
820 WARN(("crServerMuralFBOIdxFromBufferName: invalid buffer passed 0x%x", buffer));
821 return -2;
822 }
823}
824
825void crServerMuralFBOSwapBuffers(CRMuralInfo *mural)
826{
827 CRContext *ctx = crStateGetCurrent();
828 GLint iOldCurDrawBuffer = mural->iCurDrawBuffer;
829 GLint iOldCurReadBuffer = mural->iCurReadBuffer;
830 mural->iBbBuffer = ((mural->iBbBuffer + 1) % (mural->cBuffers));
831 if (mural->iCurDrawBuffer >= 0)
832 mural->iCurDrawBuffer = ((mural->iCurDrawBuffer + 1) % (mural->cBuffers));
833 if (mural->iCurReadBuffer >= 0)
834 mural->iCurReadBuffer = ((mural->iCurReadBuffer + 1) % (mural->cBuffers));
835 Assert(iOldCurDrawBuffer != mural->iCurDrawBuffer || mural->cBuffers == 1 || mural->iCurDrawBuffer < 0);
836 Assert(iOldCurReadBuffer != mural->iCurReadBuffer || mural->cBuffers == 1 || mural->iCurReadBuffer < 0);
837 if (!ctx->framebufferobject.drawFB && iOldCurDrawBuffer != mural->iCurDrawBuffer)
838 {
839 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer));
840 }
841 if (!ctx->framebufferobject.readFB && iOldCurReadBuffer != mural->iCurReadBuffer)
842 {
843 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
844 }
845 Assert(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
846}
847
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