X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_diskstream.cc;h=f06b00ae007f7ef7b1843020aec2839042990474;hb=ff122d0fe8fde6a8a4edc71f9dbba5d161036300;hp=f8d9f1eb580f903e8e626f7ff04127ca01939244;hpb=7183242b8c8d9296f94a035fb66b1eae06fd3496;p=ardour.git

diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc
index f8d9f1eb58..f06b00ae00 100644
--- a/libs/ardour/midi_diskstream.cc
+++ b/libs/ardour/midi_diskstream.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2003 Paul Davis 
+    Copyright (C) 2000-2003 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -38,8 +38,10 @@
 
 #include "ardour/ardour.h"
 #include "ardour/audioengine.h"
+#include "ardour/butler.h"
 #include "ardour/configuration.h"
 #include "ardour/cycle_timer.h"
+#include "ardour/debug.h"
 #include "ardour/io.h"
 #include "ardour/midi_diskstream.h"
 #include "ardour/midi_playlist.h"
@@ -52,6 +54,8 @@
 #include "ardour/smf_source.h"
 #include "ardour/utils.h"
 
+#include "midi++/types.h"
+
 #include "i18n.h"
 #include <locale.h>
 
@@ -82,7 +86,7 @@ MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::F
 
 	assert(!destructive());
 }
-	
+
 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
 	: Diskstream(sess, node)
 	, _playback_buf(0)
@@ -96,7 +100,7 @@ MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
 	in_set_state = true;
 	init (Recordable);
 
-	if (set_state (node)) {
+	if (set_state (node, Stateful::loading_state_version)) {
 		in_set_state = false;
 		throw failed_constructor();
 	}
@@ -121,10 +125,10 @@ MidiDiskstream::init (Diskstream::Flag f)
 	set_block_size (_session.get_block_size());
 	allocate_temporary_buffers ();
 
-	const size_t size = _session.midi_diskstream_buffer_size();
+	const size_t size = _session.butler()->midi_diskstream_buffer_size();
 	_playback_buf = new MidiRingBuffer<nframes_t>(size);
 	_capture_buf = new MidiRingBuffer<nframes_t>(size);
-	
+
 	_n_channels = ChanCount(DataType::MIDI, 1);
 
 	assert(recordable());
@@ -135,7 +139,7 @@ MidiDiskstream::~MidiDiskstream ()
 	Glib::Mutex::Lock lm (state_lock);
 }
 
-	
+
 void
 MidiDiskstream::non_realtime_locate (nframes_t position)
 {
@@ -149,7 +153,7 @@ MidiDiskstream::non_realtime_locate (nframes_t position)
 void
 MidiDiskstream::non_realtime_input_change ()
 {
-	{ 
+	{
 		Glib::Mutex::Lock lm (state_lock);
 
 		if (input_change_pending == NoChange) {
@@ -157,11 +161,11 @@ MidiDiskstream::non_realtime_input_change ()
 		}
 
 		if (input_change_pending & ConfigurationChanged) {
-			if (_io->n_inputs().n_midi() != _n_channels.n_midi()) {
-				error << "Can not feed IO " << _io->n_inputs()
+			if (_io->n_ports().n_midi() != _n_channels.n_midi()) {
+				error << "Can not feed IO " << _io->n_ports()
 					<< " with diskstream " << _n_channels << endl;
 			}
-		} 
+		}
 
 		get_input_sources ();
 		set_capture_offset ();
@@ -174,7 +178,7 @@ MidiDiskstream::non_realtime_input_change ()
 		}
 
 		input_change_pending = NoChange;
-		
+
 		/* implicit unlock */
 	}
 
@@ -197,7 +201,7 @@ MidiDiskstream::non_realtime_input_change ()
 void
 MidiDiskstream::get_input_sources ()
 {
-	uint32_t ni = _io->n_inputs().n_midi();
+	uint32_t ni = _io->n_ports().n_midi();
 
 	if (ni == 0) {
 		return;
@@ -206,16 +210,16 @@ MidiDiskstream::get_input_sources ()
 	// This is all we do for now at least
 	assert(ni == 1);
 
-	_source_port = _io->midi_input(0);
+	_source_port = _io->midi(0);
 
 	// do... stuff?
-}		
+}
 
 int
 MidiDiskstream::find_and_use_playlist (const string& name)
 {
 	boost::shared_ptr<MidiPlaylist> playlist;
-		
+
 	if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlist_by_name (name))) == 0) {
 		playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
 	}
@@ -230,7 +234,7 @@ MidiDiskstream::find_and_use_playlist (const string& name)
 
 int
 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
-{	
+{
 	assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
 
 	Diskstream::use_playlist(playlist);
@@ -240,7 +244,7 @@ MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 
 int
 MidiDiskstream::use_new_playlist ()
-{	
+{
 	string newname;
 	boost::shared_ptr<MidiPlaylist> playlist;
 
@@ -256,11 +260,11 @@ MidiDiskstream::use_new_playlist ()
 
 	if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
 			DataType::MIDI, _session, newname, hidden()))) != 0) {
-		
+
 		playlist->set_orig_diskstream_id (id());
 		return use_playlist (playlist);
 
-	} else { 
+	} else {
 		return -1;
 	}
 }
@@ -283,11 +287,11 @@ MidiDiskstream::use_copy_playlist ()
 	boost::shared_ptr<MidiPlaylist> playlist;
 
 	newname = Playlist::bump_name (_playlist->name(), _session);
-	
+
 	if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
 		playlist->set_orig_diskstream_id (id());
 		return use_playlist (playlist);
-	} else { 
+	} else {
 		return -1;
 	}
 }
@@ -301,7 +305,7 @@ MidiDiskstream::set_destructive (bool yn)
 	assert( ! yn);
 	return -1;
 }
-	
+
 void
 MidiDiskstream::set_note_mode (NoteMode m)
 {
@@ -311,124 +315,183 @@ MidiDiskstream::set_note_mode (NoteMode m)
 		_write_source->model()->set_note_mode(m);
 }
 
-void
-MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+#if 0
+static void
+trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 {
-	// FIXME: waaay too much code to duplicate (AudioDiskstream)
-	
-	int possibly_recording;
-	int rolling;
-	int change;
-	const int transport_rolling = 0x4;
-	const int track_rec_enabled = 0x2;
-	const int global_rec_enabled = 0x1;
-
-	/* merge together the 3 factors that affect record status, and compute
-	   what has changed.
-	*/
-
-	rolling = _session.transport_speed() != 0.0f;
-	possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
-	change = possibly_recording ^ last_possibly_recording;
-
-	if (possibly_recording == last_possibly_recording) {
-		return;
-	}
-
-	/* change state */
-
-	/* if per-track or global rec-enable turned on while the other was already on, we've started recording */
-
-	if (((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record)) || 
-	    ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
-		
-		/* starting to record: compute first+last frames */
-
-		first_recordable_frame = transport_frame + _capture_offset;
-		last_recordable_frame = max_frames;
-		capture_start_frame = transport_frame;
-
-		if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
-
-			/* was stopped, now rolling (and recording) */
-
-			if (_alignment_style == ExistingMaterial) {
-				first_recordable_frame += _session.worst_output_latency();
-			} else {
-				first_recordable_frame += _roll_delay;
-  			}
-		
+	using namespace MIDI;
+	eventType type;
+	const char trace_prefix = ':';
+
+	type = (eventType) (msg[0]&0xF0);
+
+	switch (type) {
+	case off:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " NoteOff NoteNum "
+		   << (int) msg[1]
+		   << " Vel "
+		   << (int) msg[2]
+		   << endl;
+		break;
+
+	case on:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " NoteOn NoteNum "
+		   << (int) msg[1]
+		   << " Vel "
+		   << (int) msg[2]
+		   << endl;
+		break;
+
+	case polypress:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " PolyPressure"
+		   << (int) msg[1]
+		   << endl;
+		break;
+
+	case MIDI::controller:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " Controller "
+		   << (int) msg[1]
+		   << " Value "
+		   << (int) msg[2]
+		   << endl;
+		break;
+
+	case program:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   <<  " Program Change ProgNum "
+		   << (int) msg[1]
+		   << endl;
+		break;
+
+	case chanpress:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " Channel Pressure "
+		   << (int) msg[1]
+		   << endl;
+		break;
+
+	case MIDI::pitchbend:
+		o << trace_prefix
+		   << "Channel "
+		   << (msg[0]&0xF)+1
+		   << " Pitch Bend "
+		   << ((msg[2]<<7)|msg[1])
+		   << endl;
+		break;
+
+	case MIDI::sysex:
+		if (len == 1) {
+			switch (msg[0]) {
+			case 0xf8:
+				o << trace_prefix
+				   << "Clock"
+				   << endl;
+				break;
+			case 0xfa:
+				o << trace_prefix
+				   << "Start"
+				   << endl;
+				break;
+			case 0xfb:
+				o << trace_prefix
+				   << "Continue"
+				   << endl;
+				break;
+			case 0xfc:
+				o << trace_prefix
+				   << "Stop"
+				   << endl;
+				break;
+			case 0xfe:
+				o << trace_prefix
+				   << "Active Sense"
+				   << endl;
+				break;
+			case 0xff:
+				o << trace_prefix
+				   << "System Reset"
+				   << endl;
+				break;
+			default:
+				o << trace_prefix
+				   << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
+				   << endl;
+				break;
+			}
 		} else {
+			o << trace_prefix
+			   << "System Exclusive (" << len << ") = [ " << hex;
+			for (unsigned int i = 0; i < len; ++i) {
+				o << (int) msg[i] << ' ';
+			}
+			o << dec << ']' << endl;
 
-			/* was rolling, but record state changed */
-
-			if (_alignment_style == ExistingMaterial) {
-
-
-				if (!Config->get_punch_in()) {
-
-					/* manual punch in happens at the correct transport frame
-					   because the user hit a button. but to get alignment correct 
-					   we have to back up the position of the new region to the 
-					   appropriate spot given the roll delay.
-					*/
-
-					capture_start_frame -= _roll_delay;
+		}
+		break;
 
-					/* XXX paul notes (august 2005): i don't know why
-					   this is needed.
-					*/
+	case MIDI::song:
+		o << trace_prefix << "Song" << endl;
+		break;
 
-					first_recordable_frame += _capture_offset;
+	case MIDI::tune:
+		o << trace_prefix << "Tune" << endl;
+		break;
 
-				} else {
+	case MIDI::eox:
+		o << trace_prefix << "End-of-System Exclusive" << endl;
+		break;
 
-					/* autopunch toggles recording at the precise
-					   transport frame, and then the DS waits
-					   to start recording for a time that depends
-					   on the output latency.
-					*/
+	case MIDI::timing:
+		o << trace_prefix << "Timing" << endl;
+		break;
 
-					first_recordable_frame += _session.worst_output_latency();
-				}
+	case MIDI::start:
+		o << trace_prefix << "Start" << endl;
+		break;
 
-			} else {
+	case MIDI::stop:
+		o << trace_prefix << "Stop" << endl;
+		break;
 
-				if (Config->get_punch_in()) {
-					first_recordable_frame += _roll_delay;
-				} else {
-					capture_start_frame -= _roll_delay;
-				}
-			}
-			
-		}
+	case MIDI::contineu:
+		o << trace_prefix << "Continue" << endl;
+		break;
 
-	} else if (!record_enabled() || !can_record) {
-		
-		/* stop recording */
+	case active:
+		o << trace_prefix << "Active Sense" << endl;
+		break;
 
-		last_recordable_frame = transport_frame + _capture_offset;
-		
-		if (_alignment_style == ExistingMaterial) {
-			last_recordable_frame += _session.worst_output_latency();
-		} else {
-			last_recordable_frame += _roll_delay;
-		}
+	default:
+		o << trace_prefix << "Unrecognized MIDI message" << endl;
+		break;
 	}
-
-	last_possibly_recording = possibly_recording;
 }
+#endif
 
 int
 MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
 {
-	// FIXME: waay too much code to duplicate (AudioDiskstream::process)
 	int       ret = -1;
 	nframes_t rec_offset = 0;
 	nframes_t rec_nframes = 0;
 	bool      nominally_recording;
 	bool      re = record_enabled ();
-	bool      collect_playback = true;
 
 	/* if we've already processed the frames corresponding to this call,
 	   just return. this allows multiple routes that are taking input
@@ -441,7 +504,7 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 	if (_processed) {
 		return 0;
 	}
-	
+
 	commit_should_unlock = false;
 
 	check_record_status (transport_frame, nframes, can_record);
@@ -465,50 +528,10 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 	commit_should_unlock = true;
 	adjust_capture_position = 0;
 
-	if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
-		OverlapType ot;
+	if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
+		OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 
-		ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
-
-		switch (ot) {
-			case OverlapNone:
-				rec_nframes = 0;
-				break;
-
-			case OverlapInternal:
-				/*     ----------    recrange
-					   |---|       transrange
-					   */
-				rec_nframes = nframes;
-				rec_offset = 0;
-				break;
-
-			case OverlapStart:
-				/*    |--------|    recrange
-					  -----|          transrange
-					  */
-				rec_nframes = transport_frame + nframes - first_recordable_frame;
-				if (rec_nframes) {
-					rec_offset = first_recordable_frame - transport_frame;
-				}
-				break;
-
-			case OverlapEnd:
-				/*    |--------|    recrange
-					  |--------  transrange
-					  */
-				rec_nframes = last_recordable_frame - transport_frame;
-				rec_offset = 0;
-				break;
-
-			case OverlapExternal:
-				/*    |--------|    recrange
-					  --------------  transrange
-					  */
-				rec_nframes = last_recordable_frame - last_recordable_frame;
-				rec_offset = first_recordable_frame - transport_frame;
-				break;
-		}
+		calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 
 		if (rec_nframes && !was_recording) {
 			capture_captured = 0;
@@ -530,7 +553,7 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 			assert(ev.buffer());
 			_capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
 		}
-	
+
 	} else {
 
 		if (was_recording) {
@@ -551,36 +574,14 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 
 	} else if (nominally_recording) {
 
-		/* can't do actual capture yet - waiting for latency effects to finish before we start*/
+		/* XXXX do this for MIDI !!!
+		   can't do actual capture yet - waiting for latency effects to finish before we start
+		   */
 
 		playback_distance = nframes;
-		collect_playback = false;
 
 	}
 
-	if (collect_playback) {
-
-		/* we're doing playback */
-
-		nframes_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;
-		} else {
-			necessary_samples = nframes;
-		}
-
-		// Pump entire port buffer into playback buffer (FIXME: split cycles?)
-		MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
-		for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
-			const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
-			assert(ev.buffer());
-			_playback_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
-		}
-	}
-
 	ret = 0;
 
 	_processed = true;
@@ -593,7 +594,7 @@ MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_
 
 		commit_should_unlock = false;
 		state_lock.unlock();
-	} 
+	}
 
 	return ret;
 }
@@ -623,7 +624,7 @@ MidiDiskstream::commit (nframes_t nframes)
 	/*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
 		" = " << frames_written - frames_read
 		<< " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
-	
+
 	if (commit_should_unlock) {
 		state_lock.unlock();
 	}
@@ -637,9 +638,9 @@ void
 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;
-	
+
 	overwrite_frame = playback_sample;
 }
 
@@ -658,7 +659,7 @@ MidiDiskstream::seek (nframes_t frame, bool complete_refill)
 {
 	Glib::Mutex::Lock lm (state_lock);
 	int ret = -1;
-	
+
 	_playback_buf->reset();
 	_capture_buf->reset();
 	g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
@@ -687,8 +688,6 @@ MidiDiskstream::can_internal_playback_seek (nframes_t distance)
 int
 MidiDiskstream::internal_playback_seek (nframes_t distance)
 {
-	cerr << "MDS: internal_playback_seek " << distance << endl;
-
 	first_recordable_frame += distance;
 	playback_sample += distance;
 
@@ -698,7 +697,7 @@ 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)
-{	
+{
 	nframes_t this_read = 0;
 	bool reloop = false;
 	nframes_t loop_end = 0;
@@ -708,23 +707,23 @@ MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
 
 	if (!reversed) {
 		/* Make the use of a Location atomic for this read operation.
-		   
+
 		   Note: Locations don't get deleted, so all we care about
 		   when I say "atomic" is that we are always pointing to
 		   the same one and using a start/length values obtained
 		   just once.
 		*/
-		
+
 		if ((loc = loop_location) != 0) {
 			loop_start = loc->start();
 			loop_end = loc->end();
 			loop_length = loop_end - loop_start;
 		}
-		
+
 		/* if we are looping, ensure that the first frame we read is at the correct
 		   position within the loop.
 		*/
-		
+
 		if (loc && (start >= loop_end)) {
 			//cerr << "start adjusted from " << start;
 			start = loop_start + ((start - loop_start) % loop_length);
@@ -758,12 +757,11 @@ MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
 					_id, this_read, start) << endmsg;
 			return -1;
 		}
-		
-		//cout << "MDS this read " << this_read << " start = " << start << endl;
+
 		g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
 
 		_read_data_count = _playlist->read_data_count();
-		
+
 		if (reversed) {
 
 			// Swap note ons with note offs here.  etc?
@@ -771,21 +769,21 @@ MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
 			// CC values etc.  hard.
 
 		} else {
-			
+
 			/* if we read to the end of the loop, go back to the beginning */
-			
+
 			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;
+				cout << "Pushing LoopEvent ts=" << loop_end-1
+				     << " start+this_read " << start+this_read << endl;
 
 				start = loop_start;
 			} else {
 				start += this_read;
 			}
-		} 
+		}
 
 		dur -= this_read;
 		//offset += this_read;
@@ -810,7 +808,7 @@ MidiDiskstream::do_refill ()
 	if (write_space == 0) {
 		return 0;
 	}
-	
+
 	if (reversed) {
 		return 0;
 	}
@@ -839,11 +837,11 @@ MidiDiskstream::do_refill ()
 	//	<< frames_written - frames_read << endl;
 
 	to_read = min(to_read, (max_frames - file_frame));
-	
+
 	if (read (file_frame, to_read, reversed)) {
 		ret = -1;
 	}
-		
+
 	return ret;
 }
 
@@ -853,12 +851,12 @@ MidiDiskstream::do_refill ()
  * of data to disk. it will never write more than that.  If it writes that
  * much and there is more than that waiting to be written, it will return 1,
  * otherwise 0 on success or -1 on failure.
- * 
+ *
  * If there is less than disk_io_chunk_frames to be written, no data will be
  * written at all unless @a force_flush is true.
  */
 int
-MidiDiskstream::do_flush (RunContext context, bool force_flush)
+MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 {
 	uint32_t to_write;
 	int32_t ret = 0;
@@ -867,7 +865,7 @@ MidiDiskstream::do_flush (RunContext context, bool force_flush)
 	_write_data_count = 0;
 
 	total = _session.transport_frame() - _last_flush_frame;
-	
+
 	if (_last_flush_frame > _session.transport_frame()
 			|| _last_flush_frame < capture_start_frame) {
 		_last_flush_frame = _session.transport_frame();
@@ -891,7 +889,7 @@ MidiDiskstream::do_flush (RunContext context, bool force_flush)
 
 	if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 		ret = 1;
-	} 
+	}
 
 	to_write = disk_io_chunk_frames;
 
@@ -913,7 +911,7 @@ out:
 }
 
 void
-MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
+MidiDiskstream::transport_stopped (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 {
 	uint32_t buffer_position;
 	bool more_work = true;
@@ -927,7 +925,7 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
 
 	finish_capture (true);
 
-	/* butler is already stopped, but there may be work to do 
+	/* butler is already stopped, but there may be work to do
 	   to flush remaining data to disk.
 	   */
 
@@ -971,7 +969,7 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
 		}
 
 		/* 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);
@@ -1024,7 +1022,7 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
 				error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
 				continue; /* XXX is this OK? */
 			}
-			
+
 			region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
 
 			_last_capture_regions.push_back (region);
@@ -1052,6 +1050,10 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
 		delete *ci;
 	}
 
+	if (_playlist) {
+		midi_playlist()->clear_note_trackers ();
+	}
+
 	capture_info.clear ();
 	capture_start_frame = 0;
 }
@@ -1086,10 +1088,10 @@ MidiDiskstream::transport_looped (nframes_t transport_frame)
 }
 
 void
-MidiDiskstream::finish_capture (bool rec_monitors_input)
+MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
 {
 	was_recording = false;
-	
+
 	if (capture_captured == 0) {
 		return;
 	}
@@ -1098,12 +1100,12 @@ MidiDiskstream::finish_capture (bool rec_monitors_input)
 	assert(!destructive());
 
 	CaptureInfo* ci = new CaptureInfo;
-	
+
 	ci->start  = capture_start_frame;
 	ci->frames = capture_captured;
-	
-	/* XXX theoretical race condition here. Need atomic exchange ? 
-	   However, the circumstances when this is called right 
+
+	/* XXX theoretical race condition here. Need atomic exchange ?
+	   However, the circumstances when this is called right
 	   now (either on record-disable or transport_stopped)
 	   mean that no actual race exists. I think ...
 	   We now have a capture_info_lock, but it is only to be used
@@ -1125,7 +1127,7 @@ MidiDiskstream::set_record_enabled (bool yn)
 	}
 
 	assert(!destructive());
-	
+
 	if (yn && _source_port == 0) {
 
 		/* pick up connections not initiated *from* the IO object
@@ -1154,9 +1156,9 @@ MidiDiskstream::engage_record_enable ()
     bool rolling = _session.transport_speed() != 0.0f;
 
 	g_atomic_int_set (&_record_enabled, 1);
-	
+
 	if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
-		_source_port->request_monitor_input (!(Config->get_auto_input() && rolling));
+		_source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
 	}
 
 	// FIXME: Why is this necessary?  Isn't needed for AudioDiskstream...
@@ -1192,12 +1194,12 @@ MidiDiskstream::get_state ()
 	node->add_property ("flags", buf);
 
 	node->add_property("channel-mode", enum_2_string(get_channel_mode()));
-	
+
 	snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
 	node->add_property("channel-mask", buf);
-	
+
 	node->add_property ("playlist", _playlist->name());
-	
+
 	snprintf (buf, sizeof(buf), "%f", _visible_speed);
 	node->add_property ("speed", buf);
 
@@ -1218,10 +1220,10 @@ MidiDiskstream::get_state ()
 
 		Location* pi;
 
-		if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
-			snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
+		if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+			snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
 		} else {
-			snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
+			snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
 		}
 
 		cs_child->add_property (X_("at"), buf);
@@ -1236,7 +1238,7 @@ MidiDiskstream::get_state ()
 }
 
 int
-MidiDiskstream::set_state (const XMLNode& node)
+MidiDiskstream::set_state (const XMLNode& node, int /*version*/)
 {
 	const XMLProperty* prop;
 	XMLNodeList nlist = node.children();
@@ -1247,24 +1249,24 @@ MidiDiskstream::set_state (const XMLNode& node)
 
 	in_set_state = true;
 
- 	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- 		/*if ((*niter)->name() == IO::state_node_name) {
+	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+		/*if ((*niter)->name() == IO::state_node_name) {
 			deprecated_io_node = new XMLNode (**niter);
- 		}*/
- 		assert ((*niter)->name() != IO::state_node_name);
+		}*/
+		assert ((*niter)->name() != IO::state_node_name);
 
 		if ((*niter)->name() == X_("CapturingSources")) {
 			capture_pending_node = *niter;
 		}
- 	}
+	}
 
 	/* prevent write sources from being created */
-	
+
 	in_set_state = true;
-	
+
 	if ((prop = node.property ("name")) != 0) {
 		_name = prop->value();
-	} 
+	}
 
 	if ((prop = node.property ("id")) != 0) {
 		_id = prop->value ();
@@ -1278,7 +1280,7 @@ MidiDiskstream::set_state (const XMLNode& node)
 	if ((prop = node.property ("channel-mode")) != 0) {
 		channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
 	}
-	
+
 	unsigned int channel_mask = 0xFFFF;
 	if ((prop = node.property ("channel-mask")) != 0) {
 		sscanf (prop->value().c_str(), "0x%x", &channel_mask);
@@ -1288,18 +1290,18 @@ MidiDiskstream::set_state (const XMLNode& node)
 	}
 
 	set_channel_mode(channel_mode, channel_mask);
-	
+
 	if ((prop = node.property ("channels")) != 0) {
 		nchans = atoi (prop->value().c_str());
 	}
-	
+
 	if ((prop = node.property ("playlist")) == 0) {
 		return -1;
 	}
 
 	{
 		bool had_playlist = (_playlist != 0);
-	
+
 		if (find_and_use_playlist (prop->value())) {
 			return -1;
 		}
@@ -1307,7 +1309,7 @@ MidiDiskstream::set_state (const XMLNode& node)
 		if (!had_playlist) {
 			_playlist->set_orig_diskstream_id (_id);
 		}
-		
+
 		if (capture_pending_node) {
 			use_pending_capture_data (*capture_pending_node);
 		}
@@ -1329,10 +1331,10 @@ MidiDiskstream::set_state (const XMLNode& node)
 	// FIXME?
 	//_capturing_source = 0;
 
-	/* write sources are handled when we handle the input set 
+	/* 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;
@@ -1362,7 +1364,7 @@ MidiDiskstream::use_new_write_source (uint32_t n)
 		if (!_write_source) {
 			throw failed_constructor();
 		}
-	} 
+	}
 
 	catch (failed_constructor &err) {
 		error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
@@ -1371,14 +1373,15 @@ MidiDiskstream::use_new_write_source (uint32_t n)
 	}
 
 	_write_source->set_allow_remove_if_empty (true);
+	_write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
 
 	return 0;
 }
 
 void
-MidiDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
 {
-	if (!recordable()) {
+	if (!_session.writable() || !recordable()) {
 		return;
 	}
 
@@ -1387,10 +1390,6 @@ MidiDiskstream::reset_write_sources (bool mark_write_complete, bool force)
 	}
 
 	use_new_write_source (0);
-			
-	if (record_enabled()) {
-		//_capturing_sources.push_back (_write_source);
-	}
 }
 
 int
@@ -1404,7 +1403,7 @@ MidiDiskstream::rename_write_sources ()
 }
 
 void
-MidiDiskstream::set_block_size (nframes_t nframes)
+MidiDiskstream::set_block_size (nframes_t /*nframes*/)
 {
 }
 
@@ -1430,7 +1429,7 @@ MidiDiskstream::set_align_style_from_io ()
 	}
 
 	get_input_sources ();
-	
+
 	if (_source_port && _source_port->flags() & JackPortIsPhysical) {
 		have_physical = true;
 	}
@@ -1458,7 +1457,7 @@ MidiDiskstream::capture_buffer_load () const
 }
 
 int
-MidiDiskstream::use_pending_capture_data (XMLNode& node)
+MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
 {
 	return 0;
 }
@@ -1471,33 +1470,24 @@ MidiDiskstream::get_playback (MidiBuffer& dst, nframes_t start, nframes_t end)
 {
 	dst.clear();
 	assert(dst.size() == 0);
-	
+
 	// Reverse.  ... We just don't do reverse, ok?  Back off.
 	if (end <= start) {
 		return;
 	}
 
-	// Check only events added this offset cycle
-	MidiBuffer::iterator this_cycle_start = dst.end();
-	
 	// Translates stamps to be relative to start
-	#if 1
-		_playback_buf->read(dst, start, end);
-	#else	
-		const size_t events_read = _playback_buf->read(dst, start, end);
-		cout << "MDS events read = " << events_read
-		<< " start = " << start << " end = " << end
-		<< " readspace " << _playback_buf->read_space()
-		<< " writespace " << _playback_buf->write_space() << endl;
-	#endif
-	
+
+
+#ifndef NDEBUG
+	const size_t events_read = _playback_buf->read(dst, start, end);
+	DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6\n", _name, events_read, start, end,
+							      _playback_buf->read_space(), _playback_buf->write_space()));
+#else
+	_playback_buf->read(dst, start, end);
+#endif
+
 	gint32 frames_read = end - start;
 	g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
-	
-	// Feed the data through the MidiStateTracker
-	// If it detects a LoopEvent it will add necessary note offs
-	if (_midi_state_tracker.track(this_cycle_start, dst.end())) {
-		_midi_state_tracker.resolve_notes(dst, end-start - 1);
-	}
 }