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