X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=77c14de10338f07396a5caf7de59b5c0f8742ea6;hb=616f2a0370a10dcc7372a95f6bca9f5a45698980;hp=9a93e4500003f04b9993ac49ece6bd0746a173c1;hpb=a1e0dc13df3cdc7033c940f0f3311a2bd47d3b2e;p=ardour.git

diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index 9a93e45000..77c14de103 100644
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -31,34 +31,30 @@
 #include <sys/mman.h>
 
 #include "pbd/error.h"
-#include <glibmm/thread.h>
 #include "pbd/xml++.h"
 #include "pbd/memento_command.h"
 #include "pbd/enumwriter.h"
-#include "pbd/stacktrace.h"
+#include "pbd/stateful_diff_command.h"
 
 #include "ardour/analyser.h"
-#include "ardour/ardour.h"
 #include "ardour/audio_buffer.h"
 #include "ardour/audio_diskstream.h"
 #include "ardour/audio_port.h"
 #include "ardour/audioengine.h"
 #include "ardour/audiofilesource.h"
-
 #include "ardour/audioplaylist.h"
 #include "ardour/audioregion.h"
 #include "ardour/butler.h"
-#include "ardour/configuration.h"
-#include "ardour/cycle_timer.h"
 #include "ardour/debug.h"
 #include "ardour/io.h"
 #include "ardour/playlist_factory.h"
 #include "ardour/region_factory.h"
-#include "ardour/send.h"
 #include "ardour/session.h"
+#include "ardour/session_playlists.h"
 #include "ardour/source_factory.h"
+#include "ardour/track.h"
+#include "ardour/types.h"
 #include "ardour/utils.h"
-#include "ardour/session_playlists.h"
 
 #include "i18n.h"
 #include <locale.h>
@@ -73,26 +69,21 @@ gain_t* AudioDiskstream::_gain_buffer          = 0;
 
 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
 	: Diskstream(sess, name, flag)
-	, deprecated_io_node(NULL)
 	, channels (new ChannelList)
 {
 	/* prevent any write sources from being created */
 
 	in_set_state = true;
-
-	init(flag);
 	use_new_playlist ();
-
 	in_set_state = false;
 }
 
 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
 	: Diskstream(sess, node)
-	, deprecated_io_node(NULL)
 	, channels (new ChannelList)
 {
 	in_set_state = true;
-	init (Recordable);
+	init ();
 
 	if (set_state (node, Stateful::loading_state_version)) {
 		in_set_state = false;
@@ -107,10 +98,8 @@ AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
 }
 
 void
-AudioDiskstream::init (Diskstream::Flag f)
+AudioDiskstream::init ()
 {
-	Diskstream::init(f);
-
 	/* there are no channels at this point, so these
 	   two calls just get speed_buffer_size and wrap_buffer
 	   size setup without duplicating their code.
@@ -118,9 +107,6 @@ AudioDiskstream::init (Diskstream::Flag f)
 
 	set_block_size (_session.get_block_size());
 	allocate_temporary_buffers ();
-
-	add_channel (1);
-	assert(_n_channels == ChanCount(DataType::AUDIO, 1));
 }
 
 AudioDiskstream::~AudioDiskstream ()
@@ -165,13 +151,13 @@ void
 AudioDiskstream::non_realtime_input_change ()
 {
 	{
-		Glib::Mutex::Lock lm (state_lock);
+		Glib::Threads::Mutex::Lock lm (state_lock);
 
-		if (input_change_pending == NoChange) {
+		if (input_change_pending.type == IOChange::NoChange) {
 			return;
 		}
 
-		{
+		if (input_change_pending.type == IOChange::ConfigurationChanged) {
 			RCUWriter<ChannelList> writer (channels);
 			boost::shared_ptr<ChannelList> c = writer.get_copy();
 
@@ -184,17 +170,13 @@ AudioDiskstream::non_realtime_input_change ()
 			}
 		}
 
-		get_input_sources ();
-		set_capture_offset ();
-
-		if (first_input_change) {
-			set_align_style (_persistent_alignment_style);
-			first_input_change = false;
-		} else {
+		if (input_change_pending.type & IOChange::ConnectionsChanged) {
+			get_input_sources ();
+			set_capture_offset ();
 			set_align_style_from_io ();
 		}
 
-		input_change_pending = NoChange;
+		input_change_pending = IOChange::NoChange;
 
 		/* implicit unlock */
 	}
@@ -206,19 +188,19 @@ AudioDiskstream::non_realtime_input_change ()
 	/* now refill channel buffers */
 
 	if (speed() != 1.0f || speed() != -1.0f) {
-		seek ((nframes_t) (_session.transport_frame() * (double) speed()));
+		seek ((framepos_t) (_session.transport_frame() * (double) speed()));
 	} else {
 		seek (_session.transport_frame());
 	}
 }
 
 void
-AudioDiskstream::non_realtime_locate (nframes_t location)
+AudioDiskstream::non_realtime_locate (framepos_t location)
 {
 	/* now refill channel buffers */
 
 	if (speed() != 1.0f || speed() != -1.0f) {
-		seek ((nframes_t) (location * (double) speed()));
+		seek ((framepos_t) (location * (double) speed()));
 	} else {
 		seek (location);
 	}
@@ -239,15 +221,12 @@ AudioDiskstream::get_input_sources ()
 		connections.clear ();
 
 		if (_io->nth (n)->get_connections (connections) == 0) {
-
-			if ((*chan)->source) {
+			if (!(*chan)->source.name.empty()) {
 				// _source->disable_metering ();
 			}
-
-			(*chan)->source = 0;
-
+			(*chan)->source.name = string();
 		} else {
-			(*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
+			(*chan)->source.name = connections[0];
 		}
 	}
 }
@@ -297,7 +276,6 @@ AudioDiskstream::use_new_playlist ()
 
 	if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 
-		playlist->set_orig_diskstream_id (id());
 		return use_playlist (playlist);
 
 	} else {
@@ -324,8 +302,7 @@ AudioDiskstream::use_copy_playlist ()
 
 	newname = Playlist::bump_name (_playlist->name(), _session);
 
-	if ((playlist  = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
-		playlist->set_orig_diskstream_id (id());
+	if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
 		return use_playlist (playlist);
 	} else {
 		return -1;
@@ -344,7 +321,14 @@ AudioDiskstream::setup_destructive_playlist ()
 
 	/* a single full-sized region */
 
-	boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
+	assert (!srcs.empty ());
+
+	PropertyList plist;
+	plist.add (Properties::name, _name.val());
+	plist.add (Properties::start, 0);
+	plist.add (Properties::length, max_framepos - (max_framepos - srcs.front()->natural_position()));
+
+	boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
 	_playlist->add_region (region, srcs.front()->natural_position());
 }
 
@@ -372,7 +356,7 @@ AudioDiskstream::use_destructive_playlist ()
 
 	/* be sure to stretch the region out to the maximum length */
 
-	region->set_length (max_frames - region->position(), this);
+	region->set_length (max_framepos - region->position());
 
 	uint32_t n;
 	ChannelList::iterator chan;
@@ -392,21 +376,20 @@ AudioDiskstream::use_destructive_playlist ()
 }
 
 void
-AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
+AudioDiskstream::prepare_record_status(framepos_t capture_start_frame)
 {
 	if (recordable() && destructive()) {
 		boost::shared_ptr<ChannelList> c = channels.reader();
 		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 
-			RingBufferNPT<CaptureTransition>::rw_vector transvec;
-			(*chan)->capture_transition_buf->get_write_vector(&transvec);
+			RingBufferNPT<CaptureTransition>::rw_vector transitions;
+			(*chan)->capture_transition_buf->get_write_vector (&transitions);
 
-			if (transvec.len[0] > 0) {
-				transvec.buf[0]->type = CaptureStart;
-				transvec.buf[0]->capture_val = capture_start_frame;
+			if (transitions.len[0] > 0) {
+				transitions.buf[0]->type = CaptureStart;
+				transitions.buf[0]->capture_val = capture_start_frame;
 				(*chan)->capture_transition_buf->increment_write_ptr(1);
-			}
-			else {
+			} else {
 				// bad!
 				fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 					<< endmsg;
@@ -415,57 +398,44 @@ AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
 	}
 }
 
+
+/** Do some record stuff [not described in this comment!]
+ *
+ *  Also:
+ *    - Setup playback_distance with the nframes, or nframes adjusted
+ *      for current varispeed, if appropriate.
+ *    - Setup current_playback_buffer in each ChannelInfo to point to data
+ *      that someone can read playback_distance worth of data from.
+ */
 int
-AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
+AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
 {
 	uint32_t n;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 	ChannelList::iterator chan;
-	int ret = -1;
-	nframes_t rec_offset = 0;
-	nframes_t rec_nframes = 0;
-	bool nominally_recording;
-	bool re = record_enabled ();
+	framecnt_t rec_offset = 0;
+	framecnt_t rec_nframes = 0;
 	bool collect_playback = false;
+	bool can_record = _session.actively_recording ();
 
-	/* if we've already processed the frames corresponding to this call,
-	   just return. this allows multiple routes that are taking input
-	   from this diskstream to call our ::process() method, but have
-	   this stuff only happen once. more commonly, it allows both
-	   the AudioTrack that is using this AudioDiskstream *and* the Session
-	   to call process() without problems.
-	*/
-
-	if (_processed) {
-		return 0;
-	}
-
-	commit_should_unlock = false;
+	playback_distance = 0;
 
 	if (!_io || !_io->active()) {
-		_processed = true;
 		return 0;
 	}
 
-	check_record_status (transport_frame, nframes, can_record);
-
-	nominally_recording = (can_record && re);
+	check_record_status (transport_frame, can_record);
 
 	if (nframes == 0) {
-		_processed = true;
 		return 0;
 	}
 
-	/* This lock is held until the end of AudioDiskstream::commit, so these two functions
-	   must always be called as a pair. The only exception is if this function
-	   returns a non-zero value, in which case, ::commit should not be called.
-	*/
+	Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
 
-	// If we can't take the state lock return.
-	if (!state_lock.trylock()) {
+	if (!sm.locked()) {
 		return 1;
 	}
-	commit_should_unlock = true;
+
 	adjust_capture_position = 0;
 
 	for (chan = c->begin(); chan != c->end(); ++chan) {
@@ -473,15 +443,17 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 		(*chan)->current_playback_buffer = 0;
 	}
 
-	if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
-		// Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
-		if (last_recordable_frame < first_recordable_frame) {
-			last_recordable_frame = max_frames;
-		}
+	// Safeguard against situations where process() goes haywire when autopunching
+	// and last_recordable_frame < first_recordable_frame
 
-		OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+	if (last_recordable_frame < first_recordable_frame) {
+		last_recordable_frame = max_framepos;
+	}
+
+	if (record_enabled()) {
 
-		calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
+		Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+		calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
 
 		if (rec_nframes && !was_recording) {
 			capture_captured = 0;
@@ -489,12 +461,11 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 		}
 	}
 
-
-	if (can_record && !_last_capture_regions.empty()) {
-		_last_capture_regions.clear ();
+	if (can_record && !_last_capture_sources.empty()) {
+		_last_capture_sources.clear ();
 	}
 
-	if (nominally_recording || rec_nframes) {
+	if (rec_nframes) {
 
 		uint32_t limit = _io->n_ports ().n_audio();
 
@@ -511,7 +482,7 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 
 			chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
 
-			if (rec_nframes <= chaninfo->capture_vector.len[0]) {
+			if (rec_nframes <= (framecnt_t) chaninfo->capture_vector.len[0]) {
 
 				chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
 
@@ -519,26 +490,27 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 				   for recording, and use rec_offset
 				*/
 
-				AudioPort* const ap = _io->audio (n);
+				boost::shared_ptr<AudioPort> const ap = _io->audio (n);
 				assert(ap);
-				assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
-				memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (rec_nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
-
+				assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
 
+				Sample *buf = bufs.get_audio (n).data(rec_offset);
+				memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes);
+				
 			} else {
 
-				nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
+				framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
 
 				if (rec_nframes > total) {
 					DiskOverrun ();
-					goto out;
+					return -1;
 				}
 
-				AudioPort* const ap = _io->audio (n);
+				boost::shared_ptr<AudioPort> const ap = _io->audio (n);
 				assert(ap);
 
-				Sample* buf = ap->get_audio_buffer(nframes).data();
-				nframes_t first = chaninfo->capture_vector.len[0];
+				Sample *buf = bufs.get_audio (n).data(rec_offset);
+				framecnt_t first = chaninfo->capture_vector.len[0];
 
 				memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
 				memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
@@ -552,7 +524,7 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 	} else {
 
 		if (was_recording) {
-			finish_capture (rec_monitors_input, c);
+			finish_capture (c);
 		}
 
 	}
@@ -582,7 +554,7 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 
 		adjust_capture_position = rec_nframes;
 
-	} else if (nominally_recording) {
+	} else if (can_record && record_enabled()) {
 
 		/* can't do actual capture yet - waiting for latency effects to finish before we start*/
 
@@ -597,16 +569,16 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 		collect_playback = true;
 	}
 
-	if (collect_playback) {
-
+	if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) {
+		
 		/* we're doing playback */
 
-		nframes_t necessary_samples;
+		framecnt_t necessary_samples;
 
 		/* no varispeed playback if we're recording, because the output .... TBD */
 
 		if (rec_nframes == 0 && _actual_speed != 1.0f) {
-			necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
+			necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2;
 		} else {
 			necessary_samples = nframes;
 		}
@@ -617,28 +589,43 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 
 		n = 0;
 
+		/* Setup current_playback_buffer in each ChannelInfo to point to data that someone
+		   can read necessary_samples (== nframes at a transport speed of 1) worth of data
+		   from right now.
+		*/
+
 		for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 
 			ChannelInfo* chaninfo (*chan);
 
-			if (necessary_samples <= chaninfo->playback_vector.len[0]) {
-
+			if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) {
+				/* There are enough samples in the first part of the ringbuffer */
 				chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 
 			} else {
-				nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
+				framecnt_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
 
 				if (necessary_samples > total) {
 					cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
 					cerr << "underrun for " << _name << endl;
 					DiskUnderrun ();
-					goto out;
+					return -1;
 
 				} else {
 
+					/* We have enough samples, but not in one lump.  Coalesce the two parts
+					   into one in playback_wrap_buffer in our ChannelInfo, and specify that
+					   as our current_playback_buffer.
+					*/
+
+					assert(wrap_buffer_size >= necessary_samples);
+
+					/* Copy buf[0] from playback_buf */
 					memcpy ((char *) chaninfo->playback_wrap_buffer,
 							chaninfo->playback_vector.buf[0],
 							chaninfo->playback_vector.len[0] * sizeof (Sample));
+					
+					/* Copy buf[1] from playback_buf */
 					memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
 							chaninfo->playback_vector.buf[1],
 							(necessary_samples - chaninfo->playback_vector.len[0])
@@ -650,53 +637,100 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can
 		}
 
 		if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
-			process_varispeed_playback(nframes, c);
+
+			interpolation.set_speed (_target_speed);
+
+			int channel = 0;
+			for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
+				ChannelInfo* chaninfo (*chan);
+				
+				playback_distance = interpolation.interpolate (
+					channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+				
+				chaninfo->current_playback_buffer = chaninfo->speed_buffer;
+			}
+			
 		} else {
 			playback_distance = nframes;
 		}
 
 		_speed = _target_speed;
-
 	}
 
-	ret = 0;
-
-  out:
-	_processed = true;
+	if (need_disk_signal) {
 
-	if (ret) {
+		/* copy data over to buffer set */
+		
+		size_t n_buffers = bufs.count().n_audio();
+		size_t n_chans = c->size();
+		gain_t scaling = 1.0f;
+		
+		if (n_chans > n_buffers) {
+			scaling = ((float) n_buffers)/n_chans;
+		}
 
-		/* we're exiting with failure, so ::commit will not
-		   be called. unlock the state lock.
-		*/
+		for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
+			
+			AudioBuffer& buf (bufs.get_audio (n%n_buffers));
+			ChannelInfo* chaninfo (*chan);
+			
+			if (n < n_chans) {
+				if (scaling != 1.0f) {
+					buf.read_from_with_gain (chaninfo->current_playback_buffer, nframes, scaling);
+				} else {
+					buf.read_from (chaninfo->current_playback_buffer, nframes);
+				}
+			} else {
+				if (scaling != 1.0f) {
+					buf.accumulate_with_gain_from (chaninfo->current_playback_buffer, nframes, scaling);
+				} else {
+					buf.accumulate_from (chaninfo->current_playback_buffer, nframes);
+				}
+			}
+		}
 
-		commit_should_unlock = false;
-		state_lock.unlock();
+		/* leave the MIDI count alone */
+		ChanCount cnt (DataType::AUDIO, n_chans);
+		cnt.set (DataType::MIDI, bufs.count().n_midi());
+		bufs.set_count (cnt);
+	
+		/* extra buffers will already be silent, so leave them alone */
 	}
 
-	return ret;
+	return 0;
 }
 
-void
-AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
+frameoffset_t
+AudioDiskstream::calculate_playback_distance (pframes_t nframes)
 {
-	ChannelList::iterator chan;
-
-	interpolation.set_speed (_target_speed);
+	frameoffset_t playback_distance = nframes;
 
-	int channel = 0;
-	for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
-		ChannelInfo* chaninfo (*chan);
-
-		playback_distance = interpolation.interpolate (
-				channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+	if (record_enabled()) {
+		playback_distance = nframes;
+	} else if (_actual_speed != 1.0f && _actual_speed != -1.0f) {
+		interpolation.set_speed (_target_speed);
+		boost::shared_ptr<ChannelList> c = channels.reader();
+		int channel = 0;
+		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
+			playback_distance = interpolation.interpolate (channel, nframes, NULL, NULL);
+		}
+	} else {
+		playback_distance = nframes;
+	}
 
-		chaninfo->current_playback_buffer = chaninfo->speed_buffer;
+	if (_actual_speed < 0.0) {
+		return -playback_distance;
+	} else {
+		return playback_distance;
 	}
 }
 
+/** Update various things including playback_sample, read pointer on each channel's playback_buf
+ *  and write pointer on each channel's capture_buf.  Also wout whether the butler is needed.
+ *  @return true if the butler is required.
+ */
 bool
-AudioDiskstream::commit (nframes_t /*nframes*/)
+AudioDiskstream::commit (framecnt_t playback_distance)
 {
 	bool need_butler = false;
 
@@ -725,6 +759,10 @@ AudioDiskstream::commit (nframes_t /*nframes*/)
 		adjust_capture_position = 0;
 	}
 
+	if (c->empty()) {
+		return false;
+	}
+
 	if (_slaved) {
 		if (_io && _io->active()) {
 			need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
@@ -733,19 +771,13 @@ AudioDiskstream::commit (nframes_t /*nframes*/)
 		}
 	} else {
 		if (_io && _io->active()) {
-			need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
-				|| c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
+			need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames)
+				|| ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
 		} else {
-			need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
+			need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
 		}
 	}
 
-	if (commit_should_unlock) {
-		state_lock.unlock();
-	}
-
-	_processed = false;
-
 	return need_butler;
 }
 
@@ -754,16 +786,25 @@ AudioDiskstream::set_pending_overwrite (bool yn)
 {
 	/* called from audio thread, so we can use the read ptr and playback sample as we wish */
 
-	pending_overwrite = yn;
+	_pending_overwrite = yn;
 
 	overwrite_frame = playback_sample;
-	overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
+
+	boost::shared_ptr<ChannelList> c = channels.reader ();
+	if (!c->empty ()) {
+		overwrite_offset = c->front()->playback_buf->get_read_ptr();
+	}
 }
 
 int
 AudioDiskstream::overwrite_existing_buffers ()
 {
 	boost::shared_ptr<ChannelList> c = channels.reader();
+	if (c->empty ()) {
+		_pending_overwrite = false;
+		return 0;
+	}
+
 	Sample* mixdown_buffer;
 	float* gain_buffer;
 	int ret = -1;
@@ -772,21 +813,23 @@ AudioDiskstream::overwrite_existing_buffers ()
 	overwrite_queued = false;
 
 	/* assume all are the same size */
-	nframes_t size = c->front()->playback_buf->bufsize();
+	framecnt_t size = c->front()->playback_buf->bufsize();
 
 	mixdown_buffer = new Sample[size];
 	gain_buffer = new float[size];
 
-	/* reduce size so that we can fill the buffer correctly. */
+	/* reduce size so that we can fill the buffer correctly (ringbuffers
+	   can only handle size-1, otherwise they appear to be empty)
+	*/
 	size--;
 
 	uint32_t n=0;
-	nframes_t start;
+	framepos_t start;
 
 	for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 
 		start = overwrite_frame;
-		nframes_t cnt = size;
+		framecnt_t cnt = size;
 
 		/* to fill the buffer without resetting the playback sample, we need to
 		   do it one or two chunks (normally two).
@@ -799,11 +842,11 @@ AudioDiskstream::overwrite_existing_buffers ()
 
 		*/
 
-		nframes_t to_read = size - overwrite_offset;
+		framecnt_t to_read = size - overwrite_offset;
 
-		if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
+		if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) {
 			error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
-					 _id, size, playback_sample) << endmsg;
+						id(), size, playback_sample) << endmsg;
 			goto out;
 		}
 
@@ -811,10 +854,9 @@ AudioDiskstream::overwrite_existing_buffers ()
 
 			cnt -= to_read;
 
-			if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
-				  start, cnt, *chan, n, reversed)) {
+			if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) {
 				error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
-						 _id, size, playback_sample) << endmsg;
+							id(), size, playback_sample) << endmsg;
 				goto out;
 			}
 		}
@@ -823,21 +865,21 @@ AudioDiskstream::overwrite_existing_buffers ()
 	ret = 0;
 
   out:
-	pending_overwrite = false;
+	_pending_overwrite = false;
 	delete [] gain_buffer;
 	delete [] mixdown_buffer;
 	return ret;
 }
 
 int
-AudioDiskstream::seek (nframes_t frame, bool complete_refill)
+AudioDiskstream::seek (framepos_t frame, bool complete_refill)
 {
 	uint32_t n;
 	int ret = -1;
 	ChannelList::iterator chan;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
-	Glib::Mutex::Lock lm (state_lock);
+	Glib::Threads::Mutex::Lock lm (state_lock);
 
 	for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 		(*chan)->playback_buf->reset ();
@@ -863,13 +905,13 @@ AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 }
 
 int
-AudioDiskstream::can_internal_playback_seek (nframes_t distance)
+AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
 {
 	ChannelList::iterator chan;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
 	for (chan = c->begin(); chan != c->end(); ++chan) {
-		if ((*chan)->playback_buf->read_space() < distance) {
+		if ((*chan)->playback_buf->read_space() < (size_t) distance) {
 			return false;
 		}
 	}
@@ -877,37 +919,48 @@ AudioDiskstream::can_internal_playback_seek (nframes_t distance)
 }
 
 int
-AudioDiskstream::internal_playback_seek (nframes_t distance)
+AudioDiskstream::internal_playback_seek (framecnt_t distance)
 {
 	ChannelList::iterator chan;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
 	for (chan = c->begin(); chan != c->end(); ++chan) {
-		(*chan)->playback_buf->increment_read_ptr (distance);
+		(*chan)->playback_buf->increment_read_ptr (llabs(distance));
 	}
 
-	first_recordable_frame += distance;
+	if (first_recordable_frame < max_framepos) {
+		first_recordable_frame += distance;
+	}
 	playback_sample += distance;
 
 	return 0;
 }
 
+/** Read some data for 1 channel from our playlist into a buffer.
+ *  @param buf Buffer to write to.
+ *  @param start Session frame to start reading from; updated to where we end up
+ *         after the read.
+ *  @param cnt Count of samples to read.
+ *  @param reversed true if we are running backwards, otherwise false.
+ */
 int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
-		       ChannelInfo* /*channel_info*/, int channel, bool reversed)
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
+                       framepos_t& start, framecnt_t cnt,
+                       int channel, bool reversed)
 {
-	nframes_t this_read = 0;
+	framecnt_t this_read = 0;
 	bool reloop = false;
-	nframes_t loop_end = 0;
-	nframes_t loop_start = 0;
-	nframes_t loop_length = 0;
-	nframes_t offset = 0;
+	framepos_t loop_end = 0;
+	framepos_t loop_start = 0;
+	framecnt_t offset = 0;
 	Location *loc = 0;
 
 	/* XXX we don't currently play loops in reverse. not sure why */
 
 	if (!reversed) {
 
+		framecnt_t loop_length = 0;
+
 		/* Make the use of a Location atomic for this read operation.
 
 		   Note: Locations don't get deleted, so all we care about
@@ -927,25 +980,24 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 		*/
 
 		if (loc && start >= loop_end) {
-			//cerr << "start adjusted from " << start;
 			start = loop_start + ((start - loop_start) % loop_length);
-			//cerr << "to " << start << endl;
 		}
+	}
 
-		//cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
+	if (reversed) {
+		start -= cnt;
 	}
 
-	while (cnt) {
+	/* We need this while loop in case we hit a loop boundary, in which case our read from
+	   the playlist must be split into more than one section.
+	*/
 
-		if (reversed) {
-			start -= cnt;
-		}
+	while (cnt) {
 
 		/* take any loop into account. we can't read past the end of the loop. */
 
 		if (loc && (loop_end - start < cnt)) {
 			this_read = loop_end - start;
-			//cerr << "reloop true: thisread: " << this_read << "  cnt: " << cnt << endl;
 			reloop = true;
 		} else {
 			reloop = false;
@@ -959,13 +1011,11 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
 		this_read = min(cnt,this_read);
 
 		if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
-			error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
+			error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), id(), this_read,
 					 start) << endmsg;
 			return -1;
 		}
 
-		_read_data_count = _playlist->read_data_count();
-
 		if (reversed) {
 
 			swap_by_ptr (buf, buf + this_read - 1);
@@ -1002,19 +1052,22 @@ AudioDiskstream::do_refill_with_alloc ()
 	return ret;
 }
 
+/** Get some more data from disk and put it in our channels' playback_bufs,
+ *  if there is suitable space in them.
+ */
 int
 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 {
 	int32_t ret = 0;
-	nframes_t to_read;
+	framecnt_t to_read;
 	RingBufferNPT<Sample>::rw_vector vector;
-	bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
-	nframes_t total_space;
-	nframes_t zero_fill;
+	bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
+	framecnt_t total_space;
+	framecnt_t zero_fill;
 	uint32_t chan_n;
 	ChannelList::iterator i;
 	boost::shared_ptr<ChannelList> c = channels.reader();
-	nframes_t ts;
+	framecnt_t ts;
 
 	if (c->empty()) {
 		return 0;
@@ -1031,6 +1084,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 	c->front()->playback_buf->get_write_vector (&vector);
 
 	if ((total_space = vector.len[0] + vector.len[1]) == 0) {
+		/* nowhere to write to */
 		return 0;
 	}
 
@@ -1039,7 +1093,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 	   for us to be called again, ASAP.
 	*/
 
-	if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
+	if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) {
 		ret = 1;
 	}
 
@@ -1048,6 +1102,10 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
 	   at higher speeds, just do it because the sync between butler
 	   and audio thread may not be good enough.
+
+	   Note: it is a design assumption that disk_io_chunk_frames is smaller
+	   than the playback buffer size, so this check should never trip when
+	   the playback buffer is empty.
 	*/
 
 	if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
@@ -1059,7 +1117,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 	   work with.
 	*/
 
-	if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
+	if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) {
 		return 0;
 	}
 
@@ -1094,7 +1152,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
 			zero_fill = total_space - file_frame;
 			total_space = file_frame;
-			file_frame = 0;
 
 		} else {
 
@@ -1103,7 +1160,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
 	} else {
 
-		if (file_frame == max_frames) {
+		if (file_frame == max_framepos) {
 
 			/* at end: nothing to do but fill with silence */
 
@@ -1120,30 +1177,30 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 			return 0;
 		}
 
-		if (file_frame > max_frames - total_space) {
+		if (file_frame > max_framepos - total_space) {
 
 			/* to close to the end: read what we can, and zero fill the rest */
 
-			zero_fill = total_space - (max_frames - file_frame);
-			total_space = max_frames - file_frame;
+			zero_fill = total_space - (max_framepos - file_frame);
+			total_space = max_framepos - file_frame;
 
 		} else {
 			zero_fill = 0;
 		}
 	}
 
-	nframes_t file_frame_tmp = 0;
+	framepos_t file_frame_tmp = 0;
 
 	for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
 
 		ChannelInfo* chan (*i);
 		Sample* buf1;
 		Sample* buf2;
-		nframes_t len1, len2;
+		framecnt_t len1, len2;
 
 		chan->playback_buf->get_write_vector (&vector);
 
-		if (vector.len[0] > disk_io_chunk_frames) {
+		if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
 
 			/* we're not going to fill the first chunk, so certainly do not bother with the
 			   other part. it won't be connected with the part we do fill, as in:
@@ -1177,9 +1234,11 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 		to_read = min (ts, len1);
 		to_read = min (to_read, disk_io_chunk_frames);
 
+		assert (to_read >= 0);
+
 		if (to_read) {
 
-			if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+			if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
 				ret = -1;
 				goto out;
 			}
@@ -1196,7 +1255,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 			   so read some or all of vector.len[1] as well.
 			*/
 
-			if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+			if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
 				ret = -1;
 				goto out;
 			}
@@ -1205,12 +1264,13 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 		}
 
 		if (zero_fill) {
-			/* do something */
+			/* XXX: do something */
 		}
 
 	}
 
 	file_frame = file_frame_tmp;
+	assert (file_frame >= 0);
 
   out:
 
@@ -1234,9 +1294,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 	int32_t ret = 0;
 	RingBufferNPT<Sample>::rw_vector vector;
 	RingBufferNPT<CaptureTransition>::rw_vector transvec;
-	nframes_t total;
-
-	_write_data_count = 0;
+	framecnt_t total;
 
 	transvec.buf[0] = 0;
 	transvec.buf[1] = 0;
@@ -1269,7 +1327,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 			ret = 1;
 		}
 
-		to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
+		to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
 
 		// check the transition buffer when recording destructive
 		// important that we get this after the capture buf
@@ -1277,7 +1335,6 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 		if (destructive()) {
 			(*chan)->capture_transition_buf->get_read_vector(&transvec);
 			size_t transcount = transvec.len[0] + transvec.len[1];
-			bool have_start = false;
 			size_t ti;
 
 			for (ti=0; ti < transcount; ++ti) {
@@ -1289,9 +1346,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 					(*chan)->write_source->mark_capture_start (captrans.capture_val);
 					(*chan)->curr_capture_cnt = 0;
 
-					have_start = true;
-				}
-				else if (captrans.type == CaptureEnd) {
+				} else if (captrans.type == CaptureEnd) {
 
 					// capture end, the capture_val represents total frames in capture
 
@@ -1325,7 +1380,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 		}
 
 		if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
-			error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
+			error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
 			return -1;
 		}
 
@@ -1339,15 +1394,13 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 			   of vector.len[1] to be flushed to disk as well.
 			*/
 
-			to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
+			to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
 
 			if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
-				error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
+				error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
 				return -1;
 			}
 
-			_write_data_count += (*chan)->write_source->write_data_count();
-
 			(*chan)->capture_buf->increment_read_ptr (to_write);
 			(*chan)->curr_capture_cnt += to_write;
 		}
@@ -1358,13 +1411,13 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 }
 
 void
-AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
+AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
 {
 	uint32_t buffer_position;
 	bool more_work = true;
 	int err = 0;
 	boost::shared_ptr<AudioRegion> region;
-	nframes_t total_capture;
+	framecnt_t total_capture;
 	SourceList srcs;
 	SourceList::iterator src;
 	ChannelList::iterator chan;
@@ -1373,7 +1426,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 	uint32_t n = 0;
 	bool mark_write_completed = false;
 
-	finish_capture (true, c);
+	finish_capture (c);
 
 	/* butler is already stopped, but there may be work to do
 	   to flush remaining data to disk.
@@ -1393,7 +1446,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 	}
 
 	/* XXX is there anything we can do if err != 0 ? */
-	Glib::Mutex::Lock lm (capture_info_lock);
+	Glib::Threads::Mutex::Lock lm (capture_info_lock);
 
 	if (capture_info.empty()) {
 		return;
@@ -1435,6 +1488,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 			s->update_header (capture_info.front()->start, when, twhen);
 			s->set_captured_for (_name.val());
 			s->mark_immutable ();
+
 			if (Config->get_auto_analyse_audio()) {
 				Analyser::queue_source_for_analysis (s, true);
 			}
@@ -1465,10 +1519,14 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 		*/
 
 		try {
-			boost::shared_ptr<Region> rx (RegionFactory::create (srcs,
-						c->front()->write_source->last_capture_start_frame(), total_capture,
-						whole_file_region_name, 0,
-						Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
+			PropertyList plist;
+
+			plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
+			plist.add (Properties::length, total_capture);
+			plist.add (Properties::name, whole_file_region_name);
+			boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+			rx->set_automatic (true);
+			rx->set_whole_file (true);
 
 			region = boost::dynamic_pointer_cast<AudioRegion> (rx);
 			region->special_set_position (capture_info.front()->start);
@@ -1480,23 +1538,32 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 			/* XXX what now? */
 		}
 
-		_last_capture_regions.push_back (region);
+		_last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
 
 		// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
 
-		XMLNode &before = _playlist->get_state();
+		_playlist->clear_changes ();
+		_playlist->set_capture_insertion_in_progress (true);
 		_playlist->freeze ();
 
 		for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 
 			string region_name;
 
-			_session.region_name (region_name, whole_file_region_name, false);
+			RegionFactory::region_name (region_name, whole_file_region_name, false);
 
-			// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
+			DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
+			                                                      _name, (*ci)->start, (*ci)->frames, region_name));
 
 			try {
-				boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
+
+				PropertyList plist;
+
+				plist.add (Properties::start, buffer_position);
+				plist.add (Properties::length, (*ci)->frames);
+				plist.add (Properties::name, region_name);
+
+				boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
 				region = boost::dynamic_pointer_cast<AudioRegion> (rx);
 			}
 
@@ -1505,20 +1572,18 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 				continue; /* XXX is this OK? */
 			}
 
-			region->DropReferences.connect_same_thread (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
-
-			_last_capture_regions.push_back (region);
-
 			i_am_the_modifier++;
+
 			_playlist->add_region (region, (*ci)->start, 1, non_layered());
+			_playlist->set_layer (region, DBL_MAX);
 			i_am_the_modifier--;
 
 			buffer_position += (*ci)->frames;
 		}
 
 		_playlist->thaw ();
-		XMLNode &after = _playlist->get_state();
-		_session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+		_playlist->set_capture_insertion_in_progress (false);
+		_session.add_command (new StatefulDiffCommand (_playlist));
 	}
 
 	mark_write_completed = true;
@@ -1537,7 +1602,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 }
 
 void
-AudioDiskstream::transport_looped (nframes_t transport_frame)
+AudioDiskstream::transport_looped (framepos_t transport_frame)
 {
 	if (was_recording) {
 		// all we need to do is finish this capture, with modified capture length
@@ -1555,14 +1620,14 @@ AudioDiskstream::transport_looped (nframes_t transport_frame)
 			}
 		}
 
-		finish_capture (true, c);
+		finish_capture (c);
 
 		// the next region will start recording via the normal mechanism
 		// we'll set the start position to the current transport pos
 		// no latency adjustment or capture offset needs to be made, as that already happened the first time
 		capture_start_frame = transport_frame;
 		first_recordable_frame = transport_frame; // mild lie
-		last_recordable_frame = max_frames;
+		last_recordable_frame = max_framepos;
 		was_recording = true;
 
 		if (recordable() && destructive()) {
@@ -1588,9 +1653,11 @@ AudioDiskstream::transport_looped (nframes_t transport_frame)
 }
 
 void
-AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
+AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
 {
 	was_recording = false;
+	first_recordable_frame = max_framepos;
+	last_recordable_frame = max_framepos;
 
 	if (capture_captured == 0) {
 		return;
@@ -1635,7 +1702,7 @@ AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<
 	capture_captured = 0;
 
 	/* now we've finished a capture, reset first_recordable_frame for next time */
-	first_recordable_frame = max_frames;
+	first_recordable_frame = max_framepos;
 }
 
 void
@@ -1661,24 +1728,33 @@ AudioDiskstream::set_record_enabled (bool yn)
 		} else {
 			disengage_record_enable ();
 		}
+
+		RecordEnableChanged (); /* EMIT SIGNAL */
 	}
 }
 
-void
-AudioDiskstream::engage_record_enable ()
+bool
+AudioDiskstream::prep_record_enable ()
 {
+	if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
+		return false;
+	}
+
+	/* can't rec-enable in destructive mode if transport is before start */
+
+	if (destructive() && _session.transport_frame() < _session.current_start_frame()) {
+		return false;
+	}
+
 	bool rolling = _session.transport_speed() != 0.0f;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
-	g_atomic_int_set (&_record_enabled, 1);
 	capturing_sources.clear ();
 
 	if (Config->get_monitoring_model() == HardwareMonitoring) {
 
 		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-			if ((*chan)->source) {
-				(*chan)->source->ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
-			}
+			(*chan)->source.request_input_monitoring (!(_session.config.get_auto_input() && rolling));
 			capturing_sources.push_back ((*chan)->write_source);
 			(*chan)->write_source->mark_streaming_write_started ();
 		}
@@ -1690,46 +1766,33 @@ AudioDiskstream::engage_record_enable ()
 		}
 	}
 
-	RecordEnableChanged (); /* EMIT SIGNAL */
+	return true;
 }
 
-void
-AudioDiskstream::disengage_record_enable ()
+bool
+AudioDiskstream::prep_record_disable ()
 {
-	g_atomic_int_set (&_record_enabled, 0);
 	boost::shared_ptr<ChannelList> c = channels.reader();
 	if (Config->get_monitoring_model() == HardwareMonitoring) {
 		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-			if ((*chan)->source) {
-				(*chan)->source->ensure_monitor_input (false);
-			}
+			(*chan)->source.request_input_monitoring (false);
 		}
 	}
 	capturing_sources.clear ();
-	RecordEnableChanged (); /* EMIT SIGNAL */
+
+	return true;
 }
 
 XMLNode&
 AudioDiskstream::get_state ()
 {
-	XMLNode* node = new XMLNode ("AudioDiskstream");
+	XMLNode& node (Diskstream::get_state());
 	char buf[64] = "";
 	LocaleGuard lg (X_("POSIX"));
-	boost::shared_ptr<ChannelList> c = channels.reader();
-
-	node->add_property ("flags", enum_2_string (_flags));
 
+	boost::shared_ptr<ChannelList> c = channels.reader();
 	snprintf (buf, sizeof(buf), "%zd", c->size());
-	node->add_property ("channels", buf);
-
-	node->add_property ("playlist", _playlist->name());
-
-	snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
-	node->add_property ("speed", buf);
-
-	node->add_property("name", _name);
-	id().print (buf, sizeof (buf));
-	node->add_property("id", buf);
+	node.add_property ("channels", buf);
 
 	if (!capturing_sources.empty() && _session.get_record_enabled()) {
 
@@ -1753,18 +1816,14 @@ AudioDiskstream::get_state ()
 		}
 
 		cs_child->add_property (X_("at"), buf);
-		node->add_child_nocopy (*cs_child);
+		node.add_child_nocopy (*cs_child);
 	}
 
-	if (_extra_xml) {
-		node->add_child_copy (*_extra_xml);
-	}
-
-	return* node;
+	return node;
 }
 
 int
-AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
+AudioDiskstream::set_state (const XMLNode& node, int version)
 {
 	const XMLProperty* prop;
 	XMLNodeList nlist = node.children();
@@ -1773,6 +1832,8 @@ AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
 	XMLNode* capture_pending_node = 0;
 	LocaleGuard lg (X_("POSIX"));
 
+	/* prevent write sources from being created */
+
 	in_set_state = true;
 
 	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
@@ -1785,26 +1846,8 @@ AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
 		}
 	}
 
-	/* prevent write sources from being created */
-
-	in_set_state = true;
-
-	if ((prop = node.property ("name")) != 0) {
-		_name = prop->value();
-	}
-
-	if (deprecated_io_node) {
-		if ((prop = deprecated_io_node->property ("id")) != 0) {
-			_id = prop->value ();
-		}
-	} else {
-		if ((prop = node.property ("id")) != 0) {
-			_id = prop->value ();
-		}
-	}
-
-	if ((prop = node.property ("flags")) != 0) {
-		_flags = Flag (string_2_enum (prop->value(), _flags));
+	if (Diskstream::set_state (node, version)) {
+		return -1;
 	}
 
 	if ((prop = node.property ("channels")) != 0) {
@@ -1826,37 +1869,14 @@ AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
 		remove_channel (_n_channels.n_audio() - nchans);
 	}
 
-	if ((prop = node.property ("playlist")) == 0) {
-		return -1;
-	}
-
-	{
-		bool had_playlist = (_playlist != 0);
 
-		if (find_and_use_playlist (prop->value())) {
-			return -1;
-		}
-
-		if (!had_playlist) {
-			_playlist->set_orig_diskstream_id (_id);
-		}
 
-		if (!destructive() && capture_pending_node) {
-			/* destructive streams have one and only one source per channel,
-			   and so they never end up in pending capture in any useful
-			   sense.
-			*/
-			use_pending_capture_data (*capture_pending_node);
-		}
-
-	}
-
-	if ((prop = node.property ("speed")) != 0) {
-		double sp = atof (prop->value().c_str());
-
-		if (realtime_set_speed (sp, false)) {
-			non_realtime_set_speed ();
-		}
+	if (!destructive() && capture_pending_node) {
+		/* destructive streams have one and only one source per channel,
+		   and so they never end up in pending capture in any useful
+		   sense.
+		*/
+		use_pending_capture_data (*capture_pending_node);
 	}
 
 	in_set_state = false;
@@ -1888,14 +1908,9 @@ AudioDiskstream::use_new_write_source (uint32_t n)
 
 	ChannelInfo* chan = (*c)[n];
 
-	if (chan->write_source) {
-		chan->write_source->done_with_peakfile_writes ();
-		chan->write_source->set_allow_remove_if_empty (true);
-		chan->write_source.reset ();
-	}
-
 	try {
-		if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
+		if ((chan->write_source = _session.create_audio_source_for_session (
+			     n_channels().n_audio(), name(), n, destructive())) == 0) {
 			throw failed_constructor();
 		}
 	}
@@ -1909,14 +1924,18 @@ AudioDiskstream::use_new_write_source (uint32_t n)
 	/* do not remove destructive files even if they are empty */
 
 	chan->write_source->set_allow_remove_if_empty (!destructive());
-	
-	/* until we write, this file is considered removable */
-
-	chan->write_source->mark_for_remove ();
 
 	return 0;
 }
 
+list<boost::shared_ptr<Source> >
+AudioDiskstream::steal_write_sources()
+{
+	/* not possible to steal audio write sources */
+	list<boost::shared_ptr<Source> > ret;
+	return ret;
+}
+
 void
 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 {
@@ -1931,11 +1950,24 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 	capturing_sources.clear ();
 
 	for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
+
 		if (!destructive()) {
 
-			if ((*chan)->write_source && mark_write_complete) {
-				(*chan)->write_source->mark_streaming_write_completed ();
+			if ((*chan)->write_source) {
+
+				if (mark_write_complete) {
+					(*chan)->write_source->mark_streaming_write_completed ();
+					(*chan)->write_source->done_with_peakfile_writes ();
+				}
+
+				if ((*chan)->write_source->removable()) {
+					(*chan)->write_source->mark_for_remove ();
+					(*chan)->write_source->drop_references ();
+				}
+
+				(*chan)->write_source.reset ();
 			}
+
 			use_new_write_source (n);
 
 			if (record_enabled()) {
@@ -1943,13 +1975,14 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 			}
 
 		} else {
+
 			if ((*chan)->write_source == 0) {
 				use_new_write_source (n);
 			}
 		}
 	}
 
-	if (destructive()) {
+	if (destructive() && !c->empty ()) {
 
 		/* we now have all our write sources set up, so create the
 		   playlist's single region.
@@ -1961,25 +1994,8 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 	}
 }
 
-int
-AudioDiskstream::rename_write_sources ()
-{
-	ChannelList::iterator chan;
-	boost::shared_ptr<ChannelList> c = channels.reader();
-	uint32_t n;
-
-	for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
-		if ((*chan)->write_source != 0) {
-			(*chan)->write_source->set_source_name (_name.val(), destructive());
-			/* XXX what to do if one of them fails ? */
-		}
-	}
-
-	return 0;
-}
-
 void
-AudioDiskstream::set_block_size (nframes_t /*nframes*/)
+AudioDiskstream::set_block_size (pframes_t /*nframes*/)
 {
 	if (_session.get_block_size() > speed_buffer_size) {
 		speed_buffer_size = _session.get_block_size();
@@ -2002,19 +2018,21 @@ AudioDiskstream::allocate_temporary_buffers ()
 	   when slaving to MTC, Timecode etc.
 	*/
 
-	double sp = max (fabsf (_actual_speed), 1.2f);
-	nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
+	double const sp = max (fabsf (_actual_speed), 1.2f);
+	framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2;
 
 	if (required_wrap_size > wrap_buffer_size) {
 
 		boost::shared_ptr<ChannelList> c = channels.reader();
 
 		for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-			if ((*chan)->playback_wrap_buffer)
+			if ((*chan)->playback_wrap_buffer) {
 				delete [] (*chan)->playback_wrap_buffer;
+			}
 			(*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
-			if ((*chan)->capture_wrap_buffer)
+			if ((*chan)->capture_wrap_buffer) {
 				delete [] (*chan)->capture_wrap_buffer;
+			}
 			(*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
 		}
 
@@ -2023,15 +2041,12 @@ AudioDiskstream::allocate_temporary_buffers ()
 }
 
 void
-AudioDiskstream::monitor_input (bool yn)
+AudioDiskstream::request_input_monitoring (bool yn)
 {
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
 	for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-
-		if ((*chan)->source) {
-			(*chan)->source->ensure_monitor_input (yn);
-		}
+		(*chan)->source.request_input_monitoring (yn);
 	}
 }
 
@@ -2040,6 +2055,10 @@ AudioDiskstream::set_align_style_from_io ()
 {
 	bool have_physical = false;
 
+	if (_alignment_choice != Automatic) {
+		return;
+	}
+
 	if (_io == 0) {
 		return;
 	}
@@ -2049,7 +2068,7 @@ AudioDiskstream::set_align_style_from_io ()
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
 	for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
-		if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
+		if ((*chan)->source.is_physical ()) {
 			have_physical = true;
 			break;
 		}
@@ -2066,8 +2085,13 @@ int
 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
 {
 	while (how_many--) {
-		c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
-		interpolation.add_channel_to (_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size);
+		c->push_back (new ChannelInfo(
+			              _session.butler()->audio_diskstream_playback_buffer_size(),
+			              _session.butler()->audio_diskstream_capture_buffer_size(),
+			              speed_buffer_size, wrap_buffer_size));
+		interpolation.add_channel_to (
+			_session.butler()->audio_diskstream_playback_buffer_size(),
+			speed_buffer_size);
 	}
 
 	_n_channels.set(DataType::AUDIO, c->size());
@@ -2088,9 +2112,7 @@ int
 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
 {
 	while (how_many-- && !c->empty()) {
-		// FIXME: crash (thread safe with RCU?)
-		// memory leak, when disabled.... :(
-		//delete c->back();
+		delete c->back();
 		c->pop_back();
 		interpolation.remove_channel_from ();
 	}
@@ -2114,6 +2136,10 @@ AudioDiskstream::playback_buffer_load () const
 {
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
+	if (c->empty ()) {
+		return 0;
+	}
+
 	return (float) ((double) c->front()->playback_buf->read_space()/
 			(double) c->front()->playback_buf->bufsize());
 }
@@ -2123,6 +2149,10 @@ AudioDiskstream::capture_buffer_load () const
 {
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
+	if (c->empty ()) {
+		return 0;
+	}
+
 	return (float) ((double) c->front()->capture_buf->write_space()/
 			(double) c->front()->capture_buf->bufsize());
 }
@@ -2136,13 +2166,13 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 	boost::shared_ptr<AudioFileSource> fs;
 	boost::shared_ptr<AudioFileSource> first_fs;
 	SourceList pending_sources;
-	nframes_t position;
+	framepos_t position;
 
 	if ((prop = node.property (X_("at"))) == 0) {
 		return -1;
 	}
 
-	if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
+	if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
 		return -1;
 	}
 
@@ -2161,8 +2191,9 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 
 			try {
 				fs = boost::dynamic_pointer_cast<AudioFileSource> (
-						SourceFactory::createWritable (DataType::AUDIO, _session,
-								prop->value(), false, _session.frame_rate()));
+					SourceFactory::createWritable (
+						DataType::AUDIO, _session,
+						prop->value(), false, _session.frame_rate()));
 			}
 
 			catch (failed_constructor& err) {
@@ -2196,10 +2227,17 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 	boost::shared_ptr<AudioRegion> region;
 
 	try {
-		region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
-				pending_sources, 0, first_fs->length(first_fs->timeline_position()),
-				region_name_from_path (first_fs->name(), true), 0,
-				Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
+
+		PropertyList plist;
+
+		plist.add (Properties::start, 0);
+		plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
+		plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
+
+		region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
+
+		region->set_automatic (true);
+		region->set_whole_file (true);
 		region->special_set_position (0);
 	}
 
@@ -2211,20 +2249,6 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 		return -1;
 	}
 
-	try {
-		region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
-				pending_sources, 0, first_fs->length(first_fs->timeline_position()),
-				region_name_from_path (first_fs->name(), true)));
-	}
-
-	catch (failed_constructor& err) {
-		error << string_compose (_("%1: cannot create region from pending capture sources"),
-				  _name)
-		      << endmsg;
-
-		return -1;
-	}
-
 	_playlist->add_region (region, position);
 
 	return 0;
@@ -2248,11 +2272,10 @@ AudioDiskstream::set_non_layered (bool yn)
 int
 AudioDiskstream::set_destructive (bool yn)
 {
-	bool bounce_ignored;
-
 	if (yn != destructive()) {
 
 		if (yn) {
+			bool bounce_ignored;
 			/* requestor should already have checked this and
 			   bounced if necessary and desired
 			*/
@@ -2286,7 +2309,10 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const
 	}
 
 	boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
-	assert (first);
+	if (!first) {
+		requires_bounce = false;
+		return true;
+	}
 
 	/* do the source(s) for the region cover the session start position ? */
 
@@ -2312,10 +2338,48 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const
 	return true;
 }
 
-AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
+void
+AudioDiskstream::adjust_playback_buffering ()
+{
+	boost::shared_ptr<ChannelList> c = channels.reader();
+
+	for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
+		(*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
+	}
+}
+
+void
+AudioDiskstream::adjust_capture_buffering ()
+{
+	boost::shared_ptr<ChannelList> c = channels.reader();
+
+	for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
+		(*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
+	}
+}
+
+bool
+AudioDiskstream::ChannelSource::is_physical () const
+{
+	if (name.empty()) {
+		return false;
+	}
+
+	return AudioEngine::instance()->port_is_physical (name);
+}
+
+void
+AudioDiskstream::ChannelSource::request_input_monitoring (bool yn) const
+{
+	if (name.empty()) {
+		return;
+	}
+
+	return AudioEngine::instance()->request_input_monitoring (name, yn);
+}
+
+AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
 {
-	peak_power = 0.0f;
-	source = 0;
 	current_capture_buffer = 0;
 	current_playback_buffer = 0;
 	curr_capture_cnt = 0;
@@ -2324,8 +2388,8 @@ AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_si
 	playback_wrap_buffer = new Sample[wrap_size];
 	capture_wrap_buffer = new Sample[wrap_size];
 
-	playback_buf = new RingBufferNPT<Sample> (bufsize);
-	capture_buf = new RingBufferNPT<Sample> (bufsize);
+	playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
+	capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
 	capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
 
 	/* touch the ringbuffer buffers, which will cause
@@ -2339,11 +2403,26 @@ AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_si
 	memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
 }
 
+void
+AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
+{
+	delete playback_buf;
+	playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
+	memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
+}
+
+void
+AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
+{
+	delete capture_buf;
+
+	capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
+	memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
+}
+
 AudioDiskstream::ChannelInfo::~ChannelInfo ()
 {
-	if (write_source) {
-		write_source.reset ();
-	}
+	write_source.reset ();
 
 	delete [] speed_buffer;
 	speed_buffer = 0;
@@ -2363,3 +2442,22 @@ AudioDiskstream::ChannelInfo::~ChannelInfo ()
 	delete capture_transition_buf;
 	capture_transition_buf = 0;
 }
+
+
+bool
+AudioDiskstream::set_name (string const & name)
+{
+	Diskstream::set_name (name);
+
+	/* get a new write source so that its name reflects the new diskstream name */
+
+	boost::shared_ptr<ChannelList> c = channels.reader();
+	ChannelList::iterator i;
+	int n = 0;
+
+	for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
+		use_new_write_source (n);
+	}
+
+	return true;
+}