X-Git-Url: https://git.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fplayer.cc;h=abcefcab5c57fcae7afbc5db48589cd12088d343;hp=823a8becb109cf5e0f5a503da2fb861f827919a9;hb=86515d34200fa2a387e48b117eed9b02cabde30d;hpb=a246aa2400e419500e364ae684bdcc419c08f56a

diff --git a/src/lib/player.cc b/src/lib/player.cc
index 823a8becb..abcefcab5 100644
--- a/src/lib/player.cc
+++ b/src/lib/player.cc
@@ -110,7 +110,7 @@ Player::Player (shared_ptr<const Film> film, Image::Alignment subtitle_alignment
 	, _fast(false)
 	, _tolerant (film->tolerant())
 	, _play_referenced(false)
-	, _audio_merger (_film->audio_frame_rate())
+	, _audio_merger(film->audio_frame_rate())
 	, _subtitle_alignment (subtitle_alignment)
 {
 	construct ();
@@ -128,7 +128,7 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
 	, _fast(false)
 	, _tolerant (film->tolerant())
 	, _play_referenced(false)
-	, _audio_merger (_film->audio_frame_rate())
+	, _audio_merger(film->audio_frame_rate())
 {
 	construct ();
 }
@@ -137,18 +137,105 @@ Player::Player (shared_ptr<const Film> film, shared_ptr<const Playlist> playlist
 void
 Player::construct ()
 {
-	_film_changed_connection = _film->Change.connect (bind (&Player::film_change, this, _1, _2));
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
+	connect();
+	set_video_container_size(film->frame_size());
+
+	film_change (ChangeType::DONE, Film::Property::AUDIO_PROCESSOR);
+
+	setup_pieces ();
+	seek (DCPTime (), true);
+}
+
+
+void
+Player::connect()
+{
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
+	_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_change (ChangeType::DONE, Film::Property::AUDIO_PROCESSOR);
 
-	setup_pieces ();
-	seek (DCPTime (), true);
+Player::Player(Player&& other)
+	: _film(other._film)
+	, _playlist(std::move(other._playlist))
+	, _suspended(other._suspended.load())
+	, _pieces(std::move(other._pieces))
+	, _video_container_size(other._video_container_size.load())
+	, _black_image(std::move(other._black_image))
+	, _ignore_video(other._ignore_video.load())
+	, _ignore_audio(other._ignore_audio.load())
+	, _ignore_text(other._ignore_text.load())
+	, _always_burn_open_subtitles(other._always_burn_open_subtitles.load())
+	, _fast(other._fast.load())
+	, _tolerant(other._tolerant)
+	, _play_referenced(other._play_referenced.load())
+	, _next_video_time(other._next_video_time)
+	, _next_audio_time(other._next_audio_time)
+	, _dcp_decode_reduction(other._dcp_decode_reduction.load())
+	, _last_video(std::move(other._last_video))
+	, _audio_merger(std::move(other._audio_merger))
+	, _shuffler(std::move(other._shuffler))
+	, _delay(std::move(other._delay))
+	, _stream_states(std::move(other._stream_states))
+	, _black(std::move(other._black))
+	, _silent(std::move(other._silent))
+	, _active_texts(std::move(other._active_texts))
+	, _audio_processor(std::move(other._audio_processor))
+	, _playback_length(other._playback_length.load())
+	, _subtitle_alignment(other._subtitle_alignment)
+{
+	connect();
+}
+
+
+Player&
+Player::operator=(Player&& other)
+{
+	if (this == &other) {
+		return *this;
+	}
+
+	_film = std::move(other._film);
+	_playlist = std::move(other._playlist);
+	_suspended = other._suspended.load();
+	_pieces = std::move(other._pieces);
+	_video_container_size = other._video_container_size.load();
+	_black_image = std::move(other._black_image);
+	_ignore_video = other._ignore_video.load();
+	_ignore_audio = other._ignore_audio.load();
+	_ignore_text = other._ignore_text.load();
+	_always_burn_open_subtitles = other._always_burn_open_subtitles.load();
+	_fast = other._fast.load();
+	_tolerant = other._tolerant;
+	_play_referenced = other._play_referenced.load();
+	_next_video_time = other._next_video_time;
+	_next_audio_time = other._next_audio_time;
+	_dcp_decode_reduction = other._dcp_decode_reduction.load();
+	_last_video = std::move(other._last_video);
+	_audio_merger = std::move(other._audio_merger);
+	_shuffler = std::move(other._shuffler);
+	_delay = std::move(other._delay);
+	_stream_states = std::move(other._stream_states);
+	_black = std::move(other._black);
+	_silent = std::move(other._silent);
+	_active_texts = std::move(other._active_texts);
+	_audio_processor = std::move(other._audio_processor);
+	_playback_length = other._playback_length.load();
+	_subtitle_alignment = other._subtitle_alignment;
+
+	connect();
+
+	return *this;
 }
 
 
@@ -171,11 +258,16 @@ Player::setup_pieces ()
 {
 	boost::mutex::scoped_lock lm (_mutex);
 
-	_playback_length = _playlist ? _playlist->length(_film) : _film->length();
-
 	auto old_pieces = _pieces;
 	_pieces.clear ();
 
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
+	_playback_length = _playlist ? _playlist->length(film) : film->length();
+
 	auto playlist_content = playlist()->content();
 	bool const have_threed = std::any_of(
 		playlist_content.begin(),
@@ -190,29 +282,29 @@ Player::setup_pieces ()
 		_shuffler->Video.connect(bind(&Player::video, this, _1, _2));
 	}
 
-	for (auto i: playlist()->content()) {
+	for (auto content: playlist()->content()) {
 
-		if (!i->paths_valid ()) {
+		if (!content->paths_valid()) {
 			continue;
 		}
 
-		if (_ignore_video && _ignore_audio && i->text.empty()) {
+		if (_ignore_video && _ignore_audio && content->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) {
+			if (j->content == content) {
 				old_decoder = j->decoder;
 				break;
 			}
 		}
 
-		auto decoder = decoder_factory (_film, i, _fast, _tolerant, old_decoder);
+		auto decoder = decoder_factory(film, content, _fast, _tolerant, old_decoder);
 		DCPOMATIC_ASSERT (decoder);
 
-		FrameRateChange frc (_film, i);
+		FrameRateChange frc(film, content);
 
 		if (decoder->video && _ignore_video) {
 			decoder->video->set_ignore (true);
@@ -236,7 +328,7 @@ Player::setup_pieces ()
 			}
 		}
 
-		auto piece = make_shared<Piece>(i, decoder, frc);
+		auto piece = make_shared<Piece>(content, decoder, frc);
 		_pieces.push_back (piece);
 
 		if (decoder->video) {
@@ -277,7 +369,7 @@ Player::setup_pieces ()
 	for (auto i: _pieces) {
 		if (i->content->audio) {
 			for (auto j: i->content->audio->streams()) {
-				_stream_states[j] = StreamState (i, i->content->position ());
+				_stream_states[j] = StreamState(i);
 			}
 		}
 	}
@@ -286,20 +378,36 @@ Player::setup_pieces ()
 		return v && v->use() && v->frame_type() != VideoFrameType::THREE_D_LEFT && v->frame_type() != VideoFrameType::THREE_D_RIGHT;
 	};
 
-	for (auto i = _pieces.begin(); i != _pieces.end(); ++i) {
-		if (ignore_overlap((*i)->content->video)) {
+	for (auto piece = _pieces.begin(); piece != _pieces.end(); ++piece) {
+		if (ignore_overlap((*piece)->content->video)) {
 			/* Look for content later in the content list with in-use video that overlaps this */
-			auto const period = DCPTimePeriod((*i)->content->position(), (*i)->content->end(_film));
-			for (auto j = std::next(i); j != _pieces.end(); ++j) {
-				if ((*j)->content->video && ignore_overlap((*j)->content->video)) {
-					(*i)->ignore_video = DCPTimePeriod((*j)->content->position(), (*j)->content->end(_film)).overlap(period);
+			auto const period = (*piece)->content->period(film);
+			for (auto later_piece = std::next(piece); later_piece != _pieces.end(); ++later_piece) {
+				if (ignore_overlap((*later_piece)->content->video)) {
+					if (auto overlap = (*later_piece)->content->period(film).overlap(period)) {
+						(*piece)->ignore_video.push_back(*overlap);
+					}
+				}
+			}
+		}
+	}
+
+	for (auto piece = _pieces.begin(); piece != _pieces.end(); ++piece) {
+		if ((*piece)->content->atmos) {
+			/* Look for content later in the content list with ATMOS that overlaps this */
+			auto const period = (*piece)->content->period(film);
+			for (auto later_piece = std::next(piece); later_piece != _pieces.end(); ++later_piece) {
+				if ((*later_piece)->content->atmos) {
+					if (auto overlap = (*later_piece)->content->period(film).overlap(period)) {
+						(*piece)->ignore_atmos.push_back(*overlap);
+					}
 				}
 			}
 		}
 	}
 
-	_black = Empty (_film, playlist(), bind(&have_video, _1), _playback_length);
-	_silent = Empty (_film, playlist(), bind(&have_audio, _1), _playback_length);
+	_black = Empty(film, playlist(), bind(&have_video, _1), _playback_length);
+	_silent = Empty(film, playlist(), bind(&have_audio, _1), _playback_length);
 
 	_next_video_time = boost::none;
 	_next_video_eyes = Eyes::BOTH;
@@ -310,11 +418,16 @@ Player::setup_pieces ()
 void
 Player::playlist_content_change (ChangeType type, int property, bool frequent)
 {
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
 	if (property == VideoContentProperty::CROP) {
 		if (type == ChangeType::DONE) {
 			boost::mutex::scoped_lock lm (_mutex);
 			for (auto const& i: _delay) {
-				i.first->reset_metadata(_film, _video_container_size);
+				i.first->reset_metadata(film, _video_container_size);
 			}
 		}
 	} else {
@@ -375,6 +488,11 @@ Player::film_change (ChangeType type, Film::Property p)
 	   last time we were run.
 	*/
 
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
 	if (p == Film::Property::CONTAINER) {
 		Change (type, PlayerProperty::FILM_CONTAINER, false);
 	} else if (p == Film::Property::VIDEO_FRAME_RATE) {
@@ -386,9 +504,9 @@ Player::film_change (ChangeType type, Film::Property p)
 		}
 		Change (type, PlayerProperty::FILM_VIDEO_FRAME_RATE, false);
 	} else if (p == Film::Property::AUDIO_PROCESSOR) {
-		if (type == ChangeType::DONE && _film->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 ());
+			_audio_processor = film->audio_processor()->clone(film->audio_frame_rate());
 		}
 	} else if (p == Film::Property::AUDIO_CHANNELS) {
 		if (type == ChangeType::DONE) {
@@ -424,8 +542,11 @@ Player::black_player_video_frame (Eyes eyes) const
 Frame
 Player::dcp_to_content_video (shared_ptr<const Piece> piece, DCPTime t) const
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	auto s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(_film), 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)
@@ -451,18 +572,24 @@ Player::content_video_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 Frame
 Player::dcp_to_resampled_audio (shared_ptr<const Piece> piece, DCPTime t) const
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	auto s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(_film), 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());
+	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
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	/* See comment in dcp_to_content_video */
-	return DCPTime::from_frames (f, _film->audio_frame_rate())
+	return DCPTime::from_frames(f, film->audio_frame_rate())
 		- DCPTime (piece->content->trim_start(), piece->frc)
 		+ piece->content->position();
 }
@@ -471,8 +598,11 @@ Player::resampled_audio_to_dcp (shared_ptr<const Piece> piece, Frame f) const
 ContentTime
 Player::dcp_to_content_time (shared_ptr<const Piece> piece, DCPTime t) const
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	auto s = t - piece->content->position ();
-	s = min (piece->content->length_after_trim(_film), s);
+	s = min (piece->content->length_after_trim(film), s);
 	return max (ContentTime (), ContentTime (s, piece->frc) + piece->content->trim_start());
 }
 
@@ -567,7 +697,9 @@ Player::pass ()
 		return false;
 	}
 
-	if (_playback_length.load() == DCPTime()) {
+	auto film = _film.lock();
+
+	if (_playback_length.load() == DCPTime() || !film) {
 		/* Special; just give one black frame */
 		emit_video (black_player_video_frame(Eyes::BOTH), DCPTime());
 		return true;
@@ -584,7 +716,7 @@ Player::pass ()
 		}
 
 		auto const t = content_time_to_dcp (i, max(i->decoder->position(), i->content->trim_start()));
-		if (t > i->content->end(_film)) {
+		if (t > i->content->end(film)) {
 			i->done = true;
 		} else {
 
@@ -632,13 +764,18 @@ Player::pass ()
 			   to `hide' the fact that no audio was emitted during the referenced DCP (though
 			   we need to behave as though it was).
 			*/
-			_next_audio_time = dcp->end (_film);
+			_next_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());
+		if (film->three_d()) {
+			emit_video(black_player_video_frame(Eyes::LEFT), _black.position());
+			emit_video(black_player_video_frame(Eyes::RIGHT), _black.position());
+		} else {
+			emit_video(black_player_video_frame(Eyes::BOTH), _black.position());
+		}
 		_black.set_position (_black.position() + one_video_frame());
 		break;
 	case SILENT:
@@ -655,7 +792,7 @@ Player::pass ()
 			/* 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);
+				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 = *_next_audio_time;
@@ -684,21 +821,25 @@ Player::pass ()
 
 	using state_pair = std::pair<AudioStreamPtr, StreamState>;
 
+	/* Find streams that have pushed */
+	std::vector<state_pair> have_pushed;
+	std::copy_if(_stream_states.begin(), _stream_states.end(), std::back_inserter(have_pushed), [](state_pair const& a) { return static_cast<bool>(a.second.last_push_end); });
+
 	/* 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; }
+		have_pushed.begin(),
+		have_pushed.end(),
+		[](state_pair const& a, state_pair const& b) { return a.second.last_push_end.get() < b.second.last_push_end.get(); }
 		);
 
-	if (latest_last_push_end != _stream_states.end()) {
-		LOG_DEBUG_PLAYER("Leading audio 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));
+	if (latest_last_push_end != have_pushed.end()) {
+		LOG_DEBUG_PLAYER("Leading audio 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.get()));
 	}
 
 	/* 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)) {
+		if (!i.second.last_push_end || (latest_last_push_end->second.last_push_end.get() - i.second.last_push_end.get()) < 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));
@@ -707,8 +848,9 @@ Player::pass ()
 
 	auto pull_to = _playback_length.load();
 	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;
+		auto position = i.second.last_push_end.get_value_or(i.second.piece->content->position());
+		if (!i.second.piece->done && position < pull_to) {
+			pull_to = position;
 		}
 	}
 	if (!_silent.done() && _silent.position() < pull_to) {
@@ -763,8 +905,13 @@ Player::pass ()
 optional<PositionImage>
 Player::open_subtitles_for_frame (DCPTime time) const
 {
+	auto film = _film.lock();
+	if (!film) {
+		return {};
+	}
+
 	list<PositionImage> captions;
-	int const vfr = _film->video_frame_rate();
+	int const vfr = film->video_frame_rate();
 
 	for (
 		auto j:
@@ -806,6 +953,18 @@ Player::open_subtitles_for_frame (DCPTime time) const
 }
 
 
+static
+Eyes
+increment_eyes (Eyes e)
+{
+	if (e == Eyes::LEFT) {
+		return Eyes::RIGHT;
+	}
+
+	return Eyes::LEFT;
+}
+
+
 void
 Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 {
@@ -822,11 +981,38 @@ Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 		return;
 	}
 
-	FrameRateChange frc (_film, piece->content);
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
+	FrameRateChange frc(film, piece->content);
 	if (frc.skip && (video.frame % 2) == 1) {
 		return;
 	}
 
+	vector<Eyes> eyes_to_emit;
+
+	if (!film->three_d()) {
+		if (video.eyes == Eyes::RIGHT) {
+			/* 2D film, 3D content: discard right */
+			return;
+		} else if (video.eyes == Eyes::LEFT) {
+			/* 2D film, 3D content: emit left as "both" */
+			video.eyes = Eyes::BOTH;
+			eyes_to_emit = { Eyes::BOTH };
+		}
+	} else {
+		if (video.eyes == Eyes::BOTH) {
+			/* 3D film, 2D content; emit "both" for left and right */
+			eyes_to_emit = { Eyes::LEFT, Eyes::RIGHT };
+		}
+	}
+
+	if (eyes_to_emit.empty()) {
+		eyes_to_emit = { video.eyes };
+	}
+
 	/* Time of the first frame we will emit */
 	DCPTime const time = content_video_to_dcp (piece, video.frame);
 	LOG_DEBUG_PLAYER("Received video frame %1 at %2", video.frame, to_string(time));
@@ -839,14 +1025,19 @@ Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 		return;
 	}
 
-	if (piece->ignore_video && piece->ignore_video->contains(time)) {
+	auto ignore_video = std::find_if(
+		piece->ignore_video.begin(),
+		piece->ignore_video.end(),
+		[time](DCPTimePeriod period) { return period.contains(time); }
+		);
+	if (ignore_video != piece->ignore_video.end()) {
 		return;
 	}
 
 	/* 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));
+	DCPTime fill_to = min(time, piece->content->end(film));
 
 	if (_next_video_time) {
 		DCPTime fill_from = max (*_next_video_time, piece->content->position());
@@ -854,12 +1045,12 @@ Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 		/* 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 (weak_piece);
-			if (_film->three_d()) {
-				auto fill_to_eyes = video.eyes;
+			if (film->three_d()) {
+				auto fill_to_eyes = eyes_to_emit[0];
 				if (fill_to_eyes == Eyes::BOTH) {
 					fill_to_eyes = Eyes::LEFT;
 				}
-				if (fill_to == piece->content->end(_film)) {
+				if (fill_to == piece->content->end(film)) {
 					/* Don't fill after the end of the content */
 					fill_to_eyes = Eyes::LEFT;
 				}
@@ -897,32 +1088,34 @@ Player::video (weak_ptr<Piece> weak_piece, ContentVideo video)
 
 	auto const content_video = piece->content->video;
 
-	_last_video[weak_piece] = 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()),
+	for (auto eyes: eyes_to_emit) {
+		_last_video[weak_piece] = 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,
+				film->frame_size(),
+				content_video->pixel_quanta()
+				),
 			_video_container_size,
-			_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
-		);
-
-	DCPTime t = time;
-	for (int i = 0; i < frc.repeat; ++i) {
-		if (t < piece->content->end(_film)) {
-			emit_video (_last_video[weak_piece], t);
+			eyes,
+			video.part,
+			content_video->colour_conversion(),
+			content_video->range(),
+			piece->content,
+			video.frame,
+			false
+			);
+
+		DCPTime t = time;
+		for (int i = 0; i < frc.repeat; ++i) {
+			if (t < piece->content->end(film)) {
+				emit_video (_last_video[weak_piece], t);
+			}
+			t += one_video_frame ();
 		}
-		t += one_video_frame ();
 	}
 }
 
@@ -941,17 +1134,22 @@ Player::audio (weak_ptr<Piece> weak_piece, AudioStreamPtr stream, ContentAudio c
 		return;
 	}
 
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
 	auto content = piece->content->audio;
 	DCPOMATIC_ASSERT (content);
 
-	int const rfr = content->resampled_frame_rate (_film);
+	int const rfr = content->resampled_frame_rate(film);
 
 	/* Compute time in the DCP */
 	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));
 
 	/* And the end of this block in the DCP */
 	auto end = time + DCPTime::from_frames(content_audio.audio->frames(), rfr);
+	LOG_DEBUG_PLAYER("Received audio frame %1 covering %2 to %3 (%4)", content_audio.frame, to_string(time), to_string(end), piece->content->path(0).filename());
 
 	/* Remove anything that comes before the start or after the end of the content */
 	if (time < piece->content->position()) {
@@ -962,11 +1160,11 @@ Player::audio (weak_ptr<Piece> weak_piece, AudioStreamPtr stream, ContentAudio c
 		}
 		content_audio.audio = cut.first;
 		time = cut.second;
-	} else if (time > piece->content->end(_film)) {
+	} 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);
+	} 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;
 		}
@@ -1001,19 +1199,19 @@ Player::audio (weak_ptr<Piece> weak_piece, AudioStreamPtr stream, ContentAudio c
 
 	/* Remap */
 
-	content_audio.audio = remap (content_audio.audio, _film->audio_channels(), stream->mapping());
+	content_audio.audio = remap(content_audio.audio, film->audio_channels(), stream->mapping());
 
 	/* Process */
 
 	if (_audio_processor) {
-		content_audio.audio = _audio_processor->run (content_audio.audio, _film->audio_channels ());
+		content_audio.audio = _audio_processor->run(content_audio.audio, film->audio_channels());
 	}
 
 	/* Push */
 
 	_audio_merger.push (content_audio.audio, time);
 	DCPOMATIC_ASSERT (_stream_states.find (stream) != _stream_states.end ());
-	_stream_states[stream].last_push_end = time + DCPTime::from_frames (content_audio.audio->frames(), _film->audio_frame_rate());
+	_stream_states[stream].last_push_end = time + DCPTime::from_frames(content_audio.audio->frames(), film->audio_frame_rate());
 }
 
 
@@ -1072,14 +1270,15 @@ Player::plain_text_start (weak_ptr<Piece> weak_piece, weak_ptr<const TextContent
 
 	auto piece = weak_piece.lock ();
 	auto content = weak_content.lock ();
-	if (!piece || !content) {
+	auto film = _film.lock();
+	if (!piece || !content || !film) {
 		return;
 	}
 
 	PlayerText ps;
 	DCPTime const from (content_time_to_dcp (piece, subtitle.from()));
 
-	if (from > piece->content->end(_film)) {
+	if (from > piece->content->end(film)) {
 		return;
 	}
 
@@ -1128,13 +1327,14 @@ Player::subtitle_stop (weak_ptr<Piece> weak_piece, weak_ptr<const TextContent> w
 	}
 
 	auto piece = weak_piece.lock ();
-	if (!piece) {
+	auto film = _film.lock();
+	if (!piece || !film) {
 		return;
 	}
 
 	DCPTime const dcp_to = content_time_to_dcp (piece, to);
 
-	if (dcp_to > piece->content->end(_film)) {
+	if (dcp_to > piece->content->end(film)) {
 		return;
 	}
 
@@ -1158,6 +1358,11 @@ Player::seek (DCPTime time, bool accurate)
 		return;
 	}
 
+	auto film = _film.lock();
+	if (!film) {
+		return;
+	}
+
 	if (_shuffler) {
 		_shuffler->clear ();
 	}
@@ -1180,7 +1385,7 @@ Player::seek (DCPTime time, bool accurate)
 			*/
 			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(_film)) {
+		} 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;
@@ -1204,13 +1409,20 @@ Player::seek (DCPTime time, bool accurate)
 	_silent.set_position (time);
 
 	_last_video.clear ();
+
+	for (auto& state: _stream_states) {
+		state.second.last_push_end = boost::none;
+	}
 }
 
 
 void
 Player::emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 {
-	if (!_film->three_d()) {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
+	if (!film->three_d()) {
 		if (pv->eyes() == Eyes::LEFT) {
 			/* Use left-eye images for both eyes... */
 			pv->set_eyes (Eyes::BOTH);
@@ -1259,21 +1471,27 @@ Player::do_emit_video (shared_ptr<PlayerVideo> pv, DCPTime time)
 void
 Player::emit_audio (shared_ptr<AudioBuffers> data, DCPTime time)
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	/* Log if the assert below is about to fail */
 	if (_next_audio_time && labs(time.get() - _next_audio_time->get()) > 1) {
-		_film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_next_audio_time)), LogEntry::TYPE_WARNING);
+		film->log()->log(String::compose("Out-of-sequence emit %1 vs %2", to_string(time), to_string(*_next_audio_time)), LogEntry::TYPE_WARNING);
 	}
 
 	/* This audio must follow on from the previous, allowing for half a sample (at 48kHz) leeway */
 	DCPOMATIC_ASSERT (!_next_audio_time || labs(time.get() - _next_audio_time->get()) < 2);
-	Audio (data, time, _film->audio_frame_rate());
-	_next_audio_time = time + DCPTime::from_frames (data->frames(), _film->audio_frame_rate());
+	Audio(data, time, film->audio_frame_rate());
+	_next_audio_time = time + DCPTime::from_frames(data->frames(), film->audio_frame_rate());
 }
 
 
 void
 Player::fill_audio (DCPTimePeriod period)
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	if (period.from == period.to) {
 		return;
 	}
@@ -1283,9 +1501,9 @@ Player::fill_audio (DCPTimePeriod period)
 	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());
+		Frame const samples = block.frames_round(film->audio_frame_rate());
 		if (samples) {
-			auto silence = make_shared<AudioBuffers>(_film->audio_channels(), samples);
+			auto silence = make_shared<AudioBuffers>(film->audio_channels(), samples);
 			silence->make_silent ();
 			emit_audio (silence, t);
 		}
@@ -1297,15 +1515,21 @@ Player::fill_audio (DCPTimePeriod period)
 DCPTime
 Player::one_video_frame () const
 {
-	return DCPTime::from_frames (1, _film->video_frame_rate ());
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
+	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
 {
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	auto const discard_time = discard_to - time;
-	auto const discard_frames = discard_time.frames_round(_film->audio_frame_rate());
+	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());
@@ -1365,7 +1589,12 @@ Player::dcp_to_content_time (shared_ptr<const Content> content, DCPTime t) const
 shared_ptr<const Playlist>
 Player::playlist () const
 {
-	return _playlist ? _playlist : _film->playlist();
+	auto film = _film.lock();
+	if (!film) {
+		return {};
+	}
+
+	return _playlist ? _playlist : film->playlist();
 }
 
 
@@ -1376,13 +1605,25 @@ Player::atmos (weak_ptr<Piece> weak_piece, ContentAtmos data)
 		return;
 	}
 
+	auto film = _film.lock();
+	DCPOMATIC_ASSERT(film);
+
 	auto piece = weak_piece.lock ();
 	DCPOMATIC_ASSERT (piece);
 
-	auto const vfr = _film->video_frame_rate();
+	auto const vfr = film->video_frame_rate();
 
 	DCPTime const dcp_time = DCPTime::from_frames(data.frame, vfr) - DCPTime(piece->content->trim_start(), FrameRateChange(vfr, vfr));
-	if (dcp_time < piece->content->position() || dcp_time >= (piece->content->end(_film))) {
+	if (dcp_time < piece->content->position() || dcp_time >= (piece->content->end(film))) {
+		return;
+	}
+
+	auto ignore_atmos = std::find_if(
+		piece->ignore_atmos.begin(),
+		piece->ignore_atmos.end(),
+		[dcp_time](DCPTimePeriod period) { return period.contains(dcp_time); }
+		);
+	if (ignore_atmos != piece->ignore_atmos.end()) {
 		return;
 	}