X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Ffilm.cc;h=70142dcf38f1ac36dcdcbea4317cb84e65b08025;hp=87037f51fb97169a6293e302d262e6aadc19e136;hb=HEAD;hpb=1a7c50245309bb0b99001940b2203a267de942ca diff --git a/src/lib/film.cc b/src/lib/film.cc index 87037f51f..d9ab6e2a3 100644 --- a/src/lib/film.cc +++ b/src/lib/film.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2020 Carl Hetherington + Copyright (C) 2012-2021 Carl Hetherington This file is part of DCP-o-matic. @@ -18,88 +18,92 @@ */ + /** @file src/film.cc * @brief A representation of some audio, video and subtitle content, and details of * how they should be presented in a DCP. */ + #include "atmos_content.h" +#include "audio_content.h" +#include "audio_processor.h" +#include "change_signaller.h" +#include "cinema.h" +#include "compose.hpp" +#include "config.h" +#include "constants.h" +#include "cross.h" +#include "dcp_content.h" +#include "dcp_content_type.h" +#include "dcp_encoder.h" +#include "dcpomatic_log.h" +#include "digester.h" +#include "environment_info.h" +#include "examine_content_job.h" +#include "exceptions.h" +#include "ffmpeg_content.h" +#include "ffmpeg_subtitle_stream.h" +#include "file_log.h" #include "film.h" +#include "font.h" #include "job.h" -#include "util.h" #include "job_manager.h" -#include "dcp_encoder.h" -#include "transcode_job.h" -#include "upload_job.h" +#include "kdm_with_metadata.h" #include "null_log.h" -#include "file_log.h" -#include "dcpomatic_log.h" -#include "exceptions.h" -#include "examine_content_job.h" -#include "config.h" #include "playlist.h" -#include "dcp_content_type.h" #include "ratio.h" -#include "cross.h" -#include "environment_info.h" -#include "audio_processor.h" -#include "digester.h" -#include "compose.hpp" #include "screen.h" -#include "audio_content.h" -#include "video_content.h" #include "text_content.h" -#include "ffmpeg_content.h" -#include "dcp_content.h" -#include "kdm_with_metadata.h" -#include "cinema.h" -#include "change_signaller.h" -#include "check_content_change_job.h" -#include "ffmpeg_subtitle_stream.h" -#include "font.h" +#include "transcode_job.h" +#include "upload_job.h" +#include "video_content.h" +#include "version.h" #include -#include #include -#include -#include +#include #include +#include +#include #include -#include #include +#include +#include #include -#include #include -#include +#include #include #include -#include -#include #include #include #include +#include #include +#include #include "i18n.h" -using std::string; -using std::pair; -using std::vector; -using std::setfill; -using std::min; -using std::max; -using std::make_pair; -using std::cout; -using std::list; -using std::set; -using std::runtime_error; -using std::copy; + using std::back_inserter; -using std::map; +using std::copy; +using std::cout; +using std::dynamic_pointer_cast; using std::exception; using std::find; -using boost::shared_ptr; -using boost::weak_ptr; -using boost::dynamic_pointer_cast; +using std::list; +using std::make_pair; +using std::make_shared; +using std::map; +using std::max; +using std::min; +using std::pair; +using std::runtime_error; +using std::set; +using std::setfill; +using std::shared_ptr; +using std::string; +using std::vector; +using std::weak_ptr; using boost::optional; using boost::is_any_of; #if BOOST_VERSION >= 106100 @@ -108,7 +112,9 @@ using namespace boost::placeholders; using dcp::raw_convert; using namespace dcpomatic; -string const Film::metadata_file = "metadata.xml"; + +static constexpr char metadata_file[] = "metadata.xml"; + /* 5 -> 6 * AudioMapping XML changed. @@ -141,6 +147,7 @@ string const Film::metadata_file = "metadata.xml"; */ int const Film::current_state_version = 38; + /** Construct a Film object in a given directory. * * @param dir Film directory. @@ -148,71 +155,64 @@ int const Film::current_state_version = 38; Film::Film (optional dir) : _playlist (new Playlist) - , _use_isdcf_name (true) + , _use_isdcf_name (Config::instance()->use_isdcf_name_by_default()) , _dcp_content_type (Config::instance()->default_dcp_content_type ()) - , _container (Config::instance()->default_container ()) - , _resolution (RESOLUTION_2K) + , _container(Ratio::from_id("185")) + , _resolution (Resolution::TWO_K) , _encrypted (false) , _context_id (dcp::make_uuid ()) , _j2k_bandwidth (Config::instance()->default_j2k_bandwidth ()) - , _isdcf_metadata (Config::instance()->default_isdcf_metadata ()) , _video_frame_rate (24) , _audio_channels (Config::instance()->default_dcp_audio_channels ()) , _three_d (false) , _sequence (true) , _interop (Config::instance()->default_interop ()) + , _limit_to_smpte_bv20(false) , _audio_processor (0) - , _reel_type (REELTYPE_SINGLE) + , _reel_type (ReelType::SINGLE) , _reel_length (2000000000) , _reencode_j2k (false) , _user_explicit_video_frame_rate (false) , _user_explicit_container (false) , _user_explicit_resolution (false) , _name_language (dcp::LanguageTag("en-US")) - , _audio_language (dcp::LanguageTag("en-US")) - , _release_territory (dcp::LanguageTag::RegionSubtag("US")) + , _release_territory(Config::instance()->default_territory()) , _version_number (1) - , _status (dcp::FINAL) - , _luminance (dcp::Luminance(4.5, dcp::Luminance::FOOT_LAMBERT)) + , _status (dcp::Status::FINAL) + , _audio_language(Config::instance()->default_audio_language()) , _state_version (current_state_version) , _dirty (false) , _tolerant (false) { set_isdcf_date_today (); + auto metadata = Config::instance()->default_metadata(); + if (metadata.find("chain") != metadata.end()) { + _chain = metadata["chain"]; + } + if (metadata.find("distributor") != metadata.end()) { + _distributor = metadata["distributor"]; + } + if (metadata.find("facility") != metadata.end()) { + _facility = metadata["facility"]; + } + if (metadata.find("studio") != metadata.end()) { + _studio = metadata["studio"]; + } + _playlist_change_connection = _playlist->Change.connect (bind (&Film::playlist_change, this, _1)); _playlist_order_changed_connection = _playlist->OrderChange.connect (bind (&Film::playlist_order_changed, this)); _playlist_content_change_connection = _playlist->ContentChange.connect (bind (&Film::playlist_content_change, this, _1, _2, _3, _4)); _playlist_length_change_connection = _playlist->LengthChange.connect (bind(&Film::playlist_length_change, this)); if (dir) { - /* Make state.directory a complete path without ..s (where possible) - (Code swiped from Adam Bowen on stackoverflow) - XXX: couldn't/shouldn't this just be boost::filesystem::canonical? - */ - - boost::filesystem::path p (boost::filesystem::system_complete (dir.get())); - boost::filesystem::path result; - for (boost::filesystem::path::iterator i = p.begin(); i != p.end(); ++i) { - if (*i == "..") { - boost::system::error_code ec; - if (boost::filesystem::is_symlink(result, ec) || result.filename() == "..") { - result /= *i; - } else { - result = result.parent_path (); - } - } else if (*i != ".") { - result /= *i; - } - } - - set_directory (result.make_preferred ()); + set_directory(dcp::filesystem::weakly_canonical(*dir)); } if (_directory) { - _log.reset (new FileLog (file ("log"))); + _log = make_shared(file("log")); } else { - _log.reset (new NullLog); + _log = make_shared(); } _playlist->set_sequence (_sequence); @@ -220,11 +220,11 @@ Film::Film (optional dir) Film::~Film () { - BOOST_FOREACH (boost::signals2::connection& i, _job_connections) { + for (auto& i: _job_connections) { i.disconnect (); } - BOOST_FOREACH (boost::signals2::connection& i, _audio_analysis_connections) { + for (auto& i: _audio_analysis_connections) { i.disconnect (); } } @@ -251,12 +251,21 @@ Film::video_identifier () const s += "_I"; } else { s += "_S"; + if (_limit_to_smpte_bv20) { + s += "_L20"; + } else { + s += "_L21"; + } } if (_three_d) { s += "_3D"; } + if (_reencode_j2k) { + s += "_R"; + } + return s; } @@ -285,16 +294,16 @@ Film::internal_video_asset_filename (DCPTimePeriod p) const boost::filesystem::path Film::audio_analysis_path (shared_ptr playlist) const { - boost::filesystem::path p = dir ("analysis"); + auto p = dir ("analysis"); Digester digester; - BOOST_FOREACH (shared_ptr i, playlist->content ()) { - if (!i->audio) { + for (auto content: playlist->content()) { + if (!content->audio) { continue; } - digester.add (i->digest ()); - digester.add (i->audio->mapping().digest ()); + digester.add(content->digest()); + digester.add(content->audio->mapping().digest()); if (playlist->content().size() != 1) { /* Analyses should be considered equal regardless of gain if they were made from just one piece of content. This @@ -302,7 +311,14 @@ Film::audio_analysis_path (shared_ptr playlist) const analysis at the plotting stage rather than having to recompute it. */ - digester.add (i->audio->gain ()); + digester.add(content->audio->gain()); + + /* Likewise we only care about position if we're looking at a + * whole-project view. + */ + digester.add(content->position().get()); + digester.add(content->trim_start().get()); + digester.add(content->trim_end().get()); } } @@ -320,16 +336,17 @@ Film::audio_analysis_path (shared_ptr playlist) const boost::filesystem::path Film::subtitle_analysis_path (shared_ptr content) const { - boost::filesystem::path p = dir ("analysis"); + auto p = dir ("analysis"); Digester digester; digester.add (content->digest()); + digester.add(_interop ? "1" : "0"); if (!content->text.empty()) { - shared_ptr tc = content->text.front(); + auto tc = content->text.front(); digester.add (tc->x_scale()); digester.add (tc->y_scale()); - BOOST_FOREACH (shared_ptr i, tc->fonts()) { + for (auto i: tc->fonts()) { digester.add (i->id()); } if (tc->effect()) { @@ -339,7 +356,7 @@ Film::subtitle_analysis_path (shared_ptr content) const digester.add (tc->outline_width()); } - shared_ptr fc = dynamic_pointer_cast(content); + auto fc = dynamic_pointer_cast(content); if (fc) { digester.add (fc->subtitle_stream()->identifier()); } @@ -349,92 +366,23 @@ Film::subtitle_analysis_path (shared_ptr content) const } -/** Add suitable Jobs to the JobManager to create a DCP for this Film. - * @param gui true if this is being called from a GUI tool. - * @param check true to check the content in the project for changes before making the DCP. - */ -void -Film::make_dcp (bool gui, bool check) -{ - if (dcp_name().find ("/") != string::npos) { - throw BadSettingError (_("name"), _("Cannot contain slashes")); - } - - if (container() == 0) { - throw MissingSettingError (_("container")); - } - - if (content().empty()) { - throw runtime_error (_("You must add some content to the DCP before creating it")); - } - - if (length() == DCPTime()) { - throw runtime_error (_("The DCP is empty, perhaps because all the content has zero length.")); - } - - if (dcp_content_type() == 0) { - throw MissingSettingError (_("content type")); - } - - if (name().empty()) { - set_name ("DCP"); - } - - BOOST_FOREACH (shared_ptr i, content ()) { - if (!i->paths_valid()) { - throw runtime_error (_("some of your content is missing")); - } - shared_ptr dcp = dynamic_pointer_cast (i); - if (dcp && dcp->needs_kdm()) { - throw runtime_error (_("Some of your content needs a KDM")); - } - if (dcp && dcp->needs_assets()) { - throw runtime_error (_("Some of your content needs an OV")); - } - } - - set_isdcf_date_today (); - - BOOST_FOREACH (string i, environment_info ()) { - LOG_GENERAL_NC (i); - } - - BOOST_FOREACH (shared_ptr i, content ()) { - LOG_GENERAL ("Content: %1", i->technical_summary()); - } - LOG_GENERAL ("DCP video rate %1 fps", video_frame_rate()); - if (Config::instance()->only_servers_encode ()) { - LOG_GENERAL_NC ("0 threads: ONLY SERVERS SET TO ENCODE"); - } else { - LOG_GENERAL ("%1 threads", Config::instance()->master_encoding_threads()); - } - LOG_GENERAL ("J2K bandwidth %1", j2k_bandwidth()); - - shared_ptr tj (new TranscodeJob (shared_from_this())); - tj->set_encoder (shared_ptr (new DCPEncoder (shared_from_this(), tj))); - if (check) { - shared_ptr cc (new CheckContentChangeJob(shared_from_this(), tj, gui)); - JobManager::instance()->add (cc); - } else { - JobManager::instance()->add (tj); - } -} - /** Start a job to send our DCP to the configured TMS */ void Film::send_dcp_to_tms () { - shared_ptr j (new UploadJob (shared_from_this())); - JobManager::instance()->add (j); + JobManager::instance()->add(make_shared(shared_from_this())); } shared_ptr Film::metadata (bool with_content_paths) const { - shared_ptr doc (new xmlpp::Document); - xmlpp::Element* root = doc->create_root_node ("Metadata"); + auto doc = make_shared(); + auto root = doc->create_root_node ("Metadata"); root->add_child("Version")->add_child_text (raw_convert (current_state_version)); + auto last_write = root->add_child("LastWrittenBy"); + last_write->add_child_text (dcpomatic_version); + last_write->set_attribute("git", dcpomatic_git_commit); root->add_child("Name")->add_child_text (_name); root->add_child("UseISDCFName")->add_child_text (_use_isdcf_name ? "1" : "0"); @@ -448,13 +396,14 @@ Film::metadata (bool with_content_paths) const root->add_child("Resolution")->add_child_text (resolution_to_string (_resolution)); root->add_child("J2KBandwidth")->add_child_text (raw_convert (_j2k_bandwidth)); - _isdcf_metadata.as_xml (root->add_child ("ISDCFMetadata")); root->add_child("VideoFrameRate")->add_child_text (raw_convert (_video_frame_rate)); + root->add_child("AudioFrameRate")->add_child_text(raw_convert(_audio_frame_rate)); root->add_child("ISDCFDate")->add_child_text (boost::gregorian::to_iso_string (_isdcf_date)); root->add_child("AudioChannels")->add_child_text (raw_convert (_audio_channels)); root->add_child("ThreeD")->add_child_text (_three_d ? "1" : "0"); root->add_child("Sequence")->add_child_text (_sequence ? "1" : "0"); root->add_child("Interop")->add_child_text (_interop ? "1" : "0"); + root->add_child("LimitToSMPTEBv20")->add_child_text(_limit_to_smpte_bv20 ? "1" : "0"); root->add_child("Encrypted")->add_child_text (_encrypted ? "1" : "0"); root->add_child("Key")->add_child_text (_key.hex ()); root->add_child("ContextID")->add_child_text (_context_id); @@ -465,29 +414,52 @@ Film::metadata (bool with_content_paths) const root->add_child("ReelLength")->add_child_text (raw_convert (_reel_length)); root->add_child("ReencodeJ2K")->add_child_text (_reencode_j2k ? "1" : "0"); root->add_child("UserExplicitVideoFrameRate")->add_child_text(_user_explicit_video_frame_rate ? "1" : "0"); - for (map::const_iterator i = _markers.begin(); i != _markers.end(); ++i) { - xmlpp::Element* m = root->add_child("Marker"); - m->set_attribute("Type", dcp::marker_to_string(i->first)); - m->add_child_text(raw_convert(i->second.get())); + for (auto const& marker: _markers) { + auto m = root->add_child("Marker"); + m->set_attribute("Type", dcp::marker_to_string(marker.first)); + m->add_child_text(raw_convert(marker.second.get())); } - BOOST_FOREACH (dcp::Rating i, _ratings) { + for (auto i: _ratings) { i.as_xml (root->add_child("Rating")); } - BOOST_FOREACH (string i, _content_versions) { + for (auto i: _content_versions) { root->add_child("ContentVersion")->add_child_text(i); } root->add_child("NameLanguage")->add_child_text(_name_language.to_string()); - root->add_child("AudioLanguage")->add_child_text(_audio_language.to_string()); - root->add_child("ReleaseTerritory")->add_child_text(_release_territory.subtag()); + root->add_child("TerritoryType")->add_child_text(territory_type_to_string(_territory_type)); + if (_release_territory) { + root->add_child("ReleaseTerritory")->add_child_text(_release_territory->subtag()); + } + if (_sign_language_video_language) { + root->add_child("SignLanguageVideoLanguage")->add_child_text(_sign_language_video_language->to_string()); + } root->add_child("VersionNumber")->add_child_text(raw_convert(_version_number)); root->add_child("Status")->add_child_text(dcp::status_to_string(_status)); - root->add_child("Chain")->add_child_text(_chain); - root->add_child("Distributor")->add_child_text(_distributor); - root->add_child("Facility")->add_child_text(_facility); - root->add_child("LuminanceValue")->add_child_text(raw_convert(_luminance.value())); - root->add_child("LuminanceUnit")->add_child_text(dcp::Luminance::unit_to_string(_luminance.unit())); + if (_chain) { + root->add_child("Chain")->add_child_text(*_chain); + } + if (_distributor) { + root->add_child("Distributor")->add_child_text(*_distributor); + } + if (_facility) { + root->add_child("Facility")->add_child_text(*_facility); + } + if (_studio) { + root->add_child("Studio")->add_child_text(*_studio); + } + root->add_child("TempVersion")->add_child_text(_temp_version ? "1" : "0"); + root->add_child("PreRelease")->add_child_text(_pre_release ? "1" : "0"); + root->add_child("RedBand")->add_child_text(_red_band ? "1" : "0"); + root->add_child("TwoDVersionOfThreeD")->add_child_text(_two_d_version_of_three_d ? "1" : "0"); + if (_luminance) { + root->add_child("LuminanceValue")->add_child_text(raw_convert(_luminance->value())); + root->add_child("LuminanceUnit")->add_child_text(dcp::Luminance::unit_to_string(_luminance->unit())); + } root->add_child("UserExplicitContainer")->add_child_text(_user_explicit_container ? "1" : "0"); root->add_child("UserExplicitResolution")->add_child_text(_user_explicit_resolution ? "1" : "0"); + if (_audio_language) { + root->add_child("AudioLanguage")->add_child_text(_audio_language->to_string()); + } _playlist->as_xml (root->add_child ("Playlist"), with_content_paths); return doc; @@ -496,28 +468,31 @@ Film::metadata (bool with_content_paths) const void Film::write_metadata (boost::filesystem::path path) const { - shared_ptr doc = metadata (); - doc->write_to_file_formatted (path.string()); + metadata()->write_to_file_formatted(path.string()); } /** Write state to our `metadata' file */ void -Film::write_metadata () const +Film::write_metadata () { DCPOMATIC_ASSERT (directory()); - boost::filesystem::create_directories (directory().get()); - shared_ptr doc = metadata (); - doc->write_to_file_formatted (file(metadata_file).string ()); - _dirty = false; + dcp::filesystem::create_directories(directory().get()); + auto const filename = file(metadata_file); + try { + metadata()->write_to_file_formatted(filename.string()); + } catch (xmlpp::exception& e) { + throw FileError(String::compose("Could not write metadata file (%1)", e.what()), filename); + } + set_dirty (false); } /** Write a template from this film */ void Film::write_template (boost::filesystem::path path) const { - boost::filesystem::create_directories (path.parent_path()); + dcp::filesystem::create_directories(path.parent_path()); shared_ptr doc = metadata (false); - doc->write_to_file_formatted (path.string ()); + metadata(false)->write_to_file_formatted(path.string()); } /** Read state from our metadata file. @@ -527,56 +502,56 @@ list Film::read_metadata (optional path) { if (!path) { - if (boost::filesystem::exists (file ("metadata")) && !boost::filesystem::exists (file (metadata_file))) { + if (dcp::filesystem::exists(file("metadata")) && !dcp::filesystem::exists(file(metadata_file))) { throw runtime_error (_("This film was created with an older version of DCP-o-matic, and unfortunately it cannot be loaded into this version. You will need to create a new Film, re-add your content and set it up again. Sorry!")); } path = file (metadata_file); } - if (!boost::filesystem::exists(*path)) { + if (!dcp::filesystem::exists(*path)) { throw FileNotFoundError(*path); } cxml::Document f ("Metadata"); - f.read_file (path.get ()); + f.read_file(dcp::filesystem::fix_long_path(path.get())); _state_version = f.number_child ("Version"); if (_state_version > current_state_version) { throw runtime_error (_("This film was created with a newer version of DCP-o-matic, and it cannot be loaded into this version. Sorry!")); } else if (_state_version < current_state_version) { /* This is an older version; save a copy (if we haven't already) */ - boost::filesystem::path const older = path->parent_path() / String::compose("metadata.%1.xml", _state_version); - if (!boost::filesystem::is_regular_file(older)) { + auto const older = path->parent_path() / String::compose("metadata.%1.xml", _state_version); + if (!dcp::filesystem::is_regular_file(older)) { try { - boost::filesystem::copy_file(*path, older); + dcp::filesystem::copy_file(*path, older); } catch (...) { /* Never mind; at least we tried */ } } } + _last_written_by = f.optional_string_child("LastWrittenBy"); + _name = f.string_child ("Name"); if (_state_version >= 9) { _use_isdcf_name = f.bool_child ("UseISDCFName"); - _isdcf_metadata = ISDCFMetadata (f.node_child ("ISDCFMetadata")); _isdcf_date = boost::gregorian::from_undelimited_string (f.string_child ("ISDCFDate")); } else { _use_isdcf_name = f.bool_child ("UseDCIName"); - _isdcf_metadata = ISDCFMetadata (f.node_child ("DCIMetadata")); _isdcf_date = boost::gregorian::from_undelimited_string (f.string_child ("DCIDate")); } { - optional c = f.optional_string_child ("DCPContentType"); + auto c = f.optional_string_child("DCPContentType"); if (c) { _dcp_content_type = DCPContentType::from_isdcf_name (c.get ()); } } { - optional c = f.optional_string_child ("Container"); + auto c = f.optional_string_child("Container"); if (c) { _container = Ratio::from_id (c.get ()); } @@ -585,6 +560,7 @@ Film::read_metadata (optional path) _resolution = string_to_resolution (f.string_child ("Resolution")); _j2k_bandwidth = f.number_child ("J2KBandwidth"); _video_frame_rate = f.number_child ("VideoFrameRate"); + _audio_frame_rate = f.optional_number_child("AudioFrameRate").get_value_or(48000); _encrypted = f.bool_child ("Encrypted"); _audio_channels = f.number_child ("AudioChannels"); /* We used to allow odd numbers (and zero) channels, but it's just not worth @@ -604,6 +580,7 @@ Film::read_metadata (optional path) _three_d = f.bool_child ("ThreeD"); _interop = f.bool_child ("Interop"); + _limit_to_smpte_bv20 = f.optional_bool_child("LimitToSMPTEBv20").get_value_or(false); _key = dcp::Key (f.string_child ("Key")); _context_id = f.optional_string_child("ContextID").get_value_or (dcp::make_uuid ()); @@ -614,63 +591,115 @@ Film::read_metadata (optional path) } if (_audio_processor && !Config::instance()->show_experimental_audio_processors()) { - list ap = AudioProcessor::visible(); + auto ap = AudioProcessor::visible(); if (find(ap.begin(), ap.end(), _audio_processor) == ap.end()) { Config::instance()->set_show_experimental_audio_processors(true); } } - _reel_type = static_cast (f.optional_number_child("ReelType").get_value_or (static_cast(REELTYPE_SINGLE))); + _reel_type = static_cast (f.optional_number_child("ReelType").get_value_or (static_cast(ReelType::SINGLE))); _reel_length = f.optional_number_child("ReelLength").get_value_or (2000000000); _reencode_j2k = f.optional_bool_child("ReencodeJ2K").get_value_or(false); _user_explicit_video_frame_rate = f.optional_bool_child("UserExplicitVideoFrameRate").get_value_or(false); - BOOST_FOREACH (cxml::ConstNodePtr i, f.node_children("Marker")) { + for (auto i: f.node_children("Marker")) { _markers[dcp::marker_from_string(i->string_attribute("Type"))] = DCPTime(dcp::raw_convert(i->content())); } - BOOST_FOREACH (cxml::ConstNodePtr i, f.node_children("Rating")) { + for (auto i: f.node_children("Rating")) { _ratings.push_back (dcp::Rating(i)); } - BOOST_FOREACH (cxml::ConstNodePtr i, f.node_children("ContentVersion")) { + for (auto i: f.node_children("ContentVersion")) { _content_versions.push_back (i->content()); } - optional name_language = f.optional_string_child("NameLanguage"); + auto name_language = f.optional_string_child("NameLanguage"); if (name_language) { _name_language = dcp::LanguageTag (*name_language); } - optional audio_language = f.optional_string_child("AudioLanguage"); - if (audio_language) { - _audio_language = dcp::LanguageTag (*audio_language); + auto territory_type = f.optional_string_child("TerritoryType"); + if (territory_type) { + _territory_type = string_to_territory_type(*territory_type); } - optional release_territory = f.optional_string_child("ReleaseTerritory"); + auto release_territory = f.optional_string_child("ReleaseTerritory"); if (release_territory) { _release_territory = dcp::LanguageTag::RegionSubtag (*release_territory); } - _version_number = f.optional_number_child("VersionNumber").get_value_or(0); + auto sign_language_video_language = f.optional_string_child("SignLanguageVideoLanguage"); + if (sign_language_video_language) { + _sign_language_video_language = dcp::LanguageTag(*sign_language_video_language); + } + + _version_number = f.optional_number_child("VersionNumber").get_value_or(1); - optional status = f.optional_string_child("Status"); + auto status = f.optional_string_child("Status"); if (status) { _status = dcp::string_to_status (*status); } - _chain = f.optional_string_child("Chain").get_value_or(""); - _distributor = f.optional_string_child("Distributor").get_value_or(""); - _facility = f.optional_string_child("Facility").get_value_or(""); + _chain = f.optional_string_child("Chain"); + _distributor = f.optional_string_child("Distributor"); + _facility = f.optional_string_child("Facility"); + _studio = f.optional_string_child("Studio"); + _temp_version = f.optional_bool_child("TempVersion").get_value_or(false); + _pre_release = f.optional_bool_child("PreRelease").get_value_or(false); + _red_band = f.optional_bool_child("RedBand").get_value_or(false); + _two_d_version_of_three_d = f.optional_bool_child("TwoDVersionOfThreeD").get_value_or(false); - float value = f.optional_number_child("LuminanceValue").get_value_or(4.5); - optional unit = f.optional_string_child("LuminanceUnit"); - if (unit) { - _luminance = dcp::Luminance (value, dcp::Luminance::string_to_unit(*unit)); + auto value = f.optional_number_child("LuminanceValue"); + auto unit = f.optional_string_child("LuminanceUnit"); + if (value && unit) { + _luminance = dcp::Luminance (*value, dcp::Luminance::string_to_unit(*unit)); } /* Disable guessing for files made in previous DCP-o-matic versions */ _user_explicit_container = f.optional_bool_child("UserExplicitContainer").get_value_or(true); _user_explicit_resolution = f.optional_bool_child("UserExplicitResolution").get_value_or(true); + auto audio_language = f.optional_string_child("AudioLanguage"); + if (audio_language) { + _audio_language = dcp::LanguageTag(*audio_language); + } + + /* Read the old ISDCFMetadata tag from 2.14.x metadata */ + auto isdcf = f.optional_node_child("ISDCFMetadata"); + if (isdcf) { + if (auto territory = isdcf->optional_string_child("Territory")) { + try { + _release_territory = dcp::LanguageTag::RegionSubtag(*territory); + } catch (...) { + /* Invalid region subtag; just ignore it */ + } + } + if (auto audio_language = isdcf->optional_string_child("AudioLanguage")) { + try { + _audio_language = dcp::LanguageTag(*audio_language); + } catch (...) { + /* Invalid language tag; just ignore it */ + } + } + if (auto content_version = isdcf->optional_string_child("ContentVersion")) { + _content_versions.push_back (*content_version); + } + if (auto rating = isdcf->optional_string_child("Rating")) { + _ratings.push_back (dcp::Rating("", *rating)); + } + if (auto mastered_luminance = isdcf->optional_number_child("MasteredLuminance")) { + if (*mastered_luminance > 0) { + _luminance = dcp::Luminance(*mastered_luminance, dcp::Luminance::Unit::FOOT_LAMBERT); + } + } + _studio = isdcf->optional_string_child("Studio"); + _facility = isdcf->optional_string_child("Facility"); + _temp_version = isdcf->optional_bool_child("TempVersion").get_value_or(false); + _pre_release = isdcf->optional_bool_child("PreRelease").get_value_or(false); + _red_band = isdcf->optional_bool_child("RedBand").get_value_or(false); + _two_d_version_of_three_d = isdcf->optional_bool_child("TwoDVersionOfThreeD").get_value_or(false); + _chain = isdcf->optional_string_child("Chain"); + } + list notes; _playlist->set_from_xml (shared_from_this(), f.node_child ("Playlist"), _state_version, notes); @@ -679,7 +708,7 @@ Film::read_metadata (optional path) set_backtrace_file (file ("backtrace.txt")); } - _dirty = false; + set_dirty (false); return notes; } @@ -697,7 +726,7 @@ Film::dir (boost::filesystem::path d, bool create) const p /= d; if (create) { - boost::filesystem::create_directories (p); + dcp::filesystem::create_directories(p); } return p; @@ -715,7 +744,7 @@ Film::file (boost::filesystem::path f) const p /= _directory.get(); p /= f; - boost::filesystem::create_directories (p.parent_path ()); + dcp::filesystem::create_directories(p.parent_path()); return p; } @@ -731,10 +760,10 @@ Film::mapped_audio_channels () const mapped.push_back (i); } } else { - BOOST_FOREACH (shared_ptr i, content ()) { + for (auto i: content()) { if (i->audio) { - list c = i->audio->mapping().mapped_output_channels (); - copy (c.begin(), c.end(), back_inserter (mapped)); + auto c = i->audio->mapping().mapped_output_channels(); + copy (c.begin(), c.end(), back_inserter(mapped)); } } @@ -745,13 +774,72 @@ Film::mapped_audio_channels () const return mapped; } + +pair, vector> +Film::subtitle_languages(bool* burnt_in) const +{ + if (burnt_in) { + *burnt_in = true; + } + + pair, vector> result; + for (auto i: content()) { + auto dcp = dynamic_pointer_cast(i); + for (auto const& text: i->text) { + auto const use = text->use() || (dcp && dcp->reference_text(TextType::OPEN_SUBTITLE)); + if (use && text->type() == TextType::OPEN_SUBTITLE) { + if (!text->burn() && burnt_in) { + *burnt_in = false; + } + if (text->language()) { + if (text->language_is_additional()) { + result.second.push_back(text->language().get()); + } else { + result.first = text->language().get(); + } + } + } + } + if (i->video && i->video->burnt_subtitle_language()) { + result.first = i->video->burnt_subtitle_language(); + } + } + + std::sort (result.second.begin(), result.second.end()); + auto last = std::unique (result.second.begin(), result.second.end()); + result.second.erase (last, result.second.end()); + return result; +} + + +vector +Film::closed_caption_languages() const +{ + vector result; + for (auto i: content()) { + for (auto text: i->text) { + if (text->use() && text->type() == TextType::CLOSED_CAPTION && text->dcp_track() && text->dcp_track()->language) { + result.push_back(*text->dcp_track()->language); + } + } + } + + return result; +} + + /** @return a ISDCF-compliant name for a DCP of this film */ string Film::isdcf_name (bool if_created_now) const { - string d; + string isdcf_name; + + auto raw_name = name (); - string raw_name = name (); + auto to_upper = [](string s) { + transform(s.begin(), s.end(), s.begin(), ::toupper); + return s; + }; /* Split the raw name up into words */ vector words; @@ -760,16 +848,16 @@ Film::isdcf_name (bool if_created_now) const string fixed_name; /* Add each word to fixed_name */ - for (vector::const_iterator i = words.begin(); i != words.end(); ++i) { - string w = *i; + for (auto i: words) { + string w = i; /* First letter is always capitalised */ w[0] = toupper (w[0]); /* Count caps in w */ size_t caps = 0; - for (size_t i = 0; i < w.size(); ++i) { - if (isupper (w[i])) { + for (size_t j = 0; j < w.size(); ++j) { + if (isupper (w[j])) { ++caps; } } @@ -778,211 +866,215 @@ Film::isdcf_name (bool if_created_now) const leave it alone. */ if (caps == w.size ()) { - for (size_t i = 1; i < w.size(); ++i) { - w[i] = tolower (w[i]); + for (size_t j = 1; j < w.size(); ++j) { + w[j] = tolower (w[j]); } } - for (size_t i = 0; i < w.size(); ++i) { - fixed_name += w[i]; + for (size_t j = 0; j < w.size(); ++j) { + fixed_name += w[j]; } } - if (fixed_name.length() > 14) { - fixed_name = fixed_name.substr (0, 14); - } + fixed_name = fixed_name.substr(0, Config::instance()->isdcf_name_part_length()); - d += fixed_name; + isdcf_name += fixed_name; if (dcp_content_type()) { - d += "_" + dcp_content_type()->isdcf_name(); - d += "-" + raw_convert(isdcf_metadata().content_version); + isdcf_name += "_" + dcp_content_type()->isdcf_name(); + string version = "1"; + if (_interop) { + if (!_content_versions.empty()) { + auto cv = _content_versions[0]; + if (!cv.empty() && std::all_of(cv.begin(), cv.end(), isdigit)) { + version = cv; + } + } + } else { + version = dcp::raw_convert(_version_number); + } + isdcf_name += "-" + version; } - ISDCFMetadata const dm = isdcf_metadata (); - - if (dm.temp_version) { - d += "-Temp"; + if (_temp_version) { + isdcf_name += "-Temp"; } - if (dm.pre_release) { - d += "-Pre"; + if (_pre_release) { + isdcf_name += "-Pre"; } - if (dm.red_band) { - d += "-RedBand"; + if (_red_band) { + isdcf_name += "-RedBand"; } - if (!dm.chain.empty ()) { - d += "-" + dm.chain; + if (_chain && !_chain->empty()) { + isdcf_name += "-" + *_chain; } if (three_d ()) { - d += "-3D"; + isdcf_name += "-3D"; } - if (dm.two_d_version_of_three_d) { - d += "-2D"; + if (_two_d_version_of_three_d) { + isdcf_name += "-2D"; } - if (!dm.mastered_luminance.empty ()) { - d += "-" + dm.mastered_luminance; + if (_luminance) { + auto fl = _luminance->value_in_foot_lamberts(); + char buffer[64]; + snprintf (buffer, sizeof(buffer), "%.1f", fl); + isdcf_name += String::compose("-%1fl", buffer); } if (video_frame_rate() != 24) { - d += "-" + raw_convert(video_frame_rate()); + isdcf_name += "-" + raw_convert(video_frame_rate()); } if (container()) { - d += "_" + container()->isdcf_name(); + isdcf_name += "_" + container()->isdcf_name(); } + auto content_list = content(); + /* XXX: this uses the first bit of content only */ /* Interior aspect ratio. The standard says we don't do this for trailers, for some strange reason */ - if (dcp_content_type() && dcp_content_type()->libdcp_kind() != dcp::TRAILER) { - Ratio const * content_ratio = 0; - BOOST_FOREACH (shared_ptr i, content ()) { - if (i->video) { - /* Here's the first piece of video content */ - content_ratio = Ratio::nearest_from_ratio(i->video->scaled_size(frame_size()).ratio()); - break; + if (dcp_content_type() && dcp_content_type()->libdcp_kind() != dcp::ContentKind::TRAILER) { + auto first_video = std::find_if(content_list.begin(), content_list.end(), [](shared_ptr c) { return static_cast(c->video); }); + if (first_video != content_list.end()) { + if (auto scaled_size = (*first_video)->video->scaled_size(frame_size())) { + auto first_ratio = lrintf(scaled_size->ratio() * 100); + auto container_ratio = lrintf(container()->ratio() * 100); + if (first_ratio != container_ratio) { + isdcf_name += "-" + dcp::raw_convert(first_ratio); + } } } - - if (content_ratio && content_ratio != container()) { - /* This needs to be the numeric version of the ratio, and ::id() is close enough */ - d += "-" + content_ratio->id(); - } } - if (!dm.audio_language.empty ()) { - d += "_" + dm.audio_language; - - /* I'm not clear on the precise details of the convention for CCAP labelling; - for now I'm just appending -CCAP if we have any closed captions. - */ - - optional subtitle_language; - bool burnt_in = true; - bool ccap = false; - BOOST_FOREACH (shared_ptr i, content()) { - BOOST_FOREACH (shared_ptr j, i->text) { - if (j->type() == TEXT_OPEN_SUBTITLE && j->use()) { - subtitle_language = j->language (); - if (!j->burn()) { - burnt_in = false; - } - } else if (j->type() == TEXT_CLOSED_CAPTION && j->use()) { - ccap = true; - } + auto entry_for_language = [](dcp::LanguageTag const& tag) { + /* Look up what we should be using for this tag in the DCNC name */ + for (auto const& dcnc: dcp::dcnc_tags()) { + if (tag.to_string() == dcnc.first) { + return dcnc.second; } } + /* Fallback to the language subtag, if there is one */ + return tag.language() ? tag.language()->subtag() : "XX"; + }; - if (dm.subtitle_language) { - /* Subtitle language is overridden in ISDCF metadata, primarily to handle - content with pre-burnt subtitles. - */ - d += "-" + *dm.subtitle_language; - if (ccap) { - d += "-CCAP"; - } - } else if (subtitle_language) { - /* Language is worked out from the content */ - if (burnt_in && *subtitle_language != "XX") { - transform (subtitle_language->begin(), subtitle_language->end(), subtitle_language->begin(), ::tolower); - } else { - transform (subtitle_language->begin(), subtitle_language->end(), subtitle_language->begin(), ::toupper); - } + auto audio_language = _audio_language ? entry_for_language(*_audio_language) : "XX"; - d += "-" + *subtitle_language; - if (ccap) { - d += "-CCAP"; - } + isdcf_name += "_" + to_upper (audio_language); + + bool burnt_in; + auto sub_langs = subtitle_languages(&burnt_in); + auto ccap_langs = closed_caption_languages(); + if (sub_langs.first && sub_langs.first->language()) { + auto lang = entry_for_language(*sub_langs.first); + if (burnt_in) { + transform (lang.begin(), lang.end(), lang.begin(), ::tolower); } else { - /* No subtitles */ - d += "-XX"; + lang = to_upper (lang); } - } - if (!dm.territory.empty ()) { - d += "_" + dm.territory; - if (dm.rating.empty ()) { - d += "-NR"; - } else { - d += "-" + dm.rating; + isdcf_name += "-" + lang; + } else if (!ccap_langs.empty()) { + isdcf_name += "-" + to_upper(entry_for_language(ccap_langs[0])) + "-CCAP"; + } else { + /* No subtitles */ + isdcf_name += "-XX"; + } + + if (_territory_type == TerritoryType::INTERNATIONAL_TEXTED) { + isdcf_name += "_INT-TD"; + } else if (_territory_type == TerritoryType::INTERNATIONAL_TEXTLESS) { + isdcf_name += "_INT-TL"; + } else if (_release_territory) { + auto territory = _release_territory->subtag(); + isdcf_name += "_" + to_upper (territory); + if (!_ratings.empty()) { + auto label = _ratings[0].label; + boost::erase_all(label, "+"); + boost::erase_all(label, "-"); + isdcf_name += "-" + label; } } /* Count mapped audio channels */ - list mapped = mapped_audio_channels (); + auto mapped = mapped_audio_channels (); - pair ch = audio_channel_types (mapped, audio_channels()); + auto ch = audio_channel_types (mapped, audio_channels()); if (!ch.first && !ch.second) { - d += "_MOS"; + isdcf_name += "_MOS"; } else if (ch.first) { - d += String::compose("_%1%2", ch.first, ch.second); + isdcf_name += String::compose("_%1%2", ch.first, ch.second); } - if (audio_channels() > static_cast(dcp::HI) && find(mapped.begin(), mapped.end(), dcp::HI) != mapped.end()) { - d += "-HI"; + if (audio_channels() > static_cast(dcp::Channel::HI) && find(mapped.begin(), mapped.end(), static_cast(dcp::Channel::HI)) != mapped.end()) { + isdcf_name += "-HI"; + } + if (audio_channels() > static_cast(dcp::Channel::VI) && find(mapped.begin(), mapped.end(), static_cast(dcp::Channel::VI)) != mapped.end()) { + isdcf_name += "-VI"; } - if (audio_channels() > static_cast(dcp::VI) && find(mapped.begin(), mapped.end(), dcp::VI) != mapped.end()) { - d += "-VI"; + + if (find_if(content_list.begin(), content_list.end(), [](shared_ptr c) { return static_cast(c->atmos); }) != content_list.end()) { + isdcf_name += "-IAB"; } - d += "_" + resolution_to_string (_resolution); + isdcf_name += "_" + resolution_to_string (_resolution); - if (!dm.studio.empty ()) { - d += "_" + dm.studio; + if (_studio && _studio->length() >= 2) { + isdcf_name += "_" + to_upper (_studio->substr(0, 4)); } if (if_created_now) { - d += "_" + boost::gregorian::to_iso_string (boost::gregorian::day_clock::local_day ()); + isdcf_name += "_" + boost::gregorian::to_iso_string (boost::gregorian::day_clock::local_day ()); } else { - d += "_" + boost::gregorian::to_iso_string (_isdcf_date); + isdcf_name += "_" + boost::gregorian::to_iso_string (_isdcf_date); } - if (!dm.facility.empty ()) { - d += "_" + dm.facility; + if (_facility && _facility->length() >= 3) { + isdcf_name += "_" + to_upper(_facility->substr(0, 3)); } if (_interop) { - d += "_IOP"; + isdcf_name += "_IOP"; } else { - d += "_SMPTE"; + isdcf_name += "_SMPTE"; } if (three_d ()) { - d += "-3D"; + isdcf_name += "-3D"; } - bool vf = false; - BOOST_FOREACH (shared_ptr i, content ()) { - shared_ptr dc = dynamic_pointer_cast (i); - if (!dc) { + auto vf = false; + for (auto content: content_list) { + auto dcp = dynamic_pointer_cast(content); + if (!dcp) { continue; } bool any_text = false; - for (int i = 0; i < TEXT_COUNT; ++i) { - if (dc->reference_text(static_cast(i))) { + for (int i = 0; i < static_cast(TextType::COUNT); ++i) { + if (dcp->reference_text(static_cast(i))) { any_text = true; } } - if (dc->reference_video() || dc->reference_audio() || any_text) { + if (dcp->reference_video() || dcp->reference_audio() || any_text) { vf = true; } } if (vf) { - d += "_VF"; + isdcf_name += "_VF"; } else { - d += "_OV"; + isdcf_name += "_OV"; } - return d; + return isdcf_name; } /** @return name to give the DCP */ @@ -1001,27 +1093,27 @@ void Film::set_directory (boost::filesystem::path d) { _directory = d; - _dirty = true; + set_dirty (true); } void Film::set_name (string n) { - ChangeSignaller ch (this, NAME); + FilmChangeSignaller ch(this, FilmProperty::NAME); _name = n; } void Film::set_use_isdcf_name (bool u) { - ChangeSignaller ch (this, USE_ISDCF_NAME); + FilmChangeSignaller ch(this, FilmProperty::USE_ISDCF_NAME); _use_isdcf_name = u; } void Film::set_dcp_content_type (DCPContentType const * t) { - ChangeSignaller ch (this, DCP_CONTENT_TYPE); + FilmChangeSignaller ch(this, FilmProperty::DCP_CONTENT_TYPE); _dcp_content_type = t; } @@ -1033,7 +1125,7 @@ Film::set_dcp_content_type (DCPContentType const * t) void Film::set_container (Ratio const * c, bool explicit_user) { - ChangeSignaller ch (this, CONTAINER); + FilmChangeSignaller ch(this, FilmProperty::CONTAINER); _container = c; if (explicit_user) { @@ -1049,7 +1141,7 @@ Film::set_container (Ratio const * c, bool explicit_user) void Film::set_resolution (Resolution r, bool explicit_user) { - ChangeSignaller ch (this, RESOLUTION); + FilmChangeSignaller ch(this, FilmProperty::RESOLUTION); _resolution = r; if (explicit_user) { @@ -1061,17 +1153,10 @@ Film::set_resolution (Resolution r, bool explicit_user) void Film::set_j2k_bandwidth (int b) { - ChangeSignaller ch (this, J2K_BANDWIDTH); + FilmChangeSignaller ch(this, FilmProperty::J2K_BANDWIDTH); _j2k_bandwidth = b; } -void -Film::set_isdcf_metadata (ISDCFMetadata m) -{ - ChangeSignaller ch (this, ISDCF_METADATA); - _isdcf_metadata = m; -} - /** @param f New frame rate. * @param user_explicit true if this comes from a direct user instruction, false if it is from * DCP-o-matic being helpful. @@ -1079,7 +1164,7 @@ Film::set_isdcf_metadata (ISDCFMetadata m) void Film::set_video_frame_rate (int f, bool user_explicit) { - ChangeSignaller ch (this, VIDEO_FRAME_RATE); + FilmChangeSignaller ch(this, FilmProperty::VIDEO_FRAME_RATE); _video_frame_rate = f; if (user_explicit) { _user_explicit_video_frame_rate = true; @@ -1089,41 +1174,49 @@ Film::set_video_frame_rate (int f, bool user_explicit) void Film::set_audio_channels (int c) { - ChangeSignaller ch (this, AUDIO_CHANNELS); + FilmChangeSignaller ch(this, FilmProperty::AUDIO_CHANNELS); _audio_channels = c; } void Film::set_three_d (bool t) { - ChangeSignaller ch (this, THREE_D); + FilmChangeSignaller ch(this, FilmProperty::THREE_D); _three_d = t; - if (_three_d && _isdcf_metadata.two_d_version_of_three_d) { - ChangeSignaller ch (this, ISDCF_METADATA); - _isdcf_metadata.two_d_version_of_three_d = false; + if (_three_d && _two_d_version_of_three_d) { + set_two_d_version_of_three_d (false); } } void Film::set_interop (bool i) { - ChangeSignaller ch (this, INTEROP); + FilmChangeSignaller ch(this, FilmProperty::INTEROP); _interop = i; } + +void +Film::set_limit_to_smpte_bv20(bool limit) +{ + FilmChangeSignaller ch(this, FilmProperty::LIMIT_TO_SMPTE_BV20); + _limit_to_smpte_bv20 = limit; +} + + void Film::set_audio_processor (AudioProcessor const * processor) { - ChangeSignaller ch1 (this, AUDIO_PROCESSOR); - ChangeSignaller ch2 (this, AUDIO_CHANNELS); + FilmChangeSignaller ch1(this, FilmProperty::AUDIO_PROCESSOR); + FilmChangeSignaller ch2(this, FilmProperty::AUDIO_CHANNELS); _audio_processor = processor; } void Film::set_reel_type (ReelType t) { - ChangeSignaller ch (this, REEL_TYPE); + FilmChangeSignaller ch(this, FilmProperty::REEL_TYPE); _reel_type = t; } @@ -1131,30 +1224,30 @@ Film::set_reel_type (ReelType t) void Film::set_reel_length (int64_t r) { - ChangeSignaller ch (this, REEL_LENGTH); + FilmChangeSignaller ch(this, FilmProperty::REEL_LENGTH); _reel_length = r; } void Film::set_reencode_j2k (bool r) { - ChangeSignaller ch (this, REENCODE_J2K); + FilmChangeSignaller ch(this, FilmProperty::REENCODE_J2K); _reencode_j2k = r; } void Film::signal_change (ChangeType type, int p) { - signal_change (type, static_cast(p)); + signal_change(type, static_cast(p)); } void -Film::signal_change (ChangeType type, Property p) +Film::signal_change(ChangeType type, FilmProperty p) { - if (type == CHANGE_TYPE_DONE) { - _dirty = true; + if (type == ChangeType::DONE) { + set_dirty (true); - if (p == Film::CONTENT) { + if (p == FilmProperty::CONTENT) { if (!_user_explicit_video_frame_rate) { set_video_frame_rate (best_video_frame_rate()); } @@ -1162,7 +1255,7 @@ Film::signal_change (ChangeType type, Property p) emit (boost::bind (boost::ref (Change), type, p)); - if (p == Film::VIDEO_FRAME_RATE || p == Film::SEQUENCE) { + if (p == FilmProperty::VIDEO_FRAME_RATE || p == FilmProperty::SEQUENCE) { /* We want to call Playlist::maybe_sequence but this must happen after the main signal emission (since the butler will see that emission and un-suspend itself). */ @@ -1179,6 +1272,7 @@ Film::set_isdcf_date_today () _isdcf_date = boost::gregorian::day_clock::local_day (); } + boost::filesystem::path Film::j2c_path (int reel, Frame frame, Eyes eyes, bool tmp) const { @@ -1190,9 +1284,9 @@ Film::j2c_path (int reel, Frame frame, Eyes eyes, bool tmp) const snprintf(buffer, sizeof(buffer), "%08d_%08" PRId64, reel, frame); string s (buffer); - if (eyes == EYES_LEFT) { + if (eyes == Eyes::LEFT) { s += ".L"; - } else if (eyes == EYES_RIGHT) { + } else if (eyes == Eyes::RIGHT) { s += ".R"; } @@ -1206,12 +1300,6 @@ Film::j2c_path (int reel, Frame frame, Eyes eyes, bool tmp) const return file (p); } -static -bool -cpl_summary_compare (CPLSummary const & a, CPLSummary const & b) -{ - return a.last_write_time > b.last_write_time; -} /** Find all the DCPs in our directory that can be dcp::DCP::read() and return details of their CPLs. * The list will be returned in reverse order of timestamp (i.e. most recent first). @@ -1220,27 +1308,29 @@ vector Film::cpls () const { if (!directory ()) { - return vector (); + return {}; } vector out; - boost::filesystem::path const dir = directory().get(); - for (boost::filesystem::directory_iterator i = boost::filesystem::directory_iterator(dir); i != boost::filesystem::directory_iterator(); ++i) { + auto const dir = directory().get(); + for (auto const& item: dcp::filesystem::directory_iterator(dir)) { if ( - boost::filesystem::is_directory (*i) && - i->path().leaf() != "j2c" && i->path().leaf() != "video" && i->path().leaf() != "info" && i->path().leaf() != "analysis" + dcp::filesystem::is_directory(item) && + item.path().filename() != "j2c" && item.path().filename() != "video" && item.path().filename() != "info" && item.path().filename() != "analysis" ) { try { - out.push_back (CPLSummary(*i)); + out.push_back(CPLSummary(item)); } catch (...) { } } } - sort (out.begin(), out.end(), cpl_summary_compare); + sort(out.begin(), out.end(), [](CPLSummary const& a, CPLSummary const& b) { + return a.last_write_time > b.last_write_time; + }); return out; } @@ -1248,7 +1338,7 @@ Film::cpls () const void Film::set_encrypted (bool e) { - ChangeSignaller ch (this, ENCRYPTED); + FilmChangeSignaller ch(this, FilmProperty::ENCRYPTED); _encrypted = e; } @@ -1268,7 +1358,7 @@ Film::examine_and_add_content (shared_ptr content, bool disable_audio_a run_ffprobe (content->path(0), file("ffprobe.log")); } - shared_ptr j (new ExamineContentJob (shared_from_this(), content)); + auto j = make_shared(shared_from_this(), content); _job_connections.push_back ( j->Finished.connect (bind (&Film::maybe_add_content, this, weak_ptr(j), weak_ptr(content), disable_audio_analysis)) @@ -1280,12 +1370,12 @@ Film::examine_and_add_content (shared_ptr content, bool disable_audio_a void Film::maybe_add_content (weak_ptr j, weak_ptr c, bool disable_audio_analysis) { - shared_ptr job = j.lock (); + auto job = j.lock (); if (!job || !job->finished_ok ()) { return; } - shared_ptr content = c.lock (); + auto content = c.lock (); if (!content) { return; } @@ -1293,7 +1383,7 @@ Film::maybe_add_content (weak_ptr j, weak_ptr c, bool disable_audi add_content (content); if (Config::instance()->automatic_audio_analysis() && content->audio && !disable_audio_analysis) { - shared_ptr playlist (new Playlist); + auto playlist = make_shared(); playlist->add (shared_from_this(), content); boost::signals2::connection c; JobManager::instance()->analyse_audio ( @@ -1315,7 +1405,7 @@ Film::add_content (shared_ptr c) if (_template_film) { /* Take settings from the first piece of content of c's type in _template */ - BOOST_FOREACH (shared_ptr i, _template_film->content()) { + for (auto i: _template_film->content()) { c->take_settings_from (i); } } @@ -1324,7 +1414,9 @@ Film::add_content (shared_ptr c) maybe_set_container_and_resolution (); if (c->atmos) { - set_audio_channels (14); + if (_audio_channels < 14) { + set_audio_channels(14); + } set_interop (false); } } @@ -1335,23 +1427,23 @@ Film::maybe_set_container_and_resolution () { /* Get the only piece of video content, if there is only one */ shared_ptr video; - BOOST_FOREACH (shared_ptr i, _playlist->content()) { - if (i->video) { + for (auto content: _playlist->content()) { + if (content->video) { if (!video) { - video = i->video; + video = content->video; } else { video.reset (); } } } - if (video) { + if (video && video->size()) { /* This is the only piece of video content in this Film. Use it to make a guess for * DCP container size and resolution, unless the user has already explicitly set these * things. */ if (!_user_explicit_container) { - if (video->size().ratio() > 2.3) { + if (video->size()->ratio() > 2.3) { set_container (Ratio::from_id("239"), false); } else { set_container (Ratio::from_id("185"), false); @@ -1359,10 +1451,10 @@ Film::maybe_set_container_and_resolution () } if (!_user_explicit_resolution) { - if (video->size_after_crop().width > 2048 || video->size_after_crop().height > 1080) { - set_resolution (RESOLUTION_4K, false); + if (video->size_after_crop()->width > 2048 || video->size_after_crop()->height > 1080) { + set_resolution (Resolution::FOUR_K, false); } else { - set_resolution (RESOLUTION_2K, false); + set_resolution (Resolution::TWO_K, false); } } } @@ -1400,7 +1492,7 @@ int Film::best_video_frame_rate () const { /* Don't default to anything above 30fps (make the user select that explicitly) */ - int best = _playlist->best_video_frame_rate (); + auto best = _playlist->best_video_frame_rate (); if (best > 30) { best /= 2; } @@ -1417,12 +1509,12 @@ void Film::playlist_content_change (ChangeType type, weak_ptr c, int p, bool frequent) { if (p == ContentProperty::VIDEO_FRAME_RATE) { - signal_change (type, Film::CONTENT); + signal_change(type, FilmProperty::CONTENT); } else if (p == AudioContentProperty::STREAMS) { - signal_change (type, Film::NAME); + signal_change(type, FilmProperty::NAME); } - if (type == CHANGE_TYPE_DONE) { + if (type == ChangeType::DONE) { emit (boost::bind (boost::ref (ContentChange), type, c, p, frequent)); if (!frequent) { check_settings_consistency (); @@ -1431,7 +1523,7 @@ Film::playlist_content_change (ChangeType type, weak_ptr c, int p, bool ContentChange (type, c, p, frequent); } - _dirty = true; + set_dirty (true); } void @@ -1443,14 +1535,14 @@ Film::playlist_length_change () void Film::playlist_change (ChangeType type) { - signal_change (type, CONTENT); - signal_change (type, NAME); + signal_change(type, FilmProperty::CONTENT); + signal_change(type, FilmProperty::NAME); - if (type == CHANGE_TYPE_DONE) { + if (type == ChangeType::DONE) { check_settings_consistency (); } - _dirty = true; + set_dirty (true); } /** Check for (and if necessary fix) impossible settings combinations, like @@ -1460,7 +1552,7 @@ void Film::check_settings_consistency () { optional atmos_rate; - BOOST_FOREACH (shared_ptr i, content()) { + for (auto i: content()) { if (i->atmos) { int rate = lrintf (i->atmos->edit_rate().as_float()); @@ -1475,8 +1567,8 @@ Film::check_settings_consistency () } bool change_made = false; - BOOST_FOREACH (shared_ptr i, content()) { - shared_ptr d = dynamic_pointer_cast(i); + for (auto i: content()) { + auto d = dynamic_pointer_cast(i); if (!d) { continue; } @@ -1490,6 +1582,14 @@ Film::check_settings_consistency () d->set_reference_audio(false); change_made = true; } + if (d->reference_text(TextType::OPEN_SUBTITLE) && !d->can_reference_text(shared_from_this(), TextType::OPEN_SUBTITLE, why_not)) { + d->set_reference_text(TextType::OPEN_SUBTITLE, false); + change_made = true; + } + if (d->reference_text(TextType::CLOSED_CAPTION) && !d->can_reference_text(shared_from_this(), TextType::CLOSED_CAPTION, why_not)) { + d->set_reference_text(TextType::CLOSED_CAPTION, false); + change_made = true; + } } if (change_made) { @@ -1501,17 +1601,9 @@ void Film::playlist_order_changed () { /* XXX: missing PENDING */ - signal_change (CHANGE_TYPE_DONE, CONTENT_ORDER); + signal_change(ChangeType::DONE, FilmProperty::CONTENT_ORDER); } -int -Film::audio_frame_rate () const -{ - /* It seems that nobody makes 96kHz DCPs at the moment, so let's avoid them. - See #1436. - */ - return 48000; -} void Film::set_sequence (bool s) @@ -1520,7 +1612,7 @@ Film::set_sequence (bool s) return; } - ChangeSignaller cc (this, SEQUENCE); + FilmChangeSignaller cc(this, FilmProperty::SEQUENCE); _sequence = s; _playlist->set_sequence (s); } @@ -1530,9 +1622,9 @@ dcp::Size Film::full_frame () const { switch (_resolution) { - case RESOLUTION_2K: + case Resolution::TWO_K: return dcp::Size (2048, 1080); - case RESOLUTION_4K: + case Resolution::FOUR_K: return dcp::Size (4096, 2160); } @@ -1552,14 +1644,15 @@ Film::frame_size () const dcp::Size Film::active_area () const { - dcp::Size const frame = frame_size (); + auto const frame = frame_size (); dcp::Size active; - BOOST_FOREACH (shared_ptr i, content()) { + for (auto i: content()) { if (i->video) { - dcp::Size s = i->video->scaled_size (frame); - active.width = max(active.width, s.width); - active.height = max(active.height, s.height); + if (auto s = i->video->scaled_size(frame)) { + active.width = max(active.width, s->width); + active.height = max(active.height, s->height); + } } } @@ -1567,76 +1660,57 @@ Film::active_area () const } -/** @param recipient KDM recipient certificate. - * @param trusted_devices Certificate thumbprints of other trusted devices (can be empty). - * @param cpl_file CPL filename. +/* @param cpl_file CPL filename. * @param from KDM from time expressed as a local time with an offset from UTC. * @param until KDM to time expressed as a local time with an offset from UTC. - * @param formulation KDM formulation to use. - * @param disable_forensic_marking_picture true to disable forensic marking of picture. - * @param disable_forensic_marking_audio if not set, don't disable forensic marking of audio. If set to 0, - * disable all forensic marking; if set above 0, disable forensic marking above that channel. */ -dcp::EncryptedKDM -Film::make_kdm ( - dcp::Certificate recipient, - vector trusted_devices, - boost::filesystem::path cpl_file, - dcp::LocalTime from, - dcp::LocalTime until, - dcp::Formulation formulation, - bool disable_forensic_marking_picture, - optional disable_forensic_marking_audio - ) const +dcp::DecryptedKDM +Film::make_kdm(boost::filesystem::path cpl_file, dcp::LocalTime from, dcp::LocalTime until) const { if (!_encrypted) { throw runtime_error (_("Cannot make a KDM as this project is not encrypted.")); } - shared_ptr cpl (new dcp::CPL (cpl_file)); - shared_ptr signer = Config::instance()->signer_chain (); - if (!signer->valid ()) { - throw InvalidSignerError (); - } + auto cpl = make_shared(cpl_file); /* Find keys that have been added to imported, encrypted DCP content */ list imported_keys; - BOOST_FOREACH (shared_ptr i, content()) { - shared_ptr d = dynamic_pointer_cast (i); + for (auto i: content()) { + auto d = dynamic_pointer_cast (i); if (d && d->kdm()) { dcp::DecryptedKDM kdm (d->kdm().get(), Config::instance()->decryption_chain()->key().get()); - list keys = kdm.keys (); + auto keys = kdm.keys (); copy (keys.begin(), keys.end(), back_inserter (imported_keys)); } } - map, dcp::Key> keys; + map, dcp::Key> keys; - BOOST_FOREACH(shared_ptr i, cpl->reel_mxfs()) { - if (!i->key_id()) { + for (auto asset: cpl->reel_file_assets()) { + if (!asset->encrypted()) { continue; } /* Get any imported key for this ID */ bool done = false; - BOOST_FOREACH (dcp::DecryptedKDMKey j, imported_keys) { - if (j.id() == i->key_id().get()) { - LOG_GENERAL ("Using imported key for %1", i->key_id().get()); - keys[i] = j.key(); + for (auto const& k: imported_keys) { + if (k.id() == asset->key_id().get()) { + LOG_GENERAL("Using imported key for %1", asset->key_id().get()); + keys[asset] = k.key(); done = true; } } if (!done) { /* No imported key; it must be an asset that we encrypted */ - LOG_GENERAL ("Using our own key for %1", i->key_id().get()); - keys[i] = key(); + LOG_GENERAL("Using our own key for %1", asset->key_id().get()); + keys[asset] = key(); } } return dcp::DecryptedKDM ( cpl->id(), keys, from, until, cpl->content_title_text(), cpl->content_title_text(), dcp::LocalTime().as_string() - ).encrypt (signer, recipient, trusted_devices, formulation, disable_forensic_marking_picture, disable_forensic_marking_audio); + ); } @@ -1663,19 +1737,19 @@ Film::should_be_enough_disk_space (double& required, double& available, bool& ca boost::filesystem::path test = internal_video_asset_dir() / "test"; boost::filesystem::path test2 = internal_video_asset_dir() / "test2"; can_hard_link = true; - FILE* f = fopen_boost (test, "w"); + dcp::File f(test, "w"); if (f) { - fclose (f); + f.close(); boost::system::error_code ec; - boost::filesystem::create_hard_link (test, test2, ec); + dcp::filesystem::create_hard_link(test, test2, ec); if (ec) { can_hard_link = false; } - boost::filesystem::remove (test); - boost::filesystem::remove (test2); + dcp::filesystem::remove(test); + dcp::filesystem::remove(test2); } - boost::filesystem::space_info s = boost::filesystem::space (internal_video_asset_dir ()); + auto s = dcp::filesystem::space(internal_video_asset_dir()); required = double (required_disk_space ()) / 1073741824.0f; if (!can_hard_link) { required *= 2; @@ -1684,29 +1758,6 @@ Film::should_be_enough_disk_space (double& required, double& available, bool& ca return (available - required) > 1; } -string -Film::subtitle_language () const -{ - set languages; - - BOOST_FOREACH (shared_ptr i, content()) { - BOOST_FOREACH (shared_ptr j, i->text) { - languages.insert (j->language ()); - } - } - - string all; - BOOST_FOREACH (string s, languages) { - if (!all.empty ()) { - all += "/" + s; - } else { - all += s; - } - } - - return all; -} - /** @return The names of the channels that audio contents' outputs are passed into; * this is either the DCP or a AudioProcessor. */ @@ -1722,7 +1773,7 @@ Film::audio_output_names () const vector n; for (int i = 0; i < audio_channels(); ++i) { - if (i != 8 && i != 9 && i != 15) { + if (Config::instance()->use_all_audio_channels() || (i != 8 && i != 9 && i != 15)) { n.push_back (NamedChannel(short_audio_channel_name(i), i)); } } @@ -1752,21 +1803,21 @@ list Film::reels () const { list p; - DCPTime const len = length(); + auto const len = length(); switch (reel_type ()) { - case REELTYPE_SINGLE: + case ReelType::SINGLE: p.push_back (DCPTimePeriod (DCPTime (), len)); break; - case REELTYPE_BY_VIDEO_CONTENT: + case ReelType::BY_VIDEO_CONTENT: { /* Collect all reel boundaries */ list split_points; split_points.push_back (DCPTime()); split_points.push_back (len); - BOOST_FOREACH (shared_ptr c, content()) { + for (auto c: content()) { if (c->video) { - BOOST_FOREACH (DCPTime t, c->reel_split_points(shared_from_this())) { + for (auto t: c->reel_split_points(shared_from_this())) { split_points.push_back (t); } split_points.push_back (c->end(shared_from_this())); @@ -1778,7 +1829,7 @@ Film::reels () const /* Make them into periods, coalescing any that are less than 1 second long */ optional last; - BOOST_FOREACH (DCPTime t, split_points) { + for (auto t: split_points) { if (last && (t - *last) >= DCPTime::from_seconds(1)) { /* Period from *last to t is long enough; use it and start a new one */ p.push_back (DCPTimePeriod(*last, t)); @@ -1788,9 +1839,13 @@ Film::reels () const last = t; } } + + if (!p.empty()) { + p.back().to = split_points.back(); + } break; } - case REELTYPE_BY_LENGTH: + case ReelType::BY_LENGTH: { DCPTime current; /* Integer-divide reel length by the size of one frame to give the number of frames per reel, @@ -1822,7 +1877,7 @@ void Film::use_template (string name) { _template_film.reset (new Film (optional())); - _template_film->read_metadata (Config::instance()->template_path (name)); + _template_film->read_metadata (Config::instance()->template_read_path(name)); _use_isdcf_name = _template_film->_use_isdcf_name; _dcp_content_type = _template_film->_dcp_content_type; _container = _template_film->_container; @@ -1837,7 +1892,6 @@ Film::use_template (string name) _audio_processor = _template_film->_audio_processor; _reel_type = _template_film->_reel_type; _reel_length = _template_film->_reel_length; - _isdcf_metadata = _template_film->_isdcf_metadata; } pair @@ -1855,8 +1909,8 @@ Film::copy_from (shared_ptr film) bool Film::references_dcp_video () const { - BOOST_FOREACH (shared_ptr i, _playlist->content()) { - shared_ptr d = dynamic_pointer_cast(i); + for (auto i: _playlist->content()) { + auto d = dynamic_pointer_cast(i); if (d && d->reference_video()) { return true; } @@ -1868,8 +1922,8 @@ Film::references_dcp_video () const bool Film::references_dcp_audio () const { - BOOST_FOREACH (shared_ptr i, _playlist->content()) { - shared_ptr d = dynamic_pointer_cast(i); + for (auto i: _playlist->content()) { + auto d = dynamic_pointer_cast(i); if (d && d->reference_audio()) { return true; } @@ -1882,13 +1936,10 @@ Film::references_dcp_audio () const bool Film::contains_atmos_content () const { - BOOST_FOREACH (shared_ptr i, _playlist->content()) { - if (i->atmos) { - return true; - } - } - - return false; + auto const content = _playlist->content(); + return std::find_if(content.begin(), content.end(), [](shared_ptr content) { + return static_cast(content->atmos); + }) != content.end(); } @@ -1896,11 +1947,11 @@ list Film::closed_caption_tracks () const { list tt; - BOOST_FOREACH (shared_ptr i, content()) { - BOOST_FOREACH (shared_ptr j, i->text) { + for (auto i: content()) { + for (auto text: i->text) { /* XXX: Empty DCPTextTrack ends up being a magic value here - the "unknown" or "not specified" track */ - DCPTextTrack dtt = j->dcp_track().get_value_or(DCPTextTrack()); - if (j->type() == TEXT_CLOSED_CAPTION && find(tt.begin(), tt.end(), dtt) == tt.end()) { + auto dtt = text->dcp_track().get_value_or(DCPTextTrack()); + if (text->type() == TextType::CLOSED_CAPTION && find(tt.begin(), tt.end(), dtt) == tt.end()) { tt.push_back (dtt); } } @@ -1912,14 +1963,15 @@ Film::closed_caption_tracks () const void Film::set_marker (dcp::Marker type, DCPTime time) { - ChangeSignaller ch (this, MARKERS); + FilmChangeSignaller ch(this, FilmProperty::MARKERS); _markers[type] = time; } + void Film::unset_marker (dcp::Marker type) { - ChangeSignaller ch (this, MARKERS); + FilmChangeSignaller ch(this, FilmProperty::MARKERS); _markers.erase (type); } @@ -1927,7 +1979,7 @@ Film::unset_marker (dcp::Marker type) void Film::clear_markers () { - ChangeSignaller ch (this, MARKERS); + FilmChangeSignaller ch(this, FilmProperty::MARKERS); _markers.clear (); } @@ -1935,14 +1987,14 @@ Film::clear_markers () void Film::set_ratings (vector r) { - ChangeSignaller ch (this, RATINGS); + FilmChangeSignaller ch(this, FilmProperty::RATINGS); _ratings = r; } void Film::set_content_versions (vector v) { - ChangeSignaller ch (this, CONTENT_VERSIONS); + FilmChangeSignaller ch(this, FilmProperty::CONTENT_VERSIONS); _content_versions = v; } @@ -1950,23 +2002,15 @@ Film::set_content_versions (vector v) void Film::set_name_language (dcp::LanguageTag lang) { - ChangeSignaller ch (this, NAME_LANGUAGE); + FilmChangeSignaller ch(this, FilmProperty::NAME_LANGUAGE); _name_language = lang; } void -Film::set_audio_language (dcp::LanguageTag lang) +Film::set_release_territory (optional region) { - ChangeSignaller ch (this, AUDIO_LANGUAGE); - _audio_language = lang; -} - - -void -Film::set_release_territory (dcp::LanguageTag::RegionSubtag region) -{ - ChangeSignaller ch (this, RELEASE_TERRITORY); + FilmChangeSignaller ch(this, FilmProperty::RELEASE_TERRITORY); _release_territory = region; } @@ -1974,7 +2018,7 @@ Film::set_release_territory (dcp::LanguageTag::RegionSubtag region) void Film::set_status (dcp::Status s) { - ChangeSignaller ch (this, STATUS); + FilmChangeSignaller ch(this, FilmProperty::STATUS); _status = s; } @@ -1982,49 +2026,57 @@ Film::set_status (dcp::Status s) void Film::set_version_number (int v) { - ChangeSignaller ch (this, VERSION_NUMBER); + FilmChangeSignaller ch(this, FilmProperty::VERSION_NUMBER); _version_number = v; } void -Film::set_chain (string c) +Film::set_chain (optional c) { - ChangeSignaller ch (this, CHAIN); + FilmChangeSignaller ch(this, FilmProperty::CHAIN); _chain = c; } void -Film::set_distributor (string d) +Film::set_distributor (optional d) { - ChangeSignaller ch (this, DISTRIBUTOR); + FilmChangeSignaller ch(this, FilmProperty::DISTRIBUTOR); _distributor = d; } void -Film::set_luminance (dcp::Luminance l) +Film::set_luminance (optional l) { - ChangeSignaller ch (this, LUMINANCE); + FilmChangeSignaller ch(this, FilmProperty::LUMINANCE); _luminance = l; } void -Film::set_facility (string f) +Film::set_facility (optional f) { - ChangeSignaller ch (this, FACILITY); + FilmChangeSignaller ch(this, FilmProperty::FACILITY); _facility = f; } +void +Film::set_studio (optional s) +{ + FilmChangeSignaller ch(this, FilmProperty::STUDIO); + _studio = s; +} + + optional Film::marker (dcp::Marker type) const { - map::const_iterator i = _markers.find (type); + auto i = _markers.find (type); if (i == _markers.end()) { - return optional(); + return {}; } return i->second; } @@ -2032,33 +2084,149 @@ Film::marker (dcp::Marker type) const shared_ptr Film::info_file_handle (DCPTimePeriod period, bool read) const { - return shared_ptr (new InfoFileHandle(_info_file_mutex, info_file(period), read)); + return std::make_shared(_info_file_mutex, info_file(period), read); } -InfoFileHandle::InfoFileHandle (boost::mutex& mutex, boost::filesystem::path file, bool read) +InfoFileHandle::InfoFileHandle (boost::mutex& mutex, boost::filesystem::path path, bool read) : _lock (mutex) - , _file (file) + , _file(path, read ? "rb" : (dcp::filesystem::exists(path) ? "r+b" : "wb")) { - if (read) { - _handle = fopen_boost (file, "rb"); - if (!_handle) { - throw OpenFileError (file, errno, OpenFileError::READ); - } - } else { - bool const exists = boost::filesystem::exists (file); - if (exists) { - _handle = fopen_boost (file, "r+b"); - } else { - _handle = fopen_boost (file, "wb"); - } + if (!_file) { + throw OpenFileError(path, errno, read ? OpenFileError::READ : (dcp::filesystem::exists(path) ? OpenFileError::READ_WRITE : OpenFileError::WRITE)); + } +} - if (!_handle) { - throw OpenFileError (file, errno, exists ? OpenFileError::READ_WRITE : OpenFileError::WRITE); - } + +/** Add FFOC and LFOC markers to a list if they are not already there */ +void +Film::add_ffoc_lfoc (Markers& markers) const +{ + if (markers.find(dcp::Marker::FFOC) == markers.end()) { + markers[dcp::Marker::FFOC] = dcpomatic::DCPTime::from_frames(1, video_frame_rate()); + } + + if (markers.find(dcp::Marker::LFOC) == markers.end()) { + markers[dcp::Marker::LFOC] = length() - DCPTime::from_frames(1, video_frame_rate()); + } +} + + +void +Film::set_temp_version (bool t) +{ + FilmChangeSignaller ch(this, FilmProperty::TEMP_VERSION); + _temp_version = t; +} + + +void +Film::set_pre_release (bool p) +{ + FilmChangeSignaller ch(this, FilmProperty::PRE_RELEASE); + _pre_release = p; +} + + +void +Film::set_red_band (bool r) +{ + FilmChangeSignaller ch(this, FilmProperty::RED_BAND); + _red_band = r; +} + + +void +Film::set_two_d_version_of_three_d (bool t) +{ + FilmChangeSignaller ch(this, FilmProperty::TWO_D_VERSION_OF_THREE_D); + _two_d_version_of_three_d = t; +} + + +void +Film::set_audio_language (optional language) +{ + FilmChangeSignaller ch(this, FilmProperty::AUDIO_LANGUAGE); + _audio_language = language; +} + + +void +Film::set_audio_frame_rate (int rate) +{ + FilmChangeSignaller ch(this, FilmProperty::AUDIO_FRAME_RATE); + _audio_frame_rate = rate; +} + + +bool +Film::has_sign_language_video_channel () const +{ + return _audio_channels >= static_cast(dcp::Channel::SIGN_LANGUAGE); +} + + +void +Film::set_sign_language_video_language (optional lang) +{ + FilmChangeSignaller ch(this, FilmProperty::SIGN_LANGUAGE_VIDEO_LANGUAGE); + _sign_language_video_language = lang; +} + + +void +Film::set_dirty (bool dirty) +{ + auto const changed = dirty != _dirty; + _dirty = dirty; + if (changed) { + emit (boost::bind(boost::ref(DirtyChange), _dirty)); + } +} + + +/** @return true if the metadata was (probably) last written by a version earlier + * than the given one; false if it definitely was not. + */ +bool +Film::last_written_by_earlier_than(int major, int minor, int micro) const +{ + if (!_last_written_by) { + return true; + } + + vector parts; + boost::split(parts, *_last_written_by, boost::is_any_of(".")); + + if (parts.size() != 3) { + /* Not sure what's going on, so let's say it was written by an old version */ + return true; } + + if (boost::ends_with(parts[2], "pre")) { + parts[2] = parts[2].substr(0, parts[2].length() - 3); + } + + int our_major = dcp::raw_convert(parts[0]); + int our_minor = dcp::raw_convert(parts[1]); + int our_micro = dcp::raw_convert(parts[2]); + + if (our_major != major) { + return our_major < major; + } + + if (our_minor != minor) { + return our_minor < minor; + } + + return our_micro < micro; } -InfoFileHandle::~InfoFileHandle () + +void +Film::set_territory_type(TerritoryType type) { - fclose (_handle); + FilmChangeSignaller ch(this, FilmProperty::TERRITORY_TYPE); + _territory_type = type; } +