hvirtual/cinelerra/preferences.C

   1 #include "asset.h"
   2 #include "audioconfig.h"
   3 #include "audiodevice.inc"
   4 #include "bcmeter.inc"
   5 #include "cache.inc"
   6 #include "clip.h"
   7 #include "defaults.h"
   8 #include "file.inc"
   9 #include "filesystem.h"
  10 #include "guicast.h"
  11 #include "preferences.h"
  12 #include "theme.h"
  13 #include "videoconfig.h"
  14 #include "videodevice.inc"
  15 #include <string.h>
  16
  17 //#define CLAMP(x, y, z) (x) = ((x) < (y) ? (y) : ((x) > (z) ? (z) : (x)))
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30 Preferences::Preferences()
  31 {
  32 // Set defaults
  33         FileSystem fs;
  34
  35         preferences_lock = new Mutex("Preferences::preferences_lock");
  36         sprintf(index_directory, BCASTDIR);
  37         if(strlen(index_directory))
  38                 fs.complete_path(index_directory);
  39         cache_size = 0xa00000;
  40         index_size = 0x300000;
  41         index_count = 100;
  42         use_thumbnails = 1;
  43         theme[0] = 0;
  44         use_renderfarm = 0;
  45         force_uniprocessor = 0;
  46         renderfarm_port = DEAMON_PORT;
  47         render_preroll = 0.5;
  48         brender_preroll = 0;
  49         renderfarm_mountpoint[0] = 0;
  50         renderfarm_vfs = 1;
  51         renderfarm_job_count = 20;
  52         processors = calculate_processors();
  53
  54 // Default brender asset
  55         brender_asset = new Asset;
  56         brender_asset->audio_data = 0;
  57         brender_asset->video_data = 1;
  58         sprintf(brender_asset->path, "/tmp/brender");
  59         brender_asset->format = FILE_JPEG_LIST;
  60         brender_asset->jpeg_quality = 80;
  61
  62         use_brender = 0;
  63         brender_fragment = 1;
  64         local_rate = 0.0;
  65 }
  66
  67 Preferences::~Preferences()
  68 {
  69         delete brender_asset;
  70         delete preferences_lock;
  71 }
  72
  73 void Preferences::copy_rates_from(Preferences *preferences)
  74 {
  75         preferences_lock->lock("Preferences::copy_rates_from");
  76 // Need to match node titles in case the order changed and in case
  77 // one of the nodes in the source is the master node.
  78         local_rate = preferences->local_rate;
  79
  80         for(int j = 0;
  81                 j < preferences->renderfarm_nodes.total;
  82                 j++)
  83         {
  84                 double new_rate = preferences->renderfarm_rate.values[j];
  85 // Put in the master node
  86                 if(preferences->renderfarm_nodes.values[j][0] == '/')
  87                 {
  88                         if(!EQUIV(new_rate, 0.0))
  89                                 local_rate = new_rate;
  90                 }
  91                 else
  92 // Search for local node and copy it to that node
  93                 if(!EQUIV(new_rate, 0.0))
  94                 {
  95                         for(int i = 0; i < renderfarm_nodes.total; i++)
  96                         {
  97                                 if(!strcmp(preferences->renderfarm_nodes.values[j], renderfarm_nodes.values[i]) &&
  98                                         preferences->renderfarm_ports.values[j] == renderfarm_ports.values[i])
  99                                 {
 100                                         renderfarm_rate.values[i] = new_rate;
 101                                         break;
 102                                 }
 103                         }
 104                 }
 105         }
 106
 107 //printf("Preferences::copy_rates_from 1 %f %f\n", local_rate, preferences->local_rate);
 108         preferences_lock->unlock();
 109 }
 110
 111 void Preferences::copy_from(Preferences *that)
 112 {
 113 // ================================= Performance ================================
 114         strcpy(index_directory, that->index_directory);
 115         index_size = that->index_size;
 116         index_count = that->index_count;
 117         use_thumbnails = that->use_thumbnails;
 118         strcpy(global_plugin_dir, that->global_plugin_dir);
 119         strcpy(theme, that->theme);
 120
 121         cache_size = that->cache_size;
 122         force_uniprocessor = that->force_uniprocessor;
 123         processors = calculate_processors();
 124         renderfarm_nodes.remove_all_objects();
 125         renderfarm_ports.remove_all();
 126         renderfarm_enabled.remove_all();
 127         renderfarm_rate.remove_all();
 128         local_rate = that->local_rate;
 129         for(int i = 0; i < that->renderfarm_nodes.total; i++)
 130         {
 131                 add_node(that->renderfarm_nodes.values[i],
 132                         that->renderfarm_ports.values[i],
 133                         that->renderfarm_enabled.values[i],
 134                         that->renderfarm_rate.values[i]);
 135         }
 136         use_renderfarm = that->use_renderfarm;
 137         renderfarm_port = that->renderfarm_port;
 138         render_preroll = that->render_preroll;
 139         brender_preroll = that->brender_preroll;
 140         renderfarm_job_count = that->renderfarm_job_count;
 141         renderfarm_vfs = that->renderfarm_vfs;
 142         strcpy(renderfarm_mountpoint, that->renderfarm_mountpoint);
 143         renderfarm_consolidate = that->renderfarm_consolidate;
 144         use_brender = that->use_brender;
 145         brender_fragment = that->brender_fragment;
 146         *brender_asset = *that->brender_asset;
 147
 148 // Check boundaries
 149
 150         FileSystem fs;
 151         if(strlen(index_directory))
 152         {
 153                 fs.complete_path(index_directory);
 154                 fs.add_end_slash(index_directory);
 155         }
 156
 157         if(strlen(global_plugin_dir))
 158         {
 159                 fs.complete_path(global_plugin_dir);
 160                 fs.add_end_slash(global_plugin_dir);
 161         }
 162
 163         boundaries();
 164 }
 165
 166 void Preferences::boundaries()
 167 {
 168         renderfarm_job_count = MAX(renderfarm_job_count, 1);
 169         CLAMP(cache_size, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 170 }
 171
 172 Preferences& Preferences::operator=(Preferences &that)
 173 {
 174 printf("Preferences::operator=\n");
 175         copy_from(&that);
 176         return *this;
 177 }
 178
 179 int Preferences::load_defaults(Defaults *defaults)
 180 {
 181         char string[BCTEXTLEN];
 182
 183         defaults->get("INDEX_DIRECTORY", index_directory);
 184         index_size = defaults->get("INDEX_SIZE", index_size);
 185         index_count = defaults->get("INDEX_COUNT", index_count);
 186         use_thumbnails = defaults->get("USE_THUMBNAILS", use_thumbnails);
 187
 188         sprintf(global_plugin_dir, PLUGIN_DIR);
 189         defaults->get("GLOBAL_PLUGIN_DIR", global_plugin_dir);
 190         if(getenv("GLOBAL_PLUGIN_DIR"))
 191         {
 192                 strcpy(global_plugin_dir, getenv("GLOBAL_PLUGIN_DIR"));
 193         }
 194
 195         strcpy(theme, DEFAULT_THEME);
 196         defaults->get("THEME", theme);
 197
 198
 199         brender_asset->load_defaults(defaults,
 200                 "BRENDER_",
 201                 1,
 202                 1,
 203                 1,
 204                 0,
 205                 0);
 206
 207
 208
 209         force_uniprocessor = defaults->get("FORCE_UNIPROCESSOR", 0);
 210         processors = calculate_processors();
 211         use_brender = defaults->get("USE_BRENDER", use_brender);
 212         brender_fragment = defaults->get("BRENDER_FRAGMENT", brender_fragment);
 213         cache_size = defaults->get("CACHE_SIZE", cache_size);
 214         local_rate = defaults->get("LOCAL_RATE", local_rate);
 215         use_renderfarm = defaults->get("USE_RENDERFARM", use_renderfarm);
 216         renderfarm_port = defaults->get("RENDERFARM_PORT", renderfarm_port);
 217         render_preroll = defaults->get("RENDERFARM_PREROLL", render_preroll);
 218         brender_preroll = defaults->get("BRENDER_PREROLL", brender_preroll);
 219         renderfarm_job_count = defaults->get("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 220         renderfarm_consolidate = defaults->get("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 221         renderfarm_vfs = defaults->get("RENDERFARM_VFS", renderfarm_vfs);
 222         defaults->get("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 223         int renderfarm_total = defaults->get("RENDERFARM_TOTAL", 0);
 224
 225         for(int i = 0; i < renderfarm_total; i++)
 226         {
 227                 sprintf(string, "RENDERFARM_NODE%d", i);
 228                 char result[BCTEXTLEN];
 229                 int result_port = 0;
 230                 int result_enabled = 0;
 231                 float result_rate = 0.0;
 232
 233                 result[0] = 0;
 234                 defaults->get(string, result);
 235
 236                 sprintf(string, "RENDERFARM_PORT%d", i);
 237                 result_port = defaults->get(string, renderfarm_port);
 238
 239                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 240                 result_enabled = defaults->get(string, result_enabled);
 241
 242                 sprintf(string, "RENDERFARM_RATE%d", i);
 243                 result_rate = defaults->get(string, result_rate);
 244
 245                 if(result[0] != 0)
 246                 {
 247                         add_node(result, result_port, result_enabled, result_rate);
 248                 }
 249         }
 250
 251         boundaries();
 252
 253         return 0;
 254 }
 255
 256 int Preferences::save_defaults(Defaults *defaults)
 257 {
 258         char string[BCTEXTLEN];
 259         defaults->update("CACHE_SIZE", cache_size);
 260         defaults->update("INDEX_DIRECTORY", index_directory);
 261         defaults->update("INDEX_SIZE", index_size);
 262         defaults->update("INDEX_COUNT", index_count);
 263         defaults->update("USE_THUMBNAILS", use_thumbnails);
 264         defaults->update("GLOBAL_PLUGIN_DIR", global_plugin_dir);
 265         defaults->update("THEME", theme);
 266
 267
 268
 269         defaults->update("FORCE_UNIPROCESSOR", force_uniprocessor);
 270         brender_asset->save_defaults(defaults,
 271                 "BRENDER_",
 272                 1,
 273                 1,
 274                 1,
 275                 0,
 276                 0);
 277         defaults->update("USE_BRENDER", use_brender);
 278         defaults->update("BRENDER_FRAGMENT", brender_fragment);
 279         defaults->update("USE_RENDERFARM", use_renderfarm);
 280         defaults->update("LOCAL_RATE", local_rate);
 281         defaults->update("RENDERFARM_PORT", renderfarm_port);
 282         defaults->update("RENDERFARM_PREROLL", render_preroll);
 283         defaults->update("BRENDER_PREROLL", brender_preroll);
 284         defaults->update("RENDERFARM_VFS", renderfarm_vfs);
 285         defaults->update("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 286         defaults->update("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 287         defaults->update("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 288         defaults->update("RENDERFARM_TOTAL", (int64_t)renderfarm_nodes.total);
 289         for(int i = 0; i < renderfarm_nodes.total; i++)
 290         {
 291                 sprintf(string, "RENDERFARM_NODE%d", i);
 292                 defaults->update(string, renderfarm_nodes.values[i]);
 293                 sprintf(string, "RENDERFARM_PORT%d", i);
 294                 defaults->update(string, renderfarm_ports.values[i]);
 295                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 296                 defaults->update(string, renderfarm_enabled.values[i]);
 297                 sprintf(string, "RENDERFARM_RATE%d", i);
 298                 defaults->update(string, renderfarm_rate.values[i]);
 299         }
 300         return 0;
 301 }
 302
 303
 304 void Preferences::add_node(char *text, int port, int enabled, float rate)
 305 {
 306         if(text[0] == 0) return;
 307
 308         preferences_lock->lock("Preferences::add_node");
 309         char *new_item = new char[strlen(text) + 1];
 310         strcpy(new_item, text);
 311         renderfarm_nodes.append(new_item);
 312         renderfarm_ports.append(port);
 313         renderfarm_enabled.append(enabled);
 314         renderfarm_rate.append(rate);
 315         preferences_lock->unlock();
 316 }
 317
 318 void Preferences::delete_node(int number)
 319 {
 320         preferences_lock->lock("Preferences::delete_node");
 321         if(number < renderfarm_nodes.total)
 322         {
 323                 delete [] renderfarm_nodes.values[number];
 324                 renderfarm_nodes.remove_number(number);
 325                 renderfarm_ports.remove_number(number);
 326                 renderfarm_enabled.remove_number(number);
 327                 renderfarm_rate.remove_number(number);
 328         }
 329         preferences_lock->unlock();
 330 }
 331
 332 void Preferences::delete_nodes()
 333 {
 334         preferences_lock->lock("Preferences::delete_nodes");
 335         for(int i = 0; i < renderfarm_nodes.total; i++)
 336                 delete [] renderfarm_nodes.values[i];
 337         renderfarm_nodes.remove_all();
 338         renderfarm_ports.remove_all();
 339         renderfarm_enabled.remove_all();
 340         renderfarm_rate.remove_all();
 341         preferences_lock->unlock();
 342 }
 343
 344 void Preferences::reset_rates()
 345 {
 346         for(int i = 0; i < renderfarm_nodes.total; i++)
 347         {
 348                 renderfarm_rate.values[i] = 0.0;
 349         }
 350         local_rate = 0.0;
 351 }
 352
 353 void Preferences::set_rate(float rate, int node)
 354 {
 355 //printf("Preferences::set_rate %f %d\n", rate, node);
 356         if(node < 0)
 357         {
 358                 local_rate = rate;
 359         }
 360         else
 361         {
 362                 int total = 0;
 363                 for(int i = 0; i < renderfarm_nodes.total; i++)
 364                 {
 365                         if(renderfarm_enabled.values[i]) total++;
 366                         if(total == node + 1)
 367                         {
 368                                 renderfarm_rate.values[i] = rate;
 369                                 return;
 370                         }
 371                 }
 372         }
 373 }
 374
 375 float Preferences::get_avg_rate(int use_master_node)
 376 {
 377         preferences_lock->lock("Preferences::get_avg_rate");
 378         float total = 0.0;
 379         if(renderfarm_rate.total)
 380         {
 381                 int enabled = 0;
 382                 if(use_master_node)
 383                 {
 384                         if(EQUIV(local_rate, 0.0))
 385                         {
 386                                 preferences_lock->unlock();
 387                                 return 0.0;
 388                         }
 389                         else
 390                         {
 391                                 enabled++;
 392                                 total += local_rate;
 393                         }
 394                 }
 395
 396                 for(int i = 0; i < renderfarm_rate.total; i++)
 397                 {
 398                         if(renderfarm_enabled.values[i])
 399                         {
 400                                 enabled++;
 401                                 total += renderfarm_rate.values[i];
 402                                 if(EQUIV(renderfarm_rate.values[i], 0.0))
 403                                 {
 404                                         preferences_lock->unlock();
 405                                         return 0.0;
 406                                 }
 407                         }
 408                 }
 409
 410                 if(enabled)
 411                         total /= enabled;
 412                 else
 413                         total = 0.0;
 414         }
 415         preferences_lock->unlock();
 416
 417         return total;
 418 }
 419
 420 void Preferences::sort_nodes()
 421 {
 422         int done = 0;
 423
 424         while(!done)
 425         {
 426                 done = 1;
 427                 for(int i = 0; i < renderfarm_nodes.total - 1; i++)
 428                 {
 429                         if(strcmp(renderfarm_nodes.values[i], renderfarm_nodes.values[i + 1]) > 0)
 430                         {
 431                                 char *temp = renderfarm_nodes.values[i];
 432                                 int temp_port = renderfarm_ports.values[i];
 433
 434                                 renderfarm_nodes.values[i] = renderfarm_nodes.values[i + 1];
 435                                 renderfarm_nodes.values[i + 1] = temp;
 436
 437                                 renderfarm_ports.values[i] = renderfarm_ports.values[i + 1];
 438                                 renderfarm_ports.values[i + 1] = temp_port;
 439
 440                                 renderfarm_enabled.values[i] = renderfarm_enabled.values[i + 1];
 441                                 renderfarm_enabled.values[i + 1] = temp_port;
 442
 443                                 renderfarm_rate.values[i] = renderfarm_rate.values[i + 1];
 444                                 renderfarm_rate.values[i + 1] = temp_port;
 445                                 done = 0;
 446                         }
 447                 }
 448         }
 449 }
 450
 451 void Preferences::edit_node(int number,
 452         char *new_text,
 453         int new_port,
 454         int new_enabled)
 455 {
 456         char *new_item = new char[strlen(new_text) + 1];
 457         strcpy(new_item, new_text);
 458
 459         delete [] renderfarm_nodes.values[number];
 460         renderfarm_nodes.values[number] = new_item;
 461         renderfarm_ports.values[number] = new_port;
 462         renderfarm_enabled.values[number] = new_enabled;
 463 }
 464
 465 int Preferences::get_enabled_nodes()
 466 {
 467         int result = 0;
 468         for(int i = 0; i < renderfarm_enabled.total; i++)
 469                 if(renderfarm_enabled.values[i]) result++;
 470         return result;
 471 }
 472
 473 char* Preferences::get_node_hostname(int number)
 474 {
 475         int total = 0;
 476         for(int i = 0; i < renderfarm_nodes.total; i++)
 477         {
 478                 if(renderfarm_enabled.values[i])
 479                 {
 480                         if(total == number)
 481                                 return renderfarm_nodes.values[i];
 482                         else
 483                                 total++;
 484                 }
 485         }
 486         return "";
 487 }
 488
 489 int Preferences::get_node_port(int number)
 490 {
 491         int total = 0;
 492         for(int i = 0; i < renderfarm_ports.total; i++)
 493         {
 494                 if(renderfarm_enabled.values[i])
 495                 {
 496                         if(total == number)
 497                                 return renderfarm_ports.values[i];
 498                         else
 499                                 total++;
 500                 }
 501         }
 502         return -1;
 503 }
 504
 505
 506 int Preferences::calculate_processors()
 507 {
 508 /* Get processor count */
 509         int result = 1;
 510         FILE *proc;
 511
 512         if(force_uniprocessor) return 1;
 513
 514         if(proc = fopen("/proc/cpuinfo", "r"))
 515         {
 516                 char string[BCTEXTLEN];
 517                 while(!feof(proc))
 518                 {
 519                         fgets(string, BCTEXTLEN, proc);
 520                         if(!strncasecmp(string, "processor", 9))
 521                         {
 522                                 char *ptr = strchr(string, ':');
 523                                 if(ptr)
 524                                 {
 525                                         ptr++;
 526                                         result = atol(ptr) + 1;
 527                                 }
 528                         }
 529                         else
 530                         if(!strncasecmp(string, "cpus detected", 13))
 531                         {
 532                                 char *ptr = strchr(string, ':');
 533                                 if(ptr)
 534                                 {
 535                                         ptr++;
 536                                         result = atol(ptr);
 537                                 }
 538                         }
 539                 }
 540                 fclose(proc);
 541         }
 542
 543         return result;
 544 }
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558