svn merge ^/trunk/blender -r41230:41266
authorCampbell Barton <ideasman42@gmail.com>
Mon, 24 Oct 2011 23:06:27 +0000 (23:06 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 24 Oct 2011 23:06:27 +0000 (23:06 +0000)
14 files changed:
1  2 
intern/itasc/ConstraintSet.cpp
intern/itasc/ControlledObject.cpp
intern/itasc/CopyPose.cpp
intern/itasc/Scene.cpp
intern/itasc/WDLSSolver.cpp
intern/itasc/WSDLSSolver.cpp
release/scripts/startup/bl_operators/wm.py
release/scripts/startup/bl_ui/properties_particle.py
source/blender/blenkernel/intern/blender.c
source/blender/blenkernel/intern/library.c
source/blender/blenlib/BLI_math_vector.h
source/blender/blenlib/intern/math_vector_inline.c
source/blender/imbuf/intern/moviecache.c
source/blender/render/intern/source/convertblender.c

Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,7492b6a..48aa019
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,382 +1,382 @@@
 -      cache->keys_pool= BLI_mempool_create(sizeof(MovieCacheKey), 64, 64, 0);
 -      cache->items_pool= BLI_mempool_create(sizeof(MovieCacheItem), 64, 64, 0);
 -      cache->userkeys_pool= BLI_mempool_create(keysize, 64, 64, 0);
+ /*
+  * ***** BEGIN GPL LICENSE BLOCK *****
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU General Public License
+  * as published by the Free Software Foundation; either version 2
+  * of the License, or (at your option) any later version.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software Foundation,
+  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+  *
+  * The Original Code is Copyright (C) 2011 Blender Foundation.
+  * All rights reserved.
+  *
+  * Contributor(s): Blender Foundation,
+  *                 Sergey Sharybin,
+  *                 Peter Schlaile
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file blender/blenkernel/intern/moviecache.c
+  *  \ingroup bke
+  */
+ #include <stdlib.h> /* for qsort */
+ #include <memory.h>
+ #include "MEM_guardedalloc.h"
+ #include "MEM_CacheLimiterC-Api.h"
+ #include "BLI_utildefines.h"
+ #include "BLI_ghash.h"
+ #include "BLI_mempool.h"
+ #include "IMB_moviecache.h"
+ #include "IMB_imbuf_types.h"
+ #include "IMB_imbuf.h"
+ static MEM_CacheLimiterC *limitor= NULL;
+ typedef struct MovieCache {
+       GHash *hash;
+       GHashHashFP hashfp;
+       GHashCmpFP cmpfp;
+       MovieCacheGetKeyDataFP getdatafp;
+       struct BLI_mempool *keys_pool;
+       struct BLI_mempool *items_pool;
+       struct BLI_mempool *userkeys_pool;
+       int keysize;
+       unsigned long curtime;
+       int totseg, *points, proxy, render_flags;       /* for visual statistics optimization */
+       int pad;
+ } MovieCache;
+ typedef struct MovieCacheKey {
+       MovieCache *cache_owner;
+       void *userkey;
+ } MovieCacheKey;
+ typedef struct MovieCacheItem {
+       MovieCache *cache_owner;
+       ImBuf *ibuf;
+       MEM_CacheLimiterHandleC * c_handle;
+       unsigned long last_access;
+ } MovieCacheItem;
+ static unsigned int moviecache_hashhash(const void *keyv)
+ {
+       MovieCacheKey *key= (MovieCacheKey*)keyv;
+       return key->cache_owner->hashfp(key->userkey);
+ }
+ static int moviecache_hashcmp(const void *av, const void *bv)
+ {
+       const MovieCacheKey *a= (MovieCacheKey*)av;
+       const MovieCacheKey *b= (MovieCacheKey*)bv;
+       return a->cache_owner->cmpfp(a->userkey, b->userkey);
+ }
+ static void moviecache_keyfree(void *val)
+ {
+       MovieCacheKey *key= (MovieCacheKey*)val;
+       BLI_mempool_free(key->cache_owner->keys_pool, key);
+ }
+ static void moviecache_valfree(void *val)
+ {
+       MovieCacheItem *item= (MovieCacheItem*)val;
+       if (item->ibuf) {
+               MEM_CacheLimiter_unmanage(item->c_handle);
+               IMB_freeImBuf(item->ibuf);
+       }
+       BLI_mempool_free(item->cache_owner->items_pool, item);
+ }
+ static void check_unused_keys(MovieCache *cache)
+ {
+       GHashIterator *iter;
+       iter= BLI_ghashIterator_new(cache->hash);
+       while(!BLI_ghashIterator_isDone(iter)) {
+               MovieCacheKey *key= BLI_ghashIterator_getKey(iter);
+               MovieCacheItem *item= BLI_ghashIterator_getValue(iter);
+               BLI_ghashIterator_step(iter);
+               if(!item->ibuf)
+                       BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
+       }
+       BLI_ghashIterator_free(iter);
+ }
+ static int compare_int(const void *av, const void *bv)
+ {
+       const int *a= (int *)av;
+       const int *b= (int *)bv;
+       return *a-*b;
+ }
+ static void IMB_moviecache_destructor(void *p)
+ {
+       MovieCacheItem *item= (MovieCacheItem *) p;
+       if (item && item->ibuf) {
+               IMB_freeImBuf(item->ibuf);
+               item->ibuf= NULL;
+               item->c_handle= NULL;
+       }
+ }
+ /* approximate size of ImBuf in memory */
+ static intptr_t IMB_get_size_in_memory(ImBuf *ibuf)
+ {
+       int a;
+       intptr_t size= 0, channel_size= 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 intptr_t get_item_size (void *p)
+ {
+       intptr_t size= sizeof(MovieCacheItem);
+       MovieCacheItem *item= (MovieCacheItem *) p;
+       if(item->ibuf)
+               size+= IMB_get_size_in_memory(item->ibuf);
+       return size;
+ }
+ void IMB_moviecache_init(void)
+ {
+       limitor= new_MEM_CacheLimiter(IMB_moviecache_destructor, get_item_size);
+ }
+ void IMB_moviecache_destruct(void)
+ {
+       if(limitor)
+               delete_MEM_CacheLimiter(limitor);
+ }
+ struct MovieCache *IMB_moviecache_create(int keysize, GHashHashFP hashfp, GHashCmpFP cmpfp,
+               MovieCacheGetKeyDataFP getdatafp)
+ {
+       MovieCache *cache;
+       cache= MEM_callocN(sizeof(MovieCache), "MovieCache");
++      cache->keys_pool= BLI_mempool_create(sizeof(MovieCacheKey), 64, 64, 0, 0);
++      cache->items_pool= BLI_mempool_create(sizeof(MovieCacheItem), 64, 64, 0, 0);
++      cache->userkeys_pool= BLI_mempool_create(keysize, 64, 64, 0, 0);
+       cache->hash= BLI_ghash_new(moviecache_hashhash, moviecache_hashcmp, "MovieClip ImBuf cache hash");
+       cache->keysize= keysize;
+       cache->hashfp= hashfp;
+       cache->cmpfp= cmpfp;
+       cache->getdatafp= getdatafp;
+       cache->proxy= -1;
+       return cache;
+ }
+ void IMB_moviecache_put(MovieCache *cache, void *userkey, ImBuf *ibuf)
+ {
+       MovieCacheKey *key;
+       MovieCacheItem *item;
+       if(!limitor)
+               IMB_moviecache_init();
+       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);
+       item= BLI_mempool_alloc(cache->items_pool);
+       item->ibuf= ibuf;
+       item->cache_owner= cache;
+       item->last_access= cache->curtime++;
+       item->c_handle= NULL;
+       BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
+       BLI_ghash_insert(cache->hash, key, 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);
+       /* cache limiter can't remove unused keys which points to destoryed values */
+       check_unused_keys(cache);
+       if(cache->points) {
+               MEM_freeN(cache->points);
+               cache->points= NULL;
+       }
+ }
+ ImBuf* IMB_moviecache_get(MovieCache *cache, void *userkey)
+ {
+       MovieCacheKey key;
+       MovieCacheItem *item;
+       key.cache_owner= cache;
+       key.userkey= userkey;
+       item= (MovieCacheItem*)BLI_ghash_lookup(cache->hash, &key);
+       if(item) {
+               item->last_access= cache->curtime++;
+               if(item->ibuf) {
+                       MEM_CacheLimiter_touch(item->c_handle);
+                       IMB_refImBuf(item->ibuf);
+                       return item->ibuf;
+               }
+       }
+       return NULL;
+ }
+ void IMB_moviecache_free(MovieCache *cache)
+ {
+       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);
+       if(cache->points)
+               MEM_freeN(cache->points);
+       MEM_freeN(cache);
+ }
+ /* 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)
+ {
+       *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_size(cache->hash);
+               int *frames= MEM_callocN(totframe*sizeof(int), "movieclip cache frames");
+               int a, totseg= 0;
+               GHashIterator *iter;
+               iter= BLI_ghashIterator_new(cache->hash);
+               a= 0;
+               while(!BLI_ghashIterator_isDone(iter)) {
+                       MovieCacheKey *key= BLI_ghashIterator_getKey(iter);
+                       MovieCacheItem *item= BLI_ghashIterator_getValue(iter);
+                       int framenr, curproxy, curflags;
+                       if(item->ibuf) {
+                               cache->getdatafp(key->userkey, &framenr, &curproxy, &curflags);
+                               if(curproxy==proxy && curflags==render_flags)
+                                       frames[a++]= framenr;
+                       }
+                       BLI_ghashIterator_step(iter);
+               }
+               BLI_ghashIterator_free(iter);
+               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);
+       }
+ }