src/lib/config.cc

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