src/lib/config.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic 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     DCP-o-matic 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 DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "cinema.h"
  23 #include "colour_conversion.h"
  24 #include "compose.hpp"
  25 #include "config.h"
  26 #include "cross.h"
  27 #include "crypto.h"
  28 #include "dcp_content_type.h"
  29 #include "dkdm_recipient.h"
  30 #include "dkdm_wrapper.h"
  31 #include "film.h"
  32 #include "filter.h"
  33 #include "log.h"
  34 #include "ratio.h"
  35 #include "types.h"
  36 #include "util.h"
  37 #include <dcp/certificate_chain.h>
  38 #include <dcp/name_format.h>
  39 #include <dcp/raw_convert.h>
  40 #include <libcxml/cxml.h>
  41 #include <glib.h>
  42 #include <libxml++/libxml++.h>
  43 #include <boost/filesystem.hpp>
  44 #include <boost/algorithm/string.hpp>
  45 #include <boost/thread.hpp>
  46 #include <cstdlib>
  47 #include <fstream>
  48 #include <iostream>
  49
  50 #include "i18n.h"
  51
  52
  53 using std::cout;
  54 using std::dynamic_pointer_cast;
  55 using std::ifstream;
  56 using std::list;
  57 using std::make_shared;
  58 using std::max;
  59 using std::min;
  60 using std::remove;
  61 using std::shared_ptr;
  62 using std::string;
  63 using std::vector;
  64 using boost::algorithm::trim;
  65 using boost::optional;
  66 using dcp::raw_convert;
  67
  68
  69 Config* Config::_instance = 0;
  70 int const Config::_current_version = 3;
  71 boost::signals2::signal<void ()> Config::FailedToLoad;
  72 boost::signals2::signal<void (string)> Config::Warning;
  73 boost::signals2::signal<bool (Config::BadReason)> Config::Bad;
  74
  75
  76 /** Construct default configuration */
  77 Config::Config ()
  78         /* DKDMs are not considered a thing to reset on set_defaults() */
  79         : _dkdms (new DKDMGroup ("root"))
  80 {
  81         set_defaults ();
  82 }
  83
  84 void
  85 Config::set_defaults ()
  86 {
  87         _master_encoding_threads = max (2U, boost::thread::hardware_concurrency ());
  88         _server_encoding_threads = max (2U, boost::thread::hardware_concurrency ());
  89         _server_port_base = 6192;
  90         _use_any_servers = true;
  91         _servers.clear ();
  92         _only_servers_encode = false;
  93         _tms_protocol = FileTransferProtocol::SCP;
  94         _tms_ip = "";
  95         _tms_path = ".";
  96         _tms_user = "";
  97         _tms_password = "";
  98         _allow_any_dcp_frame_rate = false;
  99         _allow_any_container = false;
 100         _allow_96khz_audio = false;
 101         _show_experimental_audio_processors = false;
 102         _language = optional<string> ();
 103         _default_still_length = 10;
 104         _default_container = Ratio::from_id ("185");
 105         _default_dcp_content_type = DCPContentType::from_isdcf_name ("FTR");
 106         _default_dcp_audio_channels = 6;
 107         _default_j2k_bandwidth = 150000000;
 108         _default_audio_delay = 0;
 109         _default_interop = false;
 110         _default_metadata.clear ();
 111         _upload_after_make_dcp = false;
 112         _mail_server = "";
 113         _mail_port = 25;
 114         _mail_protocol = EmailProtocol::AUTO;
 115         _mail_user = "";
 116         _mail_password = "";
 117         _kdm_from = "";
 118         _kdm_cc.clear ();
 119         _kdm_bcc = "";
 120         _notification_from = "";
 121         _notification_to = "";
 122         _notification_cc.clear ();
 123         _notification_bcc = "";
 124         _check_for_updates = false;
 125         _check_for_test_updates = false;
 126         _maximum_j2k_bandwidth = 250000000;
 127         _log_types = LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | LogEntry::TYPE_ERROR | LogEntry::TYPE_DISK;
 128         _analyse_ebur128 = true;
 129         _automatic_audio_analysis = false;
 130 #ifdef DCPOMATIC_WINDOWS
 131         _win32_console = false;
 132 #endif
 133         /* At the moment we don't write these files anywhere new after a version change, so they will be read from
 134          * ~/.config/dcpomatic2 (or equivalent) and written back there.
 135          */
 136         _cinemas_file = read_path ("cinemas.xml");
 137         _dkdm_recipients_file = read_path ("dkdm_recipients.xml");
 138         _show_hints_before_make_dcp = true;
 139         _confirm_kdm_email = true;
 140         _kdm_container_name_format = dcp::NameFormat ("KDM %f %c");
 141         _kdm_filename_format = dcp::NameFormat ("KDM %f %c %s");
 142         _dkdm_filename_format = dcp::NameFormat ("DKDM %f %c %s");
 143         _dcp_metadata_filename_format = dcp::NameFormat ("%t");
 144         _dcp_asset_filename_format = dcp::NameFormat ("%t");
 145         _jump_to_selected = true;
 146         for (int i = 0; i < NAG_COUNT; ++i) {
 147                 _nagged[i] = false;
 148         }
 149         _sound = true;
 150         _sound_output = optional<string> ();
 151         _last_kdm_write_type = KDM_WRITE_FLAT;
 152         _last_dkdm_write_type = DKDM_WRITE_INTERNAL;
 153
 154         /* I think the scaling factor here should be the ratio of the longest frame
 155            encode time to the shortest; if the thread count is T, longest time is L
 156            and the shortest time S we could encode L/S frames per thread whilst waiting
 157            for the L frame to encode so we might have to store LT/S frames.
 158
 159            However we don't want to use too much memory, so keep it a bit lower than we'd
 160            perhaps like.  A J2K frame is typically about 1Mb so 3 here will mean we could
 161            use about 240Mb with 72 encoding threads.
 162         */
 163         _frames_in_memory_multiplier = 3;
 164         _decode_reduction = optional<int>();
 165         _default_notify = false;
 166         for (int i = 0; i < NOTIFICATION_COUNT; ++i) {
 167                 _notification[i] = false;
 168         }
 169         _barco_username = optional<string>();
 170         _barco_password = optional<string>();
 171         _christie_username = optional<string>();
 172         _christie_password = optional<string>();
 173         _gdc_username = optional<string>();
 174         _gdc_password = optional<string>();
 175         _player_mode = PLAYER_MODE_WINDOW;
 176         _image_display = 0;
 177         _video_view_type = VIDEO_VIEW_SIMPLE;
 178         _respect_kdm_validity_periods = true;
 179         _player_debug_log_file = boost::none;
 180         _player_content_directory = boost::none;
 181         _player_playlist_directory = boost::none;
 182         _player_kdm_directory = boost::none;
 183         _audio_mapping = boost::none;
 184         _custom_languages.clear ();
 185         _add_files_path = boost::none;
 186
 187         _allowed_dcp_frame_rates.clear ();
 188         _allowed_dcp_frame_rates.push_back (24);
 189         _allowed_dcp_frame_rates.push_back (25);
 190         _allowed_dcp_frame_rates.push_back (30);
 191         _allowed_dcp_frame_rates.push_back (48);
 192         _allowed_dcp_frame_rates.push_back (50);
 193         _allowed_dcp_frame_rates.push_back (60);
 194
 195         set_kdm_email_to_default ();
 196         set_notification_email_to_default ();
 197         set_cover_sheet_to_default ();
 198 }
 199
 200 void
 201 Config::restore_defaults ()
 202 {
 203         Config::instance()->set_defaults ();
 204         Config::instance()->changed ();
 205 }
 206
 207 shared_ptr<dcp::CertificateChain>
 208 Config::create_certificate_chain ()
 209 {
 210         return make_shared<dcp::CertificateChain> (
 211                 openssl_path(),
 212                 "dcpomatic.com",
 213                 "dcpomatic.com",
 214                 ".dcpomatic.smpte-430-2.ROOT",
 215                 ".dcpomatic.smpte-430-2.INTERMEDIATE",
 216                 "CS.dcpomatic.smpte-430-2.LEAF"
 217                 );
 218 }
 219
 220 void
 221 Config::backup ()
 222 {
 223         using namespace boost::filesystem;
 224
 225         auto copy_adding_number = [](path const& path_to_copy) {
 226
 227                 auto add_number = [](path const& path, int number) {
 228                         return String::compose("%1.%2", path, number);
 229                 };
 230
 231                 int n = 1;
 232                 while (n < 100 && exists(add_number(path_to_copy, n))) {
 233                         ++n;
 234                 }
 235                 copy_file(path_to_copy, add_number(path_to_copy, n));
 236         };
 237
 238         /* Make a backup copy of any config.xml, cinemas.xml, dkdm_recipients.xml that we might be about
 239          * to write over.  This is more intended for the situation where we have a corrupted config.xml,
 240          * and decide to overwrite it with a new one (possibly losing important details in the corrupted
 241          * file).  But we might as well back up the other files while we're about it.
 242          */
 243         try {
 244                 /* This uses the State::write_path stuff so, e.g. for a current version 2.16 we might copy
 245                  * ~/.config/dcpomatic2/2.16/config.xml to ~/.config/dcpomatic2/2.16/config.xml.1
 246                  */
 247                 copy_adding_number (config_write_file());
 248
 249                 /* These do not use State::write_path, so whatever path is in the Config we will copy
 250                  * adding a number.
 251                  */
 252                 copy_adding_number (_cinemas_file);
 253                 copy_adding_number (_dkdm_recipients_file);
 254         } catch (...) {}
 255 }
 256
 257 void
 258 Config::read ()
 259 try
 260 {
 261         cxml::Document f ("Config");
 262         f.read_file (config_read_file());
 263
 264         auto version = f.optional_number_child<int> ("Version");
 265         if (version && *version < _current_version) {
 266                 /* Back up the old config before we re-write it in a back-incompatible way */
 267                 backup ();
 268         }
 269
 270         if (f.optional_number_child<int>("NumLocalEncodingThreads")) {
 271                 _master_encoding_threads = _server_encoding_threads = f.optional_number_child<int>("NumLocalEncodingThreads").get();
 272         } else {
 273                 _master_encoding_threads = f.number_child<int>("MasterEncodingThreads");
 274                 _server_encoding_threads = f.number_child<int>("ServerEncodingThreads");
 275         }
 276
 277         _default_directory = f.optional_string_child ("DefaultDirectory");
 278         if (_default_directory && _default_directory->empty ()) {
 279                 /* We used to store an empty value for this to mean "none set" */
 280                 _default_directory = boost::optional<boost::filesystem::path> ();
 281         }
 282
 283         auto b = f.optional_number_child<int> ("ServerPort");
 284         if (!b) {
 285                 b = f.optional_number_child<int> ("ServerPortBase");
 286         }
 287         _server_port_base = b.get ();
 288
 289         auto u = f.optional_bool_child ("UseAnyServers");
 290         _use_any_servers = u.get_value_or (true);
 291
 292         for (auto i: f.node_children("Server")) {
 293                 if (i->node_children("HostName").size() == 1) {
 294                         _servers.push_back (i->string_child ("HostName"));
 295                 } else {
 296                         _servers.push_back (i->content ());
 297                 }
 298         }
 299
 300         _only_servers_encode = f.optional_bool_child ("OnlyServersEncode").get_value_or (false);
 301         _tms_protocol = static_cast<FileTransferProtocol>(f.optional_number_child<int>("TMSProtocol").get_value_or(static_cast<int>(FileTransferProtocol::SCP)));
 302         _tms_ip = f.string_child ("TMSIP");
 303         _tms_path = f.string_child ("TMSPath");
 304         _tms_user = f.string_child ("TMSUser");
 305         _tms_password = f.string_child ("TMSPassword");
 306
 307         _language = f.optional_string_child ("Language");
 308
 309         auto c = f.optional_string_child ("DefaultContainer");
 310         if (c) {
 311                 _default_container = Ratio::from_id (c.get ());
 312         }
 313
 314         if (_default_container && !_default_container->used_for_container()) {
 315                 Warning (_("Your default container is not valid and has been changed to Flat (1.85:1)"));
 316                 _default_container = Ratio::from_id ("185");
 317         }
 318
 319         _default_dcp_content_type = DCPContentType::from_isdcf_name(f.optional_string_child("DefaultDCPContentType").get_value_or("FTR"));
 320         _default_dcp_audio_channels = f.optional_number_child<int>("DefaultDCPAudioChannels").get_value_or (6);
 321
 322         if (f.optional_string_child ("DCPMetadataIssuer")) {
 323                 _dcp_issuer = f.string_child ("DCPMetadataIssuer");
 324         } else if (f.optional_string_child ("DCPIssuer")) {
 325                 _dcp_issuer = f.string_child ("DCPIssuer");
 326         }
 327
 328         auto up = f.optional_bool_child("UploadAfterMakeDCP");
 329         if (!up) {
 330                 up = f.optional_bool_child("DefaultUploadAfterMakeDCP");
 331         }
 332         _upload_after_make_dcp = up.get_value_or (false);
 333         _dcp_creator = f.optional_string_child ("DCPCreator").get_value_or ("");
 334         _dcp_company_name = f.optional_string_child("DCPCompanyName").get_value_or("");
 335         _dcp_product_name = f.optional_string_child("DCPProductName").get_value_or("");
 336         _dcp_product_version = f.optional_string_child("DCPProductVersion").get_value_or("");
 337         _dcp_j2k_comment = f.optional_string_child("DCPJ2KComment").get_value_or("");
 338
 339         _default_still_length = f.optional_number_child<int>("DefaultStillLength").get_value_or (10);
 340         _default_j2k_bandwidth = f.optional_number_child<int>("DefaultJ2KBandwidth").get_value_or (200000000);
 341         _default_audio_delay = f.optional_number_child<int>("DefaultAudioDelay").get_value_or (0);
 342         _default_interop = f.optional_bool_child("DefaultInterop").get_value_or (false);
 343
 344         for (auto const& i: f.node_children("DefaultMetadata")) {
 345                 _default_metadata[i->string_attribute("key")] = i->content();
 346         }
 347
 348         _default_kdm_directory = f.optional_string_child("DefaultKDMDirectory");
 349
 350         /* Read any cinemas that are still lying around in the config file
 351          * from an old version.
 352          */
 353         read_cinemas (f);
 354
 355         _mail_server = f.string_child ("MailServer");
 356         _mail_port = f.optional_number_child<int> ("MailPort").get_value_or (25);
 357
 358         {
 359                 /* Make sure this matches the code in write_config */
 360                 string const protocol = f.optional_string_child("MailProtocol").get_value_or("Auto");
 361                 if (protocol == "Auto") {
 362                         _mail_protocol = EmailProtocol::AUTO;
 363                 } else if (protocol == "Plain") {
 364                         _mail_protocol = EmailProtocol::PLAIN;
 365                 } else if (protocol == "STARTTLS") {
 366                         _mail_protocol = EmailProtocol::STARTTLS;
 367                 } else if (protocol == "SSL") {
 368                         _mail_protocol = EmailProtocol::SSL;
 369                 }
 370         }
 371
 372         _mail_user = f.optional_string_child("MailUser").get_value_or ("");
 373         _mail_password = f.optional_string_child("MailPassword").get_value_or ("");
 374
 375         _kdm_subject = f.optional_string_child ("KDMSubject").get_value_or (_("KDM delivery: $CPL_NAME"));
 376         _kdm_from = f.string_child ("KDMFrom");
 377         for (auto i: f.node_children("KDMCC")) {
 378                 if (!i->content().empty()) {
 379                         _kdm_cc.push_back (i->content ());
 380                 }
 381         }
 382         _kdm_bcc = f.optional_string_child ("KDMBCC").get_value_or ("");
 383         _kdm_email = f.string_child ("KDMEmail");
 384
 385         _notification_subject = f.optional_string_child("NotificationSubject").get_value_or(_("DCP-o-matic notification"));
 386         _notification_from = f.optional_string_child("NotificationFrom").get_value_or("");
 387         _notification_to = f.optional_string_child("NotificationTo").get_value_or("");
 388         for (auto i: f.node_children("NotificationCC")) {
 389                 if (!i->content().empty()) {
 390                         _notification_cc.push_back (i->content ());
 391                 }
 392         }
 393         _notification_bcc = f.optional_string_child("NotificationBCC").get_value_or("");
 394         if (f.optional_string_child("NotificationEmail")) {
 395                 _notification_email = f.string_child("NotificationEmail");
 396         }
 397
 398         _check_for_updates = f.optional_bool_child("CheckForUpdates").get_value_or (false);
 399         _check_for_test_updates = f.optional_bool_child("CheckForTestUpdates").get_value_or (false);
 400
 401         _maximum_j2k_bandwidth = f.optional_number_child<int> ("MaximumJ2KBandwidth").get_value_or (250000000);
 402         _allow_any_dcp_frame_rate = f.optional_bool_child ("AllowAnyDCPFrameRate").get_value_or (false);
 403         _allow_any_container = f.optional_bool_child ("AllowAnyContainer").get_value_or (false);
 404         _allow_96khz_audio = f.optional_bool_child("Allow96kHzAudio").get_value_or(false);
 405         _show_experimental_audio_processors = f.optional_bool_child ("ShowExperimentalAudioProcessors").get_value_or (false);
 406
 407         _log_types = f.optional_number_child<int> ("LogTypes").get_value_or (LogEntry::TYPE_GENERAL | LogEntry::TYPE_WARNING | LogEntry::TYPE_ERROR);
 408         _analyse_ebur128 = f.optional_bool_child("AnalyseEBUR128").get_value_or (true);
 409         _automatic_audio_analysis = f.optional_bool_child ("AutomaticAudioAnalysis").get_value_or (false);
 410 #ifdef DCPOMATIC_WINDOWS
 411         _win32_console = f.optional_bool_child ("Win32Console").get_value_or (false);
 412 #endif
 413
 414         for (auto i: f.node_children("History")) {
 415                 _history.push_back (i->content ());
 416         }
 417
 418         for (auto i: f.node_children("PlayerHistory")) {
 419                 _player_history.push_back (i->content ());
 420         }
 421
 422         auto signer = f.optional_node_child ("Signer");
 423         if (signer) {
 424                 auto c = make_shared<dcp::CertificateChain>();
 425                 /* Read the signing certificates and private key in from the config file */
 426                 for (auto i: signer->node_children ("Certificate")) {
 427                         c->add (dcp::Certificate (i->content ()));
 428                 }
 429                 c->set_key (signer->string_child ("PrivateKey"));
 430                 _signer_chain = c;
 431         } else {
 432                 /* Make a new set of signing certificates and key */
 433                 _signer_chain = create_certificate_chain ();
 434         }
 435
 436         auto decryption = f.optional_node_child ("Decryption");
 437         if (decryption) {
 438                 auto c = make_shared<dcp::CertificateChain>();
 439                 for (auto i: decryption->node_children ("Certificate")) {
 440                         c->add (dcp::Certificate (i->content ()));
 441                 }
 442                 c->set_key (decryption->string_child ("PrivateKey"));
 443                 _decryption_chain = c;
 444         } else {
 445                 _decryption_chain = create_certificate_chain ();
 446         }
 447
 448         /* These must be done before we call Bad as that might set one
 449            of the nags.
 450         */
 451         for (auto i: f.node_children("Nagged")) {
 452                 auto const id = i->number_attribute<int>("Id");
 453                 if (id >= 0 && id < NAG_COUNT) {
 454                         _nagged[id] = raw_convert<int>(i->content());
 455                 }
 456         }
 457
 458         optional<BadReason> bad;
 459
 460         for (auto const& i: _signer_chain->unordered()) {
 461                 if (i.has_utf8_strings()) {
 462                         bad = BAD_SIGNER_UTF8_STRINGS;
 463                 }
 464         }
 465
 466         if (!_signer_chain->chain_valid() || !_signer_chain->private_key_valid()) {
 467                 bad = BAD_SIGNER_INCONSISTENT;
 468         }
 469
 470         if (!_decryption_chain->chain_valid() || !_decryption_chain->private_key_valid()) {
 471                 bad = BAD_DECRYPTION_INCONSISTENT;
 472         }
 473
 474         if (bad) {
 475                 auto const remake = Bad(*bad);
 476                 if (remake && *remake) {
 477                         switch (*bad) {
 478                         case BAD_SIGNER_UTF8_STRINGS:
 479                         case BAD_SIGNER_INCONSISTENT:
 480                                 _signer_chain = create_certificate_chain ();
 481                                 break;
 482                         case BAD_DECRYPTION_INCONSISTENT:
 483                                 _decryption_chain = create_certificate_chain ();
 484                                 break;
 485                         }
 486                 }
 487         }
 488
 489         if (f.optional_node_child("DKDMGroup")) {
 490                 /* New-style: all DKDMs in a group */
 491                 _dkdms = dynamic_pointer_cast<DKDMGroup> (DKDMBase::read (f.node_child("DKDMGroup")));
 492         } else {
 493                 /* Old-style: one or more DKDM nodes */
 494                 _dkdms = make_shared<DKDMGroup>("root");
 495                 for (auto i: f.node_children("DKDM")) {
 496                         _dkdms->add (DKDMBase::read (i));
 497                 }
 498         }
 499         _cinemas_file = f.optional_string_child("CinemasFile").get_value_or(read_path("cinemas.xml").string());
 500         _dkdm_recipients_file = f.optional_string_child("DKDMRecipientsFile").get_value_or(read_path("dkdm_recipients.xml").string());
 501         _show_hints_before_make_dcp = f.optional_bool_child("ShowHintsBeforeMakeDCP").get_value_or (true);
 502         _confirm_kdm_email = f.optional_bool_child("ConfirmKDMEmail").get_value_or (true);
 503         _kdm_container_name_format = dcp::NameFormat (f.optional_string_child("KDMContainerNameFormat").get_value_or ("KDM %f %c"));
 504         _kdm_filename_format = dcp::NameFormat (f.optional_string_child("KDMFilenameFormat").get_value_or ("KDM %f %c %s"));
 505         _dkdm_filename_format = dcp::NameFormat (f.optional_string_child("DKDMFilenameFormat").get_value_or("DKDM %f %c %s"));
 506         _dcp_metadata_filename_format = dcp::NameFormat (f.optional_string_child("DCPMetadataFilenameFormat").get_value_or ("%t"));
 507         _dcp_asset_filename_format = dcp::NameFormat (f.optional_string_child("DCPAssetFilenameFormat").get_value_or ("%t"));
 508         _jump_to_selected = f.optional_bool_child("JumpToSelected").get_value_or (true);
 509         /* The variable was renamed but not the XML tag */
 510         _sound = f.optional_bool_child("PreviewSound").get_value_or (true);
 511         _sound_output = f.optional_string_child("PreviewSoundOutput");
 512         if (f.optional_string_child("CoverSheet")) {
 513                 _cover_sheet = f.optional_string_child("CoverSheet").get();
 514         }
 515         _last_player_load_directory = f.optional_string_child("LastPlayerLoadDirectory");
 516         if (f.optional_string_child("LastKDMWriteType")) {
 517                 if (f.optional_string_child("LastKDMWriteType").get() == "flat") {
 518                         _last_kdm_write_type = KDM_WRITE_FLAT;
 519                 } else if (f.optional_string_child("LastKDMWriteType").get() == "folder") {
 520                         _last_kdm_write_type = KDM_WRITE_FOLDER;
 521                 } else if (f.optional_string_child("LastKDMWriteType").get() == "zip") {
 522                         _last_kdm_write_type = KDM_WRITE_ZIP;
 523                 }
 524         }
 525         if (f.optional_string_child("LastDKDMWriteType")) {
 526                 if (f.optional_string_child("LastDKDMWriteType").get() == "internal") {
 527                         _last_dkdm_write_type = DKDM_WRITE_INTERNAL;
 528                 } else if (f.optional_string_child("LastDKDMWriteType").get() == "file") {
 529                         _last_dkdm_write_type = DKDM_WRITE_FILE;
 530                 }
 531         }
 532         _frames_in_memory_multiplier = f.optional_number_child<int>("FramesInMemoryMultiplier").get_value_or(3);
 533         _decode_reduction = f.optional_number_child<int>("DecodeReduction");
 534         _default_notify = f.optional_bool_child("DefaultNotify").get_value_or(false);
 535
 536         for (auto i: f.node_children("Notification")) {
 537                 int const id = i->number_attribute<int>("Id");
 538                 if (id >= 0 && id < NOTIFICATION_COUNT) {
 539                         _notification[id] = raw_convert<int>(i->content());
 540                 }
 541         }
 542
 543         _barco_username = f.optional_string_child("BarcoUsername");
 544         _barco_password = f.optional_string_child("BarcoPassword");
 545         _christie_username = f.optional_string_child("ChristieUsername");
 546         _christie_password = f.optional_string_child("ChristiePassword");
 547         _gdc_username = f.optional_string_child("GDCUsername");
 548         _gdc_password = f.optional_string_child("GDCPassword");
 549
 550         auto pm = f.optional_string_child("PlayerMode");
 551         if (pm && *pm == "window") {
 552                 _player_mode = PLAYER_MODE_WINDOW;
 553         } else if (pm && *pm == "full") {
 554                 _player_mode = PLAYER_MODE_FULL;
 555         } else if (pm && *pm == "dual") {
 556                 _player_mode = PLAYER_MODE_DUAL;
 557         }
 558
 559         _image_display = f.optional_number_child<int>("ImageDisplay").get_value_or(0);
 560         auto vc = f.optional_string_child("VideoViewType");
 561         if (vc && *vc == "opengl") {
 562                 _video_view_type = VIDEO_VIEW_OPENGL;
 563         } else if (vc && *vc == "simple") {
 564                 _video_view_type = VIDEO_VIEW_SIMPLE;
 565         }
 566         _respect_kdm_validity_periods = f.optional_bool_child("RespectKDMValidityPeriods").get_value_or(true);
 567         _player_debug_log_file = f.optional_string_child("PlayerDebugLogFile");
 568         _player_content_directory = f.optional_string_child("PlayerContentDirectory");
 569         _player_playlist_directory = f.optional_string_child("PlayerPlaylistDirectory");
 570         _player_kdm_directory = f.optional_string_child("PlayerKDMDirectory");
 571
 572         if (f.optional_node_child("AudioMapping")) {
 573                 _audio_mapping = AudioMapping (f.node_child("AudioMapping"), Film::current_state_version);
 574         }
 575
 576         for (auto i: f.node_children("CustomLanguage")) {
 577                 try {
 578                         /* This will fail if it's called before dcp::init() as it won't recognise the
 579                          * tag.  That's OK because the Config will be reloaded again later.
 580                          */
 581                         _custom_languages.push_back (dcp::LanguageTag(i->content()));
 582                 } catch (std::runtime_error& e) {}
 583         }
 584
 585         _add_files_path = f.optional_string_child("AddFilesPath");
 586
 587         if (boost::filesystem::exists (_cinemas_file)) {
 588                 cxml::Document f ("Cinemas");
 589                 f.read_file (_cinemas_file);
 590                 read_cinemas (f);
 591         }
 592
 593         if (boost::filesystem::exists (_dkdm_recipients_file)) {
 594                 cxml::Document f ("DKDMRecipients");
 595                 f.read_file (_dkdm_recipients_file);
 596                 read_dkdm_recipients (f);
 597         }
 598 }
 599 catch (...) {
 600         if (have_existing ("config.xml")) {
 601                 backup ();
 602                 /* We have a config file but it didn't load */
 603                 FailedToLoad ();
 604         }
 605         set_defaults ();
 606         /* Make a new set of signing certificates and key */
 607         _signer_chain = create_certificate_chain ();
 608         /* And similar for decryption of KDMs */
 609         _decryption_chain = create_certificate_chain ();
 610         write ();
 611 }
 612
 613 /** @return Singleton instance */
 614 Config *
 615 Config::instance ()
 616 {
 617         if (_instance == 0) {
 618                 _instance = new Config;
 619                 _instance->read ();
 620         }
 621
 622         return _instance;
 623 }
 624
 625 /** Write our configuration to disk */
 626 void
 627 Config::write () const
 628 {
 629         write_config ();
 630         write_cinemas ();
 631         write_dkdm_recipients ();
 632 }
 633
 634 void
 635 Config::write_config () const
 636 {
 637         xmlpp::Document doc;
 638         auto root = doc.create_root_node ("Config");
 639
 640         /* [XML] Version The version number of the configuration file format. */
 641         root->add_child("Version")->add_child_text (raw_convert<string>(_current_version));
 642         /* [XML] MasterEncodingThreads Number of encoding threads to use when running as master. */
 643         root->add_child("MasterEncodingThreads")->add_child_text (raw_convert<string> (_master_encoding_threads));
 644         /* [XML] ServerEncodingThreads Number of encoding threads to use when running as server. */
 645         root->add_child("ServerEncodingThreads")->add_child_text (raw_convert<string> (_server_encoding_threads));
 646         if (_default_directory) {
 647                 /* [XML:opt] DefaultDirectory Default directory when creating a new film in the GUI. */
 648                 root->add_child("DefaultDirectory")->add_child_text (_default_directory->string ());
 649         }
 650         /* [XML] ServerPortBase Port number to use for frame encoding requests.  <code>ServerPortBase</code> + 1 and
 651            <code>ServerPortBase</code> + 2 are used for querying servers.  <code>ServerPortBase</code> + 3 is used
 652            by the batch converter to listen for job requests.
 653         */
 654         root->add_child("ServerPortBase")->add_child_text (raw_convert<string> (_server_port_base));
 655         /* [XML] UseAnyServers 1 to broadcast to look for encoding servers to use, 0 to use only those configured. */
 656         root->add_child("UseAnyServers")->add_child_text (_use_any_servers ? "1" : "0");
 657
 658         for (auto i: _servers) {
 659                 /* [XML:opt] Server IP address or hostname of an encoding server to use; you can use as many of these tags
 660                    as you like.
 661                 */
 662                 root->add_child("Server")->add_child_text (i);
 663         }
 664
 665         /* [XML] OnlyServersEncode 1 to set the master to do decoding of source content no JPEG2000 encoding; all encoding
 666            is done by the encoding servers.  0 to set the master to do some encoding as well as coordinating the job.
 667         */
 668         root->add_child("OnlyServersEncode")->add_child_text (_only_servers_encode ? "1" : "0");
 669         /* [XML] TMSProtocol Protocol to use to copy files to a TMS; 0 to use SCP, 1 for FTP. */
 670         root->add_child("TMSProtocol")->add_child_text (raw_convert<string> (static_cast<int> (_tms_protocol)));
 671         /* [XML] TMSIP IP address of TMS. */
 672         root->add_child("TMSIP")->add_child_text (_tms_ip);
 673         /* [XML] TMSPath Path on the TMS to copy files to. */
 674         root->add_child("TMSPath")->add_child_text (_tms_path);
 675         /* [XML] TMSUser Username to log into the TMS with. */
 676         root->add_child("TMSUser")->add_child_text (_tms_user);
 677         /* [XML] TMSPassword Password to log into the TMS with. */
 678         root->add_child("TMSPassword")->add_child_text (_tms_password);
 679         if (_language) {
 680                 /* [XML:opt] Language Language to use in the GUI e.g. <code>fr_FR</code>. */
 681                 root->add_child("Language")->add_child_text (_language.get());
 682         }
 683         if (_default_container) {
 684                 /* [XML:opt] DefaultContainer ID of default container
 685                    to use when creating new films (<code>185</code>,<code>239</code> or
 686                    <code>190</code>).
 687                 */
 688                 root->add_child("DefaultContainer")->add_child_text (_default_container->id ());
 689         }
 690         if (_default_dcp_content_type) {
 691                 /* [XML:opt] DefaultDCPContentType Default content type ot use when creating new films (<code>FTR</code>, <code>SHR</code>,
 692                    <code>TLR</code>, <code>TST</code>, <code>XSN</code>, <code>RTG</code>, <code>TSR</code>, <code>POL</code>,
 693                    <code>PSA</code> or <code>ADV</code>). */
 694                 root->add_child("DefaultDCPContentType")->add_child_text (_default_dcp_content_type->isdcf_name ());
 695         }
 696         /* [XML] DefaultDCPAudioChannels Default number of audio channels to use when creating new films. */
 697         root->add_child("DefaultDCPAudioChannels")->add_child_text (raw_convert<string> (_default_dcp_audio_channels));
 698         /* [XML] DCPIssuer Issuer text to write into CPL files. */
 699         root->add_child("DCPIssuer")->add_child_text (_dcp_issuer);
 700         /* [XML] DCPCreator Creator text to write into CPL files. */
 701         root->add_child("DCPCreator")->add_child_text (_dcp_creator);
 702         /* [XML] Company name to write into MXF files. */
 703         root->add_child("DCPCompanyName")->add_child_text (_dcp_company_name);
 704         /* [XML] Product name to write into MXF files. */
 705         root->add_child("DCPProductName")->add_child_text (_dcp_product_name);
 706         /* [XML] Product version to write into MXF files. */
 707         root->add_child("DCPProductVersion")->add_child_text (_dcp_product_version);
 708         /* [XML] Comment to write into JPEG2000 data. */
 709         root->add_child("DCPJ2KComment")->add_child_text (_dcp_j2k_comment);
 710         /* [XML] UploadAfterMakeDCP 1 to upload to a TMS after making a DCP, 0 for no upload. */
 711         root->add_child("UploadAfterMakeDCP")->add_child_text (_upload_after_make_dcp ? "1" : "0");
 712
 713         /* [XML] DefaultStillLength Default length (in seconds) for still images in new films. */
 714         root->add_child("DefaultStillLength")->add_child_text (raw_convert<string> (_default_still_length));
 715         /* [XML] DefaultJ2KBandwidth Default bitrate (in bits per second) for JPEG2000 data in new films. */
 716         root->add_child("DefaultJ2KBandwidth")->add_child_text (raw_convert<string> (_default_j2k_bandwidth));
 717         /* [XML] DefaultAudioDelay Default delay to apply to audio (positive moves audio later) in milliseconds. */
 718         root->add_child("DefaultAudioDelay")->add_child_text (raw_convert<string> (_default_audio_delay));
 719         /* [XML] DefaultInterop 1 to default new films to Interop, 0 for SMPTE. */
 720         root->add_child("DefaultInterop")->add_child_text (_default_interop ? "1" : "0");
 721         for (auto const& i: _default_metadata) {
 722                 auto c = root->add_child("DefaultMetadata");
 723                 c->set_attribute("key", i.first);
 724                 c->add_child_text(i.second);
 725         }
 726         if (_default_kdm_directory) {
 727                 /* [XML:opt] DefaultKDMDirectory Default directory to write KDMs to. */
 728                 root->add_child("DefaultKDMDirectory")->add_child_text (_default_kdm_directory->string ());
 729         }
 730         /* [XML] MailServer Hostname of SMTP server to use. */
 731         root->add_child("MailServer")->add_child_text (_mail_server);
 732         /* [XML] MailPort Port number to use on SMTP server. */
 733         root->add_child("MailPort")->add_child_text (raw_convert<string> (_mail_port));
 734         /* [XML] MailProtocol Protocol to use on SMTP server (Auto, Plain, STARTTLS or SSL) */
 735         switch (_mail_protocol) {
 736         case EmailProtocol::AUTO:
 737                 root->add_child("MailProtocol")->add_child_text("Auto");
 738                 break;
 739         case EmailProtocol::PLAIN:
 740                 root->add_child("MailProtocol")->add_child_text("Plain");
 741                 break;
 742         case EmailProtocol::STARTTLS:
 743                 root->add_child("MailProtocol")->add_child_text("STARTTLS");
 744                 break;
 745         case EmailProtocol::SSL:
 746                 root->add_child("MailProtocol")->add_child_text("SSL");
 747                 break;
 748         }
 749         /* [XML] MailUser Username to use on SMTP server. */
 750         root->add_child("MailUser")->add_child_text (_mail_user);
 751         /* [XML] MailPassword Password to use on SMTP server. */
 752         root->add_child("MailPassword")->add_child_text (_mail_password);
 753
 754         /* [XML] KDMSubject Subject to use for KDM emails. */
 755         root->add_child("KDMSubject")->add_child_text (_kdm_subject);
 756         /* [XML] KDMFrom From address to use for KDM emails. */
 757         root->add_child("KDMFrom")->add_child_text (_kdm_from);
 758         for (auto i: _kdm_cc) {
 759                 /* [XML] KDMCC CC address to use for KDM emails; you can use as many of these tags as you like. */
 760                 root->add_child("KDMCC")->add_child_text (i);
 761         }
 762         /* [XML] KDMBCC BCC address to use for KDM emails. */
 763         root->add_child("KDMBCC")->add_child_text (_kdm_bcc);
 764         /* [XML] KDMEmail Text of KDM email. */
 765         root->add_child("KDMEmail")->add_child_text (_kdm_email);
 766
 767         /* [XML] NotificationSubject Subject to use for notification emails. */
 768         root->add_child("NotificationSubject")->add_child_text (_notification_subject);
 769         /* [XML] NotificationFrom From address to use for notification emails. */
 770         root->add_child("NotificationFrom")->add_child_text (_notification_from);
 771         /* [XML] NotificationFrom To address to use for notification emails. */
 772         root->add_child("NotificationTo")->add_child_text (_notification_to);
 773         for (auto i: _notification_cc) {
 774                 /* [XML] NotificationCC CC address to use for notification emails; you can use as many of these tags as you like. */
 775                 root->add_child("NotificationCC")->add_child_text (i);
 776         }
 777         /* [XML] NotificationBCC BCC address to use for notification emails. */
 778         root->add_child("NotificationBCC")->add_child_text (_notification_bcc);
 779         /* [XML] NotificationEmail Text of notification email. */
 780         root->add_child("NotificationEmail")->add_child_text (_notification_email);
 781
 782         /* [XML] CheckForUpdates 1 to check dcpomatic.com for new versions, 0 to check only on request. */
 783         root->add_child("CheckForUpdates")->add_child_text (_check_for_updates ? "1" : "0");
 784         /* [XML] CheckForUpdates 1 to check dcpomatic.com for new text versions, 0 to check only on request. */
 785         root->add_child("CheckForTestUpdates")->add_child_text (_check_for_test_updates ? "1" : "0");
 786
 787         /* [XML] MaximumJ2KBandwidth Maximum J2K bandwidth (in bits per second) that can be specified in the GUI. */
 788         root->add_child("MaximumJ2KBandwidth")->add_child_text (raw_convert<string> (_maximum_j2k_bandwidth));
 789         /* [XML] AllowAnyDCPFrameRate 1 to allow users to specify any frame rate when creating DCPs, 0 to limit the GUI to standard rates. */
 790         root->add_child("AllowAnyDCPFrameRate")->add_child_text (_allow_any_dcp_frame_rate ? "1" : "0");
 791         /* [XML] AllowAnyContainer 1 to allow users to user any container ratio for their DCP, 0 to limit the GUI to DCI Flat/Scope */
 792         root->add_child("AllowAnyContainer")->add_child_text (_allow_any_container ? "1" : "0");
 793         /* [XML] Allow96kHzAudio 1 to allow users to make DCPs with 96kHz audio, 0 to always make 48kHz DCPs */
 794         root->add_child("Allow96kHzAudio")->add_child_text(_allow_96khz_audio ? "1" : "0");
 795         /* [XML] ShowExperimentalAudioProcessors 1 to offer users the (experimental) audio upmixer processors, 0 to hide them */
 796         root->add_child("ShowExperimentalAudioProcessors")->add_child_text (_show_experimental_audio_processors ? "1" : "0");
 797         /* [XML] LogTypes Types of logging to write; a bitfield where 1 is general notes, 2 warnings, 4 errors, 8 debug information related
 798            to 3D, 16 debug information related to encoding, 32 debug information for timing purposes, 64 debug information related
 799            to sending email, 128 debug information related to the video view, 256 information about disk writing, 512 debug information
 800            related to the player, 1024 debug information related to audio analyses.
 801         */
 802         root->add_child("LogTypes")->add_child_text (raw_convert<string> (_log_types));
 803         /* [XML] AnalyseEBUR128 1 to do EBUR128 analyses when analysing audio, otherwise 0. */
 804         root->add_child("AnalyseEBUR128")->add_child_text (_analyse_ebur128 ? "1" : "0");
 805         /* [XML] AutomaticAudioAnalysis 1 to run audio analysis automatically when audio content is added to the film, otherwise 0. */
 806         root->add_child("AutomaticAudioAnalysis")->add_child_text (_automatic_audio_analysis ? "1" : "0");
 807 #ifdef DCPOMATIC_WINDOWS
 808         if (_win32_console) {
 809                 /* [XML] Win32Console 1 to open a console when running on Windows, otherwise 0.
 810                  * We only write this if it's true, which is a bit of a hack to allow unit tests to work
 811                  * more easily on Windows (without a platform-specific reference in config_write_utf8_test)
 812                  */
 813                 root->add_child("Win32Console")->add_child_text ("1");
 814         }
 815 #endif
 816
 817         /* [XML] Signer Certificate chain and private key to use when signing DCPs and KDMs.  Should contain <code>&lt;Certificate&gt;</code>
 818            tags in order and a <code>&lt;PrivateKey&gt;</code> tag all containing PEM-encoded certificates or private keys as appropriate.
 819         */
 820         auto signer = root->add_child ("Signer");
 821         DCPOMATIC_ASSERT (_signer_chain);
 822         for (auto const& i: _signer_chain->unordered()) {
 823                 signer->add_child("Certificate")->add_child_text (i.certificate (true));
 824         }
 825         signer->add_child("PrivateKey")->add_child_text (_signer_chain->key().get ());
 826
 827         /* [XML] Decryption Certificate chain and private key to use when decrypting KDMs */
 828         auto decryption = root->add_child ("Decryption");
 829         DCPOMATIC_ASSERT (_decryption_chain);
 830         for (auto const& i: _decryption_chain->unordered()) {
 831                 decryption->add_child("Certificate")->add_child_text (i.certificate (true));
 832         }
 833         decryption->add_child("PrivateKey")->add_child_text (_decryption_chain->key().get ());
 834
 835         /* [XML] History Filename of DCP to present in the <guilabel>File</guilabel> menu of the GUI; there can be more than one
 836            of these tags.
 837         */
 838         for (auto i: _history) {
 839                 root->add_child("History")->add_child_text (i.string ());
 840         }
 841
 842         /* [XML] History Filename of DCP to present in the <guilabel>File</guilabel> menu of the player; there can be more than one
 843            of these tags.
 844         */
 845         for (auto i: _player_history) {
 846                 root->add_child("PlayerHistory")->add_child_text (i.string ());
 847         }
 848
 849         /* [XML] DKDMGroup A group of DKDMs, each with a <code>Name</code> attribute, containing other <code>&lt;DKDMGroup&gt;</code>
 850            or <code>&lt;DKDM&gt;</code> tags.
 851         */
 852         /* [XML] DKDM A DKDM as XML */
 853         _dkdms->as_xml (root);
 854
 855         /* [XML] CinemasFile Filename of cinemas list file. */
 856         root->add_child("CinemasFile")->add_child_text (_cinemas_file.string());
 857         /* [XML] DKDMRecipientsFile Filename of DKDM recipients list file. */
 858         root->add_child("DKDMRecipientsFile")->add_child_text (_dkdm_recipients_file.string());
 859         /* [XML] ShowHintsBeforeMakeDCP 1 to show hints in the GUI before making a DCP, otherwise 0. */
 860         root->add_child("ShowHintsBeforeMakeDCP")->add_child_text (_show_hints_before_make_dcp ? "1" : "0");
 861         /* [XML] ConfirmKDMEmail 1 to confirm before sending KDM emails in the GUI, otherwise 0. */
 862         root->add_child("ConfirmKDMEmail")->add_child_text (_confirm_kdm_email ? "1" : "0");
 863         /* [XML] KDMFilenameFormat Format for KDM filenames. */
 864         root->add_child("KDMFilenameFormat")->add_child_text (_kdm_filename_format.specification ());
 865         /* [XML] KDMFilenameFormat Format for DKDM filenames. */
 866         root->add_child("DKDMFilenameFormat")->add_child_text(_dkdm_filename_format.specification());
 867         /* [XML] KDMContainerNameFormat Format for KDM containers (directories or ZIP files). */
 868         root->add_child("KDMContainerNameFormat")->add_child_text (_kdm_container_name_format.specification ());
 869         /* [XML] DCPMetadataFilenameFormat Format for DCP metadata filenames. */
 870         root->add_child("DCPMetadataFilenameFormat")->add_child_text (_dcp_metadata_filename_format.specification ());
 871         /* [XML] DCPAssetFilenameFormat Format for DCP asset filenames. */
 872         root->add_child("DCPAssetFilenameFormat")->add_child_text (_dcp_asset_filename_format.specification ());
 873         /* [XML] JumpToSelected 1 to make the GUI jump to the start of content when it is selected, otherwise 0. */
 874         root->add_child("JumpToSelected")->add_child_text (_jump_to_selected ? "1" : "0");
 875         /* [XML] Nagged 1 if a particular nag screen has been shown and should not be shown again, otherwise 0. */
 876         for (int i = 0; i < NAG_COUNT; ++i) {
 877                 xmlpp::Element* e = root->add_child ("Nagged");
 878                 e->set_attribute ("Id", raw_convert<string>(i));
 879                 e->add_child_text (_nagged[i] ? "1" : "0");
 880         }
 881         /* [XML] PreviewSound 1 to use sound in the GUI preview and player, otherwise 0. */
 882         root->add_child("PreviewSound")->add_child_text (_sound ? "1" : "0");
 883         if (_sound_output) {
 884                 /* [XML:opt] PreviewSoundOutput Name of the audio output to use. */
 885                 root->add_child("PreviewSoundOutput")->add_child_text (_sound_output.get());
 886         }
 887         /* [XML] CoverSheet Text of the cover sheet to write when making DCPs. */
 888         root->add_child("CoverSheet")->add_child_text (_cover_sheet);
 889         if (_last_player_load_directory) {
 890                 root->add_child("LastPlayerLoadDirectory")->add_child_text(_last_player_load_directory->string());
 891         }
 892         /* [XML] LastKDMWriteType Last type of KDM-write: <code>flat</code> for a flat file, <code>folder</code> for a folder or <code>zip</code> for a ZIP file. */
 893         if (_last_kdm_write_type) {
 894                 switch (_last_kdm_write_type.get()) {
 895                 case KDM_WRITE_FLAT:
 896                         root->add_child("LastKDMWriteType")->add_child_text("flat");
 897                         break;
 898                 case KDM_WRITE_FOLDER:
 899                         root->add_child("LastKDMWriteType")->add_child_text("folder");
 900                         break;
 901                 case KDM_WRITE_ZIP:
 902                         root->add_child("LastKDMWriteType")->add_child_text("zip");
 903                         break;
 904                 }
 905         }
 906         /* [XML] LastDKDMWriteType Last type of DKDM-write: <code>file</code> for a file, <code>internal</code> to add to DCP-o-matic's list. */
 907         if (_last_dkdm_write_type) {
 908                 switch (_last_dkdm_write_type.get()) {
 909                 case DKDM_WRITE_INTERNAL:
 910                         root->add_child("LastDKDMWriteType")->add_child_text("internal");
 911                         break;
 912                 case DKDM_WRITE_FILE:
 913                         root->add_child("LastDKDMWriteType")->add_child_text("file");
 914                         break;
 915                 }
 916         }
 917         /* [XML] FramesInMemoryMultiplier value to multiply the encoding threads count by to get the maximum number of
 918            frames to be held in memory at once.
 919         */
 920         root->add_child("FramesInMemoryMultiplier")->add_child_text(raw_convert<string>(_frames_in_memory_multiplier));
 921
 922         /* [XML] DecodeReduction power of 2 to reduce DCP images by before decoding in the player. */
 923         if (_decode_reduction) {
 924                 root->add_child("DecodeReduction")->add_child_text(raw_convert<string>(_decode_reduction.get()));
 925         }
 926
 927         /* [XML] DefaultNotify 1 to default jobs to notify when complete, otherwise 0. */
 928         root->add_child("DefaultNotify")->add_child_text(_default_notify ? "1" : "0");
 929
 930         /* [XML] Notification 1 if a notification type is enabled, otherwise 0. */
 931         for (int i = 0; i < NOTIFICATION_COUNT; ++i) {
 932                 xmlpp::Element* e = root->add_child ("Notification");
 933                 e->set_attribute ("Id", raw_convert<string>(i));
 934                 e->add_child_text (_notification[i] ? "1" : "0");
 935         }
 936
 937         if (_barco_username) {
 938                 /* [XML] BarcoUsername Username for logging into Barco's servers when downloading server certificates. */
 939                 root->add_child("BarcoUsername")->add_child_text(*_barco_username);
 940         }
 941         if (_barco_password) {
 942                 /* [XML] BarcoPassword Password for logging into Barco's servers when downloading server certificates. */
 943                 root->add_child("BarcoPassword")->add_child_text(*_barco_password);
 944         }
 945
 946         if (_christie_username) {
 947                 /* [XML] ChristieUsername Username for logging into Christie's servers when downloading server certificates. */
 948                 root->add_child("ChristieUsername")->add_child_text(*_christie_username);
 949         }
 950         if (_christie_password) {
 951                 /* [XML] ChristiePassword Password for logging into Christie's servers when downloading server certificates. */
 952                 root->add_child("ChristiePassword")->add_child_text(*_christie_password);
 953         }
 954
 955         if (_gdc_username) {
 956                 /* [XML] GDCUsername Username for logging into GDC's servers when downloading server certificates. */
 957                 root->add_child("GDCUsername")->add_child_text(*_gdc_username);
 958         }
 959         if (_gdc_password) {
 960                 /* [XML] GDCPassword Password for logging into GDC's servers when downloading server certificates. */
 961                 root->add_child("GDCPassword")->add_child_text(*_gdc_password);
 962         }
 963
 964         /* [XML] PlayerMode <code>window</code> for a single window, <code>full</code> for full-screen and <code>dual</code> for full screen playback
 965            with controls on another monitor.
 966         */
 967         switch (_player_mode) {
 968         case PLAYER_MODE_WINDOW:
 969                 root->add_child("PlayerMode")->add_child_text("window");
 970                 break;
 971         case PLAYER_MODE_FULL:
 972                 root->add_child("PlayerMode")->add_child_text("full");
 973                 break;
 974         case PLAYER_MODE_DUAL:
 975                 root->add_child("PlayerMode")->add_child_text("dual");
 976                 break;
 977         }
 978
 979         /* [XML] ImageDisplay Screen number to put image on in dual-screen player mode. */
 980         root->add_child("ImageDisplay")->add_child_text(raw_convert<string>(_image_display));
 981         switch (_video_view_type) {
 982         case VIDEO_VIEW_SIMPLE:
 983                 root->add_child("VideoViewType")->add_child_text("simple");
 984                 break;
 985         case VIDEO_VIEW_OPENGL:
 986                 root->add_child("VideoViewType")->add_child_text("opengl");
 987                 break;
 988         }
 989         /* [XML] RespectKDMValidityPeriods 1 to refuse to use KDMs that are out of date, 0 to ignore KDM dates. */
 990         root->add_child("RespectKDMValidityPeriods")->add_child_text(_respect_kdm_validity_periods ? "1" : "0");
 991         if (_player_debug_log_file) {
 992                 /* [XML] PlayerLogFile Filename to use for player debug logs. */
 993                 root->add_child("PlayerDebugLogFile")->add_child_text(_player_debug_log_file->string());
 994         }
 995         if (_player_content_directory) {
 996                 /* [XML] PlayerContentDirectory Directory to use for player content in the dual-screen mode. */
 997                 root->add_child("PlayerContentDirectory")->add_child_text(_player_content_directory->string());
 998         }
 999         if (_player_playlist_directory) {
1000                 /* [XML] PlayerPlaylistDirectory Directory to use for player playlists in the dual-screen mode. */
1001                 root->add_child("PlayerPlaylistDirectory")->add_child_text(_player_playlist_directory->string());
1002         }
1003         if (_player_kdm_directory) {
1004                 /* [XML] PlayerKDMDirectory Directory to use for player KDMs in the dual-screen mode. */
1005                 root->add_child("PlayerKDMDirectory")->add_child_text(_player_kdm_directory->string());
1006         }
1007         if (_audio_mapping) {
1008                 _audio_mapping->as_xml (root->add_child("AudioMapping"));
1009         }
1010         for (auto const& i: _custom_languages) {
1011                 root->add_child("CustomLanguage")->add_child_text(i.to_string());
1012         }
1013         if (_add_files_path) {
1014                 /* [XML] AddFilesPath The default path that will be offered in the picker when adding files to a film. */
1015                 root->add_child("AddFilesPath")->add_child_text(_add_files_path->string());
1016         }
1017
1018         auto target = config_write_file();
1019
1020         try {
1021                 auto const s = doc.write_to_string_formatted ();
1022                 boost::filesystem::path tmp (string(target.string()).append(".tmp"));
1023                 auto f = fopen_boost (tmp, "w");
1024                 if (!f) {
1025                         throw FileError (_("Could not open file for writing"), tmp);
1026                 }
1027                 checked_fwrite (s.c_str(), s.bytes(), f, tmp);
1028                 fclose (f);
1029                 boost::filesystem::remove (target);
1030                 boost::filesystem::rename (tmp, target);
1031         } catch (xmlpp::exception& e) {
1032                 string s = e.what ();
1033                 trim (s);
1034                 throw FileError (s, target);
1035         }
1036 }
1037
1038
1039 template <class T>
1040 void
1041 write_file (string root_node, string node, string version, list<shared_ptr<T>> things, boost::filesystem::path file)
1042 {
1043         xmlpp::Document doc;
1044         auto root = doc.create_root_node (root_node);
1045         root->add_child("Version")->add_child_text(version);
1046
1047         for (auto i: things) {
1048                 i->as_xml (root->add_child(node));
1049         }
1050
1051         try {
1052                 doc.write_to_file_formatted (file.string() + ".tmp");
1053                 boost::filesystem::remove (file);
1054                 boost::filesystem::rename (file.string() + ".tmp", file);
1055         } catch (xmlpp::exception& e) {
1056                 string s = e.what ();
1057                 trim (s);
1058                 throw FileError (s, file);
1059         }
1060 }
1061
1062
1063 void
1064 Config::write_cinemas () const
1065 {
1066         write_file ("Cinemas", "Cinema", "1", _cinemas, _cinemas_file);
1067 }
1068
1069
1070 void
1071 Config::write_dkdm_recipients () const
1072 {
1073         write_file ("DKDMRecipients", "DKDMRecipient", "1", _dkdm_recipients, _dkdm_recipients_file);
1074 }
1075
1076
1077 boost::filesystem::path
1078 Config::default_directory_or (boost::filesystem::path a) const
1079 {
1080         return directory_or (_default_directory, a);
1081 }
1082
1083 boost::filesystem::path
1084 Config::default_kdm_directory_or (boost::filesystem::path a) const
1085 {
1086         return directory_or (_default_kdm_directory, a);
1087 }
1088
1089 boost::filesystem::path
1090 Config::directory_or (optional<boost::filesystem::path> dir, boost::filesystem::path a) const
1091 {
1092         if (!dir) {
1093                 return a;
1094         }
1095
1096         boost::system::error_code ec;
1097         auto const e = boost::filesystem::exists (*dir, ec);
1098         if (ec || !e) {
1099                 return a;
1100         }
1101
1102         return *dir;
1103 }
1104
1105 void
1106 Config::drop ()
1107 {
1108         delete _instance;
1109         _instance = 0;
1110 }
1111
1112 void
1113 Config::changed (Property what)
1114 {
1115         Changed (what);
1116 }
1117
1118 void
1119 Config::set_kdm_email_to_default ()
1120 {
1121         _kdm_subject = _("KDM delivery: $CPL_NAME");
1122
1123         _kdm_email = _(
1124                 "Dear Projectionist\n\n"
1125                 "Please find attached KDMs for $CPL_NAME.\n\n"
1126                 "Cinema: $CINEMA_NAME\n"
1127                 "Screen(s): $SCREENS\n\n"
1128                 "The KDMs are valid from $START_TIME until $END_TIME.\n\n"
1129                 "Best regards,\nDCP-o-matic"
1130                 );
1131 }
1132
1133 void
1134 Config::set_notification_email_to_default ()
1135 {
1136         _notification_subject = _("DCP-o-matic notification");
1137
1138         _notification_email = _(
1139                 "$JOB_NAME: $JOB_STATUS"
1140                 );
1141 }
1142
1143 void
1144 Config::reset_kdm_email ()
1145 {
1146         set_kdm_email_to_default ();
1147         changed ();
1148 }
1149
1150 void
1151 Config::reset_notification_email ()
1152 {
1153         set_notification_email_to_default ();
1154         changed ();
1155 }
1156
1157 void
1158 Config::set_cover_sheet_to_default ()
1159 {
1160         _cover_sheet = _(
1161                 "$CPL_NAME\n\n"
1162                 "CPL Filename: $CPL_FILENAME\n"
1163                 "Type: $TYPE\n"
1164                 "Format: $CONTAINER\n"
1165                 "Audio: $AUDIO\n"
1166                 "Audio Language: $AUDIO_LANGUAGE\n"
1167                 "Subtitle Language: $SUBTITLE_LANGUAGE\n"
1168                 "Length: $LENGTH\n"
1169                 "Size: $SIZE\n"
1170                 );
1171 }
1172
1173 void
1174 Config::add_to_history (boost::filesystem::path p)
1175 {
1176         add_to_history_internal (_history, p);
1177 }
1178
1179 /** Remove non-existant items from the history */
1180 void
1181 Config::clean_history ()
1182 {
1183         clean_history_internal (_history);
1184 }
1185
1186 void
1187 Config::add_to_player_history (boost::filesystem::path p)
1188 {
1189         add_to_history_internal (_player_history, p);
1190 }
1191
1192 /** Remove non-existant items from the player history */
1193 void
1194 Config::clean_player_history ()
1195 {
1196         clean_history_internal (_player_history);
1197 }
1198
1199 void
1200 Config::add_to_history_internal (vector<boost::filesystem::path>& h, boost::filesystem::path p)
1201 {
1202         /* Remove existing instances of this path in the history */
1203         h.erase (remove (h.begin(), h.end(), p), h.end ());
1204
1205         h.insert (h.begin (), p);
1206         if (h.size() > HISTORY_SIZE) {
1207                 h.pop_back ();
1208         }
1209
1210         changed (HISTORY);
1211 }
1212
1213 void
1214 Config::clean_history_internal (vector<boost::filesystem::path>& h)
1215 {
1216         auto old = h;
1217         h.clear ();
1218         for (auto i: old) {
1219                 try {
1220                         if (boost::filesystem::is_directory(i)) {
1221                                 h.push_back (i);
1222                         }
1223                 } catch (...) {
1224                         /* We couldn't find out if it's a directory for some reason; just ignore it */
1225                 }
1226         }
1227 }
1228
1229
1230 bool
1231 Config::have_existing (string file)
1232 {
1233         return boost::filesystem::exists (read_path(file));
1234 }
1235
1236
1237 void
1238 Config::read_cinemas (cxml::Document const & f)
1239 {
1240         _cinemas.clear ();
1241         for (auto i: f.node_children("Cinema")) {
1242                 /* Slightly grotty two-part construction of Cinema here so that we can use
1243                    shared_from_this.
1244                 */
1245                 auto cinema = make_shared<Cinema>(i);
1246                 cinema->read_screens (i);
1247                 _cinemas.push_back (cinema);
1248         }
1249 }
1250
1251 void
1252 Config::set_cinemas_file (boost::filesystem::path file)
1253 {
1254         if (file == _cinemas_file) {
1255                 return;
1256         }
1257
1258         _cinemas_file = file;
1259
1260         if (boost::filesystem::exists (_cinemas_file)) {
1261                 /* Existing file; read it in */
1262                 cxml::Document f ("Cinemas");
1263                 f.read_file (_cinemas_file);
1264                 read_cinemas (f);
1265         }
1266
1267         changed (OTHER);
1268 }
1269
1270
1271 void
1272 Config::read_dkdm_recipients (cxml::Document const & f)
1273 {
1274         _dkdm_recipients.clear ();
1275         for (auto i: f.node_children("DKDMRecipient")) {
1276                 _dkdm_recipients.push_back (make_shared<DKDMRecipient>(i));
1277         }
1278 }
1279
1280
1281 void
1282 Config::save_template (shared_ptr<const Film> film, string name) const
1283 {
1284         film->write_template (template_write_path(name));
1285 }
1286
1287
1288 list<string>
1289 Config::templates () const
1290 {
1291         if (!boost::filesystem::exists(read_path("templates"))) {
1292                 return {};
1293         }
1294
1295         list<string> n;
1296         for (auto const& i: boost::filesystem::directory_iterator(read_path("templates"))) {
1297                 n.push_back (i.path().filename().string());
1298         }
1299         return n;
1300 }
1301
1302 bool
1303 Config::existing_template (string name) const
1304 {
1305         return boost::filesystem::exists (template_read_path(name));
1306 }
1307
1308
1309 boost::filesystem::path
1310 Config::template_read_path (string name) const
1311 {
1312         return read_path("templates") / tidy_for_filename (name);
1313 }
1314
1315
1316 boost::filesystem::path
1317 Config::template_write_path (string name) const
1318 {
1319         return write_path("templates") / tidy_for_filename (name);
1320 }
1321
1322
1323 void
1324 Config::rename_template (string old_name, string new_name) const
1325 {
1326         boost::filesystem::rename (template_read_path(old_name), template_write_path(new_name));
1327 }
1328
1329 void
1330 Config::delete_template (string name) const
1331 {
1332         boost::filesystem::remove (template_write_path(name));
1333 }
1334
1335 /** @return Path to the config.xml containing the actual settings, following a link if required */
1336 boost::filesystem::path
1337 config_file (boost::filesystem::path main)
1338 {
1339         cxml::Document f ("Config");
1340         if (!boost::filesystem::exists (main)) {
1341                 /* It doesn't exist, so there can't be any links; just return it */
1342                 return main;
1343         }
1344
1345         /* See if there's a link */
1346         try {
1347                 f.read_file (main);
1348                 auto link = f.optional_string_child("Link");
1349                 if (link) {
1350                         return *link;
1351                 }
1352         } catch (xmlpp::exception& e) {
1353                 /* There as a problem reading the main configuration file,
1354                    so there can't be a link.
1355                 */
1356         }
1357
1358         return main;
1359 }
1360
1361
1362 boost::filesystem::path
1363 Config::config_read_file ()
1364 {
1365         return config_file (read_path("config.xml"));
1366 }
1367
1368
1369 boost::filesystem::path
1370 Config::config_write_file ()
1371 {
1372         return config_file (write_path("config.xml"));
1373 }
1374
1375
1376 void
1377 Config::reset_cover_sheet ()
1378 {
1379         set_cover_sheet_to_default ();
1380         changed ();
1381 }
1382
1383 void
1384 Config::link (boost::filesystem::path new_file) const
1385 {
1386         xmlpp::Document doc;
1387         doc.create_root_node("Config")->add_child("Link")->add_child_text(new_file.string());
1388         try {
1389                 doc.write_to_file_formatted(write_path("config.xml").string());
1390         } catch (xmlpp::exception& e) {
1391                 string s = e.what ();
1392                 trim (s);
1393                 throw FileError (s, write_path("config.xml"));
1394         }
1395 }
1396
1397 void
1398 Config::copy_and_link (boost::filesystem::path new_file) const
1399 {
1400         write ();
1401         boost::filesystem::copy_file (config_read_file(), new_file, boost::filesystem::copy_option::overwrite_if_exists);
1402         link (new_file);
1403 }
1404
1405 bool
1406 Config::have_write_permission () const
1407 {
1408         auto f = fopen_boost (config_write_file(), "r+");
1409         if (!f) {
1410                 return false;
1411         }
1412
1413         fclose (f);
1414         return true;
1415 }
1416
1417 /** @param  output_channels Number of output channels in use.
1418  *  @return Audio mapping for this output channel count (may be a default).
1419  */
1420 AudioMapping
1421 Config::audio_mapping (int output_channels)
1422 {
1423         if (!_audio_mapping || _audio_mapping->output_channels() != output_channels) {
1424                 /* Set up a default */
1425                 _audio_mapping = AudioMapping (MAX_DCP_AUDIO_CHANNELS, output_channels);
1426                 if (output_channels == 2) {
1427                         /* Special case for stereo output.
1428                            Map so that Lt = L(-3dB) + Ls(-3dB) + C(-6dB) + Lfe(-10dB)
1429                            Rt = R(-3dB) + Rs(-3dB) + C(-6dB) + Lfe(-10dB)
1430                         */
1431                         _audio_mapping->set (dcp::Channel::LEFT,   0, 1 / sqrt(2));  // L   -> Lt
1432                         _audio_mapping->set (dcp::Channel::RIGHT,  1, 1 / sqrt(2));  // R   -> Rt
1433                         _audio_mapping->set (dcp::Channel::CENTRE, 0, 1 / 2.0);      // C   -> Lt
1434                         _audio_mapping->set (dcp::Channel::CENTRE, 1, 1 / 2.0);      // C   -> Rt
1435                         _audio_mapping->set (dcp::Channel::LFE,    0, 1 / sqrt(10)); // Lfe -> Lt
1436                         _audio_mapping->set (dcp::Channel::LFE,    1, 1 / sqrt(10)); // Lfe -> Rt
1437                         _audio_mapping->set (dcp::Channel::LS,     0, 1 / sqrt(2));  // Ls  -> Lt
1438                         _audio_mapping->set (dcp::Channel::RS,     1, 1 / sqrt(2));  // Rs  -> Rt
1439                 } else {
1440                         /* 1:1 mapping */
1441                         for (int i = 0; i < min (MAX_DCP_AUDIO_CHANNELS, output_channels); ++i) {
1442                                 _audio_mapping->set (i, i, 1);
1443                         }
1444                 }
1445         }
1446
1447         return *_audio_mapping;
1448 }
1449
1450 void
1451 Config::set_audio_mapping (AudioMapping m)
1452 {
1453         _audio_mapping = m;
1454         changed (AUDIO_MAPPING);
1455 }
1456
1457 void
1458 Config::set_audio_mapping_to_default ()
1459 {
1460         DCPOMATIC_ASSERT (_audio_mapping);
1461         auto const ch = _audio_mapping->output_channels ();
1462         _audio_mapping = boost::none;
1463         _audio_mapping = audio_mapping (ch);
1464         changed (AUDIO_MAPPING);
1465 }
1466
1467
1468 void
1469 Config::add_custom_language (dcp::LanguageTag tag)
1470 {
1471         if (find(_custom_languages.begin(), _custom_languages.end(), tag) == _custom_languages.end()) {
1472                 _custom_languages.push_back (tag);
1473                 changed ();
1474         }
1475 }
1476