server_muralfbo.cpp@ 50123

Last change on this file since 50123 was 50123, 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: 21.3 KB

Line
1	/* $Id: server_muralfbo.cpp 50123 2014-01-20 16:30:32Z 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.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
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 < 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	int rc;
198	Tex.width = mural->width;
199	Tex.height = mural->height;
200	Tex.hwid = mural->aidColorTexs[i];
201	Tex.target = GL_TEXTURE_2D;
202
203	pData->apTexDatas[i] = CrFbTexDataCreate(&Tex);
204	}
205
206	rc = CrFbEntryCreateForTexData(hFb, pData->apTexDatas[CR_SERVER_FBO_FB_IDX(mural)], 0, &pData->hFbEntry);
207	if (!RT_SUCCESS(rc))
208	{
209	WARN(("CrFbEntryCreateForTexData failed rc %d", rc));
210	}
211	}
212	else
213	{
214	CRASSERT(pData->hFb == hFb);
215	}
216
217	rc = CrFbUpdateBegin(hFb);
218	if (!RT_SUCCESS(rc))
219	{
220	WARN(("CrFbUpdateBegin failed rc %d", rc));
221	return rc;
222	}
223
224	rc = CrFbEntryRegionsSet(hFb, pData->hFbEntry, &Pos, cRegions, pRegions, true);
225	if (!RT_SUCCESS(rc))
226	{
227	WARN(("CrFbEntryRegionsSet failed rc %d", rc));
228	}
229
230	CrFbUpdateEnd(hFb);
231
232	const struct VBOXVR_SCR_COMPOSITOR_ENTRY* pCEntry = CrFbEntryGetCompositorEntry(pData->hFbEntry);
233	if (CrVrScrCompositorEntryIsUsed(pCEntry))
234	*ppData = pData;
235
236	return rc;
237	}
238
239	static void crServerRedirMuralFbSync(CRMuralInfo *mural)
240	{
241	uint32_t i;
242	uint32_t cUsedFBs = 0;
243	HCR_FRAMEBUFFER ahUsedFbs[CR_MAX_GUEST_MONITORS];
244	HCR_FRAMEBUFFER hFb;
245
246	for (i = 0; i < mural->cUsedFBDatas; ++i)
247	{
248	CR_FBDATA *pData = mural->apUsedFBDatas[i];
249	int rc = CrFbUpdateBegin(pData->hFb);
250	if (RT_SUCCESS(rc))
251	{
252	ahUsedFbs[cUsedFBs] = pData->hFb;
253	CrFbEntryRegionsSet(pData->hFb, pData->hFbEntry, NULL, 0, NULL, false);
254	++cUsedFBs;
255	}
256	else
257	WARN(("CrFbUpdateBegin failed rc %d", rc));
258	}
259	mural->cUsedFBDatas = 0;
260
261	if (!mural->width
262	\|\| !mural->height
263	\|\| !mural->bVisible
264	)
265	goto end;
266
267	CRASSERT(mural->fRedirected);
268
269	for (hFb = CrPMgrFbGetFirstEnabled();
270	hFb;
271	hFb = CrPMgrFbGetNextEnabled(hFb))
272	{
273	CR_FBDATA *pData = NULL;
274	int rc = crServerRedirMuralDbSyncFb(mural, hFb, &pData);
275	if (!RT_SUCCESS(rc))
276	{
277	WARN(("crServerRedirMuralDbSyncFb failed %d", rc));
278	continue;
279	}
280
281	if (!pData)
282	continue;
283
284	mural->apUsedFBDatas[mural->cUsedFBDatas] = pData;
285	++mural->cUsedFBDatas;
286	}
287
288	end:
289
290	for (i = 0; i < cUsedFBs; ++i)
291	{
292	CrFbUpdateEnd(ahUsedFbs[i]);
293	}
294	}
295
296	static void crVBoxServerMuralFbCleanCB(unsigned long key, void data1, void data2)
297	{
298	CRMuralInfo pMI = (CRMuralInfo) data1;
299	HCR_FRAMEBUFFER hFb = (HCR_FRAMEBUFFER)data2;
300	uint32_t i;
301	for (i = 0; i < pMI->cUsedFBDatas; ++i)
302	{
303	CR_FBDATA *pData = pMI->apUsedFBDatas[i];
304	if (hFb != pData->hFb)
305	continue;
306
307	CrFbEntryRegionsSet(pData->hFb, pData->hFbEntry, NULL, 0, NULL, false);
308	break;
309	}
310	}
311
312	static void crVBoxServerMuralFbSetCB(unsigned long key, void data1, void data2)
313	{
314	CRMuralInfo pMI = (CRMuralInfo) data1;
315	HCR_FRAMEBUFFER hFb = (HCR_FRAMEBUFFER)data2;
316	uint32_t i;
317	CR_FBDATA *pData = NULL;
318	bool fFbWasUsed = false;
319
320	Assert(hFb);
321
322	if (!pMI->fRedirected)
323	{
324	Assert(!pMI->cUsedFBDatas);
325	return;
326	}
327
328	for (i = 0; i < pMI->cUsedFBDatas; ++i)
329	{
330	CR_FBDATA *pData = pMI->apUsedFBDatas[i];
331	if (hFb != pData->hFb)
332	continue;
333
334	fFbWasUsed = true;
335	break;
336	}
337
338	if (CrFbIsEnabled(hFb))
339	{
340	int rc = crServerRedirMuralDbSyncFb(pMI, hFb, &pData);
341	if (!RT_SUCCESS(rc))
342	{
343	WARN(("crServerRedirMuralDbSyncFb failed %d", rc));
344	pData = NULL;
345	}
346	}
347
348	if (pData)
349	{
350	if (!fFbWasUsed)
351	{
352	uint32_t idScreen = CrFbGetScreenInfo(hFb)->u32ViewIndex;
353	for (i = 0; i < pMI->cUsedFBDatas; ++i)
354	{
355	CR_FBDATA *pData = pMI->apUsedFBDatas[i];
356	uint32_t idCurScreen = CrFbGetScreenInfo(pData->hFb)->u32ViewIndex;
357	if (idCurScreen > idScreen)
358	break;
359
360	Assert(idCurScreen != idScreen);
361	}
362
363	for (int j = pMI->cUsedFBDatas; j > i; --j)
364	{
365	pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j-1];
366	}
367
368	pMI->apUsedFBDatas[i] = pData;
369	++pMI->cUsedFBDatas;
370	}
371	/* else - nothing to do */
372	}
373	else
374	{
375	if (fFbWasUsed)
376	{
377	for (int j = i; j < pMI->cUsedFBDatas - 1; ++j)
378	{
379	pMI->apUsedFBDatas[j] = pMI->apUsedFBDatas[j+1];
380	}
381	--pMI->cUsedFBDatas;
382	}
383	/* else - nothing to do */
384	}
385	}
386
387	void crVBoxServerMuralFbResizeEnd(HCR_FRAMEBUFFER hFb)
388	{
389	crHashtableWalk(cr_server.muralTable, crVBoxServerMuralFbSetCB, hFb);
390	}
391
392	void crVBoxServerMuralFbResizeBegin(HCR_FRAMEBUFFER hFb)
393	{
394	crHashtableWalk(cr_server.muralTable, crVBoxServerMuralFbCleanCB, hFb);
395	}
396
397	DECLEXPORT(int) crVBoxServerNotifyResize(const struct VBVAINFOSCREEN pScreen, void pvVRAM)
398	{
399	int rc;
400	HCR_FRAMEBUFFER hFb = CrPMgrFbGet(pScreen->u32ViewIndex);
401	if (!hFb)
402	{
403	WARN(("CrPMgrFbGet failed"));
404	return VERR_INVALID_PARAMETER;
405	}
406
407	rc = CrFbUpdateBegin(hFb);
408	if (!RT_SUCCESS(rc))
409	{
410	WARN(("CrFbUpdateBegin failed %d", rc));
411	return rc;
412	}
413
414	crVBoxServerMuralFbResizeBegin(hFb);
415
416	rc = CrFbResize(hFb, pScreen, pvVRAM);
417	if (!RT_SUCCESS(rc))
418	{
419	WARN(("CrFbResize failed %d", rc));
420	}
421
422	crVBoxServerMuralFbResizeEnd(hFb);
423
424	CrFbUpdateEnd(hFb);
425
426	CrPMgrNotifyResize(hFb);
427
428	return rc;
429	}
430
431	void crServerRedirMuralFBO(CRMuralInfo *mural, bool fEnabled)
432	{
433	if (!mural->fRedirected == !fEnabled)
434	{
435	return;
436	}
437
438	if (!mural->CreateInfo.externalID)
439	{
440	WARN(("trying to change redir setting for internal mural %d", mural->spuWindow));
441	return;
442	}
443
444	if (fEnabled)
445	{
446	if (!crServerSupportRedirMuralFBO())
447	{
448	WARN(("FBO not supported, can't redirect window output"));
449	return;
450	}
451
452	if (mural->aidFBOs[0]==0)
453	{
454	crServerCreateMuralFBO(mural);
455	}
456
457	if (cr_server.curClient && cr_server.curClient->currentMural == mural)
458	{
459	if (!crStateGetCurrent()->framebufferobject.drawFB)
460	{
461	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer));
462	}
463	if (!crStateGetCurrent()->framebufferobject.readFB)
464	{
465	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
466	}
467
468	crStateGetCurrent()->buffer.width = 0;
469	crStateGetCurrent()->buffer.height = 0;
470	}
471	}
472	else
473	{
474	if (cr_server.curClient && cr_server.curClient->currentMural == mural)
475	{
476	if (!crStateGetCurrent()->framebufferobject.drawFB)
477	{
478	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);
479	}
480	if (!crStateGetCurrent()->framebufferobject.readFB)
481	{
482	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, 0);
483	}
484
485	crStateGetCurrent()->buffer.width = mural->width;
486	crStateGetCurrent()->buffer.height = mural->height;
487	}
488	}
489
490	mural->fRedirected = !!fEnabled;
491	}
492
493	static void crServerCreateMuralFBO(CRMuralInfo *mural)
494	{
495	CRContext *ctx = crStateGetCurrent();
496	GLuint uid, i;
497	GLenum status;
498	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
499	CRContextInfo *pMuralContextInfo;
500
501	CRASSERT(mural->aidFBOs[0]==0);
502	CRASSERT(mural->aidFBOs[1]==0);
503
504	pMuralContextInfo = cr_server.currentCtxInfo;
505	if (!pMuralContextInfo)
506	{
507	/* happens on saved state load */
508	CRASSERT(cr_server.MainContextInfo.SpuContext);
509	pMuralContextInfo = &cr_server.MainContextInfo;
510	cr_server.head_spu->dispatch_table.MakeCurrent(mural->spuWindow, 0, cr_server.MainContextInfo.SpuContext);
511	}
512
513	if (pMuralContextInfo->CreateInfo.visualBits != mural->CreateInfo.visualBits)
514	{
515	WARN(("mural visual bits do not match with current context visual bits!"));
516	}
517
518	mural->cBuffers = 2;
519	mural->iBbBuffer = 0;
520	/Color texture/
521
522	if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
523	{
524	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
525	}
526
527	for (i = 0; i < mural->cBuffers; ++i)
528	{
529	gl->GenTextures(1, &mural->aidColorTexs[i]);
530	gl->BindTexture(GL_TEXTURE_2D, mural->aidColorTexs[i]);
531	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
532	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
533	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
534	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
535	gl->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, mural->width, mural->height,
536	0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
537	}
538
539	/Depth&Stencil/
540	gl->GenRenderbuffersEXT(1, &mural->idDepthStencilRB);
541	gl->BindRenderbufferEXT(GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
542	gl->RenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
543	mural->width, mural->height);
544
545	/FBO/
546	for (i = 0; i < mural->cBuffers; ++i)
547	{
548	gl->GenFramebuffersEXT(1, &mural->aidFBOs[i]);
549	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mural->aidFBOs[i]);
550
551	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
552	GL_TEXTURE_2D, mural->aidColorTexs[i], 0);
553	gl->FramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
554	GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
555	gl->FramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
556	GL_RENDERBUFFER_EXT, mural->idDepthStencilRB);
557
558	status = gl->CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
559	if (status!=GL_FRAMEBUFFER_COMPLETE_EXT)
560	{
561	WARN(("FBO status(0x%x) isn't complete", status));
562	}
563	}
564
565	mural->iCurDrawBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.drawBuffer);
566	mural->iCurReadBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.readBuffer);
567
568	mural->fboWidth = mural->width;
569	mural->fboHeight = mural->height;
570
571	mural->iCurDrawBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.drawBuffer);
572	mural->iCurReadBuffer = crServerMuralFBOIdxFromBufferName(mural, ctx->buffer.readBuffer);
573
574	/Restore gl state/
575	uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid;
576	gl->BindTexture(GL_TEXTURE_2D, uid);
577
578	uid = ctx->framebufferobject.renderbuffer ? ctx->framebufferobject.renderbuffer->hwid:0;
579	gl->BindRenderbufferEXT(GL_RENDERBUFFER_EXT, uid);
580
581	uid = ctx->framebufferobject.drawFB ? ctx->framebufferobject.drawFB->hwid:0;
582	gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, uid);
583
584	uid = ctx->framebufferobject.readFB ? ctx->framebufferobject.readFB->hwid:0;
585	gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER, uid);
586
587	if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
588	{
589	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
590	}
591
592	if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
593	{
594	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
595	}
596	else
597	{
598	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
599	}
600
601	CRASSERT(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
602	}
603
604	void crServerDeleteMuralFBO(CRMuralInfo *mural)
605	{
606	if (mural->aidFBOs[0]!=0)
607	{
608	GLuint i;
609	for (i = 0; i < mural->cBuffers; ++i)
610	{
611	cr_server.head_spu->dispatch_table.DeleteTextures(1, &mural->aidColorTexs[i]);
612	mural->aidColorTexs[i] = 0;
613	}
614
615	cr_server.head_spu->dispatch_table.DeleteRenderbuffersEXT(1, &mural->idDepthStencilRB);
616	mural->idDepthStencilRB = 0;
617
618	for (i = 0; i < mural->cBuffers; ++i)
619	{
620	cr_server.head_spu->dispatch_table.DeleteFramebuffersEXT(1, &mural->aidFBOs[i]);
621	mural->aidFBOs[i] = 0;
622	}
623	}
624
625	mural->cBuffers = 0;
626	}
627
628	#define MIN(a, b) ((a) < (b) ? (a) : (b))
629	#define MAX(a, b) ((a) > (b) ? (a) : (b))
630
631	static GLboolean crServerIntersectRect(CRrecti a, CRrecti b, CRrecti *rect)
632	{
633	CRASSERT(a && b && rect);
634
635	rect->x1 = MAX(a->x1, b->x1);
636	rect->x2 = MIN(a->x2, b->x2);
637	rect->y1 = MAX(a->y1, b->y1);
638	rect->y2 = MIN(a->y2, b->y2);
639
640	return (rect->x2>rect->x1) && (rect->y2>rect->y1);
641	}
642
643	static void crServerCopySubImage(char pDst, char pSrc, CRrecti *pRect, int srcWidth, int srcHeight)
644	{
645	int i;
646	int dstrowsize = 4*(pRect->x2-pRect->x1);
647	int srcrowsize = 4*srcWidth;
648	int height = pRect->y2-pRect->y1;
649
650	pSrc += 4pRect->x1 + srcrowsize(srcHeight-1-pRect->y1);
651
652	for (i=0; i<height; ++i)
653	{
654	crMemcpy(pDst, pSrc, dstrowsize);
655
656	pSrc -= srcrowsize;
657	pDst += dstrowsize;
658	}
659	}
660
661	DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable)
662	{
663	}
664
665	void crServerPresentFBO(CRMuralInfo *mural)
666	{
667	uint32_t i;
668	for (i = 0; i < mural->cUsedFBDatas; ++i)
669	{
670	CR_FBDATA *pData = mural->apUsedFBDatas[i];
671	int rc = CrFbUpdateBegin(pData->hFb);
672	if (RT_SUCCESS(rc))
673	{
674	CrFbEntryTexDataUpdate(pData->hFb, pData->hFbEntry, pData->apTexDatas[CR_SERVER_FBO_FB_IDX(mural)]);
675	CrFbUpdateEnd(pData->hFb);
676	}
677	else
678	WARN(("CrFbUpdateBegin failed rc %d", rc));
679	}
680	}
681
682	GLboolean crServerIsRedirectedToFBO()
683	{
684	#ifdef DEBUG_misha
685	Assert(cr_server.curClient);
686	if (cr_server.curClient)
687	{
688	Assert(cr_server.curClient->currentMural == cr_server.currentMural);
689	Assert(cr_server.curClient->currentCtxInfo == cr_server.currentCtxInfo);
690	}
691	#endif
692	return cr_server.curClient
693	&& cr_server.curClient->currentMural
694	&& cr_server.curClient->currentMural->fRedirected;
695	}
696
697	GLint crServerMuralFBOIdxFromBufferName(CRMuralInfo *mural, GLenum buffer)
698	{
699	switch (buffer)
700	{
701	case GL_FRONT:
702	case GL_FRONT_LEFT:
703	case GL_FRONT_RIGHT:
704	return CR_SERVER_FBO_FB_IDX(mural);
705	case GL_BACK:
706	case GL_BACK_LEFT:
707	case GL_BACK_RIGHT:
708	return CR_SERVER_FBO_BB_IDX(mural);
709	case GL_NONE:
710	case GL_AUX0:
711	case GL_AUX1:
712	case GL_AUX2:
713	case GL_AUX3:
714	case GL_LEFT:
715	case GL_RIGHT:
716	case GL_FRONT_AND_BACK:
717	return -1;
718	default:
719	WARN(("crServerMuralFBOIdxFromBufferName: invalid buffer passed 0x%x", buffer));
720	return -2;
721	}
722	}
723
724	void crServerMuralFBOSwapBuffers(CRMuralInfo *mural)
725	{
726	CRContext *ctx = crStateGetCurrent();
727	GLuint iOldCurDrawBuffer = mural->iCurDrawBuffer;
728	GLuint iOldCurReadBuffer = mural->iCurReadBuffer;
729	mural->iBbBuffer = ((mural->iBbBuffer + 1) % (mural->cBuffers));
730	if (mural->iCurDrawBuffer >= 0)
731	mural->iCurDrawBuffer = ((mural->iCurDrawBuffer + 1) % (mural->cBuffers));
732	if (mural->iCurReadBuffer >= 0)
733	mural->iCurReadBuffer = ((mural->iCurReadBuffer + 1) % (mural->cBuffers));
734	Assert(iOldCurDrawBuffer != mural->iCurDrawBuffer \|\| mural->cBuffers == 1 \|\| mural->iCurDrawBuffer < 0);
735	Assert(iOldCurReadBuffer != mural->iCurReadBuffer \|\| mural->cBuffers == 1 \|\| mural->iCurReadBuffer < 0);
736	if (!ctx->framebufferobject.drawFB && iOldCurDrawBuffer != mural->iCurDrawBuffer)
737	{
738	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer));
739	}
740	if (!ctx->framebufferobject.readFB && iOldCurReadBuffer != mural->iCurReadBuffer)
741	{
742	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
743	}
744	Assert(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
745	}

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

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

Download in other formats: