X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=580c3e6d43946230e85ac3001f42ce7bb9f24555;hb=cbd4450197a083bf58bda510e626f73ba583cb66;hp=a8a72a229a2b756e5e9e03d3fe3b6de228ef409b;hpb=a0eff2446835a2a29d751a4810fe182c486a2eb6;p=dcpomatic.git

diff --git a/src/lib/player.cc b/src/lib/player.cc
index a8a72a229..580c3e6d4 100644
--- a/src/lib/player.cc
+++ b/src/lib/player.cc
@@ -28,7 +28,7 @@
 #include "raw_image_proxy.h"
 #include "ratio.h"
 #include "log.h"
-#include "render_subtitles.h"
+#include "render_text.h"
 #include "config.h"
 #include "content_video.h"
 #include "player_video.h"
@@ -40,20 +40,19 @@
 #include "decoder.h"
 #include "video_decoder.h"
 #include "audio_decoder.h"
-#include "subtitle_content.h"
-#include "subtitle_decoder.h"
+#include "caption_content.h"
+#include "caption_decoder.h"
 #include "ffmpeg_content.h"
 #include "audio_content.h"
-#include "content_subtitle.h"
 #include "dcp_decoder.h"
 #include "image_decoder.h"
 #include "compose.hpp"
 #include "shuffler.h"
-#include "delay.h"
 #include <dcp/reel.h>
 #include <dcp/reel_sound_asset.h>
 #include <dcp/reel_subtitle_asset.h>
 #include <dcp/reel_picture_asset.h>
+#include <dcp/reel_closed_caption_asset.h>
 #include <boost/foreach.hpp>
 #include <stdint.h>
 #include <algorithm>
@@ -79,18 +78,22 @@ using boost::dynamic_pointer_cast;
 using boost::optional;
 using boost::scoped_ptr;
 
+int const PlayerProperty::VIDEO_CONTAINER_SIZE = 700;
+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;
+
 Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
 	: _film (film)
 	, _playlist (playlist)
 	, _have_valid_pieces (false)
 	, _ignore_video (false)
-	, _ignore_subtitle (false)
-	, _always_burn_subtitles (false)
+	, _ignore_caption (false)
 	, _fast (false)
 	, _play_referenced (false)
 	, _audio_merger (_film->audio_frame_rate())
 	, _shuffler (0)
-	, _delay (0)
 {
 	_film_changed_connection = _film->Changed.connect (bind (&Player::film_changed, this, _1));
 	_playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
@@ -105,7 +108,6 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
 Player::~Player ()
 {
 	delete _shuffler;
-	delete _delay;
 }
 
 void
@@ -117,10 +119,6 @@ Player::setup_pieces ()
 	_shuffler = new Shuffler();
 	_shuffler->Video.connect(bind(&Player::video, this, _1, _2));
 
-	delete _delay;
-	_delay = new Delay();
-	_delay->Video.connect(bind(&Player::video, this, _1, _2));
-
 	BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
 
 		if (!i->paths_valid ()) {
@@ -139,8 +137,10 @@ Player::setup_pieces ()
 			decoder->video->set_ignore (true);
 		}
 
-		if (decoder->subtitle && _ignore_subtitle) {
-			decoder->subtitle->set_ignore (true);
+		if (_ignore_caption) {
+			BOOST_FOREACH (shared_ptr<CaptionDecoder> i, decoder->caption) {
+				i->set_ignore (true);
+			}
 		}
 
 		shared_ptr<DCPDecoder> dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
@@ -159,10 +159,7 @@ Player::setup_pieces ()
 				/* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */
 				decoder->video->Data.connect (bind (&Shuffler::video, _shuffler, weak_ptr<Piece>(piece), _1));
 			} else {
-				/* We need a Delay to give a little wiggle room to ensure that relevent subtitles arrive at the
-				   player before the video that requires them.
-				*/
-				decoder->video->Data.connect (bind (&Delay::video, _delay, weak_ptr<Piece>(piece), _1));
+				decoder->video->Data.connect (bind (&Player::video, this, weak_ptr<Piece>(piece), _1));
 			}
 		}
 
@@ -170,10 +167,20 @@ Player::setup_pieces ()
 			decoder->audio->Data.connect (bind (&Player::audio, this, weak_ptr<Piece> (piece), _1, _2));
 		}
 
-		if (decoder->subtitle) {
-			decoder->subtitle->ImageStart.connect (bind (&Player::image_subtitle_start, this, weak_ptr<Piece> (piece), _1));
-			decoder->subtitle->TextStart.connect (bind (&Player::text_subtitle_start, this, weak_ptr<Piece> (piece), _1));
-			decoder->subtitle->Stop.connect (bind (&Player::subtitle_stop, this, weak_ptr<Piece> (piece), _1));
+		list<shared_ptr<CaptionDecoder> >::const_iterator j = decoder->caption.begin();
+
+		while (j != decoder->caption.end()) {
+			(*j)->BitmapStart.connect (
+				bind(&Player::bitmap_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const CaptionContent>((*j)->content()), _1)
+				);
+			(*j)->PlainStart.connect (
+				bind(&Player::plain_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const CaptionContent>((*j)->content()), _1)
+				);
+			(*j)->Stop.connect (
+				bind(&Player::subtitle_stop, this, weak_ptr<Piece>(piece), weak_ptr<const CaptionContent>((*j)->content()), _1, _2)
+				);
+
+			++j;
 		}
 	}
 
@@ -210,38 +217,40 @@ Player::playlist_content_changed (weak_ptr<Content> w, int property, bool freque
 		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 == SubtitleContentProperty::COLOUR ||
-		property == SubtitleContentProperty::EFFECT ||
-		property == SubtitleContentProperty::EFFECT_COLOUR ||
+		property == CaptionContentProperty::COLOUR ||
+		property == CaptionContentProperty::EFFECT ||
+		property == CaptionContentProperty::EFFECT_COLOUR ||
 		property == FFmpegContentProperty::SUBTITLE_STREAM ||
-		property == FFmpegContentProperty::FILTERS ||
-		property == VideoContentProperty::COLOUR_CONVERSION
+		property == FFmpegContentProperty::FILTERS
 		) {
 
 		_have_valid_pieces = false;
-		Changed (frequent);
+		Changed (property, frequent);
 
 	} else if (
-		property == SubtitleContentProperty::LINE_SPACING ||
-		property == SubtitleContentProperty::OUTLINE_WIDTH ||
-		property == SubtitleContentProperty::Y_SCALE ||
-		property == SubtitleContentProperty::FADE_IN ||
-		property == SubtitleContentProperty::FADE_OUT ||
+		property == CaptionContentProperty::LINE_SPACING ||
+		property == CaptionContentProperty::OUTLINE_WIDTH ||
+		property == CaptionContentProperty::Y_SCALE ||
+		property == CaptionContentProperty::FADE_IN ||
+		property == CaptionContentProperty::FADE_OUT ||
 		property == ContentProperty::VIDEO_FRAME_RATE ||
-		property == SubtitleContentProperty::USE ||
-		property == SubtitleContentProperty::X_OFFSET ||
-		property == SubtitleContentProperty::Y_OFFSET ||
-		property == SubtitleContentProperty::X_SCALE ||
-		property == SubtitleContentProperty::FONTS ||
+		property == CaptionContentProperty::USE ||
+		property == CaptionContentProperty::X_OFFSET ||
+		property == CaptionContentProperty::Y_OFFSET ||
+		property == CaptionContentProperty::X_SCALE ||
+		property == CaptionContentProperty::FONTS ||
+		property == CaptionContentProperty::TYPE ||
 		property == VideoContentProperty::CROP ||
 		property == VideoContentProperty::SCALE ||
 		property == VideoContentProperty::FADE_IN ||
 		property == VideoContentProperty::FADE_OUT
 		) {
 
-		Changed (frequent);
+		Changed (property, frequent);
 	}
 }
 
@@ -257,14 +266,14 @@ Player::set_video_container_size (dcp::Size s)
 	_black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
 	_black_image->make_black ();
 
-	Changed (false);
+	Changed (PlayerProperty::VIDEO_CONTAINER_SIZE, false);
 }
 
 void
 Player::playlist_changed ()
 {
 	_have_valid_pieces = false;
-	Changed (false);
+	Changed (PlayerProperty::PLAYLIST, false);
 }
 
 void
@@ -276,26 +285,28 @@ Player::film_changed (Film::Property p)
 	*/
 
 	if (p == Film::CONTAINER) {
-		Changed (false);
+		Changed (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 (false);
+		Changed (PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
 	} else if (p == Film::AUDIO_PROCESSOR) {
 		if (_film->audio_processor ()) {
 			_audio_processor = _film->audio_processor()->clone (_film->audio_frame_rate ());
 		}
+	} else if (p == Film::AUDIO_CHANNELS) {
+		_audio_merger.clear ();
 	}
 }
 
 list<PositionImage>
-Player::transform_image_subtitles (list<ImageSubtitle> subs) const
+Player::transform_bitmap_captions (list<BitmapCaption> subs) const
 {
 	list<PositionImage> all;
 
-	for (list<ImageSubtitle>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
+	for (list<BitmapCaption>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
 		if (!i->image) {
 			continue;
 		}
@@ -303,18 +314,6 @@ Player::transform_image_subtitles (list<ImageSubtitle> subs) const
 		/* 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);
 
-		/* Then we need a corrective translation, consisting of two parts:
-		 *
-		 * 1.  that which is the result of the scaling of the subtitle by _video_container_size; this will be
-		 *     rect.x * _video_container_size.width and rect.y * _video_container_size.height.
-		 *
-		 * 2.  that to shift the origin of the scale by subtitle_scale to the centre of the subtitle; this will be
-		 *     (width_before_subtitle_scale * (1 - subtitle_x_scale) / 2) and
-		 *     (height_before_subtitle_scale * (1 - subtitle_y_scale) / 2).
-		 *
-		 * Combining these two translations gives these expressions.
-		 */
-
 		all.push_back (
 			PositionImage (
 				i->image->scale (
@@ -347,7 +346,9 @@ Player::black_player_video_frame (Eyes eyes) const
 			_video_container_size,
 			eyes,
 			PART_WHOLE,
-			PresetColourConversion::all().front().conversion
+			PresetColourConversion::all().front().conversion,
+			boost::weak_ptr<Content>(),
+			boost::optional<Frame>()
 		)
 	);
 }
@@ -417,12 +418,12 @@ Player::get_subtitle_fonts ()
 	}
 
 	list<shared_ptr<Font> > fonts;
-	BOOST_FOREACH (shared_ptr<Piece>& p, _pieces) {
-		if (p->content->subtitle) {
+	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+		BOOST_FOREACH (shared_ptr<CaptionContent> j, i->content->caption) {
 			/* XXX: things may go wrong if there are duplicate font IDs
 			   with different font files.
 			*/
-			list<shared_ptr<Font> > f = p->content->subtitle->fonts ();
+			list<shared_ptr<Font> > f = j->fonts ();
 			copy (f.begin(), f.end(), back_inserter (fonts));
 		}
 	}
@@ -438,19 +439,19 @@ Player::set_ignore_video ()
 }
 
 void
-Player::set_ignore_subtitle ()
+Player::set_ignore_caption ()
 {
-	_ignore_subtitle = true;
+	_ignore_caption = true;
 }
 
-/** Set whether or not this player should always burn text subtitles into the image,
+/** Set a type of caption that this player should always burn into the image,
  *  regardless of the content settings.
- *  @param burn true to always burn subtitles, false to obey content settings.
+ *  @param type type of captions to burn.
  */
 void
-Player::set_always_burn_subtitles (bool burn)
+Player::set_always_burn_captions (CaptionType type)
 {
-	_always_burn_subtitles = burn;
+	_always_burn_captions = type;
 }
 
 /** Sets up the player to be faster, possibly at the expense of quality */
@@ -516,7 +517,7 @@ Player::get_reel_assets ()
 					);
 			}
 
-			if (j->reference_subtitle ()) {
+			if (j->reference_caption (CAPTION_OPEN)) {
 				shared_ptr<dcp::ReelAsset> ra = k->main_subtitle ();
 				DCPOMATIC_ASSERT (ra);
 				ra->set_entry_point (ra->entry_point() + trim_start);
@@ -526,6 +527,16 @@ Player::get_reel_assets ()
 					);
 			}
 
+			if (j->reference_caption (CAPTION_CLOSED)) {
+				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)))
+					);
+			}
+
 			/* Assume that main picture duration is the length of the reel */
 			offset += k->main_picture()->duration ();
 		}
@@ -557,15 +568,15 @@ Player::pass ()
 			continue;
 		}
 
-		DCPTime const t = content_time_to_dcp (i, i->decoder->position());
+		DCPTime const t = content_time_to_dcp (i, max(i->decoder->position(), i->content->trim_start()));
 		if (t > i->content->end()) {
 			i->done = true;
 		} else {
 
-			/* Given two choices at the same time, pick the one with a subtitle so we see it before
+			/* Given two choices at the same time, pick the one with captions so we see it before
 			   the video.
 			*/
-			if (!earliest_time || t < *earliest_time || (t == *earliest_time && i->decoder->subtitle)) {
+			if (!earliest_time || t < *earliest_time || (t == *earliest_time && !i->decoder->caption.empty())) {
 				earliest_time = t;
 				earliest_content = i;
 			}
@@ -660,36 +671,45 @@ Player::pass ()
 
 	if (done) {
 		_shuffler->flush ();
-		_delay->flush ();
+		for (list<pair<shared_ptr<PlayerVideo>, DCPTime> >::const_iterator i = _delay.begin(); i != _delay.end(); ++i) {
+			do_emit_video(i->first, i->second);
+		}
 	}
+
 	return done;
 }
 
 optional<PositionImage>
-Player::subtitles_for_frame (DCPTime time) const
+Player::captions_for_frame (DCPTime time) const
 {
-	list<PositionImage> subtitles;
+	list<PositionImage> captions;
 
 	int const vfr = _film->video_frame_rate();
 
-	BOOST_FOREACH (PlayerSubtitles i, _active_subtitles.get_burnt (DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_subtitles)) {
-
-		/* Image subtitles */
-		list<PositionImage> c = transform_image_subtitles (i.image);
-		copy (c.begin(), c.end(), back_inserter (subtitles));
-
-		/* Text subtitles (rendered to an image) */
-		if (!i.text.empty ()) {
-			list<PositionImage> s = render_subtitles (i.text, i.fonts, _video_container_size, time, vfr);
-			copy (s.begin(), s.end(), back_inserter (subtitles));
+	for (int i = 0; i < CAPTION_COUNT; ++i) {
+		bool const always = _always_burn_captions && *_always_burn_captions == i;
+		BOOST_FOREACH (
+			PlayerCaption j,
+			_active_captions[i].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), always)
+			) {
+
+			/* Image subtitles */
+			list<PositionImage> c = transform_bitmap_captions (j.image);
+			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);
+				copy (s.begin(), s.end(), back_inserter (captions));
+			}
 		}
 	}
 
-	if (subtitles.empty ()) {
+	if (captions.empty ()) {
 		return optional<PositionImage> ();
 	}
 
-	return merge (subtitles);
+	return merge (captions);
 }
 
 void
@@ -765,7 +785,9 @@ Player::video (weak_ptr<Piece> wp, ContentVideo video)
 			_video_container_size,
 			video.eyes,
 			video.part,
-			piece->content->video->colour_conversion ()
+			piece->content->video->colour_conversion(),
+			piece->content,
+			video.frame
 			)
 		);
 
@@ -846,48 +868,54 @@ Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_a
 }
 
 void
-Player::image_subtitle_start (weak_ptr<Piece> wp, ContentImageSubtitle subtitle)
+Player::bitmap_text_start (weak_ptr<Piece> wp, weak_ptr<const CaptionContent> wc, ContentBitmapCaption subtitle)
 {
 	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	shared_ptr<const CaptionContent> caption = wc.lock ();
+	if (!piece || !caption) {
 		return;
 	}
 
 	/* Apply content's subtitle offsets */
-	subtitle.sub.rectangle.x += piece->content->subtitle->x_offset ();
-	subtitle.sub.rectangle.y += piece->content->subtitle->y_offset ();
+	subtitle.sub.rectangle.x += caption->x_offset ();
+	subtitle.sub.rectangle.y += caption->y_offset ();
 
-	/* Apply content's subtitle scale */
-	subtitle.sub.rectangle.width *= piece->content->subtitle->x_scale ();
-	subtitle.sub.rectangle.height *= piece->content->subtitle->y_scale ();
+	/* Apply a corrective translation to keep the subtitle centred after the scale that is coming up */
+	subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * ((caption->x_scale() - 1) / 2);
+	subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * ((caption->y_scale() - 1) / 2);
 
-	/* Apply a corrective translation to keep the subtitle centred after that scale */
-	subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * (piece->content->subtitle->x_scale() - 1);
-	subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * (piece->content->subtitle->y_scale() - 1);
+	/* Apply content's subtitle scale */
+	subtitle.sub.rectangle.width *= caption->x_scale ();
+	subtitle.sub.rectangle.height *= caption->y_scale ();
 
-	PlayerSubtitles ps;
+	PlayerCaption ps;
 	ps.image.push_back (subtitle.sub);
 	DCPTime from (content_time_to_dcp (piece, subtitle.from()));
 
-	_active_subtitles.add_from (wp, ps, from);
+	_active_captions[subtitle.type()].add_from (wc, ps, from);
 }
 
 void
-Player::text_subtitle_start (weak_ptr<Piece> wp, ContentTextSubtitle subtitle)
+Player::plain_text_start (weak_ptr<Piece> wp, weak_ptr<const CaptionContent> wc, ContentTextCaption subtitle)
 {
 	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	shared_ptr<const CaptionContent> caption = wc.lock ();
+	if (!piece || !caption) {
 		return;
 	}
 
-	PlayerSubtitles ps;
+	PlayerCaption ps;
 	DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 
+	if (from > piece->content->end()) {
+		return;
+	}
+
 	BOOST_FOREACH (dcp::SubtitleString s, subtitle.subs) {
-		s.set_h_position (s.h_position() + piece->content->subtitle->x_offset ());
-		s.set_v_position (s.v_position() + piece->content->subtitle->y_offset ());
-		float const xs = piece->content->subtitle->x_scale();
-		float const ys = piece->content->subtitle->y_scale();
+		s.set_h_position (s.h_position() + caption->x_offset ());
+		s.set_v_position (s.v_position() + caption->y_offset ());
+		float const xs = caption->x_scale();
+		float const ys = caption->y_scale();
 		float size = s.size();
 
 		/* Adjust size to express the common part of the scaling;
@@ -904,31 +932,37 @@ Player::text_subtitle_start (weak_ptr<Piece> wp, ContentTextSubtitle subtitle)
 		}
 
 		s.set_in (dcp::Time(from.seconds(), 1000));
-		ps.text.push_back (SubtitleString (s, piece->content->subtitle->outline_width()));
-		ps.add_fonts (piece->content->subtitle->fonts ());
+		ps.text.push_back (TextCaption (s, caption->outline_width()));
+		ps.add_fonts (caption->fonts ());
 	}
 
-	_active_subtitles.add_from (wp, ps, from);
+	_active_captions[subtitle.type()].add_from (wc, ps, from);
 }
 
 void
-Player::subtitle_stop (weak_ptr<Piece> wp, ContentTime to)
+Player::subtitle_stop (weak_ptr<Piece> wp, weak_ptr<const CaptionContent> wc, ContentTime to, CaptionType type)
 {
-	if (!_active_subtitles.have (wp)) {
+	if (!_active_captions[type].have (wc)) {
 		return;
 	}
 
 	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	shared_ptr<const CaptionContent> caption = wc.lock ();
+	if (!piece || !caption) {
 		return;
 	}
 
 	DCPTime const dcp_to = content_time_to_dcp (piece, to);
 
-	pair<PlayerSubtitles, DCPTime> from = _active_subtitles.add_to (wp, dcp_to);
+	if (dcp_to > piece->content->end()) {
+		return;
+	}
 
-	if (piece->content->subtitle->use() && !_always_burn_subtitles && !piece->content->subtitle->burn()) {
-		Subtitle (from.first, DCPTimePeriod (from.second, dcp_to));
+	pair<PlayerCaption, DCPTime> from = _active_captions[type].add_to (wc, dcp_to);
+
+	bool const always = _always_burn_captions && *_always_burn_captions == type;
+	if (caption->use() && !always && !caption->burn()) {
+		Caption (from.first, type, DCPTimePeriod (from.second, dcp_to));
 	}
 }
 
@@ -943,21 +977,21 @@ Player::seek (DCPTime time, bool accurate)
 		_shuffler->clear ();
 	}
 
-	if (_delay) {
-		_delay->clear ();
-	}
+	_delay.clear ();
 
 	if (_audio_processor) {
 		_audio_processor->flush ();
 	}
 
 	_audio_merger.clear ();
-	_active_subtitles.clear ();
+	for (int i = 0; i < CAPTION_COUNT; ++i) {
+		_active_captions[i].clear ();
+	}
 
 	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
 		if (time < i->content->position()) {
-			/* Before; seek to 0 */
-			i->decoder->seek (ContentTime(), 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()) {
 			/* During; seek to position */
@@ -988,18 +1022,40 @@ Player::seek (DCPTime time, bool accurate)
 void
 Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 {
-	optional<PositionImage> subtitles = subtitles_for_frame (time);
-	if (subtitles) {
-		pv->set_subtitle (subtitles.get ());
-	}
-
-	Video (pv, time);
+	/* We need a delay to give a little wiggle room to ensure that relevent subtitles arrive at the
+	   player before the video that requires them.
+	*/
+	_delay.push_back (make_pair (pv, time));
 
 	if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) {
 		_last_video_time = time + one_video_frame();
-		_active_subtitles.clear_before (time);
 	}
 	_last_video_eyes = increment_eyes (pv->eyes());
+
+	if (_delay.size() < 3) {
+		return;
+	}
+
+	pair<shared_ptr<PlayerVideo>, DCPTime> to_do = _delay.front();
+	_delay.pop_front();
+	do_emit_video (to_do.first, to_do.second);
+}
+
+void
+Player::do_emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
+{
+	if (pv->eyes() == EYES_BOTH || pv->eyes() == EYES_RIGHT) {
+		for (int i = 0; i < CAPTION_COUNT; ++i) {
+			_active_captions[i].clear_before (time);
+		}
+	}
+
+	optional<PositionImage> captions = captions_for_frame (time);
+	if (captions) {
+		pv->set_caption (captions.get ());
+	}
+
+	Video (pv, time);
 }
 
 void
@@ -1067,5 +1123,22 @@ Player::set_dcp_decode_reduction (optional<int> reduction)
 
 	_dcp_decode_reduction = reduction;
 	_have_valid_pieces = false;
-	Changed (false);
+	Changed (PlayerProperty::DCP_DECODE_REDUCTION, false);
+}
+
+DCPTime
+Player::content_time_to_dcp (shared_ptr<Content> content, ContentTime t)
+{
+	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 ();
 }