static void *FSGZIP_LoadGZipFile(vfsfile_t *gziphandle, const char *desc) { gzipfile_t *gzip; const char *base; char *ext; int fd; gzip = Q_calloc(1, sizeof(*gzip)); strlcpy(gzip->filename, desc, sizeof(gzip->filename)); if (gziphandle == NULL) goto fail; gzip->raw = gziphandle; fd = fileno(((vfsosfile_t *)gziphandle)->handle); // <-- ASSUMPTION! that file is OS gzip->handle = (vfsfile_t *)gzdopen(dup(fd), "r"); gzip->references = 1; /* Remove the .gz from the file.name */ base = COM_SkipPath(desc); ext = COM_FileExtension(desc); if (strcmp(ext, "gz") == 0) { COM_StripExtension(base, gzip->file.name, sizeof(gzip->file.name)); } else { strlcpy(gzip->file.name, base, sizeof(gzip->file.name)); } return gzip; fail: // Q_free is safe to call on NULL pointers Q_free(gzip); return NULL; }
static vfsfile_t *FSPAK_OpenVFS(void *handle, flocation_t *loc, char *mode) { pack_t *pack = (pack_t*)handle; vfspack_t *vfsp; if (strcmp(mode, "rb")) return NULL; //urm, unable to write/append vfsp = Q_calloc(1, sizeof(*vfsp)); vfsp->parentpak = pack; vfsp->parentpak->references++; vfsp->startpos = loc->offset; vfsp->length = loc->len; vfsp->currentpos = vfsp->startpos; vfsp->funcs.ReadBytes = strcmp(mode, "rb") ? NULL : VFSPAK_ReadBytes; vfsp->funcs.WriteBytes = strcmp(mode, "wb") ? NULL : VFSPAK_WriteBytes; vfsp->funcs.Seek = VFSPAK_Seek; vfsp->funcs.Tell = VFSPAK_Tell; vfsp->funcs.GetLen = VFSPAK_GetLen; vfsp->funcs.Close = VFSPAK_Close; vfsp->funcs.Flush = NULL; if (loc->search) vfsp->funcs.copyprotected = loc->search->copyprotected; return (vfsfile_t *)vfsp; }
static vfsfile_t *FSGZIP_OpenVFS(void *handle, flocation_t *loc, char *mode) { gzipfile_t *gzip = (gzipfile_t *)handle; vfsgzipfile_t *vfsgz; if (strcmp(mode, "rb")) return NULL; vfsgz = Q_calloc(1, sizeof(*vfsgz)); vfsgz->parent = gzip; gzip->references++; vfsgz->startpos = loc->offset; vfsgz->length = loc->len; vfsgz->currentpos = vfsgz->startpos; vfsgz->funcs.ReadBytes = strcmp(mode, "rb") ? NULL : VFSGZIP_ReadBytes; vfsgz->funcs.WriteBytes = strcmp(mode, "wb") ? NULL : VFSGZIP_WriteBytes; vfsgz->funcs.Seek = VFSGZIP_Seek; vfsgz->funcs.Tell = VFSGZIP_Tell; vfsgz->funcs.GetLen = VFSGZIP_GetLen; vfsgz->funcs.Close = VFSGZIP_Close; vfsgz->funcs.Flush = VFSGZIP_Flush; if (loc->search) vfsgz->funcs.copyprotected = loc->search->copyprotected; return (vfsfile_t *)vfsgz; }
static sb_qtvplayer_t *QTVList_New_Player(void) { sb_qtvplayer_t *ret; ret = Q_calloc(sizeof (sb_qtvplayer_t), 1); return ret; }
static sb_qtventry_t *QTVList_New_Entry(void) { sb_qtventry_t *ret; ret = Q_calloc(sizeof (sb_qtventry_t), 1); return ret; }
void R_Bloom_InitTextures( void ) { unsigned char *data; int maxtexsize; size_t size; // Find closer power of 2 to screen size. for (screen_texture_width = 1; screen_texture_width < glwidth; screen_texture_width *= 2); for (screen_texture_height = 1; screen_texture_height < glheight; screen_texture_height *= 2); // Disable blooms if we can't handle a texture of that size. glGetIntegerv (GL_MAX_TEXTURE_SIZE, &maxtexsize); if (screen_texture_width > maxtexsize || screen_texture_height > maxtexsize) { screen_texture_width = screen_texture_height = 0; Cvar_SetValue (&r_bloom, 0); Com_Printf ("WARNING: 'R_InitBloomScreenTexture' too high resolution for Light Bloom. Effect disabled\n"); return; } // Init the screen texture. size = screen_texture_width * screen_texture_height * sizeof (int); data = Q_malloc (size); memset (data, 255, size); //r_bloomscreentexture = GL_LoadTexture ( "***r_screenbackuptexture***", screen_texture_width, screen_texture_height, data, 0, 4); // false, false, 4); if (!r_bloomscreentexture) r_bloomscreentexture = texture_extension_number++; GL_Bind (r_bloomscreentexture); glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, screen_texture_width, screen_texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); Q_free (data); // Validate bloom size and init the bloom effect texture. R_Bloom_InitEffectTexture(); // If screensize is more than 2x the bloom effect texture, set up for stepped downsampling. r_bloomdownsamplingtexture = 0; r_screendownsamplingtexture_size = 0; if( glwidth > (BLOOM_SIZE * 2) && !r_bloom_fast_sample.value ) { r_screendownsamplingtexture_size = (int)(BLOOM_SIZE * 2); data = Q_calloc (r_screendownsamplingtexture_size * r_screendownsamplingtexture_size, sizeof (int)); r_bloomdownsamplingtexture = GL_LoadTexture ( "***r_bloomdownsamplingtexture***", r_screendownsamplingtexture_size, r_screendownsamplingtexture_size, data, 0, 4); Q_free (data); } // Init the screen backup texture. if (r_screendownsamplingtexture_size) R_Bloom_InitBackUpTexture (r_screendownsamplingtexture_size, r_screendownsamplingtexture_size); else R_Bloom_InitBackUpTexture (BLOOM_SIZE, BLOOM_SIZE); }
//================= // R_Bloom_InitBackUpTexture // ================= void R_Bloom_InitBackUpTexture( int width, int height ) { unsigned char *data; data = (unsigned char *) Q_calloc (width * height, sizeof (int)); r_screenbackuptexture_size = width; r_bloombackuptexture = GL_LoadTexture ("***r_bloombackuptexture***", width, height, data, 0, 4); Q_free (data); }
static void VID_SetupModeList(void) { int i; Q_free(modelist); modelist_count = SDL_GetNumDisplayModes(0); modelist = Q_calloc(modelist_count, sizeof(*modelist)); for (i = 0; i < modelist_count; i++) { SDL_GetDisplayMode(0, i, &modelist[i]); } }
// // Label - Sets the text of a label. // void EZ_label_SetText(ez_label_t *label, const char *text) { int text_len = strlen(text) + 1; Q_free(label->text); if (text) { label->text = Q_calloc(text_len, sizeof(char)); strlcpy(label->text, text, text_len); } CONTROL_RAISE_EVENT(NULL, label, ez_label_t, OnTextChanged, NULL); }
void Log_AutoLogging_StartMatch(char *logname) { char extendedname[MAX_OSPATH * 2], *fullname; FILE *templog; void *buf; temp_log_ready = false; if (!match_auto_logconsole.value) return; if (Log_IsLogging()) { if (autologging) { autologging = false; Log_Stop(); } else { Com_Printf("Auto console logging skipped (already logging)\n"); return; } } strlcpy(auto_matchname, logname, sizeof(auto_matchname)); strlcpy (extendedname, TEMP_LOG_NAME, sizeof(extendedname)); COM_ForceExtensionEx (extendedname, ".log", sizeof (extendedname)); fullname = va("%s/%s", MT_TempDirectory(), extendedname); if (!(templog = fopen (fullname, log_readable.value ? "w" : "wb"))) { FS_CreatePath(fullname); if (!(templog = fopen (fullname, log_readable.value ? "w" : "wb"))) { Com_Printf("Error: Couldn't open %s\n", fullname); return; } } buf = Q_calloc(1, LOGFILEBUFFER); if (!buf) { Com_Printf("Not enough memory to allocate log buffer\n"); return; } memlogfile = FSMMAP_OpenVFS(buf, LOGFILEBUFFER); Com_Printf ("Auto console logging commenced\n"); logfile = templog; autologging = true; auto_starttime = cls.realtime; }
char *str_repeat (char *str, int amount) { char *ret = NULL; int i = 0; if (str == NULL) return NULL; if (amount <= 0) return ""; ret = (char *) Q_calloc(strlen(str) * amount + 1, sizeof(char)); for (i = 0; i < amount; i++) strcat(ret, str); return ret; }
// Slightly different version below were we don't take in a FILE * vfsfile_t *VFSOS_Open(char *name, FILE *f, char *mode) { vfsosfile_t *file; if (!strchr(mode, 'r') && !strchr(mode, 'w')) return NULL; // hm, no read and no write mode? if (!f) { qbool read = !!strchr(mode, 'r'); qbool write = !!strchr(mode, 'w'); qbool text = !!strchr(mode, 't'); char newmode[10]; int modec = 0; if (read) newmode[modec++] = 'r'; if (write) newmode[modec++] = 'w'; if (text) newmode[modec++] = 't'; else newmode[modec++] = 'b'; newmode[modec++] = '\0'; f = fopen(name, newmode); } if (!f) return NULL; file = Q_calloc(1, sizeof(vfsosfile_t)); file->funcs.ReadBytes = (strchr(mode, 'r') ? VFSOS_ReadBytes : NULL); file->funcs.WriteBytes = (strchr(mode, 'w') ? VFSOS_WriteBytes : NULL); file->funcs.Seek = VFSOS_Seek; file->funcs.Tell = VFSOS_Tell; file->funcs.GetLen = VFSOS_GetSize; file->funcs.Close = VFSOS_Close; file->handle = f; return (vfsfile_t*)file; }
char *Player_StripNameColor(const char *name) { extern char readableChars[]; // console.c char *stripped = NULL; int i, name_length; name_length = strlen(name); stripped = (char *)Q_calloc(name_length + 1, sizeof(char)); // Strip the color by setting bit 7 = 0 on all letters. for (i = 0; i < name_length; i++) { stripped[i] = readableChars[(unsigned char)name[i]] & 127; } stripped[i] = '\0'; return stripped; }
// VFS-XXX: This is slightly different to fs.c version in that we don't take in a FILE *f vfsfile_t *VFSOS_Open(char *osname, char *mode) { FILE *f; vfsosfile_t *file; qbool read = !!strchr(mode, 'r'); qbool write = !!strchr(mode, 'w'); qbool append = !!strchr(mode, 'a'); qbool text = !!strchr(mode, 't'); char newmode[10]; int modec = 0; if (read) newmode[modec++] = 'r'; if (write) newmode[modec++] = 'w'; if (append) newmode[modec++] = 'a'; if (text) newmode[modec++] = 't'; else newmode[modec++] = 'b'; newmode[modec++] = '\0'; f = fopen(osname, newmode); if (!f) return NULL; file = Q_calloc(1, sizeof(vfsosfile_t)); file->funcs.ReadBytes = ( strchr(mode, 'r') ? VFSOS_ReadBytes : NULL); file->funcs.WriteBytes = ((strchr(mode, 'w') || strchr(mode, 'a'))? VFSOS_WriteBytes : NULL); file->funcs.Seek = VFSOS_Seek; file->funcs.Tell = VFSOS_Tell; file->funcs.GetLen = VFSOS_GetSize; file->funcs.Close = VFSOS_Close; file->handle = f; return (vfsfile_t*)file; }
vfsfile_t *FS_OpenTemp(void) { FILE *f; vfsosfile_t *file; f = tmpfile(); if (!f) return NULL; file = Q_calloc(1, sizeof(vfsosfile_t)); file->funcs.ReadBytes = VFSOS_ReadBytes; file->funcs.WriteBytes = VFSOS_WriteBytes; file->funcs.Seek = VFSOS_Seek; file->funcs.Tell = VFSOS_Tell; file->funcs.GetLen = VFSOS_GetSize; file->funcs.Close = VFSOS_Close; file->handle = f; return (vfsfile_t*)file; }
vfsfile_t *FS_OpenTCP(char *name) { tcpfile_t *newf; int sock; // int _true = true; netadr_t adr = {0}; if (NET_StringToAdr(name, &adr)) { sock = TCP_OpenStream(adr); if (sock == INVALID_SOCKET) return NULL; // if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&_true, sizeof(_true)) == -1) // Com_Printf ("FS_OpenTCP: setsockopt: (%i): %s\n", qerrno, strerror(qerrno)); newf = Q_calloc(1, sizeof(tcpfile_t)); memset(newf, 0, sizeof(tcpfile_t)); newf->sock = sock; newf->funcs.Close = VFSTCP_Close; newf->funcs.Flush = NULL; newf->funcs.GetLen = VFSTCP_GetLen; newf->funcs.ReadBytes = VFSTCP_ReadBytes; newf->funcs.Seek = VFSTCP_Seek; newf->funcs.Tell = VFSTCP_Tell; newf->funcs.WriteBytes = VFSTCP_WriteBytes; newf->funcs.seekingisabadplan = true; // link in newf->next = vfs_tcp_list; vfs_tcp_list = newf; return &newf->funcs; } else return NULL; }
// ================= // R_Bloom_InitEffectTexture // ================= void R_Bloom_InitEffectTexture (void) { unsigned char *data; float bloomsizecheck; if (r_bloom_sample_size.value < 32) Cvar_SetValue (&r_bloom_sample_size, 32); // Make sure bloom size is a power of 2. BLOOM_SIZE = r_bloom_sample_size.value; bloomsizecheck = (float) BLOOM_SIZE; while (bloomsizecheck > 1.0f) bloomsizecheck /= 2.0f; if (bloomsizecheck != 1.0f) { BLOOM_SIZE = 32; while (BLOOM_SIZE < r_bloom_sample_size.value) BLOOM_SIZE *= 2; } // Make sure bloom size doesn't have stupid values. if (BLOOM_SIZE > screen_texture_width || BLOOM_SIZE > screen_texture_height) BLOOM_SIZE = min( screen_texture_width, screen_texture_height ); if (BLOOM_SIZE != r_bloom_sample_size.value) Cvar_SetValue (&r_bloom_sample_size, BLOOM_SIZE); data = (unsigned char *) Q_calloc (BLOOM_SIZE * BLOOM_SIZE, sizeof (int)); r_bloomeffecttexture = GL_LoadTexture ("***r_bloomeffecttexture***", BLOOM_SIZE, BLOOM_SIZE, data, 0, 4); Q_free (data); }
static void Log_log_f(void) { char *fulllogname; FILE *templog; void *buf; switch (Cmd_Argc()) { case 1: if (autologging) Com_Printf("Auto console logging is in progress\n"); else if (Log_IsLogging()) Com_Printf("Logging to %s\n", logfilename); else Com_Printf("Not logging\n"); return; case 2: if (!strcasecmp(Cmd_Argv(1), "stop")) { if (autologging) { Log_AutoLogging_StopMatch(); } else { if (Log_IsLogging()) { Log_Stop(); Com_Printf("Stopped logging to %s\n", logfilename); } else { Com_Printf("Not logging\n"); } } return; } if (autologging) { Com_Printf("Auto console logging must be stopped first!\n"); return; } if (Log_IsLogging()) { Log_Stop(); Com_Printf("Stopped logging to %s\n", logfilename); } strlcpy(logfilename, Cmd_Argv(1), sizeof(logfilename) - 4); Util_Process_Filename(logfilename); if (!Util_Is_Valid_Filename(logfilename)) { Com_Printf(Util_Invalid_Filename_Msg("filename")); return; } COM_ForceExtensionEx (logfilename, ".log", sizeof (logfilename)); fulllogname = va("%s/%s", Log_LogDirectory(), logfilename); if (!(templog = fopen (fulllogname, log_readable.value ? "w" : "wb"))) { FS_CreatePath(fulllogname); if (!(templog = fopen (fulllogname, log_readable.value ? "w" : "wb"))) { Com_Printf("Error: Couldn't open %s\n", logfilename); return; } } buf = Q_calloc(1, LOGFILEBUFFER); if (!buf) { Com_Printf("Not enough memory to allocate log buffer\n"); return; } memlogfile = FSMMAP_OpenVFS(buf, LOGFILEBUFFER); Com_Printf("Logging to %s\n", logfilename); logfile = templog; break; default: Com_Printf("Usage: %s [filename | stop]\n", Cmd_Argv(0)); return; } }
void StatsGrid_Init(stats_weight_grid_t **grid, float falloff_interval, float falloff_value, int cell_length, float grid_width, float grid_height, float hold_threshold) { int row; int col; // Allocate the grid. (*grid) = (stats_weight_grid_t *)Q_malloc(sizeof(stats_weight_grid_t)); memset((*grid), 0, sizeof(stats_weight_grid_t)); if((*grid) == NULL) { // Failure. return; } // Get the row and col count. (*grid)->row_count = Q_rint(grid_height / cell_length); (*grid)->col_count = Q_rint(grid_width / cell_length); // Allocate the rows. (*grid)->cells = (stats_cell_t **)Q_calloc((*grid)->row_count, sizeof(stats_cell_t *)); // If we failed allocating the rows, cleanup and return. if((*grid)->cells == NULL) { Q_free(*grid); return; } // Allocate the columns for each row. for(row = 0; row < (*grid)->row_count; row++) { // Allocate memory for the current rows columns. (*grid)->cells[row] = (stats_cell_t *)Q_calloc((*grid)->col_count, sizeof(stats_cell_t)); // If something went wrong cleanup and return. if((*grid)->cells[row] == NULL) { // Make sure we're not trying to free more than we allocated. (*grid)->row_count = row; // Remove the grid. StatsGrid_Remove(grid); // Failure. return; } // Set initial values for all the cells. for(col = 0; col < (*grid)->col_count; col++) { (*grid)->cells[row][col].teams[STATS_TEAM1].weight = 0.0; (*grid)->cells[row][col].teams[STATS_TEAM1].change_time = 0.0; (*grid)->cells[row][col].teams[STATS_TEAM1].death_weight = 0.0; (*grid)->cells[row][col].teams[STATS_TEAM2].weight = 0.0; (*grid)->cells[row][col].teams[STATS_TEAM2].change_time = 0.0; (*grid)->cells[row][col].teams[STATS_TEAM2].death_weight = 0.0; // Save the quake coordinates of the cells upper left corner. (*grid)->cells[row][col].tl_x = cl.worldmodel->mins[0] + (col * cell_length); (*grid)->cells[row][col].tl_y = cl.worldmodel->mins[1] + (row * cell_length); } } // If everything went well set the rest of the stuff. (*grid)->falloff_interval = falloff_interval; (*grid)->falloff_value = falloff_value; (*grid)->cell_length = cell_length; (*grid)->width = grid_width; (*grid)->height = grid_height; // We will wait with setting these until the match has started. (*grid)->teams[STATS_TEAM1].color = 0; (*grid)->teams[STATS_TEAM2].color = 0; (*grid)->teams[STATS_TEAM1].hold_count = 0; (*grid)->teams[STATS_TEAM2].hold_count = 0; (*grid)->teams[STATS_TEAM1].color = 0; (*grid)->teams[STATS_TEAM2].color = 0; (*grid)->hold_threshold = hold_threshold; }
void StatsGrid_InitHoldItems() { int i; int ents_count = 0; // This is used to keep count of how many of the different // types of items that exist on the map, so that they // can be named "RL" "RL2" and so on. int pent_count = 0; int quad_count = 0; int ring_count = 0; int suit_count = 0; int rl_count = 0; int gl_count = 0; int lg_count = 0; int sng_count = 0; int mega_count = 0; int ra_count = 0; int ya_count = 0; int ga_count = 0; // Buffer. stats_entity_t temp_ents[STATS_MAX_IMPORTANT_ENTS]; // Entities (weapons and such). cl_main.c extern visentlist_t cl_visents; // Don't create the list before we have any entities to work with. if(cl_visents.count <= 0) { return; } stats_important_ents = (stats_entities_t *)Q_malloc(sizeof(stats_entities_t)); // Something bad happened. if(stats_important_ents == NULL) { return; } // Go through the entities and check for the important ones // and save their name and location. for (i = 0; i < cl_visents.count && (ents_count < STATS_MAX_IMPORTANT_ENTS); i++) { if(!strcmp(cl_visents.list[i].model->name, "progs/invulner.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "PENT", ++pent_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/quaddama.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "QUAD", ++quad_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/invisibl.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RING", ++ring_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/suit.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "SUIT", ++suit_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/g_rock2.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RL", ++rl_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/g_light.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "LG", ++lg_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/g_rock.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "GL", ++gl_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/g_nail2.mdl")) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "SNG", ++sng_count); } else if(!strcmp(cl_visents.list[i].model->name, "maps/b_bh100.bsp")) { // Megahealth. StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "MH", ++mega_count); } else if(!strcmp(cl_visents.list[i].model->name, "progs/armor.mdl")) { if(cl_visents.list[i].skinnum == 0) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "GA", ++ga_count); } else if(cl_visents.list[i].skinnum == 1) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "YA", ++ya_count); } else if(cl_visents.list[i].skinnum == 2) { StatsGrid_SetHoldItemName(temp_ents[ents_count].name, "RA", ++ra_count); } else { continue; } } else { // The entity wasn't one we wanted. continue; } // Copy the position of the entity into the buffer. VectorCopy(cl_visents.list[i].origin, temp_ents[ents_count].origin); // Reset the team values. temp_ents[ents_count].teams_hold_count[STATS_TEAM1] = 0; temp_ents[ents_count].teams_hold_count[STATS_TEAM2] = 0; ents_count++; } // Set the count of found entities and allocate memory for the // final list of items. stats_important_ents->count = ents_count; stats_important_ents->list = Q_calloc(ents_count, sizeof(stats_entity_t)); // Something bad happened, cleanup. if(stats_important_ents->list == NULL) { Q_free(stats_important_ents); return; } // Copy the entities from the buffer to the final list. for(i = 0; i < ents_count; i++) { memcpy(&stats_important_ents->list[i], &temp_ents[i], sizeof(stats_entity_t)); } // Set the radius around the items that decides if it's being // held by a team or not. stats_important_ents->hold_radius = 264.0; // Get the entity with the longest name to use for padding // (so we don't have to calculate this more than once). stats_important_ents->longest_name = 0; for(i = 0; i < stats_important_ents->count; i++) { int current = strlen(stats_important_ents->list[i].name); stats_important_ents->longest_name = max(current, stats_important_ents->longest_name); } }
qbool Cmdline_Parse(int argc, char **argv) { int i; char *files_temp[1024]; int filecount = 0; char *arg; memset(&cmdargs, 0, sizeof(cmdargs)); if (argc < 2) { return false; } for (i = 1; i < argc; i++) { arg = argv[i]; if (((arg[0] == '-') || (arg[0] == '/')) && arg[1]) { // Command line switch. switch(arg[1]) { case 'v' : { // Verbosity based on how many v's where specified. int j = 1; while (arg[j] == 'v') { cmdargs.debug++; j++; } break; } case 'f' : { int next_arg = (i + 1); if (next_arg < argc) { cmdargs.frag_file = Q_strdup(argv[next_arg]); } break; } case 't' : { int next_arg = (i + 1); if (next_arg < argc) { cmdargs.template_file = Q_strdup(argv[next_arg]); } else { Sys_PrintError("-t: No template specified\n"); } break; } } } else { // Regard as being a file. files_temp[filecount] = arg; filecount++; } } cmdargs.mvd_files_count = filecount; // Allocate memory for the filenames. if (filecount > 0) { cmdargs.mvd_files = (char **)Q_calloc(filecount, sizeof(char **)); for (i = 0; i < filecount; i++) { cmdargs.mvd_files[i] = Q_strdup(files_temp[i]); } } return true; }
/* ================= FSPAK_LoadPackFile Takes an explicit (not game tree related) path to a pak file. Loads the header and directory, adding the files at the beginning of the list so they override previous pack files. ================= */ static void *FSPAK_LoadPackFile (vfsfile_t *file, const char *desc) { dpackheader_t header; int i; packfile_t *newfiles; int numpackfiles; pack_t *pack; vfsfile_t *packhandle; dpackfile_t info; vfserrno_t err; packhandle = file; if (packhandle == NULL) return NULL; VFS_READ(packhandle, &header, sizeof(header), &err); if (header.id[0] != 'P' || header.id[1] != 'A' || header.id[2] != 'C' || header.id[3] != 'K') { return NULL; } header.dirofs = LittleLong (header.dirofs); header.dirlen = LittleLong (header.dirlen); numpackfiles = header.dirlen / sizeof(dpackfile_t); // if (numpackfiles != PAK0_COUNT) // com_modified = true; // not the original file newfiles = (packfile_t*)Q_malloc (numpackfiles * sizeof(packfile_t)); VFS_SEEK(packhandle, header.dirofs, SEEK_SET); // fread (&info, 1, header.dirlen, packhandle); // crc the directory to check for modifications // crc = QCRC_Block((qbyte *)info, header.dirlen); // QCRC_Init (&crc); pack = (pack_t *)Q_calloc(1, sizeof (pack_t)); // parse the directory for (i=0 ; i<numpackfiles ; i++) { *info.name = '\0'; // FIXME return value (void) VFS_READ(packhandle, &info, sizeof(info), &err); /* for (j=0 ; j<sizeof(info) ; j++) CRC_ProcessByte(&crc, ((qbyte *)&info)[j]); */ strlcpy (newfiles[i].name, info.name, MAX_QPATH); newfiles[i].filepos = LittleLong(info.filepos); newfiles[i].filelen = LittleLong(info.filelen); } /* if (crc != PAK0_CRC) com_modified = true; */ strlcpy (pack->filename, desc, sizeof (pack->filename)); pack->handle = packhandle; pack->numfiles = numpackfiles; pack->files = newfiles; pack->filepos = 0; VFS_SEEK(packhandle, pack->filepos, SEEK_SET); pack->references++; return pack; }
void Capture_WriteAudio (int samples, byte *sample_buffer) { HRESULT hr = E_UNEXPECTED; unsigned long sample_bufsize; if (!m_audio_stream) { Com_Printf ("ERROR: Audio stream is NULL\n"); return; } sample_bufsize = samples * m_wave_format.nBlockAlign; if (m_audio_is_mp3) { MMRESULT mmr; byte *mp3_buffer; unsigned long mp3_bufsize; if ((mmr = qacmStreamSize(hstr, sample_bufsize, &mp3_bufsize, ACM_STREAMSIZEF_SOURCE))) { Com_Printf ("ERROR: Couldn't get mp3bufsize\n"); return; } if (!mp3_bufsize) { Com_Printf ("ERROR: mp3bufsize is zero\n"); return; } mp3_buffer = (byte *) Q_calloc (mp3_bufsize, 1); memset (&strhdr, 0, sizeof(strhdr)); strhdr.cbStruct = sizeof(strhdr); strhdr.pbSrc = sample_buffer; strhdr.cbSrcLength = sample_bufsize; strhdr.pbDst = mp3_buffer; strhdr.cbDstLength = mp3_bufsize; if ((mmr = qacmStreamPrepareHeader(hstr, &strhdr, 0))) { Com_Printf ("ERROR: Couldn't prepare header\n"); Q_free (mp3_buffer); return; } if ((mmr = qacmStreamConvert(hstr, &strhdr, ACM_STREAMCONVERTF_BLOCKALIGN))) { Com_Printf ("ERROR: Couldn't convert audio stream\n"); goto clean; } hr = qAVIStreamWrite (m_audio_stream, m_audio_frame_counter++, 1, mp3_buffer, strhdr.cbDstLengthUsed, AVIIF_KEYFRAME, NULL, NULL); clean: if ((mmr = qacmStreamUnprepareHeader(hstr, &strhdr, 0))) { Com_Printf ("ERROR: Couldn't unprepare header\n"); Q_free (mp3_buffer); return; } Q_free (mp3_buffer); } else { // The audio is not in MP3 format, just write the WAV data to the avi. hr = qAVIStreamWrite (m_audio_stream, m_audio_frame_counter++, 1, sample_buffer, samples * m_wave_format.nBlockAlign, AVIIF_KEYFRAME, NULL, NULL); } if (FAILED(hr)) { Com_Printf ("ERROR: Couldn't write to AVI file\n"); return; } }