VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c@ 20175

Last change on this file since 20175 was 19879, checked in by vboxsync, 16 years ago

crOpenGL: fix bug with crashes in unloaded render_spu.dll (hopefully)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 13.8 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 "cr_mem.h"
8#include "cr_spu.h"
9#include "cr_error.h"
10#include "cr_string.h"
11#include "cr_url.h"
12#include "renderspu.h"
13#include <stdio.h>
14
15#ifdef RT_OS_DARWIN
16# include <iprt/semaphore.h>
17#endif /* RT_OS_DARWIN */
18
19static SPUNamedFunctionTable _cr_render_table[1000];
20
21SPUFunctions render_functions = {
22 NULL, /* CHILD COPY */
23 NULL, /* DATA */
24 _cr_render_table /* THE ACTUAL FUNCTIONS */
25};
26
27RenderSPU render_spu;
28unsigned int render_spu_parent_window_id;
29
30#ifdef CHROMIUM_THREADSAFE
31CRtsd _RenderTSD;
32#endif
33
34static void swapsyncConnect(void)
35{
36 char hostname[4096], protocol[4096];
37 unsigned short port;
38
39 crNetInit(NULL, NULL);
40
41 if (!crParseURL( render_spu.swap_master_url, protocol, hostname,
42 &port, 9876))
43 crError( "Bad URL: %s", render_spu.swap_master_url );
44
45 if (render_spu.is_swap_master)
46 {
47 int a;
48
49 render_spu.swap_conns = (CRConnection **)crAlloc(
50 render_spu.num_swap_clients*sizeof(CRConnection *));
51 for (a=0; a<render_spu.num_swap_clients; a++)
52 {
53 render_spu.swap_conns[a] = crNetAcceptClient( protocol, hostname, port,
54 render_spu.swap_mtu, 1);
55 }
56 }
57 else
58 {
59 render_spu.swap_conns = (CRConnection **)crAlloc(sizeof(CRConnection *));
60
61 render_spu.swap_conns[0] = crNetConnectToServer(render_spu.swap_master_url,
62 port, render_spu.swap_mtu, 1);
63 if (!render_spu.swap_conns[0])
64 crError("Failed connection");
65 }
66}
67
68#ifdef RT_OS_WINDOWS
69static DWORD WINAPI renderSPUWindowThreadProc(void* unused)
70{
71 MSG msg;
72 bool bRet;
73
74 (void) unused;
75
76 /* Force system to create the message queue.
77 * Else, there's a chance that render spu will issue PostThreadMessage
78 * before this thread calls GetMessage for first time.
79 */
80 PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
81
82 crDebug("RenderSPU: Window thread started (%x)", crThreadID());
83 SetEvent(render_spu.hWinThreadReadyEvent);
84
85 while( (bRet = GetMessage( &msg, 0, 0, 0 )) != 0)
86 {
87 if (bRet == -1)
88 {
89 crError("RenderSPU: Window thread GetMessage failed (%x)", GetLastError());
90 break;
91 }
92 else
93 {
94 if (msg.message == WM_VBOX_RENDERSPU_CREATE_WINDOW)
95 {
96 LPCREATESTRUCT pCS = (LPCREATESTRUCT) msg.lParam;
97 HWND *phWnd;
98
99 CRASSERT(msg.lParam && !msg.wParam && pCS->lpCreateParams);
100
101 phWnd = pCS->lpCreateParams;
102
103 *phWnd = CreateWindowEx(pCS->dwExStyle, pCS->lpszName, pCS->lpszClass, pCS->style,
104 pCS->x, pCS->y, pCS->cx, pCS->cy,
105 pCS->hwndParent, pCS->hMenu, pCS->hInstance, &render_spu);
106
107 SetEvent(render_spu.hWinThreadReadyEvent);
108 }
109 else if (msg.message == WM_VBOX_RENDERSPU_DESTROY_WINDOW)
110 {
111 CRASSERT(msg.lParam && !msg.wParam);
112
113 DestroyWindow(((VBOX_RENDERSPU_DESTROY_WINDOW*) msg.lParam)->hWnd);
114
115 SetEvent(render_spu.hWinThreadReadyEvent);
116 }
117 else
118 {
119 TranslateMessage(&msg);
120 DispatchMessage(&msg);
121 }
122 }
123 }
124
125 render_spu.dwWinThreadId = 0;
126
127 crDebug("RenderSPU: Window thread stopped (%x)", crThreadID());
128 SetEvent(render_spu.hWinThreadReadyEvent);
129
130 return 0;
131}
132#endif
133
134static SPUFunctions *
135renderSPUInit( int id, SPU *child, SPU *self,
136 unsigned int context_id, unsigned int num_contexts )
137{
138 int numFuncs, numSpecial;
139 GLint defaultWin, defaultCtx;
140 WindowInfo *windowInfo;
141
142 (void) child;
143 (void) context_id;
144 (void) num_contexts;
145
146 self->privatePtr = (void *) &render_spu;
147
148#ifdef CHROMIUM_THREADSAFE
149 crDebug("Render SPU: thread-safe");
150#endif
151
152 crMemZero(&render_spu, sizeof(render_spu));
153
154 render_spu.id = id;
155 renderspuSetVBoxConfiguration(&render_spu);
156
157 if (render_spu.swap_master_url)
158 swapsyncConnect();
159
160
161 /* Get our special functions. */
162 numSpecial = renderspuCreateFunctions( _cr_render_table );
163
164#ifdef RT_OS_WINDOWS
165 /* Start thread to create windows and process window messages */
166 crDebug("RenderSPU: Starting windows serving thread");
167 render_spu.hWinThreadReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
168 if (!render_spu.hWinThreadReadyEvent)
169 {
170 crError("RenderSPU: Failed to create WinThreadReadyEvent! (%x)", GetLastError());
171 return NULL;
172 }
173
174 if (!CreateThread(NULL, 0, renderSPUWindowThreadProc, 0, 0, &render_spu.dwWinThreadId))
175 {
176 crError("RenderSPU: Failed to start windows thread! (%x)", GetLastError());
177 return NULL;
178 }
179 WaitForSingleObject(render_spu.hWinThreadReadyEvent, INFINITE);
180#endif
181
182 /* Get the OpenGL functions. */
183 numFuncs = crLoadOpenGL( &render_spu.ws, _cr_render_table + numSpecial );
184 if (numFuncs == 0) {
185 crError("The render SPU was unable to load the native OpenGL library");
186 return NULL;
187 }
188
189 numFuncs += numSpecial;
190
191#ifdef GLX
192 if (!render_spu.use_glxchoosevisual) {
193 /* sometimes want to set this option with ATI drivers */
194 render_spu.ws.glXChooseVisual = NULL;
195 }
196#endif
197
198 render_spu.window_id = 0;
199 render_spu.context_id = 0;
200 render_spu.contextTable = crAllocHashtable();
201 render_spu.windowTable = crAllocHashtable();
202
203 CRASSERT(render_spu.default_visual & CR_RGB_BIT);
204
205#ifdef USE_OSMESA
206 if (render_spu.use_osmesa) {
207 if (!crLoadOSMesa(&render_spu.OSMesaCreateContext,
208 &render_spu.OSMesaMakeCurrent,
209 &render_spu.OSMesaDestroyContext)) {
210 crError("Unable to load OSMesa library");
211 }
212 }
213#endif
214
215#ifdef DARWIN
216# ifndef __LP64__ /** @todo port to 64-bit darwin. */
217 render_spu.hRootVisibleRegion = 0;
218 render_spu.currentBufferName = 1;
219 render_spu.uiDockUpdateTS = 0;
220 /* Create a mutex for syncronizing events from the main Qt thread & this
221 thread */
222 RTSemFastMutexCreate(&render_spu.syncMutex);
223 /* Create our window groups */
224 CreateWindowGroup(kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrSharedActivation | kWindowGroupAttrHideOnCollapse | kWindowGroupAttrFixedLevel, &render_spu.pMasterGroup);
225 CreateWindowGroup(kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrSharedActivation | kWindowGroupAttrHideOnCollapse | kWindowGroupAttrFixedLevel, &render_spu.pParentGroup);
226 /* Make the correct z-layering */
227 SendWindowGroupBehind (render_spu.pParentGroup, render_spu.pMasterGroup);
228 /* and set the gParentGroup as parent for gMasterGroup. */
229 SetWindowGroupParent (render_spu.pMasterGroup, render_spu.pParentGroup);
230 /* Install the event handlers */
231 EventTypeSpec eventList[] =
232 {
233 {kEventClassVBox, kEventVBoxUpdateContext}, /* Update the context after show/size/move events */
234 {kEventClassVBox, kEventVBoxBoundsChanged} /* Clip/Pos the OpenGL windows when the main window is changed in pos/size */
235 };
236 /* We need to process events from our main window */
237 render_spu.hParentEventHandler = NewEventHandlerUPP(windowEvtHndlr);
238 InstallApplicationEventHandler (render_spu.hParentEventHandler,
239 GetEventTypeCount(eventList), eventList,
240 NULL, NULL);
241 render_spu.fInit = true;
242# endif /* !__LP64__ */
243#endif /* DARWIN */
244
245 /*
246 * Create the default window and context. Their indexes are zero and
247 * a client can use them without calling CreateContext or WindowCreate.
248 */
249 crDebug("Render SPU: Creating default window (visBits=0x%x, id=0)",
250 render_spu.default_visual);
251 defaultWin = renderspuWindowCreate( NULL, render_spu.default_visual );
252 if (defaultWin != 0) {
253 crError("Render SPU: Couldn't get a double-buffered, RGB visual with Z!");
254 return NULL;
255 }
256 crDebug( "Render SPU: WindowCreate returned %d (0=normal)", defaultWin );
257
258 crDebug("Render SPU: Creating default context, visBits=0x%x",
259 render_spu.default_visual );
260 defaultCtx = renderspuCreateContext( NULL, render_spu.default_visual, 0 );
261 CRASSERT(defaultCtx == 0);
262
263 renderspuMakeCurrent( defaultWin, 0, defaultCtx );
264
265 /* Get windowInfo for the default window */
266 windowInfo = (WindowInfo *) crHashtableSearch(render_spu.windowTable, 0);
267 CRASSERT(windowInfo);
268 windowInfo->mapPending = GL_TRUE;
269
270 /*
271 * Get the OpenGL extension functions.
272 * SIGH -- we have to wait until the very bitter end to load the
273 * extensions, because the context has to be bound before
274 * wglGetProcAddress will work correctly. No such issue with GLX though.
275 */
276 numFuncs += crLoadOpenGLExtensions( &render_spu.ws, _cr_render_table + numFuncs );
277 CRASSERT(numFuncs < 1000);
278
279#ifdef WINDOWS
280 /*
281 * Same problem as above, these are extensions so we need to
282 * load them after a context has been bound. As they're WGL
283 * extensions too, we can't simply tag them into the spu_loader.
284 * So we do them here for now.
285 * Grrr, NVIDIA driver uses EXT for GetExtensionsStringEXT,
286 * but ARB for others. Need furthur testing here....
287 */
288 render_spu.ws.wglGetExtensionsStringEXT =
289 (wglGetExtensionsStringEXTFunc_t)
290 render_spu.ws.wglGetProcAddress( "wglGetExtensionsStringEXT" );
291 render_spu.ws.wglChoosePixelFormatEXT =
292 (wglChoosePixelFormatEXTFunc_t)
293 render_spu.ws.wglGetProcAddress( "wglChoosePixelFormatARB" );
294 render_spu.ws.wglGetPixelFormatAttribivEXT =
295 (wglGetPixelFormatAttribivEXTFunc_t)
296 render_spu.ws.wglGetProcAddress( "wglGetPixelFormatAttribivARB" );
297 render_spu.ws.wglGetPixelFormatAttribfvEXT =
298 (wglGetPixelFormatAttribfvEXTFunc_t)
299 render_spu.ws.wglGetProcAddress( "wglGetPixelFormatAttribfvARB" );
300
301 if (render_spu.ws.wglGetProcAddress("glTexImage3D"))
302 {
303 _cr_render_table[numFuncs].name = crStrdup("TexImage3D");
304 _cr_render_table[numFuncs].fn = (SPUGenericFunction) render_spu.ws.wglGetProcAddress("glTexImage3D");
305 ++numFuncs;
306 crDebug("Render SPU: Found glTexImage3D function");
307 }
308
309 if (render_spu.ws.wglGetExtensionsStringEXT) {
310 crDebug("WGL - found wglGetExtensionsStringEXT\n");
311 }
312 if (render_spu.ws.wglChoosePixelFormatEXT) {
313 crDebug("WGL - found wglChoosePixelFormatEXT\n");
314 }
315#endif
316
317 render_spu.barrierHash = crAllocHashtable();
318
319 render_spu.cursorX = 0;
320 render_spu.cursorY = 0;
321 render_spu.use_L2 = 0;
322
323 render_spu.gather_conns = NULL;
324
325 crDebug("Render SPU: ---------- End of Init -------------");
326
327 return &render_functions;
328}
329
330
331static void renderSPUSelfDispatch(SPUDispatchTable *self)
332{
333 crSPUInitDispatchTable( &(render_spu.self) );
334 crSPUCopyDispatchTable( &(render_spu.self), self );
335
336 render_spu.server = (CRServer *)(self->server);
337}
338
339
340static void DeleteContextCallback( void *data )
341{
342 ContextInfo *context = (ContextInfo *) data;
343 renderspu_SystemDestroyContext(context);
344 crFree(context);
345}
346
347static void DeleteWindowCallback( void *data )
348{
349 WindowInfo *window = (WindowInfo *) data;
350 renderspu_SystemDestroyWindow(window);
351 crFree(window);
352}
353
354static int renderSPUCleanup(void)
355{
356 crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
357 render_spu.contextTable = NULL;
358 crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
359 render_spu.windowTable = NULL;
360 crFreeHashtable(render_spu.barrierHash, crFree);
361 render_spu.barrierHash = NULL;
362
363#ifdef RT_OS_DARWIN
364# ifndef __LP64__ /** @todo port to 64-bit darwin. */
365 render_spu.fInit = false;
366 DisposeEventHandlerUPP(render_spu.hParentEventHandler);
367 ReleaseWindowGroup(render_spu.pMasterGroup);
368 ReleaseWindowGroup(render_spu.pParentGroup);
369 if (render_spu.hRootVisibleRegion)
370 {
371 DisposeRgn(render_spu.hRootVisibleRegion);
372 render_spu.hRootVisibleRegion = 0;
373 }
374 render_spu.currentBufferName = 1;
375 render_spu.uiDockUpdateTS = 0;
376 RTSemFastMutexDestroy(render_spu.syncMutex);
377# endif /* __LP64__ */
378#endif /* RT_OS_DARWIN */
379
380#ifdef RT_OS_WINDOWS
381 if (render_spu.dwWinThreadId)
382 {
383 PostThreadMessage(render_spu.dwWinThreadId, WM_QUIT, 0, 0);
384 WaitForSingleObject(render_spu.hWinThreadReadyEvent, INFINITE);
385 }
386 CloseHandle(render_spu.hWinThreadReadyEvent);
387 render_spu.hWinThreadReadyEvent = NULL;
388#endif
389
390 crUnloadOpenGL();
391
392 return 1;
393}
394
395
396extern SPUOptions renderSPUOptions[];
397
398int SPULoad( char **name, char **super, SPUInitFuncPtr *init,
399 SPUSelfDispatchFuncPtr *self, SPUCleanupFuncPtr *cleanup,
400 SPUOptionsPtr *options, int *flags )
401{
402 *name = "render";
403 *super = NULL;
404 *init = renderSPUInit;
405 *self = renderSPUSelfDispatch;
406 *cleanup = renderSPUCleanup;
407 *options = renderSPUOptions;
408 *flags = (SPU_NO_PACKER|SPU_IS_TERMINAL|SPU_MAX_SERVERS_ZERO);
409
410 return 1;
411}
412
413DECLEXPORT(void) renderspuSetWindowId(unsigned int winId)
414{
415 render_spu_parent_window_id = winId;
416}
417
418static void renderspuWindowVisibleRegionCB(unsigned long key, void *data1, void *data2)
419{
420 WindowInfo *window = (WindowInfo *) data1;
421 CRASSERT(window);
422
423 renderspu_SystemWindowApplyVisibleRegion(window);
424}
425
426DECLEXPORT(void) renderspuSetRootVisibleRegion(GLint cRects, GLint *pRects)
427{
428#ifdef RT_OS_DARWIN
429 renderspu_SystemSetRootVisibleRegion(cRects, pRects);
430
431 crHashtableWalk(render_spu.windowTable, renderspuWindowVisibleRegionCB, NULL);
432#endif
433}
434
435#ifndef RT_OS_DARWIN
436void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
437{
438}
439#endif
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette