cinelerra-5.0/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.inc"
  31 #include "filesystem.h"
  32 #include "guicast.h"
  33 #include "indexfile.h"
  34 #include "mutex.h"
  35 #include "preferences.h"
  36 #include "shbtnprefs.h"
  37 #include "theme.h"
  38 #include "videoconfig.h"
  39 #include "videodevice.inc"
  40
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45
  46
  47 //#define CLAMP(x, y, z) (x) = ((x) < (y) ? (y) : ((x) > (z) ? (z) : (x)))
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58 Preferences::Preferences()
  59 {
  60 // Set defaults
  61         FileSystem fs;
  62
  63         preferences_lock = new Mutex("Preferences::preferences_lock");
  64
  65
  66
  67         get_exe_path(plugin_dir);
  68         strcat(plugin_dir,"/plugins");
  69
  70         sprintf(index_directory, BCASTDIR);
  71         if(strlen(index_directory))
  72                 fs.complete_path(index_directory);
  73         cache_size = 0xa00000;
  74         index_size = 0x300000;
  75         index_count = 100;
  76         use_thumbnails = 1;
  77         trap_sigsegv = 0;
  78         trap_sigintr = 0;
  79         theme[0] = 0;
  80         use_renderfarm = 0;
  81         force_uniprocessor = 0;
  82         renderfarm_port = DEAMON_PORT;
  83         render_preroll = 0.5;
  84         brender_preroll = 0;
  85         renderfarm_mountpoint[0] = 0;
  86         renderfarm_vfs = 0;
  87         renderfarm_job_count = 20;
  88         processors = calculate_processors(0);
  89         real_processors = calculate_processors(1);
  90         file_forking = 1;
  91         ffmpeg_early_probe = 0;
  92         warn_indecies = 1;
  93
  94 // Default brender asset
  95         brender_asset = new Asset;
  96         brender_asset->audio_data = 0;
  97         brender_asset->video_data = 1;
  98         sprintf(brender_asset->path, "/tmp/brender");
  99         brender_asset->format = FILE_JPEG_LIST;
 100         brender_asset->jpeg_quality = 80;
 101
 102         use_brender = 0;
 103         brender_fragment = 1;
 104         local_rate = 0.0;
 105
 106         use_tipwindow = 1;
 107         scan_commercials = 0;
 108
 109         android_remote = 0;
 110         android_port = 23432;
 111         strcpy(android_pin, "cinelerra");
 112
 113         for(int i = 0; i < MAXCHANNELS; i++)
 114         {
 115                 for(int j = 0; j < i + 1; j++)
 116                 {
 117                         int position = 180 - (360 * j / (i + 1));
 118                         while(position < 0) position += 360;
 119                         channel_positions[i * MAXCHANNELS + j] = position;
 120                 }
 121         }
 122 }
 123
 124 Preferences::~Preferences()
 125 {
 126         brender_asset->Garbage::remove_user();
 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         strcpy(theme, that->theme);
 176
 177         use_tipwindow = that->use_tipwindow;
 178         scan_commercials = that->scan_commercials;
 179         android_remote = that->android_remote;
 180         android_port = that->android_port;
 181         strcpy(android_pin, that->android_pin);
 182         this->shbtn_prefs.remove_all_objects();
 183         for( int i=0; i<that->shbtn_prefs.size(); ++i )
 184                 this->shbtn_prefs.append(new ShBtnPref(*that->shbtn_prefs[i]));
 185         cache_size = that->cache_size;
 186         force_uniprocessor = that->force_uniprocessor;
 187         trap_sigsegv = that->trap_sigsegv;
 188         trap_sigintr = that->trap_sigintr;
 189         processors = that->processors;
 190         real_processors = that->real_processors;
 191         file_forking = that->file_forking;
 192         ffmpeg_early_probe = that->ffmpeg_early_probe;
 193         warn_indecies = that->warn_indecies;
 194         renderfarm_nodes.remove_all_objects();
 195         renderfarm_ports.remove_all();
 196         renderfarm_enabled.remove_all();
 197         renderfarm_rate.remove_all();
 198         local_rate = that->local_rate;
 199         for(int i = 0; i < that->renderfarm_nodes.size(); i++)
 200         {
 201                 add_node(that->renderfarm_nodes.get(i),
 202                         that->renderfarm_ports.get(i),
 203                         that->renderfarm_enabled.get(i),
 204                         that->renderfarm_rate.get(i));
 205         }
 206         use_renderfarm = that->use_renderfarm;
 207         renderfarm_port = that->renderfarm_port;
 208         render_preroll = that->render_preroll;
 209         brender_preroll = that->brender_preroll;
 210         renderfarm_job_count = that->renderfarm_job_count;
 211         renderfarm_vfs = that->renderfarm_vfs;
 212         strcpy(renderfarm_mountpoint, that->renderfarm_mountpoint);
 213         renderfarm_consolidate = that->renderfarm_consolidate;
 214         use_brender = that->use_brender;
 215         brender_fragment = that->brender_fragment;
 216         brender_asset->copy_from(that->brender_asset, 0);
 217
 218 // Check boundaries
 219
 220         FileSystem fs;
 221         if(strlen(index_directory))
 222         {
 223                 fs.complete_path(index_directory);
 224                 fs.add_end_slash(index_directory);
 225         }
 226
 227 //      if(strlen(global_plugin_dir))
 228 //      {
 229 //              fs.complete_path(global_plugin_dir);
 230 //              fs.add_end_slash(global_plugin_dir);
 231 //      }
 232 //
 233
 234 // Redo with the proper value of force_uniprocessor
 235         processors = calculate_processors(0);
 236         boundaries();
 237 }
 238
 239 void Preferences::boundaries()
 240 {
 241         renderfarm_job_count = MAX(renderfarm_job_count, 1);
 242         CLAMP(cache_size, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 243 }
 244
 245 Preferences& Preferences::operator=(Preferences &that)
 246 {
 247 printf("Preferences::operator=\n");
 248         copy_from(&that);
 249         return *this;
 250 }
 251
 252 void Preferences::print_channels(char *string,
 253         int *channel_positions,
 254         int channels)
 255 {
 256         char string3[BCTEXTLEN];
 257         string[0] = 0;
 258         for(int j = 0; j < channels; j++)
 259         {
 260                 sprintf(string3, "%d", channel_positions[j]);
 261                 strcat(string, string3);
 262                 if(j < channels - 1)
 263                         strcat(string, ",");
 264         }
 265 }
 266
 267 void Preferences::scan_channels(char *string,
 268         int *channel_positions,
 269         int channels)
 270 {
 271         char string2[BCTEXTLEN];
 272         int len = strlen(string);
 273         int current_channel = 0;
 274         for(int i = 0; i < len; i++)
 275         {
 276                 strcpy(string2, &string[i]);
 277                 for(int j = 0; j < BCTEXTLEN; j++)
 278                 {
 279                         if(string2[j] == ',' || string2[j] == 0)
 280                         {
 281                                 i += j;
 282                                 string2[j] = 0;
 283                                 break;
 284                         }
 285                 }
 286                 channel_positions[current_channel++] = atoi(string2);
 287                 if(current_channel >= channels) break;
 288         }
 289 }
 290
 291 int Preferences::load_defaults(BC_Hash *defaults)
 292 {
 293         char string[BCTEXTLEN];
 294
 295         use_tipwindow = defaults->get("USE_TIPWINDOW", use_tipwindow);
 296         scan_commercials = defaults->get("SCAN_COMMERCIALS", scan_commercials);
 297         android_remote = defaults->get("ANDROID_REMOTE", android_remote);
 298         android_port = defaults->get("ANDROID_PORT", android_port);
 299         defaults->get("ANDROID_PIN", android_pin);
 300         defaults->get("INDEX_DIRECTORY", index_directory);
 301         index_size = defaults->get("INDEX_SIZE", index_size);
 302         index_count = defaults->get("INDEX_COUNT", index_count);
 303         use_thumbnails = defaults->get("USE_THUMBNAILS", use_thumbnails);
 304         trap_sigsegv = defaults->get("TRAP_SIGSEGV", trap_sigsegv);
 305         trap_sigintr = defaults->get("TRAP_SIGINTR", trap_sigintr);
 306
 307 //      sprintf(global_plugin_dir, PLUGIN_DIR);
 308 //      defaults->get("GLOBAL_PLUGIN_DIR", global_plugin_dir);
 309 //      if(getenv("GLOBAL_PLUGIN_DIR"))
 310 //      {
 311 //              strcpy(global_plugin_dir, getenv("GLOBAL_PLUGIN_DIR"));
 312 //      }
 313
 314         strcpy(theme, DEFAULT_THEME);
 315         defaults->get("THEME", theme);
 316
 317         for(int i = 0; i < MAXCHANNELS; i++)
 318         {
 319                 char string2[BCTEXTLEN];
 320                 sprintf(string, "CHANNEL_POSITIONS%d", i);
 321                 print_channels(string2,
 322                         &channel_positions[i * MAXCHANNELS],
 323                         i + 1);
 324
 325                 defaults->get(string, string2);
 326
 327                 scan_channels(string2,
 328                         &channel_positions[i * MAXCHANNELS],
 329                         i + 1);
 330         }
 331
 332         brender_asset->load_defaults(defaults,
 333                 "BRENDER_",
 334                 1,
 335                 1,
 336                 1,
 337                 0,
 338                 0);
 339
 340
 341
 342         force_uniprocessor = defaults->get("FORCE_UNIPROCESSOR", 0);
 343         file_forking = defaults->get("FILE_FORKING", 1);
 344         ffmpeg_early_probe = defaults->get("FFMPEG_EARLY_PROBE", 0);
 345         warn_indecies = defaults->get("WARN_INDECIES", 1);
 346         use_brender = defaults->get("USE_BRENDER", use_brender);
 347         brender_fragment = defaults->get("BRENDER_FRAGMENT", brender_fragment);
 348         cache_size = defaults->get("CACHE_SIZE", cache_size);
 349         local_rate = defaults->get("LOCAL_RATE", local_rate);
 350         use_renderfarm = defaults->get("USE_RENDERFARM", use_renderfarm);
 351         renderfarm_port = defaults->get("RENDERFARM_PORT", renderfarm_port);
 352         render_preroll = defaults->get("RENDERFARM_PREROLL", render_preroll);
 353         brender_preroll = defaults->get("BRENDER_PREROLL", brender_preroll);
 354         renderfarm_job_count = defaults->get("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 355         renderfarm_consolidate = defaults->get("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 356 //      renderfarm_vfs = defaults->get("RENDERFARM_VFS", renderfarm_vfs);
 357         defaults->get("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 358         int renderfarm_total = defaults->get("RENDERFARM_TOTAL", 0);
 359
 360         for(int i = 0; i < renderfarm_total; i++)
 361         {
 362                 sprintf(string, "RENDERFARM_NODE%d", i);
 363                 char result[BCTEXTLEN];
 364                 int result_port = 0;
 365                 int result_enabled = 0;
 366                 float result_rate = 0.0;
 367
 368                 result[0] = 0;
 369                 defaults->get(string, result);
 370
 371                 sprintf(string, "RENDERFARM_PORT%d", i);
 372                 result_port = defaults->get(string, renderfarm_port);
 373
 374                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 375                 result_enabled = defaults->get(string, result_enabled);
 376
 377                 sprintf(string, "RENDERFARM_RATE%d", i);
 378                 result_rate = defaults->get(string, result_rate);
 379
 380                 if(result[0] != 0)
 381                 {
 382                         add_node(result, result_port, result_enabled, result_rate);
 383                 }
 384         }
 385
 386         shbtn_prefs.remove_all_objects();
 387         int shbtns_total = defaults->get("SHBTNS_TOTAL", -1);
 388         if( shbtns_total < 0 ) {
 389                 shbtn_prefs.append(new ShBtnPref("manual", "firefox file:///$CINELERRA_PATH/manual.pdf", 0));
 390                 shbtn_prefs.append(new ShBtnPref("online help", "firefox http://cinelerra.org/help.php/", 0));
 391                 shbtns_total = 0;
 392         }
 393         for( int i=0; i<shbtns_total; ++i ) {
 394                 char name[BCTEXTLEN], commands[BCTEXTLEN];
 395                 sprintf(string, "SHBTN%d_NAME", i);
 396                 defaults->get(string, name);
 397                 sprintf(string, "SHBTN%d_COMMANDS", i);
 398                 defaults->get(string, commands);
 399                 sprintf(string, "SHBTN%d_WARN", i);
 400                 int warn = defaults->get(string, 0);
 401                 shbtn_prefs.append(new ShBtnPref(name, commands, warn));
 402         }
 403
 404 // Redo with the proper value of force_uniprocessor
 405         processors = calculate_processors(0);
 406         boundaries();
 407         return 0;
 408 }
 409
 410 int Preferences::save_defaults(BC_Hash *defaults)
 411 {
 412         char string[BCTEXTLEN];
 413
 414
 415         defaults->update("USE_TIPWINDOW", use_tipwindow);
 416         defaults->update("SCAN_COMMERCIALS", scan_commercials);
 417         defaults->update("ANDROID_REMOTE", android_remote);
 418         defaults->update("ANDROID_PIN", android_pin);
 419         defaults->update("ANDROID_PORT", android_port);
 420
 421         defaults->update("CACHE_SIZE", cache_size);
 422         defaults->update("INDEX_DIRECTORY", index_directory);
 423         defaults->update("INDEX_SIZE", index_size);
 424         defaults->update("INDEX_COUNT", index_count);
 425         defaults->update("USE_THUMBNAILS", use_thumbnails);
 426         defaults->update("TRAP_SIGSEGV", trap_sigsegv);
 427         defaults->update("TRAP_SIGINTR", trap_sigintr);
 428 //      defaults->update("GLOBAL_PLUGIN_DIR", global_plugin_dir);
 429         defaults->update("THEME", theme);
 430
 431
 432         for(int i = 0; i < MAXCHANNELS; i++)
 433         {
 434                 char string2[BCTEXTLEN];
 435                 sprintf(string, "CHANNEL_POSITIONS%d", i);
 436                 print_channels(string2, &channel_positions[i * MAXCHANNELS], i + 1);
 437                 defaults->update(string, string2);
 438         }
 439
 440         defaults->update("FORCE_UNIPROCESSOR", force_uniprocessor);
 441         defaults->update("FILE_FORKING", file_forking);
 442         defaults->update("FFMPEG_EARLY_PROBE", ffmpeg_early_probe);
 443         defaults->update("WARN_INDECIES", warn_indecies);
 444         brender_asset->save_defaults(defaults,
 445                 "BRENDER_",
 446                 1,
 447                 1,
 448                 1,
 449                 0,
 450                 0);
 451         defaults->update("USE_BRENDER", use_brender);
 452         defaults->update("BRENDER_FRAGMENT", brender_fragment);
 453         defaults->update("USE_RENDERFARM", use_renderfarm);
 454         defaults->update("LOCAL_RATE", local_rate);
 455         defaults->update("RENDERFARM_PORT", renderfarm_port);
 456         defaults->update("RENDERFARM_PREROLL", render_preroll);
 457         defaults->update("BRENDER_PREROLL", brender_preroll);
 458 //      defaults->update("RENDERFARM_VFS", renderfarm_vfs);
 459         defaults->update("RENDERFARM_MOUNTPOINT", renderfarm_mountpoint);
 460         defaults->update("RENDERFARM_JOBS_COUNT", renderfarm_job_count);
 461         defaults->update("RENDERFARM_CONSOLIDATE", renderfarm_consolidate);
 462         defaults->update("RENDERFARM_TOTAL", (int64_t)renderfarm_nodes.total);
 463         for(int i = 0; i < renderfarm_nodes.total; i++)
 464         {
 465                 sprintf(string, "RENDERFARM_NODE%d", i);
 466                 defaults->update(string, renderfarm_nodes.values[i]);
 467                 sprintf(string, "RENDERFARM_PORT%d", i);
 468                 defaults->update(string, renderfarm_ports.values[i]);
 469                 sprintf(string, "RENDERFARM_ENABLED%d", i);
 470                 defaults->update(string, renderfarm_enabled.values[i]);
 471                 sprintf(string, "RENDERFARM_RATE%d", i);
 472                 defaults->update(string, renderfarm_rate.values[i]);
 473         }
 474         defaults->update("SHBTNS_TOTAL", shbtn_prefs.size());
 475         for( int i=0; i<shbtn_prefs.size(); ++i ) {
 476                 ShBtnPref *pref = shbtn_prefs[i];
 477                 sprintf(string, "SHBTN%d_NAME", i);
 478                 defaults->update(string, pref->name);
 479                 sprintf(string, "SHBTN%d_COMMANDS", i);
 480                 defaults->update(string, pref->commands);
 481                 sprintf(string, "SHBTN%d_WARN", i);
 482                 defaults->update(string, pref->warn);
 483         }
 484         return 0;
 485 }
 486
 487
 488 void Preferences::add_node(const char *text, int port, int enabled, float rate)
 489 {
 490         if(text[0] == 0) return;
 491
 492         preferences_lock->lock("Preferences::add_node");
 493         char *new_item = new char[strlen(text) + 1];
 494         strcpy(new_item, text);
 495         renderfarm_nodes.append(new_item);
 496         renderfarm_ports.append(port);
 497         renderfarm_enabled.append(enabled);
 498         renderfarm_rate.append(rate);
 499         preferences_lock->unlock();
 500 }
 501
 502 void Preferences::delete_node(int number)
 503 {
 504         preferences_lock->lock("Preferences::delete_node");
 505         if(number < renderfarm_nodes.total && number >= 0)
 506         {
 507                 delete [] renderfarm_nodes.values[number];
 508                 renderfarm_nodes.remove_number(number);
 509                 renderfarm_ports.remove_number(number);
 510                 renderfarm_enabled.remove_number(number);
 511                 renderfarm_rate.remove_number(number);
 512         }
 513         preferences_lock->unlock();
 514 }
 515
 516 void Preferences::delete_nodes()
 517 {
 518         preferences_lock->lock("Preferences::delete_nodes");
 519         for(int i = 0; i < renderfarm_nodes.total; i++)
 520                 delete [] renderfarm_nodes.values[i];
 521         renderfarm_nodes.remove_all();
 522         renderfarm_ports.remove_all();
 523         renderfarm_enabled.remove_all();
 524         renderfarm_rate.remove_all();
 525         preferences_lock->unlock();
 526 }
 527
 528 void Preferences::reset_rates()
 529 {
 530         for(int i = 0; i < renderfarm_nodes.total; i++)
 531         {
 532                 renderfarm_rate.values[i] = 0.0;
 533         }
 534         local_rate = 0.0;
 535 }
 536
 537 float Preferences::get_rate(int node)
 538 {
 539         if(node < 0)
 540         {
 541                 return local_rate;
 542         }
 543         else
 544         {
 545                 int total = 0;
 546                 for(int i = 0; i < renderfarm_nodes.size(); i++)
 547                 {
 548                         if(renderfarm_enabled.get(i)) total++;
 549                         if(total == node + 1)
 550                         {
 551                                 return renderfarm_rate.get(i);
 552                         }
 553                 }
 554         }
 555
 556         return 0;
 557 }
 558
 559 void Preferences::set_rate(float rate, int node)
 560 {
 561 //printf("Preferences::set_rate %f %d\n", rate, node);
 562         if(node < 0)
 563         {
 564                 local_rate = rate;
 565         }
 566         else
 567         {
 568                 int total = 0;
 569                 for(int i = 0; i < renderfarm_nodes.size(); i++)
 570                 {
 571                         if(renderfarm_enabled.get(i)) total++;
 572                         if(total == node + 1)
 573                         {
 574                                 renderfarm_rate.set(i, rate);
 575                                 return;
 576                         }
 577                 }
 578         }
 579 }
 580
 581 float Preferences::get_avg_rate(int use_master_node)
 582 {
 583         preferences_lock->lock("Preferences::get_avg_rate");
 584         float total = 0.0;
 585         if(renderfarm_rate.total)
 586         {
 587                 int enabled = 0;
 588                 if(use_master_node)
 589                 {
 590                         if(EQUIV(local_rate, 0.0))
 591                         {
 592                                 preferences_lock->unlock();
 593                                 return 0.0;
 594                         }
 595                         else
 596                         {
 597                                 enabled++;
 598                                 total += local_rate;
 599                         }
 600                 }
 601
 602                 for(int i = 0; i < renderfarm_rate.total; i++)
 603                 {
 604                         if(renderfarm_enabled.values[i])
 605                         {
 606                                 enabled++;
 607                                 total += renderfarm_rate.values[i];
 608                                 if(EQUIV(renderfarm_rate.values[i], 0.0))
 609                                 {
 610                                         preferences_lock->unlock();
 611                                         return 0.0;
 612                                 }
 613                         }
 614                 }
 615
 616                 if(enabled)
 617                         total /= enabled;
 618                 else
 619                         total = 0.0;
 620         }
 621         preferences_lock->unlock();
 622
 623         return total;
 624 }
 625
 626 void Preferences::sort_nodes()
 627 {
 628         int done = 0;
 629
 630         while(!done)
 631         {
 632                 done = 1;
 633                 for(int i = 0; i < renderfarm_nodes.total - 1; i++)
 634                 {
 635                         if(strcmp(renderfarm_nodes.values[i], renderfarm_nodes.values[i + 1]) > 0)
 636                         {
 637                                 char *temp = renderfarm_nodes.values[i];
 638                                 int temp_port = renderfarm_ports.values[i];
 639
 640                                 renderfarm_nodes.values[i] = renderfarm_nodes.values[i + 1];
 641                                 renderfarm_nodes.values[i + 1] = temp;
 642
 643                                 renderfarm_ports.values[i] = renderfarm_ports.values[i + 1];
 644                                 renderfarm_ports.values[i + 1] = temp_port;
 645
 646                                 renderfarm_enabled.values[i] = renderfarm_enabled.values[i + 1];
 647                                 renderfarm_enabled.values[i + 1] = temp_port;
 648
 649                                 renderfarm_rate.values[i] = renderfarm_rate.values[i + 1];
 650                                 renderfarm_rate.values[i + 1] = temp_port;
 651                                 done = 0;
 652                         }
 653                 }
 654         }
 655 }
 656
 657 void Preferences::edit_node(int number,
 658         const char *new_text,
 659         int new_port,
 660         int new_enabled)
 661 {
 662         char *new_item = new char[strlen(new_text) + 1];
 663         strcpy(new_item, new_text);
 664
 665         delete [] renderfarm_nodes.values[number];
 666         renderfarm_nodes.values[number] = new_item;
 667         renderfarm_ports.values[number] = new_port;
 668         renderfarm_enabled.values[number] = new_enabled;
 669 }
 670
 671 int Preferences::get_enabled_nodes()
 672 {
 673         int result = 0;
 674         for(int i = 0; i < renderfarm_enabled.total; i++)
 675                 if(renderfarm_enabled.values[i]) result++;
 676         return result;
 677 }
 678
 679 const char* Preferences::get_node_hostname(int number)
 680 {
 681         int total = 0;
 682         for(int i = 0; i < renderfarm_nodes.total; i++)
 683         {
 684                 if(renderfarm_enabled.values[i])
 685                 {
 686                         if(total == number)
 687                                 return renderfarm_nodes.values[i];
 688                         else
 689                                 total++;
 690                 }
 691         }
 692         return "";
 693 }
 694
 695 int Preferences::get_node_port(int number)
 696 {
 697         int total = 0;
 698         for(int i = 0; i < renderfarm_ports.total; i++)
 699         {
 700                 if(renderfarm_enabled.values[i])
 701                 {
 702                         if(total == number)
 703                                 return renderfarm_ports.values[i];
 704                         else
 705                                 total++;
 706                 }
 707         }
 708         return -1;
 709 }
 710
 711 int Preferences::get_asset_file_path(Asset *asset, char *path)
 712 {
 713         strcpy(path, asset->path);
 714         int result = access(path, R_OK);
 715         if( !result && asset->format == FILE_MPEG ) {
 716                 char source_filename[BCTEXTLEN];
 717                 char index_filename[BCTEXTLEN];
 718                 IndexFile::get_index_filename(source_filename,
 719                         index_directory, index_filename,
 720                         asset->path, ".toc");
 721                 struct stat st;
 722                 if( !access(index_filename, R_OK) &&
 723                     !stat(index_filename,&st) && st.st_size > 0 )
 724                 strcpy(path, index_filename);
 725         }
 726         return result;
 727 }
 728
 729
 730 int Preferences::calculate_processors(int interactive)
 731 {
 732         if(force_uniprocessor && !interactive) return 1;
 733         return BC_WindowBase::get_resources()->machine_cpus;
 734 }
 735