cinelerra-5.1/cinelerra/preferences.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "asset.h"
  23 #include "audioconfig.h"
  24 #include "audiodevice.inc"
  25 #include "bcmeter.inc"
  26 #include "bcsignals.h"
  27 #include "cache.inc"
  28 #include "clip.h"
  29 #include "bchash.h"
  30 #include "file.h"
  31 #include "filesystem.h"
  32 #include "guicast.h"
  33 #include "indexfile.h"
  34 #include "mutex.h"
  35 #include "preferences.h"
  36 #include "probeprefs.h"
  37 #include "shbtnprefs.h"
  38 #include "theme.h"
  39 #include "videoconfig.h"
  40 #include "videodevice.inc"
  41
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46
  47
  48 //#define CLAMP(x, y, z) (x) = ((x) < (y) ? (y) : ((x) > (z) ? (z) : (x)))
  49
  50 Preferences::Preferences()
  51 {
  52 // Set defaults
  53         FileSystem fs;
  54
  55         preferences_lock = new Mutex("Preferences::preferences_lock");
  56
  57
  58 // initial plugin path from build -DPLUGIN_DIR="..."
  59         sprintf(plugin_dir, "%s/", File::get_plugin_path());
  60         sprintf(index_directory, "%s/", File::get_config_path());
  61         if(strlen(index_directory))
  62                 fs.complete_path(index_directory);
  63         cache_size = 0x1000000;
  64         index_size = 0x400000;
  65         index_count = 500;
  66         use_thumbnails = 1;
  67         keyframe_reticle = HAIRLINE_DRAGGING;
  68         trap_sigsegv = 1;
  69         trap_sigintr = 1;
  70         theme[0] = 0;
  71         plugin_icons[0] = 0;
  72         use_renderfarm = 0;
  73         force_uniprocessor = 0;
  74         renderfarm_port = DEAMON_PORT;
  75         render_preroll = 0.5;
  76         brender_preroll = 0;
  77         renderfarm_mountpoint[0] = 0;
  78         renderfarm_vfs = 0;
  79         renderfarm_job_count = 20;
  80         project_smp = processors = calculate_processors(0);
  81         real_processors = calculate_processors(1);
  82         ffmpeg_marker_indexes = 1;
  83         warn_indexes = 1;
  84         warn_version = 1;
  85         bd_warn_root = 1;
  86         popupmenu_btnup = 1;
  87         textbox_focus_policy = 0;
  88         forward_render_displacement = 0;
  89         dvd_yuv420p_interlace = 0;
  90
  91 // Default brender asset
  92         brender_asset = new Asset;
  93         brender_asset->audio_data = 0;
  94         brender_asset->video_data = 1;
  95         sprintf(brender_asset->path, "/tmp/brender");
  96         brender_asset->format = FILE_JPEG_LIST;
  97         brender_asset->jpeg_quality = 80;
  98
  99         use_brender = 0;
 100         brender_fragment = 1;
 101         local_rate = 0.0;
 102
 103         use_tipwindow = 1;
 104         scan_commercials = 0;
 105
 106         android_remote = 0;
 107         android_port = 23432;
 108         strcpy(android_pin, "cinelerra");
 109
 110         for(int i = 0; i < MAXCHANNELS; i++)
 111         {
 112                 for(int j = 0; j < i + 1; j++)
 113                 {
 114                         int position = 180 - (360 * j / (i + 1));
 115                         while(position < 0) position += 360;
 116                         channel_positions[i * MAXCHANNELS + j] = position;
 117                 }
 118         }
 119 }
 120
 121 Preferences::~Preferences()
 122 {
 123         brender_asset->Garbage::remove_user();
 124         shbtn_prefs.remove_all_objects();
 125         file_probes.remove_all_objects();
 126         renderfarm_nodes.remove_all_objects();
 127         delete preferences_lock;
 128 }
 129
 130 void Preferences::copy_rates_from(Preferences *preferences)
 131 {
 132         preferences_lock->lock("Preferences::copy_rates_from");
 133 // Need to match node titles in case the order changed and in case
 134 // one of the nodes in the source is the master node.
 135         local_rate = preferences->local_rate;
 136
 137         for(int j = 0;
 138                 j < preferences->renderfarm_nodes.total;
 139                 j++)
 140         {
 141                 double new_rate = preferences->renderfarm_rate.values[j];
 142 // Put in the master node
 143                 if(preferences->renderfarm_nodes.values[j][0] == '/')
 144                 {
 145                         if(!EQUIV(new_rate, 0.0))
 146                                 local_rate = new_rate;
 147                 }
 148                 else
 149 // Search for local node and copy it to that node
 150                 if(!EQUIV(new_rate, 0.0))
 151                 {
 152                         for(int i = 0; i < renderfarm_nodes.total; i++)
 153                         {
 154                                 if(!strcmp(preferences->renderfarm_nodes.values[j], renderfarm_nodes.values[i]) &&
 155                                         preferences->renderfarm_ports.values[j] == renderfarm_ports.values[i])
 156                                 {
 157                                         renderfarm_rate.values[i] = new_rate;
 158                                         break;
 159                                 }
 160                         }
 161                 }
 162         }
 163
 164 //printf("Preferences::copy_rates_from 1 %f %f\n", local_rate, preferences->local_rate);
 165         preferences_lock->unlock();
 166 }
 167
 168 void Preferences::copy_from(Preferences *that)
 169 {
 170 // ================================= Performance ================================
 171         strcpy(index_directory, that->index_directory);
 172         index_size = that->index_size;
 173         index_count = that->index_count;
 174         use_thumbnails = that->use_thumbnails;
 175         keyframe_reticle = that->keyframe_reticle;
 176         strcpy(theme, that->theme);
 177         strcpy(plugin_icons, that->plugin_icons);
 178
 179         use_tipwindow = that->use_tipwindow;
 180         scan_commercials = that->scan_commercials;
 181         android_remote = that->android_remote;
 182         android_port = that->android_port;
 183         strcpy(android_pin, that->android_pin);
 184         this->shbtn_prefs.remove_all_objects();
 185         for( int i=0; i<that->shbtn_prefs.size(); ++i )
 186                 this->shbtn_prefs.append(new ShBtnPref(*that->shbtn_prefs[i]));
 187         this->file_probes.remove_all_objects();
 188         for( int i=0; i<that->file_probes.size(); ++i )
 189                 this->file_probes.append(new ProbePref(*that->file_probes[i]));
 190         cache_size = that->cache_size;
 191         project_smp = that->project_smp;
 192         force_uniprocessor = that->force_uniprocessor;
 193         trap_sigsegv = that->trap_sigsegv;
 194         trap_sigintr = that->trap_sigintr;
 195         processors = that->processors;
 196         real_processors = that->real_processors;
 197         ffmpeg_marker_indexes = that->ffmpeg_marker_indexes;
 198         warn_indexes = that->warn_indexes;
 199         warn_version = that->warn_version;
 200         bd_warn_root = that->bd_warn_root;
 201         popupmenu_btnup = that->popupmenu_btnup;
 202         textbox_focus_policy = that->textbox_focus_policy;
 203         forward_render_displacement = that->forward_render_displacement;
 204         dvd_yuv420p_interlace = that->dvd_yuv420p_interlace;
 205         renderfarm_nodes.remove_all_objects();
 206         renderfarm_ports.remove_all();
 207         renderfarm_enabled.remove_all();
 208         renderfarm_rate.remove_all();
 209         local_rate = that->local_rate;
 210         for(int i = 0; i < that->renderfarm_nodes.size(); i++)
 211         {
 212                 add_node(that->renderfarm_nodes.get(i),
 213                         that->renderfarm_ports.get(i),
 214                         that->renderfarm_enabled.get(i),
 215                         that->renderfarm_rate.get(i));
 216         }
 217         use_renderfarm = that->use_renderfarm;
 218         renderfarm_port = that->renderfarm_port;
 219         render_preroll = that->render_preroll;
 220         brender_preroll = that->brender_preroll;
 221         renderfarm_job_count = that->renderfarm_job_count;
 222         renderfarm_vfs = that->renderfarm_vfs;
 223         strcpy(renderfarm_mountpoint, that->renderfarm_mountpoint);
 224         renderfarm_consolidate = that->renderfarm_consolidate;
 225         use_brender = that->use_brender;
 226         brender_fragment = that->brender_fragment;
 227         brender_asset->copy_from(that->brender_asset, 0);
 228
 229 // Check boundaries
 230
 231         FileSystem fs;
 232         if(strlen(index_directory))
 233         {
 234                 fs.complete_path(index_directory);
 235                 fs.add_end_slash(index_directory);
 236         }
 237
 238 //      if(strlen(global_plugin_dir))
 239 //      {
 240 //              fs.complete_path(global_plugin_dir);
 241 //              fs.add_end_slash(global_plugin_dir);
 242 //      }
 243 //
 244
 245 // Redo with the proper value of force_uniprocessor
 246         processors = calculate_processors(0);
 247         boundaries();
 248 }
 249
 250 void Preferences::boundaries()
 251 {
 252         renderfarm_job_count = MAX(renderfarm_job_count, 1);
 253         CLAMP(cache_size, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 254 }
 255
 256 Preferences& Preferences::operator=(Preferences &that)
 257 {
 258 printf("Preferences::operator=\n");
 259         copy_from(&that);
 260         return *this;
 261 }
 262
 263 void Preferences::print_channels(char *string,
 264         int *channel_positions,
 265         int channels)
 266 {
 267         char string3[BCTEXTLEN];
 268         string[0] = 0;
 269         for(int j = 0; j < channels; j++)
 270         {
 271                 sprintf(string3, "%d", channel_positions[j]);
 272                 strcat(string, string3);
 273                 if(j < channels - 1)
 274                         strcat(string, ",");
 275         }
 276 }
 277
 278 void Preferences::scan_channels(char *string,
 279         int *channel_positions,
 280         int channels)
 281 {
 282         char string2[BCTEXTLEN];
 283         int len = strlen(string);
 284         int current_channel = 0;
 285         for(int i = 0; i < len; i++)
 286         {
 287                 strcpy(string2, &string[i]);
 288                 for(int j = 0; j < BCTEXTLEN; j++)
 289                 {
 290                         if(string2[j] == ',' || string2[j] == 0)
 291                         {
 292                                 i += j;
 293                                 string2[j] = 0;
 294                                 break;
 295                         }
 296                 }
 297                 channel_positions[current_channel++] = atoi(string2);
 298                 if(current_channel >= channels) break;
 299         }
 300 }
 301
 302 int Preferences::load_defaults(BC_Hash *defaults)
 303 {
 304         char string[BCTEXTLEN];
 305
 306         use_tipwindow = defaults->get("USE_TIPWINDOW", use_tipwindow);
 307         scan_commercials = defaults->get("SCAN_COMMERCIALS", scan_commercials);
 308         android_remote = defaults->get("ANDROID_REMOTE", android_remote);
 309         android_port = defaults->get("ANDROID_PORT", android_port);
 310         defaults->get("ANDROID_PIN", android_pin);
 311         defaults->get("INDEX_DIRECTORY", index_directory);
 312         index_size = defaults->get("INDEX_SIZE", index_size);
 313         index_count = defaults->get("INDEX_COUNT", index_count);
 314         use_thumbnails = defaults->get("USE_THUMBNAILS", use_thumbnails);
 315         keyframe_reticle = defaults->get("KEYFRAME_RETICLE", keyframe_reticle);
 316         trap_sigsegv = defaults->get("TRAP_SIGSEGV", trap_sigsegv);
 317         trap_sigintr = defaults->get("TRAP_SIGINTR", trap_sigintr);
 318
 319         strcpy(theme, _(DEFAULT_THEME));
 320         strcpy(plugin_icons, DEFAULT_PICON);
 321         defaults->get("THEME", theme);
 322         defaults->get("PLUGIN_ICONS", plugin_icons);
 323
 324         for(int i = 0; i < MAXCHANNELS; i++)
 325         {
 326                 char string2[BCTEXTLEN];
 327                 sprintf(string, "CHANNEL_POSITIONS%d", i);
 328                 print_channels(string2,
 329                         &channel_positions[i * MAXCHANNELS],
 330                         i + 1);
 331
 332                 defaults->get(string, string2);
 333
 334                 scan_channels(string2,
 335                         &channel_positions[i * MAXCHANNELS],
 336                         i + 1);
 337         }
 338
 339         brender_asset->load_defaults(defaults,
 340                 "BRENDER_",
 341                 1,
 342                 1,
 343                 1,
 344                 0,
 345                 0);
 346
 347
 348
 349         project_smp = defaults->get("PROJECT_SMP", project_smp);
 350         force_uniprocessor = defaults->get("FORCE_UNIPROCESSOR", force_uniprocessor);
 351         ffmpeg_marker_indexes = defaults->get("FFMPEG_MARKER_INDEXES", ffmpeg_marker_indexes);
 352         warn_indexes = defaults->get("WARN_INDEXES", warn_indexes);
 353         warn_version = defaults->get("WARN_VERSION", warn_version);
 354         bd_warn_root = defaults->get("BD_WARN_ROOT", bd_warn_root);
 355         popupmenu_btnup = defaults->get("POPUPMENU_BTNUP", popupmenu_btnup);
 356         textbox_focus_policy = defaults->get("TEXTBOX_FOCUS_POLICY", textbox_focus_policy);
 357         forward_render_displacement = defaults->get("FORWARD_RENDER_DISPLACEMENT", forward_render_displacement);
 358         dvd_yuv420p_interlace = defaults->get("DVD_YUV420P_INTERLACE", dvd_yuv420p_interlace);
 359         use_brender = defaults->get("USE_BRENDER", use_brender);
 360         brender_fragment = defaults->get("BRENDER_FRAGMENT", brender_fragment);
 361         cache_size = defaults->get("CACHE_SIZE", cache_size);
 362         local_rate = defaults->get("LOCAL_RATE", local_rate);
 363         use_renderfarm = defaults->get("USE_RENDERFARM", use_renderfarm);
 364         renderfarm_port = defaults->get("RENDERFARM_PORT", renderfarm_port);
 365         render_preroll = defaults->get("RENDERFARM_PREROLL", render_preroll);
 366         brender_preroll = defaults->get("BRENDER_PREROLL", brender_preroll);
 367         renderfarm_job_count = defaults->get("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 368         renderfarm_consolidate = defaults->get("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 369 //      renderfarm_vfs = defaults->get("RENDERFARM_VFS", renderfarm_vfs);
 370         defaults->get("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 371         int renderfarm_total = defaults->get("RENDERFARM_TOTAL", 0);
 372
 373         for(int i = 0; i < renderfarm_total; i++)
 374         {
 375                 sprintf(string, "RENDERFARM_NODE%d", i);
 376                 char result[BCTEXTLEN];
 377                 int result_port = 0;
 378                 int result_enabled = 0;
 379                 float result_rate = 0.0;
 380
 381                 result[0] = 0;
 382                 defaults->get(string, result);
 383
 384                 sprintf(string, "RENDERFARM_PORT%d", i);
 385                 result_port = defaults->get(string, renderfarm_port);
 386
 387                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 388                 result_enabled = defaults->get(string, result_enabled);
 389
 390                 sprintf(string, "RENDERFARM_RATE%d", i);
 391                 result_rate = defaults->get(string, result_rate);
 392
 393                 if(result[0] != 0)
 394                 {
 395                         add_node(result, result_port, result_enabled, result_rate);
 396                 }
 397         }
 398
 399         shbtn_prefs.remove_all_objects();
 400         int shbtns_total = defaults->get("SHBTNS_TOTAL", -1);
 401         if( shbtns_total < 0 ) {
 402                 shbtn_prefs.append(new ShBtnPref(_("Features5"), "$CIN_BROWSER file://$CIN_DAT/doc/Features5.pdf", 0));
 403                 shbtn_prefs.append(new ShBtnPref(_("Online Help"), "$CIN_BROWSER https://cinelerra-cv.org/docs.php", 0));
 404                 shbtn_prefs.append(new ShBtnPref(_("Original Manual"), "$CIN_BROWSER file://$CIN_DAT/doc/cinelerra.html", 0));
 405                 shbtn_prefs.append(new ShBtnPref(_("Setting Shell Commands"), "$CIN_BROWSER file://$CIN_DAT/doc/ShellCmds.html", 0));
 406                 shbtn_prefs.append(new ShBtnPref(_("Shortcuts"), "$CIN_BROWSER file://$CIN_DAT/doc/shortcuts.html", 0));
 407                 shbtns_total = 0;
 408         }
 409         for( int i=0; i<shbtns_total; ++i ) {
 410                 char name[BCTEXTLEN], commands[BCTEXTLEN];
 411                 sprintf(string, "SHBTN%d_NAME", i);
 412                 defaults->get(string, name);
 413                 sprintf(string, "SHBTN%d_COMMANDS", i);
 414                 defaults->get(string, commands);
 415                 sprintf(string, "SHBTN%d_WARN", i);
 416                 int warn = defaults->get(string, 0);
 417                 shbtn_prefs.append(new ShBtnPref(name, commands, warn));
 418         }
 419
 420         file_probes.remove_all_objects();
 421         int file_probe_total = defaults->get("FILE_PROBE_TOTAL", 0);
 422         for( int i=0; i<file_probe_total; ++i ) {
 423                 char name[BCTEXTLEN];
 424                 sprintf(string, "FILE_PROBE%d_NAME", i);
 425                 defaults->get(string, name);
 426                 sprintf(string, "FILE_PROBE%d_ARMED", i);
 427                 int armed = defaults->get(string, 1);
 428                 file_probes.append(new ProbePref(name, armed));
 429         }
 430         // append any missing probes
 431         for( int i=0; i<File::nb_probes; ++i ) {
 432                 const char *nm = File::default_probes[i];
 433                 int k = file_probes.size();
 434                 while( --k>=0 && strcmp(nm, file_probes[k]->name) );
 435                 if( k >= 0 ) continue;
 436                 int armed = 1;
 437                 if( !strcmp(nm, "FFMPEG_Late") ||
 438                     !strcmp(nm, "CR2") ) armed = 0;
 439                 file_probes.append(new ProbePref(nm, armed));
 440         }
 441
 442 // Redo with the proper value of force_uniprocessor
 443         processors = calculate_processors(0);
 444         boundaries();
 445         return 0;
 446 }
 447
 448 int Preferences::save_defaults(BC_Hash *defaults)
 449 {
 450         char string[BCTEXTLEN];
 451
 452
 453         defaults->update("USE_TIPWINDOW", use_tipwindow);
 454         defaults->update("SCAN_COMMERCIALS", scan_commercials);
 455         defaults->update("ANDROID_REMOTE", android_remote);
 456         defaults->update("ANDROID_PIN", android_pin);
 457         defaults->update("ANDROID_PORT", android_port);
 458
 459         defaults->update("CACHE_SIZE", cache_size);
 460         defaults->update("INDEX_DIRECTORY", index_directory);
 461         defaults->update("INDEX_SIZE", index_size);
 462         defaults->update("INDEX_COUNT", index_count);
 463         defaults->update("USE_THUMBNAILS", use_thumbnails);
 464         defaults->update("KEYFRAME_RETICLE", keyframe_reticle);
 465         defaults->update("TRAP_SIGSEGV", trap_sigsegv);
 466         defaults->update("TRAP_SIGINTR", trap_sigintr);
 467         defaults->update("THEME", theme);
 468         defaults->update("PLUGIN_ICONS", plugin_icons);
 469
 470
 471         for(int i = 0; i < MAXCHANNELS; i++)
 472         {
 473                 char string2[BCTEXTLEN];
 474                 sprintf(string, "CHANNEL_POSITIONS%d", i);
 475                 print_channels(string2, &channel_positions[i * MAXCHANNELS], i + 1);
 476                 defaults->update(string, string2);
 477         }
 478
 479         defaults->update("PROJECT_SMP", project_smp);
 480         defaults->update("FORCE_UNIPROCESSOR", force_uniprocessor);
 481         defaults->update("FFMPEG_MARKER_INDEXES", ffmpeg_marker_indexes);
 482         defaults->update("WARN_INDEXES", warn_indexes);
 483         defaults->update("WARN_VERSION", warn_version);
 484         defaults->update("BD_WARN_ROOT", bd_warn_root);
 485         defaults->update("POPUPMENU_BTNUP", popupmenu_btnup);
 486         defaults->update("TEXTBOX_FOCUS_POLICY", textbox_focus_policy);
 487         defaults->update("FORWARD_RENDER_DISPLACEMENT", forward_render_displacement);
 488         defaults->update("DVD_YUV420P_INTERLACE", dvd_yuv420p_interlace);
 489         brender_asset->save_defaults(defaults, "BRENDER_", 1, 1, 1, 0, 0);
 490         defaults->update("USE_BRENDER", use_brender);
 491         defaults->update("BRENDER_FRAGMENT", brender_fragment);
 492         defaults->update("USE_RENDERFARM", use_renderfarm);
 493         defaults->update("LOCAL_RATE", local_rate);
 494         defaults->update("RENDERFARM_PORT", renderfarm_port);
 495         defaults->update("RENDERFARM_PREROLL", render_preroll);
 496         defaults->update("BRENDER_PREROLL", brender_preroll);
 497 //      defaults->update("RENDERFARM_VFS", renderfarm_vfs);
 498         defaults->update("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 499         defaults->update("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 500         defaults->update("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 501         defaults->update("RENDERFARM_TOTAL", (int64_t)renderfarm_nodes.total);
 502         for(int i = 0; i < renderfarm_nodes.total; i++)
 503         {
 504                 sprintf(string, "RENDERFARM_NODE%d", i);
 505                 defaults->update(string, renderfarm_nodes.values[i]);
 506                 sprintf(string, "RENDERFARM_PORT%d", i);
 507                 defaults->update(string, renderfarm_ports.values[i]);
 508                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 509                 defaults->update(string, renderfarm_enabled.values[i]);
 510                 sprintf(string, "RENDERFARM_RATE%d", i);
 511                 defaults->update(string, renderfarm_rate.values[i]);
 512         }
 513         defaults->update("SHBTNS_TOTAL", shbtn_prefs.size());
 514         for( int i=0; i<shbtn_prefs.size(); ++i ) {
 515                 ShBtnPref *pref = shbtn_prefs[i];
 516                 sprintf(string, "SHBTN%d_NAME", i);
 517                 defaults->update(string, pref->name);
 518                 sprintf(string, "SHBTN%d_COMMANDS", i);
 519                 defaults->update(string, pref->commands);
 520                 sprintf(string, "SHBTN%d_WARN", i);
 521                 defaults->update(string, pref->warn);
 522         }
 523         defaults->update("FILE_PROBE_TOTAL", file_probes.size());
 524         for( int i=0; i<file_probes.size(); ++i ) {
 525                 ProbePref *pref = file_probes[i];
 526                 sprintf(string, "FILE_PROBE%d_NAME", i);
 527                 defaults->update(string, pref->name);
 528                 sprintf(string, "FILE_PROBE%d_ARMED", i);
 529                 defaults->update(string, pref->armed);
 530         }
 531         return 0;
 532 }
 533
 534
 535 void Preferences::add_node(const char *text, int port, int enabled, float rate)
 536 {
 537         if(text[0] == 0) return;
 538
 539         preferences_lock->lock("Preferences::add_node");
 540         char *new_item = new char[strlen(text) + 1];
 541         strcpy(new_item, text);
 542         renderfarm_nodes.append(new_item);
 543         renderfarm_nodes.set_array_delete();
 544         renderfarm_ports.append(port);
 545         renderfarm_enabled.append(enabled);
 546         renderfarm_rate.append(rate);
 547         preferences_lock->unlock();
 548 }
 549
 550 void Preferences::delete_node(int number)
 551 {
 552         preferences_lock->lock("Preferences::delete_node");
 553         if(number < renderfarm_nodes.total && number >= 0)
 554         {
 555                 delete [] renderfarm_nodes.values[number];
 556                 renderfarm_nodes.remove_number(number);
 557                 renderfarm_ports.remove_number(number);
 558                 renderfarm_enabled.remove_number(number);
 559                 renderfarm_rate.remove_number(number);
 560         }
 561         preferences_lock->unlock();
 562 }
 563
 564 void Preferences::delete_nodes()
 565 {
 566         preferences_lock->lock("Preferences::delete_nodes");
 567         for(int i = 0; i < renderfarm_nodes.total; i++)
 568                 delete [] renderfarm_nodes.values[i];
 569         renderfarm_nodes.remove_all();
 570         renderfarm_ports.remove_all();
 571         renderfarm_enabled.remove_all();
 572         renderfarm_rate.remove_all();
 573         preferences_lock->unlock();
 574 }
 575
 576 void Preferences::reset_rates()
 577 {
 578         for(int i = 0; i < renderfarm_nodes.total; i++)
 579         {
 580                 renderfarm_rate.values[i] = 0.0;
 581         }
 582         local_rate = 0.0;
 583 }
 584
 585 float Preferences::get_rate(int node)
 586 {
 587         if(node < 0)
 588         {
 589                 return local_rate;
 590         }
 591         else
 592         {
 593                 int total = 0;
 594                 for(int i = 0; i < renderfarm_nodes.size(); i++)
 595                 {
 596                         if(renderfarm_enabled.get(i)) total++;
 597                         if(total == node + 1)
 598                         {
 599                                 return renderfarm_rate.get(i);
 600                         }
 601                 }
 602         }
 603
 604         return 0;
 605 }
 606
 607 void Preferences::set_rate(float rate, int node)
 608 {
 609 //printf("Preferences::set_rate %f %d\n", rate, node);
 610         if(node < 0)
 611         {
 612                 local_rate = rate;
 613         }
 614         else
 615         {
 616                 int total = 0;
 617                 for(int i = 0; i < renderfarm_nodes.size(); i++)
 618                 {
 619                         if(renderfarm_enabled.get(i)) total++;
 620                         if(total == node + 1)
 621                         {
 622                                 renderfarm_rate.set(i, rate);
 623                                 return;
 624                         }
 625                 }
 626         }
 627 }
 628
 629 float Preferences::get_avg_rate(int use_master_node)
 630 {
 631         preferences_lock->lock("Preferences::get_avg_rate");
 632         float total = 0.0;
 633         if(renderfarm_rate.total)
 634         {
 635                 int enabled = 0;
 636                 if(use_master_node)
 637                 {
 638                         if(EQUIV(local_rate, 0.0))
 639                         {
 640                                 preferences_lock->unlock();
 641                                 return 0.0;
 642                         }
 643                         else
 644                         {
 645                                 enabled++;
 646                                 total += local_rate;
 647                         }
 648                 }
 649
 650                 for(int i = 0; i < renderfarm_rate.total; i++)
 651                 {
 652                         if(renderfarm_enabled.values[i])
 653                         {
 654                                 enabled++;
 655                                 total += renderfarm_rate.values[i];
 656                                 if(EQUIV(renderfarm_rate.values[i], 0.0))
 657                                 {
 658                                         preferences_lock->unlock();
 659                                         return 0.0;
 660                                 }
 661                         }
 662                 }
 663
 664                 if(enabled)
 665                         total /= enabled;
 666                 else
 667                         total = 0.0;
 668         }
 669         preferences_lock->unlock();
 670
 671         return total;
 672 }
 673
 674 void Preferences::sort_nodes()
 675 {
 676         int done = 0;
 677
 678         while(!done)
 679         {
 680                 done = 1;
 681                 for(int i = 0; i < renderfarm_nodes.total - 1; i++)
 682                 {
 683                         if(strcmp(renderfarm_nodes.values[i], renderfarm_nodes.values[i + 1]) > 0)
 684                         {
 685                                 char *temp = renderfarm_nodes.values[i];
 686                                 int temp_port = renderfarm_ports.values[i];
 687
 688                                 renderfarm_nodes.values[i] = renderfarm_nodes.values[i + 1];
 689                                 renderfarm_nodes.values[i + 1] = temp;
 690
 691                                 renderfarm_ports.values[i] = renderfarm_ports.values[i + 1];
 692                                 renderfarm_ports.values[i + 1] = temp_port;
 693
 694                                 renderfarm_enabled.values[i] = renderfarm_enabled.values[i + 1];
 695                                 renderfarm_enabled.values[i + 1] = temp_port;
 696
 697                                 renderfarm_rate.values[i] = renderfarm_rate.values[i + 1];
 698                                 renderfarm_rate.values[i + 1] = temp_port;
 699                                 done = 0;
 700                         }
 701                 }
 702         }
 703 }
 704
 705 void Preferences::edit_node(int number,
 706         const char *new_text,
 707         int new_port,
 708         int new_enabled)
 709 {
 710         char *new_item = new char[strlen(new_text) + 1];
 711         strcpy(new_item, new_text);
 712
 713         delete [] renderfarm_nodes.values[number];
 714         renderfarm_nodes.values[number] = new_item;
 715         renderfarm_ports.values[number] = new_port;
 716         renderfarm_enabled.values[number] = new_enabled;
 717 }
 718
 719 int Preferences::get_enabled_nodes()
 720 {
 721         int result = 0;
 722         for(int i = 0; i < renderfarm_enabled.total; i++)
 723                 if(renderfarm_enabled.values[i]) result++;
 724         return result;
 725 }
 726
 727 const char* Preferences::get_node_hostname(int number)
 728 {
 729         int total = 0;
 730         for(int i = 0; i < renderfarm_nodes.total; i++)
 731         {
 732                 if(renderfarm_enabled.values[i])
 733                 {
 734                         if(total == number)
 735                                 return renderfarm_nodes.values[i];
 736                         else
 737                                 total++;
 738                 }
 739         }
 740         return "";
 741 }
 742
 743 int Preferences::get_node_port(int number)
 744 {
 745         int total = 0;
 746         for(int i = 0; i < renderfarm_ports.total; i++)
 747         {
 748                 if(renderfarm_enabled.values[i])
 749                 {
 750                         if(total == number)
 751                                 return renderfarm_ports.values[i];
 752                         else
 753                                 total++;
 754                 }
 755         }
 756         return -1;
 757 }
 758
 759 int Preferences::get_asset_file_path(Asset *asset, char *path)
 760 {
 761         strcpy(path, asset->path);
 762         int result = !access(path, R_OK) ? 0 : -1;
 763         if( !result && ( asset->format == FILE_MPEG || asset->format == FILE_AC3 ||
 764                 asset->format == FILE_VMPEG || asset->format == FILE_AMPEG ) ) {
 765                 char source_filename[BCTEXTLEN], index_filename[BCTEXTLEN];
 766                 IndexFile::get_index_filename(source_filename,
 767                         index_directory, index_filename, asset->path, ".toc");
 768                 strcpy(path, index_filename);
 769                 if( access(path, R_OK) )
 770                         result = 1;
 771         }
 772 // result = 0, asset->path/toc exist, -1 no asset, 1 no toc
 773         return result;
 774 }
 775
 776
 777 int Preferences::calculate_processors(int interactive)
 778 {
 779         if(force_uniprocessor && !interactive) return 1;
 780         return BC_WindowBase::get_resources()->machine_cpus;
 781 }
 782
 783 int Preferences::get_file_probe_armed(const char *nm)
 784 {
 785         int k = file_probes.size();
 786         while( --k>=0 && strcmp(nm, file_probes[k]->name) );
 787         if( k < 0 ) return -1;
 788         return file_probes[k]->armed;
 789 }
 790
 791 void Preferences::set_file_probe_armed(const char *nm, int v)
 792 {
 793         int k = file_probes.size();
 794         while( --k>=0 && strcmp(nm, file_probes[k]->name) );
 795         if( k < 0 ) return;
 796         file_probes[k]->armed = v;
 797 }
 798