static void vncspuNetLoggerInit(void) { #ifdef NETLOGGER if (vnc_spu.netlogger_url) { char *c; crDebug("VNC SPU: NetLogger URL: %s", vnc_spu.netlogger_url); #if 0 if (vnc_spu.netlogger_url) { /* XXX add unlink() wrapper to Cr util package */ unlink(vnc_spu.netlogger_url); } #endif NL_logger_module("vncspu", /* module name */ vnc_spu.netlogger_url, NL_LVL_DEBUG, /* logging level */ NL_TYPE_APP, /* target type */ "" /* terminator */ ); NL_info("vncspu", "spu.program.begin", ""); vnc_spu.hostname = crAlloc(101); crGetHostname(vnc_spu.hostname, 100); /* truncate at first dot */ if ((c = crStrchr(vnc_spu.hostname, '.'))) *c = 0; } else { crDebug("VNC SPU: NetLogger disabled"); } #endif }
/** * Find the index of the given enum value in the SPUOption's list of * possible enum values. * Return the enum index, or -1 if not found. */ int crSPUGetEnumIndex( const SPUOptions *options, const char *optName, const char *value ) { const SPUOptions *opt; const int valueLen = crStrlen(value); /* first, find the right option */ for (opt = options; opt->option; opt++) { if (crStrcmp(opt->option, optName) == 0) { char **values; int i; CRASSERT(opt->type == CR_ENUM); /* break into array of strings */ /* min string should be of form "'enum1', 'enum2', 'enum3', etc" */ values = crStrSplit(opt->min, ","); /* search the array */ for (i = 0; values[i]; i++) { /* find leading quote */ const char *e = crStrchr(values[i], '\''); CRASSERT(e); if (e) { /* test for match */ if (crStrncmp(value, e + 1, valueLen) == 0 && e[valueLen + 1] == '\'') { crFreeStrings(values); return i; } } } /* enum value not found! */ crFreeStrings(values); return -1; } } return -1; }
void CRUT_APIENTRY crutGetWindowParams( CRUTAPI *crut_api) { char response[8096]; if (!crut_api->mothershipConn) crError("Checking for Window Params but no connection!"); crMothershipGetCRUTServerParam( crut_api->mothershipConn, response, "window_geometry" ); crDebug("CRUTserver window geometry is %s", response); if (response[0] == '[') sscanf( response, "[ %i, %i, %i, %i ]", &crut_api->winX, &crut_api->winY, &crut_api->winWidth, &crut_api->winHeight ); else if (crStrchr(response, ',')) sscanf( response, "%i, %i, %i, %i", &crut_api->winX, &crut_api->winY, &crut_api->winWidth, &crut_api->winHeight ); else sscanf( response, "%i %i %i %i", &crut_api->winX, &crut_api->winY, &crut_api->winWidth, &crut_api->winHeight ); crDebug("CRUTserver window geometry is %s", response); crMothershipGetCRUTServerParam( crut_api->mothershipConn, response, "composite_mode" ); crut_api->compositeAlpha = crStrstr(response, "alpha") ? 1 : 0; crut_api->compositeDepth = crStrcmp(response, "depth") ? 1 : 0; }
DECLEXPORT(void) STATE_APIENTRY crStateGLSLProgramCacheUniforms(GLuint program, GLsizei maxcbData, GLsizei *cbData, GLvoid *pData) { CRGLSLProgram *pProgram = crStateGetProgramObj(program); GLint maxUniformLen, activeUniforms=0, fakeUniformsCount, i, j; char *pCurrent = pData; GLsizei cbWritten; if (!pProgram) { crWarning("Unknown program %d", program); return; } diff_api.GetProgramiv(pProgram->hwid, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformLen); diff_api.GetProgramiv(pProgram->hwid, GL_ACTIVE_UNIFORMS, &activeUniforms); *cbData = 0; cbWritten = sizeof(GLsizei); if (cbWritten>maxcbData) { crWarning("crStateGLSLProgramCacheUniforms: buffer too small"); return; } ((GLsizei*)pCurrent)[0] = activeUniforms; fakeUniformsCount = activeUniforms; pCurrent += sizeof(GLsizei); crDebug("crStateGLSLProgramCacheUniforms: %i active uniforms", activeUniforms); if (activeUniforms>0) { /*+8 to make sure our array uniforms with higher indices and [] will fit in as well*/ GLchar *name = (GLchar *) crAlloc(maxUniformLen+8); GLenum type; GLint size; GLsizei cbName; GLint location; if (!name) { crWarning("crStateGLSLProgramCacheUniforms: no memory"); return; } for (i=0; i<activeUniforms; ++i) { diff_api.GetActiveUniform(pProgram->hwid, i, maxUniformLen, &cbName, &size, &type, name); location = diff_api.GetUniformLocation(pProgram->hwid, name); if (!crStateGLSLProgramCacheOneUniform(location, cbName, name, &pCurrent, &cbWritten, maxcbData)) return; /* Only one active uniform variable will be reported for a uniform array by glGetActiveUniform, * so we insert fake elements for other array elements. */ if (size!=1) { char *pIndexStr = crStrchr(name, '['); GLint firstIndex=1; fakeUniformsCount += size; crDebug("crStateGLSLProgramCacheUniforms: expanding array uniform, size=%i", size); /*For array uniforms it's valid to query location of 1st element as both uniform and uniform[0]. *The name returned by glGetActiveUniform is driver dependent, *atleast it's with [0] on win/ati and without [0] on linux/nvidia. */ if (!pIndexStr) { pIndexStr = name+cbName; firstIndex=0; } else { cbName = pIndexStr-name; if (!crStateGLSLProgramCacheOneUniform(location, cbName, name, &pCurrent, &cbWritten, maxcbData)) return; } for (j=firstIndex; j<size; ++j) { sprintf(pIndexStr, "[%i]", j); cbName = crStrlen(name); location = diff_api.GetUniformLocation(pProgram->hwid, name); if (!crStateGLSLProgramCacheOneUniform(location, cbName, name, &pCurrent, &cbWritten, maxcbData)) return; } } } crFree(name); } if (fakeUniformsCount!=activeUniforms) { ((GLsizei*)pData)[0] = fakeUniformsCount; crDebug("FakeCount %i", fakeUniformsCount); } *cbData = cbWritten; CRASSERT((pCurrent-((char*)pData))==cbWritten); }
static void printspu_signal_handler(int signum) { /* If we receive a signal here, we should issue a marker. */ if (print_spu.fp != NULL && print_spu.marker_text != NULL) { char *text = print_spu.marker_text; char *nextVariable = crStrchr(text, '$'); /* Some of the variables will need this information */ struct timeval tv; struct timezone tz; struct tm *tm; gettimeofday(&tv, &tz); tm = localtime(&tv.tv_sec); /* While we still have variables, keep looking for more */ while (nextVariable != NULL) { /* Print the constant text up to the variable. */ if (nextVariable > text) { fprintf(print_spu.fp, "%.*s", (int) (nextVariable - text), text); text = nextVariable; } /* Make sure the '$' introduces a variable marker */ if (nextVariable[1] != '(') { /* Not a variable marker at all */ fprintf(print_spu.fp, "%c", '$'); text = nextVariable + 1; nextVariable = crStrchr(text, '$'); } else { /* Look for the last character */ char *endOfVariable = crStrchr(nextVariable, ')'); if (endOfVariable == NULL) { /* No end to the marker - spit it out as text */ text = nextVariable; nextVariable = NULL; } else { /* Compare it to the known variables */ /* Skip the initial '$(' and the final ')' */ char *variableName = nextVariable + 2; int variableLength = endOfVariable - nextVariable - 3 + 1; if (crStrncmp(variableName, "signal", variableLength) == 0) { fprintf(print_spu.fp, "%d", signum); } else if (crStrncmp(variableName, "date", variableLength) == 0) { fprintf(print_spu.fp, "%d-%02d-%02d", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); } else if (crStrncmp(variableName, "time", variableLength) == 0) { fprintf(print_spu.fp, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec); } else { /* Unknown variable. Print it verbatim. */ fprintf(print_spu.fp, "%.*s", (int) (endOfVariable - nextVariable + 1), nextVariable); } /* In all cases, advance our internal text pointer to after the endOfVariable indicator */ text = endOfVariable + 1; /* And look for the next variable */ nextVariable = crStrchr(text, '$'); } } /* end of processing a valid variable */ } /* end of processing a variable */ /* Print out any remaining text, even if it's an empty string, and the terminal newline */ fprintf(print_spu.fp, "%s\n", text); fflush(print_spu.fp); } /* Pass the signal through to the old signal handler, if any. */ if (print_spu.old_signal_handler != NULL) { (*print_spu.old_signal_handler)(signum); } }
void crServerGatherConfiguration(char *mothership) { CRMuralInfo *defaultMural; CRConnection *conn; char response[8096]; char **spuchain; int num_spus; int *spu_ids; char **spu_names; char *spu_dir = NULL; int i; /* Quadrics defaults */ int my_rank = 0; int low_context = CR_QUADRICS_DEFAULT_LOW_CONTEXT; int high_context = CR_QUADRICS_DEFAULT_HIGH_CONTEXT; char *low_node = "none"; char *high_node = "none"; unsigned char key[16]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; char hostname[1024]; char **clientchain, **clientlist; defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0); CRASSERT(defaultMural); setDefaults(); if (mothership) { crSetenv("CRMOTHERSHIP", mothership); } conn = crMothershipConnect(); if (!conn) { crError("Couldn't connect to the mothership, I have no idea what to do!"); } /* * Get my hostname */ if (crGetHostname(hostname, sizeof(hostname))) { crError("CRServer: Couldn't get my own hostname?"); } /* Identify ourselves to the mothership */ if (cr_server.vncMode) { /* we're running inside a vnc viewer */ if (!crMothershipSendString( conn, response, "vncserver %s", hostname )) crError( "Bad Mothership response: %s", response ); } else { crMothershipIdentifyServer(conn, response); } crDebug("CRServer: my SPU chain: %s", response); /* response will describe the SPU chain. * Example "2 5 wet 6 render" */ spuchain = crStrSplit(response, " "); num_spus = crStrToInt(spuchain[0]); spu_ids = (int *) crAlloc(num_spus * sizeof(*spu_ids)); spu_names = (char **) crAlloc((num_spus + 1) * sizeof(*spu_names)); for (i = 0; i < num_spus; i++) { spu_ids[i] = crStrToInt(spuchain[2 * i + 1]); spu_names[i] = crStrdup(spuchain[2 * i + 2]); crDebug("SPU %d/%d: (%d) \"%s\"", i + 1, num_spus, spu_ids[i], spu_names[i]); } spu_names[i] = NULL; /* * Gather configuration options. * NOTE: when you add new options, be sure to update the * mothership/tools/crtypes.py file's NetworkNode class's notion of * config options. * XXX Use the SPU option parser code here someday. */ if (crMothershipGetServerParam( conn, response, "spu_dir" ) && crStrlen(response) > 0) { spu_dir = crStrdup(response); } /* Quadrics networking stuff */ if (crMothershipGetRank(conn, response)) { my_rank = crStrToInt(response); } crNetSetRank(my_rank); if (crMothershipGetParam(conn, "low_context", response)) { low_context = crStrToInt(response); } if (crMothershipGetParam(conn, "high_context", response)) { high_context = crStrToInt(response); } crNetSetContextRange(low_context, high_context); if (crMothershipGetParam(conn, "low_node", response)) { low_node = crStrdup(response); } if (crMothershipGetParam(conn, "high_node", response)) { high_node = crStrdup(response); } crNetSetNodeRange(low_node, high_node); if (low_node) crFree(low_node); if (high_node) crFree(high_node); if (crMothershipGetParam(conn, "comm_key", response)) { unsigned int a; char **words, *found; /* remove the silly []'s */ while ((found = crStrchr(response, '[')) != NULL) *found = ' '; while ((found = crStrchr(response, ']')) != NULL) *found = ' '; words = crStrSplit(response, ","); a = 0; while (words[a] != NULL && a < sizeof(key)) { key[a]= crStrToInt(words[a]); a++; } crFreeStrings(words); } crNetSetKey(key,sizeof(key)); if (crMothershipGetServerParam(conn, response, "port")) { cr_server.tcpip_port = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "optimize_bucket")) { cr_server.optimizeBucket = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "local_tile_spec")) { cr_server.localTileSpec = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "lightning2")) { cr_server.useL2 = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "ignore_papi")) { cr_server.ignore_papi = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "overlap_blending")) { if (!crStrcmp(response, "blend")) cr_server.overlapBlending = 1; else if (!crStrcmp(response, "knockout")) cr_server.overlapBlending = 2; } if (crMothershipGetServerParam(conn, response, "overlap_levels")) { int a; char **levels, *found; /* remove the []'s */ while ((found = crStrchr(response, '['))) *found = ' '; while ((found = crStrchr(response, ']'))) *found = ' '; levels = crStrSplit(response, ","); a = 0; while (levels[a] != NULL) { crDebug("%d: %s", a, levels[a]); cr_server.num_overlap_intens++; a++; } cr_server.overlap_intens = (float *)crAlloc(cr_server.num_overlap_intens*sizeof(float)); for (a=0; a<cr_server.num_overlap_intens; a++) cr_server.overlap_intens[a] = crStrToFloat(levels[a]); crFreeStrings(levels); } if (crMothershipGetServerParam(conn, response, "only_swap_once")) { cr_server.only_swap_once = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "debug_barriers")) { cr_server.debug_barriers = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "shared_display_lists")) { cr_server.sharedDisplayLists = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "shared_texture_objects")) { cr_server.sharedTextureObjects = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "shared_programs")) { cr_server.sharedPrograms = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "shared_windows")) { cr_server.sharedWindows = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "unique_window_ids")) { cr_server.uniqueWindows = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "use_dmx")) { cr_server.useDMX = crStrToInt(response); } if (crMothershipGetServerParam(conn, response, "vertprog_projection_param")) { if (crIsDigit(response[0])) { cr_server.vpProjectionMatrixParameter = crStrToInt(response); } else { cr_server.vpProjectionMatrixVariable = crStrdup(response); } } if (crMothershipGetServerParam(conn, response, "stereo_view")) { if (crStrcmp(response, "left") == 0) cr_server.stereoView = 0x1; else if (crStrcmp(response, "right") == 0) cr_server.stereoView = 0x2; else if (crStrcmp(response, "both") == 0) cr_server.stereoView = 0x3; else cr_server.stereoView = 0x3; } if (crMothershipGetServerParam(conn, response, "view_matrix")) { crMatrixInitFromString(&cr_server.viewMatrix[0], response); cr_server.viewOverride = GL_TRUE; } if (crMothershipGetServerParam(conn, response, "right_view_matrix")) { crMatrixInitFromString(&cr_server.viewMatrix[1], response); cr_server.viewOverride = GL_TRUE; } if (crMothershipGetServerParam(conn, response, "projection_matrix")) { crMatrixInitFromString(&cr_server.projectionMatrix[0], response); cr_server.projectionOverride = GL_TRUE; } if (crMothershipGetServerParam(conn, response, "right_projection_matrix")) { crMatrixInitFromString(&cr_server.projectionMatrix[1], response); cr_server.projectionOverride = GL_TRUE; } if (crMothershipGetServerParam(conn, response, "exit_if_no_clients")) { cr_server.exitIfNoClients = crStrToInt(response); } crDebug("CRServer: my port number is %d", cr_server.tcpip_port); /* * Load the SPUs */ cr_server.head_spu = crSPULoadChain(num_spus, spu_ids, spu_names, spu_dir, &cr_server); /* Need to do this as early as possible */ /* XXX DMX get window size instead? */ cr_server.head_spu->dispatch_table.GetIntegerv(GL_VIEWPORT, (GLint *) defaultMural->underlyingDisplay); crFree(spu_ids); crFreeStrings(spu_names); crFreeStrings(spuchain); if (spu_dir) crFree(spu_dir); cr_server.mtu = crMothershipGetMTU( conn ); /* * Get a list of all the clients talking to me. */ if (cr_server.vncMode) { /* we're inside a vnc viewer */ if (!crMothershipSendString( conn, response, "getvncclient %s", hostname )) crError( "Bad Mothership response: %s", response ); } else { crMothershipGetClients(conn, response); } crDebug("CRServer: my clients: %s", response); /* * 'response' will now contain a number indicating the number of clients * of this server, followed by a comma-separated list of protocol/SPU ID * pairs. * Example: "3 tcpip 1,gm 2,via 10" */ clientchain = crStrSplitn(response, " ", 1); cr_server.numClients = crStrToInt(clientchain[0]); if (cr_server.numClients == 0) { crError("I have no clients! What's a poor server to do?"); } clientlist = crStrSplit(clientchain[1], ","); /* * Connect to initial set of clients. * Call crNetAcceptClient() for each client. * Also, look for a client that's _not_ using the file: protocol. */ for (i = 0; i < cr_server.numClients; i++) { CRClient *newClient = (CRClient *) crCalloc(sizeof(CRClient)); sscanf(clientlist[i], "%s %d", cr_server.protocol, &(newClient->spu_id)); newClient->conn = crNetAcceptClient(cr_server.protocol, NULL, cr_server.tcpip_port, cr_server.mtu, 1); newClient->currentCtx = cr_server.DummyContext; crServerAddToRunQueue(newClient); cr_server.clients[i] = newClient; } /* set default client and mural */ if (cr_server.numClients > 0) { cr_server.curClient = cr_server.clients[0]; cr_server.curClient->currentMural = defaultMural; cr_server.client_spu_id =cr_server.clients[0]->spu_id; } crFreeStrings(clientchain); crFreeStrings(clientlist); /* Ask the mothership for the tile info */ crServerGetTileInfoFromMothership(conn, defaultMural); if (cr_server.vncMode) { /* In vnc mode, we reset the mothership configuration so that it can be * used by subsequent OpenGL apps without having to spawn a new mothership * on a new port. */ crDebug("CRServer: Resetting mothership to initial state"); crMothershipReset(conn); } crMothershipDisconnect(conn); }