server_config.c@ 45442

Last change on this file since 45442 was 45348, checked in by vboxsync, 12 years ago
crOpenGL: improved GPU data acwuisition mechanism for VRDP (disabled still)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 13.3 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 <string.h>
8	#include "cr_mem.h"
9	#include "cr_environment.h"
10	#include "cr_string.h"
11	#include "cr_error.h"
12	#include "cr_glstate.h"
13	#include "server.h"
14
15	#ifdef WINDOWS
16	#pragma warning( disable: 4706 )
17	#endif
18
19	static void
20	setDefaults(void)
21	{
22	if (!cr_server.tcpip_port)
23	cr_server.tcpip_port = DEFAULT_SERVER_PORT;
24	cr_server.run_queue = NULL;
25	cr_server.optimizeBucket = 1;
26	cr_server.useL2 = 0;
27	cr_server.maxBarrierCount = 0;
28	cr_server.ignore_papi = 0;
29	cr_server.only_swap_once = 0;
30	cr_server.overlapBlending = 0;
31	cr_server.debug_barriers = 0;
32	cr_server.sharedDisplayLists = 0;
33	cr_server.sharedTextureObjects = 0;
34	cr_server.sharedPrograms = 0;
35	cr_server.sharedWindows = 0;
36	cr_server.useDMX = 0;
37	cr_server.vpProjectionMatrixParameter = -1;
38	cr_server.vpProjectionMatrixVariable = NULL;
39	cr_server.currentProgram = 0;
40
41	cr_server.num_overlap_intens = 0;
42	cr_server.overlap_intens = 0;
43	crMemset(&cr_server.MainContextInfo, 0, sizeof (cr_server.MainContextInfo));
44
45	crMatrixInit(&cr_server.viewMatrix[0]);
46	crMatrixInit(&cr_server.viewMatrix[1]);
47	crMatrixInit(&cr_server.projectionMatrix[0]);
48	crMatrixInit(&cr_server.projectionMatrix[1]);
49	cr_server.currentEye = -1;
50
51	cr_server.uniqueWindows = 0;
52
53	cr_server.screenCount = 0;
54	cr_server.fPresentMode = CR_SERVER_REDIR_F_NONE;
55	cr_server.fPresentModeDefault = cr_server.fPresentMode;
56	cr_server.fVramPresentModeDefault = CR_SERVER_REDIR_F_FBO_RAM;
57	cr_server.bUsePBOForReadback = GL_FALSE;
58	cr_server.bUseOutputRedirect = GL_FALSE;
59	}
60
61	static int crServerVBoxParseNumerics(const char *pszStr, const int defaultVal)
62	{
63	int result = 0;
64	bool neg = false;
65	unsigned char iDigit = 0;
66	if (!pszStr \|\| pszStr[0] == '\0')
67	return defaultVal;
68
69	for (;;)
70	{
71	if (pszStr[0] == '\0')
72	return defaultVal;
73
74	if (pszStr[0] == ' ' \|\| pszStr[0] == '\t' \|\| pszStr[0] == '\n')
75	{
76	++pszStr;
77	continue;
78	}
79
80	if (pszStr[0] == '-')
81	{
82	if (neg)
83	return defaultVal;
84
85	neg = true;
86	++pszStr;
87	continue;
88	}
89
90	break;
91	}
92
93	for (;;)
94	{
95	unsigned char digit;
96	if (pszStr[0] == '\0')
97	{
98	if (!iDigit)
99	return defaultVal;
100	break;
101	}
102
103	digit = pszStr[0] - '0';
104	if (digit > 9)
105	return defaultVal;
106
107	result *= 10;
108	result += digit;
109	++iDigit;
110
111	++pszStr;
112	}
113
114	return !neg ? result : -result;
115	}
116
117	void crServerSetVBoxConfiguration()
118	{
119	CRMuralInfo *defaultMural;
120	char response[8096];
121
122	char **spuchain;
123	int num_spus;
124	int *spu_ids;
125	char **spu_names;
126	char *spu_dir = NULL;
127	int i;
128	/* Quadrics defaults */
129	int my_rank = 0;
130	int low_context = CR_QUADRICS_DEFAULT_LOW_CONTEXT;
131	int high_context = CR_QUADRICS_DEFAULT_HIGH_CONTEXT;
132	unsigned char key[16]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
133	char hostname[1024];
134	char clientchain, clientlist;
135	GLint dims[4];
136	const char * env;
137
138	defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
139	CRASSERT(defaultMural);
140
141	setDefaults();
142
143	/*
144	* Get my hostname
145	*/
146	if (crGetHostname(hostname, sizeof(hostname)))
147	{
148	crError("CRServer: Couldn't get my own hostname?");
149	}
150
151	strcpy(response, "1 0 render");
152	crDebug("CRServer: my SPU chain: %s", response);
153
154	/* response will describe the SPU chain.
155	* Example "2 5 wet 6 render"
156	*/
157	spuchain = crStrSplit(response, " ");
158	num_spus = crStrToInt(spuchain[0]);
159	spu_ids = (int ) crAlloc(num_spus sizeof(*spu_ids));
160	spu_names = (char *) crAlloc((num_spus + 1) sizeof(*spu_names));
161	for (i = 0; i < num_spus; i++)
162	{
163	spu_ids[i] = crStrToInt(spuchain[2 * i + 1]);
164	spu_names[i] = crStrdup(spuchain[2 * i + 2]);
165	crDebug("SPU %d/%d: (%d) \"%s\"", i + 1, num_spus, spu_ids[i],
166	spu_names[i]);
167	}
168	spu_names[i] = NULL;
169
170	//spu_dir = crStrdup(response);
171	crNetSetRank(0);
172	crNetSetContextRange(32, 35);
173	crNetSetNodeRange("iam0", "iamvis20");
174	crNetSetKey(key,sizeof(key));
175	crNetSetKey(key,sizeof(key));
176	cr_server.tcpip_port = 7000;
177
178	/*cr_server.optimizeBucket = crStrToInt(response);
179	cr_server.localTileSpec = crStrToInt(response);
180	cr_server.useL2 = crStrToInt(response);
181	cr_server.ignore_papi = crStrToInt(response);
182	if (crMothershipGetServerParam(conn, response, "overlap_blending"))
183	{
184	if (!crStrcmp(response, "blend"))
185	cr_server.overlapBlending = 1;
186	else if (!crStrcmp(response, "knockout"))
187	cr_server.overlapBlending = 2;
188	}
189	if (crMothershipGetServerParam(conn, response, "overlap_levels"))
190	cr_server.only_swap_once = crStrToInt(response);
191	cr_server.debug_barriers = crStrToInt(response);
192	cr_server.sharedDisplayLists = crStrToInt(response);
193	cr_server.sharedTextureObjects = crStrToInt(response);
194	cr_server.sharedPrograms = crStrToInt(response);
195	cr_server.sharedWindows = crStrToInt(response);
196	cr_server.uniqueWindows = crStrToInt(response);
197	cr_server.useDMX = crStrToInt(response);
198	if (crMothershipGetServerParam(conn, response, "vertprog_projection_param"))
199	if (crMothershipGetServerParam(conn, response, "stereo_view"))
200	if (crMothershipGetServerParam(conn, response, "view_matrix"))
201	if (crMothershipGetServerParam(conn, response, "right_view_matrix"))
202	if (crMothershipGetServerParam(conn, response, "projection_matrix"))
203	if (crMothershipGetServerParam(conn, response, "right_projection_matrix"))*/
204
205	crDebug("CRServer: my port number is %d", cr_server.tcpip_port);
206
207	/*
208	* Load the SPUs
209	*/
210	cr_server.head_spu =
211	crSPULoadChain(num_spus, spu_ids, spu_names, spu_dir, &cr_server);
212
213	env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
214	if (env != NULL && env[0] != '\0')
215	{
216	unsigned int redir = (unsigned int)crServerVBoxParseNumerics(env, CR_SERVER_REDIR_F_NONE);
217	if (redir <= CR_SERVER_REDIR_F_ALL)
218	{
219	int rc = crServerSetOffscreenRenderingMode(redir);
220	if (!RT_SUCCESS(rc))
221	crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
222	}
223	else
224	crWarning("invalid redir option %c", redir);
225	}
226	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS) \|\| defined(GLX)
227	if (cr_server.fPresentMode == CR_SERVER_REDIR_F_NONE)
228	{
229	/* the CR_SERVER_REDIR_F_FBO_BLT is set only if parent window is received, which means we are not in headles */
230	int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_F_FBO \| CR_SERVER_REDIR_F_DISPLAY);
231	if (!RT_SUCCESS(rc))
232	crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
233
234	}
235	#endif
236	cr_server.fPresentModeDefault = cr_server.fPresentMode;
237	cr_server.fVramPresentModeDefault = CR_SERVER_REDIR_F_FBO_RAM/* \| CR_SERVER_REDIR_F_FBO_RPW*/;
238
239	/* Need to do this as early as possible */
240
241	cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);
242	cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, 0, GL_INT, 2, &dims[2]);
243
244	defaultMural->gX = dims[0];
245	defaultMural->gY = dims[1];
246	defaultMural->width = dims[2];
247	defaultMural->height = dims[3];
248
249	crFree(spu_ids);
250	crFreeStrings(spu_names);
251	crFreeStrings(spuchain);
252	if (spu_dir)
253	crFree(spu_dir);
254
255	cr_server.mtu = 1024 * 30;
256
257	/*
258	* Get a list of all the clients talking to me.
259	*/
260	if (cr_server.vncMode) {
261	/* we're inside a vnc viewer */
262	/*if (!crMothershipSendString( conn, response, "getvncclient %s", hostname ))
263	crError( "Bad Mothership response: %s", response );*/
264	}
265	else {
266	//crMothershipGetClients(conn, response);
267	strcpy(response, "1 tcpip 1");
268	}
269
270	crDebug("CRServer: my clients: %s", response);
271
272	/*
273	* 'response' will now contain a number indicating the number of clients
274	* of this server, followed by a comma-separated list of protocol/SPU ID
275	* pairs.
276	* Example: "3 tcpip 1,gm 2,via 10"
277	*/
278	clientchain = crStrSplitn(response, " ", 1);
279	cr_server.numClients = crStrToInt(clientchain[0]);
280	if (cr_server.numClients == 0)
281	{
282	crError("I have no clients! What's a poor server to do?");
283	}
284	clientlist = crStrSplit(clientchain[1], ",");
285
286	/*
287	* Connect to initial set of clients.
288	* Call crNetAcceptClient() for each client.
289	* Also, look for a client that's _not_ using the file: protocol.
290	*/
291	for (i = 0; i < cr_server.numClients; i++)
292	{
293	CRClient newClient = (CRClient ) crCalloc(sizeof(CRClient));
294	#ifdef VBOX
295	sscanf(clientlist[i], "%1023s %d", cr_server.protocol, &(newClient->spu_id));
296	#else
297	sscanf(clientlist[i], "%s %d", cr_server.protocol, &(newClient->spu_id));
298	#endif
299	newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
300	cr_server.tcpip_port,
301	cr_server.mtu, 0);
302	newClient->currentCtxInfo = &cr_server.MainContextInfo;
303	crServerAddToRunQueue(newClient);
304
305	cr_server.clients[i] = newClient;
306	}
307
308	/* set default client and mural */
309	if (cr_server.numClients > 0) {
310	cr_server.curClient = cr_server.clients[0];
311	cr_server.curClient->currentMural = defaultMural;
312	cr_server.client_spu_id =cr_server.clients[0]->spu_id;
313	}
314
315	crFreeStrings(clientchain);
316	crFreeStrings(clientlist);
317
318	/* Ask the mothership for the tile info */
319	//crServerGetTileInfoFromMothership(conn, defaultMural);
320
321	if (cr_server.vncMode) {
322	/* In vnc mode, we reset the mothership configuration so that it can be
323	* used by subsequent OpenGL apps without having to spawn a new mothership
324	* on a new port.
325	*/
326	crDebug("CRServer: Resetting mothership to initial state");
327	//crMothershipReset(conn);
328	}
329
330	//crMothershipDisconnect(conn);
331	}
332
333	void crServerSetVBoxConfigurationHGCM()
334	{
335	CRMuralInfo *defaultMural;
336
337	int spu_ids[1] = {0};
338	char *spu_names[1] = {"render"};
339	char *spu_dir = NULL;
340	int i;
341	GLint dims[4];
342	const char * env;
343
344	defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
345	CRASSERT(defaultMural);
346
347	//@todo should be moved to addclient so we have a chain for each client
348
349	setDefaults();
350
351	/* Load the SPUs */
352	cr_server.head_spu = crSPULoadChain(1, spu_ids, spu_names, spu_dir, &cr_server);
353
354	if (!cr_server.head_spu)
355	return;
356
357	env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
358	if (env != NULL && env[0] != '\0')
359	{
360	unsigned int redir = (unsigned int)crServerVBoxParseNumerics(env, CR_SERVER_REDIR_F_NONE);
361	if (redir <= CR_SERVER_REDIR_F_ALL)
362	{
363	int rc = crServerSetOffscreenRenderingMode(redir);
364	if (!RT_SUCCESS(rc))
365	crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
366	}
367	else
368	crWarning("invalid redir option %c", redir);
369	}
370	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS) \|\| defined(GLX)
371	if (cr_server.fPresentMode == CR_SERVER_REDIR_F_NONE)
372	{
373	/* the CR_SERVER_REDIR_F_FBO_BLT is set only if parent window is received, which means we are not in headles */
374	int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_F_FBO \| CR_SERVER_REDIR_F_DISPLAY);
375	if (!RT_SUCCESS(rc))
376	crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
377
378	}
379	#endif
380	cr_server.fPresentModeDefault = cr_server.fPresentMode;
381	cr_server.fVramPresentModeDefault = CR_SERVER_REDIR_F_FBO_RAM/* \| CR_SERVER_REDIR_F_FBO_RPW*/;
382
383	cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);
384	cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, 0, GL_INT, 2, &dims[2]);
385
386	defaultMural->gX = dims[0];
387	defaultMural->gY = dims[1];
388	defaultMural->width = dims[2];
389	defaultMural->height = dims[3];
390
391	cr_server.mtu = 1024 * 250;
392
393	cr_server.numClients = 0;
394	strcpy(cr_server.protocol, "vboxhgcm");
395
396	for (i = 0; i < cr_server.numClients; i++)
397	{
398	CRClient newClient = (CRClient ) crCalloc(sizeof(CRClient));
399	newClient->spu_id = 0;
400	newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
401	cr_server.tcpip_port,
402	cr_server.mtu, 0);
403	newClient->currentCtxInfo = &cr_server.MainContextInfo;
404	crServerAddToRunQueue(newClient);
405
406	cr_server.clients[i] = newClient;
407	}
408
409	/* set default client and mural */
410	if (cr_server.numClients > 0) {
411	cr_server.curClient = cr_server.clients[0];
412	cr_server.curClient->currentMural = defaultMural;
413	cr_server.client_spu_id =cr_server.clients[0]->spu_id;
414	}
415	}

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

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_config.c@ 45442

Download in other formats: