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