X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=6e6cd75d7d774b1ef3f3d1c3388ed507fd2b2bcf;hb=a95e78ea9d4c39f05fc8f7b58141a6a5bdc91ad6;hp=41cf52f2c8e5d1d692f97cc98380c37de1ea7b47;hpb=c9a97108df1d609bd13df8a21bee11d7ca55feea;p=dcpomatic.git

diff --git a/src/lib/player.cc b/src/lib/player.cc
index 41cf52f2c..6e6cd75d7 100644
--- a/src/lib/player.cc
+++ b/src/lib/player.cc
@@ -60,8 +60,6 @@
 
 #include "i18n.h"
 
-#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
-
 using std::list;
 using std::cout;
 using std::min;
@@ -83,14 +81,11 @@ int const PlayerProperty::PLAYLIST = 701;
 int const PlayerProperty::FILM_CONTAINER = 702;
 int const PlayerProperty::FILM_VIDEO_FRAME_RATE = 703;
 int const PlayerProperty::DCP_DECODE_REDUCTION = 704;
-int const PlayerProperty::IGNORE_COMPONENTS = 705;
-int const PlayerProperty::FAST = 706;
-int const PlayerProperty::PLAY_REFERENCED = 707;
 
 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)
@@ -100,13 +95,17 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
 	, _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));
+	_film_changed_connection = _film->Change.connect (bind (&Player::film_change, this, _1, _2));
+	/* The butler must hear about this first, so since we are proxying this through to the butler we must
+	   be first.
+	*/
+	_playlist_change_connection = _playlist->Change.connect (bind (&Player::playlist_change, this, _1), boost::signals2::at_front);
+	_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);
+	film_change (CHANGE_TYPE_DONE, Film::AUDIO_PROCESSOR);
 
+	setup_pieces ();
 	seek (DCPTime (), true);
 }
 
@@ -117,6 +116,25 @@ Player::~Player ()
 
 void
 Player::setup_pieces ()
+{
+	boost::mutex::scoped_lock lm (_mutex);
+	setup_pieces_unlocked ();
+}
+
+bool
+have_video (shared_ptr<Piece> piece)
+{
+	return piece->decoder && piece->decoder->video;
+}
+
+bool
+have_audio (shared_ptr<Piece> piece)
+{
+	return piece->decoder && piece->decoder->audio;
+}
+
+void
+Player::setup_pieces_unlocked ()
 {
 	_pieces.clear ();
 
@@ -135,8 +153,8 @@ Player::setup_pieces ()
 			continue;
 		}
 
-		shared_ptr<Decoder> decoder = decoder_factory (i, _film->log(), _fast);
-		FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate());
+		shared_ptr<Decoder> decoder = decoder_factory (_film, i, _fast);
+		FrameRateChange frc (_film, i);
 
 		if (!decoder) {
 			/* Not something that we can decode; e.g. Atmos content */
@@ -191,7 +209,7 @@ Player::setup_pieces ()
 				bind(&Player::plain_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
 				);
 			(*j)->Stop.connect (
-				bind(&Player::subtitle_stop, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1, _2)
+				bind(&Player::subtitle_stop, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
 				);
 
 			++j;
@@ -207,78 +225,47 @@ Player::setup_pieces ()
 		}
 	}
 
-	_black = Empty (_film->content(), _film->length(), bind(&Content::video, _1));
-	_silent = Empty (_film->content(), _film->length(), bind(&Content::audio, _1));
+	_black = Empty (_film, _pieces, bind(&have_video, _1));
+	_silent = Empty (_film, _pieces, bind(&have_audio, _1));
 
 	_last_video_time = DCPTime ();
 	_last_video_eyes = EYES_BOTH;
 	_last_audio_time = DCPTime ();
-	_have_valid_pieces = true;
 }
 
 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 ();
+		_suspended = false;
+	} else if (type == CHANGE_TYPE_CANCELLED) {
+		boost::mutex::scoped_lock lm (_mutex);
+		_suspended = false;
 	}
 
-	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
-		) {
-
-		{
-			boost::mutex::scoped_lock lm (_mutex);
-			_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)
 {
+	Change (CHANGE_TYPE_PENDING, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
+
 	{
 		boost::mutex::scoped_lock lm (_mutex);
 
 		if (s == _video_container_size) {
+			lm.unlock ();
+			Change (CHANGE_TYPE_CANCELLED, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
 			return;
 		}
 
@@ -288,22 +275,20 @@ Player::set_video_container_size (dcp::Size s)
 		_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)
 {
-	{
-		boost::mutex::scoped_lock lm (_mutex);
-		_have_valid_pieces = false;
+	if (type == CHANGE_TYPE_DONE) {
+		setup_pieces ();
 	}
-
-	Changed (PlayerProperty::PLAYLIST, false);
+	Change (type, PlayerProperty::PLAYLIST, false);
 }
 
 void
-Player::film_changed (Film::Property p)
+Player::film_change (ChangeType type, Film::Property p)
 {
 	/* Here we should notice Film properties that affect our output, and
 	   alert listeners that our output now would be different to how it was
@@ -311,58 +296,26 @@ Player::film_changed (Film::Property p)
 	*/
 
 	if (p == Film::CONTAINER) {
-		Changed (PlayerProperty::FILM_CONTAINER, false);
+		Change (type, 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.
 		*/
-		{
-			boost::mutex::scoped_lock lm (_mutex);
-			_have_valid_pieces = false;
+		if (type == CHANGE_TYPE_DONE) {
+			setup_pieces ();
 		}
-		Changed (PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
+		Change (type, PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
 	} else if (p == Film::AUDIO_PROCESSOR) {
-		if (_film->audio_processor ()) {
+		if (type == CHANGE_TYPE_DONE && _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<PositionImage>
-Player::transform_bitmap_texts (list<BitmapText> subs) const
-{
-	list<PositionImage> all;
-
-	for (list<BitmapText>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
-		if (!i->image) {
-			continue;
+		if (type == CHANGE_TYPE_DONE) {
+			boost::mutex::scoped_lock lm (_mutex);
+			_audio_merger.clear ();
 		}
-
-		/* We will scale the subtitle up to fit _video_container_size */
-		dcp::Size scaled_size (i->rectangle.width * _video_container_size.width, i->rectangle.height * _video_container_size.height);
-
-		all.push_back (
-			PositionImage (
-				i->image->scale (
-					scaled_size,
-					dcp::YUV_TO_RGB_REC601,
-					i->image->pixel_format (),
-					true,
-					_fast
-					),
-				Position<int> (
-					lrint (_video_container_size.width * i->rectangle.x),
-					lrint (_video_container_size.height * i->rectangle.y)
-					)
-				)
-			);
 	}
-
-	return all;
 }
 
 shared_ptr<PlayerVideo>
@@ -388,7 +341,7 @@ Frame
 Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 {
 	DCPTime s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(), s);
+	s = min (piece->content->length_after_trim(_film), s);
 	s = max (DCPTime(), s + DCPTime (piece->content->trim_start(), piece->frc));
 
 	/* It might seem more logical here to convert s to a ContentTime (using the FrameRateChange)
@@ -413,7 +366,7 @@ Frame
 Player::dcp_to_resampled_audio (shared_ptr<const Piece> piece, DCPTime t) const
 {
 	DCPTime s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(), s);
+	s = min (piece->content->length_after_trim(_film), s);
 	/* See notes in dcp_to_content_video */
 	return max (DCPTime (), DCPTime (piece->content->trim_start (), piece->frc) + s).frames_floor (_film->audio_frame_rate ());
 }
@@ -431,7 +384,7 @@ ContentTime
 Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 {
 	DCPTime s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(), s);
+	s = min (piece->content->length_after_trim(_film), s);
 	return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 }
 
@@ -444,11 +397,7 @@ Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 list<shared_ptr<Font> >
 Player::get_subtitle_fonts ()
 {
-	/* Does not require a lock on _mutex as it's only called from DCPEncoder */
-
-	if (!_have_valid_pieces) {
-		setup_pieces ();
-	}
+	boost::mutex::scoped_lock lm (_mutex);
 
 	list<shared_ptr<Font> > fonts;
 	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
@@ -468,37 +417,25 @@ Player::get_subtitle_fonts ()
 void
 Player::set_ignore_video ()
 {
-	{
-		boost::mutex::scoped_lock lm (_mutex);
-		_ignore_video = true;
-		_have_valid_pieces = false;
-	}
-
-	Changed (PlayerProperty::IGNORE_COMPONENTS, false);
+	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;
-		_have_valid_pieces = false;
-	}
-
-	Changed (PlayerProperty::IGNORE_COMPONENTS, false);
+	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;
-		_have_valid_pieces = false;
-	}
-
-	Changed (PlayerProperty::IGNORE_COMPONENTS, false);
+	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 */
@@ -513,25 +450,30 @@ Player::set_always_burn_open_subtitles ()
 void
 Player::set_fast ()
 {
-	{
-		boost::mutex::scoped_lock lm (_mutex);
-		_fast = true;
-		_have_valid_pieces = false;
-	}
-
-	Changed (PlayerProperty::FAST, false);
+	boost::mutex::scoped_lock lm (_mutex);
+	_fast = true;
+	setup_pieces_unlocked ();
 }
 
 void
 Player::set_play_referenced ()
 {
-	{
-		boost::mutex::scoped_lock lm (_mutex);
-		_play_referenced = true;
-		_have_valid_pieces = false;
-	}
+	boost::mutex::scoped_lock lm (_mutex);
+	_play_referenced = true;
+	setup_pieces_unlocked ();
+}
 
-	Changed (PlayerProperty::PLAY_REFERENCED, false);
+static void
+maybe_add_asset (list<ReferencedReelAsset>& a, shared_ptr<dcp::ReelAsset> r, Frame reel_trim_start, Frame reel_trim_end, DCPTime from, int const ffr)
+{
+	DCPOMATIC_ASSERT (r);
+	r->set_entry_point (r->entry_point() + reel_trim_start);
+	r->set_duration (r->duration() - reel_trim_start - reel_trim_end);
+	if (r->duration() > 0) {
+		a.push_back (
+			ReferencedReelAsset(r, DCPTimePeriod(from, from + DCPTime::from_frames(r->duration(), ffr)))
+			);
+	}
 }
 
 list<ReferencedReelAsset>
@@ -549,63 +491,56 @@ Player::get_reel_assets ()
 
 		scoped_ptr<DCPDecoder> decoder;
 		try {
-			decoder.reset (new DCPDecoder (j, _film->log(), false));
+			decoder.reset (new DCPDecoder (_film, j, false));
 		} catch (...) {
 			return a;
 		}
 
-		int64_t offset = 0;
+		DCPOMATIC_ASSERT (j->video_frame_rate ());
+		double const cfr = j->video_frame_rate().get();
+		Frame const trim_start = j->trim_start().frames_round (cfr);
+		Frame const trim_end = j->trim_end().frames_round (cfr);
+		int const ffr = _film->video_frame_rate ();
+
+		/* position in the asset from the start */
+		int64_t offset_from_start = 0;
+		/* position in the asset from the end */
+		int64_t offset_from_end = 0;
 		BOOST_FOREACH (shared_ptr<dcp::Reel> k, decoder->reels()) {
+			/* Assume that main picture duration is the length of the reel */
+			offset_from_end += k->main_picture()->duration();
+		}
 
-			DCPOMATIC_ASSERT (j->video_frame_rate ());
-			double const cfr = j->video_frame_rate().get();
-			Frame const trim_start = j->trim_start().frames_round (cfr);
-			Frame const trim_end = j->trim_end().frames_round (cfr);
-			int const ffr = _film->video_frame_rate ();
+		BOOST_FOREACH (shared_ptr<dcp::Reel> k, decoder->reels()) {
+
+			/* Assume that main picture duration is the length of the reel */
+			int64_t const reel_duration = k->main_picture()->duration();
+
+			/* See doc/design/trim_reels.svg */
+			Frame const reel_trim_start = min(reel_duration, max(int64_t(0), trim_start - offset_from_start));
+			Frame const reel_trim_end =   min(reel_duration, max(int64_t(0), reel_duration - (offset_from_end - trim_end)));
 
-			DCPTime const from = i->position() + DCPTime::from_frames (offset, _film->video_frame_rate());
+			DCPTime const from = i->position() + DCPTime::from_frames (offset_from_start, _film->video_frame_rate());
 			if (j->reference_video ()) {
-				shared_ptr<dcp::ReelAsset> ra = k->main_picture ();
-				DCPOMATIC_ASSERT (ra);
-				ra->set_entry_point (ra->entry_point() + trim_start);
-				ra->set_duration (ra->duration() - trim_start - trim_end);
-				a.push_back (
-					ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
-					);
+				maybe_add_asset (a, k->main_picture(), reel_trim_start, reel_trim_end, from, ffr);
 			}
 
 			if (j->reference_audio ()) {
-				shared_ptr<dcp::ReelAsset> ra = k->main_sound ();
-				DCPOMATIC_ASSERT (ra);
-				ra->set_entry_point (ra->entry_point() + trim_start);
-				ra->set_duration (ra->duration() - trim_start - trim_end);
-				a.push_back (
-					ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
-					);
+				maybe_add_asset (a, k->main_sound(), reel_trim_start, reel_trim_end, from, ffr);
 			}
 
 			if (j->reference_text (TEXT_OPEN_SUBTITLE)) {
-				shared_ptr<dcp::ReelAsset> ra = k->main_subtitle ();
-				DCPOMATIC_ASSERT (ra);
-				ra->set_entry_point (ra->entry_point() + trim_start);
-				ra->set_duration (ra->duration() - trim_start - trim_end);
-				a.push_back (
-					ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
-					);
+				maybe_add_asset (a, k->main_subtitle(), reel_trim_start, reel_trim_end, from, ffr);
 			}
 
 			if (j->reference_text (TEXT_CLOSED_CAPTION)) {
-				shared_ptr<dcp::ReelAsset> ra = k->closed_caption ();
-				DCPOMATIC_ASSERT (ra);
-				ra->set_entry_point (ra->entry_point() + trim_start);
-				ra->set_duration (ra->duration() - trim_start - trim_end);
-				a.push_back (
-					ReferencedReelAsset (ra, DCPTimePeriod (from, from + DCPTime::from_frames (ra->duration(), ffr)))
-					);
+				BOOST_FOREACH (shared_ptr<dcp::ReelClosedCaptionAsset> l, k->closed_captions()) {
+					maybe_add_asset (a, l, reel_trim_start, reel_trim_end, from, ffr);
+				}
 			}
 
-			/* Assume that main picture duration is the length of the reel */
-			offset += k->main_picture()->duration ();
+			offset_from_start += reel_duration;
+			offset_from_end -= reel_duration;
 		}
 	}
 
@@ -617,17 +552,12 @@ Player::pass ()
 {
 	boost::mutex::scoped_lock lm (_mutex);
 
-	if (!_have_valid_pieces) {
-		/* This should only happen when we are under the control of the butler.  In this case, _have_valid_pieces
-		   will be false if something in the Player has changed and we are waiting for the butler to notice
-		   and do a seek back to the place we were at before.  During this time we don't want pass() to do anything,
-		   as just after setup_pieces the new decoders will be back to time 0 until the seek has gone through.  Just do nothing
-		   here and assume that the seek will be forthcoming.
-		*/
+	if (_suspended) {
+		/* We can't pass in this state */
 		return false;
 	}
 
-	if (_playlist->length() == DCPTime()) {
+	if (_playlist->length(_film) == DCPTime()) {
 		/* Special case of an empty Film; just give one black frame */
 		emit_video (black_player_video_frame(EYES_BOTH), DCPTime());
 		return true;
@@ -644,7 +574,7 @@ Player::pass ()
 		}
 
 		DCPTime const t = content_time_to_dcp (i, max(i->decoder->position(), i->content->trim_start()));
-		if (t > i->content->end()) {
+		if (t > i->content->end(_film)) {
 			i->done = true;
 		} else {
 
@@ -694,11 +624,10 @@ Player::pass ()
 		DCPTimePeriod period (_silent.period_at_position());
 		if (_last_audio_time) {
 			/* Sometimes the thing that happened last finishes fractionally before
-			   this silence.  Bodge the start time of the silence to fix it.  I'm
-			   not sure if this is the right solution --- maybe the last thing should
-			   be padded `forward' rather than this thing padding `back'.
+			   or after this silence.  Bodge the start time of the silence to fix it.
 			*/
-			period.from = min(period.from, *_last_audio_time);
+			DCPOMATIC_ASSERT (labs(period.from.get() - _last_audio_time->get()) < 2);
+			period.from = *_last_audio_time;
 		}
 		if (period.duration() > one_video_frame()) {
 			period.to = period.from + one_video_frame();
@@ -767,8 +696,24 @@ Player::open_subtitles_for_frame (DCPTime time) const
 		) {
 
 		/* Bitmap subtitles */
-		list<PositionImage> c = transform_bitmap_texts (j.bitmap);
-		copy (c.begin(), c.end(), back_inserter (captions));
+		BOOST_FOREACH (BitmapText i, j.bitmap) {
+			if (!i.image) {
+				continue;
+			}
+
+			/* i.image will already have been scaled to fit _video_container_size */
+			dcp::Size scaled_size (i.rectangle.width * _video_container_size.width, i.rectangle.height * _video_container_size.height);
+
+			captions.push_back (
+				PositionImage (
+					i.image,
+					Position<int> (
+						lrint (_video_container_size.width * i.rectangle.x),
+						lrint (_video_container_size.height * i.rectangle.y)
+						)
+					)
+				);
+		}
 
 		/* String subtitles (rendered to an image) */
 		if (!j.string.empty ()) {
@@ -792,7 +737,7 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
 		return;
 	}
 
-	FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate());
+	FrameRateChange frc (_film, piece->content);
 	if (frc.skip && (video.frame % 2) == 1) {
 		return;
 	}
@@ -811,41 +756,48 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
 	/* Fill gaps that we discover now that we have some video which needs to be emitted.
 	   This is where we need to fill to.
 	*/
-	DCPTime fill_to = min (time, piece->content->end());
+	DCPTime fill_to = min (time, piece->content->end(_film));
 
 	if (_last_video_time) {
 		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 != fill_to_eyes) {
-				if (last != _last_video.end()) {
-					shared_ptr<PlayerVideo> copy = last->second->shallow_copy();
-					copy->set_eyes (eyes);
-					emit_video (copy, j);
-				} else {
-					emit_video (black_player_video_frame(eyes), j);
+
+		/* Fill if we have more than half a frame to do */
+		if ((fill_to - fill_from) > one_video_frame() / 2) {
+			LastVideoMap::const_iterator last = _last_video.find (wp);
+			if (_film->three_d()) {
+				Eyes fill_to_eyes = video.eyes;
+				if (fill_to_eyes == EYES_BOTH) {
+					fill_to_eyes = EYES_LEFT;
 				}
-				if (eyes == EYES_RIGHT) {
-					j += one_video_frame();
+				if (fill_to == piece->content->end(_film)) {
+					/* Don't fill after the end of the content */
+					fill_to_eyes = EYES_LEFT;
 				}
-				eyes = increment_eyes (eyes);
-			}
-		} else {
-			for (DCPTime j = fill_from; j < fill_to; j += one_video_frame()) {
-				if (last != _last_video.end()) {
-					emit_video (last->second, j);
-				} else {
-					emit_video (black_player_video_frame(EYES_BOTH), j);
+				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 != fill_to_eyes) {
+					if (last != _last_video.end()) {
+						shared_ptr<PlayerVideo> copy = last->second->shallow_copy();
+						copy->set_eyes (eyes);
+						emit_video (copy, j);
+					} else {
+						emit_video (black_player_video_frame(eyes), j);
+					}
+					if (eyes == EYES_RIGHT) {
+						j += one_video_frame();
+					}
+					eyes = increment_eyes (eyes);
+				}
+			} else {
+				for (DCPTime j = fill_from; j < fill_to; j += one_video_frame()) {
+					if (last != _last_video.end()) {
+						emit_video (last->second, j);
+					} else {
+						emit_video (black_player_video_frame(EYES_BOTH), j);
+					}
 				}
 			}
 		}
@@ -855,7 +807,7 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
 		new PlayerVideo (
 			video.image,
 			piece->content->video->crop (),
-			piece->content->video->fade (video.frame),
+			piece->content->video->fade (_film, video.frame),
 			piece->content->video->scale().size (
 				piece->content->video, _video_container_size, _film->frame_size ()
 				),
@@ -870,7 +822,7 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
 
 	DCPTime t = time;
 	for (int i = 0; i < frc.repeat; ++i) {
-		if (t < piece->content->end()) {
+		if (t < piece->content->end(_film)) {
 			emit_video (_last_video[wp], t);
 		}
 		t += one_video_frame ();
@@ -893,7 +845,7 @@ Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_a
 	/* Compute time in the DCP */
 	DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame);
 	/* And the end of this block in the DCP */
-	DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate());
+	DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate(_film));
 
 	/* Remove anything that comes before the start or after the end of the content */
 	if (time < piece->content->position()) {
@@ -904,11 +856,11 @@ Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_a
 		}
 		content_audio.audio = cut.first;
 		time = cut.second;
-	} else if (time > piece->content->end()) {
+	} else if (time > piece->content->end(_film)) {
 		/* Discard it all */
 		return;
-	} else if (end > piece->content->end()) {
-		Frame const remaining_frames = DCPTime(piece->content->end() - time).frames_round(_film->audio_frame_rate());
+	} else if (end > piece->content->end(_film)) {
+		Frame const remaining_frames = DCPTime(piece->content->end(_film) - time).frames_round(_film->audio_frame_rate());
 		if (remaining_frames == 0) {
 			return;
 		}
@@ -966,10 +918,13 @@ Player::bitmap_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, C
 	subtitle.sub.rectangle.height *= text->y_scale ();
 
 	PlayerText ps;
-	ps.bitmap.push_back (subtitle.sub);
+	shared_ptr<Image> image = subtitle.sub.image;
+	/* We will scale the subtitle up to fit _video_container_size */
+	dcp::Size scaled_size (subtitle.sub.rectangle.width * _video_container_size.width, subtitle.sub.rectangle.height * _video_container_size.height);
+	ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUV_TO_RGB_REC601, image->pixel_format(), true, _fast), subtitle.sub.rectangle));
 	DCPTime from (content_time_to_dcp (piece, subtitle.from()));
 
-	_active_texts[subtitle.type()].add_from (wc, ps, from);
+	_active_texts[text->type()].add_from (wc, ps, from);
 }
 
 void
@@ -984,7 +939,7 @@ Player::plain_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, Co
 	PlayerText ps;
 	DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 
-	if (from > piece->content->end()) {
+	if (from > piece->content->end(_film)) {
 		return;
 	}
 
@@ -1013,33 +968,37 @@ Player::plain_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, Co
 		ps.add_fonts (text->fonts ());
 	}
 
-	_active_texts[subtitle.type()].add_from (wc, ps, from);
+	_active_texts[text->type()].add_from (wc, ps, from);
 }
 
 void
-Player::subtitle_stop (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentTime to, TextType type)
+Player::subtitle_stop (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentTime to)
 {
-	if (!_active_texts[type].have (wc)) {
+	shared_ptr<const TextContent> text = wc.lock ();
+	if (!text) {
+		return;
+	}
+
+	if (!_active_texts[text->type()].have(wc)) {
 		return;
 	}
 
 	shared_ptr<Piece> piece = wp.lock ();
-	shared_ptr<const TextContent> text = wc.lock ();
-	if (!piece || !text) {
+	if (!piece) {
 		return;
 	}
 
 	DCPTime const dcp_to = content_time_to_dcp (piece, to);
 
-	if (dcp_to > piece->content->end()) {
+	if (dcp_to > piece->content->end(_film)) {
 		return;
 	}
 
-	pair<PlayerText, DCPTime> from = _active_texts[type].add_to (wc, dcp_to);
+	pair<PlayerText, DCPTime> from = _active_texts[text->type()].add_to (wc, dcp_to);
 
-	bool const always = (type == TEXT_OPEN_SUBTITLE && _always_burn_open_subtitles);
+	bool const always = (text->type() == TEXT_OPEN_SUBTITLE && _always_burn_open_subtitles);
 	if (text->use() && !always && !text->burn()) {
-		Text (from.first, type, DCPTimePeriod (from.second, dcp_to));
+		Text (from.first, text->type(), text->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod (from.second, dcp_to));
 	}
 }
 
@@ -1048,8 +1007,9 @@ Player::seek (DCPTime time, bool accurate)
 {
 	boost::mutex::scoped_lock lm (_mutex);
 
-	if (!_have_valid_pieces) {
-		setup_pieces ();
+	if (_suspended) {
+		/* We can't seek in this state */
+		return;
 	}
 
 	if (_shuffler) {
@@ -1072,7 +1032,7 @@ Player::seek (DCPTime time, bool accurate)
 			/* Before; seek to the start of the content */
 			i->decoder->seek (dcp_to_content_time (i, i->content->position()), accurate);
 			i->done = false;
-		} else if (i->content->position() <= time && time < i->content->end()) {
+		} else if (i->content->position() <= time && time < i->content->end(_film)) {
 			/* During; seek to position */
 			i->decoder->seek (dcp_to_content_time (i, time), accurate);
 			i->done = false;
@@ -1141,13 +1101,13 @@ void
 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
 {
 	/* Log if the assert below is about to fail */
-	if (_last_audio_time && time != *_last_audio_time) {
+	if (_last_audio_time && labs(time.get() - _last_audio_time->get()) > 1) {
 		_film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_last_audio_time)), LogEntry::TYPE_WARNING);
 	}
 
-	/* This audio must follow on from the previous */
-	DCPOMATIC_ASSERT (!_last_audio_time || time == *_last_audio_time);
-	Audio (data, time);
+	/* This audio must follow on from the previous, allowing for half a sample (at 48kHz) leeway */
+	DCPOMATIC_ASSERT (!_last_audio_time || labs(time.get() - _last_audio_time->get()) < 2);
+	Audio (data, time, _film->audio_frame_rate());
 	_last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate());
 }
 
@@ -1196,35 +1156,35 @@ Player::discard_audio (shared_ptr<const AudioBuffers> audio, DCPTime time, DCPTi
 void
 Player::set_dcp_decode_reduction (optional<int> reduction)
 {
+	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;
-		_have_valid_pieces = false;
+		setup_pieces_unlocked ();
 	}
 
-	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)
 {
 	boost::mutex::scoped_lock lm (_mutex);
 
-	if (_have_valid_pieces) {
-		setup_pieces ();
-	}
-
 	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 		if (i->content == content) {
 			return content_time_to_dcp (i, t);
 		}
 	}
 
-	DCPOMATIC_ASSERT (false);
-	return DCPTime ();
+	/* We couldn't find this content; perhaps things are being changed over */
+	return optional<DCPTime>();
 }