server_muralfbo.cpp@ 51320

Last change on this file since 51320 was 51320, checked in by vboxsync, 11 years ago
crOpenGL: multi-screen fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.8 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: