Fix merge; other tweaks.

6 files changed, 141 insertions, 118 deletions

diff --git a/src/lib/decoder.cc b/src/lib/decoder.cc
index 4287a0d5f..1f93c6c60 100644
--- a/src/lib/decoder.cc
+++ b/src/lib/decoder.cc
@@ -40,6 +40,7 @@
 using std::string;
 using std::stringstream;
 using std::min;
+using std::pair;
 using std::list;
 using boost::shared_ptr;
 
@@ -59,7 +60,7 @@ Decoder::Decoder (boost::shared_ptr<Film> f, boost::shared_ptr<const Options> o,
 	, _audio_frames_in (0)
 	, _audio_frames_out (0)
 	, _delay_line (0)
-	, _delay_in_bytes (0)
+	, _delay_in_frames (0)
 {
 	
 }
@@ -75,32 +76,30 @@ Decoder::~Decoder ()
 void
 Decoder::process_begin ()
 {
-	_delay_in_bytes = _film->audio_delay() * audio_sample_rate() * audio_channels() * bytes_per_audio_sample() / 1000;
-	_delay_line = new DelayLine (_delay_in_bytes);
+	_delay_in_frames = _film->audio_delay() * audio_sample_rate() / 1000;
+	_delay_line = new DelayLine (audio_channels(), _delay_in_frames);
 }
 
 /** Finish off a decode processing run */
 void
 Decoder::process_end ()
 {
-	if (_delay_in_bytes < 0) {
-		/* Empty the delay line */
-		uint8_t remainder[-_delay_in_bytes];
-		_delay_line->get_remaining (remainder);
-		emit_audio (remainder, -_delay_in_bytes);
+	if (_delay_in_frames < 0 && _opt->decode_audio && audio_channels()) {
+		shared_ptr<AudioBuffers> b (new AudioBuffers (audio_channels(), -_delay_in_frames));
+		b->make_silent ();
+		emit_audio (b);
 	}
 
-	if (_opt->decode_audio) {
+	if (_opt->decode_audio && audio_channels()) {
 
 		/* Ensure that our video and audio emissions are the same length */
 
-		int64_t video_frames_out_in_audio_frames = ((int64_t) _video_frames_out * audio_sample_rate() / frames_per_second());
-		int64_t audio_short_by_frames = video_frames_out_in_audio_frames - _audio_frames_out;
+		int64_t audio_short_by_frames = video_frames_to_audio_frames (_video_frames_out) - _audio_frames_out;
 
 		_film->log()->log (
 			String::compose ("Decoder has emitted %1 video frames (which equals %2 audio frames) and %3 audio frames",
 					 _video_frames_out,
-					 video_frames_out_in_audio_frames,
+					 video_frames_to_audio_frames (_video_frames_out),
 					 _audio_frames_out)
 			);
 
@@ -119,30 +118,15 @@ Decoder::process_end ()
 				emit_video (black, shared_ptr<Subtitle> ());
 			}
 
-			/* Now recompute our check values */
-			video_frames_out_in_audio_frames = ((int64_t) _video_frames_out * audio_sample_rate() / frames_per_second());
-			audio_short_by_frames = video_frames_out_in_audio_frames - _audio_frames_out;
+			/* Now recompute our check value */
+			audio_short_by_frames = video_frames_to_audio_frames (_video_frames_out) - _audio_frames_out;
 		}
 	
 		if (audio_short_by_frames > 0) {
-
 			_film->log()->log (String::compose ("Emitted %1 too few audio frames", audio_short_by_frames));
-
-			/* XXX: this is slightly questionable; does memset () give silence with all
-			   sample formats?
-			*/
-			
-			int64_t bytes = audio_short_by_frames * _film->audio_channels() * bytes_per_audio_sample();
-			
-			int64_t const silence_size = 16 * 1024 * _film->audio_channels() * bytes_per_audio_sample();
-			uint8_t silence[silence_size];
-			memset (silence, 0, silence_size);
-			
-			while (bytes) {
-				int64_t const t = min (bytes, silence_size);
-				emit_audio (silence, t);
-				bytes -= t;
-			}
+			shared_ptr<AudioBuffers> b (new AudioBuffers (audio_channels(), audio_short_by_frames));
+			b->make_silent ();
+			emit_audio (b);
 		}
 	}
 }
@@ -173,20 +157,6 @@ Decoder::go ()
 void
 Decoder::process_audio (uint8_t* data, int size)
 {
-	int const audio_frames_in_in_video_frames = _audio_frames_in * frames_per_second() / audio_sample_rate();
-	if (!within_range (audio_frames_in_in_video_frames)) {
-		return;
-	}
-	
-	/* Push into the delay line */
-	size = _delay_line->feed (data, size);
-
-	emit_audio (data, size);
-}
-
-void
-Decoder::emit_audio (uint8_t* data, int size)
-{
 	if (size == 0) {
 		return;
 	}
@@ -260,10 +230,42 @@ Decoder::emit_audio (uint8_t* data, int size)
 		}
 	}
 
-	/* Update the number of audio frames we've pushed to the encoder */
-	_audio_frames_out += audio->frames ();
+	_delay_line->feed (audio);
+
+	/* Decode range in audio frames */
+	pair<int64_t, int64_t> required_range (
+		video_frames_to_audio_frames (_film->dcp_trim_start()),
+		video_frames_to_audio_frames (_film->dcp_trim_start() + _film->dcp_length().get())
+		);
+
+	/* Range of this block of data */
+	pair<int64_t, int64_t> this_range (
+		_audio_frames_in,
+		_audio_frames_in + audio->frames()
+		);
+
+	/* Trim start */
+	if (required_range.first >= this_range.first && required_range.first < this_range.second) {
+		int64_t const shift = this_range.first - required_range.first;
+		audio->move (shift, 0, audio->frames() - shift);
+		audio->set_frames (audio->frames() - shift);
+	}
+
+	/* Trim end */
+	if (required_range.second >= this_range.first && required_range.second < this_range.second) {
+		audio->set_frames (this_range.first - required_range.second);
+	}
 
+	if (audio->frames()) {
+		emit_audio (audio);
+	}
+}
+
+void
+Decoder::emit_audio (shared_ptr<AudioBuffers> audio)
+{
 	Audio (audio);
+	_audio_frames_out += audio->frames ();
 }
 
 /** Called by subclasses to tell the world that some video data is ready.
@@ -287,7 +289,7 @@ Decoder::process_video (AVFrame* frame)
 		return;
 	}
 
-	if (!within_range (_video_frames_in)) {
+	if (_video_frames_in < _film->dcp_trim_start() || _video_frames_in > (_film->dcp_trim_start() + _film->length().get())) {
 		++_video_frames_in;
 		return;
 	}
@@ -358,9 +360,8 @@ Decoder::bytes_per_audio_sample () const
 	return av_get_bytes_per_sample (audio_sample_format ());
 }
 
-/** @param s A video frame index within the source */
-bool
-Decoder::within_range (SourceFrames s) const
+int64_t
+Decoder::video_frames_to_audio_frames (SourceFrame v) const
 {
-	return (s >= _film->dcp_trim_start() && s < (_film->length().get() + _film->dcp_trim_start()));
+	return ((int64_t) v * audio_sample_rate() / frames_per_second());
 }
diff --git a/src/lib/decoder.h b/src/lib/decoder.h
index c60ae4e59..2154da8bf 100644
--- a/src/lib/decoder.h
+++ b/src/lib/decoder.h
@@ -128,8 +128,10 @@ protected:
 
 private:
 	void emit_video (boost::shared_ptr<Image>, boost::shared_ptr<Subtitle>);
-	void emit_audio (uint8_t* data, int size);
+	void emit_audio (boost::shared_ptr<AudioBuffers>);
 
+	int64_t video_frames_to_audio_frames (SourceFrame v) const;
+	
 	SourceFrame _video_frames_in;
 	SourceFrame _video_frames_out;
 	int64_t _audio_frames_in;
@@ -138,7 +140,7 @@ private:
 	std::list<boost::shared_ptr<FilterGraph> > _filter_graphs;
 
 	DelayLine* _delay_line;
-	int _delay_in_bytes;
+	int _delay_in_frames;
 
 	boost::shared_ptr<TimedSubtitle> _timed_subtitle;
 
diff --git a/src/lib/delay_line.cc b/src/lib/delay_line.cc
index c510fb4e3..8aa43e293 100644
--- a/src/lib/delay_line.cc
+++ b/src/lib/delay_line.cc
@@ -22,89 +22,72 @@
 #include <algorithm>
 #include <iostream>
 #include "delay_line.h"
+#include "util.h"
 
-using namespace std;
+using std::min;
+using boost::shared_ptr;
 
-/** Construct a DelayLine delaying by some number of bytes.
- *  @param d Number of bytes to delay by; +ve moves data later.
+/** @param channels Number of channels of audio.
+ *  @param frames Delay in frames, +ve to move audio later.
  */
-DelayLine::DelayLine (int d)
-	: _delay (d)
-	, _buffer (0)
-	, _negative_delay_remaining (0)
+DelayLine::DelayLine (int channels, int frames)
 {
-	if (d > 0) {
+	if (frames > 0) {
 		/* We need a buffer to keep some data in */
-		_buffer = new uint8_t[d];
-		memset (_buffer, 0, d);
-	} else if (d < 0) {
+		_buffers.reset (new AudioBuffers (channels, frames));
+		_buffers->make_silent ();
+	} else if (frames < 0) {
 		/* We can do -ve delays just by chopping off
 		   the start, so no buffer needed.
 		*/
-		_negative_delay_remaining = -d;
+		_negative_delay_remaining = -frames;
 	}
 }
 
 DelayLine::~DelayLine ()
 {
-	delete[] _buffer;
+
 }
 
-int
-DelayLine::feed (uint8_t* data, int size)
+void
+DelayLine::feed (shared_ptr<AudioBuffers> data)
 {
-	int available = size;
+	if (_buffers) {
+		/* We have some buffers, so we are moving the audio later */
 
-	if (_delay > 0) {
-		
 		/* Copy the input data */
-		uint8_t input[size];
-		memcpy (input, data, size);
+		AudioBuffers input (*data.get ());
 
-		int to_do = size;
+		int to_do = data->frames ();
 
 		/* Write some of our buffer to the output */
-		int const from_buffer = min (to_do, _delay);
-		memcpy (data, _buffer, from_buffer);
+		int const from_buffer = min (to_do, _buffers->frames());
+		data->copy_from (_buffers.get(), from_buffer, 0, 0);
 		to_do -= from_buffer;
 
 		/* Write some of the input to the output */
-		int const from_input = min (to_do, size);
-		memcpy (data + from_buffer, input, from_input);
+		int const from_input = to_do;
+		data->copy_from (&input, from_input, 0, from_buffer);
+
+		int const left_in_buffer = _buffers->frames() - from_buffer;
 
-		int const left_in_buffer = _delay - from_buffer;
-		
 		/* Shuffle our buffer down */
-		memmove (_buffer, _buffer + from_buffer, left_in_buffer);
+		_buffers->move (from_buffer, 0, left_in_buffer);
 
 		/* Copy remaining input data to our buffer */
-		memcpy (_buffer + left_in_buffer, input + from_input, size - from_input);
+		_buffers->copy_from (&input, input.frames() - from_input, from_input, left_in_buffer);
 
-	} else if (_delay < 0) {
+	} else {
 
 		/* Chop the initial data off until _negative_delay_remaining
 		   is zero, then just pass data.
 		*/
 
-		int const to_do = min (size, _negative_delay_remaining);
-		available = size - to_do;
-		memmove (data, data + to_do, available);
-		_negative_delay_remaining -= to_do;
-
+		int const to_do = min (data->frames(), _negative_delay_remaining);
+		if (to_do) {
+			data->move (to_do, 0, data->frames() - to_do);
+			data->set_frames (data->frames() - to_do);
+			_negative_delay_remaining -= to_do;
+		}
 	}
-
-	return available;
-}
-
-/** With -ve delays, the DelayLine will have data to give after
- *  all input data has been passed to ::feed().
- *  Call this method after passing all input data.
- *
- *  @param buffer Pointer to buffer of _delay bytes in length,
- *  which will be filled with remaining data.
- */
-void
-DelayLine::get_remaining (uint8_t* buffer)
-{
-	memset (buffer, 0, -_delay);
 }
diff --git a/src/lib/delay_line.h b/src/lib/delay_line.h
index 377553de4..e8d9560af 100644
--- a/src/lib/delay_line.h
+++ b/src/lib/delay_line.h
@@ -17,20 +17,20 @@
 
 */
 
-/** A class which can be fed a stream of bytes and which can
- *  delay them by a positive or negative amount.
- */
+#include <boost/shared_ptr.hpp>
+
+class AudioBuffers;
+
+/** A delay line for audio */
 class DelayLine
 {
 public:
-	DelayLine (int);
+	DelayLine (int channels, int frames);
 	~DelayLine ();
 	
-	int feed (uint8_t *, int);
-	void get_remaining (uint8_t *);
+	void feed (boost::shared_ptr<AudioBuffers>);
 
 private:
-	int _delay; ///< delay in bytes, +ve to move data later
-	uint8_t* _buffer; ///< buffer for +ve delays, or 0
-	int _negative_delay_remaining; ///< number of bytes of negative delay that remain to emit
+	boost::shared_ptr<AudioBuffers> _buffers;
+	int _negative_delay_remaining; ///< number of frames of negative delay that remain to emit
 };
diff --git a/src/lib/util.cc b/src/lib/util.cc
index d89ebd0d5..26b2877f7 100644
--- a/src/lib/util.cc
+++ b/src/lib/util.cc
@@ -726,6 +726,7 @@ get_optional_int (multimap<string, string> const & kv, string k)
 AudioBuffers::AudioBuffers (int channels, int frames)
 	: _channels (channels)
 	, _frames (frames)
+	, _allocated_frames (frames)
 {
 	_data = new float*[_channels];
 	for (int i = 0; i < _channels; ++i) {
@@ -733,6 +734,18 @@ AudioBuffers::AudioBuffers (int channels, int frames)
 	}
 }
 
+AudioBuffers::AudioBuffers (AudioBuffers const & other)
+	: _channels (other._channels)
+	, _frames (other._frames)
+	, _allocated_frames (other._frames)
+{
+	_data = new float*[_channels];
+	for (int i = 0; i < _channels; ++i) {
+		_data[i] = new float[_frames];
+		memcpy (_data[i], other._data[i], _frames * sizeof (float));
+	}
+}
+
 AudioBuffers::~AudioBuffers ()
 {
 	for (int i = 0; i < _channels; ++i) {
@@ -752,7 +765,7 @@ AudioBuffers::data (int c) const
 void
 AudioBuffers::set_frames (int f)
 {
-	assert (f <= _frames);
+	assert (f <= _allocated_frames);
 	_frames = f;
 }
 
@@ -767,6 +780,24 @@ AudioBuffers::make_silent ()
 }
 
 void
+AudioBuffers::copy_from (AudioBuffers* from, int frames_to_copy, int read_offset, int write_offset)
+{
+	assert (from->channels() == channels());
+
+	for (int i = 0; i < _channels; ++i) {
+		memcpy (_data[i] + write_offset, from->_data[i] + read_offset, frames_to_copy * sizeof(float));
+	}
+}
+
+void
+AudioBuffers::move (int from, int to, int frames)
+{
+	for (int i = 0; i < _channels; ++i) {
+		memmove (_data[i] + to, _data[i] + from, frames * sizeof(float));
+	}
+}
+
+void
 ensure_ui_thread ()
 {
 	assert (this_thread::get_id() == ui_thread);
diff --git a/src/lib/util.h b/src/lib/util.h
index f87328dba..bb0a70a05 100644
--- a/src/lib/util.h
+++ b/src/lib/util.h
@@ -220,6 +220,7 @@ class AudioBuffers
 {
 public:
 	AudioBuffers (int channels, int frames);
+	AudioBuffers (AudioBuffers const &);
 	~AudioBuffers ();
 
 	float** data () const {
@@ -228,6 +229,10 @@ public:
 	
 	float* data (int) const;
 
+	int channels () const {
+		return _channels;
+	}
+
 	int frames () const {
 		return _frames;
 	}
@@ -236,12 +241,13 @@ public:
 
 	void make_silent ();
 
+	void copy_from (AudioBuffers* from, int frames_to_copy, int read_offset, int write_offset);
+	void move (int from, int to, int frames);
+
 private:
-	/* no copy construction */
-	AudioBuffers (AudioBuffers const &);
-	
 	int _channels;
 	int _frames;
+	int _allocated_frames;
 	float** _data;
 };