X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fconfig.h;h=8fbdeaf9584ffe9f9aa85c9084b2fd867aa80bb9;hb=HEAD;hp=9c1f231611e33b5e5b77a03004ac3311886b9c42;hpb=bd195d6b1a0b2928abc6aa4b75bea8b0fb1aac8a;p=dcpomatic.git diff --git a/src/lib/config.h b/src/lib/config.h index 9c1f23161..f3d080b0b 100644 --- a/src/lib/config.h +++ b/src/lib/config.h @@ -1,19 +1,20 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2022 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 . */ @@ -21,42 +22,81 @@ * @brief Class holding configuration. */ + #ifndef DCPOMATIC_CONFIG_H #define DCPOMATIC_CONFIG_H -#include "isdcf_metadata.h" -#include "types.h" + +#include "audio_mapping.h" +#include "export_config.h" +#include "rough_duration.h" +#include "state.h" +#include #include -#include +#include +#include #include #include #include + +class Cinema; class CinemaSoundProcessor; class DCPContentType; +class DKDMGroup; +class DKDMRecipient; +class Film; class Ratio; -class Cinema; + + +extern void save_all_config_as_zip (boost::filesystem::path zip_file); + /** @class Config * @brief A singleton class holding configuration. */ -class Config : public boost::noncopyable +class Config : public State { 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; + + void load_from_zip(boost::filesystem::path zip_file); enum Property { USE_ANY_SERVERS, SERVERS, + CINEMAS, + DKDM_RECIPIENTS, + SOUND, + SOUND_OUTPUT, + PLAYER_CONTENT_DIRECTORY, + PLAYER_PLAYLIST_DIRECTORY, + PLAYER_DEBUG_LOG, + HISTORY, + SHOW_EXPERIMENTAL_AUDIO_PROCESSORS, + AUDIO_MAPPING, + AUTO_CROP_THRESHOLD, + ALLOW_SMPTE_BV20, + ISDCF_NAME_PART_LENGTH, OTHER }; @@ -89,10 +129,14 @@ public: return _only_servers_encode; } - Protocol tms_protocol () const { + FileTransferProtocol tms_protocol () const { return _tms_protocol; } + bool tms_passive() const { + return _tms_passive; + } + /** @return The IP address of a TMS that we can copy DCPs to */ std::string tms_ip () const { return _tms_ip; @@ -113,13 +157,12 @@ public: return _tms_password; } - /** @return The cinema sound processor that we are using */ - CinemaSoundProcessor const * cinema_sound_processor () const { - return _cinema_sound_processor; + std::list> cinemas () const { + return _cinemas; } - std::list > cinemas () const { - return _cinemas; + std::list> dkdm_recipients () const { + return _dkdm_recipients; } std::list allowed_dcp_frame_rates () const { @@ -130,8 +173,20 @@ public: return _allow_any_dcp_frame_rate; } - ISDCFMetadata default_isdcf_metadata () const { - return _default_isdcf_metadata; + bool allow_any_container () const { + return _allow_any_container; + } + + bool allow_96khz_audio () const { + return _allow_96khz_audio; + } + + bool use_all_audio_channels () const { + return _use_all_audio_channels; + } + + bool show_experimental_audio_processors () const { + return _show_experimental_audio_processors; } boost::optional language () const { @@ -142,14 +197,14 @@ public: return _default_still_length; } - Ratio const * default_container () const { - return _default_container; - } - 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; } @@ -158,6 +213,22 @@ public: return _dcp_creator; } + std::string dcp_company_name () const { + return _dcp_company_name; + } + + std::string dcp_product_name () const { + return _dcp_product_name; + } + + std::string dcp_product_version () const { + return _dcp_product_version; + } + + std::string dcp_j2k_comment () const { + return _dcp_j2k_comment; + } + int default_j2k_bandwidth () const { return _default_j2k_bandwidth; } @@ -170,6 +241,30 @@ public: return _default_interop; } + boost::optional default_audio_language() const { + return _default_audio_language; + } + + boost::optional default_territory() const { + return _default_territory; + } + + std::map default_metadata () const { + return _default_metadata; + } + + bool upload_after_make_dcp () { + return _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; } @@ -178,6 +273,10 @@ public: return _mail_port; } + EmailProtocol mail_protocol () const { + return _mail_protocol; + } + std::string mail_user () const { return _mail_user; } @@ -194,7 +293,7 @@ public: return _kdm_from; } - std::string kdm_cc () const { + std::vector kdm_cc () const { return _kdm_cc; } @@ -206,11 +305,35 @@ public: return _kdm_email; } - boost::shared_ptr signer_chain () const { + 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; + } + + std::shared_ptr signer_chain () const { return _signer_chain; } - boost::shared_ptr decryption_chain () const { + std::shared_ptr decryption_chain () const { return _decryption_chain; } @@ -230,6 +353,10 @@ public: return _log_types; } + bool analyse_ebur128 () const { + return _analyse_ebur128; + } + bool automatic_audio_analysis () const { return _automatic_audio_analysis; } @@ -244,13 +371,276 @@ public: return _history; } - /** @param n New number of local encoding threads */ - void set_num_local_encoding_threads (int n) { - maybe_set (_num_local_encoding_threads, n); + std::vector player_history () const { + return _player_history; + } + + std::shared_ptr dkdms () const { + return _dkdms; + } + + boost::filesystem::path cinemas_file () const { + return _cinemas_file; + } + + boost::filesystem::path dkdm_recipients_file () const { + return _dkdm_recipients_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 dkdm_filename_format () const { + return _dkdm_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; + } + + /* This could be an enum class but we use the enum a lot to index _nagged + * so it means a lot of casts. + */ + enum Nag { + NAG_DKDM_CONFIG, + NAG_ENCRYPTED_METADATA, + NAG_ALTER_DECRYPTION_CHAIN, + NAG_BAD_SIGNER_CHAIN_UTF8, + NAG_IMPORT_DECRYPTION_CHAIN, + NAG_DELETE_DKDM, + NAG_32_ON_64, + NAG_TOO_MANY_DROPPED_FRAMES, + NAG_BAD_SIGNER_CHAIN_VALIDITY, + NAG_BAD_SIGNER_DN_QUALIFIER, + 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 PlayerMode { + PLAYER_MODE_WINDOW, ///< one window containing image and controls + PLAYER_MODE_FULL, ///< just the image filling the screen + PLAYER_MODE_DUAL ///< image on one monitor and extended controls on the other + }; + + PlayerMode player_mode () const { + return _player_mode; + } + + int image_display () const { + return _image_display; + } + + enum VideoViewType { + VIDEO_VIEW_SIMPLE, + VIDEO_VIEW_OPENGL + }; + + VideoViewType video_view_type () const { + return _video_view_type; + } + + bool respect_kdm_validity_periods () const { + return _respect_kdm_validity_periods; + } + + 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; + } + + AudioMapping audio_mapping (int output_channels); + + std::vector custom_languages () const { + return _custom_languages; + } + + boost::optional initial_path(std::string id) const; + + bool use_isdcf_name_by_default () const { + return _use_isdcf_name_by_default; + } + + bool write_kdms_to_disk () const { + return _write_kdms_to_disk; + } + + bool email_kdms () const { + return _email_kdms; + } + + dcp::Formulation default_kdm_type () const { + return _default_kdm_type; + } + + RoughDuration default_kdm_duration () const { + return _default_kdm_duration; + } + + double auto_crop_threshold () const { + return _auto_crop_threshold; + } + + boost::optional last_release_notes_version () const { + return _last_release_notes_version; + } + + boost::optional main_divider_sash_position() const { + return _main_divider_sash_position; + } + + boost::optional main_content_divider_sash_position() const { + return _main_content_divider_sash_position; + } + + enum class DefaultAddFileLocation { + SAME_AS_LAST_TIME, + SAME_AS_PROJECT + }; + + DefaultAddFileLocation default_add_file_location() const { + return _default_add_file_location; + } + + bool allow_smpte_bv20() const { + return _allow_smpte_bv20; + } + + int isdcf_name_part_length() const { + return _isdcf_name_part_length; + } + + /* 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 */ @@ -262,10 +652,14 @@ public: maybe_set (_only_servers_encode, o); } - void set_tms_protocol (Protocol p) { + void set_tms_protocol (FileTransferProtocol p) { maybe_set (_tms_protocol, p); } + void set_tms_passive(bool passive) { + maybe_set(_tms_passive, passive); + } + /** @param i IP address of a TMS that we can copy DCPs to */ void set_tms_ip (std::string i) { maybe_set (_tms_ip, i); @@ -286,14 +680,24 @@ public: maybe_set (_tms_password, p); } - void add_cinema (boost::shared_ptr c) { + void add_cinema (std::shared_ptr c) { _cinemas.push_back (c); - changed (); + changed (CINEMAS); } - void remove_cinema (boost::shared_ptr c) { + void remove_cinema (std::shared_ptr c) { _cinemas.remove (c); - changed (); + changed (CINEMAS); + } + + void add_dkdm_recipient (std::shared_ptr c) { + _dkdm_recipients.push_back (c); + changed (DKDM_RECIPIENTS); + } + + void remove_dkdm_recipient (std::shared_ptr c) { + _dkdm_recipients.remove (c); + changed (DKDM_RECIPIENTS); } void set_allowed_dcp_frame_rates (std::list const & r) { @@ -304,8 +708,20 @@ public: maybe_set (_allow_any_dcp_frame_rate, a); } - void set_default_isdcf_metadata (ISDCFMetadata d) { - maybe_set (_default_isdcf_metadata, d); + void set_allow_any_container (bool a) { + maybe_set (_allow_any_container, a); + } + + void set_allow_96hhz_audio (bool a) { + maybe_set (_allow_96khz_audio, a); + } + + void set_use_all_audio_channels (bool a) { + maybe_set (_use_all_audio_channels, a); + } + + void set_show_experimental_audio_processors (bool e) { + maybe_set (_show_experimental_audio_processors, e, SHOW_EXPERIMENTAL_AUDIO_PROCESSORS); } void set_language (std::string l) { @@ -329,14 +745,14 @@ public: maybe_set (_default_still_length, s); } - void set_default_container (Ratio const * c) { - maybe_set (_default_container, 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); } @@ -345,6 +761,22 @@ public: maybe_set (_dcp_creator, c); } + void set_dcp_company_name (std::string c) { + maybe_set (_dcp_company_name, c); + } + + void set_dcp_product_name (std::string c) { + maybe_set (_dcp_product_name, c); + } + + void set_dcp_product_version (std::string c) { + maybe_set (_dcp_product_version, c); + } + + void set_dcp_j2k_comment (std::string c) { + maybe_set (_dcp_j2k_comment, c); + } + void set_default_j2k_bandwidth (int b) { maybe_set (_default_j2k_bandwidth, b); } @@ -357,6 +789,30 @@ public: maybe_set (_default_interop, i); } + void set_default_audio_language(dcp::LanguageTag tag) { + maybe_set(_default_audio_language, tag); + } + + void unset_default_audio_language() { + maybe_set(_default_audio_language, boost::optional()); + } + + void set_default_territory(dcp::LanguageTag::RegionSubtag tag) { + maybe_set(_default_territory, tag); + } + + void unset_default_territory() { + maybe_set(_default_territory, boost::optional()); + } + + void set_default_metadata (std::map const& metadata) { + maybe_set (_default_metadata, metadata); + } + + void set_upload_after_make_dcp (bool u) { + maybe_set (_upload_after_make_dcp, u); + } + void set_mail_server (std::string s) { maybe_set (_mail_server, s); } @@ -365,6 +821,10 @@ public: maybe_set (_mail_port, p); } + void set_mail_protocol (EmailProtocol p) { + maybe_set (_mail_protocol, p); + } + void set_mail_user (std::string u) { maybe_set (_mail_user, u); } @@ -381,7 +841,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); } @@ -395,16 +855,45 @@ public: void reset_kdm_email (); - void set_signer_chain (boost::shared_ptr s) { + 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 (std::shared_ptr s) { maybe_set (_signer_chain, s); } - void set_decryption_chain (boost::shared_ptr c) { + void set_decryption_chain (std::shared_ptr c) { maybe_set (_decryption_chain, c); } void set_check_for_updates (bool c) { maybe_set (_check_for_updates, c); + if (!c) { + set_check_for_test_updates (false); + } } void set_check_for_test_updates (bool c) { @@ -419,6 +908,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); } @@ -429,46 +922,385 @@ public: } #endif + void set_dkdms (std::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_dkdm_filename_format (dcp::NameFormat n) { + maybe_set (_dkdm_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 clean_history (); + void add_to_player_history (boost::filesystem::path p); + void clean_player_history (); + + 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_player_mode (PlayerMode m) { + maybe_set (_player_mode, m); + } + + void set_image_display (int n) { + maybe_set (_image_display, n); + } + + void set_video_view_type (VideoViewType v) { + maybe_set (_video_view_type, v); + } + + void set_respect_kdm_validity_periods (bool r) { + maybe_set (_respect_kdm_validity_periods, r); + } + + 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 (); + } + + void set_audio_mapping (AudioMapping m); + void set_audio_mapping_to_default (); + + void add_custom_language (dcp::LanguageTag tag); + + void set_initial_path(std::string id, boost::filesystem::path path); + + void set_use_isdcf_name_by_default (bool use) { + maybe_set (_use_isdcf_name_by_default, use); + } + + void set_write_kdms_to_disk (bool write) { + maybe_set (_write_kdms_to_disk, write); + } + + void set_email_kdms (bool email) { + maybe_set (_email_kdms, email); + } + + void set_default_kdm_type (dcp::Formulation type) { + maybe_set (_default_kdm_type, type); + } + + void set_default_kdm_duration (RoughDuration duration) { + maybe_set (_default_kdm_duration, duration); + } + + void set_auto_crop_threshold (double threshold) { + maybe_set (_auto_crop_threshold, threshold, AUTO_CROP_THRESHOLD); + } + + void set_last_release_notes_version (std::string version) { + maybe_set (_last_release_notes_version, version); + } + + void unset_last_release_notes_version() { + maybe_set(_last_release_notes_version, boost::optional()); + } + + ExportConfig& export_config() { + return _export; + } + + void set_main_divider_sash_position(int position) { + maybe_set(_main_divider_sash_position, position); + } + + void set_main_content_divider_sash_position(int position) { + maybe_set(_main_content_divider_sash_position, position); + } + + void set_default_add_file_location(DefaultAddFileLocation location) { + maybe_set(_default_add_file_location, location); + } + + void set_allow_smpte_bv20(bool allow) { + maybe_set(_allow_smpte_bv20, allow, ALLOW_SMPTE_BV20); + } + + void set_isdcf_name_part_length(int length) { + maybe_set(_isdcf_name_part_length, length, ISDCF_NAME_PART_LENGTH); + } 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. + */ + enum class LoadFailure { + CONFIG, + CINEMAS, + DKDM_RECIPIENTS + }; + 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 something wrong the contents of our config. Handler can call + * true to ask Config to solve the problem (by discarding and recreating the bad thing) + */ + enum BadReason { + BAD_SIGNER_UTF8_STRINGS, ///< signer chain contains UTF-8 strings (not PRINTABLESTRING) + BAD_SIGNER_INCONSISTENT, ///< signer chain is somehow inconsistent + BAD_DECRYPTION_INCONSISTENT, ///< KDM decryption chain is somehow inconsistent + BAD_SIGNER_VALIDITY_TOO_LONG, ///< signer certificate validity periods are >10 years + BAD_SIGNER_DN_QUALIFIER, ///< some signer certificate has a bad dnQualifier (DoM #2716). + }; + + static boost::signals2::signal Bad; + + void write () const override; + void write_config () const; + void write_cinemas () const; + void write_dkdm_recipients () 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 write () const; + void save_template (std::shared_ptr film, std::string name) const; + bool existing_template (std::string name) const; + std::list templates () const; + boost::filesystem::path template_read_path (std::string name) const; + boost::filesystem::path template_write_path (std::string name) const; + void rename_template (std::string old_name, std::string new_name) const; + void delete_template (std::string name) const; + + boost::optional check_certificates () const; static Config* instance (); static void drop (); static void restore_defaults (); - static bool have_existing (); - -private: - Config (); - static boost::filesystem::path file (bool create_directories = true); - void read (); - void set_defaults (); - void set_kdm_email_to_default (); - boost::shared_ptr create_certificate_chain (); + static bool have_existing (std::string); + static boost::filesystem::path config_read_file (); + static boost::filesystem::path config_write_file (); 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); + } + + 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 to use for J2K encoding on the local machine */ - int _num_local_encoding_threads; +private: + Config (); + void read () override; + void read_config(); + void read_cinemas(); + void read_dkdm_recipients(); + 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); + void read_dkdm_recipients (cxml::Document const & f); + std::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 clean_history_internal (std::vector& h); + void backup (); + + /** 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 one above it will be used. + * this port and the two above it will be used. */ int _server_port_base; /** true to broadcast on the `any' address to look for servers */ @@ -476,7 +1308,8 @@ private: /** J2K encoding servers that should definitely be used */ std::vector _servers; bool _only_servers_encode; - Protocol _tms_protocol; + FileTransferProtocol _tms_protocol; + bool _tms_passive; /** The IP address of a TMS that we can copy DCPs to */ std::string _tms_ip; /** The path on a TMS that we should write DCPs to */ @@ -485,52 +1318,142 @@ private: std::string _tms_user; /** Password to log into the TMS with */ 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; - /** Default ISDCF metadata for newly-created Films */ - ISDCFMetadata _default_isdcf_metadata; + /** 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; + bool _allow_96khz_audio; + bool _use_all_audio_channels; + /** Offer the upmixers in the audio processor settings */ + bool _show_experimental_audio_processors; boost::optional _language; /** Default length of still image content (seconds) */ int _default_still_length; - Ratio const * _default_container; DCPContentType const * _default_dcp_content_type; + int _default_dcp_audio_channels; std::string _dcp_issuer; std::string _dcp_creator; + std::string _dcp_company_name; + std::string _dcp_product_name; + std::string _dcp_product_version; + std::string _dcp_j2k_comment; int _default_j2k_bandwidth; int _default_audio_delay; bool _default_interop; - std::list > _cinemas; + boost::optional _default_audio_language; + boost::optional _default_territory; + std::map _default_metadata; + /** 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 _upload_after_make_dcp; + std::list> _cinemas; + std::list> _dkdm_recipients; std::string _mail_server; int _mail_port; + EmailProtocol _mail_protocol; std::string _mail_user; 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; - boost::shared_ptr _signer_chain; + std::string _notification_subject; + std::string _notification_from; + std::string _notification_to; + std::vector _notification_cc; + std::string _notification_bcc; + std::string _notification_email; + std::shared_ptr _signer_chain; /** 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; + std::shared_ptr _decryption_chain; /** 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 _player_history; + std::shared_ptr _dkdms; + boost::filesystem::path _cinemas_file; + boost::filesystem::path _dkdm_recipients_file; + bool _show_hints_before_make_dcp; + bool _confirm_kdm_email; + dcp::NameFormat _kdm_filename_format; + dcp::NameFormat _dkdm_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; + PlayerMode _player_mode; + int _image_display; + VideoViewType _video_view_type; + bool _respect_kdm_validity_periods; + /** 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; + boost::optional _audio_mapping; + std::vector _custom_languages; + std::map> _initial_paths; + bool _use_isdcf_name_by_default; + bool _write_kdms_to_disk; + bool _email_kdms; + dcp::Formulation _default_kdm_type; + RoughDuration _default_kdm_duration; + double _auto_crop_threshold; + boost::optional _last_release_notes_version; + boost::optional _main_divider_sash_position; + boost::optional _main_content_divider_sash_position; + DefaultAddFileLocation _default_add_file_location; + bool _allow_smpte_bv20; + int _isdcf_name_part_length; + + ExportConfig _export; + + static int const _current_version; /** Singleton instance, or 0 */ static Config* _instance; }; + #endif