X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Ffilm.cc;h=d311c76cb4b519f78e22c5b1791be4f5387eb77d;hp=13a03d929602a1e05c5a1a558b1127e8e999aeec;hb=eefc143f08e4b4dc26ebbd2136488f5c95e6cc2a;hpb=54038beb4437c027e584fc95110f6fd4dbf2207d diff --git a/src/lib/film.cc b/src/lib/film.cc index 13a03d929..d311c76cb 100644 --- a/src/lib/film.cc +++ b/src/lib/film.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2016 Carl Hetherington + Copyright (C) 2012-2019 Carl Hetherington This file is part of DCP-o-matic. @@ -19,7 +19,7 @@ */ /** @file src/film.cc - * @brief A representation of some audio and video content, and details of + * @brief A representation of some audio, video and subtitle content, and details of * how they should be presented in a DCP. */ @@ -27,10 +27,12 @@ #include "job.h" #include "util.h" #include "job_manager.h" +#include "dcp_encoder.h" #include "transcode_job.h" #include "upload_job.h" #include "null_log.h" #include "file_log.h" +#include "dcpomatic_log.h" #include "exceptions.h" #include "examine_content_job.h" #include "config.h" @@ -45,11 +47,13 @@ #include "screen.h" #include "audio_content.h" #include "video_content.h" -#include "subtitle_content.h" +#include "text_content.h" #include "ffmpeg_content.h" #include "dcp_content.h" #include "screen_kdm.h" #include "cinema.h" +#include "change_signaller.h" +#include "check_content_change_job.h" #include #include #include @@ -57,6 +61,8 @@ #include #include #include +#include +#include #include #include #include @@ -83,6 +89,10 @@ 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::exception; using boost::shared_ptr; using boost::weak_ptr; using boost::dynamic_pointer_cast; @@ -90,8 +100,7 @@ using boost::optional; using boost::is_any_of; using dcp::raw_convert; -#define LOG_GENERAL(...) log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL); -#define LOG_GENERAL_NC(...) log()->log (__VA_ARGS__, LogEntry::TYPE_GENERAL); +string const Film::metadata_file = "metadata.xml"; /* 5 -> 6 * AudioMapping XML changed. @@ -116,8 +125,11 @@ using dcp::raw_convert; * VideoFrameType in VideoContent is a string rather than an integer. * 35 -> 36 * EffectColour rather than OutlineColour in Subtitle. + * 36 -> 37 + * TextContent can be in a Caption tag, and some of the tag names + * have had Subtitle prefixes or suffixes removed. */ -int const Film::current_state_version = 36; +int const Film::current_state_version = 37; /** Construct a Film object in a given directory. * @@ -132,6 +144,7 @@ Film::Film (optional dir) , _resolution (RESOLUTION_2K) , _signed (true) , _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) @@ -142,15 +155,17 @@ Film::Film (optional dir) , _audio_processor (0) , _reel_type (REELTYPE_SINGLE) , _reel_length (2000000000) - , _upload_after_make_dcp (false) + , _upload_after_make_dcp (Config::instance()->default_upload_after_make_dcp()) + , _reencode_j2k (false) + , _user_explicit_video_frame_rate (false) , _state_version (current_state_version) , _dirty (false) { set_isdcf_date_today (); - _playlist_changed_connection = _playlist->Changed.connect (bind (&Film::playlist_changed, this)); + _playlist_change_connection = _playlist->Change.connect (bind (&Film::playlist_change, this, _1)); _playlist_order_changed_connection = _playlist->OrderChanged.connect (bind (&Film::playlist_order_changed, this)); - _playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Film::playlist_content_changed, this, _1, _2, _3)); + _playlist_content_change_connection = _playlist->ContentChange.connect (bind (&Film::playlist_content_change, this, _1, _2, _3, _4)); if (dir) { /* Make state.directory a complete path without ..s (where possible) @@ -162,7 +177,8 @@ Film::Film (optional dir) boost::filesystem::path result; for (boost::filesystem::path::iterator i = p.begin(); i != p.end(); ++i) { if (*i == "..") { - if (boost::filesystem::is_symlink (result) || result.filename() == "..") { + boost::system::error_code ec; + if (boost::filesystem::is_symlink(result, ec) || result.filename() == "..") { result /= *i; } else { result = result.parent_path (); @@ -275,6 +291,8 @@ Film::audio_analysis_path (shared_ptr playlist) const digester.add (audio_processor()->id ()); } + digester.add (audio_channels()); + p /= digester.get (); return p; } @@ -284,7 +302,36 @@ void Film::make_dcp () { if (dcp_name().find ("/") != string::npos) { - throw BadSettingError (_("name"), _("cannot contain slashes")); + 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 (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 (); @@ -300,27 +347,14 @@ Film::make_dcp () if (Config::instance()->only_servers_encode ()) { LOG_GENERAL_NC ("0 threads: ONLY SERVERS SET TO ENCODE"); } else { - LOG_GENERAL ("%1 threads", Config::instance()->num_local_encoding_threads()); + LOG_GENERAL ("%1 threads", Config::instance()->master_encoding_threads()); } LOG_GENERAL ("J2K bandwidth %1", j2k_bandwidth()); - if (container() == 0) { - throw MissingSettingError (_("container")); - } - - if (content().empty()) { - throw runtime_error (_("You must add some content to the DCP before creating it")); - } - - if (dcp_content_type() == 0) { - throw MissingSettingError (_("content type")); - } - - if (name().empty()) { - throw MissingSettingError (_("name")); - } - - JobManager::instance()->add (shared_ptr (new TranscodeJob (shared_from_this()))); + shared_ptr tj (new TranscodeJob (shared_from_this())); + tj->set_encoder (shared_ptr (new DCPEncoder (shared_from_this(), tj))); + shared_ptr cc (new CheckContentChangeJob (shared_from_this(), tj)); + JobManager::instance()->add (cc); } /** Start a job to send our DCP to the configured TMS */ @@ -361,17 +395,27 @@ Film::metadata (bool with_content_paths) const root->add_child("Signed")->add_child_text (_signed ? "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); if (_audio_processor) { root->add_child("AudioProcessor")->add_child_text (_audio_processor->id ()); } root->add_child("ReelType")->add_child_text (raw_convert (static_cast (_reel_type))); root->add_child("ReelLength")->add_child_text (raw_convert (_reel_length)); root->add_child("UploadAfterMakeDCP")->add_child_text (_upload_after_make_dcp ? "1" : "0"); + 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"); _playlist->as_xml (root->add_child ("Playlist"), with_content_paths); return doc; } +void +Film::write_metadata (boost::filesystem::path path) const +{ + shared_ptr doc = metadata (); + doc->write_to_file_formatted (path.string()); +} + /** Write state to our `metadata' file */ void Film::write_metadata () const @@ -379,7 +423,7 @@ Film::write_metadata () const DCPOMATIC_ASSERT (directory()); boost::filesystem::create_directories (directory().get()); shared_ptr doc = metadata (); - doc->write_to_file_formatted (file("metadata.xml").string ()); + doc->write_to_file_formatted (file(metadata_file).string ()); _dirty = false; } @@ -399,11 +443,11 @@ list Film::read_metadata (optional path) { if (!path) { - if (boost::filesystem::exists (file ("metadata")) && !boost::filesystem::exists (file ("metadata.xml"))) { + if (boost::filesystem::exists (file ("metadata")) && !boost::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.xml"); + path = file (metadata_file); } cxml::Document f ("Metadata"); @@ -412,6 +456,16 @@ Film::read_metadata (optional path) _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)) { + try { + boost::filesystem::copy_file(*path, older); + } catch (...) { + /* Never mind; at least we tried */ + } + } } _name = f.string_child ("Name"); @@ -425,6 +479,7 @@ Film::read_metadata (optional path) _isdcf_date = boost::gregorian::from_undelimited_string (f.string_child ("DCIDate")); } + { optional c = f.optional_string_child ("DCPContentType"); if (c) { @@ -463,6 +518,7 @@ Film::read_metadata (optional path) _three_d = f.bool_child ("ThreeD"); _interop = f.bool_child ("Interop"); _key = dcp::Key (f.string_child ("Key")); + _context_id = f.optional_string_child("ContextID").get_value_or (dcp::make_uuid ()); if (f.optional_string_child ("AudioProcessor")) { _audio_processor = AudioProcessor::from_id (f.string_child ("AudioProcessor")); @@ -473,9 +529,10 @@ Film::read_metadata (optional path) _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); _upload_after_make_dcp = f.optional_bool_child("UploadAfterMakeDCP").get_value_or (false); + _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); list notes; - /* This method is the only one that can return notes (so far) */ _playlist->set_from_xml (shared_from_this(), f.node_child ("Playlist"), _state_version, notes); /* Write backtraces to this film's directory, until another film is loaded */ @@ -488,10 +545,11 @@ Film::read_metadata (optional path) } /** Given a directory name, return its full path within the Film's directory. - * The directory (and its parents) will be created if they do not exist. + * @param d directory name within the Film's directory. + * @param create true to create the directory (and its parents) if they do not exist. */ boost::filesystem::path -Film::dir (boost::filesystem::path d) const +Film::dir (boost::filesystem::path d, bool create) const { DCPOMATIC_ASSERT (_directory); @@ -499,7 +557,9 @@ Film::dir (boost::filesystem::path d) const p /= _directory.get(); p /= d; - boost::filesystem::create_directories (p); + if (create) { + boost::filesystem::create_directories (p); + } return p; } @@ -640,7 +700,7 @@ Film::isdcf_name (bool if_created_now) const /* XXX: this uses the first bit of content only */ - /* The standard says we don't do this for trailers, for some strange reason */ + /* 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 ()) { @@ -656,34 +716,56 @@ Film::isdcf_name (bool if_created_now) const } if (content_ratio && content_ratio != container()) { - d += "-" + content_ratio->isdcf_name(); + /* 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; - if (!dm.subtitle_language.empty()) { - bool burnt_in = true; - BOOST_FOREACH (shared_ptr i, content ()) { - if (!i->subtitle) { - continue; - } + /* 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. + */ - if (i->subtitle->use() && !i->subtitle->burn()) { - burnt_in = false; + 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; } } + } - string language = dm.subtitle_language; - if (burnt_in && language != "XX") { - transform (language.begin(), language.end(), language.begin(), ::tolower); + 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 (language.begin(), language.end(), language.begin(), ::toupper); + transform (subtitle_language->begin(), subtitle_language->end(), subtitle_language->begin(), ::toupper); } - d += "-" + language; + d += "-" + *subtitle_language; + if (ccap) { + d += "-CCAP"; + } } else { + /* No subtitles */ d += "-XX"; } } @@ -699,27 +781,21 @@ Film::isdcf_name (bool if_created_now) const /* Count mapped audio channels */ - int non_lfe = 0; - int lfe = 0; + list mapped = mapped_audio_channels (); - BOOST_FOREACH (int i, mapped_audio_channels ()) { - if (i >= audio_channels()) { - /* This channel is mapped but is not included in the DCP */ - continue; - } - - if (static_cast (i) == dcp::LFE) { - ++lfe; - } else { - ++non_lfe; - } + pair ch = audio_channel_types (mapped, audio_channels()); + if (!ch.first && !ch.second) { + d += "_MOS"; + } else if (ch.first) { + d += String::compose("_%1%2", ch.first, ch.second); } - if (non_lfe) { - d += String::compose("_%1%2", non_lfe, lfe); + if (audio_channels() > static_cast(dcp::HI) && find(mapped.begin(), mapped.end(), dcp::HI) != mapped.end()) { + d += "-HI"; + } + if (audio_channels() > static_cast(dcp::VI) && find(mapped.begin(), mapped.end(), dcp::VI) != mapped.end()) { + d += "-VI"; } - - /* XXX: HI/VI */ d += "_" + resolution_to_string (_resolution); @@ -750,7 +826,17 @@ Film::isdcf_name (bool if_created_now) const bool vf = false; BOOST_FOREACH (shared_ptr i, content ()) { shared_ptr dc = dynamic_pointer_cast (i); - if (dc && (dc->reference_video() || dc->reference_audio() || dc->reference_subtitle())) { + if (!dc) { + continue; + } + + bool any_text = false; + for (int i = 0; i < TEXT_COUNT; ++i) { + if (dc->reference_text(static_cast(i))) { + any_text = true; + } + } + if (dc->reference_video() || dc->reference_audio() || any_text) { vf = true; } } @@ -770,24 +856,10 @@ Film::dcp_name (bool if_created_now) const { string unfiltered; if (use_isdcf_name()) { - unfiltered = isdcf_name (if_created_now); - } else { - unfiltered = name (); + return careful_string_filter (isdcf_name (if_created_now)); } - /* Filter out `bad' characters which cause problems with some systems. - There's no apparent list of what really is allowed, so this is a guess. - */ - - string filtered; - string const allowed = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"; - for (size_t i = 0; i < unfiltered.size(); ++i) { - if (allowed.find (unfiltered[i]) != string::npos) { - filtered += unfiltered[i]; - } - } - - return filtered; + return careful_string_filter (name ()); } void @@ -800,133 +872,158 @@ Film::set_directory (boost::filesystem::path d) void Film::set_name (string n) { + ChangeSignaller ch (this, NAME); _name = n; - signal_changed (NAME); } void Film::set_use_isdcf_name (bool u) { + ChangeSignaller ch (this, USE_ISDCF_NAME); _use_isdcf_name = u; - signal_changed (USE_ISDCF_NAME); } void Film::set_dcp_content_type (DCPContentType const * t) { + ChangeSignaller ch (this, DCP_CONTENT_TYPE); _dcp_content_type = t; - signal_changed (DCP_CONTENT_TYPE); } void Film::set_container (Ratio const * c) { + ChangeSignaller ch (this, CONTAINER); _container = c; - signal_changed (CONTAINER); } void Film::set_resolution (Resolution r) { + ChangeSignaller ch (this, RESOLUTION); _resolution = r; - signal_changed (RESOLUTION); } void Film::set_j2k_bandwidth (int b) { + ChangeSignaller ch (this, J2K_BANDWIDTH); _j2k_bandwidth = b; - signal_changed (J2K_BANDWIDTH); } void Film::set_isdcf_metadata (ISDCFMetadata m) { + ChangeSignaller ch (this, ISDCF_METADATA); _isdcf_metadata = m; - signal_changed (ISDCF_METADATA); } +/** @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. + */ void -Film::set_video_frame_rate (int f) +Film::set_video_frame_rate (int f, bool user_explicit) { + ChangeSignaller ch (this, VIDEO_FRAME_RATE); _video_frame_rate = f; - signal_changed (VIDEO_FRAME_RATE); + if (user_explicit) { + _user_explicit_video_frame_rate = true; + } } void Film::set_audio_channels (int c) { + ChangeSignaller ch (this, AUDIO_CHANNELS); _audio_channels = c; - signal_changed (AUDIO_CHANNELS); } void Film::set_three_d (bool t) { + ChangeSignaller ch (this, THREE_D); _three_d = t; - signal_changed (THREE_D); 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; - signal_changed (ISDCF_METADATA); } } void Film::set_interop (bool i) { + ChangeSignaller ch (this, INTEROP); _interop = i; - signal_changed (INTEROP); } void Film::set_audio_processor (AudioProcessor const * processor) { + ChangeSignaller ch1 (this, AUDIO_PROCESSOR); + ChangeSignaller ch2 (this, AUDIO_CHANNELS); _audio_processor = processor; - signal_changed (AUDIO_PROCESSOR); - signal_changed (AUDIO_CHANNELS); } void Film::set_reel_type (ReelType t) { + ChangeSignaller ch (this, REEL_TYPE); _reel_type = t; - signal_changed (REEL_TYPE); } /** @param r Desired reel length in bytes */ void Film::set_reel_length (int64_t r) { + ChangeSignaller ch (this, REEL_LENGTH); _reel_length = r; - signal_changed (REEL_LENGTH); } void Film::set_upload_after_make_dcp (bool u) { + ChangeSignaller ch (this, UPLOAD_AFTER_MAKE_DCP); _upload_after_make_dcp = u; - signal_changed (UPLOAD_AFTER_MAKE_DCP); } void -Film::signal_changed (Property p) +Film::set_reencode_j2k (bool r) { - _dirty = true; + ChangeSignaller ch (this, REENCODE_J2K); + _reencode_j2k = r; +} - switch (p) { - case Film::CONTENT: - set_video_frame_rate (_playlist->best_video_frame_rate ()); - break; - case Film::VIDEO_FRAME_RATE: - case Film::SEQUENCE: - _playlist->maybe_sequence (); - break; - default: - break; - } +void +Film::signal_change (ChangeType type, int p) +{ + signal_change (type, static_cast(p)); +} + +void +Film::signal_change (ChangeType type, Property p) +{ + if (type == CHANGE_TYPE_DONE) { + _dirty = true; + + if (p == Film::CONTENT) { + if (!_user_explicit_video_frame_rate) { + set_video_frame_rate (best_video_frame_rate()); + } + } - emit (boost::bind (boost::ref (Changed), p)); + emit (boost::bind (boost::ref (Change), type, p)); + + if (p == Film::VIDEO_FRAME_RATE || p == Film::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). + */ + emit (boost::bind(&Playlist::maybe_sequence, _playlist.get(), shared_from_this())); + } + } else { + Change (type, p); + } } void @@ -962,7 +1059,16 @@ Film::j2c_path (int reel, Frame frame, Eyes eyes, bool tmp) const return file (p); } -/** Find all the DCPs in our directory that can be dcp::DCP::read() and return details of their CPLs */ +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). + */ vector Film::cpls () const { @@ -980,45 +1086,37 @@ Film::cpls () const ) { try { - dcp::DCP dcp (*i); - dcp.read (); - DCPOMATIC_ASSERT (dcp.cpls().front()->file()); - out.push_back ( - CPLSummary ( - i->path().leaf().string(), - dcp.cpls().front()->id(), - dcp.cpls().front()->annotation_text(), - dcp.cpls().front()->file().get() - ) - ); + out.push_back (CPLSummary(*i)); } catch (...) { } } } + sort (out.begin(), out.end(), cpl_summary_compare); + return out; } void Film::set_signed (bool s) { + ChangeSignaller ch (this, SIGNED); _signed = s; - signal_changed (SIGNED); } void Film::set_encrypted (bool e) { + ChangeSignaller ch (this, ENCRYPTED); _encrypted = e; - signal_changed (ENCRYPTED); } void Film::set_key (dcp::Key key) { + ChangeSignaller ch (this, KEY); _key = key; - signal_changed (KEY); } ContentList @@ -1027,31 +1125,27 @@ Film::content () const return _playlist->content (); } +/** @param content Content to add. + * @param disable_audio_analysis true to never do automatic audio analysis, even if it is enabled in configuration. + */ void -Film::examine_content (shared_ptr c) -{ - shared_ptr j (new ExamineContentJob (shared_from_this(), c)); - JobManager::instance()->add (j); -} - -void -Film::examine_and_add_content (shared_ptr c) +Film::examine_and_add_content (shared_ptr content, bool disable_audio_analysis) { - if (dynamic_pointer_cast (c) && _directory) { - run_ffprobe (c->path(0), file ("ffprobe.log"), _log); + if (dynamic_pointer_cast (content) && _directory) { + run_ffprobe (content->path(0), file("ffprobe.log")); } - shared_ptr j (new ExamineContentJob (shared_from_this(), c)); + shared_ptr j (new ExamineContentJob (shared_from_this(), content)); _job_connections.push_back ( - j->Finished.connect (bind (&Film::maybe_add_content, this, weak_ptr (j), weak_ptr (c))) + j->Finished.connect (bind (&Film::maybe_add_content, this, weak_ptr(j), weak_ptr(content), disable_audio_analysis)) ); JobManager::instance()->add (j); } void -Film::maybe_add_content (weak_ptr j, weak_ptr c) +Film::maybe_add_content (weak_ptr j, weak_ptr c, bool disable_audio_analysis) { shared_ptr job = j.lock (); if (!job || !job->finished_ok ()) { @@ -1065,12 +1159,12 @@ Film::maybe_add_content (weak_ptr j, weak_ptr c) add_content (content); - if (Config::instance()->automatic_audio_analysis() && content->audio) { + if (Config::instance()->automatic_audio_analysis() && content->audio && !disable_audio_analysis) { shared_ptr playlist (new Playlist); - playlist->add (content); + playlist->add (shared_from_this(), content); boost::signals2::connection c; JobManager::instance()->analyse_audio ( - shared_from_this (), playlist, c, bind (&Film::audio_analysis_finished, this) + shared_from_this(), playlist, false, c, bind (&Film::audio_analysis_finished, this) ); _audio_analysis_connections.push_back (c); } @@ -1081,21 +1175,19 @@ Film::add_content (shared_ptr c) { /* Add {video,subtitle} content after any existing {video,subtitle} content */ if (c->video) { - c->set_position (_playlist->video_end ()); - } else if (c->subtitle) { - c->set_position (_playlist->subtitle_end ()); + c->set_position (shared_from_this(), _playlist->video_end(shared_from_this())); + } else if (!c->text.empty()) { + c->set_position (shared_from_this(), _playlist->text_end(shared_from_this())); } 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()) { - if (typeid(i.get()) == typeid(c.get())) { - c->use_template (i); - } + c->take_settings_from (i); } } - _playlist->add (c); + _playlist->add (shared_from_this(), c); } void @@ -1107,26 +1199,31 @@ Film::remove_content (shared_ptr c) void Film::move_content_earlier (shared_ptr c) { - _playlist->move_earlier (c); + _playlist->move_earlier (shared_from_this(), c); } void Film::move_content_later (shared_ptr c) { - _playlist->move_later (c); + _playlist->move_later (shared_from_this(), c); } /** @return length of the film from time 0 to the last thing on the playlist */ DCPTime Film::length () const { - return _playlist->length (); + return _playlist->length(shared_from_this()).ceil(video_frame_rate()); } int Film::best_video_frame_rate () const { - return _playlist->best_video_frame_rate (); + /* Don't default to anything above 30fps (make the user select that explicitly) */ + int best = _playlist->best_video_frame_rate (); + if (best > 30) { + best /= 2; + } + return best; } FrameRateChange @@ -1136,50 +1233,79 @@ Film::active_frame_rate_change (DCPTime t) const } void -Film::playlist_content_changed (weak_ptr c, int p, bool frequent) +Film::playlist_content_change (ChangeType type, weak_ptr c, int p, bool frequent) { - _dirty = true; - if (p == ContentProperty::VIDEO_FRAME_RATE) { - set_video_frame_rate (_playlist->best_video_frame_rate ()); + signal_change (type, Film::CONTENT); } else if (p == AudioContentProperty::STREAMS) { - signal_changed (NAME); + signal_change (type, Film::NAME); } - emit (boost::bind (boost::ref (ContentChanged), c, p, frequent)); + if (type == CHANGE_TYPE_DONE) { + emit (boost::bind (boost::ref (ContentChange), type, c, p, frequent)); + } else { + ContentChange (type, c, p, frequent); + } } void -Film::playlist_changed () -{ - signal_changed (CONTENT); - signal_changed (NAME); +Film::playlist_change (ChangeType type) +{ + signal_change (type, CONTENT); + signal_change (type, NAME); + + if (type == CHANGE_TYPE_DONE) { + /* Check that this change hasn't made our settings inconsistent */ + bool change_made = false; + BOOST_FOREACH (shared_ptr i, content()) { + shared_ptr d = dynamic_pointer_cast(i); + if (!d) { + continue; + } + + string why_not; + if (d->reference_video() && !d->can_reference_video(shared_from_this(), why_not)) { + d->set_reference_video(false); + change_made = true; + } + if (d->reference_audio() && !d->can_reference_audio(shared_from_this(), why_not)) { + d->set_reference_audio(false); + change_made = true; + } + } + + if (change_made) { + Message (_("DCP-o-matic had to change your settings for referring to DCPs as OV. Please review those settings to make sure they are what you want.")); + } + } } void Film::playlist_order_changed () { - signal_changed (CONTENT_ORDER); + /* XXX: missing PENDING */ + signal_change (CHANGE_TYPE_DONE, CONTENT_ORDER); } int Film::audio_frame_rate () const { - BOOST_FOREACH (shared_ptr i, content ()) { - if (i->audio && i->audio->has_rate_above_48k ()) { - return 96000; - } - } - + /* 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) { + if (s == _sequence) { + return; + } + + ChangeSignaller cc (this, SEQUENCE); _sequence = s; _playlist->set_sequence (s); - signal_changed (SEQUENCE); } /** @return Size of the largest possible image in whatever resolution we are using */ @@ -1204,40 +1330,97 @@ Film::frame_size () const return fit_ratio_within (container()->ratio(), full_frame ()); } -/** @param from KDM from time expressed as a local time with an offset from UTC - * @param to KDM to time expressed as a local time with an offset from UTC +/** @param recipient KDM recipient certificate. + * @param trusted_devices Certificate thumbprints of other trusted devices (can be empty). + * @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, + vector trusted_devices, boost::filesystem::path cpl_file, dcp::LocalTime from, dcp::LocalTime until, - dcp::Formulation formulation + dcp::Formulation formulation, + bool disable_forensic_marking_picture, + optional disable_forensic_marking_audio ) 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 (); } - return dcp::DecryptedKDM ( - cpl, key(), from, until, cpl->content_title_text(), cpl->content_title_text(), dcp::LocalTime().as_string() - ).encrypt (signer, recipient, trusted_devices, formulation); -} + /* 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); + if (d && d->kdm()) { + dcp::DecryptedKDM kdm (d->kdm().get(), Config::instance()->decryption_chain()->key().get()); + list keys = kdm.keys (); + copy (keys.begin(), keys.end(), back_inserter (imported_keys)); + } + } + + map, dcp::Key> keys; + + BOOST_FOREACH(shared_ptr i, cpl->reel_assets ()) { + shared_ptr mxf = boost::dynamic_pointer_cast (i); + if (!mxf || !mxf->key_id()) { + continue; + } + + /* Get any imported key for this ID */ + bool done = false; + BOOST_FOREACH (dcp::DecryptedKDMKey j, imported_keys) { + if (j.id() == mxf->key_id().get()) { + LOG_GENERAL ("Using imported key for %1", mxf->key_id().get()); + keys[mxf] = j.key(); + done = true; + } + } + + if (!done) { + /* No imported key; it must be an asset that we encrypted */ + LOG_GENERAL ("Using our own key for %1", mxf->key_id().get()); + keys[mxf] = key(); + } + } -/** @param from KDM from time expressed as a local time in the time zone of the Screen's Cinema. - * @param to KDM to time expressed as a local time in the time zone of the Screen's Cinema. + 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); +} + +/** @param screens Screens to make KDMs for. + * @param cpl_file Path to CPL to make KDMs for. + * @param from KDM from time expressed as a local time in the time zone of the Screen's Cinema. + * @param until KDM to time expressed as a local time in the time zone of the Screen's Cinema. + * @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. */ list Film::make_kdms ( list > screens, - boost::filesystem::path dcp, + boost::filesystem::path cpl_file, boost::posix_time::ptime from, boost::posix_time::ptime until, - dcp::Formulation formulation + dcp::Formulation formulation, + bool disable_forensic_marking_picture, + optional disable_forensic_marking_audio ) const { list kdms; @@ -1246,11 +1429,13 @@ Film::make_kdms ( if (i->recipient) { dcp::EncryptedKDM const kdm = make_kdm ( i->recipient.get(), - i->trusted_devices, - dcp, - dcp::LocalTime (from, i->cinema->utc_offset_hour(), i->cinema->utc_offset_minute()), - dcp::LocalTime (until, i->cinema->utc_offset_hour(), i->cinema->utc_offset_minute()), - formulation + i->trusted_device_thumbprints(), + cpl_file, + dcp::LocalTime (from, i->cinema ? i->cinema->utc_offset_hour() : 0, i->cinema ? i->cinema->utc_offset_minute() : 0), + dcp::LocalTime (until, i->cinema ? i->cinema->utc_offset_hour() : 0, i->cinema ? i->cinema->utc_offset_minute() : 0), + formulation, + disable_forensic_marking_picture, + disable_forensic_marking_audio ); kdms.push_back (ScreenKDM (i, kdm)); @@ -1266,13 +1451,13 @@ Film::make_kdms ( uint64_t Film::required_disk_space () const { - return _playlist->required_disk_space (j2k_bandwidth(), audio_channels(), audio_frame_rate()); + return _playlist->required_disk_space (shared_from_this(), j2k_bandwidth(), audio_channels(), audio_frame_rate()); } /** This method checks the disk that the Film is on and tries to decide whether or not * there will be enough space to make a DCP for it. If so, true is returned; if not, * false is returned and required and available are filled in with the amount of disk space - * required and available respectively (in Gb). + * required and available respectively (in GB). * * Note: the decision made by this method isn't, of course, 100% reliable. */ @@ -1309,10 +1494,9 @@ Film::subtitle_language () const { set languages; - ContentList cl = content (); - BOOST_FOREACH (shared_ptr& c, cl) { - if (c->subtitle) { - languages.insert (c->subtitle->language ()); + BOOST_FOREACH (shared_ptr i, content()) { + BOOST_FOREACH (shared_ptr j, i->text) { + languages.insert (j->language ()); } } @@ -1328,55 +1512,6 @@ Film::subtitle_language () const return all; } -/** Change the gains of the supplied AudioMapping to make it a default - * for this film. The defaults are guessed based on what processor (if any) - * is in use, the number of input channels and any filename supplied. - */ -void -Film::make_audio_mapping_default (AudioMapping& mapping, optional filename) const -{ - static string const regex[] = { - ".*[\\._-]L[\\._-].*", - ".*[\\._-]R[\\._-].*", - ".*[\\._-]C[\\._-].*", - ".*[\\._-]Lfe[\\._-].*", - ".*[\\._-]Ls[\\._-].*", - ".*[\\._-]Rs[\\._-].*" - }; - - static int const regexes = sizeof(regex) / sizeof(*regex); - - if (audio_processor ()) { - audio_processor()->make_audio_mapping_default (mapping); - } else { - mapping.make_zero (); - if (mapping.input_channels() == 1) { - bool guessed = false; - - /* See if we can guess where this stream should go */ - if (filename) { - for (int i = 0; i < regexes; ++i) { - boost::regex e (regex[i], boost::regex::icase); - if (boost::regex_match (filename->string(), e) && i < mapping.output_channels()) { - mapping.set (0, i, 1); - guessed = true; - } - } - } - - if (!guessed) { - /* If we have no idea, just put it on centre */ - mapping.set (0, static_cast (dcp::CENTRE), 1); - } - } else { - /* 1:1 mapping */ - for (int i = 0; i < min (mapping.input_channels(), mapping.output_channels()); ++i) { - mapping.set (i, i, 1); - } - } - } -} - /** @return The names of the channels that audio contents' outputs are passed into; * this is either the DCP or a AudioProcessor. */ @@ -1401,7 +1536,7 @@ Film::audio_output_names () const void Film::repeat_content (ContentList c, int n) { - _playlist->repeat (c, n); + _playlist->repeat (shared_from_this(), c, n); } void @@ -1420,7 +1555,7 @@ list Film::reels () const { list p; - DCPTime const len = length().round_up (video_frame_rate ()); + DCPTime const len = length(); switch (reel_type ()) { case REELTYPE_SINGLE: @@ -1428,24 +1563,24 @@ Film::reels () const break; case REELTYPE_BY_VIDEO_CONTENT: { - optional last_split; + DCPTime last_split; shared_ptr last_video; BOOST_FOREACH (shared_ptr c, content ()) { if (c->video) { - BOOST_FOREACH (DCPTime t, c->reel_split_points()) { - if (last_split) { - p.push_back (DCPTimePeriod (last_split.get(), t)); + BOOST_FOREACH (DCPTime t, c->reel_split_points(shared_from_this())) { + if (last_split != t) { + p.push_back (DCPTimePeriod(last_split, t)); + last_split = t; } - last_split = t; } last_video = c; } } - DCPTime video_end = last_video ? last_video->end() : DCPTime(0); - if (last_split) { + DCPTime video_end = last_video ? last_video->end(shared_from_this()) : DCPTime(0); + if (last_split != video_end) { /* Definitely go from the last split to the end of the video content */ - p.push_back (DCPTimePeriod (last_split.get(), video_end)); + p.push_back (DCPTimePeriod(last_split, video_end)); } if (video_end < len) { @@ -1471,46 +1606,13 @@ Film::reels () const return p; } +/** @param period A period within the DCP + * @return Name of the content which most contributes to the given period. + */ string Film::content_summary (DCPTimePeriod period) const { - return _playlist->content_summary (period); -} - -list -Film::fix_conflicting_settings () -{ - list notes; - - list was_referencing; - BOOST_FOREACH (shared_ptr i, content()) { - shared_ptr d = dynamic_pointer_cast (i); - if (d) { - list reasons; - bool was = false; - if (!d->can_reference_video(reasons) && d->reference_video()) { - d->set_reference_video (false); - was = true; - } - if (!d->can_reference_audio(reasons) && d->reference_audio()) { - d->set_reference_audio (false); - was = true; - } - if (!d->can_reference_subtitle(reasons) && d->reference_subtitle()) { - d->set_reference_subtitle (false); - was = true; - } - if (was) { - was_referencing.push_back (d->path(0).parent_path().filename()); - } - } - } - - BOOST_FOREACH (boost::filesystem::path d, was_referencing) { - notes.push_back (String::compose (_("The DCP %1 was being referred to by this film. This not now possible because the reel sizes in the film no longer agree with those in the imported DCP.\n\nSetting the 'Reel type' to 'split by video content' will probably help.\n\nAfter doing that you would need to re-tick the appropriate 'refer to existing DCP' checkboxes."), d.string())); - } - - return notes; + return _playlist->content_summary (shared_from_this(), period); } void @@ -1534,4 +1636,94 @@ Film::use_template (string name) _reel_type = _template_film->_reel_type; _reel_length = _template_film->_reel_length; _upload_after_make_dcp = _template_film->_upload_after_make_dcp; + _isdcf_metadata = _template_film->_isdcf_metadata; +} + +pair +Film::speed_up_range (int dcp_frame_rate) const +{ + return _playlist->speed_up_range (dcp_frame_rate); +} + +void +Film::copy_from (shared_ptr film) +{ + read_metadata (film->file (metadata_file)); +} + +bool +Film::references_dcp_video () const +{ + BOOST_FOREACH (shared_ptr i, _playlist->content()) { + shared_ptr d = dynamic_pointer_cast(i); + if (d && d->reference_video()) { + return true; + } + } + + return false; +} + +bool +Film::references_dcp_audio () const +{ + BOOST_FOREACH (shared_ptr i, _playlist->content()) { + shared_ptr d = dynamic_pointer_cast(i); + if (d && d->reference_audio()) { + return true; + } + } + + return false; +} + +list +Film::closed_caption_tracks () const +{ + list tt; + BOOST_FOREACH (shared_ptr i, content()) { + BOOST_FOREACH (shared_ptr j, 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()) { + tt.push_back (dtt); + } + } + } + + return tt; +} + +shared_ptr +Film::info_file_handle (DCPTimePeriod period, bool read) const +{ + return shared_ptr (new InfoFileHandle(_info_file_mutex, info_file(period), read)); +} + +InfoFileHandle::InfoFileHandle (boost::mutex& mutex, boost::filesystem::path file, bool read) + : _lock (mutex) + , _file (file) +{ + 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 (!_handle) { + throw OpenFileError (file, errno, exists ? OpenFileError::READ_WRITE : OpenFileError::WRITE); + } + } +} + +InfoFileHandle::~InfoFileHandle () +{ + fclose (_handle); }