X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fcontent.cc;h=724cabb6c6ce28f4bf1d5057e08dc062ab07b525;hb=be511f16fa59cb97d0f671546de2055baea1cabf;hp=2fb94e9598ae621228441dc47eb8331a13258956;hpb=127672223cca569986e35c91265e269ed5a6561c;p=dcpomatic.git diff --git a/src/lib/content.cc b/src/lib/content.cc index 2fb94e959..724cabb6c 100644 --- a/src/lib/content.cc +++ b/src/lib/content.cc @@ -1,20 +1,305 @@ -#include +/* + Copyright (C) 2013-2015 Carl Hetherington + + This program 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, + 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. + +*/ + +/** @file src/lib/content.cc + * @brief Content class. + */ + #include "content.h" #include "util.h" +#include "content_factory.h" +#include "exceptions.h" +#include "film.h" +#include "safe_stringstream.h" +#include "job.h" +#include "compose.hpp" +#include "raw_convert.h" +#include +#include +#include +#include + +#include "i18n.h" using std::string; +using std::list; +using std::cout; +using std::vector; +using std::max; +using std::pair; using boost::shared_ptr; -Content::Content (boost::filesystem::path f) - : _file (f) +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; + +Content::Content (shared_ptr film) + : _film (film) + , _position (0) + , _trim_start (0) + , _trim_end (0) + , _change_signals_frequent (false) +{ + +} + +Content::Content (shared_ptr film, DCPTime p) + : _film (film) + , _position (p) + , _trim_start (0) + , _trim_end (0) + , _change_signals_frequent (false) +{ + +} + +Content::Content (shared_ptr film, boost::filesystem::path p) + : _film (film) + , _position (0) + , _trim_start (0) + , _trim_end (0) + , _change_signals_frequent (false) { + _paths.push_back (p); +} +Content::Content (shared_ptr film, cxml::ConstNodePtr node) + : _film (film) + , _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 ()); + } + _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")); +} + +Content::Content (shared_ptr film, vector > c) + : _film (film) + , _position (c.front()->position ()) + , _trim_start (c.front()->trim_start ()) + , _trim_end (c.back()->trim_end ()) + , _change_signals_frequent (false) +{ + for (size_t i = 0; i < c.size(); ++i) { + 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 () > ContentTime ()) { + throw JoinError (_("Only the last piece of content to be joined can have an end trim.")); + } + + for (size_t j = 0; j < c[i]->number_of_paths(); ++j) { + _paths.push_back (c[i]->path (j)); + } + } +} + +void +Content::as_xml (xmlpp::Node* node) 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 ()); + } + 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 ())); } void -Content::examine (shared_ptr, shared_ptr, bool) +Content::examine (shared_ptr job) { - string const d = md5_digest (_file); + if (job) { + job->sub (_("Computing digest")); + } + boost::mutex::scoped_lock lm (_mutex); + vector p = _paths; + lm.unlock (); + + /* Some content files are very big, so we use a poor man's + digest here: a MD5 of the first and last 1e6 bytes with the + size of the first file tacked on the end as a string. + */ + string const d = md5_digest_head_tail (p, 1000000) + raw_convert (boost::filesystem::file_size (p.front ())); + + lm.lock (); _digest = d; } + +void +Content::signal_changed (int p) +{ + emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent)); +} + +void +Content::set_position (DCPTime p) +{ + { + boost::mutex::scoped_lock lm (_mutex); + if (p == _position) { + return; + } + + _position = p; + } + + signal_changed (ContentProperty::POSITION); +} + +void +Content::set_trim_start (ContentTime t) +{ + { + boost::mutex::scoped_lock lm (_mutex); + _trim_start = t; + } + + signal_changed (ContentProperty::TRIM_START); +} + +void +Content::set_trim_end (ContentTime t) +{ + { + 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); + + /* notes is unused here (we assume) */ + list notes; + return content_factory (film, cxml::NodePtr (new cxml::Node (node)), Film::current_state_version, notes); +} + +string +Content::technical_summary () const +{ + return String::compose ("%1 %2 %3", path_summary(), digest(), position().seconds()); +} + +DCPTime +Content::length_after_trim () const +{ + return max (DCPTime (), full_length() - DCPTime (trim_start() + trim_end(), film()->active_frame_rate_change (position ()))); +} + +/** @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 (); +} + +bool +Content::paths_valid () const +{ + for (vector::const_iterator i = _paths.begin(); i != _paths.end(); ++i) { + if (!boost::filesystem::exists (*i)) { + return false; + } + } + + return true; +} + +void +Content::set_path (boost::filesystem::path path) +{ + _paths.clear (); + _paths.push_back (path); + signal_changed (ContentProperty::PATH); +} + +string +Content::path_summary () const +{ + /* XXX: should handle multiple paths more gracefully */ + + DCPOMATIC_ASSERT (number_of_paths ()); + + string 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 () const +{ + list p; + add_properties (p); + return p; +} + +shared_ptr +Content::film () const +{ + shared_ptr film = _film.lock (); + DCPOMATIC_ASSERT (film); + return film; +} + +/** @return DCP times of points within this content where a reel split could occur */ +list +Content::reel_split_points () const +{ + list t; + /* XXX: this is questionable; perhaps the position itself should be forced to be on a frame boundary */ + t.push_back (position().round_up (film()->video_frame_rate())); + return t; +}