VirtualBox

source: vbox/trunk/src/VBox/Additions/common/crOpenGL/load.c@ 39570

Last change on this file since 39570 was 39568, checked in by vboxsync, 13 years ago

crOpenGL: more threading fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 38.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 "cr_spu.h"
8#include "cr_net.h"
9#include "cr_error.h"
10#include "cr_mem.h"
11#include "cr_string.h"
12#include "cr_net.h"
13#include "cr_environment.h"
14#include "cr_process.h"
15#include "cr_rand.h"
16#include "cr_netserver.h"
17#include "stub.h"
18#include <stdlib.h>
19#include <string.h>
20#include <signal.h>
21#include <iprt/initterm.h>
22#include <iprt/thread.h>
23#include <iprt/err.h>
24#include <iprt/asm.h>
25#ifndef WINDOWS
26# include <sys/types.h>
27# include <unistd.h>
28#endif
29#ifdef CHROMIUM_THREADSAFE
30#include "cr_threads.h"
31#endif
32
33#ifdef VBOX_WITH_WDDM
34#include <d3d9types.h>
35#include <D3dumddi.h>
36#include "../../WINNT/Graphics/Video/common/wddm/VBoxMPIf.h"
37#include "../../WINNT/Graphics/Video/disp/wddm/VBoxDispMp.h"
38#endif
39
40/**
41 * If you change this, see the comments in tilesortspu_context.c
42 */
43#define MAGIC_CONTEXT_BASE 500
44
45#define CONFIG_LOOKUP_FILE ".crconfigs"
46
47#ifdef WINDOWS
48#define PYTHON_EXE "python.exe"
49#else
50#define PYTHON_EXE "python"
51#endif
52
53#ifdef WINDOWS
54static char* gsViewportHackApps[] = {"googleearth.exe", NULL};
55#endif
56
57static int stub_initialized = 0;
58#ifdef WINDOWS
59static CRmutex stub_init_mutex;
60#define STUB_INIT_LOCK() do { crLockMutex(&stub_init_mutex); } while (0)
61#define STUB_INIT_UNLOCK() do { crUnlockMutex(&stub_init_mutex); } while (0)
62#else
63#define STUB_INIT_LOCK() do { } while (0)
64#define STUB_INIT_UNLOCK() do { } while (0)
65#endif
66
67/* NOTE: 'SPUDispatchTable glim' is declared in NULLfuncs.py now */
68/* NOTE: 'SPUDispatchTable stubThreadsafeDispatch' is declared in tsfuncs.c */
69Stub stub;
70#ifdef CHROMIUM_THREADSAFE
71CRtsd g_stubCurrentContextTSD;
72#endif
73
74
75static void stubInitNativeDispatch( void )
76{
77#define MAX_FUNCS 1000
78 SPUNamedFunctionTable gl_funcs[MAX_FUNCS];
79 int numFuncs;
80
81 numFuncs = crLoadOpenGL( &stub.wsInterface, gl_funcs );
82
83 stub.haveNativeOpenGL = (numFuncs > 0);
84
85 /* XXX call this after context binding */
86 numFuncs += crLoadOpenGLExtensions( &stub.wsInterface, gl_funcs + numFuncs );
87
88 CRASSERT(numFuncs < MAX_FUNCS);
89
90 crSPUInitDispatchTable( &stub.nativeDispatch );
91 crSPUInitDispatch( &stub.nativeDispatch, gl_funcs );
92 crSPUInitDispatchNops( &stub.nativeDispatch );
93#undef MAX_FUNCS
94}
95
96
97/** Pointer to the SPU's real glClear and glViewport functions */
98static ClearFunc_t origClear;
99static ViewportFunc_t origViewport;
100static SwapBuffersFunc_t origSwapBuffers;
101static DrawBufferFunc_t origDrawBuffer;
102static ScissorFunc_t origScissor;
103
104static void stubCheckWindowState(WindowInfo *window, GLboolean bFlushOnChange)
105{
106 bool bForceUpdate = false;
107 bool bChanged = false;
108
109#ifdef WINDOWS
110 /* @todo install hook and track for WM_DISPLAYCHANGE */
111 {
112 DEVMODE devMode;
113
114 devMode.dmSize = sizeof(DEVMODE);
115 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devMode);
116
117 if (devMode.dmPelsWidth!=window->dmPelsWidth || devMode.dmPelsHeight!=window->dmPelsHeight)
118 {
119 crDebug("Resolution changed(%d,%d), forcing window Pos/Size update", devMode.dmPelsWidth, devMode.dmPelsHeight);
120 window->dmPelsWidth = devMode.dmPelsWidth;
121 window->dmPelsHeight = devMode.dmPelsHeight;
122 bForceUpdate = true;
123 }
124 }
125#endif
126
127 bChanged = stubUpdateWindowGeometry(window, bForceUpdate) || bForceUpdate;
128
129#if defined(GLX) || defined (WINDOWS)
130 if (stub.trackWindowVisibleRgn)
131 {
132 bChanged = stubUpdateWindowVisibileRegions(window) || bChanged;
133 }
134#endif
135
136 if (stub.trackWindowVisibility && window->type == CHROMIUM && window->drawable) {
137 const int mapped = stubIsWindowVisible(window);
138 if (mapped != window->mapped) {
139 crDebug("Dispatched: WindowShow(%i, %i)", window->spuWindow, mapped);
140 stub.spu->dispatch_table.WindowShow(window->spuWindow, mapped);
141 window->mapped = mapped;
142 bChanged = true;
143 }
144 }
145
146 if (bFlushOnChange && bChanged)
147 {
148 stub.spu->dispatch_table.Flush();
149 }
150}
151
152static bool stubSystemWindowExist(WindowInfo *pWindow)
153{
154#ifdef WINDOWS
155 if (pWindow->hWnd!=WindowFromDC(pWindow->drawable))
156 {
157 return false;
158 }
159#else
160 Window root;
161 int x, y;
162 unsigned int border, depth, w, h;
163 Display *dpy;
164
165 dpy = stubGetWindowDisplay(pWindow);
166
167 XLOCK(dpy);
168 if (!XGetGeometry(dpy, pWindow->drawable, &root, &x, &y, &w, &h, &border, &depth))
169 {
170 XUNLOCK(dpy);
171 return false;
172 }
173 XUNLOCK(dpy);
174#endif
175
176 return true;
177}
178
179static void stubCheckWindowsCB(unsigned long key, void *data1, void *data2)
180{
181 WindowInfo *pWindow = (WindowInfo *) data1;
182 ContextInfo *pCtx = (ContextInfo *) data2;
183
184 if (pWindow == pCtx->currentDrawable
185 || pWindow->type!=CHROMIUM
186 || pWindow->pOwner!=pCtx)
187 {
188 return;
189 }
190
191 if (!stubSystemWindowExist(pWindow))
192 {
193#ifdef WINDOWS
194 crWindowDestroy((GLint)pWindow->hWnd);
195#else
196 crWindowDestroy((GLint)pWindow->drawable);
197#endif
198 return;
199 }
200
201 stubCheckWindowState(pWindow, GL_FALSE);
202}
203
204static void stubCheckWindowsState(void)
205{
206 ContextInfo *context = stubGetCurrentContext();
207
208 CRASSERT(stub.trackWindowSize || stub.trackWindowPos);
209
210 if (!context)
211 return;
212
213#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
214 if (stub.bRunningUnderWDDM)
215 return;
216#endif
217
218#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
219 crLockMutex(&stub.mutex);
220#endif
221
222 stubCheckWindowState(context->currentDrawable, GL_TRUE);
223 crHashtableWalk(stub.windowTable, stubCheckWindowsCB, context);
224
225#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
226 crUnlockMutex(&stub.mutex);
227#endif
228}
229
230
231/**
232 * Override the head SPU's glClear function.
233 * We're basically trapping this function so that we can poll the
234 * application window size at a regular interval.
235 */
236static void SPU_APIENTRY trapClear(GLbitfield mask)
237{
238 stubCheckWindowsState();
239 /* call the original SPU glClear function */
240 origClear(mask);
241}
242
243/**
244 * As above, but for glViewport. Most apps call glViewport before
245 * glClear when a window is resized.
246 */
247static void SPU_APIENTRY trapViewport(GLint x, GLint y, GLsizei w, GLsizei h)
248{
249 stubCheckWindowsState();
250 /* call the original SPU glViewport function */
251 if (!stub.viewportHack)
252 {
253 origViewport(x, y, w, h);
254 }
255 else
256 {
257 ContextInfo *context = stubGetCurrentContext();
258 int winX, winY;
259 unsigned int winW, winH;
260 WindowInfo *pWindow;
261 pWindow = context->currentDrawable;
262 stubGetWindowGeometry(pWindow, &winX, &winY, &winW, &winH);
263 origViewport(0, 0, winW, winH);
264 }
265}
266
267static void SPU_APIENTRY trapSwapBuffers(GLint window, GLint flags)
268{
269 stubCheckWindowsState();
270 origSwapBuffers(window, flags);
271}
272
273static void SPU_APIENTRY trapDrawBuffer(GLenum buf)
274{
275 stubCheckWindowsState();
276 origDrawBuffer(buf);
277}
278
279static void SPU_APIENTRY trapScissor(GLint x, GLint y, GLsizei w, GLsizei h)
280{
281 int winX, winY;
282 unsigned int winW, winH;
283 WindowInfo *pWindow;
284 ContextInfo *context = stubGetCurrentContext();
285 pWindow = context->currentDrawable;
286 stubGetWindowGeometry(pWindow, &winX, &winY, &winW, &winH);
287 origScissor(0, 0, winW, winH);
288}
289
290/**
291 * Use the GL function pointers in <spu> to initialize the static glim
292 * dispatch table.
293 */
294static void stubInitSPUDispatch(SPU *spu)
295{
296 crSPUInitDispatchTable( &stub.spuDispatch );
297 crSPUCopyDispatchTable( &stub.spuDispatch, &(spu->dispatch_table) );
298
299 if (stub.trackWindowSize || stub.trackWindowPos || stub.trackWindowVisibleRgn) {
300 /* patch-in special glClear/Viewport function to track window sizing */
301 origClear = stub.spuDispatch.Clear;
302 origViewport = stub.spuDispatch.Viewport;
303 origSwapBuffers = stub.spuDispatch.SwapBuffers;
304 origDrawBuffer = stub.spuDispatch.DrawBuffer;
305 origScissor = stub.spuDispatch.Scissor;
306 stub.spuDispatch.Clear = trapClear;
307 stub.spuDispatch.Viewport = trapViewport;
308
309 if (stub.viewportHack)
310 stub.spuDispatch.Scissor = trapScissor;
311 /*stub.spuDispatch.SwapBuffers = trapSwapBuffers;
312 stub.spuDispatch.DrawBuffer = trapDrawBuffer;*/
313 }
314
315 crSPUCopyDispatchTable( &glim, &stub.spuDispatch );
316}
317
318// Callback function, used to destroy all created contexts
319static void hsWalkStubDestroyContexts(unsigned long key, void *data1, void *data2)
320{
321 stubDestroyContext(key);
322}
323
324/**
325 * This is called when we exit.
326 * We call all the SPU's cleanup functions.
327 */
328static void stubSPUTearDownLocked(void)
329{
330 crDebug("stubSPUTearDownLocked");
331
332#ifdef WINDOWS
333# ifndef CR_NEWWINTRACK
334 stubUninstallWindowMessageHook();
335# endif
336#endif
337
338#ifdef CR_NEWWINTRACK
339 ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
340#endif
341
342 //delete all created contexts
343 stubMakeCurrent( NULL, NULL);
344 crHashtableWalk(stub.contextTable, hsWalkStubDestroyContexts, NULL);
345
346 /* shutdown, now trap any calls to a NULL dispatcher */
347 crSPUCopyDispatchTable(&glim, &stubNULLDispatch);
348
349 crSPUUnloadChain(stub.spu);
350 stub.spu = NULL;
351
352#ifndef Linux
353 crUnloadOpenGL();
354#endif
355
356#ifndef WINDOWS
357 crNetTearDown();
358#endif
359
360#ifdef GLX
361 if (stub.xshmSI.shmid>=0)
362 {
363 shmctl(stub.xshmSI.shmid, IPC_RMID, 0);
364 shmdt(stub.xshmSI.shmaddr);
365 }
366 crFreeHashtable(stub.pGLXPixmapsHash, crFree);
367#endif
368
369 crFreeHashtable(stub.windowTable, crFree);
370 crFreeHashtable(stub.contextTable, NULL);
371
372 crMemset(&stub, 0, sizeof(stub));
373
374}
375
376/**
377 * This is called when we exit.
378 * We call all the SPU's cleanup functions.
379 */
380static void stubSPUTearDown(void)
381{
382 STUB_INIT_LOCK();
383 if (stub_initialized)
384 {
385 stubSPUTearDownLocked();
386 stub_initialized = 0;
387 }
388 STUB_INIT_UNLOCK();
389}
390
391static void stubSPUSafeTearDown(void)
392{
393#ifdef CHROMIUM_THREADSAFE
394 CRmutex *mutex;
395#endif
396
397 if (!stub_initialized) return;
398 stub_initialized = 0;
399
400#ifdef CHROMIUM_THREADSAFE
401 mutex = &stub.mutex;
402 crLockMutex(mutex);
403#endif
404 crDebug("stubSPUSafeTearDown");
405
406#ifdef WINDOWS
407# ifndef CR_NEWWINTRACK
408 stubUninstallWindowMessageHook();
409# endif
410#endif
411
412#if defined(CR_NEWWINTRACK)
413 crUnlockMutex(mutex);
414# if defined(WINDOWS)
415 if (RTThreadGetState(stub.hSyncThread)!=RTTHREADSTATE_TERMINATED)
416 {
417 HANDLE hNative;
418 DWORD ec=0;
419
420 hNative = OpenThread(SYNCHRONIZE|THREAD_QUERY_INFORMATION|THREAD_TERMINATE,
421 false, RTThreadGetNative(stub.hSyncThread));
422 if (!hNative)
423 {
424 crWarning("Failed to get handle for sync thread(%#x)", GetLastError());
425 }
426 else
427 {
428 crDebug("Got handle %p for thread %#x", hNative, RTThreadGetNative(stub.hSyncThread));
429 }
430
431 ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
432
433 if (PostThreadMessage(RTThreadGetNative(stub.hSyncThread), WM_QUIT, 0, 0))
434 {
435 RTThreadWait(stub.hSyncThread, 1000, NULL);
436
437 /*Same issue as on linux, RTThreadWait exits before system thread is terminated, which leads
438 * to issues as our dll goes to be unloaded.
439 *@todo
440 *We usually call this function from DllMain which seems to be holding some lock and thus we have to
441 * kill thread via TerminateThread.
442 */
443 if (WaitForSingleObject(hNative, 100)==WAIT_TIMEOUT)
444 {
445 crDebug("Wait failed, terminating");
446 if (!TerminateThread(hNative, 1))
447 {
448 crDebug("TerminateThread failed");
449 }
450 }
451 if (GetExitCodeThread(hNative, &ec))
452 {
453 crDebug("Thread %p exited with ec=%i", hNative, ec);
454 }
455 else
456 {
457 crDebug("GetExitCodeThread failed(%#x)", GetLastError());
458 }
459 }
460 else
461 {
462 crDebug("Sync thread killed before DLL_PROCESS_DETACH");
463 }
464
465 if (hNative)
466 {
467 CloseHandle(hNative);
468 }
469 }
470#else
471 if (stub.hSyncThread!=NIL_RTTHREAD)
472 {
473 ASMAtomicWriteBool(&stub.bShutdownSyncThread, true);
474 {
475 /*RTThreadWait might return too early, which cause our code being unloaded while RT thread wrapper is still running*/
476 int rc = pthread_join(RTThreadGetNative(stub.hSyncThread), NULL);
477 if (!rc)
478 {
479 crDebug("pthread_join failed %i", rc);
480 }
481 }
482 }
483#endif
484 crLockMutex(mutex);
485#endif
486
487#ifndef WINDOWS
488 crNetTearDown();
489#endif
490
491#ifdef CHROMIUM_THREADSAFE
492 crUnlockMutex(mutex);
493 crFreeMutex(mutex);
494#endif
495 crMemset(&stub, 0, sizeof(stub));
496}
497
498
499static void stubExitHandler(void)
500{
501 stubSPUSafeTearDown();
502}
503
504/**
505 * Called when we receive a SIGTERM signal.
506 */
507static void stubSignalHandler(int signo)
508{
509 stubSPUSafeTearDown();
510 exit(0); /* this causes stubExitHandler() to be called */
511}
512
513
514/**
515 * Init variables in the stub structure, install signal handler.
516 */
517static void stubInitVars(void)
518{
519 WindowInfo *defaultWin;
520
521#ifdef CHROMIUM_THREADSAFE
522 crInitMutex(&stub.mutex);
523#endif
524
525 /* At the very least we want CR_RGB_BIT. */
526 stub.haveNativeOpenGL = GL_FALSE;
527 stub.spu = NULL;
528 stub.appDrawCursor = 0;
529 stub.minChromiumWindowWidth = 0;
530 stub.minChromiumWindowHeight = 0;
531 stub.maxChromiumWindowWidth = 0;
532 stub.maxChromiumWindowHeight = 0;
533 stub.matchChromiumWindowCount = 0;
534 stub.matchChromiumWindowID = NULL;
535 stub.matchWindowTitle = NULL;
536 stub.ignoreFreeglutMenus = 0;
537 stub.threadSafe = GL_FALSE;
538 stub.trackWindowSize = 0;
539 stub.trackWindowPos = 0;
540 stub.trackWindowVisibility = 0;
541 stub.trackWindowVisibleRgn = 0;
542 stub.mothershipPID = 0;
543 stub.spu_dir = NULL;
544
545 stub.freeContextNumber = MAGIC_CONTEXT_BASE;
546 stub.contextTable = crAllocHashtable();
547#ifndef RT_OS_WINDOWS
548# ifdef CHROMIUM_THREADSAFE
549 crInitTSD(&g_stubCurrentContextTSD);
550# endif
551#endif
552 stubSetCurrentContext(NULL);
553
554 stub.windowTable = crAllocHashtable();
555
556#ifdef CR_NEWWINTRACK
557 stub.bShutdownSyncThread = false;
558 stub.hSyncThread = NIL_RTTHREAD;
559#endif
560
561 defaultWin = (WindowInfo *) crCalloc(sizeof(WindowInfo));
562 defaultWin->type = CHROMIUM;
563 defaultWin->spuWindow = 0; /* window 0 always exists */
564#ifdef WINDOWS
565 defaultWin->hVisibleRegion = INVALID_HANDLE_VALUE;
566#elif defined(GLX)
567 defaultWin->pVisibleRegions = NULL;
568 defaultWin->cVisibleRegions = 0;
569#endif
570 crHashtableAdd(stub.windowTable, 0, defaultWin);
571
572#if 1
573 atexit(stubExitHandler);
574 signal(SIGTERM, stubSignalHandler);
575 signal(SIGINT, stubSignalHandler);
576#ifndef WINDOWS
577 signal(SIGPIPE, SIG_IGN); /* the networking code should catch this */
578#endif
579#else
580 (void) stubExitHandler;
581 (void) stubSignalHandler;
582#endif
583}
584
585
586/**
587 * Return a free port number for the mothership to use, or -1 if we
588 * can't find one.
589 */
590static int
591GenerateMothershipPort(void)
592{
593 const int MAX_PORT = 10100;
594 unsigned short port;
595
596 /* generate initial port number randomly */
597 crRandAutoSeed();
598 port = (unsigned short) crRandInt(10001, MAX_PORT);
599
600#ifdef WINDOWS
601 /* XXX should implement a free port check here */
602 return port;
603#else
604 /*
605 * See if this port number really is free, try another if needed.
606 */
607 {
608 struct sockaddr_in servaddr;
609 int so_reuseaddr = 1;
610 int sock, k;
611
612 /* create socket */
613 sock = socket(AF_INET, SOCK_STREAM, 0);
614 CRASSERT(sock > 2);
615
616 /* deallocate socket/port when we exit */
617 k = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
618 (char *) &so_reuseaddr, sizeof(so_reuseaddr));
619 CRASSERT(k == 0);
620
621 /* initialize the servaddr struct */
622 crMemset(&servaddr, 0, sizeof(servaddr) );
623 servaddr.sin_family = AF_INET;
624 servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
625
626 while (port < MAX_PORT) {
627 /* Bind to the given port number, return -1 if we fail */
628 servaddr.sin_port = htons((unsigned short) port);
629 k = bind(sock, (struct sockaddr *) &servaddr, sizeof(servaddr));
630 if (k) {
631 /* failed to create port. try next one. */
632 port++;
633 }
634 else {
635 /* free the socket/port now so mothership can make it */
636 close(sock);
637 return port;
638 }
639 }
640 }
641#endif /* WINDOWS */
642 return -1;
643}
644
645
646/**
647 * Try to determine which mothership configuration to use for this program.
648 */
649static char **
650LookupMothershipConfig(const char *procName)
651{
652 const int procNameLen = crStrlen(procName);
653 FILE *f;
654 const char *home;
655 char configPath[1000];
656
657 /* first, check if the CR_CONFIG env var is set */
658 {
659 const char *conf = crGetenv("CR_CONFIG");
660 if (conf && crStrlen(conf) > 0)
661 return crStrSplit(conf, " ");
662 }
663
664 /* second, look up config name from config file */
665 home = crGetenv("HOME");
666 if (home)
667 sprintf(configPath, "%s/%s", home, CONFIG_LOOKUP_FILE);
668 else
669 crStrcpy(configPath, CONFIG_LOOKUP_FILE); /* from current dir */
670 /* Check if the CR_CONFIG_PATH env var is set. */
671 {
672 const char *conf = crGetenv("CR_CONFIG_PATH");
673 if (conf)
674 crStrcpy(configPath, conf); /* from env var */
675 }
676
677 f = fopen(configPath, "r");
678 if (!f) {
679 return NULL;
680 }
681
682 while (!feof(f)) {
683 char line[1000];
684 char **args;
685 fgets(line, 999, f);
686 line[crStrlen(line) - 1] = 0; /* remove trailing newline */
687 if (crStrncmp(line, procName, procNameLen) == 0 &&
688 (line[procNameLen] == ' ' || line[procNameLen] == '\t'))
689 {
690 crWarning("Using Chromium configuration for %s from %s",
691 procName, configPath);
692 args = crStrSplit(line + procNameLen + 1, " ");
693 return args;
694 }
695 }
696 fclose(f);
697 return NULL;
698}
699
700
701static int Mothership_Awake = 0;
702
703
704/**
705 * Signal handler to determine when mothership is ready.
706 */
707static void
708MothershipPhoneHome(int signo)
709{
710 crDebug("Got signal %d: mothership is awake!", signo);
711 Mothership_Awake = 1;
712}
713
714void stubSetDefaultConfigurationOptions(void)
715{
716 unsigned char key[16]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
717
718 stub.appDrawCursor = 0;
719 stub.minChromiumWindowWidth = 0;
720 stub.minChromiumWindowHeight = 0;
721 stub.maxChromiumWindowWidth = 0;
722 stub.maxChromiumWindowHeight = 0;
723 stub.matchChromiumWindowID = NULL;
724 stub.numIgnoreWindowID = 0;
725 stub.matchWindowTitle = NULL;
726 stub.ignoreFreeglutMenus = 0;
727 stub.trackWindowSize = 1;
728 stub.trackWindowPos = 1;
729 stub.trackWindowVisibility = 1;
730 stub.trackWindowVisibleRgn = 1;
731 stub.matchChromiumWindowCount = 0;
732 stub.spu_dir = NULL;
733 crNetSetRank(0);
734 crNetSetContextRange(32, 35);
735 crNetSetNodeRange("iam0", "iamvis20");
736 crNetSetKey(key,sizeof(key));
737 stub.force_pbuffers = 0;
738 stub.viewportHack = 0;
739
740#ifdef WINDOWS
741 {
742 char name[1000];
743 int i;
744
745# ifdef VBOX_WITH_WDDM
746 stub.bRunningUnderWDDM = false;
747# endif
748 /* Apply viewport hack only if we're running under wine */
749 if (NULL!=GetModuleHandle("wined3d.dll") || NULL != GetModuleHandle("wined3dwddm.dll"))
750 {
751 crGetProcName(name, 1000);
752 for (i=0; gsViewportHackApps[i]; ++i)
753 {
754 if (!stricmp(name, gsViewportHackApps[i]))
755 {
756 stub.viewportHack = 1;
757 break;
758 }
759 }
760 }
761 }
762#endif
763}
764
765#ifdef CR_NEWWINTRACK
766# ifdef VBOX_WITH_WDDM
767static stubDispatchVisibleRegions(WindowInfo *pWindow)
768{
769 DWORD dwCount;
770 LPRGNDATA lpRgnData;
771
772 dwCount = GetRegionData(pWindow->hVisibleRegion, 0, NULL);
773 lpRgnData = crAlloc(dwCount);
774
775 if (lpRgnData)
776 {
777 GetRegionData(pWindow->hVisibleRegion, dwCount, lpRgnData);
778 crDebug("Dispatched WindowVisibleRegion (%i, cRects=%i)", pWindow->spuWindow, lpRgnData->rdh.nCount);
779 stub.spuDispatch.WindowVisibleRegion(pWindow->spuWindow, lpRgnData->rdh.nCount, (GLint*) lpRgnData->Buffer);
780 crFree(lpRgnData);
781 }
782 else crWarning("GetRegionData failed, VisibleRegions update failed");
783}
784
785static HRGN stubMakeRegionFromRects(PVBOXVIDEOCM_CMD_RECTS pRegions, uint32_t start)
786{
787 HRGN hRgn, hTmpRgn;
788 uint32_t i;
789
790 if (pRegions->RectsInfo.cRects<=start)
791 {
792 return INVALID_HANDLE_VALUE;
793 }
794
795 hRgn = CreateRectRgn(0, 0, 0, 0);
796 for (i=start; i<pRegions->RectsInfo.cRects; ++i)
797 {
798 hTmpRgn = CreateRectRgnIndirect(&pRegions->RectsInfo.aRects[i]);
799 CombineRgn(hRgn, hRgn, hTmpRgn, RGN_OR);
800 DeleteObject(hTmpRgn);
801 }
802 return hRgn;
803}
804
805typedef struct VBOXCR_UPDATEWNDCB
806{
807 VBOXDISPMP_REGIONS Regions;
808 bool fSendUpdateMsg;
809} VBOXCR_UPDATEWNDCB, *PVBOXCR_UPDATEWNDCB;
810
811static void stubSyncTrUpdateWindowCB(unsigned long key, void *data1, void *data2)
812{
813 WindowInfo *pWindow = (WindowInfo *) data1;
814 PVBOXCR_UPDATEWNDCB pCbData = (PVBOXCR_UPDATEWNDCB) data2;
815 VBOXDISPMP_REGIONS *pRegions = &pCbData->Regions;
816 bool bChanged = false;
817 HRGN hNewRgn = INVALID_HANDLE_VALUE;
818
819 if (pRegions->hWnd != pWindow->hWnd)
820 {
821 return;
822 }
823
824 stub.spu->dispatch_table.VBoxPackSetInjectID(pWindow->u32ClientID);
825
826 if (!stubSystemWindowExist(pWindow))
827 {
828 crWindowDestroy((GLint)pWindow->hWnd);
829 return;
830 }
831
832 if (!pWindow->mapped)
833 {
834 pWindow->mapped = GL_TRUE;
835 bChanged = true;
836 crDebug("Dispatched: WindowShow(%i, %i)", pWindow->spuWindow, pWindow->mapped);
837 stub.spu->dispatch_table.WindowShow(pWindow->spuWindow, pWindow->mapped);
838 }
839
840 if (pRegions->pRegions->fFlags.bSetVisibleRects || pRegions->pRegions->fFlags.bSetViewRect)
841 {
842 /* ensure data integrity */
843 Assert(!pRegions->pRegions->fFlags.bAddHiddenRects);
844
845 if (pRegions->pRegions->fFlags.bSetViewRect)
846 {
847 int winX, winY;
848 unsigned int winW, winH;
849 BOOL bRc;
850
851 winX = pRegions->pRegions->RectsInfo.aRects[0].left;
852 winY = pRegions->pRegions->RectsInfo.aRects[0].top;
853 winW = pRegions->pRegions->RectsInfo.aRects[0].right - winX;
854 winH = pRegions->pRegions->RectsInfo.aRects[0].bottom - winY;
855
856 if (stub.trackWindowPos && (winX!=pWindow->x || winY!=pWindow->y))
857 {
858 crDebug("Dispatched WindowPosition (%i)", pWindow->spuWindow);
859 stub.spuDispatch.WindowPosition(pWindow->spuWindow, winX, winY);
860 pWindow->x = winX;
861 pWindow->y = winY;
862 bChanged = true;
863 }
864
865 if (stub.trackWindowSize && (winW!=pWindow->width || winH!=pWindow->height))
866 {
867 crDebug("Dispatched WindowSize (%i)", pWindow->spuWindow);
868 stub.spuDispatch.WindowSize(pWindow->spuWindow, winW, winH);
869 pWindow->width = winW;
870 pWindow->height = winH;
871 bChanged = true;
872 }
873
874 bRc = MoveWindow(pRegions->hWnd, winX, winY, winW, winH, FALSE /*BOOL bRepaint*/);
875 if (!bRc)
876 {
877 DWORD winEr = GetLastError();
878 crWarning("stubSyncTrUpdateWindowCB: MoveWindow failed winEr(%d)", winEr);
879 }
880 }
881
882 if (pRegions->pRegions->fFlags.bSetVisibleRects)
883 {
884 hNewRgn = stubMakeRegionFromRects(pRegions->pRegions, pRegions->pRegions->fFlags.bSetViewRect ? 1 : 0);
885 }
886 }
887 else if (!pRegions->pRegions->fFlags.bHide)
888 {
889 Assert(pRegions->pRegions->fFlags.bAddHiddenRects);
890 hNewRgn = stubMakeRegionFromRects(pRegions->pRegions, 0);
891 }
892 else
893 {
894 Assert(pRegions->pRegions->fFlags.bAddHiddenRects);
895 hNewRgn = CreateRectRgn(pWindow->x, pWindow->y, pWindow->x + pWindow->width, pWindow->y + pWindow->height);
896 }
897
898 if (hNewRgn!=INVALID_HANDLE_VALUE)
899 {
900 if (pRegions->pRegions->fFlags.bSetVisibleRects)
901 {
902 HRGN hEmptyRgn = CreateRectRgn(0, 0, 0, 0);
903
904 if (hEmptyRgn!=INVALID_HANDLE_VALUE)
905 {
906 if (pWindow->hVisibleRegion==INVALID_HANDLE_VALUE || EqualRgn(pWindow->hVisibleRegion, hEmptyRgn))
907 {
908 pCbData->fSendUpdateMsg = true;
909 }
910
911 DeleteObject(hEmptyRgn);
912 }
913 else
914 {
915 crWarning("Failed to created empty region!");
916 }
917 }
918
919 OffsetRgn(hNewRgn, -pWindow->x, -pWindow->y);
920
921 if (pWindow->hVisibleRegion!=INVALID_HANDLE_VALUE)
922 {
923 CombineRgn(hNewRgn, pWindow->hVisibleRegion, hNewRgn,
924 pRegions->pRegions->fFlags.bAddHiddenRects ? RGN_DIFF:RGN_OR);
925
926 if (!EqualRgn(pWindow->hVisibleRegion, hNewRgn))
927 {
928 DeleteObject(pWindow->hVisibleRegion);
929 pWindow->hVisibleRegion = hNewRgn;
930 stubDispatchVisibleRegions(pWindow);
931 bChanged = true;
932 }
933 else
934 {
935 DeleteObject(hNewRgn);
936 }
937 }
938 else
939 {
940 if (pRegions->pRegions->fFlags.bSetVisibleRects)
941 {
942 pWindow->hVisibleRegion = hNewRgn;
943 stubDispatchVisibleRegions(pWindow);
944 bChanged = true;
945 }
946 }
947 }
948
949 if (bChanged)
950 {
951 stub.spu->dispatch_table.Flush();
952 }
953}
954# endif
955
956static void stubSyncTrCheckWindowsCB(unsigned long key, void *data1, void *data2)
957{
958 WindowInfo *pWindow = (WindowInfo *) data1;
959 (void) data2;
960
961 if (pWindow->type!=CHROMIUM || pWindow->spuWindow==0)
962 {
963 return;
964 }
965
966 stub.spu->dispatch_table.VBoxPackSetInjectID(pWindow->u32ClientID);
967
968 if (!stubSystemWindowExist(pWindow))
969 {
970#ifdef WINDOWS
971 crWindowDestroy((GLint)pWindow->hWnd);
972#else
973 crWindowDestroy((GLint)pWindow->drawable);
974#endif
975 /*No need to flush here as crWindowDestroy does it*/
976 return;
977 }
978
979#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
980 if (stub.bRunningUnderWDDM)
981 return;
982#endif
983 stubCheckWindowState(pWindow, GL_TRUE);
984}
985
986static DECLCALLBACK(int) stubSyncThreadProc(RTTHREAD ThreadSelf, void *pvUser)
987{
988#ifdef WINDOWS
989 MSG msg;
990# ifdef VBOX_WITH_WDDM
991 static VBOXDISPMP_CALLBACKS VBoxDispMpTstCallbacks = {NULL, NULL, NULL};
992 HMODULE hVBoxD3D = NULL;
993 VBOXCR_UPDATEWNDCB RegionsData;
994 HRESULT hr;
995# endif
996#endif
997
998 (void) pvUser;
999
1000 crDebug("Sync thread started");
1001#ifdef WINDOWS
1002 PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
1003# ifdef VBOX_WITH_WDDM
1004 hVBoxD3D = GetModuleHandle("VBoxDispD3D");
1005 if (hVBoxD3D)
1006 {
1007 hVBoxD3D = LoadLibrary("VBoxDispD3D");
1008 }
1009
1010 if (hVBoxD3D)
1011 {
1012 PFNVBOXDISPMP_GETCALLBACKS pfnVBoxDispMpGetCallbacks;
1013 pfnVBoxDispMpGetCallbacks = (PFNVBOXDISPMP_GETCALLBACKS)GetProcAddress(hVBoxD3D, TEXT("VBoxDispMpGetCallbacks"));
1014 if (pfnVBoxDispMpGetCallbacks)
1015 {
1016 hr = pfnVBoxDispMpGetCallbacks(VBOXDISPMP_VERSION, &VBoxDispMpTstCallbacks);
1017 if (S_OK==hr)
1018 {
1019 CRASSERT(VBoxDispMpTstCallbacks.pfnEnableEvents);
1020 CRASSERT(VBoxDispMpTstCallbacks.pfnDisableEvents);
1021 CRASSERT(VBoxDispMpTstCallbacks.pfnGetRegions);
1022
1023 hr = VBoxDispMpTstCallbacks.pfnEnableEvents();
1024 if (hr != S_OK)
1025 {
1026 crWarning("VBoxDispMpTstCallbacks.pfnEnableEvents failed");
1027 }
1028 else
1029 {
1030 crDebug("running with VBoxDispD3D");
1031 stub.trackWindowVisibleRgn = 0;
1032 stub.bRunningUnderWDDM = true;
1033 }
1034 }
1035 else
1036 {
1037 crWarning("VBoxDispMpGetCallbacks failed");
1038 }
1039 }
1040 }
1041# endif
1042#endif
1043
1044 crLockMutex(&stub.mutex);
1045 stub.spu->dispatch_table.VBoxPackSetInjectThread();
1046 crUnlockMutex(&stub.mutex);
1047
1048 RTThreadUserSignal(ThreadSelf);
1049
1050 while(!stub.bShutdownSyncThread)
1051 {
1052#ifdef WINDOWS
1053 if (!PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
1054 {
1055# ifdef VBOX_WITH_WDDM
1056 if (VBoxDispMpTstCallbacks.pfnGetRegions)
1057 {
1058 hr = VBoxDispMpTstCallbacks.pfnGetRegions(&RegionsData.Regions, 50);
1059 if (S_OK==hr)
1060 {
1061 RegionsData.fSendUpdateMsg = false;
1062# if 0
1063 uint32_t i;
1064 crDebug(">>>Regions for HWND(0x%x)>>>", RegionsData.Regions.hWnd);
1065 crDebug("Flags(0x%x)", RegionsData.Regions.pRegions->fFlags.Value);
1066 for (i = 0; i < RegionsData.Regions.pRegions->RectsInfo.cRects; ++i)
1067 {
1068 RECT *pRect = &RegionsData.Regions.pRegions->RectsInfo.aRects[i];
1069 crDebug("Rect(%d): left(%d), top(%d), right(%d), bottom(%d)", i, pRect->left, pRect->top, pRect->right, pRect->bottom);
1070 }
1071 crDebug("<<<<<");
1072# endif
1073 /*hacky way to make sure window wouldn't be deleted in another thread as we hold hashtable lock here*/
1074 crHashtableWalk(stub.windowTable, stubSyncTrUpdateWindowCB, &RegionsData);
1075 if (RegionsData.fSendUpdateMsg)
1076 {
1077 SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, 0, SMTO_NORMAL, 1000, NULL);
1078 }
1079 }
1080 else
1081 {
1082 if (WAIT_TIMEOUT!=hr)
1083 {
1084 crWarning("VBoxDispMpTstCallbacks.pfnGetRegions failed with 0x%x", hr);
1085 }
1086 crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
1087 }
1088 }
1089 else
1090# endif
1091 {
1092 crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
1093 RTThreadSleep(50);
1094 }
1095 }
1096 else
1097 {
1098 if (WM_QUIT==msg.message)
1099 {
1100 crDebug("Sync thread got WM_QUIT");
1101 break;
1102 }
1103 else
1104 {
1105 TranslateMessage(&msg);
1106 DispatchMessage(&msg);
1107 }
1108 }
1109#else
1110 crLockMutex(&stub.mutex);
1111 crHashtableWalk(stub.windowTable, stubSyncTrCheckWindowsCB, NULL);
1112 crUnlockMutex(&stub.mutex);
1113 RTThreadSleep(50);
1114#endif
1115 }
1116
1117#ifdef VBOX_WITH_WDDM
1118 if (VBoxDispMpTstCallbacks.pfnDisableEvents)
1119 {
1120 VBoxDispMpTstCallbacks.pfnDisableEvents();
1121 }
1122 if (hVBoxD3D)
1123 {
1124 FreeLibrary(hVBoxD3D);
1125 }
1126#endif
1127 crDebug("Sync thread stopped");
1128 return 0;
1129}
1130#endif
1131
1132/**
1133 * Do one-time initializations for the faker.
1134 * Returns TRUE on success, FALSE otherwise.
1135 */
1136static bool
1137stubInitLocked(void)
1138{
1139 /* Here is where we contact the mothership to find out what we're supposed
1140 * to be doing. Networking code in a DLL initializer. I sure hope this
1141 * works :)
1142 *
1143 * HOW can I pass the mothership address to this if I already know it?
1144 */
1145
1146 CRConnection *conn = NULL;
1147 char response[1024];
1148 char **spuchain;
1149 int num_spus;
1150 int *spu_ids;
1151 char **spu_names;
1152 const char *app_id;
1153 int i;
1154 int disable_sync = 0;
1155
1156 stubInitVars();
1157
1158 crGetProcName(response, 1024);
1159 crDebug("Stub launched for %s", response);
1160
1161#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
1162 /*@todo when vm boots with compiz turned on, new code causes hang in xcb_wait_for_reply in the sync thread
1163 * as at the start compiz runs our code under XGrabServer.
1164 */
1165 if (!crStrcmp(response, "compiz") || !crStrcmp(response, "compiz_real") || !crStrcmp(response, "compiz.real")
1166 || !crStrcmp(response, "compiz-bin"))
1167 {
1168 disable_sync = 1;
1169 }
1170#endif
1171
1172 /* @todo check if it'd be of any use on other than guests, no use for windows */
1173 app_id = crGetenv( "CR_APPLICATION_ID_NUMBER" );
1174
1175 crNetInit( NULL, NULL );
1176
1177#ifndef WINDOWS
1178 {
1179 CRNetServer ns;
1180
1181 ns.name = "vboxhgcm://host:0";
1182 ns.buffer_size = 1024;
1183 crNetServerConnect(&ns);
1184 if (!ns.conn)
1185 {
1186 crWarning("Failed to connect to host. Make sure 3D acceleration is enabled for this VM.");
1187 return false;
1188 }
1189 else
1190 {
1191 crNetFreeConnection(ns.conn);
1192 }
1193#if 0 && defined(CR_NEWWINTRACK)
1194 {
1195 Status st = XInitThreads();
1196 if (st==0)
1197 {
1198 crWarning("XInitThreads returned %i", (int)st);
1199 }
1200 }
1201#endif
1202 }
1203#endif
1204
1205 strcpy(response, "2 0 feedback 1 pack");
1206 spuchain = crStrSplit( response, " " );
1207 num_spus = crStrToInt( spuchain[0] );
1208 spu_ids = (int *) crAlloc( num_spus * sizeof( *spu_ids ) );
1209 spu_names = (char **) crAlloc( num_spus * sizeof( *spu_names ) );
1210 for (i = 0 ; i < num_spus ; i++)
1211 {
1212 spu_ids[i] = crStrToInt( spuchain[2*i+1] );
1213 spu_names[i] = crStrdup( spuchain[2*i+2] );
1214 crDebug( "SPU %d/%d: (%d) \"%s\"", i+1, num_spus, spu_ids[i], spu_names[i] );
1215 }
1216
1217 stubSetDefaultConfigurationOptions();
1218
1219 stub.spu = crSPULoadChain( num_spus, spu_ids, spu_names, stub.spu_dir, NULL );
1220
1221 crFree( spuchain );
1222 crFree( spu_ids );
1223 for (i = 0; i < num_spus; ++i)
1224 crFree(spu_names[i]);
1225 crFree( spu_names );
1226
1227 // spu chain load failed somewhere
1228 if (!stub.spu) {
1229 return false;
1230 }
1231
1232 crSPUInitDispatchTable( &glim );
1233
1234 /* This is unlikely to change -- We still want to initialize our dispatch
1235 * table with the functions of the first SPU in the chain. */
1236 stubInitSPUDispatch( stub.spu );
1237
1238 /* we need to plug one special stub function into the dispatch table */
1239 glim.GetChromiumParametervCR = stub_GetChromiumParametervCR;
1240
1241#if !defined(VBOX_NO_NATIVEGL)
1242 /* Load pointers to native OpenGL functions into stub.nativeDispatch */
1243 stubInitNativeDispatch();
1244#endif
1245
1246/*crDebug("stub init");
1247raise(SIGINT);*/
1248
1249#ifdef WINDOWS
1250# ifndef CR_NEWWINTRACK
1251 stubInstallWindowMessageHook();
1252# endif
1253#endif
1254
1255#ifdef CR_NEWWINTRACK
1256 {
1257 int rc;
1258
1259 RTR3InitDll(0);
1260
1261 if (!disable_sync)
1262 {
1263 crDebug("Starting sync thread");
1264
1265 rc = RTThreadCreate(&stub.hSyncThread, stubSyncThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "Sync");
1266 if (RT_FAILURE(rc))
1267 {
1268 crError("Failed to start sync thread! (%x)", rc);
1269 }
1270 RTThreadUserWait(stub.hSyncThread, 60 * 1000);
1271 RTThreadUserReset(stub.hSyncThread);
1272
1273 crDebug("Going on");
1274 }
1275 }
1276#endif
1277
1278#ifdef GLX
1279 stub.xshmSI.shmid = -1;
1280 stub.bShmInitFailed = GL_FALSE;
1281 stub.pGLXPixmapsHash = crAllocHashtable();
1282
1283 stub.bXExtensionsChecked = GL_FALSE;
1284 stub.bHaveXComposite = GL_FALSE;
1285 stub.bHaveXFixes = GL_FALSE;
1286#endif
1287
1288 return true;
1289}
1290
1291/**
1292 * Do one-time initializations for the faker.
1293 * Returns TRUE on success, FALSE otherwise.
1294 */
1295bool
1296stubInit(void)
1297{
1298 bool bRc = true;
1299 /* we need to serialize the initialization, otherwise racing is possible
1300 * for XPDM-based d3d when a d3d switcher is testing the gl lib in two or more threads
1301 * NOTE: the STUB_INIT_LOCK/UNLOCK is a NOP for non-win currently */
1302 STUB_INIT_LOCK();
1303 if (!stub_initialized)
1304 bRc = stub_initialized = stubInitLocked();
1305 STUB_INIT_UNLOCK();
1306 return bRc;
1307}
1308
1309/* Sigh -- we can't do initialization at load time, since Windows forbids
1310 * the loading of other libraries from DLLMain. */
1311
1312#ifdef LINUX
1313/* GCC crap
1314 *void (*stub_init_ptr)(void) __attribute__((section(".ctors"))) = __stubInit; */
1315#endif
1316
1317#ifdef WINDOWS
1318#define WIN32_LEAN_AND_MEAN
1319#include <windows.h>
1320
1321#ifdef DEBUG_misha
1322 /* debugging: this is to be able to catch first-chance notifications
1323 * for exceptions other than EXCEPTION_BREAKPOINT in kernel debugger */
1324# define VDBG_VEHANDLER
1325#endif
1326
1327#ifdef VDBG_VEHANDLER
1328static PVOID g_VBoxWDbgVEHandler = NULL;
1329LONG WINAPI vboxVDbgVectoredHandler(struct _EXCEPTION_POINTERS *pExceptionInfo)
1330{
1331 PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
1332 PCONTEXT pContextRecord = pExceptionInfo->ContextRecord;
1333 switch (pExceptionRecord->ExceptionCode)
1334 {
1335 case EXCEPTION_BREAKPOINT:
1336 case EXCEPTION_ACCESS_VIOLATION:
1337 case EXCEPTION_STACK_OVERFLOW:
1338 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1339 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
1340 case EXCEPTION_FLT_INVALID_OPERATION:
1341 case EXCEPTION_INT_DIVIDE_BY_ZERO:
1342 case EXCEPTION_ILLEGAL_INSTRUCTION:
1343 CRASSERT(0);
1344 break;
1345 default:
1346 break;
1347 }
1348 return EXCEPTION_CONTINUE_SEARCH;
1349}
1350
1351void vboxVDbgVEHandlerRegister()
1352{
1353 CRASSERT(!g_VBoxWDbgVEHandler);
1354 g_VBoxWDbgVEHandler = AddVectoredExceptionHandler(1,vboxVDbgVectoredHandler);
1355 CRASSERT(g_VBoxWDbgVEHandler);
1356}
1357
1358void vboxVDbgVEHandlerUnregister()
1359{
1360 ULONG uResult;
1361 if (g_VBoxWDbgVEHandler)
1362 {
1363 uResult = RemoveVectoredExceptionHandler(g_VBoxWDbgVEHandler);
1364 CRASSERT(uResult);
1365 g_VBoxWDbgVEHandler = NULL;
1366 }
1367}
1368#endif
1369
1370/* Windows crap */
1371BOOL WINAPI DllMain(HINSTANCE hDLLInst, DWORD fdwReason, LPVOID lpvReserved)
1372{
1373 (void) lpvReserved;
1374
1375 switch (fdwReason)
1376 {
1377 case DLL_PROCESS_ATTACH:
1378 {
1379 CRNetServer ns;
1380
1381#ifdef CHROMIUM_THREADSAFE
1382 crInitTSD(&g_stubCurrentContextTSD);
1383#endif
1384
1385 crInitMutex(&stub_init_mutex);
1386
1387#ifdef VDBG_VEHANDLER
1388 vboxVDbgVEHandlerRegister();
1389#endif
1390
1391 crNetInit(NULL, NULL);
1392 ns.name = "vboxhgcm://host:0";
1393 ns.buffer_size = 1024;
1394 crNetServerConnect(&ns);
1395 if (!ns.conn)
1396 {
1397 crDebug("Failed to connect to host (is guest 3d acceleration enabled?), aborting ICD load.");
1398#ifdef VDBG_VEHANDLER
1399 vboxVDbgVEHandlerUnregister();
1400#endif
1401 return FALSE;
1402 }
1403 else
1404 crNetFreeConnection(ns.conn);
1405
1406 break;
1407 }
1408
1409 case DLL_PROCESS_DETACH:
1410 {
1411 stubSPUSafeTearDown();
1412
1413#ifdef VDBG_VEHANDLER
1414 vboxVDbgVEHandlerUnregister();
1415#endif
1416
1417 break;
1418 }
1419
1420 case DLL_THREAD_ATTACH:
1421 {
1422#if 0
1423 if (stub_initialized)
1424 {
1425 CRASSERT(stub.spu);
1426 stub.spu->dispatch_table.VBoxPackAttachThread();
1427 }
1428#endif
1429 break;
1430 }
1431
1432 case DLL_THREAD_DETACH:
1433 {
1434 stubSetCurrentContext(NULL);
1435#if 0
1436 if (stub_initialized)
1437 {
1438 CRASSERT(stub.spu);
1439 stub.spu->dispatch_table.VBoxPackDetachThread();
1440 }
1441#endif
1442 break;
1443 }
1444
1445 default:
1446 break;
1447 }
1448
1449 return TRUE;
1450}
1451#endif
Note: See TracBrowser for help on using the repository browser.

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