GLuint PACKSPU_APIENTRY packspu_CreateProgram(void)
{
GET_THREAD(thread);
int writeback = 1;
GLuint return_val = (GLuint) 0;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError("packspu_CreateProgram doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!");
}
if (pack_spu.swap)
{
crPackCreateProgramSWAP(&return_val, &writeback);
}
else
{
crPackCreateProgram(&return_val, &writeback);
}
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
return_val = (GLuint) SWAP32(return_val);
}
crStateCreateProgram(return_val);
return return_val;
}
static GLint packspu_GetUniformLocationUncached(GLuint program, const char * name)
{
GET_THREAD(thread);
int writeback = 1;
GLint return_val = (GLint) 0;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError("packspu_GetUniformLocation doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!");
}
if (pack_spu.swap)
{
crPackGetUniformLocationSWAP(program, name, &return_val, &writeback);
}
else
{
crPackGetUniformLocation(program, name, &return_val, &writeback);
}
packspuFlush((void *) thread);
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
return_val = (GLint) SWAP32(return_val);
}
return return_val;
}
void PACKSPU_APIENTRY packspu_Finish( void )
{
GET_THREAD(thread);
GLint writeback = CRPACKSPU_IS_WDDM_CRHGSMI() ? 1 : pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network;
if (pack_spu.swap)
{
crPackFinishSWAP();
}
else
{
crPackFinish();
}
if (packspuSyncOnFlushes())
{
if (writeback)
{
if (pack_spu.swap)
crPackWritebackSWAP(&writeback);
else
crPackWriteback(&writeback);
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
}
}
}
GLuint PACKSPU_APIENTRY packspu_VBoxPackGetInjectID(GLint con)
{
GLuint ret;
crLockMutex(&_PackMutex);
{
ThreadInfo *thread = NULL;
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
if (!con)
{
crError("connection expected!");
return 0;
}
thread = GET_THREAD_VAL_ID(con);
}
else
{
CRASSERT(!con);
thread = GET_THREAD_VAL();
}
CRASSERT(thread && thread->netServer.conn && thread->netServer.conn->type==CR_VBOXHGCM);
ret = thread->netServer.conn->u32ClientID;
}
crUnlockMutex(&_PackMutex);
return ret;
}
void PACKSPU_APIENTRY packspu_GenTextures( GLsizei n, GLuint * textures )
{
GET_THREAD(thread);
int writeback = 1;
unsigned int i;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_GenTextures doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackGenTexturesSWAP( n, textures, &writeback );
}
else
{
crPackGenTextures( n, textures, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
if (pack_spu.swap)
{
for (i = 0 ; i < (unsigned int) n ; i++)
{
textures[i] = SWAP32(textures[i]);
}
}
crStateRegTextures(n, textures);
}
static SPUFunctions *
packSPUInit( int id, SPU *child, SPU *self,
unsigned int context_id,
unsigned int num_contexts )
{
ThreadInfo *thread;
(void) context_id;
(void) num_contexts;
(void) child;
(void) self;
#if defined(CHROMIUM_THREADSAFE) && !defined(WINDOWS)
crInitMutex(&_PackMutex);
#endif
#ifdef CHROMIUM_THREADSAFE
crInitTSD(&_PackerTSD);
crInitTSD(&_PackTSD);
#endif
pack_spu.id = id;
packspuSetVBoxConfiguration( child );
#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
pack_spu.bIsWDDMCrHgsmi = isVBoxWDDMCrHgsmi();
#endif
#ifdef VBOX_WITH_CRPACKSPU_DUMPER
memset(&pack_spu.Dumper, 0, sizeof (pack_spu.Dumper));
#endif
if (!CRPACKSPU_IS_WDDM_CRHGSMI())
{
/* This connects to the server, sets up the packer, etc. */
thread = packspuNewThread(
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
NULL
#endif
);
if (!thread) {
return NULL;
}
CRASSERT( thread == &(pack_spu.thread[0]) );
pack_spu.idxThreadInUse = 0;
}
packspuCreateFunctions();
crStateInit();
return &pack_functions;
}
static SPUFunctions *
packSPUInit( int id, SPU *child, SPU *self,
unsigned int context_id,
unsigned int num_contexts )
{
ThreadInfo *thread;
(void) context_id;
(void) num_contexts;
(void) child;
(void) self;
#if defined(CHROMIUM_THREADSAFE) && !defined(WINDOWS)
crInitMutex(&_PackMutex);
#endif
pack_spu.id = id;
packspuSetVBoxConfiguration( child );
#if defined(WINDOWS) && defined(VBOX_WITH_WDDM)
pack_spu.bRunningUnderWDDM = !!GetModuleHandle(VBOX_MODNAME_DISPD3D);
#endif
if (!CRPACKSPU_IS_WDDM_CRHGSMI())
{
/* This connects to the server, sets up the packer, etc. */
thread = packspuNewThread(
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
NULL
#endif
);
if (!thread) {
return NULL;
}
CRASSERT( thread == &(pack_spu.thread[0]) );
pack_spu.idxThreadInUse = 0;
}
packspuCreateFunctions();
crStateInit();
return &pack_functions;
}
void PACKSPU_APIENTRY packspu_GenRenderbuffersEXT( GLsizei n, GLuint * renderbuffers )
{
GET_THREAD(thread);
int writeback = 1;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_GenRenderbuffersEXT doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackGenRenderbuffersEXTSWAP( n, renderbuffers, &writeback );
}
else
{
crPackGenRenderbuffersEXT( n, renderbuffers, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
crStateRegRenderbuffers(n, renderbuffers);
}
void PACKSPU_APIENTRY packspu_VBoxWindowDestroy( GLint con, GLint window )
{
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
GET_THREAD(thread);
if (con)
{
CRPackContext * curPacker = crPackGetContext();
CRASSERT(!thread || !thread->bInjectThread);
thread = GET_THREAD_VAL_ID(con);
crPackSetContext(thread->packer);
crPackWindowDestroy(window);
if (curPacker != thread->packer)
crPackSetContext(curPacker);
return;
}
CRASSERT(thread);
CRASSERT(thread->bInjectThread);
}
crPackWindowDestroy(window);
}
GLboolean PACKSPU_APIENTRY
packspu_AreTexturesResident( GLsizei n, const GLuint * textures,
GLboolean * residences )
{
GET_THREAD(thread);
int writeback = 1;
GLboolean return_val = GL_TRUE;
GLsizei i;
if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
{
crError( "packspu_AreTexturesResident doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
}
if (pack_spu.swap)
{
crPackAreTexturesResidentSWAP( n, textures, residences, &return_val, &writeback );
}
else
{
crPackAreTexturesResident( n, textures, residences, &return_val, &writeback );
}
packspuFlush( (void *) thread );
CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
/* Since the Chromium packer/unpacker can't return both 'residences'
* and the function's return value, compute the return value here.
*/
for (i = 0; i < n; i++) {
if (!residences[i]) {
return_val = GL_FALSE;
break;
}
}
return return_val;
}
void PACKSPU_APIENTRY packspu_VBoxDetachThread()
{
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
crPackSetContext(NULL);
crSetTSD(&_PackTSD, NULL);
}
else
{
int i;
GET_THREAD(thread);
if (thread)
{
crLockMutex(&_PackMutex);
for (i=0; i<MAX_THREADS; ++i)
{
if (pack_spu.thread[i].inUse && thread==&pack_spu.thread[i]
&& thread->id==crThreadID() && thread->netServer.conn)
{
CRASSERT(pack_spu.numThreads>0);
packspuFlush((void *) thread);
if (pack_spu.thread[i].packer)
{
CR_LOCK_PACKER_CONTEXT(thread->packer);
crPackSetContext(NULL);
CR_UNLOCK_PACKER_CONTEXT(thread->packer);
crPackDeleteContext(pack_spu.thread[i].packer);
}
crNetFreeConnection(pack_spu.thread[i].netServer.conn);
pack_spu.numThreads--;
/*note can't shift the array here, because other threads have TLS references to array elements*/
crMemZero(&pack_spu.thread[i], sizeof(ThreadInfo));
crSetTSD(&_PackTSD, NULL);
if (i==pack_spu.idxThreadInUse)
{
for (i=0; i<MAX_THREADS; ++i)
{
if (pack_spu.thread[i].inUse)
{
pack_spu.idxThreadInUse=i;
break;
}
}
}
break;
}
}
for (i=0; i<CR_MAX_CONTEXTS; ++i)
{
ContextInfo *ctx = &pack_spu.context[i];
if (ctx->currentThread == thread)
{
CRASSERT(ctx->fAutoFlush);
ctx->currentThread = NULL;
}
}
crUnlockMutex(&_PackMutex);
}
}
crStateVBoxDetachThread();
}
GLint PACKSPU_APIENTRY packspu_VBoxPackSetInjectThread(struct VBOXUHGSMI *pHgsmi)
{
GLint con = 0;
int i;
GET_THREAD(thread);
CRASSERT(!thread);
crLockMutex(&_PackMutex);
{
CRASSERT(CRPACKSPU_IS_WDDM_CRHGSMI() || (pack_spu.numThreads>0));
CRASSERT(pack_spu.numThreads<MAX_THREADS);
for (i=0; i<MAX_THREADS; ++i)
{
if (!pack_spu.thread[i].inUse)
{
thread = &pack_spu.thread[i];
break;
}
}
CRASSERT(thread);
thread->inUse = GL_TRUE;
if (!CRPACKSPU_IS_WDDM_CRHGSMI())
thread->id = crThreadID();
else
thread->id = THREAD_OFFSET_MAGIC + i;
thread->currentContext = NULL;
thread->bInjectThread = GL_TRUE;
thread->netServer.name = crStrdup(pack_spu.name);
thread->netServer.buffer_size = 64 * 1024;
packspuConnectToServer(&(thread->netServer)
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, pHgsmi
#endif
);
CRASSERT(thread->netServer.conn);
CRASSERT(thread->packer == NULL);
thread->packer = crPackNewContext( pack_spu.swap );
CRASSERT(thread->packer);
crPackInitBuffer(&(thread->buffer), crNetAlloc(thread->netServer.conn),
thread->netServer.conn->buffer_size, thread->netServer.conn->mtu);
thread->buffer.canBarf = thread->netServer.conn->Barf ? GL_TRUE : GL_FALSE;
crPackSetBuffer( thread->packer, &thread->buffer );
crPackFlushFunc( thread->packer, packspuFlush );
crPackFlushArg( thread->packer, (void *) thread );
crPackSendHugeFunc( thread->packer, packspuHuge );
crPackSetContext( thread->packer );
crSetTSD(&_PackTSD, thread);
pack_spu.numThreads++;
}
crUnlockMutex(&_PackMutex);
if (CRPACKSPU_IS_WDDM_CRHGSMI())
{
CRASSERT(thread->id - THREAD_OFFSET_MAGIC < RT_ELEMENTS(pack_spu.thread)
&& GET_THREAD_VAL_ID(thread->id) == thread);
con = thread->id;
}
return con;
}
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;
}
