src/lib/content.cc

   1 /*
   2     Copyright (C) 2013 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 #include <boost/thread/mutex.hpp>
  21 #include <libxml++/libxml++.h>
  22 #include <libcxml/cxml.h>
  23 #include "content.h"
  24 #include "util.h"
  25 #include "content_factory.h"
  26 #include "ui_signaller.h"
  27 #include "exceptions.h"
  28
  29 #include "i18n.h"
  30
  31 using std::string;
  32 using std::stringstream;
  33 using std::set;
  34 using std::list;
  35 using std::cout;
  36 using std::vector;
  37 using boost::shared_ptr;
  38 using boost::lexical_cast;
  39
  40 int const ContentProperty::PATH = 400;
  41 int const ContentProperty::POSITION = 401;
  42 int const ContentProperty::LENGTH = 402;
  43 int const ContentProperty::TRIM_START = 403;
  44 int const ContentProperty::TRIM_END = 404;
  45
  46 Content::Content (shared_ptr<const Film> f)
  47         : _film (f)
  48         , _position (0)
  49         , _trim_start (0)
  50         , _trim_end (0)
  51         , _change_signals_frequent (false)
  52 {
  53
  54 }
  55
  56 Content::Content (shared_ptr<const Film> f, Time p)
  57         : _film (f)
  58         , _position (p)
  59         , _trim_start (0)
  60         , _trim_end (0)
  61         , _change_signals_frequent (false)
  62 {
  63
  64 }
  65
  66 Content::Content (shared_ptr<const Film> f, boost::filesystem::path p)
  67         : _film (f)
  68         , _position (0)
  69         , _trim_start (0)
  70         , _trim_end (0)
  71         , _change_signals_frequent (false)
  72 {
  73         _paths.push_back (p);
  74 }
  75
  76 Content::Content (shared_ptr<const Film> f, shared_ptr<const cxml::Node> node)
  77         : _film (f)
  78         , _change_signals_frequent (false)
  79 {
  80         list<cxml::NodePtr> path_children = node->node_children ("Path");
  81         for (list<cxml::NodePtr>::const_iterator i = path_children.begin(); i != path_children.end(); ++i) {
  82                 _paths.push_back ((*i)->content ());
  83         }
  84         _digest = node->string_child ("Digest");
  85         _position = node->number_child<Time> ("Position");
  86         _trim_start = node->number_child<Time> ("TrimStart");
  87         _trim_end = node->number_child<Time> ("TrimEnd");
  88 }
  89
  90 Content::Content (shared_ptr<const Film> f, vector<shared_ptr<Content> > c)
  91         : _film (f)
  92         , _position (c.front()->position ())
  93         , _trim_start (c.front()->trim_start ())
  94         , _trim_end (c.back()->trim_end ())
  95         , _change_signals_frequent (false)
  96 {
  97         for (size_t i = 0; i < c.size(); ++i) {
  98                 if (i > 0 && c[i]->trim_start ()) {
  99                         throw JoinError (_("Only the first piece of content to be joined can have a start trim."));
 100                 }
 101
 102                 if (i < (c.size() - 1) && c[i]->trim_end ()) {
 103                         throw JoinError (_("Only the last piece of content to be joined can have an end trim."));
 104                 }
 105         }
 106 }
 107
 108 void
 109 Content::as_xml (xmlpp::Node* node) const
 110 {
 111         boost::mutex::scoped_lock lm (_mutex);
 112
 113         for (vector<boost::filesystem::path>::const_iterator i = _paths.begin(); i != _paths.end(); ++i) {
 114                 node->add_child("Path")->add_child_text (i->string ());
 115         }
 116         node->add_child("Digest")->add_child_text (_digest);
 117         node->add_child("Position")->add_child_text (lexical_cast<string> (_position));
 118         node->add_child("TrimStart")->add_child_text (lexical_cast<string> (_trim_start));
 119         node->add_child("TrimEnd")->add_child_text (lexical_cast<string> (_trim_end));
 120 }
 121
 122 void
 123 Content::examine (shared_ptr<Job> job)
 124 {
 125         boost::mutex::scoped_lock lm (_mutex);
 126         vector<boost::filesystem::path> p = _paths;
 127         lm.unlock ();
 128
 129         string const d = md5_digest (p, job);
 130
 131         lm.lock ();
 132         _digest = d;
 133 }
 134
 135 void
 136 Content::signal_changed (int p)
 137 {
 138         if (ui_signaller) {
 139                 ui_signaller->emit (boost::bind (boost::ref (Changed), shared_from_this (), p, _change_signals_frequent));
 140         }
 141 }
 142
 143 void
 144 Content::set_position (Time p)
 145 {
 146         {
 147                 boost::mutex::scoped_lock lm (_mutex);
 148                 _position = p;
 149         }
 150
 151         signal_changed (ContentProperty::POSITION);
 152 }
 153
 154 void
 155 Content::set_trim_start (Time t)
 156 {
 157         {
 158                 boost::mutex::scoped_lock lm (_mutex);
 159                 _trim_start = t;
 160         }
 161
 162         signal_changed (ContentProperty::TRIM_START);
 163 }
 164
 165 void
 166 Content::set_trim_end (Time t)
 167 {
 168         {
 169                 boost::mutex::scoped_lock lm (_mutex);
 170                 _trim_end = t;
 171         }
 172
 173         signal_changed (ContentProperty::TRIM_END);
 174 }
 175
 176
 177 shared_ptr<Content>
 178 Content::clone () const
 179 {
 180         shared_ptr<const Film> film = _film.lock ();
 181         if (!film) {
 182                 return shared_ptr<Content> ();
 183         }
 184
 185         /* This is a bit naughty, but I can't think of a compelling reason not to do it ... */
 186         xmlpp::Document doc;
 187         xmlpp::Node* node = doc.create_root_node ("Content");
 188         as_xml (node);
 189         return content_factory (film, cxml::NodePtr(new cxml::Node (node)));
 190 }
 191
 192 string
 193 Content::technical_summary () const
 194 {
 195         return String::compose ("%1 %2 %3", path_summary(), digest(), position());
 196 }
 197
 198 Time
 199 Content::length_after_trim () const
 200 {
 201         return full_length() - trim_start() - trim_end();
 202 }
 203
 204 /** @param t A time relative to the start of this content (not the position).
 205  *  @return true if this time is trimmed by our trim settings.
 206  */
 207 bool
 208 Content::trimmed (Time t) const
 209 {
 210         return (t < trim_start() || t > (full_length() - trim_end ()));
 211 }
 212
 213 /** @return string which includes everything about how this content affects
 214  *  its playlist.
 215  */
 216 string
 217 Content::identifier () const
 218 {
 219         stringstream s;
 220
 221         s << Content::digest()
 222           << "_" << position()
 223           << "_" << trim_start()
 224           << "_" << trim_end();
 225
 226         return s.str ();
 227 }
 228
 229 bool
 230 Content::path_valid () const
 231 {
 232         for (vector<boost::filesystem::path>::const_iterator i = _paths.begin(); i != _paths.end(); ++i) {
 233                 if (!boost::filesystem::exists (*i)) {
 234                         return false;
 235                 }
 236         }
 237
 238         return true;
 239 }
 240
 241 void
 242 Content::set_path (boost::filesystem::path path)
 243 {
 244         _paths.clear ();
 245         _paths.push_back (path);
 246         signal_changed (ContentProperty::PATH);
 247 }
 248
 249 string
 250 Content::path_summary () const
 251 {
 252         /* XXX: should handle multiple paths more gracefully */
 253
 254         string s = path(0).filename().string ();
 255         if (number_of_paths() > 1) {
 256                 s += " ...";
 257         }
 258
 259         return s;
 260 }