src/lib/content.cc

   1 /*
   2     Copyright (C) 2013-2015 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /** @file  src/lib/content.cc
  21  *  @brief Content class.
  22  */
  23
  24 #include "content.h"
  25 #include "util.h"
  26 #include "content_factory.h"
  27 #include "exceptions.h"
  28 #include "film.h"
  29 #include "safe_stringstream.h"
  30 #include "job.h"
  31 #include "compose.hpp"
  32 #include "raw_convert.h"
  33 #include <libcxml/cxml.h>
  34 #include <libxml++/libxml++.h>
  35 #include <boost/thread/mutex.hpp>
  36 #include <iostream>
  37
  38 #include "i18n.h"
  39
  40 using std::string;
  41 using std::list;
  42 using std::cout;
  43 using std::vector;
  44 using std::max;
  45 using std::pair;
  46 using boost::shared_ptr;
  47
  48 int const ContentProperty::PATH = 400;
  49 int const ContentProperty::POSITION = 401;
  50 int const ContentProperty::LENGTH = 402;
  51 int const ContentProperty::TRIM_START = 403;
  52 int const ContentProperty::TRIM_END = 404;
  53 int const ContentProperty::VIDEO_FRAME_RATE = 405;
  54
  55 Content::Content (shared_ptr<const Film> film)
  56         : _film (film)
  57         , _position (0)
  58         , _trim_start (0)
  59         , _trim_end (0)
  60         , _change_signals_frequent (false)
  61 {
  62
  63 }
  64
  65 Content::Content (shared_ptr<const Film> film, DCPTime p)
  66         : _film (film)
  67         , _position (p)
  68         , _trim_start (0)
  69         , _trim_end (0)
  70         , _change_signals_frequent (false)
  71 {
  72
  73 }
  74
  75 Content::Content (shared_ptr<const Film> film, boost::filesystem::path p)
  76         : _film (film)
  77         , _position (0)
  78         , _trim_start (0)
  79         , _trim_end (0)
  80         , _change_signals_frequent (false)
  81 {
  82         _paths.push_back (p);
  83 }
  84
  85 Content::Content (shared_ptr<const Film> film, cxml::ConstNodePtr node)
  86         : _film (film)
  87         , _change_signals_frequent (false)
  88 {
  89         list<cxml::NodePtr> path_children = node->node_children ("Path");
  90         for (list<cxml::NodePtr>::const_iterator i = path_children.begin(); i != path_children.end(); ++i) {
  91                 _paths.push_back ((*i)->content ());
  92         }
  93         _digest = node->optional_string_child ("Digest").get_value_or ("X");
  94         _position = DCPTime (node->number_child<DCPTime::Type> ("Position"));
  95         _trim_start = ContentTime (node->number_child<ContentTime::Type> ("TrimStart"));
  96         _trim_end = ContentTime (node->number_child<ContentTime::Type> ("TrimEnd"));
  97 }
  98
  99 Content::Content (shared_ptr<const Film> film, vector<shared_ptr<Content> > c)
 100         : _film (film)
 101         , _position (c.front()->position ())
 102         , _trim_start (c.front()->trim_start ())
 103         , _trim_end (c.back()->trim_end ())
 104         , _change_signals_frequent (false)
 105 {
 106         for (size_t i = 0; i < c.size(); ++i) {
 107                 if (i > 0 && c[i]->trim_start() > ContentTime ()) {
 108                         throw JoinError (_("Only the first piece of content to be joined can have a start trim."));
 109                 }
 110
 111                 if (i < (c.size() - 1) && c[i]->trim_end () > ContentTime ()) {
 112                         throw JoinError (_("Only the last piece of content to be joined can have an end trim."));
 113                 }
 114
 115                 for (size_t j = 0; j < c[i]->number_of_paths(); ++j) {
 116                         _paths.push_back (c[i]->path (j));
 117                 }
 118         }
 119 }
 120
 121 void
 122 Content::as_xml (xmlpp::Node* node) const
 123 {
 124         boost::mutex::scoped_lock lm (_mutex);
 125
 126         for (vector<boost::filesystem::path>::const_iterator i = _paths.begin(); i != _paths.end(); ++i) {
 127                 node->add_child("Path")->add_child_text (i->string ());
 128         }
 129         node->add_child("Digest")->add_child_text (_digest);
 130         node->add_child("Position")->add_child_text (raw_convert<string> (_position.get ()));
 131         node->add_child("TrimStart")->add_child_text (raw_convert<string> (_trim_start.get ()));
 132         node->add_child("TrimEnd")->add_child_text (raw_convert<string> (_trim_end.get ()));
 133 }
 134
 135 void
 136 Content::examine (shared_ptr<Job> job)
 137 {
 138         if (job) {
 139                 job->sub (_("Computing digest"));
 140         }
 141
 142         boost::mutex::scoped_lock lm (_mutex);
 143         vector<boost::filesystem::path> p = _paths;
 144         lm.unlock ();
 145
 146         /* Some content files are very big, so we use a poor man's
 147            digest here: a MD5 of the first and last 1e6 bytes with the
 148            size of the first file tacked on the end as a string.
 149         */
 150         string const d = md5_digest_head_tail (p, 1000000) + raw_convert<string> (boost::filesystem::file_size (p.front ()));
 151
 152         lm.lock ();
 153         _digest = d;
 154 }
 155
 156 void
 157 Content::signal_changed (int p)
 158 {
 159         try {
 160                 emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent));
 161         } catch (boost::bad_weak_ptr) {
 162                 /* This must be during construction; never mind */
 163         }
 164 }
 165
 166 void
 167 Content::set_position (DCPTime p)
 168 {
 169         {
 170                 boost::mutex::scoped_lock lm (_mutex);
 171                 if (p == _position) {
 172                         return;
 173                 }
 174
 175                 _position = p;
 176         }
 177
 178         signal_changed (ContentProperty::POSITION);
 179 }
 180
 181 void
 182 Content::set_trim_start (ContentTime t)
 183 {
 184         {
 185                 boost::mutex::scoped_lock lm (_mutex);
 186                 _trim_start = t;
 187         }
 188
 189         signal_changed (ContentProperty::TRIM_START);
 190 }
 191
 192 void
 193 Content::set_trim_end (ContentTime t)
 194 {
 195         {
 196                 boost::mutex::scoped_lock lm (_mutex);
 197                 _trim_end = t;
 198         }
 199
 200         signal_changed (ContentProperty::TRIM_END);
 201 }
 202
 203
 204 shared_ptr<Content>
 205 Content::clone () const
 206 {
 207         shared_ptr<const Film> film = _film.lock ();
 208         if (!film) {
 209                 return shared_ptr<Content> ();
 210         }
 211
 212         /* This is a bit naughty, but I can't think of a compelling reason not to do it ... */
 213         xmlpp::Document doc;
 214         xmlpp::Node* node = doc.create_root_node ("Content");
 215         as_xml (node);
 216
 217         /* notes is unused here (we assume) */
 218         list<string> notes;
 219         return content_factory (film, cxml::NodePtr (new cxml::Node (node)), Film::current_state_version, notes);
 220 }
 221
 222 string
 223 Content::technical_summary () const
 224 {
 225         return String::compose ("%1 %2 %3", path_summary(), digest(), position().seconds());
 226 }
 227
 228 DCPTime
 229 Content::length_after_trim () const
 230 {
 231         return max (DCPTime (), full_length() - DCPTime (trim_start() + trim_end(), film()->active_frame_rate_change (position ())));
 232 }
 233
 234 /** @return string which changes when something about this content changes which affects
 235  *  the appearance of its video.
 236  */
 237 string
 238 Content::identifier () const
 239 {
 240         SafeStringStream s;
 241
 242         s << Content::digest()
 243           << "_" << position().get()
 244           << "_" << trim_start().get()
 245           << "_" << trim_end().get();
 246
 247         return s.str ();
 248 }
 249
 250 bool
 251 Content::paths_valid () const
 252 {
 253         for (vector<boost::filesystem::path>::const_iterator i = _paths.begin(); i != _paths.end(); ++i) {
 254                 if (!boost::filesystem::exists (*i)) {
 255                         return false;
 256                 }
 257         }
 258
 259         return true;
 260 }
 261
 262 void
 263 Content::set_path (boost::filesystem::path path)
 264 {
 265         _paths.clear ();
 266         _paths.push_back (path);
 267         signal_changed (ContentProperty::PATH);
 268 }
 269
 270 string
 271 Content::path_summary () const
 272 {
 273         /* XXX: should handle multiple paths more gracefully */
 274
 275         DCPOMATIC_ASSERT (number_of_paths ());
 276
 277         string s = path(0).filename().string ();
 278         if (number_of_paths() > 1) {
 279                 s += " ...";
 280         }
 281
 282         return s;
 283 }
 284
 285 /** @return a list of properties that might be interesting to the user */
 286 list<UserProperty>
 287 Content::user_properties () const
 288 {
 289         list<UserProperty> p;
 290         add_properties (p);
 291         return p;
 292 }
 293
 294 shared_ptr<const Film>
 295 Content::film () const
 296 {
 297         shared_ptr<const Film> film = _film.lock ();
 298         DCPOMATIC_ASSERT (film);
 299         return film;
 300 }
 301
 302 /** @return DCP times of points within this content where a reel split could occur */
 303 list<DCPTime>
 304 Content::reel_split_points () const
 305 {
 306         list<DCPTime> t;
 307         /* XXX: this is questionable; perhaps the position itself should be forced to be on a frame boundary */
 308         t.push_back (position().round_up (film()->video_frame_rate()));
 309         return t;
 310 }
 311
 312 void
 313 Content::set_video_frame_rate (double r)
 314 {
 315         {
 316                 boost::mutex::scoped_lock lm (_mutex);
 317                 _video_frame_rate = r;
 318         }
 319
 320         signal_changed (ContentProperty::VIDEO_FRAME_RATE);
 321 }
 322
 323 double
 324 Content::active_video_frame_rate () const
 325 {
 326         {
 327                 boost::mutex::scoped_lock lm (_mutex);
 328                 if (_video_frame_rate) {
 329                         return _video_frame_rate.get ();
 330                 }
 331         }
 332
 333         /* No frame rate specified, so assume this content has been
 334            prepared for any concurrent video content or perhaps
 335            just the DCP rate.
 336         */
 337         shared_ptr<const Film> film = _film.lock ();
 338         DCPOMATIC_ASSERT (film);
 339         return film->active_frame_rate_change(position()).source;
 340 }