cinelerra/assets.C

   1 #include "asset.h"
   2 #include "assets.h"
   3 #include "awindowgui.inc"
   4 #include "batch.h"
   5 #include "cache.h"
   6 #include "bchash.h"
   7 #include "edl.h"
   8 #include "file.h"
   9 #include "filexml.h"
  10 #include "filesystem.h"
  11 #include "indexfile.h"
  12 #include "quicktime.h"
  13 #include "mainsession.h"
  14 #include "threadindexer.h"
  15 #include <string.h>
  16
  17 Assets::Assets(EDL *edl) : List<Asset>()
  18 {
  19         this->edl = edl;
  20 }
  21
  22 Assets::~Assets()
  23 {
  24         delete_all();
  25 }
  26
  27 int Assets::load(ArrayList<PluginServer*> *plugindb,
  28         FileXML *file,
  29         uint32_t load_flags)
  30 {
  31         int result = 0;
  32
  33 //printf("Assets::load 1\n");
  34         while(!result)
  35         {
  36                 result = file->read_tag();
  37                 if(!result)
  38                 {
  39                         if(file->tag.title_is("/ASSETS"))
  40                         {
  41                                 result = 1;
  42                         }
  43                         else
  44                         if(file->tag.title_is("ASSET"))
  45                         {
  46 //printf("Assets::load 2\n");
  47                                 char *path = file->tag.get_property("SRC");
  48 //printf("Assets::load 3\n");
  49                                 Asset new_asset(path ? path : SILENCE);
  50 //printf("Assets::load 4\n");
  51                                 new_asset.read(file);
  52 //printf("Assets::load 5\n");
  53                                 update(&new_asset);
  54 //printf("Assets::load 6\n");
  55                         }
  56                 }
  57         }
  58 //printf("Assets::load 7\n");
  59         return 0;
  60 }
  61
  62 int Assets::save(ArrayList<PluginServer*> *plugindb, FileXML *file, char *path)
  63 {
  64         file->tag.set_title("ASSETS");
  65         file->append_tag();
  66         file->append_newline();
  67
  68         for(Asset* current = first; current; current = NEXT)
  69         {
  70                 current->write(file,
  71                         0,
  72                         path);
  73         }
  74
  75         file->tag.set_title("/ASSETS");
  76         file->append_tag();
  77         file->append_newline();
  78         file->append_newline();
  79         return 0;
  80 }
  81
  82 void Assets::copy_from(Assets *assets)
  83 {
  84         delete_all();
  85
  86         for(Asset *current = assets->first; current; current = NEXT)
  87         {
  88                 Asset *new_asset;
  89                 append(new_asset = new Asset);
  90                 new_asset->copy_from(current, 1);
  91         }
  92 }
  93
  94 Assets& Assets::operator=(Assets &assets)
  95 {
  96 printf("Assets::operator= 1\n");
  97         copy_from(&assets);
  98         return *this;
  99 }
 100
 101
 102 void Assets::update_index(Asset *asset)
 103 {
 104         for(Asset* current = first; current; current = NEXT)
 105         {
 106                 if(current->test_path(asset->path))
 107                 {
 108                         current->update_index(asset);
 109                 }
 110         }
 111 }
 112
 113 Asset* Assets::update(Asset *asset)
 114 {
 115         if(!asset) return 0;
 116
 117         for(Asset* current = first; current; current = NEXT)
 118         {
 119 // Asset already exists.
 120                 if(current->test_path(asset->path))
 121                 {
 122                         return current;
 123                 }
 124         }
 125
 126 // Asset doesn't exist.
 127         Asset *asset_copy = new Asset(*asset);
 128         append(asset_copy);
 129         return asset_copy;
 130 }
 131
 132 int Assets::delete_all()
 133 {
 134         while(first)
 135         {
 136                 remove_asset(first);
 137         }
 138         return 0;
 139 }
 140
 141 Asset* Assets::update(const char *path)
 142 {
 143         Asset* current = first;
 144
 145         while(current)
 146         {
 147                 if(current->test_path(path))
 148                 {
 149                         return current;
 150                 }
 151                 current = NEXT;
 152         }
 153
 154         return append(new Asset(path));
 155 }
 156
 157 Asset* Assets::get_asset(const char *filename)
 158 {
 159         Asset* current = first;
 160         Asset* result = 0;
 161
 162         while(current)
 163         {
 164 //printf("Assets::get_asset %p %s\n", filename, filename);
 165                 if(current->test_path(filename))
 166                 {
 167                         result = current;
 168                         break;
 169                 }
 170                 current = current->next;
 171         }
 172
 173         return result;
 174 }
 175
 176 Asset* Assets::remove_asset(Asset *asset)
 177 {
 178         delete asset;
 179 }
 180
 181
 182 int Assets::number_of(Asset *asset)
 183 {
 184         int i;
 185         Asset *current;
 186
 187         for(i = 0, current = first; current && current != asset; i++, current = NEXT)
 188                 ;
 189
 190         return i;
 191 }
 192
 193 Asset* Assets::asset_number(int number)
 194 {
 195         int i;
 196         Asset *current;
 197
 198         for(i = 0, current = first; i < number && current; i++, current = NEXT)
 199                 ;
 200
 201         return current;
 202 }
 203
 204 int Assets::update_old_filename(char *old_filename, char *new_filename)
 205 {
 206         for(Asset* current = first; current; current = NEXT)
 207         {
 208                 if(!strcmp(current->path, old_filename))
 209                 {
 210                         current->update_path(new_filename);
 211                 }
 212         }
 213         return 0;
 214 }
 215
 216
 217 int Assets::dump()
 218 {
 219         for(Asset *current = first; current; current = NEXT)
 220         {
 221                 current->dump();
 222         }
 223         return 0;
 224 }
 225
 226