*/
-#include "content.h"
+#include "audio_content.h"
#include "change_signaller.h"
-#include "util.h"
+#include "compose.hpp"
+#include "content.h"
#include "content_factory.h"
-#include "video_content.h"
-#include "audio_content.h"
-#include "text_content.h"
#include "exceptions.h"
#include "film.h"
#include "job.h"
-#include "compose.hpp"
+#include "text_content.h"
+#include "util.h"
+#include "video_content.h"
#include <dcp/locale_convert.h>
#include <dcp/raw_convert.h>
#include <libcxml/cxml.h>
Content::Content ()
- : _change_signals_frequent (false)
{
}
Content::Content (DCPTime p)
: _position (p)
- , _change_signals_frequent (false)
{
}
Content::Content (boost::filesystem::path p)
- : _change_signals_frequent (false)
{
add_path (p);
}
Content::Content (cxml::ConstNodePtr node)
- : _change_signals_frequent (false)
{
for (auto i: node->node_children("Path")) {
_paths.push_back (i->content());
_last_write_times.push_back (*mod);
} else {
boost::system::error_code ec;
- auto last_write = boost::filesystem::last_write_time(i->content(), ec);
+ auto last_write = dcp::filesystem::last_write_time(i->content(), ec);
_last_write_times.push_back (ec ? 0 : last_write);
}
}
, _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() > ContentTime ()) {
string
Content::calculate_digest () const
{
- boost::mutex::scoped_lock lm (_mutex);
- auto p = _paths;
- lm.unlock ();
-
/* Some content files are very big, so we use a poor man's
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.
*/
- return digest_head_tail(p, 1000000) + raw_convert<string>(boost::filesystem::file_size(p.front()));
+ return simple_digest (paths());
}
_last_write_times.clear ();
for (auto i: _paths) {
boost::system::error_code ec;
- auto last_write = boost::filesystem::last_write_time(i, ec);
+ auto last_write = dcp::filesystem::last_write_time(i, ec);
_last_write_times.push_back (ec ? 0 : last_write);
}
}
void
-Content::set_trim_start (ContentTime t)
+Content::set_trim_start(shared_ptr<const Film> film, ContentTime t)
{
DCPOMATIC_ASSERT (t.get() >= 0);
/* See note in ::set_position */
if (!video && audio) {
- audio->modify_trim_start (t);
+ audio->modify_trim_start(film, t);
}
ContentChangeSignaller cc (this, ContentProperty::TRIM_START);
{
boost::mutex::scoped_lock lm (_mutex);
- _trim_start = t;
+ if (_trim_start == t) {
+ cc.abort();
+ } else {
+ _trim_start = t;
+ }
}
}
Content::paths_valid () const
{
for (auto i: _paths) {
- if (!boost::filesystem::exists (i)) {
+ if (!dcp::filesystem::exists(i)) {
return false;
}
}
_last_write_times.clear ();
for (auto i: _paths) {
boost::system::error_code ec;
- auto last_write = boost::filesystem::last_write_time(i, ec);
+ auto last_write = dcp::filesystem::last_write_time(i, ec);
_last_write_times.push_back (ec ? 0 : last_write);
}
}
void
-Content::set_video_frame_rate (double r)
+Content::set_video_frame_rate(shared_ptr<const Film> film, double r)
{
ContentChangeSignaller cc (this, ContentProperty::VIDEO_FRAME_RATE);
/* Make sure trim is still on a frame boundary */
if (video) {
- set_trim_start (trim_start());
+ set_trim_start(film, trim_start());
}
}
void
Content::add_properties (shared_ptr<const Film>, list<UserProperty>& p) const
{
- p.push_back (UserProperty (UserProperty::GENERAL, _("Filename"), path(0).string ()));
+ auto paths_to_show = std::min(number_of_paths(), size_t{8});
+ string paths = "";
+ for (auto i = size_t{0}; i < paths_to_show; ++i) {
+ paths += path(i).string();
+ if (i < (paths_to_show - 1)) {
+ paths += "\n";
+ }
+ }
+ if (paths_to_show < number_of_paths()) {
+ paths += String::compose("... and %1 more", number_of_paths() - paths_to_show);
+ }
+ p.push_back (
+ UserProperty(
+ UserProperty::GENERAL,
+ paths_to_show > 1 ? _("Filenames") : _("Filename"),
+ paths
+ )
+ );
if (_video_frame_rate) {
if (video) {
boost::mutex::scoped_lock lm (_mutex);
_paths.push_back (p);
boost::system::error_code ec;
- auto last_write = boost::filesystem::last_write_time(p, ec);
+ auto last_write = dcp::filesystem::last_write_time(p, ec);
_last_write_times.push_back (ec ? 0 : last_write);
}
{
bool write_time_changed = false;
for (auto i = 0U; i < _paths.size(); ++i) {
- if (boost::filesystem::last_write_time(_paths[i]) != last_write_time(i)) {
+ if (dcp::filesystem::last_write_time(_paths[i]) != last_write_time(i)) {
write_time_changed = true;
break;
}