server_misc.c@ 52350

Last change on this file since 52350 was 52350, checked in by vboxsync, 11 years ago
more resize fixes, dumper fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 65.4 KB

Line
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include "server_dispatch.h"
8	#include "server.h"
9	#include "cr_error.h"
10	#include "cr_mem.h"
11	#include "cr_string.h"
12	#include "cr_pixeldata.h"
13	#ifdef VBOX_WITH_CRDUMPER
14	# include "cr_dump.h"
15	#endif
16
17	void SERVER_DISPATCH_APIENTRY crServerDispatchSelectBuffer( GLsizei size, GLuint *buffer )
18	{
19	(void) size;
20	(void) buffer;
21	crError( "Unsupported network glSelectBuffer call." );
22	}
23
24	void SERVER_DISPATCH_APIENTRY crServerDispatchGetChromiumParametervCR(GLenum target, GLuint index, GLenum type, GLsizei count, GLvoid *values)
25	{
26	GLubyte local_storage[4096];
27	GLint bytes = 0;
28
29	switch (type) {
30	case GL_BYTE:
31	case GL_UNSIGNED_BYTE:
32	bytes = count * sizeof(GLbyte);
33	break;
34	case GL_SHORT:
35	case GL_UNSIGNED_SHORT:
36	bytes = count * sizeof(GLshort);
37	break;
38	case GL_INT:
39	case GL_UNSIGNED_INT:
40	bytes = count * sizeof(GLint);
41	break;
42	case GL_FLOAT:
43	bytes = count * sizeof(GLfloat);
44	break;
45	case GL_DOUBLE:
46	bytes = count * sizeof(GLdouble);
47	break;
48	default:
49	crError("Bad type in crServerDispatchGetChromiumParametervCR");
50	}
51
52	CRASSERT(bytes >= 0);
53	CRASSERT(bytes < 4096);
54
55	switch (target)
56	{
57	case GL_DBG_CHECK_BREAK_CR:
58	{
59	if (bytes > 0)
60	{
61	GLubyte *pbRc = local_storage;
62	GLuint puRc = (GLuint )(bytes >=4 ? local_storage : NULL);
63	int rc;
64	memset(local_storage, 0, bytes);
65	if (cr_server.RcToGuestOnce)
66	{
67	rc = cr_server.RcToGuestOnce;
68	cr_server.RcToGuestOnce = 0;
69	}
70	else
71	{
72	rc = cr_server.RcToGuest;
73	}
74	if (puRc)
75	*puRc = rc;
76	else
77	*pbRc = !!rc;
78	}
79	else
80	{
81	crWarning("zero bytes for GL_DBG_CHECK_BREAK_CR");
82	}
83	break;
84	}
85	default:
86	cr_server.head_spu->dispatch_table.GetChromiumParametervCR( target, index, type, count, local_storage );
87	break;
88	}
89
90	crServerReturnValue( local_storage, bytes );
91	}
92
93	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParametervCR(GLenum target, GLenum type, GLsizei count, const GLvoid *values)
94	{
95	CRMuralInfo *mural = cr_server.curClient->currentMural;
96	static int gather_connect_count = 0;
97
98	switch (target) {
99	case GL_SHARE_LISTS_CR:
100	{
101	CRContextInfo *pCtx[2];
102	GLint *ai32Values;
103	int i;
104	if (count != 2)
105	{
106	WARN(("GL_SHARE_LISTS_CR invalid cound %d", count));
107	return;
108	}
109
110	if (type != GL_UNSIGNED_INT && type != GL_INT)
111	{
112	WARN(("GL_SHARE_LISTS_CR invalid type %d", type));
113	return;
114	}
115
116	ai32Values = (GLint*)values;
117
118	for (i = 0; i < 2; ++i)
119	{
120	const int32_t val = ai32Values[i];
121
122	if (val == 0)
123	{
124	WARN(("GL_SHARE_LISTS_CR invalid value[%d] %d", i, val));
125	return;
126	}
127
128	pCtx[i] = (CRContextInfo *) crHashtableSearch(cr_server.contextTable, val);
129	if (!pCtx[i])
130	{
131	WARN(("GL_SHARE_LISTS_CR invalid pCtx1 for value[%d] %d", i, val));
132	return;
133	}
134
135	if (!pCtx[i]->pContext)
136	{
137	WARN(("GL_SHARE_LISTS_CR invalid pCtx1 pContext for value[%d] %d", i, val));
138	return;
139	}
140	}
141
142	crStateShareLists(pCtx[0]->pContext, pCtx[1]->pContext);
143
144	break;
145	}
146
147	case GL_SET_MAX_VIEWPORT_CR:
148	{
149	GLint maxDims = (GLint )values;
150	cr_server.limits.maxViewportDims[0] = maxDims[0];
151	cr_server.limits.maxViewportDims[1] = maxDims[1];
152	}
153	break;
154
155	case GL_TILE_INFO_CR:
156	/* message from tilesort SPU to set new tile bounds */
157	{
158	GLint numTiles, muralWidth, muralHeight, server, tiles;
159	GLint *tileBounds;
160	CRASSERT(count >= 4);
161	CRASSERT((count - 4) % 4 == 0); /* must be multiple of four */
162	CRASSERT(type == GL_INT);
163	numTiles = (count - 4) / 4;
164	tileBounds = (GLint *) values;
165	server = tileBounds[0];
166	muralWidth = tileBounds[1];
167	muralHeight = tileBounds[2];
168	tiles = tileBounds[3];
169	CRASSERT(tiles == numTiles);
170	tileBounds += 4; /* skip over header values */
171	/*crServerNewMuralTiling(mural, muralWidth, muralHeight, numTiles, tileBounds);
172	mural->viewportValidated = GL_FALSE;*/
173	}
174	break;
175
176	case GL_GATHER_DRAWPIXELS_CR:
177	if (cr_server.only_swap_once && cr_server.curClient != cr_server.clients[0])
178	break;
179	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
180	break;
181
182	case GL_GATHER_CONNECT_CR:
183	/*
184	* We want the last connect to go through,
185	* otherwise we might deadlock in CheckWindowSize()
186	* in the readback spu
187	*/
188	gather_connect_count++;
189	if (cr_server.only_swap_once && (gather_connect_count != cr_server.numClients))
190	{
191	break;
192	}
193	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
194	gather_connect_count = 0;
195	break;
196
197	case GL_SERVER_VIEW_MATRIX_CR:
198	/* Set this server's view matrix which will get premultiplied onto the
199	* modelview matrix. For non-planar tilesort and stereo.
200	*/
201	CRASSERT(count == 18);
202	CRASSERT(type == GL_FLOAT);
203	/* values[0] is the server index. Ignored here but used in tilesort SPU */
204	/* values[1] is the left/right eye index (0 or 1) */
205	{
206	const GLfloat v = (const GLfloat ) values;
207	const int eye = v[1] == 0.0 ? 0 : 1;
208	crMatrixInitFromFloats(&cr_server.viewMatrix[eye], v + 2);
209
210	crDebug("Got GL_SERVER_VIEW_MATRIX_CR:\n"
211	" %f %f %f %f\n"
212	" %f %f %f %f\n"
213	" %f %f %f %f\n"
214	" %f %f %f %f",
215	cr_server.viewMatrix[eye].m00,
216	cr_server.viewMatrix[eye].m10,
217	cr_server.viewMatrix[eye].m20,
218	cr_server.viewMatrix[eye].m30,
219	cr_server.viewMatrix[eye].m01,
220	cr_server.viewMatrix[eye].m11,
221	cr_server.viewMatrix[eye].m21,
222	cr_server.viewMatrix[eye].m31,
223	cr_server.viewMatrix[eye].m02,
224	cr_server.viewMatrix[eye].m12,
225	cr_server.viewMatrix[eye].m22,
226	cr_server.viewMatrix[eye].m32,
227	cr_server.viewMatrix[eye].m03,
228	cr_server.viewMatrix[eye].m13,
229	cr_server.viewMatrix[eye].m23,
230	cr_server.viewMatrix[eye].m33);
231	}
232	cr_server.viewOverride = GL_TRUE;
233	break;
234
235	case GL_SERVER_PROJECTION_MATRIX_CR:
236	/* Set this server's projection matrix which will get replace the user's
237	* projection matrix. For non-planar tilesort and stereo.
238	*/
239	CRASSERT(count == 18);
240	CRASSERT(type == GL_FLOAT);
241	/* values[0] is the server index. Ignored here but used in tilesort SPU */
242	/* values[1] is the left/right eye index (0 or 1) */
243	{
244	const GLfloat v = (const GLfloat ) values;
245	const int eye = v[1] == 0.0 ? 0 : 1;
246	crMatrixInitFromFloats(&cr_server.projectionMatrix[eye], v + 2);
247
248	crDebug("Got GL_SERVER_PROJECTION_MATRIX_CR:\n"
249	" %f %f %f %f\n"
250	" %f %f %f %f\n"
251	" %f %f %f %f\n"
252	" %f %f %f %f",
253	cr_server.projectionMatrix[eye].m00,
254	cr_server.projectionMatrix[eye].m10,
255	cr_server.projectionMatrix[eye].m20,
256	cr_server.projectionMatrix[eye].m30,
257	cr_server.projectionMatrix[eye].m01,
258	cr_server.projectionMatrix[eye].m11,
259	cr_server.projectionMatrix[eye].m21,
260	cr_server.projectionMatrix[eye].m31,
261	cr_server.projectionMatrix[eye].m02,
262	cr_server.projectionMatrix[eye].m12,
263	cr_server.projectionMatrix[eye].m22,
264	cr_server.projectionMatrix[eye].m32,
265	cr_server.projectionMatrix[eye].m03,
266	cr_server.projectionMatrix[eye].m13,
267	cr_server.projectionMatrix[eye].m23,
268	cr_server.projectionMatrix[eye].m33);
269
270	if (cr_server.projectionMatrix[eye].m33 == 0.0f) {
271	float x = cr_server.projectionMatrix[eye].m00;
272	float y = cr_server.projectionMatrix[eye].m11;
273	float a = cr_server.projectionMatrix[eye].m20;
274	float b = cr_server.projectionMatrix[eye].m21;
275	float c = cr_server.projectionMatrix[eye].m22;
276	float d = cr_server.projectionMatrix[eye].m32;
277	float znear = -d / (1.0f - c);
278	float zfar = (c - 1.0f) * znear / (c + 1.0f);
279	float left = znear * (a - 1.0f) / x;
280	float right = 2.0f * znear / x + left;
281	float bottom = znear * (b - 1.0f) / y;
282	float top = 2.0f * znear / y + bottom;
283	crDebug("Frustum: left, right, bottom, top, near, far: %f, %f, %f, %f, %f, %f", left, right, bottom, top, znear, zfar);
284	}
285	else {
286	/* Todo: Add debug output for orthographic projection*/
287	}
288
289	}
290	cr_server.projectionOverride = GL_TRUE;
291	break;
292
293	case GL_HH_SET_TMPCTX_MAKE_CURRENT:
294	/we should not receive it from the guest! /
295	break;
296
297	default:
298	/* Pass the parameter info to the head SPU */
299	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
300	break;
301	}
302	}
303
304
305	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParameteriCR(GLenum target, GLint value)
306	{
307	switch (target) {
308	case GL_SHARE_CONTEXT_RESOURCES_CR:
309	crStateShareContext(value);
310	break;
311	case GL_RCUSAGE_TEXTURE_SET_CR:
312	crStateSetTextureUsed(value, GL_TRUE);
313	break;
314	case GL_RCUSAGE_TEXTURE_CLEAR_CR:
315	crStateSetTextureUsed(value, GL_FALSE);
316	break;
317	case GL_PIN_TEXTURE_SET_CR:
318	crStatePinTexture(value, GL_TRUE);
319	break;
320	case GL_PIN_TEXTURE_CLEAR_CR:
321	crStatePinTexture(value, GL_FALSE);
322	break;
323	case GL_SHARED_DISPLAY_LISTS_CR:
324	cr_server.sharedDisplayLists = value;
325	break;
326	case GL_SHARED_TEXTURE_OBJECTS_CR:
327	cr_server.sharedTextureObjects = value;
328	break;
329	case GL_SHARED_PROGRAMS_CR:
330	cr_server.sharedPrograms = value;
331	break;
332	case GL_SERVER_CURRENT_EYE_CR:
333	cr_server.currentEye = value ? 1 : 0;
334	break;
335	case GL_HOST_WND_CREATED_HIDDEN_CR:
336	cr_server.bWindowsInitiallyHidden = value ? 1 : 0;
337	break;
338	case GL_HH_SET_DEFAULT_SHARED_CTX:
339	crWarning("Recieved GL_HH_SET_DEFAULT_SHARED_CTX from guest, ignoring");
340	break;
341	case GL_HH_RENDERTHREAD_INFORM:
342	crWarning("Recieved GL_HH_RENDERTHREAD_INFORM from guest, ignoring");
343	break;
344	default:
345	/* Pass the parameter info to the head SPU */
346	cr_server.head_spu->dispatch_table.ChromiumParameteriCR( target, value );
347	}
348	}
349
350
351	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParameterfCR(GLenum target, GLfloat value)
352	{
353	switch (target) {
354	case GL_SHARED_DISPLAY_LISTS_CR:
355	cr_server.sharedDisplayLists = (int) value;
356	break;
357	case GL_SHARED_TEXTURE_OBJECTS_CR:
358	cr_server.sharedTextureObjects = (int) value;
359	break;
360	case GL_SHARED_PROGRAMS_CR:
361	cr_server.sharedPrograms = (int) value;
362	break;
363	default:
364	/* Pass the parameter info to the head SPU */
365	cr_server.head_spu->dispatch_table.ChromiumParameterfCR( target, value );
366	}
367	}
368
369	GLint crServerGenerateID(GLint *pCounter)
370	{
371	return (*pCounter)++;
372	}
373
374	/#define CR_DUMP_BLITS/
375
376	#ifdef CR_DUMP_BLITS
377	static int blitnum=0;
378	static int copynum=0;
379	#endif
380
381	# ifdef DEBUG_misha
382	//# define CR_CHECK_BLITS
383	# include <iprt/assert.h>
384	# undef CRASSERT /* iprt assert's int3 are inlined that is why are more convenient to use since they can be easily disabled individually */
385	# define CRASSERT Assert
386	# endif
387
388
389	void SERVER_DISPATCH_APIENTRY
390	crServerDispatchCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
391	{
392	/@todo pbo/fbo disabled for now as it's slower, check on other gpus/
393	static int siHavePBO = 0;
394	static int siHaveFBO = 0;
395
396	if ((target!=GL_TEXTURE_2D) \|\| (height>=0))
397	{
398	cr_server.head_spu->dispatch_table.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
399
400	#ifdef CR_DUMP_BLITS
401	{
402	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
403	void *img;
404	GLint w, h;
405	char fname[200];
406
407	copynum++;
408
409	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
410	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
411
412	img = crAlloc(wh4);
413	CRASSERT(img);
414
415	gl->GetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, img);
416	sprintf(fname, "copy_blit%i_copy_%i.tga", blitnum, copynum);
417	crDumpNamedTGA(fname, w, h, img);
418	crFree(img);
419	}
420	#endif
421	}
422	else /* negative height, means we have to Yinvert the source pixels while copying */
423	{
424	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
425
426	if (siHavePBO<0)
427	{
428	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
429	siHavePBO = crStrstr(ext, "GL_ARB_pixel_buffer_object") ? 1:0;
430	}
431
432	if (siHaveFBO<0)
433	{
434	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
435	siHaveFBO = crStrstr(ext, "GL_EXT_framebuffer_object") ? 1:0;
436	}
437
438	if (siHavePBO==0 && siHaveFBO==0)
439	{
440	#if 1
441	GLint dRow, sRow;
442	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
443	{
444	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
445	}
446	#else
447	{
448	GLint w, h, i;
449	char img1, img2, sPtr, dPtr;
450	CRContext *ctx = crStateGetCurrent();
451
452	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
453	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
454
455	img1 = crAlloc(4wh);
456	img2 = crAlloc(4width(-height));
457	CRASSERT(img1 && img2);
458
459	gl->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, -height);
460	gl->GetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, img1);
461
462	sPtr=img1+4xoffset+4w*yoffset;
463	dPtr=img2+4width(-height-1);
464
465	for (i=0; i<-height; ++i)
466	{
467	crMemcpy(dPtr, sPtr, 4*width);
468	sPtr += 4*w;
469	dPtr -= 4*width;
470	}
471
472	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, img2);
473
474	crFree(img1);
475	crFree(img2);
476	}
477	#endif
478	}
479	else if (siHaveFBO==1) /@todo more states to set and restore here/
480	{
481	GLuint tID, fboID;
482	GLenum status;
483	CRContext *ctx = crStateGetCurrent();
484
485	gl->GenTextures(1, &tID);
486	gl->BindTexture(target, tID);
487	gl->CopyTexImage2D(target, level, GL_RGBA, x, y, width, -height, 0);
488	gl->GenFramebuffersEXT(1, &fboID);
489	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
490	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target,
491	ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid, level);
492	status = gl->CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
493	if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
494	{
495	crWarning("Framebuffer status 0x%x", status);
496	}
497
498	gl->Enable(target);
499	gl->PushAttrib(GL_VIEWPORT_BIT);
500	gl->Viewport(xoffset, yoffset, width, -height);
501	gl->MatrixMode(GL_PROJECTION);
502	gl->PushMatrix();
503	gl->LoadIdentity();
504	gl->MatrixMode(GL_MODELVIEW);
505	gl->PushMatrix();
506	gl->LoadIdentity();
507
508	gl->Disable(GL_DEPTH_TEST);
509	gl->Disable(GL_CULL_FACE);
510	gl->Disable(GL_STENCIL_TEST);
511	gl->Disable(GL_SCISSOR_TEST);
512
513	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
514	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
515	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
516	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
517	gl->TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
518
519	gl->Begin(GL_QUADS);
520	gl->TexCoord2f(0.0f, 1.0f);
521	gl->Vertex2f(-1.0, -1.0);
522
523	gl->TexCoord2f(0.0f, 0.0f);
524	gl->Vertex2f(-1.0f, 1.0f);
525
526	gl->TexCoord2f(1.0f, 0.0f);
527	gl->Vertex2f(1.0f, 1.0f);
528
529	gl->TexCoord2f(1.0f, 1.0f);
530	gl->Vertex2f(1.0f, -1.0f);
531	gl->End();
532
533	gl->PopMatrix();
534	gl->MatrixMode(GL_PROJECTION);
535	gl->PopMatrix();
536	gl->PopAttrib();
537
538	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, 0, level);
539	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->framebufferobject.drawFB ? ctx->framebufferobject.drawFB->hwid:0);
540	gl->BindTexture(target, ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid);
541	gl->DeleteFramebuffersEXT(1, &fboID);
542	gl->DeleteTextures(1, &tID);
543
544	#if 0
545	{
546	GLint dRow, sRow, w, h;
547	void img1, img2;
548
549	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
550	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
551
552	img1 = crAlloc(4wh);
553	img2 = crAlloc(4wh);
554	CRASSERT(img1 && img2);
555
556	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img1);
557
558
559	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
560	{
561	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
562	}
563
564	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img2);
565
566	if (crMemcmp(img1, img2, 4wh))
567	{
568	crDebug("MISMATCH! (%x, %i, ->%i,%i <-%i, %i [%ix%i])", target, level, xoffset, yoffset, x, y, width, height);
569	crDumpTGA(w, h, img1);
570	crDumpTGA(w, h, img2);
571	DebugBreak();
572	}
573	crFree(img1);
574	crFree(img2);
575	}
576	#endif
577	}
578	else
579	{
580	GLuint pboId, dRow, sRow;
581	CRContext *ctx = crStateGetCurrent();
582
583	gl->GenBuffersARB(1, &pboId);
584	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pboId);
585	gl->BufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, -widthheight4, 0, GL_STATIC_COPY_ARB);
586
587	#if 1
588	gl->ReadPixels(x, y, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
589	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
590
591	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
592	for (dRow=yoffset, sRow=-height-1; dRow<yoffset-height; dRow++, sRow--)
593	{
594	gl->TexSubImage2D(target, level, xoffset, dRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)sRowwidth*4));
595	}
596	#else /few times slower again/
597	for (dRow=0, sRow=y-height-1; dRow<-height; dRow++, sRow--)
598	{
599	gl->ReadPixels(x, sRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)dRowwidth*4));
600	}
601	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
602
603	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
604	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
605	#endif
606
607	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
608	gl->DeleteBuffersARB(1, &pboId);
609	}
610	}
611	}
612
613	#ifdef CR_CHECK_BLITS
614	void crDbgFree(void *pvData)
615	{
616	crFree(pvData);
617	}
618
619	void crDbgGetTexImage2D(GLint texTarget, GLint texName, GLvoid *ppvImage, GLint pw, GLint *ph)
620	{
621	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
622	GLint ppb, pub, dstw, dsth, otex;
623	GLint pa, pr, psp, psr, ua, ur, usp, usr;
624	GLvoid *pvImage;
625	GLint rfb, dfb, rb, db;
626
627	gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
628	gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
629	gl->GetIntegerv(GL_READ_BUFFER, &rb);
630	gl->GetIntegerv(GL_DRAW_BUFFER, &db);
631
632	gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER_BINDING_EXT, 0);
633	gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_BINDING_EXT, 0);
634	gl->ReadBuffer(GL_BACK);
635	gl->DrawBuffer(GL_BACK);
636
637	gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
638	gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
639	gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
640
641	gl->GetIntegerv(GL_PACK_ROW_LENGTH, &pr);
642	gl->GetIntegerv(GL_PACK_ALIGNMENT, &pa);
643	gl->GetIntegerv(GL_PACK_SKIP_PIXELS, &psp);
644	gl->GetIntegerv(GL_PACK_SKIP_ROWS, &psr);
645
646	gl->GetIntegerv(GL_UNPACK_ROW_LENGTH, &ur);
647	gl->GetIntegerv(GL_UNPACK_ALIGNMENT, &ua);
648	gl->GetIntegerv(GL_UNPACK_SKIP_PIXELS, &usp);
649	gl->GetIntegerv(GL_UNPACK_SKIP_ROWS, &usr);
650
651	gl->BindTexture(texTarget, texName);
652	gl->GetTexLevelParameteriv(texTarget, 0, GL_TEXTURE_WIDTH, &dstw);
653	gl->GetTexLevelParameteriv(texTarget, 0, GL_TEXTURE_HEIGHT, &dsth);
654
655	gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
656	gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
657	gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
658	gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
659
660	gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
661	gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
662	gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
663	gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
664
665	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER, 0);
666	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER, 0);
667
668	pvImage = crAlloc(4dstwdsth);
669	gl->GetTexImage(texTarget, 0, GL_BGRA, GL_UNSIGNED_BYTE, pvImage);
670
671	gl->BindTexture(texTarget, otex);
672
673	gl->PixelStorei(GL_PACK_ROW_LENGTH, pr);
674	gl->PixelStorei(GL_PACK_ALIGNMENT, pa);
675	gl->PixelStorei(GL_PACK_SKIP_PIXELS, psp);
676	gl->PixelStorei(GL_PACK_SKIP_ROWS, psr);
677
678	gl->PixelStorei(GL_UNPACK_ROW_LENGTH, ur);
679	gl->PixelStorei(GL_UNPACK_ALIGNMENT, ua);
680	gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, usp);
681	gl->PixelStorei(GL_UNPACK_SKIP_ROWS, usr);
682
683	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER, ppb);
684	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER, pub);
685
686	gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER_BINDING_EXT, rfb);
687	gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_BINDING_EXT, dfb);
688	gl->ReadBuffer(rb);
689	gl->DrawBuffer(db);
690
691	*ppvImage = pvImage;
692	*pw = dstw;
693	*ph = dsth;
694	}
695
696	DECLEXPORT(void) crDbgPrint(const char *format, ... )
697	{
698	va_list args;
699	static char txt[8092];
700
701	va_start( args, format );
702	vsprintf( txt, format, args );
703
704	OutputDebugString(txt);
705	}
706
707	void crDbgDumpImage2D(const char* pszDesc, const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch)
708	{
709	crDbgPrint("<?dml?><exec cmd=\"!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d\">%s</exec>, ( !vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d )\n",
710	pvData, width, height, bpp, pitch,
711	pszDesc,
712	pvData, width, height, bpp, pitch);
713	}
714
715	void crDbgDumpTexImage2D(const char* pszDesc, GLint texTarget, GLint texName, GLboolean fBreak)
716	{
717	GLvoid *pvImage;
718	GLint w, h;
719	crDbgGetTexImage2D(texTarget, texName, &pvImage, &w, &h);
720	crDbgPrint("%s target(%d), name(%d), width(%d), height(%d)", pszDesc, texTarget, texName, w, h);
721	crDbgDumpImage2D("texture data", pvImage, w, h, 32, (32 * w)/8);
722	if (fBreak)
723	{
724	CRASSERT(0);
725	}
726	crDbgFree(pvImage);
727	}
728	#endif
729
730	PCR_BLITTER crServerVBoxBlitterGet()
731	{
732	if (!CrBltIsInitialized(&cr_server.Blitter))
733	{
734	CR_BLITTER_CONTEXT Ctx;
735	int rc;
736	CRASSERT(cr_server.MainContextInfo.SpuContext);
737	Ctx.Base.id = cr_server.MainContextInfo.SpuContext;
738	Ctx.Base.visualBits = cr_server.MainContextInfo.CreateInfo.realVisualBits;
739	rc = CrBltInit(&cr_server.Blitter, &Ctx, true, true, NULL, &cr_server.TmpCtxDispatch);
740	if (RT_SUCCESS(rc))
741	{
742	CRASSERT(CrBltIsInitialized(&cr_server.Blitter));
743	}
744	else
745	{
746	crWarning("CrBltInit failed, rc %d", rc);
747	CRASSERT(!CrBltIsInitialized(&cr_server.Blitter));
748	return NULL;
749	}
750	}
751
752	if (!CrBltMuralGetCurrentInfo(&cr_server.Blitter)->Base.id)
753	{
754	CRMuralInfo *dummy = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
755	CR_BLITTER_WINDOW DummyInfo;
756	CRASSERT(dummy);
757	crServerVBoxBlitterWinInit(&DummyInfo, dummy);
758	CrBltMuralSetCurrentInfo(&cr_server.Blitter, &DummyInfo);
759	}
760
761	return &cr_server.Blitter;
762	}
763
764	PCR_BLITTER crServerVBoxBlitterGetInitialized()
765	{
766	if (CrBltIsInitialized(&cr_server.Blitter))
767	return &cr_server.Blitter;
768	return NULL;
769	}
770
771
772	int crServerVBoxBlitterTexInit(CRContext ctx, CRMuralInfo mural, PVBOXVR_TEXTURE pTex, GLboolean fDraw)
773	{
774	CRTextureObj *tobj;
775	CRFramebufferObjectState *pBuf = &ctx->framebufferobject;
776	GLenum enmBuf;
777	CRFBOAttachmentPoint *pAp;
778	GLuint idx;
779	CRTextureLevel *tl;
780	CRFramebufferObject *pFBO = fDraw ? pBuf->drawFB : pBuf->readFB;
781
782	if (!pFBO)
783	{
784	GLuint hwid;
785
786	if (!mural->fRedirected)
787	{
788	WARN(("mural not redirected!"));
789	return VERR_NOT_IMPLEMENTED;
790	}
791
792	enmBuf = fDraw ? ctx->buffer.drawBuffer : ctx->buffer.readBuffer;
793	switch (enmBuf)
794	{
795	case GL_BACK:
796	case GL_BACK_RIGHT:
797	case GL_BACK_LEFT:
798	hwid = mural->aidColorTexs[CR_SERVER_FBO_BB_IDX(mural)];
799	break;
800	case GL_FRONT:
801	case GL_FRONT_RIGHT:
802	case GL_FRONT_LEFT:
803	hwid = mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)];
804	break;
805	default:
806	WARN(("unsupported enum buf %d", enmBuf));
807	return VERR_NOT_IMPLEMENTED;
808	break;
809	}
810
811	if (!hwid)
812	{
813	crWarning("offscreen render tex hwid is null");
814	return VERR_INVALID_STATE;
815	}
816
817	pTex->width = mural->width;
818	pTex->height = mural->height;
819	pTex->target = GL_TEXTURE_2D;
820	pTex->hwid = hwid;
821	return VINF_SUCCESS;
822	}
823
824	enmBuf = fDraw ? pFBO->drawbuffer[0] : pFBO->readbuffer;
825	idx = enmBuf - GL_COLOR_ATTACHMENT0_EXT;
826	if (idx >= CR_MAX_COLOR_ATTACHMENTS)
827	{
828	crWarning("idx is invalid %d, using 0", idx);
829	}
830
831	pAp = &pFBO->color[idx];
832
833	if (!pAp->name)
834	{
835	crWarning("no collor draw attachment");
836	return VERR_INVALID_STATE;
837	}
838
839	if (pAp->level)
840	{
841	WARN(("non-zero level not implemented"));
842	return VERR_NOT_IMPLEMENTED;
843	}
844
845	tobj = (CRTextureObj*)crHashtableSearch(ctx->shared->textureTable, pAp->name);
846	if (!tobj)
847	{
848	crWarning("no texture object found for name %d", pAp->name);
849	return VERR_INVALID_STATE;
850	}
851
852	if (tobj->target != GL_TEXTURE_2D && tobj->target != GL_TEXTURE_RECTANGLE_NV)
853	{
854	WARN(("non-texture[rect\|2d] not implemented"));
855	return VERR_NOT_IMPLEMENTED;
856	}
857
858	CRASSERT(tobj->hwid);
859
860	tl = tobj->level[0];
861	pTex->width = tl->width;
862	pTex->height = tl->height;
863	pTex->target = tobj->target;
864	pTex->hwid = tobj->hwid;
865
866	return VINF_SUCCESS;
867	}
868
869	int crServerVBoxBlitterBlitCurrentCtx(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
870	GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
871	GLbitfield mask, GLenum filter)
872	{
873	PCR_BLITTER pBlitter;
874	CR_BLITTER_CONTEXT Ctx;
875	CRMuralInfo *mural;
876	CRContext *ctx = crStateGetCurrent();
877	PVBOXVR_TEXTURE pDrawTex, pReadTex;
878	VBOXVR_TEXTURE DrawTex, ReadTex;
879	int rc;
880	GLuint idDrawFBO, idReadFBO;
881	CR_BLITTER_WINDOW BltInfo;
882
883	if (mask != GL_COLOR_BUFFER_BIT)
884	{
885	WARN(("not supported blit mask %d", mask));
886	return VERR_NOT_IMPLEMENTED;
887	}
888
889	if (!cr_server.curClient)
890	{
891	crWarning("no current client");
892	return VERR_INVALID_STATE;
893	}
894	mural = cr_server.curClient->currentMural;
895	if (!mural)
896	{
897	crWarning("no current mural");
898	return VERR_INVALID_STATE;
899	}
900
901	rc = crServerVBoxBlitterTexInit(ctx, mural, &DrawTex, GL_TRUE);
902	if (RT_SUCCESS(rc))
903	{
904	pDrawTex = &DrawTex;
905	}
906	else
907	{
908	crWarning("crServerVBoxBlitterTexInit failed for draw");
909	return rc;
910	}
911
912	rc = crServerVBoxBlitterTexInit(ctx, mural, &ReadTex, GL_FALSE);
913	if (RT_SUCCESS(rc))
914	{
915	pReadTex = &ReadTex;
916	}
917	else
918	{
919	// crWarning("crServerVBoxBlitterTexInit failed for read");
920	return rc;
921	}
922
923	pBlitter = crServerVBoxBlitterGet();
924	if (!pBlitter)
925	{
926	crWarning("crServerVBoxBlitterGet failed");
927	return VERR_GENERAL_FAILURE;
928	}
929
930	crServerVBoxBlitterWinInit(&BltInfo, mural);
931
932	crServerVBoxBlitterCtxInit(&Ctx, cr_server.curClient->currentCtxInfo);
933
934	CrBltMuralSetCurrentInfo(pBlitter, &BltInfo);
935
936	idDrawFBO = CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer);
937	idReadFBO = CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer);
938
939	crStateSwitchPrepare(NULL, ctx, idDrawFBO, idReadFBO);
940
941	rc = CrBltEnter(pBlitter);
942	if (RT_SUCCESS(rc))
943	{
944	RTRECT ReadRect, DrawRect;
945	ReadRect.xLeft = srcX0;
946	ReadRect.yTop = srcY0;
947	ReadRect.xRight = srcX1;
948	ReadRect.yBottom = srcY1;
949	DrawRect.xLeft = dstX0;
950	DrawRect.yTop = dstY0;
951	DrawRect.xRight = dstX1;
952	DrawRect.yBottom = dstY1;
953	CrBltBlitTexTex(pBlitter, pReadTex, &ReadRect, pDrawTex, &DrawRect, 1, CRBLT_FLAGS_FROM_FILTER(filter));
954	CrBltLeave(pBlitter);
955	}
956	else
957	{
958	crWarning("CrBltEnter failed rc %d", rc);
959	}
960
961	crStateSwitchPostprocess(ctx, NULL, idDrawFBO, idReadFBO);
962
963	return rc;
964	}
965
966	void SERVER_DISPATCH_APIENTRY
967	crServerDispatchBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
968	GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
969	GLbitfield mask, GLenum filter)
970	{
971	CRContext *ctx = crStateGetCurrent();
972	bool fTryBlitter = false;
973	#ifdef CR_CHECK_BLITS
974	// {
975	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
976	GLint rfb=0, dfb=0, dtex=0, dlev=-1, rtex=0, rlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
977	GLint sdtex=0, srtex=0;
978	GLenum dStatus, rStatus;
979
980	CRTextureObj *tobj = 0;
981	CRTextureLevel *tl = 0;
982	GLint id, tuId, pbufId, pbufIdHw, ubufId, ubufIdHw, width, height, depth;
983
984	crDebug("===StateTracker===");
985	crDebug("Current TU: %i", ctx->texture.curTextureUnit);
986
987	tobj = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D;
988	CRASSERT(tobj);
989	tl = &tobj->level[0][0];
990	crDebug("Texture %i(hw %i), w=%i, h=%i", tobj->id, tobj->hwid, tl->width, tl->height, tl->depth);
991
992	if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
993	{
994	pbufId = ctx->bufferobject.packBuffer->hwid;
995	}
996	else
997	{
998	pbufId = 0;
999	}
1000	crDebug("Pack BufferId %i", pbufId);
1001
1002	if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
1003	{
1004	ubufId = ctx->bufferobject.unpackBuffer->hwid;
1005	}
1006	else
1007	{
1008	ubufId = 0;
1009	}
1010	crDebug("Unpack BufferId %i", ubufId);
1011
1012	crDebug("===GPU===");
1013	cr_server.head_spu->dispatch_table.GetIntegerv(GL_ACTIVE_TEXTURE, &tuId);
1014	crDebug("Current TU: %i", tuId - GL_TEXTURE0_ARB);
1015	CRASSERT(tuId - GL_TEXTURE0_ARB == ctx->texture.curTextureUnit);
1016
1017	cr_server.head_spu->dispatch_table.GetIntegerv(GL_TEXTURE_BINDING_2D, &id);
1018	cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1019	cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
1020	cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_DEPTH, &depth);
1021	crDebug("Texture: %i, w=%i, h=%i, d=%i", id, width, height, depth);
1022	CRASSERT(id == tobj->hwid);
1023	CRASSERT(width == tl->width);
1024	CRASSERT(height == tl->height);
1025	CRASSERT(depth == tl->depth);
1026
1027	cr_server.head_spu->dispatch_table.GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &pbufIdHw);
1028	crDebug("Hw Pack BufferId %i", pbufIdHw);
1029	CRASSERT(pbufIdHw == pbufId);
1030
1031	cr_server.head_spu->dispatch_table.GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &ubufIdHw);
1032	crDebug("Hw Unpack BufferId %i", ubufIdHw);
1033	CRASSERT(ubufIdHw == ubufId);
1034
1035	gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
1036	gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
1037	gl->GetIntegerv(GL_READ_BUFFER, &rb);
1038	gl->GetIntegerv(GL_DRAW_BUFFER, &db);
1039
1040	gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
1041	gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
1042
1043	gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
1044
1045	gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
1046
1047	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
1048	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
1049	dStatus = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
1050
1051	gl->GetFramebufferAttachmentParameterivEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &rtex);
1052	gl->GetFramebufferAttachmentParameterivEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &rlev);
1053	rStatus = gl->CheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT);
1054
1055	if (dtex)
1056	{
1057	CRASSERT(!dlev);
1058	}
1059
1060	if (rtex)
1061	{
1062	CRASSERT(!rlev);
1063	}
1064
1065	if (ctx->framebufferobject.drawFB)
1066	{
1067	CRASSERT(dfb);
1068	CRASSERT(ctx->framebufferobject.drawFB->hwid == dfb);
1069	CRASSERT(ctx->framebufferobject.drawFB->drawbuffer[0] == db);
1070
1071	CRASSERT(dStatus==GL_FRAMEBUFFER_COMPLETE_EXT);
1072	CRASSERT(db==GL_COLOR_ATTACHMENT0_EXT);
1073
1074	CRASSERT(ctx->framebufferobject.drawFB->color[0].type == GL_TEXTURE);
1075	CRASSERT(ctx->framebufferobject.drawFB->color[0].level == 0);
1076	sdtex = ctx->framebufferobject.drawFB->color[0].name;
1077	sdtex = crStateGetTextureHWID(sdtex);
1078
1079	CRASSERT(sdtex);
1080	}
1081	else
1082	{
1083	CRASSERT(!dfb);
1084	}
1085
1086	if (ctx->framebufferobject.readFB)
1087	{
1088	CRASSERT(rfb);
1089	CRASSERT(ctx->framebufferobject.readFB->hwid == rfb);
1090
1091	CRASSERT(rStatus==GL_FRAMEBUFFER_COMPLETE_EXT);
1092
1093	CRASSERT(ctx->framebufferobject.readFB->color[0].type == GL_TEXTURE);
1094	CRASSERT(ctx->framebufferobject.readFB->color[0].level == 0);
1095	srtex = ctx->framebufferobject.readFB->color[0].name;
1096	srtex = crStateGetTextureHWID(srtex);
1097
1098	CRASSERT(srtex);
1099	}
1100	else
1101	{
1102	CRASSERT(!rfb);
1103	}
1104
1105	CRASSERT(sdtex == dtex);
1106	CRASSERT(srtex == rtex);
1107
1108	// crDbgDumpTexImage2D("==> src tex:", GL_TEXTURE_2D, rtex, true);
1109	// crDbgDumpTexImage2D("==> dst tex:", GL_TEXTURE_2D, dtex, true);
1110
1111	// }
1112	#endif
1113	#ifdef CR_DUMP_BLITS
1114	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
1115	GLint rfb=0, dfb=0, dtex=0, dlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
1116	GLenum status;
1117	char fname[200];
1118	void *img;
1119
1120	blitnum++;
1121
1122	crDebug("[%i]BlitFramebufferEXT(%i, %i, %i, %i, %i, %i, %i, %i, %x, %x)", blitnum, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1123	crDebug("%i, %i <-> %i, %i", srcX1-srcX0, srcY1-srcY0, dstX1-dstX0, dstY1-dstY0);
1124
1125	gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
1126	gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
1127	gl->GetIntegerv(GL_READ_BUFFER, &rb);
1128	gl->GetIntegerv(GL_DRAW_BUFFER, &db);
1129
1130	gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
1131	gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
1132
1133	gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
1134
1135	gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
1136
1137	CRASSERT(!rfb && dfb);
1138	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
1139	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
1140	status = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
1141
1142	CRASSERT(status==GL_FRAMEBUFFER_COMPLETE_EXT
1143	&& db==GL_COLOR_ATTACHMENT0_EXT
1144	&& (rb==GL_FRONT \|\| rb==GL_BACK)
1145	&& !rfb && dfb && dtex && !dlev
1146	&& !ppb && !pub);
1147
1148	crDebug("Src[rb 0x%x, fbo %i] Dst[db 0x%x, fbo %i(0x%x), tex %i.%i]", rb, rfb, db, dfb, status, dtex, dlev);
1149	crDebug("Viewport [%i, %i, %i, %i]", vp[0], vp[1], vp[2], vp[3]);
1150
1151	gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
1152	gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
1153	gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
1154	gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
1155
1156	gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
1157	gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
1158	gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
1159	gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
1160
1161	gl->BindTexture(GL_TEXTURE_2D, dtex);
1162	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_WIDTH, &dstw);
1163	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_HEIGHT, &dsth);
1164	gl->BindTexture(GL_TEXTURE_2D, otex);
1165	crDebug("Dst is %i, %i", dstw, dsth);
1166
1167	CRASSERT(vp[2]>=dstw && vp[3]>=dsth);
1168	img = crAlloc(vp[2]vp[3]4);
1169	CRASSERT(img);
1170
1171	gl->ReadPixels(0, 0, vp[2], vp[3], GL_BGRA, GL_UNSIGNED_BYTE, img);
1172	sprintf(fname, "blit%iA_src.tga", blitnum);
1173	crDumpNamedTGA(fname, vp[2], vp[3], img);
1174
1175	gl->BindTexture(GL_TEXTURE_2D, dtex);
1176	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
1177	sprintf(fname, "blit%iB_dst.tga", blitnum);
1178	crDumpNamedTGA(fname, dstw, dsth, img);
1179	gl->BindTexture(GL_TEXTURE_2D, otex);
1180	#endif
1181
1182	if (srcY0 > srcY1)
1183	{
1184	/* work around Intel driver bug on Linux host */
1185	if (1 \|\| dstY0 > dstY1)
1186	{
1187	/* use srcY1 < srcY2 && dstY1 < dstY2 whenever possible to avoid GPU driver bugs */
1188	int32_t tmp = srcY0;
1189	srcY0 = srcY1;
1190	srcY1 = tmp;
1191	tmp = dstY0;
1192	dstY0 = dstY1;
1193	dstY1 = tmp;
1194	}
1195	}
1196
1197	if (srcX0 > srcX1)
1198	{
1199	if (dstX0 > dstX1)
1200	{
1201	/* use srcX1 < srcX2 && dstX1 < dstX2 whenever possible to avoid GPU driver bugs */
1202	int32_t tmp = srcX0;
1203	srcX0 = srcX1;
1204	srcX1 = tmp;
1205	tmp = dstX0;
1206	dstX0 = dstX1;
1207	dstX1 = tmp;
1208	}
1209	}
1210
1211	if (cr_server.fBlitterMode)
1212	{
1213	fTryBlitter = true;
1214	}
1215
1216	if (fTryBlitter)
1217	{
1218	int rc = crServerVBoxBlitterBlitCurrentCtx(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1219	if (RT_SUCCESS(rc))
1220	goto my_exit;
1221	}
1222
1223	if (ctx->viewport.scissorTest)
1224	cr_server.head_spu->dispatch_table.Disable(GL_SCISSOR_TEST);
1225
1226	cr_server.head_spu->dispatch_table.BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1,
1227	dstX0, dstY0, dstX1, dstY1,
1228	mask, filter);
1229
1230	if (ctx->viewport.scissorTest)
1231	cr_server.head_spu->dispatch_table.Enable(GL_SCISSOR_TEST);
1232
1233
1234	my_exit:
1235
1236	//#ifdef CR_CHECK_BLITS
1237	// crDbgDumpTexImage2D("<== src tex:", GL_TEXTURE_2D, rtex, true);
1238	// crDbgDumpTexImage2D("<== dst tex:", GL_TEXTURE_2D, dtex, true);
1239	//#endif
1240	#ifdef CR_DUMP_BLITS
1241	gl->BindTexture(GL_TEXTURE_2D, dtex);
1242	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
1243	sprintf(fname, "blit%iC_res.tga", blitnum);
1244	crDumpNamedTGA(fname, dstw, dsth, img);
1245	gl->BindTexture(GL_TEXTURE_2D, otex);
1246	crFree(img);
1247	#endif
1248	return;
1249	}
1250
1251	void SERVER_DISPATCH_APIENTRY crServerDispatchDrawBuffer( GLenum mode )
1252	{
1253	crStateDrawBuffer( mode );
1254
1255	if (!crStateGetCurrent()->framebufferobject.drawFB)
1256	{
1257	if (mode == GL_FRONT \|\| mode == GL_FRONT_LEFT \|\| mode == GL_FRONT_RIGHT)
1258	cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
1259
1260	if (crServerIsRedirectedToFBO()
1261	&& cr_server.curClient->currentMural->aidFBOs[0])
1262	{
1263	CRMuralInfo *mural = cr_server.curClient->currentMural;
1264	GLint iBufferNeeded = -1;
1265	switch (mode)
1266	{
1267	case GL_BACK:
1268	case GL_BACK_LEFT:
1269	case GL_BACK_RIGHT:
1270	mode = GL_COLOR_ATTACHMENT0;
1271	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1272	break;
1273	case GL_FRONT:
1274	case GL_FRONT_LEFT:
1275	case GL_FRONT_RIGHT:
1276	mode = GL_COLOR_ATTACHMENT0;
1277	iBufferNeeded = CR_SERVER_FBO_FB_IDX(mural);
1278	break;
1279	case GL_NONE:
1280	crDebug("DrawBuffer: GL_NONE");
1281	break;
1282	case GL_AUX0:
1283	crDebug("DrawBuffer: GL_AUX0");
1284	break;
1285	case GL_AUX1:
1286	crDebug("DrawBuffer: GL_AUX1");
1287	break;
1288	case GL_AUX2:
1289	crDebug("DrawBuffer: GL_AUX2");
1290	break;
1291	case GL_AUX3:
1292	crDebug("DrawBuffer: GL_AUX3");
1293	break;
1294	case GL_LEFT:
1295	crWarning("DrawBuffer: GL_LEFT not supported properly");
1296	mode = GL_COLOR_ATTACHMENT0;
1297	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1298	break;
1299	case GL_RIGHT:
1300	crWarning("DrawBuffer: GL_RIGHT not supported properly");
1301	mode = GL_COLOR_ATTACHMENT0;
1302	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1303	break;
1304	case GL_FRONT_AND_BACK:
1305	crWarning("DrawBuffer: GL_FRONT_AND_BACK not supported properly");
1306	mode = GL_COLOR_ATTACHMENT0;
1307	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1308	break;
1309	default:
1310	crWarning("DrawBuffer: unexpected mode! 0x%x", mode);
1311	iBufferNeeded = mural->iCurDrawBuffer;
1312	break;
1313	}
1314
1315	if (iBufferNeeded != mural->iCurDrawBuffer)
1316	{
1317	mural->iCurDrawBuffer = iBufferNeeded;
1318	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, iBufferNeeded));
1319	}
1320	}
1321	}
1322
1323	cr_server.head_spu->dispatch_table.DrawBuffer( mode );
1324	}
1325
1326	void SERVER_DISPATCH_APIENTRY crServerDispatchReadBuffer( GLenum mode )
1327	{
1328	crStateReadBuffer( mode );
1329
1330	if (crServerIsRedirectedToFBO()
1331	&& cr_server.curClient->currentMural->aidFBOs[0]
1332	&& !crStateGetCurrent()->framebufferobject.readFB)
1333	{
1334	CRMuralInfo *mural = cr_server.curClient->currentMural;
1335	GLint iBufferNeeded = -1;
1336	switch (mode)
1337	{
1338	case GL_BACK:
1339	case GL_BACK_LEFT:
1340	case GL_BACK_RIGHT:
1341	mode = GL_COLOR_ATTACHMENT0;
1342	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1343	break;
1344	case GL_FRONT:
1345	case GL_FRONT_LEFT:
1346	case GL_FRONT_RIGHT:
1347	mode = GL_COLOR_ATTACHMENT0;
1348	iBufferNeeded = CR_SERVER_FBO_FB_IDX(mural);
1349	break;
1350	case GL_NONE:
1351	crDebug("ReadBuffer: GL_NONE");
1352	break;
1353	case GL_AUX0:
1354	crDebug("ReadBuffer: GL_AUX0");
1355	break;
1356	case GL_AUX1:
1357	crDebug("ReadBuffer: GL_AUX1");
1358	break;
1359	case GL_AUX2:
1360	crDebug("ReadBuffer: GL_AUX2");
1361	break;
1362	case GL_AUX3:
1363	crDebug("ReadBuffer: GL_AUX3");
1364	break;
1365	case GL_LEFT:
1366	crWarning("ReadBuffer: GL_LEFT not supported properly");
1367	mode = GL_COLOR_ATTACHMENT0;
1368	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1369	break;
1370	case GL_RIGHT:
1371	crWarning("ReadBuffer: GL_RIGHT not supported properly");
1372	mode = GL_COLOR_ATTACHMENT0;
1373	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1374	break;
1375	case GL_FRONT_AND_BACK:
1376	crWarning("ReadBuffer: GL_FRONT_AND_BACK not supported properly");
1377	mode = GL_COLOR_ATTACHMENT0;
1378	iBufferNeeded = CR_SERVER_FBO_BB_IDX(mural);
1379	break;
1380	default:
1381	crWarning("ReadBuffer: unexpected mode! 0x%x", mode);
1382	iBufferNeeded = mural->iCurDrawBuffer;
1383	break;
1384	}
1385
1386	Assert(CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
1387	if (iBufferNeeded != mural->iCurReadBuffer)
1388	{
1389	mural->iCurReadBuffer = iBufferNeeded;
1390	cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, iBufferNeeded));
1391	}
1392	}
1393	cr_server.head_spu->dispatch_table.ReadBuffer( mode );
1394	}
1395
1396	GLenum SERVER_DISPATCH_APIENTRY crServerDispatchGetError( void )
1397	{
1398	GLenum retval, err;
1399	CRContext *ctx = crStateGetCurrent();
1400	retval = ctx->error;
1401
1402	err = cr_server.head_spu->dispatch_table.GetError();
1403	if (retval == GL_NO_ERROR)
1404	retval = err;
1405	else
1406	ctx->error = GL_NO_ERROR;
1407
1408	/* our impl has a single error flag, so we just loop here to reset all error flags to no_error */
1409	while (err != GL_NO_ERROR)
1410	err = cr_server.head_spu->dispatch_table.GetError();
1411
1412	crServerReturnValue( &retval, sizeof(retval) );
1413	return retval; /* WILL PROBABLY BE IGNORED */
1414	}
1415
1416	void SERVER_DISPATCH_APIENTRY
1417	crServerMakeTmpCtxCurrent( GLint window, GLint nativeWindow, GLint context )
1418	{
1419	CRContext *pCtx = crStateGetCurrent();
1420	CRContext *pCurCtx = NULL;
1421	GLuint idDrawFBO = 0, idReadFBO = 0;
1422	int fDoPrePostProcess = 0;
1423
1424	if (pCtx)
1425	{
1426	CRMuralInfo *pCurrentMural = cr_server.currentMural;
1427
1428	pCurCtx = cr_server.currentCtxInfo ? cr_server.currentCtxInfo->pContext : cr_server.MainContextInfo.pContext;
1429	Assert(pCurCtx == pCtx);
1430
1431	if (!context)
1432	{
1433	if (pCurrentMural)
1434	{
1435	Assert(cr_server.currentCtxInfo);
1436	context = cr_server.currentCtxInfo->SpuContext > 0 ? cr_server.currentCtxInfo->SpuContext : cr_server.MainContextInfo.SpuContext;
1437	window = pCurrentMural->spuWindow;
1438	}
1439	else
1440	{
1441	CRMuralInfo * pDummy;
1442	Assert(!cr_server.currentCtxInfo);
1443	pDummy = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
1444	context = cr_server.MainContextInfo.SpuContext;
1445	window = pDummy->spuWindow;
1446	}
1447
1448
1449	fDoPrePostProcess = -1;
1450	}
1451	else
1452	{
1453	fDoPrePostProcess = 1;
1454	}
1455
1456	if (pCurrentMural)
1457	{
1458	idDrawFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurDrawBuffer);
1459	idReadFBO = CR_SERVER_FBO_FOR_IDX(pCurrentMural, pCurrentMural->iCurReadBuffer);
1460	}
1461	else
1462	{
1463	idDrawFBO = 0;
1464	idReadFBO = 0;
1465	}
1466	}
1467	else
1468	{
1469	/* this is a GUI thread, so no need to do anything here */
1470	}
1471
1472	if (fDoPrePostProcess > 0)
1473	crStateSwitchPrepare(NULL, pCurCtx, idDrawFBO, idReadFBO);
1474
1475	cr_server.head_spu->dispatch_table.MakeCurrent( window, nativeWindow, context);
1476
1477	if (fDoPrePostProcess < 0)
1478	crStateSwitchPostprocess(pCurCtx, NULL, idDrawFBO, idReadFBO);
1479	}
1480
1481	void crServerInitTmpCtxDispatch()
1482	{
1483	MakeCurrentFunc_t pfnMakeCurrent;
1484
1485	crSPUInitDispatchTable(&cr_server.TmpCtxDispatch);
1486	crSPUCopyDispatchTable(&cr_server.TmpCtxDispatch, &cr_server.head_spu->dispatch_table);
1487	cr_server.TmpCtxDispatch.MakeCurrent = crServerMakeTmpCtxCurrent;
1488
1489	pfnMakeCurrent = crServerMakeTmpCtxCurrent;
1490	cr_server.head_spu->dispatch_table.ChromiumParametervCR(GL_HH_SET_TMPCTX_MAKE_CURRENT, GL_BYTE, sizeof (void*), &pfnMakeCurrent);
1491
1492	}
1493
1494	/* dump stuff */
1495	#ifdef VBOX_WITH_CRSERVER_DUMPER
1496
1497	# ifndef VBOX_WITH_CRDUMPER
1498	# error "VBOX_WITH_CRDUMPER undefined!"
1499	# endif
1500
1501	/* first four bits are buffer dump config
1502	* second four bits are texture dump config
1503	* config flags:
1504	* 1 - blit on enter
1505	* 2 - blit on exit
1506	*
1507	*
1508	* Example:
1509	*
1510	* 0x03 - dump buffer on enter and exit
1511	* 0x22 - dump texture and buffer on exit */
1512
1513	int64_t g_CrDbgDumpPid = 0;
1514	unsigned long g_CrDbgDumpEnabled = 0;
1515	unsigned long g_CrDbgDumpDraw = 0
1516	#if 0
1517	\| CR_SERVER_DUMP_F_COMPILE_SHADER
1518	\| CR_SERVER_DUMP_F_LINK_PROGRAM
1519	#endif
1520	;
1521	#if 0
1522	\| CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
1523	\| CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
1524	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER
1525	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER
1526	\| CR_SERVER_DUMP_F_DRAW_TEX_ENTER
1527	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER
1528	\| CR_SERVER_DUMP_F_DRAW_STATE_ENTER
1529	\| CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER
1530	\| CR_SERVER_DUMP_F_DRAWEL
1531	\| CR_SERVER_DUMP_F_SHADER_SOURCE
1532	;
1533	#endif
1534	unsigned long g_CrDbgDumpDrawFramesSettings = CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
1535	\| CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
1536	\| CR_SERVER_DUMP_F_DRAW_TEX_ENTER
1537	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER
1538	\| CR_SERVER_DUMP_F_COMPILE_SHADER
1539	\| CR_SERVER_DUMP_F_LINK_PROGRAM
1540	\| CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER;
1541	unsigned long g_CrDbgDumpDrawFramesAppliedSettings = 0;
1542	unsigned long g_CrDbgDumpDrawFramesSavedInitSettings = 0;
1543	unsigned long g_CrDbgDumpDrawFramesCount = 0;
1544
1545	uint32_t g_CrDbgDumpDrawCount = 0;
1546	uint32_t g_CrDbgDumpDumpOnCount = 10;
1547	uint32_t g_CrDbgDumpDumpOnCountEnabled = 0;
1548	uint32_t g_CrDbgDumpDumpOnCountPerform = 0;
1549	uint32_t g_CrDbgDumpDrawFlags = CR_SERVER_DUMP_F_COMPILE_SHADER
1550	\| CR_SERVER_DUMP_F_SHADER_SOURCE
1551	\| CR_SERVER_DUMP_F_COMPILE_SHADER
1552	\| CR_SERVER_DUMP_F_LINK_PROGRAM
1553	\| CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
1554	\| CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
1555	\| CR_SERVER_DUMP_F_DRAW_TEX_ENTER
1556	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER
1557	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER
1558	\| CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER
1559	\| CR_SERVER_DUMP_F_DRAW_STATE_ENTER
1560	\| CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER
1561	\| CR_SERVER_DUMP_F_DRAWEL
1562	\| CR_SERVER_DUMP_F_TEXPRESENT;
1563
1564	void crServerDumpCheckTerm()
1565	{
1566	if (!CrBltIsInitialized(&cr_server.RecorderBlitter))
1567	return;
1568
1569	CrBltTerm(&cr_server.RecorderBlitter);
1570	}
1571
1572	int crServerDumpCheckInit()
1573	{
1574	int rc;
1575	CR_BLITTER_WINDOW BltWin;
1576	CR_BLITTER_CONTEXT BltCtx;
1577	CRMuralInfo *pBlitterMural;
1578
1579	if (!CrBltIsInitialized(&cr_server.RecorderBlitter))
1580	{
1581	pBlitterMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
1582	if (!pBlitterMural)
1583	{
1584	crWarning("crServerGetDummyMural failed");
1585	return VERR_GENERAL_FAILURE;
1586	}
1587
1588	crServerVBoxBlitterWinInit(&BltWin, pBlitterMural);
1589	crServerVBoxBlitterCtxInit(&BltCtx, &cr_server.MainContextInfo);
1590
1591	rc = CrBltInit(&cr_server.RecorderBlitter, &BltCtx, true, true, NULL, &cr_server.TmpCtxDispatch);
1592	if (!RT_SUCCESS(rc))
1593	{
1594	crWarning("CrBltInit failed rc %d", rc);
1595	return rc;
1596	}
1597
1598	rc = CrBltMuralSetCurrentInfo(&cr_server.RecorderBlitter, &BltWin);
1599	if (!RT_SUCCESS(rc))
1600	{
1601	crWarning("CrBltMuralSetCurrentInfo failed rc %d", rc);
1602	return rc;
1603	}
1604	}
1605
1606	#if 0
1607	crDmpDbgPrintInit(&cr_server.DbgPrintDumper);
1608	cr_server.pDumper = &cr_server.DbgPrintDumper.Base;
1609	#else
1610	if (!crDmpHtmlIsInited(&cr_server.HtmlDumper))
1611	{
1612	static int cCounter = 0;
1613	// crDmpHtmlInit(&cr_server.HtmlDumper, "S:\\projects\\virtualbox\\3d\\dumps\\1", "index.html");
1614	crDmpHtmlInitF(&cr_server.HtmlDumper, "/Users/oracle-mac/vbox/dump/1", "index%d.html", cCounter);
1615	cr_server.pDumper = &cr_server.HtmlDumper.Base;
1616	++cCounter;
1617	}
1618	#endif
1619
1620	crRecInit(&cr_server.Recorder, &cr_server.RecorderBlitter, &cr_server.TmpCtxDispatch, cr_server.pDumper);
1621	return VINF_SUCCESS;
1622	}
1623
1624	void crServerDumpShader(GLint id)
1625	{
1626	CRContext *ctx = crStateGetCurrent();
1627	crRecDumpShader(&cr_server.Recorder, ctx, id, 0);
1628	}
1629
1630	void crServerDumpProgram(GLint id)
1631	{
1632	CRContext *ctx = crStateGetCurrent();
1633	crRecDumpProgram(&cr_server.Recorder, ctx, id, 0);
1634	}
1635
1636	void crServerDumpCurrentProgram()
1637	{
1638	CRContext *ctx = crStateGetCurrent();
1639	crRecDumpCurrentProgram(&cr_server.Recorder, ctx);
1640	}
1641
1642	void crServerDumpRecompileDumpCurrentProgram()
1643	{
1644	crDmpStrF(cr_server.Recorder.pDumper, "==Dump(1)==");
1645	crServerRecompileCurrentProgram();
1646	crServerDumpCurrentProgramUniforms();
1647	crServerDumpCurrentProgramAttribs();
1648	crDmpStrF(cr_server.Recorder.pDumper, "Done Dump(1)");
1649	crServerRecompileCurrentProgram();
1650	crDmpStrF(cr_server.Recorder.pDumper, "Dump(2)");
1651	crServerRecompileCurrentProgram();
1652	crServerDumpCurrentProgramUniforms();
1653	crServerDumpCurrentProgramAttribs();
1654	crDmpStrF(cr_server.Recorder.pDumper, "Done Dump(2)");
1655	}
1656
1657	void crServerRecompileCurrentProgram()
1658	{
1659	CRContext *ctx = crStateGetCurrent();
1660	crRecRecompileCurrentProgram(&cr_server.Recorder, ctx);
1661	}
1662
1663	void crServerDumpCurrentProgramUniforms()
1664	{
1665	CRContext *ctx = crStateGetCurrent();
1666	crDmpStrF(cr_server.Recorder.pDumper, "==Uniforms==");
1667	crRecDumpCurrentProgramUniforms(&cr_server.Recorder, ctx);
1668	crDmpStrF(cr_server.Recorder.pDumper, "==Done Uniforms==");
1669	}
1670
1671	void crServerDumpCurrentProgramAttribs()
1672	{
1673	CRContext *ctx = crStateGetCurrent();
1674	crDmpStrF(cr_server.Recorder.pDumper, "==Attribs==");
1675	crRecDumpCurrentProgramAttribs(&cr_server.Recorder, ctx);
1676	crDmpStrF(cr_server.Recorder.pDumper, "==Done Attribs==");
1677	}
1678
1679	void crServerDumpState()
1680	{
1681	CRContext *ctx = crStateGetCurrent();
1682	crRecDumpGlGetState(&cr_server.Recorder, ctx);
1683	crRecDumpGlEnableState(&cr_server.Recorder, ctx);
1684	}
1685
1686	void crServerDumpDrawel(const char*pszFormat, ...)
1687	{
1688	CRContext *ctx = crStateGetCurrent();
1689	va_list pArgList;
1690	va_start(pArgList, pszFormat);
1691	crRecDumpVertAttrV(&cr_server.Recorder, ctx, pszFormat, pArgList);
1692	va_end(pArgList);
1693	}
1694
1695	void crServerDumpDrawelv(GLuint idx, const charpszElFormat, uint32_t cbEl, const void pvVal, uint32_t cVal)
1696	{
1697	CRContext *ctx = crStateGetCurrent();
1698	crRecDumpVertAttrv(&cr_server.Recorder, ctx, idx, pszElFormat, cbEl, pvVal, cVal);
1699	}
1700
1701	void crServerDumpBuffer(int idx)
1702	{
1703	CRContextInfo *pCtxInfo = cr_server.currentCtxInfo;
1704	CRContext *ctx = crStateGetCurrent();
1705	GLint idFBO;
1706	GLint idTex;
1707	VBOXVR_TEXTURE RedirTex;
1708	int rc = crServerDumpCheckInit();
1709	idx = idx >= 0 ? idx : crServerMuralFBOIdxFromBufferName(cr_server.currentMural, pCtxInfo->pContext->buffer.drawBuffer);
1710	if (!RT_SUCCESS(rc))
1711	{
1712	crWarning("crServerDumpCheckInit failed, rc %d", rc);
1713	return;
1714	}
1715
1716	if (idx < 0)
1717	{
1718	crWarning("neg idx, unsupported");
1719	return;
1720	}
1721
1722	idFBO = CR_SERVER_FBO_FOR_IDX(cr_server.currentMural, idx);
1723	idTex = CR_SERVER_FBO_TEX_FOR_IDX(cr_server.currentMural, idx);
1724
1725	RedirTex.width = cr_server.currentMural->fboWidth;
1726	RedirTex.height = cr_server.currentMural->fboHeight;
1727	RedirTex.target = GL_TEXTURE_2D;
1728	RedirTex.hwid = idTex;
1729
1730	crRecDumpBuffer(&cr_server.Recorder, ctx, idFBO, idTex ? &RedirTex : NULL);
1731	}
1732
1733	void crServerDumpTexture(const VBOXVR_TEXTURE *pTex)
1734	{
1735	CRContextInfo *pCtxInfo = cr_server.currentCtxInfo;
1736	CR_BLITTER_WINDOW BltWin;
1737	CR_BLITTER_CONTEXT BltCtx;
1738	CRContext *ctx = crStateGetCurrent();
1739	int rc = crServerDumpCheckInit();
1740	if (!RT_SUCCESS(rc))
1741	{
1742	crWarning("crServerDumpCheckInit failed, rc %d", rc);
1743	return;
1744	}
1745
1746	crServerVBoxBlitterWinInit(&BltWin, cr_server.currentMural);
1747	crServerVBoxBlitterCtxInit(&BltCtx, pCtxInfo);
1748
1749	crRecDumpTextureF(&cr_server.Recorder, pTex, &BltCtx, &BltWin, "Tex (%d x %d), hwid (%d) target %#x", pTex->width, pTex->height, pTex->hwid, pTex->target);
1750	}
1751
1752	void crServerDumpTextures()
1753	{
1754	CRContextInfo *pCtxInfo = cr_server.currentCtxInfo;
1755	CRContext *ctx = crStateGetCurrent();
1756	int rc = crServerDumpCheckInit();
1757	if (!RT_SUCCESS(rc))
1758	{
1759	crWarning("crServerDumpCheckInit failed, rc %d", rc);
1760	return;
1761	}
1762
1763	crRecDumpTextures(&cr_server.Recorder, ctx);
1764	}
1765
1766	void crServerDumpFilterOpLeave(unsigned long event, CR_DUMPER *pDumper)
1767	{
1768	if (CR_SERVER_DUMP_F_DRAW_LEAVE_ALL & event)
1769	{
1770	g_CrDbgDumpDumpOnCountPerform = 0;
1771	}
1772	}
1773
1774	bool crServerDumpFilterOpEnter(unsigned long event, CR_DUMPER *pDumper)
1775	{
1776	if ((CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER & event)
1777	\|\| (CR_SERVER_DUMP_F_TEXPRESENT & event))
1778	{
1779	if (g_CrDbgDumpDumpOnCountEnabled == 1)
1780	g_CrDbgDumpDumpOnCountEnabled = 2;
1781	else if (g_CrDbgDumpDumpOnCountEnabled)
1782	{
1783	g_CrDbgDumpDumpOnCountEnabled = 0;
1784	if (cr_server.pDumper == &cr_server.HtmlDumper.Base)
1785	{
1786	crDmpHtmlTerm(&cr_server.HtmlDumper);
1787	cr_server.pDumper = NULL;
1788	}
1789	}
1790
1791	g_CrDbgDumpDrawCount = 0;
1792	}
1793	else if (CR_SERVER_DUMP_F_DRAW_ENTER_ALL & event)
1794	{
1795	if (g_CrDbgDumpDumpOnCountEnabled == 2)
1796	{
1797	if (g_CrDbgDumpDumpOnCount == g_CrDbgDumpDrawCount)
1798	{
1799	g_CrDbgDumpDumpOnCountPerform = 1;
1800	}
1801	++g_CrDbgDumpDrawCount;
1802	}
1803	}
1804	if (g_CrDbgDumpDumpOnCountPerform)
1805	{
1806	if (g_CrDbgDumpDrawFlags & event)
1807	return true;
1808	}
1809	return CR_SERVER_DUMP_DEFAULT_FILTER_OP(event);
1810	}
1811
1812	bool crServerDumpFilterDmp(unsigned long event, CR_DUMPER *pDumper)
1813	{
1814	if (g_CrDbgDumpDumpOnCountPerform)
1815	{
1816	if (g_CrDbgDumpDrawFlags & event)
1817	return true;
1818	}
1819	return CR_SERVER_DUMP_DEFAULT_FILTER_DMP(event);
1820	}
1821
1822	void crServerDumpFramesCheck()
1823	{
1824	if (!g_CrDbgDumpDrawFramesCount)
1825	return;
1826
1827	if (!g_CrDbgDumpDrawFramesAppliedSettings)
1828	{
1829	if (!g_CrDbgDumpDrawFramesSettings)
1830	{
1831	crWarning("g_CrDbgDumpDrawFramesSettings is NULL, bump will not be started");
1832	g_CrDbgDumpDrawFramesCount = 0;
1833	return;
1834	}
1835
1836	g_CrDbgDumpDrawFramesSavedInitSettings = g_CrDbgDumpDraw;
1837	g_CrDbgDumpDrawFramesAppliedSettings = g_CrDbgDumpDrawFramesSettings;
1838	g_CrDbgDumpDraw = g_CrDbgDumpDrawFramesSettings;
1839	crDmpStrF(cr_server.Recorder.pDumper, "***Starting draw dump for %d frames, settings(0x%x)", g_CrDbgDumpDrawFramesCount, g_CrDbgDumpDraw);
1840	return;
1841	}
1842
1843	--g_CrDbgDumpDrawFramesCount;
1844
1845	if (!g_CrDbgDumpDrawFramesCount)
1846	{
1847	crDmpStrF(cr_server.Recorder.pDumper, "***Stop draw dump");
1848	g_CrDbgDumpDraw = g_CrDbgDumpDrawFramesSavedInitSettings;
1849	g_CrDbgDumpDrawFramesAppliedSettings = 0;
1850	}
1851	}
1852	#endif
1853
1854	GLvoid crServerSpriteCoordReplEnable(GLboolean fEnable)
1855	{
1856	CRContext *g = crStateGetCurrent();
1857	CRTextureState *t = &(g->texture);
1858	GLuint curTextureUnit = t->curTextureUnit;
1859	GLuint curTextureUnitRestore = curTextureUnit;
1860	GLuint i;
1861
1862	for (i = 0; i < g->limits.maxTextureUnits; ++i)
1863	{
1864	if (g->point.coordReplacement[i])
1865	{
1866	if (i != curTextureUnit)
1867	{
1868	curTextureUnit = i;
1869	cr_server.head_spu->dispatch_table.ActiveTextureARB( i + GL_TEXTURE0_ARB );
1870	}
1871
1872	cr_server.head_spu->dispatch_table.TexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, (GLint)fEnable);
1873	}
1874	}
1875
1876	if (curTextureUnit != curTextureUnitRestore)
1877	{
1878	cr_server.head_spu->dispatch_table.ActiveTextureARB( curTextureUnitRestore + GL_TEXTURE0_ARB );
1879	}
1880	}
1881
1882	GLvoid SERVER_DISPATCH_APIENTRY crServerDispatchDrawArrays(GLenum mode, GLint first, GLsizei count)
1883	{
1884	#ifdef DEBUG
1885	GLenum status = cr_server.head_spu->dispatch_table.CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
1886	Assert(GL_FRAMEBUFFER_COMPLETE == status);
1887	#endif
1888	if (mode == GL_POINTS)
1889	crServerSpriteCoordReplEnable(GL_TRUE);
1890	CR_SERVER_DUMP_DRAW_ENTER();
1891	CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.DrawArrays(mode, first, count););
1892	CR_SERVER_DUMP_DRAW_LEAVE();
1893	if (mode == GL_POINTS)
1894	crServerSpriteCoordReplEnable(GL_FALSE);
1895	}
1896
1897	GLvoid SERVER_DISPATCH_APIENTRY crServerDispatchDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
1898	{
1899	#ifdef DEBUG
1900	GLenum status = cr_server.head_spu->dispatch_table.CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
1901	Assert(GL_FRAMEBUFFER_COMPLETE == status);
1902	#endif
1903	if (mode == GL_POINTS)
1904	crServerSpriteCoordReplEnable(GL_TRUE);
1905	CR_SERVER_DUMP_DRAW_ENTER();
1906	CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.DrawElements(mode, count, type, indices););
1907	CR_SERVER_DUMP_DRAW_LEAVE();
1908	if (mode == GL_POINTS)
1909	crServerSpriteCoordReplEnable(GL_FALSE);
1910	}
1911
1912	void SERVER_DISPATCH_APIENTRY crServerDispatchEnd( void )
1913	{
1914	CRContext *g = crStateGetCurrent();
1915	GLenum mode = g->current.mode;
1916
1917	crStateEnd();
1918	cr_server.head_spu->dispatch_table.End();
1919
1920	CR_SERVER_DUMP_DRAW_LEAVE();
1921
1922	if (mode == GL_POINTS)
1923	crServerSpriteCoordReplEnable(GL_FALSE);
1924	}
1925
1926	void SERVER_DISPATCH_APIENTRY crServerDispatchBegin(GLenum mode)
1927	{
1928	#ifdef DEBUG
1929	CRContext *ctx = crStateGetCurrent();
1930	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
1931
1932	if (ctx->program.vpProgramBinding)
1933	{
1934	AssertRelease(ctx->program.currentVertexProgram);
1935
1936	if (ctx->program.currentVertexProgram->isARBprogram)
1937	{
1938	GLint pid=-1;
1939	gl->GetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_BINDING_ARB, &pid);
1940
1941	if (pid != ctx->program.currentVertexProgram->id)
1942	{
1943	crWarning("pid(%d) != ctx->program.currentVertexProgram->id(%d)", pid, ctx->program.currentVertexProgram->id);
1944	}
1945	AssertRelease(pid == ctx->program.currentVertexProgram->id);
1946	}
1947	else
1948	{
1949	GLint pid=-1;
1950
1951	gl->GetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &pid);
1952	if (pid != ctx->program.currentVertexProgram->id)
1953	{
1954	crWarning("pid(%d) != ctx->program.currentVertexProgram->id(%d)", pid, ctx->program.currentVertexProgram->id);
1955	}
1956	AssertRelease(pid == ctx->program.currentVertexProgram->id);
1957	}
1958	}
1959	else if (ctx->glsl.activeProgram)
1960	{
1961	GLint pid=-1;
1962
1963	gl->GetIntegerv(GL_CURRENT_PROGRAM, &pid);
1964	crDebug("pid %i, state: id %i, hwid %i", pid, ctx->glsl.activeProgram->id, ctx->glsl.activeProgram->hwid);
1965	if (pid != ctx->glsl.activeProgram->hwid)
1966	{
1967	crWarning("pid(%d) != ctx->glsl.activeProgram->hwid(%d)", pid, ctx->glsl.activeProgram->hwid);
1968	}
1969	AssertRelease(pid == ctx->glsl.activeProgram->hwid);
1970	}
1971	#endif
1972
1973	if (mode == GL_POINTS)
1974	crServerSpriteCoordReplEnable(GL_TRUE);
1975
1976	CR_SERVER_DUMP_DRAW_ENTER();
1977
1978	crStateBegin(mode);
1979	cr_server.head_spu->dispatch_table.Begin(mode);
1980	}
1981

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

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c@ 52350

Download in other formats: