Differential D9481 Diff 30800 source/blender/sequencer/intern/image_cache.c

Changeset View

Standalone View

source/blender/sequencer/intern/image_cache.c

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines

typedef struct SeqCache {		typedef struct SeqCache {
Main *bmain;		Main *bmain;
struct GHash *hash;		struct GHash *hash;
ThreadMutex iterator_mutex;		ThreadMutex iterator_mutex;
struct BLI_mempool *keys_pool;		struct BLI_mempool *keys_pool;
struct BLI_mempool *items_pool;		struct BLI_mempool *items_pool;
struct SeqCacheKey *last_key;		struct SeqCacheKey *last_key;
size_t memory_used;
SeqDiskCache *disk_cache;		SeqDiskCache *disk_cache;
} SeqCache;		} SeqCache;

typedef struct SeqCacheItem {		typedef struct SeqCacheItem {
struct SeqCache *cache_owner;		struct SeqCache *cache_owner;
struct ImBuf *ibuf;		struct ImBuf *ibuf;
} SeqCacheItem;		} SeqCacheItem;

▲ Show 20 Lines • Show All 633 Lines • ▼ Show 20 Lines
{		{
SeqCacheKey *key = val;		SeqCacheKey *key = val;
BLI_mempool_free(key->cache_owner->keys_pool, key);		BLI_mempool_free(key->cache_owner->keys_pool, key);
}		}

static void seq_cache_valfree(void *val)		static void seq_cache_valfree(void *val)
{		{
SeqCacheItem item = (SeqCacheItem )val;		SeqCacheItem item = (SeqCacheItem )val;
SeqCache *cache = item->cache_owner;

if (item->ibuf) {		if (item->ibuf) {
cache->memory_used -= IMB_get_size_in_memory(item->ibuf);
IMB_freeImBuf(item->ibuf);		IMB_freeImBuf(item->ibuf);
}		}

BLI_mempool_free(item->cache_owner->items_pool, item);		BLI_mempool_free(item->cache_owner->items_pool, item);
}		}

static void seq_cache_put(SeqCache cache, SeqCacheKey key, ImBuf *ibuf)		static void seq_cache_put(SeqCache cache, SeqCacheKey key, ImBuf *ibuf)
{		{
SeqCacheItem *item;		SeqCacheItem *item;
item = BLI_mempool_alloc(cache->items_pool);		item = BLI_mempool_alloc(cache->items_pool);
item->cache_owner = cache;		item->cache_owner = cache;
item->ibuf = ibuf;		item->ibuf = ibuf;

if (BLI_ghash_reinsert(cache->hash, key, item, seq_cache_keyfree, seq_cache_valfree)) {		if (BLI_ghash_reinsert(cache->hash, key, item, seq_cache_keyfree, seq_cache_valfree)) {
IMB_refImBuf(ibuf);		IMB_refImBuf(ibuf);
cache->last_key = key;		cache->last_key = key;
cache->memory_used += IMB_get_size_in_memory(ibuf);
}		}
}		}

static ImBuf seq_cache_get(SeqCache cache, SeqCacheKey *key)		static ImBuf seq_cache_get(SeqCache cache, SeqCacheKey *key)
{		{
SeqCacheItem *item = BLI_ghash_lookup(cache->hash, key);		SeqCacheItem *item = BLI_ghash_lookup(cache->hash, key);

if (item && item->ibuf) {		if (item && item->ibuf) {
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines	static SeqCacheKey seq_cache_get_item_for_removal(Scene scene)
return finalkey;		return finalkey;
}		}

/* Find only "base" keys.		/* Find only "base" keys.
* Sources(other types) for a frame must be freed all at once.		* Sources(other types) for a frame must be freed all at once.
*/		*/
bool BKE_sequencer_cache_recycle_item(Scene *scene)		bool BKE_sequencer_cache_recycle_item(Scene *scene)
{		{
size_t memory_total = seq_cache_get_mem_total();
SeqCache *cache = seq_cache_get_from_scene(scene);		SeqCache *cache = seq_cache_get_from_scene(scene);
if (!cache) {		if (!cache) {
return false;		return false;
}		}

seq_cache_lock(scene);		seq_cache_lock(scene);

while (cache->memory_used > memory_total) {		while (BKE_sequencer_cache_is_full()) {
SeqCacheKey *finalkey = seq_cache_get_item_for_removal(scene);		SeqCacheKey *finalkey = seq_cache_get_item_for_removal(scene);

if (finalkey) {		if (finalkey) {
seq_cache_recycle_linked(scene, finalkey);		seq_cache_recycle_linked(scene, finalkey);
}		}
else {		else {
seq_cache_unlock(scene);		seq_cache_unlock(scene);
return false;		return false;
▲ Show 20 Lines • Show All 447 Lines • ▼ Show 20 Lines	while (!BLI_ghashIterator_done(&gh_iter) && !interrupt) {

interrupt = callback_iter(userdata, key->seq, key->timeline_frame, key->type, key->cost);		interrupt = callback_iter(userdata, key->seq, key->timeline_frame, key->type, key->cost);
}		}

cache->last_key = NULL;		cache->last_key = NULL;
seq_cache_unlock(scene);		seq_cache_unlock(scene);
}		}

bool BKE_sequencer_cache_is_full(Scene *scene)		bool BKE_sequencer_cache_is_full()
{		{
size_t memory_total = seq_cache_get_mem_total();		return seq_cache_get_mem_total() < MEM_get_memory_in_use();
SeqCache *cache = seq_cache_get_from_scene(scene);
if (!cache) {
return false;
}

return memory_total < cache->memory_used;
}		}