X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_diskstream.cc;h=0ec17bc3aad0a2ccb7970b588dc563f9b1e946a5;hb=0bee288b5d6c6ca1fb33b8bc3b584c6d2c3d3364;hp=836fb05c8b2ff3d9b8a85c7df0b0eaae95213f19;hpb=17088ee3ea5af1e6174b098bb5bcfdaec6ebf9b0;p=ardour.git

diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc
index 836fb05c8b..0ec17bc3aa 100644
--- a/libs/ardour/midi_diskstream.cc
+++ b/libs/ardour/midi_diskstream.cc
@@ -36,6 +36,7 @@
 #include "pbd/memento_command.h"
 #include "pbd/enumwriter.h"
 #include "pbd/stateful_diff_command.h"
+#include "pbd/stacktrace.h"
 
 #include "ardour/ardour.h"
 #include "ardour/audioengine.h"
@@ -55,6 +56,7 @@
 #include "ardour/smf_source.h"
 #include "ardour/utils.h"
 #include "ardour/session_playlists.h"
+#include "ardour/route.h"
 
 #include "midi++/types.h"
 
@@ -65,7 +67,7 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-nframes_t MidiDiskstream::midi_readahead = 4096;
+framecnt_t MidiDiskstream::midi_readahead = 4096;
 
 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
 	: Diskstream(sess, name, flag)
@@ -81,8 +83,9 @@ MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::F
 
 	in_set_state = true;
 
-	init(flag);
+	init ();
 	use_new_playlist ();
+	use_new_write_source (0);
 
 	in_set_state = false;
 
@@ -100,25 +103,22 @@ MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
 	, _frames_read_from_ringbuffer(0)
 {
 	in_set_state = true;
-	init (Recordable);
+
+	init ();
 
 	if (set_state (node, Stateful::loading_state_version)) {
 		in_set_state = false;
 		throw failed_constructor();
 	}
 
-	in_set_state = false;
+	use_new_write_source (0);
 
-	if (destructive()) {
-		use_destructive_playlist ();
-	}
+	in_set_state = false;
 }
 
 void
-MidiDiskstream::init (Diskstream::Flag f)
+MidiDiskstream::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.
@@ -128,8 +128,8 @@ MidiDiskstream::init (Diskstream::Flag f)
 	allocate_temporary_buffers ();
 
 	const size_t size = _session.butler()->midi_diskstream_buffer_size();
-	_playback_buf = new MidiRingBuffer<nframes_t>(size);
-	_capture_buf = new MidiRingBuffer<nframes_t>(size);
+	_playback_buf = new MidiRingBuffer<framepos_t>(size);
+	_capture_buf = new MidiRingBuffer<framepos_t>(size);
 
 	_n_channels = ChanCount(DataType::MIDI, 1);
 
@@ -143,7 +143,7 @@ MidiDiskstream::~MidiDiskstream ()
 
 
 void
-MidiDiskstream::non_realtime_locate (nframes_t position)
+MidiDiskstream::non_realtime_locate (framepos_t position)
 {
 	if (_write_source) {
 		_write_source->set_timeline_position (position);
@@ -158,11 +158,11 @@ MidiDiskstream::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 & ConfigurationChanged) {
+		if (input_change_pending.type & IOChange::ConfigurationChanged) {
 			if (_io->n_ports().n_midi() != _n_channels.n_midi()) {
 				error << "Can not feed IO " << _io->n_ports()
 					<< " with diskstream " << _n_channels << endl;
@@ -179,19 +179,20 @@ MidiDiskstream::non_realtime_input_change ()
 			set_align_style_from_io ();
 		}
 
-		input_change_pending = NoChange;
+		input_change_pending.type = IOChange::NoChange;
 
 		/* implicit unlock */
 	}
 
-	/* reset capture files */
-
-	reset_write_sources (false);
+	/* unlike with audio, there is never any need to reset write sources
+	   based on input configuration changes because ... a MIDI track
+	   has just 1 MIDI port as input, always.
+	*/
 
 	/* 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());
@@ -374,7 +375,7 @@ trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 		o << trace_prefix
 		   << "Channel "
 		   << (msg[0]&0xF)+1
-		   <<  " Program PropertyChange ProgNum "
+		   <<  " Program Change ProgNum "
 		   << (int) msg[1]
 		   << endl;
 		break;
@@ -487,50 +488,33 @@ trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 #endif
 
 int
-MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
+MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
 {
 	int       ret = -1;
-	nframes_t rec_offset = 0;
-	nframes_t rec_nframes = 0;
+	framecnt_t rec_offset = 0;
+	framecnt_t rec_nframes = 0;
 	bool      nominally_recording;
 	bool      re = record_enabled ();
 
-	/* 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;
 
-	check_record_status (transport_frame, nframes, can_record);
+	check_record_status (transport_frame, can_record);
 
 	nominally_recording = (can_record && re);
 
 	if (nframes == 0) {
-		_processed = true;
 		return 0;
 	}
 
-	/* This lock is held until the end of ::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;
 
-	if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
+	if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
 		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);
@@ -542,8 +526,8 @@ MidiDiskstream::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) {
@@ -556,6 +540,16 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 			_capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
 		}
 
+		if (buf.size() != 0) {
+			/* Make a copy of this data and emit it for the GUI to see */
+			boost::shared_ptr<MidiBuffer> copy (new MidiBuffer (buf.capacity ()));
+			for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
+				copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
+			}
+
+			DataRecorded (copy, _write_source); /* EMIT SIGNAL */
+		}
+
 	} else {
 
 		if (was_recording) {
@@ -586,23 +580,15 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 
 	ret = 0;
 
-	_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();
+	if (commit (nframes)) {
+		need_butler = true;
 	}
 
 	return ret;
 }
 
 bool
-MidiDiskstream::commit (nframes_t nframes)
+MidiDiskstream::commit (framecnt_t nframes)
 {
 	bool need_butler = false;
 
@@ -627,12 +613,6 @@ MidiDiskstream::commit (nframes_t nframes)
 		" = " << frames_written - frames_read
 		<< " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
 
-	if (commit_should_unlock) {
-		state_lock.unlock();
-	}
-
-	_processed = false;
-
 	return need_butler;
 }
 
@@ -641,7 +621,7 @@ MidiDiskstream::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;
 }
@@ -649,15 +629,21 @@ MidiDiskstream::set_pending_overwrite (bool yn)
 int
 MidiDiskstream::overwrite_existing_buffers ()
 {
-	//read(overwrite_frame, disk_io_chunk_frames, false);
+	/* This is safe as long as the butler thread is suspended, which it should be */
+	_playback_buf->reset ();
+
+	g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
+	g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
+
+	read (overwrite_frame, disk_io_chunk_frames, false);
 	overwrite_queued = false;
-	pending_overwrite = false;
+	_pending_overwrite = false;
 
 	return 0;
 }
 
 int
-MidiDiskstream::seek (nframes_t frame, bool complete_refill)
+MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 {
 	Glib::Mutex::Lock lm (state_lock);
 	int ret = -1;
@@ -680,7 +666,7 @@ MidiDiskstream::seek (nframes_t frame, bool complete_refill)
 }
 
 int
-MidiDiskstream::can_internal_playback_seek (nframes_t distance)
+MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 {
 	uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 	uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
@@ -688,7 +674,7 @@ MidiDiskstream::can_internal_playback_seek (nframes_t distance)
 }
 
 int
-MidiDiskstream::internal_playback_seek (nframes_t distance)
+MidiDiskstream::internal_playback_seek (framecnt_t distance)
 {
 	first_recordable_frame += distance;
 	playback_sample += distance;
@@ -698,17 +684,17 @@ MidiDiskstream::internal_playback_seek (nframes_t distance)
 
 /** @a start is set to the new frame position (TIME) read up to */
 int
-MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
+MidiDiskstream::read (framepos_t& start, framecnt_t dur, 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;
+	framepos_t loop_end = 0;
+	framepos_t loop_start = 0;
 	Location *loc = 0;
 
 	if (!reversed) {
 
-		nframes_t loop_length = 0;
+		framecnt_t loop_length = 0;
 
 		/* Make the use of a Location atomic for this read operation.
 
@@ -779,10 +765,7 @@ MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
 			if (reloop) {
 				// Synthesize LoopEvent here, because the next events
 				// written will have non-monotonic timestamps.
-				_playback_buf->write(loop_end - 1, LoopEventType, 0, 0);
-				cout << "Pushing LoopEvent ts=" << loop_end-1
-				     << " start+this_read " << start+this_read << endl;
-
+				_playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
 				start = loop_start;
 			} else {
 				start += this_read;
@@ -818,13 +801,13 @@ MidiDiskstream::do_refill ()
 	}
 
 	/* at end: nothing to do */
-	if (file_frame == max_frames) {
+	if (file_frame == max_framepos) {
 		return 0;
 	}
 
 	// At this point we...
 	assert(_playback_buf->write_space() > 0); // ... have something to write to, and
-	assert(file_frame <= max_frames); // ... something to write
+	assert(file_frame <= max_framepos); // ... something to write
 
 	// now calculate how much time is in the ringbuffer.
 	// and lets write as much as we need to get this to be midi_readahead;
@@ -835,12 +818,12 @@ MidiDiskstream::do_refill ()
 		return 0;
 	}
 
-	nframes_t to_read = midi_readahead - (frames_written - frames_read);
+	framecnt_t to_read = midi_readahead - (frames_written - frames_read);
 
 	//cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 	//	<< frames_written - frames_read << endl;
 
-	to_read = min(to_read, (max_frames - file_frame));
+	to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 
 	if (read (file_frame, to_read, reversed)) {
 		ret = -1;
@@ -864,14 +847,13 @@ MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 {
 	uint32_t to_write;
 	int32_t ret = 0;
-	nframes_t total;
+	framecnt_t total;
 
 	_write_data_count = 0;
 
 	total = _session.transport_frame() - _last_flush_frame;
 
-	if (_last_flush_frame > _session.transport_frame()
-			|| _last_flush_frame < capture_start_frame) {
+	if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) {
 		_last_flush_frame = _session.transport_frame();
 	}
 
@@ -899,10 +881,10 @@ MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 
 	assert(!destructive());
 
-	if (record_enabled()
-			&& (   (_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames)
-				|| force_flush)) {
-		if ((!_write_source) || _write_source->midi_write (*_capture_buf, capture_start_frame, to_write) != to_write) {
+	if (record_enabled() &&
+            ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
+             force_flush)) {
+		if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
 			error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
 			return -1;
 		} else {
@@ -915,7 +897,7 @@ out:
 }
 
 void
-MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
+MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 {
 	bool more_work = true;
 	int err = 0;
@@ -933,14 +915,14 @@ MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool a
 
 	while (more_work && !err) {
 		switch (do_flush (TransportContext, true)) {
-			case 0:
-				more_work = false;
-				break;
-			case 1:
-				break;
-			case -1:
-				error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
-				err++;
+		case 0:
+			more_work = false;
+			break;
+		case 1:
+			break;
+		case -1:
+			error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
+			err++;
 		}
 	}
 
@@ -954,9 +936,7 @@ MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool a
 	if (abort_capture) {
 
 		if (_write_source) {
-
 			_write_source->mark_for_remove ();
-			_write_source->drop_references ();
 			_write_source.reset();
 		}
 
@@ -966,101 +946,129 @@ MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool a
 
 		assert(_write_source);
 
-		nframes_t total_capture = 0;
+		framecnt_t total_capture = 0;
 		for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 			total_capture += (*ci)->frames;
 		}
 
-		/* figure out the name for this take */
-
-		srcs.push_back (_write_source);
-		_write_source->set_timeline_position (capture_info.front()->start);
-		_write_source->set_captured_for (_name);
-
-		string whole_file_region_name;
-		whole_file_region_name = region_name_from_path (_write_source->name(), true);
+		if (_write_source->length (capture_info.front()->start) != 0) {
 
-		/* Register a new region with the Session that
-		   describes the entire source. Do this first
-		   so that any sub-regions will obviously be
-		   children of this one (later!)
-		   */
-
-		try {
-			PropertyList plist;
+			/* phew, we have data */
 
-			plist.add (Properties::name, whole_file_region_name);
-			plist.add (Properties::whole_file, true);
-			plist.add (Properties::automatic, true);
-			plist.add (Properties::start, 0);
-			plist.add (Properties::length, total_capture);
-			plist.add (Properties::layer, 0);
+			/* figure out the name for this take */
 
-			boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+			srcs.push_back (_write_source);
 
-			region = boost::dynamic_pointer_cast<MidiRegion> (rx);
-			region->special_set_position (capture_info.front()->start);
-		}
+			_write_source->set_timeline_position (capture_info.front()->start);
+			_write_source->set_captured_for (_name);
 
+			/* flush to disk: this step differs from the audio path,
+			   where all the data is already on disk.
+			*/
 
-		catch (failed_constructor& err) {
-			error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
-			/* XXX what now? */
-		}
+			_write_source->mark_streaming_write_completed ();
 
-		_last_capture_regions.push_back (region);
+			/* set length in beats to entire capture length */
 
-		// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
+			BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
+			const double total_capture_beats = converter.from(total_capture);
+			_write_source->set_length_beats(total_capture_beats);
 
-		_playlist->clear_history ();
-		_playlist->freeze ();
+			/* make it not a stub anymore */
 
-		uint32_t buffer_position = 0;
-		for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+			_write_source->unstubify ();
 
-			string region_name;
+			/* we will want to be able to keep (over)writing the source
+			   but we don't want it to be removable. this also differs
+			   from the audio situation, where the source at this point
+			   must be considered immutable. luckily, we can rely on
+			   MidiSource::mark_streaming_write_completed() to have
+			   already done the necessary work for that.
+			*/
 
-			_session.region_name (region_name, _write_source->name(), false);
+			string whole_file_region_name;
+			whole_file_region_name = region_name_from_path (_write_source->name(), true);
 
-			// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
+			/* Register a new region with the Session that
+			   describes the entire source. Do this first
+			   so that any sub-regions will obviously be
+			   children of this one (later!)
+			*/
 
 			try {
 				PropertyList plist;
-				
-				plist.add (Properties::start, buffer_position);
-				plist.add (Properties::length, (*ci)->frames);
-				plist.add (Properties::name, region_name);
-				
+
+				plist.add (Properties::name, whole_file_region_name);
+				plist.add (Properties::whole_file, true);
+				plist.add (Properties::automatic, true);
+				plist.add (Properties::start, 0);
+				plist.add (Properties::length, total_capture);
+				plist.add (Properties::layer, 0);
+
 				boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+
 				region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+				region->special_set_position (capture_info.front()->start);
 			}
 
+
 			catch (failed_constructor& err) {
-				error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
-				continue; /* XXX is this OK? */
+				error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
+				/* XXX what now? */
+			}
+
+			_last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
+
+			_playlist->clear_changes ();
+			_playlist->freeze ();
+
+			/* Session frame time of the initial capture in this pass, which is where the source starts */
+			framepos_t initial_capture = 0;
+			if (!capture_info.empty()) {
+				initial_capture = capture_info.front()->start;
 			}
 
-			region->DropReferences.connect_same_thread (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
+			for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 
-			_last_capture_regions.push_back (region);
+				string region_name;
 
-			// cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
+				RegionFactory::region_name (region_name, _write_source->name(), false);
 
-			i_am_the_modifier++;
-			_playlist->add_region (region, (*ci)->start);
-			i_am_the_modifier--;
+				// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
 
-			buffer_position += (*ci)->frames;
-		}
+				try {
+					PropertyList plist;
 
-		_playlist->thaw ();
-		_session.add_command (new StatefulDiffCommand(_playlist));
+					/* start of this region is the offset between the start of its capture and the start of the whole pass */
+					plist.add (Properties::start, (*ci)->start - initial_capture);
+					plist.add (Properties::length, (*ci)->frames);
+					plist.add (Properties::length_beats, converter.from((*ci)->frames));
+					plist.add (Properties::name, region_name);
 
-	}
+					boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+					region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+				}
+
+				catch (failed_constructor& err) {
+					error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
+					continue; /* XXX is this OK? */
+				}
 
-	mark_write_completed = true;
+				// cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
+
+				i_am_the_modifier++;
+				_playlist->add_region (region, (*ci)->start);
+				i_am_the_modifier--;
+			}
+
+			_playlist->thaw ();
+			_session.add_command (new StatefulDiffCommand(_playlist));
+		}
+
+		mark_write_completed = true;
+	}
 
-	reset_write_sources (mark_write_completed);
+	use_new_write_source (0);
 
 	for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 		delete *ci;
@@ -1075,7 +1083,7 @@ MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool a
 }
 
 void
-MidiDiskstream::transport_looped (nframes_t transport_frame)
+MidiDiskstream::transport_looped (framepos_t transport_frame)
 {
 	if (was_recording) {
 
@@ -1098,7 +1106,7 @@ MidiDiskstream::transport_looped (nframes_t transport_frame)
 		// 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;
 	}
 }
@@ -1160,7 +1168,7 @@ MidiDiskstream::set_record_enabled (bool yn)
 void
 MidiDiskstream::engage_record_enable ()
 {
-    bool rolling = _session.transport_speed() != 0.0f;
+	bool const rolling = _session.transport_speed() != 0.0f;
 
 	g_atomic_int_set (&_record_enabled, 1);
 
@@ -1168,12 +1176,6 @@ MidiDiskstream::engage_record_enable ()
 		_source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
 	}
 
-	// FIXME: Why is this necessary?  Isn't needed for AudioDiskstream...
-	if (!_write_source)
-		use_new_write_source();
-
-	_write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
-
 	RecordEnableChanged (); /* EMIT SIGNAL */
 }
 
@@ -1193,7 +1195,7 @@ MidiDiskstream::disengage_record_enable ()
 XMLNode&
 MidiDiskstream::get_state ()
 {
-	XMLNode* node = new XMLNode ("MidiDiskstream");
+	XMLNode* node = new XMLNode ("Diskstream");
 	char buf[64];
 	LocaleGuard lg (X_("POSIX"));
 
@@ -1309,7 +1311,7 @@ MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
 		}
 
 		if (!had_playlist) {
-			_playlist->set_orig_diskstream_id (_id);
+			_playlist->set_orig_diskstream_id (id());
 		}
 
 		if (capture_pending_node) {
@@ -1328,41 +1330,29 @@ MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
 
 	in_set_state = false;
 
-	/* make sure this is clear before we do anything else */
-
-	// FIXME?
-	//_capturing_source = 0;
-
-	/* write sources are handled when we handle the input set
-	   up of the IO that owns this DS (::non_realtime_input_change())
-	*/
-
-	in_set_state = false;
-
 	return 0;
 }
 
 int
 MidiDiskstream::use_new_write_source (uint32_t n)
 {
-	if (!recordable()) {
+	if (!_session.writable() || !recordable()) {
 		return 1;
 	}
 
 	assert(n == 0);
 
-	if (_write_source) {
-
-		if (_write_source->is_empty ()) {
-			_write_source->mark_for_remove ();
-			_write_source.reset();
-		} else {
-			_write_source.reset();
-		}
-	}
+	_write_source.reset();
 
 	try {
-		_write_source = boost::dynamic_pointer_cast<SMFSource>(_session.create_midi_source_for_session (*this));
+		/* file starts off as a stub file, it will be converted
+		   when we're done with a capture pass, or when "stolen"
+		   by the GUI.
+		*/
+
+		_write_source = boost::dynamic_pointer_cast<SMFSource>(
+			_session.create_midi_source_for_session (0, name (), true));
+
 		if (!_write_source) {
 			throw failed_constructor();
 		}
@@ -1374,12 +1364,38 @@ MidiDiskstream::use_new_write_source (uint32_t n)
 		return -1;
 	}
 
-	_write_source->set_allow_remove_if_empty (true);
 	_write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
 
 	return 0;
 }
 
+list<boost::shared_ptr<Source> >
+MidiDiskstream::steal_write_sources()
+{
+	list<boost::shared_ptr<Source> > ret;
+
+	/* put some data on the disk, even if its just a header for an empty file.
+	   XXX should we not have a more direct method for doing this? Maybe not
+	   since we don't want to mess around with the model/disk relationship
+	   that the Source has to pay attention to.
+	*/
+
+	boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
+
+	/* make it visible/present */
+	_write_source->unstubify ();
+	/* never let it go away */
+	_write_source->mark_nonremovable ();
+
+	ret.push_back (_write_source);
+
+	/* get a new one */
+
+	use_new_write_source (0);
+
+	return ret;
+}
+
 void
 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 {
@@ -1390,7 +1406,6 @@ MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 	if (_write_source && mark_write_complete) {
 		_write_source->mark_streaming_write_completed ();
 	}
-
 	use_new_write_source (0);
 }
 
@@ -1405,7 +1420,7 @@ MidiDiskstream::rename_write_sources ()
 }
 
 void
-MidiDiskstream::set_block_size (nframes_t /*nframes*/)
+MidiDiskstream::set_block_size (pframes_t /*nframes*/)
 {
 }
 
@@ -1468,7 +1483,7 @@ MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
  * so that an event at \a start has time = 0
  */
 void
-MidiDiskstream::get_playback (MidiBuffer& dst, nframes_t start, nframes_t end)
+MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
 {
 	dst.clear();
 	assert(dst.size() == 0);