CRDLMContextState DLM_APIENTRY *crDLMNewContext(CRDLM *dlm)
{
CRDLMContextState *state;
/* Get a record for our own internal state structure */
state = (CRDLMContextState *)crAlloc(sizeof(CRDLMContextState));
if (!state) {
return NULL;
}
state->dlm = dlm;
state->currentListIdentifier = 0;
state->currentListInfo = NULL;
state->currentListMode = GL_FALSE;
state->listBase = 0;
/* Increment the use count of the DLM provided. This guarantees that
* the DLM won't be released until all the contexts have released it.
*/
crDLMUseDLM(dlm);
return state;
}
GLint REPLICATESPU_APIENTRY
replicatespu_CreateContext( const char *dpyName, GLint visual, GLint shareCtx )
{
static GLint freeCtxID = MAGIC_OFFSET;
char headspuname[10];
ContextInfo *context, *sharedContext = NULL;
unsigned int i;
if (shareCtx > 0) {
sharedContext = (ContextInfo *)
crHashtableSearch(replicate_spu.contextTable, shareCtx);
}
replicatespuFlushAll( &(replicate_spu.thread[0]) );
#ifdef CHROMIUM_THREADSAFE_notyet
crLockMutex(&_ReplicateMutex);
#endif
replicatespuStartVnc(dpyName);
/*
* Alloc new ContextInfo object
*/
context = (ContextInfo *) crCalloc(sizeof(ContextInfo));
if (!context) {
crWarning("Replicate SPU: Out of memory in CreateContext");
return -1;
}
/* Contexts that don't share display lists get their own
* display list managers. Contexts that do, share the
* display list managers of the contexts they're sharing
* with (man, some grammarian has to go over that and make
* it actually sound like English).
*/
if (sharedContext) {
context->displayListManager = sharedContext->displayListManager;
/* Let the DLM know that a second context is using the
* same display list manager, so it can manage when its
* resources are released.
*/
crDLMUseDLM(context->displayListManager);
}
else {
context->displayListManager = crDLMNewDLM(0, NULL);
if (!context->displayListManager) {
crWarning("Replicate SPU: could not initialize display list manager.");
}
}
/* Fill in the new context info */
if (sharedContext)
context->State = crStateCreateContext(NULL, visual, sharedContext->State);
else
context->State = crStateCreateContext(NULL, visual, NULL);
context->rserverCtx[0] = 1; /* not really used */
context->visBits = visual;
context->currentWindow = 0; /* not bound */
context->dlmState
= crDLMNewContext(context->displayListManager);
context->displayListMode = GL_FALSE; /* not compiling */
context->displayListIdentifier = 0;
context->shareCtx = shareCtx;
#if 0
/* Set the Current pointers now.... */
crStateSetCurrentPointers( context->State,
&(replicate_spu.thread[0].packer->current) );
#endif
for (i = 1; i < CR_MAX_REPLICANTS; i++) {
int r_writeback = 1, rserverCtx = -1;
int sharedServerCtx;
sharedServerCtx = sharedContext ? sharedContext->rserverCtx[i] : 0;
if (!IS_CONNECTED(replicate_spu.rserver[i].conn))
continue;
if (replicate_spu.swap)
crPackCreateContextSWAP( dpyName, visual, sharedServerCtx,
&rserverCtx, &r_writeback );
else
crPackCreateContext( dpyName, visual, sharedServerCtx,
&rserverCtx, &r_writeback );
/* Flush buffer and get return value */
replicatespuFlushOne( &(replicate_spu.thread[0]), i );
while (r_writeback)
crNetRecv();
if (replicate_spu.swap)
rserverCtx = (GLint) SWAP32(rserverCtx);
if (rserverCtx < 0) {
#ifdef CHROMIUM_THREADSAFE_notyet
crUnlockMutex(&_ReplicateMutex);
#endif
crWarning("Replicate SPU: CreateContext failed.");
return -1; /* failed */
}
context->rserverCtx[i] = rserverCtx;
}
if (!crStrcmp( headspuname, "nop" ))
replicate_spu.NOP = 0;
else
replicate_spu.NOP = 1;
#ifdef CHROMIUM_THREADSAFE_notyet
crUnlockMutex(&_ReplicateMutex);
#endif
crListPushBack(replicate_spu.contextList, (void *)freeCtxID);
crHashtableAdd(replicate_spu.contextTable, freeCtxID, context);
return freeCtxID++;
}
