Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
: _film (film)
, _playlist (playlist)
- , _have_valid_pieces (false)
+ , _suspended (false)
, _ignore_video (false)
+ , _ignore_audio (false)
, _ignore_text (false)
+ , _always_burn_open_subtitles (false)
, _fast (false)
, _play_referenced (false)
, _audio_merger (_film->audio_frame_rate())
, _shuffler (0)
{
_film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1));
- _playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
- _playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Player::playlist_content_changed, this, _1, _2, _3));
+ _playlist_change_connection = _playlist->Change.connect (bind (&Player::playlist_change, this, _1));
+ _playlist_content_change_connection = _playlist->ContentChange.connect (bind(&Player::playlist_content_change, this, _1, _3, _4));
set_video_container_size (_film->frame_size ());
film_changed (Film::AUDIO_PROCESSOR);
+ setup_pieces ();
seek (DCPTime (), true);
}
void
Player::setup_pieces ()
+{
+ boost::mutex::scoped_lock lm (_mutex);
+ setup_pieces_unlocked ();
+}
+
+void
+Player::setup_pieces_unlocked ()
{
_pieces.clear ();
continue;
}
+ if (_ignore_video && _ignore_audio && i->text.empty()) {
+ /* We're only interested in text and this content has none */
+ continue;
+ }
+
shared_ptr<Decoder> decoder = decoder_factory (i, _film->log(), _fast);
FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate());
decoder->video->set_ignore (true);
}
+ if (decoder->audio && _ignore_audio) {
+ decoder->audio->set_ignore (true);
+ }
+
if (_ignore_text) {
BOOST_FOREACH (shared_ptr<TextDecoder> i, decoder->text) {
i->set_ignore (true);
_last_video_time = DCPTime ();
_last_video_eyes = EYES_BOTH;
_last_audio_time = DCPTime ();
- _have_valid_pieces = true;
+ _suspended = false;
}
void
-Player::playlist_content_changed (weak_ptr<Content> w, int property, bool frequent)
+Player::playlist_content_change (ChangeType type, int property, bool frequent)
{
- shared_ptr<Content> c = w.lock ();
- if (!c) {
- return;
+ if (type == CHANGE_TYPE_PENDING) {
+ boost::mutex::scoped_lock lm (_mutex);
+ /* The player content is probably about to change, so we can't carry on
+ until that has happened and we've rebuilt our pieces. Stop pass()
+ and seek() from working until then.
+ */
+ _suspended = true;
+ } else if (type == CHANGE_TYPE_DONE) {
+ /* A change in our content has gone through. Re-build our pieces. */
+ setup_pieces ();
}
- if (
- property == ContentProperty::POSITION ||
- property == ContentProperty::LENGTH ||
- property == ContentProperty::TRIM_START ||
- property == ContentProperty::TRIM_END ||
- property == ContentProperty::PATH ||
- property == VideoContentProperty::FRAME_TYPE ||
- property == VideoContentProperty::COLOUR_CONVERSION ||
- property == AudioContentProperty::STREAMS ||
- property == DCPContentProperty::NEEDS_ASSETS ||
- property == DCPContentProperty::NEEDS_KDM ||
- property == TextContentProperty::COLOUR ||
- property == TextContentProperty::EFFECT ||
- property == TextContentProperty::EFFECT_COLOUR ||
- property == FFmpegContentProperty::SUBTITLE_STREAM ||
- property == FFmpegContentProperty::FILTERS
- ) {
-
- _have_valid_pieces = false;
- Changed (property, frequent);
-
- } else if (
- property == TextContentProperty::LINE_SPACING ||
- property == TextContentProperty::OUTLINE_WIDTH ||
- property == TextContentProperty::Y_SCALE ||
- property == TextContentProperty::FADE_IN ||
- property == TextContentProperty::FADE_OUT ||
- property == ContentProperty::VIDEO_FRAME_RATE ||
- property == TextContentProperty::USE ||
- property == TextContentProperty::X_OFFSET ||
- property == TextContentProperty::Y_OFFSET ||
- property == TextContentProperty::X_SCALE ||
- property == TextContentProperty::FONTS ||
- property == TextContentProperty::TYPE ||
- property == VideoContentProperty::CROP ||
- property == VideoContentProperty::SCALE ||
- property == VideoContentProperty::FADE_IN ||
- property == VideoContentProperty::FADE_OUT
- ) {
-
- Changed (property, frequent);
- }
+ Change (type, property, frequent);
}
void
Player::set_video_container_size (dcp::Size s)
{
- if (s == _video_container_size) {
- return;
- }
+ {
+ boost::mutex::scoped_lock lm (_mutex);
- _video_container_size = s;
+ if (s == _video_container_size) {
+ return;
+ }
+
+ _video_container_size = s;
- _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
- _black_image->make_black ();
+ _black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
+ _black_image->make_black ();
+ }
- Changed (PlayerProperty::VIDEO_CONTAINER_SIZE, false);
+ Change (CHANGE_TYPE_DONE, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
}
void
-Player::playlist_changed ()
+Player::playlist_change (ChangeType type)
{
- _have_valid_pieces = false;
- Changed (PlayerProperty::PLAYLIST, false);
+ if (type == CHANGE_TYPE_DONE) {
+ setup_pieces ();
+ }
+ Change (type, PlayerProperty::PLAYLIST, false);
}
void
*/
if (p == Film::CONTAINER) {
- Changed (PlayerProperty::FILM_CONTAINER, false);
+ Change (CHANGE_TYPE_PENDING, PlayerProperty::FILM_CONTAINER, false);
} else if (p == Film::VIDEO_FRAME_RATE) {
/* Pieces contain a FrameRateChange which contains the DCP frame rate,
so we need new pieces here.
*/
- _have_valid_pieces = false;
- Changed (PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
+ /* XXX: missing PENDING! */
+ setup_pieces ();
+ Change (CHANGE_TYPE_DONE, PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
} else if (p == Film::AUDIO_PROCESSOR) {
if (_film->audio_processor ()) {
+ boost::mutex::scoped_lock lm (_mutex);
_audio_processor = _film->audio_processor()->clone (_film->audio_frame_rate ());
}
} else if (p == Film::AUDIO_CHANNELS) {
+ boost::mutex::scoped_lock lm (_mutex);
_audio_merger.clear ();
}
}
list<shared_ptr<Font> >
Player::get_subtitle_fonts ()
{
- if (!_have_valid_pieces) {
- setup_pieces ();
- }
+ boost::mutex::scoped_lock lm (_mutex);
list<shared_ptr<Font> > fonts;
BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
void
Player::set_ignore_video ()
{
+ boost::mutex::scoped_lock lm (_mutex);
_ignore_video = true;
+ setup_pieces_unlocked ();
+}
+
+void
+Player::set_ignore_audio ()
+{
+ boost::mutex::scoped_lock lm (_mutex);
+ _ignore_audio = true;
+ setup_pieces_unlocked ();
}
void
Player::set_ignore_text ()
{
+ boost::mutex::scoped_lock lm (_mutex);
_ignore_text = true;
+ setup_pieces_unlocked ();
}
/** Set the player to always burn open texts into the image regardless of the content settings */
void
Player::set_always_burn_open_subtitles ()
{
+ boost::mutex::scoped_lock lm (_mutex);
_always_burn_open_subtitles = true;
}
void
Player::set_fast ()
{
+ boost::mutex::scoped_lock lm (_mutex);
_fast = true;
- _have_valid_pieces = false;
+ setup_pieces_unlocked ();
}
void
Player::set_play_referenced ()
{
+ boost::mutex::scoped_lock lm (_mutex);
_play_referenced = true;
- _have_valid_pieces = false;
+ setup_pieces_unlocked ();
}
list<ReferencedReelAsset>
Player::get_reel_assets ()
{
+ /* Does not require a lock on _mutex as it's only called from DCPEncoder */
+
list<ReferencedReelAsset> a;
BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
bool
Player::pass ()
{
- if (!_have_valid_pieces) {
- setup_pieces ();
+ boost::mutex::scoped_lock lm (_mutex);
+
+ if (_suspended) {
+ /* We can't pass in this state */
+ return false;
}
if (_playlist->length() == DCPTime()) {
return done;
}
-list<PlayerText>
-Player::closed_captions_for_frame (DCPTime time) const
-{
- return _active_texts[TEXT_CLOSED_CAPTION].get (
- DCPTimePeriod(time, time + DCPTime::from_frames(1, _film->video_frame_rate()))
- );
-}
-
/** @return Open subtitles for the frame at the given time, converted to images */
optional<PositionImage>
Player::open_subtitles_for_frame (DCPTime time) const
_active_texts[TEXT_OPEN_SUBTITLE].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_open_subtitles)
) {
- /* Image subtitles */
- list<PositionImage> c = transform_bitmap_texts (j.image);
+ /* Bitmap subtitles */
+ list<PositionImage> c = transform_bitmap_texts (j.bitmap);
copy (c.begin(), c.end(), back_inserter (captions));
- /* Text subtitles (rendered to an image) */
- if (!j.text.empty ()) {
- list<PositionImage> s = render_text (j.text, j.fonts, _video_container_size, time, vfr);
+ /* String subtitles (rendered to an image) */
+ if (!j.string.empty ()) {
+ list<PositionImage> s = render_text (j.string, j.fonts, _video_container_size, time, vfr);
copy (s.begin(), s.end(), back_inserter (captions));
}
}
DCPTime fill_from = max (*_last_video_time, piece->content->position());
LastVideoMap::const_iterator last = _last_video.find (wp);
if (_film->three_d()) {
+ Eyes fill_to_eyes = video.eyes;
+ if (fill_to == piece->content->end()) {
+ /* Don't fill after the end of the content */
+ fill_to_eyes = EYES_LEFT;
+ }
DCPTime j = fill_from;
Eyes eyes = _last_video_eyes.get_value_or(EYES_LEFT);
if (eyes == EYES_BOTH) {
eyes = EYES_LEFT;
}
- while (j < fill_to || eyes != video.eyes) {
+ while (j < fill_to || eyes != fill_to_eyes) {
if (last != _last_video.end()) {
shared_ptr<PlayerVideo> copy = last->second->shallow_copy();
copy->set_eyes (eyes);
subtitle.sub.rectangle.height *= text->y_scale ();
PlayerText ps;
- ps.image.push_back (subtitle.sub);
+ ps.bitmap.push_back (subtitle.sub);
DCPTime from (content_time_to_dcp (piece, subtitle.from()));
_active_texts[subtitle.type()].add_from (wc, ps, from);
}
s.set_in (dcp::Time(from.seconds(), 1000));
- ps.text.push_back (StringText (s, text->outline_width()));
+ ps.string.push_back (StringText (s, text->outline_width()));
ps.add_fonts (text->fonts ());
}
pair<PlayerText, DCPTime> from = _active_texts[type].add_to (wc, dcp_to);
- bool const always = type == TEXT_OPEN_SUBTITLE && _always_burn_open_subtitles;
+ bool const always = (type == TEXT_OPEN_SUBTITLE && _always_burn_open_subtitles);
if (text->use() && !always && !text->burn()) {
Text (from.first, type, DCPTimePeriod (from.second, dcp_to));
}
void
Player::seek (DCPTime time, bool accurate)
{
- if (!_have_valid_pieces) {
- setup_pieces ();
+ boost::mutex::scoped_lock lm (_mutex);
+
+ if (_suspended) {
+ /* We can't seek in this state */
+ return;
}
if (_shuffler) {
void
Player::set_dcp_decode_reduction (optional<int> reduction)
{
- if (reduction == _dcp_decode_reduction) {
- return;
+ Change (CHANGE_TYPE_PENDING, PlayerProperty::DCP_DECODE_REDUCTION, false);
+
+ {
+ boost::mutex::scoped_lock lm (_mutex);
+
+ if (reduction == _dcp_decode_reduction) {
+ lm.unlock ();
+ Change (CHANGE_TYPE_CANCELLED, PlayerProperty::DCP_DECODE_REDUCTION, false);
+ return;
+ }
+
+ _dcp_decode_reduction = reduction;
+ setup_pieces_unlocked ();
}
- _dcp_decode_reduction = reduction;
- _have_valid_pieces = false;
- Changed (PlayerProperty::DCP_DECODE_REDUCTION, false);
+ Change (CHANGE_TYPE_DONE, PlayerProperty::DCP_DECODE_REDUCTION, false);
}
-DCPTime
+optional<DCPTime>
Player::content_time_to_dcp (shared_ptr<Content> content, ContentTime t)
{
- if (_have_valid_pieces) {
- setup_pieces ();
- }
+ boost::mutex::scoped_lock lm (_mutex);
BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
if (i->content == content) {
}
}
- DCPOMATIC_ASSERT (false);
- return DCPTime ();
+ /* We couldn't find this content; perhaps things are being changed over */
+ return optional<DCPTime>();
}
projects / dcpomatic.git / blobdiff