From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/imbuf/intern/moviecache.c | 696 ++++++++++++++++--------------- 1 file changed, 353 insertions(+), 343 deletions(-) (limited to 'source/blender/imbuf/intern/moviecache.c') diff --git a/source/blender/imbuf/intern/moviecache.c b/source/blender/imbuf/intern/moviecache.c index 78a45d29775..fe6909b0f3f 100644 --- a/source/blender/imbuf/intern/moviecache.c +++ b/source/blender/imbuf/intern/moviecache.c @@ -42,7 +42,7 @@ #ifdef DEBUG_MESSAGES # if defined __GNUC__ -# define PRINT(format, args ...) printf(format, ##args) +# define PRINT(format, args...) printf(format, ##args) # else # define PRINT(format, ...) printf(__VA_ARGS__) # endif @@ -54,552 +54,562 @@ static MEM_CacheLimiterC *limitor = NULL; static pthread_mutex_t limitor_lock = BLI_MUTEX_INITIALIZER; typedef struct MovieCache { - char name[64]; + char name[64]; - GHash *hash; - GHashHashFP hashfp; - GHashCmpFP cmpfp; - MovieCacheGetKeyDataFP getdatafp; + GHash *hash; + GHashHashFP hashfp; + GHashCmpFP cmpfp; + MovieCacheGetKeyDataFP getdatafp; - MovieCacheGetPriorityDataFP getprioritydatafp; - MovieCacheGetItemPriorityFP getitempriorityfp; - MovieCachePriorityDeleterFP prioritydeleterfp; + MovieCacheGetPriorityDataFP getprioritydatafp; + MovieCacheGetItemPriorityFP getitempriorityfp; + MovieCachePriorityDeleterFP prioritydeleterfp; - struct BLI_mempool *keys_pool; - struct BLI_mempool *items_pool; - struct BLI_mempool *userkeys_pool; + struct BLI_mempool *keys_pool; + struct BLI_mempool *items_pool; + struct BLI_mempool *userkeys_pool; - int keysize; + int keysize; - void *last_userkey; + void *last_userkey; - int totseg, *points, proxy, render_flags; /* for visual statistics optimization */ - int pad; + int totseg, *points, proxy, render_flags; /* for visual statistics optimization */ + int pad; } MovieCache; typedef struct MovieCacheKey { - MovieCache *cache_owner; - void *userkey; + MovieCache *cache_owner; + void *userkey; } MovieCacheKey; typedef struct MovieCacheItem { - MovieCache *cache_owner; - ImBuf *ibuf; - MEM_CacheLimiterHandleC *c_handle; - void *priority_data; + MovieCache *cache_owner; + ImBuf *ibuf; + MEM_CacheLimiterHandleC *c_handle; + void *priority_data; } MovieCacheItem; static unsigned int moviecache_hashhash(const void *keyv) { - const MovieCacheKey *key = keyv; + const MovieCacheKey *key = keyv; - return key->cache_owner->hashfp(key->userkey); + return key->cache_owner->hashfp(key->userkey); } static bool moviecache_hashcmp(const void *av, const void *bv) { - const MovieCacheKey *a = av; - const MovieCacheKey *b = bv; + const MovieCacheKey *a = av; + const MovieCacheKey *b = bv; - return a->cache_owner->cmpfp(a->userkey, b->userkey); + return a->cache_owner->cmpfp(a->userkey, b->userkey); } static void moviecache_keyfree(void *val) { - MovieCacheKey *key = val; + MovieCacheKey *key = val; - BLI_mempool_free(key->cache_owner->userkeys_pool, key->userkey); + BLI_mempool_free(key->cache_owner->userkeys_pool, key->userkey); - BLI_mempool_free(key->cache_owner->keys_pool, key); + BLI_mempool_free(key->cache_owner->keys_pool, key); } static void moviecache_valfree(void *val) { - MovieCacheItem *item = (MovieCacheItem *)val; - MovieCache *cache = item->cache_owner; + MovieCacheItem *item = (MovieCacheItem *)val; + MovieCache *cache = item->cache_owner; - PRINT("%s: cache '%s' free item %p buffer %p\n", __func__, cache->name, item, item->ibuf); + PRINT("%s: cache '%s' free item %p buffer %p\n", __func__, cache->name, item, item->ibuf); - if (item->ibuf) { - MEM_CacheLimiter_unmanage(item->c_handle); - IMB_freeImBuf(item->ibuf); - } + if (item->ibuf) { + MEM_CacheLimiter_unmanage(item->c_handle); + IMB_freeImBuf(item->ibuf); + } - if (item->priority_data && cache->prioritydeleterfp) { - cache->prioritydeleterfp(item->priority_data); - } + if (item->priority_data && cache->prioritydeleterfp) { + cache->prioritydeleterfp(item->priority_data); + } - BLI_mempool_free(item->cache_owner->items_pool, item); + BLI_mempool_free(item->cache_owner->items_pool, item); } static void check_unused_keys(MovieCache *cache) { - GHashIterator gh_iter; + GHashIterator gh_iter; - BLI_ghashIterator_init(&gh_iter, cache->hash); + BLI_ghashIterator_init(&gh_iter, cache->hash); - while (!BLI_ghashIterator_done(&gh_iter)) { - const MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); - const MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); - bool remove; + while (!BLI_ghashIterator_done(&gh_iter)) { + const MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); + const MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); + bool remove; - BLI_ghashIterator_step(&gh_iter); + BLI_ghashIterator_step(&gh_iter); - remove = !item->ibuf; + remove = !item->ibuf; - if (remove) { - PRINT("%s: cache '%s' remove item %p without buffer\n", __func__, cache->name, item); - } + if (remove) { + PRINT("%s: cache '%s' remove item %p without buffer\n", __func__, cache->name, item); + } - if (remove) - BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree); - } + if (remove) + BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree); + } } static int compare_int(const void *av, const void *bv) { - const int *a = av; - const int *b = bv; - return *a - *b; + const int *a = av; + const int *b = bv; + return *a - *b; } static void IMB_moviecache_destructor(void *p) { - MovieCacheItem *item = (MovieCacheItem *)p; + MovieCacheItem *item = (MovieCacheItem *)p; - if (item && item->ibuf) { - MovieCache *cache = item->cache_owner; + if (item && item->ibuf) { + MovieCache *cache = item->cache_owner; - PRINT("%s: cache '%s' destroy item %p buffer %p\n", __func__, cache->name, item, item->ibuf); + PRINT("%s: cache '%s' destroy item %p buffer %p\n", __func__, cache->name, item, item->ibuf); - IMB_freeImBuf(item->ibuf); + IMB_freeImBuf(item->ibuf); - item->ibuf = NULL; - item->c_handle = NULL; + item->ibuf = NULL; + item->c_handle = NULL; - /* force cached segments to be updated */ - if (cache->points) { - MEM_freeN(cache->points); - cache->points = NULL; - } - } + /* force cached segments to be updated */ + if (cache->points) { + MEM_freeN(cache->points); + cache->points = NULL; + } + } } /* approximate size of ImBuf in memory */ static size_t IMB_get_size_in_memory(ImBuf *ibuf) { - int a; - size_t size = 0, channel_size = 0; - - /* Persistent images should have no affect on how "normal" - * images are cached. - * - * This is a bit arbitrary, but would make it so only movies - * and sequences are memory limited, keeping textures in the - * memory in order to avoid constant file reload on viewport - * update. - */ - if (ibuf->userflags & IB_PERSISTENT) { - return 0; - } - - size += sizeof(ImBuf); - - if (ibuf->rect) - channel_size += sizeof(char); - - if (ibuf->rect_float) - channel_size += sizeof(float); - - size += channel_size * ibuf->x * ibuf->y * ibuf->channels; - - if (ibuf->miptot) { - for (a = 0; a < ibuf->miptot; a++) { - if (ibuf->mipmap[a]) - size += IMB_get_size_in_memory(ibuf->mipmap[a]); - } - } - - if (ibuf->tiles) { - size += sizeof(unsigned int) * ibuf->ytiles * ibuf->xtiles; - } - - return size; + int a; + size_t size = 0, channel_size = 0; + + /* Persistent images should have no affect on how "normal" + * images are cached. + * + * This is a bit arbitrary, but would make it so only movies + * and sequences are memory limited, keeping textures in the + * memory in order to avoid constant file reload on viewport + * update. + */ + if (ibuf->userflags & IB_PERSISTENT) { + return 0; + } + + size += sizeof(ImBuf); + + if (ibuf->rect) + channel_size += sizeof(char); + + if (ibuf->rect_float) + channel_size += sizeof(float); + + size += channel_size * ibuf->x * ibuf->y * ibuf->channels; + + if (ibuf->miptot) { + for (a = 0; a < ibuf->miptot; a++) { + if (ibuf->mipmap[a]) + size += IMB_get_size_in_memory(ibuf->mipmap[a]); + } + } + + if (ibuf->tiles) { + size += sizeof(unsigned int) * ibuf->ytiles * ibuf->xtiles; + } + + return size; } static size_t get_item_size(void *p) { - size_t size = sizeof(MovieCacheItem); - MovieCacheItem *item = (MovieCacheItem *) p; + size_t size = sizeof(MovieCacheItem); + MovieCacheItem *item = (MovieCacheItem *)p; - if (item->ibuf) - size += IMB_get_size_in_memory(item->ibuf); + if (item->ibuf) + size += IMB_get_size_in_memory(item->ibuf); - return size; + return size; } static int get_item_priority(void *item_v, int default_priority) { - MovieCacheItem *item = (MovieCacheItem *) item_v; - MovieCache *cache = item->cache_owner; - int priority; + MovieCacheItem *item = (MovieCacheItem *)item_v; + MovieCache *cache = item->cache_owner; + int priority; - if (!cache->getitempriorityfp) { - PRINT("%s: cache '%s' item %p use default priority %d\n", __func__, cache-> name, item, default_priority); + if (!cache->getitempriorityfp) { + PRINT("%s: cache '%s' item %p use default priority %d\n", + __func__, + cache->name, + item, + default_priority); - return default_priority; - } + return default_priority; + } - priority = cache->getitempriorityfp(cache->last_userkey, item->priority_data); + priority = cache->getitempriorityfp(cache->last_userkey, item->priority_data); - PRINT("%s: cache '%s' item %p priority %d\n", __func__, cache-> name, item, priority); + PRINT("%s: cache '%s' item %p priority %d\n", __func__, cache->name, item, priority); - return priority; + return priority; } static bool get_item_destroyable(void *item_v) { - MovieCacheItem *item = (MovieCacheItem *) item_v; - /* IB_BITMAPDIRTY means image was modified from inside blender and - * changes are not saved to disk. - * - * Such buffers are never to be freed. - */ - if ((item->ibuf->userflags & IB_BITMAPDIRTY) || - (item->ibuf->userflags & IB_PERSISTENT)) - { - return false; - } - return true; + MovieCacheItem *item = (MovieCacheItem *)item_v; + /* IB_BITMAPDIRTY means image was modified from inside blender and + * changes are not saved to disk. + * + * Such buffers are never to be freed. + */ + if ((item->ibuf->userflags & IB_BITMAPDIRTY) || (item->ibuf->userflags & IB_PERSISTENT)) { + return false; + } + return true; } void IMB_moviecache_init(void) { - limitor = new_MEM_CacheLimiter(IMB_moviecache_destructor, get_item_size); + limitor = new_MEM_CacheLimiter(IMB_moviecache_destructor, get_item_size); - MEM_CacheLimiter_ItemPriority_Func_set(limitor, get_item_priority); - MEM_CacheLimiter_ItemDestroyable_Func_set(limitor, get_item_destroyable); + MEM_CacheLimiter_ItemPriority_Func_set(limitor, get_item_priority); + MEM_CacheLimiter_ItemDestroyable_Func_set(limitor, get_item_destroyable); } void IMB_moviecache_destruct(void) { - if (limitor) - delete_MEM_CacheLimiter(limitor); + if (limitor) + delete_MEM_CacheLimiter(limitor); } -MovieCache *IMB_moviecache_create(const char *name, int keysize, GHashHashFP hashfp, GHashCmpFP cmpfp) +MovieCache *IMB_moviecache_create(const char *name, + int keysize, + GHashHashFP hashfp, + GHashCmpFP cmpfp) { - MovieCache *cache; + MovieCache *cache; - PRINT("%s: cache '%s' create\n", __func__, name); + PRINT("%s: cache '%s' create\n", __func__, name); - cache = MEM_callocN(sizeof(MovieCache), "MovieCache"); + cache = MEM_callocN(sizeof(MovieCache), "MovieCache"); - BLI_strncpy(cache->name, name, sizeof(cache->name)); + BLI_strncpy(cache->name, name, sizeof(cache->name)); - cache->keys_pool = BLI_mempool_create(sizeof(MovieCacheKey), 0, 64, BLI_MEMPOOL_NOP); - cache->items_pool = BLI_mempool_create(sizeof(MovieCacheItem), 0, 64, BLI_MEMPOOL_NOP); - cache->userkeys_pool = BLI_mempool_create(keysize, 0, 64, BLI_MEMPOOL_NOP); - cache->hash = BLI_ghash_new(moviecache_hashhash, moviecache_hashcmp, "MovieClip ImBuf cache hash"); + cache->keys_pool = BLI_mempool_create(sizeof(MovieCacheKey), 0, 64, BLI_MEMPOOL_NOP); + cache->items_pool = BLI_mempool_create(sizeof(MovieCacheItem), 0, 64, BLI_MEMPOOL_NOP); + cache->userkeys_pool = BLI_mempool_create(keysize, 0, 64, BLI_MEMPOOL_NOP); + cache->hash = BLI_ghash_new( + moviecache_hashhash, moviecache_hashcmp, "MovieClip ImBuf cache hash"); - cache->keysize = keysize; - cache->hashfp = hashfp; - cache->cmpfp = cmpfp; - cache->proxy = -1; + cache->keysize = keysize; + cache->hashfp = hashfp; + cache->cmpfp = cmpfp; + cache->proxy = -1; - return cache; + return cache; } void IMB_moviecache_set_getdata_callback(MovieCache *cache, MovieCacheGetKeyDataFP getdatafp) { - cache->getdatafp = getdatafp; + cache->getdatafp = getdatafp; } -void IMB_moviecache_set_priority_callback(struct MovieCache *cache, MovieCacheGetPriorityDataFP getprioritydatafp, +void IMB_moviecache_set_priority_callback(struct MovieCache *cache, + MovieCacheGetPriorityDataFP getprioritydatafp, MovieCacheGetItemPriorityFP getitempriorityfp, MovieCachePriorityDeleterFP prioritydeleterfp) { - cache->last_userkey = MEM_mallocN(cache->keysize, "movie cache last user key"); + cache->last_userkey = MEM_mallocN(cache->keysize, "movie cache last user key"); - cache->getprioritydatafp = getprioritydatafp; - cache->getitempriorityfp = getitempriorityfp; - cache->prioritydeleterfp = prioritydeleterfp; + cache->getprioritydatafp = getprioritydatafp; + cache->getitempriorityfp = getitempriorityfp; + cache->prioritydeleterfp = prioritydeleterfp; } static void do_moviecache_put(MovieCache *cache, void *userkey, ImBuf *ibuf, bool need_lock) { - MovieCacheKey *key; - MovieCacheItem *item; + MovieCacheKey *key; + MovieCacheItem *item; - if (!limitor) - IMB_moviecache_init(); + if (!limitor) + IMB_moviecache_init(); - IMB_refImBuf(ibuf); + IMB_refImBuf(ibuf); - key = BLI_mempool_alloc(cache->keys_pool); - key->cache_owner = cache; - key->userkey = BLI_mempool_alloc(cache->userkeys_pool); - memcpy(key->userkey, userkey, cache->keysize); + key = BLI_mempool_alloc(cache->keys_pool); + key->cache_owner = cache; + key->userkey = BLI_mempool_alloc(cache->userkeys_pool); + memcpy(key->userkey, userkey, cache->keysize); - item = BLI_mempool_alloc(cache->items_pool); + item = BLI_mempool_alloc(cache->items_pool); - PRINT("%s: cache '%s' put %p, item %p\n", __func__, cache-> name, ibuf, item); + PRINT("%s: cache '%s' put %p, item %p\n", __func__, cache->name, ibuf, item); - item->ibuf = ibuf; - item->cache_owner = cache; - item->c_handle = NULL; - item->priority_data = NULL; + item->ibuf = ibuf; + item->cache_owner = cache; + item->c_handle = NULL; + item->priority_data = NULL; - if (cache->getprioritydatafp) { - item->priority_data = cache->getprioritydatafp(userkey); - } + if (cache->getprioritydatafp) { + item->priority_data = cache->getprioritydatafp(userkey); + } - BLI_ghash_reinsert(cache->hash, key, item, moviecache_keyfree, moviecache_valfree); + BLI_ghash_reinsert(cache->hash, key, item, moviecache_keyfree, moviecache_valfree); - if (cache->last_userkey) { - memcpy(cache->last_userkey, userkey, cache->keysize); - } + if (cache->last_userkey) { + memcpy(cache->last_userkey, userkey, cache->keysize); + } - if (need_lock) - BLI_mutex_lock(&limitor_lock); + if (need_lock) + BLI_mutex_lock(&limitor_lock); - item->c_handle = MEM_CacheLimiter_insert(limitor, item); + item->c_handle = MEM_CacheLimiter_insert(limitor, item); - MEM_CacheLimiter_ref(item->c_handle); - MEM_CacheLimiter_enforce_limits(limitor); - MEM_CacheLimiter_unref(item->c_handle); + MEM_CacheLimiter_ref(item->c_handle); + MEM_CacheLimiter_enforce_limits(limitor); + MEM_CacheLimiter_unref(item->c_handle); - if (need_lock) - BLI_mutex_unlock(&limitor_lock); + if (need_lock) + BLI_mutex_unlock(&limitor_lock); - /* cache limiter can't remove unused keys which points to destroyed values */ - check_unused_keys(cache); + /* cache limiter can't remove unused keys which points to destroyed values */ + check_unused_keys(cache); - if (cache->points) { - MEM_freeN(cache->points); - cache->points = NULL; - } + if (cache->points) { + MEM_freeN(cache->points); + cache->points = NULL; + } } void IMB_moviecache_put(MovieCache *cache, void *userkey, ImBuf *ibuf) { - do_moviecache_put(cache, userkey, ibuf, true); + do_moviecache_put(cache, userkey, ibuf, true); } bool IMB_moviecache_put_if_possible(MovieCache *cache, void *userkey, ImBuf *ibuf) { - size_t mem_in_use, mem_limit, elem_size; - bool result = false; + size_t mem_in_use, mem_limit, elem_size; + bool result = false; - elem_size = IMB_get_size_in_memory(ibuf); - mem_limit = MEM_CacheLimiter_get_maximum(); + elem_size = IMB_get_size_in_memory(ibuf); + mem_limit = MEM_CacheLimiter_get_maximum(); - BLI_mutex_lock(&limitor_lock); - mem_in_use = MEM_CacheLimiter_get_memory_in_use(limitor); + BLI_mutex_lock(&limitor_lock); + mem_in_use = MEM_CacheLimiter_get_memory_in_use(limitor); - if (mem_in_use + elem_size <= mem_limit) { - do_moviecache_put(cache, userkey, ibuf, false); - result = true; - } + if (mem_in_use + elem_size <= mem_limit) { + do_moviecache_put(cache, userkey, ibuf, false); + result = true; + } - BLI_mutex_unlock(&limitor_lock); + BLI_mutex_unlock(&limitor_lock); - return result; + return result; } ImBuf *IMB_moviecache_get(MovieCache *cache, void *userkey) { - MovieCacheKey key; - MovieCacheItem *item; + MovieCacheKey key; + MovieCacheItem *item; - key.cache_owner = cache; - key.userkey = userkey; - item = (MovieCacheItem *)BLI_ghash_lookup(cache->hash, &key); + key.cache_owner = cache; + key.userkey = userkey; + item = (MovieCacheItem *)BLI_ghash_lookup(cache->hash, &key); - if (item) { - if (item->ibuf) { - BLI_mutex_lock(&limitor_lock); - MEM_CacheLimiter_touch(item->c_handle); - BLI_mutex_unlock(&limitor_lock); + if (item) { + if (item->ibuf) { + BLI_mutex_lock(&limitor_lock); + MEM_CacheLimiter_touch(item->c_handle); + BLI_mutex_unlock(&limitor_lock); - IMB_refImBuf(item->ibuf); + IMB_refImBuf(item->ibuf); - return item->ibuf; - } - } + return item->ibuf; + } + } - return NULL; + return NULL; } bool IMB_moviecache_has_frame(MovieCache *cache, void *userkey) { - MovieCacheKey key; - MovieCacheItem *item; + MovieCacheKey key; + MovieCacheItem *item; - key.cache_owner = cache; - key.userkey = userkey; - item = (MovieCacheItem *)BLI_ghash_lookup(cache->hash, &key); + key.cache_owner = cache; + key.userkey = userkey; + item = (MovieCacheItem *)BLI_ghash_lookup(cache->hash, &key); - return item != NULL; + return item != NULL; } void IMB_moviecache_free(MovieCache *cache) { - PRINT("%s: cache '%s' free\n", __func__, cache->name); + PRINT("%s: cache '%s' free\n", __func__, cache->name); - BLI_ghash_free(cache->hash, moviecache_keyfree, moviecache_valfree); + BLI_ghash_free(cache->hash, moviecache_keyfree, moviecache_valfree); - BLI_mempool_destroy(cache->keys_pool); - BLI_mempool_destroy(cache->items_pool); - BLI_mempool_destroy(cache->userkeys_pool); + BLI_mempool_destroy(cache->keys_pool); + BLI_mempool_destroy(cache->items_pool); + BLI_mempool_destroy(cache->userkeys_pool); - if (cache->points) - MEM_freeN(cache->points); + if (cache->points) + MEM_freeN(cache->points); - if (cache->last_userkey) - MEM_freeN(cache->last_userkey); + if (cache->last_userkey) + MEM_freeN(cache->last_userkey); - MEM_freeN(cache); + MEM_freeN(cache); } -void IMB_moviecache_cleanup(MovieCache *cache, bool (cleanup_check_cb) (ImBuf *ibuf, void *userkey, void *userdata), void *userdata) +void IMB_moviecache_cleanup(MovieCache *cache, + bool(cleanup_check_cb)(ImBuf *ibuf, void *userkey, void *userdata), + void *userdata) { - GHashIterator gh_iter; + GHashIterator gh_iter; - check_unused_keys(cache); + check_unused_keys(cache); - BLI_ghashIterator_init(&gh_iter, cache->hash); + BLI_ghashIterator_init(&gh_iter, cache->hash); - while (!BLI_ghashIterator_done(&gh_iter)) { - MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); - MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); + while (!BLI_ghashIterator_done(&gh_iter)) { + MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); + MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); - BLI_ghashIterator_step(&gh_iter); + BLI_ghashIterator_step(&gh_iter); - if (cleanup_check_cb(item->ibuf, key->userkey, userdata)) { - PRINT("%s: cache '%s' remove item %p\n", __func__, cache->name, item); + if (cleanup_check_cb(item->ibuf, key->userkey, userdata)) { + PRINT("%s: cache '%s' remove item %p\n", __func__, cache->name, item); - BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree); - } - } + BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree); + } + } } /* get segments of cached frames. useful for debugging cache policies */ -void IMB_moviecache_get_cache_segments(MovieCache *cache, int proxy, int render_flags, int *totseg_r, int **points_r) +void IMB_moviecache_get_cache_segments( + MovieCache *cache, int proxy, int render_flags, int *totseg_r, int **points_r) { - *totseg_r = 0; - *points_r = NULL; - - if (!cache->getdatafp) - return; - - if (cache->proxy != proxy || cache->render_flags != render_flags) { - if (cache->points) - MEM_freeN(cache->points); - - cache->points = NULL; - } - - if (cache->points) { - *totseg_r = cache->totseg; - *points_r = cache->points; - } - else { - int totframe = BLI_ghash_len(cache->hash); - int *frames = MEM_callocN(totframe * sizeof(int), "movieclip cache frames"); - int a, totseg = 0; - GHashIterator gh_iter; - - a = 0; - GHASH_ITER(gh_iter, cache->hash) { - MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); - MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); - int framenr, curproxy, curflags; - - if (item->ibuf) { - cache->getdatafp(key->userkey, &framenr, &curproxy, &curflags); - - if (curproxy == proxy && curflags == render_flags) - frames[a++] = framenr; - } - } - - qsort(frames, totframe, sizeof(int), compare_int); - - /* count */ - for (a = 0; a < totframe; a++) { - if (a && frames[a] - frames[a - 1] != 1) - totseg++; - - if (a == totframe - 1) - totseg++; - } - - if (totseg) { - int b, *points; - - points = MEM_callocN(2 * sizeof(int) * totseg, "movieclip cache segments"); - - /* fill */ - for (a = 0, b = 0; a < totframe; a++) { - if (a == 0) - points[b++] = frames[a]; - - if (a && frames[a] - frames[a - 1] != 1) { - points[b++] = frames[a - 1]; - points[b++] = frames[a]; - } - - if (a == totframe - 1) - points[b++] = frames[a]; - } - - *totseg_r = totseg; - *points_r = points; - - cache->totseg = totseg; - cache->points = points; - cache->proxy = proxy; - cache->render_flags = render_flags; - } - - MEM_freeN(frames); - } + *totseg_r = 0; + *points_r = NULL; + + if (!cache->getdatafp) + return; + + if (cache->proxy != proxy || cache->render_flags != render_flags) { + if (cache->points) + MEM_freeN(cache->points); + + cache->points = NULL; + } + + if (cache->points) { + *totseg_r = cache->totseg; + *points_r = cache->points; + } + else { + int totframe = BLI_ghash_len(cache->hash); + int *frames = MEM_callocN(totframe * sizeof(int), "movieclip cache frames"); + int a, totseg = 0; + GHashIterator gh_iter; + + a = 0; + GHASH_ITER (gh_iter, cache->hash) { + MovieCacheKey *key = BLI_ghashIterator_getKey(&gh_iter); + MovieCacheItem *item = BLI_ghashIterator_getValue(&gh_iter); + int framenr, curproxy, curflags; + + if (item->ibuf) { + cache->getdatafp(key->userkey, &framenr, &curproxy, &curflags); + + if (curproxy == proxy && curflags == render_flags) + frames[a++] = framenr; + } + } + + qsort(frames, totframe, sizeof(int), compare_int); + + /* count */ + for (a = 0; a < totframe; a++) { + if (a && frames[a] - frames[a - 1] != 1) + totseg++; + + if (a == totframe - 1) + totseg++; + } + + if (totseg) { + int b, *points; + + points = MEM_callocN(2 * sizeof(int) * totseg, "movieclip cache segments"); + + /* fill */ + for (a = 0, b = 0; a < totframe; a++) { + if (a == 0) + points[b++] = frames[a]; + + if (a && frames[a] - frames[a - 1] != 1) { + points[b++] = frames[a - 1]; + points[b++] = frames[a]; + } + + if (a == totframe - 1) + points[b++] = frames[a]; + } + + *totseg_r = totseg; + *points_r = points; + + cache->totseg = totseg; + cache->points = points; + cache->proxy = proxy; + cache->render_flags = render_flags; + } + + MEM_freeN(frames); + } } struct MovieCacheIter *IMB_moviecacheIter_new(MovieCache *cache) { - GHashIterator *iter; + GHashIterator *iter; - check_unused_keys(cache); - iter = BLI_ghashIterator_new(cache->hash); + check_unused_keys(cache); + iter = BLI_ghashIterator_new(cache->hash); - return (struct MovieCacheIter *) iter; + return (struct MovieCacheIter *)iter; } void IMB_moviecacheIter_free(struct MovieCacheIter *iter) { - BLI_ghashIterator_free((GHashIterator *) iter); + BLI_ghashIterator_free((GHashIterator *)iter); } bool IMB_moviecacheIter_done(struct MovieCacheIter *iter) { - return BLI_ghashIterator_done((GHashIterator *) iter); + return BLI_ghashIterator_done((GHashIterator *)iter); } void IMB_moviecacheIter_step(struct MovieCacheIter *iter) { - BLI_ghashIterator_step((GHashIterator *) iter); + BLI_ghashIterator_step((GHashIterator *)iter); } ImBuf *IMB_moviecacheIter_getImBuf(struct MovieCacheIter *iter) { - MovieCacheItem *item = BLI_ghashIterator_getValue((GHashIterator *) iter); - return item->ibuf; + MovieCacheItem *item = BLI_ghashIterator_getValue((GHashIterator *)iter); + return item->ibuf; } void *IMB_moviecacheIter_getUserKey(struct MovieCacheIter *iter) { - MovieCacheKey *key = BLI_ghashIterator_getKey((GHashIterator *) iter); - return key->userkey; + MovieCacheKey *key = BLI_ghashIterator_getKey((GHashIterator *)iter); + return key->userkey; } -- cgit v1.2.3