X-Git-Url: https://git.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fcontent.cc;h=ed0e9af6db855da97f095d134679dc8c421fd192;hp=ec16b961015ee19a8eb6d1b487e297879adf53e5;hb=182b9d2e2feb6545592868606aaf0f0146095481;hpb=51cc8f575b55f2a21d8503965b628c0f59f1ed33 diff --git a/src/lib/content.cc b/src/lib/content.cc index ec16b9610..ed0e9af6d 100644 --- a/src/lib/content.cc +++ b/src/lib/content.cc @@ -1,254 +1,346 @@ /* - Copyright (C) 2013-2014 Carl Hetherington + Copyright (C) 2013-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ + /** @file src/lib/content.cc * @brief Content class. */ -#include -#include -#include -#include + +#include "audio_content.h" +#include "change_signaller.h" +#include "compose.hpp" #include "content.h" -#include "util.h" #include "content_factory.h" -#include "ui_signaller.h" #include "exceptions.h" #include "film.h" -#include "safe_stringstream.h" #include "job.h" +#include "text_content.h" +#include "util.h" +#include "video_content.h" +#include +#include +#include +#include +#include +#include #include "i18n.h" -using std::string; -using std::set; -using std::list; + using std::cout; +using std::list; +using std::make_shared; +using std::shared_ptr; +using std::string; using std::vector; -using std::max; -using boost::shared_ptr; +using boost::optional; +using dcp::locale_convert; using dcp::raw_convert; +using namespace dcpomatic; + int const ContentProperty::PATH = 400; int const ContentProperty::POSITION = 401; int const ContentProperty::LENGTH = 402; int const ContentProperty::TRIM_START = 403; int const ContentProperty::TRIM_END = 404; +int const ContentProperty::VIDEO_FRAME_RATE = 405; -Content::Content (shared_ptr f) - : _film (f) - , _position (0) - , _trim_start (0) - , _trim_end (0) - , _change_signals_frequent (false) + +Content::Content () + : _change_signals_frequent (false) { } -Content::Content (shared_ptr f, DCPTime p) - : _film (f) - , _position (p) - , _trim_start (0) - , _trim_end (0) + +Content::Content (DCPTime p) + : _position (p) , _change_signals_frequent (false) { } -Content::Content (shared_ptr f, boost::filesystem::path p) - : _film (f) - , _position (0) - , _trim_start (0) - , _trim_end (0) - , _change_signals_frequent (false) + +Content::Content (boost::filesystem::path p) + : _change_signals_frequent (false) { - _paths.push_back (p); + add_path (p); } -Content::Content (shared_ptr f, cxml::ConstNodePtr node) - : _film (f) - , _change_signals_frequent (false) + +Content::Content (cxml::ConstNodePtr node) + : _change_signals_frequent (false) { - list path_children = node->node_children ("Path"); - for (list::const_iterator i = path_children.begin(); i != path_children.end(); ++i) { - _paths.push_back ((*i)->content ()); + for (auto i: node->node_children("Path")) { + _paths.push_back (i->content()); + auto const mod = i->optional_number_attribute("mtime"); + if (mod) { + _last_write_times.push_back (*mod); + } else { + boost::system::error_code ec; + auto last_write = boost::filesystem::last_write_time(i->content(), ec); + _last_write_times.push_back (ec ? 0 : last_write); + } } - _digest = node->optional_string_child ("Digest"); - _position = DCPTime (node->number_child ("Position")); - _trim_start = DCPTime (node->number_child ("TrimStart")); - _trim_end = DCPTime (node->number_child ("TrimEnd")); + _digest = node->optional_string_child ("Digest").get_value_or ("X"); + _position = DCPTime (node->number_child ("Position")); + _trim_start = ContentTime (node->number_child ("TrimStart")); + _trim_end = ContentTime (node->number_child ("TrimEnd")); + _video_frame_rate = node->optional_number_child ("VideoFrameRate"); } -Content::Content (shared_ptr f, vector > c) - : _film (f) - , _position (c.front()->position ()) - , _trim_start (c.front()->trim_start ()) - , _trim_end (c.back()->trim_end ()) + +Content::Content (vector> c) + : _position (c.front()->position()) + , _trim_start (c.front()->trim_start()) + , _trim_end (c.back()->trim_end()) + , _video_frame_rate (c.front()->video_frame_rate()) , _change_signals_frequent (false) { for (size_t i = 0; i < c.size(); ++i) { - if (i > 0 && c[i]->trim_start() > DCPTime()) { + if (i > 0 && c[i]->trim_start() > ContentTime ()) { throw JoinError (_("Only the first piece of content to be joined can have a start trim.")); } - if (i < (c.size() - 1) && c[i]->trim_end () > DCPTime()) { + if (i < (c.size() - 1) && c[i]->trim_end () > ContentTime ()) { throw JoinError (_("Only the last piece of content to be joined can have an end trim.")); } + if ( + (_video_frame_rate && !c[i]->_video_frame_rate) || + (!_video_frame_rate && c[i]->_video_frame_rate) + ) { + throw JoinError (_("Content to be joined must have the same video frame rate")); + } + + if (_video_frame_rate && fabs (_video_frame_rate.get() - c[i]->_video_frame_rate.get()) > VIDEO_FRAME_RATE_EPSILON) { + throw JoinError (_("Content to be joined must have the same video frame rate")); + } + for (size_t j = 0; j < c[i]->number_of_paths(); ++j) { - _paths.push_back (c[i]->path (j)); + _paths.push_back (c[i]->path(j)); + _last_write_times.push_back (c[i]->_last_write_times[j]); } } } + void -Content::as_xml (xmlpp::Node* node) const +Content::as_xml (xmlpp::Node* node, bool with_paths) const { boost::mutex::scoped_lock lm (_mutex); - for (vector::const_iterator i = _paths.begin(); i != _paths.end(); ++i) { - node->add_child("Path")->add_child_text (i->string ()); + if (with_paths) { + for (size_t i = 0; i < _paths.size(); ++i) { + auto p = node->add_child("Path"); + p->add_child_text (_paths[i].string()); + p->set_attribute ("mtime", raw_convert(_last_write_times[i])); + } } - if (_digest) { - node->add_child("Digest")->add_child_text (_digest.get ()); + node->add_child("Digest")->add_child_text(_digest); + node->add_child("Position")->add_child_text(raw_convert(_position.get())); + node->add_child("TrimStart")->add_child_text(raw_convert(_trim_start.get())); + node->add_child("TrimEnd")->add_child_text(raw_convert(_trim_end.get())); + if (_video_frame_rate) { + node->add_child("VideoFrameRate")->add_child_text(raw_convert(_video_frame_rate.get())); } - node->add_child("Position")->add_child_text (raw_convert (_position.get ())); - node->add_child("TrimStart")->add_child_text (raw_convert (_trim_start.get ())); - node->add_child("TrimEnd")->add_child_text (raw_convert (_trim_end.get ())); } + +string +Content::calculate_digest () const +{ + /* Some content files are very big, so we use a poor man's + digest here: a digest of the first and last 1e6 bytes with the + size of the first file tacked on the end as a string. + */ + return simple_digest (paths()); +} + + void -Content::examine (shared_ptr job, bool calculate_digest) +Content::examine (shared_ptr, shared_ptr job) { - if (!calculate_digest) { - return; + if (job) { + job->sub (_("Computing digest")); } - job->sub (_("Computing digest")); - - boost::mutex::scoped_lock lm (_mutex); - vector p = _paths; - lm.unlock (); - - string const d = md5_digest (p, job); + auto const d = calculate_digest (); - lm.lock (); + boost::mutex::scoped_lock lm (_mutex); _digest = d; + + _last_write_times.clear (); + for (auto i: _paths) { + boost::system::error_code ec; + auto last_write = boost::filesystem::last_write_time(i, ec); + _last_write_times.push_back (ec ? 0 : last_write); + } } + void -Content::signal_changed (int p) +Content::signal_change (ChangeType c, int p) { - if (ui_signaller) { - ui_signaller->emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent)); + try { + if (c == ChangeType::PENDING || c == ChangeType::CANCELLED) { + Change (c, shared_from_this(), p, _change_signals_frequent); + } else { + emit (boost::bind (boost::ref(Change), c, shared_from_this(), p, _change_signals_frequent)); + } + } catch (std::bad_weak_ptr &) { + /* This must be during construction; never mind */ } } + void -Content::set_position (DCPTime p) +Content::set_position (shared_ptr film, DCPTime p, bool force_emit) { + /* video and audio content can modify its position */ + + if (video) { + video->modify_position (film, p); + } + + /* Only allow the audio to modify if we have no video; + sometimes p can't be on an integer video AND audio frame, + and in these cases we want the video constraint to be + satisfied since (I think) the audio code is better able to + cope. + */ + if (!video && audio) { + audio->modify_position (film, p); + } + + ContentChangeSignaller cc (this, ContentProperty::POSITION); + { boost::mutex::scoped_lock lm (_mutex); - if (p == _position) { + if (p == _position && !force_emit) { + cc.abort (); return; } - + _position = p; } - - signal_changed (ContentProperty::POSITION); } + void -Content::set_trim_start (DCPTime t) +Content::set_trim_start (ContentTime t) { + DCPOMATIC_ASSERT (t.get() >= 0); + + /* video and audio content can modify its start trim */ + + if (video) { + video->modify_trim_start (t); + } + + /* See note in ::set_position */ + if (!video && audio) { + audio->modify_trim_start (t); + } + + ContentChangeSignaller cc (this, ContentProperty::TRIM_START); + { boost::mutex::scoped_lock lm (_mutex); _trim_start = t; } - - signal_changed (ContentProperty::TRIM_START); } + void -Content::set_trim_end (DCPTime t) +Content::set_trim_end (ContentTime t) { + DCPOMATIC_ASSERT (t.get() >= 0); + + ContentChangeSignaller cc (this, ContentProperty::TRIM_END); + { boost::mutex::scoped_lock lm (_mutex); _trim_end = t; } - - signal_changed (ContentProperty::TRIM_END); } shared_ptr Content::clone () const { - shared_ptr film = _film.lock (); - if (!film) { - return shared_ptr (); - } - /* This is a bit naughty, but I can't think of a compelling reason not to do it ... */ xmlpp::Document doc; - xmlpp::Node* node = doc.create_root_node ("Content"); - as_xml (node); + auto node = doc.create_root_node ("Content"); + as_xml (node, true); /* notes is unused here (we assume) */ list notes; - return content_factory (film, cxml::NodePtr (new cxml::Node (node)), Film::current_state_version, notes); + return content_factory (make_shared(node), Film::current_state_version, notes); } + string Content::technical_summary () const { - return String::compose ("%1 %2 %3", path_summary(), digest(), position().seconds()); + auto s = String::compose ("%1 %2 %3", path_summary(), digest(), position().seconds()); + if (_video_frame_rate) { + s += String::compose(" %1", *_video_frame_rate); + } + return s; } + DCPTime -Content::length_after_trim () const +Content::length_after_trim (shared_ptr film) const { - return max (DCPTime (), full_length() - trim_start() - trim_end()); + auto length = max(DCPTime(), full_length(film) - DCPTime(trim_start() + trim_end(), film->active_frame_rate_change(position()))); + if (video) { + length = length.round(film->video_frame_rate()); + } + return length; } -/** @return string which includes everything about how this content affects - * its playlist. + +/** @return string which changes when something about this content changes which affects + * the appearance of its video. */ string Content::identifier () const { - SafeStringStream s; - - s << Content::digest() - << "_" << position().get() - << "_" << trim_start().get() - << "_" << trim_end().get(); - - return s.str (); + char buffer[256]; + snprintf ( + buffer, sizeof(buffer), "%s_%" PRId64 "_%" PRId64 "_%" PRId64, + Content::digest().c_str(), position().get(), trim_start().get(), trim_end().get() + ); + return buffer; } + bool Content::paths_valid () const { - for (vector::const_iterator i = _paths.begin(); i != _paths.end(); ++i) { - if (!boost::filesystem::exists (*i)) { + for (auto i: _paths) { + if (!boost::filesystem::exists (i)) { return false; } } @@ -256,25 +348,226 @@ Content::paths_valid () const return true; } + void -Content::set_path (boost::filesystem::path path) +Content::set_paths (vector paths) { - _paths.clear (); - _paths.push_back (path); - signal_changed (ContentProperty::PATH); + ContentChangeSignaller cc (this, ContentProperty::PATH); + + { + boost::mutex::scoped_lock lm (_mutex); + _paths = paths; + _last_write_times.clear (); + for (auto i: _paths) { + boost::system::error_code ec; + auto last_write = boost::filesystem::last_write_time(i, ec); + _last_write_times.push_back (ec ? 0 : last_write); + } + } } + string Content::path_summary () const { /* XXX: should handle multiple paths more gracefully */ - assert (number_of_paths ()); + DCPOMATIC_ASSERT (number_of_paths ()); - string s = path(0).filename().string (); + auto s = path(0).filename().string(); if (number_of_paths() > 1) { s += " ..."; } return s; } + + +/** @return a list of properties that might be interesting to the user */ +list +Content::user_properties (shared_ptr film) const +{ + list p; + add_properties (film, p); + return p; +} + + +/** @return DCP times of points within this content where a reel split could occur */ +list +Content::reel_split_points (shared_ptr) const +{ + list t; + /* This is only called for video content and such content has its position forced + to start on a frame boundary. + */ + t.push_back (position()); + return t; +} + + +void +Content::set_video_frame_rate (double r) +{ + ContentChangeSignaller cc (this, ContentProperty::VIDEO_FRAME_RATE); + + { + boost::mutex::scoped_lock lm (_mutex); + if (_video_frame_rate && fabs(r - *_video_frame_rate) < VIDEO_FRAME_RATE_EPSILON) { + cc.abort(); + } + _video_frame_rate = r; + } + + /* Make sure trim is still on a frame boundary */ + if (video) { + set_trim_start (trim_start()); + } +} + + +void +Content::unset_video_frame_rate () +{ + ContentChangeSignaller cc (this, ContentProperty::VIDEO_FRAME_RATE); + + { + boost::mutex::scoped_lock lm (_mutex); + _video_frame_rate = optional(); + } +} + + +double +Content::active_video_frame_rate (shared_ptr film) const +{ + { + boost::mutex::scoped_lock lm (_mutex); + if (_video_frame_rate) { + return _video_frame_rate.get (); + } + } + + /* No frame rate specified, so assume this content has been + prepared for any concurrent video content or perhaps + just the DCP rate. + */ + return film->active_frame_rate_change(position()).source; +} + + +void +Content::add_properties (shared_ptr, list& p) const +{ + auto paths_to_show = std::min(number_of_paths(), size_t{8}); + string paths = ""; + for (auto i = size_t{0}; i < paths_to_show; ++i) { + paths += path(i).string(); + if (i < (paths_to_show - 1)) { + paths += "\n"; + } + } + if (paths_to_show < number_of_paths()) { + paths += String::compose("... and %1 more", number_of_paths() - paths_to_show); + } + p.push_back ( + UserProperty( + UserProperty::GENERAL, + paths_to_show > 1 ? _("Filenames") : _("Filename"), + paths + ) + ); + + if (_video_frame_rate) { + if (video) { + p.push_back ( + UserProperty ( + UserProperty::VIDEO, + _("Frame rate"), + locale_convert (_video_frame_rate.get(), 5), + _("frames per second") + ) + ); + } else { + p.push_back ( + UserProperty ( + UserProperty::GENERAL, + _("Prepared for video frame rate"), + locale_convert (_video_frame_rate.get(), 5), + _("frames per second") + ) + ); + } + } +} + + +/** Take settings from the given content if it is of the correct type */ +void +Content::take_settings_from (shared_ptr c) +{ + if (video && c->video) { + video->take_settings_from (c->video); + } + if (audio && c->audio) { + audio->take_settings_from (c->audio); + } + + auto i = text.begin (); + auto j = c->text.begin (); + while (i != text.end() && j != c->text.end()) { + (*i)->take_settings_from (*j); + ++i; + ++j; + } +} + + +shared_ptr +Content::only_text () const +{ + DCPOMATIC_ASSERT (text.size() < 2); + if (text.empty()) { + return {}; + } + return text.front (); +} + + +shared_ptr +Content::text_of_original_type (TextType type) const +{ + for (auto i: text) { + if (i->original_type() == type) { + return i; + } + } + + return {}; +} + + +void +Content::add_path (boost::filesystem::path p) +{ + boost::mutex::scoped_lock lm (_mutex); + _paths.push_back (p); + boost::system::error_code ec; + auto last_write = boost::filesystem::last_write_time(p, ec); + _last_write_times.push_back (ec ? 0 : last_write); +} + + +bool +Content::changed () const +{ + bool write_time_changed = false; + for (auto i = 0U; i < _paths.size(); ++i) { + if (boost::filesystem::last_write_time(_paths[i]) != last_write_time(i)) { + write_time_changed = true; + break; + } + } + + return (write_time_changed || calculate_digest() != digest()); +}