/**
* This is a cut-down version of crSPULoad() from spuload.c. It just
* does enough to retreive the options list from the spu, but doesn't
* call any initialization functions from which the spu might try to
* connect to the mothership, etc.
*/
static SPU *
SPULoadLite( SPU *child, int id, const char *name, char *dir, void *server )
{
SPU *the_spu;
char *path;
CRASSERT( name != NULL );
the_spu = (SPU*)crAlloc( sizeof( *the_spu ) );
the_spu->id = id;
path = __findDLL( name, dir );
the_spu->dll = crDLLOpen( path, 0 /*resolveGlobal*/ );
the_spu->entry_point =
(SPULoadFunction) crDLLGetNoError( the_spu->dll, SPU_ENTRY_POINT_NAME );
if (!the_spu->entry_point)
{
crError( "Couldn't load the SPU entry point \"%s\" from SPU \"%s\"!",
SPU_ENTRY_POINT_NAME, name );
}
/* This basically calls the SPU's SPULoad() function */
if (!the_spu->entry_point( &(the_spu->name), &(the_spu->super_name),
&(the_spu->init), &(the_spu->self),
&(the_spu->cleanup),
&(the_spu->options),
&(the_spu->spu_flags)) )
{
crError( "I found the SPU \"%s\", but loading it failed!", name );
}
/* ... and that's all
*/
return the_spu;
}
//we're not going to change icdTable at runtime, so callback is unused
PICDTABLE APIENTRY DrvSetContext(HDC hdc, HGLRC hglrc, void *callback)
{
ContextInfo *pContext;
WindowInfo *pWindowInfo;
BOOL ret = false;
CR_DDI_PROLOGUE();
(void) (callback);
crHashtableLock(stub.windowTable);
crHashtableLock(stub.contextTable);
pContext = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
if (pContext)
{
pWindowInfo = stubGetWindowInfo(hdc);
if (pWindowInfo)
ret = stubMakeCurrent(pWindowInfo, pContext);
else
crError("no window info available.");
}
else
crError("No context found.");
crHashtableUnlock(stub.contextTable);
crHashtableUnlock(stub.windowTable);
return ret ? &icdTable : NULL;
}
static void
vboxApplyPatch(const char* psFuncName, void *pDst, const void *pSrc, unsigned long size)
{
void *alPatch;
int rv;
/* Get aligned start address we're going to patch*/
alPatch = (void*) ((uintptr_t)pDst & ~(uintptr_t)(PAGESIZE-1));
#ifndef VBOX_NO_MESA_PATCH_REPORTS
crDebug("MProtecting: %p, %li", alPatch, pDst-alPatch+size);
#endif
/* Get write access to mesa functions */
rv = RTMemProtect(alPatch, pDst-alPatch+size, RTMEM_PROT_READ|RTMEM_PROT_WRITE|RTMEM_PROT_EXEC);
if (RT_FAILURE(rv))
{
crError("mprotect failed with %x (%s)", rv, psFuncName);
}
#ifndef VBOX_NO_MESA_PATCH_REPORTS
crDebug("Writing %li bytes to %p from %p", size, pDst, pSrc);
#endif
crMemcpy(pDst, pSrc, size);
/*@todo Restore the protection, probably have to check what was it before us...*/
rv = RTMemProtect(alPatch, pDst-alPatch+size, RTMEM_PROT_READ|RTMEM_PROT_EXEC);
if (RT_FAILURE(rv))
{
crError("mprotect2 failed with %x (%s)", rv, psFuncName);
}
}
static void ARRAYSPU_APIENTRY arrayspu_DrawElements(GLenum mode, GLsizei count,
GLenum type, const GLvoid *indices)
{
int i;
GLubyte *p = (GLubyte *)indices;
#ifdef CR_ARB_vertex_buffer_object
CRBufferObject *elementsBuffer = array_spu.ctx->bufferobject.elementsBuffer;
#endif
if (count < 0)
{
crError("array_spu.self.DrawElements passed negative count: %d", count);
}
if (mode > GL_POLYGON)
{
crError("array_spu.self.DrawElements called with invalid mode: %d", mode);
}
if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT && type != GL_UNSIGNED_INT)
{
crError("array_spu.self.DrawElements called with invalid type: %d", type);
}
#ifdef CR_ARB_vertex_buffer_object
if (elementsBuffer->data)
{
p = (unsigned char *)(elementsBuffer->data) + (unsigned long)p;
}
#endif
array_spu.self.Begin(mode);
switch (type)
{
case GL_UNSIGNED_BYTE:
for (i=0; i<count; i++)
{
array_spu.self.ArrayElement((GLint) *p++);
}
break;
case GL_UNSIGNED_SHORT:
for (i=0; i<count; i++)
{
array_spu.self.ArrayElement((GLint) * (GLushort *) p);
p+=sizeof (GLushort);
}
break;
case GL_UNSIGNED_INT:
for (i=0; i<count; i++)
{
array_spu.self.ArrayElement((GLint) * (GLuint *) p);
p+=sizeof (GLuint);
}
break;
default:
crError( "this can't happen: array_spu.self.DrawElements" );
break;
}
array_spu.self.End();
}
/**
* Establish a connection with a server.
* \param server the server to connect to, in the form
* "protocol://servername:port" where the port specifier
* is optional and if the protocol is missing it is assumed
* to be "tcpip".
* \param default_port the port to connect to, if port not specified in the
* server URL string.
* \param mtu desired maximum transmission unit size (in bytes)
*/
CRConnection *
crNetConnectToServer( const char *server, unsigned short default_port, int mtu)
{
char hostname[4096], protocol[4096];
unsigned short port;
CRConnection *conn;
crDebug( "In crNetConnectToServer( \"%s\", port=%d, mtu=%d )",
server, default_port, mtu );
CRASSERT( cr_net.initialized );
if (mtu < CR_MINIMUM_MTU)
{
crError( "You tried to connect to server \"%s\" with an mtu of %d, "
"but the minimum MTU is %d", server, mtu, CR_MINIMUM_MTU );
}
/* Tear the URL apart into relevant portions. */
if ( !crParseURL( server, protocol, hostname, &port, default_port ) ) {
crError( "Malformed URL: \"%s\"", server );
}
crDebug( "Connecting to %s on port %d, with protocol %s",
hostname, port, protocol );
conn = (CRConnection *) crCalloc( sizeof(*conn) );
if (!conn)
return NULL;
/* init the non-zero fields */
conn->type = CR_NO_CONNECTION; /* we don't know yet */
conn->recv_credits = CR_INITIAL_RECV_CREDITS;
conn->hostname = crStrdup( hostname );
conn->port = port;
conn->mtu = mtu;
conn->buffer_size = mtu;
conn->endianness = crDetermineEndianness();
#ifdef CHROMIUM_THREADSAFE
crInitMutex(&conn->messageList.lock);
crInitCondition(&conn->messageList.nonEmpty);
#endif
/* now, just dispatch to the appropriate protocol's initialization functions. */
InitConnection(conn, protocol, mtu);
if (!crNetConnect( conn ))
{
crDebug("crNetConnectToServer() failed, freeing the connection");
crFree( conn );
return NULL;
}
crDebug( "Done connecting to %s (swapping=%d)", server, conn->swap );
#ifndef NDEBUG
crNetDumpConnectionInfo(conn);
#endif
return conn;
}
static void swapsyncConnect(void)
{
char hostname[4096], protocol[4096];
unsigned short port;
crNetInit(NULL, NULL);
if (!crParseURL( render_spu.swap_master_url, protocol, hostname,
&port, 9876))
crError( "Bad URL: %s", render_spu.swap_master_url );
if (render_spu.is_swap_master)
{
int a;
render_spu.swap_conns = (CRConnection **)crAlloc(
render_spu.num_swap_clients*sizeof(CRConnection *));
for (a=0; a<render_spu.num_swap_clients; a++)
{
render_spu.swap_conns[a] = crNetAcceptClient( protocol, hostname, port,
render_spu.swap_mtu, 1);
}
}
else
{
render_spu.swap_conns = (CRConnection **)crAlloc(sizeof(CRConnection *));
render_spu.swap_conns[0] = crNetConnectToServer(render_spu.swap_master_url,
port, render_spu.swap_mtu, 1);
if (!render_spu.swap_conns[0])
crError("Failed connection");
}
}
GLboolean
renderspu_SystemCreateContext(VisualInfo *visual, ContextInfo *context, ContextInfo *sharedContext)
{
AGLPixelFormat pix;
(void) sharedContext;
CRASSERT(visual);
CRASSERT(context);
context->visual = visual;
if( !renderspuChoosePixelFormat(context, &pix) ) {
crError( "Render SPU (renderspu_SystemCreateContext): Unable to create pixel format" );
return GL_FALSE;
}
context->context = render_spu.ws.aglCreateContext( pix, NULL );
renderspuDestroyPixelFormat( context, &pix );
if( !context->context ) {
crError( "Render SPU (renderspu_SystemCreateContext): Could not create rendering context" );
return GL_FALSE;
}
return GL_TRUE;
}
/**
* If an incoming message is not consumed by any of the connection's
* receive callbacks, this function will get called.
*
* XXX Make this function static???
*/
void
crNetDefaultRecv( CRConnection *conn, CRMessage *msg, unsigned int len )
{
switch (msg->header.type)
{
case CR_MESSAGE_GATHER:
break;
case CR_MESSAGE_MULTI_BODY:
case CR_MESSAGE_MULTI_TAIL:
crNetRecvMulti( conn, &(msg->multi), len );
return;
case CR_MESSAGE_FLOW_CONTROL:
crNetRecvFlowControl( conn, &(msg->flowControl), len );
return;
case CR_MESSAGE_OPCODES:
case CR_MESSAGE_OOB:
{
/*CRMessageOpcodes *ops = (CRMessageOpcodes *) msg;
*unsigned char *data_ptr = (unsigned char *) ops + sizeof( *ops) + ((ops->numOpcodes + 3 ) & ~0x03);
*crDebugOpcodes( stdout, data_ptr-1, ops->numOpcodes ); */
}
break;
case CR_MESSAGE_READ_PIXELS:
crError( "Can't handle read pixels" );
return;
case CR_MESSAGE_WRITEBACK:
crNetRecvWriteback( &(msg->writeback) );
return;
case CR_MESSAGE_READBACK:
crNetRecvReadback( &(msg->readback), len );
return;
case CR_MESSAGE_CRUT:
/* nothing */
break;
default:
/* We can end up here if anything strange happens in
* the GM layer. In particular, if the user tries to
* send unpinned memory over GM it gets sent as all
* 0xAA instead. This can happen when a program exits
* ungracefully, so the GM is still DMAing memory as
* it is disappearing out from under it. We can also
* end up here if somebody adds a message type, and
* doesn't put it in the above case block. That has
* an obvious fix. */
{
char string[128];
crBytesToString( string, sizeof(string), msg, len );
crError("crNetDefaultRecv: received a bad message: type=%d buf=[%s]\n"
"Did you add a new message type and forget to tell "
"crNetDefaultRecv() about it?\n",
msg->header.type, string );
}
}
/* If we make it this far, it's not a special message, so append it to
* the end of the connection's list of received messages.
*/
crEnqueueMessage(&conn->messageList, msg, len, conn);
}
SPU * crSPULoad( SPU *child, int id, char *name, char *dir, void *server )
{
SPU *the_spu;
char *path;
CRASSERT( name != NULL );
the_spu = (SPU*)crAlloc( sizeof( *the_spu ) );
the_spu->id = id;
the_spu->privatePtr = NULL;
path = __findDLL( name, dir );
the_spu->dll = crDLLOpen( path, 0/*resolveGlobal*/ );
the_spu->entry_point =
(SPULoadFunction) crDLLGetNoError( the_spu->dll, SPU_ENTRY_POINT_NAME );
if (!the_spu->entry_point)
{
crError( "Couldn't load the SPU entry point \"%s\" from SPU \"%s\"!",
SPU_ENTRY_POINT_NAME, name );
}
/* This basicall calls the SPU's SPULoad() function */
if (!the_spu->entry_point( &(the_spu->name), &(the_spu->super_name),
&(the_spu->init), &(the_spu->self),
&(the_spu->cleanup),
&(the_spu->options),
&(the_spu->spu_flags)) )
{
crError( "I found the SPU \"%s\", but loading it failed!", name );
}
if (crStrcmp(the_spu->name,"error"))
{
/* the default super/base class for an SPU is the error SPU */
if (the_spu->super_name == NULL)
{
the_spu->super_name = "error";
}
the_spu->superSPU = crSPULoad( child, id, the_spu->super_name, dir, server );
}
else
{
the_spu->superSPU = NULL;
}
crDebug("Initializing %s SPU", name);
the_spu->function_table = the_spu->init( id, child, the_spu, 0, 1 );
__buildDispatch( the_spu );
/*crDebug( "initializing dispatch table %p (for SPU %s)", (void*)&(the_spu->dispatch_table), name );*/
crSPUInitDispatchTable( &(the_spu->dispatch_table) );
/*crDebug( "Done initializing the dispatch table for SPU %s, calling the self function", name );*/
the_spu->dispatch_table.server = server;
the_spu->self( &(the_spu->dispatch_table) );
/*crDebug( "Done with the self function" );*/
return the_spu;
}
static bool
crDLMLoadListInstance(PSSMHANDLE pSSM, DLMListInfo *pListInfo, SPUDispatchTable *dispatchTable)
{
uint32_t cbInstance = 0;
DLMInstanceList *pInstance;
int32_t rc;
/* Get Display List item size. */
rc = SSMR3GetU32(pSSM, &cbInstance);
if (RT_SUCCESS(rc))
{
/* Allocate memory for the item, initialize it and put into the list. */
pInstance = crCalloc(cbInstance);
if (pInstance)
{
crMemset(pInstance, 0, cbInstance);
rc = SSMR3GetMem(pSSM, pInstance, cbInstance); AssertRCReturn(rc, rc);
if (RT_SUCCESS(rc))
{
pInstance->execute = crDLMGetExecuteRoutine(pInstance->iVBoxOpCode);
if (pInstance->execute)
{
pInstance->execute(pInstance, dispatchTable);
pInstance->next = NULL;
pInstance->stateNext = NULL;
pInstance->cbInstance = cbInstance;
pListInfo->numInstances++;
if (!pListInfo->first)
pListInfo->first = pInstance;
if (pListInfo->last)
pListInfo->last->next = pInstance;
pListInfo->last = pInstance;
return true;
}
else
crError("Restoring Display Lists: unknown list item (opcode=%u).", pInstance->iVBoxOpCode);
}
else
crError("Restoring Display Lists: can't read list element size.");
}
else
crError("Restoring Display Lists: not enough memory, aborting.");
}
else
crError("Restoring Display Lists: saved state file might be corrupted.");
return false;
}
static void crDLMSaveListsCb(unsigned long key, void *pData1, void *pData2)
{
DLMListInfo *pListInfo = (DLMListInfo*)pData1;
CRDLMSaveListsCbArg *pArg = (CRDLMSaveListsCbArg *)pData2;
PSSMHANDLE pSSM = pArg->pSSM;
DLMInstanceList *pInstance = pListInfo->first;
uint32_t cInstanceCheck = 0;
int32_t rc;
crDebug("Saving Display Lists: found ID=%u, numInstances=%d.", key, pListInfo->numInstances);
/* Store Display List length. */
rc = SSMR3PutU32(pSSM, pListInfo->numInstances);
if (RT_SUCCESS(rc))
{
/* Store Display List (guest) ID. */
rc = SSMR3PutU32(pSSM, (uint32_t)key);
if (RT_SUCCESS(rc))
{
/* Store each Display List item one by one. */
while (pInstance)
{
/* Let's count each list item and compare total number with pListInfo->numInstances.
* This is simple consistency check. */
cInstanceCheck++;
/* Store instance data size. */
rc = SSMR3PutU32(pSSM, (uint32_t)pInstance->cbInstance);
if (RT_SUCCESS(rc))
{
rc = SSMR3PutMem(pSSM, pInstance, pInstance->cbInstance);
if (RT_SUCCESS(rc))
{
/* We just stored all we need. Let's move on to the next list element. */
pInstance = pInstance->next;
continue;
}
}
crError("Saving Display Lists: can't store data.");
pArg->err = 1;
return;
}
if (cInstanceCheck == pListInfo->numInstances)
return;
crError("Saving Display Lists: list currupted.");
}
}
pArg->err = 1;
}
static void set_node( void *spu, const char *response )
{
(void) spu;
if (*response) {
binaryswap_spu.node_num = crStrToInt( response );
if(binaryswap_spu.node_num == -1)
crError( "FATAL: No node number specified for the binaryswap SPU?" );
}
else {
crError( "FATAL: No node number specified for the binaryswap SPU?" );
}
}
void PACK_APIENTRY
crPackDeleteRenderbuffersEXTSWAP(GLsizei n, const GLuint * renderbuffers)
{
(void) n;
(void) renderbuffers;
crError ("No swap version");
}
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;
}
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;
}
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;
}
static void
buildMenu(void)
{
/* XML parsing is done using expat */
int done = 1;
int len = strlen(crut_api.menuBuffer);
XML_Parser p = XML_ParserCreate(NULL);
if (! p)
{
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
XML_UseParserAsHandlerArg(p);
XML_SetElementHandler(p, start_hndl, end_hndl);
if (! XML_Parse(p, crut_api.menuBuffer, len, done))
{
crError("Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
}
buildGLUTMenu( crut_server.stack );
buildValueArray();
}
/**
* Send a set of commands on a connection. Pretty straightforward, just
* error checking, byte counting, and a dispatch to the protocol's
* "send" implementation.
* The payload will be prefixed by a 4-byte length field.
*
* \param conn the network connection
* \param bufp if non-null the buffer was provided by the network layer
* and will be returned to the 'free' pool after it's sent.
* \param start points to first byte to send, which must point to a CRMessage
* object!
* \param len number of bytes to send
*/
void
crNetSend(CRConnection *conn, void **bufp, const void *start, unsigned int len)
{
CRASSERT( conn );
CRASSERT( len > 0 );
if ( bufp ) {
/* The region from [start .. start + len - 1] must lie inside the
* buffer pointed to by *bufp.
*/
CRASSERT( start >= *bufp );
CRASSERT( (unsigned char *) start + len <=
(unsigned char *) *bufp + conn->buffer_size );
}
#ifndef NDEBUG
if ( conn->send_credits > CR_INITIAL_RECV_CREDITS )
{
crError( "crNetSend: send_credits=%u, looks like there is a leak (max=%u)",
conn->send_credits, CR_INITIAL_RECV_CREDITS );
}
#endif
conn->total_bytes_sent += len;
conn->Send( conn, bufp, start, len );
}
void packspuConnectToServer( CRNetServer *server
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, struct VBOXUHGSMI *pHgsmi
#endif
)
{
if (pack_spu.numThreads == 0) {
packspuFirstConnectToServer( server
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, pHgsmi
#endif
);
if (!server->conn) {
crError("packspuConnectToServer: no connection on first create!");
return;
}
}
else {
/* a new pthread */
crNetNewClient(server
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, pHgsmi
#endif
);
}
}
/* Send reset message to the mothership */
void crMothershipReset( CRConnection *conn )
{
if (!crMothershipSendString( conn, NULL, "reset" ))
{
crError( "Couldn't reset the server!" );
}
}
static const char* crGlslGetFsStringNoAlpha(CR_GLSL_CACHE *pCache, GLenum enmTexTarget)
{
if (!CrGlslIsSupported(pCache))
{
crWarning("CrGlslIsSupported is false");
return NULL;
}
if (pCache->iGlVersion >= CR_GLVERSION_COMPOSE(2, 1, 0))
{
if (enmTexTarget == GL_TEXTURE_2D)
return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, "", CR_GLSL_STR_2D);
else if (enmTexTarget == GL_TEXTURE_RECTANGLE_ARB)
return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, CR_GLSL_STR_EXT_TR, CR_GLSL_STR_2DRECT);
crWarning("invalid enmTexTarget %#x", enmTexTarget);
return NULL;
}
else if (pCache->iGlVersion >= CR_GLVERSION_COMPOSE(2, 0, 0))
{
if (enmTexTarget == GL_TEXTURE_2D)
return CR_GLSL_PATTERN_FS_NOALPHA("", "", CR_GLSL_STR_2D);
else if (enmTexTarget == GL_TEXTURE_RECTANGLE_ARB)
return CR_GLSL_PATTERN_FS_NOALPHA("", CR_GLSL_STR_EXT_TR, CR_GLSL_STR_2DRECT);
crWarning("invalid enmTexTarget %#x", enmTexTarget);
return NULL;
}
crError("crGlslGetFsStringNoAlpha: we should not be here!");
return NULL;
}
void
CRUT_APIENTRY
crutGetMenuXML( CRUTAPI *crut_api )
{
char response[8096];
if (!crut_api->mothershipConn)
crError("Checking for Menu XML but no connection!");
crMothershipGetParam( crut_api->mothershipConn, "crut_menu_xml", response );
if (crStrlen(response) < MENU_MAX_SIZE)
crMemcpy(crut_api->menuBuffer, response, crStrlen(response));
else
crError("Menu XML is too long for buffer");
}
GLboolean stubCtxCreate(ContextInfo *context)
{
/*
* Create a Chromium context.
*/
#if defined(GLX) || defined(DARWIN)
GLint spuShareCtx = context->share ? context->share->spuContext : 0;
#else
GLint spuShareCtx = 0;
#endif
GLint spuConnection = 0;
CRASSERT(stub.spu);
CRASSERT(stub.spu->dispatch_table.CreateContext);
context->type = CHROMIUM;
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
if (context->pHgsmi)
{
spuConnection = stub.spu->dispatch_table.VBoxConCreate(context->pHgsmi);
if (!spuConnection)
{
crError("VBoxConCreate failed");
return GL_FALSE;
}
context->spuConnection = spuConnection;
}
#endif
context->spuContext
= stub.spu->dispatch_table.VBoxCreateContext(spuConnection, context->dpyName,
context->visBits,
spuShareCtx);
return GL_TRUE;
}
void PACK_APIENTRY
crPackDeleteFramebuffersEXTSWAP(GLsizei n, const GLuint * framebuffers)
{
(void) n;
(void) framebuffers;
crError ("No swap version");
}
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 void
crSDPFree( CRConnection *conn, void *buf )
{
CRSDPBuffer *sdp_buffer = (CRSDPBuffer *) buf - 1;
CRASSERT( sdp_buffer->magic == CR_SDP_BUFFER_MAGIC );
conn->recv_credits += sdp_buffer->len;
switch ( sdp_buffer->kind )
{
case CRSDPMemory:
#ifdef CHROMIUM_THREADSAFE
crLockMutex(&cr_sdp.mutex);
#endif
if (cr_sdp.bufpool) {
/* pool may have been deallocated just a bit earlier in response
* to a SIGPIPE (Broken Pipe) signal.
*/
crBufferPoolPush( cr_sdp.bufpool, sdp_buffer, sdp_buffer->allocated );
}
#ifdef CHROMIUM_THREADSAFE
crUnlockMutex(&cr_sdp.mutex);
#endif
break;
case CRSDPMemoryBig:
crFree( sdp_buffer );
break;
default:
crError( "Weird buffer kind trying to free in crSDPFree: %d", sdp_buffer->kind );
}
}
/**
* Like crNetSend(), but the network layer is free to discard the data
* if something goes wrong. In particular, the UDP layer might discard
* the data in the event of transmission errors.
*/
void crNetBarf( CRConnection *conn, void **bufp,
const void *start, unsigned int len )
{
CRASSERT( conn );
CRASSERT( len > 0 );
CRASSERT( conn->Barf );
if ( bufp ) {
CRASSERT( start >= *bufp );
CRASSERT( (unsigned char *) start + len <=
(unsigned char *) *bufp + conn->buffer_size );
}
#ifndef NDEBUG
if ( conn->send_credits > CR_INITIAL_RECV_CREDITS )
{
crError( "crNetBarf: send_credits=%u, looks like there is a "
"leak (max=%u)", conn->send_credits,
CR_INITIAL_RECV_CREDITS );
}
#endif
conn->total_bytes_sent += len;
conn->Barf( conn, bufp, start, len );
}
bool DLM_APIENTRY
crDLMLoadState(CRDLM *dlm, PSSMHANDLE pSSM, SPUDispatchTable *dispatchTable)
{
uint32_t cLists = 0;
uint32_t i;
int32_t rc;
bool fSuccess = true;
/* Get number of Display Lists assigned to current DLM context. */
rc = SSMR3GetU32(pSSM, &cLists);
if (RT_SUCCESS(rc))
{
crDebug("Restoring Display Lists: %u lists to restore.", cLists);
for (i = 0; i < cLists; i++)
{
fSuccess = crDLMLoadList(dlm, pSSM, dispatchTable);
if (!fSuccess)
break;
}
}
else
crError("Restoring Display Lists: can't get number of lists.");
return fSuccess;
}
static void
crFileFree( CRConnection *conn, void *buf )
{
CRFileBuffer *file_buffer = (CRFileBuffer *) buf - 1;
CRASSERT( file_buffer->magic == CR_FILE_BUFFER_MAGIC );
conn->recv_credits += file_buffer->len;
switch ( file_buffer->kind )
{
case CRFileMemory:
#ifdef CHROMIUM_THREADSAFE
crLockMutex(&cr_file.mutex);
#endif
crBufferPoolPush( cr_file.bufpool, file_buffer, conn->buffer_size );
#ifdef CHROMIUM_THREADSAFE
crUnlockMutex(&cr_file.mutex);
#endif
break;
case CRFileMemoryBig:
crFree( file_buffer );
break;
default:
crError( "Weird buffer kind trying to free in crFileFree: %d", file_buffer->kind );
}
}
void stubConFlush(GLint con)
{
if (con)
stub.spu->dispatch_table.VBoxConFlush(con);
else
crError("stubConFlush called with null connection");
}
