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);
}
}
