player->Audio.connect (bind (&AnalyseAudioJob::audio, this, _1, _2));
- _samples_per_point = max (int64_t (1), _film->time_to_audio_frames (_film->length()) / _num_points);
+ _samples_per_point = max (int64_t (1), _film->time_to_audio_frames (_film->length_without_loop()) / _num_points);
_current.resize (_film->dcp_audio_channels ());
_analysis.reset (new AudioAnalysis (_film->dcp_audio_channels ()));
_done = 0;
while (!player->pass ()) {
- set_progress (double (_film->audio_frames_to_time (_done)) / _film->length ());
+ set_progress (double (_film->audio_frames_to_time (_done)) / _film->length_without_loop ());
}
_analysis->write (content->audio_analysis_path ());
#include <libcxml/cxml.h>
#include "content.h"
#include "util.h"
+#include "content_factory.h"
using std::string;
using std::set;
signal_changed (ContentProperty::START);
}
+
+shared_ptr<Content>
+Content::clone () const
+{
+ shared_ptr<const Film> film = _film.lock ();
+ if (!film) {
+ return shared_ptr<Content> ();
+ }
+
+ /* 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);
+ return content_factory (film, shared_ptr<cxml::Node> (new cxml::Node (node)));
+}
virtual void as_xml (xmlpp::Node *) const;
virtual Time length () const = 0;
+ boost::shared_ptr<Content> clone () const;
+
boost::filesystem::path file () const {
boost::mutex::scoped_lock lm (_mutex);
return _file;
--- /dev/null
+/*
+ Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
+
+ This program 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,
+ 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.
+
+*/
+
+#include <libcxml/cxml.h>
+#include "ffmpeg_content.h"
+#include "imagemagick_content.h"
+#include "sndfile_content.h"
+
+using std::string;
+using boost::shared_ptr;
+
+shared_ptr<Content>
+content_factory (shared_ptr<const Film> film, shared_ptr<cxml::Node> node)
+{
+ string const type = node->string_child ("Type");
+
+ boost::shared_ptr<Content> content;
+
+ if (type == "FFmpeg") {
+ content.reset (new FFmpegContent (film, node));
+ } else if (type == "ImageMagick") {
+ content.reset (new ImageMagickContent (film, node));
+ } else if (type == "Sndfile") {
+ content.reset (new SndfileContent (film, node));
+ }
+
+ return content;
+}
--- /dev/null
+/*
+ Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
+
+ This program 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,
+ 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.
+
+*/
+
+class Film;
+
+extern boost::shared_ptr<Content> content_factory (boost::shared_ptr<const Film>, boost::shared_ptr<cxml::Node>);
throw MissingSettingError (_("container"));
}
- if (_playlist->content().empty ()) {
+ if (content_without_loop().empty()) {
throw StringError (_("You must add some content to the DCP before creating it"));
}
}
Playlist::ContentList
-Film::content () const
+Film::content_without_loop () const
{
- return _playlist->content ();
+ return _playlist->content_without_loop ();
}
void
}
Time
-Film::length () const
+Film::length_with_loop () const
{
- return _playlist->length ();
+ return _playlist->length_with_loop ();
+}
+
+Time
+Film::length_without_loop () const
+{
+ return _playlist->length_without_loop ();
}
bool
/* Proxies for some Playlist methods */
- Playlist::ContentList content () const;
+ Playlist::ContentList content_without_loop () const;
- Time length () const;
+ Time length_with_loop () const;
+ Time length_without_loop () const;
bool has_subtitles () const;
OutputVideoFrame best_dcp_video_frame_rate () const;
using boost::weak_ptr;
using boost::dynamic_pointer_cast;
-//#define DEBUG_PLAYER 1
+#define DEBUG_PLAYER 1
class Piece
{
_pieces.clear ();
- Playlist::ContentList content = _playlist->content ();
+ Playlist::ContentList content = _playlist->content_with_loop ();
sort (content.begin(), content.end(), ContentSorter ());
for (Playlist::ContentList::iterator i = content.begin(); i != content.end(); ++i) {
#include "ffmpeg_content.h"
#include "imagemagick_decoder.h"
#include "imagemagick_content.h"
+#include "content_factory.h"
#include "job.h"
#include "config.h"
#include "util.h"
{
list<shared_ptr<cxml::Node> > c = node->node_children ("Content");
for (list<shared_ptr<cxml::Node> >::iterator i = c.begin(); i != c.end(); ++i) {
- string const type = (*i)->string_child ("Type");
-
- boost::shared_ptr<Content> content;
-
- if (type == "FFmpeg") {
- content.reset (new FFmpegContent (film, *i));
- } else if (type == "ImageMagick") {
- content.reset (new ImageMagickContent (film, *i));
- } else if (type == "Sndfile") {
- content.reset (new SndfileContent (film, *i));
- }
-
- _content.push_back (content);
+ _content.push_back (content_factory (film, *i));
}
reconnect ();
}
Time
-Playlist::length () const
+Playlist::length_without_loop () const
{
Time len = 0;
for (ContentList::const_iterator i = _content.begin(); i != _content.end(); ++i) {
return len;
}
+Time
+Playlist::length_with_loop () const
+{
+ return length_without_loop() * _loop;
+}
+
void
Playlist::reconnect ()
{
{
return a->start() < b->start();
}
+
+/** @return content in an undefined order, not taking looping into account */
+Playlist::ContentList
+Playlist::content_without_loop () const
+{
+ return _content;
+}
+
+/** @return content in an undefined order, taking looping into account */
+Playlist::ContentList
+Playlist::content_with_loop () const
+{
+ ContentList looped = _content;
+ Time const length = length_without_loop ();
+
+ Time offset = length;
+ for (int i = 1; i < _loop; ++i) {
+ for (ContentList::const_iterator i = _content.begin(); i != _content.end(); ++i) {
+ shared_ptr<Content> copy = (*i)->clone ();
+ copy->set_start (copy->start() + offset);
+ looped.push_back (copy);
+ }
+ offset += length;
+ }
+
+ return looped;
+}
* @brief A set of content files (video and audio), with knowledge of how they should be arranged into
* a DCP.
*
- * This class holds Content objects, and it knows how they should be arranged. At the moment
- * the ordering is implicit; video content is placed sequentially, and audio content is taken
- * from the video unless any sound-only files are present. If sound-only files exist, they
- * are played simultaneously (i.e. they can be split up into multiple files for different channels)
+ * This class holds Content objects, and it knows how they should be arranged.
*/
struct ContentSorter
bool has_subtitles () const;
typedef std::vector<boost::shared_ptr<Content> > ContentList;
-
- ContentList content () const {
- return _content;
- }
+
+ ContentList content_without_loop () const;
+ ContentList content_with_loop () const;
std::string video_identifier () const;
void set_loop (int l);
- Time length () const;
+ Time length_without_loop () const;
+ Time length_with_loop () const;
+
int best_dcp_frame_rate () const;
Time video_end () const;
}
/* Compute approximate proposed length here, as it's only here that we need it */
- OutputVideoFrame const left = _film->time_to_video_frames (_film->length ()) - _transcoder->video_frames_out();
+ OutputVideoFrame const left = _film->time_to_video_frames (_film->length_with_loop ()) - _transcoder->video_frames_out();
return left / fps;
}
}
lock.lock ();
- if (_film->length ()) {
- _job->set_progress (float(_full_written + _fake_written + _repeat_written) / _film->time_to_video_frames (_film->length()));
+ if (_film->length_with_loop()) {
+ _job->set_progress (
+ float (_full_written + _fake_written + _repeat_written) / _film->time_to_video_frames (_film->length_with_loop())
+ );
}
++_last_written_frame;
audio_mapping.cc
config.cc
content.cc
+ content_factory.cc
cross.cc
dci_metadata.cc
dcp_content_type.cc
film_changed (Film::DCP_VIDEO_FRAME_RATE);
film_changed (Film::DCP_AUDIO_CHANNELS);
- if (!_film->content().empty ()) {
- set_selection (_film->content().front ());
+ if (!_film->content_without_loop().empty ()) {
+ set_selection (_film->content_without_loop().front ());
}
wxListEvent ev;
_content->DeleteAllItems ();
- Playlist::ContentList content = _film->content ();
+ Playlist::ContentList content = _film->content_without_loop ();
for (Playlist::ContentList::iterator i = content.begin(); i != content.end(); ++i) {
int const t = _content->GetItemCount ();
_content->InsertItem (t, std_to_wx ((*i)->summary ()));
return shared_ptr<Content> ();
}
- Playlist::ContentList c = _film->content ();
+ Playlist::ContentList c = _film->content_without_loop ();
if (s < 0 || size_t (s) >= c.size ()) {
return shared_ptr<Content> ();
}
void
FilmEditor::set_selection (weak_ptr<Content> wc)
{
- Playlist::ContentList content = _film->content ();
+ Playlist::ContentList content = _film->content_without_loop ();
for (size_t i = 0; i < content.size(); ++i) {
if (content[i] == wc.lock ()) {
_content->SetItemState (i, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
fetch_next_frame ();
- if (_film->length()) {
- int const new_slider_position = 4096 * _player->video_position() / _film->length();
+ Time const len = _film->length_with_loop ();
+
+ if (len) {
+ int const new_slider_position = 4096 * _player->video_position() / len;
if (new_slider_position != _slider->GetValue()) {
_slider->SetValue (new_slider_position);
}
FilmViewer::slider_moved (wxScrollEvent &)
{
if (_film && _player) {
- _player->seek (_slider->GetValue() * _film->length() / 4096, false);
+ _player->seek (_slider->GetValue() * _film->length_with_loop() / 4096, false);
fetch_next_frame ();
}
}
_encoded = new ThreadedStaticText (this, _("counting..."), boost::bind (&PropertiesDialog::frames_already_encoded, this));
table->Add (_encoded, 1, wxALIGN_CENTER_VERTICAL);
- _frames->SetLabel (std_to_wx (lexical_cast<string> (_film->time_to_video_frames (_film->length()))));
- double const disk = ((double) _film->j2k_bandwidth() / 8) * _film->length() / (TIME_HZ * 1073741824.0f);
+ _frames->SetLabel (std_to_wx (lexical_cast<string> (_film->time_to_video_frames (_film->length_with_loop()))));
+ double const disk = ((double) _film->j2k_bandwidth() / 8) * _film->length_with_loop() / (TIME_HZ * 1073741824.0f);
stringstream s;
s << fixed << setprecision (1) << disk << wx_to_std (_("Gb"));
_disk->SetLabel (std_to_wx (s.str ()));
return "";
}
- if (_film->length()) {
+ if (_film->length_with_loop()) {
/* XXX: encoded_frames() should check which frames have been encoded */
- u << " (" << (_film->encoded_frames() * 100 / _film->time_to_video_frames (_film->length())) << "%)";
+ u << " (" << (_film->encoded_frames() * 100 / _film->time_to_video_frames (_film->length_with_loop())) << "%)";
}
return u.str ();
}
using boost::dynamic_pointer_cast;
using boost::bind;
-class View
+class View : public boost::noncopyable
{
public:
View (Timeline& t)
void paint (wxGraphicsContext* g)
{
+ cout << "base paint " << this << "\n";
_last_paint_bbox = bbox ();
do_paint (g);
}
dcpomatic::Rect<int> bbox () const
{
shared_ptr<const Film> film = _timeline.film ();
- shared_ptr<const Content> content = _content.lock ();
- if (!film || !content) {
+ if (!film) {
return dcpomatic::Rect<int> ();
}
return dcpomatic::Rect<int> (
- time_x (content->start ()) - 8,
+ time_x (_content->start ()) - 8,
y_pos (_track) - 8,
- content->length () * _timeline.pixels_per_time_unit() + 16,
+ _content->length () * _timeline.pixels_per_time_unit() + 16,
_timeline.track_height() + 16
);
}
return _selected;
}
- weak_ptr<Content> content () const {
+ shared_ptr<Content> content () const {
return _content;
}
void do_paint (wxGraphicsContext* gc)
{
shared_ptr<const Film> film = _timeline.film ();
- shared_ptr<const Content> content = _content.lock ();
- if (!film || !content) {
+ if (!film) {
return;
}
- Time const start = content->start ();
- Time const len = content->length ();
+ Time const start = _content->start ();
+ Time const len = _content->length ();
wxColour selected (colour().Red() / 2, colour().Green() / 2, colour().Blue() / 2);
} else {
gc->SetBrush (*wxTheBrushList->FindOrCreateBrush (colour(), wxBRUSHSTYLE_SOLID));
}
+
+ cout << "paint " << static_cast<View*> (this) << " " << _content.get() << " @ " << time_x (start) << "\n";
wxGraphicsPath path = gc->CreatePath ();
path.MoveToPoint (time_x (start), y_pos (_track) + 4);
gc->StrokePath (path);
gc->FillPath (path);
- wxString name = wxString::Format (wxT ("%s [%s]"), std_to_wx (content->file().filename().string()).data(), type().data());
+ wxString name = wxString::Format (wxT ("%s [%s]"), std_to_wx (_content->file().filename().string()).data(), type().data());
wxDouble name_width;
wxDouble name_height;
wxDouble name_descent;
}
}
- boost::weak_ptr<Content> _content;
+ /* This must be a shared_ptr, not a weak_ptr, as in the looped case this
+ will be the only remaining pointer to the looped content that we get
+ from the playlist.
+ */
+ boost::shared_ptr<Content> _content;
int _track;
bool _selected;
gc->SetFont (gc->CreateFont (*wxNORMAL_FONT));
+ cout << "painting " << _views.size() << "\n";
for (list<shared_ptr<View> >::iterator i = _views.begin(); i != _views.end(); ++i) {
(*i)->paint (gc);
}
return;
}
+ cout << "clearing views.\n";
_views.clear ();
- Playlist::ContentList content = fl->playlist()->content ();
+ Playlist::ContentList content = fl->playlist()->content_with_loop ();
for (Playlist::ContentList::iterator i = content.begin(); i != content.end(); ++i) {
if (dynamic_pointer_cast<VideoContent> (*i)) {
continue;
}
- shared_ptr<Content> acv_content = acv->content().lock ();
- assert (acv_content);
+ shared_ptr<Content> acv_content = acv->content();
int t = 1;
while (1) {
continue;
}
- shared_ptr<Content> test_content = test->content().lock ();
- assert (test_content);
+ shared_ptr<Content> test_content = test->content();
if (test && test->track() == t) {
- if ((acv_content->start() <= test_content->start() && test_content->start() <= acv_content->end()) ||
- (acv_content->start() <= test_content->end() && test_content->end() <= acv_content->end())) {
+ if ((acv_content->start() < test_content->start() && test_content->start() < acv_content->end()) ||
+ (acv_content->start() < test_content->end() && test_content->end() < acv_content->end())) {
/* we have an overlap on track `t' */
++t;
break;
return;
}
- _pixels_per_time_unit = static_cast<double>(width() - x_offset() * 2) / film->length();
+ _pixels_per_time_unit = static_cast<double>(width() - x_offset() * 2) / film->length_with_loop();
}
void
shared_ptr<ContentView> cv = dynamic_pointer_cast<ContentView> (*i);
if (cv) {
_down_view = cv;
- shared_ptr<Content> c = cv->content().lock();
- assert (c);
- _down_view_start = c->start ();
+ _down_view_start = cv->content()->start ();
}
}
_first_move = false;
if (_down_view) {
- shared_ptr<Content> c = _down_view->content().lock ();
- if (c) {
- c->set_change_signals_frequent (true);
- }
+ _down_view->content()->set_change_signals_frequent (true);
}
}
_left_down = false;
if (_down_view) {
- shared_ptr<Content> c = _down_view->content().lock ();
- if (c) {
- c->set_change_signals_frequent (false);
- }
+ _down_view->content()->set_change_signals_frequent (false);
}
set_start_from_event (ev);
Time const time_diff = (p.x - _down_point.x) / _pixels_per_time_unit;
if (_down_view) {
- shared_ptr<Content> c = _down_view->content().lock();
- if (c) {
- c->set_start (max (static_cast<Time> (0), _down_view_start + time_diff));
+ _down_view->content()->set_start (max (static_cast<Time> (0), _down_view_start + time_diff));
- shared_ptr<Film> film = _film.lock ();
- assert (film);
- film->set_sequence_video (false);
- }
+ shared_ptr<Film> film = _film.lock ();
+ assert (film);
+ film->set_sequence_video (false);
}
}
projects / dcpomatic.git / commitdiff