Improved cache management for movie clips from tomato branch

Replace pseudo-LRU approach of determining which buffer
to remove when running out of space allowed for cache
with approach which would remove the frame which is most
far away from newly added frame.

This is still a bit tricky because it's impossible to
distinguish which frame to delete in situation of:

        CCCC...CC
           ^

it's either user wants to extend left segment of cached
frames and buffers from right segment should be removed
or he wants to join this two segments and in that case
buffers from right segment should be removed.

Would need a bit more investigation which situation
is more common in general usecase.

Additional changes:

- Cleanup some memutil files (which are familiar to cache limiter)

- Add option to make moviecache verbose. If DEBUG_MESSAGES is
  defined in moviecache.c detailed logs would be printed to the
  console.

- Movie caches are now named which helps reading debug messages.

1 files changed, 51 insertions, 46 deletions

diff --git a/intern/memutil/MEM_CacheLimiterC-Api.h b/intern/memutil/MEM_CacheLimiterC-Api.h
index 4ed692fb55f..1ae5e9df1c6 100644
--- a/intern/memutil/MEM_CacheLimiterC-Api.h
+++ b/intern/memutil/MEM_CacheLimiterC-Api.h
@@ -31,7 +31,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	
+
 struct MEM_CacheLimiter_s;
 struct MEM_CacheLimiterHandle_s;
 
@@ -39,106 +39,111 @@ typedef struct MEM_CacheLimiter_s MEM_CacheLimiterC;
 typedef struct MEM_CacheLimiterHandle_s MEM_CacheLimiterHandleC;
 
 /* function used to remove data from memory */
-typedef void(*MEM_CacheLimiter_Destruct_Func)(void*);
+typedef void (*MEM_CacheLimiter_Destruct_Func)(void*);
 
 /* function used to measure stored data element size */
-typedef size_t(*MEM_CacheLimiter_DataSize_Func) (void*);
+typedef size_t (*MEM_CacheLimiter_DataSize_Func) (void*);
+
+/* function used to measure priority of item when freeing memory */
+typedef int (*MEM_CacheLimiter_ItemPriority_Func) (void*, int);
 
 #ifndef __MEM_CACHELIMITER_H__
-extern void MEM_CacheLimiter_set_maximum(size_t m);
-extern int MEM_CacheLimiter_get_maximum(void);
+void MEM_CacheLimiter_set_maximum(size_t m);
+int MEM_CacheLimiter_get_maximum(void);
 #endif /* __MEM_CACHELIMITER_H__ */
-/** 
- * Create new MEM_CacheLimiter object 
+
+/**
+ * Create new MEM_CacheLimiter object
  * managed objects are destructed with the data_destructor
  *
  * @param data_destructor
  * @return A new MEM_CacheLimter object
  */
 
-extern MEM_CacheLimiterC * new_MEM_CacheLimiter(
-	MEM_CacheLimiter_Destruct_Func data_destructor,
-	MEM_CacheLimiter_DataSize_Func data_size);
+MEM_CacheLimiterC *new_MEM_CacheLimiter(MEM_CacheLimiter_Destruct_Func data_destructor,
+                                         MEM_CacheLimiter_DataSize_Func data_size);
 
-/** 
+/**
  * Delete MEM_CacheLimiter
- * 
+ *
  * Frees the memory of the CacheLimiter but does not touch managed objects!
  *
  * @param This "This" pointer
  */
 
-extern void delete_MEM_CacheLimiter(MEM_CacheLimiterC * This);
+void delete_MEM_CacheLimiter(MEM_CacheLimiterC *This);
 
-/** 
+/**
  * Manage object
- * 
+ *
  * @param This "This" pointer, data data object to manage
  * @return CacheLimiterHandle to ref, unref, touch the managed object
  */
-	
-extern MEM_CacheLimiterHandleC * MEM_CacheLimiter_insert(
-	MEM_CacheLimiterC * This, void * data);
 
-/** 
+MEM_CacheLimiterHandleC *MEM_CacheLimiter_insert(MEM_CacheLimiterC * This, void * data);
+
+/**
  * Free objects until memory constraints are satisfied
- * 
+ *
  * @param This "This" pointer
  */
 
-extern void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC * This);
+void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC *This);
 
-/** 
- * Unmanage object previously inserted object. 
+/**
+ * Unmanage object previously inserted object.
  * Does _not_ delete managed object!
- * 
+ *
  * @param This "This" pointer, handle of object
  */
-	
-extern void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC * handle);
 
+void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC *handle);
 
-/** 
+
+/**
  * Raise priority of object (put it at the tail of the deletion chain)
- * 
+ *
  * @param handle of object
  */
-	
-extern void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC * handle);
 
-/** 
+void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC *handle);
+
+/**
  * Increment reference counter. Objects with reference counter != 0 are _not_
  * deleted.
- * 
+ *
  * @param handle of object
  */
-	
-extern void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC * handle);
 
-/** 
+void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC *handle);
+
+/**
  * Decrement reference counter. Objects with reference counter != 0 are _not_
  * deleted.
- * 
+ *
  * @param handle of object
  */
-	
-extern void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC * handle);
 
-/** 
+void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC *handle);
+
+/**
  * Get reference counter.
- * 
+ *
  * @param This "This" pointer, handle of object
  */
-	
-extern int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC * handle);
 
-/** 
+int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC *handle);
+
+/**
  * Get pointer to managed object
- * 
+ *
  * @param handle of object
  */
-	
-extern void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC * handle);
+
+void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC *handle);
+
+void MEM_CacheLimiter_ItemPriority_Func_set(MEM_CacheLimiterC *This,
+                                            MEM_CacheLimiter_ItemPriority_Func item_priority_func);
 
 #ifdef __cplusplus
 }