X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=f096a463efe421d2538c4b90124523319777f857;hb=15aa81fe70ce629cddcc75f0a0ddeb0db0d4439b;hp=40411f413321778a9d98a7c592f05de524dd5543;hpb=8687895abba4209a6de8d8a8fc1bda5996f0d875;p=ardour.git

diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index 40411f4133..f096a463ef 100644
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -31,11 +31,10 @@
 #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"
@@ -44,6 +43,7 @@
 #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"
@@ -56,8 +56,10 @@
 #include "ardour/send.h"
 #include "ardour/session.h"
 #include "ardour/source_factory.h"
+#include "ardour/track.h"
 #include "ardour/utils.h"
 #include "ardour/session_playlists.h"
+#include "ardour/route.h"
 
 #include "i18n.h"
 #include <locale.h>
@@ -72,26 +74,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;
@@ -106,10 +103,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.
@@ -117,17 +112,12 @@ 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 ()
 {
 	DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
 
-	notify_callbacks ();
-
 	{
 		RCUWriter<ChannelList> writer (channels);
 		boost::shared_ptr<ChannelList> c = writer.get_copy();
@@ -168,11 +158,11 @@ AudioDiskstream::non_realtime_input_change ()
 	{
 		Glib::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();
 
@@ -185,17 +175,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 */
 	}
@@ -207,19 +193,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);
 	}
@@ -240,15 +226,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];
 		}
 	}
 }
@@ -298,7 +281,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 {
@@ -325,8 +307,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;
@@ -345,7 +326,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());
 }
 
@@ -373,7 +361,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;
@@ -393,21 +381,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;
@@ -416,57 +403,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 (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
 {
 	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::Mutex::Lock sm (state_lock, Glib::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) {
@@ -474,15 +448,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;
+	}
 
-		calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
+	if (record_enabled()) {
+
+		OverlapType ot = 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;
@@ -490,12 +466,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();
 
@@ -512,7 +487,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];
 
@@ -520,26 +495,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 = ap->get_audio_buffer (nframes).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 = ap->get_audio_buffer(nframes).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);
@@ -553,7 +529,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);
 		}
 
 	}
@@ -583,7 +559,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*/
 
@@ -598,16 +574,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) floor ((nframes * fabs (_actual_speed))) + 1;
 		} else {
 			necessary_samples = nframes;
 		}
@@ -618,28 +594,41 @@ 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.
+					*/
+
+					/* 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])
@@ -651,53 +640,35 @@ 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 (ret) {
-
-		/* we're exiting with failure, so ::commit will not
-		   be called. unlock the state lock.
-		*/
-
-		commit_should_unlock = false;
-		state_lock.unlock();
-	}
-
-	return ret;
-}
-
-void
-AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
-{
-	ChannelList::iterator chan;
-
-	interpolation.set_speed (_target_speed);
-
-	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);
-
-		chaninfo->current_playback_buffer = chaninfo->speed_buffer;
-	}
+	return 0;
 }
 
+/** 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;
 
@@ -726,6 +697,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;
@@ -734,19 +709,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;
 }
 
@@ -755,16 +724,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;
@@ -773,21 +751,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).
@@ -800,11 +780,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;
 		}
 
@@ -812,10 +792,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;
 			}
 		}
@@ -824,14 +803,14 @@ 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;
@@ -864,13 +843,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;
 		}
 	}
@@ -878,7 +857,7 @@ 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();
@@ -887,28 +866,39 @@ AudioDiskstream::internal_playback_seek (nframes_t distance)
 		(*chan)->playback_buf->increment_read_ptr (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
@@ -928,25 +918,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;
@@ -960,13 +949,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);
@@ -1003,19 +990,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;
@@ -1032,6 +1022,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;
 	}
 
@@ -1040,7 +1031,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;
 	}
 
@@ -1049,6 +1040,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) {
@@ -1060,7 +1055,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;
 	}
 
@@ -1095,7 +1090,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
 			zero_fill = total_space - file_frame;
 			total_space = file_frame;
-			file_frame = 0;
 
 		} else {
 
@@ -1104,7 +1098,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 */
 
@@ -1121,30 +1115,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:
@@ -1178,9 +1172,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;
 			}
@@ -1197,7 +1193,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;
 			}
@@ -1206,12 +1202,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:
 
@@ -1235,9 +1232,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;
@@ -1270,7 +1265,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
@@ -1278,7 +1273,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) {
@@ -1290,9 +1284,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
 
@@ -1326,7 +1318,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;
 		}
 
@@ -1340,15 +1332,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;
 		}
@@ -1359,13 +1349,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;
@@ -1374,7 +1364,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.
@@ -1434,8 +1424,9 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 		if (s) {
 			srcs.push_back (s);
 			s->update_header (capture_info.front()->start, when, twhen);
-			s->set_captured_for (_name);
+			s->set_captured_for (_name.val());
 			s->mark_immutable ();
+
 			if (Config->get_auto_analyse_audio()) {
 				Analyser::queue_source_for_analysis (s, true);
 			}
@@ -1452,7 +1443,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 		   process. this problem is deferred to the UI.
 		 */
 
-		_playlist->Modified();
+		_playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
 
 	} else {
 
@@ -1466,10 +1457,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);
@@ -1481,23 +1476,31 @@ 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->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);
 			}
 
@@ -1506,11 +1509,16 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 				continue; /* XXX is this OK? */
 			}
 
-			region->GoingAway.connect (sigc::bind (sigc::mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
+			i_am_the_modifier++;
 
-			_last_capture_regions.push_back (region);
+			if (_playlist->explicit_relayering()) {
+				/* We are in `explicit relayering' mode, so we must specify which layer this new region
+				   should end up on.  Put it at the top.
+				*/
+				region->set_layer (_playlist->top_layer() + 1);
+				region->set_pending_explicit_relayer (true);
+			}
 
-			i_am_the_modifier++;
 			_playlist->add_region (region, (*ci)->start, 1, non_layered());
 			i_am_the_modifier--;
 
@@ -1518,8 +1526,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 		}
 
 		_playlist->thaw ();
-		XMLNode &after = _playlist->get_state();
-		_session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+		_session.add_command (new StatefulDiffCommand (_playlist));
 	}
 
 	mark_write_completed = true;
@@ -1538,7 +1545,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
@@ -1556,14 +1563,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()) {
@@ -1589,9 +1596,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;
@@ -1636,7 +1645,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
@@ -1677,9 +1686,7 @@ AudioDiskstream::engage_record_enable ()
 	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_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
 			capturing_sources.push_back ((*chan)->write_source);
 			(*chan)->write_source->mark_streaming_write_started ();
 		}
@@ -1701,9 +1708,7 @@ AudioDiskstream::disengage_record_enable ()
 	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_jack_monitors_input (false);
 		}
 	}
 	capturing_sources.clear ();
@@ -1713,24 +1718,13 @@ AudioDiskstream::disengage_record_enable ()
 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()) {
 
@@ -1754,18 +1748,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();
@@ -1774,6 +1764,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) {
@@ -1786,26 +1778,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) {
@@ -1827,37 +1801,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;
@@ -1889,14 +1840,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();
 		}
 	}
@@ -1910,14 +1856,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*/)
 {
@@ -1932,11 +1882,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()) {
@@ -1944,13 +1907,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.
@@ -1962,25 +1926,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, 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();
@@ -2003,19 +1950,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) floor (_session.get_block_size() * sp) + 1;
 
 	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];
 		}
 
@@ -2029,10 +1978,7 @@ AudioDiskstream::monitor_input (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_jack_monitors_input (yn);
 	}
 }
 
@@ -2041,6 +1987,10 @@ AudioDiskstream::set_align_style_from_io ()
 {
 	bool have_physical = false;
 
+	if (_alignment_choice != Automatic) {
+		return;
+	}
+
 	if (_io == 0) {
 		return;
 	}
@@ -2050,7 +2000,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;
 		}
@@ -2067,8 +2017,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());
@@ -2089,9 +2044,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 ();
 	}
@@ -2115,6 +2068,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());
 }
@@ -2124,6 +2081,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());
 }
@@ -2137,13 +2098,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;
 	}
 
@@ -2162,8 +2123,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(), string(), false, _session.frame_rate()));
 			}
 
 			catch (failed_constructor& err) {
@@ -2179,7 +2141,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 				first_fs = fs;
 			}
 
-			fs->set_captured_for (_name);
+			fs->set_captured_for (_name.val());
 		}
 	}
 
@@ -2197,10 +2159,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);
 	}
 
@@ -2212,20 +2181,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;
@@ -2249,11 +2204,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
 			*/
@@ -2287,7 +2241,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 ? */
 
@@ -2313,10 +2270,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_jack_monitors_input (bool yn) const
+{
+	if (name.empty()) {
+		return;
+	}
+
+	return AudioEngine::instance()->request_jack_monitors_input (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;
@@ -2325,8 +2320,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
@@ -2340,11 +2335,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;
@@ -2364,3 +2374,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;
+}