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