/* ============== Cache_Alloc ============== */ void *Cache_Alloc (cache_user_t *c, int size, const char *name) { cache_system_t *cs; if (c->data) Sys_Error ("%s: %s is already allocated", __thisfunc__, name); if (size <= 0) Sys_Error ("%s: bad size %i for %s", __thisfunc__, size, name); size = (size + sizeof(cache_system_t) + 15) & ~15; // find memory for it while (1) { cs = Cache_TryAlloc (size, false); if (cs) { q_strlcpy (cs->name, name, CACHENAME_LEN); c->data = (void *)(cs + 1); cs->user = c; break; } // free the least recently used cahedat if (cache_head.lru_prev == &cache_head) // not enough memory at all Sys_Error ("%s: out of memory", __thisfunc__); Cache_Free ( cache_head.lru_prev->user ); } return Cache_Check (c); }
void CAudioSourceMP3Cache::CacheUnload( void ) { if ( !m_cache.data ) return; Cache_Free( &m_cache ); }
/* ============== Cache_Alloc ============== */ void *Cache_Alloc (cache_user_t *c, int size, const char *name) { cache_system_t *cs; if (c->data) Sys_Error ("Cache_Alloc: already allocated"); if (size <= 0) Sys_Error ("Cache_Alloc: size %i", size); size = (size + sizeof(cache_system_t) + 15) & ~15; // find memory for it while (1) { cs = Cache_TryAlloc (size, false); if (cs) { Q_strncpy(cs->name, name, sizeof(cs->name)); c->data = (void *)(cs+1); cs->user = c; break; } // free the least recently used entry // assume if it's a locked entry that we've run out. if (cache_head.lru_prev == &cache_head || cache_head.lru_prev->locked) Sys_Error ("Cache_Alloc: out of memory"); Cache_Free ( cache_head.lru_prev->user ); } return Cache_Check (c); }
/* * ============== * Cache_AllocPadded * ============== */ void * Cache_AllocPadded(cache_user_t *c, int pad, int size, const char *name) { cache_system_t *cs; if (c->data) Sys_Error("%s: allready allocated", __func__); if (size <= 0) Sys_Error("%s: size %i", __func__, size); size = (size + pad + sizeof(cache_system_t) + 15) & ~15; /* find memory for it */ while (1) { cs = Cache_TryAlloc(size, false); if (cs) { strncpy(cs->name, name, sizeof(cs->name) - 1); cs->user = c; c->pad = pad; c->data = Cache_Data(cs); break; } /* free the least recently used cache data */ if (cache_head.lru_prev == &cache_head) Sys_Error("%s: out of memory", __func__); /* not enough memory at all */ Cache_Free(cache_head.lru_prev->user); } return Cache_Check(c); }
/* ============== Cache_Alloc ============== */ void *Cache_Alloc (cache_user_t *c, int size, const char *name) { cache_system_t *cs; if (c->data) Sys_Error ("Cache_Alloc: allready allocated"); if (size <= 0) Sys_Error ("Cache_Alloc: size %i", size); size = (size + sizeof(cache_system_t) + 15) & ~15; // find memory for it while (1) { cs = Cache_TryAlloc (size, false); if (cs) { strncpy (cs->name, name, sizeof(cs->name)-1); c->data = (void *)(cs+1); cs->user = c; break; } // free the least recently used cahedat if (cache_head.lru_prev == &cache_head) Sys_Error ("Cache_Alloc: out of memory"); // not enough memory at all Cache_Free ( cache_head.lru_prev->user ); } return Cache_Check (c); }
/* =========== Cache_Move =========== */ void Cache_Move(cache_system_t *c) { cache_system_t *new_block; // we are clearing up space at the bottom, so only allocate it late new_block = Cache_TryAlloc(c->size, true); if (new_block) { memcpy(new_block + 1, c + 1, c->size - sizeof(cache_system_t)); new_block->user = c->user; memcpy(new_block->name, c->name, sizeof(new_block->name)); Cache_Free(c->user); new_block->user->data = (void *)(new_block + 1); } else { Cache_Free(c->user); // tough luck... } }
/* ============ Cache_Flush Throw everything out, so new data will be demand cached ============ */ void Cache_Flush(void) { while (cache_head.next != &cache_head) { Cache_Free(cache_head.next->user); // reclaim the space } #ifndef SERVERONLY Mod_ClearSimpleTextures(); #endif }
/* ========== Skin_Flush ========== */ void Skin_Flush (void) { int i; for (i=0 ; i<numskins ; i++) { if (skins[i].cache.data) Cache_Free (&skins[i].cache); } numskins = 0; }
/* * =========== * Cache_Move * =========== */ static void Cache_Move(cache_system_t *c) { cache_system_t *newobj; int pad; /* we are clearing up space at the bottom, so only allocate it late */ newobj = Cache_TryAlloc(c->size, true); if (newobj) { memcpy(newobj + 1, c + 1, c->size - sizeof(cache_system_t)); newobj->user = c->user; memcpy(newobj->name, c->name, sizeof(newobj->name)); pad = c->user->pad; Cache_Free(c->user); newobj->user->pad = pad; newobj->user->data = Cache_Data(newobj); } else { /* tough luck... */ Cache_Free(c->user); } }
/* <99d0> ../engine/com_custom.c:19 */ void COM_ClearCustomizationList(customization_t *pHead, qboolean bCleanDecals) { customization_s *pCurrent, *pNext; cachewad_t *pWad; cachepic_t *pic; pCurrent = pHead->pNext; if (!pCurrent) return; while (pCurrent) { pNext = pCurrent->pNext; if (pCurrent->bInUse) { if (pCurrent->pBuffer) Mem_Free(pCurrent->pBuffer); if (pCurrent->pInfo) { if (pCurrent->resource.type == t_decal) { if (bCleanDecals && g_pcls.state == ca_active) { R_DecalRemoveAll(-1 - pCurrent->resource.playernum); } pWad = (cachewad_t *)pCurrent->pInfo; Mem_Free(pWad->lumps); for (int i = 0; i < pWad->cacheCount; i++) { pic = &pWad->cache[i]; if (Cache_Check(&pic->cache)) Cache_Free(&pic->cache); } Mem_Free(pWad->name); Mem_Free(pWad->cache); } Mem_Free(pCurrent->pInfo); } } Mem_Free(pCurrent); pCurrent = pNext; } pHead->pNext = NULL; }
/* =========== Cache_Move =========== */ static void Cache_Move ( cache_system_t *c) { cache_system_t *new_cs; // we are clearing up space at the bottom, so only allocate it late new_cs = Cache_TryAlloc (c->size, true); if (new_cs) { // Con_Printf ("cache_move ok\n"); memcpy (new_cs+1, c+1, c->size - sizeof(cache_system_t)); new_cs->user = c->user; memcpy (new_cs->name, c->name, sizeof(new_cs->name)); Cache_Free (c->user); new_cs->user->data = (void *)(new_cs + 1); } else { // Con_Printf ("cache_move failed\n"); Cache_Free (c->user); // tough luck... } }
/* ================ S_Restart ================ */ void S_Restart (void) { int i; S_Shutdown (); // flush all sounds for (i = 0; i < num_sfx; i++) { if (known_sfx[i].cache.data) Cache_Free (&known_sfx[i].cache); } S_Init (); }
/* ========== Skin_Skins_f Refind all skins, downloading if needed. ========== */ void Skin_Skins_f (void) { int i; for (i=0 ; i<numskins ; i++) { if (skins[i].cache.data) Cache_Free (&skins[i].cache); } numskins = 0; cls.downloadnumber = 0; cls.downloadtype = dl_skin; Skin_NextDownload (); }
/* ================== Mod_FindName ================== */ model_t *Mod_FindName (char *name) { int i; model_t *mod; model_t *avail = NULL; if (!name[0]) Sys_Error ("Mod_ForName: NULL name"); // // search the currently loaded models // for (i=0 , mod=mod_known ; i<mod_numknown ; i++, mod++) { if (!strcmp (mod->name, name) ) break; if (mod->needload == NL_UNREFERENCED) if (!avail || mod->type != mod_alias) avail = mod; } if (i == mod_numknown) { if (mod_numknown == MAX_MOD_KNOWN) { if (avail) { mod = avail; if (mod->type == mod_alias) if (Cache_Check (&mod->cache)) Cache_Free (&mod->cache); } else Sys_Error ("mod_numknown == MAX_MOD_KNOWN"); } else mod_numknown++; strcpy (mod->name, name); mod->needload = NL_NEEDS_LOADED; } return mod; }
/* * ============ * Cache_FreeHigh * * Throw things out until the hunk can be expanded to the given point * ============ */ static void Cache_FreeHigh(int new_high_hunk) { cache_system_t *c, *prev; prev = NULL; while (1) { c = cache_head.prev; if (c == &cache_head) return; /* nothing in cache at all */ if ((byte *)c + c->size <= hunk_base + hunk_size - new_high_hunk) return; /* there is space to grow the hunk */ if (c == prev) Cache_Free(c->user); /* didn't move out of the way */ else { Cache_Move(c); /* try to move it */ prev = c; } } }
//Refind all skins, downloading if needed. void Skin_Skins_f (void) { int i; for (i = 0; i < numskins; i++) { if (skins[i].cache.data) Cache_Free (&skins[i].cache); } numskins = 0; skins_need_preache = true; // we need precache it ASAP cls.downloadnumber = 0; cls.downloadtype = dl_skin; Skin_NextDownload (); if (cls.mvdplayback == QTV_PLAYBACK && cbuf_current != &cbuf_main) { cls.qtv_donotbuffer = false; } }
/* ============ Cache_FreeHigh Throw things out until the hunk can be expanded to the given point ============ */ void Cache_FreeHigh (int new_high_hunk) { cache_system_t *c, *prev; prev = NULL; while (1) { c = cache_head.prev; if (c == &cache_head) return; // nothing in cache at all if ( (byte *)c + c->size <= hunk_base + hunk_size - new_high_hunk) return; // there is space to grow the hunk if (c == prev) Cache_Free (c->user, true); // didn't move out of the way //johnfitz -- added second argument else { Cache_Move (c); // try to move it prev = c; } } }
/* ========== Skin_Skins_f Refind all skins, downloading if needed. ========== */ void Skin_Skins_f (void) { int i; for (i = 0; i < numskins; i++) { if (skins[i].cache.data) Cache_Free (&skins[i].cache); } numskins = 0; if (cls.state == ca_disconnected) { Con_Printf("%s: no connection to a server.\n", __thisfunc__); return; } cls.downloadnumber = 0; cls.downloadtype = dl_skin; Skin_NextDownload (); }
/* ============ Cache_FreeHigh Throw things out until the hunk can be expanded to the given point ============ */ void Cache_FreeHigh(int new_high_hunk) { cache_system_t *c, *prev; prev = NULL; while (1) { c = cache_head.prev; if (c == &cache_head) { return; // nothing in cache at all } if ((byte *)c + c->size <= hunk_base + hunk_size - new_high_hunk) { return; // there is space to grow the hunk } if (c == prev) { Cache_Free(c->user); // didn't move out of the way } else { Cache_Move(c); // try to move it prev = c; } } }
/* ============ Cache_Flush Throw everything out, so new data will be demand cached ============ */ void Cache_Flush (const quake::common::argv & argv) { while (cache_head.next != &cache_head) Cache_Free ( cache_head.next->user ); // reclaim the space }
/* ============ Cache_Flush Throw everything out, so newmem data will be demand cached ============ */ void Cache_Flush (void) { while (cache_head.next != &cache_head) Cache_Free ( cache_head.next->user ); // reclaim the space }
/* ============ Cache_Flush Throw everything out, so new data will be demand cached ============ */ void Cache_Flush (void) { while (cache_head.next != &cache_head) Cache_Free ( cache_head.next->user, true); // reclaim the space //johnfitz -- added second argument }
/* ========== Skin_Cache Returns a pointer to the skin bitmap, or NULL to use the default ========== */ byte *Skin_Cache (skin_t *skin) { char name[1024]; byte *raw; byte *out, *pix; pcx_t *pcx; int x, y; int dataByte; int runLength; if (cls.downloadtype == dl_skin) return NULL; // use base until downloaded if (noskins.value==1) // JACK: So NOSKINS > 1 will show skins, but return NULL; // not download new ones. if (skin->failedload) return NULL; out = Cache_Check (&skin->cache); if (out) return out; // // load the pic from disk // sprintf (name, "skins/%s.pcx", skin->name); raw = COM_LoadTempFile (name); if (!raw) { Con_Printf ("Couldn't load skin %s\n", name); sprintf (name, "skins/%s.pcx", baseskin.string); raw = COM_LoadTempFile (name); if (!raw) { skin->failedload = true; return NULL; } } // // parse the PCX file // pcx = (pcx_t *)raw; raw = &pcx->data; if (pcx->manufacturer != 0x0a || pcx->version != 5 || pcx->encoding != 1 || pcx->bits_per_pixel != 8 || pcx->xmax >= 320 || pcx->ymax >= 200) { skin->failedload = true; Con_Printf ("Bad skin %s\n", name); return NULL; } out = Cache_Alloc (&skin->cache, 320*200, skin->name); if (!out) Sys_Error ("Skin_Cache: couldn't allocate"); pix = out; memset (out, 0, 320*200); for (y=0 ; y<pcx->ymax ; y++, pix += 320) { for (x=0 ; x<=pcx->xmax ; ) { if (raw - (byte*)pcx > com_filesize) { Cache_Free (&skin->cache); skin->failedload = true; Con_Printf ("Skin %s was malformed. You should delete it.\n", name); return NULL; } dataByte = *raw++; if((dataByte & 0xC0) == 0xC0) { runLength = dataByte & 0x3F; if (raw - (byte*)pcx > com_filesize) { Cache_Free (&skin->cache); skin->failedload = true; Con_Printf ("Skin %s was malformed. You should delete it.\n", name); return NULL; } dataByte = *raw++; } else runLength = 1; // skin sanity check if (runLength + x > pcx->xmax + 2) { Cache_Free (&skin->cache); skin->failedload = true; Con_Printf ("Skin %s was malformed. You should delete it.\n", name); return NULL; } while(runLength-- > 0) pix[x++] = dataByte; } } if ( raw - (byte *)pcx > com_filesize) { Cache_Free (&skin->cache); skin->failedload = true; Con_Printf ("Skin %s was malformed. You should delete it.\n", name); return NULL; } skin->failedload = false; return out; }