GLint PACKSPU_APIENTRY packspu_WindowCreate( const char *dpyName, GLint visBits ) { static int num_calls = 0; int writeback = pack_spu.thread[0].netServer.conn->actual_network; GLint return_val = (GLint) 0; WindowInfo *WInfo; /* WindowCreate is special - just like CreateContext. * GET_THREAD(thread) doesn't work as the thread won't have called * MakeCurrent yet, so we've got to use the first thread's packer * buffer. */ crPackSetContext( pack_spu.thread[0].packer ); if (pack_spu.swap) { crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback ); } else { crPackWindowCreate( dpyName, visBits, &return_val, &writeback ); } packspuFlush( &pack_spu.thread[0] ); if (!(pack_spu.thread[0].netServer.conn->actual_network)) { return num_calls++; } else { while (writeback) crNetRecv(); if (pack_spu.swap) { return_val = (GLint) SWAP32(return_val); } WInfo = (WindowInfo *) crAlloc(sizeof(WindowInfo)); WInfo->XWindow = 0; WInfo->visual = visBits; crHashtableAdd(pack_spu.XWindows,return_val,WInfo); return return_val; } }
GLint PACKSPU_APIENTRY packspu_WindowCreate( const char *dpyName, GLint visBits ) { GET_THREAD(thread); static int num_calls = 0; int writeback = pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network; GLint return_val = (GLint) 0; if (!thread) { thread = packspuNewThread( crThreadID() ); } CRASSERT(thread); CRASSERT(thread->packer); crPackSetContext(thread->packer); if (pack_spu.swap) { crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback ); } else { crPackWindowCreate( dpyName, visBits, &return_val, &writeback ); } packspuFlush(thread); if (!(thread->netServer.conn->actual_network)) { return num_calls++; } else { while (writeback) crNetRecv(); if (pack_spu.swap) { return_val = (GLint) SWAP32(return_val); } return return_val; } }
GLint PACKSPU_APIENTRY packspu_VBoxWindowCreate( GLint con, const char *dpyName, GLint visBits ) { GET_THREAD(thread); static int num_calls = 0; int writeback = CRPACKSPU_IS_WDDM_CRHGSMI() ? 1 : pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network; GLint return_val = (GLint) 0; ThreadInfo *curThread = thread; GLint retVal; if (CRPACKSPU_IS_WDDM_CRHGSMI()) { if (!con) { crError("connection expected!"); return 0; } thread = GET_THREAD_VAL_ID(con); } else { CRASSERT(!con); if (!thread) { thread = packspuNewThread( #if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST) NULL #endif ); } } CRASSERT(thread); CRASSERT(thread->packer); CRASSERT(crPackGetContext() == (curThread ? curThread->packer : NULL)); crPackSetContext(thread->packer); if (pack_spu.swap) { crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback ); } else { crPackWindowCreate( dpyName, visBits, &return_val, &writeback ); } packspuFlush(thread); if (!(thread->netServer.conn->actual_network)) { retVal = num_calls++; } else { CRPACKSPU_WRITEBACK_WAIT(thread, writeback); if (pack_spu.swap) { return_val = (GLint) SWAP32(return_val); } retVal = return_val; } if (CRPACKSPU_IS_WDDM_CRHGSMI()) { if (thread != curThread) { if (curThread) crPackSetContext(curThread->packer); else crPackSetContext(NULL); } } return retVal; }
GLint REPLICATESPU_APIENTRY replicatespu_WindowCreate( const char *dpyName, GLint visBits ) { unsigned int i; static GLint freeWinID = 400; WindowInfo *winInfo = (WindowInfo *) crCalloc(sizeof(WindowInfo)); GET_THREAD(thread); if (!winInfo) return -1; if (thread) replicatespuFlushAll( (void *) thread ); else thread = replicatespuNewThread( crThreadID() ); replicatespuFlushAll( (void *) thread ); crPackSetContext( thread->packer ); #ifdef CHROMIUM_THREADSAFE_notyet crLockMutex(&_ReplicateMutex); #endif for (i = 1; i < CR_MAX_REPLICANTS; i++) { if (IS_CONNECTED(replicate_spu.rserver[i].conn)) { int writeback = 1; int return_val = -1; if (replicate_spu.swap) crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback ); else crPackWindowCreate( dpyName, visBits, &return_val, &writeback ); replicatespuFlushOne(thread, i); while (writeback) crNetRecv(); if (replicate_spu.swap) return_val = (GLint) SWAP32(return_val); if (return_val < 0) crWarning("Replicate SPU: server %d returned window id -1", i); /* XXX temp */ crDebug("Replicate SPU: Window create, server %d returned %d", i, return_val); winInfo->id[i] = return_val; } else { winInfo->id[i] = -1; } } winInfo->visBits = visBits; winInfo->width = 0; winInfo->height = 0; winInfo->nativeWindow = 0; winInfo->viewable = GL_FALSE; crHashtableAdd(replicate_spu.windowTable, freeWinID, winInfo); #ifdef CHROMIUM_THREADSAFE_notyet crUnlockMutex(&_ReplicateMutex); #endif return freeWinID++; }
/** * Callback called by crHashTableWalk() below. * Used to create viewer-side windows for all the application windows. */ static void replicatespuReplicateWindow(unsigned long key, void *data1, void *data2) { ThreadInfo *thread = (ThreadInfo *) data2; WindowInfo *winInfo = (WindowInfo *) data1; GLint window = 0; GLint writeback = 1; Window root; int x, y; unsigned int width, height, bw, d; GLboolean unviewable = GL_FALSE; XWindowAttributes winAtt; CRASSERT(NewServerIndex >= 0); /* clear this flag, in case it was still set from an old connection */ winInfo->writeback[NewServerIndex] = 0; /** * Get application window's attributes */ old_xerror_handler = XSetErrorHandler( x11_error_handler ); XSync(replicate_spu.glx_display, 0); XGetGeometry(replicate_spu.glx_display, (Window)winInfo->nativeWindow, &root, &x, &y, &width, &height, &bw, &d ); XGetWindowAttributes(replicate_spu.glx_display, (Window) winInfo->nativeWindow, &winAtt); XSetErrorHandler( old_xerror_handler ); if (!caught_x11_error) { unviewable = (winAtt.map_state == IsUnviewable); } caught_x11_error = 0; /* * Create the server-side window */ if (replicate_spu.swap) crPackWindowCreateSWAP( replicate_spu.dpyName, winInfo->visBits, &window, &writeback); else crPackWindowCreate( replicate_spu.dpyName, winInfo->visBits, &window, &writeback); replicatespuFlushOne(thread, NewServerIndex); /* Get return value */ while (writeback) { crNetRecv(); } if (replicate_spu.swap) window = (GLint) SWAP32(window); /* save the server-side window ID */ winInfo->id[NewServerIndex] = window; crDebug("Replicate SPU: created server-side window %d", window); if (window < 0) { crWarning("Replicate SPU: failed to create server-side window"); return; } XVncChromiumMonitor(replicate_spu.glx_display, window, winInfo->nativeWindow); /* * If the app window is not visible, hide the server-side window too. */ if (unviewable) { if (replicate_spu.swap) crPackWindowShowSWAP( window, GL_FALSE ); else crPackWindowShow( window, GL_FALSE ); replicatespuFlushOne(thread, NewServerIndex); } }