void screenshotJPEG(char *filename, qbyte *screendata, int screenwidth, int screenheight) //input is rgb NOT rgba { qbyte *buffer; vfsfile_t *outfile; jpeg_error_mgr_wrapper jerr; struct jpeg_compress_struct cinfo; JSAMPROW row_pointer[1]; if (!(outfile = FS_OpenVFS(filename, "wb", FS_GAMEONLY))) { FS_CreatePath (filename, FS_GAME); if (!(outfile = FS_OpenVFS(filename, "wb", FS_GAMEONLY))) { Con_Printf("Error opening %s\n", filename); return; } } cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = jpeg_error_exit; if (setjmp(jerr.setjmp_buffer)) { jpeg_destroy_compress(&cinfo); VFS_CLOSE(outfile); FS_Remove(filename, FS_GAME); Con_Printf("Failed to create jpeg\n"); return; } jpeg_create_compress(&cinfo); buffer = screendata; jpeg_mem_dest(&cinfo, outfile); cinfo.image_width = screenwidth; cinfo.image_height = screenheight; cinfo.input_components = 3; cinfo.in_color_space = JCS_RGB; jpeg_set_defaults(&cinfo); jpeg_set_quality (&cinfo, 75/*bound(0, (int) gl_image_jpeg_quality_level.value, 100)*/, true); jpeg_start_compress(&cinfo, true); while (cinfo.next_scanline < cinfo.image_height) { *row_pointer = &buffer[(cinfo.image_height - cinfo.next_scanline - 1) * cinfo.image_width * 3]; jpeg_write_scanlines(&cinfo, row_pointer, 1); } jpeg_finish_compress(&cinfo); VFS_CLOSE(outfile); jpeg_destroy_compress(&cinfo); }
static int vorbis_callback_close (void *datasource) { vfsfile_t *f = (vfsfile_t *) datasource; VFS_CLOSE(f); return 0; }
void Rank_Refresh_f(void) { int i; if (!Rank_OpenRankings()) { Con_Printf("Failed to open rankings file.\n"); return; } for (i=0, host_client = svs.clients ; i<svs.allocated_client_slots ; i++, host_client++) { if (host_client->state != cs_spawned) continue; if (host_client->rankid) { rankstats_t rs = {0}; Rank_GetPlayerStats(host_client->rankid, &rs); rs.timeonserver += realtime - host_client->stats_started; host_client->stats_started = realtime; rs.kills += host_client->kills; rs.deaths += host_client->deaths; host_client->kills=0; host_client->deaths=0; Rank_SetPlayerStats(host_client->rankid, &rs); } } if (rankfile) { VFS_CLOSE(rankfile); rankfile = NULL; } }
// returns true, if there were some problems (like domain-name addresses) // which require the source to be dumped to file in corrected form qbool Update_Source_From_File(source_data *s, char *fname, server_data **servers, int *pserversn) { vfsfile_t *f; char line[2048]; qbool should_dump = false; //length = COM_FileOpenRead (fname, &f); f = FS_OpenVFS(fname, "rb", FS_ANY); if (f) { while (VFS_GETS(f, line, sizeof(line))) { netadr_t addr; if (!strchr(line, ':')) strlcat (line, ":27000", sizeof (line)); if (!NET_StringToAdr(line, &addr)) continue; servers[(*pserversn)++] = Create_Server2(addr); if (line[0] <= '0' || line[0] >= '9') should_dump = true; } VFS_CLOSE(f); } else { //Com_Printf ("Updating %15.15s failed: file not found\n", s->name); // ?????? should_dump = true; } return should_dump; }
void QTVList_Refresh_Cache(qbool force_redownload) { vfsfile_t *cache_file; sb_qtvlist_parse_state_t *sb_qtvparse; Sys_mkdir(va("%s/" QTVLIST_CACHE_FILE_DIR, com_basedir)); if (force_redownload || !(cache_file = QTVList_Cache_File_Open("rb")) || QTVList_Cache_File_Is_Old()) { sb_qtvlist_cache.status = QTVLIST_DOWNLOADING; QTVList_Cache_File_Download(); cache_file = QTVList_Cache_File_Open("rb"); if (!cache_file) { Com_Printf("Can't open QTV cache file\n"); return; } } sb_qtvlist_cache.status = QTVLIST_PARSING; sb_qtvparse = QTVList_Parse_Init(); QTVList_Process_Full_List(cache_file, sb_qtvparse); VFS_CLOSE(cache_file); sb_qtvlist_cache.sb_qtventries = sb_qtvparse->list; Q_free(sb_qtvparse); sb_qtvlist_cache.status = QTVLIST_RESOLVING; QTVList_Resolve_Hostnames(); }
static int QDECL VMEnumMods(const char *match, qofs_t size, time_t modtime, void *args, searchpathfuncs_t *spath) { char *check; char desc[1024]; int newlen; int desclen; qboolean foundone; vfsfile_t *f; newlen = strlen(match)+1; if (newlen <= 2) return true; //make sure match is a directory if (match[newlen-2] != '/') return true; if (!stricmp(match, "baseq3/")) return true; //we don't want baseq3. FIXME: should be any basedir, rather than hardcoded. foundone = false; Sys_EnumerateFiles(va("%s%s/", ((vmsearch_t *)args)->dir, match), "*.pk3", IfFound, &foundone, spath); if (foundone == false) return true; //we only count directories with a pk3 file Q_strncpyz(desc, match, sizeof(desc)); f = FS_OpenVFS(va("%sdescription.txt", match), "rb", FS_ROOT); if (f) { VFS_GETS(f, desc, sizeof(desc)); VFS_CLOSE(f); } desclen = strlen(desc)+1; if (newlen+desclen+5 > ((vmsearch_t *)args)->bufferleft) return false; //too many files for the buffer check = ((vmsearch_t *)args)->initialbuffer; while(check < ((vmsearch_t *)args)->buffer) { if (!stricmp(check, match)) return true; //we found this one already check += strlen(check)+1; check += strlen(check)+1; } memcpy(((vmsearch_t *)args)->buffer, match, newlen); ((vmsearch_t *)args)->buffer+=newlen; ((vmsearch_t *)args)->bufferleft-=newlen; memcpy(((vmsearch_t *)args)->buffer, desc, desclen); ((vmsearch_t *)args)->buffer+=desclen; ((vmsearch_t *)args)->bufferleft-=desclen; ((vmsearch_t *)args)->found++; return true; }
void Rank_Flush (void) //new game dir? { if (rankfile) { Rank_Refresh_f(); if (!rankfile) return; VFS_CLOSE(rankfile); rankfile=NULL; } }
// read variable content from file, return 0 if error xml_variable_t * XSD_Variable_Load(char *filename) { xml_variable_t *document; vfsfile_t *f; if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) { return NULL; } document = (xml_variable_t *) XSD_Variable_LoadFromHandle(f, VFS_GETLEN(f)); VFS_CLOSE(f); return document; }
static void FSGZIP_ClosePath(void *handle) { gzipfile_t *gzip = (gzipfile_t *)handle; if (--gzip->references > 0) return; //not yet time gzclose((gzFile)gzip->handle); VFS_CLOSE(gzip->raw); Q_free(gzip); }
qboolean Rank_OpenRankings(void) { char syspath[MAX_OSPATH]; size_t result; qboolean created; if (!rankfile) { if (!*rank_filename.string) { return false; } if (!FS_NativePath(rank_filename.string, FS_GAMEONLY, syspath, sizeof(syspath))) return false; rankfile = FS_OpenVFS(rank_filename.string, "r+b", FS_GAMEONLY); if (!rankfile) //hmm... try creating { rankfile = FS_OpenVFS(rank_filename.string, "w+b", FS_GAMEONLY); created = true; } else created = false; if (!rankfile) return false; //couldn't open file. memset(&rankfileheader, 0, sizeof(rankfileheader)); VFS_SEEK(rankfile, 0); result = VFS_READ(rankfile, &rankfileheader, sizeof(rankfileheader_t)); if (result != sizeof(rankfileheader_t)) Con_Printf("Rank_OpenRankings() fread: expected %lu, result was %u (%s)\n",(long unsigned int)sizeof(rankfileheader_t),(unsigned int)result, rank_filename.string); rankfileheader.version = swaplong(rankfileheader.version); rankfileheader.usedslots = swaplong(rankfileheader.usedslots); rankfileheader.leader = swaplong(rankfileheader.leader); rankfileheader.freeslot = swaplong(rankfileheader.freeslot); if (!created && (rankfileheader.version != RANKFILE_VERSION || rankfileheader.ident != RANKFILE_IDENT)) { Con_Printf("Rank file is version %i not %i\nEither delete the file or use an equivelent version of " FULLENGINENAME "\n", rankfileheader.version, RANKFILE_VERSION); VFS_CLOSE(rankfile); rankfile = NULL; return false; } return true; //success. } return true; //already open }
static void FSPAK_ClosePath(void *handle) { pack_t *pak = handle; pak->references--; if (pak->references > 0) return; //not free yet VFS_CLOSE (pak->handle); if (pak->files) Q_free(pak->files); Q_free(pak); }
//handle a map <mapname> command from the console or progs. void SV_Map_f (void) { char level[MAX_QPATH], expanded[MAX_QPATH]; #ifndef WITH_FTE_VFS FILE *f; #else vfsfile_t *f; #endif qbool devmap; if (Cmd_Argc() != 2) { Com_Printf ("%s <levelname> : continue game on a new level\n", Cmd_Argv(0)); return; } devmap = !strcasecmp (Cmd_Argv(0), "devmap"); strlcpy (level, Cmd_Argv(1), sizeof(level)); // check to make sure the level exists snprintf (expanded, sizeof(expanded), "maps/%s.bsp", level); #ifndef WITH_FTE_VFS if (FS_FOpenFile (expanded, &f) == -1) { Com_Printf ("Can't find %s\n", expanded); return; } fclose (f); #else if (!(f = FS_OpenVFS(expanded, "rb", FS_ANY))) { Com_Printf ("Can't find %s\n", expanded); return; } VFS_CLOSE(f); #endif // WITH_FTE_VFS #ifndef SERVERONLY if (!dedicated) CL_BeginLocalConnection (); #endif SV_BroadcastCommand ("changing\n"); SV_SendMessagesToAll (); SV_SpawnServer (level, devmap); SV_BroadcastCommand ("reconnect\n"); }
int make_topmost (int id) { // FILE *logfile; vfsfile_t *logfile; int i,j=0; mform_t tempform; char *temp; temp = va("Vr2_console.log"); memcpy(&tempform, &forms[id], sizeof(mform_t)); // logfile = fopen(va("%s/QMB.log", com_gamedir),"w"); logfile = FS_OpenVFS (temp, "wb", FS_GAME); for (i=id; i<MAX_FIELDS-1; i++) { if (forms[i+1].enabled) { if (logfile) { char *temp; // vfprintf(logfile, va("i: %d", i), ""); // vfprintf(logfile, va("copy: %d to %d", i+1, i), ""); temp = va("i: %d", i); VFS_WRITE(logfile, temp, strlen(temp)); temp = va("copy: %d to %d", i+1, i); VFS_WRITE(logfile, temp, strlen(temp)); } memcpy(&forms[i], &forms[i+1], sizeof(mform_t)); //forms[i] = forms[i+1]; } if ( (forms[i].enabled == false) && (j==0) ) j = i; } memcpy(&forms[j-1], &tempform, sizeof(mform_t)); form_focus = j-1; if (logfile) VFS_CLOSE(logfile); // fclose (logfile); form_focus = j-1; return j-1; }
// VFS-FIXME: This is probably the wrong thing to do // AddDir to playlist adds the whole directory, not just the current // file void Demo_AddArchiveToPlayList(const char *archive_path) { searchpathfuncs_t *funcs; vfsfile_t *vfs = NULL; void *archive_handle = NULL; vfs = FS_OpenVFS(archive_path, "rb", FS_NONE_OS); funcs = FS_FileNameToSearchFunctions(archive_path); if (!funcs) goto fail; archive_handle = funcs->OpenNew(vfs, archive_path); if (!archive_handle) goto fail; return; fail: if (archive_handle) funcs->ClosePath(archive_handle); // This closes vfs aswell else if (vfs) VFS_CLOSE(vfs); return; }
static void ResetConfigs(qbool resetall, qbool read_legacy_configs) { #ifndef WITH_FTE_VFS FILE *f; #else vfsfile_t *v; #endif ResetVariables(CVAR_SERVERINFO, !resetall); DeleteUserAliases(); DeleteUserVariables(); ResetBinds(); ResetPlusCommands(); ResetTeamplayCommands(); ResetMiscCommands(); if (read_legacy_configs) { Cbuf_AddText ("cl_warncmd 0\n"); Cbuf_AddText ("exec default.cfg\n"); #ifndef WITH_FTE_VFS if (FS_FOpenFile("autoexec.cfg", &f) != -1) { Cbuf_AddText ("exec autoexec.cfg\n"); fclose(f); } #else if ((v = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) { Cbuf_AddText ("exec autoexec.cfg\n"); VFS_CLOSE(v); } #endif Cbuf_AddText ("cl_warncmd 1\n"); } }
// read variable content from file, return 0 if error xml_variable_t * XSD_Variable_Load(char *filename) { xml_variable_t *document; #ifndef WITH_FTE_VFS FILE *f = NULL; int len; if ((len = FS_FOpenFile(filename, &f)) < 0) return NULL; document = (xml_variable_t *) XSD_Variable_LoadFromHandle(f, len); fclose(f); #else vfsfile_t *f; if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) { return NULL; } document = (xml_variable_t *) XSD_Variable_LoadFromHandle(f, VFS_GETLEN(f)); VFS_CLOSE(f); #endif return document; }
static void ResetConfigs(qbool resetall, qbool read_legacy_configs) { vfsfile_t *v; ResetVariables(CVAR_SERVERINFO, !resetall); DeleteUserAliases(); DeleteUserVariables(); ResetBinds(); ResetPlusCommands(); ResetTeamplayCommands(); ResetMiscCommands(); if (read_legacy_configs) { Cbuf_AddText ("cl_warncmd 0\n"); if ((v = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) { Cbuf_AddText ("exec autoexec.cfg\n"); VFS_CLOSE(v); } Cbuf_AddText ("cl_warncmd 1\n"); } }
static void Log_Stop(void) { int read; vfserrno_t err; char buf[1024]; int size; if (!Log_IsLogging()) return; size = (int) VFS_TELL(memlogfile); VFS_SEEK(memlogfile, 0, SEEK_SET); while (size > 0 && (read = VFS_READ(memlogfile, buf, 1024, &err))) { fwrite(buf, 1, min(read, size), logfile); size -= read; } VFS_CLOSE(memlogfile); fclose(logfile); logfile = NULL; memlogfile = NULL; }
/* =============== Host_Loadgame_f =============== */ void Host_Loadgame_f (void) { char name[MAX_OSPATH], temp[MAX_OSPATH]; vfsfile_t *f; char mapname[MAX_QPATH]; float time, tfloat; char str[32768], *start, *c; int i, r, len, n; edict_t *ent; int entnum; int version; float spawn_parms[NUM_SPAWN_PARMS]; if (cmd_source != src_command) return; if (Cmd_Argc() != 2) { Con_Printf ("load <savename> : load a game\n"); return; } cls.demonum = -1; // stop demo loop in case this fails // sprintf (name, "%s", Cmd_Argv(1)); strcpy (name, Cmd_Argv(1)); COM_DefaultExtension (name, ".sav"); // we can't call SCR_BeginLoadingPlaque, because too much stack space has // been used. The menu calls it before stuffing loadgame command // SCR_BeginLoadingPlaque (); Con_Printf ("Loading game from %s...\n", name); // f = fopen (name, "r"); f = FS_OpenVFS(name, "rb", FS_GAMEONLY); if (!f) { Con_Printf ("ERROR: couldn't open.\n"); return; } // fscanf (f, "%i\n", &version); version = atoi(VFS_GETS(f, name, sizeof(name))); if (version != SAVEGAME_VERSION) { // fclose (f); Con_Printf ("Savegame is version %i, not %i\n", version, SAVEGAME_VERSION); VFS_CLOSE (f); return; } // fscanf (f, "%s\n", str); VFS_GETS(f, str, sizeof(str)); for (i=0 ; i<NUM_SPAWN_PARMS ; i++) spawn_parms[i] = atof(VFS_GETS(f, temp, sizeof(temp))); // fscanf (f, "%f\n", &spawn_parms[i]); // this silliness is so we can load 1.06 save files, which have float skill values // fscanf (f, "%f\n", &tfloat); tfloat = atof(VFS_GETS(f, temp, sizeof(temp))); // temp buf current_skill = (int)(tfloat + 0.1); Cvar_SetValue ("skill", (float)current_skill); #ifdef QUAKE2 Cvar_SetValue ("deathmatch", 0); Cvar_SetValue ("coop", 0); Cvar_SetValue ("teamplay", 0); #endif // fscanf (f, "%s\n",mapname); // fscanf (f, "%f\n",&time); VFS_GETS(f, mapname, sizeof(mapname)); for (c = mapname+strlen(mapname)-1; c>=mapname && (*c == '\n' || *c == '\r'); *c--='\0'); time = atof(VFS_GETS(f, temp, sizeof(temp))); CL_Disconnect_f (); allowcheats = sv_cheats.value != 0; // sv_cheats // if the video isn't initialized already, it needs to be Host_InitVideo(); #ifdef QUAKE2 SV_SpawnServer (mapname, NULL); #else SV_SpawnServer (mapname); #endif if (!sv.active) { Con_Printf ("Couldn't load map\n"); VFS_CLOSE (f); return; } sv.paused = true; // pause until all clients connect sv.loadgame = true; // load the light styles for (i=0 ; i<MAX_LIGHTSTYLES ; i++) { // fscanf (f, "%s\n", str); VFS_GETS(f, str, sizeof(str)); // sv.lightstyles[i] = Hunk_Alloc (strlen(str)+1); // this is no longer necessary, changed to straight array for (c = str+strlen(str)-1; c>=str && (*c == '\n' || *c == '\r'); *c--='\0'); strcpy (sv.lightstyles[i], str); } // load the edicts out of the savegame file entnum = -1; // -1 is the globals len = VFS_GETLEN(f); n = 0; // while (!feof(f)) for(;;) { for (i=0 ; i<sizeof(str)-1 ; i++) { // r = fgetc (f); r = VFS_GETC(f); if (r == -1 || !r) break; str[i] = r; if (r == '}') { i++; break; } } if (r == -1 || !r) break; if (i == sizeof(str)-1) Sys_Error ("Loadgame buffer overflow"); str[i] = 0; start = str; start = COM_Parse(str); if (!com_token[0]) break; // end of file if (strcmp(com_token,"{")) Sys_Error ("First token isn't a brace"); if (entnum == -1) { // parse the global vars ED_ParseGlobals (start); } else { // parse an edict ent = EDICT_NUM(entnum); memset (&ent->v, 0, progs->entityfields * 4); ent->free = false; ED_ParseEdict (start, ent); // link it into the bsp tree if (!ent->free) SV_LinkEdict (ent, false); } entnum++; n++; } sv.num_edicts = entnum; sv.time = time; // fclose (f); VFS_CLOSE (f); for (i=0 ; i<NUM_SPAWN_PARMS ; i++) svs.clients->spawn_parms[i] = spawn_parms[i]; if (cls.state != ca_dedicated) { CL_EstablishConnection ("local"); Host_Reconnect_f (); } }
/* =============== Host_Savegame_f =============== */ void Host_Savegame_f (void) { char name[256]; vfsfile_t *f; int i; char comment[SAVEGAME_COMMENT_LENGTH+1]; char *temp; if (cmd_source != src_command) return; if (!sv.active) { Con_Printf ("Not playing a local game.\n"); return; } if (cl.intermission) { Con_Printf ("Can't save in intermission.\n"); return; } if (svs.maxclients != 1) { Con_Printf ("Can't save multiplayer games.\n"); return; } if (Cmd_Argc() != 2) { Con_Printf ("save <savename> : save a game\n"); return; } if (strstr(Cmd_Argv(1), "..")) { Con_Printf ("Relative pathnames are not allowed.\n"); return; } for (i=0 ; i<svs.maxclients ; i++) { if (svs.clients[i].active && (svs.clients[i].edict->v.health <= 0) ) { Con_Printf ("Can't savegame with a dead player\n"); return; } } // sprintf (name, "%s/%s", com_gamedir, Cmd_Argv(1)); strcpy(name, Cmd_Argv(1)); COM_DefaultExtension (name, ".sav"); Con_Printf ("Saving game to %s...\n", name); // f = fopen (name, "w"); f = FS_OpenVFS(name, "wb", FS_GAMEONLY); if (!f) { Con_Printf ("ERROR: couldn't open.\n"); return; } // fprintf (f, "%i\n", SAVEGAME_VERSION); temp = va("%i\n", SAVEGAME_VERSION); VFS_WRITE(f, temp, strlen(temp)); Host_SavegameComment (comment); // fprintf (f, "%s\n", comment); temp = va("%s\n", comment); VFS_WRITE(f, temp, strlen(temp)); for (i=0 ; i<NUM_SPAWN_PARMS ; i++) { // fprintf (f, "%f\n", svs.clients->spawn_parms[i]); temp = va("%f\n", svs.clients->spawn_parms[i]); VFS_WRITE(f, temp, strlen(temp)); } // fprintf (f, "%d\n", current_skill); temp = va("%d\n", current_skill); VFS_WRITE(f, temp, strlen(temp)); // fprintf (f, "%s\n", sv.name); temp = va("%s\n", sv.name); VFS_WRITE(f, temp, strlen(temp)); // fprintf (f, "%f\n",sv.time); temp = va("%f\n", sv.time); VFS_WRITE(f, temp, strlen(temp)); // write the light styles for (i=0 ; i<MAX_LIGHTSTYLES ; i++) { if (sv.lightstyles[i][0]) temp = va("%s\n", sv.lightstyles[i]); // fprintf (f, "%s\n", sv.lightstyles[i]); else temp = va("m\n"); // fprintf (f,"m\n"); VFS_WRITE(f, temp, strlen(temp)); } ED_WriteGlobals (f); for (i=0 ; i<sv.num_edicts ; i++) { ED_Write (f, EDICT_NUM(i)); // fflush (f); } // fclose (f); VFS_CLOSE(f); Con_Printf ("done.\n"); }
void Reload_Sources(void) { int i; vfsfile_t *f; char ln[2048]; source_data *s; SB_ServerList_Lock(); for (i=0; i < sourcesn; i++) Delete_Source(sources[i]); sourcesn = 0; // create dummy unbound source sources[0] = Create_Source(); sources[0]->type = type_dummy; strlcpy (sources[0]->name, "Unbound", sizeof (sources[0]->name)); sources[0]->servers = (server_data **) Q_malloc(MAX_UNBOUND*sizeof(server_data *)); sources[0]->serversn = 0; sources[0]->servers_allocated = MAX_UNBOUND; sourcesn = 1; f = FS_OpenVFS(SOURCES_LIST_FILENAME, "rb", FS_ANY); if (!f) { //Com_Printf ("sources file not found: %s\n", SOURCES_PATH); SB_ServerList_Unlock(); return; } s = Create_Source(); while (VFS_GETS(f, ln, sizeof(ln))) { char line[2048]; char *p, *q; if (sscanf(ln, "%[ -~ ]s", line) != 1) { continue; } p = next_nonspace(line); if (*p == '/') continue; // comment q = next_space(p); if (!strncmp(p, "master", q-p)) { s->type = type_master; } else if (!strncmp(p, "file", q-p)) { s->type = type_file; } else if (!strncmp(p, "url", q-p)) { s->type = type_url; } else { continue; } p = next_nonspace(q); q = (*p == '\"') ? next_quote(++p) : next_space(p); if (q-p <= 0) continue; strlcpy (s->name, p, min(q-p+1, MAX_SOURCE_NAME+1)); p = next_nonspace(q+1); q = next_space(p); *q = 0; if (q-p <= 0) continue; if (s->type == type_file) strlcpy (s->address.filename, p, sizeof (s->address.filename)); else if (s->type == type_url) strlcpy (s->address.url, p, sizeof (s->address.url)); else if (!NET_StringToAdr(p, &(s->address.address))) continue; sources[sourcesn] = Create_Source(); i = sources[sourcesn]->unique; memcpy(sources[sourcesn], s, sizeof(source_data)); sources[sourcesn]->unique = i; sourcesn++; } Delete_Source(s); VFS_CLOSE(f); //Com_Printf("Read %d sources for Server Browser\n", sourcesn); // update all file sources for (i=0; i < sourcesn; i++) if (sources[i]->type == type_file) Update_Source(sources[i]); else if (sources[i]->type == type_master || sources[i]->type == type_url) Precache_Source(sources[i]); rebuild_servers_list = 1; resort_sources = 1; SB_ServerList_Unlock(); }
//Find and execute sound triggers. A sound trigger must be terminated by either a CR or LF. //Returns true if a sound was found and played qbool TP_CheckSoundTrigger (wchar *wstr) { char *str; int i, j, start, length; char soundname[MAX_OSPATH]; #ifndef WITH_FTE_VFS FILE *f; #else vfsfile_t *v; #endif str = wcs2str (wstr); if (!*str) return false; if (!tp_soundtrigger.string[0]) return false; for (i = strlen (str) - 1; i; i--) { if (str[i] != 0x0A && str[i] != 0x0D) continue; for (j = i - 1; j >= 0; j--) { // quick check for chars that cannot be used // as sound triggers but might be part of a file name if (isalnum((unsigned char)str[j])) continue; // file name or chat if (strchr(tp_soundtrigger.string, str[j])) { // this might be a sound trigger start = j + 1; length = i - start; if (!length) break; if (length >= MAX_QPATH) break; strlcpy (soundname, str + start, length + 1); if (strstr(soundname, "..")) break; // no thank you // clean up the message strcpy (str + j, str + i); qwcscpy (wstr + j, wstr + i); if (!snd_initialized) return false; COM_DefaultExtension (soundname, ".wav"); // make sure we have it on disk (FIXME) #ifndef WITH_FTE_VFS FS_FOpenFile (va("sound/%s", soundname), &f); if (!f) return false; fclose (f); #else if (!(v = FS_OpenVFS(va("sound/%s", soundname), "rb", FS_ANY))) return false; VFS_CLOSE(v); #endif // now play the sound S_LocalSound (soundname); return true; } if (str[j] == '\\') str[j] = '/'; if (str[j] <= ' ' || strchr("\"&'*,:;<>?\\|\x7f", str[j])) break; // we don't allow these in a file name } } return false; }
void Host_Init (int argc, char **argv, int default_memsize) { vfsfile_t *vf; cvar_t *v; char cfg[MAX_PATH] = {0}; int i; char *cfg_name; COM_InitArgv (argc, argv); COM_StoreOriginalCmdline(argc, argv); #ifdef WITH_DP_MEM Memory2_Init (); #endif Host_InitMemory (default_memsize); #ifdef WITH_TCL // interpreter should be initialized // before any cvar definitions TCL_InterpInit (); #endif Cbuf_Init (); Cmd_Init (); Cvar_Init (); COM_Init (); Key_Init (); #ifdef WITH_DP_MEM Memory2_Init_Commands (); #endif Cache_Init_Commands (); FS_InitFilesystem (); NET_Init (); Commands_For_Configs_Init (); ConfigManager_Init(); ResetBinds(); i = COM_CheckParm("+cfg_load"); if (i && (i + 1 < COM_Argc())) { cfg_name = COM_Argv(i + 1); } else { cfg_name = MAIN_CONFIG_FILENAME; } snprintf(cfg, sizeof(cfg), "%s", cfg_name); COM_ForceExtensionEx (cfg, ".cfg", sizeof (cfg)); Cbuf_AddText(va("cfg_load %s\n", cfg)); Cbuf_Execute(); Cbuf_AddEarlyCommands (); Cbuf_Execute (); Con_Init (); NET_InitClient (); Netchan_Init (); #if (!defined WITH_PNG_STATIC || !defined WITH_JPEG_STATIC || defined WITH_MP3_PLAYER) QLib_Init(); #endif Sys_Init (); CM_Init (); PM_Init (); Mod_Init (); SV_Init (); CL_Init (); Cvar_CleanUpTempVars (); SYSINFO_Init(); #ifdef WITH_TCL if (!TCL_InterpLoaded()) Com_Printf_State (PRINT_FAIL, "Could not load "TCL_LIB_NAME", embedded Tcl disabled\n"); #endif Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); host_hunklevel = Hunk_LowMark (); host_initialized = true; // walk through all vars and forse OnChange event if cvar was modified, // also apply that to variables which mirrored in userinfo because of cl_parsefunchars was't applyed as this moment, // same for serverinfo and may be this fix something also. for ( v = NULL; (v = Cvar_Next ( v )); ) { char val[2048]; // if ( !v->modified ) // continue; // not modified even that strange at this moment if ( Cvar_GetFlags( v ) & (CVAR_ROM | CVAR_INIT) ) continue; snprintf(val, sizeof(val), "%s", v->string); Cvar_Set(v, val); } Hud_262LoadOnFirstStart(); Com_Printf_State (PRINT_INFO, "Exe: "__TIME__" "__DATE__"\n"); Com_Printf_State (PRINT_INFO, "Hunk allocation: %4.1f MB.\n", (float) host_memsize / (1024 * 1024)); Com_Printf ("\nezQuake %s\n\n", VersionString()); Com_Printf(Host_PrintBars("ezQuake\x9c" "SourceForge\x9c" "net", 38)); Com_Printf(Host_PrintBars("ezQuake Initialized", 38)); Com_Printf("\n"); Com_Printf ("\nType /help to access the manual.\nUse /describe to learn about commands.\n", VersionString()); if ((vf = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) { Cbuf_AddText ("exec autoexec.cfg\n"); VFS_CLOSE(vf); } Cmd_StuffCmds_f (); // process command line arguments Cbuf_AddText ("cl_warncmd 1\n"); #ifdef WIN32 // // Verify that ezQuake is associated with the QW:// protocl handler. // { extern qbool CL_CheckIfQWProtocolHandler(); extern cvar_t cl_verify_qwprotocol; if (cl_verify_qwprotocol.integer >= 2) { // Always register the qw:// protocol. Cbuf_AddText("register_qwurl_protocol\n"); } else if (cl_verify_qwprotocol.integer == 1 && !CL_CheckIfQWProtocolHandler()) { // Check if the running exe is the one associated with the qw:// protocol. Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); Com_Printf("This ezQuake is not associated with the "); Com_Printf("\x02QW:// protocol.\n"); Com_Printf("Register it using "); Com_Printf("\x02/register_qwurl_protocol\n"); Com_Printf("(set "); Com_Printf("\x02 cl_verify_qwprotocol "); Com_Printf("to 0 to hide this warning)\n"); Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); } } #endif // WIN32 // Check if a qtv/demo file is specified as the first argument, in that case play that // otherwise, do some more checks of what to show at startup. { char cmd[1024] = {0}; if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd))) { Cbuf_AddText(cmd); } else { Startup_Place(); } } #ifdef _WIN32 SetForegroundWindow(mainwindow); SetActiveWindow(mainwindow); #endif host_everything_loaded = true; }
// load document, auto-recognizing its type, returns NULL in case of failure xml_t * XSD_LoadDocument(char *filename) { xml_t *ret = NULL; int i; vfsfile_t *f; XML_Parser parser = NULL; int len; int filelen; char buf[XML_READ_BUFSIZE]; char document_type[1024]; // FIXME: D-Kure, does FS_ANY handle both the above cases if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) { return NULL; } filelen = VFS_GETLEN(f); // initialize XML parser parser = XML_ParserCreate(NULL); if (parser == NULL) { Com_Printf("could not open2\n"); goto error; } XML_SetStartElementHandler(parser, XSD_DetectType_OnStartElement); XML_SetUserData(parser, document_type); document_type[0] = 0; while (document_type[0] == 0 && (len = VFS_READ(f, buf, XML_READ_BUFSIZE, NULL)) > 0) { if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK) { Com_Printf("could not open3\n"); goto error; } } if (document_type[0] == 0) { Com_Printf("could not open4\n"); goto error; } // now we know what document type it is... // parser is no more needed XML_ParserFree(parser); parser = NULL; // fseek to the beginning of the file VFS_SEEK(f, 0, SEEK_SET); // execute loading parser i = 0; while (xsd_mappings[i].document_type != NULL) { if (!strcmp(xsd_mappings[i].document_type, document_type)) { //??? ret = xsd_mappings[i].load_function(f, filelen); break; } i++; } if (ret) { VFS_CLOSE(f); return ret; } error: if (f) VFS_CLOSE(f); if (parser) XML_ParserFree(parser); return NULL; }
void FL_ReadArchive (filelist_t *fl) { searchpathfuncs_t *funcs; vfsfile_t *vfs = NULL; void *archive_handle = NULL; SYSTEMTIME archive_time; // Save the file modification time of the current archive archive_time = fl->entries[fl->current_entry].time; /* Set up for error case */ fl->error = true; fl->need_refresh = false; fl->display_entry = 0; fl->num_entries = 0; fl->current_entry = 0; if (fl->current_archive == NULL) { return; } vfs = FS_OpenVFS(fl->current_archive, "rb", FS_NONE_OS); if (!vfs) goto fail; // Open the archive file. funcs = FS_FileNameToSearchFunctions(fl->current_archive); if (!funcs) goto fail; archive_handle = funcs->OpenNew(vfs, fl->current_archive); if (!archive_handle) goto fail; fl->error = false; // Make sure we don't have some garbage left from the previous dir. // This caused a bug where some files inside of a zip would be // regarded as zip files, since the files with the same index // in the parent directory were zip files. memset(fl->entries, 0, sizeof(fl->entries)); // Add ".." entry to allow navigating out of archive if setting says so. if (fl->show_dirup) { // Pointer to the current file entry. filedesc_t *f = &fl->entries[fl->num_entries]; // Populate the file descriptor f->type_index = -1; f->is_directory = true; snprintf(f->name, sizeof(f->name), ".."); f->size = 0; f->time = archive_time; // Find friendly name. FL_StripFileName(fl, f); // Increase counter of how many files have been found. fl->num_entries++; if (fl->num_entries >= MAX_FILELIST_ENTRIES) { goto fail; } } funcs->EnumerateFiles(archive_handle, "*", FL_EnumerateArchive, fl); fl->need_resort = true; // Re-sort the file list if needed. if (fl->need_resort) { FL_SortDir (fl); } // Resort might have changed this. fl->current_entry = 0; // Find which item to highlight in the list. FL_FindHighlightEntry(fl); fail: if (archive_handle) funcs->ClosePath(archive_handle); // Closes vfs as well else if (vfs) VFS_CLOSE(vfs); }
qbyte *LoadJPG(vfsfile_t *fin) { qbyte *mem=NULL, *in, *out; int i; /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct my_error_mgr jerr; /* More stuff */ JSAMPARRAY buffer; /* Output row buffer */ int size_stride; /* physical row width in output buffer */ qbyte *infile; int length; length = VFS_GETLEN(fin); infile = malloc(length); VFS_READ(fin, infile, length); VFS_CLOSE(fin); /* Step 1: allocate and initialize JPEG decompression object */ /* We set up the normal JPEG error routines, then override error_exit. */ cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp(jerr.setjmp_buffer)) { // If we get here, the JPEG code has signaled an error. jpeg_destroy_decompress(&cinfo); if (mem) free(mem); return 0; } jpeg_create_decompress(&cinfo); jpeg_mem_src(&cinfo, infile, length); (void) jpeg_read_header(&cinfo, TRUE); (void) jpeg_start_decompress(&cinfo); if (cinfo.output_components!=3) Sys_Error("Bad number of componants in jpeg"); size_stride = cinfo.output_width * cinfo.output_components; /* Make a one-row-high sample array that will go away when done with image */ buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, size_stride, 1); out=mem=malloc(cinfo.output_height*cinfo.output_width*4); memset(out, 0, cinfo.output_height*cinfo.output_width*4); while (cinfo.output_scanline < cinfo.output_height) { (void) jpeg_read_scanlines(&cinfo, buffer, 1); in = buffer[0]; for (i = 0; i < cinfo.output_width; i++) {//rgb to rgba *out++ = *in++; *out++ = *in++; *out++ = *in++; *out++ = 255; } } (void) jpeg_finish_decompress(&cinfo); jpeg_destroy_decompress(&cinfo); image_width = cinfo.output_width; image_height = cinfo.output_height; return mem; }
sfxcache_t *S_LoadSound(sfx_t *s) { char namebuffer[MAX_OSPATH]; char extionless[MAX_OSPATH]; sfxcache_t *sc = NULL; int eof = 0; int current_section; vfsfile_t *f; OggVorbis_File oggfile; vorbis_info *ogginfo; ov_callbacks ovc = { vorbis_callback_read, vorbis_callback_seek, vorbis_callback_close, vorbis_callback_tell }; static char pcmbuff[4096]; //unsigned char *data; wavinfo_t info; int len; //int filesize; // see if still in memory if ((sc = (sfxcache_t *) Cache_Check (&s->cache))) return sc; if (!vorbis_CheckActive()) vorbis_LoadLibrary(); // load it in COM_StripExtension(s->name, extionless); snprintf (namebuffer, sizeof (namebuffer), "sound/%s.ogg", extionless); /* if (!(data = FS_LoadTempFile (namebuffer, &filesize))) { Com_Printf ("Couldn't load %s\n", namebuffer); return NULL; }*/ if (!(f = FS_OpenVFS(namebuffer, "rb", FS_ANY))) { Com_Printf("Couldn't load %s\n", namebuffer); return NULL; } if (qov_open_callbacks(f, &oggfile, NULL, 0, ovc)) { Com_Printf("Invalid sound file %s\n", namebuffer); VFS_CLOSE(f); return NULL; } if (!(ogginfo = qov_info(&oggfile,-1))) { Com_Printf("Unable to retrieve information for %s\n", namebuffer); goto fail; } /* Print some information */ fprintf(stderr, "%s\n", namebuffer); { char **ptr = qov_comment(&oggfile,-1)->user_comments; while(*ptr){ fprintf(stderr,"%s\n",*ptr); ++ptr; } fprintf(stderr,"\nBitstream is %d channel, %ldHz\n", ogginfo->channels, ogginfo->rate); fprintf(stderr,"\nDecoded length: %ld samples\n", (long) qov_pcm_total(&oggfile,-1)); fprintf(stderr,"Encoded by: %s\n\n", qov_comment(&oggfile,-1)->vendor); } info.rate = ogginfo->rate; // Frequency rate info.width = 1; // 8 bit samples info.channels = ogginfo->channels; // 1 == mono, 2 == stereo info.loopstart = -1; // NOOO idea... info.samples = qov_pcm_total(&oggfile,-1); // Total samples info.dataofs = 0; // offset //FMod_CheckModel(namebuffer, data, filesize); //info = GetWavinfo (s->name, data, filesize); // Stereo sounds are allowed (intended for music) if (info.channels < 1 || info.channels > 2) { Com_Printf("%s has an unsupported number of channels (%i)\n",s->name, info.channels); return NULL; } len = (int) ((double) info.samples * (double) shm->format.speed / (double) info.rate); len = len * info.width * info.channels; if (!(sc = (sfxcache_t *) Cache_Alloc (&s->cache, len + sizeof(sfxcache_t), s->name))) return NULL; /* Read the whole Ogg Vorbis file in */ byte *output = sc->data; while (!eof) { // 0 == little endian, 1 = big endian // 1 == 8 bit samples, 2 = 16 bit samples // 1 == signed samples long ret = qov_read(&oggfile, pcmbuff, sizeof(pcmbuff), 0, info.width, 1, ¤t_section); if (ret == 0) { eof = 1; } else if (ret < 0) { /* error in the stream. Not a problem, just reporting it in * case we (the app) cares. In this case, we don't. */ } else { /* we don't bother dealing with sample rate changes, etc, but * you'll have to */ memcpy(output, pcmbuff, ret); output += ret; } } qov_clear(&oggfile); sc->total_length = (unsigned int) info.samples; sc->format.speed = info.rate; sc->format.width = info.width; sc->format.channels = info.channels; if (info.loopstart < 0) sc->loopstart = -1; else sc->loopstart = (int)((double)info.loopstart * (double)shm->format.speed / (double)sc->format.speed); // ResampleSfx (s, data + info.dataofs, info.samples, &sc->format, sc->data); return sc; fail: qov_clear(&oggfile); // Only goto fail if ov_open* succeded if (f) { VFS_CLOSE(f); } return NULL; }
/* ======== LoadPCX ======== */ byte* LoadPCX (vfsfile_t *f) { pcx_t *pcx, pcxbuf; byte palette[768]; byte *pix, *image_rgba; int x, y; int dataByte, runLength; int count; // // parse the PCX file // VFS_READ (f, &pcxbuf, sizeof(pcxbuf)); pcx = &pcxbuf; if (pcx->manufacturer != 0x0a || pcx->version != 5 || pcx->encoding != 1 || pcx->bits_per_pixel != 8 || pcx->xmax > 320 || pcx->ymax > 256) { Con_Printf ("Bad pcx file\n"); VFS_CLOSE(f); return NULL; } // seek to palette VFS_SEEK(f, VFS_GETLEN(f)-768); VFS_READ(f, palette, 768); VFS_SEEK(f, sizeof(pcxbuf) - 4); count = (pcx->xmax+1) * (pcx->ymax+1); image_rgba = malloc( count * 4); for (y=0 ; y<=pcx->ymax ; y++) { pix = image_rgba + 4*y*(pcx->xmax+1); for (x=0 ; x<=pcx->xmax ; ) { dataByte = VFS_GETC(f); if((dataByte & 0xC0) == 0xC0) { runLength = dataByte & 0x3F; dataByte = VFS_GETC(f); } else runLength = 1; while(runLength-- > 0) { pix[0] = palette[dataByte*3]; pix[1] = palette[dataByte*3+1]; pix[2] = palette[dataByte*3+2]; pix[3] = 255; pix += 4; x++; } } } VFS_CLOSE(f); image_width = pcx->xmax+1; image_height = pcx->ymax+1; return image_rgba; }