cinelerra/cache.h

   1 #ifndef CACHE_H
   2 #define CACHE_H
   3
   4 // CICache for quickly reading data that is hard to decompress yet used
   5 // over and over.
   6
   7 // Actual caching is done in the File object
   8 // the CICache keeps files open while rendering.
   9
  10 // Since the CICache outlives EDLs it must copy every parameter given to it.
  11
  12 // Files given as arguments must outlive the cache.
  13
  14 #include "arraylist.h"
  15 #include "asset.inc"
  16 #include "cache.inc"
  17 #include "edl.inc"
  18 #include "file.inc"
  19 #include "linklist.h"
  20 #include "mutex.inc"
  21 #include "pluginserver.inc"
  22 #include "preferences.inc"
  23
  24 #include <stdint.h>
  25
  26 class CICacheItem : public ListItem<CICacheItem>
  27 {
  28 public:
  29         CICacheItem(CICache *cache, File *file);
  30         CICacheItem(CICache *cache, Asset *asset);
  31         CICacheItem() {};
  32         ~CICacheItem();
  33
  34         File *file;
  35         int64_t counter;     // number of age calls ago this asset was last needed
  36                           // assets used in the last render have counter == 1
  37         Asset *asset;     // Copy of asset.  CICache should outlive EDLs.
  38         Mutex *item_lock;
  39         int checked_out;
  40 private:
  41         CICache *cache;
  42 };
  43
  44 class CICache : public List<CICacheItem>
  45 {
  46 public:
  47         CICache(EDL *edl,
  48                 Preferences *preferences,
  49                 ArrayList<PluginServer*> *plugindb);
  50         ~CICache();
  51
  52         friend class CICacheItem;
  53
  54 // Enter a new file into the cache which is already open.
  55 // If the file doesn't exist return the arguments.
  56 // If the file exists delete the arguments and return the file which exists.
  57         void update(File* &file);
  58         void set_edl(EDL *edl);
  59
  60 // open it, lock it and add it to the cache if it isn't here already
  61         File* check_out(Asset *asset);
  62
  63 // unlock a file from the cache
  64         int check_in(Asset *asset);
  65
  66 // delete an entry from the cache
  67 // before deleting an asset, starting a new project or something
  68         int delete_entry(Asset *asset);
  69         int delete_entry(char *path);
  70
  71         int64_t get_memory_usage(int use_lock);
  72
  73
  74 // increment counters after rendering a buffer length
  75 // since you can't know how big the cache is until after rendering the buffer
  76 // deletes oldest assets until under the memory limit
  77         int age();
  78
  79
  80         int dump();
  81
  82         ArrayList<PluginServer*> *plugindb;
  83
  84 private:
  85 // returns 1 if nothing was available to delete
  86 // 0 if successful
  87         int delete_oldest();
  88
  89 // for deleting items
  90         int lock_all();
  91         int unlock_all();
  92
  93 // to prevent one from checking the same asset out before it's checked in
  94 // yet without blocking the asset trying to get checked in
  95 // use a seperate mutex for checkouts and checkins
  96         Mutex *check_in_lock, *check_out_lock, *total_lock;
  97 // Copy of EDL
  98         EDL *edl;
  99         Preferences *preferences;
 100 };
 101
 102
 103
 104
 105
 106
 107
 108
 109 #endif