X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fcontent.cc;h=7a808828939deeab28e9f80b0ebfe9a53d77ee22;hp=9a7cb0f34f68e0837862bbc96bc36aca00ab6d27;hb=df17bbd25da69fc38eb2dcd8b4a2531cf0bab0bc;hpb=0a93237cb5e4642d3b698ff9b7d0cfae5401478c diff --git a/src/lib/content.cc b/src/lib/content.cc index 9a7cb0f34..7a8088289 100644 --- a/src/lib/content.cc +++ b/src/lib/content.cc @@ -1,19 +1,20 @@ /* - Copyright (C) 2013-2014 Carl Hetherington + Copyright (C) 2013-2018 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 . */ @@ -24,14 +25,19 @@ #include "content.h" #include "util.h" #include "content_factory.h" +#include "video_content.h" +#include "audio_content.h" +#include "text_content.h" #include "exceptions.h" #include "film.h" -#include "safe_stringstream.h" #include "job.h" -#include "raw_convert.h" +#include "compose.hpp" +#include +#include #include #include #include +#include #include "i18n.h" @@ -40,16 +46,21 @@ using std::list; using std::cout; using std::vector; using std::max; +using std::pair; using boost::shared_ptr; +using boost::optional; +using dcp::raw_convert; +using dcp::locale_convert; 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) +Content::Content (shared_ptr film) + : _film (film) , _position (0) , _trim_start (0) , _trim_end (0) @@ -58,8 +69,8 @@ Content::Content (shared_ptr f) } -Content::Content (shared_ptr f, DCPTime p) - : _film (f) +Content::Content (shared_ptr film, DCPTime p) + : _film (film) , _position (p) , _trim_start (0) , _trim_end (0) @@ -68,8 +79,8 @@ Content::Content (shared_ptr f, DCPTime p) } -Content::Content (shared_ptr f, boost::filesystem::path p) - : _film (f) +Content::Content (shared_ptr film, boost::filesystem::path p) + : _film (film) , _position (0) , _trim_start (0) , _trim_end (0) @@ -78,8 +89,8 @@ Content::Content (shared_ptr f, boost::filesystem::path p) _paths.push_back (p); } -Content::Content (shared_ptr f, cxml::ConstNodePtr node) - : _film (f) +Content::Content (shared_ptr film, cxml::ConstNodePtr node) + : _film (film) , _change_signals_frequent (false) { list path_children = node->node_children ("Path"); @@ -87,27 +98,40 @@ Content::Content (shared_ptr f, cxml::ConstNodePtr node) _paths.push_back ((*i)->content ()); } _digest = node->optional_string_child ("Digest").get_value_or ("X"); - _position = DCPTime (node->number_child ("Position")); - _trim_start = DCPTime (node->number_child ("TrimStart")); - _trim_end = DCPTime (node->number_child ("TrimEnd")); + _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) +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 ()) + , _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)); } @@ -115,17 +139,22 @@ Content::Content (shared_ptr f, vector > c) } 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 (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 ())); + if (_video_frame_rate) { + node->add_child("VideoFrameRate")->add_child_text (raw_convert (_video_frame_rate.get())); + } } void @@ -134,16 +163,16 @@ Content::examine (shared_ptr job) 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 + 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. */ - string const d = md5_digest_head_tail (p, 1000000) + raw_convert (boost::filesystem::file_size (p.front ())); + string const d = digest_head_tail (p, 1000000) + raw_convert (boost::filesystem::file_size (p.front ())); lm.lock (); _digest = d; @@ -152,18 +181,27 @@ Content::examine (shared_ptr job) void Content::signal_changed (int p) { - emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent)); + try { + emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent)); + } catch (boost::bad_weak_ptr) { + /* This must be during construction; never mind */ + } } void Content::set_position (DCPTime p) { + /* video content can modify its position */ + if (video) { + video->modify_position (p); + } + { boost::mutex::scoped_lock lm (_mutex); if (p == _position) { return; } - + _position = p; } @@ -171,8 +209,13 @@ Content::set_position (DCPTime p) } void -Content::set_trim_start (DCPTime t) +Content::set_trim_start (ContentTime t) { + /* video content can modify its start trim */ + if (video) { + video->modify_trim_start (t); + } + { boost::mutex::scoped_lock lm (_mutex); _trim_start = t; @@ -182,7 +225,7 @@ Content::set_trim_start (DCPTime t) } void -Content::set_trim_end (DCPTime t) +Content::set_trim_end (ContentTime t) { { boost::mutex::scoped_lock lm (_mutex); @@ -200,11 +243,11 @@ Content::clone () const 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); + as_xml (node, true); /* notes is unused here (we assume) */ list notes; @@ -220,23 +263,21 @@ Content::technical_summary () const DCPTime Content::length_after_trim () const { - return max (DCPTime (), full_length() - trim_start() - trim_end()); + return max (DCPTime (), full_length() - DCPTime (trim_start() + trim_end(), film()->active_frame_rate_change (position ()))); } -/** @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 @@ -259,6 +300,13 @@ Content::set_path (boost::filesystem::path path) signal_changed (ContentProperty::PATH); } +void +Content::set_paths (vector paths) +{ + _paths = paths; + signal_changed (ContentProperty::PATH); +} + string Content::path_summary () const { @@ -273,3 +321,149 @@ Content::path_summary () const 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; + /* 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) +{ + { + boost::mutex::scoped_lock lm (_mutex); + _video_frame_rate = r; + } + + signal_changed (ContentProperty::VIDEO_FRAME_RATE); + + /* Make sure things are still on frame boundaries */ + if (video) { + set_position (position()); + set_trim_start (trim_start()); + } +} + +void +Content::unset_video_frame_rate () +{ + { + boost::mutex::scoped_lock lm (_mutex); + _video_frame_rate = optional(); + } + + signal_changed (ContentProperty::VIDEO_FRAME_RATE); +} + +double +Content::active_video_frame_rate () 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. + */ + shared_ptr film = _film.lock (); + DCPOMATIC_ASSERT (film); + return film->active_frame_rate_change(position()).source; +} + +void +Content::add_properties (list& p) const +{ + p.push_back (UserProperty (UserProperty::GENERAL, _("Filename"), path(0).string ())); + + 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); + } + + list >::iterator i = caption.begin (); + list >::const_iterator j = c->caption.begin (); + while (i != caption.end() && j != c->caption.end()) { + (*i)->take_settings_from (*j); + ++i; + ++j; + } +} + +shared_ptr +Content::only_caption () const +{ + DCPOMATIC_ASSERT (caption.size() < 2); + if (caption.empty ()) { + return shared_ptr (); + } + return caption.front (); +} + +shared_ptr +Content::caption_of_original_type (TextType type) const +{ + BOOST_FOREACH (shared_ptr i, caption) { + if (i->original_type() == type) { + return i; + } + } + + return shared_ptr (); +}