From: Carl Hetherington <cth@carlh.net>
Date: Tue, 31 Dec 2013 15:44:51 +0000 (+0000)
Subject: Merge 1.0
X-Git-Tag: v2.0.48~922^2~16
X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=commitdiff_plain;h=ad49361b303d1ceff7048fa0e89ba609ca9ce376;hp=-c

Merge 1.0
---

ad49361b303d1ceff7048fa0e89ba609ca9ce376
diff --combined src/lib/encoder.cc
index 475c230da,b78bcaeea..ca9134c04
--- a/src/lib/encoder.cc
+++ b/src/lib/encoder.cc
@@@ -96,7 -96,6 +96,6 @@@ Encoder::process_begin (
  	ServerFinder::instance()->connect (boost::bind (&Encoder::server_found, this, _1));
  }
  
- 
  void
  Encoder::process_end ()
  {
@@@ -199,9 -198,12 +198,12 @@@ Encoder::process_video (shared_ptr<Play
  		return;
  	}
  
- 	if (_writer->thrown ()) {
- 		_writer->rethrow ();
- 	}
+ 	_writer->rethrow ();
+ 	/* Re-throw any exception raised by one of our threads.  If more
+ 	   than one has thrown an exception, only one will be rethrown, I think;
+ 	   but then, if that happens something has gone badly wrong.
+ 	*/
+ 	rethrow ();
  
  	if (_writer->can_fake_write (_video_frames_out)) {
  		_writer->fake_write (_video_frames_out, eyes);
@@@ -216,7 -218,7 +218,7 @@@
  		TIMING ("adding to queue of %1", _queue.size ());
  		_queue.push_back (shared_ptr<DCPVideoFrame> (
  					  new DCPVideoFrame (
 -						  image->image(), _video_frames_out, eyes, conversion, _film->video_frame_rate(),
 +						  image->image(PIX_FMT_RGB24, false), _video_frames_out, eyes, conversion, _film->video_frame_rate(),
  						  _film->j2k_bandwidth(), _film->resolution(), _film->log()
  						  )
  					  ));
@@@ -257,6 -259,7 +259,7 @@@ Encoder::terminate_threads (
  
  void
  Encoder::encoder_thread (optional<ServerDescription> server)
+ try
  {
  	/* Number of seconds that we currently wait between attempts
  	   to connect to the server; not relevant for localhost
@@@ -338,6 -341,10 +341,10 @@@
  		_condition.notify_all ();
  	}
  }
+ catch (...)
+ {
+ 	store_current ();
+ }
  
  void
  Encoder::server_found (ServerDescription s)
diff --combined src/lib/player.cc
index 96d23a82b,cacb42651..c9f9acd94
--- a/src/lib/player.cc
+++ b/src/lib/player.cc
@@@ -18,7 -18,6 +18,7 @@@
  */
  
  #include <stdint.h>
 +#include <algorithm>
  #include "player.h"
  #include "film.h"
  #include "ffmpeg_decoder.h"
@@@ -32,6 -31,7 +32,6 @@@
  #include "job.h"
  #include "image.h"
  #include "ratio.h"
 -#include "resampler.h"
  #include "log.h"
  #include "scaler.h"
  
@@@ -45,20 -45,69 +45,20 @@@ using std::map
  using boost::shared_ptr;
  using boost::weak_ptr;
  using boost::dynamic_pointer_cast;
 +using boost::optional;
  
  class Piece
  {
  public:
 -	Piece (shared_ptr<Content> c)
 -		: content (c)
 -		, video_position (c->position ())
 -		, audio_position (c->position ())
 -		, repeat_to_do (0)
 -		, repeat_done (0)
 -	{}
 -	
 -	Piece (shared_ptr<Content> c, shared_ptr<Decoder> d)
 +	Piece (shared_ptr<Content> c, shared_ptr<Decoder> d, FrameRateChange f)
  		: content (c)
  		, decoder (d)
 -		, video_position (c->position ())
 -		, audio_position (c->position ())
 +		, frc (f)
  	{}
  
 -	/** Set this piece to repeat a video frame a given number of times */
 -	void set_repeat (IncomingVideo video, int num)
 -	{
 -		repeat_video = video;
 -		repeat_to_do = num;
 -		repeat_done = 0;
 -	}
 -
 -	void reset_repeat ()
 -	{
 -		repeat_video.image.reset ();
 -		repeat_to_do = 0;
 -		repeat_done = 0;
 -	}
 -
 -	bool repeating () const
 -	{
 -		return repeat_done != repeat_to_do;
 -	}
 -
 -	void repeat (Player* player)
 -	{
 -		player->process_video (
 -			repeat_video.weak_piece,
 -			repeat_video.image,
 -			repeat_video.eyes,
 -			repeat_done > 0,
 -			repeat_video.frame,
 -			(repeat_done + 1) * (TIME_HZ / player->_film->video_frame_rate ())
 -			);
 -
 -		++repeat_done;
 -	}
 -	
  	shared_ptr<Content> content;
  	shared_ptr<Decoder> decoder;
 -	/** Time of the last video we emitted relative to the start of the DCP */
 -	Time video_position;
 -	/** Time of the last audio we emitted relative to the start of the DCP */
 -	Time audio_position;
 -
 -	IncomingVideo repeat_video;
 -	int repeat_to_do;
 -	int repeat_done;
 +	FrameRateChange frc;
  };
  
  Player::Player (shared_ptr<const Film> f, shared_ptr<const Playlist> p)
@@@ -71,8 -120,6 +71,8 @@@
  	, _audio_position (0)
  	, _audio_merger (f->audio_channels(), bind (&Film::time_to_audio_frames, f.get(), _1), bind (&Film::audio_frames_to_time, f.get(), _1))
  	, _last_emit_was_black (false)
 +	, _just_did_inaccurate_seek (false)
 +	, _approximate_size (false)
  {
  	_playlist_changed_connection = _playlist->Changed.connect (bind (&Player::playlist_changed, this));
  	_playlist_content_changed_connection = _playlist->ContentChanged.connect (bind (&Player::content_changed, this, _1, _2, _3));
@@@ -99,131 -146,110 +99,131 @@@ Player::pass (
  		setup_pieces ();
  	}
  
 -	Time earliest_t = TIME_MAX;
 -	shared_ptr<Piece> earliest;
 -	enum {
 -		VIDEO,
 -		AUDIO
 -	} type = VIDEO;
 +	/* Interrogate all our pieces to find the one with the earliest decoded data */
 +
 +	shared_ptr<Piece> earliest_piece;
 +	shared_ptr<Decoded> earliest_decoded;
 +	DCPTime earliest_time = TIME_MAX;
 +	DCPTime earliest_audio = TIME_MAX;
  
  	for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 -		if ((*i)->decoder->done ()) {
 -			continue;
 -		}
  
 -		shared_ptr<VideoDecoder> vd = dynamic_pointer_cast<VideoDecoder> ((*i)->decoder);
 -		shared_ptr<AudioDecoder> ad = dynamic_pointer_cast<AudioDecoder> ((*i)->decoder);
 +		shared_ptr<Decoded> dec = (*i)->decoder->peek ();
  
 -		if (_video && vd) {
 -			if ((*i)->video_position < earliest_t) {
 -				earliest_t = (*i)->video_position;
 -				earliest = *i;
 -				type = VIDEO;
 -			}
 +		if (dec) {
 +			dec->set_dcp_times ((*i)->frc.speed_up, (*i)->content->position() - (*i)->content->trim_start());
  		}
  
 -		if (_audio && ad && ad->has_audio ()) {
 -			if ((*i)->audio_position < earliest_t) {
 -				earliest_t = (*i)->audio_position;
 -				earliest = *i;
 -				type = AUDIO;
 -			}
 +		if (dec && dec->dcp_time < earliest_time) {
 +			earliest_piece = *i;
 +			earliest_decoded = dec;
 +			earliest_time = dec->dcp_time;
  		}
 -	}
  
 -	if (!earliest) {
 +		if (dynamic_pointer_cast<DecodedAudio> (dec) && dec->dcp_time < earliest_audio) {
 +			earliest_audio = dec->dcp_time;
 +		}
 +	}
 +		
 +	if (!earliest_piece) {
  		flush ();
  		return true;
  	}
  
 -	switch (type) {
 -	case VIDEO:
 -		if (earliest_t > _video_position) {
 -			emit_black ();
 -		} else {
 -			if (earliest->repeating ()) {
 -				earliest->repeat (this);
 +	if (earliest_audio != TIME_MAX) {
 +		TimedAudioBuffers<DCPTime> tb = _audio_merger.pull (max (int64_t (0), earliest_audio));
 +		Audio (tb.audio, tb.time);
 +		/* This assumes that the audio_frames_to_time conversion is exact
 +		   so that there are no accumulated errors caused by rounding.
 +		*/
 +		_audio_position += _film->audio_frames_to_time (tb.audio->frames ());
 +	}
 +
 +	/* Emit the earliest thing */
 +
 +	shared_ptr<DecodedVideo> dv = dynamic_pointer_cast<DecodedVideo> (earliest_decoded);
 +	shared_ptr<DecodedAudio> da = dynamic_pointer_cast<DecodedAudio> (earliest_decoded);
 +	shared_ptr<DecodedSubtitle> ds = dynamic_pointer_cast<DecodedSubtitle> (earliest_decoded);
 +
 +	/* Will be set to false if we shouldn't consume the peeked DecodedThing */
 +	bool consume = true;
 +
 +	/* This is the margin either side of _{video,audio}_position that we will accept
 +	   as a starting point for a frame consecutive to the previous.
 +	*/
 +	DCPTime const margin = TIME_HZ / (2 * _film->video_frame_rate ());
 +	
 +	if (dv && _video) {
 +
 +		if (_just_did_inaccurate_seek) {
 +
 +			/* Just emit; no subtlety */
 +			emit_video (earliest_piece, dv);
 +			step_video_position (dv);
 +			
 +		} else if (dv->dcp_time - _video_position > margin) {
 +
 +			/* Too far ahead */
 +
 +			list<shared_ptr<Piece> >::iterator i = _pieces.begin();
 +			while (i != _pieces.end() && ((*i)->content->position() >= _video_position || _video_position >= (*i)->content->end())) {
 +				++i;
 +			}
 +
 +			if (i == _pieces.end() || !_last_incoming_video.video || !_have_valid_pieces) {
 +				/* We're outside all video content */
 +				emit_black ();
  			} else {
 -				earliest->decoder->pass ();
 +				/* We're inside some video; repeat the frame */
 +				_last_incoming_video.video->dcp_time = _video_position;
 +				emit_video (_last_incoming_video.weak_piece, _last_incoming_video.video);
 +				step_video_position (_last_incoming_video.video);
  			}
 -		}
 -		break;
  
 -	case AUDIO:
 -		if (earliest_t > _audio_position) {
 -			emit_silence (_film->time_to_audio_frames (earliest_t - _audio_position));
 +			consume = false;
 +
 +		} else if (abs (dv->dcp_time - _video_position) < margin) {
 +			/* We're ok */
 +			emit_video (earliest_piece, dv);
 +			step_video_position (dv);
  		} else {
 -			earliest->decoder->pass ();
 -
 -			if (earliest->decoder->done()) {
 -				shared_ptr<AudioContent> ac = dynamic_pointer_cast<AudioContent> (earliest->content);
 -				assert (ac);
 -				shared_ptr<Resampler> re = resampler (ac, false);
 -				if (re) {
 -					shared_ptr<const AudioBuffers> b = re->flush ();
 -					if (b->frames ()) {
 -						process_audio (earliest, b, ac->audio_length ());
 -					}
 -				}
 -			}
 +			/* Too far behind: skip */
  		}
 -		break;
 -	}
  
 -	if (_audio) {
 -		boost::optional<Time> audio_done_up_to;
 -		for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 -			if ((*i)->decoder->done ()) {
 -				continue;
 -			}
 +		_just_did_inaccurate_seek = false;
  
 -			if (dynamic_pointer_cast<AudioDecoder> ((*i)->decoder)) {
 -				audio_done_up_to = min (audio_done_up_to.get_value_or (TIME_MAX), (*i)->audio_position);
 -			}
 -		}
 +	} else if (da && _audio) {
  
 -		if (audio_done_up_to) {
 -			TimedAudioBuffers<Time> tb = _audio_merger.pull (audio_done_up_to.get ());
 -			Audio (tb.audio, tb.time);
 -			_audio_position += _film->audio_frames_to_time (tb.audio->frames ());
 +		if (da->dcp_time - _audio_position > margin) {
 +			/* Too far ahead */
 +			emit_silence (da->dcp_time - _audio_position);
 +			consume = false;
 +		} else if (abs (da->dcp_time - _audio_position) < margin) {
 +			/* We're ok */
 +			emit_audio (earliest_piece, da);
 +		} else {
 +			/* Too far behind: skip */
  		}
 -	}
  		
 +	} else if (ds && _video) {
 +		_in_subtitle.piece = earliest_piece;
 +		_in_subtitle.subtitle = ds;
 +		update_subtitle ();
 +	}
 +
 +	if (consume) {
 +		earliest_piece->decoder->consume ();
 +	}			
 +	
  	return false;
  }
  
 -/** @param extra Amount of extra time to add to the content frame's time (for repeat) */
  void
 -Player::process_video (weak_ptr<Piece> weak_piece, shared_ptr<const Image> image, Eyes eyes, bool same, VideoContent::Frame frame, Time extra)
 +Player::emit_video (weak_ptr<Piece> weak_piece, shared_ptr<DecodedVideo> video)
  {
  	/* Keep a note of what came in so that we can repeat it if required */
  	_last_incoming_video.weak_piece = weak_piece;
 -	_last_incoming_video.image = image;
 -	_last_incoming_video.eyes = eyes;
 -	_last_incoming_video.same = same;
 -	_last_incoming_video.frame = frame;
 -	_last_incoming_video.extra = extra;
 +	_last_incoming_video.video = video;
  	
  	shared_ptr<Piece> piece = weak_piece.lock ();
  	if (!piece) {
@@@ -233,18 -259,23 +233,18 @@@
  	shared_ptr<VideoContent> content = dynamic_pointer_cast<VideoContent> (piece->content);
  	assert (content);
  
 -	FrameRateConversion frc (content->video_frame_rate(), _film->video_frame_rate());
 -	if (frc.skip && (frame % 2) == 1) {
 -		return;
 -	}
 +	FrameRateChange frc (content->video_frame_rate(), _film->video_frame_rate());
  
 -	Time const relative_time = (frame * frc.factor() * TIME_HZ / _film->video_frame_rate());
 -	if (content->trimmed (relative_time)) {
 -		return;
 -	}
 -
 -	Time const time = content->position() + relative_time + extra - content->trim_start ();
  	float const ratio = content->ratio() ? content->ratio()->ratio() : content->video_size_after_crop().ratio();
 -	libdcp::Size const image_size = fit_ratio_within (ratio, _video_container_size);
 +	libdcp::Size image_size = fit_ratio_within (ratio, _video_container_size);
 +	if (_approximate_size) {
 +		image_size.width &= ~3;
 +		image_size.height &= ~3;
 +	}
  
  	shared_ptr<PlayerImage> pi (
  		new PlayerImage (
 -			image,
 +			video->image,
  			content->crop(),
  			image_size,
  			_video_container_size,
@@@ -252,15 -283,11 +252,15 @@@
  			)
  		);
  	
 -	if (_film->with_subtitles () && _out_subtitle.image && time >= _out_subtitle.from && time <= _out_subtitle.to) {
 +	if (
 +		_film->with_subtitles () &&
 +		_out_subtitle.image &&
 +		video->dcp_time >= _out_subtitle.from && video->dcp_time <= _out_subtitle.to
 +		) {
  
  		Position<int> const container_offset (
  			(_video_container_size.width - image_size.width) / 2,
 -			(_video_container_size.height - image_size.width) / 2
 +			(_video_container_size.height - image_size.height) / 2
  			);
  
  		pi->set_subtitle (_out_subtitle.image, _out_subtitle.position + container_offset);
@@@ -270,25 -297,18 +270,25 @@@
  	_last_video = piece->content;
  #endif
  
 -	Video (pi, eyes, content->colour_conversion(), same, time);
 -
 +	Video (pi, video->eyes, content->colour_conversion(), video->same, video->dcp_time);
 +	
  	_last_emit_was_black = false;
 -	_video_position = piece->video_position = (time + TIME_HZ / _film->video_frame_rate());
 +}
  
 -	if (frc.repeat > 1 && !piece->repeating ()) {
 -		piece->set_repeat (_last_incoming_video, frc.repeat - 1);
 +void
 +Player::step_video_position (shared_ptr<DecodedVideo> video)
 +{
 +	/* This is a bit of a hack; don't update _video_position if EYES_RIGHT is on its way */
 +	if (video->eyes != EYES_LEFT) {
 +		/* This assumes that the video_frames_to_time conversion is exact
 +		   so that there are no accumulated errors caused by rounding.
 +		*/
 +		_video_position += _film->video_frames_to_time (1);
  	}
  }
  
  void
 -Player::process_audio (weak_ptr<Piece> weak_piece, shared_ptr<const AudioBuffers> audio, AudioContent::Frame frame)
 +Player::emit_audio (weak_ptr<Piece> weak_piece, shared_ptr<DecodedAudio> audio)
  {
  	shared_ptr<Piece> piece = weak_piece.lock ();
  	if (!piece) {
@@@ -300,60 -320,72 +300,60 @@@
  
  	/* Gain */
  	if (content->audio_gain() != 0) {
 -		shared_ptr<AudioBuffers> gain (new AudioBuffers (audio));
 +		shared_ptr<AudioBuffers> gain (new AudioBuffers (audio->data));
  		gain->apply_gain (content->audio_gain ());
 -		audio = gain;
 +		audio->data = gain;
  	}
  
 -	/* Resample */
 -	if (content->content_audio_frame_rate() != content->output_audio_frame_rate()) {
 -		shared_ptr<Resampler> r = resampler (content, true);
 -		pair<shared_ptr<const AudioBuffers>, AudioContent::Frame> ro = r->run (audio, frame);
 -		audio = ro.first;
 -		frame = ro.second;
 -	}
 -	
 -	Time const relative_time = _film->audio_frames_to_time (frame);
 -
 -	if (content->trimmed (relative_time)) {
 +	if (content->trimmed (audio->dcp_time - content->position ())) {
  		return;
  	}
  
 -	Time time = content->position() + (content->audio_delay() * TIME_HZ / 1000) + relative_time - content->trim_start ();
 -	
  	/* Remap channels */
 -	shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), audio->frames()));
 +	shared_ptr<AudioBuffers> dcp_mapped (new AudioBuffers (_film->audio_channels(), audio->data->frames()));
  	dcp_mapped->make_silent ();
  	list<pair<int, libdcp::Channel> > map = content->audio_mapping().content_to_dcp ();
  	for (list<pair<int, libdcp::Channel> >::iterator i = map.begin(); i != map.end(); ++i) {
 -		if (i->first < audio->channels() && i->second < dcp_mapped->channels()) {
 -			dcp_mapped->accumulate_channel (audio.get(), i->first, i->second);
 +		if (i->first < audio->data->channels() && i->second < dcp_mapped->channels()) {
 +			dcp_mapped->accumulate_channel (audio->data.get(), i->first, i->second);
  		}
  	}
  
 -	audio = dcp_mapped;
 +	audio->data = dcp_mapped;
  
 -	/* We must cut off anything that comes before the start of all time */
 -	if (time < 0) {
 -		int const frames = - time * _film->audio_frame_rate() / TIME_HZ;
 -		if (frames >= audio->frames ()) {
 +	/* Delay */
 +	audio->dcp_time += content->audio_delay() * TIME_HZ / 1000;
 +	if (audio->dcp_time < 0) {
 +		int const frames = - audio->dcp_time * _film->audio_frame_rate() / TIME_HZ;
 +		if (frames >= audio->data->frames ()) {
  			return;
  		}
  
 -		shared_ptr<AudioBuffers> trimmed (new AudioBuffers (audio->channels(), audio->frames() - frames));
 -		trimmed->copy_from (audio.get(), audio->frames() - frames, frames, 0);
 +		shared_ptr<AudioBuffers> trimmed (new AudioBuffers (audio->data->channels(), audio->data->frames() - frames));
 +		trimmed->copy_from (audio->data.get(), audio->data->frames() - frames, frames, 0);
  
 -		audio = trimmed;
 -		time = 0;
 +		audio->data = trimmed;
 +		audio->dcp_time = 0;
  	}
  
 -	_audio_merger.push (audio, time);
 -	piece->audio_position += _film->audio_frames_to_time (audio->frames ());
 +	_audio_merger.push (audio->data, audio->dcp_time);
  }
  
  void
  Player::flush ()
  {
 -	TimedAudioBuffers<Time> tb = _audio_merger.flush ();
 +	TimedAudioBuffers<DCPTime> tb = _audio_merger.flush ();
- 	if (tb.audio) {
+ 	if (_audio && tb.audio) {
  		Audio (tb.audio, tb.time);
  		_audio_position += _film->audio_frames_to_time (tb.audio->frames ());
  	}
  
- 	while (_video_position < _audio_position) {
+ 	while (_video && _video_position < _audio_position) {
  		emit_black ();
  	}
  
- 	while (_audio_position < _video_position) {
+ 	while (_audio && _audio_position < _video_position) {
 -		emit_silence (_film->time_to_audio_frames (_video_position - _audio_position));
 +		emit_silence (_video_position - _audio_position);
  	}
  	
  }
@@@ -363,7 -395,7 +363,7 @@@
   *  @return true on error
   */
  void
 -Player::seek (Time t, bool accurate)
 +Player::seek (DCPTime t, bool accurate)
  {
  	if (!_have_valid_pieces) {
  		setup_pieces ();
@@@ -374,113 -406,92 +374,113 @@@
  	}
  
  	for (list<shared_ptr<Piece> >::iterator i = _pieces.begin(); i != _pieces.end(); ++i) {
 -		shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> ((*i)->content);
 -		if (!vc) {
 -			continue;
 -		}
 -
  		/* s is the offset of t from the start position of this content */
 -		Time s = t - vc->position ();
 -		s = max (static_cast<Time> (0), s);
 -		s = min (vc->length_after_trim(), s);
 +		DCPTime s = t - (*i)->content->position ();
 +		s = max (static_cast<DCPTime> (0), s);
 +		s = min ((*i)->content->length_after_trim(), s);
  
 -		/* Hence set the piece positions to the `global' time */
 -		(*i)->video_position = (*i)->audio_position = vc->position() + s;
 +		/* Convert this to the content time */
 +		ContentTime ct = (s * (*i)->frc.speed_up) + (*i)->content->trim_start ();
  
  		/* And seek the decoder */
 -		dynamic_pointer_cast<VideoDecoder>((*i)->decoder)->seek (
 -			vc->time_to_content_video_frames (s + vc->trim_start ()), accurate
 -			);
 -
 -		(*i)->reset_repeat ();
 +		(*i)->decoder->seek (ct, accurate);
  	}
  
 -	_video_position = _audio_position = t;
 +	_video_position = time_round_up (t, TIME_HZ / _film->video_frame_rate());
 +	_audio_position = time_round_up (t, TIME_HZ / _film->audio_frame_rate());
  
 -	/* XXX: don't seek audio because we don't need to... */
 +	_audio_merger.clear (_audio_position);
 +
 +	if (!accurate) {
 +		/* We just did an inaccurate seek, so it's likely that the next thing seen
 +		   out of pass() will be a fair distance from _{video,audio}_position.  Setting
 +		   this flag stops pass() from trying to fix that: we assume that if it
 +		   was an inaccurate seek then the caller does not care too much about
 +		   inserting black/silence to keep the time tidy.
 +		*/
 +		_just_did_inaccurate_seek = true;
 +	}
  }
  
  void
  Player::setup_pieces ()
  {
  	list<shared_ptr<Piece> > old_pieces = _pieces;
 -
  	_pieces.clear ();
  
  	ContentList content = _playlist->content ();
 -	sort (content.begin(), content.end(), ContentSorter ());
  
  	for (ContentList::iterator i = content.begin(); i != content.end(); ++i) {
  
 -		shared_ptr<Piece> piece (new Piece (*i));
 -
 -		/* XXX: into content? */
 +		shared_ptr<Decoder> decoder;
 +		optional<FrameRateChange> frc;
  
  		shared_ptr<const FFmpegContent> fc = dynamic_pointer_cast<const FFmpegContent> (*i);
  		if (fc) {
 -			shared_ptr<FFmpegDecoder> fd (new FFmpegDecoder (_film, fc, _video, _audio));
 -			
 -			fd->Video.connect (bind (&Player::process_video, this, weak_ptr<Piece> (piece), _1, _2, _3, _4, 0));
 -			fd->Audio.connect (bind (&Player::process_audio, this, weak_ptr<Piece> (piece), _1, _2));
 -			fd->Subtitle.connect (bind (&Player::process_subtitle, this, weak_ptr<Piece> (piece), _1, _2, _3, _4));
 -
 -			fd->seek (fc->time_to_content_video_frames (fc->trim_start ()), true);
 -			piece->decoder = fd;
 +			decoder.reset (new FFmpegDecoder (_film, fc, _video, _audio));
 +			frc = FrameRateChange (fc->video_frame_rate(), _film->video_frame_rate());
  		}
  		
  		shared_ptr<const ImageContent> ic = dynamic_pointer_cast<const ImageContent> (*i);
  		if (ic) {
 -			bool reusing = false;
 -			
  			/* See if we can re-use an old ImageDecoder */
  			for (list<shared_ptr<Piece> >::const_iterator j = old_pieces.begin(); j != old_pieces.end(); ++j) {
  				shared_ptr<ImageDecoder> imd = dynamic_pointer_cast<ImageDecoder> ((*j)->decoder);
  				if (imd && imd->content() == ic) {
 -					piece = *j;
 -					reusing = true;
 +					decoder = imd;
  				}
  			}
  
 -			if (!reusing) {
 -				shared_ptr<ImageDecoder> id (new ImageDecoder (_film, ic));
 -				id->Video.connect (bind (&Player::process_video, this, weak_ptr<Piece> (piece), _1, _2, _3, _4, 0));
 -				piece->decoder = id;
 +			if (!decoder) {
 +				decoder.reset (new ImageDecoder (_film, ic));
  			}
 +
 +			frc = FrameRateChange (ic->video_frame_rate(), _film->video_frame_rate());
  		}
  
  		shared_ptr<const SndfileContent> sc = dynamic_pointer_cast<const SndfileContent> (*i);
  		if (sc) {
 -			shared_ptr<AudioDecoder> sd (new SndfileDecoder (_film, sc));
 -			sd->Audio.connect (bind (&Player::process_audio, this, weak_ptr<Piece> (piece), _1, _2));
 +			decoder.reset (new SndfileDecoder (_film, sc));
 +
 +			/* Working out the frc for this content is a bit tricky: what if it overlaps
 +			   two pieces of video content with different frame rates?  For now, use
 +			   the one with the best overlap.
 +			*/
 +
 +			DCPTime best_overlap_t = 0;
 +			shared_ptr<VideoContent> best_overlap;
 +			for (ContentList::iterator j = content.begin(); j != content.end(); ++j) {
 +				shared_ptr<VideoContent> vc = dynamic_pointer_cast<VideoContent> (*j);
 +				if (!vc) {
 +					continue;
 +				}
  
 -			piece->decoder = sd;
 +				DCPTime const overlap = max (vc->position(), sc->position()) - min (vc->end(), sc->end());
 +				if (overlap > best_overlap_t) {
 +					best_overlap = vc;
 +					best_overlap_t = overlap;
 +				}
 +			}
 +
 +			if (best_overlap) {
 +				frc = FrameRateChange (best_overlap->video_frame_rate(), _film->video_frame_rate ());
 +			} else {
 +				/* No video overlap; e.g. if the DCP is just audio */
 +				frc = FrameRateChange (_film->video_frame_rate(), _film->video_frame_rate ());
 +			}
  		}
  
 -		_pieces.push_back (piece);
 +		decoder->seek ((*i)->trim_start (), true);
 +		
 +		_pieces.push_back (shared_ptr<Piece> (new Piece (*i, decoder, frc.get ())));
  	}
  
  	_have_valid_pieces = true;
 +
 +	/* The Piece for the _last_incoming_video will no longer be valid */
 +	_last_incoming_video.video.reset ();
 +
 +	_video_position = _audio_position = 0;
  }
  
  void
@@@ -541,6 -552,29 +541,6 @@@ Player::set_video_container_size (libdc
  		);
  }
  
 -shared_ptr<Resampler>
 -Player::resampler (shared_ptr<AudioContent> c, bool create)
 -{
 -	map<shared_ptr<AudioContent>, shared_ptr<Resampler> >::iterator i = _resamplers.find (c);
 -	if (i != _resamplers.end ()) {
 -		return i->second;
 -	}
 -
 -	if (!create) {
 -		return shared_ptr<Resampler> ();
 -	}
 -
 -	_film->log()->log (
 -		String::compose (
 -			"Creating new resampler for %1 to %2 with %3 channels", c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()
 -			)
 -		);
 -	
 -	shared_ptr<Resampler> r (new Resampler (c->content_audio_frame_rate(), c->output_audio_frame_rate(), c->audio_channels()));
 -	_resamplers[c] = r;
 -	return r;
 -}
 -
  void
  Player::emit_black ()
  {
@@@ -554,18 -588,17 +554,18 @@@
  }
  
  void
 -Player::emit_silence (OutputAudioFrame most)
 +Player::emit_silence (DCPTime most)
  {
  	if (most == 0) {
  		return;
  	}
  	
 -	OutputAudioFrame N = min (most, _film->audio_frame_rate() / 2);
 -	shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), N));
 +	DCPTime t = min (most, TIME_HZ / 2);
 +	shared_ptr<AudioBuffers> silence (new AudioBuffers (_film->audio_channels(), t * _film->audio_frame_rate() / TIME_HZ));
  	silence->make_silent ();
  	Audio (silence, _audio_position);
 -	_audio_position += _film->audio_frames_to_time (N);
 +	
 +	_audio_position += t;
  }
  
  void
@@@ -581,6 -614,18 +581,6 @@@ Player::film_changed (Film::Property p
  	}
  }
  
 -void
 -Player::process_subtitle (weak_ptr<Piece> weak_piece, shared_ptr<Image> image, dcpomatic::Rect<double> rect, Time from, Time to)
 -{
 -	_in_subtitle.piece = weak_piece;
 -	_in_subtitle.image = image;
 -	_in_subtitle.rect = rect;
 -	_in_subtitle.from = from;
 -	_in_subtitle.to = to;
 -
 -	update_subtitle ();
 -}
 -
  void
  Player::update_subtitle ()
  {
@@@ -589,7 -634,7 +589,7 @@@
  		return;
  	}
  
 -	if (!_in_subtitle.image) {
 +	if (!_in_subtitle.subtitle->image) {
  		_out_subtitle.image.reset ();
  		return;
  	}
@@@ -597,7 -642,7 +597,7 @@@
  	shared_ptr<SubtitleContent> sc = dynamic_pointer_cast<SubtitleContent> (piece->content);
  	assert (sc);
  
 -	dcpomatic::Rect<double> in_rect = _in_subtitle.rect;
 +	dcpomatic::Rect<double> in_rect = _in_subtitle.subtitle->rect;
  	libdcp::Size scaled_size;
  
  	in_rect.y += sc->subtitle_offset ();
@@@ -620,16 -665,15 +620,16 @@@
  	
  	_out_subtitle.position.x = rint (_video_container_size.width * (in_rect.x + (in_rect.width * (1 - sc->subtitle_scale ()) / 2)));
  	_out_subtitle.position.y = rint (_video_container_size.height * (in_rect.y + (in_rect.height * (1 - sc->subtitle_scale ()) / 2)));
 -	
 -	_out_subtitle.image = _in_subtitle.image->scale (
 +
 +	_out_subtitle.image = _in_subtitle.subtitle->image->scale (
  		scaled_size,
  		Scaler::from_id ("bicubic"),
 -		_in_subtitle.image->pixel_format (),
 +		PIX_FMT_RGBA,
  		true
  		);
 -	_out_subtitle.from = _in_subtitle.from + piece->content->position ();
 -	_out_subtitle.to = _in_subtitle.to + piece->content->position ();
 +
 +	_out_subtitle.from = _in_subtitle.subtitle->dcp_time;
 +	_out_subtitle.to = _in_subtitle.subtitle->dcp_time_to;
  }
  
  /** Re-emit the last frame that was emitted, using current settings for crop, ratio, scaler and subtitles.
@@@ -638,25 -682,22 +638,25 @@@
  bool
  Player::repeat_last_video ()
  {
 -	if (!_last_incoming_video.image || !_have_valid_pieces) {
 +	if (!_last_incoming_video.video || !_have_valid_pieces) {
  		return false;
  	}
  
 -	process_video (
 +	emit_video (
  		_last_incoming_video.weak_piece,
 -		_last_incoming_video.image,
 -		_last_incoming_video.eyes,
 -		_last_incoming_video.same,
 -		_last_incoming_video.frame,
 -		_last_incoming_video.extra
 +		_last_incoming_video.video
  		);
  
  	return true;
  }
  
 +void
 +Player::set_approximate_size ()
 +{
 +	_approximate_size = true;
 +}
 +			      
 +
  PlayerImage::PlayerImage (
  	shared_ptr<const Image> in,
  	Crop crop,
@@@ -681,10 -722,10 +681,10 @@@ PlayerImage::set_subtitle (shared_ptr<c
  }
  
  shared_ptr<Image>
 -PlayerImage::image ()
 +PlayerImage::image (AVPixelFormat format, bool aligned)
  {
 -	shared_ptr<Image> out = _in->crop_scale_window (_crop, _inter_size, _out_size, _scaler, PIX_FMT_RGB24, false);
 -
 +	shared_ptr<Image> out = _in->crop_scale_window (_crop, _inter_size, _out_size, _scaler, format, aligned);
 +	
  	Position<int> const container_offset ((_out_size.width - _inter_size.width) / 2, (_out_size.height - _inter_size.width) / 2);
  
  	if (_subtitle_image) {
@@@ -693,4 -734,3 +693,4 @@@
  
  	return out;
  }
 +