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