X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fconfig.h;h=21463fdb5bc44500ca16827acbfc6f766ee06b7c;hp=6b1f3fb874e16cb13d858e4fa3302ed8bb256733;hb=a5be11a965c2c38442e4e069874e7e21b5b43a5c;hpb=03dd6e03f5ee261b9c1ed9328ad2762ef3b62057 diff --git a/src/lib/config.h b/src/lib/config.h index 6b1f3fb87..21463fdb5 100644 --- a/src/lib/config.h +++ b/src/lib/config.h @@ -1,19 +1,20 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2018 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ @@ -26,6 +27,8 @@ #include "isdcf_metadata.h" #include "types.h" +#include "edid.h" +#include #include #include #include @@ -37,6 +40,8 @@ class CinemaSoundProcessor; class DCPContentType; class Ratio; class Cinema; +class Film; +class DKDMGroup; /** @class Config * @brief A singleton class holding configuration. @@ -44,20 +49,41 @@ class Cinema; class Config : public boost::noncopyable { public: - /** @return number of threads to use for J2K encoding on the local machine */ - int num_local_encoding_threads () const { - return _num_local_encoding_threads; + /** @return number of threads which a master DoM should use for J2K encoding on the local machine */ + int master_encoding_threads () const { + return _master_encoding_threads; + } + + /** @return number of threads which a server should use for J2K encoding on the local machine */ + int server_encoding_threads () const { + return _server_encoding_threads; } - boost::filesystem::path default_directory () const { + boost::optional default_directory () const { return _default_directory; } + boost::optional default_kdm_directory () const { + return _default_kdm_directory; + } + boost::filesystem::path default_directory_or (boost::filesystem::path a) const; + boost::filesystem::path default_kdm_directory_or (boost::filesystem::path a) const; enum Property { USE_ANY_SERVERS, SERVERS, + CINEMAS, + SOUND, + SOUND_OUTPUT, + INTERFACE_COMPLEXITY, + PLAYER_CONTENT_DIRECTORY, + PLAYER_PLAYLIST_DIRECTORY, + PLAYER_DEBUG_LOG, + HISTORY, +#ifdef DCPOMATIC_VARIANT_SWAROOP + PLAYER_BACKGROUND_IMAGE, +#endif OTHER }; @@ -131,6 +157,10 @@ public: return _allow_any_dcp_frame_rate; } + bool allow_any_container () const { + return _allow_any_container; + } + ISDCFMetadata default_isdcf_metadata () const { return _default_isdcf_metadata; } @@ -147,10 +177,18 @@ public: return _default_container; } + Ratio const * default_scale_to () const { + return _default_scale_to; + } + DCPContentType const * default_dcp_content_type () const { return _default_dcp_content_type; } + int default_dcp_audio_channels () const { + return _default_dcp_audio_channels; + } + std::string dcp_issuer () const { return _dcp_issuer; } @@ -171,6 +209,18 @@ public: return _default_interop; } + bool default_upload_after_make_dcp () { + return _default_upload_after_make_dcp; + } + + void set_default_kdm_directory (boost::filesystem::path d) { + if (_default_kdm_directory && _default_kdm_directory.get() == d) { + return; + } + _default_kdm_directory = d; + changed (); + } + std::string mail_server () const { return _mail_server; } @@ -195,7 +245,7 @@ public: return _kdm_from; } - std::string kdm_cc () const { + std::vector kdm_cc () const { return _kdm_cc; } @@ -207,6 +257,30 @@ public: return _kdm_email; } + std::string notification_subject () const { + return _notification_subject; + } + + std::string notification_from () const { + return _notification_from; + } + + std::string notification_to () const { + return _notification_to; + } + + std::vector notification_cc () const { + return _notification_cc; + } + + std::string notification_bcc () const { + return _notification_bcc; + } + + std::string notification_email () const { + return _notification_email; + } + boost::shared_ptr signer_chain () const { return _signer_chain; } @@ -231,6 +305,10 @@ public: return _log_types; } + bool analyse_ebur128 () const { + return _analyse_ebur128; + } + bool automatic_audio_analysis () const { return _automatic_audio_analysis; } @@ -245,17 +323,234 @@ public: return _history; } - std::vector dkdms () const { + std::vector player_history () const { + return _player_history; + } + + boost::shared_ptr dkdms () const { return _dkdms; } - /** @param n New number of local encoding threads */ - void set_num_local_encoding_threads (int n) { - maybe_set (_num_local_encoding_threads, n); + boost::filesystem::path cinemas_file () const { + return _cinemas_file; + } + + bool show_hints_before_make_dcp () const { + return _show_hints_before_make_dcp; + } + + bool confirm_kdm_email () const { + return _confirm_kdm_email; + } + + dcp::NameFormat kdm_container_name_format () const { + return _kdm_container_name_format; + } + + dcp::NameFormat kdm_filename_format () const { + return _kdm_filename_format; + } + + dcp::NameFormat dcp_metadata_filename_format () const { + return _dcp_metadata_filename_format; + } + + dcp::NameFormat dcp_asset_filename_format () const { + return _dcp_asset_filename_format; + } + + bool jump_to_selected () const { + return _jump_to_selected; + } + + enum Nag { + NAG_DKDM_CONFIG, + NAG_ENCRYPTED_METADATA, + NAG_REMAKE_DECRYPTION_CHAIN, + NAG_BAD_SIGNER_CHAIN, + /* Not really a nag but it's the same idea */ + NAG_INITIAL_SETUP, + NAG_COUNT + }; + + bool nagged (Nag nag) const { + return _nagged[nag]; + } + + bool sound () const { + return _sound; + } + + std::string cover_sheet () const { + return _cover_sheet; + } + + boost::optional sound_output () const { + return _sound_output; + } + + boost::optional last_player_load_directory () const { + return _last_player_load_directory; + } + + enum KDMWriteType { + KDM_WRITE_FLAT, + KDM_WRITE_FOLDER, + KDM_WRITE_ZIP + }; + + boost::optional last_kdm_write_type () const { + return _last_kdm_write_type; + } + + enum DKDMWriteType { + DKDM_WRITE_INTERNAL, + DKDM_WRITE_FILE + }; + + boost::optional last_dkdm_write_type () const { + return _last_dkdm_write_type; + } + + int frames_in_memory_multiplier () const { + return _frames_in_memory_multiplier; + } + + boost::optional decode_reduction () const { + return _decode_reduction; + } + + bool default_notify () const { + return _default_notify; + } + + enum Notification { + MESSAGE_BOX, + EMAIL, + NOTIFICATION_COUNT + }; + + bool notification (Notification n) const { + return _notification[n]; + } + + boost::optional barco_username () const { + return _barco_username; + } + + boost::optional barco_password () const { + return _barco_password; + } + + boost::optional christie_username () const { + return _christie_username; + } + + boost::optional christie_password () const { + return _christie_password; + } + + boost::optional gdc_username () const { + return _gdc_username; + } + + boost::optional gdc_password () const { + return _gdc_password; + } + + enum Interface { + INTERFACE_SIMPLE, + INTERFACE_FULL + }; + + Interface interface_complexity () const { + return _interface_complexity; + } + + enum PlayerMode { + PLAYER_MODE_WINDOW, + PLAYER_MODE_FULL, + PLAYER_MODE_DUAL + }; + + PlayerMode player_mode () const { + return _player_mode; + } + + int image_display () const { + return _image_display; + } + + bool respect_kdm_validity_periods () const { + return _respect_kdm_validity_periods; + } + + boost::optional player_activity_log_file () const { + return _player_activity_log_file; + } + + boost::optional player_debug_log_file () const { + return _player_debug_log_file; + } + + boost::optional player_content_directory () const { + return _player_content_directory; + } + + boost::optional player_playlist_directory () const { + return _player_playlist_directory; + } + + boost::optional player_kdm_directory () const { + return _player_kdm_directory; + } + +#ifdef DCPOMATIC_VARIANT_SWAROOP + boost::optional player_background_image () const { + return _player_background_image; + } + + std::string kdm_server_url () const { + return _kdm_server_url; + } + + std::string player_watermark_theatre () const { + return _player_watermark_theatre; + } + + int player_watermark_period () const { + return _player_watermark_period; + } + + int player_watermark_duration () const { + return _player_watermark_duration; + } + + std::vector required_monitors () const { + return _required_monitors; + } + + boost::optional player_lock_file () const { + return _player_lock_file; + } +#endif + + /* SET (mostly) */ + + void set_master_encoding_threads (int n) { + maybe_set (_master_encoding_threads, n); + } + + void set_server_encoding_threads (int n) { + maybe_set (_server_encoding_threads, n); } void set_default_directory (boost::filesystem::path d) { - maybe_set (_default_directory, d); + if (_default_directory && *_default_directory == d) { + return; + } + _default_directory = d; + changed (); } /** @param p New server port */ @@ -293,12 +588,12 @@ public: void add_cinema (boost::shared_ptr c) { _cinemas.push_back (c); - changed (); + changed (CINEMAS); } void remove_cinema (boost::shared_ptr c) { _cinemas.remove (c); - changed (); + changed (CINEMAS); } void set_allowed_dcp_frame_rates (std::list const & r) { @@ -309,6 +604,10 @@ public: maybe_set (_allow_any_dcp_frame_rate, a); } + void set_allow_any_container (bool a) { + maybe_set (_allow_any_container, a); + } + void set_default_isdcf_metadata (ISDCFMetadata d) { maybe_set (_default_isdcf_metadata, d); } @@ -338,10 +637,18 @@ public: maybe_set (_default_container, c); } + void set_default_scale_to (Ratio const * c) { + maybe_set (_default_scale_to, c); + } + void set_default_dcp_content_type (DCPContentType const * t) { maybe_set (_default_dcp_content_type, t); } + void set_default_dcp_audio_channels (int c) { + maybe_set (_default_dcp_audio_channels, c); + } + void set_dcp_issuer (std::string i) { maybe_set (_dcp_issuer, i); } @@ -362,6 +669,10 @@ public: maybe_set (_default_interop, i); } + void set_default_upload_after_make_dcp (bool u) { + maybe_set (_default_upload_after_make_dcp, u); + } + void set_mail_server (std::string s) { maybe_set (_mail_server, s); } @@ -386,7 +697,7 @@ public: maybe_set (_kdm_from, f); } - void set_kdm_cc (std::string f) { + void set_kdm_cc (std::vector f) { maybe_set (_kdm_cc, f); } @@ -400,6 +711,32 @@ public: void reset_kdm_email (); + void set_notification_subject (std::string s) { + maybe_set (_notification_subject, s); + } + + void set_notification_from (std::string f) { + maybe_set (_notification_from, f); + } + + void set_notification_to (std::string t) { + maybe_set (_notification_to, t); + } + + void set_notification_cc (std::vector f) { + maybe_set (_notification_cc, f); + } + + void set_notification_bcc (std::string f) { + maybe_set (_notification_bcc, f); + } + + void set_notification_email (std::string e) { + maybe_set (_notification_email, e); + } + + void reset_notification_email (); + void set_signer_chain (boost::shared_ptr s) { maybe_set (_signer_chain, s); } @@ -427,6 +764,10 @@ public: maybe_set (_log_types, t); } + void set_analyse_ebur128 (bool a) { + maybe_set (_analyse_ebur128, a); + } + void set_automatic_audio_analysis (bool a) { maybe_set (_automatic_audio_analysis, a); } @@ -437,50 +778,353 @@ public: } #endif - void set_dkdms (std::vector dkdms) - { + void set_dkdms (boost::shared_ptr dkdms) { _dkdms = dkdms; changed (); } + void set_cinemas_file (boost::filesystem::path file); + + void set_show_hints_before_make_dcp (bool s) { + maybe_set (_show_hints_before_make_dcp, s); + } + + void set_confirm_kdm_email (bool s) { + maybe_set (_confirm_kdm_email, s); + } + + void set_sound (bool s) { + maybe_set (_sound, s, SOUND); + } + + void set_sound_output (std::string o) { + maybe_set (_sound_output, o, SOUND_OUTPUT); + } + + void set_last_player_load_directory (boost::filesystem::path d) { + maybe_set (_last_player_load_directory, d); + } + + void set_last_kdm_write_type (KDMWriteType t) { + maybe_set (_last_kdm_write_type, t); + } + + void set_last_dkdm_write_type (DKDMWriteType t) { + maybe_set (_last_dkdm_write_type, t); + } + + void unset_sound_output () { + if (!_sound_output) { + return; + } + + _sound_output = boost::none; + changed (); + } + + void set_kdm_container_name_format (dcp::NameFormat n) { + maybe_set (_kdm_container_name_format, n); + } + + void set_kdm_filename_format (dcp::NameFormat n) { + maybe_set (_kdm_filename_format, n); + } + + void set_dcp_metadata_filename_format (dcp::NameFormat n) { + maybe_set (_dcp_metadata_filename_format, n); + } + + void set_dcp_asset_filename_format (dcp::NameFormat n) { + maybe_set (_dcp_asset_filename_format, n); + } + + void set_frames_in_memory_multiplier (int m) { + maybe_set (_frames_in_memory_multiplier, m); + } + + void set_decode_reduction (boost::optional r) { + maybe_set (_decode_reduction, r); + } + + void set_default_notify (bool n) { + maybe_set (_default_notify, n); + } + void clear_history () { _history.clear (); changed (); } + void clear_player_history () { + _player_history.clear (); + changed (); + } + void add_to_history (boost::filesystem::path p); + void add_to_player_history (boost::filesystem::path p); + + void set_jump_to_selected (bool j) { + maybe_set (_jump_to_selected, j); + } + + void set_nagged (Nag nag, bool nagged) { + maybe_set (_nagged[nag], nagged); + } + + void set_cover_sheet (std::string s) { + maybe_set (_cover_sheet, s); + } + + void reset_cover_sheet (); + + void set_notification (Notification n, bool v) { + maybe_set (_notification[n], v); + } + + void set_barco_username (std::string u) { + maybe_set (_barco_username, u); + } + + void unset_barco_username () { + maybe_set (_barco_username, boost::optional()); + } + + void set_barco_password (std::string p) { + maybe_set (_barco_password, p); + } + + void unset_barco_password () { + maybe_set (_barco_password, boost::optional()); + } + + void set_christie_username (std::string u) { + maybe_set (_christie_username, u); + } + + void unset_christie_username () { + maybe_set (_christie_username, boost::optional()); + } + + void set_christie_password (std::string p) { + maybe_set (_christie_password, p); + } + + void unset_christie_password () { + maybe_set (_christie_password, boost::optional()); + } + + void set_gdc_username (std::string u) { + maybe_set (_gdc_username, u); + } + + void unset_gdc_username () { + maybe_set (_gdc_username, boost::optional()); + } + + void set_gdc_password (std::string p) { + maybe_set (_gdc_password, p); + } + + void unset_gdc_password () { + maybe_set (_gdc_password, boost::optional()); + } + + void set_interface_complexity (Interface i) { + maybe_set (_interface_complexity, i, INTERFACE_COMPLEXITY); + } + + void set_player_mode (PlayerMode m) { + maybe_set (_player_mode, m); + } + + void set_image_display (int n) { + maybe_set (_image_display, n); + } + + void set_respect_kdm_validity_periods (bool r) { + maybe_set (_respect_kdm_validity_periods, r); + } + + void set_player_activity_log_file (boost::filesystem::path p) { + maybe_set (_player_activity_log_file, p); + } + + void unset_player_activity_log_file () { + if (!_player_activity_log_file) { + return; + } + _player_activity_log_file = boost::none; + changed (); + } + + void set_player_debug_log_file (boost::filesystem::path p) { + maybe_set (_player_debug_log_file, p, PLAYER_DEBUG_LOG); + } + + void unset_player_debug_log_file () { + if (!_player_debug_log_file) { + return; + } + _player_debug_log_file = boost::none; + changed (PLAYER_DEBUG_LOG); + } + + void set_player_content_directory (boost::filesystem::path p) { + maybe_set (_player_content_directory, p, PLAYER_CONTENT_DIRECTORY); + } + + void unset_player_content_directory () { + if (!_player_content_directory) { + return; + } + _player_content_directory = boost::none; + changed (PLAYER_CONTENT_DIRECTORY); + } + + void set_player_playlist_directory (boost::filesystem::path p) { + maybe_set (_player_playlist_directory, p, PLAYER_PLAYLIST_DIRECTORY); + } + + void unset_player_playlist_directory () { + if (!_player_playlist_directory) { + return; + } + _player_playlist_directory = boost::none; + changed (PLAYER_PLAYLIST_DIRECTORY); + } + + void set_player_kdm_directory (boost::filesystem::path p) { + maybe_set (_player_kdm_directory, p); + } + + void unset_player_kdm_directory () { + if (!_player_kdm_directory) { + return; + } + _player_kdm_directory = boost::none; + changed (); + } + +#ifdef DCPOMATIC_VARIANT_SWAROOP + void set_player_background_image (boost::filesystem::path p) { + maybe_set (_player_background_image, p, PLAYER_BACKGROUND_IMAGE); + } + + void unset_player_background_image () { + if (!_player_background_image) { + return; + } + _player_background_image = boost::none; + changed (PLAYER_BACKGROUND_IMAGE); + } + + void set_kdm_server_url (std::string s) { + maybe_set (_kdm_server_url, s); + } + + void set_player_watermark_theatre (std::string p) { + maybe_set (_player_watermark_theatre, p); + } + + void set_player_watermark_period (int minutes) { + maybe_set (_player_watermark_period, minutes); + } + + void set_player_watermark_duration (int milliseconds) { + maybe_set (_player_watermark_duration, milliseconds); + } + + void set_required_monitors (std::vector monitors) { + maybe_set (_required_monitors, monitors); + } + + void set_player_lock_file (boost::filesystem::path p) { + maybe_set (_player_lock_file, p); + } + + void unset_player_lock_file () { + if (!_player_lock_file) { + return; + } + _player_lock_file = boost::none; + changed (); + } +#endif void changed (Property p = OTHER); boost::signals2::signal Changed; + /** Emitted if read() failed on an existing Config file. There is nothing + a listener can do about it: this is just for information. + */ + static boost::signals2::signal FailedToLoad; + /** Emitted if read() issued a warning which the user might want to know about */ + static boost::signals2::signal Warning; + /** Emitted if there is a bad certificate in the signer chain. Handler can call + * true to ask Config to re-create the chain. + */ + static boost::signals2::signal BadSignerChain; void write () const; + void write_config () const; + void write_cinemas () const; + void link (boost::filesystem::path new_file) const; + void copy_and_link (boost::filesystem::path new_file) const; + bool have_write_permission () const; + + void save_template (boost::shared_ptr film, std::string name) const; + bool existing_template (std::string name) const; + std::list templates () const; + boost::filesystem::path template_path (std::string name) const; + void rename_template (std::string old_name, std::string new_name) const; + void delete_template (std::string name) const; static Config* instance (); static void drop (); static void restore_defaults (); - static bool have_existing (); + static bool have_existing (std::string); + static boost::filesystem::path config_file (); + static boost::filesystem::path path (std::string file, bool create_directories = true); + + /** If set, this overrides the standard path (in home, Library, AppData or wherever) for config.xml and cinemas.xml */ + static boost::optional override_path; private: Config (); - static boost::filesystem::path file (bool create_directories = true); void read (); void set_defaults (); void set_kdm_email_to_default (); + void set_notification_email_to_default (); + void set_cover_sheet_to_default (); + void read_cinemas (cxml::Document const & f); boost::shared_ptr create_certificate_chain (); + boost::filesystem::path directory_or (boost::optional dir, boost::filesystem::path a) const; + void add_to_history_internal (std::vector& h, boost::filesystem::path p); + void backup (); template - void maybe_set (T& member, T new_value) { + void maybe_set (T& member, T new_value, Property prop = OTHER) { if (member == new_value) { return; } member = new_value; - changed (); + changed (prop); } - /** number of threads to use for J2K encoding on the local machine */ - int _num_local_encoding_threads; + template + void maybe_set (boost::optional& member, T new_value, Property prop = OTHER) { + if (member && member.get() == new_value) { + return; + } + member = new_value; + changed (prop); + } + + /** number of threads which a master DoM should use for J2K encoding on the local machine */ + int _master_encoding_threads; + /** number of threads which a server should use for J2K encoding on the local machine */ + int _server_encoding_threads; /** default directory to put new films in */ - boost::filesystem::path _default_directory; + boost::optional _default_directory; /** base port number to use for J2K encoding servers; * this port and the two above it will be used. */ @@ -501,21 +1145,34 @@ private: std::string _tms_password; /** Our cinema sound processor */ CinemaSoundProcessor const * _cinema_sound_processor; + /** The list of possible DCP frame rates that DCP-o-matic will use */ std::list _allowed_dcp_frame_rates; /** Allow any video frame rate for the DCP; if true, overrides _allowed_dcp_frame_rates */ bool _allow_any_dcp_frame_rate; + /** Allow any container ratio, not just the standard ones. GDC SX-2001 will not play Flat + DCPs at 25fps but will play 16:9, so this is very useful for some users. + https://www.dcpomatic.com/forum/viewtopic.php?f=2&t=1119&p=4468 + */ + bool _allow_any_container; /** Default ISDCF metadata for newly-created Films */ ISDCFMetadata _default_isdcf_metadata; boost::optional _language; /** Default length of still image content (seconds) */ int _default_still_length; Ratio const * _default_container; + Ratio const * _default_scale_to; DCPContentType const * _default_dcp_content_type; + int _default_dcp_audio_channels; std::string _dcp_issuer; std::string _dcp_creator; int _default_j2k_bandwidth; int _default_audio_delay; bool _default_interop; + /** Default directory to offer to write KDMs to; if it's not set, + the home directory will be offered. + */ + boost::optional _default_kdm_directory; + bool _default_upload_after_make_dcp; std::list > _cinemas; std::string _mail_server; int _mail_port; @@ -523,26 +1180,97 @@ private: std::string _mail_password; std::string _kdm_subject; std::string _kdm_from; - std::string _kdm_cc; + std::vector _kdm_cc; std::string _kdm_bcc; std::string _kdm_email; + std::string _notification_subject; + std::string _notification_from; + std::string _notification_to; + std::vector _notification_cc; + std::string _notification_bcc; + std::string _notification_email; boost::shared_ptr _signer_chain; +#ifdef DCPOMATIC_VARIANT_SWAROOP + boost::filesystem::path _signer_chain_path; +#endif /** Chain used to decrypt KDMs; the leaf of this chain is the target * certificate for making KDMs given to DCP-o-matic. */ boost::shared_ptr _decryption_chain; +#ifdef DCPOMATIC_VARIANT_SWAROOP + boost::filesystem::path _decryption_chain_path; +#endif /** true to check for updates on startup */ bool _check_for_updates; bool _check_for_test_updates; /** maximum allowed J2K bandwidth in bits per second */ int _maximum_j2k_bandwidth; int _log_types; + bool _analyse_ebur128; bool _automatic_audio_analysis; #ifdef DCPOMATIC_WINDOWS bool _win32_console; #endif std::vector _history; - std::vector _dkdms; + std::vector _player_history; + boost::shared_ptr _dkdms; + boost::filesystem::path _cinemas_file; + bool _show_hints_before_make_dcp; + bool _confirm_kdm_email; + dcp::NameFormat _kdm_filename_format; + dcp::NameFormat _kdm_container_name_format; + dcp::NameFormat _dcp_metadata_filename_format; + dcp::NameFormat _dcp_asset_filename_format; + bool _jump_to_selected; + bool _nagged[NAG_COUNT]; + bool _sound; + /** name of a specific sound output stream to use, or empty to use the default */ + boost::optional _sound_output; + std::string _cover_sheet; + boost::optional _last_player_load_directory; + boost::optional _last_kdm_write_type; + boost::optional _last_dkdm_write_type; + int _frames_in_memory_multiplier; + boost::optional _decode_reduction; + bool _default_notify; + bool _notification[NOTIFICATION_COUNT]; + boost::optional _barco_username; + boost::optional _barco_password; + boost::optional _christie_username; + boost::optional _christie_password; + boost::optional _gdc_username; + boost::optional _gdc_password; + Interface _interface_complexity; + PlayerMode _player_mode; + int _image_display; + bool _respect_kdm_validity_periods; + /** Log file containing things the player does (e.g. started, stopped, loaded + playlist etc.) Does not contain debugging information. + */ + boost::optional _player_activity_log_file; + /** Log file containing debug information for the player */ + boost::optional _player_debug_log_file; + /** A directory containing DCPs whose contents are presented to the user + in the dual-screen player mode. DCPs on the list can be loaded + for playback. + */ + boost::optional _player_content_directory; + boost::optional _player_playlist_directory; + boost::optional _player_kdm_directory; +#ifdef DCPOMATIC_VARIANT_SWAROOP + boost::optional _player_background_image; + std::string _kdm_server_url; + std::string _player_watermark_theatre; + /** watermark period in minutes */ + int _player_watermark_period; + /** watermark duration in milliseconds */ + int _player_watermark_duration; + std::vector _required_monitors; + /** a file which, if specified, must be present for the player to work */ + boost::optional _player_lock_file; +#endif + + static int const _current_version; /** Singleton instance, or 0 */ static Config* _instance;