cinelerra-5.1/cinelerra/preferences.C

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