X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=8b2ade1dc74b49510828695a80e274b1391b2282;hp=2fc062bb513baf1d8c7ea2a0ae7a2145c079ee0c;hb=b56ca8250b8eae123c0992a50f5cabe99e655763;hpb=8142f2bc2e9cf757cb94753b1dda8f25b0ebaa22

diff --git a/src/lib/player.cc b/src/lib/player.cc
index 2fc062bb5..df10ec146 100644
--- a/src/lib/player.cc
+++ b/src/lib/player.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2013-2017 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2013-2021 Carl Hetherington <cth@carlh.net>
 
     This file is part of DCP-o-matic.
 
@@ -18,17 +18,20 @@
 
 */
 
+
+#include "atmos_decoder.h"
 #include "player.h"
 #include "film.h"
 #include "audio_buffers.h"
 #include "content_audio.h"
 #include "dcp_content.h"
+#include "dcpomatic_log.h"
 #include "job.h"
 #include "image.h"
 #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,305 +43,369 @@
 #include "decoder.h"
 #include "video_decoder.h"
 #include "audio_decoder.h"
-#include "subtitle_content.h"
-#include "subtitle_decoder.h"
+#include "text_content.h"
+#include "text_decoder.h"
 #include "ffmpeg_content.h"
 #include "audio_content.h"
-#include "content_subtitle.h"
 #include "dcp_decoder.h"
 #include "image_decoder.h"
-#include "resampler.h"
 #include "compose.hpp"
+#include "shuffler.h"
+#include "timer.h"
 #include <dcp/reel.h>
 #include <dcp/reel_sound_asset.h>
 #include <dcp/reel_subtitle_asset.h>
 #include <dcp/reel_picture_asset.h>
-#include <boost/foreach.hpp>
+#include <dcp/reel_closed_caption_asset.h>
 #include <stdint.h>
 #include <algorithm>
 #include <iostream>
 
 #include "i18n.h"
 
-#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
 
-using std::list;
+using std::copy;
 using std::cout;
-using std::min;
+using std::dynamic_pointer_cast;
+using std::list;
+using std::make_pair;
+using std::make_shared;
 using std::max;
 using std::min;
-using std::vector;
+using std::min;
 using std::pair;
-using std::map;
-using std::make_pair;
-using std::copy;
-using boost::shared_ptr;
-using boost::weak_ptr;
-using boost::dynamic_pointer_cast;
+using std::shared_ptr;
+using std::vector;
+using std::weak_ptr;
+using std::make_shared;
 using boost::optional;
 using boost::scoped_ptr;
+#if BOOST_VERSION >= 106100
+using namespace boost::placeholders;
+#endif
+using namespace dcpomatic;
+
+
+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;
+int const PlayerProperty::PLAYBACK_LENGTH = 705;
 
-Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist)
+
+Player::Player (shared_ptr<const Film> film, Image::Alignment subtitle_alignment)
+	: _film (film)
+	, _suspended (0)
+	, _tolerant (film->tolerant())
+	, _audio_merger (_film->audio_frame_rate())
+	, _subtitle_alignment (subtitle_alignment)
+{
+	construct ();
+}
+
+
+Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist_)
 	: _film (film)
-	, _playlist (playlist)
-	, _have_valid_pieces (false)
-	, _ignore_video (false)
-	, _ignore_audio (false)
-	, _always_burn_subtitles (false)
-	, _fast (false)
-	, _play_referenced (false)
-	, _last_seek_accurate (true)
+	, _playlist (playlist_)
+	, _suspended (0)
+	, _tolerant (film->tolerant())
 	, _audio_merger (_film->audio_frame_rate())
 {
-	_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));
+	construct ();
+}
+
+
+void
+Player::construct ()
+{
+	_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 (ChangeType::DONE, Film::Property::AUDIO_PROCESSOR);
 
+	setup_pieces ();
 	seek (DCPTime (), true);
 }
 
+
 void
 Player::setup_pieces ()
 {
+	boost::mutex::scoped_lock lm (_mutex);
+	setup_pieces_unlocked ();
+}
+
+
+bool
+have_video (shared_ptr<const Content> content)
+{
+	return static_cast<bool>(content->video) && content->video->use();
+}
+
+
+bool
+have_audio (shared_ptr<const Content> content)
+{
+	return static_cast<bool>(content->audio);
+}
+
+
+void
+Player::setup_pieces_unlocked ()
+{
+	_playback_length = _playlist ? _playlist->length(_film) : _film->length();
+
+	auto old_pieces = _pieces;
 	_pieces.clear ();
 
-	BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
+	_shuffler.reset (new Shuffler());
+	_shuffler->Video.connect(bind(&Player::video, this, _1, _2));
+
+	for (auto i: playlist()->content()) {
 
 		if (!i->paths_valid ()) {
 			continue;
 		}
 
-		shared_ptr<Decoder> decoder = decoder_factory (i, _film->log());
-		FrameRateChange frc (i->active_video_frame_rate(), _film->video_frame_rate());
-
-		if (!decoder) {
-			/* Not something that we can decode; e.g. Atmos content */
+		if (_ignore_video && _ignore_audio && i->text.empty()) {
+			/* We're only interested in text and this content has none */
 			continue;
 		}
 
+		shared_ptr<Decoder> old_decoder;
+		for (auto j: old_pieces) {
+			if (j->content == i) {
+				old_decoder = j->decoder;
+				break;
+			}
+		}
+
+		auto decoder = decoder_factory (_film, i, _fast, _tolerant, old_decoder);
+		DCPOMATIC_ASSERT (decoder);
+
+		FrameRateChange frc (_film, i);
+
 		if (decoder->video && _ignore_video) {
-			decoder->video->set_ignore ();
+			decoder->video->set_ignore (true);
 		}
 
 		if (decoder->audio && _ignore_audio) {
-			decoder->audio->set_ignore ();
+			decoder->audio->set_ignore (true);
+		}
+
+		if (_ignore_text) {
+			for (auto i: decoder->text) {
+				i->set_ignore (true);
+			}
 		}
 
-		shared_ptr<DCPDecoder> dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
-		if (dcp && _play_referenced) {
-			dcp->set_decode_referenced ();
+		auto dcp = dynamic_pointer_cast<DCPDecoder> (decoder);
+		if (dcp) {
+			dcp->set_decode_referenced (_play_referenced);
+			if (_play_referenced) {
+				dcp->set_forced_reduction (_dcp_decode_reduction);
+			}
 		}
 
-		shared_ptr<Piece> piece (new Piece (i, decoder, frc));
+		auto piece = make_shared<Piece>(i, decoder, frc);
 		_pieces.push_back (piece);
 
 		if (decoder->video) {
-			decoder->video->Data.connect (bind (&Player::video, this, weak_ptr<Piece> (piece), _1));
+			if (i->video->frame_type() == VideoFrameType::THREE_D_LEFT || i->video->frame_type() == VideoFrameType::THREE_D_RIGHT) {
+				/* We need a Shuffler to cope with 3D L/R video data arriving out of sequence */
+				decoder->video->Data.connect (bind(&Shuffler::video, _shuffler.get(), weak_ptr<Piece>(piece), _1));
+			} else {
+				decoder->video->Data.connect (bind(&Player::video, this, weak_ptr<Piece>(piece), _1));
+			}
 		}
 
 		if (decoder->audio) {
 			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));
+		auto j = decoder->text.begin();
+
+		while (j != decoder->text.end()) {
+			(*j)->BitmapStart.connect (
+				bind(&Player::bitmap_text_start, this, weak_ptr<Piece>(piece), weak_ptr<const TextContent>((*j)->content()), _1)
+				);
+			(*j)->PlainStart.connect (
+				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)
+				);
+
+			++j;
+		}
+
+		if (decoder->atmos) {
+			decoder->atmos->Data.connect (bind(&Player::atmos, this, weak_ptr<Piece>(piece), _1));
 		}
 	}
 
-	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+	_stream_states.clear ();
+	for (auto i: _pieces) {
 		if (i->content->audio) {
-			BOOST_FOREACH (AudioStreamPtr j, i->content->audio->streams()) {
+			for (auto j: i->content->audio->streams()) {
 				_stream_states[j] = StreamState (i, i->content->position ());
 			}
 		}
 	}
 
-	if (!_play_referenced) {
-		BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
-			shared_ptr<DCPContent> dc = dynamic_pointer_cast<DCPContent> (i->content);
-			if (dc) {
-				if (dc->reference_video()) {
-					_no_video.push_back (DCPTimePeriod (dc->position(), dc->end()));
-				}
-				if (dc->reference_audio()) {
-					_no_audio.push_back (DCPTimePeriod (dc->position(), dc->end()));
+	for (auto i = _pieces.begin(); i != _pieces.end(); ++i) {
+		if (auto video = (*i)->content->video) {
+			if (video->use() && video->frame_type() != VideoFrameType::THREE_D_LEFT && video->frame_type() != VideoFrameType::THREE_D_RIGHT) {
+				/* Look for content later in the content list with in-use video that overlaps this */
+				auto period = DCPTimePeriod((*i)->content->position(), (*i)->content->end(_film));
+				auto j = i;
+				++j;
+				for (; j != _pieces.end(); ++j) {
+					if ((*j)->content->video && (*j)->content->video->use()) {
+						(*i)->ignore_video = DCPTimePeriod((*j)->content->position(), (*j)->content->end(_film)).overlap(period);
+					}
 				}
 			}
 		}
 	}
 
-	_last_video_time = optional<DCPTime> ();
-	_last_audio_time = optional<DCPTime> ();
-	_have_valid_pieces = true;
+	_black = Empty (_film, playlist(), bind(&have_video, _1), _playback_length);
+	_silent = Empty (_film, playlist(), bind(&have_audio, _1), _playback_length);
+
+	_last_video_time = boost::optional<dcpomatic::DCPTime>();
+	_last_video_eyes = Eyes::BOTH;
+	_last_audio_time = boost::optional<dcpomatic::DCPTime>();
 }
 
+
 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 (property == VideoContentProperty::CROP) {
+		if (type == ChangeType::DONE) {
+			auto const vcs = video_container_size();
+			boost::mutex::scoped_lock lm (_mutex);
+			for (auto const& i: _delay) {
+				i.first->reset_metadata (_film, vcs);
+			}
+		}
+	} else {
+		if (type == ChangeType::PENDING) {
+			/* 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;
+		} else if (type == ChangeType::DONE) {
+			/* A change in our content has gone through.  Re-build our pieces. */
+			setup_pieces ();
+			--_suspended;
+		} else if (type == ChangeType::CANCELLED) {
+			--_suspended;
+		}
 	}
 
-	if (
-		property == ContentProperty::POSITION ||
-		property == ContentProperty::LENGTH ||
-		property == ContentProperty::TRIM_START ||
-		property == ContentProperty::TRIM_END ||
-		property == ContentProperty::PATH ||
-		property == VideoContentProperty::FRAME_TYPE ||
-		property == DCPContentProperty::NEEDS_ASSETS ||
-		property == DCPContentProperty::NEEDS_KDM ||
-		property == SubtitleContentProperty::COLOUR ||
-		property == SubtitleContentProperty::OUTLINE ||
-		property == SubtitleContentProperty::SHADOW ||
-		property == SubtitleContentProperty::EFFECT_COLOUR ||
-		property == FFmpegContentProperty::SUBTITLE_STREAM ||
-		property == VideoContentProperty::COLOUR_CONVERSION
-		) {
-
-		_have_valid_pieces = false;
-		Changed (frequent);
-
-	} else if (
-		property == SubtitleContentProperty::LINE_SPACING ||
-		property == SubtitleContentProperty::OUTLINE_WIDTH ||
-		property == SubtitleContentProperty::Y_SCALE ||
-		property == SubtitleContentProperty::FADE_IN ||
-		property == SubtitleContentProperty::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 == VideoContentProperty::CROP ||
-		property == VideoContentProperty::SCALE ||
-		property == VideoContentProperty::FADE_IN ||
-		property == VideoContentProperty::FADE_OUT
-		) {
-
-		Changed (frequent);
-	}
+	Change (type, property, frequent);
 }
 
+
 void
 Player::set_video_container_size (dcp::Size s)
 {
-	if (s == _video_container_size) {
-		return;
-	}
+	Change (ChangeType::PENDING, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
+
+	{
+		boost::mutex::scoped_lock lm (_mutex);
+
+		if (s == _video_container_size) {
+			lm.unlock ();
+			Change (ChangeType::CANCELLED, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
+			return;
+		}
 
-	_video_container_size = s;
+		_video_container_size = s;
 
-	_black_image.reset (new Image (AV_PIX_FMT_RGB24, _video_container_size, true));
-	_black_image->make_black ();
+		_black_image = make_shared<Image>(AV_PIX_FMT_RGB24, _video_container_size, Image::Alignment::PADDED);
+		_black_image->make_black ();
+	}
 
-	Changed (false);
+	Change (ChangeType::DONE, PlayerProperty::VIDEO_CONTAINER_SIZE, false);
 }
 
+
 void
-Player::playlist_changed ()
+Player::playlist_change (ChangeType type)
 {
-	_have_valid_pieces = false;
-	Changed (false);
+	if (type == ChangeType::DONE) {
+		setup_pieces ();
+	}
+	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
 	   last time we were run.
 	*/
 
-	if (p == Film::CONTAINER) {
-		Changed (false);
-	} else if (p == Film::VIDEO_FRAME_RATE) {
+	if (p == Film::Property::CONTAINER) {
+		Change (type, PlayerProperty::FILM_CONTAINER, false);
+	} else if (p == Film::Property::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);
-	} else if (p == Film::AUDIO_PROCESSOR) {
-		if (_film->audio_processor ()) {
+		if (type == ChangeType::DONE) {
+			setup_pieces ();
+		}
+		Change (type, PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
+	} else if (p == Film::Property::AUDIO_PROCESSOR) {
+		if (type == ChangeType::DONE && _film->audio_processor ()) {
+			boost::mutex::scoped_lock lm (_mutex);
 			_audio_processor = _film->audio_processor()->clone (_film->audio_frame_rate ());
 		}
-	}
-}
-
-list<PositionImage>
-Player::transform_image_subtitles (list<ImageSubtitle> subs) const
-{
-	list<PositionImage> all;
-
-	for (list<ImageSubtitle>::const_iterator i = subs.begin(); i != subs.end(); ++i) {
-		if (!i->image) {
-			continue;
+	} else if (p == Film::Property::AUDIO_CHANNELS) {
+		if (type == ChangeType::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);
-
-		/* 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 (
-					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>
-Player::black_player_video_frame () const
+Player::black_player_video_frame (Eyes eyes) const
 {
-	return shared_ptr<PlayerVideo> (
-		new PlayerVideo (
-			shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)),
-			Crop (),
-			optional<double> (),
-			_video_container_size,
-			_video_container_size,
-			EYES_BOTH,
-			PART_WHOLE,
-			PresetColourConversion::all().front().conversion
-		)
+	return std::make_shared<PlayerVideo> (
+		std::make_shared<const RawImageProxy>(_black_image),
+		Crop(),
+		optional<double>(),
+		_video_container_size,
+		_video_container_size,
+		eyes,
+		Part::WHOLE,
+		PresetColourConversion::all().front().conversion,
+		VideoRange::FULL,
+		std::weak_ptr<Content>(),
+		boost::optional<Frame>(),
+		false
 	);
 }
 
+
 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);
+	auto s = t - piece->content->position ();
+	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)
@@ -351,416 +418,627 @@ Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 	return s.frames_floor (piece->frc.dcp) / piece->frc.factor ();
 }
 
+
 DCPTime
 Player::content_video_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 {
 	/* See comment in dcp_to_content_video */
-	DCPTime const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime (piece->content->trim_start (), piece->frc);
-	return max (DCPTime (), d + piece->content->position ());
+	auto const d = DCPTime::from_frames (f * piece->frc.factor(), piece->frc.dcp) - DCPTime(piece->content->trim_start(), piece->frc);
+	return d + piece->content->position();
 }
 
+
 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);
+	auto s = t - piece->content->position ();
+	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 ());
+	return max (DCPTime(), DCPTime(piece->content->trim_start(), piece->frc) + s).frames_floor(_film->audio_frame_rate());
 }
 
+
 DCPTime
 Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 {
 	/* See comment in dcp_to_content_video */
-	DCPTime const d = DCPTime::from_frames (f, _film->audio_frame_rate()) - DCPTime (piece->content->trim_start(), piece->frc);
-	return max (DCPTime (), d + piece->content->position ());
+	return DCPTime::from_frames (f, _film->audio_frame_rate())
+		- DCPTime (piece->content->trim_start(), piece->frc)
+		+ piece->content->position();
 }
 
+
 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);
+	auto s = t - piece->content->position ();
+	s = min (piece->content->length_after_trim(_film), s);
 	return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 }
 
+
 DCPTime
 Player::content_time_to_dcp (shared_ptr<const Piece> piece, ContentTime t) const
 {
-	return max (DCPTime (), DCPTime (t - piece->content->trim_start(), piece->frc) + piece->content->position());
+	return max (DCPTime(), DCPTime(t - piece->content->trim_start(), piece->frc) + piece->content->position());
 }
 
-list<shared_ptr<Font> >
+
+vector<FontData>
 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>& p, _pieces) {
-		if (p->content->subtitle) {
-			/* XXX: things may go wrong if there are duplicate font IDs
-			   with different font files.
-			*/
-			list<shared_ptr<Font> > f = p->content->subtitle->fonts ();
-			copy (f.begin(), f.end(), back_inserter (fonts));
-		}
+	vector<FontData> fonts;
+	for (auto i: _pieces) {
+		/* XXX: things may go wrong if there are duplicate font IDs
+		   with different font files.
+		*/
+		auto f = i->decoder->fonts ();
+		copy (f.begin(), f.end(), back_inserter(fonts));
 	}
 
 	return fonts;
 }
 
+
 /** Set this player never to produce any video data */
 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 whether or not this player should always burn text subtitles into the image,
- *  regardless of the content settings.
- *  @param burn true to always burn subtitles, false to obey content settings.
- */
+
+/** Set the player to always burn open texts into the image regardless of the content settings */
 void
-Player::set_always_burn_subtitles (bool burn)
+Player::set_always_burn_open_subtitles ()
 {
-	_always_burn_subtitles = burn;
+	boost::mutex::scoped_lock lm (_mutex);
+	_always_burn_open_subtitles = true;
 }
 
+
+/** Sets up the player to be faster, possibly at the expense of quality */
 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 ();
+}
+
+
+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().get_value_or(0) + reel_trim_start);
+	r->set_duration (r->actual_duration() - reel_trim_start - reel_trim_end);
+	if (r->actual_duration() > 0) {
+		a.push_back (
+			ReferencedReelAsset(r, DCPTimePeriod(from, from + DCPTime::from_frames(r->actual_duration(), ffr)))
+			);
+	}
 }
 
+
 list<ReferencedReelAsset>
 Player::get_reel_assets ()
 {
-	list<ReferencedReelAsset> a;
+	/* Does not require a lock on _mutex as it's only called from DCPEncoder */
+
+	list<ReferencedReelAsset> reel_assets;
 
-	BOOST_FOREACH (shared_ptr<Content> i, _playlist->content ()) {
-		shared_ptr<DCPContent> j = dynamic_pointer_cast<DCPContent> (i);
-		if (!j) {
+	for (auto content: playlist()->content()) {
+		auto dcp = dynamic_pointer_cast<DCPContent>(content);
+		if (!dcp) {
 			continue;
 		}
 
 		scoped_ptr<DCPDecoder> decoder;
 		try {
-			decoder.reset (new DCPDecoder (j, _film->log()));
+			decoder.reset (new DCPDecoder(_film, dcp, false, false, shared_ptr<DCPDecoder>()));
 		} catch (...) {
-			return a;
+			return reel_assets;
+		}
+
+		DCPOMATIC_ASSERT (dcp->video_frame_rate());
+		double const cfr = dcp->video_frame_rate().get();
+		Frame const trim_start = dcp->trim_start().frames_round(cfr);
+		Frame const trim_end = dcp->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 i the asset from the end */
+		int64_t offset_from_end = 0;
+		for (auto k: decoder->reels()) {
+			/* Assume that main picture duration is the length of the reel */
+			offset_from_end += k->main_picture()->actual_duration();
 		}
 
-		int64_t offset = 0;
-		BOOST_FOREACH (shared_ptr<dcp::Reel> k, decoder->reels()) {
-
-			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 ();
-
-			DCPTime const from = i->position() + DCPTime::from_frames (offset, _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)))
-					);
+		for (auto reel: decoder->reels()) {
+
+			/* Assume that main picture duration is the length of the reel */
+			int64_t const reel_duration = reel->main_picture()->actual_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)));
+
+			auto const from = content->position() + DCPTime::from_frames(offset_from_start, ffr);
+			if (dcp->reference_video()) {
+				maybe_add_asset (reel_assets, reel->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)))
-					);
+			if (dcp->reference_audio()) {
+				maybe_add_asset (reel_assets, reel->main_sound(), reel_trim_start, reel_trim_end, from, ffr);
 			}
 
-			if (j->reference_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)))
-					);
+			if (dcp->reference_text(TextType::OPEN_SUBTITLE)) {
+				maybe_add_asset (reel_assets, reel->main_subtitle(), reel_trim_start, reel_trim_end, from, ffr);
 			}
 
-			/* Assume that main picture duration is the length of the reel */
-			offset += k->main_picture()->duration ();
+			if (dcp->reference_text(TextType::CLOSED_CAPTION)) {
+				for (auto caption: reel->closed_captions()) {
+					maybe_add_asset (reel_assets, caption, reel_trim_start, reel_trim_end, from, ffr);
+				}
+			}
+
+			offset_from_start += reel_duration;
+			offset_from_end -= reel_duration;
 		}
 	}
 
-	return a;
+	return reel_assets;
 }
 
+
 bool
 Player::pass ()
 {
-	if (!_have_valid_pieces) {
-		setup_pieces ();
+	boost::mutex::scoped_lock lm (_mutex);
+
+	if (_suspended) {
+		/* We can't pass in this state */
+		LOG_DEBUG_PLAYER_NC ("Player is suspended");
+		return false;
 	}
 
-	shared_ptr<Piece> earliest;
-	DCPTime earliest_content;
+	if (_playback_length == DCPTime()) {
+		/* Special; just give one black frame */
+		emit_video (black_player_video_frame(Eyes::BOTH), DCPTime());
+		return true;
+	}
 
-	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
-		if (!i->done) {
-			DCPTime const t = i->content->position() + DCPTime (i->decoder->position(), i->frc);
-			if (!earliest || t < earliest_content) {
-				earliest_content = t;
-				earliest = i;
-			}
+	/* Find the decoder or empty which is farthest behind where we are and make it emit some data */
+
+	shared_ptr<Piece> earliest_content;
+	optional<DCPTime> earliest_time;
+
+	for (auto i: _pieces) {
+		if (i->done) {
+			continue;
 		}
-	}
 
-	if (earliest) {
-		earliest->done = earliest->decoder->pass ();
-		if (earliest->done && earliest->content->audio) {
-			/* Flush the Player audio system for this piece */
-			BOOST_FOREACH (AudioStreamPtr i, earliest->content->audio->streams()) {
-				audio_flush (earliest, i);
+		auto const t = content_time_to_dcp (i, max(i->decoder->position(), i->content->trim_start()));
+		if (t > i->content->end(_film)) {
+			i->done = true;
+		} else {
+
+			/* Given two choices at the same time, pick the one with texts so we see it before
+			   the video.
+			*/
+			if (!earliest_time || t < *earliest_time || (t == *earliest_time && !i->decoder->text.empty())) {
+				earliest_time = t;
+				earliest_content = i;
 			}
 		}
 	}
 
-	/* Fill towards the next thing that might happen (or the end of the playlist).  This is to fill gaps between content,
-	   NOT to fill gaps within content (the latter is done in ::video())
-	*/
-	DCPTime fill_towards = earliest ? earliest_content : _playlist->length();
+	bool done = false;
 
-	/* Work out where to fill video from */
-	optional<DCPTime> video_fill_from;
-	if (_last_video_time && !_playlist->video_content_at(*_last_video_time)) {
-		/* No seek; fill from the last video time */
-		video_fill_from = _last_video_time;
-	} else if (_last_seek_time && !_playlist->video_content_at(*_last_seek_time)) {
-		/* Seek into an empty area; fill from the seek time */
-		video_fill_from = _last_seek_time;
+	enum {
+		NONE,
+		CONTENT,
+		BLACK,
+		SILENT
+	} which = NONE;
+
+	if (earliest_content) {
+		which = CONTENT;
 	}
 
-	bool filled = false;
-	/* Fill some black if we would emit before the earliest piece of content.  This is so we act like a phantom
-	   Piece which emits black in spaces (we only emit if we are the earliest thing)
-	*/
-	if (earliest && video_fill_from && *video_fill_from < earliest_content && ((fill_towards - *video_fill_from)) >= one_video_frame()) {
-		emit_video (black_player_video_frame(), *video_fill_from);
-		filled = true;
-	} else if (_playlist->length() == DCPTime()) {
-		/* Special case of an empty Film; just give one black frame */
-		emit_video (black_player_video_frame(), DCPTime());
-		filled = true;
-	}
-
-	optional<DCPTime> audio_fill_from;
-	if (_last_audio_time && !_playlist->audio_content_at(*_last_audio_time)) {
-		/* No seek; fill from the last thing that happened */
-		audio_fill_from = _last_audio_time;
-	} else if (_last_seek_time && !_playlist->audio_content_at(*_last_seek_time)) {
-		/* Seek into an empty area; fill from the seek time */
-		audio_fill_from = _last_seek_time;
-	}
-
-	if (audio_fill_from && audio_fill_from < fill_towards) {
-		DCPTimePeriod period (*audio_fill_from, fill_towards);
+	if (!_black.done() && !_ignore_video && (!earliest_time || _black.position() < *earliest_time)) {
+		earliest_time = _black.position ();
+		which = BLACK;
+	}
+
+	if (!_silent.done() && !_ignore_audio && (!earliest_time || _silent.position() < *earliest_time)) {
+		earliest_time = _silent.position ();
+		which = SILENT;
+	}
+
+	switch (which) {
+	case CONTENT:
+	{
+		LOG_DEBUG_PLAYER ("Calling pass() on %1", earliest_content->content->path(0));
+		earliest_content->done = earliest_content->decoder->pass ();
+		auto dcp = dynamic_pointer_cast<DCPContent>(earliest_content->content);
+		if (dcp && !_play_referenced && dcp->reference_audio()) {
+			/* We are skipping some referenced DCP audio content, so we need to update _last_audio_time
+			   to `hide' the fact that no audio was emitted during the referenced DCP (though
+			   we need to behave as though it was).
+			*/
+			_last_audio_time = dcp->end (_film);
+		}
+		break;
+	}
+	case BLACK:
+		LOG_DEBUG_PLAYER ("Emit black for gap at %1", to_string(_black.position()));
+		emit_video (black_player_video_frame(Eyes::BOTH), _black.position());
+		_black.set_position (_black.position() + one_video_frame());
+		break;
+	case SILENT:
+	{
+		LOG_DEBUG_PLAYER ("Emit silence for gap at %1", to_string(_silent.position()));
+		DCPTimePeriod period (_silent.period_at_position());
+		if (_last_audio_time) {
+			/* Sometimes the thing that happened last finishes fractionally before
+			   or after this silence.  Bodge the start time of the silence to fix it.
+			   I think this is nothing to worry about since we will just add or
+			   remove a little silence at the end of some content.
+			*/
+			int64_t const error = labs(period.from.get() - _last_audio_time->get());
+			/* Let's not worry about less than a frame at 24fps */
+			int64_t const too_much_error = DCPTime::from_frames(1, 24).get();
+			if (error >= too_much_error) {
+				_film->log()->log(String::compose("Silence starting before or after last audio by %1", error), LogEntry::TYPE_ERROR);
+			}
+			DCPOMATIC_ASSERT (error < too_much_error);
+			period.from = *_last_audio_time;
+		}
 		if (period.duration() > one_video_frame()) {
 			period.to = period.from + one_video_frame();
 		}
 		fill_audio (period);
-		filled = true;
+		_silent.set_position (period.to);
+		break;
+	}
+	case NONE:
+		done = true;
+		break;
 	}
 
 	/* Emit any audio that is ready */
 
-	DCPTime pull_to = _playlist->length ();
-	for (map<AudioStreamPtr, StreamState>::const_iterator i = _stream_states.begin(); i != _stream_states.end(); ++i) {
-		if (!i->second.piece->done && i->second.last_push_end < pull_to) {
-			pull_to = i->second.last_push_end;
+	/* Work out the time before which the audio is definitely all here.  This is the earliest last_push_end of one
+	   of our streams, or the position of the _silent.  First, though we choose only streams that are less than
+	   ignore_streams_behind seconds behind the furthest ahead (we assume that if a stream has fallen that far
+	   behind it has finished).  This is so that we don't withhold audio indefinitely awaiting data from a stream
+	   that will never come, causing bugs like #2101.
+	*/
+	constexpr int ignore_streams_behind = 5;
+
+	using state_pair = std::pair<AudioStreamPtr, StreamState>;
+
+	/* Find the 'leading' stream (i.e. the one that pushed data most recently) */
+	auto latest_last_push_end = std::max_element(
+		_stream_states.begin(),
+		_stream_states.end(),
+		[](state_pair const& a, state_pair const& b) { return a.second.last_push_end < b.second.last_push_end; }
+		);
+
+	if (latest_last_push_end != _stream_states.end()) {
+		LOG_DEBUG_PLAYER("Leading stream is in %1 at %2", latest_last_push_end->second.piece->content->path(0), to_string(latest_last_push_end->second.last_push_end));
+	}
+
+	/* Now make a list of those streams that are less than ignore_streams_behind behind the leader */
+	std::map<AudioStreamPtr, StreamState> alive_stream_states;
+	for (auto const& i: _stream_states) {
+		if ((latest_last_push_end->second.last_push_end - i.second.last_push_end) < dcpomatic::DCPTime::from_seconds(ignore_streams_behind)) {
+			alive_stream_states.insert(i);
+		} else {
+			LOG_DEBUG_PLAYER("Ignoring stream %1 because it is too far behind", i.second.piece->content->path(0));
+		}
+	}
+
+	auto pull_to = _playback_length;
+	for (auto const& i: alive_stream_states) {
+		if (!i.second.piece->done && i.second.last_push_end < pull_to) {
+			pull_to = i.second.last_push_end;
 		}
 	}
+	if (!_silent.done() && _silent.position() < pull_to) {
+		pull_to = _silent.position();
+	}
 
-	list<pair<shared_ptr<AudioBuffers>, DCPTime> > audio = _audio_merger.pull (pull_to);
-	for (list<pair<shared_ptr<AudioBuffers>, DCPTime> >::iterator i = audio.begin(); i != audio.end(); ++i) {
+	LOG_DEBUG_PLAYER("Emitting audio up to %1", to_string(pull_to));
+	auto audio = _audio_merger.pull (pull_to);
+	for (auto i = audio.begin(); i != audio.end(); ++i) {
 		if (_last_audio_time && i->second < *_last_audio_time) {
-			/* There has been an accurate seek and we have received some audio before the seek time;
-			   discard it.
-			*/
-			pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (i->first, i->second, *_last_audio_time);
+			/* This new data comes before the last we emitted (or the last seek); discard it */
+			auto cut = discard_audio (i->first, i->second, *_last_audio_time);
 			if (!cut.first) {
 				continue;
 			}
 			*i = cut;
-		}
-
-		if (_last_audio_time) {
+		} else if (_last_audio_time && i->second > *_last_audio_time) {
+			/* There's a gap between this data and the last we emitted; fill with silence */
 			fill_audio (DCPTimePeriod (*_last_audio_time, i->second));
 		}
 
 		emit_audio (i->first, i->second);
 	}
 
-	return !earliest && !filled;
+	if (done) {
+		_shuffler->flush ();
+		for (auto const& i: _delay) {
+			do_emit_video(i.first, i.second);
+		}
+	}
+
+	return done;
 }
 
+
+/** @return Open subtitles for the frame at the given time, converted to images */
 optional<PositionImage>
-Player::subtitles_for_frame (DCPTime time) const
+Player::open_subtitles_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 (time, _always_burn_subtitles)) {
+	for (
+		auto j:
+		_active_texts[static_cast<int>(TextType::OPEN_SUBTITLE)].get_burnt(DCPTimePeriod(time, time + DCPTime::from_frames(1, vfr)), _always_burn_open_subtitles)
+		) {
 
-		/* Image subtitles */
-		list<PositionImage> c = transform_image_subtitles (i.image);
-		copy (c.begin(), c.end(), back_inserter (subtitles));
+		/* Bitmap subtitles */
+		for (auto 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)
+						)
+					)
+				);
+		}
 
-		/* Text subtitles (rendered to an image) */
-		if (!i.text.empty ()) {
-			list<PositionImage> s = render_subtitles (i.text, i.fonts, _video_container_size, time);
-			copy (s.begin(), s.end(), back_inserter (subtitles));
+		/* String subtitles (rendered to an image) */
+		if (!j.string.empty()) {
+			auto s = render_text (j.string, j.fonts, _video_container_size, time, vfr);
+			copy (s.begin(), s.end(), back_inserter (captions));
 		}
 	}
 
-	if (subtitles.empty ()) {
-		return optional<PositionImage> ();
+	if (captions.empty()) {
+		return {};
 	}
 
-	return merge (subtitles);
+	return merge (captions, _subtitle_alignment);
 }
 
+
 void
 Player::video (weak_ptr<Piece> wp, ContentVideo video)
 {
-	shared_ptr<Piece> piece = wp.lock ();
+	if (_suspended) {
+		return;
+	}
+
+	auto piece = wp.lock ();
 	if (!piece) {
 		return;
 	}
 
-	FrameRateChange frc(piece->content->active_video_frame_rate(), _film->video_frame_rate());
+	if (!piece->content->video->use()) {
+		return;
+	}
+
+	FrameRateChange frc (_film, piece->content);
 	if (frc.skip && (video.frame % 2) == 1) {
 		return;
 	}
 
-	/* Time and period of the frame we will emit */
+	/* Time of the first frame we will emit */
 	DCPTime const time = content_video_to_dcp (piece, video.frame);
-	DCPTimePeriod const period (time, time + one_video_frame());
+	LOG_DEBUG_PLAYER("Received video frame %1 at %2", video.frame, to_string(time));
+
+	/* Discard if it's before the content's period or the last accurate seek.  We can't discard
+	   if it's after the content's period here as in that case we still need to fill any gap between
+	   `now' and the end of the content's period.
+	*/
+	if (time < piece->content->position() || (_last_video_time && time < *_last_video_time)) {
+		return;
+	}
 
-	/* Discard if it's outside the content's period or if it's before the last accurate seek */
-	if (
-		time < piece->content->position() ||
-		time >= piece->content->end() ||
-		(_last_seek_time && _last_seek_accurate && time < *_last_seek_time)) {
+	if (piece->ignore_video && piece->ignore_video->contains(time)) {
 		return;
 	}
 
-	/* Fill gaps caused by (the hopefully rare event of) a decoder not emitting contiguous video.  We have to do this here
-	   as in the problematic case we are about to emit a frame which is not contiguous with the previous.
+	/* 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(_film));
 
 	if (_last_video_time) {
-		/* XXX: this may not work for 3D */
-		BOOST_FOREACH (DCPTimePeriod i, subtract(DCPTimePeriod (*_last_video_time, time), _no_video)) {
-			for (DCPTime j = i.from; j < i.to; j += one_video_frame()) {
-				if (_last_video) {
-					emit_video (shared_ptr<PlayerVideo> (new PlayerVideo (*_last_video)), j);
-				} else {
-					emit_video (black_player_video_frame(), j);
+		DCPTime fill_from = max (*_last_video_time, piece->content->position());
+
+		/* Fill if we have more than half a frame to do */
+		if ((fill_to - fill_from) > one_video_frame() / 2) {
+			auto last = _last_video.find (wp);
+			if (_film->three_d()) {
+				auto fill_to_eyes = video.eyes;
+				if (fill_to_eyes == Eyes::BOTH) {
+					fill_to_eyes = Eyes::LEFT;
+				}
+				if (fill_to == piece->content->end(_film)) {
+					/* Don't fill after the end of the content */
+					fill_to_eyes = Eyes::LEFT;
+				}
+				auto j = fill_from;
+				auto 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()) {
+						LOG_DEBUG_PLAYER("Fill using last video at %1 in 3D mode", to_string(j));
+						auto copy = last->second->shallow_copy();
+						copy->set_eyes (eyes);
+						emit_video (copy, j);
+					} else {
+						LOG_DEBUG_PLAYER("Fill using black at %1 in 3D mode", to_string(j));
+						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);
+					}
 				}
 			}
 		}
 	}
 
-	_last_video.reset (
-		new PlayerVideo (
-			video.image,
-			piece->content->video->crop (),
-			piece->content->video->fade (video.frame),
-			piece->content->video->scale().size (
-				piece->content->video, _video_container_size, _film->frame_size ()
-				),
+	auto const content_video = piece->content->video;
+
+	_last_video[wp] = std::make_shared<PlayerVideo>(
+		video.image,
+		content_video->actual_crop(),
+		content_video->fade (_film, video.frame),
+		scale_for_display(
+			content_video->scaled_size(_film->frame_size()),
 			_video_container_size,
-			video.eyes,
-			video.part,
-			piece->content->video->colour_conversion ()
-			)
+			_film->frame_size(),
+			content_video->pixel_quanta()
+			),
+		_video_container_size,
+		video.eyes,
+		video.part,
+		content_video->colour_conversion(),
+		content_video->range(),
+		piece->content,
+		video.frame,
+		false
 		);
 
-	emit_video (_last_video, time);
+	DCPTime t = time;
+	for (int i = 0; i < frc.repeat; ++i) {
+		if (t < piece->content->end(_film)) {
+			emit_video (_last_video[wp], t);
+		}
+		t += one_video_frame ();
+	}
 }
 
+
 void
-Player::audio_flush (shared_ptr<Piece> piece, AudioStreamPtr stream)
+Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
 {
-	shared_ptr<AudioContent> content = piece->content->audio;
-	DCPOMATIC_ASSERT (content);
-
-	shared_ptr<Resampler> r = resampler (content, stream, false);
-	if (!r) {
+	if (_suspended) {
 		return;
 	}
 
-	pair<shared_ptr<const AudioBuffers>, Frame> ro = r->flush ();
-	if (ro.first->frames() == 0) {
+	DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
+
+	auto piece = wp.lock ();
+	if (!piece) {
 		return;
 	}
 
-	ContentAudio content_audio;
-	content_audio.audio = ro.first;
-	content_audio.frame = ro.second;
+	auto content = piece->content->audio;
+	DCPOMATIC_ASSERT (content);
+
+	int const rfr = content->resampled_frame_rate (_film);
 
 	/* Compute time in the DCP */
-	DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000.0);
+	auto time = resampled_audio_to_dcp (piece, content_audio.frame);
+	LOG_DEBUG_PLAYER("Received audio frame %1 at %2", content_audio.frame, to_string(time));
 
-	audio_transform (content, stream, content_audio, time);
-}
+	/* And the end of this block in the DCP */
+	auto end = time + DCPTime::from_frames(content_audio.audio->frames(), rfr);
+
+	/* Remove anything that comes before the start or after the end of the content */
+	if (time < piece->content->position()) {
+		auto cut = discard_audio (content_audio.audio, time, piece->content->position());
+		if (!cut.first) {
+			/* This audio is entirely discarded */
+			return;
+		}
+		content_audio.audio = cut.first;
+		time = cut.second;
+	} else if (time > piece->content->end(_film)) {
+		/* Discard it all */
+		return;
+	} else if (end > piece->content->end(_film)) {
+		Frame const remaining_frames = DCPTime(piece->content->end(_film) - time).frames_round(rfr);
+		if (remaining_frames == 0) {
+			return;
+		}
+		content_audio.audio = make_shared<AudioBuffers>(content_audio.audio, remaining_frames, 0);
+	}
 
-/** Do our common processing on some audio */
-void
-Player::audio_transform (shared_ptr<AudioContent> content, AudioStreamPtr stream, ContentAudio content_audio, DCPTime time)
-{
 	DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
 
 	/* Gain */
 
 	if (content->gain() != 0) {
-		shared_ptr<AudioBuffers> gain (new AudioBuffers (content_audio.audio));
-		gain->apply_gain (content->gain ());
+		auto gain = make_shared<AudioBuffers>(content_audio.audio);
+		gain->apply_gain (content->gain());
 		content_audio.audio = gain;
 	}
 
 	/* Remap */
 
-	shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), content_audio.audio->frames()));
-	dcp_mapped->make_silent ();
-
-	AudioMapping map = stream->mapping ();
-	for (int i = 0; i < map.input_channels(); ++i) {
-		for (int j = 0; j < dcp_mapped->channels(); ++j) {
-			if (map.get (i, static_cast<dcp::Channel> (j)) > 0) {
-				dcp_mapped->accumulate_channel (
-					content_audio.audio.get(),
-					i,
-					static_cast<dcp::Channel> (j),
-					map.get (i, static_cast<dcp::Channel> (j))
-					);
-			}
-		}
-	}
-
-	content_audio.audio = dcp_mapped;
+	content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping());
 
 	/* Process */
 
@@ -775,110 +1053,75 @@ Player::audio_transform (shared_ptr<AudioContent> content, AudioStreamPtr stream
 	_stream_states[stream].last_push_end = time + DCPTime::from_frames (content_audio.audio->frames(), _film->audio_frame_rate());
 }
 
+
 void
-Player::audio (weak_ptr<Piece> wp, AudioStreamPtr stream, ContentAudio content_audio)
+Player::bitmap_text_start (weak_ptr<Piece> wp, weak_ptr<const TextContent> wc, ContentBitmapText subtitle)
 {
-	DCPOMATIC_ASSERT (content_audio.audio->frames() > 0);
-
-	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	if (_suspended) {
 		return;
 	}
 
-	shared_ptr<AudioContent> content = piece->content->audio;
-	DCPOMATIC_ASSERT (content);
-
-	/* Resample */
-	if (stream->frame_rate() != content->resampled_frame_rate()) {
-		shared_ptr<Resampler> r = resampler (content, stream, true);
-		pair<shared_ptr<const AudioBuffers>, Frame> ro = r->run (content_audio.audio, content_audio.frame);
-		if (ro.first->frames() == 0) {
-			return;
-		}
-		content_audio.audio = ro.first;
-		content_audio.frame = ro.second;
+	auto piece = wp.lock ();
+	auto text = wc.lock ();
+	if (!piece || !text) {
+		return;
 	}
 
-	/* Compute time in the DCP */
-	DCPTime time = resampled_audio_to_dcp (piece, content_audio.frame) + DCPTime::from_seconds (content->delay() / 1000.0);
-	/* And the end of this block in the DCP */
-	DCPTime end = time + DCPTime::from_frames(content_audio.audio->frames(), content->resampled_frame_rate());
+	/* Apply content's subtitle offsets */
+	subtitle.sub.rectangle.x += text->x_offset ();
+	subtitle.sub.rectangle.y += text->y_offset ();
 
-	/* Pad any gap which may be caused by audio delay */
-	if (_last_audio_time) {
-		fill_audio (DCPTimePeriod (*_last_audio_time, time));
-	} else if (_last_seek_time && _last_seek_accurate) {
-		fill_audio (DCPTimePeriod (*_last_seek_time, time));
-	}
+	/* Apply a corrective translation to keep the subtitle centred after the scale that is coming up */
+	subtitle.sub.rectangle.x -= subtitle.sub.rectangle.width * ((text->x_scale() - 1) / 2);
+	subtitle.sub.rectangle.y -= subtitle.sub.rectangle.height * ((text->y_scale() - 1) / 2);
 
-	/* Remove anything that comes before the start or after the end of the content */
-	if (time < piece->content->position()) {
-		pair<shared_ptr<AudioBuffers>, DCPTime> cut = discard_audio (content_audio.audio, time, piece->content->position());
-		if (!cut.first) {
-			/* This audio is entirely discarded */
-			return;
-		}
-		content_audio.audio = cut.first;
-		time = cut.second;
-	} else if (time > piece->content->end()) {
-		/* 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());
-		if (remaining_frames == 0) {
-			return;
-		}
-		shared_ptr<AudioBuffers> cut (new AudioBuffers (content_audio.audio->channels(), remaining_frames));
-		cut->copy_from (content_audio.audio.get(), remaining_frames, 0, 0);
-		content_audio.audio = cut;
-	}
+	/* Apply content's subtitle scale */
+	subtitle.sub.rectangle.width *= text->x_scale ();
+	subtitle.sub.rectangle.height *= text->y_scale ();
 
-	audio_transform (content, stream, content_audio, time);
-}
+	PlayerText ps;
+	auto image = subtitle.sub.image;
 
-void
-Player::image_subtitle_start (weak_ptr<Piece> wp, ContentImageSubtitle subtitle)
-{
-	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	/* We will scale the subtitle up to fit _video_container_size */
+	int const width = subtitle.sub.rectangle.width * _video_container_size.width;
+	int const height = subtitle.sub.rectangle.height * _video_container_size.height;
+	if (width == 0 || height == 0) {
 		return;
 	}
 
-	/* Apply content's subtitle offsets */
-	subtitle.sub.rectangle.x += piece->content->subtitle->x_offset ();
-	subtitle.sub.rectangle.y += piece->content->subtitle->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 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);
-
-	PlayerSubtitles ps;
-	ps.image.push_back (subtitle.sub);
+	dcp::Size scaled_size (width, height);
+	ps.bitmap.push_back (BitmapText(image->scale(scaled_size, dcp::YUVToRGB::REC601, image->pixel_format(), Image::Alignment::PADDED, _fast), subtitle.sub.rectangle));
 	DCPTime from (content_time_to_dcp (piece, subtitle.from()));
 
-	_active_subtitles.add_from (wp, ps, from);
+	_active_texts[static_cast<int>(text->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 TextContent> wc, ContentStringText subtitle)
 {
-	shared_ptr<Piece> piece = wp.lock ();
-	if (!piece) {
+	if (_suspended) {
+		return;
+	}
+
+	auto piece = wp.lock ();
+	auto text = wc.lock ();
+	if (!piece || !text) {
 		return;
 	}
 
-	PlayerSubtitles ps;
+	PlayerText ps;
 	DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 
-	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();
+	if (from > piece->content->end(_film)) {
+		return;
+	}
+
+	for (auto s: subtitle.subs) {
+		s.set_h_position (s.h_position() + text->x_offset ());
+		s.set_v_position (s.v_position() + text->y_offset ());
+		float const xs = text->x_scale();
+		float const ys = text->y_scale();
 		float size = s.size();
 
 		/* Adjust size to express the common part of the scaling;
@@ -895,17 +1138,27 @@ 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.string.push_back (StringText (s, text->outline_width()));
+		ps.add_fonts (text->fonts ());
 	}
 
-	_active_subtitles.add_from (wp, ps, from);
+	_active_texts[static_cast<int>(text->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 TextContent> wc, ContentTime to)
 {
-	if (!_active_subtitles.have (wp)) {
+	if (_suspended) {
+		return;
+	}
+
+	auto text = wc.lock ();
+	if (!text) {
+		return;
+	}
+
+	if (!_active_texts[static_cast<int>(text->type())].have(wc)) {
 		return;
 	}
 
@@ -916,34 +1169,55 @@ Player::subtitle_stop (weak_ptr<Piece> wp, ContentTime to)
 
 	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(_film)) {
+		return;
+	}
+
+	auto from = _active_texts[static_cast<int>(text->type())].add_to (wc, dcp_to);
 
-	if (piece->content->subtitle->use() && !_always_burn_subtitles && !piece->content->subtitle->burn()) {
-		Subtitle (from.first, DCPTimePeriod (from.second, dcp_to));
+	bool const always = (text->type() == TextType::OPEN_SUBTITLE && _always_burn_open_subtitles);
+	if (text->use() && !always && !text->burn()) {
+		Text (from.first, text->type(), text->dcp_track().get_value_or(DCPTextTrack()), DCPTimePeriod (from.second, dcp_to));
 	}
 }
 
+
 void
 Player::seek (DCPTime time, bool accurate)
 {
-	if (_audio_processor) {
-		_audio_processor->flush ();
+	boost::mutex::scoped_lock lm (_mutex);
+	LOG_DEBUG_PLAYER("Seek to %1 (%2accurate)", to_string(time), accurate ? "" : "in");
+
+	if (_suspended) {
+		/* We can't seek in this state */
+		return;
 	}
 
-	for (ResamplerMap::iterator i = _resamplers.begin(); i != _resamplers.end(); ++i) {
-		i->second->flush ();
-		i->second->reset ();
+	if (_shuffler) {
+		_shuffler->clear ();
+	}
+
+	_delay.clear ();
+
+	if (_audio_processor) {
+		_audio_processor->flush ();
 	}
 
 	_audio_merger.clear ();
-	_active_subtitles.clear ();
+	for (int i = 0; i < static_cast<int>(TextType::COUNT); ++i) {
+		_active_texts[i].clear ();
+	}
 
-	BOOST_FOREACH (shared_ptr<Piece> i, _pieces) {
+	for (auto i: _pieces) {
 		if (time < i->content->position()) {
-			/* Before; seek to 0 */
-			i->decoder->seek (ContentTime(), accurate);
+			/* Before; seek to the start of the content.  Even if this request is for an inaccurate seek
+			   we must seek this (following) content accurately, otherwise when we come to the end of the current
+			   content we may not start right at the beginning of the next, causing a gap (if the next content has
+			   been trimmed to a point between keyframes, or something).
+			*/
+			i->decoder->seek (dcp_to_content_time (i, i->content->position()), true);
 			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;
@@ -953,92 +1227,185 @@ Player::seek (DCPTime time, bool accurate)
 		}
 	}
 
-	_last_video_time = optional<DCPTime> ();
-	_last_audio_time = optional<DCPTime> ();
-	_last_seek_time = time;
-	_last_seek_accurate = accurate;
+	if (accurate) {
+		_last_video_time = time;
+		_last_video_eyes = Eyes::LEFT;
+		_last_audio_time = time;
+	} else {
+		_last_video_time = optional<DCPTime>();
+		_last_video_eyes = optional<Eyes>();
+		_last_audio_time = optional<DCPTime>();
+	}
+
+	_black.set_position (time);
+	_silent.set_position (time);
+
+	_last_video.clear ();
 }
 
-shared_ptr<Resampler>
-Player::resampler (shared_ptr<const AudioContent> content, AudioStreamPtr stream, bool create)
+
+void
+Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 {
-	ResamplerMap::const_iterator i = _resamplers.find (make_pair (content, stream));
-	if (i != _resamplers.end ()) {
-		return i->second;
+	if (!_film->three_d()) {
+		if (pv->eyes() == Eyes::LEFT) {
+			/* Use left-eye images for both eyes... */
+			pv->set_eyes (Eyes::BOTH);
+		} else if (pv->eyes() == Eyes::RIGHT) {
+			/* ...and discard the right */
+			return;
+		}
 	}
 
-	if (!create) {
-		return shared_ptr<Resampler> ();
-	}
+	/* 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));
 
-	LOG_GENERAL (
-		"Creating new resampler from %1 to %2 with %3 channels",
-		stream->frame_rate(),
-		content->resampled_frame_rate(),
-		stream->channels()
-		);
+	if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) {
+		_last_video_time = time + one_video_frame();
+	}
+	_last_video_eyes = increment_eyes (pv->eyes());
 
-	shared_ptr<Resampler> r (
-		new Resampler (stream->frame_rate(), content->resampled_frame_rate(), stream->channels())
-		);
+	if (_delay.size() < 3) {
+		return;
+	}
 
-	_resamplers[make_pair(content, stream)] = r;
-	return r;
+	auto to_do = _delay.front();
+	_delay.pop_front();
+	do_emit_video (to_do.first, to_do.second);
 }
 
+
 void
-Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
+Player::do_emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 {
-	optional<PositionImage> subtitles = subtitles_for_frame (time);
+	if (pv->eyes() == Eyes::BOTH || pv->eyes() == Eyes::RIGHT) {
+		for (int i = 0; i < static_cast<int>(TextType::COUNT); ++i) {
+			_active_texts[i].clear_before (time);
+		}
+	}
+
+	auto subtitles = open_subtitles_for_frame (time);
 	if (subtitles) {
-		pv->set_subtitle (subtitles.get ());
+		pv->set_text (subtitles.get ());
 	}
+
 	Video (pv, time);
-	_last_video_time = time + one_video_frame();
-	_active_subtitles.clear_before (time);
 }
 
+
 void
 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
 {
-	Audio (data, time);
-	_last_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate ());
+	/* Log if the assert below is about to fail */
+	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, 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());
 }
 
+
 void
 Player::fill_audio (DCPTimePeriod period)
 {
-	BOOST_FOREACH (DCPTimePeriod i, subtract(period, _no_audio)) {
-		DCPTime t = i.from;
-		while (t < i.to) {
-			DCPTime block = min (DCPTime::from_seconds (0.5), i.to - t);
-			Frame const samples = block.frames_round(_film->audio_frame_rate());
-			if (samples) {
-				shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), samples));
-				silence->make_silent ();
-				emit_audio (silence, t);
-			}
-			t += block;
+	if (period.from == period.to) {
+		return;
+	}
+
+	DCPOMATIC_ASSERT (period.from < period.to);
+
+	DCPTime t = period.from;
+	while (t < period.to) {
+		DCPTime block = min (DCPTime::from_seconds (0.5), period.to - t);
+		Frame const samples = block.frames_round(_film->audio_frame_rate());
+		if (samples) {
+			auto silence = make_shared<AudioBuffers>(_film->audio_channels(), samples);
+			silence->make_silent ();
+			emit_audio (silence, t);
 		}
+		t += block;
 	}
 }
 
+
 DCPTime
 Player::one_video_frame () const
 {
 	return DCPTime::from_frames (1, _film->video_frame_rate ());
 }
 
+
 pair<shared_ptr<AudioBuffers>, DCPTime>
 Player::discard_audio (shared_ptr<const AudioBuffers> audio, DCPTime time, DCPTime discard_to) const
 {
-	DCPTime const discard_time = discard_to - time;
-	Frame const discard_frames = discard_time.frames_round(_film->audio_frame_rate());
-	Frame remaining_frames = audio->frames() - discard_frames;
+	auto const discard_time = discard_to - time;
+	auto const discard_frames = discard_time.frames_round(_film->audio_frame_rate());
+	auto remaining_frames = audio->frames() - discard_frames;
 	if (remaining_frames <= 0) {
 		return make_pair(shared_ptr<AudioBuffers>(), DCPTime());
 	}
-	shared_ptr<AudioBuffers> cut (new AudioBuffers (audio->channels(), remaining_frames));
-	cut->copy_from (audio.get(), remaining_frames, discard_frames, 0);
+	auto cut = make_shared<AudioBuffers>(audio, remaining_frames, discard_frames);
 	return make_pair(cut, time + discard_time);
 }
+
+
+void
+Player::set_dcp_decode_reduction (optional<int> reduction)
+{
+	Change (ChangeType::PENDING, PlayerProperty::DCP_DECODE_REDUCTION, false);
+
+	{
+		boost::mutex::scoped_lock lm (_mutex);
+
+		if (reduction == _dcp_decode_reduction) {
+			lm.unlock ();
+			Change (ChangeType::CANCELLED, PlayerProperty::DCP_DECODE_REDUCTION, false);
+			return;
+		}
+
+		_dcp_decode_reduction = reduction;
+		setup_pieces_unlocked ();
+	}
+
+	Change (ChangeType::DONE, PlayerProperty::DCP_DECODE_REDUCTION, false);
+}
+
+
+optional<DCPTime>
+Player::content_time_to_dcp (shared_ptr<Content> content, ContentTime t)
+{
+	boost::mutex::scoped_lock lm (_mutex);
+
+	for (auto i: _pieces) {
+		if (i->content == content) {
+			return content_time_to_dcp (i, t);
+		}
+	}
+
+	/* We couldn't find this content; perhaps things are being changed over */
+	return {};
+}
+
+
+shared_ptr<const Playlist>
+Player::playlist () const
+{
+	return _playlist ? _playlist : _film->playlist();
+}
+
+
+void
+Player::atmos (weak_ptr<Piece>, ContentAtmos data)
+{
+	if (_suspended) {
+		return;
+	}
+
+	Atmos (data.data, DCPTime::from_frames(data.frame, _film->video_frame_rate()), data.metadata);
+}
+