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;
}
